# Copyright 2001 David Abrahams

# Copyright 2002-2017 Rene Rivera

# Copyright 2002-2003 Vladimir Prus

# Copyright 2005 Reece H. Dunn

# Copyright 2006 Ilya Sokolov

# Copyright 2007 Roland Schwarz

# Copyright 2007 Boris Gubenko

#

# Distributed under the Boost Software License, Version 1.0.

#    (See accompanying file LICENSE_1_0.txt or copy at

#          http://www.boost.org/LICENSE_1_0.txt)

import "class" : new ;

import common ;

import cygwin ;

import feature ;

import fortran ;

import generators ;

import os ;

import pch ;

import property ;

import property-set ;

import rc ;

import regex ;

import set ;

import toolset ;

import type ;

import unix ;

import virtual-target ;

import errors ;

if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]

{

    .debug-configuration = true ;

}

feature.extend toolset : gcc ;

# feature.subfeature toolset gcc : flavor : : optional ;

toolset.inherit-generators gcc : unix : unix.link unix.link.dll ;

toolset.inherit-flags gcc : unix ;

toolset.inherit-rules gcc : unix ;

generators.override gcc.prebuilt : builtin.prebuilt ;

generators.override gcc.searched-lib-generator : searched-lib-generator ;

# Make gcc toolset object files use the "o" suffix on all platforms.

type.set-generated-target-suffix OBJ : <toolset>gcc : o ;

type.set-generated-target-suffix OBJ : <toolset>gcc <target-os>windows : o ;

type.set-generated-target-suffix OBJ : <toolset>gcc <target-os>cygwin : o ;

# Initializes the gcc toolset for the given version. If necessary, command may

# be used to specify where the compiler is located. The parameter 'options' is a

# space-delimited list of options, each one specified as

# <option-name>option-value. Valid option names are: cxxflags, linkflags and

# linker-type. Accepted linker-type values are aix, darwin, gnu, hpux, osf or

# sun and the default value will be selected based on the current OS.

# Example:

#   using gcc : 3.4 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;

#

# The compiler command to use is detected in three steps:

# 1) If an explicit command is specified by the user, it will be used and must

#    be available.

# 2) If only a certain version is specified, it is enforced:

#    - either the 'g++-VERSION' command must be available

#    - or the default command 'g++' must be available and match the exact

#      version.

# 3) Without user-provided restrictions use default 'g++'.

#

rule init ( version ? : command * : options * : requirement * )

