main.scons

# -*- Python -*-
#
#
# All the helper functions are defined in:
#  - site_scons/talk.py
# Use 'import talk' in any .scons file to get access to it.
# Add any new helper functions to it; unittest are available
# in talk_unittest.py.
#
# Each 'component' that is built is defined in a .scons file.
# See talk.Components(...) for further info on file naming convention.
#
# To add a new platform clone and modify the root_env object. Remember to add
# the new environment object to the envs list otherwise it will not be included
# in the build.
#
#
#

import talk
import os
import platform

#-------------------------------------------------------------------------------
# The build files/directories to 'build'.
# If the name is the name of a directory then that directory shall contain a
# .scons file with the same name as the directory itself:
#  Ex: The directory session/phone contains a file called phone.scons
# This list must be in order of library dependencies. e.g., if
# session/phone/phone.scons defines a target that links to a library target
# defined in sound/sound.scons, then 'sound' must come first.
# When no particular order is imposed by library dependencies, try to keep in
# mostly alphabetical order.
#
components = talk.Components("libjingle.scons")

#-------------------------------------------------------------------------------
# Build environments
#

# The list of build environments.
envs = []

# The root of all builds.
root_env = Environment(
  tools = [
    'component_bits',
    'component_setup',
    'replace_strings',
    'talk_noops',
    #'talk_utils',
  ],
  BUILD_SCONSCRIPTS = components,
  DESTINATION_ROOT = '$MAIN_DIR/build',
  CPPPATH = [
    '$OBJ_ROOT',     # generated headers are relative to here
    '$MAIN_DIR/..',  # TODO(dape): how can we use GOOGLECLIENT instead?
  ],
  CPPDEFINES = [
    'LOGGING=1',

    # Feature selection
    'FEATURE_ENABLE_SSL',
    'FEATURE_ENABLE_VOICEMAIL',
    'FEATURE_ENABLE_PSTN',
    'HAVE_SRTP',
  ],
  # Ensure the os environment is captured for any scripts we call out to
  ENV = os.environ,
)

# This is where we set common environments
#
# Detect if building on 64-bit or 32-bit platform.
DeclareBit('build_platform_64bit', 'Platform of the build machine is 64-bit')
if platform.architecture()[0] == "64bit":
  root_env.SetBits('build_platform_64bit')

# This bit denotes that an env is for 64-bit builds. When set, all build
# artifacts will be 64-bit. When unset, all build artifacts will be 32-bit.
DeclareBit('host_platform_64bit',
           'Platform of the host machine (where artifacts will execute) is '
               '64-bit')

# This bit denotes that we are cross-compiling using a sysroot.
DeclareBit('cross_compile',
           'Cross compiling using the SYSROOT environment variable')

def CrossArch(env):
  """Return whether or not the host platform architecture differs from the build
     environment architecture."""
  if env.Bit('cross_compile'):
    # The architecture of the Python process may not match the architecture of
    # the sysroot, so we just assume it's not a cross-arch build or that it
    # doesn't matter. Currently it only matters if you try to build a cross-arch
    # Debian package, so just don't do that.
    return False
  else:
    return env.Bit('host_platform_64bit') != env.Bit('build_platform_64bit')
root_env.AddMethod(CrossArch)

DeclareBit('use_static_openssl', 'Build OpenSSL as a static library')

DeclareBit('have_dbus_glib',
           'Whether the build system has the dbus-glib-1 package')
DeclareBit('have_libpulse',
           'Whether the build system has the libpulse package')


# List all the locales we localize to.
root_env.AppendUnique(locales = [
    'af', 'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en', 'en-GB',
    'es', 'es-419', 'et', 'eu', 'fa', 'fi', 'fil', 'fr', 'fr-CA', 'gl', 'gu',
    'hi', 'hr', 'hu', 'id', 'is', 'it', 'iw', 'ja', 'kn', 'ko', 'lt', 'lv',
    'ml', 'mr', 'ms', 'nl', 'no', 'or', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru',
    'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tl', 'tr', 'uk', 'ur',
    'vi', 'zh-CN', 'zh-HK', 'zh-TW', 'zu'])

