/[escript]/branches/mvexpr/SConstruct
ViewVC logotype

Diff of /branches/mvexpr/SConstruct

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

revision 3096 by caltinay, Thu Aug 19 01:40:52 2010 UTC revision 3967 by jfenwick, Mon Sep 17 04:02:58 2012 UTC
# Line 1  Line 1 
   
1  ########################################################  ########################################################
2  #  #
3  # Copyright (c) 2003-2010 by University of Queensland  # Copyright (c) 2003-2012 by University of Queensland
4  # Earth Systems Science Computational Center (ESSCC)  # Earth Systems Science Computational Center (ESSCC)
5  # http://www.uq.edu.au/esscc  # http://www.uq.edu.au/esscc
6  #  #
# Line 11  Line 10 
10  #  #
11  ########################################################  ########################################################
12    
13    EnsureSConsVersion(0,98,1)
14    EnsurePythonVersion(2,5)
15    
16  EnsureSConsVersion(0,96,91)  import sys, os, platform, re
17  EnsurePythonVersion(2,3)  from distutils import sysconfig
18    from site_init import *
19  import sys, os, re, socket, platform, stat  import subprocess
20  # For copy()  from subprocess import PIPE, Popen
21  import shutil  
22    # Version number to check for in options file. Increment when new features are
23  # Add our extensions  # added or existing options changed.
24  if os.path.isdir('scons'): sys.path.append('scons')  REQUIRED_OPTS_VERSION=201
 import scons_extensions  
   
 # Use /usr/lib64 if available, else /usr/lib  
 usr_lib = '/usr/lib'  
 if os.path.isfile('/usr/lib64/libc.so'): usr_lib = '/usr/lib64'  
   
 # The string python2.4 or python2.5  
 python_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])  
25    
26  # MS Windows support, many thanks to PH  # MS Windows support, many thanks to PH
27  IS_WINDOWS_PLATFORM = (os.name== "nt")  IS_WINDOWS = (os.name == 'nt')
28    
29  prefix = ARGUMENTS.get('prefix', Dir('#.').abspath)  ########################## Determine options file ############################
30    # 1. command line
31  #Holds names of variables from the calling environment which need to be passed  # 2. scons/<hostname>_options.py
32  #to tools  # 3. name as part of a cluster
 env_export=[]  
   
 #Determine where to read options from use:  
 #1. command line  
 #2. scons/<hostname>_options.py  
 #3. name as part of a cluster  
33  options_file=ARGUMENTS.get('options_file', None)  options_file=ARGUMENTS.get('options_file', None)
 effective_hostname=socket.gethostname().split('.')[0]  
34  if not options_file:  if not options_file:
35    mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)      ext_dir = os.path.join(os.getcwd(), 'scons')
36    options_file = os.path.join("scons",mangledhostname+"_options.py")      hostname = platform.node().split('.')[0]
37    #If there is no options file with that name see if there is a substitute      for name in hostname, effectiveName(hostname):
38    if not os.path.isfile(options_file):          mangledhostname = re.sub('[^0-9a-zA-Z]', '_', hostname)
39      effective_hostname = scons_extensions.effectiveName(effective_hostname)          options_file = os.path.join(ext_dir, mangledhostname+'_options.py')
40      mangledhostname = re.sub("[^0-9a-zA-Z]", "_", effective_hostname)          if os.path.isfile(options_file): break
     options_file = os.path.join("scons",mangledhostname+"_options.py")  