{

    #1): use user-provided command

    local tool-command = ;

    if $(command)

    {

        tool-command = [ common.get-invocation-command-nodefault gcc : g++ :

            $(command) ] ;

        if ! $(tool-command)

        {

            import errors ;

            errors.error toolset gcc initialization:

                : provided command '$(command)' not found

                : initialized from [ errors.nearest-user-location ] ;

        }

    }

    #2): enforce user-provided version

    else if $(version)

    {

        tool-command = [ common.get-invocation-command-nodefault gcc :

            "g++-$(version[1])" ] ;

        #2.1) fallback: check whether "g++" reports the requested version

        if ! $(tool-command)

        {

            tool-command = [ common.get-invocation-command-nodefault gcc : g++ ]

                ;

            if $(tool-command)

            {

                local tool-command-string = \"$(tool-command)\" ;

                tool-command-string = $(tool-command-string:J=" ") ;

                local tool-version = [ MATCH "^([0-9.]+)" :

                    [ SHELL "$(tool-command-string) -dumpversion" ] ] ;

                if $(tool-version) != $(version)

                {

                    # Permit a match betwen a two-digit version specified by the

                    # user (e.g. 4.4) and a 3-digit version reported by gcc.

                    # Since only two digits are present in the binary name

                    # anyway, insisting that user specify the 3-digit version

                    # when configuring Boost.Build, while it is not required on

                    # the command line, would be strange.

                    local stripped = [ MATCH "^([0-9]+\.[0-9]+).*" :

                        $(tool-version) ] ;

                    if $(stripped) != $(version)

                    {

                        import errors ;

                        errors.error toolset gcc initialization:

                            : version '$(version)' requested but

                                'g++-$(version)' not found and version

                                '$(tool-version)' of default '$(tool-command)'

                                does not match

                            : initialized from [ errors.nearest-user-location ]

                            ;

                        tool-command = ;

                    }

                    # Use full 3-digit version to be compatible with the

                    # 'using gcc ;' case

                    version = $(tool-version) ;

                }

            }

            else

            {

                import errors ;

                errors.error toolset gcc initialization:

                    : version '$(version)' requested but neither

                        'g++-$(version)' nor default 'g++' found

                    : initialized from [ errors.nearest-user-location ] ;

            }

        }

    }

    #3) default: no command and no version specified, try using "g++"

    else

    {

        tool-command = [ common.get-invocation-command-nodefault gcc : g++ ] ;

        if ! $(tool-command)

        {

            import errors ;

            errors.error toolset gcc initialization:

                : no command provided, default command 'g++' not found

                : initialized from [ errors.nearest-user-location ] ;

        }

    }

    # Information about the gcc command...

    #   The command.

    local command = $(tool-command) ;

    #   The 'command' variable can have multiple elements but when calling the    

    # SHELL builtin we need a single string, and we need to quote elements

    # with spaces.

    local command-string = \"$(command)\" ;

    command-string = $(command-string:J=" ") ;

    #   The root directory of the tool install.

    local root = [ feature.get-values <root> : $(options) ] ;

    #   The bin directory where to find the command to execute.

    local bin ;

    #   The compiler flavor.

    local flavor = [ feature.get-values <flavor> : $(options) ] ;

    #   vxworks build on windows uses csh that is neither mingw or cygwin

    if [ feature.get-values <target-os> : $(options) ] = vxworks

    {

        flavor ?= vxworks ;

    }

    #   Autodetect the root and bin dir if not given.

    if $(command)

    {

        bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ;

        root ?= $(bin:D) ;

    }

    #   Autodetect the version and flavor if not given.

    if $(command)

    {

        local machine = [ MATCH "^([^ ]+)" :

            [ SHELL "$(command-string) -dumpmachine" ] ] ;

        version ?= [ MATCH "^([0-9.]+)" :

            [ SHELL "$(command-string) -dumpversion" ] ] ;

        switch $(machine:L)

        {

            case *mingw* : flavor ?= mingw ;

        }

    }

    local condition ;

    if $(flavor)

    {

        condition = flavor $(flavor) ;

    }

    condition = [ common.check-init-parameters gcc $(requirement) : version $(version)

        : $(condition) ] ;

    common.handle-options gcc : $(condition) : $(command) : $(options) ;

    init-link-flags gcc "" $(condition) ;

    # If gcc is installed in a non-standard location, we would need to add

    # LD_LIBRARY_PATH when running programs created with it (for unit-test/run

    # rules).

    if $(command)

    {

        # On multilib 64-bit boxes, there are both 32-bit and 64-bit libraries

        # and all must be added to LD_LIBRARY_PATH. The linker will pick the

        # right onces. Note that we do not provide a clean way to build a 32-bit

        # binary using a 64-bit compiler, but user can always pass -m32

        # manually.

        local lib_path = $(root)/bin $(root)/lib $(root)/lib32 $(root)/lib64 ;

        if $(.debug-configuration)

        {

            ECHO notice: using gcc libraries :: $(condition) :: $(lib_path) ;

        }

        toolset.flags gcc.link RUN_PATH $(condition) : $(lib_path) ;

    }

    # If we are not using a system gcc installation we should adjust the various

    # programs as needed to prefer using their installation specific versions.

    # This is essential for correct use of MinGW and for cross-compiling.

    # - Archive builder.

    local archiver = [ common.get-invocation-command gcc

        : [ .get-prog-name $(command-string) : ar : $(flavor) ]

        : [ feature.get-values <archiver> : $(options) ]

        : $(bin)

        : search-path ] ;

    toolset.flags gcc.archive .AR $(condition) : $(archiver[1]) ;

    if $(.debug-configuration)

    {

        ECHO notice: using gcc archiver :: $(condition) :: $(archiver[1]) ;

    }

    # - Ranlib.

    local ranlib = [ common.get-invocation-command gcc

        : [ .get-prog-name $(command-string) : ranlib : $(flavor) ]

        : [ feature.get-values <ranlib> : $(options) ]

        : $(bin)

        : search-path ] ;

    toolset.flags gcc.archive .RANLIB $(condition) : $(ranlib[1]) ;

    if $(.debug-configuration)

    {

        ECHO notice: using gcc ranlib :: $(condition) :: $(ranlib[1]) ;

    }

    # - Resource compiler.

    local rc = [ common.get-invocation-command-nodefault gcc : windres :

        [ feature.get-values <rc> : $(options) ] : $(bin) : search-path ] ;

    local rc-type = [ feature.get-values <rc-type> : $(options) ] ;

    rc-type ?= windres ;

    if ! $(rc)

    {

        # If we can not find an RC compiler we fallback to a null one that

        # creates empty object files. This allows the same Jamfiles to work

        # across the board. The null RC uses assembler to create the empty

        # objects, so configure that.

        rc = [ common.get-invocation-command gcc : as : : $(bin) : search-path ]

            ;

        rc-type = null ;

    }

    rc.configure $(rc) : $(condition) : <rc-type>$(rc-type) ;

    toolset.flags gcc VERSION $(condition) : [ regex.split $(version) "[.]" ] ;

}

