fixed conflicts

6 files changed, 0 insertions, 1341 deletions

diff --git a/jam-files/boost-build/kernel/boost-build.jam b/jam-files/boost-build/kernel/boost-build.jam
deleted file mode 100644
index 377f6ec0..00000000
--- a/jam-files/boost-build/kernel/boost-build.jam
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright 2003 Dave Abrahams 
-# 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) 
-
-boost-build . ;
diff --git a/jam-files/boost-build/kernel/bootstrap.jam b/jam-files/boost-build/kernel/bootstrap.jam
deleted file mode 100644
index 89048af9..00000000
--- a/jam-files/boost-build/kernel/bootstrap.jam
+++ /dev/null
@@ -1,263 +0,0 @@
-# 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 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 don't 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 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 don't have a way to test that 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 bjam 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 bjam 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 an incremental refactoring step by moving modules to
-    # the 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 included twice.
-#
-import modules ;
-
-# Process option plugins first to alow 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 that is 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 don't have
-	        # to bother specifying "right" 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) ] ;
-                }                
-            }
-
-            
-            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 ;
-        #}
-
-    }
-}
diff --git a/jam-files/boost-build/kernel/bootstrap.py b/jam-files/boost-build/kernel/bootstrap.py
deleted file mode 100644
index 2e8dd37b..00000000
--- a/jam-files/boost-build/kernel/bootstrap.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Copyright 2009 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)
-
-import imp
-import sys
-
-def bootstrap(root_path):
-    """Performs python-side bootstrapping of Boost.Build/Python.
-
-    This function arranges for 'b2.whatever' package names to work, while also
-    allowing to put python files alongside corresponding jam modules.
-    """
-
-    m = imp.new_module("b2")
-    # Note that:
-    # 1. If __path__ is not list of strings, nothing will work
-    # 2. root_path is already list of strings.
-    m.__path__ = root_path
-    sys.modules["b2"] = m
-
-    import b2.build_system
-    return b2.build_system.main()
-
diff --git a/jam-files/boost-build/kernel/class.jam b/jam-files/boost-build/kernel/class.jam
deleted file mode 100644
index b8e55af3..00000000
--- a/jam-files/boost-build/kernel/class.jam
+++ /dev/null
@@ -1,420 +0,0 @@
-# Copyright 2001, 2002, 2003 Dave Abrahams
-# Copyright 2002, 2005 Rene Rivera
-# Copyright 2002, 2003 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)
-
-# Polymorphic class system built on top of core Jam facilities.
-#
-# Classes are defined by 'class' keywords::
-#
-#     class myclass
-#     {
-#         rule __init__ ( arg1 )     # constructor
-#         {
-#             self.attribute = $(arg1) ;
-#         }
-#
-#         rule method1 ( )           # method
-#         {
-#             return [ method2 ] ;
-#         }
-#
-#         rule method2 ( )           # method
-#         {
-#             return $(self.attribute) ;
-#         }
-#     }
-#
-# The __init__ rule is the constructor, and sets member variables.
-#
-# New instances are created by invoking [ new <class> <args...> ]:
-#
-#     local x = [ new myclass foo ] ;        # x is a new myclass object
-#     assert.result foo : [ $(x).method1 ] ; # $(x).method1 returns "foo"
-#
-# Derived class are created by mentioning base classes in the declaration::
-#
-#     class derived : myclass
-#     {
-#          rule __init__ ( arg )
-#          {
-#              myclass.__init__ $(arg) ;  # call base __init__
-#
-#          }
-#
-#          rule method2 ( )           # method override
-#          {
-#              return $(self.attribute)XXX ;
-#          }
-#     }
-#
-# All methods operate virtually, replacing behavior in the base classes. For
-# example::
-#
-#     local y = [ new derived foo ] ;            # y is a new derived object
-#     assert.result fooXXX : [ $(y).method1 ] ;  # $(y).method1 returns "foo"
-#
-# Each class instance is its own core Jam module. All instance attributes and
-# methods are accessible without additional qualification from within the class
-# instance. All rules imported in class declaration, or visible in base classses
-# are also visible. Base methods are available in qualified form:
-# base-name.method-name. By convention, attribute names are prefixed with
-# "self.".
-
-import modules ;
-import numbers ;
-
-
-rule xinit ( instance : class )
-{
-    module $(instance)
-    {
-        __class__ = $(2) ;
-        __name__ = $(1) ;
-    }
-}
-
-
-rule new ( class args * : * )
-{
-    .next-instance ?= 1 ;
-    local id = object($(class))@$(.next-instance) ;
-
-    xinit $(id) : $(class) ;
-
-    INSTANCE $(id) : class@$(class) ;
-    IMPORT_MODULE $(id) ;
-    $(id).__init__ $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
-
-    # Bump the next unique object name.
-    .next-instance = [ numbers.increment $(.next-instance) ] ;
-
-    # Return the name of the new instance.
-    return $(id) ;
-}
-
-
-rule bases ( class )
-{
-    module class@$(class)
-    {
-        return $(__bases__) ;
-    }
-}
-
-
-rule is-derived ( class : bases + )
-{
-    local stack = $(class) ;
-    local visited found ;
-    while ! $(found) && $(stack)
-    {
-        local top = $(stack[1]) ;
-        stack = $(stack[2-]) ;
-        if ! ( $(top) in $(visited) )
-        {
-            visited += $(top) ;
-            stack += [ bases $(top) ] ;
-
-            if $(bases) in $(visited)
-            {
-                found = true ;
-            }
-        }
-    }
-    return $(found) ;
-}
-
-
-# Returns true if the 'value' is a class instance.
-#
-rule is-instance ( value )
-{
-    return [ MATCH "^(object\\()[^@]+\\)@.*" : $(value) ] ;
-}
-
-
-# Check if the given value is of the given type.
-#
-rule is-a (
-    instance  # The value to check.
-    : type  # The type to test for.
-)
-{
-    if [ is-instance $(instance) ]
-    {
-        return [ class.is-derived [ modules.peek $(instance) : __class__ ] : $(type) ] ;
-    }
-}
-
-
-local rule typecheck ( x )
-{
-    local class-name = [ MATCH "^\\[(.*)\\]$" : [ BACKTRACE 1 ] ] ;
-    if ! [ is-a $(x) : $(class-name) ]
-    {
-        return "Expected an instance of "$(class-name)" but got \""$(x)"\" for argument" ;
-    }
-}
-
-
-rule __test__ ( )
-{
-    import assert ;
-    import "class" : new ;
-
-    # This will be the construction function for a class called 'myclass'.
-    #
-    class myclass
-    {
-        import assert ;
-
-        rule __init__ ( x_ * : y_ * )
-        {
-            # Set some instance variables.
-            x = $(x_) ;
-            y = $(y_) ;
-            foo += 10 ;
-        }
-
-        rule set-x ( newx * )
-        {
-            x = $(newx) ;
-        }
-
-        rule get-x ( )
-        {
-            return $(x) ;
-        }
-
-        rule set-y ( newy * )
-        {
-            y = $(newy) ;
-        }
-
-        rule get-y ( )
-        {
-            return $(y) ;
-        }
-
-        rule f ( )
-        {
-            return [ g $(x) ] ;
-        }
-
-        rule g ( args * )
-        {
-            if $(x) in $(y)
-            {
-                return $(x) ;
-            }
-            else if $(y) in $(x)
-            {
-                return $(y) ;
-            }
-            else
-            {
-                return ;
-            }
-        }
-
-        rule get-class ( )
-        {
-            return $(__class__) ;
-        }
-
-        rule get-instance ( )
-        {
-            return $(__name__) ;
-        }
-
-        rule invariant ( )
-        {
-            assert.equal 1 : 1 ;
-        }
-
-        rule get-foo ( )
-        {
-            return $(foo) ;
-        }
-    }
-#    class myclass ;
-
-    class derived1 : myclass
-    {
-        rule __init__ ( z_ )
-        {
-            myclass.__init__ $(z_) : X ;
-            z = $(z_) ;
-        }
-
-        # Override g.
-        #
-        rule g ( args * )
-        {
-            return derived1.g ;
-        }
-
-        rule h ( )
-        {
-            return derived1.h ;
-        }
-
-        rule get-z ( )
-        {
-            return $(z) ;
-        }
-
-        # Check that 'assert.equal' visible in base class is visible here.
-        #
-        rule invariant2 ( )
-        {
-            assert.equal 2 : 2 ;
-        }
-
-        # Check that 'assert.variable-not-empty' visible in base class is
-        # visible here.
-        #
-        rule invariant3 ( )
-        {
-            local v = 10 ;
-            assert.variable-not-empty v ;
-        }
-    }
-#    class derived1 : myclass ;
-
-    class derived2 : myclass
-    {
-        rule __init__ ( )
-        {
-            myclass.__init__ 1 : 2 ;
-        }
-
-        # Override g.
-        #
-        rule g ( args * )
-        {
-            return derived2.g ;
-        }
-
-        # Test the ability to call base class functions with qualification.
-        #
-        rule get-x ( )
-        {
-            return [ myclass.get-x ] ;
-        }
-    }
-#    class derived2 : myclass ;
-
-    class derived2a : derived2
-    {
-        rule __init__
-        {
-            derived2.__init__ ;
-        }
-    }
-#    class derived2a : derived2 ;
-
-    local rule expect_derived2 ( [derived2] x ) { }
-
-    local a = [ new myclass 3 4 5 : 4 5 ] ;
-    local b = [ new derived1 4 ] ;
-    local b2 = [ new derived1 4 ] ;
-    local c = [ new derived2 ] ;
-    local d = [ new derived2 ] ;
-    local e = [ new derived2a ] ;
-
-    expect_derived2 $(d) ;
-    expect_derived2 $(e) ;
-
-    # Argument checking is set up to call exit(1) directly on failure, and we
-    # can not hijack that with try, so we should better not do this test by
-    # default. We could fix this by having errors look up and invoke the EXIT
-    # rule instead; EXIT can be hijacked (;-)
-    if --fail-typecheck in [ modules.peek : ARGV ]
-    {
-        try ;
-        {
-            expect_derived2 $(a) ;
-        }
-        catch
-            "Expected an instance of derived2 but got" instead
-            ;
-    }
-
-    #try ;
-    #{
-    #    new bad_subclass ;
-    #}
-    #catch
-    #  bad_subclass.bad_subclass failed to call base class constructor myclass.__init__
-    #  ;
-
-    #try ;
-    #{
-    #    class bad_subclass ;
-    #}
-    #catch bad_subclass has already been declared ;
-
-    assert.result 3 4 5 : $(a).get-x ;
-    assert.result 4 5 : $(a).get-y ;
-    assert.result 4 : $(b).get-x ;
-    assert.result X : $(b).get-y ;
-    assert.result 4 : $(b).get-z ;
-    assert.result 1 : $(c).get-x ;
-    assert.result 2 : $(c).get-y ;
-    assert.result 4 5 : $(a).f ;
-    assert.result derived1.g : $(b).f ;
-    assert.result derived2.g : $(c).f ;
-    assert.result derived2.g : $(d).f ;
-
-    assert.result 10 : $(b).get-foo ;
-
-    $(a).invariant ;
-    $(b).invariant2 ;
-    $(b).invariant3 ;
-
-    # Check that the __class__ attribute is getting properly set.
-    assert.result myclass : $(a).get-class ;
-    assert.result derived1 : $(b).get-class ;
-    assert.result $(a) : $(a).get-instance ;
-
-    $(a).set-x a.x ;
-    $(b).set-x b.x ;
-    $(c).set-x c.x ;
-    $(d).set-x d.x ;
-    assert.result a.x : $(a).get-x ;
-    assert.result b.x : $(b).get-x ;
-    assert.result c.x : $(c).get-x ;
-    assert.result d.x : $(d).get-x ;
-
-    class derived3 : derived1 derived2
-    {
-        rule __init__ ( )
-        {
-        }
-    }
-
-    assert.result : bases myclass ;
-    assert.result myclass : bases derived1 ;
-    assert.result myclass : bases derived2 ;
-    assert.result derived1 derived2 : bases derived3 ;
-
-    assert.true is-derived derived1 : myclass ;
-    assert.true is-derived derived2 : myclass ;
-    assert.true is-derived derived3 : derived1 ;
-    assert.true is-derived derived3 : derived2 ;
-    assert.true is-derived derived3 : derived1 derived2 myclass ;
-    assert.true is-derived derived3 : myclass ;
-
-    assert.false is-derived myclass : derived1 ;
-
-    assert.true is-instance $(a) ;
-    assert.false is-instance bar ;
-
-    assert.true is-a $(a) : myclass ;
-    assert.true is-a $(c) : derived2 ;
-    assert.true is-a $(d) : myclass ;
-    assert.false is-a literal : myclass ;
-}
diff --git a/jam-files/boost-build/kernel/errors.jam b/jam-files/boost-build/kernel/errors.jam
deleted file mode 100644
index 63b11e86..00000000
--- a/jam-files/boost-build/kernel/errors.jam
+++ /dev/null
@@ -1,274 +0,0 @@
-# Copyright 2003 Dave Abrahams
-# Copyright 2004 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)
-
-# Print a stack backtrace leading to this rule's caller. Each argument
-# represents a line of output to be printed after the first line of the
-# backtrace.
-#
-rule backtrace ( skip-frames prefix messages * : * )
-{
-    local frame-skips = 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65 69 73 77 81 ;
-    local drop-elements = $(frame-skips[$(skip-frames)]) ;
-    if ! ( $(skip-frames) in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 )
-    {
-        ECHO "warning: backtrace doesn't support skipping $(skip-frames) frames;"
-            "using 1 instead." ;
-        drop-elements = 5 ;
-    }
-
-    local args = $(.args) ;
-    if $(.user-modules-only)
-    {
-        local bt = [ nearest-user-location ] ;
-        ECHO "$(prefix) at $(bt) " ;
-        for local n in $(args)
-        {
-            if $($(n))-is-not-empty
-            {
-                ECHO $(prefix) $($(n)) ;
-            }
-        }
-    }
-    else
-    {
-        # Get the whole backtrace, then drop the initial quadruples
-        # corresponding to the frames that must be skipped.
-        local bt = [ BACKTRACE ] ;
-        bt = $(bt[$(drop-elements)-]) ;
-
-        while $(bt)
-        {
-            local m = [ MATCH ^(.+)\\.$ : $(bt[3]) ] ;
-            ECHO $(bt[1]):$(bt[2]): "in" $(bt[4]) "from module" $(m) ;
-
-            # The first time through, print each argument on a separate line.
-            for local n in $(args)
-            {
-                if $($(n))-is-not-empty
-                {
-                    ECHO $(prefix) $($(n)) ;
-                }
-            }
-            args = ;  # Kill args so that this never happens again.
-
-            # Move on to the next quadruple.
-            bt = $(bt[5-]) ;
-        }
-    }
-}
-
-.args ?= messages 2 3 4 5 6 7 8 9 ;
-.disabled ?= ;
-.last-error-$(.args) ?= ;
-
-
-# try-catch --
-#
-# This is not really an exception-handling mechanism, but it does allow us to
-# perform some error-checking on our error-checking. Errors are suppressed after
-# a try, and the first one is recorded. Use catch to check that the error
-# message matched expectations.
-
-# Begin looking for error messages.
-#
-rule try ( )
-{
-    .disabled += true ;
-    .last-error-$(.args) = ;
-}
-
-
-# Stop looking for error messages; generate an error if an argument of messages
-# is not found in the corresponding argument in the error call.
-#
-rule catch ( messages * : * )
-{
-    .disabled = $(.disabled[2-]) ;  # Pop the stack.
-
-    import sequence ;
-
-    if ! $(.last-error-$(.args))-is-not-empty
-    {
-        error-skip-frames 3 expected an error, but none occurred ;
-    }
-    else
-    {
-        for local n in $(.args)
-        {
-            if ! $($(n)) in $(.last-error-$(n))
-            {
-                local v = [ sequence.join $($(n)) : " " ] ;
-                v ?= "" ;
-                local joined = [ sequence.join $(.last-error-$(n)) : " " ] ;
-
-                .last-error-$(.args) = ;
-                error-skip-frames 3 expected \"$(v)\" in argument $(n) of error
-                    : got \"$(joined)\" instead ;
-            }
-        }
-    }
-}
-
-
-rule error-skip-frames ( skip-frames messages * : * )
-{
-    if ! $(.disabled)
-    {
-        backtrace $(skip-frames) error: $(messages) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
-        EXIT ;
-    }
-    else if ! $(.last-error-$(.args))
-    {
-        for local n in $(.args)
-        {
-            # Add an extra empty string so that we always have
-            # something in the event of an error
-            .last-error-$(n) = $($(n)) "" ;
-        }
-    }
-}
-
-if --no-error-backtrace in [ modules.peek : ARGV ]
-{
-    .no-error-backtrace = true ;
-}
-
-
-# Print an error message with a stack backtrace and exit.
-#
-rule error ( messages * : * )
-{
-    if $(.no-error-backtrace)
-    {
-        # Print each argument on a separate line.
-        for local n in $(.args)
-        {
-            if $($(n))-is-not-empty
-            {
-                if ! $(first-printed)
-                {
-                    ECHO error: $($(n)) ;
-                    first-printed = true ;
-                }
-                else
-                {
-                    ECHO $($(n)) ;
-                }
-            }
-        }
-        EXIT ;
-    }
-    else
-    {
-        error-skip-frames 3 $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
-    }
-}
-
-
-# Same as 'error', but the generated backtrace will include only user files.
-#
-rule user-error ( messages * : * )
-{
-    .user-modules-only = 1 ;
-    error-skip-frames 3 $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
-}
-
-
-# Print a warning message with a stack backtrace and exit.
-#
-rule warning
-{
-    backtrace 2 warning: $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
-}
-
-
-# Convert an arbitrary argument list into a list with ":" separators and quoted
-# elements representing the same information. This is mostly useful for
-# formatting descriptions of arguments with which a rule was called when
-# reporting an error.
-#
-rule lol->list ( * )
-{
-    local result ;
-    local remaining = 1 2 3 4 5 6 7 8 9 ;
-    while $($(remaining))
-    {
-        local n = $(remaining[1]) ;
-        remaining = $(remaining[2-]) ;
-
-        if $(n) != 1
-        {
-            result += ":" ;
-        }
-        result += \"$($(n))\" ;
-    }
-    return $(result) ;
-}
-
-
-# Return the file:line for the nearest entry in backtrace which correspond to a
-# user module.
-#
-rule nearest-user-location ( )
-{
-    local bt = [ BACKTRACE ] ;
-
-    local result ;
-    while $(bt) && ! $(result)
-    {
-        local m = [ MATCH ^(.+)\\.$ : $(bt[3]) ] ;
-        local user-modules = ([Jj]amroot(.jam|.v2|)|([Jj]amfile(.jam|.v2|)|user-config.jam|site-config.jam|project-root.jam) ;
-
-        if [ MATCH $(user-modules) : $(bt[1]:D=) ]
-        {
-            result = $(bt[1]):$(bt[2]) ;
-        }
-        bt = $(bt[5-]) ;
-    }
-    return $(result) ;
-}
-
-
-# If optimized rule is available in Jam, use it.
-if NEAREST_USER_LOCATION in [ RULENAMES ]
-{
-    rule nearest-user-location ( )
-    {
-        local r = [ NEAREST_USER_LOCATION ] ;
-        return $(r[1]):$(r[2]) ;
-    }
-}
-
-
-rule __test__ ( )
-{
-    # Show that we can correctly catch an expected error.
-    try ;
-    {
-        error an error occurred : somewhere ;
-    }
-    catch an error occurred : somewhere ;
-
-    # Show that unexpected errors generate real errors.
-    try ;
-    {
-        try ;
-        {
-            error an error occurred : somewhere ;
-        }
-        catch an error occurred : nowhere ;
-    }
-    catch expected \"nowhere\" in argument 2 ;
-
-    # Show that not catching an error where one was expected is an error.
-    try ;
-    {
-        try ;
-        {
-        }
-        catch ;
-    }
-    catch expected an error, but none occurred ;
-}
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/..                         ;
-}