[Boost-commit] svn:boost r68439 - in branches/release/tools/build/v2: . build doc engine example/customization example/generate test/dependency-test tools util

Subject: [Boost-commit] svn:boost r68439 - in branches/release/tools/build/v2: . build doc engine example/customization example/generate test/dependency-test tools util
From: ghost_at_[hidden]
Date: 2011-01-25 13:46:08

Author: vladimir_prus
Date: 2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
New Revision: 68439
URL: http://svn.boost.org/trac/boost/changeset/68439

Log:
Add files that recent merge of Boost.Build missed
Added:
   branches/release/tools/build/v2/Jamroot.jam   (contents, props changed)
   branches/release/tools/build/v2/bootstrap.bat   (contents, props changed)
   branches/release/tools/build/v2/bootstrap.sh   (contents, props changed)
   branches/release/tools/build/v2/build/ac.jam   (contents, props changed)
   branches/release/tools/build/v2/build/configure.py   (contents, props changed)
   branches/release/tools/build/v2/doc/bjam.qbk   (contents, props changed)
   branches/release/tools/build/v2/doc/history.qbk   (contents, props changed)
   branches/release/tools/build/v2/engine/boost-no-inspect   (contents, props changed)
   branches/release/tools/build/v2/example/customization/verbatim.py   (contents, props changed)
   branches/release/tools/build/v2/example/generate/gen.jam   (contents, props changed)
   branches/release/tools/build/v2/example/generate/gen.py   (contents, props changed)
   branches/release/tools/build/v2/test/dependency-test/foo.py   (contents, props changed)
   branches/release/tools/build/v2/tools/cast.py   (contents, props changed)
   branches/release/tools/build/v2/tools/message.py   (contents, props changed)
   branches/release/tools/build/v2/tools/notfile.py   (contents, props changed)
   branches/release/tools/build/v2/tools/package.py   (contents, props changed)
   branches/release/tools/build/v2/tools/stage.py   (contents, props changed)
   branches/release/tools/build/v2/tools/symlink.py   (contents, props changed)
   branches/release/tools/build/v2/tools/testing-aux.jam   (contents, props changed)
   branches/release/tools/build/v2/tools/testing.py   (contents, props changed)
   branches/release/tools/build/v2/tools/zlib.jam   (contents, props changed)
   branches/release/tools/build/v2/util/indirect.py   (contents, props changed)
   branches/release/tools/build/v2/util/option.py   (contents, props changed)
   branches/release/tools/build/v2/util/os_j.py   (contents, props changed)

Added: branches/release/tools/build/v2/Jamroot.jam
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/Jamroot.jam	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,46 @@
+
+path-constant SELF : . ;
+
+import path ;
+import package ;
+import os ;
+
+local ext = "" ;
+if [ os.on-windows ]
+{
+    ext = ".exe" ;
+}
+
+
+package.install boost-build-engine boost-build
+  : # properties
+  : # binaries
+    bjam$(ext)
+  ;
+
+local e1 = [ path.glob-tree $(SELF)/example : * : . .svn ] ;
+local e2 ;
+for e in $(e1)
+{
+    if [ CHECK_IF_FILE $(e) ]
+    {
+        e2 += $(e) ;
+    }    
+}
+
+package.install-data boost-build-core
+  : # Which subdir of $prefix/share
+    boost-build  
+  : # What to install
+    $(SELF)/boost-build.jam
+    $(SELF)/build-system.jam
+    [ path.glob-tree $(SELF)/build : *.jam *.py ]
+    [ path.glob-tree $(SELF)/kernel : *.jam *.py ]
+    [ path.glob-tree $(SELF)/util : *.jam *.py ]
+    [ path.glob-tree $(SELF)/tools : *.jam *.py ]
+    $(e2)
+  : # What is the root of the directory
+    <install-source-root>.
+  ;
+  
+alias install : boost-build-engine boost-build-core ;
\ No newline at end of file

