# Copyright (c) 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.

# Notes:
# This assumes you have a working gears checkout from p4 in the current dir.
# Steps for this:
# > echo %USER%-chromegears > p4config
# > set P4CONFIG=p4config
# > g4 client -p //depot/googleclient/gears/p4_depot_paths
# > g4 sync
#
# This is a work-in-progress conversion of the current Gears set of Makefiles.
# A lot of the stuff doesn't translate to SCons-land well, and I'm not sure
# how faithful we want to be to the original.
#
# Questions:
# Should we flatten the output directory into
# Hammer/gears/platform/browser/*.obj like Gears does now?  If so, how?

# Notes to self:
# - os.path.abspath('.') (the CWD) is variant_dir if it exists, else it's the
# toplevel_dir (which contains the SConstruct).
# - env.Entry('.') is the entry representing the variant_dir.
# - env.Entry('#') is the entry representing the toplevel_dir.
# - str(entry) gives the path relative to variant_dir, or abspath if the entry
# is outside the variant_dir.
# - entry.path gives the path relative to toplevel_dir.
# - entry.abspath gives the absolute path.

import os

Import('env')

env = env.Clone(
    OPEN_DIR = "googleclient/gears/opensource/gears",
    THIRD_PARTY_DIR = "googleclient/gears/opensource/third_party",
    PRIVATE_THIRD_PARTY_DIR = "googleclient/third_party",
)

if not os.path.exists(env.Dir('#/$OPEN_DIR').abspath):
  print 'Skipping Gears build: no perforce tree checked out.'
  Return()

# Argument switches

# TODO: how do we detect linux vs osx?
os_guess = env['PLATFORM']
if os_guess == 'posix':
  os_guess = 'linux'
elif os_guess == 'darwin':
  os_guess = 'osx'

# Map of OS -> valid browser targets for that OS.
os_browsers_map = {
    'win32': ['IE', 'FF2', 'FF3', 'NPAPI'],
    'wince': ['IE'],
    'linux': ['FF2', 'FF3'],
    'osx': ['SF'],
    'android': ['NPAPI'],
}

vars = Variables(None, ARGUMENTS)
vars.AddVariables(
    EnumVariable('OS',
        'Which OS is the target', os_guess, os_browsers_map.keys()),
    EnumVariable('MODE',
        'Type of binary to generate', 'dbg', ['dbg', 'opt']),
    BoolVariable('OFFICIAL_BUILD',
        'Create a binary suitable for public release', 0)
)
vars.Update(env)

env['VALID_BROWSERS'] = os_browsers_map[env['OS']]

# Add BROWSER last, since its valid inputs depend on $OS.
vars.Add(
    EnumVariable('BROWSER',
        'Which browser we want to build the plugin for.  "all" builds all '
        'browsers for this OS.',
        'all', env['VALID_BROWSERS'] + ['all']))
vars.Update(env)

env.Replace(
    USING_CCTESTS = (env['MODE'] == 'dbg' or not env['OFFICIAL_BUILD'])
)

# Version
env.Replace(
    MAJOR = '0',
    MINOR = '4',
    BUILD = '23',
    PATCH = '0',
    VERSION = '${MAJOR}.${MINOR}.${BUILD}.${PATCH}',

    FRIENDLY_NAME = 'Google Gears',
    SHORT_NAME = 'gears',
)

# Platform
# TODO: OSX and Symbian builds will override this value.
# For other platforms we set just one value.
if env['OS'] in ['wince', 'android']:
  env.Replace(ARCH = 'arm')
elif env['OS'] == 'osx':
  # On OSX we build a fat binary.
  env.Replace(ARCH = 'i386+ppc')
else:
  env.Replace(ARCH = 'i386')

# Output dirs
env.Replace(
    BASE_OUTDIR = '$GEARS_DIR/$OS-$ARCH-$MODE',
    COMMON_OUTDIR = '$BASE_OUTDIR/common',
    BROWSER_OUTDIR = '$BASE_OUTDIR/${BROWSER.lower()}',
    IE_OUTDIR = '$BASE_OUTDIR/ie',
    FF2_OUTDIR = '$BASE_OUTDIR/ff2',
    FF3_OUTDIR = '$BASE_OUTDIR/ff3',
    NPAPI_OUTDIR = '$BASE_OUTDIR/npapi',
    SF_OUTDIR = '$BASE_OUTDIR/sf',

    GENFILES_DIR = "$BROWSER_OUTDIR/genfiles",
    COMMON_GENFILES_DIR = "$COMMON_OUTDIR/genfiles",
)