if [ os.name ] = NT

{

    # This causes single-line command invocation to not go through .bat files,

    # thus avoiding command-line length limitations.

    # TODO: Set JAMSHELL on specific targets instead of globally.

    JAMSHELL = % ;

}

# Uses -print-prog-name to get the name of the tool.

# Converts the path to native form if using cygwin.

rule .get-prog-name ( command-string : tool : flavor ? )

{

    local prog-name = [ NORMALIZE_PATH [ MATCH "(.*)[\n]+" :

        [ SHELL "$(command-string) -print-prog-name=$(tool)" ] ] ] ;

    if $(flavor) != vxworks && $(flavor) != mingw && [ os.name ] = NT

    {

        prog-name = [ cygwin.cygwin-to-windows-path $(prog-name) ] ;

    }

    return $(prog-name) ;

}

###

### Functions that set options on the targets.

###

rule set-fpic-options ( targets * : sources * : properties * )

{

    local link = [ feature.get-values link : $(properties) ] ;

    if $(link) = shared

    {

        local target-os = [ feature.get-values target-os : $(properties) ] ;

        # This logic will add -fPIC for all compilations:

        #

        # lib a : a.cpp b ;

        # obj b : b.cpp ;

        # exe c : c.cpp a d ;

        # obj d : d.cpp ;

        #

        # This all is fine, except that 'd' will be compiled with -fPIC even

        # though it is not needed, as 'd' is used only in exe. However, it is

        # hard to detect where a target is going to be used. Alternatively, we

        # can set -fPIC only when main target type is LIB but than 'b' would be

        # compiled without -fPIC which would lead to link errors on x86-64. So,

        # compile everything with -fPIC.

        #

        # Yet another alternative would be to create a propagated <sharedable>

        # feature and set it when building shared libraries, but that would be

        # hard to implement and would increase the target path length even more.

        # On Windows, fPIC is the default, and specifying -fPIC explicitly leads

        # to a warning.

        if ! $(target-os) in cygwin windows

        {

            OPTIONS on $(targets) += -fPIC ;

        }

    }

}

rule set-address-model-options ( targets * : sources * : properties * )

{

    local model = [ feature.get-values address-model : $(properties) ] ;

    if $(model)

    {

        local option ;

        local target-os = [ feature.get-values target-os : $(properties) ] ;

        if $(target-os) = aix

        {

            if $(model) = 32

            {

                option = -maix32 ;

            }

            else

            {

                option = -maix64 ;

            }

        }

        else if $(target-os) = hpux

        {

            if $(model) = 32

            {

                option = -milp32 ;

            }

            else

            {

                option = -mlp64 ;

            }

        }

        else

        {

            local arch = [ feature.get-values architecture : $(properties) ] ;

            if $(arch) = power || $(arch) = sparc || $(arch) = x86

            {

                if $(model) = 32

                {

                    option = -m32 ;

                }

                else if $(model) = 64

                {

                    option = -m64 ;

                }

            }

            # For darwin, the model can be 32_64. darwin.jam will handle that

            # on its own.

        }

        OPTIONS on $(targets) += $(option) ;

    }

}