Added: branches/release/tools/build/v2/bootstrap.bat
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/bootstrap.bat	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,47 @@
+@ECHO OFF
+
+REM Copyright (C) 2009 Vladimir Prus
+REM
+REM Distributed under the Boost Software License, Version 1.0.
+REM (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+ECHO Bootstrapping the build engine
+if exist ".\engine\src\bin.ntx86\bjam.exe" del engine\src\bin.ntx86\bjam.exe
+if exist ".\engine\src\bin.ntx86_64\bjam.exe" del engine\src\bin.ntx86_64\bjam.exe
+cd engine\src
+
+call .\build.bat %* > ..\..\bootstrap.log
+@ECHO OFF
+cd ..\..
+
+if exist ".\engine\src\bin.ntx86\bjam.exe" (
+   copy .\engine\src\bin.ntx86\bjam.exe . > nul
+   goto :bjam_built)
+
+if exist ".\engine\src\bin.ntx86_64\bjam.exe" (
+   copy .\engine\src\bin.ntx86_64\bjam.exe . > nul
+   goto :bjam_built)
+
+goto :bjam_failure
+
+:bjam_built
+
+ECHO.
+ECHO Bootstrapping is done. To build, run:
+ECHO.
+ECHO     .\bjam --prefix=DIR install
+ECHO.
+
+goto :end
+
+:bjam_failure
+
+ECHO.
+ECHO Failed to bootstrap the build engine
+ECHO Please consult bootstrap.log for furter diagnostics.
+ECHO.
+
+
+goto :end
+
+:end

Added: branches/release/tools/build/v2/bootstrap.sh
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/bootstrap.sh	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,119 @@
+#!/bin/sh
+# Copyright (C) 2005, 2006 Douglas Gregor.
+# Copyright (C) 2006 The Trustees of Indiana University
+# Copyright (C) 2010 Bryce Lelbach 
+#
+# 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)
+
+# boostinspect:notab - Tabs are required for the Makefile.
+
+BJAM=""
+TOOLSET=""
+BJAM_CONFIG=""
+
+for option
+do
+    case $option in
+
+    -help | --help | -h)
+      want_help=yes ;;
+
+    -with-toolset=* | --with-toolset=* )
+      TOOLSET=`expr "x$option" : "x-*with-toolset=\(.*\)"`
+      ;;
+
+    -*)
+      { echo "error: unrecognized option: $option
+Try \`$0 --help' for more information." >&2
+      { (exit 1); exit 1; }; }
+      ;; 
+
+    esac
+done
+
+if test "x$want_help" = xyes; then
+  cat <<EOF
+\`./bootstrap.sh' creates minimal Boost.Build, which can install itself.
+
+Usage: $0 [OPTION]... 
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help                display this help and exit
+  --with-bjam=BJAM          use existing Boost.Jam executable (bjam)
+                            [automatically built]
+  --with-toolset=TOOLSET    use specific Boost.Build toolset
+                            [automatically detected]
+EOF
+fi
+test -n "$want_help" && exit 0
+
+# TBD: Determine where the script is located
+my_dir="."
+
+# Determine the toolset, if not already decided
+if test "x$TOOLSET" = x; then
+  guessed_toolset=`$my_dir/engine/src/build.sh --guess-toolset`
+  case $guessed_toolset in
+    acc | darwin | gcc | como | mipspro | pathscale | pgi | qcc | vacpp )
+    TOOLSET=$guessed_toolset
+    ;;
+    
+    intel-* )
+    TOOLSET=intel
+    ;;
+    
+    mingw )
+    TOOLSET=gcc
+    ;;
+    
+    clang* )
+    TOOLSET=clang
+    ;;
+
+    sun* )
+    TOOLSET=sun
+    ;;
+    
+    * )
+    # Not supported by Boost.Build
+    ;;
+  esac
+fi
+
+case $TOOLSET in 
+  clang*)
+  TOOLSET=clang
+  ;;
+esac
+
+
+rm -f config.log
+
+# Build bjam
+if test "x$BJAM" = x; then
+  echo -n "Bootstrapping the build engine with toolset $TOOLSET... "
+  pwd=`pwd`
+  (cd "$my_dir/engine/src" && ./build.sh "$TOOLSET") > bootstrap.log 2>&1
+  if [ $? -ne 0 ]; then
+      echo
+      echo "Failed to bootstrap the build engine" 
+      echo "Consult 'bootstrap.log' for more details"
+      exit 1
+  fi
+  cd "$pwd"
+  arch=`cd $my_dir/engine/src && ./bootstrap/jam0 -d0 -f build.jam --toolset=$TOOLSET --toolset-root= --show-locate-target && cd ..`
+  BJAM="$my_dir/engine/src/$arch/bjam"
+  echo "engine/src/$arch/bjam"
+  cp "$BJAM" .
+fi
+
+cat << EOF
+
+Bootstrapping is done. To build and install, run:
+
+    ./bjam install --prefix=<DIR>
+
+EOF

Added: branches/release/tools/build/v2/build/ac.jam
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/build/ac.jam	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,198 @@
+# Copyright (c) 2010 Vladimir Prus.
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import property-set ;
+import path ;
+import modules ;
+import "class" ; 
+import errors ;
+import configure ;
+
+rule find-include-path ( variable : properties : header 
+    : provided-path ? )
+{
+    # FIXME: document which properties affect this function by
+    # default.
+    local target-os = [ $(properties).get <target-os> ] ;
+    properties = [ property-set.create <target-os>$(toolset) ] ;    
+    if $($(variable)-$(properties))
+    {
+        return $($(variable)-$(properties)) ;
+    }
+    else
+    {
+        provided-path ?= [ modules.peek : $(variable) ] ;
+        includes = $(provided-path) ;
+        includes += [ $(properties).get <include> ] ;
+        if [ $(properties).get <target-os> ] != windows
+        {
+            # FIXME: use sysroot
+            includes += /usr/include ;
+        }
+        
+        local result ;
+        while ! $(result) && $(includes)
+        {            
+            local f = [ path.root $(header) $(includes[1]) ] ;
+            ECHO "Checking " $(f) ;
+            if [ path.exists $(f) ]
+            {
+                result = $(includes[1]) ;
+            }
+            else if $(provided-path)
+            {
+                errors.user-error "Could not find header" $(header)
+                  : "in the user-specified directory" $(provided-path) ;
+            }            
+            includes = $(includes[2-]) ;                
+        }        
+        $(variable)-$(properties) = $(result) ;
+        return $(result) ;
+    }        
+}
+
+rule find-library ( variable : properties : names + : provided-path ? )
+{
+    local target-os = [ $(properties).get <target-os> ] ;
+    properties = [ property-set.create <target-os>$(toolset) ] ;
+    if $($(variable)-$(properties))
+    {
+        return $($(variable)-$(properties)) ;
+    }
+    else
+    {
+        provided-path ?= [ modules.peek : $(variable) ] ;
+        paths = $(provided-path) ;
+        paths += [ $(properties).get <library-path> ] ;
+        if [ $(properties).get <target-os> ] != windows
+        {
+            paths += /usr/lib /usr/lib32 /usr/lib64 ;
+        }
+        
+        local result ;               
+        while ! $(result) && $(paths)
+        {   
+            while ! $(result) && $(names)
+            {
+                local f ;
+                if $(target-os) = windows
+                {         
+                    f = $(paths[1])/$(names[1]).lib ;                
+                    if [ path.exists $(f) ] 
+                    {
+                        result = $(f) ;
+                    }
+                }
+                else
+                {
+                    # FIXME: check for .a as well, depending on
+                    # the 'link' feature.
+                    f = $(paths[1])/lib$(names[1]).so ;                
+                    ECHO "CHECKING $(f) " ;
+                    if [ path.exists $(f) ] 
+                    {
+                        result = $(f) ;
+                    }
+                }
+                if ! $(result) && $(provided-path)
+                {
+                    errors.user-error "Could not find either of: " $(names)
+                      : "in the user-specified directory" $(provided-path) ;
+                    
+                }                
+                names = $(names[2-]) ;
+            }
+            paths = $(paths[2-]) ;
+        }        
+        $(variable)-$(properties) = $(result) ;
+        return $(result) ;
+    }
+}
+
+class ac-library : basic-target
+{
+    import errors ;
+    import indirect ;
+    import virtual-target ;
+    import ac ;
+    import configure ;
+
+    rule __init__ ( name : project : * : * )
+    {
+        basic-target.__init__ $(name) : $(project) : $(sources)
+          : $(requirements) ;
+        
+        reconfigure $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ; 
+    }
+    
+    rule set-header ( header )
+    {
+        self.header = $(header) ; 
+    }
+        
+    rule set-default-names ( names + )
+    {
+        self.default-names = $(names) ;
+    }
+        
+    rule reconfigure ( * : * )
+    {
+        ECHO "XXX" $(1) ;
+        if ! $(1)
+        {
+            # This is 'using xxx ;'. Nothing to configure, really.
+        }
+        else
+        {
+            for i in 1 2 3 4 5 6 7 8 9             
+            {
+                # FIXME: this naming is inconsistent with XXX_INCLUDE/XXX_LIBRARY
+                if ! ( $($(i)[1]) in root include-path library-path library-name condition )
+                {
+                    errors.user-error "Invalid named parameter" $($(i)[1]) ;
+                }   
+                local name = $($(i)[1]) ;
+                local value = $($(i)[2-]) ;
+                if $($(name)) && $($(name)) != $(value)
+                {
+                    errors.user-error "Attempt to change value of '$(name)'" ;
+                }
+                $(name) = $(value) ;
+            }
+            
+            include-path ?= $(root)/include ;
+            library-path ?= $(root)/lib ;            
+        }        
+    }
+    
+    rule construct ( name : sources * : property-set )
+    {
+        # FIXME: log results.
+        local libnames = $(library-name) ;
+        if ! $(libnames) && ! $(include-path) && ! $(library-path)
+        {
+            libnames = [ modules.peek : $(name:U)_NAME ] ;
+            # Backward compatibility only.
+            libnames ?= [ modules.peek : $(name:U)_BINARY ] ;
+        }
+        libnames ?= $(self.default-names) ;
+                        
+        local includes = [ 
+          ac.find-include-path $(name:U)_INCLUDE : $(property-set) : $(self.header) : $(include-path) ] ;
+        local library = [ ac.find-library $(name:U)_LIBRARY : $(property-set) : $(libnames) : $(library-path) ] ;
+        if $(includes) && $(library)
+        {
+            library = [ virtual-target.from-file $(library) : . : $(self.project) ] ;
+            configure.log-library-search-result $(name) : "found" ;
+            return [ property-set.create <include>$(includes) <source>$(library) ] ;
+        }
+        else
+        {
+            configure.log-library-search-result $(name) : "no found" ;
+        }        
+    }
+}
+

Added: branches/release/tools/build/v2/build/configure.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/build/configure.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,164 @@
+# Status: ported.
+# Base revison: 64488
+#
+# Copyright (c) 2010 Vladimir Prus.
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# This module defines function to help with two main tasks:
+#
+# - Discovering build-time configuration for the purposes of adjusting
+#   build process.  
+# - Reporting what is built, and how it is configured.
+
+import b2.build.property as property
+import b2.build.property_set as property_set
+
+import b2.build.targets
+
+from b2.manager import get_manager
+from b2.util.sequence import unique
+from b2.util import bjam_signature, value_to_jam
+
+import bjam
+import os
+
+__width = 30
+
+def set_width(width):
+    global __width
+    __width = 30
+
+__components = []
+__built_components = []
+__component_logs = {}
+__announced_checks = False
+
+__log_file = None
+__log_fd = -1
+
+def register_components(components):
+    """Declare that the components specified by the parameter exist."""
+    __components.extend(components)
+    
+def components_building(components):
+    """Declare that the components specified by the parameters will be build."""
+    __built_components.extend(components)
+
+def log_component_configuration(component, message):
+    """Report something about component configuration that the user should better know."""
+    __component_logs.setdefault(component, []).append(message)
+
+def log_check_result(result):
+    global __announced_checks
+    if not __announced_checks:
+        print "Performing configuration checks"
+        __announced_checks = True
+
+    print result
+
+def log_library_search_result(library, result):
+    log_check_result(("    - %(library)s : %(result)s" % locals()).rjust(width))
+
+
+def print_component_configuration():
+
+    print "\nComponent configuration:"
+    for c in __components:
+        if c in __built_components:
+            s = "building"
+        else:
+            s = "not building"
+        message = "    - %s)" % c
+        message = message.rjust(__width)
+        message += " : " + s
+        for m in __component_logs.get(c, []):
+            print "        -" + m
+    print ""
+
+__builds_cache = {}
+
+def builds(metatarget_reference, project, ps, what):
+    # Attempt to build a metatarget named by 'metatarget-reference'
+    # in context of 'project' with properties 'ps'.
+    # Returns non-empty value if build is OK.
+
+    result = []
+
+    existing = __builds_cache.get((what, ps), None)
+    if existing is None:
+
+        result = False
+        __builds_cache[(what, ps)] = False
+
+        targets = b2.build.targets.generate_from_reference(
+            metatarget_reference, project, ps).targets()
+        jam_targets = []
+        for t in targets:
+            jam_targets.append(t.actualize())
+        
+        x = ("    - %s" % what).rjust(__width)
+        if bjam.call("UPDATE_NOW", jam_targets, str(__log_fd), "ignore-minus-n"):
+            __builds_cache[(what, ps)] = True
+            result = True
+            log_check_result("%s: yes" % x)
+        else:
+            log_check_result("%s: no" % x)
+
+        return result
+    else:
+        return existing
+
+def set_log_file(log_file_name):
+    # Called by Boost.Build startup code to specify name of a file
+    # that will receive results of configure checks.  This
+    # should never be called by users.
+    global __log_file, __log_fd
+    dirname = os.path.dirname(log_file_name)
+    if not os.path.exists(dirname):
+        os.makedirs(dirname)
+    # Make sure to keep the file around, so that it's not
+    # garbage-collected and closed
+    __log_file = open(log_file_name, "w")
+    __log_fd = __log_file.fileno()
+
+# Frontend rules
+
+class CheckTargetBuildsWorker:
+
+    def __init__(self, target, true_properties, false_properties):
+        self.target = target
+        self.true_properties = property.create_from_strings(true_properties, True)
+        self.false_properties = property.create_from_strings(false_properties, True)
+
+    def check(self, ps):
+        
+        # FIXME: this should not be hardcoded. Other checks might
+        # want to consider different set of features as relevant.
+        toolset = ps.get('toolset')[0]
+        toolset_version_property = "<toolset-" + toolset + ":version>" ;
+        relevant = ps.get_properties('target-os') + \
+                   ps.get_properties("toolset") + \
+                   ps.get_properties(toolset_version_property) + \
+                   ps.get_properties("address-model") + \
+                   ps.get_properties("architecture")
+        rps = property_set.create(relevant)
+        t = get_manager().targets().current()
+        p = t.project()        
+        if builds(self.target, p, rps, "%s builds" % self.target):
+            choosen = self.true_properties
+        else:
+            choosen = self.false_properties
+        return property.evaluate_conditionals_in_context(choosen, ps)
+
+@bjam_signature((["target"], ["true_properties", "*"], ["false_properties", "*"]))
+def check_target_builds(target, true_properties, false_properties):
+    worker = CheckTargetBuildsWorker(target, true_properties, false_properties)
+    value = value_to_jam(worker.check)
+    return "<conditional>" + value
+
+get_manager().projects().add_rule("check-target-builds", check_target_builds)
+
+

Added: branches/release/tools/build/v2/doc/bjam.qbk
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/doc/bjam.qbk	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,1696 @@
+[article Boost.Jam
+    [quickbook 1.3]
+    [version: 3.1.19]
+    [authors [Rivera, Rene], [Abrahams, David], [Prus, Vladimir]]
+    [copyright 2003 2004 2005 2006 2007 Rene Rivera, David Abrahams, Vladimir Prus]
+    [category tool-build]
+    [id jam]
+    [dirname jam]
+    [purpose
+        Jam is a make(1) replacement that makes building simple things simple 
+        and building complicated things manageable.
+    ]
+    [license
+        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])
+    ]
+]
+
+[/ QuickBook Document version 1.3 ]
+
+[/ Shortcuts ]
+
+[def :version: 3.1.19]
+
+[/ Images ]
+
+[def :NOTE:                 [$images/note.png]]
+[def :ALERT:                [$images/caution.png]]
+[def :DETAIL:               [$images/note.png]]
+[def :TIP:                  [$images/tip.png]]
+
+[/ Links ]
+
+[def :Boost:                [@http://www.boost.org Boost]]
+[def :Perforce_Jam:         [@http://www.perforce.com/jam/jam.html Perforce Jam]]
+
+[/ Templates ]
+
+[template literal[text]'''<literallayout><literal>'''[text]'''</literal></literallayout>''']
+[template list[items]'''<itemizedlist>'''[items]'''</itemizedlist>''']
+[template orderedlist[items]'''<orderedlist>'''[items]'''</orderedlist>''']
+[template li[text]'''<listitem>'''[text]'''</listitem>''']
+[template lines[items]'''<simplelist type='vert' columns='1'>'''[items]'''</simplelist>''']
+[template line[text]'''<member>'''[text]'''</member>''']
+
+[section:building Building BJam]
+
+Installing =BJam= after building it is simply a matter of copying the
+generated executables someplace in your =PATH=. For building the executables
+there are a set of =build= bootstrap scripts to accomodate particular
+environments. The scripts take one optional argument, the name of the toolset
+to build with. When the toolset is not given an attempt is made to detect an
+available toolset and use that. The build scripts accept these arguments:
+
+[pre
+/build/ \[/toolset/\]
+]
+
+Running the scripts without arguments will give you the best chance of success. On Windows platforms from a command console do:
+
+[pre
+cd /jam source location/
+.\\build.bat
+]
+
+On Unix type platforms do:
+
+[pre
+cd /jam source location/
+sh ./build.sh
+]
+
+For the Boost.Jam source included with the Boost distribution the /jam source location/ is =BOOST_ROOT/tools/jam/src=.
+
+If the scripts fail to detect an appropriate toolset to build with your particular toolset may not be auto-detectable. In that case, you can specify the toolset as the first argument, this assumes that the toolset is readily available in the =PATH=.
+
+[note
+The toolset used to build Boost.Jam is independent of the toolsets used for Boost.Build. Only one version of Boost.Jam is needed to use Boost.Build.
+]
+
+The supported toolsets, and whether they are auto-detected, are:
+
+[table Supported Toolsets
+
+[[Script] [Platform] [Toolset] [Detection and Notes]]
+
+[   [=build.bat=] [Windows NT, 2000, and XP]
+    [[lines
+        [line [@http://www.codegear.com/downloads/free/cppbuilder =borland=]]
+        [line [@http://www.borland.com/ Borland] C++Builder (BCC 5.5)]
+        ]]
+    [[list
+        [li Common install location: "=C:\Borland\BCC55="]
+        [li =BCC32.EXE= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.comeaucomputing.com/ =como=]]
+        [line Comeau Computing C/C++]
+        ]]
+    []
+]
+
+[   [] []
+    [[lines
+        [line [@http://gcc.gnu.org/ =gcc=]]
+        [line GNU GCC]
+        ]]
+    []
+]
+
+[   [] []
+    [[lines
+        [line [@http://gcc.gnu.org/ =gcc-nocygwin=]]
+        [line GNU GCC]
+        ]]
+    []
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.intel.com/software/products/compilers/c60 =intel-win32=]]
+        [line Intel C++ Compiler for Windows]
+        ]]
+    [[list
+        [li =ICL.EXE= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.metrowerks.com/ =metrowerks=]]
+        [line MetroWerks CodeWarrior C/C++ 7.x, 8.x, 9.x]
+        ]]
+    [[list
+        [li =CWFolder= variable configured]
+        [li =MWCC.EXE= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.mingw.org/ =mingw=]]
+        [line GNU [@http://gcc.gnu.org/ GCC] as the [@http://www.mingw.org/ MinGW] configuration]
+        ]]
+    [[list
+        [li Common install location: "=C:\MinGW="]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://msdn.microsoft.com/visualc/ =msvc=]]
+        [line Microsoft Visual C++ 6.x]
+        ]]
+    [[list
+        [li =VCVARS32.BAT= already configured]
+        [li =%MSVCDir%= is present in environment]
+        [li Common install locations: "=%ProgramFiles%\Microsoft Visual Studio=", "=%ProgramFiles%\Microsoft Visual C++="]
+        [li =CL.EXE= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://msdn.microsoft.com/visualc/ =vc7=]]
+        [line Microsoft Visual C++ 7.x]
+        ]]
+    [[list
+        [li =VCVARS32.BAT= or =VSVARS32.BAT= already configured]
+        [li =%VS71COMNTOOLS%= is present in environment]
+        [li =%VCINSTALLDIR%= is present in environment]
+        [li Common install locations: "=%ProgramFiles%\Microsoft Visual Studio .NET=", "=%ProgramFiles%\Microsoft Visual Studio .NET 2003="]
+        [li =CL.EXE= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://msdn.microsoft.com/visualc/ =vc8= and =vc9=]]
+        [line Microsoft Visual C++ 8.x and 9.x]
+        ]]
+    [Detection:
+        [list
+            [li =VCVARSALL.BAT= already configured]
+            [li =%VS90COMNTOOLS%= is present in environment]
+            [li Common install location: "=%ProgramFiles%\Microsoft Visual Studio 9="]
+            [li =%VS80COMNTOOLS%= is present in environment]
+            [li Common install location: "=%ProgramFiles%\Microsoft Visual Studio 8="]
+            [li =CL.EXE= in =PATH=]
+            ]
+    
+    Notes:
+        [list
+            [li If =VCVARSALL.BAT= is called to set up the toolset, it is passed all the extra arguments, see below for what those arguments are. This can be used to build, for example, a Win64 specific version of =bjam=. Consult the VisualStudio documentation for what the possible argument values to the =VCVARSALL.BAT= are.]
+            ]
+        ]
+]
+
+[   [=build.sh=] [Unix, Linux, Cygwin, etc.]
+    [[lines
+        [line [@http://www.hp.com/go/c++ =acc=]]
+        [line HP-UX aCC]
+        ]]
+    [[list
+        [li =aCC= in =PATH=]
+        [li =uname= is "HP-UX"]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.comeaucomputing.com/ =como=]]
+        [line Comeau Computing C/C++]
+        ]]
+    [[list
+        [li como in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://gcc.gnu.org/ =gcc=]]
+        [line GNU GCC]
+        ]]
+    [[list
+        [li gcc in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.intel.com/software/products/compilers/c60l/ =intel-linux=]]
+        [line Intel C++ for Linux]
+        ]]
+    [[list
+        [li =icc= in =PATH=]
+        [li Common install locations: "=/opt/intel/cc/9.0=", "=/opt/intel_cc_80=", "=/opt/intel/compiler70=", "=/opt/intel/compiler60=", "=/opt/intel/compiler50="]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line =kcc=]
+        [line Intel KAI C++]
+        ]]
+    [[list
+        [li =KCC= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.codegear.com/downloads/free/cppbuilder =kylix=]]
+        [line [@http://www.borland.com/ Borland] C++Builder]
+        ]]
+    [[list
+        [li bc++ in PATH]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.sgi.com/developers/devtools/languages/mipspro.html =mipspro=]]
+        [line SGI MIPSpro C]
+        ]]
+    [[list
+        [li =uname= is "=IRIX=" or "=IRIX64="]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line =sunpro=]
+        [line Sun Workshop 6 C++]
+        ]]
+    [[list
+        [li Standard install location: "=/opt/SUNWspro="]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line =qcc=]
+        [line [@http://www.qnx.com/ QNX Neutrino]]
+        ]]
+    [[list
+        [li =uname= is "=QNX=" and =qcc= in =PATH=]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.tru64unix.compaq.com/cplus/ =true64cxx=]]
+        [line Compaq C++ Compiler for True64 UNIX]
+        ]]
+    [[list
+        [li =uname= is "=OSF1="]
+        ]]
+]
+
+[   [] []
+    [[lines
+        [line [@http://www.ibm.com/software/awdtools/vacpp/ =vacpp=]]
+        [line IBM VisualAge C++]
+        ]]
+    [[list
+        [li =xlc= in =PATH=]
+        ]]
+]
+
+[   [] [MacOS X]
+    [[lines
+        [line [@http://developer.apple.com/tools/compilers.html =darwin=]]
+        [line Apple MacOS X GCC]
+        ]]
+    [[list
+        [li =uname= is "=Darwin="]
+        ]]
+]
+
+[   [] [Windows NT, 2000, and XP]
+    [[lines
+        [line [@http://www.mingw.org/ =mingw=]]
+        [line GNU [@http://gcc.gnu.org/ GCC] as the [@http://www.mingw.org/ MinGW] configuration with the MSYS shell]
+        ]]
+    [[list
+        [li Common install location: "=/mingw="]
+        ]]
+]
+
+]
+
+The built executables are placed in a subdirectory specific to your platform. For example, in Linux running on an Intel x86 compatible chip, the executables are placed in: "=bin.linuxx86=". The =bjam[.exe]= executable can be used to invoke Boost.Build.
+
+The build scripts support additional invocation arguments for use by developers of Boost.Jam and for additional setup of the toolset. The extra arguments come after the toolset:
+
+* Arguments not in the form of an option, before option arguments, are used for extra setup to toolset configuration scripts.
+* Arguments of the form "=--option=", which are passed to the =build.jam= build script.
+* Arguments not in the form of an option, after the options, which are targets for the =build.jam= script.
+
+[pre
+/build/ \[/toolset/\] \[/setup/\*\] \[--/option/+ /target/\*\]
+]
+
+The arguments immediately after the toolset are passed directly to the setup script of the toolset, if available and if it needs to be invoked. This allows one to configure the toolset ass needed to do non-default builds of =bjam=. For example to build a Win64 version with =vc8=. See the toolset descriptiona above for when particular toolsets support this.
+
+The arguments starting with the "=--option=" forms are passed to the =build.jam= script and are used to further customize what gets built. Options and targets supported by the =build.jam= script:
+
+[variablelist
+    [[[literal ---]]
+        [Empty option when one wants to only specify a target.]]
+    [[[literal --release]]
+        [The default, builds the optimized executable.]]
+    [[[literal --debug]]
+        [Builds debugging versions of the executable. When built they are placed in their own directory "=bin./platform/.debug=".]]
+    [[[literal --grammar]]
+        [Normally the Jam language grammar parsing files are not regenerated. This forces building of the grammar, although it may not force the regeneration of the grammar parser. If the parser is out of date it will be regenerated and subsequently built.]]
+    [[[literal --with-python=/path/]]
+        [Enables Python integration, given a path to the Python libraries.]]
+    [[[literal --gc]]
+        [Enables use of the Boehm Garbage Collector. The build will look for the Boehm-GC source in a "boehm_gc" subdirectory from the =bjam= sources.]]
+    [[[literal --duma]]
+        [Enables use of the DUMA (Detect Uintended Memory Access) debugging memory allocator. The build expects to find the DUMA source files in a "duma" subdirectory from the =bjam= sources.]]
+    [[[literal --toolset-root=/path/]]
+        [Indicates where the toolset used to build is located. This option is passed in by the bootstrap (=build.bat= or =build.sh=) script.]]
+    [[[literal --show-locate-target]]
+        [For information, prints out where it will put the built executable.]]
+    [[[literal --noassert]]
+        [Disable debug assertions, even if building the debug version of the executable.]]
+    [[[literal dist]]
+        [Generate packages (compressed archives) as appropriate for distribution in the platform, if possible.]]
+    [[[literal clean]]
+        [Remove all the built executables and objects.]]
+]
+
+[endsect]
+
+[section:language Language]
+
+=BJam= has an interpreted, procedural language. Statements in =bjam= are rule (procedure) definitions, rule invocations, flow-of-control structures, variable assignments, and sundry language support.
+
+[section:lexical Lexical Features]
+
+=BJam= treats its input files as whitespace-separated tokens, with two exceptions: double quotes (") can enclose whitespace to embed it into a token, and everything between the matching curly braces ({}) in the definition of a rule action is treated as a single string. A backslash (\\) can escape a double quote, or any single whitespace character.
+
+=BJam= requires whitespace (blanks, tabs, or newlines) to surround all tokens, including the colon (:) and semicolon (;) tokens.
+
+=BJam= keywords (an mentioned in this document) are reserved and generally
+must be quoted with double quotes (") to be used as arbitrary tokens, such as
+variable or target names. 
+
+Comments start with the [^#] character and extend until the end of line.
+
+[endsect]
+
+[section:target Targets]
+
+The essential =bjam= data entity is a target. Build targets are files to be updated. Source targets are the files used in updating built targets. Built targets and source targets are collectively referred to as file targets, and frequently built targets are source targets for other built targets. Pseudotargets are symbols which represent dependencies on other targets, but which are not themselves associated with any real file.
+
+A file target's identifier is generally the file's name, which can be absolutely rooted, relative to the directory of =bjam='s invocation, or simply local (no directory). Most often it is the last case, and the actual file path is bound using the =$(SEARCH)= and =$(LOCATE)= special variables. See [link jam.language.variables.builtins.search SEARCH and LOCATE Variables] below. A local filename is optionally qualified with grist, a string value used to assure uniqueness. A file target with an identifier of the form /file(member)/ is a library member (usually an =ar=(1) archive on Unix).
+
+[section Binding Detection]
+
+Whenever a target is bound to a location in the filesystem, Boost Jam will look for a variable called =BINDRULE= (first "on" the target being bound, then in the global module). If non-empty, =$(BINDRULE[1])= names a rule which is called with the name of the target and the path it is being bound to. The signature of the rule named by =$(BINDRULE[1])= should match the following:
+
+[pre
+rule /bind-rule/ ( /target/ : /path/ )
+]
+
+This facility is useful for correct header file scanning, since many compilers will search for `#include` files first in the directory containing the file doing the `#include` directive. =$(BINDRULE)= can be used to make a record of that directory.
+
+[endsect]
+
+[endsect]
+
+[section:rules Rules]
+
+The basic =bjam= language entity is called a rule. A rule is defined in two parts: the procedure and the actions. The procedure is a body of jam statements to be run when the rule is invoked; the actions are the OS shell commands to execute when updating the built targets of the rule.
+
+Rules can return values, which can be expanded into a list with "[ /rule/ /args/ ... ]". A rule's value is the value of its last statement, though only the following statements have values: 'if' (value of the leg chosen), 'switch' (value of the case chosen), set (value of the resulting variable), and 'return' (value of its arguments). Note that 'return' doesn't actually cause a return, i.e., is a no-op unless it is the last statement of the last block executed within rule body.
+
+The =bjam= statements for defining and invoking rules are as follows:
+
+Define a rule's procedure, replacing any previous definition.
+
+[pre
+rule /rulename/ { /statements/ }
+]
+
+Define a rule's updating actions, replacing any previous definition.
+
+[pre
+actions \[ /modifiers/ \] /rulename/ { /commands/ }
+]
+
+Invoke a rule.
+
+[pre
+/rulename/ /field1/ : /field2/ : /.../ : /fieldN/ ;
+]
+
+Invoke a rule under the influence of target's specific variables..
+
+[pre
+on /target/ /rulename/ /field1/ : /field2/ : /.../ : /fieldN/ ;
+]
+
+Used as an argument, expands to the return value of the rule invoked.
+
+[pre
+\[ /rulename/ /field1/ : /field2/ : /.../ : /fieldN/ \]
+\[ on /target/ /rulename/ /field1/ : /field2/ : /.../ : /fieldN/ \]
+]
+
+A rule is invoked with values in /field1/ through /fieldN/. They may be referenced in the procedure's statements as [^$(1)] through [^$(['N])] (9 max), and the first two only may be referenced in the action's /commands/ as [^$(1)] and [^$(2)]. [^$(<)] and [^$(>)] are synonymous with [^$(1)] and [^$(2)].
+
+Rules fall into two categories: updating rules (with actions), and pure procedure rules (without actions). Updating rules treat arguments [^$(1)] and [^$(2)] as built targets and sources, respectively, while pure procedure rules can take arbitrary arguments.
+
+When an updating rule is invoked, its updating actions are added to those associated with its built targets ([^$(1)]) before the rule's procedure is run. Later, to build the targets in the updating phase, /commands/ are passed to the OS command shell, with [^$(1)] and [^$(2)] replaced by bound versions of the target names. See Binding above.
+
+Rule invocation may be indirected through a variable:
+
+[pre
+$(/var/) /field1/ : /field2/ : /.../ : /fieldN/ ;
+
+on /target/ $(/var/) /field1/ : /field2/ : /.../ : /fieldN/ ;
+
+\[ $(/var/) /field1/ : /field2/ : /.../ : /fieldN/ \]
+\[ on /target/ $(/var/) /field1/ : /field2/ : /.../ : /fieldN/ \]
+]
+
+The variable's value names the rule (or rules) to be invoked. A rule is
+invoked for each element in the list of [^$(/var/)]'s values. The fields
+[^/field1/ : /field2/ : /.../] are passed as arguments for each
+invokation. For the [ ... ] forms, the return value is the concatenation of
+the return values for all of the invocations.
+
+[section Action Modifiers]
+
+The following action modifiers are understood:
+
+[variablelist
+
+[[[^actions bind /vars/]]
+ [[^$(/vars/)] will be replaced with bound values.]]
+
+[[[^actions existing]]
+ [[^$(>)] includes only source targets currently existing.]]
+
+[[[^actions ignore]]
+ [The return status of the commands is ignored.]]
+
+[[[^actions piecemeal]]
+ [commands are repeatedly invoked with a subset of [^$(>)] small enough to fit in the command buffer on this OS.]]
+
+[[[^actions quietly]]
+ [The action is not echoed to the standard output.]]
+
+[[[^actions together]]
+ [The [^$(>)] from multiple invocations of the same action on the same built target are glommed together.]]
+
+[[[^actions updated]]
+ [[^$(>)] includes only source targets themselves marked for updating.]]
+
+]
+
+[endsect]
+
+[section Argument lists]
+
+You can describe the arguments accepted by a rule, and refer to them by name within the rule. For example, the following prints "I'm sorry, Dave" to the console:
+
+[pre
+rule report ( pronoun index ? : state : names + )
+{
+    local he.suffix she.suffix it.suffix = s ;
+    local I.suffix = m ;
+    local they.suffix you.suffix = re ;
+    ECHO $(pronoun)'$($(pronoun).suffix) $(state), $(names\[$(index)\]) ;
+}
+report I 2 : sorry : Joe Dave Pete ;
+]
+
+Each name in a list of formal arguments (separated by "=:=" in the rule declaration) is bound to a single element of the corresponding actual argument unless followed by one of these modifiers:
+
+[table
+[[Symbol] [Semantics of preceding symbol]]
+[[=?=] [optional]]
+[[=*=] [Bind to zero or more unbound elements of the actual argument. When =*= appears where an argument name is expected, any number of additional arguments are accepted. This feature can be used to implement "varargs" rules.]]
+[[=+=] [Bind to one or more unbound elements of the actual argument.]]
+]
+
+The actual and formal arguments are checked for inconsistencies, which cause Jam to exit with an error code:
+
+[pre
+### argument error
+# rule report ( pronoun index ?  : state  : names + )
+# called with: ( I 2 foo  : sorry  : Joe Dave Pete )
+# extra argument foo
+### argument error
+# rule report ( pronoun index ?  : state  : names + )
+# called with: ( I 2  : sorry )
+# missing argument names
+]
+
+If you omit the list of formal arguments, all checking is bypassed as in "classic" Jam. Argument lists drastically improve the reliability and readability of your rules, however, and are *strongly recommended* for any new Jam code you write.
+
+[endsect]
+
+[section:builtins Built-in Rules]
+
+=BJam= has a growing set of built-in rules, all of which are pure procedure rules without updating actions. They are in three groups: the first builds the dependency graph; the second modifies it; and the third are just utility rules.
+
+[section Dependency Building]
+
+[section =DEPENDS= ]
+
+[pre
+rule DEPENDS ( /targets1/ * : /targets2/ * )
+]
+
+Builds a direct dependency: makes each of /targets1/ depend on each of /targets2/. Generally, /targets1/ will be rebuilt if /targets2/ are themselves rebuilt or are newer than /targets1/.
+
+[endsect]
+
+[section =INCLUDES= ]
+
+[pre
+rule INCLUDES ( /targets1/ * : /targets2/ * )
+]
+
+Builds a sibling dependency: makes any target that depends on any of /targets1/ also depend on each of /targets2/. This reflects the dependencies that arise when one source file includes another: the object built from the source file depends both on the original and included source file, but the two sources files don't depend on each other. For example:
+
+[pre
+DEPENDS foo.o : foo.c ;
+INCLUDES foo.c : foo.h ;
+]
+
+"=foo.o=" depends on "=foo.c=" and "=foo.h=" in this example.
+
+[endsect]
+
+[endsect]
+
+[section Modifying Binding]
+
+The six rules =ALWAYS=, =LEAVES=, =NOCARE=, =NOTFILE=, =NOUPDATE=, and =TEMPORARY= modify the dependency graph so that =bjam= treats the targets differently during its target binding phase. See Binding above. Normally, =bjam= updates a target if it is missing, if its filesystem modification time is older than any of its dependencies (recursively), or if any of its dependencies are being updated. This basic behavior can be changed by invoking the following rules:
+
+[section =ALWAYS= ]
+
+[pre
+rule ALWAYS ( /targets/ * )
+]
+
+Causes /targets/ to be rebuilt regardless of whether they are up-to-date (they must still be in the dependency graph). This is used for the clean and uninstall targets, as they have no dependencies and would otherwise appear never to need building. It is best applied to targets that are also =NOTFILE= targets, but it can also be used to force a real file to be updated as well.
+
+[endsect]
+
+[section =LEAVES= ]
+
+[pre
+rule LEAVES ( /targets/ * )
+]
+
+Makes each of /targets/ depend only on its leaf sources, and not on any intermediate targets. This makes it immune to its dependencies being updated, as the "leaf" dependencies are those without their own dependencies and without updating actions. This allows a target to be updated only if original source files change.
+
+[endsect]
+
+[section =NOCARE= ]
+
+[pre
+rule NOCARE ( /targets/ * )
+]
+
+Causes =bjam= to ignore /targets/ that neither can be found nor have updating actions to build them. Normally for such targets =bjam= issues a warning and then skips other targets that depend on these missing targets. The =HdrRule= in =Jambase= uses =NOCARE= on the header file names found during header file scanning, to let =bjam= know that the included files may not exist. For example, if an `#include` is within an `#ifdef`, the included file may not actually be around.
+
+[warning For targets with build actions: if their build actions exit with a nonzero return code, dependent targets will still be built.]
+
+[endsect]
+
+[section =NOTFILE= ]
+
+[pre
+rule NOTFILE ( /targets/ * )
+]
+
+Marks /targets/ as pseudotargets and not real files. No timestamp is checked, and so the actions on such a target are only executed if the target's dependencies are updated, or if the target is also marked with =ALWAYS=. The default =bjam= target "=all=" is a pseudotarget. In =Jambase=, =NOTFILE= is used to define several addition convenient pseudotargets.
+
+[endsect]
+
+[section =NOUPDATE= ]
+
+[pre
+rule NOUPDATE ( /targets/ * )
+]
+
+Causes the timestamps on /targets/ to be ignored. This has two effects: first, once the target has been created it will never be updated; second, manually updating target will not cause other targets to be updated. In =Jambase=, for example, this rule is applied to directories by the =MkDir= rule, because =MkDir= only cares that the target directory exists, not when it has last been updated.
+
+[endsect]
+
+[section =TEMPORARY= ]
+
+[pre
+rule TEMPORARY ( /targets/ * )
+]
+
+Marks /targets/ as temporary, allowing them to be removed after other targets that depend upon them have been updated. If a =TEMPORARY= target is missing, =bjam= uses the timestamp of the target's parent. =Jambase= uses =TEMPORARY= to mark object files that are archived in a library after they are built, so that they can be deleted after they are archived.
+
+[endsect]
+
+[section =FAIL_EXPECTED= ]
+
+[pre
+rule FAIL_EXPECTED ( /targets/ * )
+]
+
+For handling targets whose build actions are expected to fail (e.g. when testing
+that assertions or compile-time type checking work properly), Boost Jam supplies
+the =FAIL_EXPECTED= rule in the same style as =NOCARE=, et. al. During target
+updating, the return code of the build actions for arguments to =FAIL_EXPECTED=
+is inverted: if it fails, building of dependent targets continues as though it
+succeeded. If it succeeds, dependent targets are skipped.
+
+[endsect]
+
+[section =RMOLD= ]
+
+[pre
+rule RMOLD ( /targets/ * )
+]
+
+=BJam= removes any target files that may exist on disk when the rule used to build those targets fails. However, targets whose dependencies fail to build are not removed by default. The =RMOLD= rule causes its arguments to be removed if any of their dependencies fail to build.
+
+[endsect]
+
+[section =ISFILE= ]
+
+[pre
+rule ISFILE ( /targets/ * )
+]
+
+=ISFILE= marks targets as required to be files. This changes the way =bjam= searches for the target such that it ignores mathes for file system items that are not file, like directories. This makes it possible to avoid `#include "exception"` matching if one happens to have a directory named exception in the header search path.
+
+[warning This is currently not fully implemented.]
+
+[endsect]
+
+[endsect]
+
+[section Utility]
+
+The two rules =ECHO= and =EXIT= are utility rules, used only in =bjam='s parsing phase.
+
+[section =ECHO= ]
+
+[pre
+rule ECHO ( /args/ * )
+]
+
+Blurts out the message /args/ to stdout.
+
+[endsect]
+
+[section =EXIT= ]
+
+[pre
+rule EXIT ( /message/ * : /result-value/ ? )
+]
+
+Blurts out the /message/ to stdout and then exits with a failure status if no /result-value/ is given, otherwise it exits with the given /result-value/.
+
+"=Echo=", "=echo=", "=Exit=", and "=exit=" are accepted as aliases for =ECHO= and =EXIT=, since it is hard to tell that these are built-in rules and not part of the language, like "=include=". 
+
+[endsect]
+
+[section =GLOB= ]
+
+The =GLOB= rule does filename globbing.
+
+[pre
+rule GLOB ( /directories/ * : /patterns/ * : /downcase-opt/ ? )
+]
+
+Using the same wildcards as for the patterns in the switch statement. It is invoked by being used as an argument to a rule invocation inside of "=[ ]=". For example: "[^FILES = \[ GLOB dir1 dir2 : *.c *.h \]]" sets =FILES= to the list of C source and header files in =dir1= and =dir2=. The resulting filenames are the full pathnames, including the directory, but the pattern is applied only to the file name without the directory.
+
+If /downcase-opt/ is supplied, filenames are converted to all-lowercase before matching against the pattern; you can use this to do case-insensitive matching using lowercase patterns. The paths returned will still have mixed case if the OS supplies them. On Windows NT and Cygwin, filenames are always downcased before matching. 
+
+[endsect]
+
+[section =MATCH= ]
+
+The =MATCH= rule does pattern matching.
+
+[pre
+rule MATCH ( /regexps/ + : /list/ * )
+]
+
+Matches the =egrep=(1) style regular expressions /regexps/ against the strings in /list/. The result is the concatenation of matching =()= subexpressions for each string in /list/, and for each regular expression in /regexps/. Only useful within the "=[ ]=" construct, to change the result into a list.
+
+[endsect]
+
+[section =BACKTRACE= ]
+
+[pre
+rule BACKTRACE ( )
+]
+
+Returns a list of quadruples: /filename/ /line/ /module/ /rulename/..., describing each shallower level of the call stack. This rule can be used to generate useful diagnostic messages from Jam rules.
+
+[endsect]
+
+[section =UPDATE= ]
+
+[pre
+rule UPDATE ( /targets/ * )
+]
+
+Classic jam treats any non-option element of command line as a name of target to be updated. This prevented more sophisticated handling of command line. This is now enabled again but with additional changes to the =UPDATE= rule to allow for the flexibility of changing the list of targets to update. The UPDATE rule has two effects:
+
+# It clears the list of targets to update, and
+# Causes the specified targets to be updated.
+
+If no target was specified with the =UPDATE= rule, no targets will be updated. To support changing of the update list in more useful ways, the rule also returns the targets previously in the update list. This makes it possible to add targets as such:
+
+[pre
+local previous-updates = \[ UPDATE \] ;
+UPDATE $(previous-updates) a-new-target ;
+]
+
+[endsect]
+
+[section =W32_GETREG= ]
+
+[pre
+rule W32_GETREG ( /path/ : /data/ ? )
+]
+
+Defined only for win32 platform. It reads the registry of Windows. '/path/' is the location of the information, and '/data/' is the name of the value which we want to get. If '/data/' is omitted, the default value of '/path/' will be returned. The '/path/' value must conform to MS key path format and must be prefixed with one of the predefined root keys. As usual,
+
+* '=HKLM=' is equivalent to '=HKEY_LOCAL_MACHINE='.
+* '=HKCU=' is equivalent to '=HKEY_CURRENT_USER='.
+* '=HKCR=' is equivalent to '=HKEY_CLASSES_ROOT='.
+
+Other predefined root keys are not supported.
+
+Currently supported data types : '=REG_DWORD=', '=REG_SZ=', '=REG_EXPAND_SZ=', '=REG_MULTI_SZ='. The data with '=REG_DWORD=' type will be turned into a string, '=REG_MULTI_SZ=' into a list of strings, and for those with '=REG_EXPAND_SZ=' type environment variables in it will be replaced with their defined values. The data with '=REG_SZ=' type and other unsupported types will be put into a string without modification. If it can't receive the value of the data, it just return an empty list. For example,
+
+[pre
+local PSDK-location =
+  \[ W32_GETREG HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\MicrosoftSDK\\\\Directories : "Install Dir" \] ;
+]
+
+[endsect]
+
+[section =W32_GETREGNAMES= ]
+
+[pre
+rule W32_GETREGNAMES ( /path/ : /result-type/ )
+]
+
+Defined only for win32 platform. It reads the registry of Windows. '/path/' is the location of the information, and '/result-type/' is either '=subkeys=' or '=values='. For more information on '/path/' format and constraints, please see =W32_GETREG=.
+
+Depending on '/result-type/', the rule returns one of the following:
+
+[variablelist
+    [[=subkeys=] [Names of all direct subkeys of '/path/'.]]
+    [[=values=] [Names of values contained in registry key given by '/path/'. The "default" value of the key appears in the returned list only if its value has been set in the registry.]]
+]
+
+If '/result-type/' is not recognized, or requested data cannot be retrieved, the rule returns an empty list.
+Example:
+
+[pre 
+local key = "HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\App Paths" ;
+local subkeys = \[ W32_GETREGNAMES "$(key)" : subkeys \] ;
+for local subkey in $(subkeys)
+{
+    local values = \[ W32_GETREGNAMES "$(key)\\\\$(subkey)" : values \] ;
+    for local value in $(values)
+    {
+        local data = \[ W32_GETREG "$(key)\\\\$(subkey)" : "$(value)" \] ;
+        ECHO "Registry path: " $(key)\\\\$(subkey) ":" $(value) "=" $(data) ;
+    }
+}
+]
+
+[endsect]
+
+[section =SHELL= ]
+
+[pre
+rule SHELL ( /command/ : * )
+]
+
+=SHELL= executes /command/, and then returns the standard output of /command/. =SHELL= only works on platforms with a =popen()= function in the C library. On platforms without a working =popen()= function, =SHELL= is implemented as a no-op. =SHELL= works on Unix, MacOS X, and most Windows compilers. =SHELL= is a no-op on Metrowerks compilers under Windows. There is a variable set of allowed options as additional arguments:
+
+[variablelist
+    [[=exit-status=] [In addition to the output the result status of the executed command is returned as a second element of the result.]]
+    [[=no-output=] [Don't capture the output of the command. Instead an empty ("") string value is returned in place of the output.]]
+]
+
+Because the Perforce/Jambase defines a =SHELL= rule which hides the
+builtin rule, =COMMAND= can be used as an alias for =SHELL= in such a case.
+
+[endsect]
+
+[section =MD5= ]
+
+[pre
+rule MD5 ( /string/ )
+]
+
+=MD5= computes the MD5 hash of the string passed as paramater and returns it.
+
+[endsect]
+
+[section =SPLIT_BY_CHARACTERS= ]
+
+[pre
+rule SPLIT_BY_CHARACTERS ( /string/ : /delimiters/ )
+]
+
+=SPLIT_BY_CHARACTERS= splits the specified /string/ on any delimiter character
+present in /delimiters/ and returns the resulting list.
+
+[endsect]
+
+[section =PRECIOUS= ]
+
+[pre
+rule PRECIOUS ( /targets/ * )
+]
+
+The =PRECIOUS= rule specifies that each of the targets passed as the arguments
+should not be removed even if the command updating that target fails.
+
+[endsect]
+
+[section =PAD= ]
+
+[pre
+rule PAD ( /string/ : /width/ )
+]
+
+If /string/ is shorter than /width/ characters, pads it with whitespace
+characters on the right, and returns the result.  Otherwise, returns
+/string/ unmodified.
+
+[endsect]
+
+[section =FILE_OPEN= ]
+
+[pre
+rule FILE_OPEN ( /filename/ : /mode/ )
+]
+
+The =FILE_OPEN= rule opens the specified file and returns a file
+descriptor. The /mode/ parameter can be either "w" or "r". Note
+that at present, only the =UPDATE_NOW= rule can use the resulting
+file descriptor number.
+
+[endsect]
+
+[section =UPDATE_NOW= ]
+
+[pre
+rule UPDATE_NOW ( /targets/ * : /log/ ? : /ignore-minus-n/ ? )
+]
+
+The =UPDATE_NOW= caused the specified targets to be updated immediately.
+If update was successfull, non-empty string is returned. The /log/ parameter,
+if present, specifies a descriptor of a file where all output from building
+is redirected. If the /ignore-minus-n/ parameter is specified, the targets
+are updated even if the =-n= parameter is specified on the command line.
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Flow-of-Control]
+
+=BJam= has several simple flow-of-control statements:
+
+[pre
+for /var/ in /list/ { /statements/ }
+]
+
+Executes /statements/ for each element in /list/, setting the variable /var/ to the element value.
+
+[pre
+if /cond/ { /statements/ }
+\[ else { /statements/ } \]
+]
+
+Does the obvious; the =else= clause is optional. /cond/ is built of:
+
+[variablelist
+
+[[[^['a]]]
+ [true if any ['a] element is a non-zero-length string]]
+
+[[[^['a] = ['b]]]
+ [list ['a] matches list ['b] string-for-string]]
+
+[[[^['a] != ['b]]]
+ [list ['a] does not match list ['b]]]
+
+[[[^['a] < ['b]]]
+ [['a\[i\]] string is less than ['b\[i\]] string, where ['i] is first mismatched element in lists ['a] and ['b]]]
+
+[[[^['a] <= ['b]]]
+ [every ['a] string is less than or equal to its ['b] counterpart]]
+
+[[[^['a] > ['b]]]
+ [['a\[i\]] string is greater than ['b\[i\]] string, where ['i] is first mismatched element]]
+
+[[[^['a] >= ['b]]]
+ [every ['a] string is greater than or equal to its ['b] counterpart]]
+
+[[[^['a] in ['b]]]
+ [true if all elements of ['a] can be found in ['b], or if ['a] has no elements]]
+
+[[[^! ['cond]]]
+ [condition not true]]
+
+[[[^['cond] && ['cond]]]
+ [conjunction]]
+
+[[[^['cond] || ['cond]]]
+ [disjunction]]
+
+[[[^( ['cond] )]]
+ [precedence grouping]]
+
+]
+
+[pre
+include /file/ ;
+]
+
+Causes =bjam= to read the named /file/. The /file/ is bound like a regular target (see Binding above) but unlike a regular target the include /file/ cannot be built.
+
+The include /file/ is inserted into the input stream during the parsing phase. The primary input file and all the included file(s) are treated as a single file; that is, jam infers no scope boundaries from included files.
+
+[pre
+local /vars/ \[ = /values/ \] ;
+]
+
+Creates new /vars/ inside to the enclosing ={}= block, obscuring any previous values they might have. The previous values for vars are restored when the current block ends. Any rule called or file included will see the local and not the previous value (this is sometimes called Dynamic Scoping). The local statement may appear anywhere, even outside of a block (in which case the previous value is restored when the input ends). The /vars/ are initialized to /values/ if present, or left uninitialized otherwise.
+
+[pre
+return /values/ ;
+]
+
+Within a rule body, the return statement sets the return value for an invocation of the rule. It does *not* cause the rule to return; a rule's value is actually the value of the last statement executed, so a return should be the last statement executed before the rule "naturally" returns.
+
+[pre
+switch /value/
+{
+    case /pattern1/ : /statements/ ;
+    case /pattern2/ : /statements/ ;
+    ...
+}
+]
+
+The switch statement executes zero or one of the enclosed /statements/, depending on which, if any, is the first case whose /pattern/ matches /value/. The /pattern/ values are not variable-expanded. The pattern values may include the following wildcards:
+
+[variablelist
+
+[[[^?]]
+ [match any single character]]
+
+[[[^*]]
+ [match zero or more characters]]
+
+[[[^\[/chars/\]]]
+ [match any single character in /chars/]]
+
+[[[^\[\^/chars/\]]]
+ [match any single character not in /chars/]]
+
+[[[^\\/x/]]
+ [match /x/ (escapes the other wildcards)]]
+
+]
+
+[pre
+while /cond/ { /statements/ }
+]
+
+Repeatedly execute /statements/ while /cond/ remains true upon entry. (See the description of /cond/ expression syntax under if, above). 
+
+[endsect]
+
+[section Variables]
+
+=BJam= variables are lists of zero or more elements, with each element being a string value. An undefined variable is indistinguishable from a variable with an empty list, however, a defined variable may have one more elements which are null strings. All variables are referenced as [^$(/variable/)].
+
+Variables are either global or target-specific. In the latter case, the variable takes on the given value only during the updating of the specific target.
+
+A variable is defined with:
+
+[pre
+/variable/ = /elements/ ;
+/variable/ += /elements/ ;
+/variable/ on /targets/ = /elements/ ;
+/variable/ on /targets/ += /elements/ ;
+/variable/ default = /elements/ ;
+/variable/ ?= /elements/ ;
+]
+
+The first two forms set /variable/ globally. The third and forth forms set a target-specific variable. The [^\=] operator replaces any previous elements of /variable/ with /elements/; the [^+=] operation adds /elements/ to /variable/'s list of elements. The final two forms are synonymous: they set /variable/ globally, but only if it was previously unset.
+
+Variables referenced in updating commands will be replaced with their values; target-specific values take precedence over global values. Variables passed as arguments (=$(1)= and =$(2)=) to actions are replaced with their bound values; the "=bind=" modifier can be used on actions to cause other variables to be replaced with bound values. See Action Modifiers above.
+
+=BJam= variables are not re-exported to the environment of the shell that executes the updating actions, but the updating actions can reference =bjam= variables with [^$(/variable/)]. 
+
+[section:expansion Variable Expansion]
+
+During parsing, =bjam= performs variable expansion on each token that is not a keyword or rule name. Such tokens with embedded variable references are replaced with zero or more tokens. Variable references are of the form [^$(/v/)] or [^$(/vm/)], where ['v] is the variable name, and ['m] are optional modifiers.
+
+Variable expansion in a rule's actions is similar to variable expansion in statements, except that the action string is tokenized at whitespace regardless of quoting.
+
+The result of a token after variable expansion is the /product/ of the components of the token, where each component is a literal substring or a list substituting a variable reference. For example:
+
+[pre
+$(X) -> a b c
+t$(X) -> ta tb tc
+$(X)z -> az bz cz
+$(X)-$(X) -> a-a a-b a-c b-a b-b b-c c-a c-b c-c
+]
+
+The variable name and modifiers can themselves contain a variable reference, and this partakes of the product as well:
+
+[pre
+$(X) -> a b c
+$(Y) -> 1 2
+$(Z) -> X Y
+$($(Z)) -> a b c 1 2
+]
+
+Because of this product expansion, if any variable reference in a token is undefined, the result of the expansion is an empty list. If any variable element is a null string, the result propagates the non-null elements:
+
+[pre
+$(X) -> a ""
+$(Y) -> "" 1
+$(Z) ->
+-$(X)$(Y)- -> -a- -a1- -- -1-
+-$(X)$(Z)- ->
+]
+
+A variable element's string value can be parsed into grist and filename-related components. Modifiers to a variable are used to select elements, select components, and replace components. The modifiers are:
+
+[variablelist
+
+[[[^\[['n]\]]] [Select element number ['n] (starting at 1). If the variable
+ contains fewer than ['n] elements, the result is a zero-element list. ['n]
+ can be negative in which case the element number ['n] from the last leftward
+ is returned.]]
+
+[[[^\[['n]-['m]\]]]
+ [Select elements number ['n] through ['m]. ['n] and ['m] can be negative in which case they refer to elements counting from the last leftward.]]
+
+[[[^\[['n]-\]]]
+ [Select elements number ['n] through the last. ['n] can be negative in which case it refers to the element counting from the last leftward.]]
+
+[[[^:B]]
+ [Select filename base.]]
+
+[[[^:S]]
+ [Select (last) filename suffix.]]
+
+[[[^:M]]
+ [Select archive member name.]]
+
+[[[^:D]]
+ [Select directory path.]]
+
+[[[^:P]]
+ [Select parent directory.]]
+
+[[[^:G]]
+ [Select grist.]]
+
+[[[^:U]]
+ [Replace lowercase characters with uppercase.]]
+
+[[[^:L]]
+ [Replace uppercase characters with lowercase.]]
+
+[[[^:T]]
+ [Converts all back-slashes ("\\") to forward slashes ("/"). For example
+`` 
+ x = "C:\\Program Files\\Borland" ; ECHO $(x:T) ;
+``
+prints [^"C:/Program Files/Borland"]
+]]
+
+[[[^:W]]
+ [When invoking Windows-based tools from [@http://www.cygwin.com/ Cygwin] 
+  it can be important to pass them true windows-style paths. The =:W= 
+  modifier, *under Cygwin only*, turns a cygwin path into a Win32 path using
+ the  [@http://www.cygwin.com/cygwin-api/func-cygwin-conv-to-win32-path.html
+ =cygwin_conv_to_win32_path=] function. On other platforms, the string is
+ unchanged. For example
+`` 
+ x = "/cygdrive/c/Program Files/Borland" ; ECHO $(x:W) ;
+``
+prints [^"C:\\Program Files\\Borland"] on Cygwin
+]]
+
+[[[^:['chars]]]
+ [Select the components listed in ['chars].]]
+
+[[[^:G=['grist]]]
+ [Replace grist with ['grist].]]
+
+[[[^:D=['path]]]
+ [Replace directory with ['path].]]
+
+[[[^:B=['base]]]
+ [Replace the base part of file name with ['base].]]
+
+[[[^:S=['suf]]]
+ [Replace the suffix of file name with ['suf].]]
+
+[[[^:M=['mem]]]
+ [Replace the archive member name with ['mem].]]
+
+[[[^:R=['root]]]
+ [Prepend ['root] to the whole file name, if not already rooted.]]
+
+[[[^:E=['value]]]
+ [Assign ['value] to the variable if it is unset.]]
+
+[[[^:J=['joinval]]]
+ [Concatentate list elements into single element, separated by ['joinval]'.]]
+
+]
+
+On VMS, [^$(var:P)] is the parent directory of [^$(var:D)].
+
+[endsect]
+
+[section Local For Loop Variables]
+
+Boost Jam allows you to declare a local for loop control variable right in the loop:
+
+[pre
+x = 1 2 3 ;
+y = 4 5 6 ;
+for *local* y in $(x)
+{
+    ECHO $(y) ; # prints "1", "2", or "3"
+}
+ECHO $(y) ;     # prints "4 5 6"
+]
+
+[endsect]
+
+[section:atfile Generated File Expansion]
+
+During expansion of expressions =bjam= also looks for subexpressions of the form
+=@(filename:E=filecontents)= and replaces the expression with =filename= after
+creating the given file with the contents set to =filecontents=. This is useful
+for creating compiler response files, and other "internal" files. The expansion
+works both during parsing and action execution. Hence it is possible to create
+files during any of the three build phases.
+
+[endsect]
+
+[section:builtins Built-in Variables]
+
+This section discusses variables that have special meaning to =bjam=. All of
+these must be defined or used in the global module -- using those variables
+inside a named module will not have the desired effect.
+See [link jam.language.modules Modules].
+
+[section:search SEARCH and LOCATE]
+
+These two variables control the binding of file target names to locations in
+the file system. Generally, =$(SEARCH)= is used to find existing sources
+while =$(LOCATE)= is used to fix the location for built targets.
+
+Rooted (absolute path) file targets are bound as is. Unrooted file target names are also normally bound as is, and thus relative to the current directory, but the settings of =$(LOCATE)= and =$(SEARCH)= alter this:
+
+* If =$(LOCATE)= is set then the target is bound relative to the first directory in =$(LOCATE)=. Only the first element is used for binding.
+* If =$(SEARCH)= is set then the target is bound to the first directory in =$(SEARCH)= where the target file already exists.
+* If the =$(SEARCH)= search fails, the target is bound relative to the current directory anyhow. 
+
+Both =$(SEARCH)= and =$(LOCATE)= should be set target-specific and not globally. If they were set globally, =bjam= would use the same paths for all file binding, which is not likely to produce sane results. When writing your own rules, especially ones not built upon those in Jambase, you may need to set =$(SEARCH)= or =$(LOCATE)= directly. Almost all of the rules defined in Jambase set =$(SEARCH)= and =$(LOCATE)= to sensible values for sources they are looking for and targets they create, respectively.
+
+[endsect]
+
+[section:hdrscan HDRSCAN and HDRRULE]
+
+These two variables control header file scanning. =$(HDRSCAN)= is an
+=egrep(1)= pattern, with ()'s surrounding the file name, used to find file
+inclusion statements in source files. =Jambase= uses =$(HDRPATTERN)= as the
+pattern for =$(HDRSCAN)=. =$(HDRRULE)= is the name of a rule to invoke with
+the results of the scan: the scanned file is the target, the found files are
+the sources. This is the only place where =bjam= invokes a rule through a
+variable setting.
+
+Both =$(HDRSCAN)= and =$(HDRRULE)= must be set for header file scanning to take place, and they should be set target-specific and not globally. If they were set globally, all files, including executables and libraries, would be scanned for header file include statements.
+
+The scanning for header file inclusions is not exact, but it is at least dynamic, so there is no need to run something like =makedepend(GNU)= to create a static dependency file. The scanning mechanism errs on the side of inclusion (i.e., it is more likely to return filenames that are not actually used by the compiler than to miss include files) because it can't tell if `#include` lines are inside `#ifdefs` or other conditional logic. In =Jambase=, =HdrRule= applies the =NOCARE= rule to each header file found during scanning so that if the file isn't present yet doesn't cause the compilation to fail, =bjam= won't care.
+
+Also, scanning for regular expressions only works where the included file name is literally in the source file. It can't handle languages that allow including files using variable names (as the =Jam= language itself does). 
+
+[endsect]
+
+[section Semaphores]
+
+It is sometimes desirable to disallow parallel execution of some actions. For example:
+
+* Old versions of yacc use files with fixed names. So, running two yacc actions is dangerous.
+* One might want to perform parallel compiling, but not do parallel linking, because linking is i/o bound and only gets slower.
+
+Craig McPeeters has extended Perforce Jam to solve such problems, and that extension was integrated in Boost.Jam.
+
+Any target can be assigned a /semaphore/, by setting a variable called =SEMAPHORE= on that target. The value of the variable is the semaphore name. It must be different from names of any declared target, but is arbitrary otherwise.
+
+The semantic of semaphores is that in a group of targets which have the same semaphore, only one can be updated at the moment, regardless of "=-j=" option.
+
+[endsect]
+
+[section Platform Identifier]
+
+A number of Jam built-in variables can be used to identify runtime platform:
+
+[variablelist
+[[=OS=]                     [OS identifier string]]
+[[=OSPLAT=]                 [Underlying architecture, when applicable]]
+[[=MAC=]                    [true on MAC platform]]
+[[=NT=]                     [true on NT platform]]
+[[=OS2=]                    [true on OS2 platform]]
+[[=UNIX=]                   [true on Unix platforms]]
+[[=VMS=]                    [true on VMS platform]]
+]
+
+[endsect]
+
+[section Jam Version]
+
+[variablelist
+[[=JAMDATE=]                [Time and date at =bjam= start-up as an ISO-8601 UTC value.]]
+[[=JAMUNAME=]               [Ouput of uname(1) command (Unix only)]]
+[[=JAMVERSION=]             [=bjam= version, currently ":version:"]]
+[[=JAM_VERSION=]            [A predefined global variable with two elements indicates the version number of Boost Jam. Boost Jam versions start at "=03=" "=00=". Earlier versions of =Jam= do not automatically define =JAM_VERSION=.]]
+]
+
+[endsect]
+
+[section JAMSHELL]
+
+When =bjam= executes a rule's action block, it forks and execs a shell, passing the action block as an argument to the shell. The invocation of the shell can be controlled by =$(JAMSHELL)=. The default on Unix is, for example:
+
+[pre
+JAMSHELL = /bin/sh -c % ;
+]
+
+The =%= is replaced with the text of the action block.
+
+=BJam= does not directly support building in parallel across multiple hosts, since that is heavily dependent on the local environment. To build in parallel across multiple hosts, you need to write your own shell that provides access to the multiple hosts. You then reset =$(JAMSHELL)= to reference it.
+
+Just as =bjam= expands a =%= to be the text of the rule's action block, it expands a =!= to be the multi-process slot number. The slot number varies between 1 and the number of concurrent jobs permitted by the =-j= flag given on the command line. Armed with this, it is possible to write a multiple host shell. For example:
+
+[pre
+#!/bin/sh
+
+# This sample JAMSHELL uses the SunOS on(1) command to execute a
+# command string with an identical environment on another host.
+
+# Set JAMSHELL = jamshell ! %
+#
+# where jamshell is the name of this shell file.
+#
+# This version handles up to -j6; after that they get executed
+# locally.
+
+case $1 in
+1|4) on winken sh -c "$2";;
+2|5) on blinken sh -c "$2";;
+3|6) on nod sh -c "$2";;
+*) eval "$2";;
+esac
+]
+
+[endsect]
+
+[section:actionrule =__TIMING_RULE__= and =__ACTION_RULE__=]
+
+The =__TIMING_RULE__= and =__ACTION_RULE__= can be set to the name of a rule
+for =bjam= to call *after* an action completes for a target. They both give
+diagnostic information about the action that completed. For =__TIMING_RULE__=
+the rule is called as:
+
+    rule timing-rule ( args * : target : start end user system )
+
+And =__ACTION_RULE__= is called as:
+
+    rule action-rule ( args * : target : command status start end user system : output ? )
+
+The arguments for both are:
+
+[variablelist
+    [[[^args]]
+        [Any values following the rule name in the =__TIMING_RULE__= or =__ACTION_RULE__=
+        are passed along here.]]
+    [[[^target]]
+        [The =bjam= target that was built.]]
+    [[[^command]]
+        [The text of the executed command in the action body.]]
+    [[[^status]]
+        [The integer result of the executed command.]]
+    [[[^start]]
+        [The starting timestamp of the executed command as a ISO-8601 UTC value.]]
+    [[[^end]]
+        [The completion timestamp of the executed command as a ISO-8601 UTC value.]]
+    [[[^user]]
+        [The number of user CPU seconds the executed command spent as a floating
+        point value.]]
+    [[[^system]]
+        [The number of system CPU seconds the executed command spent as a floating
+        point value.]]
+    [[[^output]]
+        [The output of the command as a single string. The content of the output
+        reflects the use of the =-pX= option.]]
+]
+
+[note
+    If both variables are set for a target both are called, first =__TIMING_RULE__=
+    then =__ACTION_RULE__=. ]
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Modules]
+
+Boost Jam introduces support for modules, which provide some rudimentary namespace protection for rules and variables. A new keyword, "=module=" was also introduced. The features described in this section are primitives, meaning that they are meant to provide the operations needed to write Jam rules which provide a more elegant module interface.
+
+[section Declaration]
+
+[pre
+module /expression/ { ... }
+]
+
+Code within the [^{ ... }] executes within the module named by evaluating expression. Rule definitions can be found in the module's own namespace, and in the namespace of the global module as /module-name/./rule-name/, so within a module, other rules in that module may always be invoked without qualification:
+
+[pre
+*module my_module*
+*{*
+    rule salute ( x ) { ECHO $(x), world ; }
+    rule greet ( ) { salute hello ; }
+    greet ;
+*}*
+*my_module.salute* goodbye ;
+]
+
+When an invoked rule is not found in the current module's namespace, it is looked up in the namespace of the global module, so qualified calls work across modules:
+
+[pre
+module your_module
+{
+    rule bedtime ( ) { *my_module.salute* goodnight ; }
+}
+]
+
+[endsect]
+
+[section Variable Scope]
+
+Each module has its own set of dynamically nested variable scopes. When execution passes from module A to module B, all the variable bindings from A become unavailable, and are replaced by the bindings that belong to B. This applies equally to local and global variables:
+
+[pre
+module A
+{
+    x = 1 ;
+    rule f ( )
+    {
+        local y = 999 ; # becomes visible again when B.f calls A.g
+        B.f ;
+    }
+    rule g ( )
+    {
+        ECHO $(y) ;     # prints "999"
+    }
+}
+module B
+{
+    y = 2 ;
+    rule f ( )
+    {
+        ECHO $(y) ; # always prints "2"
+        A.g ;
+    }
+}
+]
+
+The only way to access another module's variables is by entering that module:
+
+[pre
+rule peek ( module-name ? : variables + )
+{
+    module $(module-name)
+    {
+        return $($(>)) ;
+    }
+}
+]
+
+Note that because existing variable bindings change whenever a new module scope is entered, argument bindings become unavailable. That explains the use of "=$(>)=" in the peek rule above.
+
+[endsect]
+
+[section Local Rules]
+
+[pre
+local rule /rulename/...
+]
+
+The rule is declared locally to the current module. It is not entered in the global module with qualification, and its name will not appear in the result of:
+
+[pre
+\[ RULENAMES /module-name/ \]
+]
+
+[endsect]
+
+[section The =RULENAMES= Rule]
+
+[pre
+rule RULENAMES ( /module/ ? )
+]
+
+Returns a list of the names of all non-local rules in the given module. If /module/ is omitted, the names of all non-local rules in the global module are returned.
+
+[endsect]
+
+[section The =VARNAMES= Rule]
+
+[pre
+rule VARNAMES ( /module/ ? )
+]
+
+Returns a list of the names of all variable bindings in the given module. If /module/ is omitted, the names of all variable bindings in the global module are returned.
+
+[note This includes any local variables in rules from the call stack which have not returned at the time of the =VARNAMES= invocation.]
+
+[endsect]
+
+[section The =IMPORT= Rule]
+
+=IMPORT= allows rule name aliasing across modules:
+
+[pre
+rule IMPORT ( /source_module/ ? : /source_rules/ *
+            : /target_module/ ? : /target_rules/ * )
+]
+
+The =IMPORT= rule copies rules from the /source_module/ into the /target_module/ as local rules. If either /source_module/ or /target_module/ is not supplied, it refers to the global module. /source_rules/ specifies which rules from the /source_module/ to import; /target_rules/ specifies the names to give those rules in /target_module/. If /source_rules/ contains a name which doesn't correspond to a rule in /source_module/, or if it contains a different number of items than /target_rules/, an error is issued. For example,
+
+[pre
+# import m1.rule1 into m2 as local rule m1-rule1.
+IMPORT m1 : rule1 : m2 : m1-rule1 ;
+# import all non-local rules from m1 into m2
+IMPORT m1 : \[ RULENAMES m1 \] : m2 : \[ RULENAMES m1 \] ;
+]
+
+[endsect]
+
+[section The =EXPORT= Rule]
+
+=EXPORT= allows rule name aliasing across modules:
+
+[pre
+rule EXPORT ( /module/ ? : /rules/ * )
+]
+
+The =EXPORT= rule marks /rules/ from the =source_module= as non-local (and thus exportable). If an element of /rules/ does not name a rule in /module/, an error is issued. For example,
+
+[pre
+module X {
+  local rule r { ECHO X.r ; }
+}
+IMPORT X : r : : r ; # error - r is local in X
+EXPORT X : r ;
+IMPORT X : r : : r ; # OK.
+]
+
+[endsect]
+
+[section The =CALLER_MODULE= Rule]
+
+[pre
+rule CALLER_MODULE ( /levels/ ? )
+]
+
+=CALLER_MODULE= returns the name of the module scope enclosing the call to its caller (if levels is supplied, it is interpreted as an integer number of additional levels of call stack to traverse to locate the module). If the scope belongs to the global module, or if no such module exists, returns the empty list. For example, the following prints "{Y} {X}":
+
+[pre
+module X {
+    rule get-caller { return \[ CALLER_MODULE \] ; }
+    rule get-caller's-caller { return \[ CALLER_MODULE 1 \] ; }
+    rule call-Y { return Y.call-X2 ; }
+}
+module Y {
+    rule call-X { return X.get-caller ; }
+    rule call-X2 { return X.get-caller's-caller ; }
+}
+callers = \[ X.get-caller \] \[ Y.call-X \] \[ X.call-Y \] ;
+ECHO {$(callers)} ;
+]
+
+[endsect]
+
+[section The =DELETE_MODULE= Rule]
+
+[pre
+rule DELETE_MODULE ( /module/ ? )
+]
+
+=DELETE_MODULE= removes all of the variable bindings and otherwise-unreferenced rules from the given module (or the global module, if no module is supplied), and returns their memory to the system.
+
+[note Though it won't affect rules that are currently executing until they complete, =DELETE_MODULE= should be used with extreme care because it will wipe out any others and all variable (including locals in that module) immediately. Because of the way dynamic binding works, variables which are shadowed by locals will not be destroyed, so the results can be really unpredictable.]
+
+[endsect]
+
+[endsect]
+
+[endsect]
+
+[section Miscellaneous]
+
+[section Diagnostics]
+
+In addition to generic error messages, =bjam= may emit one of the following:
+
+[pre warning: unknown rule X]
+
+A rule was invoked that has not been defined with an "=actions=" or "=rule=" statement.
+
+[pre using N temp target(s)]
+
+Targets marked as being temporary (but nonetheless present) have been found.
+
+[pre updating N target(s)]
+
+Targets are out-of-date and will be updated.
+
+[pre can't find N target(s)]
+
+Source files can't be found and there are no actions to create them.
+
+[pre can't make N target(s)]
+
+Due to sources not being found, other targets cannot be made.
+
+[pre warning: X depends on itself]
+
+A target depends on itself either directly or through its sources.
+
+[pre don't know how to make X]
+
+A target is not present and no actions have been defined to create it.
+
+[pre X skipped for lack of Y]
+
+A source failed to build, and thus a target cannot be built.
+
+[pre warning: using independent target X]
+
+A target that is not a dependency of any other target is being referenced with =$(<)= or =$(>)=.
+
+[pre X removed]
+
+=BJam= removed a partially built target after being interrupted.
+
+[endsect]
+
+[section Bugs, Limitations]
+
+For parallel building to be successful, the dependencies among files must be properly spelled out, as targets tend to get built in a quickest-first ordering. Also, beware of un-parallelizable commands that drop fixed-named files into the current directory, like =yacc(1)= does.
+
+A poorly set =$(JAMSHELL)= is likely to result in silent failure. 
+
+[endsect]
+
+[section Fundamentals]
+
+This section is derived from the official Jam documentation and from experience using it and reading the Jambase rules. We repeat the information here mostly because it is essential to understanding and using Jam, but is not consolidated in a single place. Some of it is missing from the official documentation altogether. We hope it will be useful to anyone wishing to become familiar with Jam and the Boost build system.
+
+* Jam "=rules=" are actually simple procedural entities. Think of them as functions. Arguments are separated by colons.
+
+* A Jam *target* is an abstract entity identified by an arbitrary string. The build-in =DEPENDS= rule creates a link in the dependency graph between the named targets.
+
+* Note that the original Jam documentation for the built-in =INCLUDES= rule is incorrect: [^INCLUDES ['targets1] : ['targets2]] causes everything that depends on a member of /targets1/ to depend on all members of /targets2/. It does this in an odd way, by tacking /targets2/ onto a special tail section in the dependency list of everything in /targets1/. It seems to be OK to create circular dependencies this way; in fact, it appears to be the "right thing to do" when a single build action produces both /targets1/ and /targets2/.
+
+* When a rule is invoked, if there are =actions= declared with the same name as the rule, the actions are added to the updating actions for the target identified by the rule's first argument. It is actually possible to invoke an undeclared rule if corresponding actions are declared: the rule is treated as empty.
+
+* Targets (other than =NOTFILE= targets) are associated with paths in the file system through a process called binding. Binding is a process of searching for a file with the same name as the target (sans grist), based on the settings of the target-specific =SEARCH= and =LOCATE= variables.
+
+* In addition to local and global variables, jam allows you to set a variable =on= a target. Target-specific variable values can usually not be read, and take effect only in the following contexts:
+
+    * In updating actions, variable values are first looked up =on= the target named by the first argument (the target being updated). Because Jam builds its entire dependency tree before executing actions, Jam rules make target-specific variable settings as a way of supplying parameters to the corresponding actions.
+    * Binding is controlled /entirely/ by the target-specific setting of the =SEARCH= and =LOCATE= variables, as described here.
+    * In the special rule used for header file scanning, variable values are first looked up =on= the target named by the rule's first argument (the source file being scanned).
+
+* The "bound value" of a variable is the path associated with the target named by the variable. In build actions, the first two arguments are automatically replaced with their bound values. Target-specific variables can be selectively replaced by their bound values using the =bind= action modifier.
+
+* Note that the term "binding" as used in the Jam documentation indicates a phase of processing that includes three sub-phases: /binding/ (yes!), update determination, and header file scanning. The repetition of the term "binding" can lead to some confusion. In particular, the Modifying Binding section in the Jam documentation should probably be titled "Modifying Update Determination".
+
+* "Grist" is just a string prefix of the form </characters/>. It is used in Jam to create unique target names based on simpler names. For example, the file name "=test.exe=" may be used by targets in separate subprojects, or for the debug and release variants of the "same" abstract target. Each distinct target bound to a file called "test.exe" has its own unique grist prefix. The Boost build system also takes full advantage of Jam's ability to divide strings on grist boundaries, sometimes concatenating multiple gristed elements at the beginning of a string. Grist is used instead of identifying targets with absolute paths for two reasons:
+
+   # The location of targets cannot always be derived solely from what the user puts in a Jamfile, but sometimes depends also on the binding process. Some mechanism to distinctly identify targets with the same name is still needed.
+   # Grist allows us to use a uniform abstract identifier for each built target, regardless of target file location (as allowed by setting ALL_LOCATE_TARGET).
+
+* When grist is extracted from a name with $(var:G), the result includes the leading and trailing angle brackets. When grist is added to a name with $(var:G=expr), existing grist is first stripped. Then, if expr is non-empty, leading <s and trailing >s are added if necessary to form an expression of the form <expr2>; <expr2> is then prepended.
+
+* When Jam is invoked it imports all environment variable settings into corresponding Jam variables, followed by all command-line (-s...) variable settings. Variables whose name ends in PATH, Path, or path are split into string lists on OS-specific path-list separator boundaries (e.g. ":" for UNIX and ";" for Windows). All other variables are split on space (" ") boundaries. Boost Jam modifies that behavior by allowing variables to be quoted.
+
+* A variable whose value is an empty list or which consists entirely of empty
+ strings has a negative logical value. Thus, for example, code like the
+ following allows a sensible non-empty default which can easily be overridden
+ by the user: 
+ ``
+MESSAGE ?\= starting jam... ;
+if $(MESSAGE) { ECHO The message is: $(MESSAGE) ; }
+``
+ If the user wants a specific message, he invokes jam with [^"-sMESSAGE\=message text"]. If he wants no message, he invokes jam with [^-sMESSAGE\=] and nothing at all is printed.
+
+* The parsing of command line options in Jam can be rather unintuitive, with regards to how other Unix programs accept options. There are two variants accepted as valid for an option:
+
+   # =-xvalue=, and
+   # =-x value=.
+
+[endsect]
+
+[endsect]
+
+
+[section History]
+[include history.qbk]
+[endsect]

Added: branches/release/tools/build/v2/doc/history.qbk
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/doc/history.qbk	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,377 @@
+[variablelist
+
+[[3.1.18] [
+
+After years of bjam developments.. This is going to be the last unbundled release of the
+3.1.x series. From this point forward bjam will only be bundled as part of the larger
+Boost Build system. And hence will likely change name at some point. As a side effect
+of this move people will get more frequent release of bjam (or whatever it ends up being
+called).
+
+[list
+    [li New built-ins, MD5, SPLIT_BY_CHARACTERS, PRECIOUS, PAD, FILE_OPEN, and UPDATE_NOW.
+        -- ['Vladimir P.]
+        ]
+    [li Ensure all file descriptors are closed when executing actions complete on *nix.
+        -- ['Noel B.]
+        ]
+    [li Fix warnings, patch from Mateusz Loskot.
+        -- ['Vladimir P.]
+        ]
+    [li Add KEEP_GOING var to programatically override the '-q' option.
+        -- ['Vladimir P.]
+        ]
+    [li Add more parameters, up to 19 from 9, to rule invocations. Patch from
+        Jonathan Biggar.
+        -- ['Vladimir P.]
+        ]
+    [li Print failed command output even if the normally quite '-d0' option.
+        -- ['Vladimir P.]
+        ]
+    [li Build of bjam with vc10, aka Visual Studio 2010.
+        -- ['Vladimir P.]
+        ]
+    [li More macros for detection of OSPLAT, patch from John W. Bito.
+        -- ['Vladimir P.]
+        ]
+    [li Add PARALLELISM var to programatically override the '-j' option.
+        -- ['Vladimir P.]
+        ]
+    [li Tweak doc building to allow for PDF generation of docs.
+        -- ['John M.]
+        ]
+]
+
+]]
+
+[[3.1.17] [
+
+A year in the making this release has many stability improvements and various performance
+improvements. And because of the efforts of Jurko the code is considerably more readable!
+
+[list
+    [li Reflect the results of calling bjam from Python.
+        -- ['Rene R.]
+        ]
+    [li For building on Windows: Rework how arguments are parsed and tested to fix handling
+        of quoted arguments, options arguments, and arguments with "=".
+        -- ['Rene R.]
+        ]
+    [li Try to work around at least one compiler bug with GCC and variable aliasing that
+        causes crashes with hashing file cache entries.
+        -- ['Rene R.]
+        ]
+    [li Add -Wc,-fno-strict-aliasing for QCC/QNX to avoid the same aliasing crashes as in
+        the general GCC 4.x series (thanks to Niklas Angare for the fix).
+        -- ['Rene R.]
+        ]
+    [li On Windows let the child bjam commands inherit stdin, as some commands assume
+        it's available.
+        -- ['Rene R.]
+        ]
+    [li On Windows don't limit bjam output to ASCII as some tools output characters in
+        extended character sets.
+        -- ['Rene R.]
+        ]
+    [li Isolate running of bjam tests to individual bjam instances to prevent possible
+        spillover errors from one test affecting another test. Separate the bjam used to run
+        the tests vs. the bjam being tested. And add automatic re-building of the bjam being
+        tested.
+        -- ['Rene R.]
+        ]
+    [li Fix some possible overrun issues revealed by Fortify build. Thanks to Steven Robbins
+        for pointing out the issues.
+        -- ['Rene R.]
+        ]
+    [li Handle \\n and \\r escape sequences.
+        -- ['Vladimir P.]
+        ]
+    [li Minor edits to remove -Wall warnings.
+        -- ['Rene R.]
+        ]
+    [li Dynamically adjust pwd buffer query size to allow for when PATH_MAX is default
+        defined instead of being provided by the system C library.
+        -- ['Rene R.]
+        ]
+    [li Minor perf improvement for bjam by replacing hash function with faster version. Only
+        1% diff for Boost tree.
+        -- ['Rene R.]
+        ]
+    [li Updated Boost Jam's error location reporting when parsing Jamfiles. Now it reports
+        the correct error location information when encountering an unexpected EOF. It now
+        also reports where an invalid lexical token being read started instead of finished
+        which makes it much easier to find errors like unclosed quotes or curly braces.
+        -- ['Jurko G.]
+        ]
+    [li Removed the -xarch=generic architecture from build.jam
+        as this option is unknown so the Sun compilers on Linux.
+        -- ['Noel B.]
+        ]
+    [li Fixed a bug with T_FATE_ISTMP getting reported as T_FATE_ISTMP & T_FATE_NEEDTMP at
+        the same time due to a missing break in a switch statement.
+        -- ['Jurko G.]
+        ]
+    [li Fixed a Boost Jam bug causing it to sometimes trigger actions depending on targets
+        that have not been built yet.
+        -- ['Jurko G.]
+        ]
+    [li Added missing documentation for Boost Jam's :T variable expansion modifier which
+        converts all back-slashes ('\\') to forward slashed ('/').
+        -- ['Jurko G.]
+        ]
+    [li Added Boost Jam support for executing command lines longer than 2047 characters (up
+        to 8191) characters when running on Windows XP or later OS version.
+        -- ['Jurko G.]
+        ]
+    [li Fixed a Boost Jam bug on Windows causing its SHELL command not to work correctly with
+        some commands containing quotes.
+        -- ['Jurko G.]
+        ]
+    [li Corrected a potential memory leak in Boost Jam's builtin_shell() function that would
+        appear should Boost Jam ever start to release its allocated string objects.
+        -- ['Jurko G.]
+        ]
+    [li Made all Boost Jam's ECHO commands automatically flush the standard output to make
+        that output more promptly displayed to the user.
+        -- ['Jurko G.]
+        ]
+    [li Made Boost Jam tests quote their bjam executable name when calling it allowing those
+        executables to contain spaces in their name and/or path.
+        -- ['Jurko G.]
+        ]
+    [li Change execunix.c to always use fork() instead of
+        vfork() on the Mac.  This works around known issues
+        with bjam on PPC under Tiger and a problem reported
+        by Rene with bjam on x86 under Leopard.
+        -- ['Noel B.]
+        ]
+    [li Corrected a bug in Boost Jam's base Jambase script causing it to trim the error
+        message displayed when its boost-build rule gets called multiple times.
+        -- ['Jurko G.]
+        ]
+    [li When importing from Python into an module with empty string as name,
+        import into root module.
+        -- ['Vladimir P.]
+        ]
+    [li Patch for the NORMALIZE_PATH builtin Boost Jam rule as well as an appropriate update
+        for the path.jam Boost Build module where that rule was being used to implement path
+        join and related operations.
+        -- ['Jurko G.]
+        ]
+    [li Fixed a bug causing Boost Jam not to handle target file names specified as both short
+        and long file names correctly.
+        -- ['Jurko G.]
+        ]
+    [li Relaxed test, ignoring case of drive letter.
+        -- ['Roland S.]
+        ]
+    [li Implemented a patch contributed by Igor Nazarenko reimplementing the list_sort()
+        function to use a C qsort() function instead of a hand-crafted merge-sort algorithm.
+        Makes some list sortings (e.g. 1,2,1,2,1,2,1,2, \.\.\.) extremely faster, in turn
+        significantly speeding up some project builds.
+        -- ['Jurko G.]
+        ]
+    [li Fixed a bug with bjam not handling the '\' root Windows path correctly without its
+        drive letter being specified.
+        -- ['Jurko G.]
+        ]
+    [li Solved the problem with child process returning the value 259 (Windows constant
+        STILL_ACTIVE) causing bjam never to detect that it exited and therefore keep running
+        in an endless loop.
+        -- ['Jurko G.]
+        ]
+    [li Solved the problem with bjam going into an active wait state, hogging up processor
+        resources, when waiting for one of its child processes to terminate while not all of
+        its available child process slots are being used.
+        -- ['Jurko G.]
+        ]
+    [li Solved a race condition between bjam's output reading/child process termination
+        detection and the child process's output generation/termination which could have
+        caused bjam not to collect the terminated process's final output.
+        -- ['Jurko G.]
+        ]
+    [li Change from vfork to fork for executing actions on Darwin to improve stability.
+        -- ['Noel B.]
+        ]
+    [li Code reformatting and cleanups.
+        -- ['Jurko G.]
+        ]
+    [li Implement ISFILE built-in.
+        -- ['Vladimir P.]
+        ]
+]
+
+]]
+
+[[3.1.16] [
+
+This is mostly a bug fix release.
+
+[list
+    [li Work around some Windows CMD.EXE programs that will fail executing a totally
+        empty batch file.
+        -- ['Rene R.]
+        ]
+    [li Add support for detection and building with =vc9=.
+        -- ['John P.]
+        ]
+    [li Plug memory leak when closing out actions. Thanks to Martin Kortmann for finding this.
+        -- ['Rene R.]
+        ]
+    [li Various improvements to =__TIMING_RULE__= and =__ACTION_RULE__= target variable
+        hooks.
+        -- ['Rene R.]
+        ]
+    [li Change [^JAMDATE] to use common ISO date format.
+        -- ['Rene R.]
+        ]
+    [li Add test for result status values of simple actions, i.e. empty actions.
+        -- ['Rene R.]
+        ]
+    [li Fix buffer overrun bug in expanding [^@()] subexpressions.
+        -- ['Rene R.]
+        ]
+    [li Check empty string invariants, instead of assuming all strings are allocated.
+        And reset strings when they are freed.
+        -- ['Rene R.]
+        ]
+    [li Add [^OSPLAT=PARISC] for HP-UX PA-RISC.
+        -- ['Boris G.]
+        ]
+    [li Make quietly actions really quiet by not printing the command output. The
+        output for the quietly actions is still available through =__ACTION_RULE__=.
+        -- ['Rene R.]
+        ]
+    [li Switch intel-win32 to use static multi thread runtime since the single
+        thread static runtime is no longer available.
+        -- ['Rene R.]
+        ]
+    [li When setting =OSPLAT=, check =__ia64= macro.
+        -- ['Boris G.]
+        ]
+    [li Get the unix timing working correctly.
+        -- ['Noel B.]
+        ]
+    [li Add =-fno-strict-aliasing= to compilation with gcc. Which works around
+        GCC-4.2 crash problems.
+        -- ['Boris G.]
+        ]
+    [li Increased support for Python integration.
+        -- ['Vladimir P.], ['Daniel W.]
+        ]
+    [li Allow specifying options with quotes, i.e. [^--with-python=xyz], to work
+        around the CMD shell using [^=] as an argument separator.
+        -- ['Rene R.]
+        ]
+    [li Add values of variables specified with -s to .EVNRION
+        module, so that we can override environment on
+        command line.
+        -- ['Vladimir P.]
+        ]
+    [li Make NORMALIZE_PATH convert \\ to /.
+        -- ['Vladimir P.]
+        ]
+]
+
+]]
+
+[[3.1.15] [
+
+This release sees a variety of fixes for long standing Perforce/Jam problems. Most of
+them relating to running actions in parallel with the -jN option. The end result of the
+changes is that running parallel actions is now reliably possible in Unix and Windows
+environments. Many thanks to Noel for joining the effort, to implement and fix the Unix
+side of stuff.
+
+[list
+    [li Add support for building bjam with pgi and pathscale toolsets.
+        -- ['Noel B.]
+        ]
+    [li Implement running action commands through pipes (-p option) to fix jumbled
+        output when using parallel execution with -j option. This is implemented
+        for Unix variants, and Windows (Win32/NT).
+        -- ['Rene R.], ['Noel B.]
+        ]
+    [li Add "sun" as alias to Sun Workshop compiler tools.
+        -- ['Rene R.]
+        ]
+    [li Set MAXLINE in jam.h to 23k bytes for AIX.  The piecemeal archive action
+        was broken with the default MAXLINE of 102400.  Because the AIX shell uses
+        some of the 24k default buffer size for its own use, I reduced it to 23k.
+        -- ['Noel B.]
+        ]
+    [li Make use of output dir options of msvc to not polute src dir with compiled files.
+        -- ['Rene R.]
+        ]
+    [li A small fix, so -d+2 will always show the "real" commands being executed
+        instead of casually the name of a temporary batch file.
+        -- ['Roland S.]
+        ]
+    [li Add test to check 'bjam -n'.
+        -- ['Rene R.]
+        ]
+    [li Add test to check 'bjam -d2'.
+        -- ['Rene R.]
+        ]
+    [li Bring back missing output of -n option. The -o option continues to be
+        broken as it has been for a long time now because of the @ file feature.
+        -- ['Rene R.]
+        ]
+    [li Update GC support to work with Boehm GC 7.0.
+        -- ['Rene R.]
+        ]
+    [li Revert the BOOST_BUILD_PATH change, since the directory passed to
+        boost-build should be first in searched paths, else project local
+        build system will not be picked correctly. The order had been changed to
+        allow searching of alternate user-config.jam files from boost build. This
+        better should be done with --user-config= switch or similar. 
+        -- ['Roland S.]
+        ]
+    [li Initial support for defining action body from Python.
+        -- ['Vladimir P.]
+        ]
+    [li Implement @() expansion during parse phase.
+        -- ['Rene R.]
+        ]
+    [li Define OSPLAT var unconditionally, and more generically, when possible.
+        -- ['Rene R.]
+        ]
+    [li Fix undeclared INT_MAX on some platforms, i.e. Linux.
+        -- ['Rene R.]
+        ]
+    [li Modified execunix.c to add support for terminating
+        processes that consume too much cpu or that hang and
+        fail to consume cpu at all.  This in support of the
+        bjam -lx option.
+        -- ['Noel B.]
+        ]
+    [li Add internal dependencies for multi-file generating actions to indicate
+        that the targets all only appear when the first target appears. This fixes
+        the long standing problem Perforce/Jam has with multi-file actions and
+        parallel execution (-jN).
+        -- ['Rene R.]
+        ]
+    [li Add test of -l limit option now that it's implemented on windows and unix.
+        -- ['Rene R.]
+        ]
+    [li Add test for no-op @() expansion.
+        -- ['Rene R.]
+        ]
+    [li Handle invalid formats of @() as doing a straight substitution instead of
+        erroring out.
+        -- ['Rene R.]
+        ]
+    [li Various fixes to compile on SGI/Irix.
+        -- ['Noel B.]
+        ]
+    [li Add output for when actions timeout with -lN option.
+        -- ['Rene R.], ['Noel B.]
+        ]
+    [li Add needed include (according to XOPEN) for definition of WIFEXITED and WEXITSTATUS.
+        -- ['Markus S.]
+        ]
+]
+
+]]
+
+]

Added: branches/release/tools/build/v2/engine/boost-no-inspect
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/engine/boost-no-inspect	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1 @@
+this really out of our hands, so tell inspect to ignore directory
\ No newline at end of file

Added: branches/release/tools/build/v2/example/customization/verbatim.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/example/customization/verbatim.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,47 @@
+# Copyright 2010 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) 
+
+# This file is only used with Python port of Boost.Build
+
+#  This file shows some of the primary customization mechanisms in Boost.Build V2
+#  and should serve as a basic for your own customization.
+#  Each part has a comment describing its purpose, and you can pick the parts
+#  which are relevant to your case, remove everything else, and then change names
+#  and actions to taste.
+
+#  Declare a new target type. This allows Boost.Build to do something sensible
+#  when targets with the .verbatim extension are found in sources.
+import b2.build.type as type
+type.register("VERBATIM", ["verbatim"])
+
+#  Declare a dependency scanner for the new target type. The
+#  'inline-file.py' script does not handle includes, so this is
+#  only for illustraction.
+import b2.build.scanner as scanner;
+#  First, define a new class, derived from 'common-scanner',
+#  that class has all the interesting logic, and we only need
+#  to override the 'pattern' method which return regular
+#  expression to use when scanning.
+class VerbatimScanner(scanner.CommonScanner):
+
+    def pattern(self):
+        return "//###include[ ]*\"([^\"]*)\""
+
+scanner.register(VerbatimScanner, ["include"])
+type.set_scanner("VERBATIM", VerbatimScanner)
+
+import b2.build.generators as generators
+
+generators.register_standard("verbatim.inline-file",
+                             ["VERBATIM"], ["CPP"])
+
+from b2.manager import get_manager
+
+get_manager().engine().register_action("verbatim.inline-file",
+"""
+./inline_file.py $(<) $(>)
+""")
+
+
+

Added: branches/release/tools/build/v2/example/generate/gen.jam
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/example/generate/gen.jam	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,26 @@
+
+import "class" : new ;
+import common ;
+
+rule generate-example ( project name : property-set : sources * )
+{
+    local result ;
+    for local s in $(sources)
+    {
+        #local source-name = [ $(s).name ] ;
+        #local source-action = [ $(s).action ] ;
+        #local source-properties = [ $(source-action).properties ] ;
+
+        # Create a new action, that takes the source target and runs the
+        # 'common.copy' command on it.
+        local a = [ new non-scanning-action $(s) : common.copy : $(property-set)
+            ] ;
+
+        # Create a target to represent the action result. Uses the target name
+        # passed here via the 'name' parameter and the same type and project as
+        # the source.
+        result += [ new file-target $(name) : [ $(s).type ] : $(project) : $(a)
+            ] ;
+    }
+    return $(result) ;
+}
\ No newline at end of file

Added: branches/release/tools/build/v2/example/generate/gen.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/example/generate/gen.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,16 @@
+
+from b2.build.virtual_target import NonScanningAction, FileTarget
+
+def generate_example(project, name, ps, sources):
+
+    result = []
+    for s in sources:
+
+        a = NonScanningAction([s], "common.copy", ps)
+
+        # Create a target to represent the action result. Uses the target name
+        # passed here via the 'name' parameter and the same type and project as
+        # the source.
+        result.append(FileTarget(name, s.type(), project, a))
+
+    return result

Added: branches/release/tools/build/v2/test/dependency-test/foo.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/test/dependency-test/foo.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,26 @@
+# Copyright 2003 Dave Abrahams 
+# Copyright 2002, 2003, 2005, 2010 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 bjam
+import b2.build.type as type
+import b2.build.generators as generators
+
+from b2.manager import get_manager
+
+type.register("FOO", ["foo"])
+generators.register_standard("foo.foo", ["FOO"], ["CPP", "H"])
+
+def prepare_foo(targets, sources, properties):
+
+    if properties.get('os') in ['windows', 'cygwin']:
+        bjam.call('set-target-variable', targets, "DECL", 
+                  "void __declspec(dllexport) foo(){}")
+    
+    pass
+
+get_manager().engine().register_action("foo.foo",\
+"""echo -e $(DECL:E="//")\\n > $(<[1])
+echo -e "#include <z.h>\\n" > $(<[2])
+""", function=prepare_foo)

Added: branches/release/tools/build/v2/tools/cast.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/cast.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,69 @@
+# Status: ported
+# Base revision: 64432.
+# Copyright 2005-2010 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)
+
+# Defines main target 'cast', used to change type for target. For example, in Qt
+# library one wants two kinds of CPP files -- those that just compiled and those
+# that are passed via the MOC tool.
+#
+# This is done with:
+#
+#    exe main : main.cpp [ cast _ moccable-cpp : widget.cpp ] ;
+#
+# Boost.Build will assing target type CPP to both main.cpp and widget.cpp. Then,
+# the cast rule will change target type of widget.cpp to MOCCABLE-CPP, and Qt
+# support will run the MOC tool as part of the build process.
+#
+# At the moment, the 'cast' rule only works for non-derived (source) targets.
+#
+# TODO: The following comment is unclear or incorrect. Clean it up.
+# > Another solution would be to add a separate main target 'moc-them' that
+# > would moc all the passed sources, no matter what their type is, but I prefer
+# > cast, as defining a new target type + generator for that type is somewhat
+# > simpler than defining a main target rule.
+
+import b2.build.targets as targets
+import b2.build.virtual_target as virtual_target
+
+from b2.manager import get_manager
+from b2.util import bjam_signature
+
+class CastTargetClass(targets.TypedTarget):
+
+    def construct(name, source_targets, ps):
+        result = []
+        for s in source_targets:
+            if not isinstance(s, virtual_targets.FileTarget):
+                get_manager().errors()("Source to the 'cast' metatager is not a file")
+
+            if s.action():
+                get_manager().errors()("Only non-derived targets allowed as sources for 'cast'.")
+
+
+            r = s.clone_with_different_type(self.type())
+            result.append(get_manager().virtual_targets().register(r))
+
+        return result
+    
+
+@bjam_signature((["name", "type"], ["sources", "*"], ["requirements", "*"],
+                 ["default_build", "*"], ["usage_requirements", "*"]))
+def cast(name, type, sources, requirements, default_build, usage_requirements):
+   
+    from b2.manager import get_manager
+    t = get_manager().targets()
+    
+    project = get_manager().projects().current()
+        
+    return t.main_target_alternative(
+        CastTargetClass(name, project, type,
+                        t.main_target_sources(sources, name),
+                        t.main_target_requirements(requirements, project),
+                        t.main_target_default_build(default_build, project),
+                        t.main_target_usage_requirements(usage_requirements, project)))
+
+
+get_manager().projects().add_rule("cast", cast)

Added: branches/release/tools/build/v2/tools/message.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/message.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,46 @@
+# Status: ported.
+# Base revision: 64488.
+#
+# Copyright 2008, 2010 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)
+
+# Defines main target type 'message', that prints a message when built for the
+# first time.
+
+import b2.build.targets as targets
+import b2.build.property_set as property_set
+
+from b2.manager import get_manager
+
+class MessageTargetClass(targets.BasicTarget):
+
+    def __init__(self, name, project, *args):
+
+        targets.BasicTarget.__init__(self, name, project, [])
+        self.args = args
+        self.built = False
+
+    def construct(self, name, sources, ps):
+
+        if not self.built:
+            for arg in self.args:
+                if type(arg) == type([]):
+                    arg = " ".join(arg)                
+                print arg
+            self.built = True
+
+        return (property_set.empty(), [])
+
+def message(name, *args):
+
+    if type(name) == type([]):
+        name = name[0]
+
+    t = get_manager().targets()
+    
+    project = get_manager().projects().current()
+        
+    return t.main_target_alternative(MessageTargetClass(*((name, project) + args)))
+
+get_manager().projects().add_rule("message", message)

Added: branches/release/tools/build/v2/tools/notfile.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/notfile.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,51 @@
+# Status: ported.
+# Base revision: 64429.
+#
+#  Copyright (c) 2005-2010 Vladimir Prus.
+#
+#  Use, modification and distribution is subject to the Boost Software
+#  License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+#  http://www.boost.org/LICENSE_1_0.txt)
+
+
+import b2.build.type as type
+import b2.build.generators as generators
+import b2.build.virtual_target as virtual_target
+import b2.build.toolset as toolset
+import b2.build.targets as targets
+
+from b2.manager import get_manager
+from b2.util import bjam_signature
+
+type.register("NOTFILE_MAIN")
+
+class NotfileGenerator(generators.Generator):
+
+    def run(self, project, name, ps, sources):
+        pass
+        action_name = ps.get('action')[0]
+        if action_name[0] == '@':
+            action = virtual_target.Action(get_manager(), sources, action_name[1:], ps)
+        else:
+            action = virtual_target.Action(get_manager(), sources, "notfile.run", ps)
+
+        return [get_manager().virtual_targets().register(
+            virtual_target.NotFileTarget(name, project, action))]
+
+generators.register(NotfileGenerator("notfile.main", False, [], ["NOTFILE_MAIN"]))
+
+toolset.flags("notfile.run", "ACTION", [], ["<action>"])
+
+get_manager().engine().register_action("notfile.run", "$(ACTION)")
+
+@bjam_signature((["target_name"], ["action"], ["sources", "*"], ["requirements", "*"],
+                 ["default_build", "*"]))
+def notfile(target_name, action, sources, requirements, default_build):
+
+    requirements.append("<action>" + action)
+
+    return targets.create_typed_metatarget(target_name, "NOTFILE_MAIN", sources, requirements,
+                                           default_build, [])
+
+
+get_manager().projects().add_rule("notfile", notfile)

Added: branches/release/tools/build/v2/tools/package.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/package.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,168 @@
+# Status: ported
+# Base revision: 64488
+#
+# Copyright (c) 2005, 2010 Vladimir Prus.
+# Copyright 2006 Rene Rivera.
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# Provides mechanism for installing whole packages into a specific directory
+# structure. This is opposed to the 'install' rule, that installs a number of
+# targets to a single directory, and does not care about directory structure at
+# all.
+
+# Example usage:
+#
+#   package.install boost : <properties>
+#                         : <binaries>
+#                         : <libraries>
+#                         : <headers>
+#                         ;
+#
+# This will install binaries, libraries and headers to the 'proper' location,
+# given by command line options --prefix, --exec-prefix, --bindir, --libdir and
+# --includedir.
+#
+# The rule is just a convenient wrapper, avoiding the need to define several
+# 'install' targets.
+#
+# The only install-related feature is <install-source-root>. It will apply to
+# headers only and if present, paths of headers relatively to source root will
+# be retained after installing. If it is not specified, then "." is assumed, so
+# relative paths in headers are always preserved.
+
+import b2.build.feature as feature
+import b2.build.property as property
+import b2.util.option as option
+import b2.tools.stage as stage
+
+from b2.build.alias import alias
+
+from b2.manager import get_manager
+
+from b2.util import bjam_signature
+from b2.util.utility import ungrist
+
+
+import os
+
+feature.feature("install-default-prefix", [], ["free", "incidental"])
+
+@bjam_signature((["name", "package_name", "?"], ["requirements", "*"],
+                 ["binaries", "*"], ["libraries", "*"], ["headers", "*"]))
+def install(name, package_name=None, requirements=[], binaries=[], libraries=[], headers=[]):
+
+    requirements = requirements[:]
+    binaries = binaries[:]
+    libraries
+
+    if not package_name:
+        package_name = name
+
+    if option.get("prefix"):
+        # If --prefix is explicitly specified on the command line,
+        # then we need wipe away any settings of libdir/includir that
+        # is specified via options in config files.
+        option.set("bindir", None)
+        option.set("libdir", None)
+        option.set("includedir", None)
+            
+    # If <install-source-root> is not specified, all headers are installed to
+    # prefix/include, no matter what their relative path is. Sometimes that is
+    # what is needed.
+    install_source_root = property.select('install-source-root', requirements)
+    if install_source_root:
+        requirements = property.change(requirements, 'install-source-root', None)
+            
+    install_header_subdir = property.select('install-header-subdir', requirements)
+    if install_header_subdir:
+        install_header_subdir = ungrist(install_header_subdir[0])
+        requirements = property.change(requirements, 'install-header-subdir', None)
+
+    # First, figure out all locations. Use the default if no prefix option
+    # given.
+    prefix = get_prefix(name, requirements)
+
+    # Architecture dependent files.
+    exec_locate = option.get("exec-prefix", prefix)
+
+    # Binaries.
+    bin_locate = option.get("bindir", os.path.join(prefix, "bin"))
+
+    # Object code libraries.
+    lib_locate = option.get("libdir", os.path.join(prefix, "lib"))
+
+    # Source header files.
+    include_locate = option.get("includedir", os.path.join(prefix, "include"))
+
+    stage.install(name + "-bin", binaries, requirements + ["<location>" + bin_locate])
+    
+    alias(name + "-lib", [name + "-lib-shared", name + "-lib-static"])
+    
+    # Since the install location of shared libraries differs on universe
+    # and cygwin, use target alternatives to make different targets.
+    # We should have used indirection conditioanl requirements, but it's
+    # awkward to pass bin-locate and lib-locate from there to another rule.
+    alias(name + "-lib-shared", [name + "-lib-shared-universe"])
+    alias(name + "-lib-shared", [name + "-lib-shared-cygwin"], ["<target-os>cygwin"])
+    
+    # For shared libraries, we install both explicitly specified one and the
+    # shared libraries that the installed executables depend on.
+    stage.install(name + "-lib-shared-universe", binaries + libraries,
+                  requirements + ["<location>" + lib_locate, "<install-dependencies>on",
+                                  "<install-type>SHARED_LIB"])
+    stage.install(name + "-lib-shared-cygwin", binaries + libraries,
+                  requirements + ["<location>" + bin_locate, "<install-dependencies>on",
+                                  "<install-type>SHARED_LIB"])
+
+    # For static libraries, we do not care about executable dependencies, since
+    # static libraries are already incorporated into them.
+    stage.install(name + "-lib-static", libraries, requirements +
+                  ["<location>" + lib_locate, "<install-dependencies>on", "<install-type>STATIC_LIB"])
+    stage.install(name + "-headers", headers, requirements \
+                  + ["<location>" + os.path.join(include_locate, s) for s in install_header_subdir]
+                  + install_source_root)
+
+    alias(name, [name + "-bin", name + "-lib", name + "-headers"])
+
+    pt = get_manager().projects().current()
+
+    for subname in ["bin", "lib", "headers", "lib-shared", "lib-static", "lib-shared-universe", "lib-shared-cygwin"]:
+        pt.mark_targets_as_explicit([name + "-" + subname])
+
+@bjam_signature((["target_name"], ["package_name"], ["data", "*"], ["requirements", "*"]))
+def install_data(target_name, package_name, data, requirements):
+    if not package_name:
+        package_name = target_name
+
+    if option.get("prefix"):
+        # If --prefix is explicitly specified on the command line,
+        # then we need wipe away any settings of datarootdir
+        option.set("datarootdir", None)
+    
+    prefix = get_prefix(package_name, requirements)
+    datadir = option.get("datarootdir", os.path.join(prefix, "share"))
+
+    stage.install(target_name, data,
+                  requirements + ["<location>" + os.path.join(datadir, package_name)])
+
+    get_manager().projects().current().mark_targets_as_explicit([target_name])
+
+def get_prefix(package_name, requirements):
+
+    specified = property.select("install-default-prefix", requirements)
+    if specified:
+        specified = ungrist(specified[0])
+    prefix = option.get("prefix", specified)
+    requirements = property.change(requirements, "install-default-prefix", None)    
+    # Or some likely defaults if neither is given.
+    if not prefix:
+        if os.name == "nt":
+            prefix = "C:\\" + package_name
+        elif os.name == "posix":
+            prefix = "/usr/local"
+
+    return prefix
+

Added: branches/release/tools/build/v2/tools/stage.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/stage.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,350 @@
+# Status: ported.
+# Base revision 64444.
+#
+# Copyright 2003 Dave Abrahams
+# Copyright 2005, 2006 Rene Rivera
+# Copyright 2002, 2003, 2004, 2005, 2006, 2010 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)
+
+# This module defines the 'install' rule, used to copy a set of targets to a
+# single location.
+
+import b2.build.feature as feature
+import b2.build.targets as targets
+import b2.build.property as property
+import b2.build.property_set as property_set
+import b2.build.generators as generators
+import b2.build.virtual_target as virtual_target
+
+from b2.manager import get_manager
+from b2.util.sequence import unique
+from b2.util import bjam_signature
+
+import b2.build.type
+
+import os.path
+import re
+import types
+
+feature.feature('install-dependencies', ['off', 'on'], ['incidental'])
+feature.feature('install-type', [], ['free', 'incidental'])
+feature.feature('install-source-root', [], ['free', 'path'])
+feature.feature('so-version', [], ['free', 'incidental'])
+
+# If 'on', version symlinks for shared libraries will not be created. Affects
+# Unix builds only.
+feature.feature('install-no-version-symlinks', ['on'], ['optional', 'incidental'])
+
+class InstallTargetClass(targets.BasicTarget):
+
+    def update_location(self, ps):
+        """If <location> is not set, sets it based on the project data."""
+
+        loc = ps.get('location')
+        if not loc:
+            loc = os.path.join(self.project().get('location'), self.name())
+            ps = ps.add_raw(["<location>" + loc])
+
+        return ps
+
+    def adjust_properties(self, target, build_ps):
+        a = target.action()
+        properties = []
+        if a:
+            ps = a.properties()
+            properties = ps.all()
+            
+            # Unless <hardcode-dll-paths>true is in properties, which can happen
+            # only if the user has explicitly requested it, nuke all <dll-path>
+            # properties.
+
+            if build_ps.get('hardcode-dll-paths') != ['true']:
+                properties = [p for p in properties if p.feature().name() != 'dll-path']
+
+            # If any <dll-path> properties were specified for installing, add
+            # them.
+            properties.extend(build_ps.get_properties('dll-path'))
+
+            # Also copy <linkflags> feature from current build set, to be used
+            # for relinking.
+            properties.extend(build_ps.get_properties('linkflags'))
+
+            # Remove the <tag> feature on original targets.
+            # And <location>. If stage target has another stage target in
+            # sources, then we shall get virtual targets with the <location>
+            # property set.
+            properties = [p for p in properties
+                          if not p.feature().name() in ['tag', 'location']]
+
+        properties.extend(build_ps.get_properties('dependency'))
+
+        properties.extend(build_ps.get_properties('location'))
+        
+
+        properties.extend(build_ps.get_properties('install-no-version-symlinks'))
+
+        d = build_ps.get_properties('install-source-root')
+
+        # Make the path absolute: we shall use it to compute relative paths and
+        # making the path absolute will help.
+        if d:
+            p = d[0]
+            properties.append(property.Property(p.feature(), os.path.abspath(p.value())))
+
+        return property_set.create(properties)
+    
+
+    def construct(self, name, source_targets, ps):
+
+        source_targets = self.targets_to_stage(source_targets, ps)
+        ps = self.update_location(ps)
+
+        ename = ps.get('name')
+        if ename:
+            ename = ename[0]
+        if ename and len(source_targets) > 1:
+            get_manager().errors()("When <name> property is used in 'install', only one source is allowed")
+
+        result = []
+
+        for i in source_targets:
+
+            staged_targets = []
+            new_ps = self.adjust_properties(i, ps)
+
+            # See if something special should be done when staging this type. It
+            # is indicated by the presence of a special "INSTALLED_" type.
+            t = i.type()
+            if t and b2.build.type.registered("INSTALLED_" + t):
+
+                if ename:
+                    get_manager().errors()("In 'install': <name> property specified with target that requires relinking.")
+                else:
+                    (r, targets) = generators.construct(self.project(), name, "INSTALLED_" + t,
+                                                        new_ps, [i])
+                    assert isinstance(r, property_set.PropertySet)
+                    staged_targets.extend(targets)
+                    
+            else:
+                staged_targets.append(copy_file(self.project(), ename, i, new_ps))
+
+            if not staged_targets:
+                get_manager().errors()("Unable to generate staged version of " + i)
+
+            result.extend(get_manager().virtual_targets().register(t) for t in staged_targets)
+
+        return (property_set.empty(), result)
+
+    def targets_to_stage(self, source_targets, ps):
+        """Given the list of source targets explicitly passed to 'stage', returns the
+        list of targets which must be staged."""
+
+        result = []
+
+        # Traverse the dependencies, if needed.
+        if ps.get('install-dependencies') == ['on']:
+            source_targets = self.collect_targets(source_targets)
+
+        # Filter the target types, if needed.
+        included_types = ps.get('install-type')
+        for r in source_targets:
+            ty = r.type()
+            if ty:
+                # Do not stage searched libs.
+                if ty != "SEARCHED_LIB":
+                    if included_types:
+                        if self.include_type(ty, included_types):
+                            result.append(r)
+                    else:
+                        result.append(r)
+            elif not included_types:
+                # Don't install typeless target if there is an explicit list of
+                # allowed types.
+                result.append(r)
+
+        return result
+
+    # CONSIDER: figure out why we can not use virtual-target.traverse here.
+    #
+    def collect_targets(self, targets):
+        
+        s = [t.creating_subvariant() for t in targets]
+        s = unique(s)
+        
+        result = set(targets)
+        for i in s:
+            i.all_referenced_targets(result)
+           
+        result2 = []
+        for r in result:
+            if isinstance(r, property.Property):
+                
+                if r.feature().name() != 'use':
+                    result2.append(r.value())
+            else:
+                result2.append(r)
+        result2 = unique(result2)
+        return result2
+
+    # Returns true iff 'type' is subtype of some element of 'types-to-include'.
+    #
+    def include_type(self, type, types_to_include):
+        return any(b2.build.type.is_subtype(type, ti) for ti in types_to_include)
+
+# Creates a copy of target 'source'. The 'properties' object should have a
+# <location> property which specifies where the target must be placed.
+#
+def copy_file(project, name, source, ps):
+
+    if not name:
+        name = source.name()
+
+    relative = ""
+
+    new_a = virtual_target.NonScanningAction([source], "common.copy", ps)
+    source_root = ps.get('install-source-root')
+    if source_root:
+        source_root = source_root[0]
+        # Get the real path of the target. We probably need to strip relative
+        # path from the target name at construction.
+        path = os.path.join(source.path(), os.path.dirname(name))
+        # Make the path absolute. Otherwise, it would be hard to compute the
+        # relative path. The 'source-root' is already absolute, see the
+        # 'adjust-properties' method above.
+        path = os.path.abspath(path)
+
+        relative = os.path.relpath(path, source_root)
+
+    name = os.path.join(relative, os.path.basename(name))
+    return virtual_target.FileTarget(name, source.type(), project, new_a, exact=True)
+
+def symlink(name, project, source, ps):
+    a = virtual_target.Action([source], "symlink.ln", ps)
+    return virtual_target.FileTarget(name, source.type(), project, a, exact=True)
+
+def relink_file(project, source, ps):
+    action = source.action()
+    cloned_action = virtual_target.clone_action(action, project, "", ps)
+    targets = cloned_action.targets()
+    # We relink only on Unix, where exe or shared lib is always a single file.
+    assert len(targets) == 1
+    return targets[0]
+
+
+# Declare installed version of the EXE type. Generator for this type will cause
+# relinking to the new location.
+b2.build.type.register('INSTALLED_EXE', [], 'EXE')
+
+class InstalledExeGenerator(generators.Generator):
+
+    def __init__(self):
+        generators.Generator.__init__(self, "install-exe", False, ['EXE'], ['INSTALLED_EXE'])
+
+    def run(self, project, name, ps, source):
+
+        need_relink = False;
+
+        if ps.get('os') in ['NT', 'CYGWIN'] or ps.get('target-os') in ['windows', 'cygwin']:
+            # Never relink
+            pass
+        else:
+            # See if the dll-path properties are not changed during
+            # install. If so, copy, don't relink.
+            need_relink = ps.get('dll-path') != source[0].action().properties().get('dll-path')
+
+        if need_relink:
+            return [relink_file(project, source, ps)]
+        else:
+            return [copy_file(project, None, source[0], ps)]
+
+generators.register(InstalledExeGenerator())
+
+
+# Installing a shared link on Unix might cause a creation of versioned symbolic
+# links.
+b2.build.type.register('INSTALLED_SHARED_LIB', [], 'SHARED_LIB')
+
+class InstalledSharedLibGenerator(generators.Generator):
+
+    def __init__(self):
+        generators.Generator.__init__(self, 'install-shared-lib', False, ['SHARED_LIB'], ['INSTALLED_SHARED_LIB'])
+
+    def run(self, project, name, ps, source):
+
+        source = source[0]
+        if ps.get('os') in ['NT', 'CYGWIN'] or ps.get('target-os') in ['windows', 'cygwin']:
+            copied = copy_file(project, None, source, ps)
+            return [get_manager().virtual_targets().register(copied)]
+        else:
+            a = source.action()
+            if not a:
+                # Non-derived file, just copy.
+                copied = copy_file(project, source, ps)
+            else:
+
+                need_relink = ps.get('dll-path') != source.action().properties().get('dll-path')
+                
+                if need_relink:
+                    # Rpath changed, need to relink.
+                    copied = relink_file(project, source, ps)
+                else:
+                    copied = copy_file(project, None, source, ps)
+
+            result = [get_manager().virtual_targets().register(copied)]
+            # If the name is in the form NNN.XXX.YYY.ZZZ, where all 'X', 'Y' and
+            # 'Z' are numbers, we need to create NNN.XXX and NNN.XXX.YYY
+            # symbolic links.
+            m = re.match("(.*)\\.([0123456789]+)\\.([0123456789]+)\\.([0123456789]+)$",
+                         copied.name());
+            if m:
+                # Symlink without version at all is used to make
+                # -lsome_library work.
+                result.append(symlink(m.group(1), project, copied, ps))
+
+                # Symlinks of some libfoo.N and libfoo.N.M are used so that
+                # library can found at runtime, if libfoo.N.M.X has soname of
+                # libfoo.N. That happens when the library makes some binary
+                # compatibility guarantees. If not, it is possible to skip those
+                # symlinks.
+                if ps.get('install-no-version-symlinks') != ['on']:
+                
+                    result.append(symlink(m.group(1) + '.' + m.group(2), project, copied, ps))
+                    result.append(symlink(m.group(1) + '.' + m.group(2) + '.' + m.group(3),
+                                          project, copied, ps))
+
+            return result
+            
+generators.register(InstalledSharedLibGenerator())
+
+
+# Main target rule for 'install'.
+#
+@bjam_signature((["name"], ["sources", "*"], ["requirements", "*"],
+                 ["default_build", "*"], ["usage_requirements", "*"]))
+def install(name, sources, requirements=[], default_build=[], usage_requirements=[]):
+
+    requirements = requirements[:]
+    # Unless the user has explicitly asked us to hardcode dll paths, add
+    # <hardcode-dll-paths>false in requirements, to override default value.
+    if not '<hardcode-dll-paths>true' in requirements:
+        requirements.append('<hardcode-dll-paths>false')
+
+    if any(r.startswith('<tag>') for r in requirements):
+        get_manager().errors()("The <tag> property is not allowed for the 'install' rule")
+
+    from b2.manager import get_manager
+    t = get_manager().targets()
+    
+    project = get_manager().projects().current()
+        
+    return t.main_target_alternative(
+        InstallTargetClass(name, project,
+                           t.main_target_sources(sources, name),
+                           t.main_target_requirements(requirements, project),
+                           t.main_target_default_build(default_build, project),
+                           t.main_target_usage_requirements(usage_requirements, project)))
+
+get_manager().projects().add_rule("install", install)
+get_manager().projects().add_rule("stage", install)
+

Added: branches/release/tools/build/v2/tools/symlink.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/symlink.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,112 @@
+# Status: ported.
+# Base revision: 64488.
+
+# Copyright 2003 Dave Abrahams 
+# Copyright 2002, 2003 Rene Rivera 
+# Copyright 2002, 2003, 2004, 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) 
+
+# Defines the "symlink" special target. 'symlink' targets make symbolic links
+# to the sources.
+
+import b2.build.feature as feature
+import b2.build.targets as targets
+import b2.build.property_set as property_set
+import b2.build.virtual_target as virtual_target
+import b2.build.targets
+
+from b2.manager import get_manager
+
+import bjam
+
+import os
+
+
+feature.feature("symlink-location", ["project-relative", "build-relative"], ["incidental"])
+
+class SymlinkTarget(targets.BasicTarget):
+
+    _count = 0
+
+    def __init__(self, project, targets, sources):
+         
+        # Generate a fake name for now. Need unnamed targets eventually.
+        fake_name = "symlink#%s" % SymlinkTarget._count
+        SymlinkTarget._count = SymlinkTarget._count + 1
+
+        b2.build.targets.BasicTarget.__init__(self, fake_name, project, sources)
+    
+        # Remember the targets to map the sources onto. Pad or truncate
+        # to fit the sources given.
+        assert len(targets) <= len(sources)
+        self.targets = targets[:] + sources[len(targets):]
+            
+        # The virtual targets corresponding to the given targets.
+        self.virtual_targets = []
+
+    def construct(self, name, source_targets, ps):
+        i = 0
+        for t in source_targets:
+            s = self.targets[i]
+            a = virtual_target.Action(self.manager(), [t], "symlink.ln", ps)
+            vt = virtual_target.FileTarget(os.path.basename(s), t.type(), self.project(), a)
+                        
+            # Place the symlink in the directory relative to the project
+            # location, instead of placing it in the build directory.
+            if not ps.get('symlink-location') == "project-relative":
+                vt.set_path(os.path.join(self.project().get('location'), os.path.dirname(s)))
+
+            vt = get_manager().virtual_targets().register(vt)
+            self.virtual_targets.append(vt)
+            i = i + 1
+
+        return (property_set.empty(), self.virtual_targets)
+
+# Creates a symbolic link from a set of targets to a set of sources.
+# The targets and sources map one to one. The symlinks generated are
+# limited to be the ones given as the sources. That is, the targets
+# are either padded or trimmed to equate to the sources. The padding
+# is done with the name of the corresponding source. For example::
+#
+#     symlink : one two ;
+#
+# Is equal to::
+#
+#     symlink one two : one two ;
+#
+# Names for symlink are relative to the project location. They cannot
+# include ".." path components.
+def symlink(targets, sources):
+
+    from b2.manager import get_manager
+    t = get_manager().targets()   
+    p = get_manager().projects().current()
+
+    return t.main_target_alternative(
+        SymlinkTarget(p, targets, 
+                      # Note: inline targets are not supported for symlink, intentionally,
+                      # since it's used to linking existing non-local targets.
+                      sources))
+
+
+def setup_ln(targets, sources, ps):
+
+    source_path = bjam.call("get-target-variable", sources[0], "LOCATE")[0]
+    target_path = bjam.call("get-target-variable", targets[0], "LOCATE")[0]
+    rel = os.path.relpath(source_path, target_path)
+    if rel == ".":
+        bjam.call("set-target-variable", targets, "PATH_TO_SOURCE", "")
+    else:
+        bjam.call("set-target-variable", targets, "PATH_TO_SOURCE", rel)
+
+if os.name == 'nt':
+    ln_action = """echo "NT symlinks not supported yet, making copy"
+del /f /q "$(<)" 2>nul >nul
+copy "$(>)" "$(<)" $(NULL_OUT)"""
+else:
+    ln_action = "ln -f -s '$(>:D=:R=$(PATH_TO_SOURCE))' '$(<)'"
+
+get_manager().engine().register_action("symlink.ln", ln_action, function=setup_ln)
+
+get_manager().projects().add_rule("symlink", symlink)

Added: branches/release/tools/build/v2/tools/testing-aux.jam
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/testing-aux.jam	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,210 @@
+# This module is imported by testing.py. The definitions here are
+# too tricky to do in Python
+
+# Causes the 'target' to exist after bjam invocation if and only if all the
+# dependencies were successfully built.
+#
+rule expect-success ( target : dependency + : requirements * )
+{
+    **passed** $(target) : $(sources) ;
+}
+IMPORT testing : expect-success : : testing.expect-success ;
+
+# Causes the 'target' to exist after bjam invocation if and only if all some of
+# the dependencies were not successfully built.
+#
+rule expect-failure ( target : dependency + : properties * )
+{
+    local grist = [ MATCH ^<(.*)> : $(dependency:G) ] ;
+    local marker = $(dependency:G=$(grist)*fail) ;
+    (failed-as-expected) $(marker) ;
+    FAIL_EXPECTED $(dependency) ;
+    LOCATE on $(marker) = [ on $(dependency) return $(LOCATE) ] ;
+    RMOLD $(marker) ;
+    DEPENDS $(marker) : $(dependency) ;
+    DEPENDS $(target) : $(marker) ;
+    **passed** $(target) : $(marker) ;
+}
+IMPORT testing : expect-failure : : testing.expect-failure ;
+
+# The rule/action combination used to report successful passing of a test.
+#
+rule **passed**
+{
+    # Force deletion of the target, in case any dependencies failed to build.
+    RMOLD $(<) ;
+}
+
+
+# Used to create test files signifying passed tests.
+#
+actions **passed**
+{
+    echo passed > "$(<)"
+}
+
+
+# Used to create replacement object files that do not get created during tests
+# that are expected to fail.
+#
+actions (failed-as-expected)
+{
+    echo failed as expected > "$(<)"
+}
+
+# Runs executable 'sources' and stores stdout in file 'target'. Unless
+# --preserve-test-targets command line option has been specified, removes the
+# executable. The 'target-to-remove' parameter controls what should be removed:
+#   - if 'none', does not remove anything, ever
+#   - if empty, removes 'source'
+#   - if non-empty and not 'none', contains a list of sources to remove.
+#
+rule capture-output ( target : source : properties * : targets-to-remove * )
+{
+    output-file on $(target) = $(target:S=.output) ;
+    LOCATE on $(target:S=.output) = [ on $(target) return $(LOCATE) ] ;
+
+    # The INCLUDES kill a warning about independent target...
+    INCLUDES $(target) : $(target:S=.output) ;
+    # but it also puts .output into dependency graph, so we must tell jam it is
+    # OK if it cannot find the target or updating rule.
+    NOCARE $(target:S=.output) ;
+
+    # This has two-fold effect. First it adds input files to the dependendency
+    # graph, preventing a warning. Second, it causes input files to be bound
+    # before target is created. Therefore, they are bound using SEARCH setting
+    # on them and not LOCATE setting of $(target), as in other case (due to jam
+    # bug).
+    DEPENDS $(target) : [ on $(target) return $(INPUT_FILES) ] ;
+
+    if $(targets-to-remove) = none
+    {
+        targets-to-remove = ;
+    }
+    else if ! $(targets-to-remove)
+    {
+        targets-to-remove = $(source) ;
+    }
+
+    if [ on $(target) return $(REMOVE_TEST_TARGETS) ]
+    {
+        TEMPORARY $(targets-to-remove) ;
+        # Set a second action on target that will be executed after capture
+        # output action. The 'RmTemps' rule has the 'ignore' modifier so it is
+        # always considered succeeded. This is needed for 'run-fail' test. For
+        # that test the target will be marked with FAIL_EXPECTED, and without
+        # 'ignore' successful execution will be negated and be reported as
+        # failure. With 'ignore' we do not detect a case where removing files
+        # fails, but it is not likely to happen.
+        RmTemps $(target) : $(targets-to-remove) ;
+    }
+}
+
+
+if [ os.name ] = NT
+{
+    .STATUS        = %status% ;
+    .SET_STATUS    = "set status=%ERRORLEVEL%" ;
+    .RUN_OUTPUT_NL = "echo." ;
+    .STATUS_0      = "%status% EQU 0 (" ;
+    .STATUS_NOT_0  = "%status% NEQ 0 (" ;
+    .VERBOSE       = "%verbose% EQU 1 (" ;
+    .ENDIF         = ")" ;
+    .SHELL_SET     = "set " ;
+    .CATENATE      = type ;
+    .CP            = copy ;
+}
+else
+{
+    .STATUS        = "$status" ;
+    .SET_STATUS    = "status=$?" ;
+    .RUN_OUTPUT_NL = "echo" ;
+    .STATUS_0      = "test $status -eq 0 ; then" ;
+    .STATUS_NOT_0  = "test $status -ne 0 ; then" ;
+    .VERBOSE       = "test $verbose -eq 1 ; then" ;
+    .ENDIF         = "fi" ;
+    .SHELL_SET     = "" ;
+    .CATENATE      = cat ;
+    .CP            = cp ;
+}
+
+
+.VERBOSE_TEST = 0 ;
+if --verbose-test in [ modules.peek : ARGV ]
+{
+    .VERBOSE_TEST = 1 ;
+}
+
+
+.RM = [ common.rm-command ] ;
+
+
+actions capture-output bind INPUT_FILES output-file
+{
+    $(PATH_SETUP)
+    $(LAUNCHER) "$(>)" $(ARGS) "$(INPUT_FILES)" > "$(output-file)" 2>&1
+    $(.SET_STATUS)
+    $(.RUN_OUTPUT_NL) >> "$(output-file)"
+    echo EXIT STATUS: $(.STATUS) >> "$(output-file)"
+    if $(.STATUS_0)
+        $(.CP) "$(output-file)" "$(<)"
+    $(.ENDIF)
+    $(.SHELL_SET)verbose=$(.VERBOSE_TEST)
+    if $(.STATUS_NOT_0)
+        $(.SHELL_SET)verbose=1
+    $(.ENDIF)
+    if $(.VERBOSE)
+        echo ====== BEGIN OUTPUT ======
+        $(.CATENATE) "$(output-file)"
+        echo ====== END OUTPUT ======
+    $(.ENDIF)
+    exit $(.STATUS)
+}
+
+IMPORT testing : capture-output : : testing.capture-output ;
+
+
+actions quietly updated ignore piecemeal together RmTemps
+{
+    $(.RM) "$(>)"
+}
+
+
+.MAKE_FILE = [ common.file-creation-command ] ;
+
+actions unit-test
+{
+    $(PATH_SETUP)
+    $(LAUNCHER) $(>) $(ARGS) && $(.MAKE_FILE) $(<)
+}
+
+rule record-time ( target : source : start end user system )
+{
+    local src-string = [$(source:G=:J=",")"] " ;
+    USER_TIME on $(target) += $(src-string)$(user) ;
+    SYSTEM_TIME on $(target) += $(src-string)$(system) ;
+}
+
+# Calling this rule requests that Boost Build time how long it taks to build the
+# 'source' target and display the results both on the standard output and in the
+# 'target' file.
+#
+rule time ( target : source : properties *  )
+{
+    # Set up rule for recording timing information.
+    __TIMING_RULE__ on $(source) = testing.record-time $(target) ;
+
+    # Make sure that the source is rebuilt any time we need to retrieve that
+    # information.
+    REBUILDS $(target) : $(source) ;
+}
+
+
+actions time
+{
+    echo user: $(USER_TIME)
+    echo system: $(SYSTEM_TIME)
+
+    echo user: $(USER_TIME)" seconds" > "$(<)"
+    echo system: $(SYSTEM_TIME)" seconds" >> "$(<)"
+}

Added: branches/release/tools/build/v2/tools/testing.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/testing.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,342 @@
+# Status: ported, except for --out-xml
+# Base revision: 64488
+#
+# Copyright 2005 Dave Abrahams
+# Copyright 2002, 2003, 2004, 2005, 2010 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)
+
+# This module implements regression testing framework. It declares a number of
+# main target rules which perform some action and, if the results are OK,
+# creates an output file.
+#
+# The exact list of rules is:
+# 'compile'       -- creates .test file if compilation of sources was
+#                    successful.
+# 'compile-fail'  -- creates .test file if compilation of sources failed.
+# 'run'           -- creates .test file is running of executable produced from
+#                    sources was successful. Also leaves behind .output file
+#                    with the output from program run.
+# 'run-fail'      -- same as above, but .test file is created if running fails.
+#
+# In all cases, presence of .test file is an indication that the test passed.
+# For more convenient reporting, you might want to use C++ Boost regression
+# testing utilities (see http://www.boost.org/more/regression.html).
+#
+# For historical reason, a 'unit-test' rule is available which has the same
+# syntax as 'exe' and behaves just like 'run'.
+
+# Things to do:
+#  - Teach compiler_status handle Jamfile.v2.
+# Notes:
+#  - <no-warn> is not implemented, since it is Como-specific, and it is not
+#    clear how to implement it
+#  - std::locale-support is not implemented (it is used in one test).
+
+import b2.build.feature as feature
+import b2.build.type as type
+import b2.build.targets as targets
+import b2.build.generators as generators
+import b2.build.toolset as toolset
+import b2.tools.common as common
+import b2.util.option as option
+import b2.build_system as build_system
+
+
+
+from b2.manager import get_manager
+from b2.util import stem, bjam_signature
+from b2.util.sequence import unique
+
+import bjam
+
+import re
+import os.path
+import sys
+
+def init():
+    pass
+
+# Feature controling the command used to lanch test programs.
+feature.feature("testing.launcher", [], ["free", "optional"])
+
+feature.feature("test-info", [], ["free", "incidental"])
+feature.feature("testing.arg", [], ["free", "incidental"])
+feature.feature("testing.input-file", [], ["free", "dependency"])
+
+feature.feature("preserve-test-targets", ["on", "off"], ["incidental", "propagated"])
+
+# Register target types.
+type.register("TEST", ["test"])
+type.register("COMPILE", [], "TEST")
+type.register("COMPILE_FAIL", [], "TEST")
+
+type.register("RUN_OUTPUT", ["run"])
+type.register("RUN", [], "TEST")
+type.register("RUN_FAIL", [], "TEST")
+
+type.register("LINK", [], "TEST")
+type.register("LINK_FAIL", [], "TEST")
+type.register("UNIT_TEST", ["passed"], "TEST")
+
+__all_tests = []
+
+# Declare the rules which create main targets. While the 'type' module already
+# creates rules with the same names for us, we need extra convenience: default
+# name of main target, so write our own versions.
+
+# Helper rule. Create a test target, using basename of first source if no target
+# name is explicitly passed. Remembers the created target in a global variable.
+def make_test(target_type, sources, requirements, target_name=None):
+
+    if not target_name:
+        target_name = stem(os.path.basename(sources[0]))
+
+    # Having periods (".") in the target name is problematic because the typed
+    # generator will strip the suffix and use the bare name for the file
+    # targets. Even though the location-prefix averts problems most times it
+    # does not prevent ambiguity issues when referring to the test targets. For
+    # example when using the XML log output. So we rename the target to remove
+    # the periods, and provide an alias for users.
+    real_name = target_name.replace(".", "~")
+
+    project = get_manager().projects().current()
+    # The <location-prefix> forces the build system for generate paths in the
+    # form '$build_dir/array1.test/gcc/debug'. This is necessary to allow
+    # post-processing tools to work.
+    t = get_manager().targets().create_typed_target(
+        type.type_from_rule_name(target_type), project, real_name, sources,
+        requirements + ["<location-prefix>" + real_name + ".test"], [], [])
+
+    # The alias to the real target, per period replacement above.
+    if real_name != target_name:
+        get_manager().projects().project_rules().all_names_["alias"](
+            target_name, [t])
+
+    # Remember the test (for --dump-tests). A good way would be to collect all
+    # given a project. This has some technical problems: e.g. we can not call
+    # this dump from a Jamfile since projects referred by 'build-project' are
+    # not available until the whole Jamfile has been loaded.
+    __all_tests.append(t)
+    return t
+
+
+# Note: passing more that one cpp file here is known to fail. Passing a cpp file
+# and a library target works.
+#
+@bjam_signature((["sources", "*"], ["requirements", "*"], ["target_name", "?"]))
+def compile(sources, requirements, target_name=None):
+    return make_test("compile", sources, requirements, target_name)
+
+@bjam_signature((["sources", "*"], ["requirements", "*"], ["target_name", "?"]))
+def compile_fail(sources, requirements, target_name=None):
+    return make_test("compile-fail", sources, requirements, target_name)
+
+@bjam_signature((["sources", "*"], ["requirements", "*"], ["target_name", "?"]))
+def link(sources, requirements, target_name=None):
+    return make_test("link", sources, requirements, target_name)
+
+@bjam_signature((["sources", "*"], ["requirements", "*"], ["target_name", "?"]))
+def link_fail(sources, requirements, target_name=None):
+    return make_test("link-fail", sources, requirements, target_name)
+
+def handle_input_files(input_files):
+    if len(input_files) > 1:
+        # Check that sorting made when creating property-set instance will not
+        # change the ordering.
+        if sorted(input_files) != input_files:
+            get_manager().errors()("Names of input files must be sorted alphabetically\n" +
+                                   "due to internal limitations")
+    return ["<testing.input-file>" + f for f in input_files]
+
+@bjam_signature((["sources", "*"], ["args", "*"], ["input_files", "*"],
+                 ["requirements", "*"], ["target_name", "?"],
+                 ["default_build", "*"]))                 
+def run(sources, args, input_files, requirements, target_name=None, default_build=[]):
+    if args:
+        requirements.append("<testing.arg>" + " ".join(args))
+    requirements.extend(handle_input_files(input_files))
+    return make_test("run", sources, requirements, target_name)
+
+@bjam_signature((["sources", "*"], ["args", "*"], ["input_files", "*"],
+                 ["requirements", "*"], ["target_name", "?"],
+                 ["default_build", "*"]))                 
+def run_fail(sources, args, input_files, requirements, target_name=None, default_build=[]):
+    if args:
+        requirements.append("<testing.arg>" + " ".join(args))
+    requirements.extend(handle_input_files(input_files))
+    return make_test("run-fail", sources, requirements, target_name)
+
+# Register all the rules
+for name in ["compile", "compile-fail", "link", "link-fail", "run", "run-fail"]:
+    get_manager().projects().add_rule(name, getattr(sys.modules[__name__], name.replace("-", "_")))
+
+# Use 'test-suite' as a synonym for 'alias', for backward compatibility.
+from b2.build.alias import alias
+get_manager().projects().add_rule("test-suite", alias)
+
+# For all main targets in 'project-module', which are typed targets with type
+# derived from 'TEST', produce some interesting information.
+#
+def dump_tests():
+    for t in __all_tests:
+        dump_test(t)
+
+# Given a project location in normalized form (slashes are forward), compute the
+# name of the Boost library.
+#
+__ln1 = re.compile("/(tools|libs)/(.*)/(test|example)")
+__ln2 = re.compile("/(tools|libs)/(.*)$")
+__ln3 = re.compile("(/status$)")
+def get_library_name(path):
+    
+    path = path.replace("\\", "/")
+    match1 = __ln1.match(path)
+    match2 = __ln2.match(path)
+    match3 = __ln3.match(path)
+
+    if match1:
+        return match1.group(2)
+    elif match2:
+        return match2.group(2)
+    elif match3:
+        return ""
+    elif option.get("dump-tests", False, True):
+        # The 'run' rule and others might be used outside boost. In that case,
+        # just return the path, since the 'library name' makes no sense.
+        return path
+
+# Was an XML dump requested?
+__out_xml = option.get("out-xml", False, True)
+
+# Takes a target (instance of 'basic-target') and prints
+#   - its type
+#   - its name
+#   - comments specified via the <test-info> property
+#   - relative location of all source from the project root.
+#
+def dump_test(target):
+    type = target.type()
+    name = target.name()
+    project = target.project()
+
+    project_root = project.get('project-root')
+    library = get_library_name(os.path.abspath(project.get('location')))
+    if library:
+        name = library + "/" + name
+
+    sources = target.sources()
+    source_files = []
+    for s in sources:
+        if isinstance(s, targets.FileReference):
+            location = os.path.abspath(os.path.join(s.location(), s.name()))
+            source_files.append(os.path.relpath(location, os.path.abspath(project_root)))
+
+    target_name = project.get('location') + "//" + target.name() + ".test"
+
+    test_info = target.requirements().get('test-info')
+    test_info = " ".join('"' + ti + '"' for ti in test_info)
+
+    # If the user requested XML output on the command-line, add the test info to
+    # that XML file rather than dumping them to stdout.
+    #if $(.out-xml)
+    #{
+#        local nl = "
+#" ;
+#        .contents on $(.out-xml) +=
+#            "$(nl)  <test type=\"$(type)\" name=\"$(name)\">"
+#            "$(nl)    <target><![CDATA[$(target-name)]]></target>"
+#            "$(nl)    <info><![CDATA[$(test-info)]]></info>"
+#            "$(nl)    <source><![CDATA[$(source-files)]]></source>"
+#            "$(nl)  </test>"
+#            ;
+#    }
+#    else
+
+    source_files = " ".join('"' + s + '"' for s in source_files)
+    if test_info:
+        print 'boost-test(%s) "%s" [%s] : %s' % (type, name, test_info, source_files)
+    else:
+        print 'boost-test(%s) "%s" : %s' % (type, name, source_files)
+
+# Register generators. Depending on target type, either 'expect-success' or
+# 'expect-failure' rule will be used.
+generators.register_standard("testing.expect-success", ["OBJ"], ["COMPILE"])
+generators.register_standard("testing.expect-failure", ["OBJ"], ["COMPILE_FAIL"])
+generators.register_standard("testing.expect-success", ["RUN_OUTPUT"], ["RUN"])
+generators.register_standard("testing.expect-failure", ["RUN_OUTPUT"], ["RUN_FAIL"])
+generators.register_standard("testing.expect-success", ["EXE"], ["LINK"])
+generators.register_standard("testing.expect-failure", ["EXE"], ["LINK_FAIL"])
+
+# Generator which runs an EXE and captures output.
+generators.register_standard("testing.capture-output", ["EXE"], ["RUN_OUTPUT"])
+
+# Generator which creates a target if sources run successfully. Differs from RUN
+# in that run output is not captured. The reason why it exists is that the 'run'
+# rule is much better for automated testing, but is not user-friendly (see
+# http://article.gmane.org/gmane.comp.lib.boost.build/6353).
+generators.register_standard("testing.unit-test", ["EXE"], ["UNIT_TEST"])
+
+# FIXME: if those calls are after bjam.call, then bjam will crash
+# when toolset.flags calls bjam.caller.
+toolset.flags("testing.capture-output", "ARGS", [], ["<testing.arg>"])
+toolset.flags("testing.capture-output", "INPUT_FILES", [], ["<testing.input-file>"])
+toolset.flags("testing.capture-output", "LAUNCHER", [], ["<testing.launcher>"])
+
+toolset.flags("testing.unit-test", "LAUNCHER", [], ["<testing.launcher>"])
+toolset.flags("testing.unit-test", "ARGS", [], ["<testing.arg>"])
+
+type.register("TIME", ["time"])
+generators.register_standard("testing.time", [], ["TIME"])
+
+
+# The following code sets up actions for this module. It's pretty convoluted,
+# but the basic points is that we most of actions are defined by Jam code
+# contained in testing-aux.jam, which we load into Jam module named 'testing'
+
+def run_path_setup(target, sources, ps):
+
+    # For testing, we need to make sure that all dynamic libraries needed by the
+    # test are found. So, we collect all paths from dependency libraries (via
+    # xdll-path property) and add whatever explicit dll-path user has specified.
+    # The resulting paths are added to the environment on each test invocation.
+    dll_paths = ps.get('dll-path')
+    dll_paths.extend(ps.get('xdll-path'))
+    dll_paths.extend(bjam.call("get-target-variable", sources, "RUN_PATH"))
+    dll_paths = unique(dll_paths)
+    if dll_paths:
+        bjam.call("set-target-variable", target, "PATH_SETUP",
+                  common.prepend_path_variable_command(
+                     common.shared_library_path_variable(), dll_paths))
+
+def capture_output_setup(target, sources, ps):
+    run_path_setup(target, sources, ps)
+
+    if ps.get('preserve-test-targets') == ['off']:
+        bjam.call("set-target-variable", target, "REMOVE_TEST_TARGETS", "1")
+
+get_manager().engine().register_bjam_action("testing.capture-output",
+                                            capture_output_setup)
+
+
+path = os.path.dirname(get_manager().projects().loaded_tool_module_path_[__name__])
+import b2.util.os_j
+get_manager().projects().project_rules()._import_rule("testing", "os.name",
+                                                      b2.util.os_j.name)
+import b2.tools.common
+get_manager().projects().project_rules()._import_rule("testing", "common.rm-command",
+                                                      b2.tools.common.rm_command)
+get_manager().projects().project_rules()._import_rule("testing", "common.file-creation-command",
+                                                      b2.tools.common.file_creation_command)
+
+bjam.call("load", "testing", os.path.join(path, "testing-aux.jam"))
+
+
+for name in ["expect-success", "expect-failure", "time"]:
+    get_manager().engine().register_bjam_action("testing." + name)
+
+get_manager().engine().register_bjam_action("testing.unit-test",
+                                            run_path_setup)
+
+if option.get("dump-tests", False, True):
+    build_system.add_pre_build_hook(dump_tests)

Added: branches/release/tools/build/v2/tools/zlib.jam
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/tools/zlib.jam	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,92 @@
+# Copyright (c) 2010 Vladimir Prus.
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# Supports the zlib library
+#
+# After 'using zlib', the following targets are available:
+#
+# /zlib//zlib -- The zlib library
+
+
+# In addition to direct purpose of supporting zlib, this module also
+# serves as canonical example of how third-party condiguration works
+# in Boost.Build. The operation is as follows
+#
+# - For each 'using zlib : condition ... : ...' we create a target alternative
+#   for zlib, with the specified condition.
+# - There's one target alternative for 'zlib' with no specific condition
+#   properties. 
+#
+# Two invocations of 'using zlib' with the same condition but different
+# properties are not permitted, e.g.:
+#
+#   using zlib : condition <target-os>windows : include foo ;
+#   using zlib : condition <target-os>windows : include bar ;
+#
+# is in error. One exception is for empty condition, 'using' without any
+# parameters is overridable. That is:
+#
+#   using zlib ;
+#   using zlib : include foo ;
+# 
+# Is OK then the first 'using' is ignored. Likewise if the order of the statements
+# is reversed.
+#
+# When 'zlib' target is built, a target alternative is selected as usual for
+# Boost.Build. The selected alternative is a custom target class, which:
+#
+# - calls ac.find-include-path to find header path. If explicit path is provided
+#   in 'using', only that path is checked, and if no header is found there, error
+#   is emitted. Otherwise, we check a directory specified using ZLIB_INCLUDE
+#   environment variable, and failing that, in standard directories.
+#   [TODO: document sysroot handling]
+# - calls ac.find-library to find the library, in an identical fashion.
+#
+
+import project ;
+import ac ;
+import errors ;
+import "class" : new ;
+import targets ; 
+
+project.initialize $(__name__) ;
+project = [ project.current ] ;
+project zlib ;
+
+header = zlib.h ;
+names = z zlib zll zdll ;
+
+.default-alternative = [ new ac-library zlib : $(project) ] ;
+$(.default-alternative).set-header $(header) ;
+$(.default-alternative).set-default-names $(names) ;
+targets.main-target-alternative $(.default-alternative) ;
+
+rule init ( * : * )
+{
+    if ! $(condition)
+    {
+        # Special case the no-condition case so that 'using' without parameters
+        # can mix with more specific 'using'.
+        $(.default-alternative).reconfigure $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
+    }
+    else                    
+    {
+        # FIXME: consider if we should allow overriding definitions for a given
+        # condition -- e.g. project-config.jam might want to override whatever is
+        # in user-config.jam. 
+        local mt = [ new ac-library zlib : $(project)
+          : $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
+        $(mt).set-header $(header) ;
+        $(mt).set-default-names $(names) ;
+        targets.main-target-alternative $(mt) ;
+    }    
+}
+
+
+
+
+
+

Added: branches/release/tools/build/v2/util/indirect.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/util/indirect.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,15 @@
+# Status: minimally ported. This module is not supposed to be used much
+# with Boost.Build/Python.
+# 
+# Copyright 2003 Dave Abrahams
+# Copyright 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)
+
+from b2.util import call_jam_function, bjam_signature
+
+def call(*args):
+    a1 = args[0]
+    name = a1[0]
+    a1tail = a1[1:]
+    call_jam_function(name, *((a1tail,) + args[1:]))

Added: branches/release/tools/build/v2/util/option.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/util/option.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,35 @@
+#  Copyright (c) 2005-2010 Vladimir Prus.
+#
+#  Use, modification and distribution is subject to the Boost Software
+#  License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+#  http://www.boost.org/LICENSE_1_0.txt)
+
+import sys
+import re
+import b2.util.regex
+
+options = {}
+
+# Set a value for a named option, to be used when not overridden on the command
+# line.
+def set(name, value=None):
+    
+    global options
+    
+    options[name] = value
+
+def get(name, default_value=None, implied_value=None):
+
+    global options
+
+    matches = b2.util.regex.transform(sys.argv, "--" + re.escape(name) + "=(.*)")
+    if matches:
+        return matches[-1]
+    else:
+        m = b2.util.regex.transform(sys.argv, "--(" + re.escape(name) + ")")
+        if m and implied_value:
+            return implied_value
+        elif options.has_key(name) and options[name] != None:
+            return options[name]
+        else:
+            return default_value

Added: branches/release/tools/build/v2/util/os_j.py
==============================================================================
--- (empty file)
+++ branches/release/tools/build/v2/util/os_j.py	2011-01-25 13:46:03 EST (Tue, 25 Jan 2011)
@@ -0,0 +1,19 @@
+# Status: stub, just enough to make tests work.
+#
+# Named os_j to avoid conflicts with standard 'os'. See
+# project.py:import for special-casing.
+#
+# Copyright 2001, 2002, 2003, 2005 Dave Abrahams
+# Copyright 2006 Rene Rivera
+# 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)
+
+import bjam
+
+__OS = bjam.call("peek", [], "OS")[0]
+
+# Return Jam's name of OS to prevent existing code from burning
+# when faced with Python naming
+def name():
+    return __OS