Jambase #3

#
# /+\
# +\    Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
# \+/
  JAMBASEDATE = 2004.07.24 ;
#
# This file is part of Jam - see jam.c for Copyright information.
# 05/17/04 (dunbar)- Support for Siebel 
#
#
# JAMBASE - jam 2.5 ruleset providing make(1)-like functionality
#
# 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 and Actions defined by this file:
#
# Archive lib : source ;                archive library from compiled sources
# ArchiveFromObjects lib : objects ;    archive library from objects
# 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
# 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 ;                shared library from compiled sources
# LibraryFromObjects lib : objects ;    shared 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
# ObjectDefines
# ObjectHdrs source : dirs ;            add include directories for object
# Objects sources ;                     compile sources
# Resource  xxx : yyy ;                 resource compiler
# RmTemps target : sources ;            remove temp sources after target made
# Setuid images ;                       mark executables Setuid
# Shell exe : source ;                  make a shell executable
# SoftLink target : source ;            make symlink from source to target
# 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 d1 d2 ... ;                add include dir until next SubDir
# SubInclude TOP d1 d2 ... ;            include a subdirectory Jamfile
# SubRules
# 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
# Fdefines
# 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))
# FStripCommon v1 : v2 ;                strip common initial parts of v1 v2
# FSubDirPath
# FReverse a1 a2 ... ;                  return ... a2 a1
# FRelPath d1 : d2 ;                    return rel path from d1 to d2
# FSubDir d1 d2 ... ;                   return path to root
# FDefines
# FIncludes
# FQuote

# Brief review of the jam language:
#
# Statements:
#       rule RULE - statements to process a rule
#       actions RULE - system commands to carry out target update
#
# Modifiers on actions:
#       together - multiple instances of same rule on target get executed
#                  once with their sources ($(>)) concatenated
#       updated - refers to updated sources ($(>)) only
#       ignore - ignore return status of command
#       quietly - don't trace its execution unless verbose
#       piecemeal - iterate command each time with a small subset of $(>)
#       existing - refers to currently existing sources ($(>)) only
#       bind vars - subject to binding before expanding in actions
#
# Special rules:
#       Always - always build a target
#       Depends - builds the dependency graph
#       Echo - blurt out targets on stdout
#       Exit - blurt out targets and exit
#       Includes - marks sources as headers for target (a codependency)
#       NoCare - don't panic if the target can't be built
#       NoUpdate - create the target if needed but never update it
#       NotFile - ignore the timestamp of the target (it's not a file)
#       Temporary - target need not be present if sources haven't changed
#
# Special variables set by jam:
#       $(<) - targets of a rule (to the left of the :)
#       $(>) - sources of a rule (to the right of the :)
#       $(xxx) - true on xxx (UNIX, VMS, NT, OS2, MAC)
#       $(OS) - name of OS - varies wildly
#       $(JAMVERSION) - version number (2.5)
#
# 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) {
        MV              ?= move /y ;
        CP              ?= xcopy ;
        RM              ?= del /f/q ;
        RMDIR           ?= rmdir /s/q ;
        SLASH           ?= \\ ;
        SUFDLL          ?= .dll ;
        SUFLIB          ?= .lib ;
        SUFOBJ          ?= .obj ;
        SUFEXE          ?= .exe ;
     if $(MSVCDIR) { # Visual C++ 6.0 uses MSVCDIR
        AR              ?= lib ;
        AS              ?= masm386 ;
        CC              ?= $(MSVCDIR)\\bin\\cl /nologo ;             
        CCFLAGS         ?= "" ;
        C++             ?= $(CC) ;
        C++FLAGS        ?= $(CCFLAGS) ;
        LIBDIR          ?= $(MSVCDIR)\\lib ;
        LIBFLAGS        ?= "" ;
        LINK            ?= $(MSVCDIR)\\bin\\link /nologo ;            
        LINKFLAGS       ?= "" ;
        LINKLIBS        ?= $(LIBDIR)\\kernel32.lib $(LIBDIR)\\oldnames.lib ;
        OPTIM           ?= "" ;
        RC              ?= rc ;
        STDHDRS         ?= $(MSVCDIR)\\include ;
        UNDEFFLAG       ?= "/u _" ;
    } else if $(DMCDIR) {
        CC              ?= $(DMCDIR)\\bin\\dmc.exe ;
        CCFLAGS         ?= "" ;
        C++             ?= $(CC) ;
        C++FLAGS        ?= $(CCFLAGS) ;
        LIBDIR          ?= $(DMCDIR)\\lib ;
        LIBFLAGS        ?= "" ;
        LINK            ?= $(DMCDIR)\\bin\\link /nologo ;
        LINKFLAGS       ?= "" ;
        LINKLIBS        ?= $(DMCDIR)\\lib\\kernel32.lib $(DMCDIR)\\lib\\oldnames.lib ;
        OPTIM           ?= "" ;
        RC              ?= "" ;
        STDHDRS         ?= $(DMCDIR)\\Include ;
        UNDEFFLAG       ?= "-u " ;
    } else {
        Echo set MSVCDIR=d:\\progra~1\\micros~1\\vc98 ;
        EXIT On NT, set MSVCDIR to the root of the Microsoft directories. ;
    }
} else if $(UNIX) {
    switch $(OS) {
    case AIX :
        CC              ?= xlc_r ;
        C++             ?= xlC_r ;
        LIBFLAGS        ?= "-qmkshrobj -qtwolink -G -bnoerok -bf" ;
    case HPUX :
        RANLIB          ?= "" ;
    case SOLARIS :
        CC              ?= /opt/SUNWspro/bin/cc ;
        C++             ?= /opt/SUNWspro/bin/CC ;
        RANLIB          ?= "" ;
        AR              ?= "/usr/ccs/bin/ar ru" ;
    }
    # UNIX defaults
    CCFLAGS         ?= ;
    C++FLAGS        ?= $(CCFLAGS) ;
    CHMOD           ?= chmod ;
    CHGRP           ?= chgrp ;
    CHOWN           ?= chown ;
    LEX             ?= lex ;
    LINKFLAGS       ?= $(CCFLAGS) ;
    LINKLIBS        ?= ;
    OPTIM           ?= -O ;
    RANLIB          ?= ranlib ;
    YACC            ?= yacc ;
    YACCGEN         ?= .c ;
    YACCFILES       ?= y.tab ;
    YACCFLAGS       ?= -d ;
    }
