gcc-tools.jam

C++的一个好库。。。现在很流行

flags gcc CFLAGS $(.ARCH)/<instruction-set>power2 : -mcpu=power2 ;
flags gcc CFLAGS $(.ARCH)/<instruction-set>power3 : -mcpu=power3 ;
flags gcc CFLAGS $(.ARCH)/<instruction-set>power4 : -mcpu=power4 ;
flags gcc CFLAGS $(.ARCH)/<instruction-set>power5 : -mcpu=power5 ;
flags gcc CFLAGS $(.ARCH)/<instruction-set>powerpc : -mcpu=powerpc ;
flags gcc CFLAGS $(.ARCH)/<instruction-set>powerpc64 : -mcpu=powerpc64 ;
# AIX variant of RS/6000 & PowerPC
flags gcc CFLAGS <architecture>power/<address-model>32/<object-model>aix : -maix32 ;
flags gcc LINKFLAGS <architecture>power/<address-model>32/<object-model>aix : -maix32 ;
flags gcc CFLAGS <architecture>power/<address-model>64/<object-model>aix : -maix64 ;
flags gcc LINKFLAGS <architecture>power/<address-model>64/<object-model>aix : -maix64 ;
flags gcc AROPTIONS <architecture>power/<address-model>64/<object-model>aix : "-X 64" ;
# MIPS-1-2-3-4
flags gcc MIPS <architecture>mips1 <architecture>mips2 <architecture>mips3 <architecture>mips4 : TRUE ;
flags gcc MIPS
    <instruction-set>r2000 <instruction-set>r3000 <instruction-set>r3900
    <instruction-set>r4000 <instruction-set>r4100 <instruction-set>r4300
    <instruction-set>r4400 <instruction-set>r4600 <instruction-set>r4650
    <instruction-set>r5000 <instruction-set>r6000 <instruction-set>r8000
    <instruction-set>orion
    : TRUE ;
if $(MIPS)
{
    flags gcc CFLAGS <architecture>mips1 : -mips1 ;
    flags gcc CFLAGS <architecture>mips2 : -mips2 ;
    flags gcc CFLAGS <architecture>mips3 : -mips3 ;
    flags gcc CFLAGS <architecture>mips4 : -mips4 ;
    flags gcc CFLAGS <instruction-set>r2000 : -mcpu=r2000 ;
    flags gcc CFLAGS <instruction-set>r3000 : -mcpu=r3000 ;
    flags gcc CFLAGS <instruction-set>r3900 : -mcpu=r3900 ;
    flags gcc CFLAGS <instruction-set>r4000 : -mcpu=r4000 ;
    flags gcc CFLAGS <instruction-set>r4100 : -mcpu=r4100 ;
    flags gcc CFLAGS <instruction-set>r4300 : -mcpu=r4300 ;
    flags gcc CFLAGS <instruction-set>r4400 : -mcpu=r4400 ;
    flags gcc CFLAGS <instruction-set>r4600 : -mcpu=r4600 ;
    flags gcc CFLAGS <instruction-set>r4650 : -mcpu=r4650 ;
    flags gcc CFLAGS <instruction-set>r5000 : -mcpu=r5000 ;
    flags gcc CFLAGS <instruction-set>r6000 : -mcpu=r6000 ;
    flags gcc CFLAGS <instruction-set>r8000 : -mcpu=r8000 ;
    flags gcc CFLAGS <instruction-set>orion : -mcpu=orion ;
    #   ...addressing model options
    flags gcc ADDRESS_MODEL_INVALID <address-model>16 : TRUE ;
    if $(ADDRESS_MODEL_INVALID)
    {
        EXIT "Error: Invalid addressing model for MIPS architecture (16)." ;
    }
    flags gcc CFLAGS <address-model>default : -mgp32 ;
    flags gcc CFLAGS <address-model>32 : -mgp32 ;
    flags gcc CFLAGS <address-model>64 : -mgp64 -mlong64 ;
}
#S390
if $(OSPLAT) = 390 || $(OSPLAT) = IA64
{
    flags gcc CFLAGS <threading>multi : -D_REENTRANT ;
}