rule set-threading-options ( targets * : sources * : properties * )

{

    local threading = [ feature.get-values threading : $(properties) ] ;

    if $(threading) = multi

    {

        local target-os = [ feature.get-values target-os : $(properties) ] ;

        local host-os = [ feature.get-values host-os : $(properties) ] ;

        local toolset = [ feature.get-values toolset : $(properties) ] ;

        local option ;

        local libs ;

        if $(toolset) = clang && $(target-os) = windows

        {

            option = -pthread ;

        }

        switch $(target-os)

        {

            case android : # No threading options, everything is in already.

            case windows : option ?= -mthreads ;

            case cygwin  : option ?= -mthreads ;

            case solaris : option ?= -pthreads ; libs = rt ;

            case beos    : # No threading options.

            case haiku   : # No threading options.

            case *bsd    : option ?= -pthread ;  # There is no -lrt on BSD.

            case sgi     : # gcc on IRIX does not support multi-threading.

            case darwin  : # No threading options.

            case vxworks : # No threading options.  

            case *       : option ?= -pthread ; libs = rt ;

        }

        if $(option)

        {

            OPTIONS on $(targets) += $(option) ;

        }

        if $(libs)

        {

            FINDLIBS-SA on $(targets) += $(libs) ;

        }

    }

}

local rule zero-pad ( numbers * )

{

    local result ;

    for local n in $(numbers)

    {

        switch $(n)

        {

            case ???? : result += $(n) ;

            case ??? : result += 0$(n) ;

            case ?? : result += 00$(n) ;

            case ? : result += 000$(n) ;

        }

    }

    return $(result) ;

}

rule set-cxxstd-options ( targets * : sources * : properties * : action )

{

    local *targets = [ $(action).targets ] ;

    local *sources = [ $(action).sources ] ;

    local target-type = [ $(*targets[1]).type ] ;

    local source-type = [ $(*sources[1]).type ] ;

    local toolset = [ feature.get-values toolset : $(properties) ] ;

    local version = [ zero-pad [ on $(targets[1]) return $(VERSION) ] ] ;

    version = $(version[1]).$(version[2]) ;

    local cxxstd = [ feature.get-values cxxstd : $(properties) ] ;

    local cxxstd-dialect = [ feature.get-values cxxstd-dialect : $(properties) ] ;

    cxxstd-dialect ?= iso ;

    switch $(cxxstd-dialect)

    {

        case gnu : cxxstd-dialect = gnu++ ;

        case iso : cxxstd-dialect = c++ ;

        case * :

        errors.warning Unknown cxxstd-dialect $(cxxstd-dialect:E=?) .. using

            ISO dialect instead. ;

        cxxstd-dialect = c++ ;

    }

    local option ;

    if $(cxxstd) = latest

    {

        if $(toolset) = gcc

        {

            if $(version) >= 0008.0000 { option = 2a ; }

            else if $(version) >= 0005.0001 { option = 1z ; }

            else if $(version) >= 0004.0008 { option = 1y ; }

            else if $(version) >= 0004.0007 { option = 11 ; }

            else if $(version) >= 0003.0003 { option = 98 ; }

        }

        if $(toolset) = clang

        {

            if $(version) >= 0003.0005 { option = 1z ; }

            if $(version) >= 0003.0004 { option = 14 ; }

            if $(version) >= 0003.0003 { option = 11 ; }

            option ?= 03 ;

        }

    }

    else

    {

        option = $(cxxstd) ;

    }

    if $(source-type) in CPP || $(target-type) in CPP_PCH EXE SHARED_LIB

    {

        OPTIONS on $(targets) += -std=$(cxxstd-dialect)$(option) ;

    }

}

###

### Compiling generators and actions.

###

class gcc-c-compiling-generator : C-compiling-generator

{

    rule action-class ( )

    {

        return gcc-c-compile-action ;

    }

}