41    
42  if not os.path.isfile(options_file):  if not os.path.isfile(options_file):
43    print "Options file not found (expected '%s')" % options_file      print("\nWARNING:\nOptions file %s" % options_file)
44    options_file = False      print("not found! Default options will be used which is most likely suboptimal.")
45  else:      print("It is recommended that you copy one of the TEMPLATE files in the scons/")
46    print "Options file is", options_file      print("subdirectory and customize it to your needs.\n")
47        options_file = None
48  #Does our scons support the newer Variables class or do we need to use Options?  
49    ############################### Build options ################################
50  try:  
51     dummyvar=Variables  default_prefix='/usr'
52     opts = Variables(options_file, ARGUMENTS)  mpi_flavours=('no', 'none', 'MPT', 'MPICH', 'MPICH2', 'OPENMPI', 'INTELMPI')
53     adder = opts.AddVariables  lapack_flavours=('none', 'clapack', 'mkl')
54  except:  
55     opts = Options(options_file, ARGUMENTS)  vars = Variables(options_file, ARGUMENTS)
56     adder = opts.AddOptions  vars.AddVariables(
57     BoolVariable = BoolOption    PathVariable('options_file', 'Path to options file', options_file, PathVariable.PathIsFile),
58      PathVariable('prefix', 'Installation prefix', Dir('#.').abspath, PathVariable.PathIsDirCreate),
59  ############ Load build options ################################    PathVariable('build_dir', 'Top-level build directory', Dir('#/build').abspath, PathVariable.PathIsDirCreate),
60      BoolVariable('verbose', 'Output full compile/link lines', False),
61  adder(  # Compiler/Linker options
62  #opts.AddOptions(    ('cc', 'Path to C compiler', 'default'),
63  # Where to install esys stuff    ('cxx', 'Path to C++ compiler', 'default'),
64    ('prefix', 'where everything will be installed',                       Dir('#.').abspath),    ('cc_flags', 'Base C/C++ compiler flags', 'default'),
65    ('incinstall', 'where the esys headers will be installed',             os.path.join(Dir('#.').abspath,'include')),    ('cc_optim', 'Additional C/C++ flags for a non-debug build', 'default'),
66    ('bininstall', 'where the esys binaries will be installed',            os.path.join(prefix,'bin')),    ('cc_debug', 'Additional C/C++ flags for a debug build', 'default'),
   ('libinstall', 'where the esys libraries will be installed',           os.path.join(prefix,'lib')),  
   ('pyinstall', 'where the esys python modules will be installed',       os.path.join(prefix,'esys')),  
 # Compilation options  
   BoolVariable('dodebug', 'For backwards compatibility', 'no'),  
   BoolVariable('usedebug', 'Do you want a debug build?', 'no'),  
   BoolVariable('usevtk', 'Do you want to use VTK?', 'yes'),  
   ('options_file', 'File of paths/options. Default: scons/<hostname>_options.py', options_file),  
   ('cc', 'path to C compiler', 'DEFAULT'),  
   ('cxx', 'path to C++ compiler', 'DEFAULT'),  
   ('win_cc_name', 'windows C compiler name if needed', 'msvc'),  
   # The strings -DDEFAULT_ get replaced by scons/<hostname>_options.py or by defaults below  
   ('cc_flags', 'C/C++ compiler flags to use', '-DEFAULT_1'),  
   ('cc_optim', 'C/C++ optimization flags to use', '-DEFAULT_2'),  
   ('cc_debug', 'C/C++ debug flags to use', '-DEFAULT_3'),  
   ('omp_optim', 'OpenMP compiler flags to use (Release build)', '-DEFAULT_4'),  
   ('omp_debug', 'OpenMP compiler flags to use (Debug build)', '-DEFAULT_5'),  
   ('omp_libs', 'OpenMP compiler libraries to link with', '-DEFAULT_6'),  
67    ('cc_extra', 'Extra C compiler flags', ''),    ('cc_extra', 'Extra C compiler flags', ''),
68    ('cxx_extra', 'Extra C++ compiler flags', ''),    ('cxx_extra', 'Extra C++ compiler flags', ''),
69    ('ld_extra', 'Extra linker flags', ''),    ('ld_extra', 'Extra linker flags', ''),
70    ('sys_libs', 'System libraries to link with', []),    BoolVariable('werror','Treat compiler warnings as errors', True),
71    ('ar_flags', 'Static library archiver flags to use', ''),    BoolVariable('debug', 'Compile with debug flags', False),
72    BoolVariable('useopenmp', 'Compile parallel version using OpenMP', 'no'),    BoolVariable('openmp', 'Compile parallel version using OpenMP', False),
73    BoolVariable('usepedantic', 'Compile with -pedantic if using gcc', 'no'),    ('omp_flags', 'OpenMP compiler flags', 'default'),
74    BoolVariable('usewarnings','Compile with warnings as errors if using gcc','yes'),    ('omp_ldflags', 'OpenMP linker flags', 'default'),
75    ('forcelazy','for testing use only - set the default value for autolazy','leave_alone'),  # Mandatory libraries
76    ('forcecollres','for testing use only - set the default value for force resolving collective ops','leave_alone'),    ('boost_prefix', 'Prefix/Paths of boost installation', default_prefix),
77  # Python    ('boost_libs', 'Boost libraries to link with', ['boost_python-mt']),
78    ('python_path', 'Path to Python includes', '/usr/include/'+python_version),  # Mandatory for tests
79    ('python_lib_path', 'Path to Python libs', usr_lib),    ('cppunit_prefix', 'Prefix/Paths of CppUnit installation', default_prefix),
80    ('python_libs', 'Python libraries to link with', [python_version]),    ('cppunit_libs', 'CppUnit libraries to link with', ['cppunit']),
81    ('python_cmd', 'Python command', 'python'),  # Optional libraries and options
82  # Boost    EnumVariable('mpi', 'Compile parallel version using MPI flavour', 'none', allowed_values=mpi_flavours),
83    ('boost_path', 'Path to Boost includes', '/usr/include'),    ('mpi_prefix', 'Prefix/Paths of MPI installation', default_prefix),
84    ('boost_lib_path', 'Path to Boost libs', usr_lib),    ('mpi_libs', 'MPI shared libraries to link with', ['mpi']),
85    ('boost_libs', 'Boost libraries to link with', ['boost_python']),    BoolVariable('netcdf', 'Enable netCDF file support', False),
86  # NetCDF    ('netcdf_prefix', 'Prefix/Paths of netCDF installation', default_prefix),
87    BoolVariable('usenetcdf', 'switch on/off the usage of netCDF', 'yes'),    ('netcdf_libs', 'netCDF libraries to link with', ['netcdf_c++', 'netcdf']),
88    ('netCDF_path', 'Path to netCDF includes', '/usr/include'),    BoolVariable('parmetis', 'Enable ParMETIS (requires MPI)', False),
89    ('netCDF_lib_path', 'Path to netCDF libs', usr_lib),    ('parmetis_prefix', 'Prefix/Paths of ParMETIS installation', default_prefix),
90    ('netCDF_libs', 'netCDF C++ libraries to link with', ['netcdf_c++', 'netcdf']),    ('parmetis_libs', 'ParMETIS libraries to link with', ['parmetis', 'metis']),
91  # MPI    BoolVariable('papi', 'Enable PAPI', False),
92    BoolVariable('useMPI', 'For backwards compatibility', 'no'),    ('papi_prefix', 'Prefix/Paths to PAPI installation', default_prefix),
   BoolVariable('usempi', 'Compile parallel version using MPI', 'no'),  
   ('MPICH_IGNORE_CXX_SEEK', 'name of macro to ignore MPI settings of C++ SEEK macro (for MPICH)' , 'MPICH_IGNORE_CXX_SEEK'),  
   ('mpi_path', 'Path to MPI includes', '/usr/include'),  
   ('mpi_run', 'mpirun name' , 'mpiexec -np 1'),  
   ('mpi_lib_path', 'Path to MPI libs (needs to be added to the LD_LIBRARY_PATH)', usr_lib),  
   ('mpi_libs', 'MPI libraries to link with (needs to be shared!)', []),  
   ('mpi_flavour','Type of MPI execution environment','none'),  
 # ParMETIS  
   BoolVariable('useparmetis', 'Compile parallel version using ParMETIS', 'yes'),  
   ('parmetis_path', 'Path to ParMETIS includes', '/usr/include'),  
   ('parmetis_lib_path', 'Path to ParMETIS library', usr_lib),  
   ('parmetis_libs', 'ParMETIS library to link with', ['parmetis', 'metis']),  
 # PAPI  
   BoolVariable('usepapi', 'switch on/off the usage of PAPI', 'no'),  
   ('papi_path', 'Path to PAPI includes', '/usr/include'),  
   ('papi_lib_path', 'Path to PAPI libs', usr_lib),  
93    ('papi_libs', 'PAPI libraries to link with', ['papi']),    ('papi_libs', 'PAPI libraries to link with', ['papi']),
94    BoolVariable('papi_instrument_solver', 'use PAPI in Solver.c to instrument each iteration of the solver', False),    BoolVariable('papi_instrument_solver', 'Use PAPI to instrument each iteration of the solver', False),
95  # MKL    BoolVariable('mkl', 'Enable the Math Kernel Library', False),
96    BoolVariable('usemkl', 'switch on/off the usage of MKL', 'no'),    ('mkl_prefix', 'Prefix/Paths to MKL installation', default_prefix),
97    ('mkl_path', 'Path to MKL includes', '/sw/sdev/cmkl/10.0.2.18/include'),    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver','mkl_em64t','guide','pthread']),
98    ('mkl_lib_path', 'Path to MKL libs', '/sw/sdev/cmkl/10.0.2.18/lib/em64t'),    BoolVariable('umfpack', 'Enable UMFPACK', False),
99    ('mkl_libs', 'MKL libraries to link with', ['mkl_solver', 'mkl_em64t', 'guide', 'pthread']),    ('umfpack_prefix', 'Prefix/Paths to UMFPACK installation', default_prefix),
100  # UMFPACK    ('umfpack_libs', 'UMFPACK libraries to link with', ['umfpack']),
101    BoolVariable('useumfpack', 'switch on/off the usage of UMFPACK', 'no'),    BoolVariable('boomeramg', 'Enable BoomerAMG', False),
102    ('ufc_path', 'Path to UFconfig includes', '/usr/include/suitesparse'),    ('boomeramg_prefix', 'Prefix/Paths to BoomerAMG installation', default_prefix),
103    ('umf_path', 'Path to UMFPACK includes', '/usr/include/suitesparse'),    ('boomeramg_libs', 'BoomerAMG libraries to link with', ['boomeramg']),
104    ('umf_lib_path', 'Path to UMFPACK libs', usr_lib),    EnumVariable('lapack', 'Set LAPACK flavour', 'none', allowed_values=lapack_flavours),
105    ('umf_libs', 'UMFPACK libraries to link with', ['umfpack']),    ('lapack_prefix', 'Prefix/Paths to LAPACK installation', default_prefix),
106  # Silo    ('lapack_libs', 'LAPACK libraries to link with', []),
107    BoolVariable('usesilo', 'switch on/off the usage of Silo', 'yes'),    BoolVariable('silo', 'Enable the Silo file format in weipa', False),
108    ('silo_path', 'Path to Silo includes', '/usr/include'),    ('silo_prefix', 'Prefix/Paths to Silo installation', default_prefix),
   ('silo_lib_path', 'Path to Silo libs', usr_lib),  
109    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),    ('silo_libs', 'Silo libraries to link with', ['siloh5', 'hdf5']),
110  # VisIt    BoolVariable('visit', 'Enable the VisIt simulation interface', False),
111    BoolVariable('usevisit', 'switch on/off the usage of the VisIt sim library', 'no'),    ('visit_prefix', 'Prefix/Paths to VisIt installation', default_prefix),
112    ('visit_path', 'Path to VisIt libsim includes', '/usr/include'),    ('visit_libs', 'VisIt libraries to link with', ['simV2']),
113    ('visit_lib_path', 'Path to VisIt sim library', usr_lib),    BoolVariable('vsl_random', 'Use VSL from intel for random data', False),
114  # AMD (used by UMFPACK)  # Advanced settings
115    ('amd_path', 'Path to AMD includes', '/usr/include/suitesparse'),    #dudley_assemble_flags = -funroll-loops      to actually do something
116    ('amd_lib_path', 'Path to AMD libs', usr_lib),    ('dudley_assemble_flags', 'compiler flags for some dudley optimisations', ''),
117    ('amd_libs', 'AMD libraries to link with', ['amd']),    # To enable passing function pointers through python
118  # BLAS (used by UMFPACK)    BoolVariable('iknowwhatimdoing', 'Allow non-standard C', False),
119    ('blas_path', 'Path to BLAS includes', '/usr/include/suitesparse'),    # An option for specifying the compiler tools (see windows branch)
120    ('blas_lib_path', 'Path to BLAS libs', usr_lib),    ('tools_names', 'Compiler tools to use', ['default']),
121    ('blas_libs', 'BLAS libraries to link with', ['blas']),    ('env_export', 'Environment variables to be passed to tools',[]),
122  #Lapack options    EnumVariable('forcelazy', 'For testing use only - set the default value for autolazy', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
123    BoolVariable('uselapack','switch on/off use of Lapack','no'),    EnumVariable('forcecollres', 'For testing use only - set the default value for force resolving collective ops', 'leave_alone', allowed_values=('leave_alone', 'on', 'off')),
124    ('lapack_path', 'Path to Lapack includes','/usr/include'),    # finer control over library building, intel aggressive global optimisation
125    ('lapack_lib_path', 'Path to Lapack libs', usr_lib),    # works with dynamic libraries on windows.
126    ('lapack_libs', 'Lapack libraries to link with', []),    ('build_shared', 'Build dynamic libraries only', False),
127    ('lapack_type', '{clapack,mkl}','clapack'),    ('sys_libs', 'Extra libraries to link with', []),
128  # An option for specifying the compiler tools set (see windows branch).    ('escript_opts_version', 'Version of options file (do not specify on command line)'),
129    ('tools_names', 'allow control over the tools in the env setup', ['default']),    ('SVN_VERSION', 'Do not use from options file', -2),
130  # finer control over library building, intel aggressive global optimisation    ('pythoncmd', 'which python to compile with','python'),
131  # works with dynamic libraries on windows.    ('usepython3', 'Is this a python3 build? (experimental)', False),
132    ('share_esysUtils', 'control static or dynamic esysUtils lib', False),    ('pythonlibname', 'Name of the python library to link. (This is found automatically for python2.X.)', ''),
133    ('share_paso', 'control static or dynamic paso lib', False),    ('pythonlibpath', 'Path to the python library. (You should not need to set this unless your python has moved)',''),
134    ('env_export','Environment variables to be passed to children',[]),    ('pythonincpath','Path to python include files. (You should not need to set this unless your python has moved',''),
135  #To enable passing function pointers through python    BoolVariable('BADPYTHONMACROS','Extra \#include to get around a python bug.', True),
   BoolVariable('iknowwhatimdoing','allow nonstandard C',False)  
136  )  )
137    
138    ##################### Create environment and help text #######################
139    
140  ###################  # Intel's compiler uses regular expressions improperly and emits a warning
141    # about failing to find the compilers. This warning can be safely ignored.
 # This is only to support old versions of scons which don't accept  
 # the variant_dir parameter (older than 0.98 I think).  
 # Once these are no longer an issue we can go back to a direct call  
 # to obj.SConscript  
 import SCons  
 vs=SCons.__version__.split('.')  
 cantusevariantdir=float(vs[0]+'.'+vs[1])<0.98  
   
   
 def CallSConscript(obj, **kw):  
     if cantusevariantdir:  
         if 'variant_dir' in kw:  
         kw['build_dir']=kw['variant_dir']  
         del kw['variant_dir']  
     obj.SConscript(**kw)  
   
   
 ############ Specify which compilers to use ####################  
   
 # intelc uses regular expressions improperly and emits a warning about  
 # failing to find the compilers.  This warning can be safely ignored.  
   
 if IS_WINDOWS_PLATFORM:  
       env = Environment(options = opts)  
       env = Environment(tools = ['default'] + env['tools_names'],  
                         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)  
    else:  
       env = Environment(tools = ['default'], options = opts)  
       if env['tools_names']!='default':  
     env=Environment(tools = ['default'] +env['tools_names'], options=opts)  
   
 # Override compiler choice if provided  
 if env['cc'] != 'DEFAULT': env['CC']=env['cc']  
 if env['cxx'] != 'DEFAULT': env['CXX']=env['cxx']  
   
 Help(opts.GenerateHelpText(env))  
   
 ############ Make sure target directories exist ################  
