lyx_mirror/development/scons/SConstruct

# vi:filetype=python:expandtab:tabstop=2:shiftwidth=2
#
# file SConstruct
#
# This file is part of LyX, the document processor.
# Licence details can be found in the file COPYING.
#
# \author Bo Peng
# Full author contact details are available in file CREDITS.
#
#
# This is a scons based building system for lyx, please refer
# to INSTALL.scons for detailed instructions.
#

import os, sys, copy, cPickle, glob

# config/scons_utils.py defines a few utility function
sys.path.append('config')
import scons_utils as utils

#----------------------------------------------------------
# Required runtime environment
#----------------------------------------------------------

# scons asks for 1.5.2, lyx requires 2.2
EnsurePythonVersion(2, 2)
# Please use at least 0.96.91 (not 0.96.1)
EnsureSConsVersion(0, 96)

# determine where I am ...
#
# called as 'scons -f development/scons/SConstruct'
if os.path.isfile('SConstruct'):
  TOP_SRC_DIR = '../..'
  SCONS_DIR = '.'
# called as 'cd development/scons; scons'
else:
  TOP_SRC_DIR = '.'
  SCONS_DIR = 'development/scons'


#----------------------------------------------------------
# Global definitions
#----------------------------------------------------------

# some global settings
#
# detect version of lyx
# only 1.4.x has frontends/qt2
if os.path.isdir(os.path.join(TOP_SRC_DIR, 'src', 'frontends', 'qt2')):
  PACKAGE_VERSION = '1.4.2svn'
else:
  PACKAGE_VERSION = '1.5.0svn'

DEVEL_VERSION = True
default_build_mode = 'debug'
lyx_ext = '*.C'

PACKAGE = 'lyx'
PACKAGE_BUGREPORT = 'lyx-devel@lists.lyx.org'
PACKAGE_NAME = 'LyX'
PACKAGE_TARNAME = 'lyx'
PACKAGE_STRING = '%s %s' % (PACKAGE_NAME, PACKAGE_VERSION)

# various cache/log files
default_log_file = 'scons_lyx.log'
env_cache_file = 'env.cache'


#----------------------------------------------------------
# platform dependent settings
#----------------------------------------------------------
if os.name == 'nt':
  platform_name = 'win32'
  default_frontend = 'qt4'
  default_with_x = False
  packaging_method = 'windows'
elif os.name == 'posix' and sys.platform != 'cygwin':
  platform_name = sys.platform
  default_frontend = 'qt3'
  default_with_x = True
  packaging_method = 'posix'
elif os.name == 'posix' and sys.platform == 'cygwin':
  platform_name = 'cygwin'
  default_frontend = 'qt3'
  default_with_x = True
  packaging_method = 'posix'
elif os.name == 'darwin':
  platform_name = 'mac'
  default_frontend = 'qt3'
  default_with_x = False
  packaging_method = 'mac'
else:  # unsupported system, assume posix behavior
  platform_name = 'others'
  default_frontend = 'qt3'
  default_with_x = True
  packaging_method = 'posix'


#---------------------------------------------------------
# Handling options
#----------------------------------------------------------
#
# You can set perminant default values in config.py
if os.path.isfile('config.py'):
  print "Getting options from config.py..."
  print open('config.py').read()

opts = Options(['config.py'])
opts.AddOptions(
  # frontend,
  EnumOption('frontend', 'Main GUI', default_frontend,
    allowed_values = ('xform', 'qt2', 'qt3', 'qt4', 'gtk') ),
  # debug or release build
  EnumOption('mode', 'Building method', default_build_mode,
    allowed_values = ('debug', 'release') ),
  # boost libraries
  EnumOption('boost',
    'Use included, system boost library, or try sytem boost first.',
    'auto', allowed_values = (
      'auto',       # detect boost, if not found, use included
      'included',   # always use included boost
      'system',     # always use system boost, fail if can not find
      ) ),
  # 
  EnumOption('gettext',
    'Use included, system gettext library, or try sytem gettext first',
    'auto', allowed_values = (
      'auto',       # detect gettext, if not found, use included
      'included',   # always use included gettext
      'system',     # always use system gettext, fail if can not find
      ) ),
  #
  EnumOption('spell', 'Choose spell checker to use.', 'auto',
    allowed_values = ('aspell', 'pspell', 'ispell', 'auto') ),
  #
  BoolOption('fast_start', 'Whether or not use cached tests and keep current config.h', True),
  # FIXME: I do not know how pch is working. Ignore this option now.
  BoolOption('pch', '(NA) Whether or not use pch', None),
  # enable assertion, (config.h has ENABLE_ASSERTIOS
  BoolOption('assertions', 'Use assertions', True),
  # enable warning, (config.h has WITH_WARNINGS)
  # default to False since MSVC does not have #warning
  BoolOption('warnings', 'Use warnings', False),
  # enable glib, (config.h has _GLIBCXX_CONCEPT_CHECKS)
  BoolOption('concept_checks', 'Enable concept checks', True),
  # 
  BoolOption('nls', 'Whether or not use native language support', True),
  # FIXME: not implemented
  BoolOption('profile', '(NA) Whether or not enable profiling', False),
  # FIXME: not implemented
  BoolOption('std_debug', '(NA) Whether or not turn on stdlib debug', False),
  # using x11?
  BoolOption('X11', 'Use x11 windows system', default_with_x),
  # use MS VC++ to build lyx
  # FIXME: detect mavc automatically (check for cl.exe)
  BoolOption('use_vc', 'Use MS VC++ to build lyx', False),
  #
  PathOption('qt_dir', 'Path to qt directory', None),
  #
  PathOption('qt_include_path', 'Path to qt include directory', None),
  #
  PathOption('qt_lib_path', 'Path to qt library directory', None),
  # build directory, will use $mode if not set
  PathOption('build_dir', 'Build directory', None),
  # extra include and libpath
  PathOption('extra_inc_path', 'Extra include path', None),
  #
  PathOption('extra_lib_path', 'Extra library path', None),
  #
  PathOption('extra_bin_path', 'A convenient way to add a path to $PATH', None),
  #
  PathOption('extra_inc_path1', 'Extra include path', None),
  #
  PathOption('extra_lib_path1', 'Extra library path', None),
  # rebuild only specifed, comma separated targets
  ('rebuild', 'rebuild only specifed, comma separated targets', None),
  # can be set to a non-existing directory
  ('prefix', 'install architecture-independent files in PREFIX', None),
  # will install to dest_dir if defined. Otherwise, prefix will be used.
  ('dest_dir', 'install to dest_dir', None),
  # version suffix
  ('version_suffix', 'install lyx as lyx-suffix', ''),
  # how to load options
  ('load_option', '''load option from previous scons run. option can be
    yes (default): load all options
    no: do not load any option
    opt1,opt2: load specified options
    -opt1,opt2: load all options other than specified ones''', 'yes'),
  #
  ('optimization', 'optimization CCFLAGS option.', None),
  #
  PathOption('exec_prefix', 'install architecture-independent executable files in PREFIX', None),
  # log file
  ('logfile', 'save commands (not outputs) to logfile', default_log_file),
  # environment variable can be set as options.
  ('CC', 'replace default $CC', None),
  ('LINK', 'replace default $LINK', None),
  ('CPP', 'replace default $CPP', None),
  ('CXX', 'replace default $CXX', None),
  ('CXXCPP', 'replace default $CXXCPP', None),
  ('CCFLAGS', 'replace default $CCFLAGS', None),
  ('CPPFLAGS', 'replace default $CPPFLAGS', None),
  ('LUBKFLAGS', 'replace default $LINKFLAGS', None),
)