#
# General defaults; a lot like UNIX
#
    AR              ?= ar ru ;
    AS              ?= as ;
    ASFLAGS         ?= ;
    AWK             ?= awk ;
    BINDIR          ?= /usr/local/bin ;
    C++             ?= cc ;
    C++FLAGS        ?= ;
    CC              ?= cc ;
    CCFLAGS         ?= ;
    CP              ?= cp -f ;
    DOT             ?= . ;
    DOTDOT          ?= .. ;
    EXEFLAGS        ?= ;
    EXEMODE         ?= 755 ;
    FILEMODE        ?= 644 ;
    HDRS            ?= ;
    INSTALLGRIST    ?= installed ;
    JAMFILE         ?= Jamfile ;
    JAMRULES        ?= Jamrules ;
    LEX             ?= ;
    LIBDIR          ?= /usr/local/lib ;
    LINK            ?= $(C++) ;                         # ?? $(CC) Linking is compiler dependent.
    LINKFLAGS       ?= ;
    LINKLIBS        ?= ;
    LN              ?= ln ;
    MANDIR          ?= /usr/local/man ;
    MKDIR           ?= mkdir ;
    MV              ?= mv -f ;
    OPTIM           ?= ;
    OSFULL           = $(OS)$(OSVER)$(OSPLAT) ;
    RCP             ?= rcp ;
    RM              ?= rm -f ;
    RMDIR           ?= $(RM) ;
    RSH             ?= rsh ;
    SED             ?= sed ;
    SHELLHEADER     ?= "#!/bin/sh" ;
    SHELLMODE       ?= 755 ;
    SLASH           ?= / ;
    STDHDRS         ?= /usr/include ;
    SUBDIRRULES     ?= ;
    SUBDIRRESET     ?= ASFLAGS HDRS C++FLAGS CCFLAGS DEFINES ;    # There is no SUBDIRDEFINES ??
    SUFEXE          ?= "" ;
    SUFDLL          ?= .so ;                            # MS centric. Unix uses .so suffix
    SUFLIB          ?= .so ;                            # MS has .lib and .dll
    SUFOBJ          ?= .o ;
    UNDEFFLAG       ?= "-u _" ;
    YACC            ?= ;
    YACCGEN         ?= ;
    YACCFILES       ?= ;
    YACCFLAGS       ?= ;
# Caution: HDRPATTERN contains 3 <blank><tab>  char sequences.  Do not remove/expand tabs.
    HDRPATTERN = "^[ 	]*#[ 	]*include[ 	]*[<\"]([^\">]*)[\">].*$" ;
#   HDRPATTERN = "^[ T]*#[ T]*include[ T]*[<\"]([^\">]*)[\">].*$" ;  (tabs (\t) shown as "T"

# Base dependencies - first for "bootstrap" kinds of rules ;
NotFile all clean dirs exe files first lib obj shell uninstall ;
Depends all : exe lib files obj shell ;
Depends all   exe lib files obj shell : first ;
Always clean uninstall ;

#
# Rules
#

rule    Archive {
        ArchiveFromObjects $(<) : $(>:S=$(SUFOBJ)) ; # :Suffix
        Objects $(>) ;
        }
rule    ArchiveFromObjects {
        local _file _lib _src ;
        _src = [ FGristFiles $(>) ] ;              # Add grist to file names
        _lib = $(<:S=$(SUFLIB)) ;                  # Archive :Suffix
        if $(KEEPOBJS) { Depends obj : $(_src) ; # library depends on its member objects
        } else         { Depends lib : $(_lib) ; }
        if ! $(_lib:D) { MakeLocate $(_lib) $(_lib)($(_src:BS)) : $(LOCATE_TARGET) ; } # :Base/:Suffix/:Directory
        if $(NOARSCAN) {
            Depends $(_lib) : $(_src) ;
        } else {
            Depends $(_lib) : $(_lib)($(_src:BS)) ;   # :Base/:Suffix
            for _file in $(_src) {
                Depends $(_lib)($(_file:BS)) : $(_file) ;   # :Base/:Suffix
                }
            }
        Clean clean : $(_lib) ;
        FArchive $(_lib) : $(_src) ;
        if $(RANLIB) { Ranlib $(_lib) ; }
        if ! ( $(NOARSCAN) || $(NOARUPDATE) ) { RmTemps $(_lib) : $(_src) ; }
        }
actions updated together piecemeal FArchive { $(AR) $(<) $(>) }
actions together Ranlib { $(RANLIB) $(<) }
rule    As {
        Depends $(<) : $(>) ;
        ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;
        ASHDRS on $(<) = [ FIncludes $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS) ] ;
        }
actions As       { $(AS) $(ASFLAGS) $(ASHDRS) -o $(<) $(>) }
rule    Bulk {
        local _file ;
        for _file in $(>) {
            File $(_file:D=$(<)) : $(_file) ;            # :Directory
            }
        }