# Add our tools to the PATH.
paths = []
if env['OS'] in ['win32', 'wince']:
  # Clear out our environment so we don't accidentally use the system's libs.
  env['ENV']['PATH'] = ''
  env['ENV']['LIB'] = ''
  env['ENV']['INCLUDE'] = ''

  # Keep system32 for 'xcopy'.
  paths += [env.subst('${ENV["SYSTEMROOT"]}/system32')]
  if env['OS'] == 'win32':
    env.Append(
        VC80 = env.Dir('#/$PRIVATE_THIRD_PARTY_DIR/vc_80/files').abspath)
    paths += [
        env.subst('$VC80/common7/ide'),
        env.subst('$VC80/vc/bin'),
        env.subst('$VC80/common7/tools'),
        env.subst('$VC80/common7/tools/bin'),
        env.subst('$VC80/team_tools/performance_tools'),
    ]
  else:  # wince
    env.Append(
        VC80 = env.Dir('#/$PRIVATE_THIRD_PARTY_DIR/vc_80ce/files').abspath)
    paths += [
        env.subst('$VC80/bin/x86_arm'),
        env.subst('$VC80/common7/ide'),
        env.subst('$VC80/common7/tools'),
        env.subst('$VC80/common7/tools/bin'),
        env.subst('$VC80/vc/bin'),
        env.subst('$VC80/smartdevices/sdktools'),
    ]

  paths += [env.Dir('#/$PRIVATE_THIRD_PARTY_DIR/wix/v3_0_2925/files').abspath]

paths += [env.Dir('#/$PRIVATE_THIRD_PARTY_DIR/gnu/files').abspath]
paths += [env.Dir('#/$PRIVATE_THIRD_PARTY_DIR/python_24').abspath]

# Prepend them so our tools come first.
for each in reversed(paths):
  env.PrependENVPath('PATH', each)

# Building M4 files
env.Tool('m4')

env.Append(
    M4ARCH = (env['ARCH'] == 'i386' and 'x86' or '$ARCH'),
    M4FLAGS = [
        '--prefix-builtins',
        '-DPRODUCT_VERSION=$VERSION',
        '-DPRODUCT_VERSION_MAJOR=$MAJOR',
        '-DPRODUCT_VERSION_MINOR=$MINOR',
        '-DPRODUCT_VERSION_BUILD=$BUILD',
        '-DPRODUCT_VERSION_PATCH=$PATCH',
        '-DPRODUCT_OS=$OS',
        '-DPRODUCT_ARCH="$M4ARCH"',
        '-DPRODUCT_GCC_VERSION="gcc3"',
        '-DPRODUCT_MAINTAINER="google"',
        '-DPRODUCT_FRIENDLY_NAME_UQ="$FRIENDLY_NAME"',
        '-DPRODUCT_SHORT_NAME_UQ="$SHORT_NAME"',
        '-DI18N_LANGUAGES="(${",".join(I18N_LANGS)})"',
    ],
    M4PATH = [
        '$OPEN_DIR',
        '.',
    ],
)

# SCons magic to make M4PATH work.
env.Replace(
    M4INCPREFIX = '-I',
    M4INCSUFFIX = '',
    _M4INCFLAGS = ('${_concat(M4INCPREFIX, M4PATH, M4INCSUFFIX, '
                 '__env__, RDirs, TARGET, SOURCE)}'),
    M4COM = '$M4 $M4FLAGS ${_M4INCFLAGS} $SOURCE > $TARGET',
)

