/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

revision 1244 by phornby, Mon Aug 13 07:13:17 2007 UTC revision 4244 by jfenwick, Mon Feb 25 05:37:50 2013 UTC
# Line 1  Line 1 
1  #         Copyright 2006 by ACcESS MNRF  ##############################################################################
2  #  #
3  #              http://www.access.edu.au  # Copyright (c) 2003-2013 by University of Queensland
4  #       Primary Business: Queensland, Australia  # http://www.uq.edu.au
 #  Licensed under the Open Software License version 3.0  
 #     http://www.opensource.org/licenses/osl-3.0.php  
   
 # top-level Scons configuration file for all esys13 modules  
 # Begin initialisation Section  
 # all of this section just intialises default environments and helper  
 # scripts. You shouldn't need to modify this section.  
 EnsureSConsVersion(0,96,91)  
 EnsurePythonVersion(2,3)  
   
 #===============================================================  
 #   import tools:  
 import glob  
 import sys, os  
 import socket  
 # Add our extensions  
 if sys.path.count('scons')==0: sys.path.append('scons')  
 import scons_extensions  
   
 #===============================================================  
   
 tools_prefix="/usr"  
   
 #==============================================================================================      
 #      
 #    get the installation prefix  
5  #  #
6  prefix = ARGUMENTS.get('prefix', '/usr')  # Primary Business: Queensland, Australia
7    # Licensed under the Open Software License version 3.0
8  # We may also need to know where python's site-packages subdirectory lives  # http://www.opensource.org/licenses/osl-3.0.php
9  python_version = 'python%s.%s'%(sys.version_info[0],sys.version_info[1])  #
10    # Development until 2012 by Earth Systems Science Computational Center (ESSCC)
11  # Install as a standard python package in /usr/lib64 if available, else in /usr/lib  # Development since 2012 by School of Earth Sciences
12  if os.path.isdir(  prefix+"/lib64/"+python_version+"/site-packages"):  #
13     sys_dir_packages =  prefix+"/lib64/"+python_version+"/site-packages/esys"  ##############################################################################
14     sys_dir_libraries = prefix+"/lib64"  
15  else:  EnsureSConsVersion(0,98,1)
16     sys_dir_packages =  prefix+"/lib/"+python_version+"/site-packages/esys"  EnsurePythonVersion(2,5)
17     sys_dir_libraries = prefix+"/lib"  
18    import sys, os, platform, re
19  sys_dir_examples = prefix+"/share/doc/esys"  from distutils import sysconfig
20    from site_init import *
21  source_root = Dir('#.').abspath  from subprocess import PIPE, Popen
22    
23  dir_packages = os.path.join(source_root,"esys")  # Version number to check for in options file. Increment when new features are
24  dir_examples = os.path.join(source_root,"examples")  # added or existing options changed.
25  dir_libraries = os.path.join(source_root,"lib")  REQUIRED_OPTS_VERSION=201
26    
27  print " Default packages local installation:    ", dir_packages  # MS Windows support, many thanks to PH
28  print " Default library local installation  ", dir_libraries  IS_WINDOWS = (os.name == 'nt')
29  print " Default example local  installation:    ", dir_examples  
30  print "Install prefix is: ", prefix  ########################## Determine options file ############################
31  print " Default packages system installation:   ", sys_dir_packages  # 1. command line
32  print " Default library system installation     ", sys_dir_libraries  # 2. scons/<hostname>_options.py
33  print " Default example system installation:    ", sys_dir_examples  # 3. name as part of a cluster
34    options_file=ARGUMENTS.get('options_file', None)
35  #==============================================================================================      if not options_file:
36        ext_dir = os.path.join(os.getcwd(), 'scons')
37  # Default options and options help text      hostname = platform.node().split('.')[0]
38  # These are defaults and can be overridden using command line arguments or an options file.      for name in hostname, effectiveName(hostname):
39  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
40  # DO NOT CHANGE THEM HERE          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
41  # Where to install?          if os.path.isfile(options_file): break
42  #==============================================================================================      
43  #      if not os.path.isfile(options_file):
44  #    get the options file if present:      print("\nWARNING:\nOptions file %s" % options_file)
45  #      print("not found! Default options will be used which is most likely suboptimal.")
46  if ARGUMENTS.get('options_file',0):      print("It is recommended that you copy one of the TEMPLATE files in the scons/")
47     options_file = ARGUMENTS.get('options_file',0)      print("subdirectory and customize it to your needs.\n")
48  else:      options_file = None
49     from string import ascii_letters,digits  
50     hostname=""  ############################### Build options ################################
51     for s in socket.gethostname().split('.')[0]:  
52        if s in ascii_letters+digits:  default_prefix='/usr'
53           hostname+=s  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
54        else:  lapack_flavours=('none', 'clapack', 'mkl')
55           hostname+="_"  
56     options_file = os.path.join("scons",hostname+"_options.py")  vars = Variables(options_file, ARGUMENTS)
57      vars.AddVariables(
58  if os.path.isfile(options_file):    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
59     print "option file is ",options_file,"."    PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
60  else:    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
61     print "option file is ",options_file, "(not present)."    BoolVariable('verbose', 'Output full compile/link lines', False),
62  # and load it  # Compiler/Linker options
63  opts = Options(options_file, ARGUMENTS)    ('cc', 'Path to C compiler', 'default'),
64  #================================================================    ('cxx', 'Path to C++ compiler', 'default'),
65  #    ('cc_flags', 'Base C/C++ compiler flags', 'default'),
66  #   check if UMFPACK is installed on the system:    ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
67  #    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
68  uf_root=None    ('cc_extra', 'Extra C compiler flags', ''),
69  for i in [ 'UMFPACK', 'umfpack', 'ufsparse', 'UFSPARSE']:    ('cxx_extra', 'Extra C++ compiler flags', ''),
70     if os.path.isdir(os.path.join(tools_prefix,'include',i)):    ('ld_extra', 'Extra linker flags', ''),
71         uf_root=i    BoolVariable('werror','Treat compiler warnings as errors', True),
72         print i," is used form ",tools_prefix    BoolVariable('debug', 'Compile with debug flags', False),
73         break    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
74  if not uf_root==None:    ('omp_flags', 'OpenMP compiler flags', 'default'),
75     umf_path_default=os.path.join(tools_prefix,'include',uf_root)    ('omp_ldflags', 'OpenMP linker flags', 'default'),
76     umf_lib_path_default=os.path.join(tools_prefix,'lib')  # Mandatory libraries
77     umf_libs_default=['umfpack']    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
78     amd_path_default=os.path.join(tools_prefix,'include',uf_root)    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
79     amd_lib_path_default=os.path.join(tools_prefix,'lib')  # Mandatory for tests
80     amd_libs_default=['amd']    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
81     ufc_path_default=os.path.join(tools_prefix,'include',uf_root)    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
82  else:  # Optional libraries and options
83     umf_path_default=None    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
84     umf_lib_path_default=None    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
85     umf_libs_default=None    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
86     amd_path_default=None    BoolVariable('netcdf', 'Enable netCDF file support', False),
87     amd_lib_path_default=None    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
88     amd_libs_default=None    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
89     ufc_path_default=None    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
90  #    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
91  #==========================================================================    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
92  #    BoolVariable('papi', 'Enable PAPI', False),
93  #    python installation:    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
94  #    ('papi_libs', 'PAPI libraries to link with', ['papi']),
95  python_path_default=os.path.join(tools_prefix,'include','python%s.%s'%(sys.version_info[0],sys.version_info[1]))    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
96  python_lib_path_default=os.path.join(tools_prefix,'lib')    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
97  python_lib_default="python%s.%s"%(sys.version_info[0],sys.version_info[1])    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
98      ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
99  #==========================================================================    BoolVariable('umfpack', 'Enable UMFPACK', False),
100  #    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
101  #    boost installation:    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
102  #    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
103  boost_path_default=os.path.join(tools_prefix,'include')    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
104  boost_lib_path_default=os.path.join(tools_prefix,'lib')    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
105  boost_lib_default=['boost_python']    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
106  #==========================================================================    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
107  #    ('lapack_libs', 'LAPACK libraries to link with', []),
108  #    check if netCDF is installed on the system:    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
109  #    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
110  netCDF_path_default=os.path.join(tools_prefix,'include','netcdf-3')    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
111  netCDF_lib_path_default=os.path.join(tools_prefix,'lib','netcdf-3')    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
112      ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
113  if os.path.isdir(netCDF_path_default) and os.path.isdir(netCDF_lib_path_default):    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
114       useNetCDF_default='yes'    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
115       netCDF_libs_default=[ 'netcdf_c++', 'netcdf' ]  # Advanced settings
116  else:    #dudley_assemble_flags = -funroll-loops      to actually do something
117       useNetCDF_default='no'    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
118       netCDF_path_default=None    # To enable passing function pointers through python
119       netCDF_lib_path_default=None    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
120       netCDF_libs_default=None    # 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  #    compile:    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  cc_flags_default='-O3 -std=c99 -ffast-math -fpic -Wno-unknown-pragmas -ansi -pedantic-errors'    # works with dynamic libraries on windows.
127  cc_flags_debug_default='-g -O0 -ffast-math -std=c99 -fpic -Wno-unknown-pragmas -ansi -pedantic-errors'    ('build_shared', 'Build dynamic libraries only', False),
128  cxx_flags_default='--no-warn -ansi'    ('sys_libs', 'Extra libraries to link with', []),
129  cxx_flags_debug_default='--no-warn -ansi -DDOASSERT'    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
130  #==============================================================================================        ('SVN_VERSION', 'Do not use from options file', -2),
131  # Default options and options help text    ('pythoncmd', 'which python to compile with','python'),
132  # These are defaults and can be overridden using command line arguments or an options file.    ('usepython3', 'Is this a python3 build? (experimental)', False),
133  # if the options_file or ARGUMENTS do not exist then the ones listed as default here are used    ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
134  # DO NOT CHANGE THEM HERE    ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
135  opts.AddOptions(    ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
136  # Where to install esys stuff    BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
   ('incinstall', 'where the esys headers will be installed',             Dir('#.').abspath+'/include'),  
   ('libinstall', 'where the esys libraries will be installed',           dir_libraries),  
   ('pyinstall', 'where the esys python modules will be installed',       dir_packages),  
   ('exinstall', 'where the esys examples will be installed',             dir_examples),  
   ('sys_libinstall', 'where the system esys libraries will be installed',       sys_dir_libraries),  
   ('sys_pyinstall', 'where the system esys python modules will be installed',   sys_dir_packages),  
   ('sys_exinstall', 'where the system esys examples will be installed',         sys_dir_examples),  
   ('src_zipfile', 'the source zip file will be installed.',              Dir('#.').abspath+"/release/escript_src.zip"),  
   ('test_zipfile', 'the test zip file will be installed.',               Dir('#.').abspath+"/release/escript_tests.zip"),  
   ('src_tarfile', 'the source tar file will be installed.',              Dir('#.').abspath+"/release/escript_src.tar.gz"),  
   ('test_tarfile', 'the test tar file will be installed.',               Dir('#.').abspath+"/release/escript_tests.tar.gz"),  
   ('examples_tarfile', 'the examples tar file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.tar.gz"),  
   ('examples_zipfile', 'the examples zip file will be installed.',       Dir('#.').abspath+"/release/doc/escript_examples.zip"),  
   ('guide_pdf', 'name of the user guide in pdf format',                  Dir('#.').abspath+"/release/doc/user/guide.pdf"),  
   ('api_epydoc', 'name of the epydoc api docs directory',                Dir('#.').abspath+"/release/doc/epydoc"),  
   ('guide_html', 'name of the directory for user guide in html format',  Dir('#.').abspath+"/release/doc/user/html"),  
   ('api_doxygen', 'name of the doxygen api docs directory',prefix+"/release/doc/doxygen"),  
 # Compilation options  
   BoolOption('dodebug', 'Do you want a debug build?', 'no'),  
   ('options_file', "Optional file containing preferred options. Ignored if it doesn't exist (default: scons/<hostname>_options.py)", options_file),  
   ('cc_defines','C/C++ defines to use', None),  
   ('cc_flags','C compiler flags to use (Release build)', cc_flags_default),  
   ('cc_flags_debug', 'C compiler flags to use (Debug build)', cc_flags_debug_default),  
   ('cxx_flags', 'C++ compiler flags to use (Release build)', cxx_flags_default),  
   ('cxx_flags_debug', 'C++ compiler flags to use (Debug build)', cxx_flags_debug_default),  
   ('ar_flags', 'Static library archiver flags to use', None),  
   ('sys_libs', 'System libraries to link with', None),  
   ('tar_flags','flags for zip files','-c -z'),  
 # MKL  
   PathOption('mkl_path', 'Path to MKL includes', None),  
   PathOption('mkl_lib_path', 'Path to MKL libs', None),  
   ('mkl_libs', 'MKL libraries to link with', None),  
 # SCSL  
   PathOption('scsl_path', 'Path to SCSL includes', None),  
   PathOption('scsl_lib_path', 'Path to SCSL libs', None),  
   ('scsl_libs', 'SCSL libraries to link with', None),  
   ('scsl_libs_MPI', 'SCSL libraries to link with for MPI build', None),  
 # UMFPACK  
   PathOption('ufc_path', 'Path to UFconfig includes', ufc_path_default),  
   PathOption('umf_path', 'Path to UMFPACK includes', umf_path_default),  
   PathOption('umf_lib_path', 'Path to UMFPACK libs', umf_lib_path_default),  
   ('umf_libs', 'UMFPACK libraries to link with', umf_libs_default),  
 # AMD (used by UMFPACK)  
   PathOption('amd_path', 'Path to AMD includes', amd_path_default),  
   PathOption('amd_lib_path', 'Path to AMD libs', amd_lib_path_default),  
   ('amd_libs', 'AMD libraries to link with', amd_libs_default),  
 # BLAS  
   PathOption('blas_path', 'Path to BLAS includes', None),  
   PathOption('blas_lib_path', 'Path to BLAS libs', None),  
   ('blas_libs', 'BLAS libraries to link with', None),  
 # netCDF  
   ('useNetCDF', 'switch on/off the usage of netCDF', useNetCDF_default),  
   PathOption('netCDF_path', 'Path to netCDF includes', netCDF_path_default),  
   PathOption('netCDF_lib_path', 'Path to netCDF libs', netCDF_lib_path_default),  
   ('netCDF_libs', 'netCDF C++ libraries to link with', netCDF_libs_default),  
 # Python  
 # locations of include files for python  
 # FIXME: python_path should be python_inc_path and the same for boost etc.  
   PathOption('python_path', 'Path to Python includes', python_path_default),  
   PathOption('python_lib_path', 'Path to Python libs', python_lib_path_default),  
   ('python_lib', 'Python libraries to link with', python_lib_default),  
   ('python_cmd', 'Python command', 'python'),  
 # Boost  
   PathOption('boost_path', 'Path to Boost includes', boost_path_default),  
   PathOption('boost_lib_path', 'Path to Boost libs', boost_lib_path_default),  
   ('boost_lib', 'Boost libraries to link with', boost_lib_default),  
 # Doc building  
 #  PathOption('doxygen_path', 'Path to Doxygen executable', None),  
 #  PathOption('epydoc_path', 'Path to Epydoc executable', None),  
 # PAPI  
   PathOption('papi_path', 'Path to PAPI includes', None),  
   PathOption('papi_lib_path', 'Path to PAPI libs', None),  
   ('papi_libs', 'PAPI libraries to link with', None),  
 # MPI  
   BoolOption('useMPI', 'Compile parallel version using MPI', 'no'),  
137  )  )
 #=================================================================================================  
 #  
 #   Note: On the Altix the intel compilers are not automatically  
 #   detected by scons intelc.py script. The Altix has a different directory  
 #   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  
 #  
 IS_WINDOWS_PLATFORM = (os.name== "nt")  
138    
139  if IS_WINDOWS_PLATFORM:  ##################### Create environment and help text #######################
       env = Environment(tools = ['default', 'msvc'], options = opts)  
 else:  
    if os.uname()[4]=='ia64':  
       env = Environment(tools = ['default', 'intelc'], options = opts)  
       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  
    else:  
       env = Environment(tools = ['default'], options = opts)  
 Help(opts.GenerateHelpText(env))  
140    
141  #=================================================================================================  # Intel's compiler uses regular expressions improperly and emits a warning
142  #  # about failing to find the compilers. This warning can be safely ignored.
 #     Initialise Scons Build Environment  
 #     check for user environment variables we are interested in  
 try:  
    tmp = os.environ['PYTHONPATH']  
    env['ENV']['PYTHONPATH'] = tmp  
 except KeyError:  
    pass  
   
 env.PrependENVPath('PYTHONPATH', source_root)  
   
 try:  
    omp_num_threads = os.environ['OMP_NUM_THREADS']  
 except KeyError:  
    omp_num_threads = 1  
   
 env['ENV']['OMP_NUM_THREADS'] = omp_num_threads  
   
 try:  
    env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
    env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  
 except KeyError:  
    pass  
143    
144  try:  # PATH is needed so the compiler, linker and tools are found if they are not
145     tmp = os.environ['PATH']  # in default locations.
146     env['ENV']['PATH'] = tmp  env = Environment(tools = ['default'], options = vars,
147  except KeyError:                    ENV = {'PATH': os.environ['PATH']})
148     pass                    
149    
150  try:  #set the vars for clang
151     tmp = os.environ['LD_LIBRARY_PATH']  def mkclang(env):
152     env['ENV']['LD_LIBRARY_PATH'] = tmp    env['CC']='clang'
153  except KeyError:    env['CXX']='clang++'
154     pass                    
155  #==========================================================================                    
156  #  if env['tools_names'] != 'default':
157  #    Add some customer builders      zz=env['tools_names']
158  #      if 'clang' in zz:
159  py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)          zz.remove('clang')
160  env.Append(BUILDERS = {'PyCompile' : py_builder});          zz.insert(0, mkclang)
161        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
162  runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed',                        ENV = {'PATH' : os.environ['PATH']})
163                                src_suffix=env['PROGSUFFIX'], single_source=True)  
164    if options_file:
165  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});      opts_valid=False
166        if 'escript_opts_version' in env.Dictionary() and \
167  runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)          int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
168  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});              opts_valid=True
169        if opts_valid:
170            print("Using options in %s." % options_file)
171        else:
172            print("\nOptions file %s" % options_file)
173            print("is outdated! Please update the file by examining one of the TEMPLATE")
174            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
175            Exit(1)
176    
177    # Generate help text (scons -h)
178    Help(vars.GenerateHelpText(env))
179    
180    # Check for superfluous options
181    if len(vars.UnknownVariables())>0:
182        for k in vars.UnknownVariables():
183            print("Unknown option '%s'" % k)
184        Exit(1)
185    
186    #################### Make sure install directories exist #####################
187    
188    env['BUILD_DIR']=Dir(env['build_dir']).abspath
189    prefix=Dir(env['prefix']).abspath
190    env['incinstall'] = os.path.join(prefix, 'include')
191    env['bininstall'] = os.path.join(prefix, 'bin')
192    env['libinstall'] = os.path.join(prefix, 'lib')
193    env['pyinstall']  = os.path.join(prefix, 'esys')
194    if not os.path.isdir(env['bininstall']):
195        os.makedirs(env['bininstall'])
196    if not os.path.isdir(env['libinstall']):
197        os.makedirs(env['libinstall'])
198    if not os.path.isdir(env['pyinstall']):
199        os.makedirs(env['pyinstall'])
200    
201    env.Append(CPPPATH = [env['incinstall']])
202    env.Append(LIBPATH = [env['libinstall']])
203    
204    ################# Fill in compiler options if not set above ##################
205    
206    if env['cc'] != 'default': env['CC']=env['cc']
207    if env['cxx'] != 'default': env['CXX']=env['cxx']
208    
209    # version >=9 of intel C++ compiler requires use of icpc to link in C++
210    # runtimes (icc does not)
211    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
212        env['LINK'] = env['CXX']
213    
214    # default compiler/linker options
215    cc_flags = ''
216    cc_optim = ''
217    cc_debug = ''
218    omp_flags = ''
219    omp_ldflags = ''
220    fatalwarning = '' # switch to turn warnings into errors
221    sysheaderopt = '' # how to indicate that a header is a system header
222    
223    # env['CC'] might be a full path
224    cc_name=os.path.basename(env['CC'])
225    
226    if cc_name == 'icc':
227        # Intel compiler
228        # #1875: offsetof applied to non-POD types is nonstandard (in boost)
229        cc_flags    = "-std=c99 -fPIC -w2 -wd1875 -Wno-unknown-pragmas -DBLOCKTIMER -DCORE_ID1"
230        cc_optim    = "-O3 -ftz -fno-alias -ipo -xHost"
231        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
232        omp_flags   = "-openmp"
233        omp_ldflags = "-openmp -openmp_report=1"
234        fatalwarning = "-Werror"
235    elif cc_name[:3] == 'gcc':
236        # GNU C on any system
237        # note that -ffast-math is not used because it breaks isnan(),
238        # see mantis #691
239        cc_flags     = "-pedantic -Wall -fPIC -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing -finline-functions"
240        cc_optim     = "-O3"
241        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
242        omp_flags    = "-fopenmp"
243        omp_ldflags  = "-fopenmp"
244        fatalwarning = "-Werror"
245        sysheaderopt = "-isystem"
246    elif cc_name == 'cl':
247        # Microsoft Visual C on Windows
248        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
249        cc_optim     = "/O2 /Op /W3"
250        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
251        fatalwarning = "/WX"
252    elif cc_name == 'icl':
253        # Intel C on Windows
254        cc_flags     = '/EHsc /GR /MD'
255        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
256        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
257        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
258        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
259    
260    # set defaults if not otherwise specified
261    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
262    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
263    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
264    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
265    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
266    if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
267    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
268    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
269    
270    if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
271    
272    if env['usepython3']:
273        env.Append(CPPDEFINES=['ESPYTHON3'])
274    
275    # set up the autolazy values
276    if env['forcelazy'] == 'on':
277        env.Append(CPPDEFINES=['FAUTOLAZYON'])
278    elif env['forcelazy'] == 'off':
279        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
280    
281    # set up the collective resolve values
282    if env['forcecollres'] == 'on':
283        env.Append(CPPDEFINES=['FRESCOLLECTON'])
284    elif env['forcecollres'] == 'off':
285        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
286    
287    # allow non-standard C if requested
288    if env['iknowwhatimdoing']:
289        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
290    
291    # Disable OpenMP if no flags provided
292    if env['openmp'] and env['omp_flags'] == '':
293       print("OpenMP requested but no flags provided - disabling OpenMP!")
294       env['openmp'] = False
295    
296    if env['openmp']:
297        env.Append(CCFLAGS = env['omp_flags'])
298        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
299    else:
300        env['omp_flags']=''
301        env['omp_ldflags']=''
302    
303    # add debug/non-debug compiler flags
304    if env['debug']:
305        env.Append(CCFLAGS = env['cc_debug'])
306    else:
307        env.Append(CCFLAGS = env['cc_optim'])
308    
309    # always add cc_flags
310    env.Append(CCFLAGS = env['cc_flags'])
311    
312    # add system libraries
313    env.AppendUnique(LIBS = env['sys_libs'])
314    
315    
316    global_revision=ARGUMENTS.get('SVN_VERSION', None)
317    if global_revision:
318        global_revision = re.sub(':.*', '', global_revision)
319        global_revision = re.sub('[^0-9]', '', global_revision)
320        if global_revision == '': global_revision='-2'
321    else:
322      # Get the global Subversion revision number for the getVersion() method
323      try:
324        global_revision = os.popen('svnversion -n .').read()
325        global_revision = re.sub(':.*', '', global_revision)
326        global_revision = re.sub('[^0-9]', '', global_revision)
327        if global_revision == '': global_revision='-2'
328      except:
329        global_revision = '-1'
330    env['svn_revision']=global_revision
331    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
332    
333    if IS_WINDOWS:
334        if not env['build_shared']:
335            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
336            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
337    
338    ###################### Copy required environment vars ########################
339    
340    # Windows doesn't use LD_LIBRARY_PATH but PATH instead
341    if IS_WINDOWS:
342        LD_LIBRARY_PATH_KEY='PATH'
343        env['ENV']['LD_LIBRARY_PATH']=''
344    else:
345        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
346    
347  # 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
 try:  
    incinstall = env['incinstall']  
    env.Append(CPPPATH = [incinstall,])  
 except KeyError:  
    incinstall = None  
 try:  
    libinstall = env['libinstall']  
    env.Append(LIBPATH = [libinstall,]) # Adds -L for building of libescript.so libfinley.so escriptcpp.so finleycpp.so  
    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'] # all targets will install into pyinstall/esys but PYTHONPATH points at straight pyinstall so you go import esys.escript etc  
 except KeyError:  
    pyinstall = None  
 try:  
    exinstall = env['exinstall']  
 except KeyError:  
    exinstall = None  
 try:  
    sys_libinstall = env['sys_libinstall']  
 except KeyError:  
    sys_libinstall = None  
 try:  
    sys_pyinstall = env['sys_pyinstall']  
 except KeyError:  
    sys_pyinstall = None  
 try:  
    sys_exinstall = env['sys_exinstall']  
 except KeyError:  
    sys_exinstall = 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  