rule    Cc {
        Depends $(<) : $(>) ;
        # Just to clarify here: this sets the per-target CCFLAGS to
        # be the current value of (global) CCFLAGS and SUBDIRCCFLAGS.
        # CCHDRS and CCDEFS must be reformatted each time for some
        # compiles (NT) that malign multiple -D or -I flags.
        CCFLAGS on $(<) += $(CCFLAGS) $(SUBDIRCCFLAGS) $(OPTIM) ;
        CCHDRS  on $(<) = [ on $(<) FIncludes $(HDRS) ] ;
        CCDEFS  on $(<) = [ on $(<) FDefines  $(DEFINES) ] ;
        }
actions Cc       { $(CC)  $(CCFLAGS)  $(CCDEFS) $(CCHDRS) $(>) -c -o $(<) }
rule    C++ {
        Depends $(<) : $(>) ;
        C++FLAGS on $(<) += $(C++FLAGS) $(SUBDIRC++FLAGS) $(OPTIM) ;
        CCHDRS   on $(<) = [ on $(<) FIncludes $(HDRS) ] ;
        CCDEFS   on $(<) = [ on $(<) FDefines  $(DEFINES) ] ;
        }
actions C++      { $(C++) $(C++FLAGS) $(CCDEFS) $(CCHDRS) $(>) -c -o $(<) }
rule    C++Flags { C++FLAGS += $(<) ; }
actions Chgrp    { $(CHGRP) $(GROUP) $(<) }
rule    Chmod    { if $(CHMOD) { Chmod1 $(<) ; } }
actions Chmod1   { $(CHMOD) $(MODE) $(<) }
actions Chown    { $(CHOWN) $(OWNER) $(<) }
actions piecemeal together existing Clean { $(RM) $(>) }  # ??
rule    Defines { DEFINES += $(<) ; }
rule    File {
        Depends files : $(<) ;
        Depends $(<) : $(>) ;
        SEARCH on $(>) = $(SEARCH_SOURCE) ;
        MODE   on $(<) = $(FILEMODE) ;
        Chmod $(<) ;
        }
actions File     { $(CP) "$(>)" $(<) }                       
rule    GenFile {
        local _tgt = [ FGristSourceFiles $(<) ] ;
        local _src = [ FAppendSuffix $(>[1]) : $(SUFEXE) ] ;
        Depends  $(_tgt) : $(_src) $(>[2-]) ;
        GenFile1 $(_tgt) : $(_src) $(>[2-]) ;
        Clean clean : $(_tgt) ;
        }
rule    GenFile1 {
        MakeLocate $(<) : $(LOCATE_SOURCE) ;
        SEARCH on  $(>) = $(SEARCH_SOURCE) ;
        }
actions GenFile1 { PATH="$PATH:." $(>[1]) $(<) $(>[2-]) }
rule    HardLink {
        Depends files : $(<) ;
        Depends $(<) : $(>) ;
        SEARCH on $(>) = $(SEARCH_SOURCE) ;
        }
actions HardLink { $(RM) $(<) && $(LN) $(>) $(<) }
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 _hdr = $(>:G=$(HDRGRIST:E)) ;               # :Grist/:Value
        Includes $(<) : $(_hdr) ;
        SEARCH on $(_hdr) = $(HDRSEARCH) ;
        NoCare $(_hdr) ;
        # Propagate on $(<) to $(>)
        HDRSEARCH on $(_hdr) = $(HDRSEARCH) ;
        HDRSCAN   on $(_hdr) = $(HDRSCAN) ;
        HDRRULE   on $(_hdr) = $(HDRRULE) ;
        HDRGRIST  on $(_hdr) = $(HDRGRIST) ;
        }
actions Install  { $(CP) $(>) $(<) }
rule    InstallInto {            # InstallInto dir : sources ;
        local _src _sfile _tfile ;
        _src = $(>:G=$(INSTALLGRIST)) ;                   # :Grist
        # Arrange for jam install
        # Arrange for jam uninstall
        # sources are in SEARCH_SOURCE
        # targets are in dir
        Depends install : $(_src) ;
        Clean uninstall : $(_src) ;
        SEARCH on $(>) = $(SEARCH_SOURCE) ;
        MakeLocate $(_src) : $(<) ;
        # For each source, make gristed target name
        # and Install, Chmod, Chown, and Chgrp
        for _sfile in $(>) {
            _tfile = $(_sfile:G=$(INSTALLGRIST)) ;        # :Grist
            Depends $(_tfile) : $(_sfile) ;
            Install $(_tfile) : $(_sfile) ;
            Chmod $(_tfile) ;
            if $(OWNER) && $(CHOWN) {
                Chown    $(_tfile) ;
                OWNER on $(_tfile) = $(OWNER) ;
                }
            if $(GROUP) && $(CHGRP) {
                Chgrp    $(_tfile) ;
                GROUP on $(_tfile) = $(GROUP) ;
                }
            }
        }
rule    InstallBin {
        local _tgt = [ FAppendSuffix $(>) : $(SUFEXE) ] ;
        InstallInto $(<) : $(_tgt) ;
        MODE on $(_tgt:G=$(INSTALLGRIST)) = $(EXEMODE) ; # :Grist
        }
rule    InstallFile {
        InstallInto $(<) : $(>) ;
        MODE on $(>:G=$(INSTALLGRIST)) = $(FILEMODE) ; # :Grist
        }
rule    InstallLib {
        InstallInto $(<) : $(>) ;
        MODE on $(>:G=$(INSTALLGRIST)) = $(FILEMODE) ; # :Grist
        }