142    
143    # PATH is needed so the compiler, linker and tools are found if they are not
144    # in default locations.
145    env = Environment(tools = ['default'], options = vars,
146                      ENV = {'PATH': os.environ['PATH']})
147                      
148    
149    #set the vars for clang
150    def mkclang(env):
151      env['CC']='clang'
152      env['CXX']='clang++'
153                      
154                      
155    if env['tools_names'] != 'default':
156        zz=env['tools_names']
157        if 'clang' in zz:
158            zz.remove('clang')
159            zz.insert(0, mkclang)
160        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
161                          ENV = {'PATH' : os.environ['PATH']})
162    
163    if options_file:
164        opts_valid=False
165        if 'escript_opts_version' in env.Dictionary() and \
166            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
167                opts_valid=True
168        if opts_valid:
169            print("Using options in %s." % options_file)
170        else:
171            print("\nOptions file %s" % options_file)
172            print("is outdated! Please update the file by examining one of the TEMPLATE")
173            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
174            Exit(1)
175    
176    # Generate help text (scons -h)
177    Help(vars.GenerateHelpText(env))
178    
179    # Check for superfluous options
180    if len(vars.UnknownVariables())>0:
181        for k in vars.UnknownVariables():
182            print("Unknown option '%s'" % k)
183        Exit(1)
184    
185    #################### Make sure install directories exist #####################
186    
187    env['BUILD_DIR']=env['build_dir']
188    prefix=Dir(env['prefix']).abspath
189    env['incinstall'] = os.path.join(prefix, 'include')
190    env['bininstall'] = os.path.join(prefix, 'bin')
191    env['libinstall'] = os.path.join(prefix, 'lib')
192    env['pyinstall']  = os.path.join(prefix, 'esys')
193  if not os.path.isdir(env['bininstall']):  if not os.path.isdir(env['bininstall']):
194      os.makedirs(env['bininstall'])      os.makedirs(env['bininstall'])
195  if not os.path.isdir(env['libinstall']):  if not os.path.isdir(env['libinstall']):
# Line 239  if not os.path.isdir(env['libinstall']): Line 197  if not os.path.isdir(env['libinstall']):
197  if not os.path.isdir(env['pyinstall']):  if not os.path.isdir(env['pyinstall']):
198      os.makedirs(env['pyinstall'])      os.makedirs(env['pyinstall'])
199    
200  ########## Copy required environment vars ######################  env.Append(CPPPATH = [env['incinstall']])
201    env.Append(LIBPATH = [env['libinstall']])
 for i in env['env_export']:  
    env.Append(ENV = {i:os.environ[i]})  
   
 ############ Fill in compiler options if not set above #########  
   
 # Backwards compatibility: allow dodebug=yes and useMPI=yes  
 if env['dodebug']: env['usedebug'] = 1  
 if env['useMPI']: env['usempi'] = 1  
   
 # Default compiler options (override allowed in hostname_options.py, but should not be necessary)  
 # For both C and C++ you get: cc_flags and either the optim flags or debug flags  
   
 sysheaderopt = ""       # how do we indicate that a header is a system header. Use "" for no action.  
   
 cc_flags = ""  
 cc_optim = ""  
 cc_debug = ""  
 omp_optim = ""  
 omp_debug = ""  
 omp_libs = []  
   
 if env["CC"] == "icc":  
   # Intel compilers  
   cc_flags      = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"  
   cc_optim      = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = "-openmp -openmp_report0"  
   omp_debug     = "-openmp -openmp_report0"  
   omp_libs      = ['guide', 'pthread']  
   pedantic      = ""  
   fatalwarning      = ""        # Switch to turn warnings into errors  
   sysheaderopt      = ""  
 elif env["CC"][:3] == "gcc":  
   # GNU C on any system  
   cc_flags      = "-pedantic -Wall -fPIC -ffast-math -Wno-unknown-pragmas -DBLOCKTIMER  -Wno-sign-compare -Wno-system-headers -Wno-long-long -Wno-strict-aliasing"  
 #the long long warning occurs on the Mac  
   cc_optim      = "-O3"  
   cc_debug      = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"  
   omp_optim     = "-fopenmp"  
   omp_debug     = "-fopenmp"  
   omp_libs      = []  
   pedantic      = "-pedantic-errors -Wno-long-long"  
   fatalwarning      = "-Werror"  
   sysheaderopt      = "-isystem "  
 elif env["CC"] == "cl":  
   # Microsoft Visual C on Windows  
   cc_flags      = "/FD /EHsc /GR /wd4068 -D_USE_MATH_DEFINES -DDLL_NETCDF"  
   cc_optim      = "/O2 /Op /MT /W3"  
   cc_debug      = "/Od /RTC1 /MTd /ZI -DBOUNDS_CHECK"  
   omp_optim     = ""  
   omp_debug     = ""  
   omp_libs      = []  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
 elif env["CC"] == "icl":  
   # intel C on Windows, see windows_intelc_options.py for a start  
   pedantic      = ""  
   fatalwarning      = ""  
   sysheaderopt      = ""  
   
   
 # If not specified in hostname_options.py then set them here  
 if env["cc_flags"]  == "-DEFAULT_1": env['cc_flags'] = cc_flags  
 if env["cc_optim"]  == "-DEFAULT_2": env['cc_optim'] = cc_optim  
 if env["cc_debug"]  == "-DEFAULT_3": env['cc_debug'] = cc_debug  
 if env["omp_optim"] == "-DEFAULT_4": env['omp_optim'] = omp_optim  
 if env["omp_debug"] == "-DEFAULT_5": env['omp_debug'] = omp_debug  
 if env["omp_libs"]  == "-DEFAULT_6": env['omp_libs'] = omp_libs  
   
 #set up the autolazy values  
 if env['forcelazy']    != "leave_alone":  
   if env['forcelazy'] == 'on':  
     env.Append(CPPDEFINES=['FAUTOLAZYON'])  
   else:  
      if env['forcelazy'] == 'off':  
     env.Append(CPPDEFINES=['FAUTOLAZYOFF'])  
   
 #set up the colective resolve values  
 if env['forcecollres']    != "leave_alone":  
   print env['forcecollres']  
   if env['forcecollres'] == 'on':  
     env.Append(CPPDEFINES=['FRESCOLLECTON'])  
   else:  
      if env['forcecollres'] == 'off':  
     env.Append(CPPDEFINES=['FRESCOLLECTOFF'])  
   
   
 if env['iknowwhatimdoing']:  
     env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])  
   
 # OpenMP is disabled if useopenmp=no or both variables omp_optim and omp_debug are empty  
 if not env["useopenmp"]:  
   env['omp_optim'] = ""  
   env['omp_debug'] = ""  
   env['omp_libs'] = []  
   
 if env['omp_optim'] == "" and env['omp_debug'] == "": env["useopenmp"] = 0  
202    
203  # Windows doesn't use LD_LIBRARY_PATH but PATH instead  ################# Fill in compiler options if not set above ##################
 if IS_WINDOWS_PLATFORM:  
     LD_LIBRARY_PATH_KEY='PATH'  
     env['ENV']['LD_LIBRARY_PATH']=''  
 else:  
     LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'  
 ############ Copy environment variables into scons env #########  
204    
205  try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  if env['cc'] != 'default': env['CC']=env['cc']
206  except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  if env['cxx'] != 'default': env['CXX']=env['cxx']
207    
208  try: env['ENV']['ESCRIPT_NUM_THREADS'] = os.environ['ESCRIPT_NUM_THREADS']  # version >=9 of intel C++ compiler requires use of icpc to link in C++
209  except KeyError: pass  # runtimes (icc does not)
210    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
211        env['LINK'] = env['CXX']
212    
213    # default compiler/linker options
214    cc_flags = ''
215    cc_optim = ''
216    cc_debug = ''
217    omp_flags = ''
218    omp_ldflags = ''
219    fatalwarning = '' # switch to turn warnings into errors
220    sysheaderopt = '' # how to indicate that a header is a system header
221    
222    # env['CC'] might be a full path
223    cc_name=os.path.basename(env['CC'])
224    
225    if cc_name == 'icc':
226        # Intel compiler
227        cc_flags    = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"
228        cc_optim    = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -ip"
229        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
230        omp_flags   = "-openmp -openmp_report0"
231        omp_ldflags = "-openmp -openmp_report0 -lpthread"
232        fatalwarning = "-Werror"
233    elif cc_name[:3] == 'gcc':
234        # GNU C on any system
235        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"
236        cc_optim     = "-O3"
237        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
238        omp_flags    = "-fopenmp"
239        omp_ldflags  = "-fopenmp"
240        fatalwarning = "-Werror"
241        sysheaderopt = "-isystem"
242    elif cc_name == 'cl':
243        # Microsoft Visual C on Windows
244        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
245        cc_optim     = "/O2 /Op /W3"
246        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
247        fatalwarning = "/WX"
248    elif cc_name == 'icl':
249        # Intel C on Windows
250        cc_flags     = '/EHsc /GR /MD'
251        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
252        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
253        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
254        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
255    
256    # set defaults if not otherwise specified
257    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
258    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
259    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
260    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
261    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
262    if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
263    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
264    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
265    
266  try: env['ENV']['ESCRIPT_NUM_PROCS'] = os.environ['ESCRIPT_NUM_PROCS']  if env['BADPYTHONMACROS']: env.Append(CXXFLAGS = ' -DBADPYTHONMACROS')
 except KeyError: env['ENV']['ESCRIPT_NUM_PROCS']=1  
