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

Diff of /branches/py3_attempt2/SConstruct

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

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

Legend:
Removed from v.1141  
changed lines
  Added in v.3871

  ViewVC Help
Powered by ViewVC 1.1.26