FM / tools

/usr/share/boost-build/src/tools

Name	Size	Mode	Actions
doxygen/	-	0755	rm
features/	-	0755	rm
generators/	-	0755	rm
types/	-	0755	rm
xsltproc/	-	0755	rm
acc.jam	4800	0644	edit dl rm
asciidoctor.jam	6480	0644	edit dl rm
auto-index.jam	8324	0644	edit dl rm
bison.jam	589	0644	edit dl rm
boostbook-config.jam	389	0644	edit dl rm
boostbook.jam	24056	0644	edit dl rm
borland.jam	9992	0644	edit dl rm
builtin.jam	3037	0644	edit dl rm
bzip2.jam	8066	0644	edit dl rm
cast.jam	3237	0644	edit dl rm
clang-darwin.jam	6713	0644	edit dl rm
clang-linux.jam	9984	0644	edit dl rm
clang-vxworks.jam	4026	0644	edit dl rm
clang-win.jam	6094	0644	edit dl rm
clang.jam	2310	0644	edit dl rm
common.jam	31679	0644	edit dl rm
como-linux.jam	3528	0644	edit dl rm
como-win.jam	4237	0644	edit dl rm
como.jam	2063	0644	edit dl rm
convert.jam	1987	0644	edit dl rm
cray.jam	41128	0644	edit dl rm
cw-config.jam	1283	0644	edit dl rm
cw.jam	9549	0644	edit dl rm
cygwin.jam	403	0644	edit dl rm
darwin.jam	22165	0644	edit dl rm
diab.jam	4307	0644	edit dl rm
dmc.jam	6094	0644	edit dl rm
docutils.jam	3444	0644	edit dl rm
doxproc.py	36621	0644	edit dl rm
doxygen-config.jam	388	0644	edit dl rm
doxygen.jam	24745	0644	edit dl rm
embarcadero.jam	21487	0644	edit dl rm
emscripten.jam	3779	0644	edit dl rm
flags.jam	4570	0644	edit dl rm
fop.jam	1693	0644	edit dl rm
fortran.jam	1989	0644	edit dl rm
gcc.jam	55288	0644	edit dl rm
generate.jam	3339	0644	edit dl rm
gettext.jam	7663	0644	edit dl rm
gfortran.jam	1008	0644	edit dl rm
hpfortran.jam	902	0644	edit dl rm
hp_cxx.jam	8089	0644	edit dl rm
ifort.jam	1495	0644	edit dl rm
intel-darwin.jam	9785	0644	edit dl rm
intel-linux.jam	9193	0644	edit dl rm
intel-vxworks.jam	7085	0644	edit dl rm
intel-win.jam	16396	0644	edit dl rm
intel.jam	2626	0644	edit dl rm
lex.jam	559	0644	edit dl rm
libjpeg.jam	7362	0644	edit dl rm
libpng.jam	7104	0644	edit dl rm
libtiff.jam	7208	0644	edit dl rm
link.jam	15021	0644	edit dl rm
lzma.jam	3277	0644	edit dl rm
make.jam	2266	0644	edit dl rm
mc.jam	1311	0644	edit dl rm
message.jam	1667	0644	edit dl rm
midl.jam	5367	0644	edit dl rm
mipspro.jam	5291	0644	edit dl rm
mpi.jam	21826	0644	edit dl rm
msvc-config.jam	393	0644	edit dl rm
msvc.jam	84672	0644	edit dl rm
notfile.jam	1654	0644	edit dl rm
openssl.jam	3613	0644	edit dl rm
package.jam	9281	0644	edit dl rm
pathscale.jam	6629	0644	edit dl rm
pch.jam	2719	0644	edit dl rm
pgi.jam	4879	0644	edit dl rm
pkg-config.jam	13443	0644	edit dl rm
python-config.jam	836	0644	edit dl rm
python.jam	43679	0644	edit dl rm
qcc.jam	10836	0644	edit dl rm
qt.jam	530	0644	edit dl rm
qt3.jam	6810	0644	edit dl rm
qt4.jam	23974	0644	edit dl rm
qt5.jam	26517	0644	edit dl rm
quickbook-config.jam	1266	0644	edit dl rm
quickbook.jam	13277	0644	edit dl rm
rc.jam	5364	0644	edit dl rm
sass.jam	5702	0644	edit dl rm
saxonhe.jam	1329	0644	edit dl rm
stage.jam	28513	0644	edit dl rm
stlport.jam	11880	0644	edit dl rm
sun.jam	8054	0644	edit dl rm
symlink.jam	4351	0644	edit dl rm
testing-aux.jam	10238	0644	edit dl rm
testing.jam	27889	0644	edit dl rm
unix.jam	5847	0644	edit dl rm
vacpp.jam	5725	0644	edit dl rm
vmsdecc.jam	20185	0644	edit dl rm
whale.jam	3253	0644	edit dl rm
xlcpp.jam	6121	0644	edit dl rm
xlf.jam	900	0644	edit dl rm
xsltproc-config.jam	838	0644	edit dl rm
xsltproc.jam	5603	0644	edit dl rm
zlib.jam	6976	0644	edit dl rm
zstd.jam	2446	0644	edit dl rm

Edit: /usr/share/boost-build/src/tools/cray.jam (41128B)

# Copyright 2001 David Abrahams
# Copyright 2004, 2005 Markus Schoepflin
# Copyright 2011 John Maddock
# Copyright 2013, 2017-2018 Cray, Inc.
#
# 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)