267    
268  try: env['ENV']['ESCRIPT_NUM_NODES'] = os.environ['ESCRIPT_NUM_NODES']  if env['usepython3']:
269  except KeyError: env['ENV']['ESCRIPT_NUM_NODES']=1      env.Append(CPPDEFINES=['ESPYTHON3'])
270    
271  try: env['ENV']['ESCRIPT_HOSTFILE'] = os.environ['ESCRIPT_HOSTFILE']  # set up the autolazy values
272  except KeyError: pass  if env['forcelazy'] == 'on':
273        env.Append(CPPDEFINES=['FAUTOLAZYON'])
274    elif env['forcelazy'] == 'off':
275        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
276    
277    # set up the collective resolve values
278    if env['forcecollres'] == 'on':
279        env.Append(CPPDEFINES=['FRESCOLLECTON'])
280    elif env['forcecollres'] == 'off':
281        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
282    
283  try: env['ENV']['PATH'] = os.environ['PATH']  # allow non-standard C if requested
284  except KeyError: pass  if env['iknowwhatimdoing']:
285        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
286    
287  try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  # Disable OpenMP if no flags provided
288  except KeyError: pass  if env['openmp'] and env['omp_flags'] == '':
289       print("OpenMP requested but no flags provided - disabling OpenMP!")
290       env['openmp'] = False
291    
292  try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  if env['openmp']:
293  except KeyError: pass      env.Append(CCFLAGS = env['omp_flags'])
294        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
295    else:
296        env['omp_flags']=''
297        env['omp_ldflags']=''
298    
299  try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  # add debug/non-debug compiler flags
300  except KeyError: pass  if env['debug']:
301        env.Append(CCFLAGS = env['cc_debug'])
302    else:
303        env.Append(CCFLAGS = env['cc_optim'])
304    
305  try: env.PrependENVPath(LD_LIBRARY_PATH_KEY,os.environ['LD_LIBRARY_PATH'])  # always add cc_flags
306  except KeyError: pass  env.Append(CCFLAGS = env['cc_flags'])
307    
308  try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  # add system libraries
309  except KeyError: pass  env.AppendUnique(LIBS = env['sys_libs'])
310    
 try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
 except KeyError: pass  
311    
312  try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  global_revision=ARGUMENTS.get('SVN_VERSION', None)
313  except KeyError: pass  if global_revision:
314        global_revision = re.sub(':.*', '', global_revision)
315        global_revision = re.sub('[^0-9]', '', global_revision)
316        if global_revision == '': global_revision='-2'
317    else:
318      # Get the global Subversion revision number for the getVersion() method
319      try:
320        global_revision = os.popen('svnversion -n .').read()
321        global_revision = re.sub(':.*', '', global_revision)
322        global_revision = re.sub('[^0-9]', '', global_revision)
323        if global_revision == '': global_revision='-2'
324      except:
325        global_revision = '-1'
326    env['svn_revision']=global_revision
327    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
328    
329    if IS_WINDOWS:
330        if not env['build_shared']:
331            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
332            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
333    
334  try: env['ENV']['HOME'] = os.environ['HOME']  ###################### Copy required environment vars ########################
 except KeyError: pass  
335    
336  # Configure for test suite  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
337    if IS_WINDOWS:
338        LD_LIBRARY_PATH_KEY='PATH'
339        env['ENV']['LD_LIBRARY_PATH']=''
340    else:
341        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
342    
343    # the following env variables are exported for the unit tests
344    
345  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
346  env.PrependENVPath('PYTHONPATH', prefix)      try:
347  env['ENV']['ESCRIPT_ROOT'] = prefix          env['ENV'][key] = os.environ[key]
348        except KeyError:
349            env['ENV'][key] = 1
350    
351    env_export=env['env_export']
352    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','TMPDIR','TEMP','TMP'])
353    
354    for key in set(env_export):
355        try:
356            env['ENV'][key] = os.environ[key]
357        except KeyError:
358            pass
359    
360  ############ Set up paths for Configure() ######################  try:
361        env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
362    except KeyError:
363        pass
364    
365  # Make a copy of an environment  # these shouldn't be needed
366  # Use env.Clone if available, but fall back on env.Copy for older version of scons  #for key in 'C_INCLUDE_PATH','CPLUS_INCLUDE_PATH','LIBRARY_PATH':
367  def clone_env(env):  #    try:
368    if 'Clone' in dir(env): return env.Clone()    # scons-0.98  #        env['ENV'][key] = os.environ[key]
369    else:                   return env.Copy() # scons-0.96  #    except KeyError:
370    #        pass
371    
372  # Add cc option -I<Escript>/trunk/include  try:
373  env.Append(CPPPATH      = [Dir('include')])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
374    except KeyError:
375        pass
376    
377  # Add cc option -L<Escript>/trunk/lib  ######################## Add some custom builders ############################
 env.Append(LIBPATH      = [Dir(env['libinstall'])])  
378    
379  if env['cc_extra'] != '': env.Append(CFLAGS = env['cc_extra'])  if env['pythoncmd']=='python':
380  if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
381  if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  else:
382        py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
383    env.Append(BUILDERS = {'PyCompile' : py_builder});
384    
385  if env['usepedantic']: env.Append(CCFLAGS = pedantic)  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
386    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
387    
388  # MS Windows  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
389  if IS_WINDOWS_PLATFORM:  env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});
   env.AppendENVPath('PATH', [env['boost_lib_path']])  
   env.AppendENVPath('PATH', [env['libinstall']])  
   if not env['share_esysUtils'] :  
     env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])  
   if not env['share_paso'] :  
     env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])  
390    
391    if env['usenetcdf']:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
392      env.AppendENVPath('PATH',   [env['netCDF_lib_path']])  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
393    
394  env.Append(ARFLAGS = env['ar_flags'])  ############################ Dependency checks ###############################
395    
396  # Get the global Subversion revision number for getVersion() method  # Create a Configure() environment to check for compilers and python
397  try:  conf = Configure(env.Clone())
    global_revision = os.popen("svnversion -n .").read()  
    global_revision = re.sub(":.*", "", global_revision)  
    global_revision = re.sub("[^0-9]", "", global_revision)  
 except:  
    global_revision="-1"  
 if global_revision == "": global_revision="-2"  
 env.Append(CPPDEFINES = ["SVN_VERSION="+global_revision])  
398    
399  ############ numpy (required) ###############################  ######## Test that the compilers work
400    
401  try:  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
402    from numpy import identity      if not conf.CheckCC():
403  except ImportError:          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
404    print "Cannot import numpy, you need to set your PYTHONPATH"          Exit(1)
405    sys.exit(1)      if not conf.CheckCXX():
406            print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
407  ############ C compiler (required) #############################          Exit(1)
408    else:
409  # Create a Configure() environment for checking existence of required libraries and headers      if not conf.CheckFunc('printf', language='c'):
410  conf = Configure(clone_env(env))          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
411            Exit(1)
412  # Test that the compiler is working      if not conf.CheckFunc('printf', language='c++'):
413  if not conf.CheckFunc('printf'):          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
414     print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])          Exit(1)
    sys.exit(1)  
415    
416  if conf.CheckFunc('gethostname'):  if conf.CheckFunc('gethostname'):
417    conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])      conf.env.Append(CPPDEFINES = ['HAVE_GETHOSTNAME'])
   
 ############ python libraries (required) #######################  
   
   
 if not sysheaderopt =="":  
   conf.env.Append(CCFLAGS=sysheaderopt+env['python_path'])  
 else:  
   conf.env.AppendUnique(CPPPATH     = [env['python_path']])  