class gcc-c-compile-action : compile-action

{

    import gcc ;

    rule execute ( action-name targets + : sources * : properties * )

    {

        gcc.set-threading-options $(targets) : $(sources) : $(properties) ;

        gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;

        gcc.set-address-model-options $(targets) : $(sources) : $(properties) ;

        gcc.set-cxxstd-options $(targets) : $(sources) : $(properties) : $(__name__) ;

        compile-action.execute $(action-name) $(targets) : $(sources) : $(properties) ;

    }

}

local rule register-gcc-c-compiler ( id : source-types + : target-types + : requirements *

    : optional-properties * )

{

    generators.register [ new gcc-c-compiling-generator $(id) : $(source-types) :

        $(target-types) : $(requirements) : $(optional-properties) ] ;

}

register-gcc-c-compiler gcc.compile.c++.preprocess : CPP : PREPROCESSED_CPP : <toolset>gcc ;

register-gcc-c-compiler gcc.compile.c.preprocess   : C   : PREPROCESSED_C   : <toolset>gcc ;

register-gcc-c-compiler gcc.compile.c++ : CPP : OBJ : <toolset>gcc ;

register-gcc-c-compiler gcc.compile.c   : C   : OBJ : <toolset>gcc ;

register-gcc-c-compiler gcc.compile.asm : ASM : OBJ : <toolset>gcc ;

class gcc-fortran-compiling-generator : fortran-compiling-generator

{

    rule action-class ( )

    {

        return gcc-fortran-compile-action ;

    }

}

class gcc-fortran-compile-action : compile-action

{

    import gcc ;

    rule execute ( action-name targets + : sources * : properties * )

    {

        gcc.set-threading-options $(targets) : $(sources) : $(properties) ;

        gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;

        gcc.set-address-model-options $(targets) : $(sources) : $(properties) ;

        gcc.set-cxxstd-options $(targets) : $(sources) : $(properties) : $(__name__) ;

        compile-action.execute $(action-name) $(targets) : $(sources) : $(properties) ;

    }

}

generators.register [ new gcc-fortran-compiling-generator

    gcc.compile.fortran : FORTRAN FORTRAN90 : OBJ : <toolset>gcc ] ;

rule compile.c++.preprocess ( targets * : sources * : properties * )

{

    # Some extensions are compiled as C++ by default. For others, we need to

    # pass -x c++. We could always pass -x c++ but distcc does not work with it.

    if ! $(>:S) in .cc .cp .cxx .cpp .c++ .C

    {

        LANG on $(<) = "-x c++" ;

    }

    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;

}

rule compile.c.preprocess ( targets * : sources * : properties * )

{

    # If we use the name g++ then default file suffix -> language mapping does

    # not work. So have to pass -x option. Maybe, we can work around this by

    # allowing the user to specify both C and C++ compiler names.

    #if $(>:S) != .c

    #{

        LANG on $(<) = "-x c" ;

    #}

    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;

}

rule compile.c++ ( targets * : sources * : properties * )

{

    # Some extensions are compiled as C++ by default. For others, we need to

    # pass -x c++. We could always pass -x c++ but distcc does not work with it.

    if ! $(>:S) in .cc .cp .cxx .cpp .c++ .C

    {

        LANG on $(<) = "-x c++" ;

    }

    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;

}

rule compile.c ( targets * : sources * : properties * )

{

    # If we use the name g++ then default file suffix -> language mapping does

    # not work. So have to pass -x option. Maybe, we can work around this by

    # allowing the user to specify both C and C++ compiler names.

    #if $(>:S) != .c

    #{

        LANG on $(<) = "-x c" ;

    #}

    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;

}

rule compile.fortran ( targets * : sources * : properties * )

{

}

actions compile.c++ bind PCH_FILE

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<:W)" "$(>:W)"

}

actions compile.c bind PCH_FILE

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<)" "$(>)"

}

actions compile.c++.preprocess bind PCH_FILE

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" "$(>:W)" -E >"$(<:W)"

}

actions compile.c.preprocess bind PCH_FILE

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" "$(>)" -E >$(<)

}

