| /external/chromium_org/gin/ |
| runner.cc | 15 Runner::Scope::Scope(Runner* runner)
21 Runner::Scope::~Scope() {
|
| runner.h | 24 // context by creating an instance of Runner::Scope on the stack.
43 class GIN_EXPORT Scope {
45 explicit Scope(Runner* runner);
46 ~Scope();
49 v8::Isolate::Scope isolate_scope_;
51 v8::Context::Scope scope_;
53 DISALLOW_COPY_AND_ASSIGN(Scope);
57 friend class Scope;
|
| /external/chromium_org/tools/gn/ |
| args.h | 12 #include "tools/gn/scope.h"
17 // command line, and sets up the root scope with the proper values.
32 void AddArgOverrides(const Scope::KeyValueMap& overrides);
39 Scope::KeyValueMap GetAllOverrides() const;
41 // Sets up the root scope for a toolchain. This applies the default system
44 void SetupRootScope(Scope* dest,
45 const Scope::KeyValueMap& toolchain_overrides) const;
47 // Sets up the given scope with arguments passed in.
56 bool DeclareArgs(const Scope::KeyValueMap& args,
57 Scope* scope_to_set
[all...] |
| config_values_generator.h | 16 class Scope;
19 // This class fills in the config values from a given scope. It's shared
26 Scope* scope,
36 Scope* scope_;
|
| import_manager.h | 14 class Scope;
24 // Does an import of the given file into the given scope. On error, sets the
28 Scope* scope,
35 typedef std::map<SourceFile, const Scope*> ImportMap;
|
| template.h | 18 class Scope;
30 // Makes a new closure based on the given scope.
31 Template(const Scope* scope, const FunctionCallNode* def);
34 Template(scoped_ptr<Scope> closure, const FunctionCallNode* def);
38 Value Invoke(Scope* scope,
53 scoped_ptr<Scope> closure_;
|
| scope.h | 29 // Scope for the script execution.
31 // Scopes are nested. Writing goes into the toplevel scope, reading checks
35 // A containing scope can be const or non-const. The const containing scope is
37 // many invocations. A const containing scope, however, prevents us from
39 // variables. So you should use a non-const containing scope whenever possible.
40 class Scope {
52 ProgrammaticProvider(Scope* scope) : scope_(scope) {
[all...] |
| scope.cc | 5 #include "tools/gn/scope.h"
14 // FLags set in the mode_flags_ of a scope. If a bit is set, it applies
28 Scope::Scope(const Settings* settings)
36 Scope::Scope(Scope* parent)
44 Scope::Scope(const Scope* parent
[all...] |
| operators.h | 11 class Scope;
25 Value ExecuteUnaryOperator(Scope* scope,
29 Value ExecuteBinaryOperator(Scope* scope,
|
| scope_unittest.cc | 8 #include "tools/gn/scope.h"
13 bool HasStringValueEqualTo(const Scope* scope,
16 const Value* value = scope->GetValue(name);
26 TEST(Scope, NonRecursiveMergeTo) {
38 setup.scope()->SetValue("v", old_value, &assignment);
40 setup.scope()->SetValue(private_var_name, old_value, &assignment);
44 Scope new_scope(setup.settings());
49 EXPECT_FALSE(setup.scope()->NonRecursiveMergeTo(
50 &new_scope, Scope::MergeOptions()
[all...] |
| functions.h | 20 class Scope;
31 typedef Value (*SelfEvaluatingArgsFunction)(Scope* scope,
37 typedef Value (*GenericBlockFunction)(Scope* scope,
48 Scope* block_scope,
52 typedef Value (*NoBlockFunction)(Scope* scope,
60 Value RunAction(Scope* scope,
[all...] |
| copy_target_generator.h | 15 Scope* scope,
|
| function_set_defaults.cc | 8 #include "tools/gn/scope.h"
22 " set_default's block will be copied into the current scope.\n"
25 " If a variable with that name is already in scope, the build will fail\n"
43 Value RunSetDefaults(Scope* scope,
67 if (scope->GetTargetDefaults(target_type)) {
79 Scope block_scope(scope);
84 // Now copy the values set on the scope we made into the free-floating one
85 // (with no containing scope) used to hold the target defaults
[all...] |
| group_target_generator.h | 15 Scope* scope,
|
| target_generator.h | 20 class Scope;
23 // Fills the variables in a Target object from a Scope (the result of a script
30 Scope* scope,
39 static void GenerateTarget(Scope* scope,
58 Scope* scope_;
|
| args.cc | 89 void Args::AddArgOverrides(const Scope::KeyValueMap& overrides) {
92 for (Scope::KeyValueMap::const_iterator i = overrides.begin();
102 Scope::KeyValueMap::const_iterator found =
109 Scope::KeyValueMap Args::GetAllOverrides() const {
114 void Args::SetupRootScope(Scope* dest,
115 const Scope::KeyValueMap& toolchain_overrides) const {
124 bool Args::DeclareArgs(const Scope::KeyValueMap& args,
125 Scope* scope_to_set,
129 for (Scope::KeyValueMap::const_iterator i = args.begin();
137 Scope::KeyValueMap::iterator previously_declared
[all...] |
| template.cc | 10 #include "tools/gn/scope.h"
14 Template::Template(const Scope* scope, const FunctionCallNode* def)
15 : closure_(scope->MakeClosure()),
19 Template::Template(scoped_ptr<Scope> scope, const FunctionCallNode* def)
20 : closure_(scope.Pass()),
27 Value Template::Invoke(Scope* scope,
34 if (!EnsureNotProcessingImport(invocation, scope, err)
[all...] |
| value_unittest.cc | 30 Scope* scope = new Scope(setup.scope()); local
31 Value scopeval(NULL, scoped_ptr<Scope>(scope));
34 scope->SetValue("a", Value(NULL, static_cast<int64>(42)), NULL);
35 scope->SetValue("b", Value(NULL, "hello, world"), NULL);
|
| import_manager.cc | 15 // Returns a newly-allocated scope on success, null on failure.
16 Scope* UncachedImport(const Settings* settings,
27 scoped_ptr<Scope> scope(new Scope(settings->base_config()));
28 scope->set_source_dir(file.GetDir());
33 ScopePerFileProvider per_file_provider(scope.get(), false);
35 scope->SetProcessingImport();
36 block->ExecuteBlockInScope(scope.get(), err);
39 scope->ClearProcessingImport()
[all...] |
| /external/clang/include/clang/Sema/ |
| Scope.h | 1 //===--- Scope.h - Scope interface ------------------------------*- C++ -*-===//
10 // This file defines the Scope interface.
34 /// Scope - A scope is a transient data structure that is used while parsing the
38 class Scope {
41 /// scope, which defines the sorts of things the scope contains.
43 /// \brief This indicates that the scope corresponds to a function, which
55 /// \brief This is a scope that can contain a declaration. Some scope
[all...] |
| /external/chromium_org/content/public/browser/ |
| service_worker_context.h | 18 // https://rawgithub.com/slightlyoff/ServiceWorker/master/spec/service_worker/index.html#url-scope:
20 typedef GURL Scope;
24 // Equivalent to calling navigator.serviceWorker.register(script_url, {scope:
35 virtual void RegisterServiceWorker(const Scope& pattern,
47 virtual void UnregisterServiceWorker(const Scope& pattern,
50 // TODO(jyasskin): Provide a way to SendMessage to a Scope.
|
| /external/llvm/lib/CodeGen/ |
| LexicalScopes.cpp | 1 //===- LexicalScopes.cpp - Collecting lexical scope info ------------------===//
12 // This pass collects lexical scope information and maps machine instructions
39 /// initialize - Scan machine function and constuct lexical scope nest.
71 // If scope has not changed then skip this instruction.
83 // current instruction scope does not match scope of first instruction
108 MDNode *Scope = nullptr;
110 DL.getScopeAndInlinedAt(Scope, IA, MF->getFunction()->getContext());
111 auto I = InlinedLexicalScopeMap.find(std::make_pair(Scope, IA));
115 /// findLexicalScope - Find lexical scope, either regular or inlined, for th
[all...] |
| /external/llvm/lib/ExecutionEngine/ |
| EventListenerCommon.h | 28 // Holds the filename of each Scope, so that we can pass a null-terminated
35 const char *getFilename(MDNode *Scope) {
36 std::string &Filename = Filenames[Scope];
38 DIScope DIScope(Scope);
44 const char *getFullPath(MDNode *Scope) {
45 std::string &P = Paths[Scope];
47 DIScope DIScope(Scope);
|
| /libcore/json/src/main/java/org/json/ |
| JSONStringer.java | 71 enum Scope {
114 private final List<Scope> stack = new ArrayList<Scope>();
139 return open(Scope.EMPTY_ARRAY, "[");
148 return close(Scope.EMPTY_ARRAY, Scope.NONEMPTY_ARRAY, "]");
158 return open(Scope.EMPTY_OBJECT, "{");
167 return close(Scope.EMPTY_OBJECT, Scope.NONEMPTY_OBJECT, "}");
171 * Enters a new scope by appending any necessary whitespace and the give
[all...] |
| /external/llvm/lib/IR/ |
| DebugLoc.cpp | 48 /// Return both the Scope and the InlinedAt values.
49 void DebugLoc::getScopeAndInlinedAt(MDNode *&Scope, MDNode *&IA,
52 Scope = IA = nullptr;
61 Scope = Ctx.pImpl->ScopeRecords[ScopeIdx-1].get();
69 Scope = Ctx.pImpl->ScopeInlinedAtRecords[-ScopeIdx-1].first.get();
80 const MDNode *Scope = getScopeNode(Ctx);
81 DISubprogram SP = getDISubprogram(Scope);
95 MDNode *Scope, MDNode *InlinedAt) {
98 // If no scope is available, this is an unknown location.
99 if (!Scope) return Result
[all...] |