# TODO: Dependency scanner for m4 files - doesn't work.  It can't detect files
# that don't exist!
#m4_include_re = re.compile(r'm4_include\((.*)\)', re.M)
#def m4_scan(node, env, path):
#  contents = node.get_contents()
#  includes = m4_include_re.findall(contents)
#  ret_includes = []
#  for include in includes:
#    for dir in path:
#      file = os.path.join(dir, include)
#      if os.path.exists(file):
#        ret_includes.append(file)
#        break
#  return ret_includes
#
#m4_scanner = Scanner(function = m4_scan, skeys = ['.m4', '.html_m4'])
#env.Append(SCANNERS = m4_scanner)


# C++ build flags.

# Clear out the inherited defines from Chrome's build.  I want to match Gears'
# current build as closely as possible until we switch everyone to SCons, then
# gradually integrate.
env.Replace(
    CPPPATH = [
        '$OPEN_DIR',
        '$OPEN_DIR/..',
        '$THIRD_PARTY_DIR',
	'$THIRD_PARTY_DIR/breakpad/src',
        '$THIRD_PARTY_DIR/googleurl',
        '$THIRD_PARTY_DIR/npapi',
        '$THIRD_PARTY_DIR/zlib',
        '$THIRD_PARTY_DIR/v8/bindings_local',
        '.',
        '$COMMON_OUTDIR',
    ],
    LIBPATH = [
        '$LIBS_DIR',
    ],
    CCFLAGS = [],
    CPPDEFINES = [],
    LIBS = [],
    LINKFLAGS = [],
)

if env['MODE'] == 'dbg':
  env.Append(
      CPPDEFINES = [
          'DEBUG=1',
          '_DEBUG=1',
      ],
      M4FLAGS = '-DDEBUG=1',
  )
else:
  env.Append(
      CPPDEFINES = 'NDEBUG=1',
      M4FLAGS = '-DNDEBUG=1',
  )
if env['USING_CCTESTS']:
  env.Append(
      CPPDEFINES = 'USING_CCTESTS=1',
      M4FLAGS = '-DUSING_CCTESTS=1',
  )
if env['OFFICIAL_BUILD']:
  env.Append(
      CPPDEFINES = 'OFFICIAL_BUILD=1',
      M4FLAGS = '-DOFFICIAL_BUILD=1',
  )

# TODO: if USING_PNG
env.Append(CPPDEFINES = 'PNG_USER_CONFIG')
# TODO: if USING_ZLIB
env.Append(
    CPPDEFINES = [
        'NO_GZIP',
        'NO_GZCOMPRESS',
    ]
)
if env['OS'] == 'wince':
  env.Append(CPPDEFINES = 'NO_ERRNO_H')

# Languages

env['I18N_LANGS'] = [
    'en-US',
    'ar',
    'bg',
    'ca',
    'cs',
    'da',
    'de',
    'el',
    'en-GB',
    'es',
    'et',
    'fa',
    'fi',
    'fil',
    'fr',
    'he',
    'hi',
    'hr',
    'hu',
    'id',
    'is',
    'it',
    'ja',
    'ko',
    'lt',
    'lv',
    'ms',
    'nl',
    'no',
    'pl',
    'pt-BR',
    'pt-PT',
    'ro',
    'ru',
    'sk',
    'sl',
    'sr',
    'sv',
    'th',
    'tr',
    'uk',
    'ur',
    'vi',
    'zh-CN',
    'zh-TW',
    'ml',
    'te',
    'gu',
    'kn',
    'or',
    'bn',
    'ta',
    'mr',
]

# Platform-specific flags follow.

