/[escript]/branches/diaplayground/SConstruct
ViewVC logotype

Diff of /branches/diaplayground/SConstruct

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 700 by gross, Thu Apr 6 00:13:40 2006 UTC revision 4640 by jfenwick, Fri Jan 31 00:56:51 2014 UTC
# Line 1  Line 1 
1  #          Copyright 2006 by ACcESS MNRF                    ##############################################################################
 #                                                            
 #              http://www.access.edu.au                      
 #       Primary Business: Queensland, Australia              
 #  Licensed under the Open Software License version 3.0      
 #     http://www.opensource.org/licenses/osl-3.0.php        
 #                                                            
2  #  #
3    # Copyright (c) 2003-2013 by University of Queensland
4    # http://www.uq.edu.au
5  #  #
6    # Primary Business: Queensland, Australia
7    # Licensed under the Open Software License version 3.0
8    # http://www.opensource.org/licenses/osl-3.0.php
9    #
10    # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11    # Development since 2012 by School of Earth Sciences
12    #
13    ##############################################################################
14    
15  # top-level Scons configuration file for all esys13 modules  EnsureSConsVersion(0,98,1)
16  # Begin initialisation Section  EnsurePythonVersion(2,5)
17  # all of this section just intialises default environments and helper  
18  # scripts. You shouldn't need to modify this section.  import atexit, sys, os, platform, re
19  EnsureSConsVersion(0,96,91)  from distutils import sysconfig
20  EnsurePythonVersion(2,3)  from dependencies import *
21    from site_init import *
22  # import tools:  
23  import glob  # Version number to check for in options file. Increment when new features are
24  import sys, os  # added or existing options changed.
25  # Add our extensions  REQUIRED_OPTS_VERSION=201
26  if sys.path.count('scons')==0: sys.path.append('scons')  
27  import scons_extensions  # MS Windows support, many thanks to PH
28    IS_WINDOWS = (os.name == 'nt')
29  # Default options and options help text  
30  # These are defaults and can be overridden using command line arguments or an options file.  IS_OSX = (os.uname()[0] == 'Darwin')
31  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used  
32  # DO NOT CHANGE THEM HERE  ########################## Determine options file ############################
33  if ARGUMENTS.get('options_file',0):  # 1. command line
34     options_file = ARGUMENTS.get('options_file',0)  # 2. scons/<hostname>_options.py
35  else:  # 3. name as part of a cluster
36     import socket  options_file=ARGUMENTS.get('options_file', None)
37     from string import ascii_letters,digits  if not options_file:
38     hostname=""      ext_dir = os.path.join(os.getcwd(), 'scons')
39     for s in socket.gethostname().split('.')[0]:      hostname = platform.node().split('.')[0]
40        if s in ascii_letters+digits:      for name in hostname, effectiveName(hostname):
41           hostname+=s          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
42        else:          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
43           hostname+="_"          if os.path.isfile(options_file): break
44     options_file = "scons/"+hostname+"_options.py"  
45    if not os.path.isfile(options_file):
46  opts = Options(options_file, ARGUMENTS)      print("\nWARNING:\nOptions file %s" % options_file)
47  opts.AddOptions(      print("not found! Default options will be used which is most likely suboptimal.")
48  # Where to install esys stuff      print("We recommend that you copy one of the TEMPLATE files in the scons/")
49    ('incinstall', 'where the esys headers will be installed', Dir('#.').abspath+'/include'),      print("subdirectory and customize it to your needs.\n")
50    ('libinstall', 'where the esys libraries will be installed', Dir('#.').abspath+'/lib'),      options_file = None
51    ('pyinstall', 'where the esys python modules will be installed', Dir('#.').abspath),  
52    ('src_zipfile', 'the source zip file will be installed.', Dir('#.').abspath+"/release/escript_src.zip"),  ############################### Build options ################################
53    ('test_zipfile', 'the test zip file will be installed.', Dir('#.').abspath+"/release/escript_src_tests.zip"),  
54    ('src_tarfile', 'the source tar file will be installed.', Dir('#.').abspath+"/release/escript_src.tar.gz"),  default_prefix='/usr'
55    ('test_tarfile', 'the test tar file will be installed.', Dir('#.').abspath+"/release/escript_src_tests.tar.gz"),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
56    ('doc', 'where the doc files will be installed', Dir('#.').abspath+'/release/doc'),  lapack_flavours=('none', 'clapack', 'mkl')
57    
58  # Compilation options  vars = Variables(options_file, ARGUMENTS)
59    BoolOption('dodebug', 'Do you want a debug build?', 'no'),  vars.AddVariables(
60    ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/hostname_options.py)", options_file),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
61    ('cc_defines','C/C++ defines to use', None),    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
62    ('cc_flags','C compiler flags to use (Release build)', '-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
63    ('cc_flags_debug', 'C compiler flags to use (Debug build)', '-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas'),    BoolVariable('verbose', 'Output full compile/link lines', False),
64    ('cxx_flags', 'C++ compiler flags to use (Release build)', '--no-warn -ansi'),  # Compiler/Linker options
65    ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', '--no-warn -ansi -DDOASSERT -DDOPROF'),    ('cxx', 'Path to C++ compiler', 'default'),
66    ('ar_flags', 'Static library archiver flags to use', None),    ('cc_flags', 'Base C++ compiler flags', 'default'),
67    ('sys_libs', 'System libraries to link with', None),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
68    ('tar_flags','flags for zip files','-c -z'),    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
69  # MKL    ('cxx_extra', 'Extra C++ compiler flags', ''),
70    PathOption('mkl_path', 'Path to MKL includes', None),    ('ld_extra', 'Extra linker flags', ''),
71    PathOption('mkl_lib_path', 'Path to MKL libs', None),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('mkl_libs', 'MKL libraries to link with', None),    BoolVariable('debug', 'Compile with debug flags', False),
73  # SCSL    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74    PathOption('scsl_path', 'Path to SCSL includes', None),    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    PathOption('scsl_lib_path', 'Path to SCSL libs', None),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76    ('scsl_libs', 'SCSL libraries to link with', None),  # Mandatory libraries
77  # UMFPACK    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    PathOption('umf_path', 'Path to UMF includes', None),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79    PathOption('umf_lib_path', 'Path to UMF libs', None),  # Mandatory for tests
80    ('umf_libs', 'UMF libraries to link with', None),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81  # Python    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82  # locations of include files for python  # Optional libraries and options
83    PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85    ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86  # Boost    BoolVariable('netcdf', 'Enable netCDF file support', False),
87    PathOption('boost_path', 'Path to Boost includes', '/usr/include'),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89    ('boost_lib', 'Boost libraries to link with', ['boost_python',]),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90  # Doc building    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    PathOption('doxygen_path', 'Path to Doxygen executable', None),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92    PathOption('epydoc_path', 'Path to Epydoc executable', None),    BoolVariable('papi', 'Enable PAPI', False),
93    PathOption('epydoc_pythonpath', 'Path to Epydoc python files', None),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
94  # PAPI    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    PathOption('papi_path', 'Path to PAPI includes', None),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96    PathOption('papi_lib_path', 'Path to PAPI libs', None),    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97    ('papi_libs', 'PAPI libraries to link with', None),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98      ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99      BoolVariable('umfpack', 'Enable UMFPACK', False),
100      ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101      ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102      BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103      ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104      ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105      EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106      ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107      ('lapack_libs', 'LAPACK libraries to link with', []),
108      BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109      ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
110      ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111      BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112      ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113      ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114      BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
115    # Advanced settings
116      #dudley_assemble_flags = -funroll-loops      to actually do something
117      ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
118      # To enable passing function pointers through python
119      BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
120      # An option for specifying the compiler tools (see windows branch)
121      ('tools_names', 'Compiler tools to use', ['default']),
122      ('env_export', 'Environment variables to be passed to tools',[]),
123      EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124      EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
125      # finer control over library building, intel aggressive global optimisation
126      # works with dynamic libraries on windows.
127      ('build_shared', 'Build dynamic libraries only', False),
128      ('sys_libs', 'Extra libraries to link with', []),
129      ('escript_opts_version', 'Version of options file (do not specify on command line)'),
130      ('SVN_VERSION', 'Do not use from options file', -2),
131      ('pythoncmd', 'which python to compile with','python'),
132      ('usepython3', 'Is this a python3 build? (experimental)', False),
133      ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
134      ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
135      ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
136      BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
137  )  )
138    
139  # Initialise Scons Build Environment  ##################### Create environment and help text #######################
 # check for user environment variables we are interested in  
 try:  
    python_path = os.environ['PYTHONPATH']  
 except KeyError:  
    python_path = ''  
 try:  
    path = os.environ['PATH']  
 except KeyError:  
    path = ''  
 try:  
    ld_library_path = os.environ['LD_LIBRARY_PATH']  
 except KeyError:  
    ld_library_path = ''  