rule    InstallMan {       # This just strips the . from the suffix
        local _file _suf _dir ;
        for _file in $(>) {
            switch $(_file:S) {                   # :Suffix
              case .1 : _suf = 1 ; case .2 : _suf = 2 ; case .3 : _suf = 3 ;
              case .4 : _suf = 4 ; case .5 : _suf = 5 ; case .6 : _suf = 6 ;
              case .7 : _suf = 7 ; case .8 : _suf = 8 ; case .l : _suf = l ;
              case .n : _suf = n ; case .man : _suf = 1 ;
              }
            _dir = man$(_suf) ;
            InstallInto $(_dir:R=$(<)) : $(_file) ;                   # :Root
            }
        MODE on $(>:G=$(INSTALLGRIST)) = $(FILEMODE) ; # :Grist
        }
rule    InstallShell {
        InstallInto $(<) : $(>) ;
        MODE on $(>:G=$(INSTALLGRIST)) = $(SHELLMODE) ; # :Grist
        }
rule    Lex {
        LexMv   $(<) : $(>) ;
        Depends $(<) : $(>) ;
        MakeLocate $(<) : $(LOCATE_SOURCE) ;
        Clean clean : $(<) ;
        }
actions Lex      { $(LEX) $(>) }
actions LexMv    { $(MV) lex.yy.c $(<) }
rule    Library {
        LibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ; # :Suffix
        Objects $(>) ;
        LINKFLAGS += $(LIBFLAGS) ;
        }
# AIX example
#     xlC_r -G -qmkshrobj -g  shared.o -o libshared1.so -ldl
# Note: -G is combo flag for: erok, rtl, nortllib, nosymbolic, noautoexp, and M:SRE

rule    LibraryFromObjects {
        local _loc _src _lib _dll _file ;      # _src: sources
        _src   = [ FGristFiles $(>) ] ;        # Add grist to file names
        _lib = $(<:S=$(SUFLIB)) ;              # Library :Suffix  (.dll on windows, .so on unix)
        _dll = $(<:S=$(SUFDLL)) ;              # Library :Suffix  (.lib on windows, .so / .a on unix)
        if $(KEEPOBJS) { Depends obj : $(_src) ; # library depends on its member objects
        } else         { Depends lib : $(_lib) ; }
        # 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 ! $(_lib:D) {
             _loc = [ FDirName $(LOCATE_TARGET) ] ;
             MakeLocate $(_lib) $(_lib)($(_src:BS)) : $(_loc) ;
             } # :Base/:Suffix/:Directory
        Depends $(_lib) : $(_src) ;
        Depends $(_lib) : $(_lib)($(_src:BS)) ;
        for _file in $(_src) {
            Depends $(_lib)($(_file:BS)) : $(_file) ;
            }
        Clean clean : $(_lib) ;
        Link    $(_lib) : $(_src) ;
#       RmTemps $(_lib) : $(_src) ;      # Breaks incremental builds on win32 (probably AIX too)
        }
rule    LibFlags { LIBFLAGS += $(<) ; }
rule    Libs {
        # make library dependencies of target
        # set NEEDLIBS variable used by 'actions Main' / 'actions Library'
        local _exe = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
        Depends     $(_exe) :  $(>:S=$(SUFLIB)) ;   # :Suffix
        NEEDLIBS on $(_exe) += $(>:S=$(SUFLIB)) ;   # :Suffix
        }
rule    Link {
        MODE on $(<) = $(EXEMODE) ;
        Chmod   $(<) ;
        }
actions Link bind NEEDLIBS { $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS) }
rule    LinkFlags { LINKFLAGS += $(<) ; }
rule    Main {
        LINKFLAGS += $(LIBFLAGS) ;                              # Siebel
        MainFromObjects $(<) : $(>:S=$(SUFOBJ)) ; # :Suffix
        Objects $(>) ;
        }
rule    MainFromObjects {
        local _src _tgt _loc _i ;
        # Add grist to file names
        # Add suffix to exe
        _src = [ FGristFiles $(>) ] ;
        _tgt = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
        # so 'jam foo' works when it's really foo.exe
        if $(_tgt) != $(<) {
            Depends $(<) : $(_tgt) ;
            NotFile $(<) ;
            }
        # make compiled sources a dependency of target
        if ! $(_tgt:D) {                                      
           _loc = [ FDirName $(LOCATE_TARGET) ] ;
           MakeLocate $(_tgt) $(_tgt)($(_src:BS)) : $(_loc) ;
           }   # :Base/:Suffix/:Directory
        Depends exe : $(_tgt) ;
        Depends $(_tgt) : $(_src) ;
        Depends $(_tgt) : $(_tgt)($(_src:BS)) ;               
        for _i in $(_src) {                                   # Why? Difference from line above??
            Depends $(_tgt)($(_i:BS)) : $(i) ;
            }
        MakeLocate $(_tgt) : $(LOCATE_TARGET) ;               # Link2 Windows(no effect) AIX(needed) ??
        Clean clean   : $(_tgt) ;
        Link2 $(_tgt) : $(_src) ;
        }
rule    MakeLocate {           # MakeLocate targets : directory ;
        # Sets special variable LOCATE on targets, and arranges
        # with MkDir to create target directory.
        # Note we grist the directory name with 'dir',
        # so that directory path components and other
        # targets don't conflict.
        if $(>) {
            LOCATE on $(<) = $(>) ;
            Depends $(<) : $(>[1]:G=dir) ;             # :Grist
            MkDir $(>[1]:G=dir) ;                      # :Grist
            }
        }