348    
349  if dodebug:  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
   if useMPI:  
350      try:      try:
351        flags = env['cc_flags_debug_MPI']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
352      except KeyError:      except KeyError:
353        pass          env['ENV'][key] = 1
354    else:  
355    env_export=env['env_export']
356    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','KMP_MONITOR_STACKSIZE','TMPDIR','TEMP','TMP'])
357    
358    for key in set(env_export):
359      try:      try:
360        flags = env['cc_flags_debug']          env['ENV'][key] = os.environ[key]
       env.Append(CCFLAGS = flags)  
361      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:  
362          pass          pass
    else:  
      try:  
         flags = env['cxx_flags_debug']  
         env.Append(CXXFLAGS = flags)  
      except KeyError:  
         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 = []  
   
 try:  
    tar_flags = env['tar_flags']  
    env.Replace(TARFLAGS = tar_flags)  
 except KeyError:  
    pass  
   
 try:  
    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  
   
 if useMPI:  
    mkl_libs = []  
 else:  
    try:  
       mkl_libs = env['mkl_libs']  
    except KeyError:  
       mkl_libs = []  
   
 try:  
    includes = env['scsl_path']  
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
363    
364  try:  try:
365     lib_path = env['scsl_lib_path']      env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
    env.Append(LIBPATH = [lib_path,])  