if env['OS'] in ['win32', 'wince']:
  env.Append(
      CPPDEFINES = [
          'STRICT',
          '_UNICODE',
          'UNICODE',
          '_USRDLL',
          'WIN32',
          '_WINDLL',
          '_CRT_SECURE_NO_DEPRECATE',
          'NOMINMAX',

# In VC8, the way to disable exceptions is to remove all /EH* flags, and to
# define _HAS_EXCEPTIONS=0 (for C++ headers) and _ATL_NO_EXCEPTIONS (for ATL).
          '_HAS_EXCEPTIONS=0',
          '_ATL_NO_EXCEPTIONS',
# Do not export UTF functions.
          'U_STATIC_IMPLEMENTATION',
      ],
      LINKFLAGS = [
          '/NOLOGO',
          '/DEBUG',
          '/RELEASE',

          '/PDB:${TARGET.base}.pdb',
# Set the preferred base address.  This value was chosen because (a) it's near
# the top of the valid address range, and (b) it doesn't conflict with other
# DLLs loaded by Chrome in either the browser or plugin process.
          '/BASE:0x65000000',
      ],
      CPPFLAGS = [
          '/nologo',
          '/Zi',  # TODO: Chrome defines /Z7, no idea what these are.
          '/Zc:wchar_t-',
          '/c',
          '/W3',
          '/WX',
          '/GR-',
      ],
      CXXFLAGS = [
          '/TP',
          '/J',
      ],
      CPPPATH = [
          '$VC80_CPPPATH',
      ],
      LIBPATH = [
          '$VC80_LIBPATH',
      ],
  )
  if env['OS'] == 'win32':
    env.Append(
        CPPDEFINES = [
# We require APPVER=5.0 for things like HWND_MESSAGE.
# When APPVER=5.0, win32.mak in the Platform SDK sets:
#   C defines:  WINVER=0x0500
#               _WIN32_WINNT=0x0500
#               _WIN32_IE=0x0500
#               _RICHEDIT_VER=0x0010
#   RC defines: WINVER=0x0500
#   MIDL flags: /target NT50
# Note: _WIN32_WINDOWS was replaced by _WIN32_WINNT for post-Win95 builds.
# Note: XP_WIN is only used by Firefox headers
            '_WINDOWS',
            'WINVER=0x0500',
            '_WIN32_WINNT=0x0500',
            '_WIN32_IE=0x0500',
            '_RICHEDIT_VER=0x0010',
            '_MERGE_PROXYSTUB',
            'BREAKPAD_AVOID_STREAMS',
            'XP_WIN',
        ],
        LINKFLAGS = [
            '/MACHINE:X86',
            '/NODEFAULTLIB:msvcrt',
# Flags for security hardening (only available for win32, not wince).
            '/DYNAMICBASE',
            '/SAFESEH',

# We only use /SUBSYSTEM on DLLs. For EXEs we omit the flag, and
# the presence of main() or WinMain() determines the subsystem.
            '/SUBSYSTEM:WINDOWS',
        ],
        VC80_CPPPATH = [
# TODO: switch over to Chrome's SDK.
# Note: these must come after $THIRD_PARTY_DIR/npapi because we want our own
# npapi.h to take precedence.
            '$PRIVATE_THIRD_PARTY_DIR/atlmfc_vc80/files/include',
            '$PRIVATE_THIRD_PARTY_DIR/platformsdk_vc80/files/include',
            '$PRIVATE_THIRD_PARTY_DIR/vc_80/files/include',
        ],
        VC80_LIBPATH = [
            '$PRIVATE_THIRD_PARTY_DIR/atlmfc_vc80/files/lib',
            '$PRIVATE_THIRD_PARTY_DIR/platformsdk_vc80/files/lib',
            '$PRIVATE_THIRD_PARTY_DIR/vc_80/files/vc/lib',
        ],
    )
  else:  # OS=wince
    env.Append(
        CPPDEFINES = [
# For Windows Mobile we need:
#   C defines:  _WIN32_WCE=0x0501
#               _UNDER_CE=0x0501
            '_WIN32_WCE=0x501',
            'WINVER=_WIN32_WCE',
            'UNDER_CE=0x501',
            'WINCE',
            'WIN32_PLATFORM_PSPC',
            'ARM',
            '_ARM_',
            'POCKETPC2003_UI_MODEL',
            '_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA',
            '_CE_CRT_ALLOW_WIN_MINMAX',
        ],
        LINKFLAGS = [
            '/MACHINE:THUMB',
            '/NODEFAULTLIB:secchk.lib',
            '/NODEFAULTLIB:oldnames.lib',
            '/SUBSYSTEM:WINDOWSCE,5.01',
        ],
        VC80_CPPPATH = [
            '$PRIVATE_THIRD_PARTY_DIR/atlmfc_vc80ce/files/include',
            '$PRIVATE_THIRD_PARTY_DIR/vc_80ce/files/include',
# Visual Studio must be setup before the PocketPC SDK.
            '$PRIVATE_THIRD_PARTY_DIR/pocketpc_sdk_ce_50/files/include/armv4i',
        ],
        VC80_LIBPATH = [
            '$PRIVATE_THIRD_PARTY_DIR/atlmfc_vc80ce/files/lib/armv4i',
            '$PRIVATE_THIRD_PARTY_DIR/vc_80ce/files/lib/armv4i',
            '$PRIVATE_THIRD_PARTY_DIR/pocketpc_sdk_ce_50/files/lib/armv4i',
        ],
    )

  if env['MODE'] == 'dbg':
    env.Append(
        CPPFLAGS = [
          '/MTd',
        ],
    )
  else:  # MODE=opt
    env.Append(
        CPPFLAGS = [
          '/MT',
          '/O2',
        ],
        LINKFLAGS = [
          '/INCREMENTAL:NO',
          '/OPT:REF',
          '/OPT:ICF',
        ],
    )
