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

Diff of /branches/diaplayground/SConstruct

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

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

Legend:
Removed from v.690  
changed lines
  Added in v.5085

  ViewVC Help
Powered by ViewVC 1.1.26