AddTargetGroup('all_breakpads', 'breakpad files can be built')

AddTargetGroup('all_dsym', 'dsym debug packages can be built')

#-------------------------------------------------------------------------------
# W I N D O W S
#
win_env = root_env.Clone(
  tools = [
    'atlmfc_vc80',
    #'code_signing',
    'component_targets_msvs',
    'directx_9_0_c',
    #'grid_builder',
    'midl',
    'target_platform_windows'
  ],
  # Don't use default vc80 midl.exe.  It doesn't understand vista_sdk idl files.
  MIDL = '$PLATFORM_SDK_VISTA_6_0_DIR/Bin/midl.exe ',
  WIX_DIR = '$GOOGLECLIENT/third_party/wix/v3_0_2925/files',
  # Flags for debug and optimization are added to CCFLAGS instead
  CCPDBFLAGS = '',
  CCFLAGS_DEBUG = '',
  CCFLAGS_OPTIMIZED = '',
  # We force a x86 target even when building on x64 Windows platforms.
  TARGET_ARCH = 'x86',
)


win_env.Decider('MD5-timestamp')
win_env.Append(
  COMPONENT_LIBRARY_PUBLISH = True,  # Put dlls in output dir too
  CCFLAGS = [
    '/Fd${TARGET}.pdb', # pdb per object allows --jobs=
    '/WX',          # warnings are errors
    '/Zc:forScope', # handle 'for (int i = 0 ...)' right
    '/EHs-c-',      # disable C++ EH
    '/GR-',         # disable RTTI
    '/Gy',          # enable function level linking
    '/wd4996',      # ignore POSIX deprecated warnings

    # promote certain level 4 warnings
    '/w14701',     # potentially uninitialized var
    '/w14702',     # unreachable code
    '/w14706',     # assignment within a conditional
    '/w14709',     # comma operator within array index
    '/w14063',     # case 'identifier' is not a valid value for switch of enum
    '/w14064',     # switch of incomplete enum 'enumeration'
    '/w14057',     # 'identifier1' indirection to slightly different base
                   #   types from 'identifier2'
    '/w14263',     # member function does not override any base class virtual
                   #   member function
    '/w14266',     # no override available for virtual memberfunction from base
                   #  'type'; function is hidden
    '/w14296',     # expression is always false
    '/w14355',     # 'this' : used in base member initializer list
  ],
  CPPDEFINES = [
    '_ATL_CSTRING_EXPLICIT_CONSTRUCTORS',
    # TODO(dape): encapsulate all string operations that are not based
    # on std::string/std::wstring and make sure we use the safest versions
    # available on all platforms.
    '_CRT_SECURE_NO_WARNINGS',
    '_USE_32BIT_TIME_T',
    '_UNICODE',
    'UNICODE',
    '_HAS_EXCEPTIONS=0',
    'WIN32',
    # TODO(dape): remove this from logging.cc and enable here instead.
    #'WIN32_LEAN_AND_MEAN',

    'WINVER=0x0500',
    '_WIN32_WINNT=0x0501',
    '_WIN32_IE=0x0501',
    # The Vista platform SDK 6.0 needs at least
    # this NTDDI version or else the headers
    # that LMI includes from it won't compile.
    'NTDDI_VERSION=NTDDI_WINXP',

    # npapi.h requires the following:
    '_WINDOWS',
  ],
  CPPPATH = [
    '$THIRD_PARTY/wtl_71/include',
    '$PLATFORM_SDK_VISTA_6_0_DIR/Include',
  ],
  LIBPATH = [
    '$PLATFORM_SDK_VISTA_6_0_DIR/Lib'
  ],
  LINKFLAGS = [
    '-manifest', # TODO(thaloun): Why do we need this?
    # Some of the third-party libraries we link in don't have public symbols, so
    # ignore that linker warning.
    '/ignore:4221',
    '/nxcompat',    # Binary was tested to be be compatible with Windows DEP.
    '/dynamicbase', # Use ASLR to dynamically rebase at load-time.
    '/fixed:no',    # Binary can be loaded at any base-address.
  ],
  MIDLFLAGS = [
    '/win32',
    '/I$PLATFORM_SDK_VISTA_6_0_DIR/include'
  ]
)