actions compile.fortran

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<)" "$(>)"

}

rule compile.asm ( targets * : sources * : properties * )

{

    LANG on $(<) = "-x assembler-with-cpp" ;

}

actions compile.asm

{

    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"

}

###

### Preconpiled header use and generation.

###

# The compiler looks for a precompiled header in each directory just before it

# looks for the include file in that directory. The name searched for is the

# name specified in the #include directive with ".gch" suffix appended. The

# logic in gcc-pch-generator will make sure that the BASE_PCH suffix is appended

# to the full header name.

type.set-generated-target-suffix PCH : <toolset>gcc : gch ;

# GCC-specific pch generator.

class gcc-pch-generator : pch-generator

{

    import project ;

    import property-set ;

    import type ;

    rule run-pch ( project name ? : property-set : sources + )

    {

        # Find the header in sources. Ignore any CPP sources.

        local header ;

        for local s in $(sources)

        {

            if [ type.is-derived [ $(s).type ] H ]

            {

                header = $(s) ;

            }

        }

        # Error handling: base header file name should be the same as the base

        # precompiled header name.

        local header-name = [ $(header).name ] ;

        local header-basename = $(header-name:B) ;

        if $(header-basename) != $(name)

        {

            local location = [ $(project).project-module ] ;

            import errors : user-error : errors.user-error ;

            errors.user-error "in" $(location): pch target name '$(name)' should

                be the same as the base name of header file '$(header-name)' ;

        }

        local pch-file = [ generator.run $(project) $(name) : $(property-set)

            : $(header) ] ;

        # Return result of base class and pch-file property as

        # usage-requirements.

        return

            [ property-set.create <pch-file>$(pch-file) <cflags>-Winvalid-pch ]

            $(pch-file)

          ;

    }

    # Calls the base version specifying source's name as the name of the created

    # target. As a result, the PCH will be named whatever.hpp.gch, and not

    # whatever.gch.

    rule generated-targets ( sources + : property-set : project name ? )

    {

        name = [ $(sources[1]).name ] ;

        return [ generator.generated-targets $(sources)

          : $(property-set) : $(project) $(name) ] ;

    }

    rule action-class ( )

    {

        return gcc-pch-compile-action ;

    }

}

class gcc-pch-compile-action : compile-action

{

    import gcc ;

    rule execute ( action-name targets + : sources * : properties * )

    {

        gcc.set-threading-options $(targets) : $(sources) : $(properties) ;

        gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;

        gcc.set-address-model-options $(targets) : $(sources) : $(properties) ;

        gcc.set-cxxstd-options $(targets) : $(sources) : $(properties) : $(__name__) ;

        compile-action.execute $(action-name) $(targets) : $(sources) : $(properties) ;

    }

}

# Note: the 'H' source type will catch both '.h' header and '.hpp' header. The

# latter have HPP type, but HPP type is derived from H. The type of compilation

# is determined entirely by the destination type.

generators.register [ new gcc-pch-generator gcc.compile.c.pch   : H :   C_PCH : <pch>on <toolset>gcc ] ;

generators.register [ new gcc-pch-generator gcc.compile.c++.pch : H : CPP_PCH : <pch>on <toolset>gcc ] ;

# Override default do-nothing generators.

generators.override gcc.compile.c.pch   : pch.default-c-pch-generator   ;

generators.override gcc.compile.c++.pch : pch.default-cpp-pch-generator ;

toolset.flags gcc.compile PCH_FILE <pch>on : <pch-file> ;

rule compile.c++.pch ( targets * : sources * : properties * )

{

}

actions compile.c++.pch

{

    "$(CONFIG_COMMAND)" -x c++-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"

}

rule compile.c.pch ( targets * : sources * : properties * )

{

}

actions compile.c.pch

{

    "$(CONFIG_COMMAND)" -x c-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"

}

###

### General options, like optimization.

###

# Declare flags and action for compilation.

toolset.flags gcc.compile OPTIONS <optimization>off   :  ;

toolset.flags gcc.compile OPTIONS <optimization>speed :  ;

toolset.flags gcc.compile OPTIONS <optimization>space :  ;