elif env['OS'] == 'linux':
  env.Append(
      CPPDEFINES = [
          'LINUX',
      ],
      CPPPATH = [
          '$THIRD_PARTY_DIR/gtk/include/gtk-2.0',
          '$THIRD_PARTY_DIR/gtk/include/atk-1.0',
          '$THIRD_PARTY_DIR/gtk/include/glib-2.0',
          '$THIRD_PARTY_DIR/gtk/include/pango-1.0',
          '$THIRD_PARTY_DIR/gtk/include/cairo',
          '$THIRD_PARTY_DIR/gtk/lib/gtk-2.0/include',
          '$THIRD_PARTY_DIR/gtk/lib/glib-2.0/include',
      ],
      CCFLAGS = [
          '-fPIC',
          '-fmessage-length=0',
          '-Wall',
          '-Werror',
# NS_LITERAL_STRING does not work properly without this compiler option
          '-fshort-wchar',
# Additions to compile on hardy
          '-Wno-unused-variable',
          '-Wno-missing-braces',
          '-Wno-address',
          '-m32',
      ],
      CXXFLAGS = [
          '-fno-exceptions',
          '-fno-rtti',
          '-Wno-non-virtual-dtor',
          '-Wno-ctor-dtor-privacy',
          '-funsigned-char',
          '-Wno-char-subscripts',
      ],
      LINKFLAGS = [
          '-fPIC',
          '-Bsymbolic',
          '-pthread',

# TODO: Following are DLLFLAGS.  Figure something out for non-lib targets.
          '-shared',
          '-Wl,--version-script',
          '-Wl,$OPEN_DIR/tools/xpcom-ld-script',
# for PortAudio: need pthread and math
          '-lpthread',
          '-lm',
# Additions to compile on hardy
          '-m32',
      ],
  )
  if env['MODE'] == 'dbg':
    env.Append(
      CPPFLAGS = [
          '-g',
          '-O0',
      ],
    )
  else:  # MODE=opt
    env.Append(
      CPPFLAGS = [
          '-O2',
      ],
    )

# Load all the components

sconscripts = [
    'SConscript.googleurl',
    'SConscript.libgd',
    'SConscript.libjpeg',
    'SConscript.libpng',
    'SConscript.portaudio',
    'SConscript.sqlite',
    'SConscript.zlib',
]


for each in sconscripts:
  env.SConscript(each,
                 exports=['env'],
                 variant_dir='$COMMON_OUTDIR',
                 duplicate=0)

# Must come before SConscript.dll because it Imports targets from this
# SConscript.
env.SConscript('SConscript.common',
             exports=['env'],
             variant_dir='$COMMON_OUTDIR',
             duplicate=0)

browsers = [env['BROWSER']]
if browsers[0] == 'all':
  browsers = env['VALID_BROWSERS']
print 'Building:', browsers

for each in browsers:
  env.Replace(BROWSER = each)
  env.SConscript('SConscript.dll',
                 exports=['env'],
                 variant_dir='$BROWSER_OUTDIR',
                 duplicate=0)

env.SConscript('SConscript.installers',
               exports=['env'],
               variant_dir='$BASE_OUTDIR',
               duplicate=0)