# README.md
#
# This toolset is for the Cray Compiling Environment (CCE).
#
# The assembler, linker, and archiver are the same as those used in the
# `gcc` toolset. Therefore, there is some duplication of code between the
# `gcc` toolset and this toolset.
#
# # CCE Introduction
#
# Users want to compile and run massively parallel applications on Cray
# supercomputers. Typically, the user compiles code on a login node of the
# supercomputer and then runs the compiled program on multiple compute
# nodes using a batch control system. This means the user is almost always
# cross compiling.
#
# But, they're not just cross compiling. In order for a program to run on
# a Cray supercomputer it has to link to particular libraries. There are
# three general categories of libraries that user programs must link to:
#
# - Network libraries: Enable communication between processes on different
#   compute nodes. Depends on the network hardware in the supercomputer.
# - Compute node libraries: Depends on the hardware on the targeted
#   compute nodes.
# - Language extension libraries: Depends on the language extensions used
#   by the program (e.g. OpenMP, Unified Parallel C, et cetera).
#
# Instead of forcing users to invoke the compiler with a bunch of
# libraries listed on the command line, CCE decides what libraries to link
# based on the environment. This is primarily controlled by loading and
# unloading modules (with the `module` command) to create a cross
# compiling and linking environment suitable for the particular hardware
# on the targeted Cray supercomputer.
#
# CCE compilers come in two parts: the compiler itself, and the compiler
# driver. Invoking a compiler directly is not supported. We must always
# invoke the compiler through a compiler driver: either `cc` for C code,
# `CC` for C++ code, or `ftn` for Fortran code. The compiler driver is
# responsible for gathering information from the environment and invoking
# the selected compiler with the appropriate command line options.
#
# For more information on CCE, search for Cray publication S-2529 on the
# Cray publications website (https://pubs.cray.com).

import "class" : new ;
import common ;
import feature ;
import gcc ;
import generators ;
import os ;
import regex ;
import set ;
import toolset ;
import type ;
import unix ;

###
### 'init'
###

rule init ( : : options * : requirements * )
{

# User cannot specify a 'version' in their 'using' statement. Compiler
    # version is always controlled by loading and unloading modules in the
    # user's environment.

# User cannot specify a 'command' in their 'using' statement. Using a
    # single 'command' argument only makes sense when a single executable can
    # compile different types of code (e.g. gcc will compile C or C++ based on
    # the file name extensions). In CCE, you have to invoke one of the three
    # compiler drivers: cc for C code, CC for C++ code, or ftn for Fortran
    # code. Each compiler driver compiles a single type of source code. It is
    # possible to let the user pass in three 'command' arguments, one for each
    # driver, but that seems like more effort that it's worth.

local toolset = cray ;

check-prgenv-module $(toolset) ;

local command-c = [ validate-command $(toolset) cc ] ;
    local command-cxx = [ validate-command $(toolset) CC ] ;
    local command-fortran = [ validate-command $(toolset) ftn ] ;

# Archive builder.
    local command-ar = [ validate-command $(toolset) ar ] ;

# Archive indexer.
    local command-ranlib = [ validate-command $(toolset) ranlib ] ;

# The 'command' variables always have one element, but they may contain
    # spaces (e.g. if 'command' is an absolute path and some path components
    # have spaces).

local version = ;
    local developer-build = ;
    {
        local version-string = [ SHELL "\"$(command-cxx)\" -VV 2>&1" ] ;
        local version-components = [ MATCH "Version ([0-9]+).([0-9]+).([a-zA-Z0-9]+)" : $(version-string) ] ;
        if ! [ MATCH "([0-9]+)" : $(version-components[3]) ]
        {

# The last component of the version is not a series of digits. This means
            # we're probably using a developer build of CCE (i.e. a compiler built by
            # a Cray employee). Developer builds report versions like '8.7.x'.

developer-build = true ;

# We want to treat developer builds as though they are the highest
            # possible patch version of the release. Effectively, we want to turn
            # '8.7.x' into '8.7.99'.

version-components = $(version-components[1]) $(version-components[2]) 99 ;

}

version = $(version-components:J=.) ;
    }

local build = ;
    if $(developer-build)
    {

# If this is a developer build, we want to add the build subfeature to the
        # compiler.

local version-string = [ SHELL "\"$(command-cxx)\" -VV 2>&1" ] ;
        build = [ MATCH "[(][0-9]+_([0-9a-fA-F]+)[)]" : $(version-string) ] ;

# Truncate build hash to 7 characters
        build = [ MATCH "(.......)................................." : $(build) ] ;
    }

# IMPORTANT: 'set-cray-feature-defaults' causes the B2 tests to
    # fail. I tried using an 'init' argument called 'ignore-cray-defaults' and
    # setting up 'test-config.jam' to pass 'ignore-cray-defaults' during
    # testing, but I couldn't get the test to read my 'test-config.jam' file
    # when running tests individually. So, I just comment out
    # 'set-cray-feature-defaults' during testing.

set-cray-feature-defaults ;

{

# 'check-init-parameters' ensures that each time a toolset is initialized,
        # it is initialized with a unique configuration. The return value is a
        # B2 property condition which uniquely identifies this
        # configured instance of this toolset. Typically, toolsets use the
        # returned condition as the conditional in a 'toolset.flags' call to set
        # flags specific to this configuration of this toolset.

local identifying-condition = [ common.check-init-parameters $(toolset) $(requirements) : version $(version) : build $(build) ] ;

# 'handle-options' uses 'toolset.flags' to set 'CONFIG_COMMAND' variables
        # on targets when this toolset is used. The 'CONFIG_COMMAND' variables
        # specify the commands to call for compiling. This would be more relevant
        # if our 'init' rule had arguments that might affect the command that is
        # invoked (e.g. in many toolsets 'version' affects the name of the
        # compiler command). For now, we'll do this because it is a common pattern
        # in toolsets, and we may need it in the future.

handle-options
            $(toolset)
          : $(identifying-condition)
          : $(command-c) $(command-cxx) $(command-fortran) $(command-ar) $(command-ranlib)
          : $(options) ;

# Add compiler version to 'VERSION' variable on all targets. 'VERSION' is
        # not used in any actions, but it is used in some updating rule
        # procedures.

toolset.flags $(toolset) VERSION $(identifying-condition) : [ numeric-version $(version) ] ;
    }
}

