/[escript]/branches/4.0fordebian/SConstruct
ViewVC logotype

Diff of /branches/4.0fordebian/SConstruct

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

revision 786 by gross, Tue Jul 25 04:58:05 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_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_tests.tar.gz"),  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
56    ('examples_tarfile', 'the examples tar file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  lapack_flavours=('none', 'clapack', 'mkl')
57    ('examples_zipfile', 'the examples zip file will be installed.', Dir('#.').abspath+"/release/doc/escript_examples.zip"),  
58    ('guide_pdf', 'name of the user guide in pdf format', Dir('#.').abspath+"/release/doc/user/guide.pdf"),  vars = Variables(options_file, ARGUMENTS)
59    ('api_epydoc', 'name of the epydoc api docs directory',Dir('#.').abspath+"/release/doc/epydoc"),  vars.AddVariables(
60    ('guide_html', 'name of the directory for user guide in html format', Dir('#.').abspath+"/release/doc/user/html"),    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
61  # Compilation options    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
62    BoolOption('dodebug', 'Do you want a debug build?', 'no'),    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
63    ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/hostname_options.py)", options_file),    BoolVariable('verbose', 'Output full compile/link lines', False),
64    ('cc_defines','C/C++ defines to use', None),  # Compiler/Linker options
65    ('cc_flags','C compiler flags to use (Release build)', '-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas'),    ('cxx', 'Path to C++ compiler', 'default'),
66    ('cc_flags_debug', 'C compiler flags to use (Debug build)', '-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas'),    ('cc_flags', 'Base C++ compiler flags', 'default'),
67    ('cxx_flags', 'C++ compiler flags to use (Release build)', '--no-warn -ansi'),    ('cc_optim', 'Additional C++ flags for a non-debug build', 'default'),
68    ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', '--no-warn -ansi -DDOASSERT -DDOPROF'),    ('cc_debug', 'Additional C++ flags for a debug build', 'default'),
69    ('cc_flags_MPI','C compiler flags to use (Release MPI build)', '-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -fno-alias -c99 -w1 -fpic -wd161'),    ('cxx_extra', 'Extra C++ compiler flags', ''),
70    ('cc_flags_debug_MPI', 'C compiler flags to use (Debug MPI build)', '-g -O0 -c99 -w1 -fpic -wd161'),    ('ld_extra', 'Extra linker flags', ''),
71    ('cxx_flags_MPI', 'C++ compiler flags to use (Release MPI build)', '-ansi -wd1563 -wd161'),    BoolVariable('werror','Treat compiler warnings as errors', True),
72    ('cxx_flags_debug_MPI', 'C++ compiler flags to use (Debug MPI build)', '-ansi -DDOASSERT -DDOPROF -wd1563 -wd161'),    BoolVariable('debug', 'Compile with debug flags', False),
73    ('ar_flags', 'Static library archiver flags to use', None),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74    ('sys_libs', 'System libraries to link with', None),    ('omp_flags', 'OpenMP compiler flags', 'default'),
75    ('tar_flags','flags for zip files','-c -z'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76  # MKL  # Mandatory libraries
77    PathOption('mkl_path', 'Path to MKL includes', None),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78    PathOption('mkl_lib_path', 'Path to MKL libs', None),    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79    ('mkl_libs', 'MKL libraries to link with', None),  # Mandatory for tests
80  # SCSL    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81    PathOption('scsl_path', 'Path to SCSL includes', None),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82    PathOption('scsl_lib_path', 'Path to SCSL libs', None),  # Optional libraries and options
83    ('scsl_libs', 'SCSL libraries to link with', None),    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84    ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85  # UMFPACK    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86    PathOption('umf_path', 'Path to UMF includes', None),    BoolVariable('netcdf', 'Enable netCDF file support', False),
87    PathOption('umf_lib_path', 'Path to UMF libs', None),    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88    ('umf_libs', 'UMF libraries to link with', None),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89  # Python    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90  # locations of include files for python    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91    PathOption('python_path', 'Path to Python includes', '/usr/include/python%s.%s'%(sys.version_info[0],sys.version_info[1])),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92    PathOption('python_lib_path', 'Path to Python libs', '/usr/lib'),    BoolVariable('papi', 'Enable PAPI', False),
93    ('python_lib', 'Python libraries to link with', ["python%s.%s"%(sys.version_info[0],sys.version_info[1]),]),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
94  # Boost    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95    PathOption('boost_path', 'Path to Boost includes', '/usr/include'),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96    PathOption('boost_lib_path', 'Path to Boost libs', '/usr/lib'),    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97    ('boost_lib', 'Boost libraries to link with', ['boost_python',]),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98  # Doc building    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99  #  PathOption('doxygen_path', 'Path to Doxygen executable', None),    BoolVariable('umfpack', 'Enable UMFPACK', False),
100  #  PathOption('epydoc_path', 'Path to Epydoc executable', None),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101  # PAPI    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102    PathOption('papi_path', 'Path to PAPI includes', None),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103    PathOption('papi_lib_path', 'Path to PAPI libs', None),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104    ('papi_libs', 'PAPI libraries to link with', None),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105  # MPI    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106    BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),    ('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.
143  # path and in some locations the "modules" facility is used to support  
144  # multiple compiler versions. This forces the need to import the users PATH  # PATH is needed so the compiler, linker and tools are found if they are not
145  # environment which isn't the "scons way"  # in default locations.
146  # 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)  env = Environment(tools = ['default'], options = vars,
147  # FIXME: Perhaps a modification to intelc.py will allow better support for ia64 on altix                    ENV = {'PATH': os.environ['PATH']})
148    
149  if os.name != "nt" and os.uname()[4]=='ia64':  # set the vars for clang
150     env = Environment(ENV = {'PATH':path}, tools = ['default', 'intelc'], options = opts)  def mkclang(env):
151     env['ENV']['PATH'] = path      env['CXX']='clang++'
152     env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
153     env['ENV']['PYTHONPATH'] = python_path  if env['tools_names'] != 'default':
154     if env['CXX'] == 'icpc':      zz=env['tools_names']
155        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      if 'clang' in zz:
156  elif os.name == "nt":          zz.remove('clang')
157     env = Environment(tools = ['default', 'intelc'], options = opts)          zz.insert(0, mkclang)
158     env['ENV']['PYTHONPATH'] = python_path      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:  else:
304     env = Environment(tools = ['default'], options = opts)      env['omp_flags']=''
305     env['ENV']['PATH'] = path      env['omp_ldflags']=''
    env['ENV']['LD_LIBRARY_PATH'] = ld_library_path  
    env['ENV']['PYTHONPATH'] = python_path  
306    
307  # Setup help for options  env['buildvars']['openmp']=int(env['openmp'])
 Help(opts.GenerateHelpText(env))  
308    
309  # Add some customer builders  # add debug/non-debug compiler flags
310  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  env['buildvars']['debug']=int(env['debug'])
311  env.Append(BUILDERS = {'PyCompile' : py_builder});  if env['debug']:
312        env.Append(CCFLAGS = env['cc_debug'])
313    else:
314        env.Append(CCFLAGS = env['cc_optim'])
315    
316    # always add cc_flags
317    env.Append(CCFLAGS = env['cc_flags'])
318    
319    # add system libraries
320    env.AppendUnique(LIBS = env['sys_libs'])
321    
322  if env['PLATFORM'] == "win32":  # determine svn revision
323     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix='.exe', single_source=True)  global_revision=ARGUMENTS.get('SVN_VERSION', None)
324    if global_revision:
325        global_revision = re.sub(':.*', '', global_revision)
326        global_revision = re.sub('[^0-9]', '', global_revision)
327        if global_revision == '': global_revision='-2'
328  else:  else:
329     runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', single_source=True)    # Get the global Subversion revision number for the getVersion() method
330  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});    try:
331        global_revision = os.popen('svnversion -n .').read()
332        global_revision = re.sub(':.*', '', global_revision)
333        global_revision = re.sub('[^0-9]', '', global_revision)
334        if global_revision == '': global_revision='-2'
335      except:
336        global_revision = '-1'
337    env['svn_revision']=global_revision
338    env['buildvars']['svn_revision']=global_revision
339    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
340    
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:
360        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
361    
362  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  env['LD_LIBRARY_PATH_KEY']=LD_LIBRARY_PATH_KEY
 env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  
