1 files changed, 0 insertions, 354 deletions
diff --git a/jam-files/boost-build/kernel/modules.jam b/jam-files/boost-build/kernel/modules.jam
deleted file mode 100644
index 1f75354f..00000000
--- a/jam-files/boost-build/kernel/modules.jam
+++ /dev/null
@@ -1,354 +0,0 @@
-# Copyright 2003 Dave Abrahams
-# Copyright 2003, 2005 Vladimir Prus
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
-
-# Essentially an include guard; ensures that no module is loaded multiple times.
-.loaded ?= ;
-
-# A list of modules currently being loaded for error reporting of circular
-# dependencies.
-.loading ?= ;
-
-# A list of modules needing to be tested using their __test__ rule.
-.untested ?= ;
-
-# A list of modules which have been tested using their __test__ rule.
-.tested ?= ;
-
-
-# Runs internal Boost Build unit tests for the specified module. The module's
-# __test__ rule is executed in its own module to eliminate any inadvertent
-# effects of testing module dependencies (such as assert) on the module itself.
-#
-local rule run-module-test ( m )
-{
-    local tested-modules = [ modules.peek modules : .tested ] ;
-
-    if ( ! $(m) in $(tested-modules) )  # Avoid recursive test invocations.
-        && ( ( --debug in $(argv) ) || ( --debug-module=$(m) in $(argv) ) )
-    {
-        modules.poke modules : .tested : $(tested-modules) $(m) ;
-
-        if ! ( __test__ in [ RULENAMES $(m) ] )
-        {
-            local argv = [ peek : ARGV ] ;
-            if ! ( --quiet in $(argv) ) && ( --debug-tests in $(argv) )
-            {
-                ECHO warning: no __test__ rule defined in module $(m) ;
-            }
-        }
-        else
-        {
-            if ! ( --quiet in $(argv) )
-            {
-                ECHO testing module $(m)... ;
-            }
-
-            local test-module = __test-$(m)__ ;
-            IMPORT $(m) : [ RULENAMES $(m) ] : $(test-module) : [ RULENAMES $(m) ] ;
-            IMPORT $(m) : __test__ : $(test-module) : __test__ : LOCALIZE ;
-            module $(test-module)
-            {
-                __test__ ;
-            }
-        }
-    }
-}
-
-
-# Return the binding of the given module.
-#
-rule binding ( module )
-{
-    return $($(module).__binding__) ;
-}
-
-
-# Sets the module-local value of a variable. This is the most reliable way to
-# set a module-local variable in a different module; it eliminates issues of
-# name shadowing due to dynamic scoping.
-#
-rule poke ( module-name ? : variables + : value * )
-{
-    module $(<)
-    {
-        $(>) = $(3) ;
-    }
-}
-
-
-# Returns the module-local value of a variable. This is the most reliable way to
-# examine a module-local variable in a different module; it eliminates issues of
-# name shadowing due to dynamic scoping.
-#
-rule peek ( module-name ? : variables + )
-{
-    module $(<)
-    {
-        return $($(>)) ;
-    }
-}
-
-
-# Call the given rule locally in the given module. Use this for rules accepting
-# rule names as arguments, so that the passed rule may be invoked in the context
-# of the rule's caller (for example, if the rule accesses module globals or is a
-# local rule). Note that rules called this way may accept at most 8 parameters.
-#
-rule call-in ( module-name ? : rule-name args * : * )
-{
-    module $(module-name)
-    {
-        return [ $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
-    }
-}
-
-
-# Given a possibly qualified rule name and arguments, remove any initial module
-# qualification from the rule and invoke it in that module. If there is no
-# module qualification, the rule is invoked in the global module. Note that
-# rules called this way may accept at most 8 parameters.
-#
-rule call-locally ( qualified-rule-name args * : * )
-{
-    local module-rule = [ MATCH (.*)\\.(.*) : $(qualified-rule-name) ] ;
-    local rule-name = $(module-rule[2]) ;
-    rule-name ?= $(qualified-rule-name) ;
-    #   We pass only 8 parameters here since Boost Jam allows at most 9 rule
-    # parameter positions and the call-in rule already uses up the initial
-    # position for the module name.
-    return [ call-in $(module-rule[1]) : $(rule-name) $(args) : $(2) : $(3) :
-        $(4) : $(5) : $(6) : $(7) : $(8) ] ;
-}
-
-
-# Load the indicated module if it is not already loaded.
-#
-rule load (
-      module-name  # Name of module to load. Rules will be defined in this
-                   # module.
-    : filename ?   # (partial) path to file; Defaults to $(module-name).jam.
-    : search *     # Directories in which to search for filename. Defaults to
-                   # $(BOOST_BUILD_PATH).
-)
-{
-    # Avoid loading modules twice.
-    if ! ( $(module-name) in $(.loaded) )
-    {
-        filename ?= $(module-name).jam ;
-
-        # Mark the module loaded so we do not try to load it recursively.
-        .loaded += $(module-name) ;
-
-        # Suppress tests if any module loads are already in progress.
-        local suppress-test = $(.loading[1]) ;
-
-        # Push this module on the loading stack.
-        .loading += $(module-name) ;
-
-        # Remember that it is untested.
-        .untested += $(module-name) ;
-
-        # Insert the new module's __name__ and __file__ globals.
-        poke $(module-name) : __name__ : $(module-name) ;
-        poke $(module-name) : __file__ : $(filename) ;
-
-        module $(module-name)
-        {
-            # Add some grist so that the module will have a unique target name.
-            local module-target = $(__file__:G=module@) ;
-
-            local search = $(3) ;
-            search ?= [ modules.peek : BOOST_BUILD_PATH ] ;
-            SEARCH on $(module-target) = $(search) ;
-            BINDRULE on $(module-target) = modules.record-binding ;
-
-            include $(module-target) ;
-
-            # Allow the module to see its own names with full qualification.
-            local rules = [ RULENAMES $(__name__) ] ;
-            IMPORT $(__name__) : $(rules) : $(__name__) : $(__name__).$(rules) ;
-        }
-
-        if $(module-name) != modules && ! [ binding $(module-name) ]
-        {
-            import errors ;
-            errors.error "Could not find module" $(module-name) in $(search) ;
-        }
-
-        # Pop the loading stack. Must happen before testing or we will run into
-        # a circular loading dependency.
-        .loading = $(.loading[1--2]) ;
-
-        # Run any pending tests if this is an outer load.
-        if ! $(suppress-test)
-        {
-            local argv = [ peek : ARGV ] ;
-            for local m in $(.untested)
-            {
-                run-module-test $(m) ;
-            }
-            .untested = ;
-        }
-    }
-    else if $(module-name) in $(.loading)
-    {
-        import errors ;
-        errors.error loading \"$(module-name)\"
-            : circular module loading dependency:
-            : $(.loading)" ->" $(module-name) ;
-    }
-}
-
-
-# This helper is used by load (above) to record the binding (path) of each
-# loaded module.
-#
-rule record-binding ( module-target : binding )
-{
-    $(.loading[-1]).__binding__ = $(binding) ;
-}
-
-
-# Transform each path in the list, with all backslashes converted to forward
-# slashes and all detectable redundancy removed. Something like this is probably
-# needed in path.jam, but I am not sure of that, I do not understand it, and I
-# am not ready to move all of path.jam into the kernel.
-#
-local rule normalize-raw-paths ( paths * )
-{
-    local result ;
-    for p in $(paths:T)
-    {
-        result += [ NORMALIZE_PATH $(p) ] ;
-    }
-    return $(result) ;
-}
-
-
-.cwd = [ PWD ] ;
-
-
-# Load the indicated module and import rule names into the current module. Any
-# members of rules-opt will be available without qualification in the caller's
-# module. Any members of rename-opt will be taken as the names of the rules in
-# the caller's module, in place of the names they have in the imported module.
-# If rules-opt = '*', all rules from the indicated module are imported into the
-# caller's module. If rename-opt is supplied, it must have the same number of
-# elements as rules-opt.
-#
-rule import ( module-names + : rules-opt * : rename-opt * )
-{
-    if ( $(rules-opt) = * || ! $(rules-opt) ) && $(rename-opt)
-    {
-        import errors ;
-        errors.error "Rule aliasing is only available for explicit imports." ;
-    }
-
-    if $(module-names[2]) && ( $(rules-opt) || $(rename-opt) )
-    {
-        import errors ;
-        errors.error "When loading multiple modules, no specific rules or"
-            "renaming is allowed" ;
-    }
-
-    local caller = [ CALLER_MODULE ] ;
-
-    # Import each specified module
-    for local m in $(module-names)
-    {
-        if ! $(m) in $(.loaded)
-        {
-            # If the importing module isn't already in the BOOST_BUILD_PATH,
-            # prepend it to the path.  We don't want to invert the search order
-            # of modules that are already there.
-
-            local caller-location ;
-            if $(caller)
-            {
-                caller-location = [ binding $(caller) ] ;
-                caller-location = $(caller-location:D) ;
-                caller-location = [ normalize-raw-paths $(caller-location:R=$(.cwd)) ] ;
-            }
-
-            local search = [ peek : BOOST_BUILD_PATH ] ;
-            search = [ normalize-raw-paths $(search:R=$(.cwd)) ] ;
-
-            if $(caller-location) && ! $(caller-location) in $(search)
-            {
-                search = $(caller-location) $(search) ;
-            }
-
-            load $(m) : : $(search) ;
-        }
-
-        IMPORT_MODULE $(m) : $(caller) ;
-
-        if $(rules-opt)
-        {
-            local source-names ;
-            if $(rules-opt) = *
-            {
-                local all-rules = [ RULENAMES $(m) ] ;
-                source-names = $(all-rules) ;
-            }
-            else
-            {
-                source-names = $(rules-opt) ;
-            }
-            local target-names = $(rename-opt) ;
-            target-names ?= $(source-names) ;
-            IMPORT $(m) : $(source-names) : $(caller) : $(target-names) ;
-        }
-    }
-}
-
-
-# Define exported copies in $(target-module) of all rules exported from
-# $(source-module). Also make them available in the global module with
-# qualification, so that it is just as though the rules were defined originally
-# in $(target-module).
-#
-rule clone-rules ( source-module target-module )
-{
-    local rules = [ RULENAMES $(source-module) ] ;
-
-    IMPORT $(source-module) : $(rules) : $(target-module) : $(rules) : LOCALIZE ;
-    EXPORT $(target-module) : $(rules) ;
-    IMPORT $(target-module) : $(rules) : : $(target-module).$(rules) ;
-}
-
-
-# These rules need to be available in all modules to implement module loading
-# itself and other fundamental operations.
-local globalize = peek poke record-binding ;
-IMPORT modules : $(globalize) : : modules.$(globalize) ;
-
-
-rule __test__ ( )
-{
-    import assert ;
-    import modules : normalize-raw-paths ;
-
-    module modules.__test__
-    {
-        foo = bar ;
-    }
-
-    assert.result bar : peek modules.__test__ : foo ;
-
-    poke modules.__test__ : foo : bar baz ;
-    assert.result bar baz : peek modules.__test__ : foo ;
-
-    assert.result c:/foo/bar : normalize-raw-paths c:/x/../foo/./xx/yy/../../bar ;
-    assert.result .          : normalize-raw-paths .                             ;
-    assert.result ..         : normalize-raw-paths ..                            ;
-    assert.result ../..      : normalize-raw-paths ../..                         ;
-    assert.result ..         : normalize-raw-paths ./..                          ;
-    assert.result / /        : normalize-raw-paths / \\                          ;
-    assert.result a          : normalize-raw-paths a                             ;
-    assert.result a          : normalize-raw-paths a/                            ;
-    assert.result /a         : normalize-raw-paths /a/                           ;
-    assert.result /          : normalize-raw-paths /a/..                         ;
-}