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

Diff of /branches/mvexpr/SConstruct

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

revision 3097 by gross, Fri Aug 20 04:59:12 2010 UTC revision 3961 by jfenwick, Tue Sep 11 07:21:41 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    if env['tools_names'] != 'default':
148        env = Environment(tools = ['default'] + env['tools_names'], options = vars,
149                          ENV = {'PATH' : os.environ['PATH']})
150    
151    if options_file:
152        opts_valid=False
153        if 'escript_opts_version' in env.Dictionary() and \
154            int(env['escript_opts_version']) >= REQUIRED_OPTS_VERSION:
155                opts_valid=True
156        if opts_valid:
157            print("Using options in %s." % options_file)
158        else:
159            print("\nOptions file %s" % options_file)
160            print("is outdated! Please update the file by examining one of the TEMPLATE")
161            print("files in the scons/ subdirectory and setting escript_opts_version to %d.\n"%REQUIRED_OPTS_VERSION)
162            Exit(1)
163    
164    # Generate help text (scons -h)
165    Help(vars.GenerateHelpText(env))
166    
167    # Check for superfluous options
168    if len(vars.UnknownVariables())>0:
169        for k in vars.UnknownVariables():
170            print("Unknown option '%s'" % k)
171        Exit(1)
172    
173    #################### Make sure install directories exist #####################
174    
175    env['BUILD_DIR']=env['build_dir']
176    prefix=Dir(env['prefix']).abspath
177    env['incinstall'] = os.path.join(prefix, 'include')
178    env['bininstall'] = os.path.join(prefix, 'bin')
179    env['libinstall'] = os.path.join(prefix, 'lib')
180    env['pyinstall']  = os.path.join(prefix, 'esys')
181  if not os.path.isdir(env['bininstall']):  if not os.path.isdir(env['bininstall']):
182      os.makedirs(env['bininstall'])      os.makedirs(env['bininstall'])
183  if not os.path.isdir(env['libinstall']):  if not os.path.isdir(env['libinstall']):
# Line 239  if not os.path.isdir(env['libinstall']): Line 185  if not os.path.isdir(env['libinstall']):
185  if not os.path.isdir(env['pyinstall']):  if not os.path.isdir(env['pyinstall']):
186      os.makedirs(env['pyinstall'])      os.makedirs(env['pyinstall'])
187    
188  ########## Copy required environment vars ######################  env.Append(CPPPATH = [env['incinstall']])
189    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 -ip"  
   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 -finline-functions"  
 #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  
190    
191  # 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 #########  
192    
193  try: env['ENV']['OMP_NUM_THREADS'] = os.environ['OMP_NUM_THREADS']  if env['cc'] != 'default': env['CC']=env['cc']
194  except KeyError: env['ENV']['OMP_NUM_THREADS'] = 1  if env['cxx'] != 'default': env['CXX']=env['cxx']
195    
196  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++
197  except KeyError: pass  # runtimes (icc does not)
198    if not IS_WINDOWS and os.uname()[4]=='ia64' and env['CXX']=='icpc':
199        env['LINK'] = env['CXX']
200    
201    # default compiler/linker options
202    cc_flags = ''
203    cc_optim = ''
204    cc_debug = ''
205    omp_flags = ''
206    omp_ldflags = ''
207    fatalwarning = '' # switch to turn warnings into errors
208    sysheaderopt = '' # how to indicate that a header is a system header
209    
210    # env['CC'] might be a full path
211    cc_name=os.path.basename(env['CC'])
212    
213    if cc_name == 'icc':
214        # Intel compiler
215        cc_flags    = "-std=c99 -fPIC -wd161 -w1 -vec-report0 -DBLOCKTIMER -DCORE_ID1"
216        cc_optim    = "-O3 -ftz -IPF_ftlacc- -IPF_fma -fno-alias -ip"
217        cc_debug    = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
218        omp_flags   = "-openmp -openmp_report0"
219        omp_ldflags = "-openmp -openmp_report0 -lpthread"
220        fatalwarning = "-Werror"
221    elif cc_name[:3] == 'gcc':
222        # GNU C on any system
223        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"
224        cc_optim     = "-O3"
225        cc_debug     = "-g -O0 -DDOASSERT -DDOPROF -DBOUNDS_CHECK"
226        omp_flags    = "-fopenmp"
227        omp_ldflags  = "-fopenmp"
228        fatalwarning = "-Werror"
229        sysheaderopt = "-isystem"
230    elif cc_name == 'cl':
231        # Microsoft Visual C on Windows
232        cc_flags     = "/EHsc /MD /GR /wd4068 /D_USE_MATH_DEFINES /DDLL_NETCDF"
233        cc_optim     = "/O2 /Op /W3"
234        cc_debug     = "/Od /RTCcsu /ZI /DBOUNDS_CHECK"
235        fatalwarning = "/WX"
236    elif cc_name == 'icl':
237        # Intel C on Windows
238        cc_flags     = '/EHsc /GR /MD'
239        cc_optim     = '/fast /Oi /W3 /Qssp /Qinline-factor- /Qinline-min-size=0 /Qunroll'
240        cc_debug     = '/Od /RTCcsu /Zi /Y- /debug:all /Qtrapuv'
241        omp_flags    = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
242        omp_ldflags  = '/Qvec-report0 /Qopenmp /Qopenmp-report0 /Qparallel'
243    
244    # set defaults if not otherwise specified
245    if env['cc_flags']    == 'default': env['cc_flags'] = cc_flags
246    if env['cc_optim']    == 'default': env['cc_optim'] = cc_optim
247    if env['cc_debug']    == 'default': env['cc_debug'] = cc_debug
248    if env['omp_flags']   == 'default': env['omp_flags'] = omp_flags
249    if env['omp_ldflags'] == 'default': env['omp_ldflags'] = omp_ldflags
250    if env['cc_extra']  != '': env.Append(CFLAGS = env['cc_extra'])
251    if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])
252    if env['ld_extra']  != '': env.Append(LINKFLAGS = env['ld_extra'])
253    
254  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  
255    
256  try: env['ENV']['ESCRIPT_NUM_NODES'] = os.environ['ESCRIPT_NUM_NODES']  if env['usepython3']:
257  except KeyError: env['ENV']['ESCRIPT_NUM_NODES']=1      env.Append(CPPDEFINES=['ESPYTHON3'])
258    
259  try: env['ENV']['ESCRIPT_HOSTFILE'] = os.environ['ESCRIPT_HOSTFILE']  # set up the autolazy values
260  except KeyError: pass  if env['forcelazy'] == 'on':
261        env.Append(CPPDEFINES=['FAUTOLAZYON'])
262    elif env['forcelazy'] == 'off':
263        env.Append(CPPDEFINES=['FAUTOLAZYOFF'])
264    
265    # set up the collective resolve values
266    if env['forcecollres'] == 'on':
267        env.Append(CPPDEFINES=['FRESCOLLECTON'])
268    elif env['forcecollres'] == 'off':
269        env.Append(CPPDEFINES=['FRESCOLLECTOFF'])
270    
271  try: env['ENV']['PATH'] = os.environ['PATH']  # allow non-standard C if requested
272  except KeyError: pass  if env['iknowwhatimdoing']:
273        env.Append(CPPDEFINES=['IKNOWWHATIMDOING'])
274    
275  try: env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']  # Disable OpenMP if no flags provided
276  except KeyError: pass  if env['openmp'] and env['omp_flags'] == '':
277       print("OpenMP requested but no flags provided - disabling OpenMP!")
278       env['openmp'] = False
279    
280  try: env['ENV']['C_INCLUDE_PATH'] = os.environ['C_INCLUDE_PATH']  if env['openmp']:
281  except KeyError: pass      env.Append(CCFLAGS = env['omp_flags'])
282        if env['omp_ldflags'] != '': env.Append(LINKFLAGS = env['omp_ldflags'])
283    else:
284        env['omp_flags']=''
285        env['omp_ldflags']=''
286    
287  try: env['ENV']['CPLUS_INCLUDE_PATH'] = os.environ['CPLUS_INCLUDE_PATH']  # add debug/non-debug compiler flags
288  except KeyError: pass  if env['debug']:
289        env.Append(CCFLAGS = env['cc_debug'])
290    else:
291        env.Append(CCFLAGS = env['cc_optim'])
292    
293  try: env.PrependENVPath(LD_LIBRARY_PATH_KEY,os.environ['LD_LIBRARY_PATH'])  # always add cc_flags
294  except KeyError: pass  env.Append(CCFLAGS = env['cc_flags'])
295    
296  try: env['ENV']['LIBRARY_PATH'] = os.environ['LIBRARY_PATH']  # add system libraries
297  except KeyError: pass  env.AppendUnique(LIBS = env['sys_libs'])
298    
 try: env['ENV']['DISPLAY'] = os.environ['DISPLAY']  
 except KeyError: pass  