# copied from SCons/Options/BoolOption.py
true_strings  = ('y', 'yes', 'true', 't', '1', 'on' , 'all' )
false_strings = ('n', 'no', 'false', 'f', '0', 'off', 'none')

# whether or not use current config.h, and cached tests
# note that env is not defined yet, so we have to use ARGUMENTS
# and raw values of 'yes', 'no' etc.
#
# if fast_start=yes (default), load variables from env_cache_file
if (not ARGUMENTS.has_key('fast_start') or \
  ARGUMENTS['fast_start'] in true_strings) \
  and os.path.isfile(env_cache_file):
  fast_start = True
  cache_file = open(env_cache_file)
  env_cache = cPickle.load(cache_file)
  cache_file.close()
  print '------------ fast_start mode --------------------'
  print '  Use cached test results and current config.h'
  print '  use fast_start=no to override'
  print
else:
  fast_start = False
  env_cache = {}

# if load_option=yes (default), load saved comand line options
#
# This option can take values yes/no/opt1,opt2/-opt1,opt2
# and tries to be clever in choosing options to load
if (not ARGUMENTS.has_key('load_option') or \
  ARGUMENTS['load_option'] not in false_strings) \
  and os.path.isfile(env_cache_file):
  cache_file = open(env_cache_file)
  opt_cache = cPickle.load(cache_file)['arg_cache']
  cache_file.close()
  # import cached options, but we should ignore qt_dir when frontend changes
  if ARGUMENTS.has_key('frontend') and opt_cache.has_key('frontend') \
    and ARGUMENTS['frontend'] != opt_cache['frontend'] \
    and opt_cache.has_key('qt_dir'):
    opt_cache.pop('qt_dir')
  # some options will require full rebuild
  # these are in general things that will change src/config.h
  for arg in ['version_suffix', 'nls', 'boost']:
    if ARGUMENTS.has_key(arg) and ((not opt_cache.has_key(arg)) or \
      ARGUMENTS[arg] != opt_cache[arg]):
      if fast_start:
        print "  ** fast_start is disabled because of the change of option", arg
        print
        fast_start = False
  # and we do not cache some options
  for arg in ['fast_start', 'load_option']:
    if opt_cache.has_key(arg):
      opt_cache.pop(arg)
  # now, if load_option=opt1,opt2
  if ARGUMENTS.has_key('load_option') and \
    ARGUMENTS['load_option'] not in true_strings + false_strings:
    # if -opt1,opt2 is specified, do not load these options
    if ARGUMENTS['load_option'][0] == '-':
      for arg in ARGUMENTS['load_option'][1:].split(','):
        if opt_cache.has_key(arg):
          opt_cache.pop(arg)
    # if opt1,opt2 is specified, only load specified options
    else:
      args = ARGUMENTS['load_option'].split(',')
      for arg in opt_cache.keys():
        if arg not in args:
          opt_cache.pop(arg)
  # now restore options as if entered from command line
  for key in opt_cache.keys():
    if not ARGUMENTS.has_key(key):
      ARGUMENTS[key] = opt_cache[key]
      print "Restoring cached option  %s=%s" % (key, ARGUMENTS[key])
  print

# save arguments
env_cache['arg_cache'] = ARGUMENTS


#---------------------------------------------------------
# Setting up environment
#---------------------------------------------------------

# I do not really like ENV=os.environ, but you may add it 
# here if you experience some environment related problem
env = Environment(options = opts)

# Determine the frontend to use, which may be loaded
# from option cache
frontend = env.get('frontend', default_frontend)
# make sure the key exists (when using default_frontend)
env['frontend'] = frontend
# FIXME: will remove after lyx change file extension to .cpp
env['LYX_EXT'] = lyx_ext
#
use_X11 = env.get('X11', default_with_x)
# FIXME: determine the use of vc automatically
use_vc = env.get('use_vc', False)
# FIXME: use it only once for s scons-bug, will remove it later.
env['USE_VC'] = use_vc

# set individual variables since I do not really like ENV = os.environ
env['ENV']['PATH'] = os.environ.get('PATH')
env['ENV']['HOME'] = os.environ.get('HOME')
# these are defined for MSVC
env['ENV']['LIB'] = os.environ.get('LIB')
env['ENV']['INCLUDE'] = os.environ.get('INCLUDE')
if use_vc:
  # full path name is used to build msvs project files
  env['TOP_SRC_DIR'] = Dir(TOP_SRC_DIR).abspath
else:
  env['TOP_SRC_DIR'] = TOP_SRC_DIR
env['SCONS_DIR'] = SCONS_DIR

# determine share_dir etc
if packaging_method == 'windows':
  share_dir = 'Resources'
  man_dir = 'Resources/man/man1'
  locale_dir = 'Resources/locale'
  default_prefix = 'c:/program files/lyx'
else:
  share_dir = 'share/lyx'
  man_dir = 'man/man1'
  locale_dir = 'share/locale'
  default_prefix = '/usr/local/'

# install to default_prefix by default
env['PREFIX'] = env.get('prefix', default_prefix)
# program suffix: can be yes, or a string
if env.has_key('version_suffix'):
  if env['version_suffix'] in true_strings:
    env['PROGRAM_SUFFIX'] = PACKAGE_VERSION
  else:
    env['PROGRAM_SUFFIX'] = env['version_suffix']
else:
  env['PROGRAM_SUFFIX'] = ''

# whether or not add suffix to file and directory names
env['ADD_SUFFIX'] = packaging_method != 'windows'
if env['ADD_SUFFIX']:
  env['SHARE_DIR'] = os.path.join(env['PREFIX'], share_dir + env['PROGRAM_SUFFIX'])
else:  
  env['SHARE_DIR'] = os.path.join(env['PREFIX'], share_dir)
env['LOCALE_DIR'] = os.path.join(env['PREFIX'], locale_dir)
#
# if dest_dir is different from prefix.
env['DEST_DIR'] = env.get('dest_dir', env['PREFIX'])
if env.has_key('exec_prefix'):
  env['BIN_DEST_DIR'] = env['exec_prefix']
else:
  env['BIN_DEST_DIR'] = os.path.join(env['DEST_DIR'], 'bin')
if env['ADD_SUFFIX']:
  env['SHARE_DEST_DIR'] = os.path.join(env['DEST_DIR'], share_dir + env['PROGRAM_SUFFIX'])
else:
  env['SHARE_DEST_DIR'] = os.path.join(env['DEST_DIR'], share_dir)
env['MAN_DEST_DIR'] = os.path.join(env['DEST_DIR'], man_dir)
env['LOCALE_DEST_DIR'] = os.path.join(env['DEST_DIR'], locale_dir)

