/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1248  
changed lines
  Added in v.4167

  ViewVC Help
Powered by ViewVC 1.1.26