363    
364  # Convert the options which are held in environment variable into python variables for ease of handling and configure compilation options  # the following env variables are exported for the unit tests
365  try:  
366     incinstall = env['incinstall']  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None    
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,])  
    env.PrependENVPath('LD_LIBRARY_PATH', libinstall)  
    if env['PLATFORM'] == "win32":  
       env.PrependENVPath('PATH', libinstall)  
       env.PrependENVPath('PATH', env['boost_lib_path'])  
 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:  
    useMPI = env['useMPI']  
 except KeyError:  
    useMPI = None    
 try:  
    cc_defines = env['cc_defines']  
    env.Append(CPPDEFINES = cc_defines)  
 except KeyError:  
    pass  
 if dodebug:  
   if useMPI:  
367      try:      try:
368        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
369      except KeyError:      except KeyError:
370        pass          env['ENV'][key] = 1
371    else:                        
372    env_export=env['env_export']
373    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
374    
375    for key in set(env_export):
376      try:      try:
377        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
378      except KeyError:      except KeyError:
       pass  
 else:  
   if useMPI:  
    try:  
      flags = env['cc_flags_MPI']  
      env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
   else:  
    try:  
       flags = env['cc_flags']  
       env.Append(CCFLAGS = flags)  
    except KeyError:  
       pass  
 if dodebug:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_debug_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
    else:  
      try:  
         flags = env['cxx_flags_debug']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