140    
141  # Note: On the Altix the intel compilers are not automatically  # Intel's compiler uses regular expressions improperly and emits a warning
142  # detected by scons intelc.py script. The Altix has a different directory  # about failing to find the compilers. This warning can be safely ignored.
 # path and in some locations the "modules" facility is used to support  
 # multiple compiler versions. This forces the need to import the users PATH  
 # environment which isn't the "scons way"  
 # This doesn't impact linux and windows which will use the default compiler (g++ or msvc, or the intel compiler if it is installed on both platforms)  
 # FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix  
   
 if os.name != "nt" and os.uname()[4]=='ia64':  
    env = Environment(ENV = {'PATH':path}, tools = ['default', 'intelc'], options = opts)  
    env['ENV']['PATH'] = path  
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
    if env['CXX'] == 'icpc':  
       env['LINK'] = env['CXX'] # version >=9 of intel c++ compiler requires use of icpc to link in C++ runtimes (icc does not). FIXME: this behaviour could be directly incorporated into scons intelc.py  
 elif os.name == "nt":  
    # FIXME: Need to implement equivalent of ld library path for windoze  
    env = Environment(tools = ['default', 'intelc'], options = opts)  
    env['ENV']['PYTHONPATH'] = python_path  
 else:  
    env = Environment(tools = ['default'], options = opts)  
    env['ENV']['PATH'] = path  
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
143    
144  # Setup help for options  # PATH is needed so the compiler, linker and tools are found if they are not
145  Help(opts.GenerateHelpText(env))  # in default locations.
146    env = Environment(tools = ['default'], options = vars,
147                      ENV = {'PATH': os.environ['PATH']})
148    
149    # set the vars for clang
150    def mkclang(env):
151        env['CXX']='clang++'
152    
153    if env['tools_names'] != 'default':
154        zz=env['tools_names']
155        if 'clang' in zz:
156            zz.remove('clang')
157            zz.insert(0, mkclang)
158        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
159                          ENV = {'PATH' : os.environ['PATH']})
160    
161    if options_file:
162        opts_valid=False
163        if 'escript_opts_version' in env.Dictionary() and \
164            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
165                opts_valid=True
166        if opts_valid:
167            print("Using options in %s." % options_file)
168        else:
169            print("\nOptions file %s" % options_file)
170            print("is outdated! Please update the file by examining one of the TEMPLATE")
171            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
172            Exit(1)
173    
174    # Generate help text (scons -h)
175    Help(vars.GenerateHelpText(env))
176    
177    # Check for superfluous options
178    if len(vars.UnknownVariables())>0:
179        for k in vars.UnknownVariables():
180            print("Unknown option '%s'" % k)
181        Exit(1)
182    
183    # create dictionary which will be populated with info for buildvars file
184    env['buildvars']={}
185    # create list which will be populated with warnings if there are any
186    env['warnings']=[]
187    
188    #################### Make sure install directories exist #####################
189    
190    env['BUILD_DIR']=Dir(env['build_dir']).abspath
191    prefix=Dir(env['prefix']).abspath
192    env['buildvars']['prefix']=prefix
193    env['incinstall'] = os.path.join(prefix, 'include')
194    env['bininstall'] = os.path.join(prefix, 'bin')
195    env['libinstall'] = os.path.join(prefix, 'lib')
196    env['pyinstall']  = os.path.join(prefix, 'esys')
197    if not os.path.isdir(env['bininstall']):
198        os.makedirs(env['bininstall'])
199    if not os.path.isdir(env['libinstall']):
200        os.makedirs(env['libinstall'])
201    if not os.path.isdir(env['pyinstall']):
202        os.makedirs(env['pyinstall'])
203    
204    env.Append(CPPPATH = [env['incinstall']])
205    env.Append(LIBPATH = [env['libinstall']])
206    
207    ################# Fill in compiler options if not set above ##################
208    
209    if env['cxx'] != 'default': env['CXX']=env['cxx']
210    
211    # version >=9 of intel C++ compiler requires use of icpc to link in C++
212    # runtimes (icc does not)
213    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
214        env['LINK'] = env['CXX']
215    
216    # default compiler/linker options
217    cc_flags = ''
218    cc_optim = ''
219    cc_debug = ''
220    omp_flags = ''
221    omp_ldflags = ''
222    fatalwarning = '' # switch to turn warnings into errors
223    sysheaderopt = '' # how to indicate that a header is a system header
224    
225    # env['CC'] might be a full path
226    cc_name=os.path.basename(env['CXX'])
227    
228    if cc_name == 'icpc':
229        # Intel compiler
230        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
231        # removed -std=c99 because icpc doesn't like it and we aren't using c anymore
232        cc_flags    = "-fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
233        cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
234        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
235        omp_flags   = "-openmp"
236        omp_ldflags = "-openmp -openmp_report=1"
237        fatalwarning = "-Werror"
238    elif cc_name[:3] == 'g++':
239        # GNU C on any system
240        # note that -ffast-math is not used because it breaks isnan(),
241        # see mantis #691
242        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
243        cc_optim     = "-O3"
244        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
245        omp_flags    = "-fopenmp"
246        omp_ldflags  = "-fopenmp"
247        fatalwarning = "-Werror"
248        sysheaderopt = "-isystem"
249    elif cc_name == 'cl':
250        # Microsoft Visual C on Windows
251        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
252        cc_optim     = "/O2 /Op /W3"
253        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
254        fatalwarning = "/WX"
255    elif cc_name == 'icl':
256        # Intel C on Windows
257        cc_flags     = '/EHsc /GR /MD'
258        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
259        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
260        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
261        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
262    
263    env['sysheaderopt']=sysheaderopt
264    
265    # set defaults if not otherwise specified
266    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
267    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
268    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
269    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
270    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
271    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
272    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
273    
274    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
275    
276    if env['usepython3']:
277        env.Append(CPPDEFINES=['ESPYTHON3'])
278    
279    # set up the autolazy values
280    if env['forcelazy'] == 'on':
281        env.Append(CPPDEFINES=['FAUTOLAZYON'])
282    elif env['forcelazy'] == 'off':
283        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
284    
285    # set up the collective resolve values
286    if env['forcecollres'] == 'on':
287        env.Append(CPPDEFINES=['FRESCOLLECTON'])
288    elif env['forcecollres'] == 'off':
289        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
290    
291    # allow non-standard C if requested
292    if env['iknowwhatimdoing']:
293        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
294    
295    # Disable OpenMP if no flags provided
296    if env['openmp'] and env['omp_flags'] == '':
297       env['warnings'].append("OpenMP requested but no flags provided - disabling OpenMP!")
298       env['openmp'] = False
299    
300    if env['openmp']:
301        env.Append(CCFLAGS = env['omp_flags'])
302        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
303    else:
304        env['omp_flags']=''
305        env['omp_ldflags']=''
306    
307  # Add some customer builders  env['buildvars']['openmp']=int(env['openmp'])
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
 env.Append(BUILDERS = {'PyCompile' : py_builder});  