#
# define compiler names if not set:
.GCC ?= gcc ;
.GXX ?= g++ ;


flags gcc CFLAGS <profiling>on : -pg ;
flags gcc LINKFLAGS <profiling>on : -pg ;

flags gcc C++FLAGS <rtti>off : -fno-rtti ;
flags gcc C++FLAGS <vtable-thunks>on : -fvtable-thunks ;
flags gcc C++FLAGS <vtable-thunks>off : -fvtable-thunks=0 ;

flags gcc CFLAGS <cflags> ;
flags gcc C++FLAGS <cxxflags> ;
flags gcc DEFINES <define> ;
flags gcc UNDEFS <undef> ;
flags gcc HDRS <include> ;
flags gcc SYSHDRS <sysinclude> ;
flags gcc LINKFLAGS <linkflags> ;
flags gcc LINKFLAGS <debug-symbols>off : -s ;
flags gcc ARFLAGS <arflags> ;

flags gcc STDHDRS : $(GCC_INCLUDE_DIRECTORY) ;
flags gcc STDLIBPATH : $(GCC_STDLIB_DIRECTORY) ;

if ! $(ARFLAGS)
{
    flags gcc ARFLAGS : "" ;
}

if ! $(on-windows) # The compiler complains about -fPIC on NT
{
    flags gcc CFLAGS <shared-linkable>true : -fPIC ;
    flags gcc LINKFLAGS <shared-linkable>true : -fPIC ;
}


if $(BETOOLS)
{
    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -nostart ;
}
else
{
    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -shared ;
}

flags gcc LIBPATH <library-path> ;
flags gcc NEEDLIBS <library-file> ;
flags gcc FINDLIBS <find-library> ;

flags gcc DLLVERSION <dllversion> ;
DLLVERSION = $(DLLVERSION[1]) ;
DLLVERSION ?= $(BOOST_VERSION) ;

flags gcc TARGET_TYPE <target-type> ;

# allow for "ar" to be part of the compiler distribution, for
# example in mingw and cygwin
flags gcc .AR : [ GLOB $(GCC_BIN_DIRECTORY) $(PATH) : ar ar.exe ] ;
.AR ?= ar ;

# used to manipulate the object files produced by GCC to
# prevent the merging of debug symbols (which happens to be n^2 slow)
if ! ( --no-objcopy in $(ARGV) )
{
    flags gcc .OBJCOPY : [ GLOB $(GCC_BIN_DIRECTORY) $(PATH) : objcopy ] ;
}

if ! $(on-windows)
{
    flags gcc .SET_EXIT : "set -e" ;
}

# Since GCC doesn't support response files, we want to give it a
# chance to execute any long commands via spawnvp on NT, where the
# command-line length limitation can really get in the way.  We call
# this on every target, but it will only take effect for targets we
# deem spawnable, and that have long command-lines.
rule gcc-spawn ( targets + )
{
    if $(NT) 
    {
        JAMSHELL on $(targets) = % ;
    }
}

#### Link ####