379          pass          pass
 else:  
    if useMPI:  
      try:  
         flags = env['cxx_flags_MPI']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
    else:  
      try:  
         flags = env['cxx_flags']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         pass  
 try:  
    flags = env['ar_flags']  
    env.Append(ARFLAGS = flags)  
 except KeyError:  
    ar_flags = None    
 try:  
    sys_libs = env['sys_libs']  
 except KeyError:  
    sys_libs = ''  
380    
381  try:  try:
382     tar_flags = env['tar_flags']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Replace(TARFLAGS = tar_flags)  
383  except KeyError:  except KeyError:
384     pass      pass
385    
386  try:  if IS_OSX:
    includes = env['mkl_path']  
    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  
 if useMPI:    
   try:  
     scsl_libs = env['scsl_libs_MPI']  
   except KeyError:  
     scsl_libs = ''  
 else:          
387    try:    try:
388      scsl_libs = env['scsl_libs']      env.PrependENVPath('DYLD_LIBRARY_PATH', os.environ['DYLD_LIBRARY_PATH'])
389    except KeyError:    except KeyError:
390      scsl_libs = ''      pass
 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:  
    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    
391    
392    
393  try:  # these shouldn't be needed
394     src_zipfile = env.File(env['src_zipfile'])  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
395  except KeyError:  #    try:
396     src_zipfile = None    #        env['ENV'][key] = os.environ[key]
397  try:  #    except KeyError:
398     test_zipfile = env.File(env['test_zipfile'])  #        pass
 except KeyError:  
    test_zipfile = None    
 try:  
    examples_zipfile = env.File(env['examples_zipfile'])  
 except KeyError:  
    examples_zipfile = None    
399    
400  try:  try:
401     src_tarfile = env.File(env['src_tarfile'])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
 except KeyError:  
    src_tarfile = None    
 try:  
    test_tarfile = env.File(env['test_tarfile'])  
 except KeyError:  
    test_tarfile = None    
 try:  
    examples_tarfile = env.File(env['examples_tarfile'])  
402  except KeyError:  except KeyError:
403     examples_tarfile = None        pass
404    
405  try:  ######################## Add some custom builders ############################
    guide_pdf = env.File(env['guide_pdf'])  
 except KeyError:  
    guide_pdf = None    
406    
407  try:  if env['pythoncmd']=='python':
408     guide_html_index = env.File('index.htm',env['guide_html'])      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
409  except KeyError:  else:
410     guide_html_index = 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     api_epydoc = env.Dir(env['api_epydoc'])  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
415  except KeyError:  
416     api_epydoc = 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_examples',[ examples_zipfile, examples_tarfile])  
 env.Alias('api_epydoc',api_epydoc)  
 env.Alias('docs',[ 'release_examples', guide_pdf, guide_html_index, api_epydoc])  
 env.Alias('release', ['release_src', 'release_tests', 'docs'])  
 env.Alias('build_tests')    # target to build all C++ tests  
 env.Alias('build_py_tests') # target to build all python tests  
 env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests  
 env.Alias('run_tests', 'build_tests')   # target to run all C++ test  
 env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests  
 env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests  
   
 # Python install - esys __init__.py  
 init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))  
 env.Alias(init_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", "papi_libs",  
         "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile",  
         "guide_pdf", "guide_html_index", "api_epydoc", "useMPI"])  
   
 # 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 = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
 # env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  
   
 # added by Ben Cumming  
 env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)  

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

  ViewVC Help
Powered by ViewVC 1.1.26