# frontend, mode, BUILDDIR and LOCALLIBPATH=BUILDDIR/libs
env['mode'] = env.get('mode', default_build_mode)
# lyx will be built to $build/build_dir so it is possible
# to build multiple build_dirs using the same source
# $mode can be debug or release
if env.has_key('build_dir') and env['build_dir']:
  build_dir = env['build_dir']
  env['BUILDDIR'] = build_dir
else:
  # Determine the name of the build $mode
  env['BUILDDIR'] = '#' + env['mode']
# all built libraries will go to build_dir/libs
# (This is different from the make file approach)
env['LOCALLIBPATH'] = '$BUILDDIR/libs'
# to make use of local cached parameters, this one has to be '.'
env['MSVSPATH'] = '.'
env.AppendUnique(LIBPATH = ['$LOCALLIBPATH'])


#---------------------------------------------------------
# Setting building environment (Tools, compiler flags etc)
#---------------------------------------------------------

# Since Tool('mingw') will reset CCFLAGS etc, this should be 
# done before getEnvVariable
if platform_name == 'win32' and not use_vc:
  env.Tool('mingw')
  # FIXME: set this as option?
  env.AppendUnique(CPPPATH = ['#c:/MinGW/include'])
elif use_vc:
  env.Tool('msvc')
  env.Tool('mslink')

# we differentiate between hard-coded options and default options
# hard-coded options are required and will always be there
# default options can be replaced by enviromental variables or command line options
CCFLAGS_required = []
LINKFLAGS_required = []
CCFLAGS_default = []

# under windows, scons is confused by .C/.c and uses gcc instead of
# g++. I am forcing the use of g++ here. This is expected to change
# after lyx renames all .C files to .cpp
#
# Note that this step has to be after env.Tool('mingw') step
# since env.Tool('mingw') will set env['CC'] etc.
#
# save the old c compiler and CCFLAGS (used by libintl)
env['C_COMPILER'] = env.subst('$CC')
env['C_CCFLAGS'] = env.subst('$CCFLAGS').split()
# if we use ms vc, the commands are fine (cl.exe and link.exe)
if not use_vc:
  if env.has_key('CXX') and env['CXX']:
    env['CC'] = env.subst('$CXX')
    env['LINK'] = env.subst('$CXX')
  else:
    env['CC'] = 'g++'
    env['LINK'] = 'g++'
else: 
  # /TP treat all source code as C++
  # C4819: The file contains a character that cannot be represented 
  #   in the current code page (number)
  # C4996: foo was decleared deprecated
  CCFLAGS_required.extend(['/TP', '/EHsc'])
  CCFLAGS_default.extend(['/wd4819', '/wd4996'])
  env.Append(C_CCFLAGS=['/Dinline#', '/D__attribute__(x)#', '/Duintmax_t=UINT_MAX'])

# for debug/release mode
if env.has_key('optimization') and env['optimization'] is not None:
  # if user supplies optimization flags, use it anyway
  CCFLAGS_required.extend(env['optimization'].split())
  # and do not use default
  set_default_optimization_flags = False
else:
  set_default_optimization_flags = True

if env['mode'] == 'debug':
  if use_vc:
    CCFLAGS_required.append('/Zi')
    LINKFLAGS_required.extend(['/debug', '/map'])
  else:
    CCFLAGS_required.append('-g')
    CCFLAGS_default.append('-Wall')
elif env['mode'] == 'release' and set_default_optimization_flags:
  if use_vc:
    CCFLAGS_default.append('/O2')
  else:
    CCFLAGS_default.append('-O2')

# Now, set the variables as follows:
# 1. if command line option exists: replace default
# 2. then if s envronment variable exists: replace default
# 3. set variable to required + default
def setEnvVariable(env, name, required=[], default=[]):
  # first try command line argument (override environment settings)
  if ARGUMENTS.has_key(name):
    # multiple options may be passed like "-02 -g"
    default = ARGUMENTS[name].split()
  # then use environment default
  elif os.environ.has_key(name):
    print "Acquiring varaible %s from system environment: %s" % (name, env[name])
    default = os.environ[name].split()
  # set variable
  if required != [] or default != []:
    env[name] = required + default

setEnvVariable(env, 'CC')
setEnvVariable(env, 'LINK')
setEnvVariable(env, 'CPP')
setEnvVariable(env, 'CXX')
setEnvVariable(env, 'CXXCPP')
setEnvVariable(env, 'CCFLAGS', CCFLAGS_required, CCFLAGS_default)
setEnvVariable(env, 'CXXFLAGS')
setEnvVariable(env, 'CPPFLAGS')
setEnvVariable(env, 'LINKFLAGS', LINKFLAGS_required)


#---------------------------------------------------------
# Frontend related variables (QTDIR etc)
#---------------------------------------------------------

if env.has_key('qt_dir') and env['qt_dir']:
  env['QTDIR'] = env['qt_dir']
  # add path to the qt tools
  env.AppendUnique(LIBPATH = [os.path.join(env['qt_dir'], 'lib')])
  # set environment so that moc etc can be found even if its path is not set properly
  env.PrependENVPath('PATH', os.path.join(env['qt_dir'], 'bin'))
else:
  env['QTDIR'] = os.environ.get('QTDIR', '/usr/lib/qt-3.3')

if env.has_key('qt_lib_path') and env['qt_lib_path']:
  env['QT_LIB_PATH'] = env['qt_lib_path']
else:
  env['QT_LIB_PATH'] = '$QTDIR/lib'
env.AppendUnique(LIBPATH = ['$QT_LIB_PATH'])
# qt4 seems to be using pkg_config
env.PrependENVPath('PKG_CONFIG_PATH', env.subst('$QT_LIB_PATH'))

if env.has_key('qt_inc_path') and env['qt_inc_path']:
  env['QT_INC_PATH'] = env['qt_inc_path']
elif os.path.isdir(os.path.join(env.subst('$QTDIR'), 'include')):
  env['QT_INC_PATH'] = '$QTDIR/include'
else: # have to guess
  env['QT_INC_PATH'] = '/usr/include/$frontend/'
# Note that this CPPPATH is for testing only
# it will be removed before calling SConscript
env['CPPPATH'] = [env['QT_INC_PATH']]

#
# extra_inc_path and extra_lib_path
#
if env.has_key('extra_inc_path') and env['extra_inc_path']:
  env.AppendUnique(CPPPATH = [env['extra_inc_path']])
if env.has_key('extra_lib_path') and env['extra_lib_path']:
  env.AppendUnique(LIBPATH = [env['extra_lib_path']])
if env.has_key('extra_inc_path1') and env['extra_inc_path1']:
  env.AppendUnique(CPPPATH = [env['extra_inc_path1']])
if env.has_key('extra_lib_path1') and env['extra_lib_path1']:
  env.AppendUnique(LIBPATH = [env['extra_lib_path1']])
if env.has_key('extra_bin_path') and env['extra_bin_path']:
  # maybe only one of them is needed
  os.environ['PATH'] += os.pathsep + env['extra_bin_path']
  env['ENV']['PATH'] += os.pathsep + env['extra_bin_path']


#----------------------------------------------------------
# Autoconf business
#----------------------------------------------------------