366  except KeyError:  except KeyError:
367     pass      pass
368    
369  if useMPI:  # these shouldn't be needed
370    try:  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
371      scsl_libs = env['scsl_libs_MPI']  #    try:
372    except KeyError:  #        env['ENV'][key] = os.environ[key]
373      scsl_libs = []  #    except KeyError:
374  else:  #        pass
   try:  
     scsl_libs = env['scsl_libs']  
   except KeyError:  
     scsl_libs = []  
375    
376  try:  try:
377     includes = env['umf_path']      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
    env.Append(CPPPATH = [includes,])  
378  except KeyError:  except KeyError:
379     pass      pass
380    
381  try:  ######################## Add some custom builders ############################
    lib_path = env['umf_lib_path']  
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
382    
383  if useMPI:  if env['pythoncmd']=='python':
384      umf_libs = []      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
385  else:  else:
386     try:      py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
387        umf_libs = env['umf_libs']  env.Append(BUILDERS = {'PyCompile' : py_builder});
    except KeyError:  
       umf_libs = []  
388    
389  try:  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
390     includes = env['ufc_path']  env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
391    
392  try:  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
393     includes = env['amd_path']  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
394    
395  try:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
396     lib_path = env['amd_lib_path']  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
    env.Append(LIBPATH = [lib_path,])  
 except KeyError:  
    pass  
