build/SConscript.main - Issue 53121: Remove the checked-in scons configuration files.

Unified Diff: build/SConscript.main

Issue 53121: Remove the checked-in scons configuration files. (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/

Patch Set: Created 11 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: build/SConscript.main

===================================================================

--- build/SConscript.main (revision 12583)

+++ build/SConscript.main (working copy)

@@ -1,900 +0,0 @@

-# 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

-if sys.platform == 'win32':

- console = 'con'

-else:

- console = '/dev/tty'

-p = ARGUMENTS.get('PROGRESS')

-if p == 'spinner':

- Progress(['/\r', '|\r', '\\\r', '-\r'], interval=5, file=open(console, 'w'))

-elif p == 'name':

- Progress('$TARGET\r', overwrite=True, file=open(console, 'w'))

-default_warnings = ['no-missing-sconscript', 'no-no-parallel-support']

-default_warnings = ['no-no-parallel-support']

-SetOption('warn', default_warnings + GetOption('warn'))

-# Variables for controlling the build.

-# The following variables can be set either on the command line

-# or in the external environment when executing SCons, with the

-# command line overriding any environment setting.

-# BUILD_TARGET_DIR

-# Specifies the target subdirectory name in which we'll

-# build everything. This is intended to mimic the Visual

-# Visual Studio "Debug\" and "Release\" subdirectories.

-# The default value is "Hammer."

-# CHROME_BUILD_TYPE

-# When set, applies settings from the file

-# build\internal\release_impl${CHROME_BUILD_TYPE}.scons

-# to be applied to the construction environment.

-# CHROMIUM_BUILD

-# When set, applies settings from the file

-# build\internal\chromium_build${CHROMIUM_BUILD}.scons

-# to be applied to the construction environment.

-# INCREMENTAL

-# Controls whether or not libraries and executable programs are

-# linked incrementally. When set to any True value (1, T, y, True),

-# uses the /INCREMENTAL flag to the Microsoft linker. An

-# explicit False value (0, f, N, false) uses the /INCREMENTAL:NO.

-# When not set, the default is to link debug (developer) builds

-# incrementally, but release builds use full links.

-clvars = Variables('scons.opts', ARGUMENTS)

-clvars.AddVariables(

- ('BUILD_TARGET_DIR', '', 'Hammer'),

- ('CHROME_BUILD_TYPE', '', os.environ.get('CHROME_BUILD_TYPE', '')),

- ('CHROMIUM_BUILD', '', os.environ.get('CHROMIUM_BUILD', '')),

- BoolVariable('INCREMENTAL', '', os.environ.get('INCREMENTAL')),

-if ARGUMENTS.get('_GYP'):

- tool_list = ['chromium_builders']

-else:

- tool_list = ['component_setup',

- 'chromium_builders',

- 'chromium_load_component',

- 'MSVSNew']

-root_env = Environment(

- # MSVSNew in the base environment? Yes, the point is we can (and

- # want to) generate Visual Studio project and solution files from

- # any platform.

- tools = tool_list,

- variables = clvars,

- # 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_SRC_DIR = '$MAIN_DIR/..',

- SRC_DIR = '$MAIN_DIR/..',

- DESTINATION_ROOT = '$MAIN_DIR/$BUILD_TARGET_DIR',

- # Where ComponentTestProgram() will build test executables.

- TESTS_DIR = '$DESTINATION_ROOT',

- # Where ComponentProgram() will build program executables.

- STAGING_DIR = '$DESTINATION_ROOT',

- # 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',

- PRINTING_DIR = '$OBJ_ROOT/printing',

- 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',

- TOOLS_DIR = '$OBJ_ROOT/tools',

- 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',

- SQLITE_DIR = '$THIRD_PARTY_DIR/sqlite',

- ZLIB_DIR = '$THIRD_PARTY_DIR/zlib',

- THIRD_PARTY_WEBKIT_DIR = '$THIRD_PARTY_DIR/WebKit',

- GTK_CLIP_DUMP_DIR = '$TOOLS_DIR/gtk_clipboard_dump',

- GRIT_DIR = '$TOOLS_DIR/grit',

- 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(',')

-root_env['_GYP'] = ARGUMENTS.get('GYP') and '_gyp' or ''

-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")

-# 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)

-# 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 = []

-components = []

-# Figure out what SConscript files to load based on the user's request.

-# Default is to load all SConscript files for a full-tree build.

-# The keyword arguments in the call below (base, breakpad, etc.) can be

-# specified in the LOAD= argument to cut down on the build.

-Default(None) # Reset default target to empty.

-if root_env.get('_GYP'):

- webkit_sconscript = '$WEBKIT_DIR/tools/test_shell/test_shell_main${_GYP}.scons'

-else:

- webkit_sconscript = '$WEBKIT_DIR/webkit_main${_GYP}.scons'

-sconscript_map = dict(

- base = '$BASE_DIR/base_main${_GYP}.scons',

- breakpad = '$BREAKPAD_DIR/SConscript',

- chrome = '$CHROME_DIR/chrome_main${_GYP}.scons',

- gears = '$GEARS_DIR/SConscript',

- google_update = '$GOOGLE_UPDATE_DIR/SConscript',

- googleurl = '$GOOGLEURL_DIR/googleurl.scons',

- media = '$MEDIA_DIR/media.scons',

- net = '$NET_DIR/net_main${_GYP}.scons',

- printing = '$PRINTING_DIR/printing.scons',

- rlz = '$RLZ_DIR/SConscript',

- sandbox = '$SANDBOX_DIR/sandbox.scons',

- sdch = '$SDCH_DIR/SConscript',

- skia = '$SKIA_DIR/SConscript',

- testing = '$TESTING_DIR/SConscript.gtest',

- third_party = [

- '$BSDIFF_DIR/bsdiff.scons',

- '$BSPATCH_DIR/bspatch.scons',

- '$BZIP2_DIR/bzip2.scons',

- '$ICU38_DIR/icu38_main${_GYP}.scons',

- '$LIBJPEG_DIR/libjpeg${_GYP}.scons',

- '$LIBPNG_DIR/libpng${_GYP}.scons',

- '$LIBXML_DIR/libxml.scons',

- '$LIBXSLT_DIR/libxslt.scons',

- '$LZMA_SDK_DIR/lzma_sdk.scons',

- '$MODP_B64_DIR/modp_b64.scons',

- '$ZLIB_DIR/zlib${_GYP}.scons',

- ],

- tools = '$GTK_CLIP_DUMP_DIR/gcd.scons',

- v8 = '$OBJ_ROOT/build/SConscript.v8',

- webkit = webkit_sconscript,

-if root_env.get('_GYP'):

- Import('build_component')

- sconscripts = [sconscript_map[build_component]]

- components = [build_component]

-else:

- sconscripts = root_env.ChromiumLoadComponentSConscripts(**sconscript_map)

-# Add the final list into the root environment to be build in BuildComponents.

-root_env.Append(BUILD_SCONSCRIPTS = sconscripts)

-if not root_env.WantSystemLib('sqlite') and not root_env.get('_GYP'):

- root_env.Append(BUILD_SCONSCRIPTS = ['$SQLITE_DIR/SConscript'])

-# --------------------------------------------------------------------------

-# Windows specific

-windows_env = root_env.Clone()

-# TODO(siggi) Remove this code once SCons plays well when the

-# Platform SDK 6.1 is installed with VS2005 but not VS2008.

-if root_env['PLATFORM'] in ['win32', 'cygwin']:

- windows_env['MSVS_VERSION'] = '8.0'

-windows_env.Tool('target_platform_windows')

-windows_env.Tool('component_targets_msvs') # Per target project support.

-# Hammer's target_platform_windows module added the stock SCons

-# MSVSProject() and MSVSSolution() Builders, which we're going to

-# replace with our newer, more flexible implementation. Wipe out the

-# older ones so they don't interfere with our initialization and so

-# SCons doesn't propagate them to cloned construction environments.

-del windows_env['BUILDERS']['MSVSProject']

-del windows_env['BUILDERS']['MSVSSolution']

-windows_env.Tool('MSVSNew')

-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'

-windows_env['MSVC_BATCH'] = True

-# 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'])['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'

-# If side-by-side platform sdk is not available try local copy.

-platform_sdk_path = '$CHROME_SRC_DIR/third_party/platformsdk_win2008_6_1/files'

-if (root_env['PLATFORM'] in ['win32', 'cygwin'] and

- not os.path.exists(windows_env.subst(platform_sdk_path))):

- platform_sdk_path = (

- msvs_drive + ':\\Program Files\\Microsoft SDKs\\Windows\\v6.1')

-windows_env.Replace(

- CSCRIPT = 'c:\\Windows\\System32\\cscript',

- PLATFORMSDK_6_1 = platform_sdk_path,

- 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'])

-# --------------------------------------------------------------------------

-# Platform-independent "msvs" mode for generating Visual Studio

-# project and solution files from any platform.

-DeclareBit('msvs', 'Generate Visual Studio files')

-msvs_env = windows_env.Clone()

-msvs_env.Tool('target_platform_windows')

-msvs_env.Tool('component_targets_msvs') # Per target project support.

-del msvs_env['BUILDERS']['MSVSProject']

-del msvs_env['BUILDERS']['MSVSSolution']

-msvs_env.Tool('MSVSNew')

-msvs_env.Tool('midl')

-environment_list.append(msvs_env)

-msvs_env.Replace(

- BUILD_TYPE = 'msvs',

- BUILD_TYPE_DESCRIPTION = 'Generate Visual Studio files',

- HOST_PLATFORMS = ['*'],

- ICU_LIBS = [],

-msvs_env.SetBits('windows', 'msvs')

-# TODO(sgk): turn into separate debug + release env adding

-# to a common .sln file

-msvs_env.Tool('target_debug')

-# --------------------------------------------------------------------------

-# Linux specific

-linux_env = root_env.Clone()

-linux_env.Tool('target_platform_linux')

-linux_env.Tool('yacc')

-# By default scons will depend on the first path element for any command line.

-# For example, it will resolve 'gcc' with $PATH and depend on that for any

-# action which runs gcc. This disables this behaviour:

-linux_env['IMPLICIT_COMMAND_DEPENDENCIES'] = False

-# 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]

- linux_env['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',

- 'CHROME_BUILD_TYPE', 'CHROMIUM_BUILD',

- '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

-if not root_env.get('_GYP'):

- linux_env.Append(

- BUILD_SCONSCRIPTS = [

- '$LIBEVENT_DIR/libevent${_GYP}.scons',

- ],

- )

-linux_env.Append(

- ASFLAGS = ['-32'],

- CCFLAGS = ['-m32', '-pthread', '-march=pentium4', '-fno-exceptions',

- # All floating-point computations on x87 happens in 80-bit precision.

- # Because the C and C++ language standards allow the compiler to keep the

- # floating-point values in higher precision than what's specified in the

- # source and doing so is more efficient than constantly rounding up to

- # 64-bit or 32-bit precision as specified in the source, the compiler,

- # especially in the optimized mode, tries very hard to keep values in x87

- # floating-point stack (in 80-bit precision) as long as possible. This has

- # important side effects, that the real value used in computation may

- # change depending on how the compiler did the optimization - that is, the

- # value kept in 80-bit is different than the value rounded down to 64-bit

- # or 32-bit. There are possible compiler options to make this behavior

- # consistent (e.g. -ffloat-store would keep all floating-values in the

- # memory, thus force them to be rounded to its original precision) but they

- # have significant runtime performance penalty.

- #

- # -mfpmath=sse -msse2 makes the compiler use SSE instructions which keep

- # floating-point values in SSE registers in its native precision (32-bit

- # for single precision, and 64-bit for double precision values). This means

- # the floating-point value used during computation does not change

- # depending on how the compiler optimized the code, since the value is

- # always kept in its specified precision.

- '-msse2', '-mfpmath=sse'],

- # GCC will generate ident directives with the GCC version. Accumulate

- # these all up and you end up with ~80K repeated in a .comment section.

- CCFLAGS_OPTIMIZED = ['-fno-ident'],

- 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 -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',

- '$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 an "official" build (DCHECKs completely compiled out, etc).

-if ARGUMENTS.get('OFFICIAL') == '1':

- linux_env.Append(CPPDEFINES=['OFFICIAL_BUILD'])

- # Make sure units of code and data go in their own section, and then GC them

- # in the linker to remove unreferenced data and code. Currently gold doesn't

- # support --gc-sections, so you'll have to build with the original GNU ld.

- linux_env.Append(CCFLAGS_OPTIMIZED=['-ffunction-sections', '-fdata-sections'])

- linux_env.Append(LINKFLAGS_OPTIMIZED=['-Wl,--gc-sections'])

-# 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 support for gprof when PROFILE=1.

-if ARGUMENTS.get('PROFILE') == '1':

- linux_env.Append(CCFLAGS=['-pg', '-g'])

- linux_env.Append(LINKFLAGS=['-pg'])

-# Build with symbols (useful for opt builds, for example) when SYMBOLS=1.

-if ARGUMENTS.get('SYMBOLS') == '1':

- linux_env.Append(CCFLAGS=['-g'])

-# Build shared libraries (useful for fast links) when SHARED=1.

-if ARGUMENTS.get('SHARED') == '1':

- linux_env.Replace(COMPONENT_STATIC=False)

-# 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)

- # TODO: Factor the code here into aits own function.

- 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)

- if root_env.WantSystemLib('sqlite'):

- try:

- linux_env.ParseConfig('pkg-config --cflags --libs sqlite')

- except OSError, e:

- print ('\n'

- 'sqlite 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(SHCCFLAGS = ['-fPIC'])

-mac_env.FilterOut(SHLINKFLAGS = ['-fPIC'])

-mac_env.FilterOut(

- BUILD_SCONSCRIPTS = [

- '$BREAKPAD_DIR/SConscript',

- '$BSDIFF_DIR/bsdiff.scons',

- '$BSPATCH_DIR/bspatch.scons',

- '$CHROME_DIR/chrome_main${_GYP}.scons',

- '$GOOGLE_UPDATE_DIR/SConscript',

- '$LIBJPEG_DIR/libjpeg.scons',

- '$LIBXML_DIR/libxml.scons',

- '$LIBXSLT_DIR/libxslt.scons',

- '$RLZ_DIR/SConscript',

- '$SANDBOX_DIR/sandbox.scons',

- '$WEBKIT_DIR/SConscript',

- 'build/SConscript.v8',

- ],

-# TODO(bradnelson): this is needed for now because target_platform_mac has

-# OS_MACOSX defined in a weird way.

-mac_env.FilterOut(CPPDEFINES = ['OS_MACOSX=OS_MACOSX'])

-if not root_env.WantSystemLib('libevent') and not root_env.get('_GYP'):

- mac_env.Append(

- BUILD_SCONSCRIPTS = [

- '$LIBEVENT_DIR/libevent${_GYP}.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'],

-# --------------------------------------------------------------------------

-# Platform-independent "xcode" mode for generating XCode files

-# from any platform.

-DeclareBit('xcode', 'Generate XCode files')

-# TODO(sgk): remove this after we update Hammer modules.

-DeclareBit('mac', 'Target platform is mac.')

-xcode_env = mac_env.Clone()

-# TODO(sgk): uncomment when xcode generation becomes real.

-#environment_list.append(xcode_env)

-xcode_env.Replace(

- BUILD_TYPE = 'xcode',

- BUILD_TYPE_DESCRIPTION = 'Generate XCode files',

- HOST_PLATFORMS = ['*'],

- ICU_LIBS = [],

-xcode_env.SetBits('mac', 'xcode')

-# TODO(sgk): turn into separate debug + release env adding

-# to a common .sln file

-xcode_env.Tool('target_debug')

-# -------------------------------------------------------------------------

-# 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')),

- SRC_DIR = str(env.Dir('$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

- GYP=1 Any non-null value uses GYP-generated files

- (*_gyp.scons).

-"""

-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))

-# -------------------------------------------------------------------------

-# Invoke all the SConscripts in each of the environments that make sense on

-# this host-platform.

-BuildComponents(environment_list)

-# -------------------------------------------------------------------------

-if not root_env.get('_GYP'):

- modes = GetTargetModes().keys()

- if set(modes) - set(['msvs', 'xcode']):

- # There's at least one mode being built besides the platform-

- # independent 'msvs' or 'xcode' modes. Build the current

- # build_component's Alias as default--that is, "base" when we're

- # in the base/ subdirectory, "chrome" under chrome/, etc.

- Import('build_component')

- Default(Alias(build_component)) # Set default target based on where built.

- if 'msvs' in modes:

- # We're in --mode=msvs, so add its Alias(es) to the default targets.

- Default(Alias('msvs'))

-# -------------------------------------------------------------------------

-# 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'),

-# -------------------------------------------------------------------------

« no previous file with comments | « breakpad/using_breakpad.scons ('k') | build/SConscript.v8 » ('j') | no next file with comments »