308    
309  if env['PLATFORM'] == "win32":  # add debug/non-debug compiler flags
310     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  env['buildvars']['debug']=int(env['debug'])
311    if env['debug']:
312        env.Append(CCFLAGS = env['cc_debug'])
313  else:  else:
314     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)      env.Append(CCFLAGS = env['cc_optim'])
 env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  
315    
316  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  # always add cc_flags
317  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  env.Append(CCFLAGS = env['cc_flags'])
318    
319  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  # add system libraries
320  try:  env.AppendUnique(LIBS = env['sys_libs'])
321     incinstall = env['incinstall']  
322     env.Append(CPPPATH = [incinstall,])  # determine svn revision
323  except KeyError:  global_revision=ARGUMENTS.get('SVN_VERSION', None)
324     incinstall = None    if global_revision:
325  try:      global_revision = re.sub(':.*', '', global_revision)
326     libinstall = env['libinstall']      global_revision = re.sub('[^0-9]', '', global_revision)
327     env.Append(LIBPATH = [libinstall,])      if global_revision == '': global_revision='-2'
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
 except KeyError:  
    libinstall = None    
 try:  
    pyinstall = env['pyinstall']+'/esys' # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  
    env.PrependENVPath('PYTHONPATH', env['pyinstall'])  
 except KeyError:  
    pyinstall = None    
 try:  
    dodebug = env['dodebug']  
 except KeyError:  
    dodebug = None    
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = [cc_defines,])  
 except KeyError:  
    pass  
 if dodebug:  
    try:  
       flags = env['cc_flags_debug']  
       env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
