no message

[SVN r10265]

build/Jamfile

@@ -1,8 +0,0 @@
-SubDir TOP ;
-
-exe foo : foo.cpp : <include>z:/boost ;
-lib top : top.cpp ;
-
-SubInclude TOP x ;
-SubInclude TOP y ;
-

build/allyourbase.jam

@@ -1,1643 +0,0 @@
-#
-# /+\
-# +\    Copyright 1993, 2000 Christopher Seiwald.
-# \+/
-#
-# This file is part of Jam - see jam.c for Copyright information.
-#
-
-#
-# 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 dependent 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
-# join 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)
-#       NCARE - 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)
-{
-    CP              ?= copy ;
-    RM              ?= del /f/q ;
-    SLASH           ?= \\ ;
-    SUFLIB          ?= .lib ;
-    SUFOBJ          ?= .obj ;
-    SUFEXE          ?= .exe ;
-    NOARSCAN        ?= true ;
-
-    LEX = flex -d ;
-    YACC = bison -t -d -l -v ;
-    YACCFILES       = y.tab ;
-    YACC_OUTPUT     = --output= ;
-    LEX_OUTPUT     = -o ;
-    # YACC_FIX_LINES = sed '/simple/d ; # fix up #line directives for metrowerks
-}
-else if $(OS2)
-{
-    WATCOM          ?= $(watcom) ;
-
-    if ! $(WATCOM)
-    {
-        EXIT On OS2, set WATCOM to the root of the Watcom directory. ;
-    }
-
-    AR              ?= wlib ;
-    BINDIR          ?= \\os2\\apps ;
-    CP              ?= copy ;
-    DOT             ?= . ;
-    DOTDOT          ?= .. ;
-    MV              ?= move ;
-    NOARSCAN        ?= true ;
-    OPTIM           ?= ;
-    RM              ?= del /f ;
-    SLASH           ?= \\ ;
-    STDHDRS         ?= $(WATCOM)\\h ;
-    SUFEXE          ?= .exe ;
-    SUFLIB          ?= .lib ;
-    SUFOBJ          ?= .obj ;
-    UNDEFFLAG       ?= "/u _" ;
-
-}
-else if $(VMS)
-{
-    CHMOD           ?= set file/prot= ;
-    CP              ?= copy/replace ;
-    CRELIB          ?= true ;
-    DOT             ?= [] ;
-    DOTDOT          ?= [-] ;
-    EXEMODE         ?= (w:e) ;
-    FILEMODE        ?= (w:r) ;
-    HDRS            ?= ;
-    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 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" ;
-
-    CP              ?= duplicate -y ;
-    DOT             ?= ":" ;
-    DOTDOT          ?= "::" ;
-    HDRS            ?= $(MACHDRS) $(MPWHDRS) ;
-    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 ;
-    FORTRAN         ?= "" ;
-    LIBDIR          ?= /boot/develop/libraries ;
-    MANDIR          ?= /boot/documentation/"Shell Tools"/HTML ;
-    NOARSCAN        ?= true ;
-    STDHDRS         ?= /boot/develop/headers/posix ;
-}
-else if $(OS) = BEOS 
-{
-    BINDIR          ?= /boot/apps ;
-    FORTRAN         ?= "" ;
-    LIBDIR          ?= /boot/develop/libraries ;
-    NOARSCAN        ?= true ;
-    STDHDRS         ?= /boot/develop/headers/posix ;
-}
-else if $(UNIX)
-{
-    switch $(OS)
-    {
-    case AIX :
-
-    case AMIGA :
-        YACC            ?= bison ;
-
-    case CYGWIN :       
-        LEX             ?= flex ;
-        JAMSHELL        ?= sh -c ;
-        RANLIB          ?= "" ;
-        SUFEXE          ?= .exe ;
-        YACC            ?= bison ;
-
-    case DGUX :
-        RANLIB          ?= "" ;
-        RELOCATE        ?= true ;
-
-    case HPUX :
-        RANLIB          ?= "" ;
-
-    case INTERIX :
-        JAMSHELL        ?= sh -c ;
-        RANLIB          ?= "" ;
-
-    case IRIX :
-        RANLIB          ?= "" ;
-
-    case MPEIX :
-        HDRS            += /usr/include ;
-        RANLIB          ?= "" ; 
-        NOARSCAN        ?= true ;
-        NOARUPDATE      ?= true ;
-
-    case MVS :
-        RANLIB          ?= "" ; 
-
-    case NEXT :
-        AR              ?= libtool -o ;
-        RANLIB          ?= "" ;
-
-    case MACOSX :
-        AR              ?= libtool -o ;
-        MANDIR          ?= /usr/local/share/man ;
-        RANLIB          ?= "" ;
-
-    case NCR :
-        RANLIB          ?= "" ;
-
-    case PTX :
-        RANLIB          ?= "" ;
-
-    case QNX :
-        AR              ?= wlib ;
-        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
-    CHMOD           ?= chmod ;
-    LEX             ?= lex ;
-    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 ;
-CP              ?= cp -f ;
-CRELIB          ?= ;
-DOT             ?= . ;
-DOTDOT          ?= .. ;
-EXEMODE         ?= 711 ;
-FILEMODE        ?= 644 ;
-FORTRAN         ?= f77 ;
-FORTRANFLAGS    ?= ;
-HDRS            ?= ;
-JAMFILE         ?= Jamfile ;
-JAMRULES        ?= Jamrules ;
-LEX             ?= ;
-LIBDIR          ?= /usr/local/lib ;
-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[      ]*[<\"]([^\">]*)[\">].*$" ;
-
-#"# the quote makes emacs' perl-mode (which I'm using to edit Jamfiles) happy.
-
-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 type-DEPENDS # type : targets...
-{
-    if ! $(gIN_LIB_INCLUDE)
-    {
-        DEPENDS $(<) : $(>) ;
-    }
-}
-
-rule Archive
-{
-    Archive-action $(<) : $(>) ;
-}
-
-rule As
-{
-        DEPENDS $(<) : $(>) ;
-        ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;
-}
-
-rule Bulk
-{
-        local i ;
-
-        for i in $(>)
-        {
-            File $(i:D=$(<)) : $(i) ;
-        }
-}
-
-# factored out stuff from the builtin Cc and C++ rules
-rule Cc-platform-specifics
-{
-    # If the compiler's -o flag doesn't work, relocate the .o
-
-    if $(RELOCATE)
-    {
-        CcMv $(<) : $(>) ;
-    }
-
-    local _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 always-c++
-{
-    <always-c++> += [ FGristFiles $(<) ] ;
-}
-
-rule Cc
-{
-    DEPENDS $(<) : $(>) ;
-
-    Cc-platform-specifics $(<) : $(>) ;
-
-    if $(>) in $(<always-c++>)
-    {
-        C++-action $(<) : $(>) ;
-    }
-    else
-    {
-        Cc-action $(<) : $(>) ;
-    }
-}
-
-rule C++
-{
-    DEPENDS $(<) : $(>) ;
-
-    Cc-platform-specifics $(<) : $(>) ;
-    
-    C++-action $(<) : $(>) ;
-}
-
-rule Chmod
-{
-    if $(CHMOD) { Chmod1 $(<) ; }
-}
-
-# conditional <cond> : <true-value> : <false-value>
-# returns <true-value> if <cond>, <false-value> otherwise
-rule conditional
-{
-    if $(1) { return $(2) ; } else { return $(3) ; }
-}
-
-rule File
-{
-    type-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
-{
-    type-DEPENDS files : $(<) ;
-    DEPENDS $(<) : $(>) ;
-    SEARCH on $(>) = $(SEARCH_SOURCE) ;
-}
-
-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
-{
-    local i t ;
-
-    t = $(>:G=installed) ;
-
-    type-DEPENDS install : $(t) ;
-    DEPENDS $(t) : $(>) ;
-    SEARCH on $(>) = $(SEARCH_SOURCE) ;
-    MakeLocate $(t) : $(<) ;
-
-    # Arrange for jam uninstall
-
-    Clean uninstall : $(t) ;
-
-    for i in $(>)
-    {
-        Install $(i:G=installed) : $(i) ;
-    }
-
-    Chmod $(t) ;
-
-    if $(UNIX)
-    {
-        if $(OWNER) { Chown $(t) ; OWNER on $(t) = $(OWNER) ; }
-        if $(GROUP) { Chgrp $(t) ; GROUP on $(t) = $(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 # file.c : file.l
-{
-    # If we don't have a way of specifying the lex output file, we'll have to move it
-    # We'd rather not do this if possible because: a. lex generates #line
-    # directives for the output file which would refer to the wrong place and
-    # b. the Jam invocation directory could be read-only
-    if ! $(LEX_OUTPUT)
-    {
-        LexMv $(<) : $(>) ;
-    }
-    
-    DEPENDS $(<) : $(>) ;
-    MakeLocate $(<) : $(LOCATE_SOURCE) ;
-    SEARCH on $(<) = $(LOCATE_SOURCE) ;
-    Clean clean : $(<) ;
-}
-
-rule Library
-{
-    LibraryFromObjects $(<) : [ Objects $(>) ] ;
-}
-
-rule LibraryFromObjects
-{
-    local _i _l ;
-
-    _l = $(<:S=$(SUFLIB)) ;
-
-    # library depends on its member objects
-
-    if $(KEEPOBJS)
-    {
-        type-DEPENDS obj : $(>) ;
-    }
-    else
-    {
-        type-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)($(>: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) : $(>) ;
-    }
-    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)($(>:BS)) ;
-
-        for _i in $(>)
-        {
-            DEPENDS $(_l)($(_i:BS)) : $(_i) ;
-        }
-    }
-
-    Clean clean : $(_l) ;
-
-    if $(CRELIB) { CreLib $(_l) : $(>[1]) ; }
-
-    Archive $(_l) : $(>) ;
-
-    if $(RANLIB) { Ranlib $(_l) ; }
-
-    # If we can't scan the library, we have to leave the .o's around.
-
-    if ! ( $(NOARSCAN) || $(KEEPOBJS) ) { RmTemps $(_l) : $(>) ; }
-}
-
-rule Link
-{
-    MODE on $(<) = $(EXEMODE) ;
-    Link-action $(<) : $(>) ;
-    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 $(<) : [ Objects $(>) ] ;
-}
-
-rule MainFromObjects
-{
-    local _s _t ;
-
-    # Add grist to file names
-    # Add suffix to exe
-
-    _s = $(>) ;
-    _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
-
-    if $(_t) != $(<)
-    {
-        DEPENDS $(<) : $(_t) ;
-        NOTFILE $(<) ;
-    }
-
-    # make compiled sources a dependency of target
-
-    type-DEPENDS exe : $(_t) ;
-    DEPENDS $(_t) : $(_s) ;
-    MakeLocate $(_t) : $(LOCATE_TARGET) ;
-
-    Clean clean : $(_t) ;
-
-    Link $(_t) : $(_s) ;
-}
-
-rule MakeLocate
-{
-    if $(>)
-    {
-        LOCATE on $(<) = $(>) ;
-        # We add directory-grist here so that implicitly-created directory
-        # target names don't collide with user-specified targets.
-        Depends $(<) : $(>[1]:G=directory-grist) ;
-        MkDir $(>[1]:G=directory-grist) ;
-    }
-}
-
-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 ;
-
-    type-DEPENDS obj : $(<) ;
-    set-target-variables $(<) ;
-    
-    # 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).
-
-    # Use unique to clean up confusing duplicates a bit
-    HDRS on $(<) = [ unique $(LOCATE_SOURCE) $(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 .s :   As $(<) : $(>) ;
-        case * :    UserObject $(<) : $(>) ;
-    }
-}
-    
-# Return the corresponding object file target names given a list of source file
-# target names.
-rule object-name # sources...
-{
-    return $(<:D=:S=$(SUFOBJ):G=$(TARGET_GRIST)) ;
-}
-
-# Build a generated source file from input-target, and build whatever that file generates.
-# Return a list of all object target names ultimately generated by recursively
-# building the products of input-target.
-rule gen-source # source => object-file-names
-{
-    local suffix = .c ;
-    if $(<:S) in .lpp .ypp
-    {
-        suffix = .cpp ;
-    }
-    
-    local immediate-target = $(<:D=:S=$(suffix):G=$(SOURCE_GRIST)) ;
-    switch $(<:S)
-    {
-     case .l* : Lex $(immediate-target) : $(<) ;
-     case .y* : Yacc $(immediate-target) : $(<) ;
-    }
-    return [ Objects $(immediate-target) ] ;
-}
-
-# A list of all file extensions which generate source files when built.
-SOURCE_GENERATING_EXTENSIONS ?= .lpp .ypp .l .y ;
-
-# Build all object files generated by building $(<), and return a list of the
-# names of those object file targets.
-rule Objects
-{
-    local _i _n _r ;
-
-
-    for _i in $(<)
-    {
-        if $(_i:S) in $(SOURCE_GENERATING_EXTENSIONS)
-        {
-            _n = [ gen-source $(_i) ] ;
-        }
-        else
-        {
-            _n = [ object-name $(_i) ] ;
-            Object $(_n) : $(_i) ;
-        }
-        _r += $(_n) ;
-    }
-    return $(_r) ;
-}
-
-rule RmTemps
-{
-    TEMPORARY $(>) ;
-}
-
-rule Setuid
-{
-    MODE on [ FAppendSuffix $(<) : $(SUFEXE) ] = 4711 ;
-}
-
-rule Shell
-{
-    type-DEPENDS shell : $(<) ;
-    DEPENDS $(<) : $(>) ;
-    SEARCH on $(>) = $(SEARCH_SOURCE) ;
-    MODE on $(<) = $(SHELLMODE) ;
-    Clean clean : $(<) ;
-    Chmod $(<) ;
-}
-
-rule SubDir
-{
-    local _r ;
-
-    #
-    # 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 ! $(gINCLUDED($(<[1])))
-    {
-        # Gated entry.
-
-        gINCLUDED($(<[1])) = TRUE ;
-
-        # File is $(TOPRULES) or $(TOP)/Jamrules.
-
-        _r = $($(<[1])RULES) ;
-
-        if ! $(_r)
-        {
-            _r = $(JAMRULES:R=$($(<[1]))) ;
-        }
-
-        # Include it.
-
-        include $(_r) ;
-
-        # determine where toolset specifications and boost-base can be found. 
-        TOOLSET_DIR ?= $($(<[1])) ;
-        BOOST_BASE_DIR ?= $($(<[1])) ;
-        # and include boost-base
-        include [ join-path $(BOOST_BASE_DIR) boost-base.jam ] ;
-    }
-
-    # Get path to current directory from root using SubDir.
-    # Save dir tokens for other potential uses.
-    SUBDIR_TOKENS = $(<[2-]) ;
-
-    # SUBDIR is the path from the invocation directory to the subproject
-    # directory. 
-    SUBDIR = [ FDirName [ simplify-path-tokens $($(<[1]))  $(SUBDIR_TOKENS) ] ] ;
-
-    SEARCH_SOURCE = $(SUBDIR) ;
-
-    # This will strip off any leading dot on SUBDIR_TOKENS
-    local nodot_subdir = [ simplify-path-tokens $(SUBDIR_TOKENS) ] ;
-
-    ALL_LOCATE_TARGET ?= $($(<[1])) ;
-    LOCATE_SOURCE = [ FDirName $(ALL_LOCATE_TARGET) $(nodot_subdir) ] ;
-    LOCATE_TARGET = $(LOCATE_SOURCE) ;
-    
-    SOURCE_GRIST = [ FGrist $(<[2-]) ] ;
-
-    # Reset per-directory ccflags, hdrs
-
-    SUBDIRCCFLAGS = ;
-    SUBDIRC++FLAGS = ;
-    SUBDIRHDRS = ;
-
-    # This allows us to determine whether we're in the directory where jam was
-    # invoked from so that we can make locally named targets
-    
-    gINVOCATION_SUBDIR ?= $(SUBDIR) ;
-
-    # This variable holds the path from the directory of Jam's invocation to the
-    # directory of the current subproject.
-    RELATIVE_SUBDIR_TOKENS = [ simplify-path-tokens [ split-path $($(<[1])) ] $(SUBDIR_TOKENS) ] ;
-    RELATIVE_SUBDIR = [ join-path $(RELATIVE_SUBDIR_TOKENS) ] ;
-}
-
-rule FGristFiles 
-{
-	if ! $(SOURCE_GRIST)
-	{
-	    return $(<) ;
-	}
-	else 
-	{
-	    return $(<:G=$(SOURCE_GRIST)) ;
-	}
-}
-
-
-rule strip-grist
-{
-    local x = $(<:G=) ;
-    if ! $(x:G)
-    {
-        return $(x) ;
-    }
-    else
-    {
-        return [ strip-grist $(x) ] ;
-    }
-}
-
-# Breaks $(<) into path components
-#
-# split-path <foo>bar/<bee>baz/mumble  => <foo>bar <bee>baz mumble 
-rule split-path
-{
-    local parent = $(<:P) ;
-    if ! $(parent:G=)
-    {
-        return $(<) ;
-    }
-    else
-    {
-        local p = [ split-path $(parent) ] ;
-        local b = [ strip-grist $(<) ] ;
-        p += $(b:D=) ; # can't use :B here because it destroys . and ..
-        return $(p) ;
-    }
-}
-
-rule reverse
-{
-    local result ;
-    for x in $(<)
-    {
-        result = $(x) $(result) ;
-    }
-    return $(result) ;
-}
-
-# simplify-path-tokens token1 token2 ... tokenN : DOT-opt
-#
-# Remove redundant information from the given path elements
-# if DOT-opt is supplied, empty results are replaced with
-# $(DOT-opt).
-#
-# [ simplify-path-tokens a b . c .. .. d e ] => a d e
-# [ simplify-path-tokens a b .. .. .. d e ]  => .. d e
-# [ simplify-path-tokens .. .. d e : xxx ]   => .. .. d e
-# [ simplify-path-tokens a b .. .. : xxx ]   => xxx
-rule simplify-path-tokens
-{
-    local reverse-path = [ reverse $(<) ] ;
-    local dotdots ;
-    local result ;
-    for token in $(reverse-path)
-    {
-        if $(token) = $(DOT)
-        {
-        }
-        else if $(token) = $(DOTDOT)
-        {
-            dotdots += $(token) ;
-        }
-        else if $(dotdots)
-        {
-            dotdots = $(dotdots[2-]) ;
-        }
-        else
-        {
-            result = $(token) $(result) ;
-        }
-    }
-
-    result = $(dotdots) $(result) ;
-    result ?= $(>) ;
-    return $(result) ;
-}
-
-
-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 ;
-
-    # Can't just replace .cpp with .h, because bison seems to generate a .cpp.h file
-    _h = $(<).h ;
-
-    # Some places don't have a yacc.
-
-    MakeLocate $(<) $(_h) : $(LOCATE_SOURCE) ;
-    SEARCH on $(<) $(_h) = $(LOCATE_SOURCE) ;
-
-    if $(YACC)
-    {
-        DEPENDS $(<) $(_h) : $(>) ;
-
-        # if YACC can accept an output file, we'll just generate the file there.
-        YACCFILES on $(<) $(_h) = [ join-path $(LOCATE_SOURCE) $(<[1]) ] ;
-        
-        Yacc1 $(<) $(_h) : $(>) ;
-        
-        if ! $(YACC_OUTPUT)
-        {
-            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 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 *.hpp :      _o += $(_i) ;
-            case * :        _o += $(_i:G=$(SOURCE_GRIST)) ;
-            }
-        }
-
-        return $(_o) ;
-    }
-}
-
-rule join
-{
-    # Puts the variables together, removing spaces.
-
-    local _t _r ;
-
-    _r = $(<[1]) ;
-
-    local sep = $(>) ;
-    if ! $(sep)
-    {
-        sep = "" ;
-    }
-    for _t in $(<[2-])
-    {
-        _r = $(_r)$(sep)$(_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) ;
-}
-
-# Turn individual elements in $(<) into a usable path. If $(<) is empty, $(>) is
-# returned.
-rule join-path
-{
-    local _s _i ;
-
-    if ! $(<)
-    {
-        _s = $(>) ;
-    }
-    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 FDirName
-{
-    # Turn individual elements in $(<) into a usable path.
-    return [ join-path $(<) : $(DOT) ] ;
-}
-
-
-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
-    {
-        $(<) = $(>) ;
-    }
-}
-
-#
-# Actions
-#
-
-#
-# First the defaults
-#
-
-actions As
-{
-    $(AS) $(ASFLAGS) -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 together Lex
-{
-    $(LEX) $(LEXFLAGS) $(LEX_OUTPUT)$(<) $(>)
-}
-
-actions together LexMv
-{
-    $(MV) lex.yy.c $(<)
-}
-
-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 together Yacc1
-{
-    $(YACC) $(YACCFLAGS) $(YACC_OUTPUT)$(<[1]) $(>)
-}
-
-actions together YaccMv
-{
-    $(MV) $(YACCFILES).c $(<[1])
-    $(MV) $(YACCFILES).h $(<[2])
-}
-
-actions together Yacc-fix-line-directives
-{
-    $(YACC_FIX_LINES) $(<) > $(<)
-}
-#
-# Now include the user's Jamfile.
-#
-
-{
-     if $(JAMFILE) { include $(JAMFILE) ; }
-}

build/bar.c

@@ -1 +0,0 @@
-class X {};

build/bar.cpp

@@ -1,4 +0,0 @@
-int main()
-{
-    return 0;
-}

build/baz.c

@@ -1 +0,0 @@
-class X {};

build/boost-base.jam

@@ -1,1166 +0,0 @@
-#  (C) Copyright David Abrahams and Carlos Pinto Coelho 2001. Permission to
-#  copy, use, modify, sell and distribute this software is granted provided this
-#  copyright notice appears in all copies. This software is provided "as is"
-#  without express or implied warranty, and with no claim as to its suitability
-#  for any purpose.
-#
-# Jamrules file by David Abrahams (abrahams@mediaone.net) and Carlos Pinto
-# Coelho (cfspc@altrabroadband.com).
-
-# Notes on the design of the system:
-#
-# This system is designed to support building the "same" targets with multiple
-# build tool suites (e.g. msvc, gcc,...)  and build variants (e.g. debug,
-# release...). Although it currently varies across two dimensions, it should
-# trivially support extension to three or more, e.g. in case of cross-platform
-# builds. The word "same" is written in quotes above because internally,
-# separate targets are generated for each unique toolset/build-variant
-# combination.
-#
-# Specifics of build tool suites are specified in files with names of the form
-# "<name>-tools.jam", where <name> is the name used to identify the tool suite.
-
-# Workarounds for Jam limitations:
-#
-# 1. Jam supports something like the setting of attributes on targets using the
-#    syntax:
-#       <name> on <target> = <expression>
-#
-#    This facility is used to control build actions for individual targets
-#    (target-specific variables take precedence over global ones when build
-#    actions # are executed). An obvious approach would be to use target
-#    attributes to hold # properties of build tools (e.g. where to find the
-#    standard includes).  # Unfortunately, although you can write target
-#    attributes, there is no way to # read them. Instead, we take advantage of
-#    two properties of Jam:
-#
-#    a. A variable name can be formed by evaluating an expression. For example,
-#       the following rule, appends FOOBAR to its first argument to form the
-#       name of a new variable, which is given the value "baz"
-#
-#          rule X { $(1)FOOBAR = baz ; }
-#
-#    b. Any character is allowed in a variable name. So, although they are
-#       actually global variables, we can form names like <name>.c++-flags thus:
-#       
-#          C++FLAGS = $($(1).c++-flags) # Get the c++-flags "attribute" from $(1)
-#
-# 2. There is no way to call a rule based on the value of a variable
-#    other than by using a switch statement. Because that approach requires
-#    intrusive changes to rules when the system is extended, we have avoided
-#    it. Instead, we have taken advantage of two "features" of Jam:
-#
-#    a. The name of a file to be included can be computed from an
-#       expression. For example, the following includes a file whose name is
-#       formed by concatenating $(1) and "-tools.jam":
-#
-#           include $(1)-tools.jam 
-#
-#    b. A rule can be redefined any number of times. Its latest definition is
-#       the one invoked. For example, the following prints "#2".
-#
-#           rule X { ECHO #1 ; }
-#           rule X { ECHO #2 ; }
-#           X ;
-#
-#    Together, these facts allow us to select tool-suite-specific actions for
-#    building specific target types by repeatedly redefining the generalized
-#    build actions in the various <build-tools>-tools.jam files
-
-TOOLS ?= borland gcc metrowerks msvc ;
-
-# detect-build-tools <tools-name> : <detection-command>
-#
-# Declares a pseudotarget for the specified build tools which is built by
-# the given <detection-command>. 
-#
-# Although not currently implemented, the plan is to make compilation of
-# tool-specific targets dependent on this pseudotarget. That way, we will never
-# even attempt to build targets for tools that don't exist.
-rule detect-build-tools
-{
-    detection-command on $(<) = $($(<).bin-directory)$(>) ;
-}
-
-actions build-tools
-{
-    $(detection-command)
-}
-
-rule library-file
-{
-    LibraryFromObjects $(<) : [ Objects $(>) ] ;
-}
-
-rule executable-file
-{
-    executable-from-objects $(<) : [ Objects $(>) ] ;
-}
-
-rule executable-from-objects
-{
-    # make compiled sources a dependency of target
-
-    type-DEPENDS exe : $(<) ;
-    DEPENDS $(<) : $(>) ;
-	MakeLocate $(<) : $(LOCATE_TARGET) ;
-
-    Clean clean : $(<) ;
-
-    Link $(<) : $(>) ;
-
-    # Setting RUN_ALL causes all executable targets to be run.
-    if $(RUN_ALL)
-    {
-        Run $(<) ;
-    }
-}
-
-# A simple action to run an executable target
-actions Run
-{
-    $(<)
-}
-
-# assert_equal a : b
-#
-# exits with an assertion failure if a != b
-rule assert_equal
-{
-    # we can turn off assertions by putting the symbol NDEBUG in the global TEST
-    # variable 
-    if ! ( NDEBUG in $(TEST) )
-    {
-        if $(<) != $(>)
-        {
-            EXIT "assertion failure: [" $(<) "] != [" $(>) "]" ;
-        }
-    }
-}
-
-# bubble variable-name
-#
-# Helper function for sort, below
-# Removes the greatest element from $(variable-name) and returns it.
-rule bubble # 
-{
-    local result = ;
-    local last = $($(<)[1]) ;
-    for x in $($(<)[2-])
-    {
-        if $(last) <= $(x)
-        {
-            result += $(last) ;
-            last = $(x) ;
-        }
-        else
-        {
-            result += $(x) ;
-        }
-    }
-    $(<) = $(result) ;
-    return $(last) ;
-}
-
-# sort args
-#
-# return args sorted in lexicographic order.
-rule sort
-{
-    local _all = $(<) ;
-    local _result = ;
-    local _count ;
-    for _count in $(<)
-    {
-        _result = [ bubble _all ] $(_result) ;
-    }
-    return $(_result) ;
-}
-assert_equal [ sort 7 3 5 6 2 4 ] : 2 3 4 5 6 7 ;
-
-# min args
-#
-# return the lexicographic minimum element of args
-rule min
-{
-    local result = ;
-    local x ;
-    for x in $(<)
-    {
-        if ! $(result) || ( $(x) < $(result) )
-        {
-            result = $(x) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ min 7 3 5 6 2 4 ] : 2 ;
-
-# difference listB : listA
-# returns the elements of B that are not in A
-rule difference
-{
-    local result = ;
-    local element ;
-    for element in $(<)
-    {
-        if ! ( $(element) in $(>) )
-        {
-            result += $(element) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ difference 0 1 2 3 4 5 6 7 8 9 : 2 3 5 7 ] : 0 1 4 6 8 9 ;
-
-# replace list : old-value new-value
-#
-# returns list with occurrences of old-value replaced by new-value
-rule replace
-{
-    local result = ;
-    local x ;
-    for x in $(<)
-    {
-        if $(x) = $(>[1])
-        {
-            result += $(>[2]) ;
-        }
-        else
-        {
-            result += $(x) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ replace 1 3 5 7 7 9 2 5 4 3 1 : 7 x ] : 1 3 5 x x 9 2 5 4 3 1 ;
-
-# select-ungristed list...
-#
-# Returns the elements of list that have no grist
-rule select-ungristed
-{
-    local result x ;
-    for x in $(<)
-    {
-        if ! $(x:G)
-        {
-            result += $(x) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ select-ungristed <a>b c <d>e f ] : c f ;
-
-# Split a qualified property into 3 elements. 
-#
-# Grammar description of qualified-property :
-#   [[<toolset>]<variant>]property
-#
-# returns <toolset> <variant> property
-# missing <toolset> or <variant> are treated as <*>
-rule split-qualified-property
-{
-    local grist1 = $(<:G) ;
-    local ungrist1 = $(<:G=) ;
-    local grist2 = $(ungrist1:G) ;
-    local ungrist2 = $(ungrist1:G=) ;
-    local grist3 = $(ungrist2:G) ;
-    local ungrist3 = $(ungrist2:G=) ;
-    if $(grist3)
-    {
-        return $(grist1) $(grist2) $(grist3)$(ungrist3) ;
-    }
-    else if $(grist2)
-    {
-        return <*> $(grist1) $(grist2)$(ungrist2) ;
-    }
-    else
-    {
-        return <*> <*> $(<) ;
-    }
-}
-assert_equal [ split-qualified-property <feature>value ]
-    : <*> <*> <feature>value ;
-assert_equal [ split-qualified-property <variant><feature>value ]
-    : <*> <variant> <feature>value ;
-assert_equal [ split-qualified-property <toolset><variant><feature>value ]
-    : <toolset> <variant> <feature>value ;
-
-rule unique # list
-{
-    local result = ;
-    local f ;
-    for f in $(<)
-    {
-        if ! $(f) in $(result)
-        {
-            result += $(f) ;
-        }
-    }
-    return $(result) ;
-}
-
-assert_equal [ unique 0 1 2 3 1 7 6 6 4 5 ] : 0 1 2 3 7 6 4 5 ;
-
-# get-properties features : properties
-#
-# Given a list of gristed features and a list of properties, returns the
-# properties matching the given features.
-rule get-properties 
-{
-    local result = ;
-    local property ;
-    for property in $(>)
-    {
-        if $(property:G) in $(<)
-        {
-            result += $(property) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ get-properties <foo> <bar> : <foo>bar <foo>baz <bar>fight <baz>niss ]
-    : <foo>bar <foo>baz <bar>fight ;
-    
-# get-values feature : properties
-#
-# Given a single gristed feature name and a list of properties, returns the
-# value(s) of that feature.
-rule get-values
-{
-    if $(<[2])
-    {
-        EXIT "Error: Expecting a single gristed feature name for $1 in get-values, got" "$(<)" ;
-    }
-    else
-    {
-        local _properties = [ get-properties $(<) : $(>) ] ;
-        return $(_properties:G=) ;
-    }
-}
-assert_equal [ get-values <foo> : <foo>bar <foo>baz <bar>fight <baz>niss ] : bar baz ;
-
-# normalize-properties properties
-#
-# Normalizes a set of (possibly qualified) properties by prepending <*> as many
-# times as neccessary to ensure that each property has at least 3 gristed elements.
-rule normalize-properties
-{
-    local property ;
-    local result ;
-    for property in $(<)
-    {
-        result += [ join [ split-qualified-property $(property) ] ] ;
-    }
-    return $(result) ;
-}
-assert_equal [ normalize-properties <a>b <c><d>e <f><g><h>i ] :
-     <*><*><a>b <*><c><d>e <f><g><h>i ;
-
-# intersection set1 : set2
-#
-# Removes from set1 any items which don't appear in set2 and returns the result.
-rule intersection 
-{
-    local result v ;
-    for v in $(<)
-    {
-        if $(v) in $(>)
-        {
-            result += $(v) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ intersection 1 2 2 3 3 4 5 6 7 : 5 1 3 7 3 9 11 ] : 1 3 3 5 7 ;
-
-# subset sub : super
-#
-# Returns true iff sub is a subset of super, empty otherwise
-rule is-subset
-{
-    if [ intersection $(<) : $(>) ] = $(<)
-    {
-        return true ;
-    }
-}
-assert_equal [ is-subset a b c : c a b d ] : true ;
-assert_equal [ is-subset a b z : c a b d ] : ;
-
-# distribute-feature <feature>value1[/value2...]
-#
-# Distribute the given feature across the slash-separated set of values, i.e.
-# returns <feature>value1[ <feature>/value2...]
-rule distribute-feature
-{
-    local g = $(<:G) ;
-    local result = [ split-path $(<:G=) ] ;
-    return $(g)$(result) ;
-}
-assert_equal [ distribute-feature <feature>value1 ] : <feature>value1 ;
-assert_equal [ distribute-feature <feature>value1/value2 ] : <feature>value1 <feature>value2 ;
-assert_equal [ distribute-feature <feature>value1/value2/value3 ] : <feature>value1 <feature>value2 <feature>value3 ;
-
-# set-insert variable-name : value... ;
-#
-# Appends the given values to the list designated by variable-name if they are
-# not already present.
-rule set-insert
-{
-    local v ;
-    for v in $(>)
-    {
-        if ! ( $(v) in $($(<)) )
-        {
-            $(<) += $(v) ;
-        }
-    }
-}
-if ! ( NDEBUG in $(TEST) )
-{
-    gTEST_SET = 1 2 3 ;
-    set-insert gTEST_SET : 2 ;
-    assert_equal $(gTEST_SET) : 1 2 3 ;
-    set-insert gTEST_SET : 0 ;
-    assert_equal $(gTEST_SET) : 1 2 3 0 ;
-}
-
-# equal-sets set1 : set2
-#
-# Returns true iff set1 contains the same elements as set2.
-# Not sensitive to the same element appearing multiple times
-rule equal-sets
-{
-    if ( ! [ difference $(<) : $(>) ] ) && ( ! [ difference $(>) : $(<) ] )
-    {
-        return true ;
-    }
-}
-assert_equal [ equal-sets 1 2 3 : 3 2 2 1 ] : true ;
-assert_equal [ equal-sets 1 2 3 3 : 3 2 2 1 ] : true ;
-assert_equal [ equal-sets 1 2 3 3 4 : 3 2 2 1 ] : ;
-
-# flags tools-name variable-name condition [: value(s)]
-#
-# Declare command-line settings for a given toolset.
-#   toolset:         the name of the toolset
-#   variable-name:   the name of a global variable which can be used to carry
-#                    information to a command-line
-#   condition:       one of the following:
-#                    1. zero or more <simple-feature>value[/<simple-feature>value...]
-#                    2. <free-feature>
-#   values:          non-empty in case 1 above, empty in case 2.
-#
-# Semantics only affect targets built with the specified toolset, and depend on
-# the form of condition:
-#
-# 1. For targets whose build-properties are a superset of any element of condition
-# (or, when condition is empty, for all targets), values will be appended to
-# $(variable-name).
-#
-# 2. for each free property of a built target whose feature is specified by
-# condition, the property's value will be appended to $(variable-name)
-#
-# In either case, the variable will be set "on" the target so it may be  used in
-# the build actions. 
-rule flags
-{
-    local toolset = $(<[1]) ;
-    local variable = $(<[2]) ;
-    local condition = $(<[3-]) ;
-
-    # record the names of all variables used so they can be set on targets
-    if ! ( $(variable) in $(gTARGET_VARIABLES) )
-    {
-        gTARGET_VARIABLES += $(variable) ;
-        $(variable) = ;
-    }
-
-    if $(>)
-    {
-        # values is non-empty: specifying simple properties
-        if ! $(condition) 
-        {
-             $(variable) += $(>) ; # condition is empty: unconditionally add values
-        }
-        else
-        {
-            local found = ;
-            
-            local property_set ;
-            for property_set in $(condition)
-            {
-                local properties = [ split-path $(property_set) ] ;
-                
-                # Add each feature to the set of features relevant to the toolset
-                gRELEVANT_FEATURES($(toolset)) += $(properties:G) ;
-
-                # if this property_set is a subset of the current build-properties
-                if ( ! $(found) ) && [ is-subset $(properties) : $(gBUILD_PROPERTIES) ]
-                {
-                    found = true ;
-                    $(variable) += $(>) ;
-                }
-            }
-        }
-    }
-    else
-    {
-        
-        if $(condition[2])
-            || $(condition[1]:G=)
-            || ! ( $(condition[1]) in $(gFREE_FEATURES) )
-        {
-            EXIT "Error: rule flags expects only a single free feature"
-            " name when no values are supplied. "
-            "got (" $(condition) ") instead." ;
-        }
-        # Add the values of the free feature specified by condition to $(variable)
-        $(variable) += [ get-values $(condition) : $(gBUILD_PROPERTIES) ] ;
-        # Record that the feature is relevant to the toolset
-        gRELEVANT_FEATURES($(toolset)) += $(condition) ;
-    }
-}
-
-# include-tools toolset
-#
-# Unconditionally process the specification file for the given toolset. It is
-# neccessary to do this for each target built with that toolset, since the
-# toolset will invoke the flags rule to set global variables based on the build
-# properties of the target.
-rule include-tools 
-{
-    gCURRENT_TOOLSET = $(<) ;
-
-    gTARGET_VARIABLES = ;
-    gRELEVANT_FEATURES($(<)) = ; # clear relevant feature set
-    
-    include $(TOOLSET_DIR)$(SLASH)$(<)-tools.jam ;
-
-    # Always maintain the list of relevant features as unique
-    gRELEVANT_FEATURES($(<)) = [ unique $(gRELEVANT_FEATURES($(<))) ] ;
-    
-    gINCLUDED($(TOOLSET_DIR)$(SLASH)$(<)-tools.jam) = true ;
-}
-
-# relevant-features toolset
-#
-# Returns the set of unique features relevant to the given toolset; includes the
-# toolset description file as a side-effect if neccessary.
-rule relevant-features # name
-{
-    if ! $(gRELEVANT_FEATURES($(<)))
-    {
-        include-tools $(<) ;
-    }
-    return $(gRELEVANT_FEATURES($(<))) ;
-}
-
-rule assert_equal_sets
-{
-    # we can turn off assertions by putting the symbol NDEBUG in the global TEST
-    # variable 
-    if ! ( NDEBUG in $(TEST) )
-    {
-        if ! [ equal-sets $(<) : $(>) ]
-        {
-            EXIT "assertion failure: [" $(<) "] !=(set) [" $(>) "]" ;
-        }
-    }
-}
-{
-    assert_equal [ sort $(<) ] : [ sort $(>) ] ;
-}
-
-# select-properties toolset variant target-name : qualified-properties...
-#
-# Returns
-rule select-properties
-{
-    local relevant_features = [ relevant-features $(<[1]) ] ;
-    local normalized = [ normalize-properties $(>) ] ;
-
-    # Classify properties by the specificity of their qualification.
-    # First, grab those that apply to this toolset, or all toolsets
-    local this_toolset = [ get-values <$(<[1])> : $(normalized) ] ;
-    local all_toolsets = [ get-values <*> : $(normalized) ] ;
-    
-    local 0-stars = [ get-values <$(<[2])> : $(this_toolset) ] ;
-    local 1-stars = [ get-values <*> : $(this_toolset) ] [ get-values <$(<[2])> : $(all_toolsets) ] ;
-    local 2-stars = [ get-values <*> : $(all_toolsets) ] ;
-
-    # Select feature names from the features relevant to the toolset.
-    local features = [ intersection $(relevant_features)
-        : $(0-stars:G) $(1-stars:G) $(2-stars:G) ] ;
-
-    local result f ;
-    for f in $(features)
-    {
-        local is_free = [ intersection $(f) : $(gFREE_FEATURES) ] ;
-        
-        # Go through the $(n-stars) lists from most- to least- specific;
-        # collect the best set of values of a simple feature, and /all/
-        # values of a free feature.
-        local r n ;
-        for n in 0 1 2
-        {
-            if ! $(r) || $(is_free)
-            {
-                r += [ get-values $(f) : $($(n)-stars) ] ;
-            }
-        }
-
-        r = [ unique $(r) ] ;
-        if $(r[2]) && ! $(is_free) # Check for conflicting simple-feature requests
-        {
-            EXIT "Error: Ambiguous properties requested for"
-            $(<[3]) <$(<[1])><$(<[2])> ":" $(f)$(r) ;
-        }
-        result += $(f)$(r) ;
-    }
-    return $(result) ;
-}
-# get toolset features
-include $(TOP)$(SLASH)features.jam ;
-if ! ( NDEBUG in $(TEST) )
-{
-    TEST_PROPERTIES = <inlining>off <define>FOO <*><release><inlining>on
-                      <debug><define>DEBUG <msvc><release><foo>bar
-                      <gcc><*><inlining>on
-                      <msvc><*><foo>baz
-                      <msvc><release><optimization>speed
-                      <msvc><*><optimization>off
-                      <*><debug><optimization>off
-                      ;
-    assert_equal_sets [ select-properties gcc debug my-target : $(TEST_PROPERTIES) ]
-        : <define>FOO <define>DEBUG <inlining>on <optimization>off ;
-        
-    assert_equal_sets [ select-properties gcc release my-target : $(TEST_PROPERTIES) ]
-        : <define>FOO <inlining>on ;
-        
-    assert_equal_sets [ select-properties msvc debug my-target : $(TEST_PROPERTIES) ]
-        : <define>FOO <define>DEBUG <inlining>off <optimization>off ;
-        
-    assert_equal_sets [ select-properties msvc release my-target : $(TEST_PROPERTIES) ]
-        : <define>FOO <inlining>on <optimization>speed ;
-}    
-
-# ungrist-properties properties...
-#
-# Transforms a list of properties of the form:
-#   <feature1>value1 [<feature2>value2... ]
-# into a list of the form:
-#   feature1-value1 feature2-value2
-# suitable for use as directory path elements
-rule ungrist-properties
-{
-    local property ;
-    local result = ;
-    for property in $(<)
-    {
-        local f = [ ungrist $(property:G) ] ;
-        result += $(f)-$(property:G=) ;
-    }
-    return $(result) ;
-}
-if ! ( NDEBUG in $(TEST) )
-{
-    feature TEST_FEATURE1 : a b ;
-    feature TEST_FEATURE2 : c d ;
-    assert_equal [ ungrist-properties <TEST_FEATURE1>a <TEST_FEATURE2>c ]
-        : TEST_FEATURE1-a TEST_FEATURE2-c ;
-}
-
-# set-target-variables target
-#
-# attach global build tool settings to the given file-target, so that they can be
-# used in build actions.
-rule set-target-variables # file-target
-{
-    local s ;
-    for s in $(gTARGET_VARIABLES)
-    {
-        $(s) on $(<) = $($(s)) ;
-    }
-}
-
-# fixup-path-properties properties...
-#
-# For free properties that have been declared with "PATH", add a relative path
-# prefix to the value as neccessary to locate the path relative to the current
-# subproject. 
-rule fixup-path-properties
-{
-    local path-properties = [ get-properties $(gPATH_FEATURES) : $(<) ] ;
-    local non-path = [ difference $(<) : $(path-properties) ] ;    
-    if $(RELATIVE_SUBDIR) && ! $(path-properties:R)
-    {
-        path-properties = $(path-properties:R=$(RELATIVE_SUBDIR)) ;
-    }
-    return $(path-properties) $(non-path) ;
-}
-if ! ( NDEBUG in $(TEST) )
-{
-    local RELATIVE_SUBDIR = foobar ;
-    local gPATH_FEATURES = <include> ;
-    assert_equal [ fixup-path-properties <a>b <include>.. <c>d ]
-                : <include>foobar$(SLASH).. <a>b <c>d ;
-}
-
-# report-any-incompatible-properties requirements... : build-request... : target-name
-#
-# If any element of requirements has the same grist but a different ungristed
-# part as any element of build-request, exits with an error report about target-name
-rule report-any-incompatible-properties
-{
-    local common_features = [ intersection $(<:G) : $(>:G) ] ;
-    if ! [ equal-sets [ get-properties $(common_features) : $(<) ]
-                    : [ get-properties $(common_features) : $(>) ] ]
-    {
-        EXIT "Error:" "$(3):" "target requirements for the features {"
-                $(common_features) "} conflict with requested build {" $(>) "}" ;
-    }
-}
-if report-any-incompatible-properties in $(TEST)
-{
-    report-any-incompatible-properties <foo>bar <baz>mumble : <b>c <foo>bar : my-target ;
-    report-any-incompatible-properties <foo>bat <baz>mumble : <b>c <foo>bar : my-target ;
-}
-
-# multiply-property-sets [<feature>value1[/value2...] ]...
-#
-# Expands a set of (possibly multi-valued) properties into all the combinations
-# that include every feature in the set. Each combination is given as a path,
-# with the slash separating the properties, sorted in feature order.
-rule multiply-property-sets
-{
-    local result p ;
-    for p in [ sort $(<) ]
-    {
-        # expand any multi-valued simple features from the default build
-        local multiple = [ distribute-feature $(p) ] ;
-
-        # concatenation produces a product, so the tree branches for each
-        # multi-valued simple feature.
-        result = $(result)/$(multiple) ;
-        result ?= $(multiple) ; # this trick allows us to get started 
-    }
-    return $(result) ;
-}
-assert_equal [ multiply-property-sets <b>1 <a>2/3 <c>4/5 ]
-    : <a>2/<b>1/<c>4 <a>2/<b>1/<c>5 <a>3/<b>1/<c>4 <a>3/<b>1/<c>5 ;
-
-# make-path-property-set-pairs base-path : common-properties : property-sets
-#
-# Returns a list of pairs where each odd-numbered element is a relative path
-# into which a configuration should be built, and each following
-# even-numbered element is a slash-separated property set describing the
-# properties of the target to be built.
-#
-# Each path returned is base-path extended by one of the ungristed property-sets
-# (or just the base-path if no property-sets are supplied). Each property set
-# returned is formed by extending common-properties with one of the property-sets.
-rule make-path-property-set-pairs
-{
-    local result ;
-    local s ;
-    for s in $(3)
-    {
-        # Add the directory
-        result += [ join-path $(<)
-                    [ ungrist-properties [ split-path $(s) ] ] ] ;
-
-        # Add the complete set of properties (can't use join-path because of grist)
-        result += [ join $(>) $(s) : $(SLASH) ] ;
-    }
-
-    if $(result)
-    {
-        return $(result) ;
-    }
-    else
-    {
-        # if there were no overrides, just add the base variant and properties
-        return $(<) [ join $(>) : $(SLASH) ] ;
-    }
-}
-if ! ( NDEBUG in $(TEST) )
-{
-  gUNGRISTED(<a>) = a ;
-  gUNGRISTED(<c>) = c ;
-  gUNGRISTED(<e>) = e ;
-  gUNGRISTED(<g>) = g ;
-  gUNGRISTED(<i>) = i ;
-  assert_equal [ make-path-property-set-pairs foo$(SLASH)bar : <a>b <c>d : <e>f$(SLASH)<g>h <i>j ]
-    : foo$(SLASH)bar$(SLASH)e-f$(SLASH)g-h <a>b$(SLASH)<c>d$(SLASH)<e>f$(SLASH)<g>h foo$(SLASH)bar$(SLASH)i-j <a>b$(SLASH)<c>d$(SLASH)<i>j ;
-  assert_equal [ make-path-property-set-pairs foo$(SLASH)bar : <a>b <c>d : ]
-    : foo$(SLASH)bar <a>b$(SLASH)<c>d ;
-}
-
-# expand-build-request
-#      toolset variant target-name : requirements : build-request
-#    
-# Returns a list of pairs (build-path, properties) for the given variant
-# build of the given target with the given toolset, and all subvariant builds
-# specified by build-request.
-rule expand-build-request 
-{
-    local toolset = $(<[1]) ;
-    local variant = $(<[2]) ;
-
-    # grab the requirements and BUILD-request relevant to this toolset and variant
-    local requirements = [ select-properties $(toolset) $(variant) : $(>) ] ;
-    local build-request = [ select-properties $(toolset) $(variant) : $(3) ] ;
-
-    # Separate the free features (e.g. <define>, <undef>, <include>) from the others
-    local free-properties = [ get-properties $(gFREE_FEATURES) : $(requirements) $(build-request) ] ;
-    local requirements = [ difference $(requirements) : $(free-properties) ] ;
-    local build-request = [ difference $(build-request) : $(free-properties) ] ;
-
-    # Check for conflicts
-    report-any-incompatible-properties $(requirements) : $(build-request) : $(<[3]) ;
-
-    # Get  the base variant for the toolset. Includes free features
-    local base-properties = $(gBASE_PROPERTIES($(toolset),$(variant))) ;
-
-    # Which properties will override settings in the base variant?
-    local override-properties = [ unique $(requirements) $(build-request) ] ;
-    override-properties = [ difference $(override-properties) : $(base-properties) ] ;
-
-    # Which features, and thus properties, of the base variant are we keeping?
-    local kept-features = [ difference $(base-properties:G) : $(override-properties:G) ] ;
-    local kept-properties = [ get-properties $(kept-features) : $(base-properties) ] ;
-
-    # Which features will pick up a default value because they are not in
-    # the base variant or in the overrides?
-    local relevant_features = [ relevant-features $(toolset) ] ;
-    local defaulted-features = [ difference $(relevant_features)
-                                : $(override-properties:G) $(kept-features) ] ;
-    local defaulted-properties = [ feature-default $(defaulted-features) ] ;
-
-    # form override property sets of the form (property1[/property2...] )+,
-    # sorted in feature order. These represent the properties of subvariants
-    # that differ from the base variant 
-    local override-sets
-        = [ multiply-property-sets $(override-properties) $(defaulted-properties) ] ;
-
-    # return pairs (path, property-set) corresponding to each (sub)variant build
-    # described.
-    return [ make-path-property-set-pairs $(toolset)$(SLASH)$(variant)
-                : $(kept-properties) [ fixup-path-properties $(free-properties) ]
-                : $(override-sets) ] ;
-}
-
-# split-property-set property-set
-#
-# Used to peel apart path-separated property sets that may themselves
-# include paths. This arises most often when the <include> feature is used,
-# since its parameter is typically a path.
-#
-# The split properties are returned in reverse order
-rule split-property-set
-{
-    local full-split = [ split-path $(<) ] ;
-    local result x ;
-    for x in $(full-split)
-    {
-        if $(x:G)
-        {
-            result = $(x) $(result) ;
-        }
-        else
-        {
-            result = $(result[1])$(SLASH)$(x) $(result[2-]) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal
- [ split-property-set <a>b$(SLASH)c$(SLASH)<d>e$(SLASH)<f>g$(SLASH)h$(SLASH)i ]
- : <f>g$(SLASH)h$(SLASH)i <d>e <a>b$(SLASH)c ;
- 
-# declare-local-target name : sources : requirements : local-BUILD : target-type
-#
-# declares a subproject-local target of the given name and target-type. This is
-# all top-level rules which declare targets should eventually go through here.
-rule declare-local-target 
-{
-
-    # We grist the base target name here because we're referring the abstract
-    # target which generates all of the actual builds. We need a way to
-    # distinguish targets of the same name from different subprojects.
-    local base-target = [ FGristFiles $(<) ] ;
-
-    gTARGET_SOURCES($(base-target)) = $(2) ;
-    gTARGET_REQUIREMENTS($(base-target)) = $(3) ;
-    gTARGET_BUILD($(base-target)) = $(4) ;
-    gTARGET_TYPE($(base-target)) = $(5) ;
-
-    # Check to avoid infinite recursion when subprojects contain mutual
-    # dependencies. 
-    if ! $(gCURRENTLY_DECLARING($(base-target)))
-    {
-        local gCURRENTLY_DECLARING($(base-target)) = true ;
-        declare-target $(1) : $(2) : $(3) : $(4) : $(5) ;
-    }
-}
-
-# directory-of files...
-#
-# Returns a list of the directories containing each element of files
-rule directory-of
-{
-    local result d ;
-    for d in $(<:D)
-    {
-        if $(d) = ""
-        {
-            result += $(DOT) ;
-        }
-        else
-        {
-            result += $(d) ;
-        }
-    }
-    return $(result) ;
-}
-assert_equal [ directory-of a$(SLASH)b c d$(SLASH)e$(SLASH)f ] : a . d$(SLASH)e ;
-
-# top-relative-tokens path
-#
-# Returns a list of path elements which form the relative path from TOP to path,
-# which is expected to be given relative to the current subproject.
-rule top-relative-tokens
-{
-    return [ simplify-path-tokens $(SUBDIR_TOKENS) [ split-path $(<) ] ] ;
-}
-{
-    local SUBDIR_TOKENS = a b c ;
-    assert_equal [ top-relative-tokens ..$(SLASH)d$(SLASH)e ] : a b d e ;
-}
-
-# dependent-include target-path...
-#
-# For each target-path, ensure that the appropriate Jamfile has been
-# included. Used when a target declares its dependency on another target.
-
-rule dependent-include
-{
-    local target ;
-    for target in $(<)
-    {
-        # compute the path to the Jamfile containing target. This path must be
-        # relative to the directory of Jam's invocation in order for the include
-        # rule to find it.
-        
-        local jamfile-path
-            = [ join-path
-                [ simplify-path-tokens
-                  $(RELATIVE_SUBDIR_TOKENS) [ directory-of $(target) ] $(JAMFILE) ] ] ;
-                  
-        if ! $(gINCLUDED($(jamfile-path)))
-        {
-            # protect variables from being permanently set by SubDir invocations
-            # in included files.
-            local SUBDIR SUBDIR_TOKENS SEARCH_SOURCE LOCATE_SOURCE LOCATE_TARGET ;
-            local SOURCE_GRIST SUBDIRCCFLAGS SUBDIRC++FLAGS SUBDIRHDRS ;
-            local RELATIVE_SUBDIR RELATIVE_SUBDIR_TOKENS ;
-
-            # this stack allows us to avoid making dependee libraries part of
-            # the "type" targets, e.g. all, exe, obj. See rule type-DEPENDS.
-            local gIN_LIB_INCLUDE = 1 ;
-            
-            include $(jamfile-path) ;
-            gINCLUDED($(jamfile-path)) = true ;
-        }
-    }
-}
-
-# link-libraries dependent : libs... : target-path
-#
-# Used to make the given dependent target depend on the file result of building
-# the given libs. The 3rd argument should specify the directory path relative to
-# the subproject directory where the appropriate build is located.
-rule link-libraries
-{
-  local lib-path ;
-  for lib-path in $(>)
-  {
-    local new-subdir = TOP [ top-relative-tokens [ directory-of $(lib-path) ] ] ;
-    
-    # protect global variables from being permanently set by SubDir
-    local SUBDIR SUBDIR_TOKENS SEARCH_SOURCE LOCATE_SOURCE LOCATE_TARGET ;
-    local SOURCE_GRIST SUBDIRCCFLAGS SUBDIRC++FLAGS SUBDIRHDRS ;
-    local RELATIVE_SUBDIR RELATIVE_SUBDIR_TOKENS ;
-
-    # Enter the dependee subproject
-    SubDir $(new-subdir) ;
-
-    local target = [ FGristFiles $(lib-path:D=) ] ;
-    local target-type = $(gTARGET_TYPE($(target))) ;
-
-    local target-grist = [ join-path $(SOURCE_GRIST) $(3) ] ;
-    local build-target = $(target:G=$(target-grist)) ;
-    
-    # if build instructions for the given target have not been given, do that now.
-    if ! $(build-target) in $(gDECLARED_TARGETS)
-    {
-        declare-target $(target)
-            : $(gTARGET_SOURCES($(target)))
-            : $(gTARGET_REQUIREMENTS($(target)))
-            : $(BUILD) : $(target-type) ;
-    }
-
-    # Get the name of the built target file
-    local target-file = [ FAppendSuffix $(build-target) : $(SUF$(target-type)) ] ;
-
-    # Set up dependencies and link instructions
-    DEPENDS $(<) : $(target-file) ;
-    NEEDLIBS on $(<) += $(target-file) ;
-  }
-}
-
-# Which configuration(s) to build if nothing is explicitly specified
-DEFAULT_BUILD ?= debug ;
-
-# get-BUILD [target-default-build]
-#
-# If BUILD is set, return it. Otherwise if target-default-build is non-empty,
-# return it. Otherwise, return $(DEFAULT_BUILD)
-rule get-BUILD
-{
-  local build = $(BUILD) ;
-  build ?= $(<) ;
-  build ?= $(DEFAULT_BUILD) ;
-  return $(build) ;
-}
-
-BIN_DIRECTORY ?= bin ;
-
-# declare-fake-targets abstract-target : target-file
-#
-# 
-rule declare-fake-targets
-{
-    # make a fake target so that it can be built without knowing the suffix
-    # Since executables under *NIX have no suffix, we'd better check
-    if $(>) != $(<)
-    {
-        DEPENDS $(<) : $(>) ;
-        NOTFILE $(<) ;
-    }
-    
-    # The following checks that we're in the subdirectory of Jam's invocation
-    # so that we can arrange for ungristed target names to be built from the
-    # command-line.
-    if ( $(SUBDIR) = $(gINVOCATION_SUBDIR) )
-    {
-        DEPENDS $(<:G=) : $(<) ; # allows $(<:G=) to be used to build all variants
-        NOTFILE $(<:G=) ;
-    }
-}
-
-rule declare-target # target : sources : requirements : local-build : target-type
-{
-  local target-type = $(5) ;
-  local requirements = $(3) ;
-  local BUILD = [ get-BUILD $(4) ] ;
-  local variants = [ select-ungristed $(BUILD) ] ;
-  local build-request = [ difference $(BUILD) : $(variants) ] ;
-
-  # extract and remove <lib> targets from $(>)
-  local libs = [ get-values <lib> : $(>) ] ;
-  local sources = [ FGristFiles [ difference $(>:G=) : $(libs) ] ] ;
-
-  # include each jamfile describing a dependee target.
-  dependent-include $(libs) ;
-  
-  local toolset ;
-  for toolset in $(TOOLS)
-  {
-    local v ;
-    for v in $(variants)
-    {
-      local build-pairs
-          = [ expand-build-request $(toolset) $(v) $(<)
-              : $(requirements) : $(build-request) ] ;
-
-      local x;
-      local build = $(build-pairs) ;
-      for x in $(build-pairs)
-      {
-        if $(x:G) # Half the elements have grist; we're processing a pair-at-a-time
-        {
-          # extract the elements of the pair
-          local bin-path = $(build[1]) ;
-          local property-set = $(build[2]) ;
-
-          # SOURCE_GRIST identifies the subproject directory; TARGET_GRIST
-          # should identify the subvariant.
-          local TARGET_GRIST = [ join-path $(SOURCE_GRIST) $(bin-path) ] ;
-
-          # target is the unsuffixed name of the target, with TARGET_GRIST
-          local target = $(<:G=$(TARGET_GRIST)) ;
-
-          # Do nothing if build instructions and dependencies for this target
-          # have already been generated.
-          if ! $(target) in $(gDECLARED_TARGETS)
-          {
-            gDECLARED_TARGETS += $(target) ;
-
-            # LOCATE_TARGET affects where built targets are generated. We move
-            # it relative to the default location based on the subvariant
-            local LOCATE_TARGET
-              = [ join-path $(LOCATE_TARGET) $(BIN_DIRECTORY) $(bin-path) ] ;
-
-            local target-file = [ FAppendSuffix $(target) : $(SUF$(target-type)) ] ;
-            declare-fake-targets $(target) : $(target-file) ;
-            
-            # set up gBUILD_PROPERTIES for include-tools (below)
-            local gBUILD_PROPERTIES = [ split-property-set $(property-set) ] ;
-
-            # Include the toolset specification. This will set up the global
-            # flags variables in a way appropriate to this build.
-            include-tools $(toolset) ;
-            
-            # transfer target variables to the target file.
-            set-target-variables $(target-file) ;
-
-            # dispatch to the appropriate declaration function. It would be much
-            # better to be able to do this with some sort of indirection, but
-            # Jam doesn't yet support it.
-            switch $(target-type)
-            {
-              case EXE : executable-file $(target-file) : $(sources) ;
-              case LIB : library-file $(target-file) : $(sources) ;
-            }
-
-            # generate build instructions
-            link-libraries $(target-file) : $(libs) : $(bin-path) ;
-          }
-
-          # peel the first pair off the front
-          build = $(build[3-]) ;
-        }
-      }
-    }
-  }
-}
-
-# exe target : sources : requirements : local-build
-#
-# Declare an executable target.
-rule exe
-{
-    declare-local-target $(<) : $(2) : $(3) : $(4) : EXE ;
-}
-
-# lib target : sources : requirements : local-build
-#
-# Declare a statically-linked library target.
-rule lib
-{
-    declare-local-target $(<) : $(2) : $(3) : $(4) : LIB ;
-}
-

build/borland-tools.jam

@@ -1,128 +0,0 @@
-borland.bin-directory = [ conditional $(borland.root-directory) : $(borland.root-directory)$(SLASH)bin$(SLASH) : " " ] ;
-detect-build-tools borland : bcc32 ;
-
-flags borland CFLAGS <debug-symbols>on : -v ;
-flags borland LINKFLAGS <debug-symbols>on : -v ;
-flags borland CFLAGS <optimization>off : -Od ;
-flags borland CFLAGS <optimization>speed : -O2 ;
-flags borland CFLAGS <optimization>space : -O1 ;
-flags borland CFLAGS <inlining>off : -vi- ;
-flags borland CFLAGS <inlining>on : -vi -w-inl ;
-flags borland CFLAGS <inlining>full : -vi -w-inl ;
-
-
-flags borland CFLAGS <threading>multi : -tWM ;
-
-flags borland CFLAGS <user-interface>gui : -tW ;
-flags borland CFLAGS <user-interface>console : -tWC ;
-
-
-# -tWD Make the target a Windows .DLL with all functions exportable. 
-
-# C0D32.OBJ - 32-bit DLL startup module (cod32w: wide-char version; cod32x: no
-# exception handling)
-flags borland CFLAGS <runtime-link>dynamic/<user-interface>gui : -tWR ;
-flags borland CFLAGS <runtime-link>dynamic/<user-interface>console : -tWCR ;
-
-
-flags borland STDLIBS <user-interface>gui/<wide-character-support>off : COW32.OBJ ;
-flags borland STDLIBS <user-interface>gui/<wide-character-support>on : COW32w.OBJ ;
-
-flags borland STDLIBS <user-interface>console/<wide-character-support>off : COX32.OBJ ;
-flags borland STDLIBS <user-interface>console/<wide-character-support>on : COX32w.OBJ ;
-
-flags borland STDLIBS <runtime-link>static/<threading>single :  CW32.LIB ;
-flags borland STDLIBS <runtime-link>dynamic/<threading>single :  CW32I.LIB ;
-
-flags borland STDLIBS <runtime-link>static/<threading>multi : CW32MT.LIB ;
-flags borland STDLIBS <runtime-link>dynamic/<threading>multi :  CW32MTI.LIB ;
-
-flags borland DEFINES <define> ;
-flags borland UNDEFS <undef> ;
-flags borland HDRS <include> ;
-
-flags borland STDHDRS : $(borland.root-directory)$(SLASH)include ;
-flags borland STDLIBPATH : $(borland.root-directory)$(SLASH)lib ;
-
-# IMPORT32.LIB - 32-bit import library 
-
-# For detailed information about borland tools and their command-line switches,
-# see http://www.objectcentral.com/vide/help/videdoc/bcc32.html
-
-#### Link ####
-
-rule Link-action
-{
-    borland-Link-action $(<) : $(>) ;
-}
-
-# bcc32 needs to have ilink32 in the path in order to invoke it, so explicitly
-# specifying borland.bin-directory doesn't help, and I can't figure out the
-# right way to explicitly invoke ilink32. Maybe somebody else can fill in the
-# details...
-actions borland-Link-action bind NEEDLIBS
-{
-    set PATH="$(borland.bin-directory)";%PATH% ;
-    bcc32 -q $(LINKFLAGS) -L"$(STDLIBPATH)" -e"$(<)" "$(>)"  "$(STDLIBS)" "$(NEEDLIBS)"
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    borland-Cc-action $(<) : $(>) ;
-}
-
-actions borland-Cc-action
-{
-    $(borland.bin-directory)bcc32 -q -c -w- -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o"$(<)" "$(>)"
-}
-#### C++ ####
-rule C++-action
-{
-    borland-C++-action $(<) : $(>) ;
-}
-
-actions borland-C++-action
-{
-    $(borland.bin-directory)bcc32 -q -c -P -w- -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) $(OPTIM)  -I"$(HDRS)" -I"$(STDHDRS)" -o"$(<)" "$(>)"
-}
-
-#### Archive ####
-rule Archive-action
-{
-    borland-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal borland-Archive-action
-{
-    $(borland.bin-directory)tlib /P32 /u /a /C "$(<)" +"$(>)"
-}
-
-
-# FILEINFO.OBJ - Passes open file-handle information to child processes. Include
-# this file in your link to pass full information about open files to child
-# processes created with exec and spawn. Works with the C++ runtime library to
-# inherit this information.
-
-# WILDARGS.OBJ - If you want wild-card expansion for you console-mode
-# applications, then you should also link in this file when you link your
-# console-mode application. It apparently doesn t work for GUI apps. It does the
-# normal DOS-like wild card expansion and passes them to argv and argc of your
-# main.
-
-# C0S32.OBJ  - Unknown
-
-# dxextra.lib - DirectX static library 
-
-# inet.lib - Import lib for MS Internet DLLs 
-# noeh32.lib - No exception handling support lib 
-# ole2w32.lib - Import lib for 32-bit OLE 2.0 API 
-# oleaut32.lib - Unknown
-
-# uuid.lib - GUID static lib for Direct3d, DirectDraw, DirectSound, Shell
-# extensions, DAO, Active Scripting, etc.
-
-# wininet.lib - Unknown 
-# ws2_32.lib - Import lib for WinSock 2.0 API 
-# GP.OBJ - Prints register-dump information when an exception occurs.

build/build_system.htm

@@ -1,531 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-    <meta name="generator" content="HTML Tidy, see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-
-    <title>Boost Build System</title>
-
-    <h1>Boost Build System</h1>
-
-    <h2>Table of Contents</h2>
-
-    <ul>
-    <li>Introduction
-        <ul>
-        <li>Assumptions
-        <li>Requirements
-        </ul>
-    <li>Basic Design and Terminology
-        <ul>
-        <li>Projects and Subprojects
-        <li>Targets
-        <li>Features
-        <li>Build Variants
-        <li>Subvariants
-        <li>Dependent Targets
-        </ul>
-    <li>Usage
-        <ul>
-        <li>Some Terminology
-        <li>Subproject Jamfiles
-        </ul>
-    </ul>
-
-    <h2>Introduction</h2>
-
-    <h3>Assumptions</h3>
-
-    <p>The requirements are driven by several basic assumptions:
-
-    <ul>
-      <li>There is no single Boost developer or test facility with access to or 
-          knowledge of all the platforms and compilers Boost libraries are used with. 
-
-      <li>Boost libraries are used across such a wide range of platforms and 
-        compilers that almost no other assumptions can be made.    
-    </ul>
-
-    <h3>Requirements</h3>
-
-    <p>This build system was designed to satisfy the following requirements:
-
-    <ul>
-      <li>A developer adding a new library or test program must only have to add
-          simple entries naming the source files to a text file, and not have to
-          know anything about platform specific files. The developer should not
-          have to supply header dependency information.
-
-      <li>There should be a very high likelihood of builds succeeding on all
-          platforms if a build succeeds on any platform. In other words, a
-          developer must not be required to have access to many platforms or
-          compilers to ensure correct builds
-
-     <li>A user or developer adding support for a new platform or compiler
-         should only have to add to a single file describing how to do the build
-         for that platform or compiler, and shouldn't have to identify the files
-         that will need to be built.
-
-     <li>The build should rely only on tools native to the platform and
-         compiler, or supplied via the boost download.
-
-     <li>The details of how the build is done for a particular platform or
-         compiler should be appropriate for that platform.
-
-     <li>It should be possible to build multiple variants (e.g. debug/release)
-         of a single target.
-
-     <li>It should be possible to build multiple variants of multiple targets
-         with multiple compilers from a single build command.
-     
-     <li>The build tools must be able to handle Boost growth issues such as
-         identified in Directory Structure proposals and discussion.
-
-     <li>Support for dynamic and static linking should be included.
-
-     <li>It should be relatively straightforward to add support for a new
-         compiler. In most cases, no modification of files used to describe
-         existing targets should be required.
-
-     <li>Support for compiler- and variant-specific configuration for each target
-
-     <li>It should be possible to build targets into a directory unrelated to the source
-         directories (they may be read-only)
-
-    </ul>
-
-    <h2>Basic Design and Terminology</h2>
-
-    This section gives an overview of the way that the system works, outlining
-    the system's capabilities and overall design. It also introduces the
-    terminology and concepts neccessary to understand the sections on writing
-    Jamfiles and command-line invocations.
-
-    <h3>Projects and Subprojects</h3>
-    <p>
-
-    A <b>project</b> is a source directory tree containing a
-    <tt>Jamfile</tt>. The root directory of the project is known as the
-    <b>project root</b>.
-
-    <p>
-    Subdirectories containing <tt>Jamfile</tt>s are called <b>subproject
-    directories</b>. Each such <tt>Jamfile</tt> describes a <b>subproject</b>.
-
-    <p>The <b>build root</b> is a directory containing Jam files describing
-    compilers and build variants. The build root can be specified explicitly by
-    setting the variable <tt>BOOST_BUILD_ROOT</tt>. If the build root is not
-    specified, it is a subdirectory of the project root called <tt>build</tt>,
-    and <tt>BOOST_BUILD_ROOT</tt> is set to refer to that directory.
-
-    <h3>Targets</h3>
-
-    <p>Each <tt>Jamfile</tt> describes one or more <b>main targets</b>. 
-
-    <p>Each main target is an abstract description of one or more <b>built
-    targets</b> which are expressions of the corresponding main target under
-    particular compilers and build variants. Intermediate files such as
-    <tt>.o</tt>/<tt>.obj</tt> files generated by compiling <tt>.cpp</tt> files
-    as a consequence of building a main target are also referred to as built
-    targets.
-
-    The term <b>target directory tree</b> refers to the location of built
-    target files.
-
-    <ul>
-   <li> By default, the target directory tree is overlaid with the project
-        directory tree, with targets generated into a subtree rooted at the
-        <tt>bin</tt> subdirectory of each subproject directory (the name of this
-        directory can be customized by changing the <tt>BIN_DIRECTORY</tt> variable.
-
-    <li>If the variable <tt>ALL_LOCATE_TARGET</tt> is set, it specifies an
-        alternate target directory tree whose structure mirrors that of the
-        project. In this case, built targets of a subproject are generated into
-        the corresponding directory of the target directory tree.
-    </ul>
-
-
-    <h3>Features and Properties</h3>
-
-    <p>A <b>feature</b> is a normalized description of an individual build
-    parameter, such as whether inlining is enabled. Each feature usually
-    corresponds to a command-line option of one or more build tools. Features
-    come in two varieties:
-
-    <ol>
-      <li><b>Simple features</b> can take on any of several predetermined
-          values. For example, the feature <tt>optimization</tt> might take one
-          of the values <tt>off</tt>, <tt>speed</tt>, or <tt>space</tt>. Simple
-          features have a default value. Most features fall into this category.
-
-      <li><b>Free features</b> can take on any number of user-specified values
-          simultaneously. For example, the <tt>define</tt> feature for a release
-          build might have the values <tt>NDEBUG</tt> and
-          <tt>BOOST_RELEASE_BUILD</tt>. 
-    </ol>
-
-    <p>A feature-value pair is known as a <b>build property</b>, or simply
-    <b>property</b>. The prefixes <i>Simple</i> and <i>free </i> apply to
-    properties in an analogous way to features.
-
-    <h3>Build Variants</h3>
-
-    <p>A build variant, or simply <b>variant</b> is a named set of build
-        properties describing how targets should be built for
-        each compiler. Built targets for distinct build variants and compilers
-        are generated in separate parts of the target directory tree, known as
-        the <b>variant directories</b>. For example, a (sub)project with main targets
-        <tt>foo</tt> and <tt>bar</tt>, compiled with both GCC and KAI for <tt>debug</tt>
-        and <tt>release</tt> variants might generate the following structure
-        (target directories in <b>bold</b>).
-<blockquote><pre>
- bin
- +-foo
- | +-gcc
- | | +-<b>debug</b>
- | | `-<b>release</b>
- | `-kai
- |   +-<b>debug</b>
- |   `-<b>release</b>
- `-bar
-   +-gcc
-   | +-<b>debug</b>
-   | `-<b>release</b>
-   `-kai
-     +-<b>debug</b>
-     `-<b>release</b>
-</pre></blockquote>
-
-     <h3>Subvariants</h3>
-
-     <p>When a target is built with <i>simple</i> properties
-     that don't exactly match those specified in a build variant, the
-     non-matching features are called <b>subvariant features</b> and the target
-     is located in a <b>subvariant directory</b> beneath the directory of the
-     base variant. This can occur for two reasons:
-
-     <ol>
-       <li>Some features are only relevant to certain compilers. When
-           relevant simple features have no value specified in the build
-           variant, a value must be chosen. Even when the default value is used,
-           the target is generated into a subvariant directory. For example, the
-           <tt>runtime-link</tt> feature may be unspecified in the
-           <tt>debug</tt> variant, but relevant to MSVC. In that case, a
-           fragment of the target tree might look like:
-
-<blockquote><pre>
- bin
- +-foo
- | +-msvc
- | | +-debug
- . . . `-<b>runtime-link-dynamic</b>
- . . .
-</pre></blockquote>
-
-        Because the default value of <tt>runtime-link</tt> is <tt>dynamic</tt>,
-        when the <tt>debug</tt> variant is requested, the
-        <tt>runtime-link-dynamic</tt> subvariant of foo is built.<br><br>
-
-       <li>It is possible to request (either on the command-line, or as part of
-           a main target description) that particular subvariants be built. For
-           example, it may be desirable to generate builds that link to
-           the runtime both statically <i>and</i> dynamically. In that case,
-           both subvariant directories in the example above would be generated:
-<blockquote><pre>
- bin
- +-foo
- | +-msvc
- | | +-debug
- . . . +-<b>runtime-link-dynamic</b>
- . . . `-<b>runtime-link-static</b>
- . . .
-</pre></blockquote>
-
-     </ol>
-
-     In no case will targets be built directly into <tt>bin/foo/msvc/debug</tt>,
-     since the <tt>debug</tt> variant doesn't include the <tt>runtime-link</tt>
-     feature, which is relevant to MSVC.
-
-     <p>When a subvariant includes multiple subvariant features, targets are built
-     into a subvariant directory whose path is determined by concatenating the
-     properties sorted in order of their feature names. For example, the
-     borland compiler, which uses different libraries depending on whether the
-     target is a console or GUI program, might create the following structure
-     for a DLL:
-<blockquote><pre>
- bin
- +-foo
- | +-msvc
- | | +-debug
- | | | +-runtime-link-dynamic
- | | | | +-<b>user-interface-console</b>
- | | | | `-<b>user-interface-gui</b>
- . . . `-runtime-link-static
- . . .   +-<b>user-interface-console</b>
- . . .   `-<b>user-interface-gui</b>
-</pre></blockquote>
-
-<p>Any configuration of properties for which a target is built, whether base
-variant or subvariant, is known as a <b>build configuration</b>, or simply a
-<b>build</b>. 
-
-    <h3>Dependent Targets</h3>
-
-    <p>When a main target depends on the product of a second main target (as
-    when an executable depends on and links to a static library), each build configuration
-    of the dependent target is depends on the <i>same</i>
-    build of the dependee. Because only simple features
-    participate in build identity, the dependent and dependee targets may
-    have completely different free features. This puts the onus on the user for
-    ensuring link-compatibility when certain free properties are used. For
-    example, when <tt>assert()</tt> is used in header files, the preprocessor
-    symbol <tt>NDEBUG</tt> can impact link-compatibility of separate compilation
-    units. This danger can be minimized by encapsulating such feature
-    differences inside of build variants.
-
-    <h2>Usage</h2>
-
-    <p>This section describes how to start a build from the command-line and how
-    to write project and subproject Jamfiles. It also describes the other files
-    written in the Jam language: build-tool specification files, feature
-    descriptions files.
-
-    <h3>Some terminology</h3>
-    
-    <p>In the Jam language, a name can be divided into two parts. If the name
-    starts with a '<tt>&lt;</tt>' symbol and contains a '<tt>&gt;</tt>' symbol,
-    the characters between the '<tt>&lt;</tt>' and the first '<tt>&gt;</tt>',
-    inclusive, is known as <i>grist</i> (if the name doesn't match this format,
-    the grist is empty). The rest of the name is known as the <i>ungristed
-    part</i>. The boost build system takes advantage of Jam's ability to divide
-    names on grist boundaries, sometimes concatenating multiple gristed elements
-    at the beginning of a name.
-
-     <h3>SubProject Jamfiles</h2>
-
-    This section describes how to write a Jamfile for a subproject.
-
-    <h4>The <tt>subproject</tt> rule</h4>
-    <p>A subproject's Jamfile begins with an invocation of the <tt>subproject</tt> rule
-    that specifies the subproject's location relative to the top of the project
-    tree:
-
-<blockquote><pre>
-subproject <i>path-from-top</i> ;
-</blockquote></pre>
-
-    <p>The <tt>subproject</tt> rule tells the build system where to place built
-    targets from the subproject in case <tt>ALL_LOCATE_TARGET</tt> is used to
-    specify the target directory tree.
-    
-    <h4>Describing Main Targets</h4>
-
-    <p>A main target is described using the following syntax:
-
-<blockquote>
-<pre>
-<i>target-type</i> <i>name</i> : <i>sources</i>
-    [ : <i>requirements</i> [ : <i>default-BUILD</i> ] ] ;
-</pre></blockquote>
-<ul>
-<li><i>target-type</i> may be one of <tt>exe</tt>, <tt>lib</tt>, <tt>dll</tt>,
-or <tt>python</tt>.
-
-
-<p><li><i>name</i> specifies the name of the main target
-
-<p><li><i>sources</i> is a list of paths to source files and dependee targets. A
-dependee target path is preceded by <tt>&lt;target:&gt;</tt>, and the final path component
-specifies the name of a main target in a Jamfile located in the directory given
-by the inital path components. Paths may be absolute or relative.
-
-<p><li><i>requirements</i> specifies the build properties intrinsic to the
-target. Requirements are given as sets of optionally-<b>qualified build properties</b>:
-
-<blockquote><pre>
-[[&lt;<i>compiler</i>&gt;]&lt;<i>variant</i>&gt;]&lt;<i>feature</i>&gt;<i>value</i>
-</pre></blockquote>
-
-<tt>&lt;<i>compiler</i>&gt;</tt> and <tt>&lt;<i>variant</i>&gt;</tt>, if
-supplied, can be used to restrict the applicability of the requirement. Either
-one may be replaced by <tt>&lt;*&gt;</tt>, which is the same as ommitting it.
-
-<p>The system checks that simple feature requirements are not violated by
-explicit subvariant build requests, and will issue a warning
-otherwise. Free features specified as requirements are simply added to each
-corresponding build configuration.
-
-<p>
-<li><i>default-BUILD</i> specifies the configurations that should be
-built if the <tt>BUILD</tt> variable is not otherwise specified. Any ungristed
-elements refer to build variants. Gristed elements use the same syntax as the
-requirements described above, except that multiple values may be
-specified for a simple feature by separating them with a slash, forming (qualified)
-<b>multi-valued properties</b>:
-<blockquote><pre>
-[[&lt;<i>compiler</i>&gt;]&lt;<i>variant</i>&gt;]&lt;<i>feature</i>&gt;<i>value1</i>[/<i>value2</i>...]
-</pre></blockquote>
-When multiple values are specified, it causes <i>all</i> the implied configurations
-to be built by default.
-</ul>
-
-<p><b>NOTE:</b> for simple features in both <i>requirements</i> and
-<i>default-BUILD</i>, more-specific qualification overrides less-specific.
-
-<h4>Example</h4>
-
-<p>This example shows how an executable called &quot;foo&quot; might be
-described in a Jamfile. The executable is composed of the sources
-<tt>./foo.cpp</tt> and <tt>./src/bar.cpp</tt> (specified relative to the
-directory in which the Jamfile resides), and the built target which results from
-building the target <tt>baz</tt> as described in <tt>../bazlib/Jamfile</tt>.
-
-<blockquote><pre>
-exe foo : foo.cpp src/bar.cpp &lt;lib&gt;../bazlib/baz
-    ## Requirements ##
-    : &lt;include&gt;../bazlib/include 
-      &lt;define&gt;BUILDING_FOO=1
-      &lt;release&gt;&lt;define&gt;FOO_RELEASE
-      &lt;msvc&gt;&lt;*&gt;&lt;define&gt;FOO_MSVC
-      &lt;msvc&gt;&lt;release&gt;&lt;define&gt;FOO_MSVC_RELEASE
-      &lt;gcc&gt;&lt;*&gt;&lt;optimization&gt;off
-      &lt;gcc&gt;&lt;release&gt;&lt;optimization&gt;space
-      &lt;threading&gt;multi
-    
-    ## default-BUILD ##
-    : debug release
-      &lt;debug&gt;&lt;runtime-link&gt;static/dynamic
-    ;
-</pre></blockquote>
-
-<p>The requirements section:
-<ul>
-  <li>Adds <tt>../bazlib/include</tt> to the <tt>#include</tt> path
-  <li>Sets the preprocessor symbol <tt>BUILDING_FOO</tt> to <tt>1</tt>
-  <li>In the <tt>release</tt> builds, <tt>#define</tt>s <tt>FOO_RELEASE</tt>.
-  <li>When built with MSVC, <tt>#define</tt>s <tt>FOO_MSVC</tt>.
-  <li>In <tt>release</tt> variants built with MSVC, <tt>#define</tt>s
-  <tt>FOO_MSVC_RELEASE</tt>.
-  <li>Most builds under GCC have optimization turned off, but...
-  <li>...GCC <tt>release</tt> builds require optimization for space.
-  <li>Requires multithread support on compilers where it's relevant.
-</ul>
-
-<p>The default-BUILD section:
-<ul>
-  <li>specifies that <tt>debug</tt> and <tt>release</tt> base variants are built
-  by default.
-
-  <li>on compilers where the feature is relevant, requests both statically- and
-      dynamically-linked subvariants of the debug variant.
-</ul>
-
-<h3>Toolset Description Files</h3>
-
-<p>Toolset descriptions are located in the project's root directory, or a
-directory specified by <tt>TOOLSET_DIR</tt>. Each file is called
-<i>toolset-name</i><tt>-tools.jam</tt>, where <i>toolset-name</i> is the name of
-the toolset. The  toolset description file has two main jobs:
-
-<ol>
-<li>redefine the following rules:
-<ul>
-<li><tt>Link-action</tt> - links an executable from objects and libraries
-<li><tt>Archive-action</tt> - links a static library from object files
-<li><tt>C++-action</tt> - compiles a 'C++' file into an object file
-<li><tt>Cc-action</tt> - compiles a 'C' file into an object file
-</ul>
-These rules should simply invoke the action part of a rule whose name is
-uniquely defined for the toolset. For example, 
-
-<blockquote><pre>
-rule C++-action
-{
-    msvc-C++-action $(&lt;) : $(&gt;) ;
-}
-
-actions msvc-C++-action
-{
-    cl -nologo -GX -c -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -Fo$(&lt;) -Tp$(&gt;)
-}
-
-</pre></blockquote>
-
-<li> Translate build settings given in the global <tt>gBUILD_PROPERTIES</tt>
-variable into something that can be used by the toolset. The build system
-provides the <tt>flags</tt> rule to help translate build properties into
-elements of global variables which are later attached to targets so that they
-can affect the build actions.
-
-The  <tt>flags</tt> rule is used as follows:
-<blockquote><pre>
-flags <i>tools-name variable-name condition</i> [: <i>value</i>...]
-</pre></blockquote>
-
-The parameters are:
-<ol>
-<li> <i>toolset</i> -         the name of the toolset 
-<li> <i>variable</i> -   the name of a global variable which can be used to carry
-information to a command-line 
-<li> <i>condition</i> -       one of the following:
-<ol>
-<li> a list of property-sets: <tt>&lt;<i>simple-feature</i>&gt;<i>value</i></tt>[<tt>/&lt;<i>simple-feature</i>&gt;<i>value</i></tt>...]
-<li> <tt>&lt;<i>free-feature</i>&gt;</tt>
-</ol>
-<li> values - empty if <i>condition</i> is a free freature; non-empty otherwise
-</ol>
-
-<p>
-Semantics only affect targets built with the specified toolset, and depend on
-the form of condition:
-
-<ul>
-<li> For targets whose build-properties are a superset of any element of
-condition, values will be appended to the given <i>variable</i>.
-
-<li> for each free property of a built target whose feature is specified by
-condition, the property's value will be appended to the given <i>variable</i>
-</ul>
-In either case, the variable will be set "on" the target so it may be  used in
-the build actions. 
-</ol>
-
-<h3>Example</h3>
-
-<p>The description of the <tt>flags</tt> rule above is actually more complicated
-than it sounds. For example, the following line might be used to specify how
-optimization can be turned off for MSVC:
-
-<blockquote><pre>
-flags msvc CFLAGS &lt;optimization&gt;off : /Od ;
-</pre></blockquote>
-
-It says that the string <tt>/Od</tt> should be added to the global
-<tt>CFLAGS</tt> variable whenever a build configuration includes the property
-<tt>&lt;optimization&gt;off</tt>. 
-
-<p>Similarly, in the following example,
-<blockquote><pre>
-flags msvc CFLAGS &lt;runtime-build&gt;release/&lt;runtime-link&gt;dynamic/&lt;threading&gt;multi : /MD ;
-</pre></blockquote>
-
-we add <tt>/MD</tt> to the CFLAGS variable when all of the specified conditions
-are satisfied. We could grab all of the values of the free feature
-<tt>&lt;include&gt;</tt> in the <tt>HDRS</tt> variable as follows:
-
-<blockquote><pre>
-flags msvc HDRS &lt;include&gt; ;
-</pre></blockquote>
-
-<p>The use of these variables should be apparent from the declaration of
-<tt>actions msvc-C++-action</tt> in the previous section.
-
-    <hr>
-
-    <p>&copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
-    sell and distribute this document is granted provided this copyright notice
-    appears in all copies. This document is provided "as is" without express or
-    implied warranty, and with no claim as to its suitability for any purpose. 
-
-    <p>Revised 
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
-    -->3 June, 2001<!--webbot bot="Timestamp" endspan i-checksum="28779" -->

build/features.jam

@@ -1,134 +0,0 @@
-# feature name : [values...] : [ PATH ]
-#
-# Declares a feature with the given name. If values is empty, declares a free
-# feature; declares a simple feature otherwise. "PATH" should be supplied for a
-# free feature whose values might be paths specified relative to the
-# (sub)project directory.
-rule feature
-{
-    gUNGRISTED(<$(<)>) = $(<) ;
-    gFEATURE_VALUES(<$(<)>) = $(>) ;
-    
-    if ( ! $(>) ) && ! ( <$(<)> in $(gFREE_FEATURES) )
-    {
-        gFREE_FEATURES += <$(<)> ;
-        if PATH in $(3)
-        {
-            gPATH_FEATURES += <$(<)> ;
-        }
-    }
-    else
-    {
-        if PATH in $(3)
-        {
-            ECHO "Simple feature" <$(<)> "qualified with PATH in 3rd"
-                  "argument. PATH ignored." ;
-        }
-    }
-}
-
-rule ungrist
-{
-    local result = ; 
-    local x ;
-    for x in $(<)
-    {
-        if ! $(x:G)
-        {
-            result += $(x) ;
-        }
-        else if $(gUNGRISTED($(x)))
-        {
-            result += $(gUNGRISTED($(x))) ;
-        }
-        else
-        {
-            EXIT gUNGRISTED($(x)) "not defined!" ;
-        }
-    }
-    return $(result) ;
-}
-
-feature profiling : off on ;
-feature struct-alignment : auto 1 2 4 8 16 ;
-feature eh-model : default fast msvc ; # metrowerks only
-
-feature threading : single multi ;
-
-feature runtime-link : dynamic static ;
-feature runtime-build : debug release ;
-
-feature optimization : off speed space ;
-feature inlining : off on full ;
-feature debug-symbols : on off : ;
-feature user-interface : console gui : ;
-
-feature wide-character-support : on off ;
-feature exception-handling : on off ;
-
-feature define : : ; # <define>PYTHON=foo
-feature undef : : ; # <undef>PYTHON=foo
-feature "include" : : PATH ; # <include>../foo/bar/mumble
-
-# feature-default <feature>...
-#
-# return the default values for the given feature(s)
-rule feature-default
-{
-    local result f ;
-    for f in $(<)
-    {
-        result += $(f)$(gFEATURE_VALUES($(f))[1]) ;
-    }
-    return $(result) ;
-}
-
-rule variant # name : properties
-{
-    local toolset ;
-    for toolset in $(TOOLS)
-    {
-        # We hijack select-properties to do our dirty work here.
-        # Because properties in a variant declaration are only qualified with
-        # toolset and not variant, we specify the toolset where
-        # select-properties expects a variant name. The first toolset parameter
-        # is neccessary to get the relevant-features correctly set. We supply
-        # the variant name as the target name, so that error messages will look
-        # coherent.
-        gBASE_PROPERTIES($(toolset),$(<))
-            = [ sort [ select-properties $(toolset) $(toolset) $(<) : $(>) ] ] ;
-    }
-}
-
-common-properties = 
-    <profiling>off
-    <struct-alignment>auto
-    <eh-model>default
-    # <threading>multi
-    <user-interface>console
-    <wide-character-support>on
-    <exception-handling>on
-    # <runtime-link>dynamic
-    ;
-    
-variant debug :
-    $(common-properties)
-    <threading>multi
-    <debug-symbols>on
-    <runtime-build>debug
-    <optimization>off
-    <inlining>off
-    <borland><inlining>on # example only
-    ;
-
-variant release : 
-    $(common-properties)
-    <threading>multi
-    <debug-symbols>off
-    <runtime-build>release
-    <optimization>speed
-    <inlining>full
-    <msvc><inlining>off # - example only
-    <define>NDEBUG ;
-
-

build/foo.cpp

@@ -1,194 +0,0 @@
-#include <boost/smart_ptr.hpp>
-#include <memory> // for std::auto_ptr
-#include <iostream>
-#include <boost/type_traits.hpp>
-#include <typeinfo>
-
-#define CheckPoint \
-std::cout << __FILE__ << "(" << __LINE__ << ")" <<  std::endl
-
-struct PyObject {};
-
-namespace python {
-
-  template <class T>
-  struct type {};
-
-  PyObject* to_python(int) {
-      typedef int T;
-    CheckPoint;
-    return 0;
-  }
-
-  template <class T>
-  PyObject* to_python(const T&) {
-    CheckPoint;
-    return 0;
-  }
-
-  template <class T>
-  PyObject* to_python(std::auto_ptr<T>& x) {
-    CheckPoint;
-    return 0;
-  }
-
-  template <class T>
-  PyObject* to_python(boost::shared_ptr<T>& x) {
-    CheckPoint;
-    return 0;
-  }
-
-  template <class T> struct converter;
-
-  // Generalized converter which retrieves a non-const reference to T.
-  template <class T>
-  struct converter<T&>
-  {
-      typedef T& value_type;
-      static value_type from_python(PyObject* p)
-      {
-          CheckPoint;
-          static T t;
-          return t;
-      }
-  };
-
-  // If the user requests T by value, we can hijack semantics for T const&,
-  // except in the case of std::auto_ptr, for which we have a specialization.
-  template <class T>
-  struct converter : converter<T const&> {};
-
-  // For T*, we use the semantics of T& and take the address of the result
-  template <class T>
-  struct converter<T*>
-  {
-      typedef T* value_type;
-      static value_type from_python(PyObject* p)
-      {
-          CheckPoint;
-          return &converter<T&>::from_python(p);
-      }
-  };
-
-  // trying to get a T*& should raise a compile error, since that pointer must
-  // not be modified.
-  template <class T> struct non_const_reference_to_pointer_parameter_not_wrappable;
-  template <class T>
-  struct converter<T*&> : non_const_reference_to_pointer_parameter_not_wrappable<T*&> {};
-
-  // T* const& can use the T* semantics: the const& will bind to the temporary
-  // return value.
-  template <class T>
-  struct converter<T* const&> : converter<T*> {};
-
-  // No specialization for converter<T const*> because compiler will select
-  // converter<U*> where U* == T const*
-
-  template <class T>
-  struct converter<std::auto_ptr<T>&>
-  {
-      typedef std::auto_ptr<T>& value_type;
-      static value_type from_python(PyObject* p)
-      {
-          CheckPoint;
-          static std::auto_ptr<T> t(new T);
-          return t;
-      }
-  };
-
-  // Specialization for std::auto_ptr<T> because it is an exception to the rule
-  // that a requeset for T can always be satisfied by the result of a request
-  // for T const&.
-  template <class T>
-  struct converter<std::auto_ptr<T> >
-  {
-      typedef std::auto_ptr<T> value_type;
-      static value_type from_python(PyObject* p)
-      {
-          CheckPoint;
-          static std::auto_ptr<T> t(new T);
-          return t;
-      }
-  };
-
-  template <class T>
-  struct converter<boost::shared_ptr<T>&>
-  {
-      typedef boost::shared_ptr<T>& value_type;
-      static value_type from_python(PyObject* p)
-      {
-          CheckPoint;
-          static boost::shared_ptr<T> t(new T);
-          return t;
-      }
-  };
-
-  // No specialization for converter<T const&> because compiler will select
-  // converter<U&> where U& == T const&
-
-  // remove top-level const for completeness
-  template <class T>
-  typename converter<typename boost::remove_const<T>::type>::value_type
-  from_python(PyObject * p, python::type<T> t) {
-    return converter<typename boost::remove_const<T>::type>::from_python(p);
-  }
-}
-
-namespace application {
-
-  struct user { user() {} };
-}
-
-template <class T>
-void f(T) {};
-
-int main()
-{
-  PyObject* pyobj;
-
-  int i = 1;
-  pyobj = python::to_python(i);
-
-  application::user u;
-  pyobj = python::to_python(u);
-
-  std::auto_ptr<application::user> a(new application::user);
-  pyobj = python::to_python(a);
-
-  boost::shared_ptr<application::user> s(new application::user);
-  pyobj = python::to_python(s);
-
-  f<application::user>(python::from_python(pyobj, python::type<application::user>()));
-  f<application::user const>(python::from_python(pyobj, python::type<application::user const>()));
-  f<application::user&>(python::from_python(pyobj, python::type<application::user&>()));
-  f<application::user const&>(python::from_python(pyobj, python::type<application::user const&>()));
-  f<application::user*>(python::from_python(pyobj, python::type<application::user*>()));
-  f<application::user const*>(python::from_python(pyobj, python::type<application::user const*>()));
-  f<application::user*const&>(python::from_python(pyobj, python::type<application::user*const&>()));
-  f<application::user const*const&>(python::from_python(pyobj, python::type<application::user const*const&>()));
-
-  // Expected to cause an error
-//  f<application::user*&>(python::from_python(pyobj, python::type<application::user*&>()));
-
-  f<std::auto_ptr<application::user> >(python::from_python(pyobj, python::type<std::auto_ptr<application::user> >()));
-  f<std::auto_ptr<application::user>&>(python::from_python(pyobj, python::type<std::auto_ptr<application::user>&>()));
-  f<std::auto_ptr<application::user> const&>(python::from_python(pyobj, python::type<std::auto_ptr<application::user> const&>()));
-
-  f<boost::shared_ptr<application::user>&>(python::from_python(pyobj, python::type<boost::shared_ptr<application::user>&>()));
-  f<boost::shared_ptr<application::user> >(python::from_python(pyobj, python::type<boost::shared_ptr<application::user> >()));
-  f<boost::shared_ptr<application::user> const&>(python::from_python(pyobj, python::type<boost::shared_ptr<application::user> const&>()));
-}
-
-#if 0
-#include "foo.h"
-
-foo::foo() : x(20) {}
-
-int main()
-{
-    foo y;
-    y.x[1] = 0;
-    return 0;
-}
-
-#endif

build/foo.h

@@ -1,7 +0,0 @@
-#include <vector>
-
-struct foo
-{
-    std::vector<int> x;
-    foo();
-};

build/gcc-stlport-tools.jam

@@ -1,76 +0,0 @@
-gcc.bin-directory = [ conditional $(gcc.root-directory) : $(gcc.root-directory)$(SLASH)bin$(SLASH) : " " ] ;
-detect-build-tools gcc : "g++ -v" ;
-
-flags gcc-stlport LINKFLAGS <runtime-link>static : -static ;
-flags gcc-stlport CFLAGS <debug-symbols>on : -g ;
-flags gcc-stlport LINKFLAGS <debug-symbols>on : -g ;
-flags gcc-stlport CFLAGS <optimization>off : -O0 ;
-flags gcc-stlport CFLAGS <optimization>speed : -O3 ;
-flags gcc-stlport CFLAGS <optimization>space : -O2 ;
-flags gcc-stlport CFLAGS <inlining>off : -fno-inline ;
-flags gcc-stlport CFLAGS <inlining>on : -Wno-inline ;
-flags gcc-stlport CFLAGS <inlining>full : -finline-functions -Wno-inline ;
-
-flags gcc-stlport DEFINES <define> ;
-flags gcc-stlport UNDEFS <undef> ;
-flags gcc-stlport HDRS <include> ;
-
-flags gcc-stlport STDHDRS : $(stl-port-root)$(SLASH)stlport $(gcc-stlport.root-directory)$(SLASH)include ;
-flags gcc-stlport STDLIBPATH :  $(gcc-stlport.root-directory)$(SLASH)lib ;
-
-flags gcc-stlport LINKFLAGS <runtime-link>static : -static ;
-flags gcc-stlport STLPORTPATH  : $(stl-port-root)$(SLASH)lib ;
-
-flags gcc-stlport CFLAGS     <runtime-build>debug    : -D_REENTRANT -D__STL_DEBUG ;
-flags gcc-stlport CFLAGS     <runtime-build>release  : -D_REENTRANT ;
-
-flags gcc-stlport STLPORTLIB <runtime-build>debug    : stlport_cygwin_stldebug ;
-flags gcc-stlport STLPORTLIB <runtime-build>release  : stlport_cygwin ;
-                              
-#### Link ####
-
-rule Link-action
-{
-    gcc-Link-action $(<) : $(>) ;
-}
-
-# for gcc, we repeat all libraries so that dependencies are always resolved
-actions gcc-Link-action bind NEEDLIBS
-{
-    $(gcc.bin-directory)g++ $(LINKFLAGS) -o $(<) $(UNDEFS) -L$(STLPORTPATH) -L$(STDLIBPATH) $(>) $(NEEDLIBS) $(NEEDLIBS) -l$(STLPORTLIB)
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    gcc-Cc-action $(<) : $(>) ;
-}
-
-actions gcc-Cc-action
-{
-    $(gcc.bin-directory)gcc -c  -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o$(<) $(>)
-}
-
-#### C++ ####
-rule C++-action
-{
-    gcc-C++-action $(<) : $(>) ;
-}
-
-actions gcc-C++-action
-{
-    $(gcc.bin-directory)g++ -c  -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o$(<) $(>)
-}
-
-#### Archive ####
-rule Archive-action
-{
-    gcc-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal gcc-Archive-action
-{
-    ar ru $(<) $(>)
-}
-

build/gcc-tools.jam

@@ -1,67 +0,0 @@
-gcc.bin-directory = [ conditional $(gcc.root-directory) : $(gcc.root-directory)$(SLASH)bin$(SLASH) : " " ] ;
-detect-build-tools gcc : "g++ -v" ;
-
-flags gcc LINKFLAGS <runtime-link>static : -static ;
-flags gcc CFLAGS <debug-symbols>on : -g ;
-flags gcc LINKFLAGS <debug-symbols>on : -g ;
-flags gcc CFLAGS <optimization>off : -O0 ;
-flags gcc CFLAGS <optimization>speed : -O3 ;
-flags gcc CFLAGS <optimization>space : -O2 ;
-flags gcc CFLAGS <inlining>off : -fno-inline ;
-flags gcc CFLAGS <inlining>on : -Wno-inline ;
-flags gcc CFLAGS <inlining>full : -finline-functions -Wno-inline ;
-
-flags gcc DEFINES <define> ;
-flags gcc UNDEFS <undef> ;
-flags gcc HDRS <include> ;
-
-flags gcc STDHDRS : $(gcc.root-directory)$(SLASH)include ;
-flags gcc STDLIBPATH : $(gcc.root-directory)$(SLASH)lib ;
-
-#### Link ####
-
-rule Link-action
-{
-    gcc-Link-action $(<) : $(>) ;
-}
-
-# for gcc, we repeat all libraries so that dependencies are always resolved
-actions gcc-Link-action bind NEEDLIBS
-{
-    $(gcc.bin-directory)g++ $(LINKFLAGS) -o $(<) $(UNDEFS) -L$(STDLIBPATH) $(>) $(NEEDLIBS) $(NEEDLIBS)
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    gcc-Cc-action $(<) : $(>) ;
-}
-
-actions gcc-Cc-action
-{
-    $(gcc.bin-directory)gcc -c  -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o$(<) $(>)
-}
-
-#### C++ ####
-rule C++-action
-{
-    gcc-C++-action $(<) : $(>) ;
-}
-
-actions gcc-C++-action
-{
-    $(gcc.bin-directory)g++ -c  -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o$(<) $(>)
-}
-
-#### Archive ####
-rule Archive-action
-{
-    gcc-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal gcc-Archive-action
-{
-    ar ru $(<) $(>)
-}
-

build/kcc-tools.jam

@@ -1,50 +0,0 @@
-kcc.bin-directory = [ conditional $(kcc.root-directory) : $(kcc.root-directory)$(SLASH)bin$(SLASH) : " " ] ;
-detect-build-tools kcc : "KCC" ;
-
-#### Link ####
-
-rule Link-action
-{
-    kcc-Link-action $(<) : $(>) ;
-}
-
-actions kcc-Link-action bind NEEDLIBS
-{
-    $(kcc.bin-directory)KCC $(LINKFLAGS) -o $(<) $(UNDEFS) -L$(STDLIBPATH) $(NEEDLIBS) $(>)
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    kcc-Cc-action $(<) : $(>) ;
-}
-
-actions kcc-Cc-action
-{
-    $(kcc.bin-directory)KCC -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o $(<) $(>)
-}
-
-#### C++ ####
-rule C++-action
-{
-    kcc-C++-action $(<) : $(>) ;
-}
-
-actions kcc-C++-action
-{
-    $(kcc.bin-directory)KCC -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o $(<) $(>)
-}
-
-
-#### Archive ####
-rule Archive-action
-{
-    kcc-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal kcc-Archive-action
-{
-    KCC -g -o $(<) $(>)
-}
-

build/metrowerks-tools.jam

@@ -1,73 +0,0 @@
-# Metrowerks
-local msl-c++-path = $(metrowerks.root-directory)$(SLASH)MSL$(SLASH)MSL_C++$(SLASH) ;
-
-flags metrowerks STDLIBPATH : $(msl-c++-path)MSL_Win32$(SLASH)Lib$(SLASH)x86 ;
-flags metrowerks STDHDRS : $(msl-c++-path)MSL_Common$(SLASH)Include ;
-
-flags metrowerks DEFINES <define> ;
-flags metrowerks UNDEFS <undef> ;
-flags metrowerks HDRS <include> ;
-
-flags metrowerks CFLAGS <debug-symbols>on : -g ;
-flags metrowerks LINKFLAGS <debug-symbols>on : -g ;
-flags metrowerks CFLAGS <optimization>off : -O0 ;
-flags metrowerks CFLAGS <optimization>speed : -Op ;
-flags metrowerks CFLAGS <optimization>space : -Os ;
-flags metrowerks CFLAGS <inlining>off : -inline off ;
-flags metrowerks CFLAGS <inlining>on : -inline on ;
-flags metrowerks CFLAGS <inlining>full : -inline auto -inline level=8 ;
-
-metrowerks.bin-directory = " " ;
-detect-build-tools metrowerks : mwcc ;
-
-if $(metrowerks.root-directory)
-{
-    metrowerks.bin-directory = "$(.metrowerks.root-directory)$(SLASH)Other Metrowerks Tools$(SLASH)Command Line Tools$(SLASH)" ;
-}
-
-#### Link ####
-
-rule Link-action
-{
-    metrowerks-Link-action $(<) : $(>) ;
-}
-
-actions metrowerks-Link-action bind NEEDLIBS
-{
-    "$(metrowerks.bin-directory)mwld" -msgstyle gcc $(LINKFLAGS) -o $(<) $(UNDEFS) -L$(STDLIBPATH) $(NEEDLIBS) $(>)
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    metrowerks-Cc-action $(<) : $(>) ;
-}
-
-actions metrowerks-Cc-action
-{
-    "$(metrowerks.bin-directory)mwcc" -c  -U$(UNDEFS) -D$(DEFINES) -msgstyle gcc -nowraplines $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o $(<) $(>)
-}
-
-#### C++ ####
-rule C++-action
-{
-    metrowerks-C++-action $(<) : $(>) ;
-}
-
-actions metrowerks-C++-action
-{
-    "$(metrowerks.bin-directory)mwcc" -c  -U$(UNDEFS) -D$(DEFINES) -msgstyle gcc -nowraplines -lang c++ $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -o $(<) $(>)
-}
-
-#### Archive ####
-rule Archive-action
-{
-    metrowerks-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal metrowerks-Archive-action
-{
-    mwld -library -o $(<) $(>)
-}
-

build/msvc-tools.jam

@@ -1,75 +0,0 @@
-# Microsoft Visual C++
-flags msvc CFLAGS <debug-symbols>on : /Zi ;
-flags msvc LINKFLAGS <debug-symbols>on : /DEBUG ;
-
-flags msvc CFLAGS <optimization>off : /Od ;
-flags msvc CFLAGS <optimization>speed : /O2 ;
-flags msvc CFLAGS <optimization>space : /O1 ;
-flags msvc CFLAGS <inlining>off : /Ob0 ;
-flags msvc CFLAGS <inlining>on : /Ob1 ;
-flags msvc CFLAGS <inline>full : /Ob2 ;
-
-flags msvc CFLAGS <runtime-build>release/<runtime-link>dynamic/<threading>multi : /MD ;
-flags msvc CFLAGS <runtime-build>debug/<runtime-link>dynamic/<threading>multi : /MDd ;
-flags msvc CFLAGS <runtime-build>release/<runtime-link>static/<threading>single : /ML ;
-flags msvc CFLAGS <runtime-build>debug/<runtime-link>static/<threading>single : /MLd ;
-flags msvc CFLAGS <runtime-build>release/<runtime-link>static/<threading>multi : /MT ;
-flags msvc CFLAGS <runtime-build>debug/<runtime-link>static/<threading>multi : /MTd ;
-
-flags msvc DEFINES <define> ;
-flags msvc UNDEFS <undef> ;
-flags msvc HDRS <include> ;
-
-flags msvc STDHDRS : $(msvc.root-directory)$(SLASH)include ;
-flags msvc STDLIBPATH : $(msvc.root-directory)$(SLASH)lib ;
-
-msvc.bin-directory = [ conditional $(msvc.root-directory) : $(msvc.root-directory)$(SLASH)bin$(SLASH) : " " ] ;
-detect-build-tools msvc : cl ;
-
-#### Link ####
-
-rule Link-action
-{
-    msvc-Link-action $(<) : $(>) ;
-}
-
-actions msvc-Link-action bind NEEDLIBS bind pdb-name
-{
-    $(msvc.bin-directory)link /nologo $(LINKFLAGS) /PDB:$(<:S=.pdb) /out:$(<) $(UNDEFS) /LIBPATH:$(STDLIBPATH) $(NEEDLIBS) $(>)
-}
-
-#### Cc #####
-
-rule Cc-action
-{
-    msvc-Cc-action $(<) : $(>) ;
-}
-
-actions msvc-Cc-action
-{
-    $(msvc.bin-directory)cl -nologo -c -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(CCFLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -Fo$(<) $(>)
-}
-
-#### C++ ####
-rule C++-action
-{
-    msvc-C++-action $(<) : $(>) ;
-}
-
-actions msvc-C++-action
-{
-    $(msvc.bin-directory)cl -nologo -GX -c -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) $(OPTIM) -I$(HDRS) -I$(STDHDRS) -Fo$(<) -Tp$(>)
-}
-
-#### Archive ####
-rule Archive-action
-{
-    msvc-Archive-action $(<) : $(>) ;
-}
-
-actions updated together piecemeal msvc-Archive-action
-{
-	if exist $(<) set _$(<:B)_=$(<)
-	link /lib /out:$(<) %_$(<:B)_% $(>)
-}
-

build/top.cpp

@@ -1,7 +0,0 @@
-#include "top.hpp"
-#include <iostream>
-
-void top()
-{
-    std::cout << "hello from top" << std::endl ;
-}

build/top.hpp

@@ -1 +0,0 @@
-void top(); //

build/x/Jamfile

@@ -1,11 +0,0 @@
-SubDir TOP x ;
-
-lib xl : xl.cpp ../top.cpp ;
-exe x : x.cpp <lib>xl ;
-
-# Says to build an executable here called y using the source file in ../y/y.cpp,
-# which contains a Jamfile. If it didn't contain a Jamfile, we'd write
-#       <nojam>.. y y.cpp
-# instead.
-# multi-target-executable y : <jam>.. y y.cpp ;
-

build/x/x.cpp

@@ -1,15 +0,0 @@
-#include "x.hpp"
-#include "xl.hpp"
-#include "../top.hpp"
-
-foo::foo() : x(20) {}
-
-int main()
-{
-    foo y;
-    y.x[1] = 0;
-    xl();
-    top();
-    return 0;
-}
-

build/x/x.hpp

@@ -1,7 +0,0 @@
-#include <vector>
-
-struct foo
-{
-    std::vector<int> x;
-    foo();
-};

build/x/x.map

@@ -1,6 +0,0 @@
-
- Start         Length     Name                   Class
- 0001:00401000 000008BFCH _TEXT                  CODE
- 0002:0040A000 0000038D4H _DATA                  DATA
- 0003:0040D8D4 000000870H _BSS                   BSS
- 0004:00000000 00000009CH _TLS                   TLS

build/x/xl.cpp

@@ -1,7 +0,0 @@
-#include "xl.hpp"
-#include <iostream>
-
-void xl()
-{
-    std::cout << "hello from xl" << std::endl ;
-}

build/x/xl.hpp

@@ -1,3 +0,0 @@
-#include "../top.hpp"
-
-void xl();

build/y/Jamfile

@@ -1,4 +0,0 @@
-SubDir TOP y ;
-
-exe y : y.cpp <lib>../top : <include>.. ;
-exe foo : foo.cpp ;

build/y/foo.cpp

@@ -1,11 +0,0 @@
-#include "foo.h"
-
-foo::foo() : x(20) {}
-
-int main()
-{
-    foo y;
-    y.x[1] = 0;
-    return 0;
-}
-

build/y/foo.h

@@ -1,7 +0,0 @@
-#include <vector>
-
-struct foo
-{
-    std::vector<int> x;
-    foo();
-};

build/y/y.cpp

@@ -1,13 +0,0 @@
-#include "y.hpp"
-#include "top.hpp"
-
-foo::foo() : x(20) {}
-
-int main()
-{
-    foo y;
-    y.x[1] = 0;
-    top();
-    return 0;
-}
-

build/y/y.hpp

@@ -1,7 +0,0 @@
-#include <vector>
-
-struct foo
-{
-    std::vector<int> x;
-    foo();
-};