conf = Configure(env,
  custom_tests = {
    'CheckPkgConfig' : utils.checkPkgConfig,
    'CheckPackage' : utils.checkPackage,
    'CheckMkdirOneArg' : utils.checkMkdirOneArg,
    'CheckSelectArgType' : utils.checkSelectArgType,
    'CheckBoostLibraries' : utils.checkBoostLibraries,
    'CheckCommand' : utils.checkCommand,
    'CheckCXXGlobalCstd' : utils.checkCXXGlobalCstd,
    'CheckLC_MESSAGES' : utils.checkLC_MESSAGES,
    'CheckIconvConst' : utils.checkIconvConst,
  }
)


# pkg-config? (if not, we use hard-coded options)
if not fast_start:
  if conf.CheckPkgConfig('0.15.0'):
    env['HAS_PKG_CONFIG'] = True
  else:
    print 'pkg-config >= 0.1.50 is not found'
    env['HAS_PKG_CONFIG'] = False
  env_cache['HAS_PKG_CONFIG'] = env['HAS_PKG_CONFIG']
else:
  env['HAS_PKG_CONFIG'] = env_cache['HAS_PKG_CONFIG']

# zlib? This is required. (fast_start assumes the existance of zlib)
if not fast_start:
  if (not use_vc and not conf.CheckLibWithHeader('z', 'zlib.h', 'C')) \
    or (use_vc and not conf.CheckLibWithHeader('zdll', 'zlib.h', 'C')):
    print 'Did not find zdll.lib or zlib.h, exiting!'
    Exit(1)

# qt libraries?
if not fast_start:
  #
  # qt3 does not use pkg_config
  if frontend in ['qt2', 'qt3']:
    if not conf.CheckLibWithHeader('qt-mt', 'qapp.h', 'c++', 'QApplication qapp();'):
      print 'Did not find qt libraries, exiting!'
      Exit(1)
  elif frontend == 'qt4':
    succ = False
    # first: try pkg_config
    if env['HAS_PKG_CONFIG']:
      succ = conf.CheckPackage('QtCore') or conf.CheckPackage('QtCore4')
      env['QT4_PKG_CONFIG'] = succ
    # second: try to link to it
    if not succ:
      # FIXME: under linux, I can test the following perfectly
      # However, under windows, lib names need to passed as libXXX4.a ...
      succ = conf.CheckLibWithHeader('QtCore', 'QtGui/QApplication', 'c++', 'QApplication qapp();') or \
        conf.CheckLibWithHeader('QtCore4', 'QtGui/QApplication', 'c++', 'QApplication qapp();')
    # third: try to look up the path
    if not succ:
      succ = True
      for lib in ['QtCore', 'QtGui']:
        # windows version has something like QtGui4 ...
        if not (os.path.isfile(os.path.join(env.subst('$QT_LIB_PATH'), 'lib%s.a' % lib)) or \
          os.path.isfile(os.path.join(env.subst('$QT_LIB_PATH'), 'lib%s4.a' % lib))):
          succ = False
          break
    # still can not find it
    if succ:
      print "Qt4 libraries are found."
    else:
      print 'Did not find qt libraries, exiting!'
      Exit(1)

# now, if msvc2005 is used, we will need that QT_LIB_PATH/QT_LIB.manifest file
if use_vc:
  # glob file xxx.dll.manifest (msvc 2003 may not have it)
  manifests = glob.glob(os.path.join(env.subst('$QT_LIB_PATH'), '*.dll.manifest'))
  if manifests != []:
    env['LINKCOM'] = [env['LINKCOM'], 'mt.exe /MANIFEST %s /outputresource:$TARGET;1' % manifests[0]]

# check socket libs
if not fast_start:
  env['SOCKET_LIBS'] = []
  if conf.CheckLib('socket'):
    env['SOCKET_LIBS'].append('socket')

  # nsl is the network services library and provides a
  # transport-level interface to networking services.
  if conf.CheckLib('nsl'):
    env['SOCKET_LIBS'].append('nsl')

  env_cache['SOCKET_LIBS'] = env['SOCKET_LIBS']
else:
  env['SOCKET_LIBS'] = env_cache['SOCKET_LIBS']

if not fast_start:
  # check boost libraries
  boost_opt = ARGUMENTS.get('boost', default_boost_opt)
  # check for system boost
  paths = env['LIBPATH'] + ['/usr/lib', '/usr/local/lib']
  env['BOOST_LIBRARIES'] = []
  boost_libpath = None
  # here I assume that all libraries are in the same directory
  for lib in ['signals', 'regex', 'filesystem', 'iostreams']:
    # lyx1.4 does not use iostreams
    if not os.path.isdir(os.path.join(env.subst('$TOP_SRC_DIR'), 'boost', 'libs', lib)):
      continue
    if boost_opt == 'included':
      env['BOOST_LIBRARIES'].append('included_boost_%s' % lib)
      env['INCLUDED_BOOST'] = True
    elif boost_opt == 'auto':
      res = conf.CheckBoostLibraries('boost_%s' % lib , paths)
      # if not found
      if res[0] == '':
        env['BOOST_LIBRARIES'].append('included_boost_%s' % lib)
        env['INCLUDED_BOOST'] = True
      else:
        env['BOOST_LIBRARIES'].append(res[1])
        env['INCLUDED_BOOST'] = False
        boost_libpath = res[0]
    elif boost_opt == 'system':
      res = conf.CheckBoostLibraries('boost_%s' % lib , paths)
      if res[0] == '':
        print "Can not find system boost libraries"
        print "Please supply a path through extra_lib_path and try again."
        print "Or use boost=included to use included boost libraries."
        Exit(2)
      else:
        env['BOOST_LIBRARIES'].append(res[1])
        env.AppendUnique(LIBPATH = [res[0]])
        boost_libpath = res[0]
  env_cache['BOOST_LIBRARIES'] = env['BOOST_LIBRARIES']
  env_cache['INCLUDED_BOOST'] = env['INCLUDED_BOOST']
  env_cache['BOOST_LIBPATH'] = boost_libpath
else:
  env['BOOST_LIBRARIES'] = env_cache['BOOST_LIBRARIES']
  if env_cache['BOOST_LIBPATH'] is not None:
    env.AppendUnique(LIBPATH = [env_cache['BOOST_LIBPATH']])
  env['INCLUDED_BOOST'] = env_cache['INCLUDED_BOOST']


env['ENABLE_NLS'] = not env.has_key('nls') or env['nls']

if not fast_start:
  if not env['ENABLE_NLS']:
    env['INTL_LIBS'] = []
    env['INCLUDED_GETTEXT'] = False
  else:
    # check gettext libraries
    gettext_opt = ARGUMENTS.get('gettext', default_gettext_opt)
    # check for system gettext
    succ = False
    if gettext_opt in ['auto', 'system']:
      if conf.CheckLib('intl'):
        env['INCLUDED_GETTEXT'] = False
        env['INTL_LIBS'] = ['intl']
        succ = True
      else: # no found
        if gettext_opt == 'system':
          print "Can not find system gettext library"
          print "Please supply a path through extra_lib_path and try again."
          print "Or use gettext=included to use included gettext libraries."
          Exit(2)
    # now, auto and succ = false, or gettext=included
    if not succ:
      # we do not need to set LIBPATH now.
      env['INCLUDED_GETTEXT'] = True
      env['INTL_LIBS'] = ['included_intl']
  env_cache['INCLUDED_GETTEXT'] = env['INCLUDED_GETTEXT']
  env_cache['INTL_LIBS'] = env['INTL_LIBS']