rule check-prgenv-module ( toolset )
{

local compiler = [ os.environ PE_ENV ] ;
    compiler = $(compiler:L) ;

# We could check that environment variable CRAY_PRGENV$PE_ENV is set to
    # "loaded", but this seems unnecessary and redundant.

local default-compiler = cray ;

if ! $(compiler)
    {
        log-warning $(toolset) : no PrgEnv module loaded
                               : falling back to PrgEnv-$(default-compiler)
                               : please load the PrgEnv-$(default-compiler) module next time ;
        compiler = $(default-compiler) ;
    }

if $(compiler) != $(default-compiler)
    {
        log-error $(toolset) : compiler '$(compiler)' not supported
                             : toolset initialization failed
                             : please load the PrgEnv-$(default-compiler) module next time ;
        # Do not abort, as suggested by:
        # http://www.boost.org/build/doc/html/bbv2/extending/toolset_modules.html.
    }
}

rule set-cray-feature-defaults ( )
{

# CCE users expect that using the 'cray' toolset without any explicit
    # options will give them the same result as invoking CCE without any
    # explicit options. So, we set feature defaults to match the default CCE
    # options.
    #
    # The decision to turn off <debug-symbols> by default was a tough one.
    # When CCE produces debugging symbols, it disables all inlining. This
    # causes a decrease in performance, which the user probably was not
    # expecting since they thought they were compiling with default CCE
    # options.

feature.set-default cxxstd-dialect : gnu ;
    feature.set-default debug-symbols  : off ;
    feature.set-default optimization   : default ;
    feature.set-default inlining       : default ;
    feature.set-default vectorize      : default ;
}

###
### Command line options
###

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

# Check if '--debug-configuration' was passed on the command line. This is
    # inspired by 'common.jam' and other modules.

# Variable names with a '.' prefix are intended to be globals.
    #
    # Refer to:
    # https://github.com/boostorg/build/blob/develop/CONTRIBUTING.rst

# The Jam language uses dynamic scoping. Setting '.debug-configuration' in
    # this module influences the behavior of methods called from this module.

.debug-configuration = true ;
}

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

.debug-driver = true ;
}

###
### Features
###

feature.extend toolset : cray ;

# Typically, extending '<toolset>' with the value 'cray' would cause
# 'cray' to be the default '<toolset>' as long as it is the first value
# added to '<toolset>'. However, we already imported the 'gcc' toolset, so
# 'cray' is not the first value added to '<toolset>'. Therefore, we need
# to call 'feature.set-default'.
#
# If the build request specifies a '<toolset>' (e.g. on the command line),
# then the '<toolset>' feature default is ignored. However, if the 'cray'
# toolset is selected in 'user-config.jam' (e.g. with 'using cray ;'),
# then the build request will use the '<toolset>' feature default.
# Therefore, we must use 'feature.set-default' so that selecting the
# 'cray' toolset in 'user-config.jam' works correctly.

feature.set-default toolset : cray ;

# CCE is different from other compilers in that it optimizes, inlines, and
# vectorizes by default. B2 assumes that 'off' is the default for
# all compilers. However, for CCE, 'off' and 'default' have different
# meanings. For CCE, 'off' requires an additional command line argument to
# turn the feature off. 'default' will not include an additional command
# line argument, but will do optimization, inlining, and vectorizing at
# whatever default level CCE uses.

feature.extend optimization : default ;
feature.extend inlining     : default ;
feature.extend vectorize    : default ;

###
### Flags
###

# Updating rules are named in a dotted hierarchy. For example:
#
# compile
#  \_ compile.c++
#      \_ compile.c++.preprocess
#  \_ compile.c
#      \_ compile.c.preprocess
#
# This naming convention allows us to apply flags to multiple children in
# the hierarchy. For example, if we apply a flag to 'compile.c++', that
# flag is also applied to its child 'compile.c++.preprocess'. If we apply
# a flag to 'compile', then that flag is applied to all children under
# 'compile'.

toolset.flags cray.compile OPTIONS <link>shared : -h pic ;

toolset.flags cray.compile OPTIONS <optimization>default        ; # Blank.
toolset.flags cray.compile OPTIONS <optimization>off     : -O 0 ;
toolset.flags cray.compile OPTIONS <optimization>speed   : -O 3 ;
toolset.flags cray.compile OPTIONS <optimization>space          ; # Blank. CCE does not optimize for space.

toolset.flags cray.compile OPTIONS <inlining>default           ; # Blank.
toolset.flags cray.compile OPTIONS <inlining>off     : -h ipa0 ;
toolset.flags cray.compile OPTIONS <inlining>on                ; # Blank. CCE does inlining by default.
toolset.flags cray.compile OPTIONS <inlining>full    : -h ipa5 ;

toolset.flags cray.compile OPTIONS <vectorize>default              ; # Blank.
toolset.flags cray.compile OPTIONS <vectorize>off     : -h vector0 ;
toolset.flags cray.compile OPTIONS <vectorize>on                   ; # Blank. CCE vectorizes by default.
toolset.flags cray.compile OPTIONS <vectorize>full    : -h vector3 ;

toolset.flags cray.link FINDLIBS-SA <threading>multi : rt ; # Not sure if this is correct.