418    
419  conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  ######## Python headers & library (required)
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
420    
421  conf.env.PrependENVPath('PYTHONPATH', prefix)  #First we check to see if the config file has specified
422  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['python_lib_path'])    # The wrapper script needs to find these libs  ##Where to find the filae. Ideally, this should be automatic
423  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  #But we need to deal with the case where python is not in its INSTALL
424    #Directory
425    # Use the python scons is running
426    if env['pythoncmd']=='python':
427        python_inc_path=sysconfig.get_python_inc()
428        if IS_WINDOWS:
429            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
430        elif env['PLATFORM']=='darwin':
431            python_lib_path=sysconfig.get_config_var('LIBPL')
432        else:
433            python_lib_path=sysconfig.get_config_var('LIBDIR')
434    
435        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
436        if IS_WINDOWS:
437            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
438        else:
439            python_libs=['python'+sysconfig.get_python_version()]
440    
441    #if we want to use a python other than the one scons is running
442    else:
443        initstring='from __future__ import print_function;from distutils import sysconfig;'
444        if env['pythonlibname']!='':
445            python_libs=env['pythonlibname']
446        else:   # work it out by calling python    
447            if IS_WINDOWS:
448                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
449            else:
450                cmd='print("python"+sysconfig.get_python_version())'
451            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
452            python_libs=p.stdout.readline()
453            if env['usepython3']:       # This is to convert unicode str into py2 string
454                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
455            p.wait()
456            python_libs=python_libs.strip()
457    
458      
459        # Now we know whether we are using python3 or not
460        p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
461        python_inc_path=p.stdout.readline()
462        if env['usepython3']:
463             python_inc_path=python_inc_path.encode()
464        p.wait()  
465        python_inc_path=python_inc_path.strip()
466        if IS_WINDOWS:
467            cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
468        elif env['PLATFORM']=='darwin':
469            cmd="sysconfig.get_config_var(\"LIBPL\")"
470        else:
471            cmd="sysconfig.get_config_var(\"LIBDIR\")"
472    
473        p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
474        python_lib_path=p.stdout.readline()
475        if env['usepython3']:
476            python_lib_path=python_lib_path.decode()
477        p.wait()
478        python_lib_path=python_lib_path.strip()
479    
480    #Check for an override from the config file.
481    #Ideally, this should be automatic
482    #But we need to deal with the case where python is not in its INSTALL
483    #Directory
484    if env['pythonlibpath']!='':
485        python_lib_path=env['pythonlibpath']
486    
487    if env['pythonincpath']!='':
488        python_inc_path=env['pythonincpath']
489    
490    
491    if sysheaderopt == '':
492        conf.env.AppendUnique(CPPPATH = [python_inc_path])
493    else:
494        conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
495    
496    conf.env.AppendUnique(LIBPATH = [python_lib_path])
497    conf.env.AppendUnique(LIBS = python_libs)
498    # The wrapper script needs to find the libs
499    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
500    
501  if not conf.CheckCHeader('Python.h'):  if not conf.CheckCHeader('Python.h'):
502    print "Cannot find python include files (tried 'Python.h' in directory %s)" % (env['python_path'])      print("Cannot find python include files (tried 'Python.h' in directory %s)" % (python_inc_path))
503    sys.exit(1)      Exit(1)
504  if not conf.CheckFunc('Py_Exit'):  if not conf.CheckFunc('Py_Exit'):
505    print "Cannot find python library method Py_Main (tried lib %s in directory %s)" % (env['python_libs'], env['python_lib_path'])      print("Cannot find python library method Py_Main (tried %s in directory %s)" % (python_libs, python_lib_path))
506    sys.exit(1)      Exit(1)
   
 ############ boost (required) ##################################  
   
 if not sysheaderopt =="":  
 # This is required because we can't -isystem /usr/system because it breaks std includes  
   if os.path.normpath(env['boost_path']) =="/usr/include":  
     conf.env.Append(CCFLAGS=sysheaderopt+os.path.join(env['boost_path'],'boost'))  
   else:  
     conf.env.Append(CCFLAGS=sysheaderopt+env['boost_path'])  
 else:  
   conf.env.AppendUnique(CPPPATH     = [env['boost_path']])  
   
 conf.env.AppendUnique(LIBPATH       = [env['boost_lib_path']])  
 conf.env.AppendUnique(LIBS      = [env['boost_libs']])  
   
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['boost_lib_path']) # The wrapper script needs to find these libs  
 #ensure that our path entries remain at the front  
 conf.env.PrependENVPath('PYTHONPATH', prefix)  
 conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
   
 #Yep we still cant figure this one out. - working on it.  
 if not IS_WINDOWS_PLATFORM:  
   if not conf.CheckCXXHeader('boost/python.hpp'):  
     print "Cannot find boost include files (tried boost/python.hpp in directory %s)" % (env['boost_path'])  
     sys.exit(1)  
   
   if not conf.CheckFunc('PyObject_SetAttr'):  
     print "Cannot find boost library method PyObject_SetAttr (tried method PyObject_SetAttr in library %s in directory %s)" % (env['boost_libs'], env['boost_lib_path'])  
     sys.exit(1)  
507    
508    ## reuse conf to check for numpy header (optional)
509    if env['usepython3']:
510        # FIXME: This is until we can work out how to make the checks in python 3
511        conf.env['numpy_h']=False
512    else:
513        if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
514            conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
515            conf.env['numpy_h']=True
516        else:
517            conf.env['numpy_h']=False
518    
519  # Commit changes to environment  # Commit changes to environment
520  env = conf.Finish()  env = conf.Finish()
521    
522  ############ VTK (optional) ####################################  ######## boost (required)
523    
524  if env['usevtk']:  boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
525    try:  if sysheaderopt == '':
526      import vtk      env.AppendUnique(CPPPATH = [boost_inc_path])
527      env['usevtk'] = 1  else:
528    except ImportError:      # This is required because we can't -isystem /usr/include since it breaks
529      env['usevtk'] = 0      # std includes
530        if os.path.normpath(boost_inc_path) == '/usr/include':
531  # Add VTK to environment env if it was found          conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
532  if env['usevtk']:      else:
533    env.Append(CPPDEFINES = ['USE_VTK'])          env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
534    
535  ############ NetCDF (optional) #################################  env.AppendUnique(LIBPATH = [boost_lib_path])
536    env.AppendUnique(LIBS = env['boost_libs'])
537  conf = Configure(clone_env(env))  env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
538    
539  if env['usenetcdf']:  ######## numpy (required)
540    conf.env.AppendUnique(CPPPATH = [env['netCDF_path']])  
541    conf.env.AppendUnique(LIBPATH = [env['netCDF_lib_path']])  if env['pythoncmd']=='python':
542    conf.env.AppendUnique(LIBS    = [env['netCDF_libs']])      try:
543    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['netCDF_lib_path'])  # The wrapper script needs to find these libs        from numpy import identity
544    #ensure that our path entries remain at the front      except ImportError:
545    conf.env.PrependENVPath('PYTHONPATH', prefix)        print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
546    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])        Exit(1)
547    else:
548  if env['usenetcdf'] and not conf.CheckCHeader('netcdf.h'): env['usenetcdf'] = 0      p=subprocess.call([env['pythoncmd'],'-c','import numpy'])
549  if env['usenetcdf'] and not conf.CheckFunc('nc_open'): env['usenetcdf'] = 0      if p!=0:
550          print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
551  # Add NetCDF to environment env if it was found        Exit(1)
 if env['usenetcdf']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['USE_NETCDF'])  
 else:  
   conf.Finish()  
552    
553  ############ PAPI (optional) ###################################  ######## CppUnit (required for tests)
554    
555  # Start a new configure environment that reflects what we've already found  try:
556  conf = Configure(clone_env(env))      cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
557        env.AppendUnique(CPPPATH = [cppunit_inc_path])
558        env.AppendUnique(LIBPATH = [cppunit_lib_path])
559        env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
560        env['cppunit']=True
561    except:
562        env['cppunit']=False
563    
564  if env['usepapi']:  ######## netCDF (optional)
   conf.env.AppendUnique(CPPPATH = [env['papi_path']])  
   conf.env.AppendUnique(LIBPATH = [env['papi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env['papi_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['papi_lib_path'])    # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env['usepapi'] and not conf.CheckCHeader('papi.h'): env['usepapi'] = 0  
 if env['usepapi'] and not conf.CheckFunc('PAPI_start_counters'): env['usepapi'] = 0  
   
 # Add PAPI to environment env if it was found  
 if env['usepapi']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['BLOCKPAPI'])  
 else:  
   conf.Finish()  
565    
566  ############ MKL (optional) ####################################  netcdf_inc_path=''
567    netcdf_lib_path=''
568    if env['netcdf']:
569        netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
570        env.AppendUnique(CPPPATH = [netcdf_inc_path])
571        env.AppendUnique(LIBPATH = [netcdf_lib_path])
572        env.AppendUnique(LIBS = env['netcdf_libs'])
573        env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
574        env.Append(CPPDEFINES = ['USE_NETCDF'])
575    
576    ######## PAPI (optional)
577    
578    papi_inc_path=''
579    papi_lib_path=''
580    if env['papi']:
581        papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
582        env.AppendUnique(CPPPATH = [papi_inc_path])
583        env.AppendUnique(LIBPATH = [papi_lib_path])
584        env.AppendUnique(LIBS = env['papi_libs'])
585        env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
586        env.Append(CPPDEFINES = ['BLOCKPAPI'])
587    
588    ######## MKL (optional)
589    
590    mkl_inc_path=''
591    mkl_lib_path=''
592    if env['mkl']:
593        mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
594        env.AppendUnique(CPPPATH = [mkl_inc_path])
595        env.AppendUnique(LIBPATH = [mkl_lib_path])
596        env.AppendUnique(LIBS = env['mkl_libs'])
597        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
598        env.Append(CPPDEFINES = ['MKL'])
599    
600    ######## UMFPACK (optional)
601    
602    umfpack_inc_path=''
603    umfpack_lib_path=''
604    if env['umfpack']:
605        umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
606        env.AppendUnique(CPPPATH = [umfpack_inc_path])
607        env.AppendUnique(LIBPATH = [umfpack_lib_path])
608        env.AppendUnique(LIBS = env['umfpack_libs'])
609        env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
610        env.Append(CPPDEFINES = ['UMFPACK'])
611    
612    ######## LAPACK (optional)
613    
614    if env['lapack']=='mkl' and not env['mkl']:
615        print("mkl_lapack requires MKL!")
616        Exit(1)
617    
618    env['uselapack'] = env['lapack']!='none'
619    lapack_inc_path=''
620    lapack_lib_path=''
621    if env['uselapack']:
622        header='clapack.h'
623        if env['lapack']=='mkl':
624            env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
625            header='mkl_lapack.h'
626        lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
627        env.AppendUnique(CPPPATH = [lapack_inc_path])
628        env.AppendUnique(LIBPATH = [lapack_lib_path])
629        env.AppendUnique(LIBS = env['lapack_libs'])
630        env.Append(CPPDEFINES = ['USE_LAPACK'])
631    
632    ######## Silo (optional)
633    
634    silo_inc_path=''
635    silo_lib_path=''
636    if env['silo']:
637        silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
638        env.AppendUnique(CPPPATH = [silo_inc_path])
639        env.AppendUnique(LIBPATH = [silo_lib_path])
640        # Note that we do not add the libs since they are only needed for the
641        # weipa library and tools.
642        #env.AppendUnique(LIBS = [env['silo_libs']])
643    
644    ######## VSL random numbers (optional)
645    if env['vsl_random']:
646        env.Append(CPPDEFINES = ['MKLRANDOM'])
647    
648    ######## VisIt (optional)
649    
650    visit_inc_path=''
651    visit_lib_path=''
652    if env['visit']:
653        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
654        env.AppendUnique(CPPPATH = [visit_inc_path])
655        env.AppendUnique(LIBPATH = [visit_lib_path])
656    
657    ######## MPI (optional)
658    
659    if env['mpi']=='no':
660        env['mpi']='none'
661    
662    env['usempi'] = env['mpi']!='none'
663    mpi_inc_path=''
664    mpi_lib_path=''
665    if env['usempi']:
666        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
667        env.AppendUnique(CPPPATH = [mpi_inc_path])
668        env.AppendUnique(LIBPATH = [mpi_lib_path])
669        env.AppendUnique(LIBS = env['mpi_libs'])
670        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
671        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
672        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
673        # On the other hand MPT and OpenMPI don't define the latter so we have to
674        # do that here
675        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
676            env.Append(CPPDEFINES = ['MPI_INCLUDED'])
677    
678    ######## BOOMERAMG (optional)
679    
680    if env['mpi'] == 'none': env['boomeramg'] = False
681    
682    boomeramg_inc_path=''
683    boomeramg_lib_path=''
684    if env['boomeramg']:
685        boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
686        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
687        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
688        env.AppendUnique(LIBS = env['boomeramg_libs'])
689        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
690        env.Append(CPPDEFINES = ['BOOMERAMG'])
691    
692    ######## ParMETIS (optional)
693    
694    if not env['usempi']: env['parmetis'] = False
695    
696    parmetis_inc_path=''
697    parmetis_lib_path=''
698    if env['parmetis']:
699        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
700        env.AppendUnique(CPPPATH = [parmetis_inc_path])
701        env.AppendUnique(LIBPATH = [parmetis_lib_path])
702        env.AppendUnique(LIBS = env['parmetis_libs'])
703        env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
704        env.Append(CPPDEFINES = ['USE_PARMETIS'])
705    
706  # Start a new configure environment that reflects what we've already found  ######## gmsh (optional, for tests)
 conf = Configure(clone_env(env))  
707    
708  if env['usemkl']:  try:
709    conf.env.AppendUnique(CPPPATH = [env['mkl_path']])      import subprocess
710    conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])      p=subprocess.Popen(['gmsh', '-info'], stderr=subprocess.PIPE)
711    conf.env.AppendUnique(LIBS    = [env['mkl_libs']])      _,e=p.communicate()
712    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mkl_lib_path']) # The wrapper script needs to find these libs      if e.split().count("MPI"):
713    #ensure that our path entries remain at the front          env['gmsh']='m'
714    conf.env.PrependENVPath('PYTHONPATH', prefix)      else:
715    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])          env['gmsh']='s'
716    except OSError:
717  if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0      env['gmsh']=False
718  if env['usemkl'] and not conf.CheckFunc('pardiso'): env['usemkl'] = 0  
719    ######## PDFLaTeX (for documentation)
720    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
721  # Add MKL to environment env if it was found      env['pdflatex']=True
 if env['usemkl']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['MKL'])  
