# -*- Python -*- # Copyright 2008 Google Inc. All Rights Reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # Author: joi@google.com (Joi Sigurdsson) # Author: vladl@google.com (Vlad Losev) # # Shared SCons utilities for building Google Test inside and outside of # Google's environment. # EnsurePythonVersion(2, 3) BUILD_DIR_PREFIX = 'build' class SConstructHelper: def __init__(self): # A dictionary to look up an environment by its name. self.env_dict = {} def Initialize(self, build_root_path, support_multiple_win_builds=False): test_env = Environment() platform = test_env['PLATFORM'] if platform == 'win32': if support_multiple_win_builds: available_build_types = ['win-dbg8', 'win-opt8', 'win-dbg', 'win-opt'] else: available_build_types = ['win-dbg', 'win-opt'] elif platform == 'darwin': # MacOSX available_build_types = ['mac-dbg', 'mac-opt'] else: available_build_types = ['dbg', 'opt'] # Assuming POSIX-like environment # with GCC by default. vars = Variables() vars.Add(ListVariable('BUILD', 'Build type', available_build_types[0], available_build_types)) vars.Add(BoolVariable('GTEST_BUILD_SAMPLES', 'Build samples', False)) # Create base environment. self.env_base = Environment(variables=vars, BUILD_MODE={'BUILD' : '"${BUILD}"'}) # Leave around a variable pointing at the build root so that SConscript # files from outside our project root can find their bearings. Trick # borrowed from Hammer in Software Construction Toolkit # (http://code.google.com/p/swtoolkit/); if/when we switch to using the # Hammer idioms instead of just Hammer's version of SCons, we should be # able to remove this line. self.env_base['SOURCE_ROOT'] = self.env_base.Dir(build_root_path) # And another that definitely always points to the project root. self.env_base['PROJECT_ROOT'] = self.env_base.Dir('.').abspath # Enable scons -h Help(vars.GenerateHelpText(self.env_base)) class EnvCreator: """Creates new customized environments from a base one.""" def _Remove(cls, env, attribute, value): """Removes the given attribute value from the environment.""" attribute_values = env[attribute] if value in attribute_values: attribute_values.remove(value) _Remove = classmethod(_Remove) def Create(cls, base_env, modifier=None): # User should NOT create more than one environment with the same # modifier (including None). env = base_env.Clone() if modifier: modifier(env) else: env['OBJ_SUFFIX'] = '' # Default suffix for unchanged environment. return env; Create = classmethod(Create) # Each of the following methods modifies the environment for a particular # purpose and can be used by clients for creating new environments. Each # one needs to set the OBJ_SUFFIX variable to a unique suffix to # differentiate targets built with that environment. Otherwise, SCons may # complain about same target built with different settings. def UseOwnTuple(cls, env): """Instructs Google Test to use its internal implementation of tuple.""" env['OBJ_SUFFIX'] = '_use_own_tuple' env.Append(CPPDEFINES = 'GTEST_USE_OWN_TR1_TUPLE=1') UseOwnTuple = classmethod(UseOwnTuple) def WarningOk(cls, env): """Does not treat warnings as errors. Necessary for compiling gtest_unittest.cc, which triggers a gcc warning when testing EXPECT_EQ(NULL, ptr).""" env['OBJ_SUFFIX'] = '_warning_ok' if env['PLATFORM'] == 'win32': cls._Remove(env, 'CCFLAGS', '-WX') else: cls._Remove(env, 'CCFLAGS', '-Werror') WarningOk = classmethod(WarningOk) def WithExceptions(cls, env): """Re-enables exceptions.""" env['OBJ_SUFFIX'] = '_ex' if env['PLATFORM'] == 'win32': env.Append(CCFLAGS=['/EHsc']) env.Append(CPPDEFINES='_HAS_EXCEPTIONS=1') # Undoes the _TYPEINFO_ hack, which is unnecessary and only creates # trouble when exceptions are enabled. cls._Remove(env, 'CPPDEFINES', '_TYPEINFO_') cls._Remove(env, 'CPPDEFINES', '_HAS_EXCEPTIONS=0') else: env.Append(CCFLAGS='-fexceptions') cls._Remove(env, 'CCFLAGS', '-fno-exceptions') WithExceptions = classmethod(WithExceptions) def LessOptimized(cls, env): """Disables certain optimizations on Windows. We need to disable some optimization flags for some tests on Windows; otherwise the redirection of stdout does not work (apparently because of a compiler bug).""" env['OBJ_SUFFIX'] = '_less_optimized' if env['PLATFORM'] == 'win32': for flag in ['/O1', '/Os', '/Og', '/Oy']: cls._Remove(env, 'LINKFLAGS', flag) LessOptimized = classmethod(LessOptimized) def WithThreads(cls, env): """Allows use of threads. Currently only enables pthreads under GCC.""" env['OBJ_SUFFIX'] = '_with_threads' if env['PLATFORM'] != 'win32': # Assuming POSIX-like environment with GCC. # TODO(vladl@google.com): sniff presence of pthread_atfork instead of # selecting on a platform. env.Append(CCFLAGS=['-pthread']) env.Append(LINKFLAGS=['-pthread']) WithThreads = classmethod(WithThreads) def NoRtti(cls, env): """Disables RTTI support.""" env['OBJ_SUFFIX'] = '_no_rtti' if env['PLATFORM'] == 'win32': env.Append(CCFLAGS=['/GR-']) else: env.Append(CCFLAGS=['-fno-rtti']) env.Append(CPPDEFINES='GTEST_HAS_RTTI=0') NoRtti = classmethod(NoRtti) def AllowVc71StlWithoutExceptions(self, env): env.Append( CPPDEFINES = [# needed for using some parts of STL with exception # disabled. The scoop is given here, with comments # from P.J. Plauger at # http://groups.google.com/group/microsoft.public.vc.stl/browse_thread/thread/5e719833c6bdb177?q=_HAS_EXCEPTIONS+using+namespace+std&pli=1 '_TYPEINFO_']) def MakeWinBaseEnvironment(self): win_base = self.env_base.Clone( platform='win32', CCFLAGS=['-GS', # Enable buffer security check '-W4', # Warning level # Disables warnings that are either uninteresting or # hard to fix. '-WX', # Treat warning as errors #'-GR-', # Disable runtime type information '-RTCs', # Enable stack-frame run-time error checks '-RTCu', # Report when variable used without init. #'-EHs', # enable C++ EH (no SEH exceptions) '-nologo', # Suppress logo line '-J', # All chars unsigned #'-Wp64', # Detect 64-bit portability issues. This # flag has been deprecated by VS 2008. '-Zi', # Produce debug information in PDB files. ], CCPDBFLAGS='', CPPDEFINES=['_UNICODE', 'UNICODE', 'WIN32', '_WIN32', 'STRICT', 'WIN32_LEAN_AND_MEAN', '_HAS_EXCEPTIONS=0', ], LIBPATH=['#/$MAIN_DIR/lib'], LINKFLAGS=['-MACHINE:x86', # Enable safe SEH (not supp. on x64) '-DEBUG', # Generate debug info '-NOLOGO', # Suppress logo line ], # All strings in string tables zero terminated. RCFLAGS=['-n']) return win_base def SetBuildNameAndDir(self, env, name): env['BUILD_NAME'] = name; env['BUILD_DIR'] = '%s/%s' % (BUILD_DIR_PREFIX, name) self.env_dict[name] = env def MakeWinDebugEnvironment(self, base_environment, name): """Takes a VC71 or VC80 base environment and adds debug settings.""" debug_env = base_environment.Clone() self.SetBuildNameAndDir(debug_env, name) debug_env.Append( CCFLAGS = ['-Od', # Disable optimizations '-MTd', # Multithreaded, static link (debug) # Path for PDB files '-Fd%s\\' % debug_env.Dir(debug_env['BUILD_DIR']), ], CPPDEFINES = ['DEBUG', '_DEBUG', ], LIBPATH = [], LINKFLAGS = ['-INCREMENTAL:yes', '/OPT:NOICF', ] ) return debug_env def MakeWinOptimizedEnvironment(self, base_environment, name): """Takes a VC71 or VC80 base environment and adds release settings.""" optimized_env = base_environment.Clone() self.SetBuildNameAndDir(optimized_env, name) optimized_env.Append( CCFLAGS = ['-GL', # Enable link-time code generation (/GL) '-GF', # Enable String Pooling (/GF) '-MT', # Multithreaded, static link # Path for PDB files '-Fd%s\\' % optimized_env.Dir(optimized_env['BUILD_DIR']), # Favor small code (this is /O1 minus /Og) '-Os', '-Oy', '-Ob2', '-Gs', '-GF', '-Gy', ], CPPDEFINES = ['NDEBUG', '_NDEBUG', ], LIBPATH = [], ARFLAGS = ['-LTCG'], # Link-time Code Generation LINKFLAGS = ['-LTCG', # Link-time Code Generation '-OPT:REF', # Optimize by reference. '-OPT:ICF=32', # Optimize by identical COMDAT folding '-OPT:NOWIN98', # Optimize by not aligning section for # Win98 '-INCREMENTAL:NO', # No incremental linking as we don't # want padding bytes in release build. ], ) return optimized_env def AddGccFlagsTo(self, env, optimized): env.Append(CCFLAGS=['-fno-exceptions', '-Wall', '-Werror', ]) if optimized: env.Append(CCFLAGS=['-O2'], CPPDEFINES=['NDEBUG', '_NDEBUG']) else: env.Append(CCFLAGS=['-g'], CPPDEFINES=['DEBUG', '_DEBUG']) def ConfigureGccEnvironments(self): # Mac environments. mac_base = self.env_base.Clone(platform='darwin') mac_dbg = mac_base.Clone() self.AddGccFlagsTo(mac_dbg, optimized=False) self.SetBuildNameAndDir(mac_dbg, 'mac-dbg') mac_opt = mac_base.Clone() self.AddGccFlagsTo(mac_opt, optimized=True) self.SetBuildNameAndDir(mac_opt, 'mac-opt') # Generic GCC environments. gcc_dbg = self.env_base.Clone() self.AddGccFlagsTo(gcc_dbg, optimized=False) self.SetBuildNameAndDir(gcc_dbg, 'dbg') gcc_opt = self.env_base.Clone() self.AddGccFlagsTo(gcc_opt, optimized=True) self.SetBuildNameAndDir(gcc_opt, 'opt') def BuildSelectedEnvironments(self): EnvCreator = SConstructHelper.EnvCreator Export('EnvCreator') # Build using whichever environments the 'BUILD' option selected for build_name in self.env_base['BUILD']: print 'BUILDING %s' % build_name env = self.env_dict[build_name] # Make sure SConscript files can refer to base build dir env['MAIN_DIR'] = env.Dir(env['BUILD_DIR']) #print 'CCFLAGS: %s' % env.subst('$CCFLAGS') #print 'LINK: %s' % env.subst('$LINK') #print 'AR: %s' % env.subst('$AR') #print 'CC: %s' % env.subst('$CC') #print 'CXX: %s' % env.subst('$CXX') #print 'LIBPATH: %s' % env.subst('$LIBPATH') #print 'ENV:PATH: %s' % env['ENV']['PATH'] #print 'ENV:INCLUDE: %s' % env['ENV']['INCLUDE'] #print 'ENV:LIB: %s' % env['ENV']['LIB'] #print 'ENV:TEMP: %s' % env['ENV']['TEMP'] Export('env') # Invokes SConscript with variant_dir being build/. # Counter-intuitively, src_dir is relative to the build dir and has # to be '..' to point to the scons directory. SConscript('SConscript', src_dir='..', variant_dir=env['BUILD_DIR'], duplicate=0) sconstruct_helper = SConstructHelper() Return('sconstruct_helper')