# TODO(dape): Figure out what this does; found it in
# omaha/main.scons. This fixes the problem with redefinition
# of OS_WINDOWS symbol.
win_env.FilterOut(CPPDEFINES = ['OS_WINDOWS=OS_WINDOWS'])

# Set up digital signing
DeclareBit('test_signing', 'Sign binaries with the test certificate')
win_env.SetBitFromOption('test_signing', False)
if win_env.Bit('test_signing'):
   win_env.Replace(
     CERTIFICATE_PATH = win_env.File(
         '$GOOGLECLIENT/tools/test_key/testkey.pfx').abspath,
     CERTIFICATE_PASSWORD = 'test',
   )
AddTargetGroup('signed_binaries', 'digitally signed binaries can be built')

win_dbg_env = win_env.Clone(
  BUILD_TYPE = 'dbg',
  BUILD_TYPE_DESCRIPTION = 'Windows debug build',
  BUILD_GROUPS = ['default', 'all'],
  tools = ['target_debug'],
)

win_dbg_env.Prepend(
  CCFLAGS = [
    '/ZI',     # enable debugging
    '/Od',     # disable optimizations
    '/MTd',    # link with LIBCMTD.LIB debug lib
    '/RTC1',   # enable runtime checks
  ],
)

envs.append(win_dbg_env)

win_dbg64_env = win_dbg_env.Clone(
  BUILD_TYPE = 'dbg64',
  BUILD_TYPE_DESCRIPTION = 'Windows debug 64bit build',
  BUILD_GROUPS = ['all'],
)

win_dbg64_env.FilterOut(CCFLAGS = ['/ZI'])

win_dbg64_env.Append(
  CCFLAGS = [
    '/Zi',     # enable debugging that is 64 bit compatible.
    # TODO(fbarchard): fix warnings and remove these disables.
    '/wd4244', # disable cast warning
    '/wd4267', # disable cast warning
  ],
  ARFLAGS = [
    '/MACHINE:x64',
  ],
  CPPDEFINES = [
    'WIN64',
    'ARCH_CPU_64_BITS',
  ],
  LIBFLAGS = [
    '/MACHINE:x64',
  ],
  LINKFLAGS = [
    '/MACHINE:x64',
  ],
)

win_dbg64_env.FilterOut(CPPDEFINES = ['_USE_32BIT_TIME_T'])

win_dbg64_env.Prepend(
  LIBPATH = [
      '$VC80_DIR/vc/lib/amd64',
      '$ATLMFC_VC80_DIR/lib/amd64',
      '$PLATFORM_SDK_VISTA_6_0_DIR/Lib/x64',
  ],
)
win_dbg64_env.PrependENVPath(
  'PATH',
  win_dbg64_env.Dir('$VC80_DIR/vc/bin/x86_amd64'))

win_dbg64_env.SetBits('host_platform_64bit')

envs.append(win_dbg64_env)

win_coverage_env = win_dbg_env.Clone(
  tools = ['code_coverage'],
  BUILD_TYPE = 'coverage',
  BUILD_TYPE_DESCRIPTION = 'Windows code coverage build',
  BUILD_GROUPS = ['all'],
)

win_coverage_env.Append(
  CPPDEFINES = [
    'COVERAGE_ENABLED',
  ],
)

envs.append(win_coverage_env)

win_opt_env = win_env.Clone(
  BUILD_TYPE = 'opt',
  BUILD_TYPE_DESCRIPTION = 'Windows opt build',
  BUILD_GROUPS = ['all'],
  tools = ['target_optimized'],
)

win_opt_env.Prepend(
  CCFLAGS=[
      '/Zi',       # enable debugging
      '/O1',       # optimize for size
      '/fp:fast',  # float faster but less precise
      '/MT',       # link with LIBCMT.LIB (multi-threaded, static linked crt)
      '/GS',       # enable security checks
  ],
  LINKFLAGS = [
    '/safeseh',     # protect against attacks against exception handlers
    '/opt:ref',     # Remove unused references (functions/data).
  ],
)