rule Link-action
{
    _ on $(<) = " " ;
    # if we don't have a GNU linker then we can't pass any GNU-ld specific flags:
    if $(NO_GNU_LN)
    {
        LNOPT on $(<) = ;
    }
    else
    {
        LNOPT on $(<) = "" ;
    }
    # do we use sonames or not?
    if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN)
    {
        OUTTAG on $(<) = ".$(DLLVERSION)" ;
        SOTAG on $(<) = ".$(DLLVERSION)" ;
        ACTION_1 on $(<) = "" ;
    }
    else
    {
        OUTTAG on $(<) = "" ;
        SOTAG on $(<) = ;
        ACTION_1 on $(<) = ;
    }

    if [ on $(<) return $(ON_WINDOWS) ]
    {
        # On Win32, choose different image bases for load-time efficiency
        DLL_LINK_FLAGS on $(<) += "-Wl,--enable-auto-image-base" ;
    }

    if $(<[2]) && [ on $(<) return $(ON_WINDOWS) ]
    {
        # Allow gcc-nocygwin to avoid this flag
        if ! $(GCC_NO_EXPORT_ALL)
        {
            DLL_LINK_FLAGS on $(<) += "-Wl,--export-all-symbols" ;
        }

        # This will appear before the import library name when building a DLL, but
        # will be "multiplied away" otherwise. The --exclude-symbols directive
        # proved to be necessary with some versions of Cygwin.
        DLL_LINK_FLAGS on $(<) += "-Wl,--exclude-symbols,_bss_end__:_bss_start__:_data_end__:_data_start__" ;

        # set the link command to generate an import library
        if ! $(NO_GNU_LN)
        {
            IMPLIB_COMMAND on $(<) = "-Wl,--out-implib," ;
        }
    }

    DEPENDS $(<) : $(NEEDLIBS) $(NEEDIMPS) ;
    gRUN_LD_LIBRARY_PATH($(<)) += $(STDLIBPATH:T) ;
    
    # Workaround GCC's lack of command-files and NT's line-length limitation.
    gcc-spawn $(<) ;
    gcc-Link-action $(<) : $(>) ;

    if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD || $(OS) = KFREEBSD ) && ! $(NO_GNU_LN)
    {
        return "$(<[1]).$(DLLVERSION)" ;
    }
}

# for gcc, we repeat all libraries so that dependencies are always resolved
actions gcc-Link-action bind NEEDLIBS NEEDIMPS
{
    $(.SET_EXIT)
    $(SHELL_SET)$(gSHELL_LIBPATH)=$(LINK_LIBPATH)$(gAPPEND_LD_LIBRARY_PATH)
    $(SHELL_EXPORT)$(gSHELL_LIBPATH)
    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) "$(DLL_LINK_FLAGS)" "$(IMPLIB_COMMAND)$(<[2])" $(LINKFLAGS) -o "$(<[1])$(OUTTAG)" -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(>)" "$(NEEDLIBS)" "$(NEEDLIBS)" "$(IMPLIB_FLAGS)$(NEEDIMPS)" -l$(FINDLIBS) $(LNOPT)$(RPATH_LINK). $(LNOPT)$(SONAME)$(<[1]:D=)$(SOTAG)
    $(ACTION_1)$(LN)$(_)-fs$(_)"$(<[1]:D=)$(OUTTAG)"$(_)"$(<[1])"
}

#### Cc #####

rule Cc-action
{
    gcc-spawn $(<) ;
    _ on $(<) = " " ;
    gcc-Cc-action $(<) : $(>) ;
}

actions gcc-Cc-action
{
    $(.SET_EXIT)
    "$(.GCC[1]:R=$(GCC_BIN_DIR))" $(.GCC[2-]) -c -Wall -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
    "$(.OBJCOPY[1])"$(_)$(OBJCOPY_FLAGS)$(_)"$(<)"
}

#### C++ ####
rule C++-action
{
    gcc-spawn $(<) ;
    _ on $(<) = " " ;
    gcc-C++-action $(<) : $(>) ;
}

actions gcc-C++-action
{
    $(.SET_EXIT)
    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) -c -Wall -ftemplate-depth-255 -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
    "$(.OBJCOPY[1])"$(_)$(OBJCOPY_FLAGS)$(_)"$(<)"
}

#### Archive ####

rule Archive-action
{
    gcc-spawn $(<) ;
    gcc-Archive-action $(<) : $(>) ;
}

actions updated together piecemeal gcc-Archive-action
{
    "$(.AR[1])" $(AROPTIONS) ru$(ARFLAGS:J=) "$(<)" "$(>)"
}