/[escript]/trunk/SConstruct
ViewVC logotype

Diff of /trunk/SConstruct

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

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

Legend:
Removed from v.1164  
changed lines
  Added in v.3982

  ViewVC Help
Powered by ViewVC 1.1.26