envs.append(win_opt_env)

#-------------------------------------------------------------------------------
# P O S I X
#
posix_env = root_env.Clone()
posix_env.Append(
  CPPDEFINES = [
    'HASHNAMESPACE=__gnu_cxx',
    'HASH_NAMESPACE=__gnu_cxx',
    'POSIX',
    'DISABLE_DYNAMIC_CAST',
    # The POSIX standard says we have to define this.
    '_REENTRANT',
  ],
  CCFLAGS = [
    '-Wall',
    '-Werror',
    '-Wno-switch',
    '-fno-exceptions',
    # Needed for a clean ABI and for link-time dead-code removal to work
    # properly.
    '-fvisibility=hidden',
    # Generate debugging info in the DWARF2 format.
    '-gdwarf-2',
    # Generate maximal debugging information. (It is stripped from what we ship
    # to users, so we want it for both dbg and opt.)
    # Note that hammer automatically supplies "-g" for mac/linux dbg, so that
    # flag must be filtered out of linux_dbg and mac_dbg envs below.
    '-g3',
  ],
  CXXFLAGS = [
    '-Wno-non-virtual-dtor',
    '-Wno-ctor-dtor-privacy',
    '-fno-rtti',
  ],
)

# Switch-hit between NSS and OpenSSL
if 'NSS_BUILD_PLATFORM' in root_env['ENV']:
   posix_env.AppendUnique(CPPDEFINES=['HAVE_NSS_SSL_H=1',
                                      'NSS_SSL_RELATIVE_PATH'])
else:
   posix_env.AppendUnique(CPPDEFINES=['HAVE_OPENSSL_SSL_H=1'])


#-------------------------------------------------------------------------------
# M A C OSX
#
mac_env = posix_env.Clone(
  tools = [
    'target_platform_mac',
    #'talk_mac',
    #'fill_plist',
  ],
)
# Use static OpenSSL on mac so that we can use the latest APIs on all
# supported mac platforms (10.5+).
mac_env.SetBits('use_static_openssl')

# For libjingle we don't specify a sysroot or minimum OS version.
mac_osx_version_min_32 = ""
mac_osx_version_min_64 = ""

# Generic mac environment common to all targets
mac_env.Append(
  CPPDEFINES = [
    'OSX',
  ],
  CCFLAGS = [
    '-arch', 'i386',
    '-fasm-blocks',
  ],
  LINKFLAGS = [
    '-Wl,-search_paths_first',
    # This flag makes all members of a static library be included in the
    # final exe - that increases the size of the exe, but without it
    # Obj-C categories aren't properly included in the exe.
    # TODO(thaloun): consider only defining for libs that actually have objc.
    '-ObjC',
    '-arch', 'i386',
    '-dead_strip',
  ],
  FRAMEWORKS = [
    'CoreServices',
    'Security',
    'SystemConfiguration',
    'OpenGL',
    'CoreAudio',
    'Quartz',
    'Cocoa',
    'QTKit',
  ]
)

if 'NSS_BUILD_PLATFORM' in root_env['ENV']:
  mac_env.AppendUnique(LINKFLAGS = ['-Lthird_party/mozilla/dist/' + root_env['ENV']['NSS_BUILD_PLATFORM'] + '/lib'])
else:
  mac_env.AppendUnique(LINKFLAGS = ['-Lthird_party/openssl'])


# add debug flags to environment
def mac_debug_include(env):
  env.Append(
    CCFLAGS = [
      '-O0',
    ],
    CPPDEFINES = [
      'DEBUG=1',
    ],
  )
  # Remove -g set by hammer, which is not what we want (we have set -g3 above).
  env.FilterOut(CCFLAGS = ['-g'])

# add 32/64 bit specific options to specified environment
def mac_common_include_x86_32(env):
  env.Append(
    CCFLAGS = [
      '-m32',
    ],
    LINKFLAGS = [
      '-m32',
    ],
    FRAMEWORKS = [
      'Carbon',
      'QuickTime',
    ],
  )
  envs.append(env)

