Menu
▾
▴
[xml-cppdom-checkins] SF.net SVN: xml-cppdom:[674] trunk/deps/scons-addons/src/SConsAddons/ EnvironmentBuilder.py
|
From: <pat...@us...> - 2010-10-03 17:00:32
|
Revision: 674
http://xml-cppdom.svn.sourceforge.net/xml-cppdom/?rev=674&view=rev
Author: patrickh
Date: 2010-10-03 17:00:26 +0000 (Sun, 03 Oct 2010)
Log Message:
-----------
Merge changes in from Revision 412 of SConsAddons.
Revision Links:
--------------
http://xml-cppdom.svn.sourceforge.net/xml-cppdom/?rev=412&view=rev
Modified Paths:
--------------
trunk/deps/scons-addons/src/SConsAddons/EnvironmentBuilder.py
Modified: trunk/deps/scons-addons/src/SConsAddons/EnvironmentBuilder.py
===================================================================
--- trunk/deps/scons-addons/src/SConsAddons/EnvironmentBuilder.py 2010-10-03 16:57:51 UTC (rev 673)
+++ trunk/deps/scons-addons/src/SConsAddons/EnvironmentBuilder.py 2010-10-03 17:00:26 UTC (rev 674)
@@ -29,7 +29,7 @@
class EnvironmentBuilder(object):
""" Builder class for scons environments.
Used to build up an environment based on user settings.
-
+
There are default settings for all levels. These settings can be overriden
through the class interface or through the supported options processing.
"""
@@ -39,22 +39,25 @@
STANDARD = 2
EXTENSIVE = 3
MAXIMUM = 4
-
+
# Opt flags
REDUCE_SIZE = 'reduce_size'
FAST_MATH = 'fast_math'
ARCH_SPEC = 'arch_specific'
-
+
# Warning flags
WARN_AS_ERROR = 'warn_as_error'
WARN_STRICT = 'warn_strict'
-
+
+ #debug tags
+ DISABLE_INLINE = 'disable_inline'
+
# MSVC runtime
MSVC_MT_DLL_RT = "msvc_mt_dll_rt"
MSVC_MT_DBG_DLL_RT = "msvc_mt_dbg_dll_rt"
MSVC_MT_RT = "msvc_mt_rt"
MSVC_MT_DBG_RT = "msvc_mt_dbg_rt"
-
+
# CPU ARCH
AUTODETECT_ARCH = "autodetect_arch"
IA32_ARCH = "ia32"
@@ -67,30 +70,30 @@
def __init__(self):
""" Initialize the class with defaults. """
global default_funcs
- self.debugLevel = EnvironmentBuilder.NONE
+ self.debugLevel = EnvironmentBuilder.NONE
self.debugTags = []
self.optLevel = EnvironmentBuilder.NONE
self.optTags = []
- self.warningLevel = EnvironmentBuilder.MINIMAL
+ self.warningLevel = EnvironmentBuilder.MINIMAL
self.warningTags = []
self.profEnabled = False
self.exceptionsEnabled = True
self.structuredExceptionsEnabled = False
- self.rttiEnabled = True
+ self.rttiEnabled = True
self.cpuArch = None
-
+
# Darwin specific
self.darwinUniversalEnabled = False
self.darwinSdk = ''
-
+
# MSVC specific
self.msvcRuntime = None
-
+
# List of [ [compilers], [platforms], func ]
# If compiler or platform list is empty, then ignore that check
self.funcList = copy.copy(default_funcs)
-
- # Defaults: These levels are applied if the user just enables with no level
+
+ # Defaults: These levels are applied if the user just enables with no level
self.defaultDebugLevel = EnvironmentBuilder.STANDARD
self.defaultOptLevel = EnvironmentBuilder.STANDARD
self.defaultWarningLevel = EnvironmentBuilder.STANDARD
@@ -98,7 +101,7 @@
def clone(self):
return copy.copy(self)
- def buildEnvironment(self, options=None, variant=None, **kw):
+ def buildEnvironment(self, options = None, variant = None, **kw):
""" Build an environment object and apply any options to it.
Takes same parameters as Environment() in SCons.
options - If passed and is instance of SCons.Options.Options, it will
@@ -107,15 +110,15 @@
and available when applying options.
"""
if options and not isinstance(options, Options.Options):
- kw["options"] = options
- new_env = apply(SCons.Environment.Environment, [], kw)
- self.applyToEnvironment(new_env,variant, options)
+ kw["options"] = options
+ new_env = apply(SCons.Environment.Environment, [], kw)
+ self.applyToEnvironment(new_env, variant, options)
return new_env
-
- def applyToEnvironment(self, env, variant=None, options=None):
+
+ def applyToEnvironment(self, env, variant = None, options = None):
""" Apply current builder options to an existing environment.
- Returns env argument.
-
+ Returns env argument.
+
Ex: new_env = bldr.applyToEnvironment(env.Clone())
"""
if variant:
@@ -125,51 +128,51 @@
self._applyOptionsToEnvironment(env)
return env
- def enableDebug(self, level=None, tags=[]):
+ def enableDebug(self, level = None, tags = []):
if not level:
level = self.defaultDebugLevel
self.debugLevel = level
self.debugTags = tags
def disableDebug(self):
- self.enableDebug(level=EnvironmentBuilder.NONE)
-
- def enableOpt(self, level=None, tags=[]):
+ self.enableDebug(level = EnvironmentBuilder.NONE)
+
+ def enableOpt(self, level = None, tags = []):
if not level:
level = self.defaultOptLevel
self.optLevel = level
self.optTags = tags
def disableOpt(self):
self.enableOpt(EnvironmentBuilder.NONE)
-
- def enableProfiling(self, val=True):
+
+ def enableProfiling(self, val = True):
self.profEnabled = val
def disableProfiling(self):
self.enableProfiling(False)
-
- def enableWarnings(self, level=None, tags=[]):
+
+ def enableWarnings(self, level = None, tags = []):
if level is None:
level = self.defaultWarningLevel
self.warningLevel = level
self.warningTags = tags
def disableWarnings(self):
self.enableWarnings(EnvironmentBuilder.NONE)
-
- def enableExceptions(self, val=True):
+
+ def enableExceptions(self, val = True):
self.exceptionsEnabled = val
def disableExceptions(self):
self.enableExceptions(False)
-
- def enableStructuredExceptions(self, val=True):
+
+ def enableStructuredExceptions(self, val = True):
self.structuredExceptionsEnabled = val
def disableStructuredExceptions(self):
self.enableStructuredExceptions(False)
-
- def enableRTTI(self, val=True):
+
+ def enableRTTI(self, val = True):
self.rttiEnabled = val
def disableRTTI(self):
self.enableRTTI(False)
-
- def setCpuArch(self, val=AUTODETECT_ARCH):
+
+ def setCpuArch(self, val = AUTODETECT_ARCH):
if val != EnvironmentBuilder.AUTODETECT_ARCH:
self.cpuArch = val
else:
@@ -180,35 +183,35 @@
self.cpuArch = arch_map.get(GetArch(), EnvironmentBuilder.AUTODETECT_ARCH)
# ---- Darwin specific ----- #
- def darwin_enableUniversalBinaries(self, val=True):
+ def darwin_enableUniversalBinaries(self, val = True):
self.darwinUniversalEnabled = val
def darwin_disableUniversalBinaries(self):
self.darwin_enableUniversalBinaries(False)
def darwin_setSdk(self, val):
self.darwinSdk = val
-
+
# ---- MSVC specific ---- #
def setMsvcRuntime(self, val):
self.msvcRuntime = val
-
+
# ---- Command-line option processing ---- #
def addOptions(self, opts):
""" The EnvironmentBuilder has support for adding command line options to an
option processing object. This object has to be an instance
of SConsAddons.Options. Once the options are added, the user
will be able to set defaults for the environment builder.
-
+
TODO: Add options for tags.
"""
import SConsAddons.Options as sca_opts
-
+
assert isinstance(opts, sca_opts.Options)
- opts.AddOption(sca_opts.SeparatorOption("\nEnvironment Builder Defaults"))
+ opts.AddOption(sca_opts.SeparatorOption("\nEnvironment Builder Defaults"))
opts.AddOption(sca_opts.EnumOption('default_debug_level',
'Default debug level for environment builder.',
- 'standard',
- ['none','minimal','standard','extensive','maximum'],
+ 'standard',
+ ['none', 'minimal', 'standard', 'extensive', 'maximum'],
{'none':EnvironmentBuilder.NONE,
'minimal':EnvironmentBuilder.MINIMAL,
'standard':EnvironmentBuilder.STANDARD,
@@ -216,8 +219,8 @@
'maximum':EnvironmentBuilder.MAXIMUM}))
opts.AddOption(sca_opts.EnumOption('default_opt_level',
'Default optimization level for environment builder.',
- 'standard',
- ['none','minimal','standard','extensive','maximum'],
+ 'standard',
+ ['none', 'minimal', 'standard', 'extensive', 'maximum'],
{'none':EnvironmentBuilder.NONE,
'minimal':EnvironmentBuilder.MINIMAL,
'standard':EnvironmentBuilder.STANDARD,
@@ -230,12 +233,12 @@
'minimal':EnvironmentBuilder.MINIMAL,
'standard':EnvironmentBuilder.STANDARD,
'extensive':EnvironmentBuilder.EXTENSIVE,
- 'maximum':EnvironmentBuilder.MAXIMUM}))
+ 'maximum':EnvironmentBuilder.MAXIMUM}))
if GetPlatform() == "darwin":
opts.Add(sca_opts.BoolOption('darwin_universal',
'Build universal binaries.', False))
opts.Add('darwin_sdk', 'Darwin Platform SDK.', '')
-
+
def readOptions(self, optEnv):
""" Read the processed options from the given environment. """
self.defaultDebugLevel = optEnv["default_debug_level"]
@@ -250,29 +253,29 @@
def _applyOptionsToEnvironment(self, env):
tools = env["TOOLS"]
#print "Using tools: ", tools
-
+
# Find the compilers/builders we are using
c_compiler = env["CC"]
cxx_compiler = env["CXX"]
linker = env["LINK"]
- # one of: ['cygwin','irix','sunos','linux','freebsd','darwin','win32']
+ # one of: ['cygwin', 'irix', 'sunos', 'linux', 'freebsd', 'darwin', 'win32']
platform = GetPlatform()
# Special case for compiler callers like distcc
# XXX: This is a bit of a hack, but it will work for now
- for x in ["distcc",]:
+ for x in ["distcc"]:
if c_compiler.startswith(x):
c_compiler = c_compiler.split()[-1]
if cxx_compiler.startswith(x):
cxx_compiler = cxx_compiler.split()[-1]
if linker.startswith(x):
linker = linker.split()[-1]
-
+
# Based on compiler and platform
for f in self.funcList:
- (compiler_list,platform_list, func) = f
- if (len(compiler_list)==0) or (c_compiler in compiler_list) or (cxx_compiler in compiler_list):
- if (len(platform_list)==0) or (platform in platform_list):
+ (compiler_list, platform_list, func) = f
+ if len(compiler_list) == 0 or c_compiler in compiler_list or cxx_compiler in compiler_list:
+ if len(platform_list) == 0 or platform in platform_list:
func(self, env)
@@ -281,7 +284,7 @@
def gcc_optimizations(bldr, env):
if EnvironmentBuilder.NONE == bldr.optLevel:
return
-
+
CCFLAGS = []
CXXFLAGS = []
CPPDEFINES = []
@@ -293,203 +296,205 @@
CCFLAGS.append('-O1')
elif bldr.optLevel == EnvironmentBuilder.STANDARD:
CCFLAGS.append('-O2')
- elif ((bldr.optLevel == EnvironmentBuilder.EXTENSIVE) or
- (bldr.optLevel == EnvironmentBuilder.MAXIMUM)):
+ elif (bldr.optLevel == EnvironmentBuilder.EXTENSIVE or
+ bldr.optLevel == EnvironmentBuilder.MAXIMUM):
CCFLAGS.append('-O3')
# Fast math
if EnvironmentBuilder.FAST_MATH in bldr.optTags:
CCFLAGS.append('-ffast-math')
-
+
# TODO: Do architecture specific optimizations here
- env.Append(CXXFLAGS=CXXFLAGS, CCFLAGS=CCFLAGS, CPPDEFINES=CPPDEFINES)
+ env.AppendUnique(CXXFLAGS = CXXFLAGS, CCFLAGS = CCFLAGS, CPPDEFINES = CPPDEFINES)
def gcc_debug(bldr, env):
#print "Calling gcc_debug."
if EnvironmentBuilder.NONE == bldr.debugLevel:
return
- env.Append(CCFLAGS = ["-g", "-fno-inline"],
- CXXFLAGS = ["-fno-implicit-inline-templates", "-fno-default-inline"])
+ env.AppendUnique(CCFLAGS = ["-g"])
+ if EnvironmentBuilder.DISABLE_INLINE in bldr.debugTags:
+ env.AppendUnique(CCFLAGS = ["-fno-inline"],
+ CXXFLAGS = ["-fno-implicit-inline-templates", "-fno-default-inline"])
def gcc_warnings(bldr, env):
CCFLAGS = []
-
+
if EnvironmentBuilder.NONE == bldr.warningLevel:
- CCFLAGS.append(['-w',])
+ CCFLAGS.append(['-w'])
elif bldr.warningLevel == EnvironmentBuilder.MINIMAL:
pass
elif bldr.warningLevel == EnvironmentBuilder.STANDARD:
- CCFLAGS.append(['-Wall',])
+ CCFLAGS.append(['-Wall'])
elif bldr.warningLevel == EnvironmentBuilder.EXTENSIVE:
- CCFLAGS.append(['-Wall','-Wextra'])
+ CCFLAGS.append(['-Wall', '-Wextra'])
elif bldr.warningLevel == EnvironmentBuilder.MAXIMUM:
- CCFLAGS.extend(['-Wall','-Wextra'])
+ CCFLAGS.extend(['-Wall', '-Wextra'])
# warnings as errors
if EnvironmentBuilder.WARN_AS_ERROR in bldr.debugTags:
- CCFLAGS.append(['-Werror',])
-
+ CCFLAGS.append(['-Werror'])
+
if EnvironmentBuilder.WARN_STRICT in bldr.debugTags:
- CCFLAGS.append(['-pedantic',])
-
- env.Append(CCFLAGS=CCFLAGS)
-
+ CCFLAGS.append(['-pedantic'])
+
+ env.AppendUnique(CCFLAGS = CCFLAGS)
+
def gcc_misc(bldr, env):
if bldr.profEnabled:
- env.Append(CCFLAGS=["-pg",], LINKFLAGS=['-pg',])
+ env.AppendUnique(CCFLAGS = ["-pg"], LINKFLAGS = ['-pg'])
def gcc_linux_misc(bldr, env):
assert isinstance(bldr, EnvironmentBuilder)
- env.Append(CCFLAGS = ['-pipe',]) # Add pipe to speed up compiles on Linux
+ env.AppendUnique(CCFLAGS = ['-pipe']) # Add pipe to speed up compiles on Linux
if bldr.cpuArch:
if bldr.cpuArch == EnvironmentBuilder.IA32_ARCH:
- env.Append(CCFLAGS = ['-m32'],
- LINKFLAGS = ['-m32'])
+ env.AppendUnique(CCFLAGS = ['-m32'],
+ LINKFLAGS = ['-m32'])
elif bldr.cpuArch == EnvironmentBuilder.X64_ARCH:
- env.Append(CCFLAGS = ['-m64'],
- LINKFLAGS = ['-m64'])
+ env.AppendUnique(CCFLAGS = ['-m64'],
+ LINKFLAGS = ['-m64'])
else:
assert False, "Invalid arch used for Linux gcc."
-def gcc_darwin_misc(bldr,env):
+def gcc_darwin_misc(bldr, env):
assert isinstance(bldr, EnvironmentBuilder)
# We use libtool(1) here instead of ar(1) to ensure that we can build
# static universal binaries.
env['AR'] = 'libtool'
env['ARFLAGS'] = ['-static', '-o']
- env.Append(CCFLAGS = ['-pipe'])
+ env.AppendUnique(CCFLAGS = ['-pipe'])
# XXX: This list should be hard coded. It should contain the architectures
# that have been detected as being valid.
universal_arch_list = ['ppc', 'i386', 'ppc64']
- print os.uname()
if os.uname()[2].split('.')[0] >= '9':
universal_arch_list.append('x64')
if bldr.darwinUniversalEnabled:
for a in universal_arch_list:
- env.Append(CCFLAGS = ['-arch', a], LINKFLAGS = ['-arch', a])
+ env.AppendUniqie(CCFLAGS = ['-arch', a], LINKFLAGS = ['-arch', a])
else:
if bldr.cpuArch != None:
if bldr.cpuArch == EnvironmentBuilder.UNIVERSAL_ARCH:
for a in universal_arch_list:
- env.Append(CCFLAGS = ['-arch', a], LINKFLAGS = ['-arch', a])
+ env.AppendUnique(CCFLAGS = ['-arch', a], LINKFLAGS = ['-arch', a])
elif bldr.cpuArch == EnvironmentBuilder.X64_ARCH:
- env.Append(CCFLAGS = ['-arch', 'x86_64'],
- LINKFLAGS = ['-arch', 'x86_64'])
+ env.AppendUnique(CCFLAGS = ['-arch', 'x86_64'],
+ LINKFLAGS = ['-arch', 'x86_64'])
elif bldr.cpuArch == EnvironmentBuilder.IA32_ARCH:
- env.Append(CCFLAGS = ['-arch', 'i386'],
- LINKFLAGS = ['-arch', 'i386'])
+ env.AppendUnique(CCFLAGS = ['-arch', 'i386'],
+ LINKFLAGS = ['-arch', 'i386'])
elif bldr.cpuArch == EnvironmentBuilder.PPC_ARCH:
- env.Append(CCFLAGS = ['-arch', 'ppc'],
- LINKFLAGS = ['-arch', 'ppc'])
+ env.AppendUnique(CCFLAGS = ['-arch', 'ppc'],
+ LINKFLAGS = ['-arch', 'ppc'])
elif bldr.cpuArch == EnvironmentBuilder.PPC64_ARCH:
- env.Append(CCFLAGS = ['-arch', 'ppc64'],
- LINKFLAGS = ['-arch', 'ppc64'])
+ env.AppendUnique(CCFLAGS = ['-arch', 'ppc64'],
+ LINKFLAGS = ['-arch', 'ppc64'])
else:
assert False, "Invalid arch used for darwin gcc."
if bldr.darwinSdk != '':
- env.Append(CCFLAGS = ['-isysroot', bldr.darwinSdk],
- LINKFLAGS = ['-isysroot', bldr.darwinSdk])
+ env.AppendUnique(CCFLAGS = ['-isysroot', bldr.darwinSdk],
+ LINKFLAGS = ['-isysroot', bldr.darwinSdk])
sdk_re = re.compile('MacOSX(10\..*?)u?\.sdk')
match = sdk_re.search(bldr.darwinSdk)
if match is not None:
min_osx_ver = '-mmacosx-version-min=' + match.group(1)
- env.Append(CCFLAGS = [min_osx_ver], LINKFLAGS = [min_osx_ver])
+ env.AppendUnique(CCFLAGS = [min_osx_ver], LINKFLAGS = [min_osx_ver])
# GCC functions
-default_funcs.append([['gcc','g++'],[],gcc_optimizations])
-default_funcs.append([['gcc','g++'],[],gcc_debug])
-default_funcs.append([['gcc','g++'],[],gcc_warnings])
-default_funcs.append([['gcc','g++'],[],gcc_misc])
-default_funcs.append([['gcc','g++'],['linux'],gcc_linux_misc])
-default_funcs.append([['gcc','g++'],['darwin'],gcc_darwin_misc])
+default_funcs.append([['gcc', 'g++'], [], gcc_optimizations])
+default_funcs.append([['gcc', 'g++'], [], gcc_debug])
+default_funcs.append([['gcc', 'g++'], [], gcc_warnings])
+default_funcs.append([['gcc', 'g++'], [], gcc_misc])
+default_funcs.append([['gcc', 'g++'], ['linux'], gcc_linux_misc])
+default_funcs.append([['gcc', 'g++'], ['darwin'], gcc_darwin_misc])
# ---- Irix ---- #
-# XXX: Irix support is very minimal at this time.
+# XXX: Irix support is very minimal at this time.
# I don't have access to an Irix box anymore and I don't compile
# code for Irix very often. This could be easily extended to support
# many more features (archs, warnings, etc)
def irix_opt(bldr, env):
if EnvironmentBuilder.NONE == bldr.optLevel:
return
-
+
CCFLAGS = []
-
+
if bldr.optLevel == EnvironmentBuilder.MINIMAL:
CCFLAGS.append('-O1')
elif bldr.optLevel == EnvironmentBuilder.STANDARD:
CCFLAGS.append('-O2')
- elif ((bldr.optLevel == EnvironmentBuilder.EXTENSIVE) or
- (bldr.optLevel == EnvironmentBuilder.MAXIMUM)):
+ elif (bldr.optLevel == EnvironmentBuilder.EXTENSIVE or
+ bldr.optLevel == EnvironmentBuilder.MAXIMUM):
CCFLAGS.append('-O3')
# TODO: Do architecture specific optimizations here
- env.Append(CXXFLAGS=CXXFLAGS, CCFLAGS=CCFLAGS, CPPDEFINES=CPPDEFINES)
+ env.AppendUnique(CXXFLAGS = CXXFLAGS, CCFLAGS = CCFLAGS, CPPDEFINES = CPPDEFINES)
def irix_debug(bldr, env):
#print "Calling gcc_debug."
if EnvironmentBuilder.NONE == bldr.debugLevel:
return
- env.Append(CCFLAGS=["-g",])
+ env.AppendUnique(CCFLAGS = ["-g"])
def irix_misc(bldr, env):
CCFLAGS = []
- env.Append(CXXFLAGS=["-mips3","-LANG:std","-n32"])
+ env.AppendUnique(CXXFLAGS = ["-mips3", "-LANG:std", "-n32"])
-default_funcs.append([['cc',],['irix'],irix_opt])
-default_funcs.append([['cc',],['irix'],irix_debug])
-default_funcs.append([['cc',],['irix'],irix_misc])
+default_funcs.append([['cc'], ['irix'], irix_opt])
+default_funcs.append([['cc'], ['irix'], irix_debug])
+default_funcs.append([['cc'], ['irix'], irix_misc])
-# ---- MSVC ---- #
+# ---- MSVC ---- #
def msvc_optimizations(bldr, env):
if EnvironmentBuilder.NONE == bldr.optLevel:
return
-
+
CCFLAGS = []
CXXFLAGS = []
CPPDEFINES = []
- LINKFLAGS = ["/RELEASE",]
+ LINKFLAGS = ["/RELEASE"]
if EnvironmentBuilder.REDUCE_SIZE in bldr.optTags:
CCFLAGS.extend(['/O1'])
else:
if bldr.optLevel == EnvironmentBuilder.MINIMAL:
- CCFLAGS.extend(['/Ot','/Og'])
+ CCFLAGS.extend(['/Ot', '/Og'])
elif bldr.optLevel == EnvironmentBuilder.STANDARD:
CCFLAGS.append(['/O2'])
- elif ((bldr.optLevel == EnvironmentBuilder.EXTENSIVE) or
- (bldr.optLevel == EnvironmentBuilder.MAXIMUM)):
+ elif (bldr.optLevel == EnvironmentBuilder.EXTENSIVE or
+ bldr.optLevel == EnvironmentBuilder.MAXIMUM):
CCFLAGS.append(['/Ox'])
# Fast math
if EnvironmentBuilder.FAST_MATH in bldr.optTags:
CCFLAGS.append(['/fp:fast'])
-
+
# TODO: Do architecture specific optimizations here
- # /arch:SSE/SEE2 /G1 /G2
+ # /arch:SSE/SEE2 /G1 /G2
# /favor
- env.Append(CXXFLAGS=CXXFLAGS, CCFLAGS=CCFLAGS, CPPDEFINES=CPPDEFINES, LINKFLAGS=LINKFLAGS)
+ env.AppendUnique(CXXFLAGS = CXXFLAGS, CCFLAGS = CCFLAGS, CPPDEFINES = CPPDEFINES,
+ LINKFLAGS = LINKFLAGS)
def msvc_debug(bldr, env):
- """ TODO: Update to handle PDB debug database files.
+ """ TODO: Update to handle PDB debug database files.
TODO: Add support for run-time error checking.
"""
#print "Calling msvc_debug."
if EnvironmentBuilder.NONE == bldr.debugLevel:
return
- env.Append(CCFLAGS=['/Od','/Ob0','/Z7'],
- LINKFLAGS=['/DEBUG'])
+ env.AppendUnique(CCFLAGS = ['/Od', '/Ob0', '/Z7'],
+ LINKFLAGS = ['/DEBUG'])
def msvc_warnings(bldr, env):
CCFLAGS = []
-
+
if EnvironmentBuilder.NONE == bldr.warningLevel:
CCFLAGS.append(['/W0'])
if bldr.warningLevel == EnvironmentBuilder.MINIMAL:
@@ -504,36 +509,41 @@
# warnings as errors
if EnvironmentBuilder.WARN_AS_ERROR in bldr.debugTags:
CCFLAGS.append(['/WX'])
-
+
if EnvironmentBuilder.WARN_STRICT in bldr.debugTags:
CCFLAGS.append(['/Za'])
-
- env.Append(CCFLAGS=CCFLAGS)
-
+
+ env.AppendUnique(CCFLAGS = CCFLAGS)
+
def msvc_misc(bldr, env):
# Runtime library
rt_map = { EnvironmentBuilder.MSVC_MT_DLL_RT:'/MD',
EnvironmentBuilder.MSVC_MT_DBG_DLL_RT:'/MDd',
EnvironmentBuilder.MSVC_MT_RT:'/MT',
EnvironmentBuilder.MSVC_MT_DBG_RT:'/MTd'
- }
+ }
if rt_map.has_key(bldr.msvcRuntime):
- env.Append(CCFLAGS=[rt_map[bldr.msvcRuntime]])
+ env.AppendUnique(CCFLAGS = [rt_map[bldr.msvcRuntime]])
# Exception handling
if bldr.exceptionsEnabled:
- if env["MSVS"]["VERSION"] >= "7.1":
+ if env.has_key("MSVC_VERSION"):
+ msvc_version = env["MSVC_VERSION"]
+ else:
+ msvc_version = env["MSVS"]["VERSION"]
+
+ if msvc_version >= "7.1":
if bldr.structuredExceptionsEnabled:
- env.Append(CCFLAGS=['/EHa'])
+ env.AppendUnique(CCFLAGS = ['/EHa'])
else:
- env.Append(CCFLAGS=['/EHsc'])
+ env.AppendUnique(CCFLAGS = ['/EHsc'])
else:
- env.Append(CCFLAGS=['/GX',])
+ env.AppendUnique(CCFLAGS = ['/GX'])
# RTTI
if bldr.rttiEnabled:
- env.Append(CCFLAGS=["/GR"])
-
+ env.AppendUnique(CCFLAGS = ["/GR"])
+
# Default defines
env.AppendUnique(CPPDEFINES = ["_WINDOWS"])
@@ -553,17 +563,17 @@
LINKFLAGS = '/MACHINE:X86')
# MSVC functions
-default_funcs.append([['cl'],[],msvc_optimizations])
-default_funcs.append([['cl'],[],msvc_debug])
-default_funcs.append([['cl'],[],msvc_warnings])
-default_funcs.append([['cl'],[],msvc_misc])
+default_funcs.append([['cl'], [], msvc_optimizations])
+default_funcs.append([['cl'], [], msvc_debug])
+default_funcs.append([['cl'], [], msvc_warnings])
+default_funcs.append([['cl'], [], msvc_misc])
# ---- DEFAULT ---- #
-def default_debug_define(bldr,env):
+def default_debug_define(bldr, env):
if EnvironmentBuilder.NONE != bldr.optLevel and EnvironmentBuilder.NONE == bldr.debugLevel:
- env.Append(CPPDEFINES=["NDEBUG",])
+ env.AppendUnique(CPPDEFINES = ["NDEBUG"])
-default_funcs.append([[],[],default_debug_define])
+default_funcs.append([[], [], default_debug_define])
# ---- Helpers ---- #
@@ -575,10 +585,10 @@
def CheckArch(context, archName):
""" Custom config context check for checking arch in this method. """
context.Message( 'Checking for arch [%s] ...'%archName )
- ret = context.TryCompile("""int main() { return 0; }""",'.c')
+ ret = context.TryCompile("""int main() { return 0; }""", '.c')
context.Result( ret )
return ret
-
+
valid_archs = []
cur_arch = GetArch()
if "ia32" == cur_arch:
@@ -586,10 +596,10 @@
elif "x64" == cur_arch:
valid_archs.append(EnvironmentBuilder.X64_ARCH)
elif "ppc" == cur_arch:
- valid_archs.append(EnvironmentBuilder.PPC_ARCH)
+ valid_archs.append(EnvironmentBuilder.PPC_ARCH)
elif "ppc64" == cur_arch:
- valid_archs.append(EnvironmentBuilder.PPC64_ARCH)
-
+ valid_archs.append(EnvironmentBuilder.PPC64_ARCH)
+
# Only handle case of using Visual C++ or GCC as the compiler for now.
test_env = EnvironmentBuilder().buildEnvironment()
# XXX: This is bad: GCC is not always called 'gcc'. It may also exist as
@@ -607,10 +617,10 @@
EnvironmentBuilder.UNIVERSAL_ARCH]
if os.uname()[2][0] >= '9':
arch_checks.insert(3, EnvironmentBuilder.X64_ARCH)
- elif cur_arch in ["ia32","x64"]: # Check x86 platforms
+ elif cur_arch in ["ia32", "x64"]: # Check x86 platforms
arch_checks = [EnvironmentBuilder.IA32_ARCH,
EnvironmentBuilder.X64_ARCH]
- elif cur_arch in ["ppc","ppc64"]: # Check PowerPC architectures
+ elif cur_arch in ["ppc", "ppc64"]: # Check PowerPC architectures
arch_checks = [EnvironmentBuilder.PPC_ARCH,
EnvironmentBuilder.PPC64_ARCH]
@@ -619,7 +629,7 @@
env_bldr = EnvironmentBuilder()
env_bldr.setCpuArch(test_arch)
conf_env = env_bldr.buildEnvironment()
- conf_ctxt = conf_env.Configure(custom_tests={"CheckArch":CheckArch})
+ conf_ctxt = conf_env.Configure(custom_tests = {"CheckArch":CheckArch})
passed_test = conf_ctxt.CheckArch(test_arch)
conf_ctxt.Finish()
if passed_test:
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
