/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...] |