def mac_common_include_x86_64(env):
  env.Append(
    CCFLAGS = [
      '-m64',
      '-fPIC',
    ],
    CPPDEFINES = [
      'ARCH_CPU_64_BITS',
      'CARBON_DEPRECATED',
    ],
    LINKFLAGS = [
      '-m64',
    ],
    FRAMEWORKS = [
      'AppKit',
    ],
  )
  env.SetBits('host_platform_64bit')
  envs.append(env)

def mac_osx_version_min(env, ver):
  if ver != "":
    sdk_path = '/Developer/SDKs/MacOSX%s.sdk' % ver
    env.Append(
      CCFLAGS = [
        '-mmacosx-version-min=' + ver,
        '-isysroot', sdk_path,
      ],
      LINKFLAGS = [
        '-mmacosx-version-min=' + ver,
        '-isysroot', sdk_path,
      ],
      osx_sdk_path = sdk_path,
      osx_version_min = ver,
    )

# Create all environments
mac_dbg_env = mac_env.Clone(
  BUILD_TYPE = 'dbg',
  BUILD_TYPE_DESCRIPTION = 'Mac debug build',
  BUILD_GROUPS = ['default', 'all'],
  tools = ['target_debug'],
)

mac_opt_env = mac_env.Clone(
  BUILD_TYPE = 'opt',
  BUILD_TYPE_DESCRIPTION = 'Mac opt build',
  BUILD_GROUPS = ['all'],
  tools = ['target_optimized'],
)

mac_dbg64_env = mac_dbg_env.Clone(
  BUILD_TYPE = 'dbg64',
  BUILD_TYPE_DESCRIPTION = 'Mac debug 64bit build',
  BUILD_GROUPS = ['all'],
)

mac_opt64_env = mac_opt_env.Clone(
  BUILD_TYPE = 'opt64',
  BUILD_TYPE_DESCRIPTION = 'Mac opt 64bit build',
  BUILD_GROUPS = ['all'],
)

mac_debug_include(mac_dbg_env)
mac_debug_include(mac_dbg64_env)
mac_common_include_x86_32(mac_dbg_env)
mac_common_include_x86_32(mac_opt_env)
mac_common_include_x86_64(mac_dbg64_env)
mac_common_include_x86_64(mac_opt64_env)
mac_osx_version_min(mac_dbg_env, mac_osx_version_min_32)
mac_osx_version_min(mac_opt_env, mac_osx_version_min_32)
mac_osx_version_min(mac_dbg64_env, mac_osx_version_min_64)
mac_osx_version_min(mac_opt64_env, mac_osx_version_min_64)


#-------------------------------------------------------------------------------
# L I N U X
#
linux_common_env = posix_env.Clone(
  tools = [
    'target_platform_linux',
    'talk_linux',
  ],
)

linux_common_env.Append(
  CPPDEFINES = [
    'LINUX',
  ],
  CCFLAGS = [
    # Needed for link-time dead-code removal to work properly.
    '-ffunction-sections',
    '-fdata-sections',
  ],
  LINKFLAGS = [
    # Enable dead-code removal.
    '-Wl,--gc-sections',
    # Elide dependencies on shared libraries that we're not actually using.
    '-Wl,--as-needed',
    '-Wl,--start-group',
  ],
  _LIBFLAGS = ['-Wl,--end-group'],
)

# Remove default rpath set by Hammer. Hammer sets it to LIB_DIR, which is wrong.
# The rpath is the _run-time_ library search path for the resulting binary, i.e.
# the one used by ld.so at load time. Setting it equal to the path to build
# output on the build machine is nonsense.
linux_common_env.Replace(
  RPATH = [],
)

# Enable the optional DBus-GLib code if the build machine has the required
# dependency.
linux_common_env.EnableFeatureWherePackagePresent('have_dbus_glib',
                                                  'HAVE_DBUS_GLIB',
                                                  'dbus-glib-1')