722  else:  else:
723    conf.Finish()      env['pdflatex']=False
724    
725  ############ UMFPACK (optional) ################################  ######################## Summarize our environment ###########################
726    
727  # Start a new configure environment that reflects what we've already found  # keep some of our install paths first in the list for the unit tests
728  conf = Configure(clone_env(env))  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
729    env.PrependENVPath('PYTHONPATH', prefix)
730    env['ENV']['ESCRIPT_ROOT'] = prefix
731    
732  if env['useumfpack']:  if not env['verbose']:
733    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      env['CCCOMSTR'] = "Compiling $TARGET"
734    conf.env.AppendUnique(CPPPATH = [env['umf_path']])      env['CXXCOMSTR'] = "Compiling $TARGET"
735    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])      env['SHCCCOMSTR'] = "Compiling $TARGET"
736    conf.env.AppendUnique(LIBS    = [env['umf_libs']])      env['SHCXXCOMSTR'] = "Compiling $TARGET"
737    conf.env.AppendUnique(CPPPATH = [env['amd_path']])      env['ARCOMSTR'] = "Linking $TARGET"
738    conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])      env['LINKCOMSTR'] = "Linking $TARGET"
739    conf.env.AppendUnique(LIBS    = [env['amd_libs']])      env['SHLINKCOMSTR'] = "Linking $TARGET"
740    conf.env.AppendUnique(CPPPATH = [env['blas_path']])      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
741    conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])      env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
742    conf.env.AppendUnique(LIBS    = [env['blas_libs']])      env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
743    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['umf_lib_path']) # The wrapper script needs to find these libs      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
744    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['amd_lib_path']) # The wrapper script needs to find these libs      #Progress(['Checking -\r', 'Checking \\\r', 'Checking |\r', 'Checking /\r'], interval=17)
745    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['blas_lib_path'])    # The wrapper script needs to find these libs  
746    #ensure that our path entries remain at the front  print("")
747    conf.env.PrependENVPath('PYTHONPATH', prefix)  print("*** Config Summary (see config.log and lib/buildvars for details) ***")
748    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  print("Escript/Finley revision %s"%global_revision)
749    print("  Install prefix:  %s"%env['prefix'])
750  if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  print("          Python:  %s"%sysconfig.PREFIX)
751  if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  print("           boost:  %s"%env['boost_prefix'])
752  # if env['useumfpack'] and not conf.CheckFunc('daxpy'): env['useumfpack'] = 0 # this does not work on shake73?  print("           numpy:  YES")
753    if env['usempi']:
754  # Add UMFPACK to environment env if it was found      print("             MPI:  YES (flavour: %s)"%env['mpi'])
 if env['useumfpack']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['UMFPACK'])  
755  else:  else:
756    conf.Finish()      print("             MPI:  DISABLED")
   
 ############ Silo (optional) ###################################  
   
 if env['usesilo']:  
   conf = Configure(clone_env(env))  
   conf.env.AppendUnique(CPPPATH = [env['silo_path']])  
   conf.env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   conf.env.AppendUnique(LIBS = [env['silo_libs']])  
   if not conf.CheckCHeader('silo.h'): env['usesilo'] = 0  
   if not conf.CheckFunc('DBMkDir'): env['usesilo'] = 0  
   conf.Finish()  
   
 # Add the path to Silo to environment env if it was found.  
 # Note that we do not add the libs since they are only needed for the  
 # weipa library and tools.  
 if env['usesilo']:  
   env.AppendUnique(CPPPATH = [env['silo_path']])  
   env.AppendUnique(LIBPATH = [env['silo_lib_path']])  
   
 ############ VisIt (optional) ###################################  
   
 if env['usevisit']:  
   env.AppendUnique(CPPPATH = [env['visit_path']])  
   env.AppendUnique(LIBPATH = [env['visit_lib_path']])  
   
 ########### Lapack (optional) ##################################  
   
757  if env['uselapack']:  if env['uselapack']:
758      env.AppendUnique(CPPDEFINES='USE_LAPACK')      print("          LAPACK:  YES (flavour: %s)"%env['lapack'])
     env.AppendUnique(CPPPATH = [env['lapack_path']])  
     env.AppendUnique(LIBPATH =[env['lapack_lib_path']])  
   
     env.Append(LIBPATH = '/usr/lib/atlas')  
     env.Append(LIBS = [env['lapack_libs']])  
     if env['lapack_type']=='mkl':  
        if not env['usemkl']:  
         env['uselapack']=0  
         print "mkl_lapack requires mkl"  
        else:  
         env.AppendUnique(CPPDEFINES='MKL_LAPACK')  
         
   
 ############ Add the compiler flags ############################  
   
 # Enable debug by choosing either cc_debug or cc_optim  
 if env['usedebug']:  
   env.Append(CCFLAGS        = env['cc_debug'])  
   env.Append(CCFLAGS        = env['omp_debug'])  
 else:  
   env.Append(CCFLAGS        = env['cc_optim'])  
   env.Append(CCFLAGS        = env['omp_optim'])  
   
 # Always use cc_flags  
 env.Append(CCFLAGS      = env['cc_flags'])  
 env.Append(LIBS         = [env['omp_libs']])  
   
 ############ Add some custom builders ##########################  
   
 py_builder = Builder(action = scons_extensions.build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)  
 env.Append(BUILDERS = {'PyCompile' : py_builder});  
   
 runUnitTest_builder = Builder(action = scons_extensions.runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)  
 env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});  
   
 runPyUnitTest_builder = Builder(action = scons_extensions.runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)  
 env.Append(BUILDERS = {'RunPyUnitTest' : runPyUnitTest_builder});  
   
 epstopdfbuilder = Builder(action = scons_extensions.eps2pdf, suffix=".pdf", src_suffix=".eps", single_source=True)  
 env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});  
   
 ############ MPI (optional) ####################################  
 if not env['usempi']: env['mpi_flavour']='none'  
   
 # Create a modified environment for MPI programs (identical to env if usempi=no)  
 env_mpi = clone_env(env)  
   
 # Start a new configure environment that reflects what we've already found  
 conf = Configure(clone_env(env_mpi))  
   
 if env_mpi['usempi']:  
   VALID_MPIs=[ "MPT", "MPICH", "MPICH2", "OPENMPI", "INTELMPI" ]  
   if not env_mpi['mpi_flavour'] in VALID_MPIs:  
       raise ValueError,"MPI is enabled but mpi_flavour = %s is not a valid key from %s."%( env_mpi['mpi_flavour'],VALID_MPIs)  
   conf.env.AppendUnique(CPPPATH = [env_mpi['mpi_path']])  
   conf.env.AppendUnique(LIBPATH = [env_mpi['mpi_lib_path']])  
   conf.env.AppendUnique(LIBS    = [env_mpi['mpi_libs']])  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mpi_lib_path']) # The wrapper script needs to find these libs  
   #ensure that our path entries remain at the front  
   conf.env.PrependENVPath('PYTHONPATH', prefix)  
   conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  
   
 if env_mpi['usempi'] and not conf.CheckCHeader('mpi.h'): env_mpi['usempi'] = 0  
 # if env_mpi['usempi'] and not conf.CheckFunc('MPI_Init'): env_mpi['usempi'] = 0  
   
 # Add MPI to environment env_mpi if it was found  
 if env_mpi['usempi']:  
   env_mpi = conf.Finish()  
   env_mpi.Append(CPPDEFINES = ['PASO_MPI', 'MPI_NO_CPPBIND', env_mpi['MPICH_IGNORE_CXX_SEEK']])  
   # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!  
   # On the other hand MPT and OpenMPI don't define the latter so we have to  
   # do that here  
   if env['usenetcdf'] and env_mpi['mpi_flavour'] in ["MPT","OPENMPI"]:  
     env_mpi.Append(CPPDEFINES = ['MPI_INCLUDED'])  