rule    MkDir {                     # MkDir directory ;
        # Make a directory and all its parent directories.
        # Ignore timestamps on directories: we only care if they
        # exist.
        NoUpdate $(<) ;
        # Don't create . or any directory already created.
        if $(<:G=) != $(DOT) && ! $($(<)-mkdir) {      # :Grist
            # Cheesy gate to prevent multiple invocations on same dir
            # Arrange for jam dirs
            # MkDir1 has the actions
            $(<)-mkdir = true ;
            Depends dirs : $(<) ;
            MkDir1 $(<) ;
            # Recursively make parent directories.               #Siebel: Why not use mkdir -p 
            # $(<:P) = $(<)'s parent, & we recurse until root
            local _parent = $(<:P) ;              # :Parent
            # Don't try to create A: or A:\ on windows
            if $(NT) {
                switch $(_parent) {
                  case *:   : _parent = ;
                  case *:\\ : _parent = ;
                  }
                }
            if $(_parent) = $(<) {
                # The parent is the same as the dir.
                # We're at the root, which some OS's can't stat, so we mark
                # it as NotFile.
                NotFile $(_parent) ;
            } else if $(_parent:G=) {                        # :Grist
                # There's a parent; recurse.
                Depends $(<) : $(_parent) ;
                MkDir $(_parent) ;
                }
            }
        }
actions MkDir1   { $(MKDIR) $(<) }
rule    Object {
        # locate object and search for source, if wanted
        local _loc ;                              
        Clean clean : $(<) ;
        _loc = [ FDirName $(LOCATE_TARGET) ] ;    
        MakeLocate $(<) : $(_loc) ;               # Siebel Solve Src/foo.cpp windows directory structure
        SEARCH on $(>)  = $(SEARCH_SOURCE) ;
        # Save HDRS for -I$(HDRS) on compile.
        # We shouldn't need -I$(SEARCH_SOURCE) as cc can find headers
        # in the .c file's directory, but generated .c files (from
        # yacc, lex, etc) are located in $(LOCATE_TARGET), possibly
        # different from $(SEARCH_SOURCE).
        HDRS on $(<) = $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS) ;
        # 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.
        # $(SEARCH_SOURCE:E) 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).
        HDRRULE   on $(>) = HdrRule ;
        HDRSCAN   on $(>) = $(HDRPATTERN) ;
        HDRSEARCH on $(>) = $(SEARCH_SOURCE:E) $(SUBDIRHDRS) $(HDRS) $(STDHDRS) ;  # :E value
        HDRGRIST  on $(>) = $(HDRGRIST) ;
        # propagate target specific-defines
        DEFINES on $(<) += $(DEFINES) ;
        # if source is not .c, generate .c with specific rule
        switch $(>:S) {                         # :Suffix
            case .asm : As  $(<) : $(>) ;
            case .c :   Cc  $(<) : $(>) ;
            case .C :   C++ $(<) : $(>) ;
            case .cc :  C++ $(<) : $(>) ;
            case .cpp : C++ $(<) : $(>) ;
            case .l :   Cc  $(<) : $(<:S=.c) ;  # :Suffix
                        Lex $(<:S=.c) : $(>) ;  # :Suffix
            case .s :   As  $(<) : $(>) ;
            case .y :   Cc  $(<) : $(<:S=$(YACCGEN)) ;  # :Suffix
                        Yacc $(<:S=$(YACCGEN)) : $(>) ; # :Suffix
            case * :    UserObject $(<) : $(>) ;
            }
        }
rule    ObjectCcFlags  { CCFLAGS  on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ; }     # :Suffix
rule    ObjectC++Flags { C++FLAGS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ; }     # :Suffix
rule    ObjectDefines  {   # reformat CCDEFS according to current defines
        local _src = [ FGristFiles $(<:S=$(SUFOBJ)) ] ;  # :Suffix
        DEFINES on $(_src) += $(>) ;
        CCDEFS  on $(_src)  = [ on $(_src) FDefines $(DEFINES) ] ;
        }
rule    ObjectHdrs {
        # Add to HDRS for HdrScan's benefit.
        # must reformat CCHDRS according to headers
        local _obj = [ FGristFiles $(<:S=$(SUFOBJ)) ] ;  # :Suffix
        HDRS on $(_obj) += $(>) ;
        CCHDRS on $(_obj) = [ on $(_obj) FIncludes $(HDRS) ] ;
        }
rule    Objects {
        local _obj ;
        for _obj in [ FGristFiles $(<) ] {
                Object $(_obj:S=$(SUFOBJ)) : $(_obj) ;  # :Suffix
                Depends obj : $(_obj:S=$(SUFOBJ)) ;     # :Suffix
                }
        }
rule    Resource  {
        local _src = [ FGristFiles $(>) ] ;
        local _res = $(_src:S=.res) ;
        local _exe = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
        Depends $(_exe) : $(_res) ;
        Depends $(_res) : $(_src) ;
        LOCATE    on $(_res)  = $(LOCATE_TARGET) ;
        SEARCH    on $(_src)  = $(SEARCH_SOURCE) ;
        NEEDLIBS  on $(_exe) += $(_res) ;
        HDRS      on $(_res)  = $(HDRS) $(SEARCH_SOURCE) $(SUBDIRHDRS) ;
        HDRRULE   on $(_src)  = HdrRule ;
        HDRSCAN   on $(_src)  = $(HDRPATTERN) ;
        HDRSEARCH on $(_src)  = $(SEARCH_SOURCE) $(SUBDIRHDRS) ;
        HDRGRIST  on $(_src)  = $(HDRGRIST) ;
        Rc $(_res) : $(_src) ;
        Clean clean : $(<) ;
        }
actions Rc       { $(RC) $(RCFLAGS) /I$(HDRS) /I$(RCHDRS) /Fo $(<) $(>) }
rule    RmTemps { Temporary $(>) ; }       
actions quietly updated piecemeal together RmTemps { $(RM) $(>) }
rule    Setuid  { MODE on [ FAppendSuffix $(<) : $(SUFEXE) ] = 4711 ; }
rule    Shell   {
        Depends shell : $(<) ;
        Depends $(<) : $(>) ;
        SEARCH on $(>) = $(SEARCH_SOURCE) ;
        MODE   on $(<) = $(SHELLMODE) ;
        Clean clean : $(<) ;
        Chmod $(<) ;
        }
