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