299    
300  try: env['ENV']['XAUTHORITY'] = os.environ['XAUTHORITY']  global_revision=ARGUMENTS.get('SVN_VERSION', None)
301  except KeyError: pass  if global_revision:
302        global_revision = re.sub(':.*', '', global_revision)
303        global_revision = re.sub('[^0-9]', '', global_revision)
304        if global_revision == '': global_revision='-2'
305    else:
306      # Get the global Subversion revision number for the getVersion() method
307      try:
308        global_revision = os.popen('svnversion -n .').read()
309        global_revision = re.sub(':.*', '', global_revision)
310        global_revision = re.sub('[^0-9]', '', global_revision)
311        if global_revision == '': global_revision='-2'
312      except:
313        global_revision = '-1'
314    env['svn_revision']=global_revision
315    env.Append(CPPDEFINES=['SVN_VERSION='+global_revision])
316    
317    if IS_WINDOWS:
318        if not env['build_shared']:
319            env.Append(CPPDEFINES = ['ESYSUTILS_STATIC_LIB'])
320            env.Append(CPPDEFINES = ['PASO_STATIC_LIB'])
321    
322  try: env['ENV']['HOME'] = os.environ['HOME']  ###################### Copy required environment vars ########################
 except KeyError: pass  
323    
324  # Configure for test suite  # Windows doesn't use LD_LIBRARY_PATH but PATH instead
325    if IS_WINDOWS:
326        LD_LIBRARY_PATH_KEY='PATH'
327        env['ENV']['LD_LIBRARY_PATH']=''
328    else:
329        LD_LIBRARY_PATH_KEY='LD_LIBRARY_PATH'
330    
331    # the following env variables are exported for the unit tests
332    
333  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  for key in 'OMP_NUM_THREADS', 'ESCRIPT_NUM_PROCS', 'ESCRIPT_NUM_NODES':
334  env.PrependENVPath('PYTHONPATH', prefix)      try:
335  env['ENV']['ESCRIPT_ROOT'] = prefix          env['ENV'][key] = os.environ[key]
336        except KeyError:
337            env['ENV'][key] = 1
338    
339    env_export=env['env_export']
340    env_export.extend(['ESCRIPT_NUM_THREADS','ESCRIPT_HOSTFILE','DISPLAY','XAUTHORITY','PATH','HOME','TMPDIR','TEMP','TMP'])
341    
342    for key in set(env_export):
343        try:
344            env['ENV'][key] = os.environ[key]
345        except KeyError:
346            pass
347    
348  ############ Set up paths for Configure() ######################  try:
349        env.PrependENVPath(LD_LIBRARY_PATH_KEY, os.environ[LD_LIBRARY_PATH_KEY])
350    except KeyError:
351        pass
352    
353  # Make a copy of an environment  # these shouldn't be needed
354  # 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':
355  def clone_env(env):  #    try:
356    if 'Clone' in dir(env): return env.Clone()    # scons-0.98  #        env['ENV'][key] = os.environ[key]
357    else:                   return env.Copy() # scons-0.96  #    except KeyError:
358    #        pass
359    
360  # Add cc option -I<Escript>/trunk/include  try:
361  env.Append(CPPPATH      = [Dir('include')])      env['ENV']['PYTHONPATH'] = os.environ['PYTHONPATH']
362    except KeyError:
363        pass
364    
365  # Add cc option -L<Escript>/trunk/lib  ######################## Add some custom builders ############################
 env.Append(LIBPATH      = [Dir(env['libinstall'])])  