actions Shell    {
        $(AWK) '
                NR == 1 { print "$(SHELLHEADER)" }
                NR == 1 && /^[#:]/ { next }
                /^##/ { next }
                { print }
        ' < $(>) > $(<)
        }
rule    SoftLink {
        Depends files : $(<) ;
        Depends $(<)  : $(>) ;
        SEARCH on $(>) = $(SEARCH_SOURCE) ;
        Clean clean : $(<) ;
        }
actions SoftLink { $(RM) $(<) && $(LN) -s $(>) $(<) }
rule    SubDir {              # SubDir TOP d1 d2 ... ;
        # Support for a project tree spanning multiple directories.
        #
        # SubDir declares a Jamfile's location in a project tree, setting
        # Jambase variables (SEARCH_SOURCE, LOCATE_TARGET) so that source
        # files can be found.
        #
        # TOP is a user-select variable name for root of the tree, and
        # d1 d2 ...  are the directory elements that lead from the root
        # of the tree to the directory of the Jamfile.
        #
        # TOP can be set externally, but normally the first SubDir call
        # computes TOP as the path up from the current directory; the
        # path contains one ../ for each of d1 d2 ...
        #
        # SubDir reads once the project-specific rules file Jamrules
        # in the TOP directory, if present.  This can be overridden
        # with the variable TOPRULES.
        #
        # SubDir supports multiple, overlaid project trees:  SubDir
        # invocations with different TOPs can appear in the same Jamfile.
        # The location established by the first SubDir call is used set
        # the TOPs for the subsequent SubDir calls.
        #
        # SubDir's public variables:
        #
        #       $(TOP) = path from CWD to root.
        #       $(SUBDIR) = path from CWD to the directory SubDir names.
        #       $(SUBDIR_TOKENS) = path from $(TOP) to $(SUBDIR) as dir names
        #       $(SEARCH_SOURCE) = $(SUBDIR)
        #       $(LOCATE_SOURCE) = $(ALL_LOCATE_TARGET) $(SUBDIR)
        #       $(LOCATE_TARGET) = $(ALL_LOCATE_TARGET) $(SUBDIR)
        #       $(SOURCE_GRIST) = $(SUBDIR_TOKENS) with !'s
        #
        local _top    = $(<[1]) ;
        local _tokens = $(<[2-]) ;
        #
        # First time through sets up relative root and includes Jamrules.
        #
        if ! $(_top) { Exit SubDir syntax error ; }
        if ! $($(_top)-SET) {
            $(_top)-SET = true ;       # First time we've seen this TOP.
            # We'll initialize a number of internal variables:
            #
            #   $(TOP-UP) = directories from ROOT to a common point
            #   $(TOP-DOWN) = directories from common point to TOP
            #   $(TOP-ROOT) = root directory for UP/DOWN -- normally CWD
            #   $(SUBDIR_UP) = current value of $(TOP-UP)
            #   $(SUBDIR_DOWN) = current value of $(TOP-DOWN)
            #   $(SUBDIR_ROOT) = current value of $(TOP-ROOT)
            #
            if $($(_top)) {
                # TOP externally set.
                # We'll ignore the relative (UP/DOWN) path that
                # got us here, and instead remember the hard ROOT.
                $(_top)-UP = ;
                $(_top)-DOWN = ;
                $(_top)-ROOT = $($(_top)) ;
            } else {                   # TOP not preset.
                # Establishing a new TOP.  In the simplest case,
                # (SUBDIR_UP/SUBDIR_DOWN/SUBDIR_ROOT unset), it's
                # merely a certain number of directories down from
                # the current directory, and FSubDirPath will set
                # TOP to a path consisting of ../ for each of the
                # elements of _tokens, because that represents how
                # far below TOP the current directory sits.
                #
                # In the more complicated case, the starting directory
                # isn't the directory of jam's invocation but an
                # location established by previous SubDir call.  The
                # starting directory is SUBDIR_UP directories up from
                # SUBDIR_ROOT, and then SUBDIR_DOWN directories down
                # from that.   If SUBDIR_ROOT is not set, that means
                # SUBDIR_DOWN and SUBDIR_UP represent the path from
                # the directory of jam's invocation.
                #
                # In the most complicated case, the _tokens also
                # represents directories down, because TOP is being
                # estalished in a directory other than TOP's root.
                # Hopefully, _tokens and SUBDIR_DOWN represent the
                # same final directory, relative to the new TOP and
                # the previous SubDIr's TOP.  To find the new TOP,
                # we have to chop off any common directories from
                # then ends of _tokens and SUBDIR_DOWN.  To do so,
                # we reverse each of them, call FStripCommon to
                # remove the initial common elements, and then
                # reverse them again.  After this process, if
                # both _tokens and SUBDIR_DOWN have elements, it
                # means the directory names estalished by the two
                # SubDir calls don't match, and a warning is issued.
                # All hell will likely break loose at this point,
                # since the whole SubDir scheme relies on the SubDir
                # calls accurately naming the current directory.
                # Strip common trailing elements of _tokens and SUBDIR_DOWN.
                _tokens = [ FReverse $(_tokens) ] ;
                SUBDIR_DOWN = [ FReverse $(SUBDIR_DOWN) ] ;
                FStripCommon _tokens : SUBDIR_DOWN ;
                SUBDIR_DOWN = [ FReverse $(SUBDIR_DOWN) ] ;
                _tokens = [ FReverse $(_tokens) ] ;
                if $(SUBDIR_DOWN) && $(_tokens) { Echo Warning: SubDir $(<) misplaced! ; }
                # We'll remember the relative (UP/DOWN) path that
                # got us here, plus any hard ROOT starting point
                # for the UP/DOWN.  If TOP is never set externally,
                # ROOT will always be "" (directory of jam's invocation).
                $(_top)-UP = $(SUBDIR_UP) $(_tokens) ;
                $(_top)-DOWN = $(SUBDIR_DOWN) ;
                $(_top)-ROOT = $(SUBDIR_ROOT:E="") ;                               # :E value
                $(_top) = [ FSubDirPath $(_top) ] ;
                }
            # Set subdir vars for the inclusion of the Jamrules,
            # just in case they have SubDir rules of their own.
            # Note that SUBDIR_DOWN is empty: it's all the way
            # up where the Jamrules live.  These gets overrided
            # just after the inclusion.
            SUBDIR_UP   = $($(_top)-UP) ;
            SUBDIR_DOWN = ;
            SUBDIR_ROOT = $($(_top)-ROOT) ;
            # Include $(TOPRULES) or $(TOP)/Jamrules.
            # Include $(TOPRULES) if set.
            # Otherwise include $(TOP)/Jamrules if present.
            if $($(_top)RULES) {
                include $($(_top)RULES) ;
            } else {
                NoCare  $(JAMRULES:R=$($(_top)):G=$(_top)) ;   # :Root/:Grist
                include $(JAMRULES:R=$($(_top)):G=$(_top)) ;   # :Root/:Grist
                }
           }
        # Get path from $(TOP) to named directory.
        # Save dir tokens for other potential uses.
        SUBDIR_UP     = $($(_top)-UP) ;
        SUBDIR_DOWN   = $($(_top)-DOWN) $(_tokens) ;
        SUBDIR_ROOT   = $($(_top)-ROOT) ;
        SUBDIR_TOKENS = $(SUBDIR_DOWN) ;
        SUBDIR = [ FSubDirPath $(<) ] ;
        # Now set up SEARCH_SOURCE, LOCATE_TARGET, SOURCE_GRIST
        # These can be reset if needed.  For example, if the source
        # directory should not hold object files, LOCATE_TARGET can
        # subsequently be redefined.
        SEARCH_SOURCE = $(SUBDIR) ;
        LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
        LOCATE_TARGET = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
        SOURCE_GRIST  = [ FGrist $(SUBDIR_TOKENS) ] ;
        # Reset per-directory ccflags, hdrs, etc,
        # listed in SUBDIRRESET.
        # Note use of variable expanded assignment var
        SUBDIR$(SUBDIRRESET) = ;
        # Invoke user-specific SubDir extensions,
        # rule names listed in SUBDIRRULES.
        # Note use of variable expanded rule invocation
        $(SUBDIRRULES) $(<) ;
        }
rule    SubDirCcFlags  { SUBDIRCCFLAGS  += $(<) ; }
rule    SubDirC++Flags { SUBDIRC++FLAGS += $(<) ; }
rule    SubDirDefines  { SUBDIRC++FLAGS += [ FDefines $(<) ] ; }
rule    SubDirHdrs     { SUBDIRHDRS += [ FDirName $(<) ] ; }
rule    SubInclude {                # SubInclude TOP d1 ... ;
        # Include a subdirectory's Jamfile.
        # We use SubDir to get there, in case the included Jamfile
        # either doesn't have its own SubDir (naughty) or is a subtree
        # with its own TOP.
        if ! $($(<[1])) { Exit SubInclude $(<[1]) without prior SubDir $(<[1]) ; }
        SubDir  $(<) ;
        include $(JAMFILE:D=$(SUBDIR)) ;                             # :Directory
        }
rule    SubRules {                  # SubRules TOP d1 ... : Other-TOP ;
        #
        # Read another tree's Jamrules, by giving it's path according
        # to this tree and it's own name.
        if ! $($(<[1])) { Exit SubRules $(<[1]) without prior SubDir $(<[1]) ; }
        SubDir $(<) ;
        SubDir $(>) ;
        }
rule    Undefines { UNDEFS on [ FAppendSuffix $(<) : $(SUFEXE) ] += $(UNDEFFLAG)$(>) ; }
rule    UserObject { Exit "Unknown suffix on" $(>) "- see UserObject rule in Jamfile(5)." ; }
rule    Yacc {
        local _hdr ;
        _hdr = $(<:BS=.h) ;    # :Base/:Suffix
        MakeLocate $(<) $(_hdr) : $(LOCATE_SOURCE) ; # Some places don't have yacc.
        if $(YACC) {
            Depends $(<) $(_hdr) : $(>) ;
            Yacc1 $(<) $(_hdr) : $(>) ;
            YaccMv $(<) $(_hdr) : $(>) ;
            Clean clean : $(<) $(_hdr) ;
            }
        # make sure someone includes $(_hdr) else it will be
        # a deadly independent target
        Includes $(<) : $(_hdr) ;
        }
actions Yacc1    { $(YACC) $(YACCFLAGS) $(>) }
actions YaccMv   {
        $(MV) $(YACCFILES).c $(<[1])
        $(MV) $(YACCFILES).h $(<[2])
        }
#
# Utility rules; no side effects on these
#
rule    FAppendSuffix {    # "FAppendSuffix yacc lex foo.bat : $(SUFEXE) ;"
       # returns (yacc,lex,foo.bat) on Unix and
       # (yacc.exe,lex.exe,foo.bat) on NT.
        local _file _out ;
        if $(>) {
            for _file in $(<) {
                if $(_file:S) { _out += $(_file) ;          # :Suffix
                } else        { _out += $(_file:S=$(>)) ;   # :Suffix
                }
            }
            return $(_out) ;
        } else { return $(<) ; }
        }
rule    FDefines  { return -D$(<) ; }
rule    FDirName  {
        # Turn individual elements in $(<) into a usable path.
        local _dir ;
        local _path = $(DOT) ;
        for _dir in $(<) { _path = $(_dir:R=$(_path)) ; }       # :Root
        return $(_path) ;
        }
rule    FGrist      { return $(<:J=!) ; }        # :Join
rule    FGristFiles { return $(<:G=$(SOURCE_GRIST:E)) ; }   # :Grist # :E value
rule    FGristSourceFiles {
        # Produce source file 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 _src _gsrc ;
            for _src in $(<) {
                switch $(_src) {
                  case *.h : _gsrc += $(_src) ;
                  case *   : _gsrc += $(_src:G=$(SOURCE_GRIST)) ; # :Grist
                  }
                }
            return $(_gsrc) ;
            }
        }