else:
  env['INTL_LIBS'] = env_cache['INTL_LIBS']
  env['INCLUDED_GETTEXT'] = env_cache['INCLUDED_GETTEXT']

#
# check for msgfmt command
if not fast_start:
  env['MSGFMT'] = conf.CheckCommand('msgfmt')
  env_cache['MSGFMT'] = env['MSGFMT']
else:
  env['MSGFMT'] = env_cache['MSGFMT']


#----------------------------------------------------------
# Generating config.h
#----------------------------------------------------------
if not fast_start:
  print "Generating ", utils.config_h, "..."

  # I do not handle all macros in src/config.h.in, rather I am following a list
  # of *used-by-lyx* macros compiled by Abdelrazak Younes <younes.a@free.fr>
  #
  # Note: addToConfig etc are defined in scons_util
  utils.startConfigH()

  # HAVE_IO_H
  # HAVE_LIMITS_H
  # HAVE_LOCALE_H
  # HAVE_LOCALE
  # HAVE_PROCESS_H
  # HAVE_STDLIB_H
  # HAVE_SYS_STAT_H
  # HAVE_SYS_TIME_H
  # HAVE_SYS_TYPES_H
  # HAVE_SYS_UTIME_H
  # HAVE_UNISTD_H
  # HAVE_UTIME_H
  # HAVE_STRINGS_H
  # HAVE_DIRECT_H
  # HAVE_ISTREAM
  # HAVE_OSTREAM
  # HAVE_IOS

  # for libintl % grep HAVE * | grep _H | cut -d: -f2 | sort -u
  
  # 
  # HAVE_INTTYPES_H
  # HAVE_STDINT_H
  # HAVE_ALLOCA_H
  # HAVE_STDLIB_H
  # HAVE_STRING_H
  # HAVE_STDDEF_H
  # HAVE_LIMITS_H
  # HAVE_ARGZ_H
  # HAVE_UNISTD_H
  # HAVE_SYS_PARAM_H

  # Check header files
  headers = [
    ('io.h', 'HAVE_IO_H', 'c'),
    ('limits.h', 'HAVE_LIMITS_H', 'c'),
    ('locale.h', 'HAVE_LOCALE_H', 'c'),
    ('locale', 'HAVE_LOCALE', 'cxx'),
    ('process.h', 'HAVE_PROCESS_H', 'c'),
    ('stdlib.h', 'HAVE_STDLIB_H', 'c'),
    ('sys/stat.h', 'HAVE_SYS_STAT_H', 'c'),
    ('sys/time.h', 'HAVE_SYS_TIME_H', 'c'),
    ('sys/types.h', 'HAVE_SYS_TYPES_H', 'c'),
    ('sys/utime.h', 'HAVE_SYS_UTIME_H', 'c'),
    ('sys/socket.h', 'HAVE_SYS_SOCKET_H', 'c'),
    ('unistd.h', 'HAVE_UNISTD_H', 'c'),
    ('inttypes.h', 'HAVE_INTTYPES_H', 'c'),
    ('utime.h', 'HAVE_UTIME_H', 'c'),
    ('string.h', 'HAVE_STRING_H', 'c'),
    ('strings.h', 'HAVE_STRINGS_H', 'c'),
    ('direct.h', 'HAVE_DIRECT_H', 'c'),
    ('istream', 'HAVE_ISTREAM', 'cxx'),
    ('ostream', 'HAVE_OSTREAM', 'cxx'),
    ('ios', 'HAVE_IOS', 'cxx'),
    ('argz.h', 'HAVE_ARGZ_H', 'c'),
    ('limits.h', 'HAVE_LIMITS_H', 'c'),
    ('alloca.h', 'HAVE_ALLOCA_H', 'c'),
    ('stddef.h', 'HAVE_STDDEF_H', 'c'),
    ('stdint.h', 'HAVE_STDINT_H', 'c'),
    ('sys/param.h', 'HAVE_SYS_PARAM_H', 'c'),
  ]

  for header in headers:
    description = "Define to 1 if you have the <%s> header file." % header[0]
    if (header[2] == 'c' and conf.CheckCHeader(header[0])) or \
      (header[2] == 'cxx' and conf.CheckCXXHeader(header[0])):
      utils.addToConfig('#define %s 1' % header[1], desc = description)
    else:
      utils.addToConfig('/* #undef %s */' % header[1], desc = description)

  # HAVE_OPEN
  # HAVE_CLOSE
  # HAVE_POPEN
  # HAVE_PCLOSE
  # HAVE__OPEN
  # HAVE__CLOSE
  # HAVE__POPEN
  # HAVE__PCLOSE
  # HAVE_GETPID
  # HAVE__GETPID
  # HAVE_MKDIR
  # HAVE__MKDIR
  # HAVE_PUTENV
  # HAVE_MKTEMP
  # HAVE_MKSTEMP
  # HAVE_STRERROR
  # HAVE_STD_COUNT
  # HAVE_GETCWD
  # HAVE_STRCPY
  # HAVE_STRCASECMP 
  # HAVE_STRDUP
  # HAVE_STRTOUL
  # HAVE_WCSLEN
  # HAVE_MMAP ?
  # HAVE_ALLOCA
  # HAVE___FSETLOCKING
  # HAVE_MEMPCPY
  # HAVE_STRCASECMP
  # HAVE___ARGZ_COUNT
  # HAVE___ARGZ_NEXT
  # HAVE___ARGZ_STRINGIFY
  # HAVE___FSETLOCKING
  # HAVE_GETCWD 
  # HAVE_STRTOUL  
  # HAVE_STRCASECMP
  # HAVE_STRDUP
  # HAVE_TSEARCH 

  # Check functions
  functions = [
    ('open', 'HAVE_OPEN', None),
    ('close', 'HAVE_CLOSE', None),
    ('popen', 'HAVE_POPEN', None),
    ('pclose', 'HAVE_PCLOSE', None),
    ('_open', 'HAVE__OPEN', None),
    ('_close', 'HAVE__CLOSE', None),
    ('_popen', 'HAVE__POPEN', None),
    ('_pclose', 'HAVE__PCLOSE', None),
    ('getpid', 'HAVE_GETPID', None),
    ('_getpid', 'HAVE__GETPID', None),
    ('mkdir', 'HAVE_MKDIR', None),
    ('_mkdir', 'HAVE__MKDIR', None),
    ('putenv', 'HAVE_PUTENV', None),
    ('mktemp', 'HAVE_MKTEMP', None),
    ('mkstemp', 'HAVE_MKSTEMP', None),
    ('strerror', 'HAVE_STRERROR', None),
    ('count', 'HAVE_STD_COUNT', '''
#include <algorithm>
int count()
{
  char a[] = "hello";
  return std::count(a, a+5, 'l');
}
'''),
    ('getcwd', 'HAVE_GETCWD', None),
    ('stpcpy', 'HAVE_STPCPY', None),
    ('strcasecmp', 'HAVE_STRCASECMP', None),
    ('strdup', 'HAVE_STRDUP', None),
    ('strtoul', 'HAVE_STRTOUL', None),
    ('alloca', 'HAVE_ALLOCA', None),
    ('__fsetlocking', 'HAVE___FSETLOCKING', None),
    ('mempcpy', 'HAVE_MEMPCPY', None),
    ('__argz_count', 'HAVE___ARGZ_COUNT', None),
    ('__argz_next', 'HAVE___ARGZ_NEXT', None),
    ('__argz_stringify', 'HAVE___ARGZ_STRINGIFY', None),
    ('setlocale', 'HAVE_SETLOCALE', None),
    ('tsearch', 'HAVE_TSEARCH', None),
    ('getegid', 'HAVE_GETEGID', None),
    ('getgid', 'HAVE_GETGID', None),
    ('getuid', 'HAVE_GETUID', None),
    ('wcslen', 'HAVE_WCSLEN', None)
  ]

  for func in functions:
    description = "Define to 1 if you have the `%s' function." % func[0]
    if conf.CheckFunc(func[0], header=func[2]):
      utils.addToConfig('#define %s 1' % func[1], desc = description)
    else:
      utils.addToConfig('/* #undef %s */' % func[1], desc = description)


  # HAVE_ASPRINTF
  # HAVE_WPRINTF
  # HAVE_SNPRINTF
  # HAVE_POSIX_PRINTF
  # HAVE_FCNTL

  env_functions = [
    ('asprintf', 'HAVE_ASPRINTF'),
    ('wprintf', 'HAVE_WPRINTF'),
    ('snprintf', 'HAVE_SNPRINTF'),
    ('printf', 'HAVE_POSIX_PRINTF'),
    ('fcntl', 'HAVE_FCNTL')
  ]

  for func in env_functions:
    description = "Define to 1 if you have the `%s' function." % func[0]
    if conf.CheckFunc(func[0]):
      utils.addToConfig('#define %s 1' % func[1], desc = description)
      env[func[1]] = 1
    else:
      utils.addToConfig('/* #undef %s */' % func[1], desc = description)
      env[func[1]] = 0

  # HAVE_INTMAX_T
  # HAVE_DECL_ISTREAMBUF_ITERATOR
  description = "Define to 1 if you have the `intmax_t' type."
  if conf.CheckType('intmax_t', includes='#include <stdint.h>') or \
    conf.CheckType('intmax_t', includes='#include <inttypes.h>'):
    utils.addToConfig('#define HAVE_INTMAX_T 1', desc = description)
  else:
    utils.addToConfig('/* #undef HAVE_INTMAX_T */',desc = description)

  # HAVE_INTMAX_T
  # HAVE_LONG_DOUBLE
  # HAVE_LONG_LONG
  # HAVE_WCHAR_T
  # HAVE_WINT_T
  # HAVE_INTTYPES_H_WITH_UINTMAX 
  # HAVE_STDINT_H_WITH_UINTMAX

  types = [
    ('intmax_t', 'HAVE_INTMAX_T', None),
    ('long double', 'HAVE_LONG_DOUBLE', None),
    ('long long', 'HAVE_LONG_LONG', None),
    ('wchar_t', 'HAVE_WCHAR_T', None),
    ('wint_t', 'HAVE_WINT_T', None),
    ('uintmax_t', 'HAVE_INTTYPES_H_WITH_UINTMAX', '#include <inttypes.h>'),
    ('uintmax_t', 'HAVE_STDINT_H_WITH_UINTMAX', '#include <stdint.h>'),
    ('std::istreambuf_iterator<std::istream>', 'HAVE_DECL_ISTREAMBUF_ITERATOR',
      '#include <streambuf>\n#include <istream>')
  ]
  for t in types: 
    description = "Define to 1 if you have the `%s' type." % t[0]
    if conf.CheckType(t[0], includes=t[2]):
      utils.addToConfig('#define %s 1' % t[1], desc = description)
    else:
      utils.addToConfig('/* #undef %s */' % t[1],  desc = description)

  # windows/msvc sys/types.h does not have pid_t
  # FIXME: #include <windows.h> is the right way?
  if not conf.CheckType('pid_t', includes='#include <sys/types.h>'):
    utils.addToConfig('#define pid_t int', desc = 'Define is sys/types.h does not have pid_t')

  # determine the use of std::tolower or tolower
  description = 'Define if your C++ compiler puts C library functions in the global namespace'
  if conf.CheckCXXGlobalCstd():
    utils.addToConfig('#define CXX_GLOBAL_CSTD 1', desc = description)
  else:
    utils.addToConfig('/* #undef CXX_GLOBAL_CSTD */', desc = description)

  # HAVE_LIBGDI32
  # HAVE_ICONV
  # HAVE_LIBC
  # HAVE_LIBAIKSAURUS
  libs = [
    ('gdi32', 'HAVE_LIBGDI32'),
    ('iconv', 'HAVE_ICONV'),
    ('c', 'HAVE_LIBC'),
    ('Aiksaurus', 'HAVE_LIBAIKSAURUS'),
  ]
  for lib in libs:
    description = "Define to 1 if you have the `%s' library (-l%s)." % (lib[0], lib[0])
    if conf.CheckLib(lib[0]):
      utils.addToConfig('#define %s 1' % lib[1], desc = description)
      env[lib[1]] = True
    else:
      utils.addToConfig('/* #undef %s */' % lib[1], desc = description)
      env[lib[1]] = False

  # HAVE_LC_MESSAGES
  description = 'Define if your <locale.h> file defines LC_MESSAGES.'
  if conf.CheckLC_MESSAGES():
    utils.addToConfig('#define HAVE_LC_MESSAGES 1', desc = description)
  else:
    utils.addToConfig('/* #undef HAVE_LC_MESSAGES */', desc = description)

  # ICONV_CONST
  description = 'Define as const if the declaration of iconv() needs const.'
  if conf.CheckIconvConst():
    utils.addToConfig('#define ICONV_CONST', desc = description)
  else:
    utils.addToConfig('/* #undef ICONV_CONST */', desc = description)

  # PACKAGE
  # PACKAGE_VERSION
  # PACKAGE_BUGREPORT
  # PACKAGE_NAME
  # PACKAGE_STRING
  # DEVEL_VERSION
  utils.addToConfig('#define PACKAGE "%s%s"' % (PACKAGE, env['PROGRAM_SUFFIX']),
    desc = "Name of package")

  utils.addToConfig('#define PACKAGE_BUGREPORT "%s"' % PACKAGE_BUGREPORT,
    desc = 'Define to the address where bug reports for this package should be sent.')

  utils.addToConfig('#define PACKAGE_NAME "%s"' % PACKAGE_NAME,
      desc = 'Define to the full name of this package.')

  utils.addToConfig('#define PACKAGE_STRING "%s"' % PACKAGE_STRING,
      desc = "Define to the full name and version of this package.")

  utils.addToConfig('#define PACKAGE_TARNAME "%s"' % PACKAGE_TARNAME,
      desc = "Define to the one symbol short name of this package.")

  utils.addToConfig('#define PACKAGE_VERSION "%s"' % PACKAGE_VERSION,
    desc = "Define to the version of this package.")

  if DEVEL_VERSION:
    utils.addToConfig('#define DEVEL_VERSION 1')

  # ENABLE_ASSERTIONS
  # ENABLE_NLS
  # WITH_WARNINGS
  # _GLIBCXX_CONCEPT_CHECKS

  # items are (ENV, ARGUMENTS)
  values = [
    ('ENABLE_ASSERTIONS', 'assertions', 'Define if you want assertions to be enabled in the code'),
    ('ENABLE_NLS', 'nls', "Define to 1 if translation of program messages to the user's native anguage is requested."),
    ('WITH_WARNINGS', 'warnings', 'Define this if you want to see the warning directives put here and there by the developpers to get attention'),
    ('_GLIBCXX_CONCEPT_CHECKS', 'concept_checks', 'libstdc++ concept checking'),
  ]

  for val in values:
    if (env.has_key(val[0]) and env[val[0]]) or \
       (env.has_key(val[1]) and env[val[1]]):
      utils.addToConfig('#define %s 1' % val[0], desc = val[2])
    else:
      utils.addToConfig('/* #undef %s */' % val[0], desc = val[2])

  # disable automatic linking of boost libraries.
  # This is an interesting feature that is supposed to be useful under
  # windows but since I can not find a way to use it on all platforms, 
  # I disable it for now.
  utils.addToConfig('#define BOOST_ALL_NO_LIB 1')

  # AIKSAURUS_H_LOCATION
  if (conf.CheckCXXHeader("Aiksaurus.h")):
    utils.addToConfig("#define AIKSAURUS_H_LOCATION <Aiksaurus.h>")
  elif (conf.CheckCXXHeader("Aiksaurus/Aiksaurus.h")):
    utils.addToConfig("#define AIKSAURUS_H_LOCATION <Aiksaurus/Aiksaurus.h>")
  else:
    utils.addToConfig("#define AIKSAURUS_H_LOCATION")

  # USE_ASPELL
  # USE_PSPELL
  # USE_ISPELL

  # determine headers to use
  spell_engine = ARGUMENTS.get('spell', 'auto')
  spell_detected = False
  if spell_engine in ['auto', 'aspell'] and \
    conf.CheckLib('aspell'):
    utils.addToConfig('#define USE_ASPELL 1', desc = 'Define as 1 to use the aspell library')
    env['USE_ASPELL'] = True
    env['USE_PSPELL'] = False
    env['USE_ISPELL'] = False
    spell_detected = True
  elif spell_engine in ['auto', 'pspell'] and \
    conf.CheckLib('pspell'):
    utils.addToConfig('#define USE_PSPELL 1', desc = 'Define as 1 to use the pspell library')
    env['USE_ASPELL'] = False
    env['USE_PSPELL'] = True
    env['USE_ISPELL'] = False
    spell_detected = True
  elif spell_engine in ['auto', 'ispell'] and \
    conf.CheckLib('ispell'):
    utils.addToConfig('#define USE_ISPELL 1', desc = 'Define as 1 to use the ispell library')
    env['USE_ASPELL'] = False
    env['USE_PSPELL'] = False
    env['USE_ISPELL'] = True
    spell_detected = True

  if not spell_detected:
    env['USE_ASPELL'] = False
    env['USE_PSPELL'] = False
    env['USE_ISPELL'] = False
    # FIXME: can lyx work without an spell engine
    if spell_engine == 'auto':
      print "Warning: Can not locate any spell checker"
    else:
      print "Warning: Can not locate specified spell checker:", spell_engine

  # USE_POSIX_PACKAGING
  # USE_MACOSX_PACKAGING
  # USE_WINDOWS_PACKAGING
  if packaging_method == 'windows':
    utils.addToConfig('#define USE_WINDOWS_PACKAGING 1')
  elif packaging_method == 'posix':
    utils.addToConfig('#define USE_POSIX_PACKAGING 1')
  elif packaging_method == 'mac':
    utils.addToConfig('#define USE_MACOSX_PACKAGING 1')

  # BOOST_POSIX
  # boost_posix indicates to boost which API to use (posix or windows).
  # If not specified, boost tries to figure out by itself, but it may fail.
  if os.name != 'nt':
    utils.addToConfig('#define BOOST_POSIX 1')
  else:
    utils.addToConfig('/* #undef BOOST_POSIX */')

  # MKDIR_TAKES_ONE_ARG
  description = 'Define if mkdir takes only one argument.'
  if conf.CheckMkdirOneArg():
    utils.addToConfig('#define MKDIR_TAKES_ONE_ARG 1', desc = description)
  else:
    utils.addToConfig('/* #undef MKDIR_TAKES_ONE_ARG */', desc = description)

  # SELECT_TYPE_ARG1
  # SELECT_TYPE_ARG234
  # SELECT_TYPE_ARG5
  (arg1, arg234, arg5) = conf.CheckSelectArgType()
  utils.addToConfig('#define SELECT_TYPE_ARG1 %s' % arg1,
    desc = "Define to the type of arg 1 for `select'.")
  utils.addToConfig('#define SELECT_TYPE_ARG234 %s' % arg234,
    desc = "Define to the type of arg 2, 3, 4 for `select'.")
  utils.addToConfig('#define SELECT_TYPE_ARG5 %s' % arg5,
    desc = "Define to the type of arg 5 for `select'.")

  # mkstemp
  # USE_BOOST_FORMAT
  # WANT_GETFILEATTRIBUTESEX_WRAPPER
  utils.endConfigH(TOP_SRC_DIR)

  for key in ['USE_ASPELL', 'USE_PSPELL', 'USE_ISPELL', 'HAVE_ASPRINTF', \
    'HAVE_WPRINTF', 'HAVE_SNPRINTF', 'HAVE_POSIX_PRINTF', 'HAVE_FCNTL', \
    'HAVE_ICONV', 'HAVE_LIBGDI32', 'HAVE_LIBC', 'HAVE_LIBAIKSAURUS']:
    env_cache[key] = env[key]
