anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-13 06:20:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5e3b997b85
lyx_mirror/SConstruct
Lars Gullik Bjønnes 5e3b997b85 Remove the now superseeded SConscript files, and some small missing parts to SConstruct 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@13825 a592a061-630c-0410-9148-cb99ea01b6c8
2006-05-10 18:05:12 +00:00

1596 lines
42 KiB
Python
Raw Blame History

# 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)
#
# scons [frontend=qt3|gt4] [boost=included|auto] ...
#
# Where:
# * use scons -h for details about parameters
# * qt3 is used by default on linux, cygwin and mac
# * qt4 is used by default on win32
#
# File layouts (Important):
# * Unless you specify builddir=dir, building will happen
# in $BUILDDIR = $mode/$platform-$frontend. E.g., something like
# debug/linux-qt3/
# * All shared libs will be put in $BUILDDIR/libs, e.g.
# debug/linux-qt3/libs
# * 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)
#----------------------------------------------------------
# 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'
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'
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'
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'
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'
#---------------------------------------------------------
# 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),
# FIXME: not implemented
PathOption('prefix', '(NA) install architecture-independent files in PREFIX', '.'),
# FIXME: not implemented
PathOption('exec_prefix', '(NA) 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', ''),
)
# Determine the frontend to use
frontend = ARGUMENTS.get('frontend', default_frontend)
use_X11 = ARGUMENTS.get('X11', default_with_x)
#---------------------------------------------------------
# Setting up environment
#---------------------------------------------------------
env = Environment(
options = opts
)
# 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')
# 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')
env['TOP_SRC_DIR'] = Dir('.').abspath
# 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
if platform_name in ['win32', 'cygwin']:
env['CC'] = 'g++'
env['LINK'] = 'g++'
#
# frontend, mode, BUILDDIR and LOCALLIBPATH=BUILDDIR/libs
#
env['frontend'] = frontend
env['mode'] = ARGUMENTS.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
build_dir = '%s-%s' % (platform_name, frontend)
if use_X11 and platform_name == 'cygwin':
build_dir += '-X11'
env['BUILDDIR'] = os.path.join(env['mode'], build_dir)
# 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 ARGUMENTS.has_key('qt_dir'):
env['QTDIR'] = ARGUMENTS['qt_dir']
# add path to the qt tools
env.AppendUnique(LIBPATH = [os.path.join(ARGUMENTS['qt_dir'], 'lib')])
env.AppendUnique(CPPPATH = [os.path.join(ARGUMENTS['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(ARGUMENTS['qt_dir'], 'bin'))
else:
env['QTDIR'] = os.environ.get('QTDIR', '/usr/lib/qt-3.3')
if ARGUMENTS.has_key('qt_lib_path'):
env['QT_LIB_PATH'] = ARGUMENTS['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 ARGUMENTS.has_key('qt_inc_path'):
env['QT_INC_PATH'] = ARGUMENTS['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 ARGUMENTS.has_key('extra_inc_path'):
env.AppendUnique(CPPPATH = [ARGUMENTS['extra_inc_path']])
if ARGUMENTS.has_key('extra_lib_path'):
env.AppendUnique(LIBPATH = [ARGUMENTS['extra_lib_path']])
if ARGUMENTS.has_key('extra_inc_path1'):
env.AppendUnique(CPPPATH = [ARGUMENTS['extra_inc_path1']])
if ARGUMENTS.has_key('extra_lib_path1'):
env.AppendUnique(LIBPATH = [ARGUMENTS['extra_lib_path1']])
if ARGUMENTS.has_key('aikasurus_path'):
env.AppendUnique(LIBPATH = [ARGUMENTS['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', 'Qt3Support']:
# 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.AppendUnique(socket_libs = ['socket'])
# FIXME: What is nsl, is it related to socket?
if conf.CheckLib('nsl'):
env.AppendUnique(socket_libs = ['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 <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_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])
else:
utils.addToConfig('/* #undef %s */' % header[1])
# 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
# 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')
]
for func in functions:
if conf.CheckFunc(func[0]):
utils.addToConfig('#define %s 1' % func[1])
else:
utils.addToConfig('/* #undef %s */' % func[1])
# PACKAGE
# PACKAGE_VERSION
# DEVEL_VERSION
utils.addToConfig('#define PACKAGE "%s"' % PACKAGE)
utils.addToConfig('#define PACKAGE_VERSION "%s"' % PACKAGE_VERSION)
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'),
('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])
else:
utils.addToConfig('/* #undef %s */' % val[0])
env['EXTRA_LIBS'] = []
# HAVE_LIBAIKSAURUS
# AIKSAURUS_H_LOCATION
if conf.CheckLib('Aiksaurus'):
utils.addToConfig("#define HAVE_LIBAIKSAURUS 1")
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")
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')
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')
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')
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')
elif packaging_method == 'posix':
utils.addToConfig('#define USE_POSIX_PACKAGING 1')
elif packaging_method == 'mac':
utils.addToConfig('#define USE_MACOSX_PACKAGING 1')
# BOOST_POSIX
if boost_posix:
utils.addToConfig('#define BOOST_POSIX 1')
else:
utils.addToConfig('/* #undef BOOST_POSIX */')
# HAVE_PUTENV
if conf.CheckPutenv():
utils.addToConfig('#define HAVE_PUTENV 1')
else:
utils.addToConfig('/* #undef HAVE_PUTENV */')
# HAVE_DECL_ISTREAMBUF_ITERATOR
if conf.CheckIstreambufIterator():
utils.addToConfig('#define HAVE_DECL_ISTREAMBUF_ITERATOR 1')
else:
utils.addToConfig('/* #undef HAVE_DECL_ISTREAMBUF_ITERATOR */')
# MKDIR_TAKES_ONE_ARG
if conf.CheckMkdirOneArg():
utils.addToConfig('#define MKDIR_TAKES_ONE_ARG 1')
else:
utils.addToConfig('/* #undef MKDIR_TAKES_ONE_ARG */')
# HAVE_STD_COUNT
if conf.CheckStdCount():
utils.addToConfig('#define HAVE_STD_COUNT 1')
else:
utils.addToConfig('/* #undef HAVE_STD_COUNT */')
# SELECT_TYPE_ARG1
# SELECT_TYPE_ARG234
# SELECT_TYPE_ARG5
(arg1, arg234, arg5) = conf.CheckSelectArgType()
utils.addToConfig('#define SELECT_TYPE_ARG1 %s' % arg1)
utils.addToConfig('#define SELECT_TYPE_ARG234 %s' % arg234)
utils.addToConfig('#define SELECT_TYPE_ARG5 %s' % arg5)
# mkstemp
# USE_BOOST_FORMAT
# WANT_GETFILEATTRIBUTESEX_WRAPPER
utils.endConfigH()
#
# 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', 'Qt3Support4']
else:
env['QT_LIB'] = ['QtCore', 'QtGui', 'Qt3Support']
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 == 'win32':
env['SYSTEM_LIBS'] = ['shlwapi', 'zlib1']
elif platform_name == 'cygwin':
env['SYSTEM_LIBS'] = ['shlwapi', 'z']
else:
env['SYSTEM_LIBS'] = ['z']
#
# Build parameters CPPPATH etc
#
# boost is always in
env.AppendUnique(CPPPATH = ['#boost', '#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']))
BuildDir('#$BUILDDIR', 'src', duplicate = 0)
env.BuildDir('#$BUILDDIR', 'src', duplicate = 0)
print "Building all targets recursively"
print "Entering src/support"
env.Append(CPPPATH = ['.'])
env['SUBST_KEYS'] = ['LYX_DIR', 'LOCALEDIR', 'TOP_SRCDIR', 'PROGRAM_SUFFIX']
env.substFile('#$BUILDDIR/support/package.C', 'src/support/package.C.in')
supports = env.StaticLibrary(
target = '$LOCALLIBPATH/supports',
source = map(lambda a: '#$BUILDDIR/support/%s' % a, Split('''
FileMonitor.C
abort.C
chdir.C
convert.C
copy.C
environment.C
filefilterlist.C
filename.C
filetools.C
forkedcall.C
forkedcallqueue.C
forkedcontr.C
fs_extras.C
getcwd.C
kill.C
lstrings.C
lyxtime.C
lyxsum.C
mkdir.C
os.C
path.C
package.C
rename.C
socktools.C
systemcall.C
tempname.C
userinfo.C
unlink.C
'''))
)
print "Entering src/mathed"
mathed = env.StaticLibrary(
target = '$LOCALLIBPATH/mathed',
source = map(lambda a: "#$BUILDDIR/mathed/%s" % a, Split('''
textpainter.C
math_amsarrayinset.C
math_arrayinset.C
math_atom.C
math_autocorrect.C
math_biginset.C
math_binominset.C
math_boldsymbolinset.C
math_boxinset.C
math_boxedinset.C
math_braceinset.C
math_casesinset.C
math_charinset.C
math_colorinset.C
math_commentinset.C
math_data.C
math_decorationinset.C
math_deliminset.C
math_dfracinset.C
math_diffinset.C
math_diminset.C
math_dotsinset.C
math_envinset.C
math_extern.C
math_exfuncinset.C
math_exintinset.C
math_factory.C
math_fboxinset.C
math_frameboxinset.C
math_fontinset.C
math_fontoldinset.C
math_fracinset.C
math_fracbase.C
math_gridinset.C
math_hullinset.C
math_inset.C
math_kerninset.C
math_lefteqninset.C
math_liminset.C
math_macro.C
math_macroarg.C
math_macrotemplate.C
math_macrotable.C
math_makeboxinset.C
math_mathmlstream.C
math_matrixinset.C
math_nestinset.C
math_numberinset.C
math_oversetinset.C
math_parinset.C
math_parser.C
math_phantominset.C
math_rootinset.C
math_scriptinset.C
math_sizeinset.C
math_spaceinset.C
math_splitinset.C
math_sqrtinset.C
math_stackrelinset.C
math_streamstr.C
math_stringinset.C
math_substackinset.C
math_support.C
math_symbolinset.C
math_tabularinset.C
math_tfracinset.C
math_unknowninset.C
math_undersetinset.C
math_xarrowinset.C
math_xymatrixinset.C
command_inset.C
ref_inset.C
'''))
)
print "Entering src/insets"
insets = env.StaticLibrary(
target = '$LOCALLIBPATH/insets',
source = map(lambda a: "#$BUILDDIR/insets/%s" % a, Split('''
mailinset.C
ExternalSupport.C
ExternalTemplate.C
ExternalTransforms.C
render_button.C
render_graphic.C
render_preview.C
inset.C
insetbase.C
insetbibitem.C
insetbibtex.C
insetbox.C
insetbranch.C
insetcaption.C
insetcharstyle.C
insetcite.C
insetcollapsable.C
insetcommand.C
insetcommandparams.C
insetenv.C
insetert.C
insetexternal.C
insetfloat.C
insetfloatlist.C
insetfoot.C
insetfootlike.C
insetgraphicsParams.C
insetgraphics.C
insethfill.C
insetinclude.C
insetindex.C
insetlabel.C
insetlatexaccent.C
insetline.C
insetmarginal.C
insetnewline.C
insetnote.C
insetoptarg.C
insetpagebreak.C
insetquotes.C
insetref.C
insetspace.C
insetspecialchar.C
insettabular.C
insettext.C
insettoc.C
inseturl.C
insetvspace.C
insetwrap.C
'''))
)
print "Entering src/frontends"
frontends = env.StaticLibrary(
target = '$LOCALLIBPATH/frontends',
source = map(lambda a: "#$BUILDDIR/frontends/%s" % a, Split('''
Alert.C
Dialogs.C
LyXView.C
Painter.C
Timeout.C
Toolbars.C
guiapi.C
nullpainter.C
screen.C
screen.h
'''))
)
print "Entering src/frontends/qt3"
qtenv = env.Copy()
# load qt3 tools
qtenv.Tool('qt')
qtenv.Append(CPPPATH = [
'#$BUILDDIR',
'#$BUILDDIR/frontends',
'#$BUILDDIR/images',
'#$BUILDDIR/frontends/controllers',
'#$BUILDDIR/frontends/qt3',
'$QT_INC_DIR',
'.']
)
ui_files = Split('''
BiblioModuleBase.ui
BranchesModuleBase.ui
BulletsModuleBase.ui
TextLayoutModuleBase.ui
LanguageModuleBase.ui
LaTeXModuleBase.ui
MarginsModuleBase.ui
NumberingModuleBase.ui
MathsModuleBase.ui
PageLayoutModuleBase.ui
PreambleModuleBase.ui
QAboutDialogBase.ui
QAskForTextDialog.ui
QBibitemDialogBase.ui
QBibtexDialogBase.ui
QBibtexAddDialogBase.ui
QBoxDialogBase.ui
QBranchDialogBase.ui
QChangesDialogBase.ui
QCharacterDialogBase.ui
QCitationDialogBase.ui
QCitationFindDialogBase.ui
QDelimiterDialogBase.ui
QDocumentDialogBase.ui
QErrorListDialogBase.ui
QERTDialogBase.ui
QExternalDialogBase.ui
QFloatDialogBase.ui
QGraphicsDialogBase.ui
QIncludeDialogBase.ui
QIndexDialogBase.ui
QLogDialogBase.ui
QViewSourceDialogBase.ui
QMathDialogBase.ui
QMathMatrixDialogBase.ui
QNoteDialogBase.ui
QParagraphDialogBase.ui
QPrefAsciiModule.ui
QPrefColorsModule.ui
QPrefConvertersModule.ui
QPrefCopiersModule.ui
QPrefCygwinPathModule.ui
QPrefDateModule.ui
QPrefDisplayModule.ui
QPrefFileformatsModule.ui
QPrefIdentityModule.ui
QPrefKeyboardModule.ui
QPrefLanguageModule.ui
QPrefLatexModule.ui
QPrefPathsModule.ui
QPrefPrinterModule.ui
QPrefScreenFontsModule.ui
QPrefsDialogBase.ui
QPrefSpellcheckerModule.ui
QPrefUIModule.ui
QPrintDialogBase.ui
QRefDialogBase.ui
QSearchDialogBase.ui
QSendtoDialogBase.ui
QShowFileDialogBase.ui
QSpellcheckerDialogBase.ui
QTabularCreateDialogBase.ui
QTabularDialogBase.ui
QTexinfoDialogBase.ui
QThesaurusDialogBase.ui
QTocDialogBase.ui
QURLDialogBase.ui
QVSpaceDialogBase.ui
QWrapDialogBase.ui
''')
moc_files = map(lambda a: "#$BUILDDIR/frontends/qt3/%s" % a, Split('''
BulletsModule.C
emptytable.C
FileDialog_private.C
floatplacement.C
iconpalette.C
lengthcombo.C
panelstack.C
QAboutDialog.C
QBibitemDialog.C
QBibtexDialog.C
QBoxDialog.C
QBranchDialog.C
QBrowseBox.C
QChangesDialog.C
QCharacterDialog.C
QCitationDialog.C
QCommandBuffer.C
QCommandEdit.C
QContentPane.C
QDelimiterDialog.C
QDocumentDialog.C
QErrorListDialog.C
QERTDialog.C
QExternalDialog.C
QFloatDialog.C
QGraphicsDialog.C
QIncludeDialog.C
QIndexDialog.C
QLogDialog.C
QViewSourceDialog.C
QLPopupMenu.C
QLPrintDialog.C
QMathDialog.C
QMathMatrixDialog.C
QNoteDialog.C
QParagraphDialog.C
QPrefsDialog.C
QRefDialog.C
QSearchDialog.C
QSendtoDialog.C
qsetborder.C
QShowFileDialog.C
QSpellcheckerDialog.C
QDialogView.C
QTabularCreateDialog.C
QTabularDialog.C
QTexinfoDialog.C
QThesaurusDialog.C
QTocDialog.C
qttableview.C
QtView.C
QURLDialog.C
QVSpaceDialog.C
QWrapDialog.C
QLToolbar.C
socket_callback.C
validators.C
'''))
# under windows, because of the .C/.c confusion
# moc_files are not moced automatically.
# I am doing it manually here, until lyx changes
# file extension from .C to .cpp
moced_files = []
if os.name == 'nt' or sys.platform == 'cygwin':
moced_files = [qtenv.Moc(x.replace('.C', '.h')) for x in moc_files]
qt3 = qtenv.StaticLibrary(
target = '$LOCALLIBPATH/qt3',
source = map(lambda a: "#$BUILDDIR/frontends/qt3/%s" % a, Split('''
QDialogView.C
Alert_pimpl.C
Dialogs.C
FileDialog.C
LyXKeySymFactory.C
LyXScreenFactory.C
QLMenubar.C
qtTimeout.C
QAbout.C
QBibitem.C
QBibtex.C
QBox.C
QBranch.C
QChanges.C
QCharacter.C
QCitation.C
QDocument.C
QErrorList.C
QERT.C
QExternal.C
QFloat.C
QGraphics.C
QInclude.C
QIndex.C
QLImage.C
QLog.C
QViewSource.C
QLPainter.C
QLyXKeySym.C
QMath.C
QNote.C
QParagraph.C
QPrefs.C
QPrint.C
QRef.C
QSearch.C
QSendto.C
QShowFile.C
QSpellchecker.C
QTabular.C
QTabularCreate.C
QTexinfo.C
QThesaurus.C
QToc.C
QURL.C
QVSpace.C
QWorkArea.C
QWrap.C
Qt2BC.C
WorkAreaFactory.C
checkedwidgets.C
lyx_gui.C
lcolorcache.C
panelstack.C
qcoloritem.C
qfontexample.C
qfont_loader.C
qfont_metrics.C
qscreen.C
qt_helpers.C
''')) +
moc_files + moced_files +
['#$BUILDDIR/frontends/qt3/ui/' + x for x in ui_files]
)
print "Entering src/frontends/controllers"
controllers = env.StaticLibrary(
target = '$LOCALLIBPATH/controllers',
source = map(lambda a: "#$BUILDDIR/frontends/controllers/%s" % a, Split('''
Dialog.C
Kernel.C
biblio.C
character.C
frnt_lang.C
tex_helpers.C
BCView.C
ButtonController.C
ButtonPolicies.C
ControlAboutlyx.C
ControlBibtex.C
ControlBox.C
ControlBranch.C
ControlCharacter.C
ControlChanges.C
ControlCitation.C
ControlCommand.C
ControlCommandBuffer.C
ControlDocument.C
ControlErrorList.C
ControlERT.C
ControlExternal.C
ControlFloat.C
ControlGraphics.C
ControlInclude.C
ControlLog.C
ControlViewSource.C
ControlMath.C
ControlNote.C
ControlParagraph.C
ControlPreamble.C
ControlPrefs.C
ControlPrint.C
ControlRef.C
ControlSearch.C
ControlSendto.C
ControlShowFile.C
ControlSpellchecker.C
ControlTabular.C
ControlTabularCreate.C
ControlTexinfo.C
ControlThesaurus.C
ControlToc.C
ControlVSpace.C
ControlWrap.C
helper_funcs.C
helper_funcs.h
'''))
)
print "Entering src/graphics"
graphics = env.StaticLibrary(
target = '$LOCALLIBPATH/graphics',
source = map(lambda a: "#$BUILDDIR/graphics/%s" % a, Split('''
GraphicsCache.C
GraphicsCacheItem.C
GraphicsConverter.C
GraphicsImage.C
GraphicsLoader.C
GraphicsParams.C
LoaderQueue.C
GraphicsTypes.C
PreviewImage.C
PreviewLoader.C
Previews.C
'''))
)
# INCLUDED BOOST not really supported yet.
#if env['INCLUDED_BOOST']:
# env.SConscript(dirs = ['#boost/libs'], duplicate=0)
#
# Start in src directory
#
env['SUBST_KEYS'] = ['PACKAGE_VERSION', 'VERSION_INFO']
env.substFile('#$BUILDDIR/version.C', 'src/version.C.in')
lyx_source = Split('''
Bidi.C
BufferView.C
BufferView_pimpl.C
Bullet.C
BranchList.C
Chktex.C
Color.C
CutAndPaste.C
DepTable.C
FloatList.C
Floating.C
FontIterator.C
FuncStatus.C
InsetList.C
LColor.C
LaTeX.C
LaTeXFeatures.C
LyXAction.C
MenuBackend.C
ParagraphParameters.C
PrinterParams.C
Spacing.C
Thesaurus.C
ToolbarBackend.C
author.C
boost.C
box.C
buffer.C
buffer_funcs.C
bufferlist.C
bufferparams.C
bufferview_funcs.C
changes.C
chset.C
converter.C
counters.C
coordcache.C
cursor.C
cursor_slice.C
debug.C
dimension.C
dociterator.C
encoding.C
errorlist.C
exporter.C
gettext.C
factory.C
format.C
funcrequest.C
graph.C
importer.C
intl.C
insetiterator.C
kbmap.C
kbsequence.C
language.C
session.C
lengthcommon.C
lyx_cb.C
lyx_main.C
lyx_sty.C
lyxfont.C
lyxfind.C
lyxfunc.C
lyxgluelength.C
lyxlayout.C
lyxlength.C
lyxlex.C
lyxlex_pimpl.C
lyxrc.C
lyxrow.C
lyxrow_funcs.C
lyxserver.C
lyxsocket.C
lyxtextclass.C
lyxtextclasslist.C
lyxvc.C
messages.C
metricsinfo.C
mover.C
output.C
outputparams.C
output_docbook.C
output_latex.C
output_linuxdoc.C
output_plaintext.C
paragraph.C
paragraph_funcs.C
paragraph_pimpl.C
pariterator.C
SpellBase.C
rowpainter.C
sgml.C
tabular.C
tex-accent.C
tex-strings.C
texrow.C
text.C
text2.C
text3.C
TocBackend.C
toc.C
trans.C
trans_mgr.C
undo.C
vc-backend.C
version.C
vspace.C
main.C
''')
if env.has_key('USE_ASPELL') and env['USE_ASPELL']:
lyx_source += ['aspell.C']
elif env.has_key('USE_PSPELL') and env['USE_PSPELL']:
lyx_source += ['pspell.C']
elif env.has_key('USE_ISPELL') and env['USE_ISPELL']:
lyx_source += ['ispell.C']
#
# Build lyx with given frontend
#
lyx = env.Program(
target = '#$BUILDDIR/lyx',
source = map(lambda a: "#$BUILDDIR/%s" % a, lyx_source),
LIBS = [
'mathed',
'insets',
'frontends',
env['frontend'],
'controllers',
'graphics',
'supports'] +
env['BOOST_LIBRARIES'] +
env['EXTRA_LIBS'] +
env['SYSTEM_LIBS']
)
print "Entering src/client"
lyxclient = env.Program(
target = '#$BUILDDIR/client/lyxclient',
LIBS = [ 'boost_regex', 'boost_filesystem',
'supports' ] + env['socket_libs'],
source = map(lambda a: "#$BUILDDIR/client/%s" % a, Split('''
boost.C
client.C
debug.C
gettext.C
messages.C
'''))
)
print "Entering src/tex2lyx"
tex2lyx_env = env.Copy()
# the order is important here.
tex2lyx_env.Prepend(CPPPATH = ['#$BUILDDIR/tex2lyx'])
tex2lyx_env.Append(LIBPATH = ['#$LOCALLIBPATH'])
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/FloatList.C', 'src/FloatList.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/Floating.C', 'src/Floating.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/counters.C', 'src/counters.C')
# for some reason I do not know, I have to copy the header files as well.
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlayout.h', 'src/lyxlayout.h')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlayout.C', 'src/lyxlayout.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxtextclass.h', 'src/lyxtextclass.h')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxtextclass.C', 'src/lyxtextclass.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlex.C', 'src/lyxlex.C')
tex2lyx_env.fileCopy('#$BUILDDIR/tex2lyx/lyxlex_pimpl.C', 'src/lyxlex_pimpl.C')
tex2lyx = tex2lyx_env.Program(
target = '#$BUILDDIR/tex2lyx/tex2lyx',
LIBS = ['supports'] + env['BOOST_LIBRARIES'] + env['SYSTEM_LIBS'],
source = map(lambda a: "#$BUILDDIR/tex2lyx/%s" % a, Split('''
FloatList.C
Floating.C
counters.C
lyxlayout.C
lyxtextclass.C
lyxlex.C
lyxlex_pimpl.C
boost.C
context.C
gettext.C
lengthcommon.C
lyxfont.C
texparser.C
tex2lyx.C
preamble.C
math.C
table.C
text.C
'''))
)
#client = env.SConscript('#$BUILDDIR/client/SConscript', duplicate = 0)
#lyx = env.SConscript('#$BUILDDIR/SConscript', duplicate=0)
#tex2lyx = env.SConscript('#$BUILDDIR/tex2lyx/SConscript', duplicate = 0)
# avoid using full path to build them
Alias('client', lyxclient)
Alias('tex2lyx', tex2lyx)
Alias('lyx', lyx)
#Default('lyx', 'tex2lyx')
#Default('lyx')
print "Building lyx done with targets", map(str, BUILD_TARGETS)
Reference in New Issue View Git Blame Copy Permalink