toolset.flags cray.link OPTIONS <link>shared : -h pic ;

{
    #
    # Link flags copied from 'gcc.jam'.
    #

local toolset = cray ;
    local generic-os = [ set.difference [ feature.values <target-os> ] : aix darwin vxworks solaris osf hpux ] ;
    # Strip the binary when no debugging is needed. We use --strip-all flag
    # as opposed to -s since icc (intel's compiler) is generally
    # option-compatible with and inherits from the gcc toolset, but does not
    # support -s.
    toolset.flags $(toolset).link OPTIONS <target-os>$(generic-os)/<strip>on : -Wl,--strip-all ;
    toolset.flags $(toolset).link RPATH <target-os>$(generic-os) : <dll-path> ;
    toolset.flags $(toolset).link RPATH_OPTION <target-os>$(generic-os) : -rpath ;
    toolset.flags $(toolset).link RPATH_LINK <target-os>$(generic-os) : <xdll-path> ;
    toolset.flags $(toolset).link START-GROUP <target-os>$(generic-os) : -Wl,--start-group ;
    toolset.flags $(toolset).link END-GROUP <target-os>$(generic-os) : -Wl,--end-group ;

# gnu ld has the ability to change the search behaviour for libraries
    # referenced by the -l switch. These modifiers are -Bstatic and
    # -Bdynamic and change search for -l switches that follow them. The
    # following list shows the tried variants. Search stops at the first
    # variant that has a match.
    #
    # *nix: -Bstatic -lxxx
    #    libxxx.a
    #
    # *nix: -Bdynamic -lxxx
    #    libxxx.so
    #    libxxx.a
    #
    # windows (mingw, cygwin) -Bstatic -lxxx
    #    libxxx.a
    #    xxx.lib
    #
    # windows (mingw, cygwin) -Bdynamic -lxxx
    #    libxxx.dll.a
    #    xxx.dll.a
    #    libxxx.a
    #    xxx.lib
    #    cygxxx.dll (*)
    #    libxxx.dll
    #    xxx.dll
    #    libxxx.a
    #
    # (*) This is for cygwin
    # Please note that -Bstatic and -Bdynamic are not a guarantee that a
    # static or dynamic lib indeed gets linked in. The switches only change
    # search patterns!

# On *nix mixing shared libs with static runtime is not a good idea.
    toolset.flags $(toolset).link FINDLIBS-ST-PFX <target-os>$(generic-os)/<runtime-link>shared : -Wl,-Bstatic ;
    toolset.flags $(toolset).link FINDLIBS-SA-PFX <target-os>$(generic-os)/<runtime-link>shared : -Wl,-Bdynamic ;

toolset.flags $(toolset).link HAVE_SONAME <target-os>$(generic-os) : "" ;
    toolset.flags $(toolset).link SONAME_OPTION <target-os>$(generic-os) : -h ;

# See note [1]
    toolset.flags $(toolset).link OPTIONS <target-os>$(generic-os)/<runtime-link>static : -static ;

# [1]
    # For <runtime-link>static we made sure there are no dynamic libraries in the
    # link. On HP-UX not all system libraries exist as archived libraries (for
    # example, there is no libunwind.a), so, on this platform, the -static option
    # cannot be specified.
}

# Flags for 'free' features ('free' features are features that do not have
# a pre-defined set of values).

toolset.flags cray.compile USER_OPTIONS <cflags> ;
toolset.flags cray.compile.c++ USER_OPTIONS <cxxflags> ;
toolset.flags cray.compile.asm USER_OPTIONS <asmflags> ;
toolset.flags cray.compile DEFINES <define> ;
toolset.flags cray.compile INCLUDES <include> ;

toolset.flags cray.link USER_OPTIONS <linkflags> ;
toolset.flags cray.link LINKPATH <library-path> ;
toolset.flags cray.link FINDLIBS-ST <find-static-library> ;
toolset.flags cray.link FINDLIBS-SA <find-shared-library> ;
toolset.flags cray.link LIBRARIES <library-file> ;

toolset.flags cray.archive AROPTIONS <archiveflags> ;

###
### Actions
###

actions compile.c++
{
    "$(CONFIG_COMMAND_CXX)" $(OPTIONS) $(USER_OPTIONS) -D$(SPACE)$(DEFINES) -I$(SPACE)"$(INCLUDES)" -c -o "$(<)" "$(>)" $(DRIVER_OPTIONS)
}

actions compile.c
{
    "$(CONFIG_COMMAND_C)" $(OPTIONS) $(USER_OPTIONS) -D$(SPACE)$(DEFINES) -I$(SPACE)"$(INCLUDES)" -c -o "$(<)" "$(>)" $(DRIVER_OPTIONS)
}

actions compile.asm
{
    "$(CONFIG_COMMAND_CXX)" $(OPTIONS) $(USER_OPTIONS) -D$(SPACE)$(DEFINES) -I$(SPACE)"$(INCLUDES)" -c -o "$(<)" "$(>)" $(DRIVER_OPTIONS)
}

actions compile.c++.preprocess
{
    "$(CONFIG_COMMAND_CXX)" $(OPTIONS) $(USER_OPTIONS) -D$(SPACE)$(DEFINES) -I$(SPACE)"$(INCLUDES)" -E "$(>)" >"$(<)" $(DRIVER_OPTIONS)
}

actions compile.c.preprocess
{
    "$(CONFIG_COMMAND_C)" $(OPTIONS) $(USER_OPTIONS) -D$(SPACE)$(DEFINES) -I$(SPACE)"$(INCLUDES)" -E "$(>)" >"$(<)" $(DRIVER_OPTIONS)
}