328  else:  else:
329     try:    # Get the global Subversion revision number for the getVersion() method
330        flags = env['cc_flags']    try:
331        env.Append(CCFLAGS = flags)      global_revision = os.popen('svnversion -n .').read()
332     except KeyError:      global_revision = re.sub(':.*', '', global_revision)
333        pass      global_revision = re.sub('[^0-9]', '', global_revision)
334        if global_revision == '': global_revision='-2'
335  if dodebug:    except:
336     try:      global_revision = '-1'
337        flags = env['cxx_flags_debug']  env['svn_revision']=global_revision
338        env.Append(CXXFLAGS = flags)  env['buildvars']['svn_revision']=global_revision
339     except KeyError:  env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
340        pass  
341    if IS_WINDOWS:
342        if not env['build_shared']:
343            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
344            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
345    
346    # VSL random numbers
347    env['buildvars']['vsl_random']=int(env['vsl_random'])
348    if env['vsl_random']:
349        env.Append(CPPDEFINES = ['MKLRANDOM'])
350    
351    env['IS_WINDOWS']=IS_WINDOWS
352    
353    ###################### Copy required environment vars ########################
354    
355    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
356    if IS_WINDOWS:
357        LD_LIBRARY_PATH_KEY='PATH'
358        env['ENV']['LD_LIBRARY_PATH']=''
359  else:  else:
360     try:      LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
       flags = env['cxx_flags']  
       env.Append(CXXFLAGS = flags)  
    except KeyError:  
       pass  