366    
367  if env['cc_extra'] != '': env.Append(CFLAGS = env['cc_extra'])  if env['pythoncmd']=='python':
368  if env['cxx_extra'] != '': env.Append(CXXFLAGS = env['cxx_extra'])      py_builder = Builder(action = build_py, suffix = '.pyc', src_suffix = '.py', single_source=True)
369  if env['ld_extra'] != '': env.Append(LINKFLAGS = env['ld_extra'])  else:
370        py_builder = Builder(action = env['pythoncmd']+" scripts/py_comp.py $SOURCE $TARGET", suffix = '.pyc', src_suffix = '.py', single_source=True)
371    env.Append(BUILDERS = {'PyCompile' : py_builder});
372    
373  if env['usepedantic']: env.Append(CCFLAGS = pedantic)  runUnitTest_builder = Builder(action = runUnitTest, suffix = '.passed', src_suffix=env['PROGSUFFIX'], single_source=True)
374    env.Append(BUILDERS = {'RunUnitTest' : runUnitTest_builder});
375    
376  # MS Windows  runPyUnitTest_builder = Builder(action = runPyUnitTest, suffix = '.passed', src_suffic='.py', single_source=True)
377  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'])  
378    
379    if env['usenetcdf']:  epstopdfbuilder = Builder(action = eps2pdf, suffix='.pdf', src_suffix='.eps', single_source=True)
380      env.AppendENVPath('PATH',   [env['netCDF_lib_path']])  env.Append(BUILDERS = {'EpsToPDF' : epstopdfbuilder});
381    
382  env.Append(ARFLAGS = env['ar_flags'])  ############################ Dependency checks ###############################
383    
384  # Get the global Subversion revision number for getVersion() method  # Create a Configure() environment to check for compilers and python
385  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])  
386    
387  ############ numpy (required) ###############################  ######## Test that the compilers work
388    
389  try:  if 'CheckCC' in dir(conf): # exists since scons 1.1.0
390    from numpy import identity      if not conf.CheckCC():
391  except ImportError:          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
392    print "Cannot import numpy, you need to set your PYTHONPATH"          Exit(1)
393    sys.exit(1)      if not conf.CheckCXX():
394            print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
395  ############ C compiler (required) #############################          Exit(1)
396    else:
397  # Create a Configure() environment for checking existence of required libraries and headers      if not conf.CheckFunc('printf', language='c'):
398  conf = Configure(clone_env(env))          print("Cannot run C compiler '%s' (check config.log)" % (env['CC']))
399            Exit(1)
400  # Test that the compiler is working      if not conf.CheckFunc('printf', language='c++'):
401  if not conf.CheckFunc('printf'):          print("Cannot run C++ compiler '%s' (check config.log)" % (env['CXX']))
402     print "Cannot run C compiler '%s' (or libc is missing)" % (env['CC'])          Exit(1)
    sys.exit(1)  
403    
404  if conf.CheckFunc('gethostname'):  if conf.CheckFunc('gethostname'):
405    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']])  
406    
407  conf.env.AppendUnique(LIBPATH       = [env['python_lib_path']])  ######## Python headers & library (required)
 conf.env.AppendUnique(LIBS      = [env['python_libs']])  
408    
409  conf.env.PrependENVPath('PYTHONPATH', prefix)  #First we check to see if the config file has specified
410  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
411  conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  #But we need to deal with the case where python is not in its INSTALL
412    #Directory
413    # Use the python scons is running
414    if env['pythoncmd']=='python':
415        python_inc_path=sysconfig.get_python_inc()
416        if IS_WINDOWS:
417            python_lib_path=os.path.join(sysconfig.get_config_var('prefix'), 'libs')
418        elif env['PLATFORM']=='darwin':
419            python_lib_path=sysconfig.get_config_var('LIBPL')
420        else:
421            python_lib_path=sysconfig.get_config_var('LIBDIR')
422    
423        #python_libs=[sysconfig.get_config_var('LDLIBRARY')] # only on linux
424        if IS_WINDOWS:
425            python_libs=['python%s%s'%(sys.version_info[0], sys.version_info[1])]
426        else:
427            python_libs=['python'+sysconfig.get_python_version()]
428    
429    #if we want to use a python other than the one scons is running
430    else:
431        initstring='from __future__ import print_function;from distutils import sysconfig;'
432        if env['pythonlibname']!='':
433            python_libs=env['pythonlibname']
434        else:   # work it out by calling python    
435            if IS_WINDOWS:
436                cmd='print("python%s%s"%(sys.version_info[0], sys.version_info[1]))'
437            else:
438                cmd='print("python"+sysconfig.get_python_version())'
439            p=Popen([env['pythoncmd'], '-c', initstring+cmd], stdout=PIPE)
440            python_libs=p.stdout.readline()
441            if env['usepython3']:       # This is to convert unicode str into py2 string
442                python_libs=python_libs.encode() # If scons runs on py3 then this must be rethought
443            p.wait()
444            python_libs=python_libs.strip()
445    
446      
447        # Now we know whether we are using python3 or not
448        p=Popen([env['pythoncmd'], '-c',  initstring+'print(sysconfig.get_python_inc())'], stdout=PIPE)
449        python_inc_path=p.stdout.readline()
450        if env['usepython3']:
451             python_inc_path=python_inc_path.encode()
452        p.wait()  
453        python_inc_path=python_inc_path.strip()
454        if IS_WINDOWS:
455            cmd="os.path.join(sysconfig.get_config_var('prefix'), 'libs')"
456        elif env['PLATFORM']=='darwin':
457            cmd="sysconfig.get_config_var(\"LIBPL\")"
458        else:
459            cmd="sysconfig.get_config_var(\"LIBDIR\")"
460    
461        p=Popen([env['pythoncmd'], '-c', initstring+'print('+cmd+')'], stdout=PIPE)
462        python_lib_path=p.stdout.readline()
463        if env['usepython3']:
464            python_lib_path=python_lib_path.decode()
465        p.wait()
466        python_lib_path=python_lib_path.strip()
467    
468    #Check for an override from the config file.
469    #Ideally, this should be automatic
470    #But we need to deal with the case where python is not in its INSTALL
471    #Directory
472    if env['pythonlibpath']!='':
473        python_lib_path=env['pythonlibpath']
474    
475    if env['pythonincpath']!='':
476        python_inc_path=env['pythonincpath']
477    
478    
479    if sysheaderopt == '':
480        conf.env.AppendUnique(CPPPATH = [python_inc_path])
481    else:
482        conf.env.Append(CCFLAGS = [sysheaderopt, python_inc_path])
483    
484    conf.env.AppendUnique(LIBPATH = [python_lib_path])
485    conf.env.AppendUnique(LIBS = python_libs)
486    # The wrapper script needs to find the libs
487    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, python_lib_path)
488    
489  if not conf.CheckCHeader('Python.h'):  if not conf.CheckCHeader('Python.h'):
490    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))
491    sys.exit(1)      Exit(1)
492  if not conf.CheckFunc('Py_Exit'):  if not conf.CheckFunc('Py_Exit'):
493    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))
494    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)  
495    
496    ## reuse conf to check for numpy header (optional)
497    if env['usepython3']:
498        # FIXME: This is until we can work out how to make the checks in python 3
499        conf.env['numpy_h']=False
500    else:
501        if conf.CheckCXXHeader(['Python.h','numpy/ndarrayobject.h']):
502            conf.env.Append(CPPDEFINES = ['HAVE_NUMPY_H'])
503            conf.env['numpy_h']=True
504        else:
505            conf.env['numpy_h']=False
506    
507  # Commit changes to environment  # Commit changes to environment
508  env = conf.Finish()  env = conf.Finish()
509    
510  ############ VTK (optional) ####################################  ######## boost (required)
511    
512  if env['usevtk']:  boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
513    try:  if sysheaderopt == '':
514      import vtk      env.AppendUnique(CPPPATH = [boost_inc_path])
515      env['usevtk'] = 1  else:
516    except ImportError:      # This is required because we can't -isystem /usr/include since it breaks
517      env['usevtk'] = 0      # std includes
518        if os.path.normpath(boost_inc_path) == '/usr/include':
519  # Add VTK to environment env if it was found          conf.env.Append(CCFLAGS=[sysheaderopt, os.path.join(boost_inc_path,'boost')])
520  if env['usevtk']:      else:
521    env.Append(CPPDEFINES = ['USE_VTK'])          env.Append(CCFLAGS=[sysheaderopt, boost_inc_path])
522    
523  ############ NetCDF (optional) #################################  env.AppendUnique(LIBPATH = [boost_lib_path])
524    env.AppendUnique(LIBS = env['boost_libs'])
525  conf = Configure(clone_env(env))  env.PrependENVPath(LD_LIBRARY_PATH_KEY, boost_lib_path)
526    
527  if env['usenetcdf']:  ######## numpy (required)
528    conf.env.AppendUnique(CPPPATH = [env['netCDF_path']])  
529    conf.env.AppendUnique(LIBPATH = [env['netCDF_lib_path']])  if env['pythoncmd']=='python':
530    conf.env.AppendUnique(LIBS    = [env['netCDF_libs']])      try:
531    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['netCDF_lib_path'])  # The wrapper script needs to find these libs        from numpy import identity
532    #ensure that our path entries remain at the front      except ImportError:
533    conf.env.PrependENVPath('PYTHONPATH', prefix)        print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
534    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])        Exit(1)
535    else:
536  if env['usenetcdf'] and not conf.CheckCHeader('netcdf.h'): env['usenetcdf'] = 0      p=subprocess.call([env['pythoncmd'],'-c','import numpy'])
537  if env['usenetcdf'] and not conf.CheckFunc('nc_open'): env['usenetcdf'] = 0      if p!=0:
538          print("Cannot import numpy, you need to set your PYTHONPATH and probably %s"%LD_LIBRARY_PATH_KEY)
539  # 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()  
540    
541  ############ PAPI (optional) ###################################  ######## CppUnit (required for tests)
542    
543  # Start a new configure environment that reflects what we've already found  try:
544  conf = Configure(clone_env(env))      cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
545        env.AppendUnique(CPPPATH = [cppunit_inc_path])
546        env.AppendUnique(LIBPATH = [cppunit_lib_path])
547        env.PrependENVPath(LD_LIBRARY_PATH_KEY, cppunit_lib_path)
548        env['cppunit']=True
549    except:
550        env['cppunit']=False
551    
552  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()  
553    
554  ############ MKL (optional) ####################################  netcdf_inc_path=''
555    netcdf_lib_path=''
556    if env['netcdf']:
557        netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdf.h', env['netcdf_prefix'], lang='c++')
558        env.AppendUnique(CPPPATH = [netcdf_inc_path])
559        env.AppendUnique(LIBPATH = [netcdf_lib_path])
560        env.AppendUnique(LIBS = env['netcdf_libs'])
561        env.PrependENVPath(LD_LIBRARY_PATH_KEY, netcdf_lib_path)
562        env.Append(CPPDEFINES = ['USE_NETCDF'])
563    
564    ######## PAPI (optional)
565    
566    papi_inc_path=''
567    papi_lib_path=''
568    if env['papi']:
569        papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c')
570        env.AppendUnique(CPPPATH = [papi_inc_path])
571        env.AppendUnique(LIBPATH = [papi_lib_path])
572        env.AppendUnique(LIBS = env['papi_libs'])
573        env.PrependENVPath(LD_LIBRARY_PATH_KEY, papi_lib_path)
574        env.Append(CPPDEFINES = ['BLOCKPAPI'])
575    
576    ######## MKL (optional)
577    
578    mkl_inc_path=''
579    mkl_lib_path=''
580    if env['mkl']:
581        mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_solver.h', env['mkl_prefix'], lang='c')
582        env.AppendUnique(CPPPATH = [mkl_inc_path])
583        env.AppendUnique(LIBPATH = [mkl_lib_path])
584        env.AppendUnique(LIBS = env['mkl_libs'])
585        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mkl_lib_path)
586        env.Append(CPPDEFINES = ['MKL'])
587    
588    ######## UMFPACK (optional)
589    
590    umfpack_inc_path=''
591    umfpack_lib_path=''
592    if env['umfpack']:
593        umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c')
594        env.AppendUnique(CPPPATH = [umfpack_inc_path])
595        env.AppendUnique(LIBPATH = [umfpack_lib_path])
596        env.AppendUnique(LIBS = env['umfpack_libs'])
597        env.PrependENVPath(LD_LIBRARY_PATH_KEY, umfpack_lib_path)
598        env.Append(CPPDEFINES = ['UMFPACK'])
599    
600    ######## LAPACK (optional)
601    
602    if env['lapack']=='mkl' and not env['mkl']:
603        print("mkl_lapack requires MKL!")
604        Exit(1)
605    
606    env['uselapack'] = env['lapack']!='none'
607    lapack_inc_path=''
608    lapack_lib_path=''
609    if env['uselapack']:
610        header='clapack.h'
611        if env['lapack']=='mkl':
612            env.AppendUnique(CPPDEFINES = ['MKL_LAPACK'])
613            header='mkl_lapack.h'
614        lapack_inc_path,lapack_lib_path=findLibWithHeader(env, env['lapack_libs'], header, env['lapack_prefix'], lang='c')
615        env.AppendUnique(CPPPATH = [lapack_inc_path])
616        env.AppendUnique(LIBPATH = [lapack_lib_path])
617        env.AppendUnique(LIBS = env['lapack_libs'])
618        env.Append(CPPDEFINES = ['USE_LAPACK'])
619    
620    ######## Silo (optional)
621    
622    silo_inc_path=''
623    silo_lib_path=''
624    if env['silo']:
625        silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c')
626        env.AppendUnique(CPPPATH = [silo_inc_path])
627        env.AppendUnique(LIBPATH = [silo_lib_path])
628        # Note that we do not add the libs since they are only needed for the
629        # weipa library and tools.
630        #env.AppendUnique(LIBS = [env['silo_libs']])
631    
632    ######## VSL random numbers (optional)
633    if env['vsl_random']:
634        env.Append(CPPDEFINES = ['MKLRANDOM'])
635    
636    ######## VisIt (optional)
637    
638    visit_inc_path=''
639    visit_lib_path=''
640    if env['visit']:
641        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c')
642        env.AppendUnique(CPPPATH = [visit_inc_path])
643        env.AppendUnique(LIBPATH = [visit_lib_path])
644    
645    ######## MPI (optional)
646    
647    if env['mpi']=='no':
648        env['mpi']='none'
649    
650    env['usempi'] = env['mpi']!='none'
651    mpi_inc_path=''
652    mpi_lib_path=''
653    if env['usempi']:
654        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c')
655        env.AppendUnique(CPPPATH = [mpi_inc_path])
656        env.AppendUnique(LIBPATH = [mpi_lib_path])
657        env.AppendUnique(LIBS = env['mpi_libs'])
658        env.PrependENVPath(LD_LIBRARY_PATH_KEY, mpi_lib_path)
659        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
660        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
661        # On the other hand MPT and OpenMPI don't define the latter so we have to
662        # do that here
663        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
664            env.Append(CPPDEFINES = ['MPI_INCLUDED'])
665    
666    ######## BOOMERAMG (optional)
667    
668    if env['mpi'] == 'none': env['boomeramg'] = False
669    
670    boomeramg_inc_path=''
671    boomeramg_lib_path=''
672    if env['boomeramg']:
673        boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c')
674        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
675        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
676        env.AppendUnique(LIBS = env['boomeramg_libs'])
677        env.PrependENVPath(LD_LIBRARY_PATH_KEY, boomeramg_lib_path)
678        env.Append(CPPDEFINES = ['BOOMERAMG'])
679    
680    ######## ParMETIS (optional)
681    
682    if not env['usempi']: env['parmetis'] = False
683    
684    parmetis_inc_path=''
685    parmetis_lib_path=''
686    if env['parmetis']:
687        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c')
688        env.AppendUnique(CPPPATH = [parmetis_inc_path])
689        env.AppendUnique(LIBPATH = [parmetis_lib_path])
690        env.AppendUnique(LIBS = env['parmetis_libs'])
691        env.PrependENVPath(LD_LIBRARY_PATH_KEY, parmetis_lib_path)
692        env.Append(CPPDEFINES = ['USE_PARMETIS'])
693    
694  # Start a new configure environment that reflects what we've already found  ######## gmsh (optional, for tests)
 conf = Configure(clone_env(env))  
