1 files changed, 266 insertions, 0 deletions
diff --git a/tools/build/src/kernel/bootstrap.jam b/tools/build/src/kernel/bootstrap.jam
new file mode 100644
index 000000000..c4320dc29
--- /dev/null
+++ b/tools/build/src/kernel/bootstrap.jam
@@ -0,0 +1,266 @@
+# Copyright 2003 Dave Abrahams
+# Copyright 2003, 2005, 2006 Rene Rivera
+# Copyright 2003, 2005, 2006 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# First of all, check the jam version.
+if $(JAM_VERSION:J="") < 030112
+{
+    ECHO "error: Boost.Jam version 3.1.12 or later required" ;
+    EXIT ;
+}
+
+local required-rules = GLOB-RECURSIVELY HAS_NATIVE_RULE ;
+for local r in $(required-rules)
+{
+    if ! $(r) in [ RULENAMES ]
+    {
+        ECHO "error: builtin rule '$(r)' is not present" ;
+        ECHO "error: your version of bjam is likely out of date" ;
+        ECHO "error: please get a fresh version from SVN." ;
+        EXIT ;
+    }
+}
+
+local native = regex transform 2 ;
+while $(native)
+{
+    if ! [ HAS_NATIVE_RULE $(native[1]) : $(native[2]) : $(native[3]) ]
+    {
+        ECHO "error: missing native rule '$(native[1]).$(native[2])'" ;
+        ECHO "error: or interface version of that rule is too low" ;
+        ECHO "error: your version of bjam is likely out of date" ;
+        ECHO "error: please get a fresh version from SVN." ;
+        EXIT ;
+    }
+    native = $(native[4-]) ;
+}
+
+
+# Check that the builtin .ENVIRON module is present. We do not have a builtin to
+# check that a module is present, so we assume that the PATH environment
+# variable is always set and verify that the .ENVIRON module has a non-empty
+# value of that variable.
+module .ENVIRON
+{
+    local p = $(PATH) $(Path) $(path) ;
+    if ! $(p)
+    {
+        ECHO "error: no builtin module .ENVIRON is found" ;
+        ECHO "error: your version of bjam is likely out of date" ;
+        ECHO "error: please get a fresh version from SVN." ;
+        EXIT ;
+    }
+}
+
+# Check that @() functionality is present. Similarly to modules, we do not have
+# a way to test this directly. Instead we check that $(TMPNAME) functionality is
+# present which was added at roughly the same time (more precisely, it was added
+# just before).
+{
+    if ! $(TMPNAME)
+    {
+        ECHO "error: no @() functionality found" ;
+        ECHO "error: your version of b2 is likely out of date" ;
+        ECHO "error: please get a fresh version from SVN." ;
+        EXIT ;
+    }
+}
+
+# Make sure that \n escape is avaiable.
+if "\n" = "n"
+{
+    if $(OS) = CYGWIN
+    {
+        ECHO "warning: escape sequences are not supported" ;
+        ECHO "warning: this will cause major misbehaviour on cygwin" ;
+        ECHO "warning: your version of b2 is likely out of date" ;
+        ECHO "warning: please get a fresh version from SVN." ;
+    }
+}
+
+
+# Bootstrap the module system. Then bring the import rule into the global module.
+#
+SEARCH on <module@>modules.jam = $(.bootstrap-file:D) ;
+module modules { include <module@>modules.jam ; }
+IMPORT modules : import : : import ;
+
+{
+    # Add module subdirectories to the BOOST_BUILD_PATH, which allows us to make
+    # incremental refactoring steps by moving modules to appropriate
+    # subdirectories, thereby achieving some physical separation of different
+    # layers without changing all of our code to specify subdirectories in
+    # import statements or use an extra level of qualification on imported
+    # names.
+
+    local subdirs =
+        kernel        # only the most-intrinsic modules: modules, errors
+        util          # low-level substrate: string/number handling, etc.
+        build         # essential elements of the build system architecture
+        tools         # toolsets for handling specific build jobs and targets.
+        contrib       # user contributed (unreviewed) modules
+        .             # build-system.jam lives here
+        ;
+    local whereami = [ NORMALIZE_PATH $(.bootstrap-file:DT) ] ;
+    BOOST_BUILD_PATH += $(whereami:D)/$(subdirs) ;
+
+    modules.poke .ENVIRON : BOOST_BUILD_PATH : $(BOOST_BUILD_PATH) ;
+
+    modules.poke : EXTRA_PYTHONPATH : $(whereami) ;
+}
+
+# Reload the modules, to clean up things. The modules module can tolerate being
+# imported twice.
+#
+import modules ;
+
+# Process option plugins first to allow them to prevent loading the rest of the
+# build system.
+#
+import option ;
+local dont-build = [ option.process ] ;
+
+# Should we skip building, i.e. loading the build system, according to the
+# options processed?
+#
+if ! $(dont-build)
+{
+    if ! --python in $(ARGV)
+    {
+        # Allow users to override the build system file from the command-line
+        # (mostly for testing).
+        local build-system = [ MATCH --build-system=(.*) : $(ARGV) ] ;
+        build-system ?= build-system ;
+
+        # Use last element in case of multiple command-line options.
+        import $(build-system[-1]) ;
+    }
+    else
+    {
+        ECHO "Boost.Build V2 Python port (experimental)" ;
+
+        # Define additional interface exposed to Python code. Python code will
+        # also have access to select bjam builtins in the 'bjam' module, but
+        # some things are easier to define outside C.
+        module python_interface
+        {
+            rule load ( module-name : location )
+            {
+                USER_MODULE $(module-name) ;
+                # Make all rules in the loaded module available in the global
+                # namespace, so that we do not have to bother specifying the
+                # "correct" module when calling from Python.
+                module $(module-name)
+                {
+                    __name__ = $(1) ;
+                    include $(2) ;
+                    local rules = [ RULENAMES $(1) ] ;
+                    IMPORT $(1) : $(rules) : $(1) : $(1).$(rules) ;
+                }
+            }
+
+            rule peek ( module-name ? : variables + )
+            {
+                module $(<)
+                {
+                    return $($(>)) ;
+                }
+            }
+
+            rule set-variable ( module-name : name : value * )
+            {
+                module $(<)
+                {
+                    $(>) = $(3) ;
+                }
+            }
+
+            rule set-top-level-targets ( targets * )
+            {
+                DEPENDS all : $(targets) ;
+            }
+
+            rule call-in-module ( m : rulename : * )
+            {
+                module $(m)
+                {
+                    return [ $(2) $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9)
+                        : $(10) : $(11) : $(12) : $(13) : $(14) : $(15) : $(16)
+                        : $(17) : $(18) : $(19) ] ;
+                }
+            }
+
+
+            rule set-update-action ( action : targets * : sources * :
+                properties * )
+            {
+                $(action) $(targets) : $(sources) : $(properties) ;
+            }
+
+            rule set-update-action-in-module ( m : action : targets * :
+                sources * : properties * )
+            {
+                module $(m)
+                {
+                    $(2) $(3) : $(4) : $(5) ;
+                }
+            }
+
+            rule set-target-variable ( targets + : variable : value * : append ?
+                )
+            {
+                if $(append)
+                {
+                    $(variable) on $(targets) += $(value) ;
+                }
+                else
+                {
+                    $(variable) on $(targets) = $(value) ;
+                }
+            }
+
+            rule get-target-variable ( targets + : variable )
+            {
+                return [ on $(targets) return $($(variable)) ] ;
+            }
+
+            rule import-rules-from-parent ( parent-module : this-module :
+                user-rules * )
+            {
+                IMPORT $(parent-module) : $(user-rules) : $(this-module) :
+                    $(user-rules) ;
+                EXPORT $(this-module) : $(user-rules) ;
+            }
+
+            rule mark-included ( targets * : includes * )
+            {
+                NOCARE $(includes) ;
+                INCLUDES $(targets) : $(includes) ;
+                ISFILE $(includes) ;
+            }
+        }
+
+        PYTHON_IMPORT_RULE bootstrap : bootstrap : PyBB : bootstrap ;
+        modules.poke PyBB : root : [ NORMALIZE_PATH $(.bootstrap-file:DT)/.. ] ;
+
+        module PyBB
+        {
+            local ok = [ bootstrap $(root) ] ;
+            if ! $(ok)
+            {
+                EXIT ;
+            }
+        }
+
+
+        #PYTHON_IMPORT_RULE boost.build.build_system : main : PyBB : main ;
+
+        #module PyBB
+        #{
+        #    main ;
+        #}
+    }
+}