# Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import os import shutil import sys p = ARGUMENTS.get('PROGRESS') if p == 'spinner': Progress(['/\r', '|\r', '\\\r', '-\r'], interval=5, file=open('con', 'w')) elif p == 'name': Progress('$TARGET\r', overwrite=True, file=open('con', 'w')) default_warnings = ['no-missing-sconscript', 'no-no-parallel-support'] default_warnings = ['no-no-parallel-support'] SetOption('warn', default_warnings + GetOption('warn')) load = ARGUMENTS.get('LOAD') if load: load = load.split(',') else: load = [] root_env = Environment( tools = ['component_setup'], # Requested list of system (shared) libraries, from the comma separated # SYSTEM_LIBS command-line argument req_system_libs = [], # All supported system libraries, for the help message all_system_libs = [], CHROME_BUILD_TYPE = os.environ.get('CHROME_BUILD_TYPE', ''), CHROMIUM_BUILD = os.environ.get('CHROMIUM_BUILD', ''), CHROME_SRC_DIR = '$MAIN_DIR/..', DESTINATION_ROOT = '$MAIN_DIR/Hammer', # Where ComponentTestProgram() will build test executables. TESTS_DIR = '$DESTINATION_ROOT', # Where ComponentProgram() will build program executables. STAGING_DIR = '$DESTINATION_ROOT', # Where ComponentLibrary() will build libraries. LIBS_DIR = '$COMPONENT_LIBRARY_DIR', # TODO(hammer): when Hammer supports this... # Have Hammer prefix all Library aliases with lib_ (to avoid # collisions with the component names themselves). #COMPONENT_LIBRARY_ALIAS = 'lib_$LIBNAME', # Disable running of tests thru scons for now. COMPONENT_TEST_RUNNABLE = False, BASE_DIR = '$OBJ_ROOT/base', BREAKPAD_DIR = '$OBJ_ROOT/breakpad', CHROME_DIR = '$OBJ_ROOT/chrome', GEARS_DIR = '$OBJ_ROOT/gears', GOOGLE_UPDATE_DIR = '$OBJ_ROOT/google_update', GOOGLEURL_DIR = '$OBJ_ROOT/googleurl', MEDIA_DIR = '$OBJ_ROOT/media', NET_DIR = '$OBJ_ROOT/net', RLZ_DIR = '$OBJ_ROOT/rlz', SANDBOX_DIR = '$OBJ_ROOT/sandbox', SDCH_DIR = '$OBJ_ROOT/sdch', SKIA_DIR = '$OBJ_ROOT/skia', TESTING_DIR = '$OBJ_ROOT/testing', THIRD_PARTY_DIR = '$OBJ_ROOT/third_party', V8_DIR = '$OBJ_ROOT/v8', WEBKIT_DIR = '$OBJ_ROOT/webkit', GTEST_DIR = '$TESTING_DIR/gtest', BSDIFF_DIR = '$THIRD_PARTY_DIR/bsdiff', BSPATCH_DIR = '$THIRD_PARTY_DIR/bspatch', BZIP2_DIR = '$THIRD_PARTY_DIR/bzip2', ICU38_DIR = '$THIRD_PARTY_DIR/icu38', LIBEVENT_DIR = '$THIRD_PARTY_DIR/libevent', LIBJPEG_DIR = '$THIRD_PARTY_DIR/libjpeg', LIBPNG_DIR = '$THIRD_PARTY_DIR/libpng', LIBXML_DIR = '$THIRD_PARTY_DIR/libxml', LIBXSLT_DIR = '$THIRD_PARTY_DIR/libxslt', LZMA_SDK_DIR = '$THIRD_PARTY_DIR/lzma_sdk', MODP_B64_DIR = '$THIRD_PARTY_DIR/modp_b64', NPAPI_DIR = '$THIRD_PARTY_DIR/npapi', ZLIB_DIR = '$THIRD_PARTY_DIR/zlib', THIRD_PARTY_WEBKIT_DIR = '$THIRD_PARTY_DIR/WebKit', PYTHON=sys.executable, PERL = 'perl', PERL_INCLUDE_FLAG = '-I ', PERL_INCLUDE_SUFFIX = '', _PERL_INCLUDE_FLAGS = ('${_concat(PERL_INCLUDE_FLAG, ' 'PERL_INCLUDE_PATH, ' 'PERL_INCLUDE_SUFFIX,' '__env__, RDirs, TARGET, SOURCE)}'), ) root_env['req_system_libs'] = ARGUMENTS.get('SYSTEM_LIBS', '').split(',') def WantSystemLib(env, lib): """ Return true if lib has been requested as a system library in SYSTEM_LIBS. """ if lib not in env['all_system_libs']: env['all_system_libs'].append(lib) return (lib in env['req_system_libs']) root_env.AddMethod(WantSystemLib, "WantSystemLib") def ChromeProgram(env, *args, **kw): return env.ComponentProgram(*args, **kw) root_env.AddMethod(ChromeProgram) def ChromeTestProgram(env, *args, **kw): return env.ComponentTestProgram(*args, **kw) root_env.AddMethod(ChromeTestProgram) def ChromeStaticLibrary(env, *args, **kw): kw['COMPONENT_STATIC'] = True return env.ComponentLibrary(*args, **kw) root_env.AddMethod(ChromeStaticLibrary) def ChromeSharedLibrary(env, *args, **kw): kw['COMPONENT_STATIC'] = False return [env.ComponentLibrary(*args, **kw)[0]] root_env.AddMethod(ChromeSharedLibrary, "ChromeSharedLibrary") def ChromeObject(env, *args, **kw): return env.ComponentObject(*args, **kw) root_env.AddMethod(ChromeObject) # TODO(bradnelson): pull this functionality into hammer. # Auto select the number of processors if root_env['PLATFORM'] in ['win32', 'cygwin']: cpus = int(os.environ.get('NUMBER_OF_PROCESSORS', 1)) elif root_env['PLATFORM'] in ['linux', 'linux2', 'posix']: # TODO(evanm): this is Linux-specific, not posix. # Parse /proc/cpuinfo for processor count. cpus = len([l for l in open('/proc/cpuinfo') if l.startswith('processor\t')]) else: cpus = 1 SetOption('num_jobs', cpus + 1) if ARGUMENTS.get('VERBOSE') in (None, '0'): root_env['CCCOMSTR'] = 'Compiling $TARGET ...' root_env['CXXCOMSTR'] = 'Compiling $TARGET ...' root_env['SHCCCOMSTR'] = 'Compiling $TARGET ...' root_env['SHCXXCOMSTR'] = 'Compiling $TARGET ...' root_env['ARCOMSTR'] = 'Archiving $TARGET ...' root_env['LINKCOMSTR'] = 'Linking $TARGET ...' root_env['BINDINGSCOMSTR'] = 'Building bindings in $TARGET ...' # Use timestamps change, followed by MD5 for speed root_env.Decider('MD5-timestamp') # Incorporate settings that should apply globally (primarily to provide # an obvious place for developmental experimentation). root_env.ApplySConscript(['$CHROME_SRC_DIR/build/common.scons']) # The list of all leaf (fully described) environments. environment_list = [] # -------------------------------------------------------------------------- # Decide which things to load. # Don't put anything platform depended here, this is just to gate things # in or out for speed. included = [c for c in load if not c.startswith('-')] excluded = [c[1:] for c in load if c.startswith('-')] if not included: included = ['all'] components = ['all'] def LoadComponent(c): components.append(c) return (not GetOption('help') and c in included or ('all' in included and not c in excluded)) sconscripts = [] if LoadComponent('base'): sconscripts.append('$BASE_DIR/base.scons') if LoadComponent('breakpad'): sconscripts.append('$BREAKPAD_DIR/SConscript') if LoadComponent('chrome'): sconscripts.append('$CHROME_DIR/chrome.scons') if LoadComponent('gears'): sconscripts.append('$GEARS_DIR/SConscript') if LoadComponent('google_update'): sconscripts.append('$GOOGLE_UPDATE_DIR/SConscript') if LoadComponent('googleurl'): # googleurl comes from a different repository so we provide the SConscript # file. sconscripts.append('$GOOGLEURL_DIR/googleurl.scons') if LoadComponent('media'): sconscripts.append('$MEDIA_DIR/media.scons') if LoadComponent('net'): sconscripts.append('$NET_DIR/net.scons') if LoadComponent('rlz'): sconscripts.append('$RLZ_DIR/SConscript') if LoadComponent('sandbox'): sconscripts.append('$SANDBOX_DIR/sandbox.scons') if LoadComponent('sdch'): sconscripts.append('$SDCH_DIR/SConscript') if LoadComponent('skia'): sconscripts.append('$SKIA_DIR/SConscript') if LoadComponent('testing'): sconscripts.append('$TESTING_DIR/SConscript.gtest') if LoadComponent('third_party'): if not root_env.WantSystemLib('bzip2'): sconscripts.append('$BZIP2_DIR/bzip2.scons') root_env.Append(BZIP2_LIB = ['bzip2']) else: root_env.Append(BZIP2_LIB = ['bz2']) if not root_env.WantSystemLib('libpng'): sconscripts.append('$LIBPNG_DIR/libpng.scons') if not root_env.WantSystemLib('libjpeg'): sconscripts.append('$LIBJPEG_DIR/SConscript') if not root_env.WantSystemLib('libxml'): sconscripts.append('$LIBXML_DIR/SConscript') root_env.Append(XML_LIB = ['libxml']) else: root_env.Append(XML_LIB = ['xml2']) if not root_env.WantSystemLib('libxslt'): sconscripts.append('$LIBXSLT_DIR/SConscript') if not root_env.WantSystemLib('lzma_sdk'): sconscripts.append('$LZMA_SDK_DIR/lzma_sdk.scons') if not root_env.WantSystemLib('zlib'): sconscripts.append('$ZLIB_DIR/zlib.scons') root_env.Append(ZLIB_LIB = ['zlib']) else: root_env.Append(ZLIB_LIB = ['z']) sconscripts.extend([ '$BSDIFF_DIR/bsdiff.scons', '$BSPATCH_DIR/bspatch.scons', '$ICU38_DIR/icu38.scons', '$MODP_B64_DIR/modp_b64.scons', ]) if LoadComponent('v8') and root_env.Dir('$CHROME_SRC_DIR/v8').exists(): sconscripts.append('$OBJ_ROOT/build/SConscript.v8') if LoadComponent('webkit'): sconscripts.append('$WEBKIT_DIR/webkit.scons') # Add the final list into the root environment to be build in BuildComponents. root_env.Append(BUILD_SCONSCRIPTS = sconscripts) # -------------------------------------------------------------------------- # Windows specific windows_env = root_env.Clone() windows_env.Tool('target_platform_windows') windows_env.Tool('component_targets_msvs') # Per target project support. windows_env.Tool('midl') # TODO(bradnelson): target_platform_windows defines a whole bunch of # flags that we don't care about, including defining OS_WINDOWS in a # way that we don't want, and (most especially) adding *_DEBUG and # *_OPTIMIZED constructionv variables that add magic values to # CCFLAGS. We override the normal variables (CPPDEFINES, CCFLAGS, # LINKFLAGS, ARFLAGS) below, but get rid of the special Hammer ones # here, until Hammer can be made a little nicer about htis. del windows_env['CCFLAGS_DEBUG'] del windows_env['LINKFLAGS_DEBUG'] del windows_env['CCFLAGS_OPTIMIZED'] windows_env['PDB'] = '${TARGET.base}.pdb' # TODO(bradnelson): this should not need to be gated on host platform. if root_env['PLATFORM'] in ['win32', 'cygwin']: msvs_env = Environment(tools=['msvc', 'mslink', 'msvs'])['ENV'] msvs_drive = msvs_env['PATH'][0] else: msvs_env = {'PATH': '', 'INCLUDE': '', 'LIB': ''} msvs_drive = 'C' # Use the absolute path for MSVC because it might not be on the same drive # as our source checkout. visual_studio_path = msvs_drive + ':/Program Files/Microsoft Visual Studio 8' windows_env.Replace( CSCRIPT = 'c:\\Windows\\System32\\cscript', PLATFORMSDK_VISTA_REL = '../third_party/platformsdk_vista_6_0', PLATFORMSDK_VISTA = '$CHROME_SRC_DIR/third_party/platformsdk_vista_6_0', VISUAL_STUDIO = visual_studio_path, CYGWIN_DIR = windows_env.Dir('$CHROME_SRC_DIR/third_party/cygwin'), CYGWIN_BIN_DIR = '$CYGWIN_DIR/bin', PERL = '$CYGWIN_BIN_DIR/perl.exe', MSVS_ENV = msvs_env, YACC = '$CYGWIN_BIN_DIR/bison.exe', ARFLAGS = [ '/nologo', ], CCFLAGS = [ '/nologo', '/errorReport:prompt', ], CPPDEFINES = [ '_UNICODE', 'UNICODE', ], LIBS = [ 'advapi32.lib', 'comdlg32.lib', 'gdi32.lib', 'kernel32.lib', 'odbc32.lib', 'odbccp32.lib', 'ole32.lib', 'oleaut32.lib', 'shell32.lib', 'user32.lib', 'uuid.lib', 'winspool.lib', 'DelayImp.lib', ], LINKFLAGS = [ '/nologo', ], ICU_LIBS = ['icu'], ) # Force scons to handle long include lines correctly. pchcom_fixed = windows_env['PCHCOM'] pchcom_fixed = pchcom_fixed.replace('${TARGETS[0]}', '$TARGET') pchcom_fixed = pchcom_fixed.replace('${TARGETS[1]}', '$TARGETS1') # Below, we'll redefine $CXXFLAGS so its expansion doesn't include # $CCFLAGS. Modify $PCHCOM, which was relying on this fact, so # that $CCFLAGS still shows up in precompiled header compilations. pchcom_fixed = pchcom_fixed.replace('$CXXFLAGS', '$CXXFLAGS $CCFLAGS') windows_env.Replace( CCCOM = "${TEMPFILE('%s')}" % windows_env['CCCOM'], CXXCOM = "${TEMPFILE('%s')}" % windows_env['CXXCOM'], SHCCCOM = "${TEMPFILE('%s')}" % windows_env['SHCCCOM'], SHCXXCOM = "${TEMPFILE('%s')}" % windows_env['SHCXXCOM'], PCHCOM = "${TEMPFILE('%s')}" % pchcom_fixed, TARGETS1 = '${TARGETS[1]}', # The SCons default for $CXXFLAGS contains $CCFLAGS, which is # also on the $CCCOM command line string separately. Redefine # $CXXFLAGS to avoid the duplication CXXFLAGS = '$( /TP $)', ) windows_env['ENV']['PROGRAMFILES'] = os.environ.get('PROGRAMFILES', '') windows_env['ENV']['SystemDrive'] = os.environ.get('SystemDrive', '') windows_env['ENV']['USERPROFILE'] = os.environ.get('USERPROFILE', '') windows_env.AppendENVPath('PATH', ';C:\\WINDOWS\\system32') windows_dbg = windows_env.Clone() environment_list.append(windows_dbg) windows_dbg.Replace( BUILD_TYPE = 'dbg', BUILD_TYPE_DESCRIPTION = 'Windows debug build', ) windows_dbg.Tool('target_debug') windows_dbg.ApplySConscript(['$CHROME_SRC_DIR/build/debug.scons']) windows_dbg.Append(BUILD_GROUPS = ['default']) windows_opt = windows_env.Clone() environment_list.append(windows_opt) windows_opt.Replace( BUILD_TYPE = 'opt', BUILD_TYPE_DESCRIPTION = 'Windows optimized build', ) windows_opt.Tool('target_optimized') windows_opt.ApplySConscript(['$CHROME_SRC_DIR/build/release.scons']) # -------------------------------------------------------------------------- # Linux specific linux_env = root_env.Clone() linux_env.Tool('target_platform_linux') linux_env.Tool('yacc') # TODO(bradnelson): this is needed for now because target_platform_linux has # OS_LINUX defined in a weird way. linux_env.FilterOut(CPPDEFINES = ['OS_LINUX=OS_LINUX']) # Copy some environment variables from the outer environment to the # SCons.Environment if they exist. for envvar in ('CC', 'CXX', 'LINK'): if envvar in os.environ: linux_env[envvar] = os.environ[envvar] # Copy these environment variables from the outer environment to the # environment that the build commands run in. # $HOME is needed by distcc so it can find its lock file. for envvar in ('HOME', 'DISTCC_DIR', 'DISTCC_HOSTS', 'CCACHE_DIR', 'INTERCEPTOR_SOCKET', 'ENFORGE_DIGEST_CACHE', 'ENFORGE_CACHE_HOST', 'ENFORGE_CACHE_PORT'): if envvar in os.environ: linux_env['ENV'][envvar] = os.environ[envvar] excluded_warnings = [ # TODO: Clean up uses of ext/hash_map and remove this. # (see unordered_map and base/hash_tables.h) '-Wno-deprecated', # Needed for using ext/hash_map on GCC 4.3 '-Wno-unknown-pragmas', # In wtf's ref counting system ] linux_env.Append( BUILD_SCONSCRIPTS = [ '$LIBEVENT_DIR/libevent.scons', ], CCFLAGS = ['-m32', '-pthread', '-march=i686', '-fno-exceptions'], CXXFLAGS = ['-Wall', '-Werror', '-march=i686'] + excluded_warnings, LINKFLAGS = ['-m32', '-pthread'], ) linux_env.Replace( # Linking of large files uses lots of RAM, so serialize links # using the handy flock command from util-linux. LINK = 'flock $TARGET_ROOT/linker.lock ' + linux_env['LINK'], # We have several cases where archives depend on each other in a cyclic # fashion. (V8Bindings, libport and WebCore being the most significant # example.) Since the GNU linker does only a single pass over the archives # we need some extra trickery to deal with these unavoidable cycles. That # trickery is --start-group and --end-group (aka -( and -) ). That causes ld # to loop over the group until no more undefined symbols are found. In an # ideal world we would only make groups from those libraries which we knew # to be in cycles. However, that's tough with SCons, so we bodge it by # making all the archives a group by redefining the linking command here. SHLINKCOM = ('$SHLINK -shared -o $TARGET $SHLINKFLAGS $SOURCES ' '$_LIBDIRFLAGS ' '-Wl,--start-group $_LIBFLAGS -Wl,--end-group'), LINKCOM = ('$LINK -o $TARGET $LINKFLAGS $SOURCES ' '$_LIBDIRFLAGS ' '-Wl,--start-group $_LIBFLAGS -Wl,--end-group'), ) linux_env.Replace( PERL = '/usr/bin/perl', PERL_INCLUDE_FLAG = '-I ', PERL_INCLUDE_SUFFIX = '', _PERL_INCLUDE_FLAGS = ('${_concat(PERL_INCLUDE_FLAG, ' 'PERL_INCLUDE_PATH, ' 'PERL_INCLUDE_SUFFIX,' '__env__, RDirs, TARGET, SOURCE)}'), ) linux_env.FilterOut( BUILD_SCONSCRIPTS = [ '$BSPATCH_DIR/bspatch.scons', '$BSDIFF_DIR/bsdiff.scons', '$GEARS_DIR/SConscript', '$GOOGLE_UPDATE_DIR/SConscript', '$RLZ_DIR/SConscript', '$SANDBOX_DIR/sandbox.scons', ], ) linux_env.Append( # We need rt for clock_gettime. LIBS = ['rt'], ICU_LIBS = ['icu'], ) # Build with support for gcov when COVERAGE=1. if ARGUMENTS.get('COVERAGE') == '1': linux_env.Append(CCFLAGS=['-fprofile-arcs', '-ftest-coverage']) linux_env.Append(LINKFLAGS=['-fprofile-arcs']) # Build with system-provided NSS and GTK. if root_env['PLATFORM'] in ['linux', 'linux2', 'posix']: try: linux_env.ParseConfig('pkg-config --cflags --libs nss') linux_env.ParseConfig('pkg-config --cflags --libs gtk+-2.0') linux_env.ParseConfig('pkg-config --cflags --libs pangoft2') except OSError, e: print ('\n' 'Failed to find a package dependency. Please install all the\n' 'packages listed at\n' 'http://code.google.com/p/chromium/wiki/LinuxBuildInstructions' '#Software_Requirements') sys.exit(1) if root_env.WantSystemLib('libxml'): try: linux_env.ParseConfig('pkg-config --cflags --libs libxml-2.0') except OSError, e: print ('\n' 'libxml requested in SYSTEM_LIBS but not found\n') sys.exit(1) if root_env.WantSystemLib('libxslt'): try: linux_env.ParseConfig('pkg-config --cflags --libs libxslt') except OSError, e: print ('\n' 'libxslt requested in SYSTEM_LIBS but not found\n') sys.exit(1) linux_dbg = linux_env.Clone() environment_list.append(linux_dbg) linux_dbg.Replace( BUILD_TYPE = 'dbg', BUILD_TYPE_DESCRIPTION = 'Linux debug build', ) linux_dbg.Tool('target_debug') linux_dbg.ApplySConscript(['$CHROME_SRC_DIR/build/debug.scons']) linux_dbg.Append(BUILD_GROUPS = ['default']) linux_opt = linux_env.Clone() environment_list.append(linux_opt) # Disable rpath for faster startup. linux_opt.Append(RPATH = []) linux_opt.Replace( BUILD_TYPE = 'opt', BUILD_TYPE_DESCRIPTION = 'Linux optimized build', ) linux_opt.Tool('target_optimized') linux_opt.ApplySConscript(['$CHROME_SRC_DIR/build/release.scons']) # -------------------------------------------------------------------------- # Mac specific mac_env = root_env.Clone() environment_list.append(mac_env) mac_env.Tool('target_platform_mac') mac_env.Tool('target_debug') mac_env.ApplySConscript(['$CHROME_SRC_DIR/build/debug.scons']) mac_env.Replace( BUILD_TYPE = 'debug-mac', BUILD_TYPE_DESCRIPTION = 'Mac debug build', ) mac_env.Append(BUILD_GROUPS = ['default']) mac_env.Replace( # Reproduce XCode's behavior of using gcc even to link C++, # and distinguishing it the -x c++ option. CC = 'gcc-4.2', CXX = 'g++-4.2', LINK = '$CXX', ) mac_env.FilterOut( BUILD_SCONSCRIPTS = [ '$BSPATCH_DIR/bspatch.scons', '$BSDIFF_DIR/bsdiff.scons', '$LIBJPEG_DIR/SConscript', '$LIBXML_DIR/SConscript', '$LIBXSLT_DIR/SConscript', '$BREAKPAD_DIR/SConscript', '$CHROME_DIR/SConscript', '$GEARS_DIR/SConscript', '$GOOGLE_UPDATE_DIR/SConscript', '$RLZ_DIR/SConscript', '$SANDBOX_DIR/sandbox.scons', 'build/SConscript.v8', '$WEBKIT_DIR/SConscript', ], ) if not root_env.WantSystemLib('libevent'): mac_env.Append( BUILD_SCONSCRIPTS = [ '$LIBEVENT_DIR/libevent.scons', ], ) mac_env.Append( CFLAGS = [ '-std=c99', ], CXXFLAGS = [ '-fvisibility-inlines-hidden', '${str(SOURCE).endswith(".mm") and "-fobjc-gc" or ""}', ], CCFLAGS = [ '-fmessage-length=0', '-pipe', '-O0', '-mdynamic-no-pic', '-Werror', '-Wnewline-eof', '-fvisibility=hidden', '-gdwarf-2', '-Wall', '-Wendif-labels', '-fstack-protector', '-fstack-protector-all', ], CPPDEFINES = [ 'DEBUG', ], FRAMEWORKPATH = [ mac_env.Dir('${TARGET_ROOT}'), '/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks', ], FRAMEWORKS = [ 'AppKit', 'ApplicationServices', 'Foundation', ], ICU_LIBS = ['icui18n', 'icuuc', 'icudata'], ) # Add --clobber (for the buildbot). # NOTE: seems to be crucial to do this before any builders are invoked. AddOption('--clobber', action='store_true', dest='clobber', default=False, help='Delete build directory before building.') if GetOption('clobber'): shutil.rmtree(root_env.Dir('$DESTINATION_ROOT').abspath, True) # sconsign file gets put here at the moment. shutil.rmtree(root_env.Dir('$MAIN_DIR/scons-out').abspath, True) # ------------------------------------------------------------------------- # Overlay things from a layer below. for env in environment_list: env.Dir('$OBJ_ROOT').addRepository(env.Dir('$CHROME_SRC_DIR')) env.Dir('$OBJ_ROOT/googleurl').addRepository(env.Dir('$CHROME_SRC_DIR/build')) # We pre-resolve some common targets. We end up spending lots of time # resolving these over and over again. env.Replace( CHROME_SRC_DIR = str(env.Dir('$CHROME_SRC_DIR')), DESTINATION_ROOT = str(env.Dir('$DESTINATION_ROOT')), TARGET_ROOT = str(env.Dir('$TARGET_ROOT')), OBJ_ROOT = str(env.Dir('$OBJ_ROOT')), WEBKIT_DIR = str(env.Dir('$WEBKIT_DIR')), ) help_fmt = """ Usage: hammer [SCONS_OPTIONS] [VARIABLES] [TARGET] ... Supported build variables: LOAD=[module,...] Comma-separated list of components to load in the dependency graph ('-' prefix excludes): %s SYSTEM_LIBS=[lib,...] Comma-separated list of system libraries to link dynamically (by default they are built in from included sources): %s PROGRESS=type Display a progress indicator: name: print each evaluated target name spinner: print a spinner every 5 targets VERBOSE=1 Display full command lines """ if GetOption('help'): import textwrap tw = textwrap.TextWrapper( width = 78, initial_indent = ' '*32, subsequent_indent = ' '*32, ) components = tw.fill(', '.join(components)) all_system_libs = tw.fill(', '.join(env['all_system_libs'])) Help(help_fmt % (components, all_system_libs)) Import('build_component') Default(None) # Reset default target to empty. Default(Alias(build_component)) # Set default target based on where built. # ------------------------------------------------------------------------- # Invoke all the SConscripts in each of the environments that make sense on # this host-platform. BuildComponents(environment_list) # ------------------------------------------------------------------------- # This must occur after BuildComponents so that the dependency graph # will be populated. vs_env = windows_env.Clone() vs_env.Append(COMPONENT_VS_SOURCE_SUFFIXES = [ '.def', '.ini', '.txt', '.ui', '.xml', ]) # Source project p = vs_env.ComponentVSDirProject( 'chrome_src', [ # TODO(bradnelson): need to make sure we can use $CHROME_SRC_DIR here '$CHROME_SRC_DIR/base', '$CHROME_SRC_DIR/breakpad', '$CHROME_SRC_DIR/build', # '$CHROME_SRC_DIR/chrome', '.', '$CHROME_SRC_DIR/data', '$CHROME_SRC_DIR/gears', '$CHROME_SRC_DIR/google_update', '$CHROME_SRC_DIR/googleurl', '$CHROME_SRC_DIR/net', '$CHROME_SRC_DIR/rlz', '$CHROME_SRC_DIR/sandbox', '$CHROME_SRC_DIR/sdhc', '$CHROME_SRC_DIR/site_scons', '$CHROME_SRC_DIR/skia', '$CHROME_SRC_DIR/testing', '$CHROME_SRC_DIR/third_party', '$CHROME_SRC_DIR/tools', '$CHROME_SRC_DIR/v8', '$CHROME_SRC_DIR/webkit', ], COMPONENT_VS_SOURCE_FOLDERS = [ (None, '$DESTINATION_ROOT'), ('src', '$CHROME_SRC_DIR'), ], COMPONENT_VS_PROJECT_DIR = '$MAIN_DIR', ) # Always try to (re)build the project files when requested. vs_env.AlwaysBuild(p) vs_env.ComponentVSSolution( 'chrome_solution', [ 'all_libraries', 'all_languages', 'all_programs', 'all_test_programs', ], projects = [p], COMPONENT_VS_PROJECT_SCRIPT_PATH=( 'cd $$(ProjectDir)/$VS_PROJECT_TO_MAIN_DIR && hammer.bat'), ) # -------------------------------------------------------------------------