759  else:  else:
760    conf.Finish()      print("          LAPACK:  DISABLED")
761    d_list=[]
762  env['usempi'] = env_mpi['usempi']  e_list=[]
763    for i in 'debug','openmp','netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit','vsl_random':
764  ############ ParMETIS (optional) ###############################      if env[i]: e_list.append(i)
765        else: d_list.append(i)
766  # Start a new configure environment that reflects what we've already found  for i in e_list:
767  conf = Configure(clone_env(env_mpi))      print("%16s:  YES"%i)
768    for i in d_list:
769  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0      print("%16s:  DISABLED"%i)
770    if env['cppunit']:
771  if env_mpi['useparmetis']:      print("         CppUnit:  FOUND")
772    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  else:
773    conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])      print("         CppUnit:  NOT FOUND")
774    conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  if env['gmsh']=='m':
775    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['parmetis_lib_path'])    # The wrapper script needs to find these libs      print("            gmsh:  FOUND, MPI-ENABLED")
776    #ensure that our path entries remain at the front  elif env['gmsh']=='s':
777    conf.env.PrependENVPath('PYTHONPATH', prefix)      print("            gmsh:  FOUND")
778    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  else:
779        print("            gmsh:  NOT FOUND")
780  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  if env['numpy_h']:
781  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0      print("   numpy headers:  FOUND")
782    else:
783  # Add ParMETIS to environment env_mpi if it was found      print("   numpy headers:  NOT FOUND")
784  if env_mpi['useparmetis']:  print("   vsl_random:  %s"%env['vsl_random'])
785    env_mpi = conf.Finish()      
786    env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  if ((fatalwarning != '') and (env['werror'])):
787        print("  Treating warnings as errors")
788  else:  else:
789    conf.Finish()      print("  NOT treating warnings as errors")
790    print("")
 env['useparmetis'] = env_mpi['useparmetis']  
   
 ############ Summarize our environment #########################  
   
 print ""  
 print "Summary of configuration (see ./config.log for information)"  
 print " Using python libraries"  
 print " Using numpy"  
 print " Using boost"  
 if env['usenetcdf']: print "    Using NetCDF"  
 else: print "   Not using NetCDF"  
 if env['usevtk']: print "   Using VTK"  
 else: print "   Not using VTK"  
 if env['usevisit']: print " Using VisIt"  
 else: print "   Not using VisIt"  
 if env['usemkl']: print "   Using MKL"  
 else: print "   Not using MKL"  
 if env['useumfpack']: print "   Using UMFPACK"  
 else: print "   Not using UMFPACK"  
 if env['usesilo']: print "  Using Silo"  
 else: print "   Not using Silo"  
 if env['useopenmp']: print "    Using OpenMP"  
 else: print "   Not using OpenMP"  
 if env['usempi']: print "   Using MPI (flavour = %s)"%env['mpi_flavour']  
 else: print "   Not using MPI"  
 if env['useparmetis']: print "  Using ParMETIS"  
 else: print "   Not using ParMETIS (requires MPI)"  
 if env['usepapi']: print "  Using PAPI"  
 else: print "   Not using PAPI"  
 if env['uselapack']: print "    Using Lapack"  
 else: print "   Not using Lapack"  
 if env['usedebug']: print " Compiling for debug"  
 else: print "   Not compiling for debug"  
 print " Installing in", prefix  
 if ((fatalwarning != "") and (env['usewarnings'])): print " Treating warnings as errors"  
 else: print "   Not treating warnings as errors"  
 print ""  
   
 ############ Delete option-dependent files #####################  
   
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.debug")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.mpi")))  
 Execute(Delete(os.path.join(env['libinstall'],"Compiled.with.openmp")))  
 Execute(Delete(os.path.join(env['libinstall'],"pyversion")))  
 Execute(Delete(os.path.join(env['libinstall'],"buildvars")))  
 if not env['usempi']: Execute(Delete(os.path.join(env['libinstall'],"pythonMPI")))  
   
   
 ############ Build the subdirectories ##########################  
   
 if env['usepedantic']: env_mpi.Append(CCFLAGS = pedantic)  
791    
792    ####################### Configure the subdirectories #########################
793    
794  from grouptest import *  from grouptest import *
795    
796  TestGroups=[]  TestGroups=[]
797    
798  dodgy_env=clone_env(env_mpi)    # Environment without pedantic options  # keep an environment without warnings-as-errors
799    dodgy_env=env.Clone()
 ############ Now we switch on Warnings as errors ###############  
   
 #this needs to be done after configuration because the scons test files have warnings in them  
   
 if ((fatalwarning != "") and (env['usewarnings'])):  
   env.Append(CCFLAGS        = fatalwarning)  
   env_mpi.Append(CCFLAGS        = fatalwarning)  
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(  Export(
807    ["env",    ['env',
808     "env_mpi",     'dodgy_env',
809     "clone_env",     'IS_WINDOWS',
810     "dodgy_env",     'TestGroups'
811     "IS_WINDOWS_PLATFORM",    ]
812     "TestGroups",  )
    "CallSConscript",  
    "cantusevariantdir"  
    ]  
   )  
   
 CallSConscript(env, dirs = ['tools/CppUnitTest/src'], variant_dir='build/$PLATFORM/tools/CppUnitTest', duplicate=0)  
 CallSConscript(env, dirs = ['tools/escriptconvert'], variant_dir='build/$PLATFORM/tools/escriptconvert', duplicate=0)  
 CallSConscript(env, dirs = ['paso/src'], variant_dir='build/$PLATFORM/paso', duplicate=0)  
 CallSConscript(env, dirs = ['weipa/src'], variant_dir='build/$PLATFORM/weipa', duplicate=0)  
 CallSConscript(env, dirs = ['escript/src'], variant_dir='build/$PLATFORM/escript', duplicate=0)  
 CallSConscript(env, dirs = ['esysUtils/src'], variant_dir='build/$PLATFORM/esysUtils', duplicate=0)  
 CallSConscript(env, dirs = ['finley/src'], variant_dir='build/$PLATFORM/finley', duplicate=0)  
 CallSConscript(env, dirs = ['modellib/py_src'], variant_dir='build/$PLATFORM/modellib', duplicate=0)  
 CallSConscript(env, dirs = ['doc'], variant_dir='build/$PLATFORM/doc', duplicate=0)  
 CallSConscript(env, dirs = ['pyvisi/py_src'], variant_dir='build/$PLATFORM/pyvisi', duplicate=0)  
 CallSConscript(env, dirs = ['pycad/py_src'], variant_dir='build/$PLATFORM/pycad', duplicate=0)  
 CallSConscript(env, dirs = ['pythonMPI/src'], variant_dir='build/$PLATFORM/pythonMPI', duplicate=0)  
 CallSConscript(env, dirs = ['scripts'], variant_dir='build/$PLATFORM/scripts', duplicate=0)  
 CallSConscript(env, dirs = ['paso/profiling'], variant_dir='build/$PLATFORM/paso/profiling', duplicate=0)  
   
   
 ############ Remember what optimizations we used ###############  
   
 remember_list = []  
   
 if env['usedebug']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.debug"), None, Touch('$TARGET'))  
   
 if env['usempi']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.mpi"), None, Touch('$TARGET'))  
   
 if env['useopenmp']:  
   remember_list += env.Command(os.path.join(env['libinstall'],"Compiled.with.openmp"), None, Touch('$TARGET'))  
   
 env.Alias('remember_options', remember_list)  
   
   
 ############### Record python interpreter version ##############  
   
 if not IS_WINDOWS_PLATFORM:  
   
   versionstring="Python "+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])  
   if sys.version_info[4] >0 : versionstring+="rc%s"%sys.version_info[4]  
   os.system("echo "+versionstring+" > "+os.path.join(env['libinstall'],"pyversion"))  
   
 ############## Populate the buildvars file #####################  