toolset.flags gcc.compile OPTIONS <inlining>off  :  ;

toolset.flags gcc.compile OPTIONS <inlining>on   :  ;

toolset.flags gcc.compile OPTIONS <inlining>full :  ;

toolset.flags gcc.compile OPTIONS <warnings>off :  ;

toolset.flags gcc.compile OPTIONS <warnings>on  :  ;

toolset.flags gcc.compile OPTIONS <warnings>all :  ;

toolset.flags gcc.compile OPTIONS <warnings-as-errors>on : -Werror ;

toolset.flags gcc.compile OPTIONS <debug-symbols>on : -g ;

toolset.flags gcc.compile OPTIONS <profiling>on : -pg ;

toolset.flags gcc.compile.c++ OPTIONS <rtti>off : -fno-rtti ;

toolset.flags gcc.compile.c++ OPTIONS <exception-handling>off : -fno-exceptions ;

###

### User free feature options.

###

toolset.flags gcc.compile USER_OPTIONS <cflags> ;

toolset.flags gcc.compile.c++ USER_OPTIONS <cxxflags> ;

toolset.flags gcc.compile.asm USER_OPTIONS <asmflags> ;

toolset.flags gcc.compile DEFINES <define> ;

toolset.flags gcc.compile INCLUDES <include> ;

toolset.flags gcc.compile.c++ TEMPLATE_DEPTH <c++-template-depth> ;

toolset.flags gcc.compile.fortran USER_OPTIONS <fflags> ;

###

### Linking generators and actions.

###

# Class checking that we do not try to use the <runtime-link>static property

# while creating or using a shared library, since it is not supported by

# gcc/libc.

class gcc-linking-generator : unix-linking-generator

{

    rule run ( project name ? : property-set : sources + )

    {

        local target-os = [ $(property-set).get <target-os> ] ;

        local no-static-link = true ;

        switch $(target-os)

        {

            case vms : no-static-link = ;

            case windows : no-static-link = ;

        }

        local properties = [ $(property-set).raw ] ;

        local reason ;

        if $(no-static-link) && <runtime-link>static in $(properties)

        {

            if <link>shared in $(properties)

            {

                reason = On gcc, DLLs can not be built with

                    '<runtime-link>static'. ;

            }

            else if [ type.is-derived $(self.target-types[1]) EXE ]

            {

                for local s in $(sources)

                {

                    local type = [ $(s).type ] ;

                    if $(type) && [ type.is-derived $(type) SHARED_LIB ]

                    {

                        reason = On gcc, using DLLs together with the

                            '<runtime-link>static' option is not possible. ;

                    }

                }

            }

        }

        if $(reason)

        {

            ECHO warning: $(reason) ;

            ECHO warning: It is suggested to use '<runtime-link>static' together

                with '<link>static'. ;

        }

        else

        {

            return [ unix-linking-generator.run $(project) $(name) :

                $(property-set) : $(sources) ] ;

        }

    }

    rule action-class ( )

    {

        return gcc-link-action ;

    }

}

class gcc-link-action : action

{

    import gcc ;

    rule execute ( action-name targets + : sources * : properties * )

    {

        gcc.set-threading-options $(targets) : $(sources) : $(properties) ;

        gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;

        gcc.set-address-model-options $(targets) : $(sources) : $(properties) ;

        gcc.set-cxxstd-options $(targets) : $(sources) : $(properties) : $(__name__) ;

        gcc.set-link-options $(action-name) $(targets) : $(sources) : $(properties) ;

        action.execute $(action-name) $(targets) : $(sources) : $(properties) ;

    }

}

# The set of permissible input types is different on mingw. So, define two sets

# of generators, with mingw generators selected when target-os=windows.

local g ;

g = [ new gcc-linking-generator gcc.mingw.link

      : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB

      : EXE

      : <toolset>gcc <target-os>windows ] ;

$(g).set-rule-name gcc.link ;

generators.register $(g) ;

g = [ new gcc-linking-generator gcc.mingw.link.dll

      : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB

      : IMPORT_LIB SHARED_LIB

      : <toolset>gcc <target-os>windows ] ;

$(g).set-rule-name gcc.link.dll ;