else:
  #
  # this comes as a big surprise, without this line 
  # (doing nothing obvious), adding fast_start=yes
  # to a build with fast_start=no will result in a rebuild
  # Note that the exact header file to check does not matter
  conf.CheckCHeader('io.h')
  # only a few variables need to be rescanned
  for key in ['USE_ASPELL', 'USE_PSPELL', 'USE_ISPELL', 'HAVE_ASPRINTF', \
    'HAVE_WPRINTF', 'HAVE_SNPRINTF', 'HAVE_POSIX_PRINTF', 'HAVE_FCNTL', \
    'HAVE_ICONV', 'HAVE_LIBGDI32', 'HAVE_LIBC', 'HAVE_LIBAIKSAURUS']:
    env[key] = env_cache[key]


#
# Finish auto-configuration
env = conf.Finish()

#----------------------------------------------------------
# Now set up our build process accordingly
#----------------------------------------------------------

#
# QT_LIB
#
# NOTE: Tool('qt') or Tool('qt4') will be loaded later
# in their respective directory and specialized env.
try:
  if frontend in ['qt2', 'qt3']:
    # note: env.Tool('qt') my set QT_LIB to qt
    env['QT_LIB'] = 'qt-mt'
    env['FRONTEND_LIBS'] = ['qt-mt']
    if platform_name == 'cygwin' and use_X11:
      env.AppendUnique(LIBPATH = ['/usr/X11R6/lib'])
  elif frontend == 'qt4':
    if platform_name == "win32":
      env['QT_LIB'] = ['QtCore4', 'QtGui4']
    else:
      env['QT_LIB'] = ['QtCore', 'QtGui']
    env['FRONTEND_LIBS'] = env['QT_LIB']