# We don't want to invoke 'ld' (the linker) directly for 'link', since we
# want to give the CCE compiler driver a chance to modify the command line
# it passes to 'ld'.
#
# The question is: which CCE compiler driver do we use? The driver for C,
# the driver for C++, or the driver for Fortran?
#
# Here are things that definitely do not work:
#
# - Using the driver for C doesn't work when linking C++ programs, because
#   things like 'std::cout' are not available in C, they are only
#   available in C++.
#
# We use the driver for C++ below since we are primarily interested in
# compiling Boost, which is written in C++. Also, the C++ driver will
# properly link C code as well.

actions link bind LIBRARIES
{
    "$(CONFIG_COMMAND_CXX)" -L"$(LINKPATH)" -Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,$(RPATH) -Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" -o "$(<)" $(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) $(USER_OPTIONS) $(DRIVER_OPTIONS)
}

actions link.dll bind LIBRARIES
{
    "$(CONFIG_COMMAND_CXX)" -L"$(LINKPATH)" -Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,$(RPATH) -o "$(<[-1])" $(HAVE_SONAME)-Wl,$(SONAME_OPTION)$(SPACE)-Wl,$(<[-1]:D=) $(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) $(USER_OPTIONS) $(DRIVER_OPTIONS)
}

actions piecemeal archive
{
    "$(.AR)" $(AROPTIONS) rc "$(<)" "$(>)"
    "$(.RANLIB)" "$(<)"
}

###
### Updating rules
###

# These are the actual updating rules that apply the associated actions
# when called.