813    
814  buildvars=open(os.path.join(env['libinstall'],'buildvars'),'w')  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
815  buildvars.write('python='+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+'\n')  env.SConscript(dirs = ['paso/src'], variant_dir='$BUILD_DIR/$PLATFORM/paso', duplicate=0)
816    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
817    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  # Find the boost version by extracting it from version.hpp  # Try to extract the boost version from version.hpp
839  boosthpp=open(os.path.join(env['boost_path'],'boost','version.hpp'))  boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
840  boostversion='unknown'  boostversion='unknown'
841  try:  try:
842      for line in boosthpp:      for line in boosthpp:
843          ver=re.match(r'#define BOOST_VERSION (\d+)',line)          ver=re.match(r'#define BOOST_VERSION (\d+)',line)
844          if ver:          if ver:
845              boostversion=ver.group(1)              boostversion=ver.group(1)
846  except StopIteration:  except StopIteration:
847      pass      pass
848  buildvars.write("boost="+boostversion+"\n")  boosthpp.close()
849    
850    
851    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
852  buildvars.write("svn_revision="+str(global_revision)+"\n")  buildvars.write("svn_revision="+str(global_revision)+"\n")
853  out="usedebug="  buildvars.write("prefix="+prefix+"\n")
854  if env['usedebug']:  buildvars.write("cc="+env['CC']+"\n")
855      out+="y"  buildvars.write("cxx="+env['CXX']+"\n")
856  else:  if env['pythoncmd']=='python':
857      out+="n"      buildvars.write("python="+sys.executable+"\n")
858  out+="\nusempi="      buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
859  if env['usempi']:  else:
860      out+="y"      buildvars.write("python="+env['pythoncmd']+"\n")
861  else:      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      out+="n"      verstring=p.stdout.readline().strip()
863  out+="\nuseopenmp="      p.wait()
864  if env['useopenmp']:      buildvars.write("python_version="+verstring+"\n")
865      out+="y"  buildvars.write("boost_inc_path="+boost_inc_path+"\n")
866  else:  buildvars.write("boost_lib_path="+boost_lib_path+"\n")
867      out+="n"  buildvars.write("boost_version="+boostversion+"\n")
868  buildvars.write(out+"\n")  buildvars.write("debug=%d\n"%int(env['debug']))
869  buildvars.write("mpi_flavour="+env['mpi_flavour']+'\n')  buildvars.write("openmp=%d\n"%int(env['openmp']))
870  out="lapack="  buildvars.write("mpi=%s\n"%env['mpi'])
871  if env['uselapack']:  buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
872     out+="y"  buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
873  else:  buildvars.write("lapack=%s\n"%env['lapack'])
874     out+="n"  buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
875  out+="\nsilo="  for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
876  if env['usesilo']:      buildvars.write("%s=%d\n"%(i, int(env[i])))
877     out+="y"      if env[i]:
878  else:          buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
879     out+="n"          buildvars.write("%s_lib_path=%s\n"%(i, eval(i+'_lib_path')))
 out+="\nusevisit="  
 if env['usevisit']:  
    out+="y"  
 else:  
    out+="n"  
 buildvars.write(out+"\n")  
880  buildvars.close()  buildvars.close()
881    
882    ################### Targets to build and install libraries ###################
883    
884  ############ Targets to build and install libraries ############  target_init = env.Command(os.path.join(env['pyinstall'],'__init__.py'), None, Touch('$TARGET'))
   
 target_init = env.Command(env['pyinstall']+'/__init__.py', None, Touch('$TARGET'))  
885  env.Alias('target_init', [target_init])  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 #include <paso/Common.h>  # The headers have to be installed prior to build in order to satisfy
890  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])  # #include <paso/Common.h>
891  env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])  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', ['target_install_paso_headers', 'target_paso_a'])  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
895  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
896    
897  env.Alias('build_weipa', ['target_install_weipa_headers', 'target_weipa_so', 'target_weipacpp_so'])  env.Alias('build_escript', ['install_escript_headers', 'build_escript_lib', 'build_escriptcpp_lib'])
898  env.Alias('install_weipa', ['build_weipa', 'target_install_weipa_so', 'target_install_weipacpp_so', 'target_install_weipa_py'])  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_escriptreader', ['target_install_weipa_headers', 'target_escriptreader_a'])  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
904  env.Alias('install_escriptreader', ['build_escriptreader', 'target_install_escriptreader_a'])  env.Alias('install_dudley', ['build_dudley', 'install_dudley_lib', 'install_dudleycpp_lib', 'install_dudley_py'])
905    
906  env.Alias('build_escript', ['target_install_escript_headers', 'target_escript_so', 'target_escriptcpp_so'])  env.Alias('build_finley', ['install_finley_headers', 'build_finley_lib', 'build_finleycpp_lib'])
907  env.Alias('install_escript', ['build_escript', 'target_install_escript_so', 'target_install_escriptcpp_so', 'target_install_escript_py'])  env.Alias('install_finley', ['build_finley', 'install_finley_lib', 'install_finleycpp_lib', 'install_finley_py'])
908    
909  env.Alias('build_finley', ['target_install_finley_headers', 'target_finley_so', 'target_finleycpp_so'])  env.Alias('build_ripley', ['install_ripley_headers', 'build_ripley_lib', 'build_ripleycpp_lib'])
910  env.Alias('install_finley', ['build_finley', 'target_install_finley_so', 'target_install_finleycpp_so', 'target_install_finley_py'])  env.Alias('install_ripley', ['build_ripley', 'install_ripley_lib', 'install_ripleycpp_lib', 'install_ripley_py'])
911    
912  # Now gather all the above into a couple easy targets: build_all and install_all  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 = []  build_all_list = []
920  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
921  build_all_list += ['build_paso']  build_all_list += ['build_paso']
 build_all_list += ['build_weipa']  
922  build_all_list += ['build_escript']  build_all_list += ['build_escript']
923    build_all_list += ['build_pasowrap']
924    build_all_list += ['build_dudley']
925  build_all_list += ['build_finley']  build_all_list += ['build_finley']
926  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  build_all_list += ['build_ripley']
927  #if not IS_WINDOWS_PLATFORM:    build_all_list += ['target_escript_wrapper']  build_all_list += ['build_weipa']
928  build_all_list += ['target_escriptconvert']  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)  env.Alias('build_all', build_all_list)
932    
933  install_all_list = []  install_all_list = []
934  install_all_list += ['target_init']  install_all_list += ['target_init']
935  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
936  install_all_list += ['install_paso']  install_all_list += ['install_paso']
 install_all_list += ['install_weipa']  
937  install_all_list += ['install_escript']  install_all_list += ['install_escript']
938    install_all_list += ['install_pasowrap']
939    install_all_list += ['install_dudley']
940  install_all_list += ['install_finley']  install_all_list += ['install_finley']
941  install_all_list += ['target_install_pyvisi_py']  install_all_list += ['install_ripley']
942  install_all_list += ['target_install_modellib_py']  install_all_list += ['install_weipa']
943  install_all_list += ['target_install_pycad_py']  if not IS_WINDOWS: install_all_list += ['install_escriptreader']
944  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  install_all_list += ['install_downunder_py']
945  #if not IS_WINDOWS_PLATFORM:    install_all_list += ['target_install_escript_wrapper']  install_all_list += ['install_modellib_py']
946  if env['usesilo']:  install_all_list += ['target_install_escriptconvert']  install_all_list += ['install_pycad_py']
947  install_all_list += ['remember_options']  if env['usempi']:   install_all_list += ['install_pythonMPI']
948    install_all_list += ['install_escriptconvert']
949  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
950    
951  # Default target is install  # Default target is install
952  env.Default('install_all')  env.Default('install_all')
953    
954  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
955    
956  env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  if not env['cppunit']:
957  env.Alias('install_cppunittest', ['build_cppunittest', 'target_install_cppunittest_a'])      test_msg = env.Command('.dummy.', None, '@echo "Cannot run C/C++ unit tests, CppUnit not found!";exit 1')
958  env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])      env.Alias('run_tests', test_msg)
959  env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])  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'])  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 #####################
 ############ Targets to build the documentation ################  
965    
966  env.Alias('api_epydoc','install_all')  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  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html','install_pdf', 'cookbook_pdf'])  if not IS_WINDOWS:
971        try:
972  build_platform=os.name          utest=open('utest.sh','w')
973            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix))
974  if not IS_WINDOWS_PLATFORM:          for tests in TestGroups:
975     try:              utest.write(tests.makeString())
976      utest=open("utest.sh","w")          utest.close()
977      #Sometimes Mac python says it is posix          Execute(Chmod('utest.sh', 0o755))
978      if (build_platform=='posix') and platform.system()=="Darwin":          print("Generated utest.sh.")
979          build_platform='darwin'      except IOError:
980      utest.write(GroupTest.makeHeader(build_platform))          print("Error attempting to write unittests file.")
981      for tests in TestGroups:          Exit(1)
982          utest.write(tests.makeString())  
983      utest.close()      # delete utest.sh upon cleanup
984      os.chmod("utest.sh",stat.S_IRWXU|stat.S_IRGRP|stat.S_IXGRP|stat.S_IROTH|stat.S_IXOTH)      env.Clean('target_init', 'utest.sh')
985      print "utest.sh written"  
986     except IOError:      # Make sure that the escript wrapper is in place
987      print "Error attempting to write unittests file."      if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
988      sys.exit(1)          print("Copying escript wrapper.")
989            Execute(Copy(os.path.join(env['bininstall'],'run-escript'), 'bin/run-escript'))
    #Make sure that the escript wrapper is in place  
    if not os.path.isfile(os.path.join(env['bininstall'],'escript')):  
        print "Copying escript wrapper"  
        shutil.copy("bin/escript",os.path.join(env['bininstall'],'escript'))  
   
 ############ Targets to build PasoTests suite ################  
   
 env.Alias('build_PasoTests','build/'+build_platform+'/paso/profiling/PasoTests')  
990    
 env.Alias('release_prep', ['docs', 'install_all'])  

Legend:
Removed from v.3096  
changed lines
  Added in v.3967

  ViewVC Help
Powered by ViewVC 1.1.26