397    
398  if useMPI:  ############################ Dependency checks ###############################
     amd_libs = []  
 else:  
    try:  
       amd_libs = env['amd_libs']  
    except KeyError:  
       amd_libs = []  
399    
400  try:  # Create a Configure() environment to check for compilers and python
401     includes = env['blas_path']  conf = Configure(env.Clone())
    env.Append(CPPPATH = [includes,])  
 except KeyError:  
    pass  
402    
403  try:  ######## Test that the compilers work
404     lib_path = env['blas_lib_path']  
405     env.Append(LIBPATH = [lib_path,])  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
406  except KeyError:      if not conf.CheckCC():
407     pass          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
408            Exit(1)
409  try:      if not conf.CheckCXX():
410     blas_libs = env['blas_libs']          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
411  except KeyError:          Exit(1)
412     blas_libs = []  else:
413        if not conf.CheckFunc('printf', language='c'):
414            print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
415            Exit(1)
416        if not conf.CheckFunc('printf', language='c++'):
417            print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
418            Exit(1)
419    
420    if conf.CheckFunc('gethostname'):
421        conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])
422    
423    ######## Python headers & library (required)
424    
425    #First we check to see if the config file has specified
426    ##Where to find the filae. Ideally, this should be automatic
427    #But we need to deal with the case where python is not in its INSTALL
428    #Directory
429    # Use the python scons is running
430    if env['pythoncmd']=='python':
431        python_inc_path=sysconfig.get_python_inc()
432        if IS_WINDOWS:
433            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
434        elif env['PLATFORM']=='darwin':
435            python_lib_path=sysconfig.get_config_var('LIBPL')
436        else:
437            python_lib_path=sysconfig.get_config_var('LIBDIR')
438    
439        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
440        if IS_WINDOWS:
441            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
442        else:
443            python_libs=['python'+sysconfig.get_python_version()]
444    
445    #if we want to use a python other than the one scons is running
446    else:
447        initstring='from __future__ import print_function;from distutils import sysconfig;'
448        if env['pythonlibname']!='':
449            python_libs=env['pythonlibname']
450        else:   # work it out by calling python    
451            if IS_WINDOWS:
452                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
453            else:
454                cmd='print("python"+sysconfig.get_python_version())'
455            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
456            python_libs=p.stdout.readline()
457            if env['usepython3']:       # This is to convert unicode str into py2 string
458                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
459            p.wait()
460            python_libs=python_libs.strip()
461    
 try:  
    useNetCDF = env['useNetCDF']  
 except KeyError:  
    useNetCDF = 'yes'  
    pass  
   
 if not useNetCDF == 'yes':  
    print "Warning: Installation is not configured with netCDF. Some I/O function may not be available."  