rule compile.c++ ( targets * : sources * : properties * )
{
    compile-c++-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile.c ( targets * : sources * : properties * )
{
    compile-c-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile.asm ( targets * : sources * : properties * )
{
    compile-asm-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile.c++.preprocess ( targets * : sources * : properties * )
{
    compile-c++-preprocess-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile.c.preprocess ( targets * : sources * : properties * )
{
    compile-c-preprocess-procedure $(targets) : $(sources) : $(properties) ;
}

rule link ( targets * : sources * : properties * )
{
    link-procedure $(targets) : $(sources) : $(properties) ;
}

rule link.dll ( targets * : sources * : properties * )
{
    link-dll-procedure $(targets) : $(sources) : $(properties) ;
}

rule archive ( targets * : sources * : properties * )
{
    archive-procedure $(targets) : $(sources) : $(properties) ;
}

# These are the procedure portions of the updating rules. Calling the
# procedure portion may modify the targets, but it will not apply actions
# to the targets. This allows us to reuse the procedure portions of the
# updating rules without applying the same actions to targets.

rule compile-c++-procedure ( targets * : sources * : properties * )
{
    set-cxxstd-procedure $(targets) : $(sources) : $(properties) ;
    set-cxxstd-dialect-procedure $(targets) : $(sources) : $(properties) ;
    set-debug-symbols-procedure $(targets) : $(sources) : $(properties) ;
    add-space-procedure $(targets) : $(sources) : $(properties) ;
    debug-driver-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile-c-procedure ( targets * : sources * : properties * )
{
    set-debug-symbols-procedure $(targets) : $(sources) : $(properties) ;
    add-space-procedure $(targets) : $(sources) : $(properties) ;
    debug-driver-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile-asm-procedure ( targets * : sources * : properties * )
{
    compile-c++-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile-c++-preprocess-procedure ( targets * : sources * : properties * )
{
    compile-c++-procedure $(targets) : $(sources) : $(properties) ;
}

rule compile-c-preprocess-procedure ( targets * : sources * : properties * )
{
    compile-c-procedure $(targets) : $(sources) : $(properties) ;
}

rule link-procedure ( targets * : sources * : properties * )
{
    set-cxxstd-procedure $(targets) : $(sources) : $(properties) ;
    set-cxxstd-dialect-procedure $(targets) : $(sources) : $(properties) ;
    gcc-link-procedure $(targets) : $(sources) : $(properties) ;
    debug-driver-procedure $(targets) : $(sources) : $(properties) ;

# CCE driver command line flags for linking executables.

local link = [ feature.get-values <link> : $(properties) ] ;
    switch $(link)
    {
        case shared :
            DRIVER_OPTIONS on $(<) += -dynamic ;
        case static :
            DRIVER_OPTIONS on $(<) += -static ;
    }

# The link command line from the 'gcc' toolset includes:
    #
    # '$(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA)'
    #
    # The 'FINDLIBS-ST' and 'FINDLIBS-SA' variables are the libraries
    # specified by the '<find-static-library>' and '<find-shared-library>'
    # features, respectively. The 'FINDLIBS-ST-PFX' is typically
    # '-Wl,-Bstatic'. The 'FINDLIBS-SA-PFX' is typically '-Wl,-Bdynamic'.
    #
    # The '-Bstatic' and '-Bdynamic' flags passed to the linker tell the
    # linker how to link all of the following libraries. The flag is in effect
    # until it is overridden by another '-B' flag on the command line.
    #
    # So, it makes sense that the 'gcc' toolset includes these flags, so the
    # '<find-static-library>' and '<find-shared-library>' libraries are linked
    # properly.
    #
    # The last flag that is set ('-Bdynamic') affects the link type for any
    # other libraries on the command line. In the 'gcc' toolset, this is okay,
    # since there are no other libraries specified on the command line after
    # these flags. However, when the CCE compiler driver invokes the linker,
    # it adds additional libraries to the command line based on what modules
    # are loaded in the environment. So, the last '-B' flag on the CCE driver
    # command line affects the link type for all libraries that CCE
    # automatically appends.
    #
    # Therefore, we have to set the final '-B' flag to the link type we want
    # the CCE libraries to be linked with. Appending to the 'OPTIONS' variable
    # seems reasonable.

local link = [ feature.get-values <link> : $(properties) ] ;
    switch $(link)
    {
        case shared :
            OPTIONS on $(<) += -Wl,-Bdynamic ;
        case static :
            OPTIONS on $(<) += -Wl,-Bstatic ;
    }
}

rule link-dll-procedure ( targets * : sources * : properties * )
{
    set-cxxstd-procedure $(targets) : $(sources) : $(properties) ;
    set-cxxstd-dialect-procedure $(targets) : $(sources) : $(properties) ;
    gcc-link-dll-procedure $(targets) : $(sources) : $(properties) ;
    debug-driver-procedure $(targets) : $(sources) : $(properties) ;

# CCE driver command line flags for linking shared libraries.

DRIVER_OPTIONS on $(<) += -shared ;
}

rule archive-procedure ( targets * : sources * : properties * )
{
    gcc-archive-procedure $(targets) : $(sources) : $(properties) ;
    debug-driver-procedure $(targets) : $(sources) : $(properties) ;
}

# Utility procedure rules intended to be called from updating rules.

rule gcc-link-procedure ( targets * : sources * : properties * )
{

# Copied from 'gcc.jam'.

SPACE on $(targets) = " " ;
    # Serialize execution of the 'link' action, since running N links in
    # parallel is just slower. For now, serialize only gcc links, it might be a
    # good idea to serialize all links.
    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
    gcc.quote-rpath $(targets) ;
}

rule gcc-link-dll-procedure ( targets * : sources * : properties * )
{

# Copied from 'gcc.jam'.

SPACE on $(targets) = " " ;
    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
    gcc.quote-rpath $(targets) ;
}

rule gcc-archive-procedure ( targets * : sources * : properties * )
{

# Copied from 'gcc.jam'.

# Always remove archive and start again. Here is the rationale from
    #
    # Andre Hentz:
    #
    # I had a file, say a1.c, that was included into liba.a. I moved a1.c to
    # a2.c, updated my Jamfiles and rebuilt. My program was crashing with absurd
    # errors. After some debugging I traced it back to the fact that a1.o was
    # *still* in liba.a
    #
    # Rene Rivera:
    #
    # Originally removing the archive was done by splicing an RM onto the
    # archive action. That makes archives fail to build on NT when they have
    # many files because it will no longer execute the action directly and blow
    # the line length limit. Instead we remove the file in a different action,
    # just before building the archive.
    #
    local clean.a = $(targets[1])(clean) ;
    TEMPORARY $(clean.a) ;
    NOCARE $(clean.a) ;
    LOCATE on $(clean.a) = [ on $(targets[1]) return $(LOCATE) ] ;
    DEPENDS $(clean.a) : $(sources) ;
    DEPENDS $(targets) : $(clean.a) ;
    common.RmTemps $(clean.a) : $(targets) ;
}

rule add-space-procedure ( targets * : sources * : properties * )
{
    SPACE on $(targets) = " " ;
}

rule set-cxxstd-procedure ( targets * : sources * : properties * )
{

# Translate '<cxxstd>' into a standard recognized by CCE.

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

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

local unsupported-values = 2a 20 ; # I don't know what '2a' means.
    if $(cxxstd) && $(cxxstd) in $(unsupported-values)
    {

log-warning cray : ignoring unsupported property '<cxxstd>$(cxxstd)' ;

# Set to default value, or blank if default is unsupported.

local default-value = [ get-default-feature-value cxxstd ] ;
        if $(default-value) in $(unsupported-values)
        {
            cxxstd = ;
        }
        else
        {
            cxxstd = $(default-value) ;
        }
    }

switch $(cxxstd)
    {
        case 98 : cray-cxxstd = 03 ;
        case 03 : cray-cxxstd = 03 ;
        case 0x : cray-cxxstd = 11 ;
        case 11 : cray-cxxstd = 11 ;
        case 1y : cray-cxxstd = 14 ;
        case 14 : cray-cxxstd = 14 ;
        case 1z : cray-cxxstd = 17 ;
        case 17 : cray-cxxstd = 17 ;
        case latest :
            cray-cxxstd = [ latest-cray-cxxstd $(version) ] ;
    }

# If the 'cray-cxxstd' is not supported by this compiler version, we just
    # let the command line fail.

# If 'cxxstd' was blank, then 'cray-cxxstd' is also blank, and nothing is
    # added to the command line. The compiler just uses it's default C++
    # standard.

# Apply final options.
    local space = " " ;
    OPTIONS on $(targets) += -h$(space)std=c++$(cray-cxxstd) ;
}

rule set-cxxstd-dialect-procedure ( targets * : sources * : properties * )
{

# Translate '<cxxstd-dialect>' into '-h [no]conform' and '-h [no]gnu'
    # options.

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

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

local unsupported-values = ms ;
    if $(cxxstd-dialect) && $(cxxstd-dialect) in $(unsupported-values)
    {

log-warning cray : ignoring unsupported property '<cxxstd-dialect>$(cxxstd-dialect)' ;

# Set to default value, or blank if default is unsupported.

local default-value = [ get-default-feature-value cxxstd-dialect ] ;
        if $(default-value) in $(unsupported-values)
        {
            cxxstd-dialect = ;
        }
        else
        {
            cxxstd-dialect = $(default-value) ;
        }
    }

switch $(cxxstd-dialect)
    {
        case gnu : cray-conform = noconform ;
                   cray-gnu = gnu ;
        case iso : cray-conform = conform ;
                   cray-gnu = nognu ;
    }

if [ has-conform-option $(version) ] = false
    {
        # The '-h [no]conform' option is ignored in recent versions of CCE.
        cray-conform = ;
    }

# If 'cxxstd-dialect' was blank, then 'cray-conform' and 'cray-gnu' are
    # also blank, and nothing is added to the command line. The compiler just
    # uses it's default C++ dialect.

# Apply final options.
    local space = " " ;
    OPTIONS on $(targets) += -h$(space)$(cray-conform)
                             -h$(space)$(cray-gnu) ;
}

rule set-debug-symbols-procedure ( targets * : sources * : properties * )
{

local debug-symbols = [ feature.get-values <debug-symbols> : $(properties) ] ;
    if $(debug-symbols) = "on"
    {
        local optimization = [ feature.get-values <optimization> : $(properties) ] ;
        local debug-option = ;
        if $(optimization) = off
        {
            debug-option = 0 ;
        }
        else
        {
            debug-option = 3 ;
        }

local space = " " ;
        OPTIONS on $(targets) += -G$(space)$(debug-option) ;
    }
}

rule debug-driver-procedure ( targets * : sources * : properties * )
{
    if $(.debug-driver)
    {

# Passing '-vv' to the CCE driver causes it to output the command lines
        # for the underlying tools that it invokes.

DRIVER_OPTIONS on $(<) += -vv ;
    }
}

###
### Generators
###

class cray-linking-generator : gcc-linking-generator
{
    rule action-class ( )
    {
        return action ;
    }
}

# We reuse some generator classes from the 'unix' toolset. Specifically,
# we are reusing generators for the following updating actions:
#
# - 'archive'
# - 'searched-lib-generator'
# - 'prebuilt'
#
# Inheriting these generators is like using the same generator classes as
# the 'unix' toolset, but pointing them to the 'cray' updating rules.

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

# The 'C-compiling-generator' class adds source paths to the '<include>'
# property.

generators.register [ new C-compiling-generator
                          cray.compile.c++
                        : CPP
                        : OBJ
                        : <toolset>cray ] ;
generators.register [ new C-compiling-generator
                          cray.compile.c
                        : C
                        : OBJ
                        : <toolset>cray ] ;
generators.register [ new C-compiling-generator
                          cray.compile.asm
                        : ASM
                        : OBJ
                        : <toolset>cray ] ;
generators.register [ new C-compiling-generator
                          cray.compile.c++.preprocess
                        : CPP
                        : PREPROCESSED_CPP
                        : <toolset>cray ] ;
generators.register [ new C-compiling-generator
                          cray.compile.c.preprocess
                        : C
                        : PREPROCESSED_C
                        : <toolset>cray ] ;
generators.register [ new cray-linking-generator
                          cray.link
                        : LIB OBJ
                        : EXE
                        : <toolset>cray ] ;
generators.register [ new cray-linking-generator
                          cray.link.dll
                        : LIB OBJ
                        : SHARED_LIB
                        : <toolset>cray ] ;

# Tell B2 to prefer 'cray' generators over other valid
# generators. This is used to resolve a tie when B2 finds that
# there is more than one viable generator for a particular build request.

generators.override cray.prebuilt : builtin.prebuilt ;
generators.override cray.searched-lib-generator : searched-lib-generator ;

type.set-generated-target-suffix PREPROCESSED_CPP : <toolset>cray : i ;
type.set-generated-target-suffix PREPROCESSED_C : <toolset>cray : i ;

###
### Utility rules
###

rule validate-command ( toolset command )
{
    local found-command = [ common.find-tool $(command) ] ;
    if $(found-command) && $(.debug-configuration)
    {
        log-notice $(toolset) : command '$(command)' found at [ common.get-absolute-tool-path $(found-command) ] ;
    }
    if ! $(found-command)
    {
        log-warning $(toolset) : command '$(command)' not found ;
        found-command = $(command) ;
    }
    return $(found-command) ;
}

local rule options-helper ( rule-or-module variable-name condition * : feature options * )
{
    toolset.flags $(rule-or-module) $(variable-name) $(condition) : [ feature.get-values $(feature) : $(options) ] : unchecked ;
}

rule handle-options (
    toolset
  : toolset-condition *
  : command-c command-cxx command-fortran command-ar command-ranlib
  : options *
)
{

# Configures some common 'toolset.flags' options. In particular, this rule
    # sets the compiler command name to invoke. Inspired by
    # 'common.handle-options'.

# We cannot use a single 'CONFIG_COMMAND' variable because each CCE driver
    # can only handle a single source code language. Therefore, we have to
    # give actions a way to specify which driver they intend to use, and we
    # accomplish this by providing multiple 'CONFIG_COMMAND' variables to the
    # action. We cannot set the language through a flag in the 'OPTIONS'
    # variable the way the 'gcc' toolset does.

toolset.flags $(toolset) CONFIG_COMMAND_C $(toolset-condition) : $(command-c) : unchecked ;
    toolset.flags $(toolset) CONFIG_COMMAND_CXX $(toolset-condition) : $(command-cxx) : unchecked ;
    toolset.flags $(toolset) CONFIG_COMMAND_FORTRAN $(toolset-condition) : $(command-fortran) : unchecked ;
    toolset.flags $(toolset).archive .AR $(toolset-condition) : $(command-ar) : unchecked ;
    toolset.flags $(toolset).archive .RANLIB $(toolset-condition) : $(command-ranlib) : unchecked ;

# The following flags are applied to all targets built by this
    # configuration of this toolset. This particular configuration of this
    # toolset is identified by '$(toolset-condition)'. This allows the user to
    # specify 'options' in their 'using' statement, and those options will be
    # applied to all targets built by this configuration of this toolset.

options-helper $(toolset).compile USER_OPTIONS $(toolset-condition) : <compileflags> $(options) ;
    options-helper $(toolset).compile USER_OPTIONS $(toolset-condition) : <cflags> $(options) ;
    options-helper $(toolset).compile.c++ USER_OPTIONS $(toolset-condition) : <cxxflags> $(options) ;
    options-helper $(toolset).compile.fortran USER_OPTIONS $(toolset-condition) : <fflags> $(options) ;
    options-helper $(toolset).compile.asm USER_OPTIONS $(toolset-condition) : <asmflags> $(options) ;
    options-helper $(toolset).compile DEFINES $(toolset-condition) : <define> $(options) ;
    options-helper $(toolset).compile INCLUDES $(toolset-condition) : <include> $(options) ;

options-helper $(toolset).link USER_OPTIONS $(toolset-condition) : <linkflags> $(options) ;
    options-helper $(toolset).link LINKPATH $(toolset-condition) : <library-path> $(options) ;
    options-helper $(toolset).link FINDLIBS-ST $(toolset-condition) : <find-static-library> $(options) ;
    options-helper $(toolset).link FINDLIBS-SA $(toolset-condition) : <find-shared-library> $(options) ;
    options-helper $(toolset).link LIBRARIES $(toolset-condition) : <library-file> $(options) ;

options-helper $(toolset).archive AROPTIONS $(toolset-condition) : <archiveflags> $(options) ;
}

rule latest-cray-cxxstd ( compiler-version )
{
    # Select latest 'cray-cxxstd' based on compiler version.

local cray-cxxstd = 03 ;

if $(compiler-version) >= [ numeric-version 8.6 ]
    {
        cray-cxxstd = 14 ;
    }

return $(cray-cxxstd) ;
}

rule has-conform-option ( compiler-version )
{

# Returns 'true' or 'false'. Returns empty list if the 'compiler-version'
    # is not supported.

local result = true ;

if $(compiler-version) >= [ numeric-version 8.6 ]
    {
        result = false ;
    }

return $(result) ;
}

local rule justify-right ( pad-char elements * )
{

# Returns a list of 'elements' where each 'element' is at least 2
    # characters long. If an 'element' is less than two characters long, pads
    # 'element' with 'pad-char' to make it 2 characters long.

local result = ;
    local p = $(pad-char) ;
    for local e in $(elements)
    {
        switch $(e)
        {
            case ?? : result += $(e) ;
            case ?  : result += $(p)$(e) ;
            case *  : result += $(p)$(p) ;
        }
    }
    return $(result) ;
}

local rule list-justify-left ( pad-elem elements * )
{

# Add 'pad-elem' to 'elements' list until it has 4 elements. If 'elements'
    # list already had 4 or more elements, returns the first 4 elements in
    # 'elements' list.

local tally = x ;
    local result = ;
    for local e in $(elements)
    {
        if $(tally) != xxxxx
        {
            result += $(e) ;
            tally = $(tally)x ;
        }
    }

while $(tally) != xxxxx
    {
        result += $(pad-elem) ;
        tally = $(tally)x ;
    }

return $(result) ;
}

local rule numeric-version ( dotted-version )
{

# Returns a numeric representation of version that can be compared
    # directly with comparison operators.

local result = [ regex.split $(dotted-version) "[.]" ] ;
    result = [ list-justify-left 0 $(result) ] ;
    result = [ justify-right 0 $(result) ] ;
    result = $(result:J="") ;

return $(result) ;
}

local rule get-default-feature-value ( feature-name )
{
    local default-property = [ feature.defaults $(feature-name) ] ;
    local default-value = [ feature.get-values $(feature-name) : $(default-property) ] ;
    return $(default-value) ;
}

rule log ( log-level prefix ? : * )
{
    for local message-arg in 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
    {
        local message = $($(message-arg)) ;
        if $(message)
        {
            ECHO "$(log-level):" "$(prefix):" $(message) ;
        }
    }
}

rule log-error ( prefix ? : * )
{
    log error $(prefix) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) : $(10) : $(11) : $(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) : $(19) : $(20) : $(21) : $(22) : $(23) : $(24) ;
}

rule log-warning ( prefix ? : * )
{
    log warning $(prefix) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) : $(10) : $(11) : $(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) : $(19) : $(20) : $(21) : $(22) : $(23) : $(24) ;
}

rule log-notice ( prefix ? : * )
{
    log notice $(prefix) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) : $(10) : $(11) : $(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) : $(19) : $(20) : $(21) : $(22) : $(23) : $(24) ;
}

rule __test__ ( )
{
    import assert ;

assert.result 08060000 : numeric-version 8.6 ;
    assert.result 08061500 : numeric-version 8.6.15 ;
    assert.result 08061501 : numeric-version 8.6.15.1 ;
    assert.result 08061501 : numeric-version 8.6.15.1.2 ;

local a = [ numeric-version 8.6 ] ;
    local b = [ numeric-version 8.5.9 ] ;

# 'assert.equal x : y' forces the test to fail. It's like saying 'assert
    # false'.

if ! ( $(a) > $(b) )
    {
        assert.equal x : y ;
    }

if ! ( $(b) < $(a) )
    {
        assert.equal x : y ;
    }

if ! ( $(a) >= $(b) )
    {
        assert.equal x : y ;
    }

if ! ( $(a) >= $(a) )
    {
        assert.equal x : y ;
    }

if ! ( $(b) <= $(a) )
    {
        assert.equal x : y ;
    }

if ! ( $(b) <= $(b) )
    {
        assert.equal x : y ;
    }

if ! ( $(a) = $(a) )
    {
        assert.equal x : y ;
    }

if ! ( $(a) != $(b) )
    {
        assert.equal x : y ;
    }
}

cmd: