mirror of
https://github.com/bvanroll/college-python-image.git
synced 2025-09-03 14:22:47 +00:00
first commit
This commit is contained in:
File diff suppressed because it is too large
Load Diff
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,158 @@
|
||||
|
||||
# http://www.absoft.com/literature/osxuserguide.pdf
|
||||
# http://www.absoft.com/documentation.html
|
||||
|
||||
# Notes:
|
||||
# - when using -g77 then use -DUNDERSCORE_G77 to compile f2py
|
||||
# generated extension modules (works for f2py v2.45.241_1936 and up)
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import os
|
||||
|
||||
from numpy.distutils.cpuinfo import cpu
|
||||
from numpy.distutils.fcompiler import FCompiler, dummy_fortran_file
|
||||
from numpy.distutils.misc_util import cyg2win32
|
||||
|
||||
compilers = ['AbsoftFCompiler']
|
||||
|
||||
class AbsoftFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'absoft'
|
||||
description = 'Absoft Corp Fortran Compiler'
|
||||
#version_pattern = r'FORTRAN 77 Compiler (?P<version>[^\s*,]*).*?Absoft Corp'
|
||||
version_pattern = r'(f90:.*?(Absoft Pro FORTRAN Version|FORTRAN 77 Compiler|Absoft Fortran Compiler Version|Copyright Absoft Corporation.*?Version))'+\
|
||||
r' (?P<version>[^\s*,]*)(.*?Absoft Corp|)'
|
||||
|
||||
# on windows: f90 -V -c dummy.f
|
||||
# f90: Copyright Absoft Corporation 1994-1998 mV2; Cray Research, Inc. 1994-1996 CF90 (2.x.x.x f36t87) Version 2.3 Wed Apr 19, 2006 13:05:16
|
||||
|
||||
# samt5735(8)$ f90 -V -c dummy.f
|
||||
# f90: Copyright Absoft Corporation 1994-2002; Absoft Pro FORTRAN Version 8.0
|
||||
# Note that fink installs g77 as f77, so need to use f90 for detection.
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None, # set by update_executables
|
||||
'compiler_f77' : ["f77"],
|
||||
'compiler_fix' : ["f90"],
|
||||
'compiler_f90' : ["f90"],
|
||||
'linker_so' : ["<F90>"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
if os.name=='nt':
|
||||
library_switch = '/out:' #No space after /out:!
|
||||
|
||||
module_dir_switch = None
|
||||
module_include_switch = '-p'
|
||||
|
||||
def update_executables(self):
|
||||
f = cyg2win32(dummy_fortran_file())
|
||||
self.executables['version_cmd'] = ['<F90>', '-V', '-c',
|
||||
f+'.f', '-o', f+'.o']
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
if os.name=='nt':
|
||||
opt = ['/dll']
|
||||
# The "-K shared" switches are being left in for pre-9.0 versions
|
||||
# of Absoft though I don't think versions earlier than 9 can
|
||||
# actually be used to build shared libraries. In fact, version
|
||||
# 8 of Absoft doesn't recognize "-K shared" and will fail.
|
||||
elif self.get_version() >= '9.0':
|
||||
opt = ['-shared']
|
||||
else:
|
||||
opt = ["-K", "shared"]
|
||||
return opt
|
||||
|
||||
def library_dir_option(self, dir):
|
||||
if os.name=='nt':
|
||||
return ['-link', '/PATH:"%s"' % (dir)]
|
||||
return "-L" + dir
|
||||
|
||||
def library_option(self, lib):
|
||||
if os.name=='nt':
|
||||
return '%s.lib' % (lib)
|
||||
return "-l" + lib
|
||||
|
||||
def get_library_dirs(self):
|
||||
opt = FCompiler.get_library_dirs(self)
|
||||
d = os.environ.get('ABSOFT')
|
||||
if d:
|
||||
if self.get_version() >= '10.0':
|
||||
# use shared libraries, the static libraries were not compiled -fPIC
|
||||
prefix = 'sh'
|
||||
else:
|
||||
prefix = ''
|
||||
if cpu.is_64bit():
|
||||
suffix = '64'
|
||||
else:
|
||||
suffix = ''
|
||||
opt.append(os.path.join(d, '%slib%s' % (prefix, suffix)))
|
||||
return opt
|
||||
|
||||
def get_libraries(self):
|
||||
opt = FCompiler.get_libraries(self)
|
||||
if self.get_version() >= '11.0':
|
||||
opt.extend(['af90math', 'afio', 'af77math', 'amisc'])
|
||||
elif self.get_version() >= '10.0':
|
||||
opt.extend(['af90math', 'afio', 'af77math', 'U77'])
|
||||
elif self.get_version() >= '8.0':
|
||||
opt.extend(['f90math', 'fio', 'f77math', 'U77'])
|
||||
else:
|
||||
opt.extend(['fio', 'f90math', 'fmath', 'U77'])
|
||||
if os.name =='nt':
|
||||
opt.append('COMDLG32')
|
||||
return opt
|
||||
|
||||
def get_flags(self):
|
||||
opt = FCompiler.get_flags(self)
|
||||
if os.name != 'nt':
|
||||
opt.extend(['-s'])
|
||||
if self.get_version():
|
||||
if self.get_version()>='8.2':
|
||||
opt.append('-fpic')
|
||||
return opt
|
||||
|
||||
def get_flags_f77(self):
|
||||
opt = FCompiler.get_flags_f77(self)
|
||||
opt.extend(['-N22', '-N90', '-N110'])
|
||||
v = self.get_version()
|
||||
if os.name == 'nt':
|
||||
if v and v>='8.0':
|
||||
opt.extend(['-f', '-N15'])
|
||||
else:
|
||||
opt.append('-f')
|
||||
if v:
|
||||
if v<='4.6':
|
||||
opt.append('-B108')
|
||||
else:
|
||||
# Though -N15 is undocumented, it works with
|
||||
# Absoft 8.0 on Linux
|
||||
opt.append('-N15')
|
||||
return opt
|
||||
|
||||
def get_flags_f90(self):
|
||||
opt = FCompiler.get_flags_f90(self)
|
||||
opt.extend(["-YCFRL=1", "-YCOM_NAMES=LCS", "-YCOM_PFX", "-YEXT_PFX",
|
||||
"-YCOM_SFX=_", "-YEXT_SFX=_", "-YEXT_NAMES=LCS"])
|
||||
if self.get_version():
|
||||
if self.get_version()>'4.6':
|
||||
opt.extend(["-YDEALLOC=ALL"])
|
||||
return opt
|
||||
|
||||
def get_flags_fix(self):
|
||||
opt = FCompiler.get_flags_fix(self)
|
||||
opt.extend(["-YCFRL=1", "-YCOM_NAMES=LCS", "-YCOM_PFX", "-YEXT_PFX",
|
||||
"-YCOM_SFX=_", "-YEXT_SFX=_", "-YEXT_NAMES=LCS"])
|
||||
opt.extend(["-f", "fixed"])
|
||||
return opt
|
||||
|
||||
def get_flags_opt(self):
|
||||
opt = ['-O']
|
||||
return opt
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='absoft').get_version())
|
||||
@@ -0,0 +1,126 @@
|
||||
|
||||
#http://www.compaq.com/fortran/docs/
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
from numpy.distutils.compat import get_exception
|
||||
from distutils.errors import DistutilsPlatformError
|
||||
|
||||
compilers = ['CompaqFCompiler']
|
||||
if os.name != 'posix' or sys.platform[:6] == 'cygwin' :
|
||||
# Otherwise we'd get a false positive on posix systems with
|
||||
# case-insensitive filesystems (like darwin), because we'll pick
|
||||
# up /bin/df
|
||||
compilers.append('CompaqVisualFCompiler')
|
||||
|
||||
class CompaqFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'compaq'
|
||||
description = 'Compaq Fortran Compiler'
|
||||
version_pattern = r'Compaq Fortran (?P<version>[^\s]*).*'
|
||||
|
||||
if sys.platform[:5]=='linux':
|
||||
fc_exe = 'fort'
|
||||
else:
|
||||
fc_exe = 'f90'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ['<F90>', "-version"],
|
||||
'compiler_f77' : [fc_exe, "-f77rtl", "-fixed"],
|
||||
'compiler_fix' : [fc_exe, "-fixed"],
|
||||
'compiler_f90' : [fc_exe],
|
||||
'linker_so' : ['<F90>'],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
module_dir_switch = '-module ' # not tested
|
||||
module_include_switch = '-I'
|
||||
|
||||
def get_flags(self):
|
||||
return ['-assume no2underscore', '-nomixed_str_len_arg']
|
||||
def get_flags_debug(self):
|
||||
return ['-g', '-check bounds']
|
||||
def get_flags_opt(self):
|
||||
return ['-O4', '-align dcommons', '-assume bigarrays',
|
||||
'-assume nozsize', '-math_library fast']
|
||||
def get_flags_arch(self):
|
||||
return ['-arch host', '-tune host']
|
||||
def get_flags_linker_so(self):
|
||||
if sys.platform[:5]=='linux':
|
||||
return ['-shared']
|
||||
return ['-shared', '-Wl,-expect_unresolved,*']
|
||||
|
||||
class CompaqVisualFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'compaqv'
|
||||
description = 'DIGITAL or Compaq Visual Fortran Compiler'
|
||||
version_pattern = (r'(DIGITAL|Compaq) Visual Fortran Optimizing Compiler'
|
||||
r' Version (?P<version>[^\s]*).*')
|
||||
|
||||
compile_switch = '/compile_only'
|
||||
object_switch = '/object:'
|
||||
library_switch = '/OUT:' #No space after /OUT:!
|
||||
|
||||
static_lib_extension = ".lib"
|
||||
static_lib_format = "%s%s"
|
||||
module_dir_switch = '/module:'
|
||||
module_include_switch = '/I'
|
||||
|
||||
ar_exe = 'lib.exe'
|
||||
fc_exe = 'DF'
|
||||
|
||||
if sys.platform=='win32':
|
||||
from numpy.distutils.msvccompiler import MSVCCompiler
|
||||
|
||||
try:
|
||||
m = MSVCCompiler()
|
||||
m.initialize()
|
||||
ar_exe = m.lib
|
||||
except DistutilsPlatformError:
|
||||
pass
|
||||
except AttributeError:
|
||||
msg = get_exception()
|
||||
if '_MSVCCompiler__root' in str(msg):
|
||||
print('Ignoring "%s" (I think it is msvccompiler.py bug)' % (msg))
|
||||
else:
|
||||
raise
|
||||
except IOError:
|
||||
e = get_exception()
|
||||
if not "vcvarsall.bat" in str(e):
|
||||
print("Unexpected IOError in", __file__)
|
||||
raise e
|
||||
except ValueError:
|
||||
e = get_exception()
|
||||
if not "path']" in str(e):
|
||||
print("Unexpected ValueError in", __file__)
|
||||
raise e
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ['<F90>', "/what"],
|
||||
'compiler_f77' : [fc_exe, "/f77rtl", "/fixed"],
|
||||
'compiler_fix' : [fc_exe, "/fixed"],
|
||||
'compiler_f90' : [fc_exe],
|
||||
'linker_so' : ['<F90>'],
|
||||
'archiver' : [ar_exe, "/OUT:"],
|
||||
'ranlib' : None
|
||||
}
|
||||
|
||||
def get_flags(self):
|
||||
return ['/nologo', '/MD', '/WX', '/iface=(cref,nomixed_str_len_arg)',
|
||||
'/names:lowercase', '/assume:underscore']
|
||||
def get_flags_opt(self):
|
||||
return ['/Ox', '/fast', '/optimize:5', '/unroll:0', '/math_library:fast']
|
||||
def get_flags_arch(self):
|
||||
return ['/threads']
|
||||
def get_flags_debug(self):
|
||||
return ['/debug']
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='compaq').get_version())
|
||||
@@ -0,0 +1,44 @@
|
||||
# http://g95.sourceforge.net/
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['G95FCompiler']
|
||||
|
||||
class G95FCompiler(FCompiler):
|
||||
compiler_type = 'g95'
|
||||
description = 'G95 Fortran Compiler'
|
||||
|
||||
# version_pattern = r'G95 \((GCC (?P<gccversion>[\d.]+)|.*?) \(g95!\) (?P<version>.*)\).*'
|
||||
# $ g95 --version
|
||||
# G95 (GCC 4.0.3 (g95!) May 22 2006)
|
||||
|
||||
version_pattern = r'G95 \((GCC (?P<gccversion>[\d.]+)|.*?) \(g95 (?P<version>.*)!\) (?P<date>.*)\).*'
|
||||
# $ g95 --version
|
||||
# G95 (GCC 4.0.3 (g95 0.90!) Aug 22 2006)
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "--version"],
|
||||
'compiler_f77' : ["g95", "-ffixed-form"],
|
||||
'compiler_fix' : ["g95", "-ffixed-form"],
|
||||
'compiler_f90' : ["g95"],
|
||||
'linker_so' : ["<F90>", "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
pic_flags = ['-fpic']
|
||||
module_dir_switch = '-fmod='
|
||||
module_include_switch = '-I'
|
||||
|
||||
def get_flags(self):
|
||||
return ['-fno-second-underscore']
|
||||
def get_flags_opt(self):
|
||||
return ['-O']
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
from numpy.distutils import customized_fcompiler
|
||||
log.set_verbosity(2)
|
||||
print(customized_fcompiler('g95').get_version())
|
||||
@@ -0,0 +1,539 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import re
|
||||
import os
|
||||
import sys
|
||||
import warnings
|
||||
import platform
|
||||
import tempfile
|
||||
import hashlib
|
||||
import base64
|
||||
from subprocess import Popen, PIPE, STDOUT
|
||||
from copy import copy
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
from numpy.distutils.exec_command import exec_command
|
||||
from numpy.distutils.compat import get_exception
|
||||
from numpy.distutils.system_info import system_info
|
||||
|
||||
compilers = ['GnuFCompiler', 'Gnu95FCompiler']
|
||||
|
||||
TARGET_R = re.compile(r"Target: ([a-zA-Z0-9_\-]*)")
|
||||
|
||||
# XXX: handle cross compilation
|
||||
|
||||
|
||||
def is_win64():
|
||||
return sys.platform == "win32" and platform.architecture()[0] == "64bit"
|
||||
|
||||
|
||||
if is_win64():
|
||||
#_EXTRAFLAGS = ["-fno-leading-underscore"]
|
||||
_EXTRAFLAGS = []
|
||||
else:
|
||||
_EXTRAFLAGS = []
|
||||
|
||||
|
||||
class GnuFCompiler(FCompiler):
|
||||
compiler_type = 'gnu'
|
||||
compiler_aliases = ('g77', )
|
||||
description = 'GNU Fortran 77 compiler'
|
||||
|
||||
def gnu_version_match(self, version_string):
|
||||
"""Handle the different versions of GNU fortran compilers"""
|
||||
# Strip warning(s) that may be emitted by gfortran
|
||||
while version_string.startswith('gfortran: warning'):
|
||||
version_string = version_string[version_string.find('\n') + 1:]
|
||||
|
||||
# Gfortran versions from after 2010 will output a simple string
|
||||
# (usually "x.y", "x.y.z" or "x.y.z-q") for ``-dumpversion``; older
|
||||
# gfortrans may still return long version strings (``-dumpversion`` was
|
||||
# an alias for ``--version``)
|
||||
if len(version_string) <= 20:
|
||||
# Try to find a valid version string
|
||||
m = re.search(r'([0-9.]+)', version_string)
|
||||
if m:
|
||||
# g77 provides a longer version string that starts with GNU
|
||||
# Fortran
|
||||
if version_string.startswith('GNU Fortran'):
|
||||
return ('g77', m.group(1))
|
||||
|
||||
# gfortran only outputs a version string such as #.#.#, so check
|
||||
# if the match is at the start of the string
|
||||
elif m.start() == 0:
|
||||
return ('gfortran', m.group(1))
|
||||
else:
|
||||
# Output probably from --version, try harder:
|
||||
m = re.search(r'GNU Fortran\s+95.*?([0-9-.]+)', version_string)
|
||||
if m:
|
||||
return ('gfortran', m.group(1))
|
||||
m = re.search(
|
||||
r'GNU Fortran.*?\-?([0-9-.]+\.[0-9-.]+)', version_string)
|
||||
if m:
|
||||
v = m.group(1)
|
||||
if v.startswith('0') or v.startswith('2') or v.startswith('3'):
|
||||
# the '0' is for early g77's
|
||||
return ('g77', v)
|
||||
else:
|
||||
# at some point in the 4.x series, the ' 95' was dropped
|
||||
# from the version string
|
||||
return ('gfortran', v)
|
||||
|
||||
# If still nothing, raise an error to make the problem easy to find.
|
||||
err = 'A valid Fortran version was not found in this string:\n'
|
||||
raise ValueError(err + version_string)
|
||||
|
||||
def version_match(self, version_string):
|
||||
v = self.gnu_version_match(version_string)
|
||||
if not v or v[0] != 'g77':
|
||||
return None
|
||||
return v[1]
|
||||
|
||||
possible_executables = ['g77', 'f77']
|
||||
executables = {
|
||||
'version_cmd' : [None, "-dumpversion"],
|
||||
'compiler_f77' : [None, "-g", "-Wall", "-fno-second-underscore"],
|
||||
'compiler_f90' : None, # Use --fcompiler=gnu95 for f90 codes
|
||||
'compiler_fix' : None,
|
||||
'linker_so' : [None, "-g", "-Wall"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"],
|
||||
'linker_exe' : [None, "-g", "-Wall"]
|
||||
}
|
||||
module_dir_switch = None
|
||||
module_include_switch = None
|
||||
|
||||
# Cygwin: f771: warning: -fPIC ignored for target (all code is
|
||||
# position independent)
|
||||
if os.name != 'nt' and sys.platform != 'cygwin':
|
||||
pic_flags = ['-fPIC']
|
||||
|
||||
# use -mno-cygwin for g77 when Python is not Cygwin-Python
|
||||
if sys.platform == 'win32':
|
||||
for key in ['version_cmd', 'compiler_f77', 'linker_so', 'linker_exe']:
|
||||
executables[key].append('-mno-cygwin')
|
||||
|
||||
g2c = 'g2c'
|
||||
suggested_f90_compiler = 'gnu95'
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
opt = self.linker_so[1:]
|
||||
if sys.platform == 'darwin':
|
||||
target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', None)
|
||||
# If MACOSX_DEPLOYMENT_TARGET is set, we simply trust the value
|
||||
# and leave it alone. But, distutils will complain if the
|
||||
# environment's value is different from the one in the Python
|
||||
# Makefile used to build Python. We let disutils handle this
|
||||
# error checking.
|
||||
if not target:
|
||||
# If MACOSX_DEPLOYMENT_TARGET is not set in the environment,
|
||||
# we try to get it first from the Python Makefile and then we
|
||||
# fall back to setting it to 10.3 to maximize the set of
|
||||
# versions we can work with. This is a reasonable default
|
||||
# even when using the official Python dist and those derived
|
||||
# from it.
|
||||
import distutils.sysconfig as sc
|
||||
g = {}
|
||||
try:
|
||||
get_makefile_filename = sc.get_makefile_filename
|
||||
except AttributeError:
|
||||
pass # i.e. PyPy
|
||||
else:
|
||||
filename = get_makefile_filename()
|
||||
sc.parse_makefile(filename, g)
|
||||
target = g.get('MACOSX_DEPLOYMENT_TARGET', '10.3')
|
||||
os.environ['MACOSX_DEPLOYMENT_TARGET'] = target
|
||||
if target == '10.3':
|
||||
s = 'Env. variable MACOSX_DEPLOYMENT_TARGET set to 10.3'
|
||||
warnings.warn(s, stacklevel=2)
|
||||
|
||||
opt.extend(['-undefined', 'dynamic_lookup', '-bundle'])
|
||||
else:
|
||||
opt.append("-shared")
|
||||
if sys.platform.startswith('sunos'):
|
||||
# SunOS often has dynamically loaded symbols defined in the
|
||||
# static library libg2c.a The linker doesn't like this. To
|
||||
# ignore the problem, use the -mimpure-text flag. It isn't
|
||||
# the safest thing, but seems to work. 'man gcc' says:
|
||||
# ".. Instead of using -mimpure-text, you should compile all
|
||||
# source code with -fpic or -fPIC."
|
||||
opt.append('-mimpure-text')
|
||||
return opt
|
||||
|
||||
def get_libgcc_dir(self):
|
||||
status, output = exec_command(
|
||||
self.compiler_f77 + ['-print-libgcc-file-name'], use_tee=0)
|
||||
if not status:
|
||||
return os.path.dirname(output)
|
||||
return None
|
||||
|
||||
def get_libgfortran_dir(self):
|
||||
if sys.platform[:5] == 'linux':
|
||||
libgfortran_name = 'libgfortran.so'
|
||||
elif sys.platform == 'darwin':
|
||||
libgfortran_name = 'libgfortran.dylib'
|
||||
else:
|
||||
libgfortran_name = None
|
||||
|
||||
libgfortran_dir = None
|
||||
if libgfortran_name:
|
||||
find_lib_arg = ['-print-file-name={0}'.format(libgfortran_name)]
|
||||
status, output = exec_command(
|
||||
self.compiler_f77 + find_lib_arg, use_tee=0)
|
||||
if not status:
|
||||
libgfortran_dir = os.path.dirname(output)
|
||||
return libgfortran_dir
|
||||
|
||||
def get_library_dirs(self):
|
||||
opt = []
|
||||
if sys.platform[:5] != 'linux':
|
||||
d = self.get_libgcc_dir()
|
||||
if d:
|
||||
# if windows and not cygwin, libg2c lies in a different folder
|
||||
if sys.platform == 'win32' and not d.startswith('/usr/lib'):
|
||||
d = os.path.normpath(d)
|
||||
path = os.path.join(d, "lib%s.a" % self.g2c)
|
||||
if not os.path.exists(path):
|
||||
root = os.path.join(d, *((os.pardir, ) * 4))
|
||||
d2 = os.path.abspath(os.path.join(root, 'lib'))
|
||||
path = os.path.join(d2, "lib%s.a" % self.g2c)
|
||||
if os.path.exists(path):
|
||||
opt.append(d2)
|
||||
opt.append(d)
|
||||
# For Macports / Linux, libgfortran and libgcc are not co-located
|
||||
lib_gfortran_dir = self.get_libgfortran_dir()
|
||||
if lib_gfortran_dir:
|
||||
opt.append(lib_gfortran_dir)
|
||||
return opt
|
||||
|
||||
def get_libraries(self):
|
||||
opt = []
|
||||
d = self.get_libgcc_dir()
|
||||
if d is not None:
|
||||
g2c = self.g2c + '-pic'
|
||||
f = self.static_lib_format % (g2c, self.static_lib_extension)
|
||||
if not os.path.isfile(os.path.join(d, f)):
|
||||
g2c = self.g2c
|
||||
else:
|
||||
g2c = self.g2c
|
||||
|
||||
if g2c is not None:
|
||||
opt.append(g2c)
|
||||
c_compiler = self.c_compiler
|
||||
if sys.platform == 'win32' and c_compiler and \
|
||||
c_compiler.compiler_type == 'msvc':
|
||||
opt.append('gcc')
|
||||
if sys.platform == 'darwin':
|
||||
opt.append('cc_dynamic')
|
||||
return opt
|
||||
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
def get_flags_opt(self):
|
||||
v = self.get_version()
|
||||
if v and v <= '3.3.3':
|
||||
# With this compiler version building Fortran BLAS/LAPACK
|
||||
# with -O3 caused failures in lib.lapack heevr,syevr tests.
|
||||
opt = ['-O2']
|
||||
else:
|
||||
opt = ['-O3']
|
||||
opt.append('-funroll-loops')
|
||||
return opt
|
||||
|
||||
def _c_arch_flags(self):
|
||||
""" Return detected arch flags from CFLAGS """
|
||||
from distutils import sysconfig
|
||||
try:
|
||||
cflags = sysconfig.get_config_vars()['CFLAGS']
|
||||
except KeyError:
|
||||
return []
|
||||
arch_re = re.compile(r"-arch\s+(\w+)")
|
||||
arch_flags = []
|
||||
for arch in arch_re.findall(cflags):
|
||||
arch_flags += ['-arch', arch]
|
||||
return arch_flags
|
||||
|
||||
def get_flags_arch(self):
|
||||
return []
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
sep = ',' if sys.platform == 'darwin' else '='
|
||||
return '-Wl,-rpath%s"%s"' % (sep, dir)
|
||||
|
||||
|
||||
class Gnu95FCompiler(GnuFCompiler):
|
||||
compiler_type = 'gnu95'
|
||||
compiler_aliases = ('gfortran', )
|
||||
description = 'GNU Fortran 95 compiler'
|
||||
|
||||
def version_match(self, version_string):
|
||||
v = self.gnu_version_match(version_string)
|
||||
if not v or v[0] != 'gfortran':
|
||||
return None
|
||||
v = v[1]
|
||||
if v >= '4.':
|
||||
# gcc-4 series releases do not support -mno-cygwin option
|
||||
pass
|
||||
else:
|
||||
# use -mno-cygwin flag for gfortran when Python is not
|
||||
# Cygwin-Python
|
||||
if sys.platform == 'win32':
|
||||
for key in [
|
||||
'version_cmd', 'compiler_f77', 'compiler_f90',
|
||||
'compiler_fix', 'linker_so', 'linker_exe'
|
||||
]:
|
||||
self.executables[key].append('-mno-cygwin')
|
||||
return v
|
||||
|
||||
possible_executables = ['gfortran', 'f95']
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "-dumpversion"],
|
||||
'compiler_f77' : [None, "-Wall", "-g", "-ffixed-form",
|
||||
"-fno-second-underscore"] + _EXTRAFLAGS,
|
||||
'compiler_f90' : [None, "-Wall", "-g",
|
||||
"-fno-second-underscore"] + _EXTRAFLAGS,
|
||||
'compiler_fix' : [None, "-Wall", "-g","-ffixed-form",
|
||||
"-fno-second-underscore"] + _EXTRAFLAGS,
|
||||
'linker_so' : ["<F90>", "-Wall", "-g"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"],
|
||||
'linker_exe' : [None, "-Wall"]
|
||||
}
|
||||
|
||||
module_dir_switch = '-J'
|
||||
module_include_switch = '-I'
|
||||
|
||||
g2c = 'gfortran'
|
||||
|
||||
def _universal_flags(self, cmd):
|
||||
"""Return a list of -arch flags for every supported architecture."""
|
||||
if not sys.platform == 'darwin':
|
||||
return []
|
||||
arch_flags = []
|
||||
# get arches the C compiler gets.
|
||||
c_archs = self._c_arch_flags()
|
||||
if "i386" in c_archs:
|
||||
c_archs[c_archs.index("i386")] = "i686"
|
||||
# check the arches the Fortran compiler supports, and compare with
|
||||
# arch flags from C compiler
|
||||
for arch in ["ppc", "i686", "x86_64", "ppc64"]:
|
||||
if _can_target(cmd, arch) and arch in c_archs:
|
||||
arch_flags.extend(["-arch", arch])
|
||||
return arch_flags
|
||||
|
||||
def get_flags(self):
|
||||
flags = GnuFCompiler.get_flags(self)
|
||||
arch_flags = self._universal_flags(self.compiler_f90)
|
||||
if arch_flags:
|
||||
flags[:0] = arch_flags
|
||||
return flags
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
flags = GnuFCompiler.get_flags_linker_so(self)
|
||||
arch_flags = self._universal_flags(self.linker_so)
|
||||
if arch_flags:
|
||||
flags[:0] = arch_flags
|
||||
return flags
|
||||
|
||||
def get_library_dirs(self):
|
||||
opt = GnuFCompiler.get_library_dirs(self)
|
||||
if sys.platform == 'win32':
|
||||
c_compiler = self.c_compiler
|
||||
if c_compiler and c_compiler.compiler_type == "msvc":
|
||||
target = self.get_target()
|
||||
if target:
|
||||
d = os.path.normpath(self.get_libgcc_dir())
|
||||
root = os.path.join(d, *((os.pardir, ) * 4))
|
||||
path = os.path.join(root, "lib")
|
||||
mingwdir = os.path.normpath(path)
|
||||
if os.path.exists(os.path.join(mingwdir, "libmingwex.a")):
|
||||
opt.append(mingwdir)
|
||||
# For Macports / Linux, libgfortran and libgcc are not co-located
|
||||
lib_gfortran_dir = self.get_libgfortran_dir()
|
||||
if lib_gfortran_dir:
|
||||
opt.append(lib_gfortran_dir)
|
||||
return opt
|
||||
|
||||
def get_libraries(self):
|
||||
opt = GnuFCompiler.get_libraries(self)
|
||||
if sys.platform == 'darwin':
|
||||
opt.remove('cc_dynamic')
|
||||
if sys.platform == 'win32':
|
||||
c_compiler = self.c_compiler
|
||||
if c_compiler and c_compiler.compiler_type == "msvc":
|
||||
if "gcc" in opt:
|
||||
i = opt.index("gcc")
|
||||
opt.insert(i + 1, "mingwex")
|
||||
opt.insert(i + 1, "mingw32")
|
||||
c_compiler = self.c_compiler
|
||||
if c_compiler and c_compiler.compiler_type == "msvc":
|
||||
return []
|
||||
else:
|
||||
pass
|
||||
return opt
|
||||
|
||||
def get_target(self):
|
||||
status, output = exec_command(self.compiler_f77 + ['-v'], use_tee=0)
|
||||
if not status:
|
||||
m = TARGET_R.search(output)
|
||||
if m:
|
||||
return m.group(1)
|
||||
return ""
|
||||
|
||||
def _hash_files(self, filenames):
|
||||
h = hashlib.sha1()
|
||||
for fn in filenames:
|
||||
with open(fn, 'rb') as f:
|
||||
while True:
|
||||
block = f.read(131072)
|
||||
if not block:
|
||||
break
|
||||
h.update(block)
|
||||
text = base64.b32encode(h.digest())
|
||||
if sys.version_info[0] >= 3:
|
||||
text = text.decode('ascii')
|
||||
return text.rstrip('=')
|
||||
|
||||
def _link_wrapper_lib(self, objects, output_dir, extra_dll_dir,
|
||||
chained_dlls, is_archive):
|
||||
"""Create a wrapper shared library for the given objects
|
||||
|
||||
Return an MSVC-compatible lib
|
||||
"""
|
||||
|
||||
c_compiler = self.c_compiler
|
||||
if c_compiler.compiler_type != "msvc":
|
||||
raise ValueError("This method only supports MSVC")
|
||||
|
||||
object_hash = self._hash_files(list(objects) + list(chained_dlls))
|
||||
|
||||
if is_win64():
|
||||
tag = 'win_amd64'
|
||||
else:
|
||||
tag = 'win32'
|
||||
|
||||
basename = 'lib' + os.path.splitext(
|
||||
os.path.basename(objects[0]))[0][:8]
|
||||
root_name = basename + '.' + object_hash + '.gfortran-' + tag
|
||||
dll_name = root_name + '.dll'
|
||||
def_name = root_name + '.def'
|
||||
lib_name = root_name + '.lib'
|
||||
dll_path = os.path.join(extra_dll_dir, dll_name)
|
||||
def_path = os.path.join(output_dir, def_name)
|
||||
lib_path = os.path.join(output_dir, lib_name)
|
||||
|
||||
if os.path.isfile(lib_path):
|
||||
# Nothing to do
|
||||
return lib_path, dll_path
|
||||
|
||||
if is_archive:
|
||||
objects = (["-Wl,--whole-archive"] + list(objects) +
|
||||
["-Wl,--no-whole-archive"])
|
||||
self.link_shared_object(
|
||||
objects,
|
||||
dll_name,
|
||||
output_dir=extra_dll_dir,
|
||||
extra_postargs=list(chained_dlls) + [
|
||||
'-Wl,--allow-multiple-definition',
|
||||
'-Wl,--output-def,' + def_path,
|
||||
'-Wl,--export-all-symbols',
|
||||
'-Wl,--enable-auto-import',
|
||||
'-static',
|
||||
'-mlong-double-64',
|
||||
])
|
||||
|
||||
# No PowerPC!
|
||||
if is_win64():
|
||||
specifier = '/MACHINE:X64'
|
||||
else:
|
||||
specifier = '/MACHINE:X86'
|
||||
|
||||
# MSVC specific code
|
||||
lib_args = ['/def:' + def_path, '/OUT:' + lib_path, specifier]
|
||||
if not c_compiler.initialized:
|
||||
c_compiler.initialize()
|
||||
c_compiler.spawn([c_compiler.lib] + lib_args)
|
||||
|
||||
return lib_path, dll_path
|
||||
|
||||
def can_ccompiler_link(self, compiler):
|
||||
# MSVC cannot link objects compiled by GNU fortran
|
||||
return compiler.compiler_type not in ("msvc", )
|
||||
|
||||
def wrap_unlinkable_objects(self, objects, output_dir, extra_dll_dir):
|
||||
"""
|
||||
Convert a set of object files that are not compatible with the default
|
||||
linker, to a file that is compatible.
|
||||
"""
|
||||
if self.c_compiler.compiler_type == "msvc":
|
||||
# Compile a DLL and return the lib for the DLL as
|
||||
# the object. Also keep track of previous DLLs that
|
||||
# we have compiled so that we can link against them.
|
||||
|
||||
# If there are .a archives, assume they are self-contained
|
||||
# static libraries, and build separate DLLs for each
|
||||
archives = []
|
||||
plain_objects = []
|
||||
for obj in objects:
|
||||
if obj.lower().endswith('.a'):
|
||||
archives.append(obj)
|
||||
else:
|
||||
plain_objects.append(obj)
|
||||
|
||||
chained_libs = []
|
||||
chained_dlls = []
|
||||
for archive in archives[::-1]:
|
||||
lib, dll = self._link_wrapper_lib(
|
||||
[archive],
|
||||
output_dir,
|
||||
extra_dll_dir,
|
||||
chained_dlls=chained_dlls,
|
||||
is_archive=True)
|
||||
chained_libs.insert(0, lib)
|
||||
chained_dlls.insert(0, dll)
|
||||
|
||||
if not plain_objects:
|
||||
return chained_libs
|
||||
|
||||
lib, dll = self._link_wrapper_lib(
|
||||
plain_objects,
|
||||
output_dir,
|
||||
extra_dll_dir,
|
||||
chained_dlls=chained_dlls,
|
||||
is_archive=False)
|
||||
return [lib] + chained_libs
|
||||
else:
|
||||
raise ValueError("Unsupported C compiler")
|
||||
|
||||
|
||||
def _can_target(cmd, arch):
|
||||
"""Return true if the architecture supports the -arch flag"""
|
||||
newcmd = cmd[:]
|
||||
fid, filename = tempfile.mkstemp(suffix=".f")
|
||||
os.close(fid)
|
||||
try:
|
||||
d = os.path.dirname(filename)
|
||||
output = os.path.splitext(filename)[0] + ".o"
|
||||
try:
|
||||
newcmd.extend(["-arch", arch, "-c", filename])
|
||||
p = Popen(newcmd, stderr=STDOUT, stdout=PIPE, cwd=d)
|
||||
p.communicate()
|
||||
return p.returncode == 0
|
||||
finally:
|
||||
if os.path.exists(output):
|
||||
os.remove(output)
|
||||
finally:
|
||||
os.remove(filename)
|
||||
return False
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
from numpy.distutils import customized_fcompiler
|
||||
log.set_verbosity(2)
|
||||
|
||||
print(customized_fcompiler('gnu').get_version())
|
||||
try:
|
||||
print(customized_fcompiler('g95').get_version())
|
||||
except Exception:
|
||||
print(get_exception())
|
||||
@@ -0,0 +1,43 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['HPUXFCompiler']
|
||||
|
||||
class HPUXFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'hpux'
|
||||
description = 'HP Fortran 90 Compiler'
|
||||
version_pattern = r'HP F90 (?P<version>[^\s*,]*)'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["f90", "+version"],
|
||||
'compiler_f77' : ["f90"],
|
||||
'compiler_fix' : ["f90"],
|
||||
'compiler_f90' : ["f90"],
|
||||
'linker_so' : ["ld", "-b"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
module_dir_switch = None #XXX: fix me
|
||||
module_include_switch = None #XXX: fix me
|
||||
pic_flags = ['+Z']
|
||||
def get_flags(self):
|
||||
return self.pic_flags + ['+ppu', '+DD64']
|
||||
def get_flags_opt(self):
|
||||
return ['-O3']
|
||||
def get_libraries(self):
|
||||
return ['m']
|
||||
def get_library_dirs(self):
|
||||
opt = ['/usr/lib/hpux64']
|
||||
return opt
|
||||
def get_version(self, force=0, ok_status=[256, 0, 1]):
|
||||
# XXX status==256 may indicate 'unrecognized option' or
|
||||
# 'no input file'. So, version_cmd needs more work.
|
||||
return FCompiler.get_version(self, force, ok_status)
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(10)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='hpux').get_version())
|
||||
@@ -0,0 +1,95 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
from numpy.distutils.exec_command import exec_command, find_executable
|
||||
from numpy.distutils.misc_util import make_temp_file
|
||||
from distutils import log
|
||||
|
||||
compilers = ['IBMFCompiler']
|
||||
|
||||
class IBMFCompiler(FCompiler):
|
||||
compiler_type = 'ibm'
|
||||
description = 'IBM XL Fortran Compiler'
|
||||
version_pattern = r'(xlf\(1\)\s*|)IBM XL Fortran ((Advanced Edition |)Version |Enterprise Edition V|for AIX, V)(?P<version>[^\s*]*)'
|
||||
#IBM XL Fortran Enterprise Edition V10.1 for AIX \nVersion: 10.01.0000.0004
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F77>", "-qversion"],
|
||||
'compiler_f77' : ["xlf"],
|
||||
'compiler_fix' : ["xlf90", "-qfixed"],
|
||||
'compiler_f90' : ["xlf90"],
|
||||
'linker_so' : ["xlf95"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
def get_version(self,*args,**kwds):
|
||||
version = FCompiler.get_version(self,*args,**kwds)
|
||||
|
||||
if version is None and sys.platform.startswith('aix'):
|
||||
# use lslpp to find out xlf version
|
||||
lslpp = find_executable('lslpp')
|
||||
xlf = find_executable('xlf')
|
||||
if os.path.exists(xlf) and os.path.exists(lslpp):
|
||||
s, o = exec_command(lslpp + ' -Lc xlfcmp')
|
||||
m = re.search(r'xlfcmp:(?P<version>\d+([.]\d+)+)', o)
|
||||
if m: version = m.group('version')
|
||||
|
||||
xlf_dir = '/etc/opt/ibmcmp/xlf'
|
||||
if version is None and os.path.isdir(xlf_dir):
|
||||
# linux:
|
||||
# If the output of xlf does not contain version info
|
||||
# (that's the case with xlf 8.1, for instance) then
|
||||
# let's try another method:
|
||||
l = sorted(os.listdir(xlf_dir))
|
||||
l.reverse()
|
||||
l = [d for d in l if os.path.isfile(os.path.join(xlf_dir, d, 'xlf.cfg'))]
|
||||
if l:
|
||||
from distutils.version import LooseVersion
|
||||
self.version = version = LooseVersion(l[0])
|
||||
return version
|
||||
|
||||
def get_flags(self):
|
||||
return ['-qextname']
|
||||
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
opt = []
|
||||
if sys.platform=='darwin':
|
||||
opt.append('-Wl,-bundle,-flat_namespace,-undefined,suppress')
|
||||
else:
|
||||
opt.append('-bshared')
|
||||
version = self.get_version(ok_status=[0, 40])
|
||||
if version is not None:
|
||||
if sys.platform.startswith('aix'):
|
||||
xlf_cfg = '/etc/xlf.cfg'
|
||||
else:
|
||||
xlf_cfg = '/etc/opt/ibmcmp/xlf/%s/xlf.cfg' % version
|
||||
fo, new_cfg = make_temp_file(suffix='_xlf.cfg')
|
||||
log.info('Creating '+new_cfg)
|
||||
fi = open(xlf_cfg, 'r')
|
||||
crt1_match = re.compile(r'\s*crt\s*[=]\s*(?P<path>.*)/crt1.o').match
|
||||
for line in fi:
|
||||
m = crt1_match(line)
|
||||
if m:
|
||||
fo.write('crt = %s/bundle1.o\n' % (m.group('path')))
|
||||
else:
|
||||
fo.write(line)
|
||||
fi.close()
|
||||
fo.close()
|
||||
opt.append('-F'+new_cfg)
|
||||
return opt
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['-O3']
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils import customized_fcompiler
|
||||
log.set_verbosity(2)
|
||||
print(customized_fcompiler(compiler='ibm').get_version())
|
||||
@@ -0,0 +1,219 @@
|
||||
# http://developer.intel.com/software/products/compilers/flin/
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
|
||||
from numpy.distutils.ccompiler import simple_version_match
|
||||
from numpy.distutils.fcompiler import FCompiler, dummy_fortran_file
|
||||
|
||||
compilers = ['IntelFCompiler', 'IntelVisualFCompiler',
|
||||
'IntelItaniumFCompiler', 'IntelItaniumVisualFCompiler',
|
||||
'IntelEM64VisualFCompiler', 'IntelEM64TFCompiler']
|
||||
|
||||
|
||||
def intel_version_match(type):
|
||||
# Match against the important stuff in the version string
|
||||
return simple_version_match(start=r'Intel.*?Fortran.*?(?:%s).*?Version' % (type,))
|
||||
|
||||
|
||||
class BaseIntelFCompiler(FCompiler):
|
||||
def update_executables(self):
|
||||
f = dummy_fortran_file()
|
||||
self.executables['version_cmd'] = ['<F77>', '-FI', '-V', '-c',
|
||||
f + '.f', '-o', f + '.o']
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
return '-Wl,-rpath="%s"' % dir
|
||||
|
||||
|
||||
class IntelFCompiler(BaseIntelFCompiler):
|
||||
|
||||
compiler_type = 'intel'
|
||||
compiler_aliases = ('ifort',)
|
||||
description = 'Intel Fortran Compiler for 32-bit apps'
|
||||
version_match = intel_version_match('32-bit|IA-32')
|
||||
|
||||
possible_executables = ['ifort', 'ifc']
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None, # set by update_executables
|
||||
'compiler_f77' : [None, "-72", "-w90", "-w95"],
|
||||
'compiler_f90' : [None],
|
||||
'compiler_fix' : [None, "-FI"],
|
||||
'linker_so' : ["<F90>", "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
pic_flags = ['-fPIC']
|
||||
module_dir_switch = '-module ' # Don't remove ending space!
|
||||
module_include_switch = '-I'
|
||||
|
||||
def get_flags_free(self):
|
||||
return ['-FR']
|
||||
|
||||
def get_flags(self):
|
||||
return ['-fPIC']
|
||||
|
||||
def get_flags_opt(self): # Scipy test failures with -O2
|
||||
v = self.get_version()
|
||||
mpopt = 'openmp' if v and v < '15' else 'qopenmp'
|
||||
return ['-fp-model strict -O1 -{}'.format(mpopt)]
|
||||
|
||||
def get_flags_arch(self):
|
||||
return []
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
opt = FCompiler.get_flags_linker_so(self)
|
||||
v = self.get_version()
|
||||
if v and v >= '8.0':
|
||||
opt.append('-nofor_main')
|
||||
if sys.platform == 'darwin':
|
||||
# Here, it's -dynamiclib
|
||||
try:
|
||||
idx = opt.index('-shared')
|
||||
opt.remove('-shared')
|
||||
except ValueError:
|
||||
idx = 0
|
||||
opt[idx:idx] = ['-dynamiclib', '-Wl,-undefined,dynamic_lookup']
|
||||
return opt
|
||||
|
||||
|
||||
class IntelItaniumFCompiler(IntelFCompiler):
|
||||
compiler_type = 'intele'
|
||||
compiler_aliases = ()
|
||||
description = 'Intel Fortran Compiler for Itanium apps'
|
||||
|
||||
version_match = intel_version_match('Itanium|IA-64')
|
||||
|
||||
possible_executables = ['ifort', 'efort', 'efc']
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None,
|
||||
'compiler_f77' : [None, "-FI", "-w90", "-w95"],
|
||||
'compiler_fix' : [None, "-FI"],
|
||||
'compiler_f90' : [None],
|
||||
'linker_so' : ['<F90>', "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
|
||||
class IntelEM64TFCompiler(IntelFCompiler):
|
||||
compiler_type = 'intelem'
|
||||
compiler_aliases = ()
|
||||
description = 'Intel Fortran Compiler for 64-bit apps'
|
||||
|
||||
version_match = intel_version_match('EM64T-based|Intel\\(R\\) 64|64|IA-64|64-bit')
|
||||
|
||||
possible_executables = ['ifort', 'efort', 'efc']
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None,
|
||||
'compiler_f77' : [None, "-FI"],
|
||||
'compiler_fix' : [None, "-FI"],
|
||||
'compiler_f90' : [None],
|
||||
'linker_so' : ['<F90>', "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
def get_flags(self):
|
||||
return ['-fPIC']
|
||||
|
||||
def get_flags_opt(self): # Scipy test failures with -O2
|
||||
v = self.get_version()
|
||||
mpopt = 'openmp' if v and v < '15' else 'qopenmp'
|
||||
return ['-fp-model strict -O1 -{}'.format(mpopt)]
|
||||
|
||||
def get_flags_arch(self):
|
||||
return ['']
|
||||
|
||||
# Is there no difference in the version string between the above compilers
|
||||
# and the Visual compilers?
|
||||
|
||||
|
||||
class IntelVisualFCompiler(BaseIntelFCompiler):
|
||||
compiler_type = 'intelv'
|
||||
description = 'Intel Visual Fortran Compiler for 32-bit apps'
|
||||
version_match = intel_version_match('32-bit|IA-32')
|
||||
|
||||
def update_executables(self):
|
||||
f = dummy_fortran_file()
|
||||
self.executables['version_cmd'] = ['<F77>', '/FI', '/c',
|
||||
f + '.f', '/o', f + '.o']
|
||||
|
||||
ar_exe = 'lib.exe'
|
||||
possible_executables = ['ifort', 'ifl']
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None,
|
||||
'compiler_f77' : [None],
|
||||
'compiler_fix' : [None],
|
||||
'compiler_f90' : [None],
|
||||
'linker_so' : [None],
|
||||
'archiver' : [ar_exe, "/verbose", "/OUT:"],
|
||||
'ranlib' : None
|
||||
}
|
||||
|
||||
compile_switch = '/c '
|
||||
object_switch = '/Fo' # No space after /Fo!
|
||||
library_switch = '/OUT:' # No space after /OUT:!
|
||||
module_dir_switch = '/module:' # No space after /module:
|
||||
module_include_switch = '/I'
|
||||
|
||||
def get_flags(self):
|
||||
opt = ['/nologo', '/MD', '/nbs', '/names:lowercase', '/assume:underscore']
|
||||
return opt
|
||||
|
||||
def get_flags_free(self):
|
||||
return []
|
||||
|
||||
def get_flags_debug(self):
|
||||
return ['/4Yb', '/d2']
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['/O1'] # Scipy test failures with /O2
|
||||
|
||||
def get_flags_arch(self):
|
||||
return ["/arch:IA32", "/QaxSSE3"]
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class IntelItaniumVisualFCompiler(IntelVisualFCompiler):
|
||||
compiler_type = 'intelev'
|
||||
description = 'Intel Visual Fortran Compiler for Itanium apps'
|
||||
|
||||
version_match = intel_version_match('Itanium')
|
||||
|
||||
possible_executables = ['efl'] # XXX this is a wild guess
|
||||
ar_exe = IntelVisualFCompiler.ar_exe
|
||||
|
||||
executables = {
|
||||
'version_cmd' : None,
|
||||
'compiler_f77' : [None, "-FI", "-w90", "-w95"],
|
||||
'compiler_fix' : [None, "-FI", "-4L72", "-w"],
|
||||
'compiler_f90' : [None],
|
||||
'linker_so' : ['<F90>', "-shared"],
|
||||
'archiver' : [ar_exe, "/verbose", "/OUT:"],
|
||||
'ranlib' : None
|
||||
}
|
||||
|
||||
|
||||
class IntelEM64VisualFCompiler(IntelVisualFCompiler):
|
||||
compiler_type = 'intelvem'
|
||||
description = 'Intel Visual Fortran Compiler for 64-bit apps'
|
||||
|
||||
version_match = simple_version_match(start=r'Intel\(R\).*?64,')
|
||||
|
||||
def get_flags_arch(self):
|
||||
return ['']
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='intel').get_version())
|
||||
@@ -0,0 +1,47 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import os
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['LaheyFCompiler']
|
||||
|
||||
class LaheyFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'lahey'
|
||||
description = 'Lahey/Fujitsu Fortran 95 Compiler'
|
||||
version_pattern = r'Lahey/Fujitsu Fortran 95 Compiler Release (?P<version>[^\s*]*)'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "--version"],
|
||||
'compiler_f77' : ["lf95", "--fix"],
|
||||
'compiler_fix' : ["lf95", "--fix"],
|
||||
'compiler_f90' : ["lf95"],
|
||||
'linker_so' : ["lf95", "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
module_dir_switch = None #XXX Fix me
|
||||
module_include_switch = None #XXX Fix me
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['-O']
|
||||
def get_flags_debug(self):
|
||||
return ['-g', '--chk', '--chkglobal']
|
||||
def get_library_dirs(self):
|
||||
opt = []
|
||||
d = os.environ.get('LAHEY')
|
||||
if d:
|
||||
opt.append(os.path.join(d, 'lib'))
|
||||
return opt
|
||||
def get_libraries(self):
|
||||
opt = []
|
||||
opt.extend(['fj9f6', 'fj9i6', 'fj9ipp', 'fj9e6'])
|
||||
return opt
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='lahey').get_version())
|
||||
@@ -0,0 +1,56 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.cpuinfo import cpu
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['MIPSFCompiler']
|
||||
|
||||
class MIPSFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'mips'
|
||||
description = 'MIPSpro Fortran Compiler'
|
||||
version_pattern = r'MIPSpro Compilers: Version (?P<version>[^\s*,]*)'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "-version"],
|
||||
'compiler_f77' : ["f77", "-f77"],
|
||||
'compiler_fix' : ["f90", "-fixedform"],
|
||||
'compiler_f90' : ["f90"],
|
||||
'linker_so' : ["f90", "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : None
|
||||
}
|
||||
module_dir_switch = None #XXX: fix me
|
||||
module_include_switch = None #XXX: fix me
|
||||
pic_flags = ['-KPIC']
|
||||
|
||||
def get_flags(self):
|
||||
return self.pic_flags + ['-n32']
|
||||
def get_flags_opt(self):
|
||||
return ['-O3']
|
||||
def get_flags_arch(self):
|
||||
opt = []
|
||||
for a in '19 20 21 22_4k 22_5k 24 25 26 27 28 30 32_5k 32_10k'.split():
|
||||
if getattr(cpu, 'is_IP%s'%a)():
|
||||
opt.append('-TARG:platform=IP%s' % a)
|
||||
break
|
||||
return opt
|
||||
def get_flags_arch_f77(self):
|
||||
r = None
|
||||
if cpu.is_r10000(): r = 10000
|
||||
elif cpu.is_r12000(): r = 12000
|
||||
elif cpu.is_r8000(): r = 8000
|
||||
elif cpu.is_r5000(): r = 5000
|
||||
elif cpu.is_r4000(): r = 4000
|
||||
if r is not None:
|
||||
return ['r%s' % (r)]
|
||||
return []
|
||||
def get_flags_arch_f90(self):
|
||||
r = self.get_flags_arch_f77()
|
||||
if r:
|
||||
r[0] = '-' + r[0]
|
||||
return r
|
||||
|
||||
if __name__ == '__main__':
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='mips').get_version())
|
||||
@@ -0,0 +1,84 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
import re
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['NAGFCompiler', 'NAGFORCompiler']
|
||||
|
||||
class BaseNAGFCompiler(FCompiler):
|
||||
version_pattern = r'NAG.* Release (?P<version>[^(\s]*)'
|
||||
|
||||
def version_match(self, version_string):
|
||||
m = re.search(self.version_pattern, version_string)
|
||||
if m:
|
||||
return m.group('version')
|
||||
else:
|
||||
return None
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
return ["-Wl,-shared"]
|
||||
def get_flags_opt(self):
|
||||
return ['-O4']
|
||||
def get_flags_arch(self):
|
||||
return ['']
|
||||
|
||||
class NAGFCompiler(BaseNAGFCompiler):
|
||||
|
||||
compiler_type = 'nag'
|
||||
description = 'NAGWare Fortran 95 Compiler'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "-V"],
|
||||
'compiler_f77' : ["f95", "-fixed"],
|
||||
'compiler_fix' : ["f95", "-fixed"],
|
||||
'compiler_f90' : ["f95"],
|
||||
'linker_so' : ["<F90>"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
def get_flags_linker_so(self):
|
||||
if sys.platform == 'darwin':
|
||||
return ['-unsharedf95', '-Wl,-bundle,-flat_namespace,-undefined,suppress']
|
||||
return BaseNAGFCompiler.get_flags_linker_so(self)
|
||||
def get_flags_arch(self):
|
||||
version = self.get_version()
|
||||
if version and version < '5.1':
|
||||
return ['-target=native']
|
||||
else:
|
||||
return BaseNAGFCompiler.get_flags_arch(self)
|
||||
def get_flags_debug(self):
|
||||
return ['-g', '-gline', '-g90', '-nan', '-C']
|
||||
|
||||
class NAGFORCompiler(BaseNAGFCompiler):
|
||||
|
||||
compiler_type = 'nagfor'
|
||||
description = 'NAG Fortran Compiler'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["nagfor", "-V"],
|
||||
'compiler_f77' : ["nagfor", "-fixed"],
|
||||
'compiler_fix' : ["nagfor", "-fixed"],
|
||||
'compiler_f90' : ["nagfor"],
|
||||
'linker_so' : ["nagfor"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
|
||||
def get_flags_debug(self):
|
||||
version = self.get_version()
|
||||
if version and version > '6.1':
|
||||
return ['-g', '-u', '-nan', '-C=all', '-thread_safe',
|
||||
'-kind=unique', '-Warn=allocation', '-Warn=subnormal']
|
||||
else:
|
||||
return ['-g', '-nan', '-C=all', '-u', '-thread_safe']
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
compiler = customized_fcompiler(compiler='nagfor')
|
||||
print(compiler.get_version())
|
||||
print(compiler.get_flags_debug())
|
||||
@@ -0,0 +1,30 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
from numpy.distutils import customized_fcompiler
|
||||
|
||||
compilers = ['NoneFCompiler']
|
||||
|
||||
class NoneFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'none'
|
||||
description = 'Fake Fortran compiler'
|
||||
|
||||
executables = {'compiler_f77': None,
|
||||
'compiler_f90': None,
|
||||
'compiler_fix': None,
|
||||
'linker_so': None,
|
||||
'linker_exe': None,
|
||||
'archiver': None,
|
||||
'ranlib': None,
|
||||
'version_cmd': None,
|
||||
}
|
||||
|
||||
def find_executables(self):
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
print(customized_fcompiler(compiler='none').get_version())
|
||||
@@ -0,0 +1,35 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['PathScaleFCompiler']
|
||||
|
||||
class PathScaleFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'pathf95'
|
||||
description = 'PathScale Fortran Compiler'
|
||||
version_pattern = r'PathScale\(TM\) Compiler Suite: Version (?P<version>[\d.]+)'
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["pathf95", "-version"],
|
||||
'compiler_f77' : ["pathf95", "-fixedform"],
|
||||
'compiler_fix' : ["pathf95", "-fixedform"],
|
||||
'compiler_f90' : ["pathf95"],
|
||||
'linker_so' : ["pathf95", "-shared"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
pic_flags = ['-fPIC']
|
||||
module_dir_switch = '-module ' # Don't remove ending space!
|
||||
module_include_switch = '-I'
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['-O3']
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='pathf95').get_version())
|
||||
@@ -0,0 +1,141 @@
|
||||
# http://www.pgroup.com
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
from numpy.distutils.fcompiler import FCompiler, dummy_fortran_file
|
||||
from sys import platform
|
||||
from os.path import join, dirname, normpath
|
||||
|
||||
compilers = ['PGroupFCompiler', 'PGroupFlangCompiler']
|
||||
|
||||
|
||||
class PGroupFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'pg'
|
||||
description = 'Portland Group Fortran Compiler'
|
||||
version_pattern = r'\s*pg(f77|f90|hpf|fortran) (?P<version>[\d.-]+).*'
|
||||
|
||||
if platform == 'darwin':
|
||||
executables = {
|
||||
'version_cmd': ["<F77>", "-V"],
|
||||
'compiler_f77': ["pgfortran", "-dynamiclib"],
|
||||
'compiler_fix': ["pgfortran", "-Mfixed", "-dynamiclib"],
|
||||
'compiler_f90': ["pgfortran", "-dynamiclib"],
|
||||
'linker_so': ["libtool"],
|
||||
'archiver': ["ar", "-cr"],
|
||||
'ranlib': ["ranlib"]
|
||||
}
|
||||
pic_flags = ['']
|
||||
else:
|
||||
executables = {
|
||||
'version_cmd': ["<F77>", "-V"],
|
||||
'compiler_f77': ["pgfortran"],
|
||||
'compiler_fix': ["pgfortran", "-Mfixed"],
|
||||
'compiler_f90': ["pgfortran"],
|
||||
'linker_so': ["pgfortran", "-shared", "-fpic"],
|
||||
'archiver': ["ar", "-cr"],
|
||||
'ranlib': ["ranlib"]
|
||||
}
|
||||
pic_flags = ['-fpic']
|
||||
|
||||
module_dir_switch = '-module '
|
||||
module_include_switch = '-I'
|
||||
|
||||
def get_flags(self):
|
||||
opt = ['-Minform=inform', '-Mnosecond_underscore']
|
||||
return self.pic_flags + opt
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['-fast']
|
||||
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
if platform == 'darwin':
|
||||
def get_flags_linker_so(self):
|
||||
return ["-dynamic", '-undefined', 'dynamic_lookup']
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
return '-R"%s"' % dir
|
||||
|
||||
|
||||
if sys.version_info >= (3, 5):
|
||||
import subprocess
|
||||
import shlex
|
||||
import functools
|
||||
|
||||
class PGroupFlangCompiler(FCompiler):
|
||||
compiler_type = 'flang'
|
||||
description = 'Portland Group Fortran LLVM Compiler'
|
||||
version_pattern = r'\s*(flang|clang) version (?P<version>[\d.-]+).*'
|
||||
|
||||
ar_exe = 'lib.exe'
|
||||
possible_executables = ['flang']
|
||||
|
||||
executables = {
|
||||
'version_cmd': ["<F77>", "--version"],
|
||||
'compiler_f77': ["flang"],
|
||||
'compiler_fix': ["flang"],
|
||||
'compiler_f90': ["flang"],
|
||||
'linker_so': [None],
|
||||
'archiver': [ar_exe, "/verbose", "/OUT:"],
|
||||
'ranlib': None
|
||||
}
|
||||
|
||||
library_switch = '/OUT:' # No space after /OUT:!
|
||||
module_dir_switch = '-module ' # Don't remove ending space!
|
||||
|
||||
def get_libraries(self):
|
||||
opt = FCompiler.get_libraries(self)
|
||||
opt.extend(['flang', 'flangrti', 'ompstub'])
|
||||
return opt
|
||||
|
||||
@functools.lru_cache(maxsize=128)
|
||||
def get_library_dirs(self):
|
||||
"""List of compiler library directories."""
|
||||
opt = FCompiler.get_library_dirs(self)
|
||||
flang_dir = dirname(self.executables['compiler_f77'][0])
|
||||
opt.append(normpath(join(flang_dir, '..', 'lib')))
|
||||
|
||||
return opt
|
||||
|
||||
def get_flags(self):
|
||||
return []
|
||||
|
||||
def get_flags_free(self):
|
||||
return []
|
||||
|
||||
def get_flags_debug(self):
|
||||
return ['-g']
|
||||
|
||||
def get_flags_opt(self):
|
||||
return ['-O3']
|
||||
|
||||
def get_flags_arch(self):
|
||||
return []
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
raise NotImplementedError
|
||||
|
||||
else:
|
||||
from numpy.distutils.fcompiler import CompilerNotFound
|
||||
|
||||
# No point in supporting on older Pythons because not ABI compatible
|
||||
class PGroupFlangCompiler(FCompiler):
|
||||
compiler_type = 'flang'
|
||||
description = 'Portland Group Fortran LLVM Compiler'
|
||||
|
||||
def get_version(self):
|
||||
raise CompilerNotFound('Flang unsupported on Python < 3.5')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
if 'flang' in sys.argv:
|
||||
print(customized_fcompiler(compiler='flang').get_version())
|
||||
else:
|
||||
print(customized_fcompiler(compiler='pg').get_version())
|
||||
@@ -0,0 +1,53 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
from numpy.distutils.ccompiler import simple_version_match
|
||||
from numpy.distutils.fcompiler import FCompiler
|
||||
|
||||
compilers = ['SunFCompiler']
|
||||
|
||||
class SunFCompiler(FCompiler):
|
||||
|
||||
compiler_type = 'sun'
|
||||
description = 'Sun or Forte Fortran 95 Compiler'
|
||||
# ex:
|
||||
# f90: Sun WorkShop 6 update 2 Fortran 95 6.2 Patch 111690-10 2003/08/28
|
||||
version_match = simple_version_match(
|
||||
start=r'f9[05]: (Sun|Forte|WorkShop).*Fortran 95')
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["<F90>", "-V"],
|
||||
'compiler_f77' : ["f90"],
|
||||
'compiler_fix' : ["f90", "-fixed"],
|
||||
'compiler_f90' : ["f90"],
|
||||
'linker_so' : ["<F90>", "-Bdynamic", "-G"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
module_dir_switch = '-moddir='
|
||||
module_include_switch = '-M'
|
||||
pic_flags = ['-xcode=pic32']
|
||||
|
||||
def get_flags_f77(self):
|
||||
ret = ["-ftrap=%none"]
|
||||
if (self.get_version() or '') >= '7':
|
||||
ret.append("-f77")
|
||||
else:
|
||||
ret.append("-fixed")
|
||||
return ret
|
||||
def get_opt(self):
|
||||
return ['-fast', '-dalign']
|
||||
def get_arch(self):
|
||||
return ['-xtarget=generic']
|
||||
def get_libraries(self):
|
||||
opt = []
|
||||
opt.extend(['fsu', 'sunmath', 'mvec'])
|
||||
return opt
|
||||
|
||||
def runtime_library_dir_option(self, dir):
|
||||
return '-R"%s"' % dir
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='sun').get_version())
|
||||
@@ -0,0 +1,54 @@
|
||||
from __future__ import division, absolute_import, print_function
|
||||
|
||||
import os
|
||||
|
||||
from numpy.distutils.fcompiler.gnu import GnuFCompiler
|
||||
|
||||
compilers = ['VastFCompiler']
|
||||
|
||||
class VastFCompiler(GnuFCompiler):
|
||||
compiler_type = 'vast'
|
||||
compiler_aliases = ()
|
||||
description = 'Pacific-Sierra Research Fortran 90 Compiler'
|
||||
version_pattern = (r'\s*Pacific-Sierra Research vf90 '
|
||||
r'(Personal|Professional)\s+(?P<version>[^\s]*)')
|
||||
|
||||
# VAST f90 does not support -o with -c. So, object files are created
|
||||
# to the current directory and then moved to build directory
|
||||
object_switch = ' && function _mvfile { mv -v `basename $1` $1 ; } && _mvfile '
|
||||
|
||||
executables = {
|
||||
'version_cmd' : ["vf90", "-v"],
|
||||
'compiler_f77' : ["g77"],
|
||||
'compiler_fix' : ["f90", "-Wv,-ya"],
|
||||
'compiler_f90' : ["f90"],
|
||||
'linker_so' : ["<F90>"],
|
||||
'archiver' : ["ar", "-cr"],
|
||||
'ranlib' : ["ranlib"]
|
||||
}
|
||||
module_dir_switch = None #XXX Fix me
|
||||
module_include_switch = None #XXX Fix me
|
||||
|
||||
def find_executables(self):
|
||||
pass
|
||||
|
||||
def get_version_cmd(self):
|
||||
f90 = self.compiler_f90[0]
|
||||
d, b = os.path.split(f90)
|
||||
vf90 = os.path.join(d, 'v'+b)
|
||||
return vf90
|
||||
|
||||
def get_flags_arch(self):
|
||||
vast_version = self.get_version()
|
||||
gnu = GnuFCompiler()
|
||||
gnu.customize(None)
|
||||
self.version = gnu.get_version()
|
||||
opt = GnuFCompiler.get_flags_arch(self)
|
||||
self.version = vast_version
|
||||
return opt
|
||||
|
||||
if __name__ == '__main__':
|
||||
from distutils import log
|
||||
log.set_verbosity(2)
|
||||
from numpy.distutils import customized_fcompiler
|
||||
print(customized_fcompiler(compiler='vast').get_version())
|
||||
Reference in New Issue
Block a user