462        
463  if useNetCDF == 'yes':      # Now we know whether we are using python3 or not
464     try:      p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
465        includes = env['netCDF_path']      python_inc_path=p.stdout.readline()
466        env.Append(CPPPATH = [includes,])      if env['usepython3']:
467     except KeyError:           python_inc_path=python_inc_path.encode()
468        pass      p.wait()  
469        python_inc_path=python_inc_path.strip()
470     try:      if IS_WINDOWS:
471        lib_path = env['netCDF_lib_path']          cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
472        if IS_WINDOWS_PLATFORM: env['ENV']['PATH']+=";"+lib_path      elif env['PLATFORM']=='darwin':
473        env.Append(LIBPATH = [ lib_path, ])          cmd="sysconfig.get_config_var(\"LIBPL\")"
474     except KeyError:      else:
475        pass          cmd="sysconfig.get_config_var(\"LIBDIR\")"
476    
477     try:      p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
478        netCDF_libs = env['netCDF_libs']      python_lib_path=p.stdout.readline()
479     except KeyError:      if env['usepython3']:
480        netCDF_libs = [ ]          python_lib_path=python_lib_path.decode()
481  else:      p.wait()
482     netCDF_libs=[ ]      python_lib_path=python_lib_path.strip()
483    
484  try:  #Check for an override from the config file.
485     includes = env['boost_path']  #Ideally, this should be automatic
486     env.Append(CPPPATH = [includes,])  #But we need to deal with the case where python is not in its INSTALL
487  except KeyError:  #Directory
488     pass  if env['pythonlibpath']!='':
489  try:      python_lib_path=env['pythonlibpath']
490     lib_path = env['boost_lib_path']  
491     env.Append(LIBPATH = [lib_path,])  if env['pythonincpath']!='':
492  except KeyError:      python_inc_path=env['pythonincpath']
493     pass  
494  try:  
495     boost_lib = env['boost_lib']  if sysheaderopt == '':
496  except KeyError:      conf.env.AppendUnique(CPPPATH = [python_inc_path])
497     boost_lib = None  else:
498  try:      conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
499     includes = env['python_path']  
500     env.Append(CPPPATH = [includes,])  conf.env.AppendUnique(LIBPATH = [python_lib_path])
501  except KeyError:  conf.env.AppendUnique(LIBS = python_libs)
502     pass  # The wrapper script needs to find the libs
503  try:  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
504     lib_path = env['python_lib_path']  
505     env.Append(LIBPATH = [lib_path,])  if not conf.CheckCHeader('Python.h'):
506  except KeyError:      print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
507     pass      Exit(1)
508  try:  if not conf.CheckFunc('Py_Exit'):
509     python_lib = env['python_lib']      print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
510  except KeyError:      Exit(1)
511     python_lib = None  
512  try:  ## reuse conf to check for numpy header (optional)
513     doxygen_path = env['doxygen_path']  if env['usepython3']:
514  except KeyError:      # FIXME: This is until we can work out how to make the checks in python 3
515     doxygen_path = None      conf.env['numpy_h']=False
516  try:  else:
517     epydoc_path = env['epydoc_path']      if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
518  except KeyError:          conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
519     epydoc_path = None          conf.env['numpy_h']=True
520  try:      else:
521     includes = env['papi_path']          conf.env['numpy_h']=False
522     env.Append(CPPPATH = [includes,])  
523  except KeyError:  # Commit changes to environment
524     pass  env = conf.Finish()
525  try:  
526     lib_path = env['papi_lib_path']  ######## boost (required)
527     env.Append(LIBPATH = [lib_path,])  
528  except KeyError:  boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
529     pass  if sysheaderopt == '':
530  try:      env.AppendUnique(CPPPATH = [boost_inc_path])
531     papi_libs = env['papi_libs']  else:
532  except KeyError:      # This is required because we can't -isystem /usr/include since it breaks
533     papi_libs = None      # std includes
534        if os.path.normpath(boost_inc_path) == '/usr/include':
535            conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
536  try:      else:
537     src_zipfile = env.File(env['src_zipfile'])          env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
538  except KeyError:  
539     src_zipfile = None  env.AppendUnique(LIBPATH = [boost_lib_path])
540  try:  env.AppendUnique(LIBS = env['boost_libs'])
541     test_zipfile = env.File(env['test_zipfile'])  env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
542  except KeyError:  
543     test_zipfile = None  ######## numpy (required)
544  try:  
545     examples_zipfile = env.File(env['examples_zipfile'])  if not detectModule(env, 'numpy'):
546  except KeyError:      print("Cannot import numpy. If it is installed try setting your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
547     examples_zipfile = None      Exit(1)
548    
549  try:  ######## CppUnit (required for tests)
550     src_tarfile = env.File(env['src_tarfile'])  
551  except KeyError:  try:
552     src_tarfile = None      cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
553  try:      env.AppendUnique(CPPPATH = [cppunit_inc_path])
554     test_tarfile = env.File(env['test_tarfile'])      env.AppendUnique(LIBPATH = [cppunit_lib_path])
555  except KeyError:      env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
556     test_tarfile = None      env['cppunit']=True
557  try:  except:
558     examples_tarfile = env.File(env['examples_tarfile'])      env['cppunit']=False
559  except KeyError:  
560     examples_tarfile = None  ######## sympy (optional)
561    
562  try:  if detectModule(env, 'sympy'):
563     guide_pdf = env.File(env['guide_pdf'])      env['sympy'] = True
564  except KeyError:  else:
565     guide_pdf = None      print("Cannot import sympy. Symbolic toolbox and nonlinear PDEs will not be available.")
566        env['sympy'] = False
567  try:  
568     guide_html_index = env.File('index.htm',env['guide_html'])  ######## pyproj (optional)
569  except KeyError:  
570     guide_html_index = None  if detectModule(env, 'pyproj'):
571        env['pyproj'] = True
572  try:  else:
573     api_epydoc = env.Dir(env['api_epydoc'])      print("Cannot import pyproj. Inversions may not work.")
574  except KeyError:      env['pyproj'] = False
575     api_epydoc = None  
576    ######## netCDF (optional)
577  try:  
578     api_doxygen = env.Dir(env['api_doxygen'])  netcdf_inc_path=''
579  except KeyError:  netcdf_lib_path=''
580     api_doxygen = None  if env['netcdf']:
581        netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
582        env.AppendUnique(CPPPATH = [netcdf_inc_path])
583  # FIXME: exinstall and friends related to examples are not working.      env.AppendUnique(LIBPATH = [netcdf_lib_path])
584  build_target = env.Alias('build',[libinstall,incinstall,pyinstall])      env.AppendUnique(LIBS = env['netcdf_libs'])
585        env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
586  env.Default(build_target)      env.Append(CPPDEFINES = ['USE_NETCDF'])
587    
588  # Zipgets  ######## PAPI (optional)
589  env.Alias('release_src',[ src_zipfile, src_tarfile ])  
590  env.Alias('release_tests',[ test_zipfile, test_tarfile])  papi_inc_path=''
591  env.Alias('release_examples',[ examples_zipfile, examples_tarfile])  papi_lib_path=''
592  env.Alias('examples_zipfile',examples_zipfile)  if env['papi']:
593  env.Alias('examples_tarfile',examples_tarfile)      papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
594  env.Alias('api_epydoc',api_epydoc)      env.AppendUnique(CPPPATH = [papi_inc_path])
595  env.Alias('api_doxygen',api_doxygen)      env.AppendUnique(LIBPATH = [papi_lib_path])
596  env.Alias('guide_html_index',guide_html_index)      env.AppendUnique(LIBS = env['papi_libs'])
597  env.Alias('guide_pdf', guide_pdf)      env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
598  env.Alias('docs',[ 'release_examples', 'guide_pdf', api_epydoc, api_doxygen, guide_html_index])      env.Append(CPPDEFINES = ['BLOCKPAPI'])
599  env.Alias('release', ['release_src', 'release_tests', 'docs'])  
600    ######## MKL (optional)
601  env.Alias('build_tests')    # target to build all C++ tests  
602  env.Alias('build_py_tests') # target to build all python tests  mkl_inc_path=''
603  env.Alias('build_all_tests', [ 'build_tests', 'build_py_tests' ] ) # target to build all python tests  mkl_lib_path=''
604  env.Alias('run_tests', 'build_tests')   # target to run all C++ test  if env['mkl']:
605  env.Alias('py_tests', 'build_py_tests') # taget to run all released python tests      mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
606  env.Alias('all_tests', ['run_tests', 'py_tests']) # target to run all C++ and released python tests      env.AppendUnique(CPPPATH = [mkl_inc_path])
607        env.AppendUnique(LIBPATH = [mkl_lib_path])
608  # Python install - esys __init__.py      env.AppendUnique(LIBS = env['mkl_libs'])
609  init_target = env.Command(pyinstall+'/__init__.py', None, Touch('$TARGET'))      env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
610  env.Alias(init_target)      env.Append(CPPDEFINES = ['MKL'])
611    
612  # Allow sconscripts to see the env  ######## UMFPACK (optional)
613  Export(["IS_WINDOWS_PLATFORM", "env", "incinstall", "libinstall", "pyinstall", "exinstall", "dodebug", "mkl_libs", "scsl_libs", "umf_libs", "amd_libs", "blas_libs", "netCDF_libs", "useNetCDF",  
614      "boost_lib", "python_lib", "doxygen_path", "epydoc_path", "papi_libs",  umfpack_inc_path=''
615          "sys_libs", "test_zipfile", "src_zipfile", "test_tarfile", "src_tarfile", "examples_tarfile", "examples_zipfile",  umfpack_lib_path=''
616          "guide_pdf", "guide_html_index", "api_epydoc", "api_doxygen", "useMPI" ])  if env['umfpack']:
617        umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
618  # End initialisation section      env.AppendUnique(CPPPATH = [umfpack_inc_path])
619  # Begin configuration section      env.AppendUnique(LIBPATH = [umfpack_lib_path])
620  # adds this file and the scons option directore to the source tar      env.AppendUnique(LIBS = env['umfpack_libs'])
621  release_srcfiles=[env.File('SConstruct'),]+[ env.File(x) for x in glob.glob('scons/*.py') ]      env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
622  release_testfiles=[env.File('README_TESTS'),]      env.Append(CPPDEFINES = ['UMFPACK'])
623  env.Zip(src_zipfile, release_srcfiles)  
624  env.Zip(test_zipfile, release_testfiles)  ######## LAPACK (optional)
625  try:  
626     env.Tar(src_tarfile, release_srcfiles)  if env['lapack']=='mkl' and not env['mkl']:
627     env.Tar(test_tarfile, release_testfiles)      print("mkl_lapack requires MKL!")
628  except AttributeError:      Exit(1)
629     pass  
630  # Insert new components to be build here  env['uselapack'] = env['lapack']!='none'
631  # FIXME: might be nice to replace this verbosity with a list of targets and some  lapack_inc_path=''
632  # FIXME: nifty python to create the lengthy but very similar env.Sconscript lines  lapack_lib_path=''
633  # Third Party libraries  if env['uselapack']:
634  env.SConscript(dirs = ['tools/CppUnitTest/src'], build_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)      header='clapack.h'
635  # C/C++ Libraries      if env['lapack']=='mkl':
636  env.SConscript(dirs = ['paso/src'], build_dir='build/$PLATFORM/paso', duplicate=0)          env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
637  # bruce is removed for now as it doesn't really do anything          header='mkl_lapack.h'
638  # env.SConscript(dirs = ['bruce/src'], build_dir='build/$PLATFORM/bruce', duplicate=0)      lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
639  env.SConscript(dirs = ['escript/src'], build_dir='build/$PLATFORM/escript', duplicate=0)      env.AppendUnique(CPPPATH = [lapack_inc_path])
640  env.SConscript(dirs = ['esysUtils/src'], build_dir='build/$PLATFORM/esysUtils', duplicate=0)      env.AppendUnique(LIBPATH = [lapack_lib_path])
641  env.SConscript(dirs = ['finley/src'], build_dir='build/$PLATFORM/finley', duplicate=0)      env.AppendUnique(LIBS = env['lapack_libs'])
642  env.SConscript(dirs = ['modellib/py_src'], build_dir='build/$PLATFORM/modellib', duplicate=0)      env.Append(CPPDEFINES = ['USE_LAPACK'])
643  env.SConscript(dirs = ['doc'], build_dir='build/$PLATFORM/doc', duplicate=0)  
644  env.SConscript(dirs = ['pyvisi/py_src'], build_dir='build/$PLATFORM/pyvisi', duplicate=0)  ######## Silo (optional)
645  env.SConscript(dirs = ['pycad/py_src'], build_dir='build/$PLATFORM/pycad', duplicate=0)  
646    silo_inc_path=''
647  # added by Ben Cumming  silo_lib_path=''
648  env.SConscript(dirs = ['pythonMPI/src'], build_dir='build/$PLATFORM/pythonMPI', duplicate=0)  if env['silo']:
649  #env.SConscript(dirs = ['../test'], build_dir='../test/build', duplicate=0)      silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
650        env.AppendUnique(CPPPATH = [silo_inc_path])
651        env.AppendUnique(LIBPATH = [silo_lib_path])
652        # Note that we do not add the libs since they are only needed for the
653        # weipa library and tools.
654        #env.AppendUnique(LIBS = [env['silo_libs']])
655    
656    ######## VSL random numbers (optional)
657    if env['vsl_random']:
658        env.Append(CPPDEFINES = ['MKLRANDOM'])
659    
660    ######## VisIt (optional)
661    
662    visit_inc_path=''
663    visit_lib_path=''
664    if env['visit']:
665        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
666        env.AppendUnique(CPPPATH = [visit_inc_path])
667        env.AppendUnique(LIBPATH = [visit_lib_path])
668    
669    ######## MPI (optional)
670    
671    if env['mpi']=='no':
672        env['mpi']='none'
673    
674    env['usempi'] = env['mpi']!='none'
675    mpi_inc_path=''
676    mpi_lib_path=''
677    if env['usempi']:
678        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
679        env.AppendUnique(CPPPATH = [mpi_inc_path])
680        env.AppendUnique(LIBPATH = [mpi_lib_path])
681        env.AppendUnique(LIBS = env['mpi_libs'])
682        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
683        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
684        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
685        # On the other hand MPT and OpenMPI don't define the latter so we have to
686        # do that here
687        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
688            env.Append(CPPDEFINES = ['MPI_INCLUDED'])
689    
690    ######## BOOMERAMG (optional)
691    
692    if env['mpi'] == 'none': env['boomeramg'] = False
693    
694    boomeramg_inc_path=''
695    boomeramg_lib_path=''
696    if env['boomeramg']:
697        boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
698        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
699        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
700        env.AppendUnique(LIBS = env['boomeramg_libs'])
701        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
702        env.Append(CPPDEFINES = ['BOOMERAMG'])
703    
704    ######## ParMETIS (optional)
705    
706    if not env['usempi']: env['parmetis'] = False
707    
708    parmetis_inc_path=''
709    parmetis_lib_path=''
710    if env['parmetis']:
711        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
712        env.AppendUnique(CPPPATH = [parmetis_inc_path])
713        env.AppendUnique(LIBPATH = [parmetis_lib_path])
714        env.AppendUnique(LIBS = env['parmetis_libs'])
715        env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
716        env.Append(CPPDEFINES = ['USE_PARMETIS'])
717    
718    ######## gmsh (optional, for tests)
719    
720    try:
721        p=Popen(['gmsh', '-info'], stderr=PIPE)
722        _,e=p.communicate()
723        if e.split().count("MPI"):
724            env['gmsh']='m'
725        else:
726            env['gmsh']='s'
727    except OSError:
728        env['gmsh']=False
729    
730    ######## PDFLaTeX (for documentation)
731    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
732        env['pdflatex']=True
733    else:
734        env['pdflatex']=False
735    
736    ######################## Summarize our environment ###########################
737    
738    # keep some of our install paths first in the list for the unit tests
739    env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
740    env.PrependENVPath('PYTHONPATH', prefix)
741    env['ENV']['ESCRIPT_ROOT'] = prefix
742    
743    if not env['verbose']:
744        env['CCCOMSTR'] = "Compiling $TARGET"
745        env['CXXCOMSTR'] = "Compiling $TARGET"
746        env['SHCCCOMSTR'] = "Compiling $TARGET"
747        env['SHCXXCOMSTR'] = "Compiling $TARGET"
748        env['ARCOMSTR'] = "Linking $TARGET"
749        env['LINKCOMSTR'] = "Linking $TARGET"
750        env['SHLINKCOMSTR'] = "Linking $TARGET"
751        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
752        env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
753        env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
754        env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
755        #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
756    
757    print("")
758    print("*** Config Summary (see config.log and lib/buildvars for details) ***")
759    print("Escript/Finley revision %s"%global_revision)
760    print("  Install prefix:  %s"%env['prefix'])
761    print("          Python:  %s"%sysconfig.PREFIX)
762    print("           boost:  %s"%env['boost_prefix'])
763    print("           numpy:  YES")
764    if env['usempi']:
765        print("             MPI:  YES (flavour: %s)"%env['mpi'])
766    else:
767        print("             MPI:  DISABLED")
768    if env['uselapack']:
769        print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
770    else:
771        print("          LAPACK:  DISABLED")
772    d_list=[]
773    e_list=[]
774    for i in 'debug','openmp','boomeramg','mkl','netcdf','papi','parmetis','pyproj','silo','sympy','umfpack','visit','vsl_random':
775        if env[i]: e_list.append(i)
776        else: d_list.append(i)
777    for i in e_list:
778        print("%16s:  YES"%i)
779    for i in d_list:
780        print("%16s:  DISABLED"%i)
781    if env['cppunit']:
782        print("         CppUnit:  FOUND")
783    else:
784        print("         CppUnit:  NOT FOUND")
785    if env['gmsh']=='m':
786        print("            gmsh:  FOUND, MPI-ENABLED")
787    elif env['gmsh']=='s':
788        print("            gmsh:  FOUND")
789    else:
790        print("            gmsh:  NOT FOUND")
791    if env['numpy_h']:
792        print("   numpy headers:  FOUND")
793    else:
794        print("   numpy headers:  NOT FOUND")
795    print("   vsl_random:  %s"%env['vsl_random'])
796        
797    if ((fatalwarning != '') and (env['werror'])):
798        print("  Treating warnings as errors")
799    else:
800        print("  NOT treating warnings as errors")
801    print("")
802    
803    ####################### Configure the subdirectories #########################
804    
805    from grouptest import *
806    
807    TestGroups=[]
808    
809    # keep an environment without warnings-as-errors
810    dodgy_env=env.Clone()
811    
812    # now add warnings-as-errors flags. This needs to be done after configuration
813    # because the scons test files have warnings in them
814    if ((fatalwarning != '') and (env['werror'])):
815        env.Append(CCFLAGS = fatalwarning)
816    
817    Export(
818      ['env',
819       'dodgy_env',
820       'IS_WINDOWS',
821       'TestGroups'
822      ]
823    )
824    
825    env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
826    env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
827    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
828    env.SConscript(dirs = ['escript/src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
829    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
830    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
831    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
832    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
833    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
834    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
835    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
836    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
837    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
838    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
839    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
840    
841    
842    ######################## Populate the buildvars file #########################
843    
844    # remove obsolete file
845    if not env['usempi']:
846        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
847        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
848    
849    # Try to extract the boost version from version.hpp
850    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
851    boostversion='unknown'
852    try:
853        for line in boosthpp:
854            ver=re.match(r'#define BOOST_VERSION (\d+)',line)
855            if ver:
856                boostversion=ver.group(1)
857    except StopIteration:
858        pass
859    boosthpp.close()
860    
861    
862    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
863    buildvars.write("svn_revision="+str(global_revision)+"\n")
864    buildvars.write("prefix="+prefix+"\n")
865    buildvars.write("cc="+env['CC']+"\n")
866    buildvars.write("cxx="+env['CXX']+"\n")
867    if env['pythoncmd']=='python':
868        buildvars.write("python="+sys.executable+"\n")
869        buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
870    else:
871        buildvars.write("python="+env['pythoncmd']+"\n")
872        p=Popen([env['pythoncmd'], '-c', 'from __future__ import print_function;import sys;print(str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2]))'], stdout=PIPE)
873        verstring=p.stdout.readline().strip()
874        p.wait()
875        buildvars.write("python_version="+verstring+"\n")
876    buildvars.write("boost_inc_path="+boost_inc_path+"\n")
877    buildvars.write("boost_lib_path="+boost_lib_path+"\n")
878    buildvars.write("boost_version="+boostversion+"\n")
879    buildvars.write("debug=%d\n"%int(env['debug']))
880    buildvars.write("openmp=%d\n"%int(env['openmp']))
881    buildvars.write("mpi=%s\n"%env['mpi'])
882    buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
883    buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
884    buildvars.write("lapack=%s\n"%env['lapack'])
885    buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
886    for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
887        buildvars.write("%s=%d\n"%(i, int(env[i])))
888        if env[i]:
889            buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
890            buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
891    buildvars.close()
892    
893    ################### Targets to build and install libraries ###################
894    
895    target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
896    env.Alias('target_init', [target_init])
897    # delete buildvars upon cleanup
898    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
899    
900    # The headers have to be installed prior to build in order to satisfy
901    # #include <paso/Common.h>
902    env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
903    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
904    
905    env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
906    env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
907    
908    env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
909    env.Alias('install_escript', ['build_escript', 'install_escript_lib', 'install_escriptcpp_lib', 'install_escript_py'])
910    
911    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
912    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
913    
914    env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
915    env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
916    
917    env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
918    env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
919    
920    env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
921    env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
922    
923    env.Alias('build_weipa', ['install_weipa_headers', 'build_weipa_lib', 'build_weipacpp_lib'])
924    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
925    
926    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
927    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
928    
929    # Now gather all the above into some easy targets: build_all and install_all
930    build_all_list = []
931    build_all_list += ['build_esysUtils']
932    build_all_list += ['build_paso']
933    build_all_list += ['build_escript']
934    build_all_list += ['build_pasowrap']
935    build_all_list += ['build_dudley']
936    build_all_list += ['build_finley']
937    build_all_list += ['build_ripley']
938    build_all_list += ['build_weipa']
939    if not IS_WINDOWS: build_all_list += ['build_escriptreader']
940    if env['usempi']:   build_all_list += ['build_pythonMPI']
941    build_all_list += ['build_escriptconvert']
942    env.Alias('build_all', build_all_list)
943    
944    install_all_list = []
945    install_all_list += ['target_init']
946    install_all_list += ['install_esysUtils']
947    install_all_list += ['install_paso']
948    install_all_list += ['install_escript']
949    install_all_list += ['install_pasowrap']
950    install_all_list += ['install_dudley']
951    install_all_list += ['install_finley']
952    install_all_list += ['install_ripley']
953    install_all_list += ['install_weipa']
954    if not IS_WINDOWS: install_all_list += ['install_escriptreader']
955    install_all_list += ['install_downunder_py']
956    install_all_list += ['install_modellib_py']
957    install_all_list += ['install_pycad_py']
958    if env['usempi']:   install_all_list += ['install_pythonMPI']
959    install_all_list += ['install_escriptconvert']
960    env.Alias('install_all', install_all_list)
961    
962    # Default target is install
963    env.Default('install_all')
964    
965    ################## Targets to build and run the test suite ###################
966    
967    if not env['cppunit']:
968        test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
969        env.Alias('run_tests', test_msg)
970    env.Alias('run_tests', ['install_all'])
971    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
972    env.Alias('build_full',['install_all','build_tests','build_py_tests'])
973    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
974    
975    ##################### Targets to build the documentation #####################
976    
977    env.Alias('pdfdocs',['user_pdf', 'install_pdf', 'cookbook_pdf', 'inversion_pdf'])
978    env.Alias('basedocs', ['pdfdocs','examples_tarfile', 'examples_zipfile', 'api_doxygen'])
979    env.Alias('docs', ['basedocs', 'sphinxdoc'])
980    env.Alias('release_prep', ['docs', 'install_all'])
981    env.Alias('release_prep_old', ['basedocs', 'api_epydoc', 'install_all'])
982    
983    
984    # The test scripts are always generated, this target allows us to
985    # generate the testscripts without doing a full build
986    env.Alias('testscripts',[])
987    
988  syslib_install_target = env.installDirectory(sys_libinstall,libinstall)  if not IS_WINDOWS:
989  syspy_install_target = env.installDirectory(sys_pyinstall,pyinstall,recursive=True)      try:
990            utest=open('utest.sh','w')
991            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix, False))
992            for tests in TestGroups:
993                utest.write(tests.makeString())
994            utest.close()
995            Execute(Chmod('utest.sh', 0o755))
996            print("Generated utest.sh.")
997            # This version contains only python tests - I want this to be usable
998            # From a binary only install if you have the test files
999            utest=open('itest.sh','w')
1000            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix, True))
1001            for tests in TestGroups:
1002              if tests.exec_cmd=='$PYTHONRUNNER ':
1003                utest.write(tests.makeString())
1004            utest.close()
1005            Execute(Chmod('itest.sh', 0o755))
1006            print("Generated itest.sh.")        
1007        except IOError:
1008            print("Error attempting to write unittests file.")
1009            Exit(1)
1010    
1011        # delete utest.sh upon cleanup
1012        env.Clean('target_init', 'utest.sh')
1013        env.Clean('target_init', 'itest.sh')
1014    
1015        # Make sure that the escript wrapper is in place
1016        if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
1017            print("Copying escript wrapper.")
1018            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
1019    
 install_target = env.Alias("install", env.Flatten([syslib_install_target, syspy_install_target]) )  

Legend:
Removed from v.1244  
changed lines
  Added in v.4244

  ViewVC Help
Powered by ViewVC 1.1.26