def linux_common_include_x86_32(env):
  """Include x86-32 settings into an env based on linux_common."""
  env.Append(
    CCFLAGS = [
      '-m32',
    ],
    LINKFLAGS = [
      '-m32',
    ],
  )

def linux_common_include_x86_64(env):
  """Include x86-64 settings into an env based on linux_common."""
  env.Append(
    CCFLAGS = [
      '-m64',
      '-fPIC',
    ],
    LINKFLAGS = [
      '-m64',
    ],
  )
  env.SetBits('host_platform_64bit')

#-------------------------------------------------------------------------------
# L I N U X -- C R O S S -- B U I L D

# Cross build requires the following tool names be provided by the environment:
linux_cross_common_env = linux_common_env.Clone(
  AR = os.environ.get("AR"),
  AS = os.environ.get("AS"),
  LD = os.environ.get("LD"),
  NM = os.environ.get("NM"),
  RANLIB = os.environ.get("RANLIB"),
  CC = str(os.environ.get("CC")) +
    ' --sysroot=' + str(os.environ.get("SYSROOT")),
  CXX = str(os.environ.get("CXX")) +
    ' --sysroot=' + str(os.environ.get("SYSROOT")),
)
linux_cross_common_env.SetBits('cross_compile')

# The rest of these paths and flags are optional:
if os.environ.get("CPPPATH"):
  linux_cross_common_env.Append(
    CPPPATH = os.environ.get("CPPPATH").split(':'),
  )
if os.environ.get("LIBPATH"):
  linux_cross_common_env.Append(
    LIBPATH = os.environ.get("LIBPATH").split(':'),
  )
if os.environ.get("CFLAGS"):
  linux_cross_common_env.Append(
    CFLAGS = os.environ.get("CFLAGS").split(' '),
  )
if os.environ.get("CCFLAGS"):
  linux_cross_common_env.Append(
    CCFLAGS = os.environ.get("CCFLAGS").split(' '),
  )
if os.environ.get("CXXFLAGS"):
  linux_cross_common_env.Append(
    CXXFLAGS = os.environ.get("CXXFLAGS").split(' '),
  )
if os.environ.get("LIBFLAGS"):
  linux_cross_common_env.Append(
    _LIBFLAGS = os.environ.get("LIBFLAGS").split(' '),
  )
if os.environ.get("LINKFLAGS"):
  linux_cross_common_env.Prepend(
    LINKFLAGS = os.environ.get("LINKFLAGS").split(' '),
  )

#-------------------------------------------------------------------------------
# L I N U X -- T R A D I T I O N A L -- X 8 6
#
# Settings that are specific to our desktop Linux x86 targets.
def linux_common_include_traditional(env):
  """Include traditional Linux settings into an env based on linux_common."""
  # OpenSSL has infamously poor ABI stability, so that building against one
  # version and running against a different one often will not work. Since our
  # non-ChromeOS Linux builds are used on many different distros and distro
  # versions, this means we can't safely dynamically link to OpenSSL because the
  # product would end up being broken on any computer with a different version
  # installed. So instead we build it ourself and statically link to it.
  env.SetBits('use_static_openssl')
  # Enable the optional PulseAudio code if the build machine has the required
  # dependency.
  # TODO(?): This belongs in linux_common_env, but we can't safely move it there
  # yet because pkg-config is not being used properly with ChromeOS builds (see
  # TODO below).
  env.EnableFeatureWherePackagePresent('have_libpulse',
                                       'HAVE_LIBPULSE',
                                       'libpulse')

def linux_traditional_include_dbg(env):
  """Include traditional Linux dbg settings into an env based on the above."""
  # Remove -g set by hammer, which is not what we want (we have set -g3 above).
  env.FilterOut(CCFLAGS = ['-g'])

def linux_traditional_include_opt(env):
  """Include traditional Linux opt settings into an env based on the above."""
  # Remove -O2 set by hammer, which is not what we want.
  env.FilterOut(CCFLAGS = ['-O2'])
  env.Append(CCFLAGS = ['-Os'])

