# 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, you can use it as follows: # (after of course installation of scons from www.scons.org) # # $ cd development/scons # $ scons [options] [targets] # or: # $ scons -f development/scons/SConstruct [options] [targets] # # After compiling, you can install lyx by # $ scons [prefix=.] install # # Where: # * targets can be one or more of lyx, tex2lyx, client, default to lyx # * options: use scons -h for details about parameters, the most important # one is frontend=qt3|qt4. # * qt3 is used by default on linux, cygwin and mac # * qt4 is used by default on win32/mingw # # File layouts (Important): # * Unless you specify builddir=dir, building will happen # in $BUILDDIR = $mode, which can be debug or release # * $BUILDDIR has subdirectories # libs: all intermediate libraries # boost: boost libraries, if boost=included is used # qt3: build result # * lyx executable will be in directories like debug/linux-qt3 # # Hints: # * scons --config=force # force re-configuration (use scons -H for details) # # * check config.log to see why config has failed # # * use extra_inc_path, extra_lib_path, qt_dir, qt_inc_path # qt_lib_path to help locate qt and other libraries # (there are extra_inc_path1, extra_lib_path1 for now) # # * (Important) use scons logfile=logfile.log to enable command line # logging. (default is no logging) # # Notes: # * Currently, all scons does is building lyx in # $LYXROOT/$mode/$build_dir/ # where $mode is debug or release, $build_dir is the build_dir name # listed above # # * scons install etc may be added later. Interested contributors can follow # http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/AccumulateBuilder # or # http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/DistTarBuilder # Please also see the commented out code in scons_utils.py # # * NSIS support can be found here. # http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/NsisSconsTool # # * rpm support? # http://www.scons.org/cgi-sys/cgiwrap/scons/moin.cgi/RpmHonchoTemp # # However, I decide to wait since scons seems to be standardizing these # features. # import os, sys # config/scons_utils.py defines a few utility function sys.path.append('config') import scons_utils as utils SetOption('implicit_cache', 1) #---------------------------------------------------------- # Required runtime environment #---------------------------------------------------------- # FIXME: I remember lyx requires higher version of python? EnsurePythonVersion(1, 5) # 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 PACKAGE_VERSION = '1.5.0svn' DEVEL_VERSION = True default_build_mode = 'debug' PACKAGE = 'lyx' PACKAGE_BUGREPORT = 'lyx-devel@lists.lyx.org' PACKAGE_NAME = 'LyX' PACKAGE_TARNAME = 'lyx' PACKAGE_STRING = '%s %s' % (PACKAGE_NAME, PACKAGE_VERSION) PROGRAM_SUFFIX = '' default_log_file = 'scons_lyx.log' # FIXME: what is this? (They are used in src/support/package.C.in LOCALEDIR = "../locale/" LYX_DIR = "/usr/local/share/lyx" # platform dependent default build_dir and other settings # # I know, somebody would say: # This is TOTALLY wrong! Everything should be automatically # determined. # if os.name == 'nt': platform_name = 'win32' default_frontend = 'qt4' # boost and gettext are unlikely to be installed already default_boost_opt = 'included' default_gettext_opt = 'included' default_pch_opt = False default_with_x = False spell_checker = 'auto' # FIXME: I need to know what exactly is boost_posix # EF: It indicates to boost which API to use (posix or windows). # If not specified, boost tries to figure out by itself, but it may fail. boost_posix = False packaging_method = 'windows' share_dir = 'Resources' man_dir = 'Resouces/man/man1' locale_dir = 'Resources/locale' elif os.name == 'posix' and sys.platform != 'cygwin': platform_name = sys.platform default_frontend = 'qt3' # try to use system boost/gettext libraries default_boost_opt = 'auto' default_gettext_opt = 'auto' default_pch_opt = False default_with_x = True boost_posix = True packaging_method = 'posix' share_dir = 'share/lyx' man_dir = 'man/man1' locale_dir = 'share/locale' elif os.name == 'posix' and sys.platform == 'cygwin': platform_name = 'cygwin' default_frontend = 'qt3' # force the use of cygwin/boost/gettext default_boost_opt = 'system' default_gettext_opt = 'system' default_pch_opt = False default_with_x = True boost_posix = True packaging_method = 'posix' share_dir = 'share/lyx' man_dir = 'man/man1' locale_dir = 'share/locale' elif os.name == 'darwin': platform_name = 'mac' default_frontend = 'qt3' # to be safe default_boost_opt = 'included' default_gettext_opt = 'included' default_pch_opt = False default_with_x = False boost_posix = True packaging_method = 'msc' share_dir = 'Resources' man_dir = 'Resouces/man/man1' locale_dir = 'Resources/locale' else: # unsupported system platform_name = 'others' default_frontend = 'qt3' # to be safe default_boost_opt = 'included' default_gettext_opt = 'included' default_pch_opt = False default_with_x = True boost_posix = False packaging_method = 'posix' share_dir = 'share/lyx' man_dir = 'man/man1' locale_dir = 'share/locale' #--------------------------------------------------------- # Handling options #---------------------------------------------------------- # Note that if you set the options via the command line, # they will be remembered in the file 'options.cache' # # NOTE: the scons people are trying to fix scons so that # options like --prefix will be accepted. Right now, # we have to use the KEY=VALUE style of scons # if os.path.isfile('options.cache'): print "Getting options from auto-saved options.cache..." print open('options.cache').read() if os.path.isfile('config.py'): print "Getting options from config.py..." print open('config.py').read() opts = Options(['options.cache', 'config.py']) opts.AddOptions( # frontend, EnumOption('frontend', 'Main GUI', default_frontend, allowed_values = ('xform', '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 first.', default_boost_opt, 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 first', default_gettext_opt, 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 ) ), # FIXME: I am not allowed to use '' as default, '.' is not good either. PathOption('qt_dir', 'Path to qt directory', '.'), PathOption('qt_include_path', 'Path to qt include directory', '.'), PathOption('qt_lib_path', 'Path to qt library directory', '.'), # FIXME: I do not know how pch is working. Ignore this option now. BoolOption('pch', '(NA) Whether or not use pch', default_pch_opt), # FIXME: Not implemented yet. BoolOption('version_suffix', '(NA) Whether or not add version suffix', False), # build directory, will replace build_dir if set PathOption('build_dir', 'Build directory', '.'), # extra include and libpath PathOption('extra_inc_path', 'Extra include path', '.'), PathOption('extra_lib_path', 'Extra library path', '.'), PathOption('extra_inc_path1', 'Extra include path', '.'), PathOption('extra_lib_path1', 'Extra library path', '.'), # enable assertion, (config.h has ENABLE_ASSERTIOS BoolOption('assertions', 'Use assertions', True), # enable warning, (config.h has WITH_WARNINGS) BoolOption('warnings', 'Use warnings', True), # enable glib, (config.h has _GLIBCXX_CONCEPT_CHECKS) BoolOption('concept_checks', 'Enable concept checks', True), # FIXME: I do not know what is nls BoolOption('nls', '(NA) Whether or not use native language support', False), # FIXME: not implemented BoolOption('profile', '(NA) Whether or not enable profiling', False), # PathOption('prefix', 'install architecture-independent files in PREFIX', '.'), # PathOption('exec_prefix', 'install architecture-independent executable files in PREFIX', '.'), # 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), # FIXME: not implemented BoolOption('libintl', '(NA) Use libintl library', False), # FIXME: not implemented PathOption('intl_prefix', '(NA) Path to intl library', '.'), # log file ('logfile', 'save commands (not outputs) to logfile', default_log_file), # Path to aikasurus PathOption('aikasurus_path', 'Path to aikasurus library', '.'), # EnumOption('spell', 'Choose spell checker to use.', 'auto', allowed_values = ('aspell', 'pspell', 'ispell', 'auto') ), # environment variable can be set as options ('CC', '$CC', 'gcc'), ('CPP', '$CPP', 'gcc -E'), ('CXX', '$CXX', 'g++'), ('CXXCPP', '$CXXCPP', 'g++ -E'), ('CCFLAGS', '$CCFLAGS', ''), ('CPPFLAGS', '$CPPFLAGS', ''), ('CPPPATH', '$CPPPATH', ''), ('LDFLAGS', '$LDFLAGS', ''), ) #--------------------------------------------------------- # Setting up environment #--------------------------------------------------------- env = Environment(options = opts) # Determine the frontend to use, which may be loaded # from option cache frontend = env.get('frontend', default_frontend) use_X11 = env.get('X11', default_with_x) # set environment since I do not really like ENV = os.environ env['ENV']['PATH'] = os.environ.get('PATH') env['ENV']['HOME'] = os.environ.get('HOME') env['TOP_SRC_DIR'] = TOP_SRC_DIR env['SCONS_DIR'] = SCONS_DIR # install to current directory by default env['PREFIX'] = env.get('prefix', '.') if env.has_key('exec_prefix') and env['exec_prefix'] != '.': env['BIN_DIR'] = env['exec_prefix'] else: env['BIN_DIR'] = os.path.join(env['PREFIX'], 'bin') env['SHARE_DIR'] = os.path.join(env['PREFIX'], share_dir) env['MAN_DIR'] = os.path.join(env['PREFIX'], man_dir) env['LOCALE_DIR'] = os.path.join(env['PREFIX'], locale_dir) # speed up source file processing #env['CPPSUFFIXES'] = ['.C', '.cc', '.cpp'] #env['CXXSUFFIX'] = ['.C'] def getEnvVariable(env, name): # first try command line argument (override environment settings) if ARGUMENTS.has_key(name) and ARGUMENTS[name].strip() != '': env[name] = ARGUMENTS[name] # then try environment variable elif os.environ.has_key(name) and os.environ[name].strip() != '': env[name] = os.environ[name] print "Acquiring varaible %s from system environment: %s" % (name, env[name]) getEnvVariable(env, 'CC') getEnvVariable(env, 'CPP') getEnvVariable(env, 'CXX') getEnvVariable(env, 'CXXCPP') getEnvVariable(env, 'CCFLAGS') getEnvVariable(env, 'CXXFLAGS') getEnvVariable(env, 'CPPFLAGS') getEnvVariable(env, 'CPPPATH') getEnvVariable(env, 'LDFLAGS') # 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 # # Solaris seems to use gcc for the last step as well, so, to # make sure everyone uses a C++ compiler, linker, I do this for # all platform # # just to be safe if env.has_key('CXX') and env['CXX'] != '': env['CC'] = env['CXX'] env['LINK'] = env['CXX'] else: env['CC'] = 'g++' env['LINK'] = 'g++' # # frontend, mode, BUILDDIR and LOCALLIBPATH=BUILDDIR/libs # env['frontend'] = frontend 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 ARGUMENTS.has_key('build_dir'): build_dir = ARGUMENTS['build_dir'] env['BUILDDIR'] = build_dir else: # Determine the name of the build (platform+frontend 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' env.AppendUnique(LIBPATH = ['$LOCALLIBPATH']) # # QTDIR, QT_LIB_PATH, QT_INC_PATH # if platform_name == 'win32': env.Tool('mingw') 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')]) env.AppendUnique(CPPPATH = [os.path.join(env['qt_dir'], 'include')]) # 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/' env.AppendUnique(CPPPATH = env['QT_INC_PATH']) # # extra_inc_path and extra_lib_path # if env.has_key('extra_inc_path'): env.AppendUnique(CPPPATH = [env['extra_inc_path']]) if env.has_key('extra_lib_path'): env.AppendUnique(LIBPATH = [env['extra_lib_path']]) if env.has_key('extra_inc_path1'): env.AppendUnique(CPPPATH = [env['extra_inc_path1']]) if env.has_key('extra_lib_path1'): env.AppendUnique(LIBPATH = [env['extra_lib_path1']]) if env.has_key('aikasurus_path'): env.AppendUnique(LIBPATH = [env['aikasurus_path']]) # # this is a bit out of place (after auto-configration) # but it is required to do the tests. if platform_name == 'win32': env.AppendUnique(CPPPATH = ['#c:/MinGW/include']) #---------------------------------------------------------- # Autoconf business #---------------------------------------------------------- conf = Configure(env, custom_tests = { 'CheckPkgConfig' : utils.checkPkgConfig, 'CheckPackage' : utils.checkPackage, 'CheckPutenv' : utils.checkPutenv, 'CheckIstreambufIterator' : utils.checkIstreambufIterator, 'CheckMkdirOneArg' : utils.checkMkdirOneArg, 'CheckStdCount' : utils.checkStdCount, 'CheckSelectArgType' : utils.checkSelectArgType, 'CheckBoostLibraries' : utils.checkBoostLibraries, } ) # pkg-config? (if not, we use hard-coded options) 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 # zlib? This is required. if not conf.CheckLibWithHeader('z', 'zlib.h', 'C'): print 'Did not find libz or zlib.h, exiting!' Exit(1) # qt libraries? # # qt3 does not use pkg_config if env['frontend'] == 'qt3': if not conf.CheckLibWithHeader('qt-mt', 'qapp.h', 'c++', 'QApplication qapp();'): print 'Did not find qt libraries, exiting!' Exit(1) elif env['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) # check socket libs env['SOCKET_LIBS'] = [] if conf.CheckLib('socket'): env['SOCKET_LIBS'].append('socket') # EF: This is the network services library and provides a # transport-level interface to networking services. if conf.CheckLib('nsl'): env['SOCKET_LIBS'].append('nsl') # check boost libraries boost_opt = ARGUMENTS.get('boost', default_boost_opt) # check for system boost succ = False if boost_opt in ['auto', 'system']: pathes = env['LIBPATH'] + ['/usr/lib', '/usr/local/lib'] sig = conf.CheckBoostLibraries('boost_signals', pathes) reg = conf.CheckBoostLibraries('boost_regex', pathes) fil = conf.CheckBoostLibraries('boost_filesystem', pathes) ios = conf.CheckBoostLibraries('boost_iostreams', pathes) # if any them is not found if ('' in [sig[0], reg[0], fil[0], ios[0]]): if boost_opt == 'system': print "Can not find system boost libraries" print "Please supply a path through extra_lib_path" print "and try again." Exit(2) else: env['BOOST_LIBRARIES'] = [sig[1], reg[1], fil[1], ios[1]] # assume all boost libraries are in the same path... print sig[0] env.AppendUnique(LIBPATH = [sig[0]]) env['INCLUDED_BOOST'] = False succ = True # now, auto and succ = false, or included if not succ: # we do not need to set LIBPATH now. env['BOOST_LIBRARIES'] = ['boost_signals', 'boost_regex', 'boost_filesystem', 'boost_iostreams'] env['INCLUDED_BOOST'] = True # # Building config.h # 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 # # Note: addToConfig etc are defined in scons_util utils.startConfigH(TOP_SRC_DIR) # 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_ISTREAM # HAVE_OSTREAM # HAVE_IOS # 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'), ('utime.h', 'HAVE_UTIME_H', 'c'), ('istream', 'HAVE_ISTREAM', 'cxx'), ('ostream', 'HAVE_OSTREAM', 'cxx'), ('ios', 'HAVE_IOS', 'cxx') ] for header in headers: 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], TOP_SRC_DIR) else: utils.addToConfig('/* #undef %s */' % header[1], TOP_SRC_DIR) # 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_MKTEMP # HAVE_MKSTEMP # HAVE_STRERROR # HAVE_FCNTL # Check functions functions = [ ('open', 'HAVE_OPEN'), ('close', 'HAVE_CLOSE'), ('popen', 'HAVE_POPEN'), ('pclose', 'HAVE_PCLOSE'), ('_open', 'HAVE__OPEN'), ('_close', 'HAVE__CLOSE'), ('_popen', 'HAVE__POPEN'), ('_pclose', 'HAVE__PCLOSE'), ('getpid', 'HAVE_GETPID'), ('_getpid', 'HAVE__GETPID'), ('mkdir', 'HAVE_MKDIR'), ('_mkdir', 'HAVE__MKDIR'), ('mktemp', 'HAVE_MKTEMP'), ('mkstemp', 'HAVE_MKSTEMP'), ('strerror', 'HAVE_STRERROR'), ('fcntl', 'HAVE_FCNTL') ] for func in functions: if conf.CheckFunc(func[0]): utils.addToConfig('#define %s 1' % func[1], TOP_SRC_DIR) else: utils.addToConfig('/* #undef %s */' % func[1], TOP_SRC_DIR) # PACKAGE # PACKAGE_VERSION # DEVEL_VERSION utils.addToConfig('#define PACKAGE "%s"' % PACKAGE, TOP_SRC_DIR) utils.addToConfig('#define PACKAGE_VERSION "%s"' % PACKAGE_VERSION, TOP_SRC_DIR) if DEVEL_VERSION: utils.addToConfig('#define DEVEL_VERSION 1', TOP_SRC_DIR) # ENABLE_ASSERTIONS # ENABLE_NLS # WITH_WARNINGS # _GLIBCXX_CONCEPT_CHECKS # items are (ENV, ARGUMENTS) values = [ ('ENABLE_ASSERTIONS', 'assertions'), ('ENABLE_NLS', 'nls'), ('WITH_WARNINGS', 'warnings'), ('_GLIBCXX_CONCEPT_CHECKS', 'concept_checks'), ] for val in values: if (env.has_key(val[0]) and env[val[0]]) or \ ARGUMENTS.get(val[1]): utils.addToConfig('#define %s 1' % val[0], TOP_SRC_DIR) else: utils.addToConfig('/* #undef %s */' % val[0], TOP_SRC_DIR) env['EXTRA_LIBS'] = [] # HAVE_LIBAIKSAURUS # AIKSAURUS_H_LOCATION if conf.CheckLib('Aiksaurus'): utils.addToConfig("#define HAVE_LIBAIKSAURUS 1", TOP_SRC_DIR) if (conf.CheckCXXHeader("Aiksaurus.h")): utils.addToConfig("#define AIKSAURUS_H_LOCATION ", TOP_SRC_DIR) elif (conf.CheckCXXHeader("Aiksaurus/Aiksaurus.h")): utils.addToConfig("#define AIKSAURUS_H_LOCATION ", TOP_SRC_DIR) else: utils.addToConfig("#define AIKSAURUS_H_LOCATION", TOP_SRC_DIR) env['EXTRA_LIBS'].append('Aiksaurus') # 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', TOP_SRC_DIR) env['USE_ASPELL'] = True env['EXTRA_LIBS'].append('aspell') spell_detected = True elif spell_engine in ['auto', 'pspell'] and \ conf.CheckLib('pspell'): utils.addToConfig('#define USE_PSPELL 1', TOP_SRC_DIR) env['USE_PSPELL'] = True env['EXTRA_LIBS'].append('pspell') spell_detected = True elif spell_engine in ['auto', 'ispell'] and \ conf.CheckLib('ispell'): utils.addToConfig('#define USE_ISPELL 1', TOP_SRC_DIR) env['USE_ISPELL'] = True env['EXTRA_LIBS'].append('ispell') spell_detected = True if not spell_detected: # 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', TOP_SRC_DIR) elif packaging_method == 'posix': utils.addToConfig('#define USE_POSIX_PACKAGING 1', TOP_SRC_DIR) elif packaging_method == 'mac': utils.addToConfig('#define USE_MACOSX_PACKAGING 1', TOP_SRC_DIR) # BOOST_POSIX if boost_posix: utils.addToConfig('#define BOOST_POSIX 1', TOP_SRC_DIR) else: utils.addToConfig('/* #undef BOOST_POSIX */', TOP_SRC_DIR) # HAVE_PUTENV if conf.CheckPutenv(): utils.addToConfig('#define HAVE_PUTENV 1', TOP_SRC_DIR) else: utils.addToConfig('/* #undef HAVE_PUTENV */', TOP_SRC_DIR) # HAVE_DECL_ISTREAMBUF_ITERATOR if conf.CheckIstreambufIterator(): utils.addToConfig('#define HAVE_DECL_ISTREAMBUF_ITERATOR 1', TOP_SRC_DIR) else: utils.addToConfig('/* #undef HAVE_DECL_ISTREAMBUF_ITERATOR */', TOP_SRC_DIR) # MKDIR_TAKES_ONE_ARG if conf.CheckMkdirOneArg(): utils.addToConfig('#define MKDIR_TAKES_ONE_ARG 1', TOP_SRC_DIR) else: utils.addToConfig('/* #undef MKDIR_TAKES_ONE_ARG */', TOP_SRC_DIR) # HAVE_STD_COUNT if conf.CheckStdCount(): utils.addToConfig('#define HAVE_STD_COUNT 1', TOP_SRC_DIR) else: utils.addToConfig('/* #undef HAVE_STD_COUNT */', TOP_SRC_DIR) # SELECT_TYPE_ARG1 # SELECT_TYPE_ARG234 # SELECT_TYPE_ARG5 (arg1, arg234, arg5) = conf.CheckSelectArgType() utils.addToConfig('#define SELECT_TYPE_ARG1 %s' % arg1, TOP_SRC_DIR) utils.addToConfig('#define SELECT_TYPE_ARG234 %s' % arg234, TOP_SRC_DIR) utils.addToConfig('#define SELECT_TYPE_ARG5 %s' % arg5, TOP_SRC_DIR) # mkstemp # USE_BOOST_FORMAT # WANT_GETFILEATTRIBUTESEX_WRAPPER utils.endConfigH(TOP_SRC_DIR) # # Finish auto-configuration env = conf.Finish() #---------------------------------------------------------- # Now set up our build process accordingly #---------------------------------------------------------- # # QT_LIB etc (EXTRA_LIBS holds lib for each frontend) # # NOTE: Tool('qt') or Tool('qt4') will be loaded later # in their respective directory and specialized env. try: if frontend == 'qt3': # note: env.Tool('qt') my set QT_LIB to qt env['QT_LIB'] = 'qt-mt' env['EXTRA_LIBS'] += ['qt-mt'] if platform_name == 'cygwin' and use_X11: env['EXTRA_LIBS'] += ['GL', 'Xmu', 'Xi', 'Xrender', 'Xrandr', 'Xcursor', 'Xft', 'freetype', 'fontconfig', 'Xext', 'X11', 'SM', 'ICE', 'resolv', 'pthread'] env.AppendUnique(LIBPATH = ['/usr/X11R6/lib']) elif frontend == 'qt4': # local qt4 toolset from # http://www.iua.upf.es/~dgarcia/Codders/sconstools.html if platform_name == "win32": env['QT_LIB'] = ['QtCore4', 'QtGui4'] else: env['QT_LIB'] = ['QtCore', 'QtGui'] env['EXTRA_LIBS'] += [x for x in 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']: env['SYSTEM_LIBS'] = ['shlwapi', 'z'] else: env['SYSTEM_LIBS'] = ['z'] # # Build parameters CPPPATH etc # # boost is always in env.AppendUnique(CPPPATH = ['$TOP_SRC_DIR/boost', '$TOP_SRC_DIR/src']) # TODO: add (more) appropriate compiling options (-DNDEBUG etc) # for debug/release mode if ARGUMENTS.get('mode', default_build_mode) == 'debug': env.AppendUnique(CCFLAGS = []) else: env.AppendUnique(CCFLAGS = []) # # Customized builders # # install customized builders env['BUILDERS']['substFile'] = Builder(action = utils.env_subst) # FIXME: there must be a better way. env['BUILDERS']['fileCopy'] = Builder(action = utils.env_filecopy) # # 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' and env['frontend'] == 'qt3': 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 env['LYX_DIR'] = LYX_DIR env['LOCALEDIR'] = LOCALEDIR env['TOP_SRCDIR'] = str(Dir('#')) env['PROGRAM_SUFFIX'] = PROGRAM_SUFFIX # 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 pathes: %s Boost libraries: %s Extra libraries: %s System libraries: %s Frontend: Frontend: %s Packaging: %s LyX binary dir: FIXME LyX files dir: FIXME ''' % (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['EXTRA_LIBS']), str(env['SYSTEM_LIBS']), env['frontend'], packaging_method) if env['frontend'] in ['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) 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 = ARGUMENTS.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 # # save options opts.Save('options.cache', env) # -h will print out help info Help(opts.GenerateHelpText(env)) #---------------------------------------------------------- # Start building #---------------------------------------------------------- Export('env') SConsignFile(os.path.abspath('%s/sconsign' % env['BUILDDIR'])) env['BUILD_TARGETS'] = BUILD_TARGETS print "Building all targets recursively" env.SConscript('$SCONS_DIR/SConscript', duplicate = 0)