rule    FIncludes { return -I$(<) ; }
rule    FRelPath {
        local _tgt _src ;       # first strip off common parts
        _tgt = $(<) ;
        _src = $(>) ;
        FStripCommon _tgt : _src ;
        _tgt = [ FSubDir  $(_tgt) ] ;   # now make path to root and path down
        _src = [ FDirName $(_src) ] ;
        # Concatenate and save
        if $(_src) = $(DOT) { return $(_tgt) ;
        } else              { return $(_src:R=$(_tgt)) ; }           # :Root
        }
rule    FReverse {               # FReverse a1 a2 a3 ... ;
        # return ... a3 a2 a1 ;
        if $(1) { return [ FReverse $(1[2-]) ] $(1[1]) ; }
        }
rule    FSubDir {
        # If $(>) is the path to the current directory, compute the
        # path (using ../../ etc) back to that root directory.
        # Sets result in $(<)
        if ! $(<[1]) { return $(DOT) ;
        } else {
            local _dir _path ;
            _path = $(DOTDOT) ;
            for _dir in $(<[2-]) { _path = $(_path:R=$(DOTDOT)) ; }    # :Root
            return $(_path) ;
            }
        }
rule    FSubDirPath {             # FSubDirPath TOP d1 ... ;
        # Returns path to named directory.
        # If jam is invoked in a subdirectory of the TOP, then we
        # need to prepend a ../ for every level we must climb up
        # (TOP-UP), and then append the directory names we must
        # climb down (TOP-DOWN), plus the named directories d1 ...
        # If TOP was set externally, or computed from another TOP
        # that was, we'll have to reroot the whole thing at TOP-ROOT.
        local _path = [ FRelPath $($(<[1])-UP) : $($(<[1])-DOWN) $(<[2-]) ] ;
        return $(_path:R=$($(<[1])-ROOT)) ;                       # :Root
        }