def gen_linux_nonhermetic(linux_env, type_suffix, desc_suffix):
  groups = ['nonhermetic']
  if not linux_env.CrossArch():
    groups = groups + ['nonhermetic-native']
    # The non-hermetic, native-arch dbg build is the default.
    dbg_groups = groups + ['default']
    native_desc = ', native '
    # No suffix for native modes.
    type_suffix = ''
  else:
    groups = groups + ['nonhermetic-cross']
    dbg_groups = groups
    native_desc = ', cross-built for '

  linux_dbg_env = linux_env.Clone(
    BUILD_TYPE = 'dbg' + type_suffix,
    BUILD_TYPE_DESCRIPTION = 'Linux debug build%s%s' % (native_desc,
        desc_suffix),
    BUILD_GROUPS = dbg_groups,
    tools = ['target_debug'],
  )
  linux_traditional_include_dbg(linux_dbg_env)
  envs.append(linux_dbg_env)

  linux_opt_env = linux_env.Clone(
    BUILD_TYPE = 'opt' + type_suffix,
    BUILD_TYPE_DESCRIPTION = 'Linux optimized build%s%s' % (native_desc,
        desc_suffix),
    BUILD_GROUPS = groups,
    tools = ['target_optimized'],
  )
  linux_traditional_include_opt(linux_opt_env)
  envs.append(linux_opt_env)

linux_nonhermetic_common_env = linux_common_env.Clone()
linux_common_include_traditional(linux_nonhermetic_common_env)

linux_nonhermetic_x86_32_env = linux_nonhermetic_common_env.Clone()
linux_common_include_x86_32(linux_nonhermetic_x86_32_env)
gen_linux_nonhermetic(linux_nonhermetic_x86_32_env, '32', '32-bit')

linux_nonhermetic_x86_64_env = linux_nonhermetic_common_env.Clone()
linux_common_include_x86_64(linux_nonhermetic_x86_64_env)
gen_linux_nonhermetic(linux_nonhermetic_x86_64_env, '64', '64-bit')

def gen_linux_hermetic(linux_env, type_suffix, desc):
  groups = ['hermetic']

  linux_dbg_env = linux_env.Clone(
    BUILD_TYPE = 'hermetic-dbg' + type_suffix,
    BUILD_TYPE_DESCRIPTION = 'Hermetic %s Linux debug build' % desc,
    BUILD_GROUPS = groups,
    tools = ['target_debug'],
  )
  linux_traditional_include_dbg(linux_dbg_env)
  envs.append(linux_dbg_env)

  linux_opt_env = linux_env.Clone(
    BUILD_TYPE = 'hermetic-opt' + type_suffix,
    BUILD_TYPE_DESCRIPTION = 'Hermetic %s Linux optimized build' % desc,
    BUILD_GROUPS = groups,
    tools = ['target_optimized'],
  )
  linux_traditional_include_opt(linux_opt_env)
  envs.append(linux_opt_env)

linux_hermetic_common_env = linux_cross_common_env.Clone()
linux_common_include_traditional(linux_hermetic_common_env)

linux_hermetic_x86_32_env = linux_hermetic_common_env.Clone()
linux_common_include_x86_32(linux_hermetic_x86_32_env)
gen_linux_hermetic(linux_hermetic_x86_32_env, '32', '32-bit')

linux_hermetic_x86_64_env = linux_hermetic_common_env.Clone()
linux_common_include_x86_64(linux_hermetic_x86_64_env)
gen_linux_hermetic(linux_hermetic_x86_64_env, '64', '64-bit')

#-------------------------------------------------------------------------------
# L I N U X -- C R O S S -- B U I L D -- A R M

# TODO(noahric): All the following Linux builds are running against a sysroot
# but improperly using the host machine's pkg-config environment. The ChromeOS
# ones should probably be using
# https://cs.corp.google.com/#chrome/src/build/linux/pkg-config-wrapper.

linux_cross_arm_env = linux_cross_common_env.Clone()
linux_cross_arm_env.Append(
  CPPDEFINES = [
    'NACL_BUILD_ARCH=arm',
    'DISABLE_EFFECTS=1',
  ],
  CCFLAGS = [
    '-fPIC',
  ],
)
DeclareBit('arm', 'ARM build')
linux_cross_arm_env.SetBits('arm')

