| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef TOOLS_GN_SCOPE_H_ |
| #define TOOLS_GN_SCOPE_H_ |
| |
| #include <map> |
| #include <set> |
| |
| #include "base/basictypes.h" |
| #include "base/containers/hash_tables.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "tools/gn/err.h" |
| #include "tools/gn/pattern.h" |
| #include "tools/gn/value.h" |
| |
| class FunctionCallNode; |
| class ImportManager; |
| class ParseNode; |
| class Settings; |
| class TargetManager; |
| |
| // Scope for the script execution. |
| // |
| // Scopes are nested. Writing goes into the toplevel scope, reading checks |
| // values resursively down the stack until a match is found or there are no |
| // more containing scopes. |
| // |
| // A containing scope can be const or non-const. The const containing scope is |
| // used primarily to refer to the master build config which is shared across |
| // many invocations. A const containing scope, however, prevents us from |
| // marking variables "used" which prevents us from issuing errors on unused |
| // variables. So you should use a non-const containing scope whenever possible. |
| class Scope { |
| public: |
| typedef std::vector<std::pair<base::StringPiece, Value> > KeyValueVector; |
| |
| // Allows code to provide values for built-in variables. This class will |
| // automatically register itself on construction and deregister itself on |
| // destruction. |
| class ProgrammaticProvider { |
| public: |
| ProgrammaticProvider(Scope* scope) : scope_(scope) { |
| scope_->AddProvider(this); |
| } |
| ~ProgrammaticProvider() { |
| scope_->RemoveProvider(this); |
| } |
| |
| // Returns a non-null value if the given value can be programmatically |
| // generated, or NULL if there is none. |
| virtual const Value* GetProgrammaticValue( |
| const base::StringPiece& ident) = 0; |
| |
| protected: |
| Scope* scope_; |
| }; |
| |
| // Creates an empty toplevel scope. |
| Scope(const Settings* settings); |
| |
| // Creates a dependent scope. |
| Scope(Scope* parent); |
| Scope(const Scope* parent); |
| |
| ~Scope(); |
| |
| const Settings* settings() const { return settings_; } |
| |
| // See the const_/mutable_containing_ var declaraions below. Yes, it's a |
| // bit weird that we can have a const pointer to the "mutable" one. |
| Scope* mutable_containing() { return mutable_containing_; } |
| const Scope* mutable_containing() const { return mutable_containing_; } |
| const Scope* const_containing() const { return const_containing_; } |
| const Scope* containing() const { |
| return mutable_containing_ ? mutable_containing_ : const_containing_; |
| } |
| |
| // Returns NULL if there's no such value. |
| // |
| // counts_as_used should be set if the variable is being read in a way that |
| // should count for unused variable checking. |
| const Value* GetValue(const base::StringPiece& ident, |
| bool counts_as_used); |
| const Value* GetValue(const base::StringPiece& ident) const; |
| |
| // Same as GetValue, but if the value exists in a parent scope, we'll copy |
| // it to the current scope. If the return value is non-null, the value is |
| // guaranteed to be set in the current scope. Generatlly this will be used |
| // if the calling code is planning on modifying the value in-place. |
| // |
| // Since this is used when doing read-modifies, we never count this access |
| // as reading the variable, since we assume it will be written to. |
| Value* GetValueForcedToCurrentScope(const base::StringPiece& ident, |
| const ParseNode* set_node); |
| |
| // The set_node indicates the statement that caused the set, for displaying |
| // errors later. Returns a pointer to the value in the current scope (a copy |
| // is made for storage). |
| Value* SetValue(const base::StringPiece& ident, |
| const Value& v, |
| const ParseNode* set_node); |
| |
| // Templates associated with this scope. A template can only be set once, so |
| // AddTemplate will fail and return NULL if a rule with that name already |
| // exists. GetTemplate returns NULL if the rule doesn't exist, and it will |
| // check all containing scoped rescursively. |
| bool AddTemplate(const std::string& name, const FunctionCallNode* decl); |
| const FunctionCallNode* GetTemplate(const std::string& name) const; |
| |
| // Marks the given identifier as (un)used in the current scope. |
| void MarkUsed(const base::StringPiece& ident); |
| void MarkUnused(const base::StringPiece& ident); |
| |
| // Checks to see if the scope has a var set that hasn't been used. This is |
| // called before replacing the var with a different one. It does not check |
| // containing scopes. |
| // |
| // If the identifier is present but hasnn't been used, return true. |
| bool IsSetButUnused(const base::StringPiece& ident) const; |
| |
| // Checks the scope to see if any values were set but not used, and fills in |
| // the error and returns false if they were. |
| bool CheckForUnusedVars(Err* err) const; |
| |
| // Returns all values set in the current scope, without going to the parent |
| // scopes. |
| void GetCurrentScopeValues(KeyValueVector* output) const; |
| |
| // Copies this scope's values into the destination. Values from the |
| // containing scope(s) (normally shadowed into the current one) will not be |
| // copied, neither will the reference to the containing scope (this is why |
| // it's "non-recursive"). |
| // |
| // It is an error to merge a variable into a scope that already has something |
| // with that name in scope (meaning in that scope or in any of its containing |
| // scopes). If this happens, the error will be set and the function will |
| // return false. |
| // |
| // This is used in different contexts. When generating the error, the given |
| // parse node will be blamed, and the given desc will be used to describe |
| // the operation that doesn't support doing this. For example, desc_for_err |
| // would be "import" when doing an import, and the error string would say |
| // something like "The import contains...". |
| bool NonRecursiveMergeTo(Scope* dest, |
| const ParseNode* node_for_err, |
| const char* desc_for_err, |
| Err* err) const; |
| |
| // Makes an empty scope with the given name. Returns NULL if the name is |
| // already set. |
| Scope* MakeTargetDefaults(const std::string& target_type); |
| |
| // Gets the scope associated with the given target name, or null if it hasn't |
| // been set. |
| const Scope* GetTargetDefaults(const std::string& target_type) const; |
| |
| // Filter to apply when the sources variable is assigned. May return NULL. |
| const PatternList* GetSourcesAssignmentFilter() const; |
| void set_sources_assignment_filter( |
| scoped_ptr<PatternList> f) { |
| sources_assignment_filter_ = f.Pass(); |
| } |
| |
| // Indicates if we're currently processing the build configuration file. |
| // This is true when processing the config file for any toolchain. See also |
| // *ProcessingDefaultBuildConfig() below. |
| // |
| // To set or clear the flag, it must currently be in the opposite state in |
| // the current scope. Note that querying the state of the flag recursively |
| // checks all containing scopes until it reaches the top or finds the flag |
| // set. |
| void SetProcessingBuildConfig(); |
| void ClearProcessingBuildConfig(); |
| bool IsProcessingBuildConfig() const; |
| |
| // Indicates we're currently processing the default toolchain's build |
| // configuration file. |
| void SetProcessingDefaultBuildConfig(); |
| void ClearProcessingDefaultBuildConfig(); |
| bool IsProcessingDefaultBuildConfig() const; |
| |
| // Indicates if we're currently processing an import file. |
| // |
| // See SetProcessingBaseConfig for how flags work. |
| void SetProcessingImport(); |
| void ClearProcessingImport(); |
| bool IsProcessingImport() const; |
| |
| // Properties are opaque pointers that code can use to set state on a Scope |
| // that it can retrieve later. |
| // |
| // The key should be a pointer to some use-case-specific object (to avoid |
| // collisions, otherwise it doesn't matter). Memory management is up to the |
| // setter. Setting the value to NULL will delete the property. |
| // |
| // Getting a property recursively searches all scopes, and the optional |
| // |found_on_scope| variable will be filled with the actual scope containing |
| // the key (if the pointer is non-NULL). |
| void SetProperty(const void* key, void* value); |
| void* GetProperty(const void* key, const Scope** found_on_scope) const; |
| |
| private: |
| friend class ProgrammaticProvider; |
| |
| struct Record { |
| Record() : used(false) {} |
| Record(const Value& v) : used(false), value(v) {} |
| |
| bool used; // Set to true when the variable is used. |
| Value value; |
| }; |
| |
| void AddProvider(ProgrammaticProvider* p); |
| void RemoveProvider(ProgrammaticProvider* p); |
| |
| // Scopes can have no containing scope (both null), a mutable containing |
| // scope, or a const containing scope. The reason is that when we're doing |
| // a new target, we want to refer to the base_config scope which will be read |
| // by multiple threads at the same time, so we REALLY want it to be const. |
| // When you jsut do a nested {}, however, we sometimes want to be able to |
| // change things (especially marking unused vars). |
| const Scope* const_containing_; |
| Scope* mutable_containing_; |
| |
| const Settings* settings_; |
| |
| // Bits set for different modes. See the flag definitions in the .cc file |
| // for more. |
| unsigned mode_flags_; |
| |
| typedef base::hash_map<base::StringPiece, Record> RecordMap; |
| RecordMap values_; |
| |
| // Owning pointers. Note that this can't use string pieces since the names |
| // are constructed from Values which might be deallocated before this goes |
| // out of scope. |
| typedef base::hash_map<std::string, Scope*> NamedScopeMap; |
| NamedScopeMap target_defaults_; |
| |
| // Null indicates not set and that we should fallback to the containing |
| // scope's filter. |
| scoped_ptr<PatternList> sources_assignment_filter_; |
| |
| // Non-owning pointers, the function calls are owned by the input file which |
| // should be kept around by the input file manager. |
| typedef std::map<std::string, const FunctionCallNode*> TemplateMap; |
| TemplateMap templates_; |
| |
| typedef std::map<const void*, void*> PropertyMap; |
| PropertyMap properties_; |
| |
| typedef std::set<ProgrammaticProvider*> ProviderSet; |
| ProviderSet programmatic_providers_; |
| |
| DISALLOW_COPY_AND_ASSIGN(Scope); |
| }; |
| |
| #endif // TOOLS_GN_SCOPE_H_ |