mirror of
https://github.com/boostorg/build.git
synced 2026-02-17 13:42:14 +00:00
6585ab5128
Make sure we only try to embed manifest in executable if it was created. Patch from Alexey Pakhunov. [SVN r32306]
828 lines
28 KiB
Plaintext
828 lines
28 KiB
Plaintext
# Copyright (c) 2003 David Abrahams.
|
|
# Copyright (c) 2005 Vladimir Prus.
|
|
# Copyright (c) 2005 Alexey Pakhunov.
|
|
#
|
|
# Use, modification and distribution is subject to the Boost Software
|
|
# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
|
|
# http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
import property ;
|
|
import generators ;
|
|
import os ;
|
|
import type ;
|
|
import toolset : flags ;
|
|
import errors : error ;
|
|
import feature : feature get-values ;
|
|
import path ;
|
|
import sequence : unique ;
|
|
import common ;
|
|
import "class" : new ;
|
|
import rc ;
|
|
import midl ;
|
|
import mc ;
|
|
import pch ;
|
|
|
|
if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
|
|
{
|
|
.debug-configuration = true ;
|
|
}
|
|
|
|
feature.extend toolset : msvc ;
|
|
|
|
feature.subfeature toolset msvc : vendor
|
|
: intel
|
|
: propagated optional
|
|
# intel and msvc supposedly have link-compatible objects... remains
|
|
# to be seen, though ;-)
|
|
;
|
|
|
|
# List of all registered configurations
|
|
.versions = [ new configurations ] ;
|
|
|
|
# Inherit MIDL flags
|
|
toolset.inherit-flags msvc : midl ;
|
|
|
|
# Inherit MC flags
|
|
toolset.inherit-flags msvc : mc ;
|
|
|
|
RM = [ common.rm-command ] ;
|
|
nl = "
|
|
" ;
|
|
|
|
|
|
# Initialize the toolset for a specific version. As the result, path to
|
|
# compiler and, possible, program names are set up, and will be used when
|
|
# that version of compiler is requested. For example, you might have:
|
|
#
|
|
# using msvc : 6.5 : cl.exe ;
|
|
# using msvc : 7.0 : Y:/foo/bar/cl.exe ;
|
|
#
|
|
# The version paramater can be ommited:
|
|
#
|
|
# using msvc : : Z:/foo/bar/cl.exe ;
|
|
#
|
|
# Two special version keywords may be supplied:
|
|
# - all - all detected versions will be registered;
|
|
# - default - this is an equivalent to an empty version.
|
|
#
|
|
# Depending on a supplied version, detected configurations and presence
|
|
# 'cl.exe' in the path different results may be achieved. The following
|
|
# table describes all possible cases:
|
|
#
|
|
# Nothing "x.y"
|
|
# Passed Nothing "x.y" detected, detected,
|
|
# version detected detected cl.exe in path cl.exe in path
|
|
#
|
|
# default Error Use "x.y" Create "default" Use "x.y"
|
|
# all None Use all None Use all
|
|
# x.y - Use "x.y" - Use "x.y"
|
|
# a.b Error Error Create "a.b" Create "a.b"
|
|
#
|
|
# "x.y" - refers to a detected version;
|
|
# "a.b" - refers to an undetected version.
|
|
#
|
|
# Note: for free VC7.1 tools, we don't correctly find vcvars32.bar when user
|
|
# explicitly provides a path.
|
|
rule init (
|
|
version ? # the msvc version which is being configured. When omitted
|
|
# the tools invoked when no explicit version is given will be configured.
|
|
: command *
|
|
# the command to invoke the compiler. If not specified:
|
|
# - if version is given, default location for that version will be searched
|
|
#
|
|
# - if version is not given, default locations for 7.1, 7.0 and 6.* will
|
|
# be searched
|
|
#
|
|
# - if compiler is not found in default locations, PATH will be searched.
|
|
: options *
|
|
# options can include <setup>, <compiler>, <assembler>, <linker> and <resource-compiler>
|
|
)
|
|
{
|
|
if $(command)
|
|
{
|
|
options += <command>$(command) ;
|
|
}
|
|
|
|
configure $(version) : $(options) ;
|
|
}
|
|
|
|
|
|
# 'configure' is a newer version of 'init'. The parameter 'command' is passed as
|
|
# a part of the 'options' list.
|
|
rule configure (
|
|
version ? :
|
|
options *
|
|
)
|
|
{
|
|
switch $(version)
|
|
{
|
|
case all :
|
|
if $(options)
|
|
{
|
|
error "msvc: options should be empty when 'all' is specified" ;
|
|
}
|
|
|
|
# use all detected versions
|
|
for local v in [ $(.versions).all ]
|
|
{
|
|
configure-really $(v) ;
|
|
}
|
|
|
|
case "default" :
|
|
configure-really : $(options) ;
|
|
|
|
case * :
|
|
configure-really $(version) : $(options) ;
|
|
}
|
|
}
|
|
|
|
|
|
# Supported CPU architectures
|
|
cpu-arch-i386 =
|
|
<architecture>/<address-model>
|
|
<architecture>/<address-model>32
|
|
<architecture>x86/<address-model>
|
|
<architecture>x86/<address-model>32 ;
|
|
|
|
cpu-arch-amd64 =
|
|
<architecture>/<address-model>64
|
|
<architecture>x86/<address-model>64 ;
|
|
|
|
cpu-arch-ia64 =
|
|
<architecture>ia64/<address-model>
|
|
<architecture>ia64/<address-model>64 ;
|
|
|
|
|
|
local rule configure-really (
|
|
version ? :
|
|
options *
|
|
)
|
|
{
|
|
# If no version supplied use the default configuration. Note that condition
|
|
# remains versionless.
|
|
local v = $(version) ;
|
|
if ! $(v)
|
|
{
|
|
# take the first detected version
|
|
version = [ $(.versions).all ] ;
|
|
version = $(version[1]) ;
|
|
|
|
# Note: 'version' can still be empty at this point if no versions were
|
|
# detected.
|
|
version ?= "default" ;
|
|
}
|
|
|
|
# Version alias -> real version number
|
|
if $(.version-alias-$(version))
|
|
{
|
|
version = $(.version-alias-$(version)) ;
|
|
}
|
|
|
|
# Check whether selected configuration is used already
|
|
if $(version) in [ $(.versions).used ]
|
|
{
|
|
# Allow multiple 'toolset.usage' calls for the same configuration
|
|
# if the identical sets of options are used
|
|
if $(options) && ( $(options) != [ $(.versions).get $(version) : options ] )
|
|
{
|
|
error "msvc: the toolset version '$(version)' is configured already" ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# Register a new configuration
|
|
$(.versions).register $(version) ;
|
|
|
|
# Set new options if any
|
|
if $(options)
|
|
{
|
|
$(.versions).set $(version) : options : $(options) ;
|
|
}
|
|
|
|
# Mark the configuration as 'used'.
|
|
$(.versions).use $(version) ;
|
|
|
|
# Get auto-detected or user-supplied options
|
|
options = [ $(.versions).get $(version) : options ] ;
|
|
|
|
# Generate condition and save it
|
|
local condition = [ common.check-init-parameters msvc :
|
|
version $(v) ] ;
|
|
|
|
$(.versions).set $(version) : condition : $(condition) ;
|
|
|
|
|
|
local command = [ get-values <command> : $(options) ] ;
|
|
|
|
# If version is specified, we try to search first in default paths,
|
|
# and only then in PATH.
|
|
command = [ common.get-invocation-command msvc : cl.exe : $(command)
|
|
: [ default-paths $(version) ] : $(version) ] ;
|
|
|
|
common.handle-options msvc : $(condition) : $(command) : $(options) ;
|
|
|
|
|
|
if ! $(version)
|
|
{
|
|
# Even if version is not explicitly specified, try to detect the version
|
|
# from the path.
|
|
if [ MATCH "(Microsoft Visual Studio 8)" : $(command) ]
|
|
{
|
|
version = 8.0 ;
|
|
}
|
|
else if [ MATCH "(NET 2003[\/\\]VC7)" : $(command) ]
|
|
{
|
|
version = 7.1 ;
|
|
}
|
|
else if [ MATCH "(Microsoft Visual C\\+\\+ Toolkit 2003)" : $(command) ]
|
|
{
|
|
version = 7.1toolkit ;
|
|
}
|
|
else if [ MATCH "(.NET[\/\\]VC7)" : $(command) ]
|
|
{
|
|
version = 7.0 ;
|
|
}
|
|
else
|
|
{
|
|
version = 6.0 ;
|
|
}
|
|
}
|
|
|
|
|
|
# Generate and register setup command
|
|
|
|
local below-8.0 = [ MATCH ^([67]\\.) : $(version) ] ;
|
|
|
|
local cpu = i386 ;
|
|
|
|
local setup ;
|
|
local setup-option ;
|
|
|
|
if $(command)
|
|
{
|
|
command = [ common.get-absolute-tool-path $(command[-1]) ] ;
|
|
|
|
local parent = [ path.make $(command) ] ;
|
|
parent = [ path.parent $(parent) ] ;
|
|
parent = [ path.native $(parent) ] ;
|
|
|
|
# setup will be used if the script name has been specified.
|
|
# If setup is not specified, a default script will be used instead.
|
|
setup = [ get-values <setup> : $(options) ] ;
|
|
|
|
if ! $(setup)
|
|
{
|
|
if $(below-8.0)
|
|
{
|
|
setup ?= vcvars32.bat ;
|
|
}
|
|
else
|
|
{
|
|
setup ?= vcvarsall.bat ;
|
|
}
|
|
|
|
# The vccars32.bat is actually in "bin" directory.
|
|
# (except for free VC7.1 tools)
|
|
setup = [ GLOB $(command) $(parent) : $(setup) ] ;
|
|
}
|
|
|
|
if $(setup)
|
|
{
|
|
# Note Cygwin to Windows translation
|
|
setup = "\""$(setup[1]:W)"\"" ;
|
|
|
|
if ! $(below-8.0)
|
|
{
|
|
cpu = i386 amd64 ia64 ;
|
|
setup-option = x86 x86_amd64 x86_ia64 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
local prefix = "call " ;
|
|
local suffix = " >nul
|
|
" ;
|
|
if ! [ os.name ] in NT
|
|
{
|
|
prefix = "cmd.exe /S /C call " ;
|
|
suffix = " >nul \"&&\" " ;
|
|
}
|
|
|
|
command = $(prefix)$(setup)" "$(setup-option:E="")$(suffix) ;
|
|
|
|
# Setup script is not required in some configurations
|
|
command ?= "" ;
|
|
|
|
# Get tool names (if any) and finish setup
|
|
|
|
compiler = [ get-values <compiler> : $(options) ] ;
|
|
compiler ?= cl ;
|
|
|
|
linker = [ get-values <linker> : $(options) ] ;
|
|
linker ?= link ;
|
|
|
|
resource-compiler = [ get-values <resource-compiler> : $(options) ] ;
|
|
resource-compiler ?= rc ;
|
|
|
|
assembler = [ get-values <assembler> : $(options) ] ;
|
|
assembler ?= ml ;
|
|
|
|
idl-compiler = [ get-values <idl-compiler> : $(options) ] ;
|
|
idl-compiler ?= midl ;
|
|
|
|
mc-compiler = [ get-values <mc-compiler> : $(options) ] ;
|
|
mc-compiler ?= mc ;
|
|
|
|
manifest-tool = mt ;
|
|
|
|
for local i in 1 2 3
|
|
{
|
|
local c = $(cpu[$(i)]) ;
|
|
|
|
if $(c)
|
|
{
|
|
local cond = $(condition)/$(cpu-arch-$(c)) ;
|
|
|
|
if $(.debug-configuration)
|
|
{
|
|
ECHO "msvc: condition: '$(cond)', "
|
|
"command: '$(command[$(i)])'" ;
|
|
}
|
|
|
|
flags msvc.compile .CC $(cond) : $(command[$(i)])$(compiler) ;
|
|
flags msvc.compile .RC $(cond) : $(command[$(i)])$(resource-compiler) ;
|
|
flags msvc.compile .ASM $(cond) : $(command[$(i)])$(assembler) ;
|
|
flags msvc.link .LD $(cond) : $(command[$(i)])$(linker) ;
|
|
flags msvc.archive .LD $(cond) : $(command[$(i)])$(linker) ;
|
|
flags msvc.compile .IDL $(cond) : $(command[$(i)])$(idl-compiler) ;
|
|
flags msvc.compile .MC $(cond) : $(command[$(i)])$(mc-compiler) ;
|
|
|
|
if ! [ os.name ] in NT
|
|
{
|
|
flags msvc.link .MT $(cond) : $(command[$(i)])$(manifest-tool) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
# Set version-specific flags
|
|
configure-version-specific $(version) : $(condition) ;
|
|
}
|
|
}
|
|
|
|
|
|
# Supported CPU types
|
|
cpu-type-g5 = i586 pentium pentium-mmx ;
|
|
cpu-type-g6 =
|
|
i686 pentiumpro pentium2 pentium3 pentium3m pentium-m k6 k6-2 k6-3
|
|
winchip-c6 winchip2 c3 c3-2 ;
|
|
|
|
cpu-type-em64t = prescott nocona ;
|
|
cpu-type-amd64 = k8 opteron athlon64 athlon-fx ;
|
|
|
|
cpu-type-g7 =
|
|
pentium4 pentium4m athlon athlon-tbird athlon-4 athlon-xp athlon-mp
|
|
$(cpu-type-em64t) $(cpu-type-amd64) ;
|
|
|
|
cpu-type-itanium = itanium itanium1 merced ;
|
|
cpu-type-itanium2 = itanium2 mckinley ;
|
|
|
|
|
|
local rule configure-version-specific ( version : condition )
|
|
{
|
|
# Starting with versions 7.0, the msvc compiler have the /Zc:forScope
|
|
# and /Zc:wchar_t options that improve C++ standard conformance, but
|
|
# those options are off by default.
|
|
# If we're sure that msvc version is at 7.*, add those options explicitly.
|
|
# We can be sure either if user specified version 7.* explicitly,
|
|
# or if the installation path contain 7.* (this is checked above).
|
|
if ! [ MATCH ^(6\\.) : $(version) ]
|
|
{
|
|
flags msvc.compile CFLAGS $(condition) : /Zc:forScope /Zc:wchar_t ;
|
|
flags msvc.compile.c++ C++FLAGS $(condition) : /wd4675 ;
|
|
flags msvc.compile CFLAGS $(condition)/<warnings>all : /Wp64 ; # 64-bit compatibility warning
|
|
}
|
|
|
|
#
|
|
# Processor-specific optimization
|
|
#
|
|
|
|
if [ MATCH ^([67]\\.) : $(version) ]
|
|
{
|
|
# 8.0 deprecates some of the options
|
|
flags msvc.compile CFLAGS $(condition)/<optimization>speed $(condition)/<optimization>space : /Ogiy /Gs ;
|
|
flags msvc.compile CFLAGS $(condition)/<optimization>speed : /Ot ;
|
|
flags msvc.compile CFLAGS $(condition)/<optimization>space : /Os ;
|
|
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set> : /GB ;
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set>i386 : /G3 ;
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set>i486 : /G4 ;
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set>$(cpu-type-g5) : /G5 ;
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set>$(cpu-type-g6) : /G6 ;
|
|
flags msvc.compile CFLAGS $(condition)/$(cpu-arch-i386)/<instruction-set>$(cpu-type-g7) : /G7 ;
|
|
}
|
|
}
|
|
|
|
|
|
# Returns the default installation path for the given version.
|
|
local rule default-path ( version )
|
|
{
|
|
# Use auto-detected path if possible
|
|
local path = [ get-values <command> :
|
|
[ $(.versions).get $(version) : options ] ] ;
|
|
|
|
if $(path)
|
|
{
|
|
path = $(path:D) ;
|
|
}
|
|
else
|
|
{
|
|
# Check environment
|
|
if $(.version-$(version)-env)
|
|
{
|
|
local vc-path = [ os.environ $(.version-$(version)-env) ] ;
|
|
if $(vc-path)
|
|
{
|
|
vc-path = [ path.make $(vc-path) ] ;
|
|
vc-path = [ path.join $(vc-path) $(.version-$(version)-envpath) ] ;
|
|
vc-path = [ path.native $(vc-path) ] ;
|
|
|
|
path = $(vc-path) ;
|
|
}
|
|
}
|
|
|
|
# Check default path
|
|
if ! $(path) && $(.version-$(version)-path)
|
|
{
|
|
path = [ path.native [ path.join $(.ProgramFiles) $(.version-$(version)-path) ] ] ;
|
|
}
|
|
}
|
|
|
|
return $(path) ;
|
|
}
|
|
|
|
# Returns either the default installation path (if 'version' is not empty) or list of all
|
|
# known default paths (if no version is given)
|
|
rule default-paths ( version ? )
|
|
{
|
|
local possible-paths ;
|
|
|
|
if $(version)
|
|
{
|
|
default-path += [ default-path $(version) ] ;
|
|
}
|
|
else
|
|
{
|
|
for local i in $(.known-versions)
|
|
{
|
|
default-path += [ default-path $(i) ] ;
|
|
}
|
|
}
|
|
|
|
return $(possible-paths) ;
|
|
}
|
|
|
|
|
|
# Declare generators
|
|
|
|
# is it possible to combine these?
|
|
# make the generators non-composing, so that they don't convert each source
|
|
# into separate rsp file.
|
|
generators.register-linker msvc.link : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : EXE : <toolset>msvc ;
|
|
generators.register-linker msvc.link.dll : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : SHARED_LIB IMPORT_LIB : <toolset>msvc ;
|
|
|
|
generators.register-archiver msvc.archive : OBJ : STATIC_LIB : <toolset>msvc ;
|
|
generators.register-c-compiler msvc.compile.c++ : CPP : OBJ : <toolset>msvc ;
|
|
generators.register-c-compiler msvc.compile.c : C : OBJ : <toolset>msvc ;
|
|
|
|
# Using 'register-c-compiler' adds the build directory to INCLUDES
|
|
generators.register-c-compiler msvc.compile.rc : RC : OBJ(%_res) : <toolset>msvc ;
|
|
generators.override msvc.compile.rc : rc.resource-compile ;
|
|
generators.register-standard msvc.compile.asm : ASM : OBJ : <toolset>msvc ;
|
|
|
|
generators.register-c-compiler msvc.compile.idl : IDL : MSTYPELIB H C(%_i) C(%_proxy) C(%_dlldata) : <toolset>msvc ;
|
|
generators.override msvc.compile.idl : midl.compile.idl ;
|
|
|
|
generators.register-standard msvc.compile.mc : MC : H RC : <toolset>msvc ;
|
|
generators.override msvc.compile.mc : mc.compile ;
|
|
|
|
generators.register [ new pch-generator msvc.compile.pch : PCHEADER : OBJ PCH : <toolset>msvc ] ;
|
|
|
|
#
|
|
# Declare flags and action for compilation
|
|
#
|
|
feature.feature debug-store : object database : propagated ;
|
|
|
|
flags msvc.compile CFLAGS <optimization>speed : /O2 ;
|
|
flags msvc.compile CFLAGS <optimization>space : /O1 ;
|
|
|
|
flags msvc.compile CFLAGS $(cpu-arch-amd64)/<instruction-set> : /favor:blend ;
|
|
flags msvc.compile CFLAGS $(cpu-arch-amd64)/<instruction-set>$(cpu-type-em64t) : /favor:EM64T ;
|
|
flags msvc.compile CFLAGS $(cpu-arch-amd64)/<instruction-set>$(cpu-type-amd64) : /favor:AMD64 ;
|
|
|
|
flags msvc.compile CFLAGS $(cpu-arch-ia64)/<instruction-set>$(cpu-type-itanium) : /G1 ;
|
|
flags msvc.compile CFLAGS $(cpu-arch-ia64)/<instruction-set>$(cpu-type-itanium2) : /G2 ;
|
|
|
|
flags msvc.compile CFLAGS <debug-symbols>on/<debug-store>object : /Z7 ;
|
|
flags msvc.compile CFLAGS <debug-symbols>on/<debug-store>database : /Zi ;
|
|
flags msvc.compile CFLAGS <optimization>off : /Od ;
|
|
flags msvc.compile CFLAGS <inlining>off : /Ob0 ;
|
|
flags msvc.compile CFLAGS <inlining>on : /Ob1 ;
|
|
flags msvc.compile CFLAGS <inlining>full : /Ob2 ;
|
|
|
|
flags msvc.compile CFLAGS <warnings>on : /W3 ;
|
|
flags msvc.compile CFLAGS <warnings>off : /W0 ;
|
|
flags msvc.compile CFLAGS <warnings>all : /W4 ;
|
|
flags msvc.compile CFLAGS <warnings-as-errors>on : /WX ;
|
|
|
|
flags msvc.compile C++FLAGS <exception-handling>on/<asynch-exceptions>off/<extern-c-nothrow>off : /EHs ;
|
|
flags msvc.compile C++FLAGS <exception-handling>on/<asynch-exceptions>off/<extern-c-nothrow>on : /EHsc ;
|
|
flags msvc.compile C++FLAGS <exception-handling>on/<asynch-exceptions>on/<extern-c-nothrow>off : /EHa ;
|
|
flags msvc.compile C++FLAGS <exception-handling>on/<asynch-exceptions>on/<extern-c-nothrow>on : /EHac ;
|
|
|
|
flags msvc.compile CFLAGS <rtti>on : /GR ;
|
|
flags msvc.compile CFLAGS <runtime-debugging>off/<runtime-link>shared : /MD ;
|
|
flags msvc.compile CFLAGS <runtime-debugging>on/<runtime-link>shared : /MDd ;
|
|
|
|
flags msvc.compile CFLAGS <runtime-debugging>off/<runtime-link>static/<threading>single : /ML ;
|
|
flags msvc.compile CFLAGS <runtime-debugging>on/<runtime-link>static/<threading>single : /MLd ;
|
|
flags msvc.compile CFLAGS <runtime-debugging>off/<runtime-link>static/<threading>multi : /MT ;
|
|
flags msvc.compile CFLAGS <runtime-debugging>on/<runtime-link>static/<threading>multi : /MTd ;
|
|
|
|
flags msvc.compile USER_CFLAGS <cflags> : ;
|
|
flags msvc.compile.c++ USER_CFLAGS <cxxflags> : ;
|
|
|
|
flags msvc.compile PDB_CFLAG <debug-symbols>on/<debug-store>database : /Fd ; # not used yet
|
|
|
|
flags msvc.compile DEFINES <define> ;
|
|
flags msvc.compile UNDEFS <undef> ;
|
|
flags msvc.compile INCLUDES <include> ;
|
|
|
|
flags msvc.compile PCH_SOURCE <pch-source> ;
|
|
flags msvc.compile PCH_HEADER <pch>on : <pch-header> ;
|
|
flags msvc.compile PCH_FILE <pch>on : <pch-file> ;
|
|
|
|
rule compile.c ( targets + : sources * : properties * )
|
|
{
|
|
DEPENDS $(<) : [ on $(<) return $(PCH_HEADER) ] ;
|
|
DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
|
|
}
|
|
|
|
rule compile.c++ ( targets + : sources * : properties * )
|
|
{
|
|
DEPENDS $(<) : [ on $(<) return $(PCH_HEADER) ] ;
|
|
DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
|
|
}
|
|
|
|
rule compile.pch ( targets + : sources * : properties * )
|
|
{
|
|
DEPENDS $(<) : [ on $(<) return $(PCH_SOURCE) ] ;
|
|
}
|
|
|
|
|
|
# The actions differ only by explicit selection of input language
|
|
actions compile.c bind PCH_HEADER PCH_FILE
|
|
{
|
|
$(.CC) /Zm800 -nologo -TC -U$(UNDEFS) $(CFLAGS) $(USER_CFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)-D$(DEFINES) $(nl)"-I$(INCLUDES)")" -c -Fo"$(<[1]:W)" -Yu"$(PCH_HEADER:D=)" -Fp"$(PCH_FILE:W)"
|
|
}
|
|
|
|
actions compile.c++ bind PCH_HEADER PCH_FILE
|
|
{
|
|
$(.CC) /Zm800 -nologo -TP -U$(UNDEFS) $(CFLAGS) $(C++FLAGS) $(USER_CFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)-D$(DEFINES) $(nl)"-I$(INCLUDES)")" -c -Fo"$(<[1]:W)" -Yu"$(PCH_HEADER:D=)" -Fp"$(PCH_FILE:W)"
|
|
}
|
|
|
|
actions compile.pch bind PCH_SOURCE
|
|
{
|
|
$(.CC) /Zm800 -nologo -TP -U$(UNDEFS) $(CFLAGS) $(C++FLAGS) $(USER_CFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(PCH_SOURCE:W)" $(nl)-D$(DEFINES) $(nl)"-I$(INCLUDES)")" -c -Fo"$(<[1]:W)" /Yc"$(>[1]:D=)" -Fp"$(<[2]:W)"
|
|
}
|
|
|
|
|
|
actions compile.rc
|
|
{
|
|
$(.RC) -l 0x409 -U$(UNDEFS) -D$(DEFINES) -I"$(INCLUDES)" -fo "$(<:W)" "$(>:W)"
|
|
}
|
|
|
|
# See midl.jam for details
|
|
TOUCH_FILE = [ common.file-touch-command ] ;
|
|
|
|
actions compile.idl
|
|
{
|
|
$(.IDL) /nologo @"@($(<[1]:W).rsp:E=$(nl)"$(>:W)" $(nl)-D$(DEFINES) $(nl)"-I$(INCLUDES)" $(nl)-U$(UNDEFS) $(nl)$(MIDLFLAGS) $(nl)/tlb "$(<[1]:W)" $(nl)/h "$(<[2]:W)" $(nl)/iid "$(<[3]:W)" $(nl)/proxy "$(<[4]:W)" $(nl)/dlldata "$(<[5]:W)")"
|
|
$(TOUCH_FILE) "$(<[4]:W)"
|
|
$(TOUCH_FILE) "$(<[5]:W)"
|
|
}
|
|
|
|
# Declare flags and action for the assembler
|
|
|
|
flags msvc.compile.asm USER_ASMFLAGS <asmflags> : ;
|
|
|
|
#
|
|
# for the assembler the following options are turned on by default:
|
|
#
|
|
# -coff generate COFF format object file (compatible with cl.exe output)
|
|
# -Zp4 align structures to 4 bytes
|
|
# -Cp preserve case of user identifiers
|
|
# -Cx preserve case in publics, externs
|
|
|
|
actions compile.asm
|
|
{
|
|
$(.ASM) -nologo -c -coff -Zp4 -Cp -Cx $(USER_ASMFLAGS) -Fo "$(<:W)" "$(>:W)"
|
|
}
|
|
|
|
# Declare flags and action for linking
|
|
flags msvc.link PDB_LINKFLAG <debug-symbols>on/<debug-store>database : /PDB: ; # not used yet
|
|
flags msvc.link LINKFLAGS <debug-symbols>on : /DEBUG ;
|
|
flags msvc.link DEF_FILE <def-file> ;
|
|
# The linker disables the default optimizations when using /DEBUG. Whe have
|
|
# to enable them manually for release builds with debug symbols.
|
|
flags msvc LINKFLAGS <debug-symbols>on/<runtime-debugging>off : /OPT:REF,ICF ;
|
|
|
|
flags msvc LINKFLAGS <user-interface>console : /subsystem:console ;
|
|
flags msvc LINKFLAGS <user-interface>gui : /subsystem:windows ;
|
|
flags msvc LINKFLAGS <user-interface>wince : /subsystem:windowsce ;
|
|
flags msvc LINKFLAGS <user-interface>native : /subsystem:native ;
|
|
flags msvc LINKFLAGS <user-interface>auto : /subsystem:posix ;
|
|
|
|
flags msvc LINKFLAGS <main-target-type>LIB/<link>shared : /DLL ;
|
|
|
|
flags msvc.link USER_LINKFLAGS <linkflags> ;
|
|
flags msvc.link LINKPATH <library-path> ;
|
|
|
|
|
|
flags msvc.link FINDLIBS_ST <find-static-library> ;
|
|
flags msvc.link FINDLIBS_SA <find-shared-library> ;
|
|
flags msvc.link LIBRARY_OPTION <toolset>msvc : "" : unchecked ;
|
|
flags msvc.link LIBRARIES_MENTIONED_BY_FILE : <library-file> ;
|
|
|
|
|
|
rule link.dll ( targets + : sources * : properties * )
|
|
{
|
|
DEPENDS $(<) : [ on $(<) return $(DEF_FILE) ] ;
|
|
}
|
|
|
|
# Declare action for creating static libraries
|
|
# If library exists, remove it before adding files. See
|
|
# http://article.gmane.org/gmane.comp.lib.boost.build/4241
|
|
# for rationale.
|
|
if [ os.name ] in NT
|
|
{
|
|
# The 'DEL' command would issue a message to stdout
|
|
# if the file does not exist, so need a check.
|
|
actions archive
|
|
{
|
|
if exist "$(<[1])" DEL "$(<[1])"
|
|
$(.LD) /lib /NOLOGO /out:"$(<[1])" @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
}
|
|
}
|
|
else
|
|
{
|
|
actions archive
|
|
{
|
|
$(RM) "$(<[1])"
|
|
$(.LD) /lib /NOLOGO /out:"$(<[1])" @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
}
|
|
}
|
|
|
|
# incremental linking a DLL causes no end of problems: if the
|
|
# actual exports don't change, the import .lib file is never
|
|
# updated. Therefore, the .lib is always out-of-date and gets
|
|
# rebuilt every time. I'm not sure that incremental linking is
|
|
# such a great idea in general, but in this case I'm sure we
|
|
# don't want it.
|
|
|
|
# Windows Manifests is a new way to specify dependencies
|
|
# on managed DotNet assemblies and Windows native DLLs. The
|
|
# manifests are embedded as resourses and are useful in
|
|
# any PE targets (both DLL and EXE)
|
|
|
|
if [ os.name ] in NT
|
|
{
|
|
actions link bind DEF_FILE
|
|
{
|
|
$(.LD) /NOLOGO $(LINKFLAGS) /out:"$(<[1]:W)" /INCREMENTAL:NO /LIBPATH:"$(LINKPATH:W)" $(USER_LINKFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
if exist "$(<[1]).manifest" (
|
|
mt -nologo -manifest "$(<[1]).manifest" "-outputresource:$(<[1]);1"
|
|
)
|
|
}
|
|
|
|
actions link.dll bind DEF_FILE
|
|
{
|
|
$(.LD) /NOLOGO $(LINKFLAGS) /out:"$(<[1]:W)" /INCREMENTAL:NO /IMPLIB:"$(<[2]:W)" /LIBPATH:"$(LINKPATH:W)" /def:$(DEF_FILE) $(USER_LINKFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
if exist "$(<[1]).manifest" (
|
|
mt -nologo -manifest "$(<[1]).manifest" "-outputresource:$(<[1]);2"
|
|
)
|
|
}
|
|
}
|
|
else
|
|
{
|
|
actions link bind DEF_FILE
|
|
{
|
|
$(.LD) /NOLOGO $(LINKFLAGS) /out:"$(<[1]:W)" /INCREMENTAL:NO /LIBPATH:"$(LINKPATH:W)" $(USER_LINKFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
if test -e "$(<[1]).manifest"; then
|
|
$(.MT) -nologo -manifest "$(<[1]:W).manifest" "-outputresource:$(<[1]:W);1"
|
|
fi
|
|
}
|
|
|
|
actions link.dll bind DEF_FILE
|
|
{
|
|
$(.LD) /NOLOGO $(LINKFLAGS) /out:"$(<[1]:W)" /INCREMENTAL:NO /IMPLIB:"$(<[2]:W)" /LIBPATH:"$(LINKPATH:W)" /def:$(DEF_FILE) $(USER_LINKFLAGS) @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES_MENTIONED_BY_FILE) $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
|
|
if test -e "$(<[1]).manifest"; then
|
|
$(.MT) -nologo -manifest "$(<[1]:W).manifest" "-outputresource:$(<[1]:W);2"
|
|
fi
|
|
}
|
|
}
|
|
|
|
|
|
actions compile.mc
|
|
{
|
|
$(.MC) $(MCFLAGS) -h "$(<[1]:DW)" -r "$(<[2]:DW)" "$(>:W)"
|
|
}
|
|
|
|
|
|
#
|
|
# Autodetection code
|
|
# detects versions listed as '.known-versions' using registry, environment
|
|
# and checking default paths. Supports both native Windows and Cygwin.
|
|
#
|
|
|
|
.ProgramFiles = [ path.make [ common.get-program-files-dir ] ] ;
|
|
|
|
.known-versions = 8.0 8.0express 7.1 7.1toolkit 7.0 6.0 ;
|
|
|
|
# Version aliases
|
|
.version-alias-6 = 6.0 ;
|
|
.version-alias-7 = 7.0 ;
|
|
.version-alias-8 = 8.0 ;
|
|
|
|
# Name of the registry key that contains Visual C++ installation path
|
|
# (relative to "HKEY_LOCAL_MACHINE\SOFTWARE\\Microsoft"
|
|
.version-6.0-reg = "VisualStudio\\6.0\\Setup\\Microsoft Visual C++" ;
|
|
.version-7.0-reg = "VisualStudio\\7.0\\Setup\\VC" ;
|
|
.version-7.1-reg = "VisualStudio\\7.1\\Setup\\VC" ;
|
|
.version-8.0-reg = "VisualStudio\\8.0\\Setup\\VC" ;
|
|
.version-8.0express-reg = "VCExpress\\8.0\\Setup\\VC" ;
|
|
|
|
# Visual C++ Toolkit 2003 do not store its installation path in the registry.
|
|
# The environment variable 'VCToolkitInstallDir' and the default installation
|
|
# path will be checked instead.
|
|
.version-7.1toolkit-path = "Microsoft Visual C++ Toolkit 2003" "bin" ;
|
|
.version-7.1toolkit-env = VCToolkitInstallDir ;
|
|
|
|
# Path to the folder containing "cl.exe" relative to the value of the corresponding
|
|
# environment variable
|
|
.version-7.1toolkit-envpath = "bin" ;
|
|
|
|
|
|
# Validates given path, registers found configuration and prints debug information
|
|
# about it.
|
|
local rule register-configuration ( version : path ? )
|
|
{
|
|
if $(path)
|
|
{
|
|
local command = [ GLOB $(path) : cl.exe ] ;
|
|
|
|
if $(command)
|
|
{
|
|
if $(.debug-configuration)
|
|
{
|
|
ECHO "notice: msvc-$(version) detected, command: '$(command)'" ;
|
|
}
|
|
|
|
$(.versions).register $(version) ;
|
|
$(.versions).set $(version) : options : <command>$(command) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if [ os.name ] in NT CYGWIN
|
|
{
|
|
# Get installation paths from the registry
|
|
|
|
for local i in $(.known-versions)
|
|
{
|
|
if $(.version-$(i)-reg)
|
|
{
|
|
local vc-path = [ W32_GETREG
|
|
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"$(.version-$(i)-reg)
|
|
: "ProductDir" ] ;
|
|
|
|
if $(vc-path)
|
|
{
|
|
vc-path = [ path.native [ path.join [ path.make-NT $(vc-path) ] "bin" ] ] ;
|
|
register-configuration $(i) : $(vc-path) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
# Check environment and default installation paths
|
|
|
|
for local i in $(.known-versions)
|
|
{
|
|
if ! $(i) in [ $(.versions).all ]
|
|
{
|
|
register-configuration $(i) : [ default-path $(i) ] ;
|
|
}
|
|
}
|
|
|