Rename build directory/namespace to build2

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