695    
696  if env['usemkl']:  try:
697    conf.env.AppendUnique(CPPPATH = [env['mkl_path']])      import subprocess
698    conf.env.AppendUnique(LIBPATH = [env['mkl_lib_path']])      p=subprocess.Popen(['gmsh', '-info'], stderr=subprocess.PIPE)
699    conf.env.AppendUnique(LIBS    = [env['mkl_libs']])      _,e=p.communicate()
700    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['mkl_lib_path']) # The wrapper script needs to find these libs      if e.split().count("MPI"):
701    #ensure that our path entries remain at the front          env['gmsh']='m'
702    conf.env.PrependENVPath('PYTHONPATH', prefix)      else:
703    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])          env['gmsh']='s'
704    except OSError:
705  if env['usemkl'] and not conf.CheckCHeader('mkl_solver.h'): env['usemkl'] = 0      env['gmsh']=False
706  if env['usemkl'] and not conf.CheckFunc('pardiso'): env['usemkl'] = 0  
707    ######## PDFLaTeX (for documentation)
708    if 'PDF' in dir(env) and '.tex' in env.PDF.builder.src_suffixes(env):
709  # Add MKL to environment env if it was found      env['pdflatex']=True
 if env['usemkl']:  
   env = conf.Finish()  
   env.Append(CPPDEFINES = ['MKL'])  
