/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1387  
changed lines
  Added in v.3975

  ViewVC Help
Powered by ViewVC 1.1.26