diff options
Diffstat (limited to 'src/engine/SCons')
23 files changed, 674 insertions, 439 deletions
diff --git a/src/engine/SCons/Tool/FortranCommon.py b/src/engine/SCons/Tool/FortranCommon.py new file mode 100644 index 0000000..579b4dd --- /dev/null +++ b/src/engine/SCons/Tool/FortranCommon.py @@ -0,0 +1,242 @@ +"""SCons.Tool.FortranCommon + +Stuff for processing Fortran, common to all fortran dialects. + +""" + +# +# __COPYRIGHT__ +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +import re +import string +import os.path + +import SCons.Action +import SCons.Defaults +import SCons.Scanner.Fortran +import SCons.Tool +import SCons.Util + +def isfortran(env, source): + """Return 1 if any of code in source has fortran files in it, 0 + otherwise.""" + try: + fsuffixes = env['FORTRANSUFFIXES'] + except KeyError: + # If no FORTRANSUFFIXES, no fortran tool, so there is no need to look + # for fortran sources. + return 0 + + if not source: + # Source might be None for unusual cases like SConf. + return 0 + for s in source: + if s.sources: + ext = os.path.splitext(str(s.sources[0]))[1] + if ext in fsuffixes: + return 1 + return 0 + +def _fortranEmitter(target, source, env): + node = source[0].rfile() + if not node.exists() and not node.is_derived(): + print "Could not locate " + str(node.name) + return ([], []) + mod_regex = """(?i)^\s*MODULE\s+(?!PROCEDURE)(\w+)""" + cre = re.compile(mod_regex,re.M) + # Retrieve all USE'd module names + modules = cre.findall(node.get_contents()) + # Remove unique items from the list + modules = SCons.Util.unique(modules) + # Convert module name to a .mod filename + suffix = env.subst('$FORTRANMODSUFFIX', target=target, source=source) + moddir = env.subst('$FORTRANMODDIR', target=target, source=source) + modules = map(lambda x, s=suffix: string.lower(x) + s, modules) + for m in modules: + target.append(env.fs.File(m, moddir)) + return (target, source) + +def FortranEmitter(target, source, env): + target, source = _fortranEmitter(target, source, env) + return SCons.Defaults.StaticObjectEmitter(target, source, env) + +def ShFortranEmitter(target, source, env): + target, source = _fortranEmitter(target, source, env) + return SCons.Defaults.SharedObjectEmitter(target, source, env) + +def ComputeFortranSuffixes(suffixes, ppsuffixes): + """suffixes are fortran source files, and ppsuffixes the ones to be + pre-processed. Both should be sequences, not strings.""" + assert len(suffixes) > 0 + s = suffixes[0] + sup = string.upper(s) + if SCons.Util.case_sensitive_suffixes(s, sup): + for i in suffixes: + ppsuffixes.append(string.upper(i)) + else: + for i in suffixes: + suffixes.append(string.upper(i)) + +def CreateDialectActions(dialect): + """Create dialect specific actions.""" + CompAction = SCons.Action.Action('$%sCOM ' % dialect, '$%sCOMSTR' % dialect) + CompPPAction = SCons.Action.Action('$%sPPCOM ' % dialect, '$%sPPCOMSTR' % dialect) + ShCompAction = SCons.Action.Action('$SH%sCOM ' % dialect, '$SH%sCOMSTR' % dialect) + ShCompPPAction = SCons.Action.Action('$SH%sPPCOM ' % dialect, '$SH%sPPCOMSTR' % dialect) + + return CompAction, CompPPAction, ShCompAction, ShCompPPAction + +def DialectAddToEnv(env, dialect, suffixes, ppsuffixes, support_module = 0): + """Add dialect specific construction variables.""" + ComputeFortranSuffixes(suffixes, ppsuffixes) + + fscan = SCons.Scanner.Fortran.FortranScan("%sPATH" % dialect) + + for suffix in suffixes + ppsuffixes: + SCons.Tool.SourceFileScanner.add_scanner(suffix, fscan) + + env.AppendUnique(FORTRANSUFFIXES = suffixes + ppsuffixes) + + compaction, compppaction, shcompaction, shcompppaction = \ + CreateDialectActions(dialect) + + static_obj, shared_obj = SCons.Tool.createObjBuilders(env) + + for suffix in suffixes: + static_obj.add_action(suffix, compaction) + shared_obj.add_action(suffix, shcompaction) + static_obj.add_emitter(suffix, FortranEmitter) + shared_obj.add_emitter(suffix, ShFortranEmitter) + + for suffix in ppsuffixes: + static_obj.add_action(suffix, compppaction) + shared_obj.add_action(suffix, shcompppaction) + static_obj.add_emitter(suffix, FortranEmitter) + shared_obj.add_emitter(suffix, ShFortranEmitter) + + if not env.has_key('%sFLAGS' % dialect): + env['%sFLAGS' % dialect] = SCons.Util.CLVar('') + + if not env.has_key('SH%sFLAGS' % dialect): + env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS' % dialect) + + # If a tool does not define fortran prefix/suffix for include path, use C ones + if not env.has_key('INC%sPREFIX' % dialect): + env['INC%sPREFIX' % dialect] = '$INCPREFIX' + + if not env.has_key('INC%sSUFFIX' % dialect): + env['INC%sSUFFIX' % dialect] = '$INCSUFFIX' + + env['_%sINCFLAGS' % dialect] = '$( ${_concat(INC%sPREFIX, %sPATH, INC%sSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' % (dialect, dialect, dialect) + + if support_module == 1: + env['%sCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) + env['%sPPCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) + env['SH%sCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) + env['SH%sPPCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) + else: + env['%sCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) + env['%sPPCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) + env['SH%sCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) + env['SH%sPPCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) + +def add_fortran_to_env(env): + """Add Builders and construction variables for Fortran to an Environment.""" + try: + FortranSuffixes = env['FORTRANFILESUFFIXES'] + except KeyError: + FortranSuffixes = ['.f', '.for', '.ftn'] + + #print "Adding %s to fortran suffixes" % FortranSuffixes + try: + FortranPPSuffixes = env['FORTRANPPFILESUFFIXES'] + except KeyError: + FortranPPSuffixes = ['.fpp', '.FPP'] + + DialectAddToEnv(env, "FORTRAN", FortranSuffixes, + FortranPPSuffixes, support_module = 1) + + env['FORTRANMODPREFIX'] = '' # like $LIBPREFIX + env['FORTRANMODSUFFIX'] = '.mod' # like $LIBSUFFIX + + env['FORTRANMODDIR'] = '' # where the compiler should place .mod files + env['FORTRANMODDIRPREFIX'] = '' # some prefix to $FORTRANMODDIR - similar to $INCPREFIX + env['FORTRANMODDIRSUFFIX'] = '' # some suffix to $FORTRANMODDIR - similar to $INCSUFFIX + env['_FORTRANMODFLAG'] = '$( ${_concat(FORTRANMODDIRPREFIX, FORTRANMODDIR, FORTRANMODDIRSUFFIX, __env__, RDirs)} $)' + +def add_f77_to_env(env): + """Add Builders and construction variables for f77 to an Environment.""" + try: + F77Suffixes = env['F77FILESUFFIXES'] + except KeyError: + F77Suffixes = ['.f77'] + + #print "Adding %s to f77 suffixes" % F77Suffixes + try: + F77PPSuffixes = env['F77PPFILESUFFIXES'] + except KeyError: + F77PPSuffixes = [] + + DialectAddToEnv(env, "F77", F77Suffixes, F77PPSuffixes) + +def add_f90_to_env(env): + """Add Builders and construction variables for f90 to an Environment.""" + try: + F90Suffixes = env['F90FILESUFFIXES'] + except KeyError: + F90Suffixes = ['.f90'] + + #print "Adding %s to f90 suffixes" % F90Suffixes + try: + F90PPSuffixes = env['F90PPFILESUFFIXES'] + except KeyError: + F90PPSuffixes = [] + + DialectAddToEnv(env, "F90", F90Suffixes, F90PPSuffixes, + support_module = 1) + +def add_f95_to_env(env): + """Add Builders and construction variables for f95 to an Environment.""" + try: + F95Suffixes = env['F95FILESUFFIXES'] + except KeyError: + F95Suffixes = ['.f95'] + + #print "Adding %s to f95 suffixes" % F95Suffixes + try: + F95PPSuffixes = env['F95PPFILESUFFIXES'] + except KeyError: + F95PPSuffixes = [] + + DialectAddToEnv(env, "F95", F95Suffixes, F95PPSuffixes, + support_module = 1) + +def add_all_to_env(env): + """Add builders and construction variables for all supported fortran + dialects.""" + add_fortran_to_env(env) + add_f77_to_env(env) + add_f90_to_env(env) + add_f95_to_env(env) diff --git a/src/engine/SCons/Tool/__init__.py b/src/engine/SCons/Tool/__init__.py index e0ada5e..f197b68 100644 --- a/src/engine/SCons/Tool/__init__.py +++ b/src/engine/SCons/Tool/__init__.py @@ -555,7 +555,7 @@ def tool_list(platform, env): c_compilers = ['msvc', 'mingw', 'gcc', 'intelc', 'icl', 'icc', 'cc', 'bcc32' ] cxx_compilers = ['msvc', 'intelc', 'icc', 'g++', 'c++', 'bcc32' ] assemblers = ['masm', 'nasm', 'gas', '386asm' ] - fortran_compilers = ['g77', 'ifl', 'cvf', 'f95', 'f90', 'fortran'] + fortran_compilers = ['gfortran', 'g77', 'ifl', 'cvf', 'f95', 'f90', 'fortran'] ars = ['mslib', 'ar', 'tlib'] elif str(platform) == 'os2': "prefer IBM tools on OS/2" @@ -579,7 +579,8 @@ def tool_list(platform, env): c_compilers = ['suncc', 'gcc', 'cc'] cxx_compilers = ['sunc++', 'g++', 'c++'] assemblers = ['as', 'gas'] - fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran'] + fortran_compilers = ['sunf95', 'sunf90', 'sunf77', 'f95', 'f90', 'f77', + 'gfortran', 'g77', 'fortran'] ars = ['sunar'] elif str(platform) == 'hpux': "prefer aCC tools on HP-UX" @@ -603,7 +604,7 @@ def tool_list(platform, env): c_compilers = ['gcc', 'cc'] cxx_compilers = ['g++', 'c++'] assemblers = ['as'] - fortran_compilers = ['f95', 'f90', 'g77'] + fortran_compilers = ['gfortran', 'f95', 'f90', 'g77'] ars = ['ar'] else: "prefer GNU tools on all other platforms" @@ -611,7 +612,7 @@ def tool_list(platform, env): c_compilers = ['gcc', 'msvc', 'intelc', 'icc', 'cc'] cxx_compilers = ['g++', 'msvc', 'intelc', 'icc', 'c++'] assemblers = ['gas', 'nasm', 'masm'] - fortran_compilers = ['f95', 'f90', 'g77', 'ifort', 'ifl', 'fortran'] + fortran_compilers = ['gfortran', 'g77', 'ifort', 'ifl', 'f95', 'f90', 'f77'] ars = ['ar', 'mslib'] c_compiler = FindTool(c_compilers, env) or c_compilers[0] diff --git a/src/engine/SCons/Tool/f77.py b/src/engine/SCons/Tool/f77.py index bd1e870..c8da35a 100644 --- a/src/engine/SCons/Tool/f77.py +++ b/src/engine/SCons/Tool/f77.py @@ -37,99 +37,20 @@ import SCons.Defaults import SCons.Scanner.Fortran import SCons.Tool import SCons.Util -import fortran +from SCons.Tool.FortranCommon import add_all_to_env, add_f77_to_env compilers = ['f77'] -# -F77Suffixes = ['.f77'] -F77PPSuffixes = [] -if SCons.Util.case_sensitive_suffixes('.f77', '.F77'): - F77PPSuffixes.append('.F77') -else: - F77Suffixes.append('.F77') - -# -F77Scan = SCons.Scanner.Fortran.FortranScan("F77PATH") - -for suffix in F77Suffixes + F77PPSuffixes: - SCons.Tool.SourceFileScanner.add_scanner(suffix, F77Scan) -del suffix - -# -fVLG = fortran.VariableListGenerator - -F77Generator = fVLG('F77', 'FORTRAN', '_FORTRAND') -F77FlagsGenerator = fVLG('F77FLAGS', 'FORTRANFLAGS') -F77CommandGenerator = fVLG('F77COM', 'FORTRANCOM', '_F77COMD') -F77CommandStrGenerator = fVLG('F77COMSTR', 'FORTRANCOMSTR', '_F77COMSTRD') -F77PPCommandGenerator = fVLG('F77PPCOM', 'FORTRANPPCOM', '_F77PPCOMD') -F77PPCommandStrGenerator = fVLG('F77PPCOMSTR', 'FORTRANPPCOMSTR', '_F77PPCOMSTRD') -ShF77Generator = fVLG('SHF77', 'SHFORTRAN', 'F77', 'FORTRAN', '_FORTRAND') -ShF77FlagsGenerator = fVLG('SHF77FLAGS', 'SHFORTRANFLAGS') -ShF77CommandGenerator = fVLG('SHF77COM', 'SHFORTRANCOM', '_SHF77COMD') -ShF77CommandStrGenerator = fVLG('SHF77COMSTR', 'SHFORTRANCOMSTR', '_SHF77COMSTRD') -ShF77PPCommandGenerator = fVLG('SHF77PPCOM', 'SHFORTRANPPCOM', '_SHF77PPCOMD') -ShF77PPCommandStrGenerator = fVLG('SHF77PPCOMSTR', 'SHFORTRANPPCOMSTR', '_SHF77PPCOMSTRD') - -del fVLG - -# -F77Action = SCons.Action.Action('$_F77COMG ', '$_F77COMSTRG') -F77PPAction = SCons.Action.Action('$_F77PPCOMG ', '$_F77PPCOMSTRG') -ShF77Action = SCons.Action.Action('$_SHF77COMG ', '$_SHF77COMSTRG') -ShF77PPAction = SCons.Action.Action('$_SHF77PPCOMG ', '$_SHF77PPCOMSTRG') - -def add_to_env(env): - """Add Builders and construction variables for f77 to an Environment.""" - env.AppendUnique(FORTRANSUFFIXES = F77Suffixes + F77PPSuffixes) - - static_obj, shared_obj = SCons.Tool.createObjBuilders(env) - - for suffix in F77Suffixes: - static_obj.add_action(suffix, F77Action) - shared_obj.add_action(suffix, ShF77Action) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - for suffix in F77PPSuffixes: - static_obj.add_action(suffix, F77PPAction) - shared_obj.add_action(suffix, ShF77PPAction) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - env['_F77G'] = F77Generator - env['_F77FLAGSG'] = F77FlagsGenerator - env['_F77COMG'] = F77CommandGenerator - env['_F77PPCOMG'] = F77PPCommandGenerator - env['_F77COMSTRG'] = F77CommandStrGenerator - env['_F77PPCOMSTRG'] = F77PPCommandStrGenerator - - env['_SHF77G'] = ShF77Generator - env['_SHF77FLAGSG'] = ShF77FlagsGenerator - env['_SHF77COMG'] = ShF77CommandGenerator - env['_SHF77PPCOMG'] = ShF77PPCommandGenerator - env['_SHF77COMSTRG'] = ShF77CommandStrGenerator - env['_SHF77PPCOMSTRG'] = ShF77PPCommandStrGenerator - - env['_F77INCFLAGS'] = '$( ${_concat(INCPREFIX, F77PATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' - - env['_F77COMD'] = '$_F77G -o $TARGET -c $_F77FLAGSG $_F77INCFLAGS $SOURCES' - env['_F77PPCOMD'] = '$_F77G -o $TARGET -c $_F77FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F77INCFLAGS $SOURCES' - env['_SHF77COMD'] = '$_SHF77G -o $TARGET -c $_SHF77FLAGSG $_F77INCFLAGS $SOURCES' - env['_SHF77PPCOMD'] = '$_SHF77G -o $TARGET -c $_SHF77FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F77INCFLAGS $SOURCES' - def generate(env): - fortran.add_to_env(env) - - import f90 - import f95 - f90.add_to_env(env) - f95.add_to_env(env) + add_all_to_env(env) + add_f77_to_env(env) - add_to_env(env) + fcomp = env.Detect(compilers) or 'f77' + env['F77'] = fcomp + env['SHF77'] = fcomp - env['_FORTRAND'] = env.Detect(compilers) or 'f77' + env['FORTRAN'] = fcomp + env['SHFORTRAN'] = fcomp def exists(env): return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/f77.xml b/src/engine/SCons/Tool/f77.xml index 3281bd6..8e60d71 100644 --- a/src/engine/SCons/Tool/f77.xml +++ b/src/engine/SCons/Tool/f77.xml @@ -13,6 +13,8 @@ F77 F77FLAGS F77COM F77PPCOM +F77FILESUFFIXES +F77PPFILESUFFIXES FORTRAN FORTRANFLAGS FORTRANCOM @@ -60,6 +62,20 @@ for all Fortran versions. </summary> </cvar> +<cvar name="F77FILESUFFIXES"> +<summary> +The list of file extensions for which the F77 dialect will be used. By +default, this is ['.f77'] +</summary> +</cvar> + +<cvar name="F77PPFILESUFFIXES"> +<summary> +The list of file extensions for which the compilation + preprocessor pass for +F77 dialect will be used. By default, this is empty +</summary> +</cvar> + <cvar name="F77COMSTR"> <summary> The string displayed when a Fortran 77 source file diff --git a/src/engine/SCons/Tool/f90.py b/src/engine/SCons/Tool/f90.py index fab4ccb..4eb8f7c 100644 --- a/src/engine/SCons/Tool/f90.py +++ b/src/engine/SCons/Tool/f90.py @@ -37,96 +37,20 @@ import SCons.Defaults import SCons.Scanner.Fortran import SCons.Tool import SCons.Util -import fortran +from SCons.Tool.FortranCommon import add_all_to_env, add_f90_to_env compilers = ['f90'] -# -F90Suffixes = ['.f90'] -F90PPSuffixes = [] -if SCons.Util.case_sensitive_suffixes('.f90', '.F90'): - F90PPSuffixes.append('.F90') -else: - F90Suffixes.append('.F90') - -# -F90Scan = SCons.Scanner.Fortran.FortranScan("F90PATH") - -for suffix in F90Suffixes + F90PPSuffixes: - SCons.Tool.SourceFileScanner.add_scanner(suffix, F90Scan) -del suffix - -# -fVLG = fortran.VariableListGenerator - -F90Generator = fVLG('F90', 'FORTRAN', '_FORTRAND') -F90FlagsGenerator = fVLG('F90FLAGS', 'FORTRANFLAGS') -F90CommandGenerator = fVLG('F90COM', 'FORTRANCOM', '_F90COMD') -F90CommandStrGenerator = fVLG('F90COMSTR', 'FORTRANCOMSTR', '_F90COMSTRD') -F90PPCommandGenerator = fVLG('F90PPCOM', 'FORTRANPPCOM', '_F90PPCOMD') -F90PPCommandStrGenerator = fVLG('F90PPCOMSTR', 'FORTRANPPCOMSTR', '_F90PPCOMSTRD') -ShF90Generator = fVLG('SHF90', 'SHFORTRAN', 'F90', 'FORTRAN', '_FORTRAND') -ShF90FlagsGenerator = fVLG('SHF90FLAGS', 'SHFORTRANFLAGS') -ShF90CommandGenerator = fVLG('SHF90COM', 'SHFORTRANCOM', '_SHF90COMD') -ShF90CommandStrGenerator = fVLG('SHF90COMSTR', 'SHFORTRANCOMSTR', '_SHF90COMSTRD') -ShF90PPCommandGenerator = fVLG('SHF90PPCOM', 'SHFORTRANPPCOM', '_SHF90PPCOMD') -ShF90PPCommandStrGenerator = fVLG('SHF90PPCOMSTR', 'SHFORTRANPPCOMSTR', '_SHF90PPCOMSTRD') - -del fVLG - -# -F90Action = SCons.Action.Action('$_F90COMG ', '$_F90COMSTRG') -F90PPAction = SCons.Action.Action('$_F90PPCOMG ', '$_F90PPCOMSTRG') -ShF90Action = SCons.Action.Action('$_SHF90COMG ', '$_SHF90COMSTRG') -ShF90PPAction = SCons.Action.Action('$_SHF90PPCOMG ', '$_SHF90PPCOMSTRG') - -def add_to_env(env): - """Add Builders and construction variables for f90 to an Environment.""" - env.AppendUnique(FORTRANSUFFIXES = F90Suffixes + F90PPSuffixes) - - static_obj, shared_obj = SCons.Tool.createObjBuilders(env) - - for suffix in F90Suffixes: - static_obj.add_action(suffix, F90Action) - shared_obj.add_action(suffix, ShF90Action) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - for suffix in F90PPSuffixes: - static_obj.add_action(suffix, F90PPAction) - shared_obj.add_action(suffix, ShF90PPAction) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - env['_F90G'] = F90Generator - env['_F90FLAGSG'] = F90FlagsGenerator - env['_F90COMG'] = F90CommandGenerator - env['_F90COMSTRG'] = F90CommandStrGenerator - env['_F90PPCOMG'] = F90PPCommandGenerator - env['_F90PPCOMSTRG'] = F90PPCommandStrGenerator - - env['_SHF90G'] = ShF90Generator - env['_SHF90FLAGSG'] = ShF90FlagsGenerator - env['_SHF90COMG'] = ShF90CommandGenerator - env['_SHF90COMSTRG'] = ShF90CommandStrGenerator - env['_SHF90PPCOMG'] = ShF90PPCommandGenerator - env['_SHF90PPCOMSTRG'] = ShF90PPCommandStrGenerator - - env['_F90INCFLAGS'] = '$( ${_concat(INCPREFIX, F90PATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' - env['_F90COMD'] = '$_F90G -o $TARGET -c $_F90FLAGSG $_F90INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_F90PPCOMD'] = '$_F90G -o $TARGET -c $_F90FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F90INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHF90COMD'] = '$_SHF90G -o $TARGET -c $_SHF90FLAGSG $_F90INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHF90PPCOMD'] = '$_SHF90G -o $TARGET -c $_SHF90FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F90INCFLAGS $_FORTRANMODFLAG $SOURCES' - def generate(env): - fortran.add_to_env(env) - - import f77 - f77.add_to_env(env) + add_all_to_env(env) + add_f90_to_env(env) - add_to_env(env) + fc = env.Detect(compilers) or 'f90' + env['F90'] = fc + env['SHF90'] = fc - env['_FORTRAND'] = env.Detect(compilers) or 'f90' + env['FORTRAN'] = fc + env['SHFORTRAN'] = fc def exists(env): return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/f90.xml b/src/engine/SCons/Tool/f90.xml index 18135a3..4a2884e 100644 --- a/src/engine/SCons/Tool/f90.xml +++ b/src/engine/SCons/Tool/f90.xml @@ -58,6 +58,20 @@ If this is not set, then &cv-link-F90COM; or &cv-link-FORTRANCOM; </summary> </cvar> +<cvar name="F90FILESUFFIXES"> +<summary> +The list of file extensions for which the F90 dialect will be used. By +default, this is ['.f90'] +</summary> +</cvar> + +<cvar name="F90PPFILESUFFIXES"> +<summary> +The list of file extensions for which the compilation + preprocessor pass for +F90 dialect will be used. By default, this is empty +</summary> +</cvar> + <cvar name="F90FLAGS"> <summary> General user-specified options that are passed to the Fortran 90 compiler. diff --git a/src/engine/SCons/Tool/f95.py b/src/engine/SCons/Tool/f95.py index 94786c8..545894a 100644 --- a/src/engine/SCons/Tool/f95.py +++ b/src/engine/SCons/Tool/f95.py @@ -37,99 +37,21 @@ import SCons.Defaults import SCons.Tool import SCons.Util import fortran +from SCons.Tool.FortranCommon import add_all_to_env, add_f95_to_env compilers = ['f95'] -# -F95Suffixes = ['.f95'] -F95PPSuffixes = [] -if SCons.Util.case_sensitive_suffixes('.f95', '.F95'): - F95PPSuffixes.append('.F95') -else: - F95Suffixes.append('.F95') - -# -F95Scan = SCons.Scanner.Fortran.FortranScan("F95PATH") - -for suffix in F95Suffixes + F95PPSuffixes: - SCons.Tool.SourceFileScanner.add_scanner(suffix, F95Scan) -del suffix - -# -fVLG = fortran.VariableListGenerator - -F95Generator = fVLG('F95', 'FORTRAN', '_FORTRAND') -F95FlagsGenerator = fVLG('F95FLAGS', 'FORTRANFLAGS') -F95CommandGenerator = fVLG('F95COM', 'FORTRANCOM', '_F95COMD') -F95CommandStrGenerator = fVLG('F95COMSTR', 'FORTRANCOMSTR', '_F95COMSTRD') -F95PPCommandGenerator = fVLG('F95PPCOM', 'FORTRANPPCOM', '_F95PPCOMD') -F95PPCommandStrGenerator = fVLG('F95PPCOMSTR', 'FORTRANPPCOMSTR', '_F95PPCOMSTRD') -ShF95Generator = fVLG('SHF95', 'SHFORTRAN', 'F95', 'FORTRAN', '_FORTRAND') -ShF95FlagsGenerator = fVLG('SHF95FLAGS', 'SHFORTRANFLAGS') -ShF95CommandGenerator = fVLG('SHF95COM', 'SHFORTRANCOM', '_SHF95COMD') -ShF95CommandStrGenerator = fVLG('SHF95COMSTR', 'SHFORTRANCOMSTR', '_SHF95COMSTRD') -ShF95PPCommandGenerator = fVLG('SHF95PPCOM', 'SHFORTRANPPCOM', '_SHF95PPCOMD') -ShF95PPCommandStrGenerator = fVLG('SHF95PPCOMSTR', 'SHFORTRANPPCOMSTR', '_SHF95PPCOMSTRD') - -del fVLG - -# -F95Action = SCons.Action.Action('$_F95COMG ', '$_F95COMSTRG') -F95PPAction = SCons.Action.Action('$_F95PPCOMG ', '$_F95PPCOMSTRG') -ShF95Action = SCons.Action.Action('$_SHF95COMG ', '$_SHF95COMSTRG') -ShF95PPAction = SCons.Action.Action('$_SHF95PPCOMG ', '$_SHF95PPCOMSTRG') - -def add_to_env(env): - """Add Builders and construction variables for f95 to an Environment.""" - env.AppendUnique(FORTRANSUFFIXES = F95Suffixes + F95PPSuffixes) - - static_obj, shared_obj = SCons.Tool.createObjBuilders(env) - - for suffix in F95Suffixes: - static_obj.add_action(suffix, F95Action) - shared_obj.add_action(suffix, ShF95Action) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - for suffix in F95PPSuffixes: - static_obj.add_action(suffix, F95PPAction) - shared_obj.add_action(suffix, ShF95PPAction) - static_obj.add_emitter(suffix, fortran.FortranEmitter) - shared_obj.add_emitter(suffix, fortran.ShFortranEmitter) - - env['_F95G'] = F95Generator - env['_F95FLAGSG'] = F95FlagsGenerator - env['_F95COMG'] = F95CommandGenerator - env['_F95COMSTRG'] = F95CommandStrGenerator - env['_F95PPCOMG'] = F95PPCommandGenerator - env['_F95PPCOMSTRG'] = F95PPCommandStrGenerator - - env['_SHF95G'] = ShF95Generator - env['_SHF95FLAGSG'] = ShF95FlagsGenerator - env['_SHF95COMG'] = ShF95CommandGenerator - env['_SHF95COMSTRG'] = ShF95CommandStrGenerator - env['_SHF95PPCOMG'] = ShF95PPCommandGenerator - env['_SHF95PPCOMSTRG'] = ShF95PPCommandStrGenerator - - env['_F95INCFLAGS'] = '$( ${_concat(INCPREFIX, F95PATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' - - env['_F95COMD'] = '$_F95G -o $TARGET -c $_F95FLAGSG $_F95INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_F95PPCOMD'] = '$_F95G -o $TARGET -c $_F95FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F95INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHF95COMD'] = '$_SHF95G -o $TARGET -c $_SHF95FLAGSG $_F95INCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHF95PPCOMD'] = '$_SHF95G -o $TARGET -c $_SHF95FLAGSG $CPPFLAGS $_CPPDEFFLAGS $_F95INCFLAGS $_FORTRANMODFLAG $SOURCES' - def generate(env): - fortran.add_to_env(env) - - import f77 - f77.add_to_env(env) + add_all_to_env(env) + add_f95_to_env(env) - import f90 - f90.add_to_env(env) + fcomp = env.Detect(compilers) or 'f95' + env['F95'] = fcomp + env['SHF95'] = fcomp - add_to_env(env) + env['FORTRAN'] = fcomp + env['SHFORTRAN'] = fcomp - env['_FORTRAND'] = env.Detect(compilers) or 'f95' def exists(env): return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/f95.xml b/src/engine/SCons/Tool/f95.xml index 0882a45..4c2a91a 100644 --- a/src/engine/SCons/Tool/f95.xml +++ b/src/engine/SCons/Tool/f95.xml @@ -58,6 +58,20 @@ If this is not set, then &cv-link-F95COM; or &cv-link-FORTRANCOM; </summary> </cvar> +<cvar name="F95FILESUFFIXES"> +<summary> +The list of file extensions for which the F95 dialect will be used. By +default, this is ['.f95'] +</summary> +</cvar> + +<cvar name="F95PPFILESUFFIXES"> +<summary> +The list of file extensions for which the compilation + preprocessor pass for +F95 dialect will be used. By default, this is empty +</summary> +</cvar> + <cvar name="F95FLAGS"> <summary> General user-specified options that are passed to the Fortran 95 compiler. diff --git a/src/engine/SCons/Tool/fortran.py b/src/engine/SCons/Tool/fortran.py index b748303..d81ba45 100644 --- a/src/engine/SCons/Tool/fortran.py +++ b/src/engine/SCons/Tool/fortran.py @@ -41,146 +41,17 @@ import SCons.Defaults import SCons.Scanner.Fortran import SCons.Tool import SCons.Util +from SCons.Tool.FortranCommon import add_all_to_env, add_fortran_to_env compilers = ['f95', 'f90', 'f77'] -# -# Not yet sure how to deal with fortran pre-processor functions. -# Different compilers do this differently in modern fortran. Some still -# rely on the c pre-processor, some (like cvf, ivf) have their own -# pre-processor technology and use intermediary suffixes (.i90) -# -FortranSuffixes = [".f", ".for", ".ftn", ] -FortranPPSuffixes = ['.fpp', '.FPP'] -upper_case = [".F", ".FOR", ".FTN"] -if SCons.Util.case_sensitive_suffixes('.f', '.F'): - FortranPPSuffixes.extend(upper_case) -else: - FortranSuffixes.extend(upper_case) - -# -FortranScan = SCons.Scanner.Fortran.FortranScan("FORTRANPATH") - -for suffix in FortranSuffixes + FortranPPSuffixes: - SCons.Tool.SourceFileScanner.add_scanner(suffix, FortranScan) -del suffix - -# -def _fortranEmitter(target, source, env): - node = source[0].rfile() - if not node.exists() and not node.is_derived(): - print "Could not locate " + str(node.name) - return ([], []) - mod_regex = """(?i)^\s*MODULE\s+(?!PROCEDURE)(\w+)""" - cre = re.compile(mod_regex,re.M) - # Retrieve all USE'd module names - modules = cre.findall(node.get_contents()) - # Remove unique items from the list - modules = SCons.Util.unique(modules) - # Convert module name to a .mod filename - suffix = env.subst('$FORTRANMODSUFFIX', target=target, source=source) - moddir = env.subst('$FORTRANMODDIR', target=target, source=source) - modules = map(lambda x, s=suffix: string.lower(x) + s, modules) - for m in modules: - target.append(env.fs.File(m, moddir)) - return (target, source) - -def FortranEmitter(target, source, env): - target, source = _fortranEmitter(target, source, env) - return SCons.Defaults.StaticObjectEmitter(target, source, env) - -def ShFortranEmitter(target, source, env): - target, source = _fortranEmitter(target, source, env) - return SCons.Defaults.SharedObjectEmitter(target, source, env) - -class VariableListGenerator: - def __init__(self, *variablelist): - self.variablelist = variablelist - def __call__(self, env, target, source, for_signature=0): - for v in self.variablelist: - try: return env[v] - except KeyError: pass - return '' - -# -FortranGenerator = VariableListGenerator('FORTRAN', 'F77', '_FORTRAND') -FortranFlagsGenerator = VariableListGenerator('FORTRANFLAGS', 'F77FLAGS') -FortranCommandGenerator = VariableListGenerator('FORTRANCOM', 'F77COM', '_FORTRANCOMD') -FortranCommandStrGenerator = VariableListGenerator('FORTRANCOMSTR', 'F77COMSTR', '_FORTRANCOMSTRD') -FortranPPCommandGenerator = VariableListGenerator('FORTRANPPCOM', 'F77PPCOM', '_FORTRANPPCOMD') -FortranPPCommandStrGenerator = VariableListGenerator('FORTRANPPCOMSTR', 'F77PPCOMSTR', '_FORTRANPPCOMSTRD') -ShFortranGenerator = VariableListGenerator('SHFORTRAN', 'SHF77', 'FORTRAN', 'F77', '_FORTRAND') -ShFortranFlagsGenerator = VariableListGenerator('SHFORTRANFLAGS', 'SHF77FLAGS') -ShFortranCommandGenerator = VariableListGenerator('SHFORTRANCOM', 'SHF77COM', '_SHFORTRANCOMD') -ShFortranCommandStrGenerator = VariableListGenerator('SHFORTRANCOMSTR', 'SHF77COMSTR', '_SHFORTRANCOMSTRD') -ShFortranPPCommandGenerator = VariableListGenerator('SHFORTRANPPCOM', 'SHF77PPCOM', '_SHFORTRANPPCOMD') -ShFortranPPCommandStrGenerator = VariableListGenerator('SHFORTRANPPCOMSTR', 'SHF77PPCOMSTR', '_SHFORTRANPPCOMSTRD') - -# -FortranAction = SCons.Action.Action('$_FORTRANCOMG ', '$_FORTRANCOMSTRG') -FortranPPAction = SCons.Action.Action('$_FORTRANPPCOMG ', '$_FORTRANPPCOMSTRG') -ShFortranAction = SCons.Action.Action('$_SHFORTRANCOMG ', '$_SHFORTRANCOMSTRG') -ShFortranPPAction = SCons.Action.Action('$_SHFORTRANPPCOMG ', '$_SHFORTRANPPCOMSTRG') - -def add_to_env(env): - """Add Builders and construction variables for Fortran to an Environment.""" - - env['_FORTRANG'] = FortranGenerator - env['_FORTRANFLAGSG'] = FortranFlagsGenerator - env['_FORTRANCOMG'] = FortranCommandGenerator - env['_FORTRANCOMSTRG'] = FortranCommandStrGenerator - env['_FORTRANPPCOMG'] = FortranPPCommandGenerator - env['_FORTRANPPCOMSTRG'] = FortranPPCommandStrGenerator - - env['_SHFORTRANG'] = ShFortranGenerator - env['_SHFORTRANFLAGSG'] = ShFortranFlagsGenerator - env['_SHFORTRANCOMG'] = ShFortranCommandGenerator - env['_SHFORTRANCOMSTRG'] = ShFortranCommandStrGenerator - env['_SHFORTRANPPCOMG'] = ShFortranPPCommandGenerator - env['_SHFORTRANPPCOMSTRG'] = ShFortranPPCommandStrGenerator - - env['_FORTRANINCFLAGS'] = '$( ${_concat(INCPREFIX, FORTRANPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' - - env['FORTRANMODPREFIX'] = '' # like $LIBPREFIX - env['FORTRANMODSUFFIX'] = '.mod' # like $LIBSUFFIX - - env['FORTRANMODDIR'] = '' # where the compiler should place .mod files - env['FORTRANMODDIRPREFIX'] = '' # some prefix to $FORTRANMODDIR - similar to $INCPREFIX - env['FORTRANMODDIRSUFFIX'] = '' # some suffix to $FORTRANMODDIR - similar to $INCSUFFIX - env['_FORTRANMODFLAG'] = '$( ${_concat(FORTRANMODDIRPREFIX, FORTRANMODDIR, FORTRANMODDIRSUFFIX, __env__, RDirs)} $)' - - env.AppendUnique(FORTRANSUFFIXES = FortranSuffixes + FortranPPSuffixes) - - static_obj, shared_obj = SCons.Tool.createObjBuilders(env) - - for suffix in FortranSuffixes: - static_obj.add_action(suffix, FortranAction) - shared_obj.add_action(suffix, ShFortranAction) - static_obj.add_emitter(suffix, FortranEmitter) - shared_obj.add_emitter(suffix, ShFortranEmitter) - - for suffix in FortranPPSuffixes: - static_obj.add_action(suffix, FortranPPAction) - shared_obj.add_action(suffix, ShFortranPPAction) - static_obj.add_emitter(suffix, FortranEmitter) - shared_obj.add_emitter(suffix, ShFortranEmitter) - - env['_FORTRANCOMD'] = '$_FORTRANG -o $TARGET -c $_FORTRANFLAGSG $_FORTRANINCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_FORTRANPPCOMD'] = '$_FORTRANG -o $TARGET -c $_FORTRANFLAGSG $CPPFLAGS $_CPPDEFFLAGS $_FORTRANINCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHFORTRANCOMD'] = '$_SHFORTRANG -o $TARGET -c $_SHFORTRANFLAGSG $_FORTRANINCFLAGS $_FORTRANMODFLAG $SOURCES' - env['_SHFORTRANPPCOMD'] = '$_SHFORTRANG -o $TARGET -c $_SHFORTRANFLAGSG $CPPFLAGS $_CPPDEFFLAGS $_FORTRANINCFLAGS $_FORTRANMODFLAG $SOURCES' - def generate(env): - import f77 - import f90 - import f95 - f77.add_to_env(env) - f90.add_to_env(env) - f95.add_to_env(env) - - add_to_env(env) + add_all_to_env(env) + add_fortran_to_env(env) - env['_FORTRAND'] = env.Detect(compilers) or 'f77' + fc = env.Detect(compilers) or 'f77' + env['SHFORTRAN'] = fc + env['FORTRAN'] = fc def exists(env): return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/fortran.xml b/src/engine/SCons/Tool/fortran.xml index 6dbe7b0..fa8133e 100644 --- a/src/engine/SCons/Tool/fortran.xml +++ b/src/engine/SCons/Tool/fortran.xml @@ -54,6 +54,20 @@ If this is not set, then &cv-link-FORTRANCOM; </summary> </cvar> +<cvar name="FORTRANFILESUFFIXES"> +<summary> +The list of file extensions for which the FORTRAN dialect will be used. By +default, this is ['.f', '.for', '.ftn'] +</summary> +</cvar> + +<cvar name="FORTRANPPFILESUFFIXES"> +<summary> +The list of file extensions for which the compilation + preprocessor pass for +FORTRAN dialect will be used. By default, this is ['.fpp', '.FPP'] +</summary> +</cvar> + <cvar name="FORTRANFLAGS"> <summary> General user-specified options that are passed to the Fortran compiler. diff --git a/src/engine/SCons/Tool/g77.py b/src/engine/SCons/Tool/g77.py index f481546..058b061 100644 --- a/src/engine/SCons/Tool/g77.py +++ b/src/engine/SCons/Tool/g77.py @@ -33,15 +33,35 @@ selection method. __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" -import f77 +import SCons.Util +from SCons.Tool.FortranCommon import add_all_to_env, add_f77_to_env compilers = ['g77', 'f77'] def generate(env): """Add Builders and construction variables for g77 to an Environment.""" - f77.generate(env) + add_all_to_env(env) + add_f77_to_env(env) - env['_FORTRAND'] = env.Detect(compilers) or 'g77' + fcomp = env.Detect(compilers) or 'g77' + if env['PLATFORM'] in ['cygwin', 'win32']: + env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS') + env['SHF77FLAGS'] = SCons.Util.CLVar('$F77FLAGS') + else: + env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$SHFORTRANFLAGS -fPIC') + env['SHF77FLAGS'] = SCons.Util.CLVar('$SHF77FLAGS -fPIC') + + env['FORTRAN'] = fcomp + env['SHFORTRAN'] = '$FORTRAN' + + env['F77'] = fcomp + env['SHF77'] = '$F77' + + env['INCFORTRANPREFIX'] = "-I" + env['INCFORTRANSUFFIX'] = "" + + env['INCF77PREFIX'] = "-I" + env['INCF77SUFFIX'] = "" def exists(env): return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/gfortran.py b/src/engine/SCons/Tool/gfortran.py index f3db693..72f38ee 100644 --- a/src/engine/SCons/Tool/gfortran.py +++ b/src/engine/SCons/Tool/gfortran.py @@ -43,20 +43,16 @@ def generate(env): Environment.""" fortran.generate(env) - # which one is the good one ? ifort uses _FORTRAND, ifl FORTRAN, - # aixf77 F77 ... - #env['_FORTRAND'] = 'gfortran' - env['FORTRAN'] = 'gfortran' - - # XXX does this need to be set too ? - #env['SHFORTRAN'] = 'gfortran' - - if env['PLATFORM'] in ['cygwin', 'win32']: - env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS') - else: - env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS -fPIC') - - # XXX; Link problems: we need to add -lgfortran somewhere... + for dialect in ['F77', 'F90', 'FORTRAN', 'F95']: + env['%s' % dialect] = 'gfortran' + env['SH%s' % dialect] = '$%s' % dialect + if env['PLATFORM'] in ['cygwin', 'win32']: + env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS' % dialect) + else: + env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS -fPIC' % dialect) + + env['INC%sPREFIX' % dialect] = "-I" + env['INC%sSUFFIX' % dialect] = "" def exists(env): return env.Detect('gfortran') diff --git a/src/engine/SCons/Tool/gfortran.xml b/src/engine/SCons/Tool/gfortran.xml index ba0fe76..21666ea 100644 --- a/src/engine/SCons/Tool/gfortran.xml +++ b/src/engine/SCons/Tool/gfortran.xml @@ -10,6 +10,16 @@ Sets construction variables for the GNU F95/F2003 GNU compiler. </summary> <sets> FORTRAN +F77 +F90 +F95 +SHFORTRAN +SHF77 +SHF90 +SHF95 SHFORTRANFLAGS +SHF77FLAGS +SHF90FLAGS +SHF95FLAGS </sets> </tool> diff --git a/src/engine/SCons/Tool/ifl.py b/src/engine/SCons/Tool/ifl.py index b8b2012..b3a3fc8 100644 --- a/src/engine/SCons/Tool/ifl.py +++ b/src/engine/SCons/Tool/ifl.py @@ -34,16 +34,29 @@ selection method. __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" import SCons.Defaults - -import fortran +from SCons.Scanner.Fortran import FortranScan +from FortranCommon import add_all_to_env def generate(env): """Add Builders and construction variables for ifl to an Environment.""" - SCons.Tool.SourceFileScanner.add_scanner('.i90', fortran.FortranScan) - fortran.FortranSuffixes.extend(['.i90']) - fortran.generate(env) + fscan = FortranScan("FORTRANPATH") + SCons.Tool.SourceFileScanner.add_scanner('.i', fscan) + SCons.Tool.SourceFileScanner.add_scanner('.i90', fscan) + + if not env.has_key('FORTRANFILESUFFIXES'): + env['FORTRANFILESUFFIXES'] = ['.i'] + else: + env['FORTRANFILESUFFIXES'].append('.i') + + if not env.has_key('F90FILESUFFIXES'): + env['F90FILESUFFIXES'] = ['.i90'] + else: + env['F90FILESUFFIXES'].append('.i90') + + add_all_to_env(env) env['FORTRAN'] = 'ifl' + env['SHFORTRAN'] = '$FORTRAN' env['FORTRANCOM'] = '$FORTRAN $FORTRANFLAGS $_FORTRANINCFLAGS /c $SOURCES /Fo$TARGET' env['FORTRANPPCOM'] = '$FORTRAN $FORTRANFLAGS $CPPFLAGS $_CPPDEFFLAGS $_FORTRANINCFLAGS /c $SOURCES /Fo$TARGET' env['SHFORTRANCOM'] = '$SHFORTRAN $SHFORTRANFLAGS $_FORTRANINCFLAGS /c $SOURCES /Fo$TARGET' diff --git a/src/engine/SCons/Tool/ifort.py b/src/engine/SCons/Tool/ifort.py index 7681f38..d017658 100644 --- a/src/engine/SCons/Tool/ifort.py +++ b/src/engine/SCons/Tool/ifort.py @@ -37,37 +37,44 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" import string import SCons.Defaults - -import fortran +from SCons.Scanner.Fortran import FortranScan +from FortranCommon import add_all_to_env def generate(env): """Add Builders and construction variables for ifort to an Environment.""" # ifort supports Fortran 90 and Fortran 95 # Additionally, ifort recognizes more file extensions. - SCons.Tool.SourceFileScanner.add_scanner('.i', fortran.FortranScan) - SCons.Tool.SourceFileScanner.add_scanner('.i90', fortran.FortranScan) - fortran.FortranSuffixes.extend(['.i', '.i90']) - fortran.generate(env) + fscan = FortranScan("FORTRANPATH") + SCons.Tool.SourceFileScanner.add_scanner('.i', fscan) + SCons.Tool.SourceFileScanner.add_scanner('.i90', fscan) + + if not env.has_key('FORTRANFILESUFFIXES'): + env['FORTRANFILESUFFIXES'] = ['.i'] + else: + env['FORTRANFILESUFFIXES'].append('.i') + + if not env.has_key('F90FILESUFFIXES'): + env['F90FILESUFFIXES'] = ['.i90'] + else: + env['F90FILESUFFIXES'].append('.i90') - env['_FORTRAND'] = 'ifort' + add_all_to_env(env) - # If files are compiled into objects, the Intel Fortran Compiler must use - # ld to link shared libraries. - env['SHLINK'] = 'ld' + fc = 'ifort' - # Additionally, no symbols can be defined in an archive file; to use - # Intel Fortran to create shared libraries, all external symbols must - # be in shared libraries. - env['SHLINKFLAGS'] = '-shared -no_archive' + for dialect in ['F77', 'F90', 'FORTRAN', 'F95']: + env['%s' % dialect] = fc + env['SH%s' % dialect] = '$%s' % dialect + env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS -fPIC' % dialect) - # if env['PLATFORM'] == 'win32': # On Windows, the ifort compiler specifies the object on the # command line with -object:, not -o. Massage the necessary # command-line construction variables. - for var in ['_FORTRANCOMD', '_FORTRANPPCOMD', - '_SHFORTRANCOMD', '_SHFORTRANPPCOMD']: - env[var] = string.replace(env[var], '-o $TARGET', '-object:$TARGET') + for dialect in ['F77', 'F90', 'FORTRAN', 'F95']: + for var in ['%sCOM' % dialect, '%sPPCOM' % dialect, + 'SH%sCOM' % dialect, 'SH%sPPCOM' % dialect]: + env[var] = string.replace(env[var], '-o $TARGET', '-object:$TARGET') def exists(env): return env.Detect('ifort') diff --git a/src/engine/SCons/Tool/ifort.xml b/src/engine/SCons/Tool/ifort.xml index 20950f8..834708f 100644 --- a/src/engine/SCons/Tool/ifort.xml +++ b/src/engine/SCons/Tool/ifort.xml @@ -10,7 +10,17 @@ Sets construction variables for newer versions of the Intel Fortran compiler for Linux. </summary> <sets> -SHLINK -SHLINKFLAGS +FORTRAN +F77 +F90 +F95 +SHFORTRAN +SHF77 +SHF90 +SHF95 +SHFORTRANFLAGS +SHF77FLAGS +SHF90FLAGS +SHF95FLAGS </sets> </tool> diff --git a/src/engine/SCons/Tool/link.py b/src/engine/SCons/Tool/link.py index b60aa87..866df08 100644 --- a/src/engine/SCons/Tool/link.py +++ b/src/engine/SCons/Tool/link.py @@ -36,11 +36,21 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" import SCons.Defaults import SCons.Tool import SCons.Util +import SCons.Errors + +from SCons.Tool.FortranCommon import isfortran cplusplus = __import__('c++', globals(), locals(), []) def smart_link(source, target, env, for_signature): - if cplusplus.iscplusplus(source): + has_cplusplus = cplusplus.iscplusplus(source) + has_fortran = isfortran(env, source) + if has_cplusplus and has_fortran: + raise SCons.Errors.InternalError( + "Sorry, scons cannot yet link c++ and fortran code together.") + elif has_fortran: + return '$FORTRAN' + elif has_cplusplus: return '$CXX' return '$CC' diff --git a/src/engine/SCons/Tool/sunf77.py b/src/engine/SCons/Tool/sunf77.py new file mode 100644 index 0000000..4c2fe1c --- /dev/null +++ b/src/engine/SCons/Tool/sunf77.py @@ -0,0 +1,57 @@ +"""SCons.Tool.sunf77 + +Tool-specific initialization for sunf77, the Sun Studio F77 compiler. + +There normally shouldn't be any need to import this module directly. +It will usually be imported through the generic SCons.Tool.Tool() +selection method. + +""" + +# +# __COPYRIGHT__ +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +import SCons.Util + +from FortranCommon import add_all_to_env + +compilers = ['sunf77', 'f77'] + +def generate(env): + """Add Builders and construction variables for sunf77 to an Environment.""" + add_all_to_env(env) + + fcomp = env.Detect(compilers) or 'f77' + env['FORTRAN'] = fcomp + env['F77'] = fcomp + + env['SHFORTRAN'] = '$FORTRAN' + env['SHF77'] = '$F77' + + env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS -KPIC') + env['SHF77FLAGS'] = SCons.Util.CLVar('$F77FLAGS -KPIC') + +def exists(env): + return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/sunf77.xml b/src/engine/SCons/Tool/sunf77.xml new file mode 100644 index 0000000..3f02163 --- /dev/null +++ b/src/engine/SCons/Tool/sunf77.xml @@ -0,0 +1,19 @@ +<!-- +__COPYRIGHT__ + +This file is processed by the bin/SConsDoc.py module. +See its __doc__ string for a discussion of the format. +--> +<tool name="sunf77"> +<summary> +Set construction variables for the Sun &f77; Fortran compiler. +</summary> +<sets> +FORTRAN +F77 +SHFORTRAN +SHF77 +SHFORTRANFLAGS +SHF77FLAGS +</sets> +</tool> diff --git a/src/engine/SCons/Tool/sunf90.py b/src/engine/SCons/Tool/sunf90.py new file mode 100644 index 0000000..92aecc6 --- /dev/null +++ b/src/engine/SCons/Tool/sunf90.py @@ -0,0 +1,58 @@ +"""SCons.Tool.sunf90 + +Tool-specific initialization for sunf90, the Sun Studio F90 compiler. + +There normally shouldn't be any need to import this module directly. +It will usually be imported through the generic SCons.Tool.Tool() +selection method. + +""" + +# +# __COPYRIGHT__ +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +import SCons.Util + +from FortranCommon import add_all_to_env + +compilers = ['sunf90', 'f90'] + +def generate(env): + """Add Builders and construction variables for sun f90 compiler to an + Environment.""" + add_all_to_env(env) + + fcomp = env.Detect(compilers) or 'f90' + env['FORTRAN'] = fcomp + env['F90'] = fcomp + + env['SHFORTRAN'] = '$FORTRAN' + env['SHF90'] = '$F90' + + env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS -KPIC') + env['SHF90FLAGS'] = SCons.Util.CLVar('$F90FLAGS -KPIC') + +def exists(env): + return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/sunf90.xml b/src/engine/SCons/Tool/sunf90.xml new file mode 100644 index 0000000..1d51846 --- /dev/null +++ b/src/engine/SCons/Tool/sunf90.xml @@ -0,0 +1,19 @@ +<!-- +__COPYRIGHT__ + +This file is processed by the bin/SConsDoc.py module. +See its __doc__ string for a discussion of the format. +--> +<tool name="sunf90"> +<summary> +Set construction variables for the Sun &f90; Fortran compiler. +</summary> +<sets> +FORTRAN +F90 +SHFORTRAN +SHF90 +SHFORTRANFLAGS +SHF90FLAGS +</sets> +</tool> diff --git a/src/engine/SCons/Tool/sunf95.py b/src/engine/SCons/Tool/sunf95.py new file mode 100644 index 0000000..8e02655 --- /dev/null +++ b/src/engine/SCons/Tool/sunf95.py @@ -0,0 +1,58 @@ +"""SCons.Tool.sunf95 + +Tool-specific initialization for sunf95, the Sun Studio F95 compiler. + +There normally shouldn't be any need to import this module directly. +It will usually be imported through the generic SCons.Tool.Tool() +selection method. + +""" + +# +# __COPYRIGHT__ +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +import SCons.Util + +from FortranCommon import add_all_to_env + +compilers = ['sunf95', 'f95'] + +def generate(env): + """Add Builders and construction variables for sunf95 to an + Environment.""" + add_all_to_env(env) + + fcomp = env.Detect(compilers) or 'f95' + env['FORTRAN'] = fcomp + env['F95'] = fcomp + + env['SHFORTRAN'] = '$FORTRAN' + env['SHF95'] = '$F95' + + env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS -KPIC') + env['SHF95FLAGS'] = SCons.Util.CLVar('$F95FLAGS -KPIC') + +def exists(env): + return env.Detect(compilers) diff --git a/src/engine/SCons/Tool/sunf95.xml b/src/engine/SCons/Tool/sunf95.xml new file mode 100644 index 0000000..be6cdb7 --- /dev/null +++ b/src/engine/SCons/Tool/sunf95.xml @@ -0,0 +1,19 @@ +<!-- +__COPYRIGHT__ + +This file is processed by the bin/SConsDoc.py module. +See its __doc__ string for a discussion of the format. +--> +<tool name="sunf95"> +<summary> +Set construction variables for the Sun &f95; Fortran compiler. +</summary> +<sets> +FORTRAN +F95 +SHFORTRAN +SHF95 +SHFORTRANFLAGS +SHF95FLAGS +</sets> +</tool> |