Give in and copy bjam into cdec source code

1 files changed, 2473 insertions, 0 deletions

diff --git a/jam-files/engine/Jambase b/jam-files/engine/Jambase
new file mode 100644
index 00000000..94f8fbde
--- /dev/null
+++ b/jam-files/engine/Jambase
@@ -0,0 +1,2473 @@
+#
+# /+\
+# +\    Copyright 1993, 2000 Christopher Seiwald.
+# \+/
+#
+# This file is part of Jam - see jam.c for Copyright information.
+#
+
+# This file is ALSO:
+# Copyright 2001-2004 David Abrahams.
+# Copyright 2002-2004 Rene Rivera.
+# 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)
+
+if $(NT)
+{
+    SLASH ?= \\ ;
+}
+SLASH ?= / ;
+
+
+# Glob for patterns in the directories starting from the given start directory,
+# up to and including the root of the file-system. We stop globbing as soon as
+# we find at least one match.
+#
+rule find-to-root ( dir : patterns + )
+{
+    local globs = [ GLOB $(dir) : $(patterns) ] ;
+    while ! $(globs) && $(dir:P) != $(dir)
+    {
+        dir = $(dir:P) ;
+        globs = [ GLOB $(dir) : $(patterns) ] ;
+    }
+    return $(globs) ;
+}
+
+
+# This global will hold the location of the user's boost-build.jam file.
+.boost-build-file = ;
+
+# This global will hold the location of the build system bootstrap file.
+.bootstrap-file = ;
+
+# Remember the value of $(BOOST_BUILD_PATH) supplied to us by the user.
+BOOST_BUILD_PATH.user-value = $(BOOST_BUILD_PATH) ;
+
+# On Unix only, when BOOST_BUILD_PATH is not supplied by the user, set it to a
+# sensible default value. This allows Boost.Build to work without any
+# environment variables, which is good in itself and also required by the Debian
+# Policy.
+if ! $(BOOST_BUILD_PATH) && $(UNIX)
+{
+    BOOST_BUILD_PATH = /usr/share/boost-build ;
+}
+
+
+rule _poke ( module-name ? : variables + : value * )
+{
+    module $(<)
+    {
+        $(>) = $(3) ;
+    }
+}
+
+
+# This rule can be invoked from an optional user's boost-build.jam file to both
+# indicate where to find the build system files, and to load them. The path
+# indicated is relative to the location of the boost-build.jam file.
+#
+rule boost-build ( dir ? )
+{
+    if $(.bootstrap-file)
+    {
+        ECHO "Error: Illegal attempt to re-bootstrap the build system by invoking" ;
+        ECHO ;
+        ECHO "   'boost-build" $(dir) ";'" ;
+        ECHO ;
+        EXIT "Please consult the documentation at 'http://www.boost.org'." ;
+    }
+
+    # Add the given directory to the path so we can find the build system. If
+    # dir is empty, has no effect.
+    BOOST_BUILD_PATH = $(dir:R=$(.boost-build-file:D)) $(BOOST_BUILD_PATH) ;
+
+    # We might have just modified the *global* value of BOOST_BUILD_PATH. The
+    # code that loads the rest of Boost.Build, in particular the site-config.jam
+    # and user-config.jam configuration files uses os.environ, so we need to
+    # update the value there.
+    _poke .ENVIRON : BOOST_BUILD_PATH : $(BOOST_BUILD_PATH) ;
+
+    # Try to find the build system bootstrap file 'bootstrap.jam'.
+    local bootstrap-file = [ GLOB $(BOOST_BUILD_PATH) : bootstrap.jam ] ;
+    .bootstrap-file = $(bootstrap-file[1]) ;
+
+    # There is no bootstrap.jam we can find, exit with an error.
+    if ! $(.bootstrap-file)
+    {
+        ECHO "Unable to load Boost.Build: could not find build system." ;
+        ECHO --------------------------------------------------------- ;
+        ECHO "$(.boost-build-file) attempted to load the build system by invoking" ;
+        ECHO ;
+        ECHO "   'boost-build" $(dir) ";'" ;
+        ECHO ;
+        ECHO "but we were unable to find \"bootstrap.jam\" in the specified directory" ;
+        ECHO "or in BOOST_BUILD_PATH (searching "$(BOOST_BUILD_PATH:J=", ")")." ;
+        ECHO ;
+        EXIT "Please consult the documentation at 'http://www.boost.org'." ;
+    }
+
+    if [ MATCH .*(--debug-configuration).* : $(ARGV) ]
+    {
+        ECHO "notice: loading Boost.Build from"
+            [ NORMALIZE_PATH $(.bootstrap-file:D) ] ;
+    }
+
+    # Load the build system, now that we know where to start from.
+    include $(.bootstrap-file) ;
+}
+
+
+if [ MATCH .*(b2).* : $(ARGV[1]:BL) ] 
+  || [ MATCH .*(bjam).* : $(ARGV[1]:BL) ]
+  || $(BOOST_ROOT)    # A temporary measure so Jam works with Boost.Build v1.
+{
+    # We attempt to load "boost-build.jam" by searching from the current
+    # invocation directory up to the root of the file-system.
+    #
+    # boost-build.jam is expected to invoke the "boost-build" rule to load the
+    # Boost.Build files.
+
+    local search-path = $(BOOST_BUILD_PATH) $(BOOST_ROOT) ;
+    local self = [ SELF_PATH ] ;
+    local boost-build-relative = ../../share/boost-build ;
+    local self-based-path = [ NORMALIZE_PATH $(boost-build-relative:R=$(self)) ] ;
+
+    local boost-build-files =
+        [ find-to-root [ PWD ] : boost-build.jam ]
+        [ GLOB $(self-based-path) : boost-build.jam ]
+        # Another temporary measure so Jam works with Boost.Build v1.
+        [ GLOB $(search-path) : boost-build.jam ] ;
+
+    .boost-build-file = $(boost-build-files[1]) ;
+
+    # There is no boost-build.jam we can find, exit with an error, and
+    # information.
+    if ! $(.boost-build-file)
+    {
+        ECHO "Unable to load Boost.Build: could not find \"boost-build.jam\"" ;
+        ECHO --------------------------------------------------------------- ;
+
+        if ! [ MATCH .*(bjam).* : $(ARGV[1]:BL) ]
+        {
+            ECHO "BOOST_ROOT must be set, either in the environment, or " ;
+            ECHO "on the command-line with -sBOOST_ROOT=..., to the root" ;
+            ECHO "of the boost installation." ;
+            ECHO ;
+        }
+
+        ECHO "Attempted search from" [ PWD ] "up to the root" ;
+        ECHO "at" $(self-based-path) ;
+        ECHO "and in these directories from BOOST_BUILD_PATH and BOOST_ROOT: "$(search-path:J=", ")"." ;
+        EXIT "Please consult the documentation at 'http://www.boost.org'." ;
+    }
+
+    if [ MATCH .*(--debug-configuration).* : $(ARGV) ]
+    {
+        ECHO "notice: found boost-build.jam at"
+            [ NORMALIZE_PATH $(.boost-build-file) ] ;
+    }
+
+    # Now load the boost-build.jam to get the build system loaded. This
+    # incidentaly loads the users jamfile and attempts to build targets.
+    #
+    # We also set it up so we can tell whether we are loading the new V2 system
+    # or the the old V1 system.
+    include $(.boost-build-file) ;
+
+    # Check that, at minimum, the bootstrap file was found.
+    if ! $(.bootstrap-file)
+    {
+        ECHO "Unable to load Boost.Build" ;
+        ECHO -------------------------- ;
+        ECHO "\"$(.boost-build-file)\" was found by searching from" [ PWD ] "up to the root" ;
+        ECHO "and in these directories from BOOST_BUILD_PATH and BOOST_ROOT: "$(search-path:J=", ")"." ;
+        ECHO ;
+        ECHO "However, it failed to call the \"boost-build\" rule to indicate" ;
+        ECHO "the location of the build system." ;
+        ECHO ;
+        EXIT "Please consult the documentation at 'http://www.boost.org'." ;
+    }
+}
+else
+{
+
+#
+# JAMBASE - jam 2.3 ruleset providing make(1)-like functionality
+#
+# Supports UNIX, NT, and VMS.
+#
+# 12/27/93 (seiwald) - purturb library sources with SOURCE_GRIST
+# 04/18/94 (seiwald) - use '?=' when setting OS specific vars
+# 04/21/94 (seiwald) - do RmTemps together
+# 05/05/94 (seiwald) - all supported C compilers support -o: relegate
+#              RELOCATE as an option; set Ranlib to "" to disable it
+# 06/01/94 (seiwald) - new 'actions existing' to do existing sources
+# 08/25/94 (seiwald) - new ObjectCcFlags rule to append to per-target CCFLAGS
+# 08/29/94 (seiwald) - new ObjectHdrs rule to append to per-target HDRS
+# 09/19/94 (seiwald) - LinkLibraries and Undefs now append
+#            - Rule names downshifted.
+# 10/06/94 (seiwald) - Dumb yyacc stuff moved into Jamfile.
+# 10/14/94 (seiwald) - (Crude) support for .s, .C, .cc, .cpp, and .f files.
+# 01/08/95 (seiwald) - Shell now handled with awk, not sed
+# 01/09/95 (seiwald) - Install* now take dest directory as target
+# 01/10/95 (seiwald) - All entries sorted.
+# 01/10/95 (seiwald) - NT support moved in, with LauraW's help.
+# 01/10/95 (seiwald) - VMS support moved in.
+# 02/06/95 (seiwald) - ObjectC++Flags and SubDirC++Flags added.
+# 02/07/95 (seiwald) - Iron out when HDRSEARCH uses "" or SEARCH_SOURCE.
+# 02/08/95 (seiwald) - SubDir works on VMS.
+# 02/14/95 (seiwald) - MkDir and entourage.
+# 04/30/95 (seiwald) - Use install -c flag so that it copies, not moves.
+# 07/10/95 (taylor) - Support for Microsoft C++.
+# 11/21/96 (peterk) - Support for BeOS
+# 07/19/99 (sickel) - Support for Mac OS X Server (and maybe client)
+# 02/18/00 (belmonte)- Support for Cygwin.
+
+# Special targets defined in this file:
+#
+# all       - parent of first, shell, files, lib, exe
+# first     - first dependency of 'all', for potential initialization
+# shell     - parent of all Shell targets
+# files     - parent of all File targets
+# lib       - parent of all Library targets
+# exe       - parent of all Main targets
+# dirs      - parent of all MkDir targets
+# clean     - removes all Shell, File, Library, and Main targets
+# uninstall - removes all Install targets
+#
+
+# Rules defined by this file:
+#
+# as obj.o : source.s ;         .s -> .o
+# Bulk dir : files ;            populate directory with many files
+# Cc obj.o : source.c ;         .c -> .o
+# C++ obj.o : source.cc ;       .cc -> .o
+# Clean clean : sources ;       remove sources with 'jam clean'
+# File dest : source ;          copy file
+# Fortran obj.o : source.f ;        .f -> .o
+# GenFile source.c : program args ; make custom file
+# Hardlink target : source ;        make link from source to target
+# HdrRule source : headers ;        handle #includes
+# InstallInto dir : sources ;       install any files
+# InstallBin dir : sources ;        install binaries
+# InstallLib dir : sources ;        install files
+# InstallFile dir : sources ;       install files
+# InstallMan dir : sources ;        install man pages
+# InstallShell dir : sources ;      install shell scripts
+# Lex source.c : source.l ;     .l -> .c
+# Library lib : source ;        archive library from compiled sources
+# LibraryFromObjects lib : objects ;    archive library from objects
+# LinkLibraries images : libraries ;    bag libraries onto Mains
+# Main image : source ;         link executable from compiled sources
+# MainFromObjects image : objects ; link executable from objects
+# MkDir dir ;               make a directory, if not there
+# Object object : source ;      compile object from source
+# ObjectCcFlags source : flags ;    add compiler flags for object
+# ObjectC++Flags source : flags ;   add compiler flags for object
+# ObjectHdrs source : dirs ;        add include directories for object
+# Objects sources ;         compile sources
+# RmTemps target : sources ;        remove temp sources after target made
+# Setuid images ;           mark executables Setuid
+# SubDir TOP d1 d2 ... ;        start a subdirectory Jamfile
+# SubDirCcFlags flags ;         add compiler flags until next SubDir
+# SubDirC++Flags flags ;        add compiler flags until next SubDir
+# SubDirHdrs dirs ;         add include dirs until next SubDir
+# SubInclude TOP d1 d2 ... ;        include a subdirectory Jamfile
+# Shell exe : source ;          make a shell executable
+# Undefines images : symbols ;      save undef's for linking
+# UserObject object : source ;      handle unknown suffixes for Object
+# Yacc source.c : source.y ;        .y -> .c
+#
+# Utility rules that have no side effects (not supported):
+#
+# FAppendSuffix f1 f2 ... : $(SUF) ;    return $(<) with suffixes
+# FConcat value ... ;               return contatenated values
+# FDirName d1 d2 ... ;          return path from root to dir
+# FGrist d1 d2 ... ;            return d1!d2!...
+# FGristFiles value ;           return $(value:G=$(SOURCE_GRIST))
+# FGristSourceFiles value ;     return $(value:G=$(SOURCE_GRIST))
+# FRelPath d1 : d2 ;            return rel path from d1 to d2
+# FSubDir d1 d2 ... ;           return path to root
+#
+
+
+# Brief review of the jam language:
+#
+# Statements:
+#   rule RULE - statements to process a rule
+#   actions RULE - system commands to carry out target update
+#
+# Modifiers on actions:
+#   together - multiple instances of same rule on target get executed
+#          once with their sources ($(>)) concatenated
+#   updated - refers to updated sources ($(>)) only
+#   ignore - ignore return status of command
+#   quietly - don't trace its execution unless verbose
+#   piecemeal - iterate command each time with a small subset of $(>)
+#   existing - refers to currently existing sources ($(>)) only
+#   bind vars - subject to binding before expanding in actions
+#
+# Special rules:
+#   ALWAYS - always build a target
+#   DEPENDS - builds the dependency graph
+#   ECHO - blurt out targets on stdout
+#   EXIT - blurt out targets and exit
+#   INCLUDES - marks sources as headers for target (a codependency)
+#   NOCARE - don't panic if the target can't be built
+#   NOUPDATE - create the target if needed but never update it
+#   NOTFILE - ignore the timestamp of the target (it's not a file)
+#   TEMPORARY - target need not be present if sources haven't changed
+#
+# Special variables set by jam:
+#   $(<) - targets of a rule (to the left of the :)
+#   $(>) - sources of a rule (to the right of the :)
+#   $(xxx) - true on xxx (UNIX, VMS, NT, OS2, MAC)
+#   $(OS) - name of OS - varies wildly
+#   $(JAMVERSION) - version number (2.3)
+#
+# Special variables used by jam:
+#   SEARCH - where to find something (used during binding and actions)
+#   LOCATE - where to plop something not found with SEARCH
+#   HDRRULE - rule to call to handle include files
+#   HDRSCAN - egrep regex to extract include files
+#
+# Special targets:
+#   all - default if none given on command line
+#
+
+# Initialize variables
+#
+
+#
+# OS specific variable settings
+#
+if $(NT)
+{
+    # the list of supported toolsets on Windows NT and Windows 95/98
+    #
+    local SUPPORTED_TOOLSETS = "BORLANDC" "VC7" "VISUALC" "VISUALC16" "INTELC" "WATCOM"
+                               "MINGW" "LCC" ;
+
+    # this variable holds the current toolset
+    #
+    TOOLSET = "" ;
+
+    # if the JAM_TOOLSET environment variable is defined, check that it is
+    # one of our supported values
+    #
+    if $(JAM_TOOLSET)
+    {
+      local t ;
+
+      for t in $(SUPPORTED_TOOLSETS)
+      {
+        $(t) = $($(t):J=" ") ; # reconstitute paths with spaces in them
+        if $(t) = $(JAM_TOOLSET) { TOOLSET = $(t) ; }
+      }
+
+      if ! $(TOOLSET)
+      {
+        ECHO  "The JAM_TOOLSET environment variable is defined but its value" ;
+        ECHO  "is invalid, please use one of the following:" ;
+        ECHO  ;
+
+        for t in $(SUPPORTED_TOOLSETS) { ECHO "  " $(t) ; }
+        EXIT ;
+      }
+    }
+
+    # if TOOLSET is empty, we'll try to detect the toolset from other
+    # environment variables to remain backwards compatible with Jam 2.3
+    #
+    if ! $(TOOLSET)
+    {
+      if $(BCCROOT)
+      {
+        TOOLSET  = BORLANDC ;
+        BORLANDC = $(BCCROOT:J=" ") ;
+      }
+      else if $(MSVC)
+      {
+        TOOLSET   = VISUALC16 ;
+        VISUALC16 = $(MSVC:J=" ") ;
+      }
+      else if $(MSVCNT)
+      {
+        TOOLSET = VISUALC ;
+        VISUALC = $(MSVCNT:J=" ") ;
+      }
+      else if $(MSVCDir)
+      {
+        TOOLSET = VISUALC ;
+        VISUALC = $(MSVCDir:J=" ") ;
+      }
+      else if $(MINGW)
+      {
+        TOOLSET = MINGW ;
+      }
+      else
+      {
+        ECHO  "Jam cannot be run because, either:" ;
+        ECHO  "   a. You didn't set BOOST_ROOT to indicate the root of your" ;
+        ECHO  "      Boost installation." ;
+        ECHO  "   b. You are trying to use stock Jam but didn't indicate which" ;
+        ECHO  "      compilation toolset to use. To do so, follow these simple" ;
+        ECHO  "      instructions:" ;
+        ECHO  ;
+        ECHO  "  - define one of the following environment variable, with the" ;
+        ECHO  "    appropriate value according to this list:" ;
+        ECHO  ;
+        ECHO  "   Variable    Toolset                      Description" ;
+        ECHO  ;
+        ECHO  "   BORLANDC    Borland C++                  BC++ install path" ;
+        ECHO  "   VISUALC     Microsoft Visual C++         VC++ install path" ;
+        ECHO  "   VISUALC16   Microsoft Visual C++ 16 bit  VC++ 16 bit install" ;
+        ECHO  "   INTELC      Intel C/C++                  IC++ install path" ;
+        ECHO  "   WATCOM      Watcom C/C++                 Watcom install path" ;
+        ECHO  "   MINGW       MinGW (gcc)                  MinGW install path" ;
+        ECHO  "   LCC         Win32-LCC                    LCC-Win32 install path" ;
+        ECHO  ;
+        ECHO  "  - define the JAM_TOOLSET environment variable with the *name*" ;
+        ECHO  "    of the toolset variable you want to use." ;
+        ECHO  ;
+        ECHO  "  e.g.:  set VISUALC=C:\\Visual6" ;
+        ECHO  "         set JAM_TOOLSET=VISUALC" ;
+        EXIT  ;
+      }
+    }
+
+    CP          ?= copy ;
+    RM          ?= del /f/q ;
+    SLASH       ?= \\ ;
+    SUFLIB      ?= .lib ;
+    SUFOBJ      ?= .obj ;
+    SUFEXE      ?= .exe ;
+
+    if $(TOOLSET) = BORLANDC
+    {
+    ECHO "Compiler is Borland C++" ;
+
+    AR          ?= tlib /C /P64 ;
+    CC          ?= bcc32 ;
+    CCFLAGS     ?= -q -y -d -v -w-par -w-ccc -w-rch -w-pro -w-aus ;
+    C++         ?= bcc32 ;
+    C++FLAGS    ?= -q -y -d -v -w-par -w-ccc -w-rch -w-pro -w-aus -P ;
+    LINK        ?= $(CC) ;
+    LINKFLAGS   ?= $(CCFLAGS) ;
+    STDLIBPATH  ?= $(BORLANDC)\\lib ;
+    STDHDRS     ?= $(BORLANDC)\\include ;
+    NOARSCAN    ?= true ;
+    }
+    else if $(TOOLSET) = VISUALC16
+    {
+    ECHO "Compiler is Microsoft Visual C++ 16 bit" ;
+
+    AR          ?= lib /nologo ;
+    CC          ?= cl /nologo ;
+    CCFLAGS     ?= /D \"WIN\" ;
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    LINK        ?= $(CC) ;
+    LINKFLAGS   ?= $(CCFLAGS) ;
+    LINKLIBS    ?=
+                \"$(VISUALC16)\\lib\\mlibce.lib\"
+                \"$(VISUALC16)\\lib\\oldnames.lib\"
+                ;
+    LINKLIBS    ?= ;
+    NOARSCAN    ?= true ;
+    OPTIM       ?= "" ;
+    STDHDRS     ?= $(VISUALC16)\\include ;
+    UNDEFFLAG   ?= "/u _" ;
+    }
+    else if $(TOOLSET) = VISUALC
+    {
+    ECHO "Compiler is Microsoft Visual C++" ;
+
+    AR          ?= lib ;
+    AS          ?= masm386 ;
+    CC          ?= cl /nologo ;
+    CCFLAGS     ?= "" ;
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    LINK        ?= link /nologo ;
+    LINKFLAGS   ?= "" ;
+    LINKLIBS    ?= \"$(VISUALC)\\lib\\advapi32.lib\"
+                   # $(VISUALC)\\lib\\libc.lib
+                   # $(VISUALC)\\lib\\oldnames.lib
+                   \"$(VISUALC)\\lib\\gdi32.lib\"
+                   \"$(VISUALC)\\lib\\user32.lib\"
+                   \"$(VISUALC)\\lib\\kernel32.lib\" ;
+    OPTIM       ?= "" ;
+    STDHDRS     ?= $(VISUALC)\\include ;
+    UNDEFFLAG   ?= "/u _" ;
+    }
+    else if $(TOOLSET) = VC7
+    {
+    ECHO "Compiler is Microsoft Visual C++ .NET" ;
+
+    AR          ?= lib ;
+    AS          ?= masm386 ;
+    CC          ?= cl /nologo ;
+    CCFLAGS     ?= "" ;
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    LINK        ?= link /nologo ;
+    LINKFLAGS   ?= "" ;
+    LINKLIBS    ?= \"$(VISUALC)\\PlatformSDK\\lib\\advapi32.lib\"
+                   # $(VISUALC)\\lib\\libc.lib
+                   # $(VISUALC)\\lib\\oldnames.lib
+                   \"$(VISUALC)\\PlatformSDK\\lib\\gdi32.lib\"
+                   \"$(VISUALC)\\PlatformSDK\\lib\\user32.lib\"
+                   \"$(VISUALC)\\PlatformSDK\\lib\\kernel32.lib\" ;
+    OPTIM       ?= "" ;
+    STDHDRS     ?= \"$(VISUALC)\\include\"
+									 \"$(VISUALC)\\PlatformSDK\\include\" ;
+    UNDEFFLAG   ?= "/u _" ;
+    }
+    else if $(TOOLSET) = INTELC
+    {
+    ECHO "Compiler is Intel C/C++" ;
+
+        if ! $(VISUALC)
+        {
+          ECHO "As a special exception, when using the Intel C++ compiler, you need" ;
+          ECHO "to define the VISUALC environment variable to indicate the location" ;
+          ECHO "of your Visual C++ installation. Aborting.." ;
+          EXIT ;
+        }
+
+    AR          ?= lib ;
+    AS          ?= masm386 ;
+    CC          ?= icl /nologo ;
+    CCFLAGS     ?= "" ;
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    LINK        ?= link /nologo ;
+    LINKFLAGS   ?= "" ;
+    LINKLIBS    ?= $(VISUALC)\\lib\\advapi32.lib
+                   # $(VISUALC)\\lib\\libc.lib
+                   # $(VISUALC)\\lib\\oldnames.lib
+                   $(VISUALC)\\lib\\kernel32.lib
+                   ;
+    OPTIM       ?= "" ;
+    STDHDRS     ?= $(INTELC)\include $(VISUALC)\\include ;
+    UNDEFFLAG   ?= "/u _" ;
+    }
+    else if $(TOOLSET) = WATCOM
+    {
+        ECHO "Compiler is Watcom C/C++" ;
+
+    AR          ?= wlib ;
+    CC          ?= wcc386 ;
+    CCFLAGS     ?= /zq /DWIN32 /I$(WATCOM)\\h ; # zq=quiet
+    C++         ?= wpp386 ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    CP          ?= copy ;
+    DOT         ?= . ;
+    DOTDOT      ?= .. ;
+    LINK        ?= wcl386 ;
+    LINKFLAGS   ?= /zq ; # zq=quiet
+    LINKLIBS    ?= ;
+    MV          ?= move ;
+    NOARSCAN    ?= true ;
+    OPTIM       ?= ;
+    RM          ?= del /f ;
+    SLASH       ?= \\ ;
+    STDHDRS     ?= $(WATCOM)\\h $(WATCOM)\\h\\nt ;
+    SUFEXE      ?= .exe ;
+    SUFLIB      ?= .lib ;
+    SUFOBJ      ?= .obj ;
+    UNDEFFLAG   ?= "/u _" ;
+    }
+    else if $(TOOLSET) = MINGW
+    {
+        ECHO "Compiler is GCC with Mingw" ;
+
+        AR              ?= ar -ru ;
+        CC              ?= gcc ;
+        CCFLAGS         ?= "" ;
+        C++             ?= $(CC) ;
+        C++FLAGS        ?= $(CCFLAGS) ;
+        LINK            ?= $(CC) ;
+        LINKFLAGS       ?= "" ;
+        LINKLIBS        ?= "" ;
+        OPTIM           ?= ;
+        SUFOBJ           = .o ;
+        SUFLIB           = .a ;
+        SLASH            = / ;
+#       NOARSCAN        ?= true ;
+    }
+    else if $(TOOLSET) = LCC
+    {
+        ECHO "Compiler is Win32-LCC" ;
+
+        AR              ?= lcclib ;
+        CC              ?= lcc ;
+        CCFLAGS         ?= "" ;
+        C++             ?= $(CC) ;
+        C++FLAGS        ?= $(CCFLAGS) ;
+        LINK            ?= lcclnk ;
+        LINKFLAGS       ?= "" ;
+        LINKLIBS        ?= "" ;
+        OPTIM           ?= ;
+        NOARSCAN         = true ;
+    }
+    else
+    {
+#
+# XXX: We need better comments here !!
+#
+    EXIT On NT, set BCCROOT, MSVCNT, MINGW or MSVC to the root of the
+        Borland or Microsoft directories. ;
+    }
+
+}
+else if $(OS2)
+{
+    # the list of supported toolsets on Windows NT and Windows 95/98
+    #
+    local SUPPORTED_TOOLSETS = "EMX" "WATCOM" ;
+
+    # this variable holds the current toolset
+    #
+    TOOLSET = "" ;
+
+    # if the JAM_TOOLSET environment variable is defined, check that it is
+    # one of our supported values
+    #
+    if $(JAM_TOOLSET)
+    {
+      local t ;
+
+      for t in $(SUPPORTED_TOOLSETS)
+      {
+        $(t) = $($(t):J=" ") ; # reconstitute paths with spaces in them
+        if $(t) = $(JAM_TOOLSET) { TOOLSET = $(t) ; }
+      }
+
+      if ! $(TOOLSET)
+      {
+        ECHO  "The JAM_TOOLSET environment variable is defined but its value" ;
+        ECHO  "is invalid, please use one of the following:" ;
+        ECHO  ;
+
+        for t in $(SUPPORTED_TOOLSETS) { ECHO "  " $(t) ; }
+        EXIT ;
+      }
+    }
+
+    # if TOOLSET is empty, we'll try to detect the toolset from other
+    # environment variables to remain backwards compatible with Jam 2.3
+    #
+    if ! $(TOOLSET)
+    {
+      if $(watcom)
+      {
+        WATCOM   = $(watcom:J=" ") ;
+        TOOLSET  = WATCOM ;
+      }
+      else
+      {
+        ECHO  "Jam cannot be run because you didn't indicate which compilation toolset" ;
+        ECHO  "to use. To do so, follow these simple instructions:" ;
+        ECHO  ;
+        ECHO  "  - define one of the following environment variable, with the" ;
+        ECHO  "    appropriate value according to this list:" ;
+        ECHO  ;
+        ECHO  "   Variable    Toolset                      Description" ;
+        ECHO  ;
+        ECHO  "   WATCOM      Watcom C/C++                 Watcom install path" ;
+        ECHO  "   EMX         EMX (gcc)                    EMX install path" ;
+        ECHO  "   VISUALAGE   IBM Visual Age C/C++         VisualAge install path" ;
+        ECHO  ;
+        ECHO  "  - define the JAM_TOOLSET environment variable with the *name*" ;
+        ECHO  "    of the toolset variable you want to use." ;
+        ECHO  ;
+        ECHO  "  e.g.:  set WATCOM=C:\WATCOM" ;
+        ECHO  "         set JAM_TOOLSET=WATCOM" ;
+        ECHO  ;
+        EXIT  ;
+      }
+    }
+
+    RM       = del /f ;
+    CP       = copy ;
+    MV      ?= move ;
+    DOT     ?= . ;
+    DOTDOT  ?= .. ;
+    SUFLIB  ?= .lib ;
+    SUFOBJ  ?= .obj ;
+    SUFEXE  ?= .exe ;
+
+    if $(TOOLSET) = WATCOM
+    {
+       AR           ?= wlib ;
+       BINDIR       ?= \\os2\\apps ;
+       CC           ?= wcc386 ;
+       CCFLAGS      ?= /zq /DOS2 /I$(WATCOM)\\h ; # zq=quiet
+       C++          ?= wpp386 ;
+       C++FLAGS     ?= $(CCFLAGS) ;
+       LINK         ?= wcl386 ;
+       LINKFLAGS    ?= /zq ; # zq=quiet
+       LINKLIBS     ?= ;
+       NOARSCAN     ?= true ;
+       OPTIM        ?= ;
+       SLASH        ?= \\ ;
+       STDHDRS      ?= $(WATCOM)\\h ;
+       UNDEFFLAG    ?= "/u _" ;
+    }
+    else if $(TOOLSET) = EMX
+    {
+      ECHO "Compiler is GCC-EMX" ;
+      AR            ?= ar -ru ;
+      CC            ?= gcc ;
+      CCFLAGS       ?= "" ;
+      C++           ?= $(CC) ;
+      C++FLAGS      ?= $(CCFLAGS) ;
+      LINK          ?= $(CC) ;
+      LINKFLAGS     ?= "" ;
+      LINKLIBS      ?= "" ;
+      OPTIM         ?= ;
+      SUFOBJ         = .o ;
+      SUFLIB         = .a ;
+      UNDEFFLAG     ?= "-U" ;
+      SLASH          = / ;
+#     NOARSCAN      ?= true ;
+    }
+    else
+    {
+      # should never happen
+      EXIT  "Sorry, but the $(JAM_TOOLSET) toolset isn't supported for now" ;
+    }
+}
+else if $(VMS)
+{
+    C++         ?= cxx ;
+    C++FLAGS    ?= ;
+    CC          ?= cc ;
+    CCFLAGS     ?= ;
+    CHMOD       ?= set file/prot= ;
+    CP          ?= copy/replace ;
+    CRELIB      ?= true ;
+    DOT         ?= [] ;
+    DOTDOT      ?= [-] ;
+    EXEMODE     ?= (w:e) ;
+    FILEMODE    ?= (w:r) ;
+    HDRS        ?= ;
+    LINK        ?= link ;
+    LINKFLAGS   ?= "" ;
+    LINKLIBS    ?= ;
+    MKDIR       ?= create/dir ;
+    MV          ?= rename ;
+    OPTIM       ?= "" ;
+    RM          ?= delete ;
+    RUNVMS      ?= mcr ;
+    SHELLMODE   ?= (w:er) ;
+    SLASH       ?= . ;
+    STDHDRS     ?= decc$library_include ;
+    SUFEXE      ?= .exe ;
+    SUFLIB      ?= .olb ;
+    SUFOBJ      ?= .obj ;
+
+    switch $(OS)
+    {
+    case OPENVMS : CCFLAGS  ?= /stand=vaxc ;
+    case VMS     : LINKLIBS ?= sys$library:vaxcrtl.olb/lib ;
+    }
+}
+else if $(MAC)
+{
+    local OPT ;
+
+    CW  ?= "{CW}" ;
+
+    MACHDRS ?=
+        "$(UMACHDRS):Universal:Interfaces:CIncludes"
+        "$(CW):MSL:MSL_C:MSL_Common:Include"
+        "$(CW):MSL:MSL_C:MSL_MacOS:Include" ;
+
+    MACLIBS ?=
+        "$(CW):MacOS Support:Universal:Libraries:StubLibraries:Interfacelib"
+        "$(CW):MacOS Support:Universal:Libraries:StubLibraries:Mathlib" ;
+
+    MPWLIBS ?=
+        "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib"
+        "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC MPW.Lib" ;
+
+    MPWNLLIBS ?=
+        "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib"
+        "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC MPW(NL).Lib" ;
+
+    SIOUXHDRS ?= ;
+
+    SIOUXLIBS ?=
+        "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL RuntimePPC.lib"
+        "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL SIOUX.PPC.Lib"
+        "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC.Lib" ;
+
+    C++         ?= mwcppc ;
+    C++FLAGS    ?= -w off -nomapcr ;
+    CC          ?= mwcppc ;
+    CCFLAGS     ?= -w off -nomapcr ;
+    CP          ?= duplicate -y ;
+    DOT         ?= ":" ;
+    DOTDOT      ?= "::" ;
+    HDRS        ?= $(MACHDRS) $(MPWHDRS) ;
+    LINK        ?= mwlinkppc ;
+    LINKFLAGS   ?= -mpwtool -warn ;
+    LINKLIBS    ?= $(MACLIBS) $(MPWLIBS) ;
+    MKDIR       ?= newfolder ;
+    MV          ?= rename -y ;
+    NOARSCAN    ?= true ;
+    OPTIM       ?= ;
+    RM          ?= delete -y ;
+    SLASH       ?= ":" ;
+    STDHDRS     ?= ;
+    SUFLIB      ?= .lib ;
+    SUFOBJ      ?= .o ;
+}
+else if $(OS) = BEOS && $(METROWERKS)
+{
+    AR          ?= mwld -xml -o ;
+    BINDIR      ?= /boot/apps ;
+    CC          ?= mwcc ;
+    CCFLAGS     ?= -nosyspath ;
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= -nosyspath ;
+    FORTRAN     ?= "" ;
+    LIBDIR      ?= /boot/develop/libraries ;
+    LINK        ?= mwld ;
+    LINKFLAGS   ?= "" ;
+    MANDIR      ?= /boot/documentation/"Shell Tools"/HTML ;
+    NOARSCAN    ?= true ;
+    STDHDRS     ?= /boot/develop/headers/posix ;
+}
+else if $(OS) = BEOS
+{
+    BINDIR      ?= /boot/apps ;
+    CC          ?= gcc ;
+    C++         ?= $(CC) ;
+    FORTRAN     ?= "" ;
+    LIBDIR      ?= /boot/develop/libraries ;
+    LINK        ?= gcc ;
+    LINKLIBS    ?= -lnet ;
+    NOARSCAN    ?= true ;
+    STDHDRS     ?= /boot/develop/headers/posix ;
+}
+else if $(UNIX)
+{
+    switch $(OS)
+    {
+    case AIX :
+    LINKLIBS    ?= -lbsd ;
+
+    case AMIGA :
+    CC          ?= gcc ;
+    YACC        ?= "bison -y" ;
+
+    case CYGWIN :
+    CC          ?= gcc ;
+    CCFLAGS     += -D__cygwin__ ;
+    LEX         ?= flex ;
+    RANLIB      ?= "" ;
+    SUFEXE      ?= .exe ;
+    YACC        ?= "bison -y" ;
+
+    case DGUX :
+    RANLIB      ?= "" ;
+    RELOCATE    ?= true ;
+
+    case HPUX :
+    YACC        = ;
+    CFLAGS      += -Ae ;
+    CCFLAGS     += -Ae ;
+    RANLIB      ?= "" ;
+
+    case INTERIX :
+    CC          ?= gcc ;
+    RANLIB      ?= "" ;
+
+    case IRIX :
+    RANLIB      ?= "" ;
+
+    case MPEIX :
+    CC          ?= gcc ;
+    C++         ?= gcc ;
+    CCFLAGS     += -D_POSIX_SOURCE ;
+    HDRS        += /usr/include ;
+    RANLIB      ?= "" ;
+    NOARSCAN    ?= true ;
+    NOARUPDATE  ?= true ;
+
+    case MVS :
+    RANLIB      ?= "" ;
+
+    case NEXT :
+    AR          ?= libtool -o ;
+    RANLIB      ?= "" ;
+
+    case MACOSX :
+    AR          ?= libtool -o ;
+    C++         ?= c++ ;
+    MANDIR      ?= /usr/local/share/man ;
+    RANLIB      ?= "" ;
+
+    case NCR :
+    RANLIB      ?= "" ;
+
+    case PTX :
+    RANLIB      ?= "" ;
+
+    case QNX :
+    AR          ?= wlib ;
+    CC          ?= cc ;
+    CCFLAGS     ?= -Q ; # quiet
+    C++         ?= $(CC) ;
+    C++FLAGS    ?= -Q ; # quiet
+    LINK        ?= $(CC) ;
+    LINKFLAGS   ?= -Q ; # quiet
+    NOARSCAN    ?= true ;
+    RANLIB      ?= "" ;
+
+    case SCO :
+    RANLIB      ?= "" ;
+    RELOCATE    ?= true ;
+
+    case SINIX :
+    RANLIB      ?= "" ;
+
+    case SOLARIS :
+    RANLIB      ?= "" ;
+    AR          ?= "/usr/ccs/bin/ar ru" ;
+
+    case UNICOS :
+    NOARSCAN    ?= true ;
+    OPTIM       ?= -O0 ;
+
+    case UNIXWARE :
+    RANLIB      ?= "" ;
+    RELOCATE    ?= true ;
+    }
+
+    # UNIX defaults
+
+    CCFLAGS     ?= ;
+    C++FLAGS    ?= $(CCFLAGS) ;
+    CHMOD       ?= chmod ;
+    CHGRP       ?= chgrp ;
+    CHOWN       ?= chown ;
+    LEX         ?= lex ;
+    LINKFLAGS   ?= $(CCFLAGS) ;
+    LINKLIBS    ?= ;
+    OPTIM       ?= -O ;
+    RANLIB      ?= ranlib ;
+    YACC        ?= yacc ;
+    YACCFILES   ?= y.tab ;
+    YACCFLAGS   ?= -d ;
+}
+
+#
+# General defaults; a lot like UNIX
+#
+
+    AR          ?= ar ru ;
+    AS          ?= as ;
+    ASFLAGS     ?= ;
+    AWK         ?= awk ;
+    BINDIR      ?= /usr/local/bin ;
+    C++         ?= cc ;
+    C++FLAGS    ?= ;
+    CC          ?= cc ;
+    CCFLAGS     ?= ;
+    CP          ?= cp -f ;
+    CRELIB      ?= ;
+    DOT         ?= . ;
+    DOTDOT      ?= .. ;
+    EXEMODE     ?= 711 ;
+    FILEMODE    ?= 644 ;
+    FORTRAN     ?= f77 ;
+    FORTRANFLAGS ?= ;
+    HDRS        ?= ;
+    INSTALLGRIST ?= installed ;
+    JAMFILE     ?= Jamfile ;
+    JAMRULES    ?= Jamrules ;
+    LEX         ?= ;
+    LIBDIR      ?= /usr/local/lib ;
+    LINK        ?= $(CC) ;
+    LINKFLAGS   ?= ;
+    LINKLIBS    ?= ;
+    LN          ?= ln ;
+    MANDIR      ?= /usr/local/man ;
+    MKDIR       ?= mkdir ;
+    MV          ?= mv -f ;
+    OPTIM       ?= ;
+    RCP         ?= rcp ;
+    RM          ?= rm -f ;
+    RSH         ?= rsh ;
+    SED         ?= sed ;
+    SHELLHEADER ?= "#!/bin/sh" ;
+    SHELLMODE   ?= 755 ;
+    SLASH       ?= / ;
+    STDHDRS     ?= /usr/include ;
+    SUFEXE      ?= "" ;
+    SUFLIB      ?= .a ;
+    SUFOBJ      ?= .o ;
+    UNDEFFLAG   ?= "-u _" ;
+    YACC        ?= ;
+    YACCFILES   ?= ;
+    YACCFLAGS   ?= ;
+
+    HDRPATTERN =
+            "^[     ]*#[    ]*include[  ]*[<\"]([^\">]*)[\">].*$" ;
+
+    OSFULL = $(OS)$(OSVER)$(OSPLAT) $(OS)$(OSPLAT) $(OS)$(OSVER) $(OS) ;
+
+
+#
+# Base dependencies - first for "bootstrap" kinds of rules
+#
+
+DEPENDS all : shell files lib exe obj ;
+DEPENDS all shell files lib exe obj : first ;
+NOTFILE all first shell files lib exe obj dirs clean uninstall ;
+ALWAYS clean uninstall ;
+
+#
+# Rules
+#
+
+rule As
+{
+    DEPENDS $(<) : $(>) ;
+    ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;
+}
+
+rule Bulk
+{
+    local i ;
+
+    for i in $(>)
+    {
+        File $(i:D=$(<)) : $(i) ;
+    }
+}
+
+rule Cc
+{
+    local _h ;
+
+    DEPENDS $(<) : $(>) ;
+
+    # Just to clarify here: this sets the per-target CCFLAGS to
+    # be the current value of (global) CCFLAGS and SUBDIRCCFLAGS.
+
+    CCFLAGS on $(<) += $(CCFLAGS) $(SUBDIRCCFLAGS) ;
+
+    # If the compiler's -o flag doesn't work, relocate the .o
+
+    if $(RELOCATE)
+    {
+        CcMv $(<) : $(>) ;
+    }
+
+    _h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
+
+    if $(VMS) && $(_h)
+    {
+        SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
+    }
+    else if $(MAC) && $(_h)
+    {
+        local _i _j ;
+        _j = $(_h[1]) ;
+        for _i in $(_h[2-])
+        {
+            _j = $(_j),$(_i) ;
+        }
+        MACINC on $(<) = \"$(_j)\" ;
+    }
+}
+
+rule C++
+{
+    local _h ;
+
+    DEPENDS $(<) : $(>) ;
+    C++FLAGS on $(<) += $(C++FLAGS) $(SUBDIRC++FLAGS) ;
+
+    if $(RELOCATE)
+    {
+        CcMv $(<) : $(>) ;
+    }
+
+    _h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
+
+    if $(VMS) && $(_h)
+    {
+        SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
+    }
+    else if $(MAC) && $(_h)
+    {
+        local _i _j ;
+        _j = $(_h[1]) ;
+        for _i in $(_h[2-])
+        {
+            _j = $(_j),$(_i) ;
+        }
+        MACINC on $(<) = \"$(_j)\" ;
+    }
+}
+
+rule Chmod
+{
+    if $(CHMOD) { Chmod1 $(<) ; }
+}
+
+rule File
+{
+    DEPENDS files : $(<) ;
+    DEPENDS $(<) : $(>) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+    MODE on $(<) = $(FILEMODE) ;
+    Chmod $(<) ;
+}
+
+rule Fortran
+{
+    DEPENDS $(<) : $(>) ;
+}
+
+rule GenFile
+{
+    local _t = [ FGristSourceFiles $(<) ] ;
+    local _s = [ FAppendSuffix $(>[1]) : $(SUFEXE) ] ;
+    Depends $(_t) : $(_s) $(>[2-]) ;
+    GenFile1 $(_t) : $(_s) $(>[2-]) ;
+    Clean clean : $(_t) ;
+}
+
+rule GenFile1
+{
+    MakeLocate $(<) : $(LOCATE_SOURCE) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+}
+
+rule HardLink
+{
+    DEPENDS files : $(<) ;
+    DEPENDS $(<) : $(>) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+}
+
+rule HdrMacroFile
+{
+  # HdrMacroFile file ;
+  #
+  # this rule is used to indicate that a given file contains definitions
+  # for filename macros (e.g. "#define  MYFILE_H <myfile.h>") that can
+  # later be used in #include statements in the rest of the source
+  #
+  # theses files must be parsed before any make is tried..
+  #
+  HDRMACRO $(<) ;
+}
+
+rule HdrRule
+{
+    # HdrRule source : headers ;
+
+    # N.B.  This rule is called during binding, potentially after
+    # the fate of many targets has been determined, and must be
+    # used with caution: don't add dependencies to unrelated
+    # targets, and don't set variables on $(<).
+
+    # Tell Jam that anything depending on $(<) also depends on $(>),
+    # set SEARCH so Jam can find the headers, but then say we don't
+    # care if we can't actually find the headers (they may have been
+    # within ifdefs),
+
+    local s ;
+
+    if $(HDRGRIST)
+    {
+        s = $(>:G=$(HDRGRIST)) ;
+    } else {
+        s = $(>) ;
+    }
+
+    INCLUDES $(<) : $(s) ;
+    SEARCH on $(s) = $(HDRSEARCH) ;
+    NOCARE $(s) ;
+
+    # Propagate on $(<) to $(>)
+
+    HDRSEARCH on $(s) = $(HDRSEARCH) ;
+    HDRSCAN on $(s) = $(HDRSCAN) ;
+    HDRRULE on $(s) = $(HDRRULE) ;
+    HDRGRIST on $(s) = $(HDRGRIST) ;
+}
+
+rule InstallInto
+{
+    # InstallInto dir : sources ;
+
+    local i t ;
+
+    t = $(>:G=$(INSTALLGRIST)) ;
+
+    # Arrange for jam install
+    # Arrange for jam uninstall
+    # sources are in SEARCH_SOURCE
+    # targets are in dir
+
+    Depends install : $(t) ;
+    Clean uninstall : $(t) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+    MakeLocate $(t) : $(<) ;
+
+    # For each source, make gristed target name
+    # and Install, Chmod, Chown, and Chgrp
+
+    for i in $(>)
+    {
+        local tt = $(i:G=$(INSTALLGRIST)) ;
+
+        Depends $(tt) : $(i) ;
+        Install $(tt) : $(i) ;
+        Chmod $(tt) ;
+
+        if $(OWNER) && $(CHOWN)
+        {
+        Chown $(tt) ;
+        OWNER on $(tt) = $(OWNER) ;
+        }
+
+        if $(GROUP) && $(CHGRP)
+        {
+        Chgrp $(tt) ;
+        GROUP on $(tt) = $(GROUP) ;
+        }
+    }
+}
+
+rule InstallBin
+{
+    local _t = [ FAppendSuffix $(>) : $(SUFEXE) ] ;
+
+    InstallInto $(<) : $(_t) ;
+    MODE on $(_t:G=installed) = $(EXEMODE) ;
+}
+
+rule InstallFile
+{
+    InstallInto $(<) : $(>) ;
+    MODE on $(>:G=installed) = $(FILEMODE) ;
+}
+
+rule InstallLib
+{
+    InstallInto $(<) : $(>) ;
+    MODE on $(>:G=installed) = $(FILEMODE) ;
+}
+
+rule InstallMan
+{
+    # Really this just strips the . from the suffix
+
+    local i s d ;
+
+    for i in $(>)
+    {
+        switch $(i:S)
+        {
+        case .1 : s = 1 ; case .2 : s = 2 ; case .3 : s = 3 ;
+        case .4 : s = 4 ; case .5 : s = 5 ; case .6 : s = 6 ;
+        case .7 : s = 7 ; case .8 : s = 8 ; case .l : s = l ;
+        case .n : s = n ; case .man : s = 1 ;
+        }
+
+        d = man$(s) ;
+
+        InstallInto $(d:R=$(<)) : $(i) ;
+    }
+
+    MODE on $(>:G=installed) = $(FILEMODE) ;
+}
+
+rule InstallShell
+{
+    InstallInto $(<) : $(>) ;
+    MODE on $(>:G=installed) = $(SHELLMODE) ;
+}
+
+rule Lex
+{
+    LexMv $(<) : $(>) ;
+    DEPENDS $(<) : $(>) ;
+    MakeLocate $(<) : $(LOCATE_SOURCE) ;
+    Clean clean : $(<) ;
+}
+
+rule Library
+{
+    LibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
+    Objects $(>) ;
+}
+
+rule LibraryFromObjects
+{
+    local _i _l _s ;
+
+    # Add grist to file names
+
+    _s = [ FGristFiles $(>) ] ;
+    _l = $(<:S=$(SUFLIB)) ;
+
+    # library depends on its member objects
+
+    if $(KEEPOBJS)
+    {
+        DEPENDS obj : $(_s) ;
+    }
+    else
+    {
+        DEPENDS lib : $(_l) ;
+    }
+
+    # Set LOCATE for the library and its contents.  The bound
+    # value shows up as $(NEEDLIBS) on the Link actions.
+    # For compatibility, we only do this if the library doesn't
+    # already have a path.
+
+    if ! $(_l:D)
+    {
+        MakeLocate $(_l) $(_l)($(_s:BS)) : $(LOCATE_TARGET) ;
+    }
+
+    if $(NOARSCAN)
+    {
+        # If we can't scan the library to timestamp its contents,
+        # we have to just make the library depend directly on the
+        # on-disk object files.
+
+        DEPENDS $(_l) : $(_s) ;
+    }
+    else
+    {
+        # If we can scan the library, we make the library depend
+        # on its members and each member depend on the on-disk
+        # object file.
+
+        DEPENDS $(_l) : $(_l)($(_s:BS)) ;
+
+        for _i in $(_s)
+        {
+        DEPENDS $(_l)($(_i:BS)) : $(_i) ;
+        }
+    }
+
+    Clean clean : $(_l) ;
+
+    if $(CRELIB) { CreLib $(_l) : $(_s[1]) ; }
+
+    Archive $(_l) : $(_s) ;
+
+    if $(RANLIB) { Ranlib $(_l) ; }
+
+    # If we can't scan the library, we have to leave the .o's around.
+
+    if ! ( $(NOARSCAN) || $(KEEPOBJS) ) { RmTemps $(_l) : $(_s) ; }
+}
+
+rule Link
+{
+    MODE on $(<) = $(EXEMODE) ;
+    Chmod $(<) ;
+}
+
+rule LinkLibraries
+{
+    # make library dependencies of target
+    # set NEEDLIBS variable used by 'actions Main'
+
+    local _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
+
+    DEPENDS $(_t) : $(>:S=$(SUFLIB)) ;
+    NEEDLIBS on $(_t) += $(>:S=$(SUFLIB)) ;
+}
+
+rule Main
+{
+    MainFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
+    Objects $(>) ;
+}
+
+rule MainFromObjects
+{
+    local _s _t ;
+
+    # Add grist to file names
+    # Add suffix to exe
+
+    _s = [ FGristFiles $(>) ] ;
+    _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
+
+    if $(_t) != $(<)
+    {
+        DEPENDS $(<) : $(_t) ;
+        NOTFILE $(<) ;
+    }
+
+    # make compiled sources a dependency of target
+
+    DEPENDS exe : $(_t) ;
+    DEPENDS $(_t) : $(_s) ;
+    MakeLocate $(_t) : $(LOCATE_TARGET) ;
+
+    Clean clean : $(_t) ;
+
+    Link $(_t) : $(_s) ;
+}
+
+rule MakeLocate
+{
+    if $(>)
+    {
+        LOCATE on $(<) = $(>) ;
+        Depends $(<) : $(>[1]) ;
+        MkDir $(>[1]) ;
+    }
+}
+
+rule MkDir
+{
+    # If dir exists, don't update it
+    # Do this even for $(DOT).
+
+    NOUPDATE $(<) ;
+
+    if $(<) != $(DOT) && ! $($(<)-mkdir)
+    {
+        local s ;
+
+        # Cheesy gate to prevent multiple invocations on same dir
+        # MkDir1 has the actions
+        # Arrange for jam dirs
+
+        $(<)-mkdir = true ;
+        MkDir1 $(<) ;
+        Depends dirs : $(<) ;
+
+        # Recursively make parent directories.
+        # $(<:P) = $(<)'s parent, & we recurse until root
+
+        s = $(<:P) ;
+
+        if $(NT)
+        {
+            switch $(s)
+        {
+        case *:   : s = ;
+        case *:\\ : s = ;
+        }
+        }
+
+        if $(s) && $(s) != $(<)
+        {
+        Depends $(<) : $(s) ;
+        MkDir $(s) ;
+        }
+        else if $(s)
+        {
+            NOTFILE $(s) ;
+        }
+
+    }
+}
+
+rule Object
+{
+    local h ;
+
+    # locate object and search for source, if wanted
+
+    Clean clean : $(<) ;
+
+    MakeLocate $(<) : $(LOCATE_TARGET) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+
+    # Save HDRS for -I$(HDRS) on compile.
+    # We shouldn't need -I$(SEARCH_SOURCE) as cc can find headers
+    # in the .c file's directory, but generated .c files (from
+    # yacc, lex, etc) are located in $(LOCATE_TARGET), possibly
+    # different from $(SEARCH_SOURCE).
+
+    HDRS on $(<) = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
+
+    # handle #includes for source: Jam scans for headers with
+    # the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
+    # with the scanned file as the target and the found headers
+    # as the sources.  HDRSEARCH is the value of SEARCH used for
+    # the found header files.  Finally, if jam must deal with
+    # header files of the same name in different directories,
+    # they can be distinguished with HDRGRIST.
+
+    # $(h) is where cc first looks for #include "foo.h" files.
+    # If the source file is in a distant directory, look there.
+    # Else, look in "" (the current directory).
+
+    if $(SEARCH_SOURCE)
+    {
+        h = $(SEARCH_SOURCE) ;
+    }
+    else
+    {
+        h = "" ;
+    }
+
+    HDRRULE on $(>) = HdrRule ;
+    HDRSCAN on $(>) = $(HDRPATTERN) ;
+    HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(h) $(STDHDRS) ;
+    HDRGRIST on $(>) = $(HDRGRIST) ;
+
+    # if source is not .c, generate .c with specific rule
+
+    switch $(>:S)
+    {
+        case .asm : As $(<) : $(>) ;
+        case .c :   Cc $(<) : $(>) ;
+        case .C :   C++ $(<) : $(>) ;
+        case .cc :  C++ $(<) : $(>) ;
+        case .cpp : C++ $(<) : $(>) ;
+        case .f :   Fortran $(<) : $(>) ;
+        case .l :   Cc $(<) : $(<:S=.c) ;
+                    Lex $(<:S=.c) : $(>) ;
+        case .s :   As $(<) : $(>) ;
+        case .y :   Cc $(<) : $(<:S=.c) ;
+                    Yacc $(<:S=.c) : $(>) ;
+        case * :    UserObject $(<) : $(>) ;
+    }
+}
+
+
+rule ObjectCcFlags
+{
+    CCFLAGS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
+}
+
+rule ObjectC++Flags
+{
+    C++FLAGS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
+}
+
+rule ObjectHdrs
+{
+    HDRS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
+}
+
+rule Objects
+{
+    local _i ;
+
+    for _i in [ FGristFiles $(<) ]
+    {
+        Object $(_i:S=$(SUFOBJ)) : $(_i) ;
+        DEPENDS obj : $(_i:S=$(SUFOBJ)) ;
+    }
+}
+
+rule RmTemps
+{
+    TEMPORARY $(>) ;
+}
+
+rule Setuid
+{
+    MODE on [ FAppendSuffix $(<) : $(SUFEXE) ] = 4711 ;
+}
+
+rule Shell
+{
+    DEPENDS shell : $(<) ;
+    DEPENDS $(<) : $(>) ;
+    SEARCH on $(>) = $(SEARCH_SOURCE) ;
+    MODE on $(<) = $(SHELLMODE) ;
+    Clean clean : $(<) ;
+    Chmod $(<) ;
+}
+
+rule SubDir
+{
+    local _r _s ;
+
+    #
+    # SubDir TOP d1 [ ... ]
+    #
+    # This introduces a Jamfile that is part of a project tree
+    # rooted at $(TOP).  It (only once) includes the project-specific
+    # rules file $(TOP)/Jamrules and then sets search & locate stuff.
+    #
+    # If the variable $(TOPRULES) is set (where TOP is the first arg
+    # to SubDir), that file is included instead of $(TOP)/Jamrules.
+    #
+    # d1 ... are the directory elements that lead to this directory
+    # from $(TOP).  We construct the system dependent path from these
+    # directory elements in order to set search & locate stuff.
+    #
+
+    if ! $($(<[1]))
+    {
+        if ! $(<[1])
+        {
+            EXIT SubDir syntax error ;
+        }
+
+        $(<[1]) = [ FSubDir $(<[2-]) ] ;
+    }
+
+    #
+    # If $(TOP)/Jamrules hasn't been included, do so.
+    #
+
+    if ! $($(<[1])-included)
+    {
+        # Gated entry.
+
+        $(<[1])-included = TRUE ;
+
+        # File is $(TOPRULES) or $(TOP)/Jamrules.
+
+        _r = $($(<[1])RULES) ;
+
+        if ! $(_r)
+        {
+        _r = $(JAMRULES:R=$($(<[1]))) ;
+        }
+
+        # Include it.
+
+        include $(_r) ;
+    }
+
+    # Get path to current directory from root using SubDir.
+    # Save dir tokens for other potential uses.
+
+    _s = [ FDirName $(<[2-]) ] ;
+    SUBDIR = $(_s:R=$($(<[1]))) ;
+        SUBDIR_TOKENS = $(<[2-]) ;
+
+    # Now set up SEARCH_SOURCE, LOCATE_TARGET, SOURCE_GRIST
+    # These can be reset if needed.  For example, if the source
+    # directory should not hold object files, LOCATE_TARGET can
+    # subsequently be redefined.
+
+    SEARCH_SOURCE = $(SUBDIR) ;
+    LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
+    LOCATE_TARGET = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
+    SOURCE_GRIST = [ FGrist $(<[2-]) ] ;
+
+    # Reset per-directory ccflags, hdrs
+
+    SUBDIRCCFLAGS = ;
+    SUBDIRC++FLAGS = ;
+    SUBDIRHDRS = ;
+}
+
+rule SubDirCcFlags
+{
+    SUBDIRCCFLAGS += $(<) ;
+}
+
+rule SubDirC++Flags
+{
+    SUBDIRC++FLAGS += $(<) ;
+}
+
+rule SubDirHdrs
+{
+    SUBDIRHDRS += $(<) ;
+}
+
+rule SubInclude
+{
+    local _s ;
+
+    # That's
+    #   SubInclude TOP d1 [ d2 [ d3 [ d4 ] ] ]
+    #
+    # to include a subdirectory's Jamfile.
+
+    if ! $($(<[1]))
+    {
+        EXIT Top level of source tree has not been set with $(<[1]) ;
+    }
+
+    _s = [ FDirName $(<[2-]) ] ;
+
+    include $(JAMFILE:D=$(_s):R=$($(<[1]))) ;
+}
+
+rule Undefines
+{
+    UNDEFS on [ FAppendSuffix $(<) : $(SUFEXE) ] += $(UNDEFFLAG)$(>) ;
+}
+
+rule UserObject
+{
+    EXIT "Unknown suffix on" $(>) "- see UserObject rule in Jamfile(5)." ;
+}
+
+rule Yacc
+{
+    local _h ;
+
+    _h = $(<:BS=.h) ;
+
+    # Some places don't have a yacc.
+
+    MakeLocate $(<) $(_h) : $(LOCATE_SOURCE) ;
+
+    if $(YACC)
+    {
+        DEPENDS $(<) $(_h) : $(>) ;
+        Yacc1 $(<) $(_h) : $(>) ;
+        YaccMv $(<) $(_h) : $(>) ;
+        Clean clean : $(<) $(_h) ;
+    }
+
+    # Make sure someone includes $(_h) else it will be a deadly independent
+    # target.
+    INCLUDES $(<) : $(_h) ;
+}
+
+#
+# Utility rules; no side effects on these.
+#
+
+rule FGrist
+{
+    # Turn individual elements in $(<) into grist.
+
+    local _g _i ;
+
+    _g = $(<[1]) ;
+
+    for _i in $(<[2-])
+    {
+        _g = $(_g)!$(_i) ;
+    }
+
+    return $(_g) ;
+}
+
+rule FGristFiles
+{
+    if ! $(SOURCE_GRIST)
+    {
+        return $(<) ;
+    }
+    else
+    {
+        return $(<:G=$(SOURCE_GRIST)) ;
+    }
+}
+
+rule FGristSourceFiles
+{
+    # Produce source file name name with grist in it,
+    # if SOURCE_GRIST is set.
+
+    # Leave header files alone, because they have a global
+    # visibility.
+
+    if ! $(SOURCE_GRIST)
+    {
+        return $(<) ;
+    }
+    else
+    {
+        local _i _o ;
+
+        for _i in $(<)
+        {
+        switch $(_i)
+        {
+        case *.h :  _o += $(_i) ;
+        case * :    _o += $(_i:G=$(SOURCE_GRIST)) ;
+        }
+        }
+
+        return $(_o) ;
+    }
+}
+
+rule FConcat
+{
+    # Puts the variables together, removing spaces.
+
+    local _t _r ;
+
+    $(_r) = $(<[1]) ;
+
+    for _t in $(<[2-])
+    {
+        $(_r) = $(_r)$(_t) ;
+    }
+
+    return $(_r) ;
+}
+
+rule FSubDir
+{
+    local _i _d ;
+
+    # If $(>) is the path to the current directory, compute the
+    # path (using ../../ etc) back to that root directory.
+    # Sets result in $(<)
+
+    if ! $(<[1])
+    {
+        _d = $(DOT) ;
+    }
+    else
+    {
+        _d = $(DOTDOT) ;
+
+        for _i in $(<[2-])
+        {
+        _d = $(_d:R=$(DOTDOT)) ;
+        }
+    }
+
+    return $(_d) ;
+}
+
+rule FDirName
+{
+    local _s _i ;
+
+    # Turn individual elements in $(<) into a usable path.
+
+    if ! $(<)
+    {
+        _s = $(DOT) ;
+    }
+    else if $(VMS)
+    {
+        # This handles the following cases:
+        #   a -> [.a]
+        #   a b c -> [.a.b.c]
+        #   x: -> x:
+        #   x: a -> x:[a]
+        #   x:[a] b -> x:[a.b]
+
+        switch $(<[1])
+        {
+        case *:* : _s = $(<[1]) ;
+        case \\[*\\] : _s = $(<[1]) ;
+        case * : _s = [.$(<[1])] ;
+        }
+
+        for _i in [.$(<[2-])]
+        {
+        _s = $(_i:R=$(_s)) ;
+        }
+    }
+    else if $(MAC)
+    {
+        _s = $(DOT) ;
+
+        for _i in $(<)
+        {
+            _s = $(_i:R=$(_s)) ;
+        }
+    }
+    else
+    {
+        _s = $(<[1]) ;
+
+        for _i in $(<[2-])
+        {
+        _s = $(_i:R=$(_s)) ;
+        }
+    }
+
+    return $(_s) ;
+}
+
+
+rule _makeCommon
+{
+    # strip common initial elements
+
+    if $($(<)[1]) && $($(<)[1]) = $($(>)[1])
+    {
+        $(<) = $($(<)[2-]) ;
+        $(>) = $($(>)[2-]) ;
+        _makeCommon $(<) : $(>) ;
+    }
+}
+
+
+rule FRelPath
+{
+    local _l _r ;
+
+    # first strip off common parts
+
+    _l = $(<) ;
+    _r = $(>) ;
+
+    _makeCommon _l : _r ;
+
+    # now make path to root and path down
+
+    _l = [ FSubDir $(_l) ] ;
+    _r = [ FDirName $(_r) ] ;
+
+    # Concatenate and save
+
+    # XXX This should be better
+
+    if $(_r) = $(DOT) {
+        return $(_l) ;
+    } else {
+        return $(_r:R=$(_l)) ;
+    }
+}
+
+rule FAppendSuffix
+{
+       # E.g., "FAppendSuffix yacc lex foo.bat : $(SUFEXE) ;"
+       # returns (yacc,lex,foo.bat) on Unix and
+       # (yacc.exe,lex.exe,foo.bat) on NT.
+
+    if $(>)
+    {
+        local _i _o ;
+
+        for _i in $(<)
+        {
+        if $(_i:S)
+        {
+            _o += $(_i) ;
+        }
+        else
+        {
+            _o += $(_i:S=$(>)) ;
+        }
+        }
+        return $(_o) ;
+    }
+    else
+    {
+        return $(<) ;
+    }
+}
+
+rule unmakeDir
+{
+    if $(>[1]:D) && $(>[1]:D) != $(>[1]) && $(>[1]:D) != \\\\
+    {
+        unmakeDir $(<) : $(>[1]:D) $(>[1]:BS) $(>[2-]) ;
+    }
+    else
+    {
+        $(<) = $(>) ;
+    }
+}
+
+
+rule FConvertToSlashes
+{
+  local _d, _s, _i ;
+
+  unmakeDir _d : $(<) ;
+
+  _s = $(_d[1]) ;
+  for _i in $(_d[2-])
+  {
+    _s = $(_s)/$(_i) ;
+  }
+  return $(_s) ;
+}
+
+
+#
+# Actions
+#
+
+#
+# First the defaults
+#
+
+actions updated together piecemeal Archive
+{
+    $(AR) $(<) $(>)
+}
+
+actions As
+{
+    $(AS) $(ASFLAGS) -I$(HDRS) -o $(<) $(>)
+}
+
+actions C++
+{
+    $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
+}
+
+actions Cc
+{
+    $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
+}
+
+actions Chgrp
+{
+    $(CHGRP) $(GROUP) $(<)
+}
+
+actions Chmod1
+{
+    $(CHMOD) $(MODE) $(<)
+}
+
+actions Chown
+{
+    $(CHOWN) $(OWNER) $(<)
+}
+
+actions piecemeal together existing Clean
+{
+    $(RM) $(>)
+}
+
+actions File
+{
+    $(CP) $(>) $(<)
+}
+
+actions GenFile1
+{
+    $(>[1]) $(<) $(>[2-])
+}
+
+actions Fortran
+{
+    $(FORTRAN) $(FORTRANFLAGS) -o $(<) $(>)
+}
+
+actions HardLink
+{
+    $(RM) $(<) && $(LN) $(>) $(<)
+}
+
+actions Install
+{
+    $(CP) $(>) $(<)
+}
+
+actions Lex
+{
+    $(LEX) $(>)
+}
+
+actions LexMv
+{
+    $(MV) lex.yy.c $(<)
+}
+
+actions Link bind NEEDLIBS
+{
+    $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+}
+
+actions MkDir1
+{
+    $(MKDIR) $(<)
+}
+
+actions together Ranlib
+{
+    $(RANLIB) $(<)
+}
+
+actions quietly updated piecemeal together RmTemps
+{
+    $(RM) $(>)
+}
+
+actions Shell
+{
+    $(AWK) '
+        NR == 1 { print "$(SHELLHEADER)" }
+        NR == 1 && /^[#:]/ { next }
+        /^##/ { next }
+        { print }
+    ' < $(>) > $(<)
+}
+
+actions Yacc1
+{
+    $(YACC) $(YACCFLAGS) $(>)
+}
+
+actions YaccMv
+{
+    $(MV) $(YACCFILES).c $(<[1])
+    $(MV) $(YACCFILES).h $(<[2])
+}
+
+#
+# RELOCATE - for compilers with broken -o flags
+#
+
+if $(RELOCATE)
+{
+    actions C++
+    {
+    $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) $(>)
+    }
+
+    actions Cc
+    {
+    $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) $(>)
+    }
+
+    actions ignore CcMv
+    {
+    [ $(<) != $(>:BS=$(SUFOBJ)) ] && $(MV) $(>:BS=$(SUFOBJ)) $(<)
+    }
+}
+
+#
+# NOARUPDATE - can't update an archive
+#
+
+if $(NOARUPDATE)
+{
+    actions Archive
+    {
+    $(AR) $(<) $(>)
+    }
+}
+
+#
+# NT specific actions
+#
+
+if $(NT)
+{
+  if $(TOOLSET) = VISUALC || $(TOOLSET) = VC7 || $(TOOLSET) = INTELC
+  {
+    actions updated together piecemeal Archive
+    {
+    if exist $(<) set _$(<:B)_=$(<)
+    $(AR) /out:$(<) %_$(<:B)_% $(>)
+    }
+
+    actions As
+    {
+    $(AS) /Ml /p /v /w2 $(>) $(<) ,nul,nul;
+    }
+
+    actions Cc
+    {
+    $(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) /Tp$(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+    }
+  }
+  else if $(TOOLSET) = VISUALC16
+  {
+    actions updated together piecemeal Archive
+    {
+    $(AR) $(<) -+$(>)
+    }
+
+    actions Cc
+    {
+    $(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /Tp$(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+    }
+  }
+  else if $(TOOLSET) = BORLANDC
+  {
+    actions updated together piecemeal Archive
+    {
+    $(AR) $(<) -+$(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) -e$(<) $(LINKFLAGS) $(UNDEFS) -L$(LINKLIBS) $(NEEDLIBS) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+
+    actions Cc
+    {
+    $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+
+  }
+  else if $(TOOLSET) = MINGW
+  {
+    actions together piecemeal Archive
+    {
+      $(AR) $(<) $(>:T)
+    }
+
+    actions Cc
+    {
+    $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+  }
+  else if $(TOOLSET) = WATCOM
+  {
+    actions together piecemeal Archive
+    {
+    $(AR) $(<) +-$(>)
+    }
+
+    actions Cc
+    {
+    $(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+    }
+
+    actions Shell
+    {
+    $(CP) $(>) $(<)
+    }
+  }
+  else if $(TOOLSET) = LCC
+  {
+    actions together piecemeal Archive
+    {
+    $(AR) /out:$(<) $(>)
+    }
+
+    actions Cc
+    {
+    $(CC) $(CCFLAGS) $(OPTIM) -Fo$(<) -I$(HDRS) $(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+    }
+
+    actions Shell
+    {
+    $(CP) $(>) $(<)
+    }
+  }
+}
+
+#
+# OS2 specific actions
+#
+
+else if $(OS2)
+{
+  if $(TOOLSET) = WATCOM
+  {
+    actions together piecemeal Archive
+    {
+    $(AR) $(<) +-$(>)
+    }
+
+    actions Cc
+    {
+    $(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
+    }
+
+    actions Shell
+    {
+    $(CP) $(>) $(<)
+    }
+  }
+  else if $(TOOLSET) = EMX
+  {
+    actions together piecemeal Archive
+    {
+      $(AR) $(<) $(>:T)
+    }
+
+    actions Cc
+    {
+    $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+
+    actions C++
+    {
+    $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
+    }
+  }
+}
+
+#
+# VMS specific actions
+#
+
+else if $(VMS)
+{
+    actions updated together piecemeal Archive
+    {
+    lib/replace $(<) $(>[1]) ,$(>[2-])
+    }
+
+    actions Cc
+    {
+    $(CC)/obj=$(<) $(CCFLAGS) $(OPTIM) $(SLASHINC) $(>)
+    }
+
+    actions C++
+    {
+    $(C++)/obj=$(<) $(C++FLAGS) $(OPTIM) $(SLASHINC) $(>)
+    }
+
+    actions piecemeal together existing Clean
+    {
+    $(RM) $(>[1]);* ,$(>[2-]);*
+    }
+
+    actions together quietly CreLib
+    {
+    if f$search("$(<)") .eqs. "" then lib/create $(<)
+    }
+
+    actions GenFile1
+    {
+    mcr $(>[1]) $(<) $(>[2-])
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK)/exe=$(<) $(LINKFLAGS) $(>[1]) ,$(>[2-]) ,$(NEEDLIBS)/lib ,$(LINKLIBS)
+    }
+
+    actions quietly updated piecemeal together RmTemps
+    {
+    $(RM) $(>[1]);* ,$(>[2-]);*
+    }
+
+    actions Shell
+    {
+    $(CP) $(>) $(<)
+    }
+}
+
+#
+# Mac specifc actions
+#
+
+else if $(MAC)
+{
+    actions together Archive
+    {
+    $(LINK) -library -o $(<) $(>)
+    }
+
+    actions Cc
+    {
+    set -e MWCincludes $(MACINC)
+    $(CC) -o $(<) $(CCFLAGS) $(OPTIM) $(>)
+    }
+
+    actions C++
+    {
+    set -e MWCincludes $(MACINC)
+    $(CC) -o $(<) $(C++FLAGS) $(OPTIM) $(>)
+    }
+
+    actions Link bind NEEDLIBS
+    {
+    $(LINK) -o $(<) $(LINKFLAGS) $(>) $(NEEDLIBS) "$(LINKLIBS)"
+    }
+}
+
+#
+# Backwards compatibility with jam 1, where rules were uppercased.
+#
+
+rule BULK { Bulk $(<) : $(>) ; }
+rule FILE { File $(<) : $(>) ; }
+rule HDRRULE { HdrRule $(<) : $(>) ; }
+rule INSTALL { Install $(<) : $(>) ; }
+rule LIBRARY { Library $(<) : $(>) ; }
+rule LIBS { LinkLibraries $(<) : $(>) ; }
+rule LINK { Link $(<) : $(>) ; }
+rule MAIN { Main $(<) : $(>) ; }
+rule SETUID { Setuid $(<) ; }
+rule SHELL { Shell $(<) : $(>) ; }
+rule UNDEFINES { Undefines $(<) : $(>) ; }
+
+# Old INSTALL* didn't take dest directory.
+
+rule INSTALLBIN { InstallBin $(BINDIR) : $(<) ; }
+rule INSTALLLIB { InstallLib $(LIBDIR) : $(<) ; }
+rule INSTALLMAN { InstallMan $(MANDIR) : $(<) ; }
+
+# Compatibility with jam 2.2.
+
+rule addDirName { $(<) += [ FDirName $(>) ] ; }
+rule makeDirName { $(<) = [ FDirName $(>) ] ; }
+rule makeGristedName { $(<) = [ FGristSourceFiles $(>) ] ; }
+rule makeRelPath { $(<[1]) = [ FRelPath $(<[2-]) : $(>) ] ; }
+rule makeSuffixed { $(<[1]) = [ FAppendSuffix $(>) : $(<[2]) ] ; }
+
+#
+# Now include the user's Jamfile.
+#
+
+{
+    if $(JAMFILE) { include $(JAMFILE) ; }
+}
+
+}