# Detect NEON support from the -mfpu build flag.
DeclareBit('arm_neon', 'ARM supporting neon')
if '-mfpu=neon' in linux_cross_arm_env['CFLAGS'] or \
   '-mfpu=neon' in linux_cross_arm_env['CCFLAGS'] or \
   '-mfpu=neon' in linux_cross_arm_env['CXXFLAGS']:
  print "Building with ARM NEON support."
  linux_cross_arm_env.SetBits('arm_neon')

# Detect hardfp from the -mfloat-abi build flag
DeclareBit('arm_hardfp', 'ARM supporting hardfp')
if '-mfloat-abi=hard' in linux_cross_arm_env['CFLAGS'] or \
   '-mfloat-abi=hard' in linux_cross_arm_env['CCFLAGS'] or \
   '-mfloat-abi=hard' in linux_cross_arm_env['CXXFLAGS']:
  print "Building with hard floating point support."
  linux_cross_arm_env.SetBits('arm_hardfp')

linux_cross_arm_dbg_env = linux_cross_arm_env.Clone(
  BUILD_TYPE = 'arm-dbg',
  BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM debug build',
  BUILD_GROUPS = ['arm'],
  tools = ['target_debug'],
)
envs.append(linux_cross_arm_dbg_env)

linux_cross_arm_opt_env = linux_cross_arm_env.Clone(
  BUILD_TYPE = 'arm-opt',
  BUILD_TYPE_DESCRIPTION = 'Cross-compiled ARM optimized build',
  BUILD_GROUPS = ['arm'],
  tools = ['target_optimized'],
)
envs.append(linux_cross_arm_opt_env)



# Create a group for installers
AddTargetGroup('all_installers', 'installers that can be built')

# Parse child .scons files
BuildEnvironments(envs)

# Explicitly set which targets to build when not stated on commandline
Default(None)
# Build the following, which excludes unit test output (ie running them)
# To run unittests, specify the test to run, or run_all_tests.  See -h option.
Default(['all_libraries', 'all_programs', 'all_test_programs'])

# .sln creation code lifted from googleclient/bar/main.scons.  Must be after
# the call to BuildEnvironments for all_foo aliases to be defined.
# Run 'hammer --mode=all --vsproj' to generate
DeclareBit('vsproj', 'Generate Visual Studio projects and solution files.')
win_env.SetBitFromOption('vsproj', False)

if win_env.Bit('vsproj'):
  vs_env = win_env.Clone()
  vs_env.Append(
    COMPONENT_VS_SOURCE_SUFFIXES = [
      '.def',
      '.grd',
      '.html',
      '.idl',
      '.mk',
      '.txt',
      '.py',
      '.scons',
      '.wxs.template',
    ]
  )

  # Source project
  p = vs_env.ComponentVSDirProject(
    'flute_source',
    ['$MAIN_DIR',
    ],
    COMPONENT_VS_SOURCE_FOLDERS = [
      # Files are assigned to first matching folder. Folder names of None
      # are filters.
      (None, '$DESTINATION_ROOT'),
      ('flute', '$MAIN_DIR'),
      ('google3', '$GOOGLE3'),
      ('third_party', '$THIRD_PARTY'),
    ],
    # Force source project to main dir, so that Visual Studio can find the
    # source files corresponding to build errors.
    COMPONENT_VS_PROJECT_DIR = '$MAIN_DIR',
  )
  vs_env.AlwaysBuild(p)

  # Solution and target projects
  s = vs_env.ComponentVSSolution(
    # 'libjingle',  # Please uncomment this line if you build VS proj files.
    ['all_libraries', 'all_programs', 'all_test_programs'],
    projects = [p],
  )

  print '***Unfortunately the vsproj creator isn\'t smart enough to '
  print '***automatically get the correct output locations.  It is very easy'
  print '***though to change it in the properties pane to the following'
  print '***$(SolutionDir)/build/<foo>/staging/<bar>.exe'
  Default(None)
  Default([s])