361    
362  try:  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None    
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = ''  
363    
364  try:  # the following env variables are exported for the unit tests
    tar_flags = env['tar_flags']  
    env.Replace(TARFLAGS = tar_flags)  
 except KeyError:  
    pass  
365    
366  try:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
367     includes = env['mkl_path']      try:
368     env.Append(CPPPATH = [includes,])          env['ENV'][key] = os.environ[key]
369  except KeyError:      except KeyError:
370     pass          env['ENV'][key] = 1
371    
372  try:  env_export=env['env_export']
373     lib_path = env['mkl_lib_path']  env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
374    
375  try:  for key in set(env_export):
376     mkl_libs = env['mkl_libs']      try:
377  except KeyError:          env['ENV'][key] = os.environ[key]
378     mkl_libs = ''      except KeyError:
379  try:          pass
    includes = env['scsl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['scsl_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    scsl_libs = env['scsl_libs']  
 except KeyError:  
    scsl_libs = ''  
 try:  
    includes = env['umf_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['umf_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    umf_libs = env['umf_libs']  
 except KeyError:  
    umf_libs = ''  
 try:  
    includes = env['boost_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['boost_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    boost_lib = env['boost_lib']  
 except KeyError:  
    boost_lib = None    
 try:  
    includes = env['python_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['python_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    python_lib = env['python_lib']  
 except KeyError:  
    python_lib = None    
 try:  
    doxygen_path = env['doxygen_path']  
 except KeyError:  
    doxygen_path = None    
 try:  
    epydoc_path = env['epydoc_path']  
 except KeyError:  
    epydoc_path = None    
 try:  
    epydoc_pythonpath = env['epydoc_pythonpath']  
 except KeyError:  
    epydoc_pythonpath = None    
 try:  
    includes = env['papi_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
 try:  
    lib_path = env['papi_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
 try:  
    papi_libs = env['papi_libs']  
 except KeyError:  
    papi_libs = None    
380    
381  try:  try:
382     src_zipfile = env['src_zipfile']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
383  except KeyError:  except KeyError:
384     src_zipfile = None        pass
385    
386    if IS_OSX:
387      try:
388        env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
389      except KeyError:
390        pass
391    
392  try:  
393     test_zipfile = env['test_zipfile']  # these shouldn't be needed
394  except KeyError:  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
395     test_zipfile = None    #    try:
396    #        env['ENV'][key] = os.environ[key]
397    #    except KeyError:
398    #        pass
399    
400  try:  try:
401     src_tarfile = env['src_tarfile']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
402  except KeyError:  except KeyError:
403     src_tarfile = None        pass
404    
405    ######################## Add some custom builders ############################
406    
407  try:  if env['pythoncmd']=='python':
408     test_tarfile = env['test_tarfile']      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
409  except KeyError:  else:
410     test_tarfile = None        py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
411    env.Append(BUILDERS = {'PyCompile' : py_builder});
412    
413  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
414     doc = env['doc']  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
415  except KeyError:  
416     doc = None    runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
417    env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
418    
419    epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
420    env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
421    
422    ############################ Dependency checks ###############################
423    
424    ######## Compiler
425    env=checkCompiler(env)
426    
427    ######## Python headers & library (required)
428    env=checkPython(env)
429    
430    ######## boost & boost-python (required)
431    env=checkBoost(env)
432    
433    ######## numpy (required) and numpy headers (optional)
434    env=checkNumpy(env)
435    
436    ######## CppUnit (required for tests)
437    env=checkCppUnit(env)
438    
439    ######## optional python modules (sympy, pyproj)
440    env=checkOptionalModules(env)
441    
442    ######## optional dependencies (netCDF, PAPI, MKL, UMFPACK, Lapack, Silo, ...)
443    env=checkOptionalLibraries(env)
444    
445    ######## PDFLaTeX (for documentation)
446    env=checkPDFLatex(env)
447    
448    # keep some of our install paths first in the list for the unit tests
449    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
450    env.PrependENVPath('PYTHONPATH', prefix)
451    env['ENV']['ESCRIPT_ROOT'] = prefix
452    
453    if not env['verbose']:
454        env['CXXCOMSTR'] = "Compiling $TARGET"
455        env['SHCXXCOMSTR'] = "Compiling $TARGET"
456        env['ARCOMSTR'] = "Linking $TARGET"
457        env['LINKCOMSTR'] = "Linking $TARGET"
458        env['SHLINKCOMSTR'] = "Linking $TARGET"
459        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
460        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
461        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
462        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
463        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
464    
465    ####################### Configure the subdirectories #########################
466    
467    # remove obsolete files
468    if not env['usempi']:
469        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
470        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
471    
472    from grouptest import *
473    TestGroups=[]
474    
475    # keep an environment without warnings-as-errors
476    dodgy_env=env.Clone()
477    
478    # now add warnings-as-errors flags. This needs to be done after configuration
479    # because the scons test files have warnings in them
480    if ((fatalwarning != '') and (env['werror'])):
481        env.Append(CCFLAGS = fatalwarning)
482    
483    Export(
484      ['env',
485       'dodgy_env',
486       'IS_WINDOWS',
487       'TestGroups'
488      ]
489    )
490    
491    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
492    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
493    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
494    env.SConscript(dirs = ['escript/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
495    
496    #This will pull in the escriptcore/py_src and escriptcore/test
497    env.SConscript(dirs = ['escriptcore/src'], variant_dir='$BUILD_DIR/$PLATFORM/escriptcore', duplicate=0)
498    #env.SConscript(dirs = ['escript/test'], variant_dir='$BUILD_DIR/$PLATFORM/escript/test', duplicate=0)
499    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
500    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
501    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
502    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
503    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
504    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
505    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
506    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
507    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
508    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
509    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
510    
511    
512    ######################## Populate the buildvars file #########################
513    
514    write_buildvars(env)
515    
516    ################### Targets to build and install libraries ###################
517    
518    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
519    env.Alias('target_init', [target_init])
520    # delete buildvars upon cleanup
521    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
522    
523    # The headers have to be installed prior to build in order to satisfy
524    # #include <paso/Common.h>
525    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
526    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
527    
528    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
529    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
530    
531    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
532    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escriptcore_py', 'install_escript_py'])
533    
534    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
535    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
536    
537    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
538    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
539    
540    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
541    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
542    
543    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
544    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
545    
546    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
547    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
548    
549    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
550    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
551    
552    # Now gather all the above into some easy targets: build_all and install_all
553    build_all_list = []
554    build_all_list += ['build_esysUtils']
555    build_all_list += ['build_paso']
556    build_all_list += ['build_escript']
557    build_all_list += ['build_pasowrap']
558    build_all_list += ['build_dudley']
559    build_all_list += ['build_finley']
560    build_all_list += ['build_ripley']
561    build_all_list += ['build_weipa']
562    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
563    if env['usempi']:   build_all_list += ['build_pythonMPI']
564    build_all_list += ['build_escriptconvert']
565    env.Alias('build_all', build_all_list)
566    
567    install_all_list = []
568    install_all_list += ['target_init']
569    install_all_list += ['install_esysUtils']
570    install_all_list += ['install_paso']
571    install_all_list += ['install_escript']
572    install_all_list += ['install_pasowrap']
573    install_all_list += ['install_dudley']
574    install_all_list += ['install_finley']
575    install_all_list += ['install_ripley']
576    install_all_list += ['install_weipa']
577    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
578    install_all_list += ['install_downunder_py']
579    install_all_list += ['install_modellib_py']
580    install_all_list += ['install_pycad_py']
581    if env['usempi']:   install_all_list += ['install_pythonMPI']
582    install_all_list += ['install_escriptconvert']
583    env.Alias('install_all', install_all_list)
584    
585    # Default target is install
586    env.Default('install_all')
587    
588    ################## Targets to build and run the test suite ###################
589    
590    if not env['cppunit']:
591        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C++ unit tests, CppUnit not found!";exit 1')
592        env.Alias('run_tests', test_msg)
593        env.Alias('build_tests', '')
594    env.Alias('run_tests', ['install_all'])
595    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
596    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
597    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
598    
599    ##################### Targets to build the documentation #####################
600    
601    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
602    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
603    env.Alias('docs', ['basedocs', 'sphinxdoc'])
604    env.Alias('release_prep', ['docs', 'install_all'])
605    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
606    
607    # The test scripts are always generated, this target allows us to
608    # generate the testscripts without doing a full build
609    env.Alias('testscripts',[])
610    
611    if not IS_WINDOWS:
612        generateTestScripts(env, TestGroups)
613    
614    
615    
616    ######################## Summarize our environment ###########################
617    def print_summary():
618        print("")
619        print("*** Config Summary (see config.log and <prefix>/lib/buildvars for details) ***")
620        print("Escript/Finley revision %s"%global_revision)
621        print("  Install prefix:  %s"%env['prefix'])
622        print("          Python:  %s"%sysconfig.PREFIX)
623        print("           boost:  %s"%env['boost_prefix'])
624        if env['numpy_h']:
625            print("           numpy:  YES (with headers)")
626        else:
627            print("           numpy:  YES (without headers)")
628        if env['usempi']:
629            print("             MPI:  YES (flavour: %s)"%env['mpi'])
630        else:
631            print("             MPI:  DISABLED")
632        if env['uselapack']:
633            print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
634        else:
635            print("          LAPACK:  DISABLED")
636        d_list=[]
637        e_list=[]
638        for i in 'debug','openmp','boomeramg','gdal','mkl','netcdf','papi','parmetis','pyproj','scipy','silo','sympy','umfpack','visit','vsl_random':
639            if env[i]: e_list.append(i)
640            else: d_list.append(i)
641        for i in e_list:
642            print("%16s:  YES"%i)
643        for i in d_list:
644            print("%16s:  DISABLED"%i)
645        if env['cppunit']:
646            print("         CppUnit:  FOUND")
647        else:
648            print("         CppUnit:  NOT FOUND")
649        if env['gmsh']=='m':
650            print("            gmsh:  FOUND, MPI-ENABLED")
651        elif env['gmsh']=='s':
652            print("            gmsh:  FOUND")
653        else:
654            print("            gmsh:  NOT FOUND")
655    
656        if ((fatalwarning != '') and (env['werror'])):
657            print("  Treating warnings as errors")
658        else:
659            print("  NOT treating warnings as errors")
660        print("")
661        for w in env['warnings']:
662            print("WARNING: %s"%w)
663    
664    atexit.register(print_summary)
665    
 # Zipgets  
 env.Default(libinstall)  
 env.Default(incinstall)  
 env.Default(pyinstall)  
 env.Alias('release_src',[ src_zipfile, src_tarfile ])  
 env.Alias('release_tests',[ test_zipfile, test_tarfile])  
 env.Alias('release', ['release_src', 'release_tests'])  
 env.Alias('docs')  
 env.Alias('build_tests')  
 env.Alias('build_py_tests')  
 env.Alias('local_py_tests')  
 env.Alias('run_tests',['build_tests'])  
 env.Alias('py_tests', ['build_py_tests'])  
 env.Alias('all_tests', ['run_tests', 'py_tests'])  
   
 # Python install - esys __init__.py  
 # This is just an empty file but stills need to be touched so add a special target and Command. Note you can't use the scons Touch() function as it will not  
 # create the file if it doesn't exist  
 env.Command(pyinstall+'/__init__.py', None, 'touch $TARGET')  
   
 # Allow sconscripts to see the env  
 Export(["env", "incinstall", "libinstall", "pyinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs",  
     "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "epydoc_pythonpath", "papi_libs",  
         "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "doc" ])  
   
 # End initialisation section  
 # Begin configuration section  
 # adds this file and the scons option directore to the source tar  
 release_srcfiles=[env.File('SConstruct'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]  
 release_testfiles=[env.File('README_TESTS'),]  
 env.Zip(src_zipfile,release_srcfiles)  
 env.Zip(test_zipfile, release_testfiles)  
 env.Tar(src_tarfile, release_srcfiles)  
 env.Tar(test_tarfile, release_testfiles)  
   
 # Insert new components to be build here  
 # FIXME: might be nice to replace this verbosity with a list of targets and some  
 # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines  
 # Third Party libraries  
 env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 # C/C++ Libraries  
 env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)  
 env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)  
 env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)  
 env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)  
 env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)  
 #env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
   
 # FIXME:need to be incorporated into build system  
 # FIXME: 'doc/SConstruct']  
 # FIXME: 'doc/SConstruct']  

Legend:
Removed from v.700  
changed lines
  Added in v.4640

  ViewVC Help
Powered by ViewVC 1.1.26