710  else:  else:
711    conf.Finish()      env['pdflatex']=False
712    
713  ############ UMFPACK (optional) ################################  ######################## Summarize our environment ###########################
714    
715  # 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
716  conf = Configure(clone_env(env))  env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])
717    env.PrependENVPath('PYTHONPATH', prefix)
718    env['ENV']['ESCRIPT_ROOT'] = prefix
719    
720  if env['useumfpack']:  if not env['verbose']:
721    conf.env.AppendUnique(CPPPATH = [env['ufc_path']])      env['CCCOMSTR'] = "Compiling $TARGET"
722    conf.env.AppendUnique(CPPPATH = [env['umf_path']])      env['CXXCOMSTR'] = "Compiling $TARGET"
723    conf.env.AppendUnique(LIBPATH = [env['umf_lib_path']])      env['SHCCCOMSTR'] = "Compiling $TARGET"
724    conf.env.AppendUnique(LIBS    = [env['umf_libs']])      env['SHCXXCOMSTR'] = "Compiling $TARGET"
725    conf.env.AppendUnique(CPPPATH = [env['amd_path']])      env['ARCOMSTR'] = "Linking $TARGET"
726    conf.env.AppendUnique(LIBPATH = [env['amd_lib_path']])      env['LINKCOMSTR'] = "Linking $TARGET"
727    conf.env.AppendUnique(LIBS    = [env['amd_libs']])      env['SHLINKCOMSTR'] = "Linking $TARGET"
728    conf.env.AppendUnique(CPPPATH = [env['blas_path']])      env['PDFLATEXCOMSTR'] = "Building $TARGET from LaTeX input $SOURCES"
729    conf.env.AppendUnique(LIBPATH = [env['blas_lib_path']])      env['BIBTEXCOMSTR'] = "Generating bibliography $TARGET"
730    conf.env.AppendUnique(LIBS    = [env['blas_libs']])      env['MAKEINDEXCOMSTR'] = "Generating index $TARGET"
731    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"
732    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)
733    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['blas_lib_path'])    # The wrapper script needs to find these libs  
734    #ensure that our path entries remain at the front  print("")
735    conf.env.PrependENVPath('PYTHONPATH', prefix)  print("*** Config Summary (see config.log and lib/buildvars for details) ***")
736    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  print("Escript/Finley revision %s"%global_revision)
737    print("  Install prefix:  %s"%env['prefix'])
738  if env['useumfpack'] and not conf.CheckCHeader('umfpack.h'): env['useumfpack'] = 0  print("          Python:  %s"%sysconfig.PREFIX)
739  if env['useumfpack'] and not conf.CheckFunc('umfpack_di_symbolic'): env['useumfpack'] = 0  print("           boost:  %s"%env['boost_prefix'])
740  # if env['useumfpack'] and not conf.CheckFunc('daxpy'): env['useumfpack'] = 0 # this does not work on shake73?  print("           numpy:  YES")
741    if env['usempi']:
742  # 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'])  
743  else:  else:
744    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) ##################################  
   