rule    FStripCommon {          # FStripCommon v1 : v2 ;
        # Strip common initial elements of variables v1 and v2.
        # Modifies the variable values themselves.
        if $($(<)[1]) && $($(<)[1]) = $($(>)[1]) {
            $(<) = $($(<)[2-]) ;
            $(>) = $($(>)[2-]) ;
            FStripCommon $(<) : $(>) ;
            }
        }
rule    FQuote    { return \\\"$(<)\\\" ; }

if $(MSVCDIR) {                             # NT specific actions
   rule    FDefines  { return /D$(<) ; }
   actions GenFile1 { $(>[1]) $(<) $(>[2-]) }
   rule    FIncludes { return /I$(<) ; }
   actions updated together piecemeal FArchive {
      if exist $(<) set _$(<:B)_= $(<) ; else set _$<:B) = ;
      $(AR) /out:$(<) %_$(<:B)_% $(>)
      }
   actions As  { $(AS)  /Ml /p /v /w2 $(>) $(<) ,nul,nul }
   actions Cc  { $(CC)  $(CCFLAGS)  $(CCDEFS) $(CCHDRS) /I$(STDHDRS)    $(>) /c /Fo".\\$(<:D)\\" /Fd".\\$(<:D)\\" }
   actions C++ { $(C++) $(C++FLAGS) $(CCDEFS) $(CCHDRS) /I$(STDHDRS) /Tp$(>) /c /Fo".\\$(<:D)\\" /Fd".\\$(<:D)\\" }
   actions Link  bind NEEDLIBS { $(LINK) /subsystem:windows /dll $(LINKFLAGS) $(UNDEFS) $(>) /libpath:$(LIBDIR) $(NEEDLIBS) $(LINKLIBS) /out:$(<:S=.dll) /implib:$(<:S=.lib) /pdb:$(<:S=.pdb) }
   actions Link2 bind NEEDLIBS { $(LINK) /subsystem:console      $(LINKFLAGS) $(UNDEFS) $(>) /libpath:$(LIBDIR) $(NEEDLIBS) $(LINKLIBS) /out:$(<:S=.exe) /implib:$(<:S=.lib) /pdb:$(<:S=.pdb) }
   }
# Compatibility with jam 2.5
rule    LinkLibraries { Libs $(<) ; }

# Compatibility with jam 2.2.
rule    addDirName   { $(<)   += [ FDirName $(>) ] ; }
rule     makeCommon  { FStripCommon $(<) : $(>) ; }
rule    _makeCommon  { FStripCommon $(<) : $(>) ; }
rule    makeDirName  { $(<)    = [ FDirName $(>) ] ; }
rule    makeGrist    { $(<)    = [ FGrist $(>) ] ; }
rule    makeGristedName { $(<) = [ FGristSourceFiles $(>) ] ; }
rule    makeRelPath  { $(<[1]) = [ FRelPath $(<[2-]) : $(>) ] ; }
rule    makeString   { $(<)    = $(>:J) ; }         # :Join
rule    makeSubDir   { $(<)    = [ FSubDir $(>) ] ; }
rule    makeSuffixed { $(<[1]) = [ FAppendSuffix $(>) : $(<[2]) ] ; }
#
# Now include the user's Jamfile.
#
include $(JAMFILE) ;