blob: 7d0547ed4d498e74c3e69683a1aa70220c3ba584 [file] [log] [blame]
// 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.
#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 {
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 {
ProgrammaticProvider(Scope* scope) : scope_(scope) {
~ProgrammaticProvider() {
// 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;
Scope* scope_;
// Creates an empty toplevel scope.
Scope(const Settings* settings);
// Creates a dependent scope.
Scope(Scope* parent);
Scope(const Scope* parent);
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;
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_;
#endif // TOOLS_GN_SCOPE_H_