except:
  print "Can not locate qt tools"
  print "What I get is "
  print "  QTDIR: ", env['QTDIR']


if platform_name in ['win32', 'cygwin']:
  # the final link step needs stdc++ to succeed under mingw
  # FIXME: shouldn't g++ automatically link to stdc++?
  if use_vc:
    env['SYSTEM_LIBS'] = ['shlwapi', 'shell32', 'advapi32', 'zdll']
  else:
    env['SYSTEM_LIBS'] = ['shlwapi', 'stdc++', 'z']
elif platform_name == 'cygwin' and use_X11:
  env['SYSTEM_LIBS'] = ['GL',  'Xmu', 'Xi', 'Xrender', 'Xrandr', 'Xcursor',
    'Xft', 'freetype', 'fontconfig', 'Xext', 'X11', 'SM', 'ICE', 'resolv',
    'pthread', 'z']
else:
  env['SYSTEM_LIBS'] = ['z']

libs = [
  ('HAVE_ICONV', 'iconv'),
  ('HAVE_LIBGDI32', 'gdi32'),
  ('HAVE_LIBAIKSAURUS', 'Aiksaurus'),
  ('USE_ASPELL', 'aspell'),
  ('USE_ISPELL', 'ispell'),
  ('USE_PSPELL', 'pspell'),
]

