aboutsummaryrefslogtreecommitdiff
path: root/build/scope
diff options
context:
space:
mode:
authorBoris Kolpackov <boris@codesynthesis.com>2016-01-05 11:55:15 +0200
committerBoris Kolpackov <boris@codesynthesis.com>2016-01-05 11:55:15 +0200
commit9fb791e9fad6c63fc1dac49f4d05ae63b8a3db9b (patch)
treed60322d4382ca5f97b676c5abe2e39524f35eab4 /build/scope
parentf159b1dac68c8714f7ba71ca168e3b695891aad9 (diff)
Rename build directory/namespace to build2
Diffstat (limited to 'build/scope')
-rw-r--r--build/scope312
1 files changed, 0 insertions, 312 deletions
diff --git a/build/scope b/build/scope
deleted file mode 100644
index 0cb319f..0000000
--- a/build/scope
+++ /dev/null
@@ -1,312 +0,0 @@
-// file : build/scope -*- C++ -*-
-// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd
-// license : MIT; see accompanying LICENSE file
-
-#ifndef BUILD_SCOPE
-#define BUILD_SCOPE
-
-#include <functional> // function
-#include <unordered_set>
-#include <unordered_map>
-
-#include <butl/path-map>
-
-#include <build/types>
-#include <build/utility>
-
-#include <build/module>
-#include <build/variable>
-#include <build/prerequisite>
-#include <build/target-type>
-#include <build/rule-map>
-#include <build/operation>
-
-namespace build
-{
- class scope
- {
- public:
- // Absolute and normalized.
- //
- const dir_path&
- out_path () const {return *out_path_;}
-
- const dir_path&
- src_path () const {return *src_path_;}
-
- // These are pointers to the keys in scope_map.
- //
- const dir_path* out_path_ {nullptr};
- const dir_path* src_path_ {nullptr};
-
- bool
- root () const {return root_ == this;}
-
- scope*
- parent_scope () const {return parent_;}
-
- // Root scope of this scope or NULL if this scope is not (yet)
- // in any (known) project. Note that if the scope itself is
- // root, then this function return this. To get to the outer
- // root, query the root scope of the parent.
- //
- scope*
- root_scope () const {return root_;}
-
- // Root scope of a strong amalgamation of this scope or NULL if
- // this scope is not (yet) in any (known) project. If there is
- // no strong amalgamation, then this function returns the root
- // scope of the project (in other words, in this case a project
- // is treated as its own strong amalgamation).
- //
- scope*
- strong_scope () const
- {
- return root_ != nullptr
- ? root_->strong_ != nullptr ? root_->strong_ : root_
- : nullptr;
- }
-
- // Root scope of the outermost amalgamation or NULL if this scope is not
- // (yet) in any (known) project. If there is no amalgamation, then this
- // function returns the root scope of the project (in other words, in this
- // case a project is treated as its own amalgamation).
- //
- scope*
- weak_scope () const
- {
- scope* r (root_);
- if (r != nullptr)
- for (; r->parent_->root_ != nullptr; r = r->parent_->root_) ;
- return r;
- }
-
- // Variables.
- //
- public:
- variable_map vars;
-
- // Lookup, including in outer scopes. If you only want to lookup
- // in this scope, do it on the the variables map directly.
- //
- build::lookup<const value>
- operator[] (const variable& var) const
- {
- return lookup (nullptr, nullptr, var);
- }
-
- build::lookup<const value>
- operator[] (const std::string& name) const
- {
- return operator[] (var_pool.find (name));
- }
-
- // As above, but includes target type/pattern-specific variables.
- //
- build::lookup<const value>
- lookup (const target_key& tk, const variable& var) const
- {
- return lookup (tk.type, tk.name, var);
- }
-
- build::lookup<const value>
- lookup (const target_key& tk, const string& var) const
- {
- return lookup (tk, var_pool.find (var));
- }
-
- build::lookup<const value>
- lookup (const target_type& tt,
- const string& name,
- const variable& var) const
- {
- return lookup (&tt, &name, var);
- }
-
- build::lookup<const value>
- lookup (const target_type& tt, const string& name, const string& var) const
- {
- return lookup (tt, name, var_pool.find (var));
- }
-
- build::lookup<const value>
- lookup (const target_type*, const string* name, const variable&) const;
-
- // Return a value suitable for assignment (or append if you only
- // want to append to the value from this scope). If the variable
- // does not exist in this scope's map, then a new one with the
- // NULL value is added and returned. Otherwise the existing value
- // is returned.
- //
- value&
- assign (const variable& var) {return vars.assign (var).first.get ();}
-
- value&
- assign (const std::string& name) {return vars.assign (name).first.get ();}
-
- // Return a value suitable for appending. If the variable does not
- // exist in this scope's map, then outer scopes are searched for
- // the same variable. If found then a new variable with the found
- // value is added to this scope and returned. Otherwise this
- // function proceeds as assign().
- //
- value&
- append (const variable&);
-
- value&
- append (const std::string& name)
- {
- return append (var_pool.find (name));
- }
-
- // Target type/pattern-specific variables.
- //
- variable_type_map target_vars;
-
- // Prerequisite cache.
- //
- public:
- prerequisite_set prerequisites;
-
- // Meta/operations supported by this project (set on the root
- // scope only).
- //
- build::meta_operations meta_operations;
- build::operations operations;
-
- typedef build::path path_type;
-
- // Set of buildfiles already loaded for this scope. The included
- // buildfiles are checked against the project's root scope while
- // imported -- against the global scope (global_scope).
- //
- std::unordered_set<path_type> buildfiles;
-
- // Target types.
- //
- public:
- target_type_map target_types;
-
- const target_type*
- find_target_type (const string&, const scope** = nullptr) const;
-
- // Given a name, figure out its type, taking into account extensions,
- // special names (e.g., '.' and '..'), or anything else that might be
- // relevant. Also process the name (in place) by extracting the
- // extension, adjusting dir/value, etc., (note that the dir is not
- // necessarily normalized). Return NULL if not found.
- //
- const target_type*
- find_target_type (name&, const string*& ext) const;
-
- // Rules.
- //
- public:
- rule_map rules;
-
- // Modules.
- //
- public:
- loaded_module_map modules; // Only on root scope.
-
- public:
- bool
- empty () const
- {
- return
- vars.empty () &&
- target_vars.empty () &&
- prerequisites.empty () &&
- meta_operations.empty () &&
- operations.empty () &&
- buildfiles.empty () &&
- target_types.empty () &&
- rules.empty () &&
- modules.empty ();
- }
-
- private:
- friend class scope_map;
- friend class temp_scope;
-
- // These two from <build/file> set strong_.
- //
- friend void create_bootstrap_outer (scope&);
- friend scope& create_bootstrap_inner (scope&, const dir_path&);
-
- scope () = default;
-
- scope* parent_;
- scope* root_;
- scope* strong_ = nullptr; // Only set on root sopes.
- // NULL means no strong amalgamtion.
- };
-
- // Temporary scope. The idea is to be able to create a temporary
- // scope in order not to change the variables in the current scope.
- // Such a scope is not entered in to the scope map. As a result it
- // can only be used as a temporary set of variables. In particular,
- // defining targets/prerequisites directly in such a scope will surely
- // end up badly. Defining any nested scopes will be as if defining
- // such a scope in the parent (since path() returns parent's path).
- //
- class temp_scope: public scope
- {
- public:
- temp_scope (scope& p)
- {
- out_path_ = p.out_path_;
- src_path_ = p.src_path_;
- parent_ = &p;
- root_ = p.root_;
- // No need to copy strong_ since we are never root scope.
- }
- };
-
- class scope_map
- {
- public:
- using map_type = butl::dir_path_map<scope*>;
- using iterator = map_type::iterator;
- using const_iterator = map_type::const_iterator;
-
- // Note that we assume the first insertion into the map is that
- // of the global scope. If the passed scope pointer is not NULL,
- // then insert this scope instead of a new one.
- //
- iterator
- insert (const dir_path&, scope*, bool parent, bool root);
-
- // Find the most qualified scope that encompasses this path.
- //
- scope&
- find (const dir_path&) const;
-
- scope&
- find (const path& p) const
- {
- // Natural thing to do here would be to call find (p.directory ()).
- // However, there could be a situation where the passed path is a
- // directory (i.e., the calling code does not know what it is dealing
- // with), so let's use the whole path.
- //
- return find (dir_path (p.string ()));
- }
-
- const_iterator begin () const {return map_.begin ();}
- const_iterator end () const {return map_.end ();}
-
- void
- clear ();
-
- ~scope_map () {clear ();}
-
- private:
- map_type map_;
- };
-
- extern scope_map scopes;
- extern scope* global_scope;
-}
-
-#endif // BUILD_SCOPE