745  if env['uselapack']:  if env['uselapack']:
746      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'])  
747  else:  else:
748    conf.Finish()      print("          LAPACK:  DISABLED")
749    d_list=[]
750  env['usempi'] = env_mpi['usempi']  e_list=[]
751    for i in 'debug','openmp','netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit','vsl_random':
752  ############ ParMETIS (optional) ###############################      if env[i]: e_list.append(i)
753        else: d_list.append(i)
754  # Start a new configure environment that reflects what we've already found  for i in e_list:
755  conf = Configure(clone_env(env_mpi))      print("%16s:  YES"%i)
756    for i in d_list:
757  if not env_mpi['usempi']: env_mpi['useparmetis'] = 0      print("%16s:  DISABLED"%i)
758    if env['cppunit']:
759  if env_mpi['useparmetis']:      print("         CppUnit:  FOUND")
760    conf.env.AppendUnique(CPPPATH = [env_mpi['parmetis_path']])  else:
761    conf.env.AppendUnique(LIBPATH = [env_mpi['parmetis_lib_path']])      print("         CppUnit:  NOT FOUND")
762    conf.env.AppendUnique(LIBS    = [env_mpi['parmetis_libs']])  if env['gmsh']=='m':
763    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['parmetis_lib_path'])    # The wrapper script needs to find these libs      print("            gmsh:  FOUND, MPI-ENABLED")
764    #ensure that our path entries remain at the front  elif env['gmsh']=='s':
765    conf.env.PrependENVPath('PYTHONPATH', prefix)      print("            gmsh:  FOUND")
766    conf.env.PrependENVPath(LD_LIBRARY_PATH_KEY, env['libinstall'])  else:
767        print("            gmsh:  NOT FOUND")
768  if env_mpi['useparmetis'] and not conf.CheckCHeader('parmetis.h'): env_mpi['useparmetis'] = 0  if env['numpy_h']:
769  if env_mpi['useparmetis'] and not conf.CheckFunc('ParMETIS_V3_PartGeomKway'): env_mpi['useparmetis'] = 0      print("   numpy headers:  FOUND")
770    else:
771  # Add ParMETIS to environment env_mpi if it was found      print("   numpy headers:  NOT FOUND")
772  if env_mpi['useparmetis']:  print("   vsl_random:  %s"%env['vsl_random'])
773    env_mpi = conf.Finish()      
774    env_mpi.Append(CPPDEFINES = ['USE_PARMETIS'])  if ((fatalwarning != '') and (env['werror'])):
775        print("  Treating warnings as errors")
776  else:  else:
777    conf.Finish()      print("  NOT treating warnings as errors")
778    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)  
779    
780    ####################### Configure the subdirectories #########################
781    
782  from grouptest import *  from grouptest import *
783    
784  TestGroups=[]  TestGroups=[]
785    
786  dodgy_env=clone_env(env_mpi)    # Environment without pedantic options  # keep an environment without warnings-as-errors
787    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)  
788    
789    # now add warnings-as-errors flags. This needs to be done after configuration
790    # because the scons test files have warnings in them
791    if ((fatalwarning != '') and (env['werror'])):
792        env.Append(CCFLAGS = fatalwarning)
793    
794  Export(  Export(
795    ["env",    ['env',
796     "env_mpi",     'dodgy_env',
797     "clone_env",     'IS_WINDOWS',
798     "dodgy_env",     'TestGroups'
799     "IS_WINDOWS_PLATFORM",    ]
800     "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 #####################  
801    
802  buildvars=open(os.path.join(env['libinstall'],'buildvars'),'w')  env.SConscript(dirs = ['tools/escriptconvert'], variant_dir='$BUILD_DIR/$PLATFORM/tools/escriptconvert', duplicate=0)
803  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)
804    env.SConscript(dirs = ['weipa/src'], variant_dir='$BUILD_DIR/$PLATFORM/weipa', duplicate=0)
805    env.SConscript(dirs = ['escript/src'], variant_dir='$BUILD_DIR/$PLATFORM/escript', duplicate=0)
806    env.SConscript(dirs = ['esysUtils/src'], variant_dir='$BUILD_DIR/$PLATFORM/esysUtils', duplicate=0)
807    env.SConscript(dirs = ['pasowrap/src'], variant_dir='$BUILD_DIR/$PLATFORM/pasowrap', duplicate=0)
808    env.SConscript(dirs = ['dudley/src'], variant_dir='$BUILD_DIR/$PLATFORM/dudley', duplicate=0)
809    env.SConscript(dirs = ['finley/src'], variant_dir='$BUILD_DIR/$PLATFORM/finley', duplicate=0)
810    env.SConscript(dirs = ['ripley/src'], variant_dir='$BUILD_DIR/$PLATFORM/ripley', duplicate=0)
811    env.SConscript(dirs = ['downunder/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/downunder', duplicate=0)
812    env.SConscript(dirs = ['modellib/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/modellib', duplicate=0)
813    env.SConscript(dirs = ['pycad/py_src'], variant_dir='$BUILD_DIR/$PLATFORM/pycad', duplicate=0)
814    env.SConscript(dirs = ['pythonMPI/src'], variant_dir='$BUILD_DIR/$PLATFORM/pythonMPI', duplicate=0)
815    env.SConscript(dirs = ['doc'], variant_dir='$BUILD_DIR/$PLATFORM/doc', duplicate=0)
816    env.SConscript(dirs = ['paso/profiling'], variant_dir='$BUILD_DIR/$PLATFORM/paso/profiling', duplicate=0)
817    
818    
819    ######################## Populate the buildvars file #########################
820    
821    # remove obsolete file
822    if not env['usempi']:
823        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPI')))
824        Execute(Delete(os.path.join(env['libinstall'], 'pythonMPIredirect')))
825    
826  # Find the boost version by extracting it from version.hpp  # Try to extract the boost version from version.hpp
827  boosthpp=open(os.path.join(env['boost_path'],'boost','version.hpp'))  boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
828  boostversion='unknown'  boostversion='unknown'
829  try:  try:
830      for line in boosthpp:      for line in boosthpp:
831          ver=re.match(r'#define BOOST_VERSION (\d+)',line)          ver=re.match(r'#define BOOST_VERSION (\d+)',line)
832          if ver:          if ver:
833              boostversion=ver.group(1)              boostversion=ver.group(1)
834  except StopIteration:  except StopIteration:
835      pass      pass
836  buildvars.write("boost="+boostversion+"\n")  boosthpp.close()
837    
838    
839    buildvars=open(os.path.join(env['libinstall'], 'buildvars'), 'w')
840  buildvars.write("svn_revision="+str(global_revision)+"\n")  buildvars.write("svn_revision="+str(global_revision)+"\n")
841  out="usedebug="  buildvars.write("prefix="+prefix+"\n")
842  if env['usedebug']:  buildvars.write("cc="+env['CC']+"\n")
843      out+="y"  buildvars.write("cxx="+env['CXX']+"\n")
844  else:  if env['pythoncmd']=='python':
845      out+="n"      buildvars.write("python="+sys.executable+"\n")
846  out+="\nusempi="      buildvars.write("python_version="+str(sys.version_info[0])+"."+str(sys.version_info[1])+"."+str(sys.version_info[2])+"\n")
847  if env['usempi']:  else:
848      out+="y"      buildvars.write("python="+env['pythoncmd']+"\n")
849  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)
850      out+="n"      verstring=p.stdout.readline().strip()
851  out+="\nuseopenmp="      p.wait()
852  if env['useopenmp']:      buildvars.write("python_version="+verstring+"\n")
853      out+="y"  buildvars.write("boost_inc_path="+boost_inc_path+"\n")
854  else:  buildvars.write("boost_lib_path="+boost_lib_path+"\n")
855      out+="n"  buildvars.write("boost_version="+boostversion+"\n")
856  buildvars.write(out+"\n")  buildvars.write("debug=%d\n"%int(env['debug']))
857  buildvars.write("mpi_flavour="+env['mpi_flavour']+'\n')  buildvars.write("openmp=%d\n"%int(env['openmp']))
858  out="lapack="  buildvars.write("mpi=%s\n"%env['mpi'])
859  if env['uselapack']:  buildvars.write("mpi_inc_path=%s\n"%mpi_inc_path)
860     out+="y"  buildvars.write("mpi_lib_path=%s\n"%mpi_lib_path)
861  else:  buildvars.write("lapack=%s\n"%env['lapack'])
862     out+="n"  buildvars.write("vsl_random=%d\n"%int(env['vsl_random']))
863  out+="\nsilo="  for i in 'netcdf','parmetis','papi','mkl','umfpack','boomeramg','silo','visit':
864  if env['usesilo']:      buildvars.write("%s=%d\n"%(i, int(env[i])))
865     out+="y"      if env[i]:
866  else:          buildvars.write("%s_inc_path=%s\n"%(i, eval(i+'_inc_path')))
867     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")  
868  buildvars.close()  buildvars.close()
869    
870    ################### Targets to build and install libraries ###################
871    
872  ############ 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'))  
873  env.Alias('target_init', [target_init])  env.Alias('target_init', [target_init])
874    # delete buildvars upon cleanup
875    env.Clean('target_init', os.path.join(env['libinstall'], 'buildvars'))
876    
877  # 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
878  env.Alias('build_esysUtils', ['target_install_esysUtils_headers', 'target_esysUtils_a'])  # #include <paso/Common.h>
879  env.Alias('install_esysUtils', ['build_esysUtils', 'target_install_esysUtils_a'])  env.Alias('build_esysUtils', ['install_esysUtils_headers', 'build_esysUtils_lib'])
880    env.Alias('install_esysUtils', ['build_esysUtils', 'install_esysUtils_lib'])
881    
882  env.Alias('build_paso', ['target_install_paso_headers', 'target_paso_a'])  env.Alias('build_paso', ['install_paso_headers', 'build_paso_lib'])
883  env.Alias('install_paso', ['build_paso', 'target_install_paso_a'])  env.Alias('install_paso', ['build_paso', 'install_paso_lib'])
884    
885  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'])
886  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'])
887    
888    env.Alias('build_pasowrap', ['install_pasowrap_headers', 'build_pasowrap_lib', 'build_pasowrapcpp_lib'])
889    env.Alias('install_pasowrap', ['build_pasowrap', 'install_pasowrap_lib', 'install_pasowrapcpp_lib', 'install_pasowrap_py'])
890    
891  env.Alias('build_escriptreader', ['target_install_weipa_headers', 'target_escriptreader_a'])  env.Alias('build_dudley', ['install_dudley_headers', 'build_dudley_lib', 'build_dudleycpp_lib'])
892  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'])
893    
894  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'])
895  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'])
896    
897  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'])
898  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'])
899    
900  # 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'])
901    env.Alias('install_weipa', ['build_weipa', 'install_weipa_lib', 'install_weipacpp_lib', 'install_weipa_py'])
902    
903    env.Alias('build_escriptreader', ['install_weipa_headers', 'build_escriptreader_lib'])
904    env.Alias('install_escriptreader', ['build_escriptreader', 'install_escriptreader_lib'])
905    
906    # Now gather all the above into some easy targets: build_all and install_all
907  build_all_list = []  build_all_list = []
908  build_all_list += ['build_esysUtils']  build_all_list += ['build_esysUtils']
909  build_all_list += ['build_paso']  build_all_list += ['build_paso']
 build_all_list += ['build_weipa']  
910  build_all_list += ['build_escript']  build_all_list += ['build_escript']
911    build_all_list += ['build_pasowrap']
912    build_all_list += ['build_dudley']
913  build_all_list += ['build_finley']  build_all_list += ['build_finley']
914  if env['usempi']:       build_all_list += ['target_pythonMPI_exe']  build_all_list += ['build_ripley']
915  #if not IS_WINDOWS_PLATFORM:    build_all_list += ['target_escript_wrapper']  build_all_list += ['build_weipa']
916  build_all_list += ['target_escriptconvert']  if not IS_WINDOWS: build_all_list += ['build_escriptreader']
917    if env['usempi']:   build_all_list += ['build_pythonMPI']
918    build_all_list += ['build_escriptconvert']
919  env.Alias('build_all', build_all_list)  env.Alias('build_all', build_all_list)
920    
921  install_all_list = []  install_all_list = []
922  install_all_list += ['target_init']  install_all_list += ['target_init']
923  install_all_list += ['install_esysUtils']  install_all_list += ['install_esysUtils']
924  install_all_list += ['install_paso']  install_all_list += ['install_paso']
 install_all_list += ['install_weipa']  
925  install_all_list += ['install_escript']  install_all_list += ['install_escript']
926    install_all_list += ['install_pasowrap']
927    install_all_list += ['install_dudley']
928  install_all_list += ['install_finley']  install_all_list += ['install_finley']
929  install_all_list += ['target_install_pyvisi_py']  install_all_list += ['install_ripley']
930  install_all_list += ['target_install_modellib_py']  install_all_list += ['install_weipa']
931  install_all_list += ['target_install_pycad_py']  if not IS_WINDOWS: install_all_list += ['install_escriptreader']
932  if env['usempi']:       install_all_list += ['target_install_pythonMPI_exe']  install_all_list += ['install_downunder_py']
933  #if not IS_WINDOWS_PLATFORM:    install_all_list += ['target_install_escript_wrapper']  install_all_list += ['install_modellib_py']
934  if env['usesilo']:  install_all_list += ['target_install_escriptconvert']  install_all_list += ['install_pycad_py']
935  install_all_list += ['remember_options']  if env['usempi']:   install_all_list += ['install_pythonMPI']
936    install_all_list += ['install_escriptconvert']
937  env.Alias('install_all', install_all_list)  env.Alias('install_all', install_all_list)
938    
939  # Default target is install  # Default target is install
940  env.Default('install_all')  env.Default('install_all')
941    
942  ############ Targets to build and run the test suite ###########  ################## Targets to build and run the test suite ###################
943    
944  env.Alias('build_cppunittest', ['target_install_cppunittest_headers', 'target_cppunittest_a'])  if not env['cppunit']:
945  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')
946  env.Alias('run_tests', ['install_all', 'target_install_cppunittest_a'])      env.Alias('run_tests', test_msg)
947  env.Alias('all_tests', ['install_all', 'target_install_cppunittest_a', 'run_tests', 'py_tests'])  env.Alias('run_tests', ['install_all'])
948    env.Alias('all_tests', ['install_all', 'run_tests', 'py_tests'])
949  env.Alias('build_full',['install_all','build_tests','build_py_tests'])  env.Alias('build_full',['install_all','build_tests','build_py_tests'])
950    env.Alias('build_PasoTests','$BUILD_DIR/$PLATFORM/paso/profiling/PasoTests')
951    
952    ##################### Targets to build the documentation #####################
 ############ Targets to build the documentation ################  
953    
954  env.Alias('api_epydoc','install_all')  env.Alias('api_epydoc','install_all')
955    env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'user_pdf', 'install_pdf', 'cookbook_pdf'])
956    env.Alias('release_prep', ['docs', 'install_all'])
957    
958  env.Alias('docs', ['examples_tarfile', 'examples_zipfile', 'api_epydoc', 'api_doxygen', 'guide_pdf', 'guide_html','install_pdf', 'cookbook_pdf'])  if not IS_WINDOWS:
959        try:
960  build_platform=os.name          utest=open('utest.sh','w')
961            utest.write(GroupTest.makeHeader(env['PLATFORM'], prefix))
962  if not IS_WINDOWS_PLATFORM:          for tests in TestGroups:
963     try:              utest.write(tests.makeString())
964      utest=open("utest.sh","w")          utest.close()
965      #Sometimes Mac python says it is posix          Execute(Chmod('utest.sh', 0o755))
966      if (build_platform=='posix') and platform.system()=="Darwin":          print("Generated utest.sh.")
967          build_platform='darwin'      except IOError:
968      utest.write(GroupTest.makeHeader(build_platform))          print("Error attempting to write unittests file.")
969      for tests in TestGroups:          Exit(1)
970          utest.write(tests.makeString())  
971      utest.close()      # delete utest.sh upon cleanup
972      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')
973      print "utest.sh written"  
974     except IOError:      # Make sure that the escript wrapper is in place
975      print "Error attempting to write unittests file."      if not os.path.isfile(os.path.join(env['bininstall'], 'run-escript')):
976      sys.exit(1)          print("Copying escript wrapper.")
977            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')  
978    
 env.Alias('release_prep', ['docs', 'install_all'])  

Legend:
Removed from v.3097  
changed lines
  Added in v.3961

  ViewVC Help
Powered by ViewVC 1.1.26