for lib in libs:
  if env[lib[0]]:
    env['SYSTEM_LIBS'].append(lib[1])

#
# Build parameters CPPPATH etc
#
# boost is always in, src is needed for config.h
# 
# QT_INC_PATH is not needed for *every* source file
env['CPPPATH'].remove(env['QT_INC_PATH'])
env['CPPPATH'] += ['$TOP_SRC_DIR/boost', '$TOP_SRC_DIR/src']

#
# Customized builders
#
# install customized builders
env['BUILDERS']['substFile'] = Builder(action = utils.env_subst)

#
# A Link script for cygwin see
# http://www.cygwin.com/ml/cygwin/2004-09/msg01101.html
# http://www.cygwin.com/ml/cygwin-apps/2004-09/msg00309.html
# for details
#
if platform_name == 'cygwin':
  ld_script_path = '/usr/lib/qt3/mkspecs/cygwin-g++'
  ld_script = utils.installCygwinLDScript(ld_script_path)
  env.AppendUnique(LINKFLAGS = ['-Wl,--enable-runtime-pseudo-reloc',
    '-Wl,--script,%s' % ld_script, '-Wl,-s'])

#
# Report results
#
# src/support/package.C.in needs the following to replace
#  LYX_ABS_INSTALLED_DATADIR (e.g. /usr/local/lyx/share/lyx)
env['LYX_DIR'] = Dir(env['SHARE_DIR']).abspath
#  LYX_ABS_INSTALLED_LOCALEDIR
env['LOCALEDIR'] = Dir(env['LOCALE_DIR']).abspath
# during variable substitution, absolute path is needed.
env['TOP_SRCDIR'] = Dir(env['TOP_SRC_DIR']).abspath
# needed by src/version.C.in => src/version.C
env['PACKAGE_VERSION'] = PACKAGE_VERSION
# fill in the version info
env['VERSION_INFO'] = '''Configuration
  Host type:                      %s
  Special build flags:            %s
  C   Compiler:                   %s
  C   Compiler flags:             %s %s
  C++ Compiler:                   %s
  C++ Compiler LyX flags:         %s
  C++ Compiler flags:             %s %s
  Linker flags:                   %s
  Linker user flags:              %s
Build info:
  Builing directory:              %s
  Local library directory:        %s
  Libraries paths:                %s
  Boost libraries:                %s
  Frontend libraries:             %s
  System libraries:               %s
  include search path:            %s
Frontend:
  Frontend:                       %s
  Packaging:                      %s
  LyX dir:                        %s
  LyX binary dir:                 %s
  LyX files dir:                  %s
''' % (platform_name,
  env.subst('$CCFLAGS'), env.subst('$CC'),
  env.subst('$CPPFLAGS'), env.subst('$CFLAGS'),
  env.subst('$CXX'), env.subst('$CXXFLAGS'),
  env.subst('$CPPFLAGS'), env.subst('$CXXFLAGS'),
  env.subst('$LINKFLAGS'), env.subst('$LINKFLAGS'),
  env.subst('$BUILDDIR'), env.subst('$LOCALLIBPATH'),
  str(env['LIBPATH']), str(env['BOOST_LIBRARIES']),
  str(env['FRONTEND_LIBS']), str(env['SYSTEM_LIBS']), str(env['CPPPATH']),
  env['frontend'], packaging_method,
  env['PREFIX'], env['BIN_DEST_DIR'], env['SHARE_DIR'])

if env['frontend'] in ['qt2', 'qt3', 'qt4']:
  env['VERSION_INFO'] += '''  include dir:                    %s
  library dir:                    %s
  X11:                            %s
''' % (env.subst('$QT_INC_PATH'), env.subst('$QT_LIB_PATH'), use_X11)

if not fast_start:
  print env['VERSION_INFO']

#
# Mingw command line may be too short for our link usage,
# Here we use a trick from scons wiki
# http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/LongCmdLinesOnWin32
#
# I also would like to add logging (commands only) capacity to the
# spawn system.
logfile = env.get('logfile', default_log_file)
if logfile != '' or platform_name == 'win32':
  import time
  utils.setLoggedSpawn(env, logfile, longarg = (platform_name == 'win32'),
    info = '''# This is a log of commands used by scons to build lyx
# Time: %s
# Command: %s
# Info: %s
''' % (time.asctime(), ' '.join(sys.argv),
  env['VERSION_INFO'].replace('\n','\n# ')) )


#
# Cleanup stuff
#
# -h will print out help info
Help(opts.GenerateHelpText(env))
# save environment settings (for fast_start option)
cache_file = open(env_cache_file, 'w')
cPickle.dump(env_cache, cache_file)
cache_file.close()

#----------------------------------------------------------
# Start building
#----------------------------------------------------------
Export('env')

# this has been the source of problems on some platforms...
# I find that I need to supply it with full path name
env.SConsignFile(os.path.join(Dir(env['BUILDDIR']).abspath, '.sconsign'))
# this usage needs further investigation.
#env.CacheDir('%s/Cache/%s' % (env['BUILDDIR'], frontend))

env['BUILD_TARGETS'] = BUILD_TARGETS
if env.has_key('rebuild'):
  env['REBUILD_TARGETS'] = env['rebuild'].split(',')
else:
  env['REBUILD_TARGETS'] = None

print "Building all targets recursively"

env.SConscript('$SCONS_DIR/SConscript', duplicate = 0)