Moved scipy directory to numpy

15 files changed, 1870 insertions, 0 deletions

diff --git a/numpy/distutils/fcompiler/__init__.py b/numpy/distutils/fcompiler/__init__.py
new file mode 100644
index 000000000..f7cbc3bad
--- /dev/null
+++ b/numpy/distutils/fcompiler/__init__.py
@@ -0,0 +1,755 @@
+"""scipy.distutils.fcompiler
+
+Contains FCompiler, an abstract base class that defines the interface
+for the scipy.distutils Fortran compiler abstraction model.
+"""
+
+__all__ = ['FCompiler','new_fcompiler','show_fcompilers',
+           'dummy_fortran_file']
+
+import os
+import sys
+import re
+from types import StringType,NoneType
+from distutils.sysconfig import get_config_var
+from distutils.fancy_getopt import FancyGetopt
+from distutils.errors import DistutilsModuleError,DistutilsArgError,\
+     DistutilsExecError,CompileError,LinkError,DistutilsPlatformError
+from distutils.util import split_quoted
+
+from scipy.distutils.ccompiler import CCompiler, gen_lib_options
+from scipy.distutils import log
+from scipy.distutils.command.config_compiler import config_fc
+from distutils.spawn import _nt_quote_args
+
+class FCompiler(CCompiler):
+    """ Abstract base class to define the interface that must be implemented
+    by real Fortran compiler classes.
+
+    Methods that subclasses may redefine:
+
+        get_version_cmd(), get_linker_so(), get_version()
+        get_flags(), get_flags_opt(), get_flags_arch(), get_flags_debug()
+        get_flags_f77(), get_flags_opt_f77(), get_flags_arch_f77(),
+        get_flags_debug_f77(), get_flags_f90(), get_flags_opt_f90(),
+        get_flags_arch_f90(), get_flags_debug_f90(),
+        get_flags_fix(), get_flags_linker_so(), get_flags_version()
+
+    DON'T call these methods (except get_version) after
+    constructing a compiler instance or inside any other method.
+    All methods, except get_version_cmd() and get_flags_version(), may
+    call get_version() method.
+
+    After constructing a compiler instance, always call customize(dist=None)
+    method that finalizes compiler construction and makes the following
+    attributes available:
+      compiler_f77
+      compiler_f90
+      compiler_fix
+      linker_so
+      archiver
+      ranlib
+      libraries
+      library_dirs
+    """
+
+
+    language_map = {'.f':'f77',
+                    '.for':'f77',
+                    '.F':'f77',    # XXX: needs preprocessor
+                    '.ftn':'f77',
+                    '.f77':'f77',
+                    '.f90':'f90',
+                    '.F90':'f90',  # XXX: needs preprocessor
+                    '.f95':'f90',
+                    }
+    language_order = ['f90','f77']
+
+    version_pattern = None
+
+    executables = {
+        'version_cmd'  : ["f77","-v"],
+        'compiler_f77' : ["f77"],
+        'compiler_f90' : ["f90"],
+        'compiler_fix' : ["f90","-fixed"],
+        'linker_so'    : ["f90","-shared"],
+        'linker_exe'   : ["f90"],
+        'archiver'     : ["ar","-cr"],
+        'ranlib'       : None,
+        }
+
+    compile_switch = "-c"
+    object_switch = "-o "   # Ending space matters! It will be stripped
+                            # but if it is missing then object_switch
+                            # will be prefixed to object file name by
+                            # string concatenation.
+    library_switch = "-o "  # Ditto!
+
+    # Switch to specify where module files are created and searched
+    # for USE statement.  Normally it is a string and also here ending
+    # space matters. See above.
+    module_dir_switch = None
+
+    # Switch to specify where module files are searched for USE statement.
+    module_include_switch = '-I' 
+
+    pic_flags = []           # Flags to create position-independent code
+
+    src_extensions = ['.for','.ftn','.f77','.f','.f90','.f95','.F','.F90']
+    obj_extension = ".o"
+    shared_lib_extension = get_config_var('SO')  # or .dll
+    static_lib_extension = ".a"  # or .lib
+    static_lib_format = "lib%s%s" # or %s%s
+    shared_lib_format = "%s%s"
+    exe_extension = ""
+
+    ######################################################################
+    ## Methods that subclasses may redefine. But don't call these methods!
+    ## They are private to FCompiler class and may return unexpected
+    ## results if used elsewhere. So, you have been warned..
+
+    def get_version_cmd(self):
+        """ Compiler command to print out version information. """
+        f77 = self.executables['compiler_f77']
+        if f77 is not None:
+            f77 = f77[0]
+        cmd = self.executables['version_cmd']
+        if cmd is not None:
+            cmd = cmd[0]
+            if cmd==f77:
+                cmd = self.compiler_f77[0]
+            else:
+                f90 = self.executables['compiler_f90']
+                if f90 is not None:
+                    f90 = f90[0]
+                if cmd==f90:
+                    cmd = self.compiler_f90[0]
+        return cmd
+
+    def get_linker_so(self):
+        """ Linker command to build shared libraries. """
+        f77 = self.executables['compiler_f77']
+        if f77 is not None:
+            f77 = f77[0]
+        ln = self.executables['linker_so']
+        if ln is not None:
+            ln = ln[0]
+            if ln==f77:
+                ln = self.compiler_f77[0]
+            else:
+                f90 = self.executables['compiler_f90']
+                if f90 is not None:
+                    f90 = f90[0]
+                if ln==f90:
+                    ln = self.compiler_f90[0]
+        return ln
+
+    def get_linker_exe(self):
+        """ Linker command to build shared libraries. """
+        f77 = self.executables['compiler_f77']
+        if f77 is not None:
+            f77 = f77[0]
+        ln = self.executables.get('linker_exe')
+        if ln is not None:
+            ln = ln[0]
+            if ln==f77:
+                ln = self.compiler_f77[0]
+            else:
+                f90 = self.executables['compiler_f90']
+                if f90 is not None:
+                    f90 = f90[0]
+                if ln==f90:
+                    ln = self.compiler_f90[0]
+        return ln
+
+    def get_flags(self):
+        """ List of flags common to all compiler types. """
+        return [] + self.pic_flags
+    def get_flags_version(self):
+        """ List of compiler flags to print out version information. """
+        if self.executables['version_cmd']:
+            return self.executables['version_cmd'][1:]
+        return []
+    def get_flags_f77(self):
+        """ List of Fortran 77 specific flags. """
+        if self.executables['compiler_f77']:
+            return self.executables['compiler_f77'][1:]
+        return []
+    def get_flags_f90(self):
+        """ List of Fortran 90 specific flags. """
+        if self.executables['compiler_f90']:
+            return self.executables['compiler_f90'][1:]
+        return []
+    def get_flags_free(self):
+        """ List of Fortran 90 free format specific flags. """
+        return []
+    def get_flags_fix(self):
+        """ List of Fortran 90 fixed format specific flags. """
+        if self.executables['compiler_fix']:
+            return self.executables['compiler_fix'][1:]
+        return []
+    def get_flags_linker_so(self):
+        """ List of linker flags to build a shared library. """
+        if self.executables['linker_so']:
+            return self.executables['linker_so'][1:]
+        return []
+    def get_flags_linker_exe(self):
+        """ List of linker flags to build an executable. """
+        if self.executables['linker_exe']:
+            return self.executables['linker_exe'][1:]
+        return []
+    def get_flags_ar(self):
+        """ List of archiver flags. """
+        if self.executables['archiver']:
+            return self.executables['archiver'][1:]
+        return []
+    def get_flags_opt(self):
+        """ List of architecture independent compiler flags. """
+        return []
+    def get_flags_arch(self):
+        """ List of architecture dependent compiler flags. """
+        return []
+    def get_flags_debug(self):
+        """ List of compiler flags to compile with debugging information. """
+        return []
+
+    get_flags_opt_f77 = get_flags_opt_f90 = get_flags_opt
+    get_flags_arch_f77 = get_flags_arch_f90 = get_flags_arch
+    get_flags_debug_f77 = get_flags_debug_f90 = get_flags_debug
+
+    def get_libraries(self):
+        """ List of compiler libraries. """
+        return self.libraries[:]
+    def get_library_dirs(self):
+        """ List of compiler library directories. """
+        return self.library_dirs[:]
+
+    ############################################################
+
+    ## Public methods:
+
+    def customize(self, dist=None):
+        """ Customize Fortran compiler.
+
+        This method gets Fortran compiler specific information from
+        (i) class definition, (ii) environment, (iii) distutils config
+        files, and (iv) command line.
+
+        This method should be always called after constructing a
+        compiler instance. But not in __init__ because Distribution
+        instance is needed for (iii) and (iv).
+        """
+        log.info('customize %s' % (self.__class__.__name__))
+        if dist is None:
+            # These hooks are for testing only!
+            from distutils.dist import Distribution
+            dist = Distribution()
+            dist.script_name = os.path.basename(sys.argv[0])
+            dist.script_args = ['config_fc'] + sys.argv[1:]
+            dist.cmdclass['config_fc'] = config_fc
+            dist.parse_config_files()
+            dist.parse_command_line()
+        conf = dist.get_option_dict('config_fc')
+        noopt = conf.get('noopt',[None,0])[1]
+        if 0: # change to `if 1:` when making release.
+            # Don't use architecture dependent compiler flags:
+            noarch = 1
+        else:
+            noarch = conf.get('noarch',[None,noopt])[1]
+        debug = conf.get('debug',[None,0])[1]
+
+
+        f77 = self.__get_cmd('compiler_f77','F77',(conf,'f77exec'))
+        f90 = self.__get_cmd('compiler_f90','F90',(conf,'f90exec'))
+        # Temporarily setting f77,f90 compilers so that
+        # version_cmd can use their executables.
+        if f77:
+            self.set_executables(compiler_f77=[f77])
+        if f90:
+            self.set_executables(compiler_f90=[f90])
+
+        # Must set version_cmd before others as self.get_flags*
+        # methods may call self.get_version.
+        vers_cmd = self.__get_cmd(self.get_version_cmd)
+        if vers_cmd:
+            vflags = self.__get_flags(self.get_flags_version)
+            self.set_executables(version_cmd=[vers_cmd]+vflags)
+
+        if f77:
+            f77flags = self.__get_flags(self.get_flags_f77,'F77FLAGS',
+                                   (conf,'f77flags'))
+        if f90:
+            f90flags = self.__get_flags(self.get_flags_f90,'F90FLAGS',
+                                       (conf,'f90flags'))
+            freeflags = self.__get_flags(self.get_flags_free,'FREEFLAGS',
+                                         (conf,'freeflags'))
+        # XXX Assuming that free format is default for f90 compiler.
+        fix = self.__get_cmd('compiler_fix','F90',(conf,'f90exec'))
+        if fix:
+            fixflags = self.__get_flags(self.get_flags_fix) + f90flags
+
+        oflags,aflags,dflags = [],[],[]
+        if not noopt:
+            oflags = self.__get_flags(self.get_flags_opt,'FOPT',(conf,'opt'))
+            if f77 and self.get_flags_opt is not self.get_flags_opt_f77:
+                f77flags += self.__get_flags(self.get_flags_opt_f77)
+            if f90 and self.get_flags_opt is not self.get_flags_opt_f90:
+                f90flags += self.__get_flags(self.get_flags_opt_f90)
+            if fix and self.get_flags_opt is not self.get_flags_opt_f90:
+                fixflags += self.__get_flags(self.get_flags_opt_f90)
+            if not noarch:
+                aflags = self.__get_flags(self.get_flags_arch,'FARCH',
+                                          (conf,'arch'))
+                if f77 and self.get_flags_arch is not self.get_flags_arch_f77:
+                    f77flags += self.__get_flags(self.get_flags_arch_f77)
+                if f90 and self.get_flags_arch is not self.get_flags_arch_f90:
+                    f90flags += self.__get_flags(self.get_flags_arch_f90)
+                if fix and self.get_flags_arch is not self.get_flags_arch_f90:
+                    fixflags += self.__get_flags(self.get_flags_arch_f90)
+        if debug:
+            dflags = self.__get_flags(self.get_flags_debug,'FDEBUG')
+            if f77  and self.get_flags_debug is not self.get_flags_debug_f77:
+                f77flags += self.__get_flags(self.get_flags_debug_f77)
+            if f90  and self.get_flags_debug is not self.get_flags_debug_f90:
+                f90flags += self.__get_flags(self.get_flags_debug_f90)
+            if fix and self.get_flags_debug is not self.get_flags_debug_f90:
+                fixflags += self.__get_flags(self.get_flags_debug_f90)
+
+        fflags = self.__get_flags(self.get_flags,'FFLAGS') \
+                 + dflags + oflags + aflags
+
+        if f77:
+            self.set_executables(compiler_f77=[f77]+f77flags+fflags)
+        if f90:
+            self.set_executables(compiler_f90=[f90]+freeflags+f90flags+fflags)
+        if fix:
+            self.set_executables(compiler_fix=[fix]+fixflags+fflags)
+        #XXX: Do we need LDSHARED->SOSHARED, LDFLAGS->SOFLAGS
+        linker_so = self.__get_cmd(self.get_linker_so,'LDSHARED')
+        if linker_so:
+            linker_so_flags = self.__get_flags(self.get_flags_linker_so,'LDFLAGS')
+            self.set_executables(linker_so=[linker_so]+linker_so_flags)
+
+        linker_exe = self.__get_cmd(self.get_linker_exe,'LD')
+        if linker_exe:
+            linker_exe_flags = self.__get_flags(self.get_flags_linker_exe,'LDFLAGS')
+            self.set_executables(linker_exe=[linker_exe]+linker_exe_flags)
+        ar = self.__get_cmd('archiver','AR')
+        if ar:
+            arflags = self.__get_flags(self.get_flags_ar,'ARFLAGS')
+            self.set_executables(archiver=[ar]+arflags)
+
+        ranlib = self.__get_cmd('ranlib','RANLIB')
+        if ranlib:
+            self.set_executables(ranlib=[ranlib])
+
+        self.set_library_dirs(self.get_library_dirs())
+        self.set_libraries(self.get_libraries())
+
+
+        verbose = conf.get('verbose',[None,0])[1]
+        if verbose:
+            self.dump_properties()
+        return
+
+    def dump_properties(self):
+        """ Print out the attributes of a compiler instance. """
+        props = []
+        for key in self.executables.keys() + \
+                ['version','libraries','library_dirs',
+                 'object_switch','compile_switch']:
+            if hasattr(self,key):
+                v = getattr(self,key)
+                props.append((key, None, '= '+`v`))
+        props.sort()
+
+        pretty_printer = FancyGetopt(props)
+        for l in pretty_printer.generate_help("%s instance properties:" \
+                                              % (self.__class__.__name__)):
+            if l[:4]=='  --':
+                l = '  ' + l[4:]
+            print l
+        return
+
+    ###################
+
+    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
+        """Compile 'src' to product 'obj'."""
+        if is_f_file(src) and not has_f90_header(src):
+            flavor = ':f77'
+            compiler = self.compiler_f77
+        elif is_free_format(src):
+            flavor = ':f90'
+            compiler = self.compiler_f90
+            if compiler is None:
+                raise DistutilsExecError, 'f90 not supported by '\
+                      +self.__class__.__name__
+        else:
+            flavor = ':fix'
+            compiler = self.compiler_fix
+            if compiler is None:
+                raise DistutilsExecError, 'f90 (fixed) not supported by '\
+                      +self.__class__.__name__
+        if self.object_switch[-1]==' ':
+            o_args = [self.object_switch.strip(),obj]
+        else:
+            o_args = [self.object_switch.strip()+obj]
+
+        assert self.compile_switch.strip()
+        s_args = [self.compile_switch, src]
+
+        if os.name == 'nt':
+            compiler = _nt_quote_args(compiler)
+        command = compiler + cc_args + s_args + o_args + extra_postargs
+
+        display = '%s: %s' % (os.path.basename(compiler[0]) + flavor,
+                              src)
+        try:
+            self.spawn(command,display=display)
+        except DistutilsExecError, msg:
+            raise CompileError, msg
+
+        return
+
+    def module_options(self, module_dirs, module_build_dir):
+        options = []
+        if self.module_dir_switch is not None:
+            if self.module_dir_switch[-1]==' ':
+                options.extend([self.module_dir_switch.strip(),module_build_dir])
+            else:
+                options.append(self.module_dir_switch.strip()+module_build_dir)
+        else:
+            print 'XXX: module_build_dir=%r option ignored' % (module_build_dir)
+            print 'XXX: Fix module_dir_switch for ',self.__class__.__name__
+        if self.module_include_switch is not None:
+            for d in [module_build_dir]+module_dirs:
+                options.append('%s%s' % (self.module_include_switch, d))
+        else:
+            print 'XXX: module_dirs=%r option ignored' % (module_dirs)
+            print 'XXX: Fix module_include_switch for ',self.__class__.__name__
+        return options
+
+    def library_option(self, lib):
+        return "-l" + lib
+    def library_dir_option(self, dir):
+        return "-L" + dir
+
+    def link(self, target_desc, objects,
+             output_filename, output_dir=None, libraries=None,
+             library_dirs=None, runtime_library_dirs=None,
+             export_symbols=None, debug=0, extra_preargs=None,
+             extra_postargs=None, build_temp=None, target_lang=None):
+        objects, output_dir = self._fix_object_args(objects, output_dir)
+        libraries, library_dirs, runtime_library_dirs = \
+            self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
+
+        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
+                                   libraries)
+        if type(output_dir) not in (StringType, NoneType):
+            raise TypeError, "'output_dir' must be a string or None"
+        if output_dir is not None:
+            output_filename = os.path.join(output_dir, output_filename)
+
+        if self._need_link(objects, output_filename):
+            if self.library_switch[-1]==' ':
+                o_args = [self.library_switch.strip(),output_filename]
+            else:
+                o_args = [self.library_switch.strip()+output_filename]
+            
+            if type(self.objects) is type(''):
+                ld_args = objects + [self.objects]
+            else:
+                ld_args = objects + self.objects
+            ld_args = ld_args + lib_opts + o_args
+            if debug:
+                ld_args[:0] = ['-g']
+            if extra_preargs:
+                ld_args[:0] = extra_preargs
+            if extra_postargs:
+                ld_args.extend(extra_postargs)
+            self.mkpath(os.path.dirname(output_filename))
+            if target_desc == CCompiler.EXECUTABLE:
+                linker = self.linker_exe[:]
+            else:
+                linker = self.linker_so[:]
+            if os.name == 'nt':
+                linker = _nt_quote_args(linker)
+            command = linker + ld_args
+            try:
+                self.spawn(command)
+            except DistutilsExecError, msg:
+                raise LinkError, msg
+        else:
+            log.debug("skipping %s (up-to-date)", output_filename)
+        return
+
+
+    ## Private methods:
+
+    def __get_cmd(self, command, envvar=None, confvar=None):
+        if command is None:
+            var = None
+        elif type(command) is type(''):
+            var = self.executables[command]
+            if var is not None:
+                var = var[0]
+        else:
+            var = command()
+        if envvar is not None:
+            var = os.environ.get(envvar, var)
+        if confvar is not None:
+            var = confvar[0].get(confvar[1], [None,var])[1]
+        return var
+
+    def __get_flags(self, command, envvar=None, confvar=None):
+        if command is None:
+            var = []
+        elif type(command) is type(''):
+            var = self.executables[command][1:]
+        else:
+            var = command()
+        if envvar is not None:
+            var = os.environ.get(envvar, var)
+        if confvar is not None:
+            var = confvar[0].get(confvar[1], [None,var])[1]
+        if type(var) is type(''):
+            var = split_quoted(var)
+        return var
+
+    ## class FCompiler
+
+fcompiler_class = {'gnu':('gnu','GnuFCompiler',
+                          "GNU Fortran Compiler"),
+                   'gnu95':('gnu','Gnu95FCompiler',
+                            "GNU 95 Fortran Compiler"),
+                   'g95':('g95','G95FCompiler',
+                          "GNU Fortran 95 Compiler"),
+                   'pg':('pg','PGroupFCompiler',
+                         "Portland Group Fortran Compiler"),
+                   'absoft':('absoft','AbsoftFCompiler',
+                             "Absoft Corp Fortran Compiler"),
+                   'mips':('mips','MipsFCompiler',
+                           "MIPSpro Fortran Compiler"),
+                   'sun':('sun','SunFCompiler',
+                          "Sun|Forte Fortran 95 Compiler"),
+                   'intel':('intel','IntelFCompiler',
+                            "Intel Fortran Compiler for 32-bit apps"),
+                   'intelv':('intel','IntelVisualFCompiler',
+                             "Intel Visual Fortran Compiler for 32-bit apps"),
+                   'intele':('intel','IntelItaniumFCompiler',
+                             "Intel Fortran Compiler for Itanium apps"),
+                   'intelev':('intel','IntelItaniumVisualFCompiler',
+                              "Intel Visual Fortran Compiler for Itanium apps"),
+                   'nag':('nag','NAGFCompiler',
+                          "NAGWare Fortran 95 Compiler"),
+                   'compaq':('compaq','CompaqFCompiler',
+                             "Compaq Fortran Compiler"),
+                   'compaqv':('compaq','CompaqVisualFCompiler',
+                             "DIGITAL|Compaq Visual Fortran Compiler"),
+                   'vast':('vast','VastFCompiler',
+                           "Pacific-Sierra Research Fortran 90 Compiler"),
+                   'hpux':('hpux','HPUXFCompiler',
+                           "HP Fortran 90 Compiler"),
+                   'lahey':('lahey','LaheyFCompiler',
+                            "Lahey/Fujitsu Fortran 95 Compiler"),
+                   'ibm':('ibm','IbmFCompiler',
+                          "IBM XL Fortran Compiler"),
+                   'f':('f','FFCompiler',
+                        "Fortran Company/NAG F Compiler"),
+                   'none':('none','NoneFCompiler',"Fake Fortran compiler")
+                   }
+
+_default_compilers = (
+    # Platform mappings
+    ('win32',('gnu','intelv','absoft','compaqv','intelev','gnu95','g95')),
+    ('cygwin.*',('gnu','intelv','absoft','compaqv','intelev','gnu95','g95')),
+    ('linux.*',('gnu','intel','lahey','pg','absoft','nag','vast','compaq',
+                'intele','gnu95','g95')),
+    ('darwin.*',('nag','absoft','ibm','gnu','gnu95','g95')),
+    ('sunos.*',('sun','gnu','gnu95','g95')),
+    ('irix.*',('mips','gnu','gnu95',)),
+    ('aix.*',('ibm','gnu','gnu95',)),
+    # OS mappings
+    ('posix',('gnu','gnu95',)),
+    ('nt',('gnu','gnu95',)),
+    ('mac',('gnu','gnu95',)),
+    )
+
+def _find_existing_fcompiler(compilers, osname=None, platform=None):
+    for compiler in compilers:
+        v = None
+        try:
+            c = new_fcompiler(plat=platform, compiler=compiler)
+            c.customize()
+            v = c.get_version()
+        except DistutilsModuleError:
+            pass
+        except Exception, msg:
+            log.warn(msg)
+        if v is not None:
+            return compiler
+    return
+
+def get_default_fcompiler(osname=None, platform=None):
+    """ Determine the default Fortran compiler to use for the given platform. """
+    if osname is None:
+        osname = os.name
+    if platform is None:
+        platform = sys.platform
+    matching_compilers = []
+    for pattern, compiler in _default_compilers:
+        if re.match(pattern, platform) is not None or \
+               re.match(pattern, osname) is not None:
+            if type(compiler) is type(()):
+                matching_compilers.extend(list(compiler))
+            else:
+                matching_compilers.append(compiler)
+    if not matching_compilers:
+        matching_compilers.append('gnu')
+    compiler =  _find_existing_fcompiler(matching_compilers,
+                                         osname=osname,
+                                         platform=platform)
+    if compiler is not None:
+        return compiler
+    return matching_compilers[0]
+
+def new_fcompiler(plat=None,
+                  compiler=None,
+                  verbose=0,
+                  dry_run=0,
+                  force=0):
+    """ Generate an instance of some FCompiler subclass for the supplied
+    platform/compiler combination.
+    """
+    if plat is None:
+        plat = os.name
+    try:
+        if compiler is None:
+            compiler = get_default_fcompiler(plat)
+        (module_name, class_name, long_description) = fcompiler_class[compiler]
+    except KeyError:
+        msg = "don't know how to compile Fortran code on platform '%s'" % plat
+        if compiler is not None:
+            msg = msg + " with '%s' compiler." % compiler
+            msg = msg + " Supported compilers are: %s)" \
+                  % (','.join(fcompiler_class.keys()))
+        raise DistutilsPlatformError, msg
+
+    try:
+        module_name = 'scipy.distutils.fcompiler.'+module_name
+        __import__ (module_name)
+        module = sys.modules[module_name]
+        klass = vars(module)[class_name]
+    except ImportError:
+        raise DistutilsModuleError, \
+              "can't compile Fortran code: unable to load module '%s'" % \
+              module_name
+    except KeyError:
+        raise DistutilsModuleError, \
+              ("can't compile Fortran code: unable to find class '%s' " +
+               "in module '%s'") % (class_name, module_name)
+    compiler = klass(None, dry_run, force)
+    log.debug('new_fcompiler returns %s' % (klass))
+    return compiler
+
+def show_fcompilers(dist = None):
+    """ Print list of available compilers (used by the "--help-fcompiler"
+    option to "config_fc").
+    """
+    if dist is None:
+        from distutils.dist import Distribution
+        dist = Distribution()
+        dist.script_name = os.path.basename(sys.argv[0])
+        dist.script_args = ['config_fc'] + sys.argv[1:]
+        dist.cmdclass['config_fc'] = config_fc
+        dist.parse_config_files()
+        dist.parse_command_line()
+
+    compilers = []
+    compilers_na = []
+    compilers_ni = []
+    for compiler in fcompiler_class.keys():
+        v = 'N/A'
+        try:
+            c = new_fcompiler(compiler=compiler)
+            c.customize(dist)
+            v = c.get_version()
+        except DistutilsModuleError:
+            pass
+        except Exception, msg:
+            log.warn(msg)
+        if v is None:
+            compilers_na.append(("fcompiler="+compiler, None,
+                              fcompiler_class[compiler][2]))
+        elif v=='N/A':
+            compilers_ni.append(("fcompiler="+compiler, None,
+                                 fcompiler_class[compiler][2]))
+        else:
+            compilers.append(("fcompiler="+compiler, None,
+                              fcompiler_class[compiler][2] + ' (%s)' % v))
+
+    compilers.sort()
+    compilers_na.sort()
+    pretty_printer = FancyGetopt(compilers)
+    pretty_printer.print_help("List of available Fortran compilers:")
+    pretty_printer = FancyGetopt(compilers_na)
+    pretty_printer.print_help("List of unavailable Fortran compilers:")
+    if compilers_ni:
+        pretty_printer = FancyGetopt(compilers_ni)
+        pretty_printer.print_help("List of unimplemented Fortran compilers:")
+    print "For compiler details, run 'config_fc --verbose' setup command."
+
+def dummy_fortran_file():
+    import atexit
+    import tempfile
+    dummy_name = tempfile.mktemp()+'__dummy'
+    dummy = open(dummy_name+'.f','w')
+    dummy.write("      subroutine dummy()\n      end\n")
+    dummy.close()
+    def rm_file(name=dummy_name,log_threshold=log._global_log.threshold):
+        save_th = log._global_log.threshold
+        log.set_threshold(log_threshold)
+        try: os.remove(name+'.f'); log.debug('removed '+name+'.f')
+        except OSError: pass
+        try: os.remove(name+'.o'); log.debug('removed '+name+'.o')
+        except OSError: pass
+        log.set_threshold(save_th)
+    atexit.register(rm_file)
+    return dummy_name
+
+is_f_file = re.compile(r'.*[.](for|ftn|f77|f)\Z',re.I).match
+_has_f_header = re.compile(r'-[*]-\s*fortran\s*-[*]-',re.I).search
+_has_f90_header = re.compile(r'-[*]-\s*f90\s*-[*]-',re.I).search
+_has_fix_header = re.compile(r'-[*]-\s*fix\s*-[*]-',re.I).search
+_free_f90_start = re.compile(r'[^c*]\s*[^\s\d\t]',re.I).match
+def is_free_format(file):
+    """Check if file is in free format Fortran."""
+    # f90 allows both fixed and free format, assuming fixed unless
+    # signs of free format are detected.
+    result = 0
+    f = open(file,'r')
+    line = f.readline()
+    n = 15 # the number of non-comment lines to scan for hints
+    if _has_f_header(line):
+        n = 0
+    elif _has_f90_header(line):
+        n = 0
+        result = 1
+    while n>0 and line:
+        if line[0]!='!':
+            n -= 1
+            if (line[0]!='\t' and _free_f90_start(line[:5])) or line[-2:-1]=='&':
+                result = 1
+                break
+        line = f.readline()
+    f.close()
+    return result
+
+def has_f90_header(src):
+    f = open(src,'r')
+    line = f.readline()
+    f.close()
+    return _has_f90_header(line) or _has_fix_header(line)
+
+if __name__ == '__main__':
+    show_fcompilers()
diff --git a/numpy/distutils/fcompiler/absoft.py b/numpy/distutils/fcompiler/absoft.py
new file mode 100644
index 000000000..51c3548db
--- /dev/null
+++ b/numpy/distutils/fcompiler/absoft.py
@@ -0,0 +1,137 @@
+
+# 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)
+
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler, dummy_fortran_file
+from scipy.distutils.misc_util import cyg2win32
+
+class AbsoftFCompiler(FCompiler):
+
+    compiler_type = 'absoft'
+    #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))'+\
+                       r' (?P<version>[^\s*,]*)(.*?Absoft Corp|)'
+
+    # 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'  : ["f90", "-V -c %(fname)s.f -o %(fname)s.o" \
+                          % {'fname':cyg2win32(dummy_fortran_file())}],
+        '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 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:
+            opt.append(os.path.join(d,'lib'))
+        return opt
+
+    def get_libraries(self):
+        opt = FCompiler.get_libraries(self)
+        if 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 scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='absoft')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/compaq.py b/numpy/distutils/fcompiler/compaq.py
new file mode 100644
index 000000000..7abb23ae2
--- /dev/null
+++ b/numpy/distutils/fcompiler/compaq.py
@@ -0,0 +1,94 @@
+
+#http://www.compaq.com/fortran/docs/
+
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class CompaqFCompiler(FCompiler):
+
+    compiler_type = 'compaq'
+    version_pattern = r'Compaq Fortran (?P<version>[^\s]*).*'
+
+    if sys.platform[:5]=='linux':
+        fc_exe = 'fort'
+    else:
+        fc_exe = 'f90'
+
+    executables = {
+        'version_cmd'  : [fc_exe, "-version"],
+        'compiler_f77' : [fc_exe, "-f77rtl","-fixed"],
+        'compiler_fix' : [fc_exe, "-fixed"],
+        'compiler_f90' : [fc_exe],
+        'linker_so'    : [fc_exe],
+        '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'
+    version_pattern = r'(DIGITAL|Compaq) Visual Fortran Optimizing Compiler'\
+                      ' 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 distutils.msvccompiler import MSVCCompiler
+        ar_exe = MSVCCompiler().lib
+
+    executables = {
+        'version_cmd'  : ['DF', "/what"],
+        'compiler_f77' : ['DF', "/f77rtl","/fixed"],
+        'compiler_fix' : ['DF', "/fixed"],
+        'compiler_f90' : ['DF'],
+        'linker_so'    : ['DF'],
+        '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 fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='compaq')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/g95.py b/numpy/distutils/fcompiler/g95.py
new file mode 100644
index 000000000..a3bf374a8
--- /dev/null
+++ b/numpy/distutils/fcompiler/g95.py
@@ -0,0 +1,41 @@
+# http://g95.sourceforge.net/
+
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class G95FCompiler(FCompiler):
+
+    compiler_type = 'g95'
+    version_pattern = r'G95.*\(experimental\) \(g95!\) (?P<version>.*)\).*'
+
+    executables = {
+        'version_cmd'  : ["g95", "--version"],
+        'compiler_f77' : ["g95", "-ffixed-form"],
+        'compiler_fix' : ["g95", "-ffixed-form"],
+        'compiler_f90' : ["g95"],
+        'linker_so'    : ["g95","-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
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    #compiler = new_fcompiler(compiler='g95')
+    compiler = G95FCompiler()
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/gnu.py b/numpy/distutils/fcompiler/gnu.py
new file mode 100644
index 000000000..b0072571f
--- /dev/null
+++ b/numpy/distutils/fcompiler/gnu.py
@@ -0,0 +1,244 @@
+
+import re
+import os
+import sys
+import warnings
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+from scipy.distutils.exec_command import exec_command, find_executable
+
+class GnuFCompiler(FCompiler):
+
+    compiler_type = 'gnu'
+    version_pattern = r'GNU Fortran ((\(GCC[^\)]*(\)\)|\)))|)\s*'\
+                      '(?P<version>[^\s*\)]+)'
+
+    # 'g77 --version' results
+    # SunOS: GNU Fortran (GCC 3.2) 3.2 20020814 (release)
+    # Debian: GNU Fortran (GCC) 3.3.3 20040110 (prerelease) (Debian)
+    #         GNU Fortran (GCC) 3.3.3 (Debian 20040401)
+    #         GNU Fortran 0.5.25 20010319 (prerelease)
+    # Redhat: GNU Fortran (GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)) 3.2.2 20030222 (Red Hat Linux 3.2.2-5)
+
+    for fc_exe in map(find_executable,['g77','f77']):
+        if os.path.isfile(fc_exe):
+            break
+    executables = {
+        'version_cmd'  : [fc_exe,"--version"],
+        'compiler_f77' : [fc_exe,"-Wall","-fno-second-underscore"],
+        'compiler_f90' : None,
+        'compiler_fix' : None,
+        'linker_so'    : [fc_exe,"-Wall"],
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"],
+        'linker_exe'   : [fc_exe,"-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']
+
+    g2c = 'g2c'
+
+    #def get_linker_so(self):
+    #    # win32 linking should be handled by standard linker
+    #    # Darwin g77 cannot be used as a linker.
+    #    #if re.match(r'(darwin)', sys.platform):
+    #    #    return
+    #    return FCompiler.get_linker_so(self)
+
+    def get_flags_linker_so(self):
+        opt = []
+        if sys.platform=='darwin':
+            target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', None)
+            if target is None:
+                target = '10.3'
+            major, minor = target.split('.')
+            if int(minor) < 3:
+                minor = '3'
+                warnings.warn('Environment variable ' 
+                    'MACOSX_DEPLOYMENT_TARGET reset to 10.3')
+            os.environ['MACOSX_DEPLOYMENT_TARGET'] = '%s.%s' % (major,
+                minor)
+            
+            opt.extend(['-undefined', 'dynamic_lookup', '-bundle'])
+        else:
+            opt.append("-shared")
+        if sys.platform[:5]=='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('%s -print-libgcc-file-name' \
+                                      % (self.compiler_f77[0]),use_tee=0)        
+        if not status:
+            return os.path.dirname(output)
+        return
+
+    def get_library_dirs(self):
+        opt = []
+        if sys.platform[:5] != 'linux':
+            d = self.get_libgcc_dir()
+            if d:
+                opt.append(d)
+        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 sys.platform=='win32':
+            opt.append('gcc')
+        if g2c is not None:
+            opt.append(g2c)
+        if sys.platform == 'darwin':
+            opt.append('cc_dynamic')
+        return opt
+
+    def get_flags_debug(self):
+        return ['-g']
+
+    def get_flags_opt(self):
+        if self.get_version()<='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 get_flags_arch(self):
+        opt = []
+        if sys.platform=='darwin':
+            if os.name != 'posix':
+                # this should presumably correspond to Apple
+                if cpu.is_ppc():
+                    opt.append('-arch ppc')
+                elif cpu.is_i386():
+                    opt.append('-arch i386')
+            for a in '601 602 603 603e 604 604e 620 630 740 7400 7450 750'\
+                    '403 505 801 821 823 860'.split():
+                if getattr(cpu,'is_ppc%s'%a)():
+                    opt.append('-mcpu='+a)
+                    opt.append('-mtune='+a)
+                    break    
+            return opt
+        march_flag = 1
+        # 0.5.25 corresponds to 2.95.x
+        if self.get_version() == '0.5.26': # gcc 3.0
+            if cpu.is_AthlonK6():
+                opt.append('-march=k6')
+            elif cpu.is_AthlonK7():
+                opt.append('-march=athlon')
+            else:
+                march_flag = 0
+        # Note: gcc 3.2 on win32 has breakage with -march specified
+        elif self.get_version() >= '3.1.1' \
+            and not sys.platform=='win32': # gcc >= 3.1.1
+            if cpu.is_AthlonK6():
+                opt.append('-march=k6')
+            elif cpu.is_AthlonK6_2():
+                opt.append('-march=k6-2')
+            elif cpu.is_AthlonK6_3():
+                opt.append('-march=k6-3')
+            elif cpu.is_AthlonK7():
+                opt.append('-march=athlon')
+            elif cpu.is_AthlonMP():
+                opt.append('-march=athlon-mp')
+                # there's also: athlon-tbird, athlon-4, athlon-xp
+            elif cpu.is_Nocona():
+                opt.append('-march=nocona')
+            elif cpu.is_Prescott():
+                opt.append('-march=prescott')
+            elif cpu.is_PentiumIV():
+                opt.append('-march=pentium4')
+            elif cpu.is_PentiumIII():
+                opt.append('-march=pentium3')
+            elif cpu.is_PentiumII():
+                opt.append('-march=pentium2')
+            else:
+                march_flag = 0
+            if self.get_version() >= '3.4' and not march_flag:
+                march_flag = 1
+                if cpu.is_Opteron():
+                    opt.append('-march=opteron')
+                elif cpu.is_Athlon64():
+                    opt.append('-march=athlon64')
+                else:
+                    march_flag = 0
+            if cpu.has_mmx(): opt.append('-mmmx')      
+            if self.get_version() > '3.2.2':
+                if cpu.has_sse2(): opt.append('-msse2')
+                if cpu.has_sse(): opt.append('-msse')
+            if self.get_version() >= '3.4':
+                if cpu.has_sse3(): opt.append('-msse3')
+            if cpu.has_3dnow(): opt.append('-m3dnow')
+        else:
+            march_flag = 0
+        if march_flag:
+            pass
+        elif cpu.is_i686():
+            opt.append('-march=i686')
+        elif cpu.is_i586():
+            opt.append('-march=i586')
+        elif cpu.is_i486():
+            opt.append('-march=i486')
+        elif cpu.is_i386():
+            opt.append('-march=i386')
+        if cpu.is_Intel():
+            opt.append('-fomit-frame-pointer')
+            if cpu.is_32bit():
+                opt.append('-malign-double')
+        return opt
+
+class Gnu95FCompiler(GnuFCompiler):
+
+    compiler_type = 'gnu95'
+    version_pattern = r'GNU Fortran 95 \(GCC (?P<version>[^\s*\)]+)'
+
+    # 'gfortran --version' results:
+    # Debian: GNU Fortran 95 (GCC 4.0.3 20051023 (prerelease) (Debian 4.0.2-3))
+
+    for fc_exe in map(find_executable,['gfortran','f95']):
+        if os.path.isfile(fc_exe):
+            break
+    executables = {
+        'version_cmd'  : [fc_exe,"--version"],
+        'compiler_f77' : [fc_exe,"-Wall","-ffixed-form","-fno-second-underscore"],
+        'compiler_f90' : [fc_exe,"-Wall","-fno-second-underscore"],
+        'compiler_fix' : [fc_exe,"-Wall","-ffixed-form","-fno-second-underscore"],
+        'linker_so'    : [fc_exe,"-Wall"],
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"],
+        'linker_exe'   : [fc_exe,"-Wall"]
+        }
+    module_dir_switch = '-M'
+    module_include_switch = '-I'
+
+    g2c = 'gfortran'
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    #compiler = new_fcompiler(compiler='gnu')
+    compiler = GnuFCompiler()
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/hpux.py b/numpy/distutils/fcompiler/hpux.py
new file mode 100644
index 000000000..95f326cea
--- /dev/null
+++ b/numpy/distutils/fcompiler/hpux.py
@@ -0,0 +1,41 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class HPUXFCompiler(FCompiler):
+
+    compiler_type = 'hpux'
+    version_pattern =  r'HP F90 (?P<version>[^\s*,]*)'
+
+    executables = {
+        'version_cmd'  : ["f90", "+version"],
+        'compiler_f77' : ["f90"],
+        'compiler_fix' : ["f90"],
+        'compiler_f90' : ["f90"],
+        'linker_so'    : None,
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"]
+        }
+    module_dir_switch = None #XXX: fix me
+    module_include_switch = None #XXX: fix me
+    pic_flags = ['+pic=long']
+    def get_flags(self):
+        return self.pic_flags + ['+ppu']
+    def get_flags_opt(self):
+        return ['-O3']
+    def get_libraries(self):
+        return ['m']
+    def get_version(self, force=0, ok_status=[256,0]):
+        # 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 scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='hpux')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/ibm.py b/numpy/distutils/fcompiler/ibm.py
new file mode 100644
index 000000000..5fc59d1e6
--- /dev/null
+++ b/numpy/distutils/fcompiler/ibm.py
@@ -0,0 +1,80 @@
+import os
+import re
+import sys
+
+from scipy.distutils.fcompiler import FCompiler
+from distutils import log
+
+class IbmFCompiler(FCompiler):
+
+    compiler_type = 'ibm'
+    version_pattern =  r'xlf\(1\)\s*IBM XL Fortran (Advanced Edition |)Version (?P<version>[^\s*]*)'
+
+    executables = {
+        'version_cmd'  : ["xlf"],
+        '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)
+        xlf_dir = '/etc/opt/ibmcmp/xlf'
+        if version is None and os.path.isdir(xlf_dir):
+            # 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 = os.listdir(xlf_dir)
+            l.sort()
+            l.reverse()
+            l = [d for d in l if os.path.isfile(os.path.join(xlf_dir,d,'xlf.cfg'))]
+            if not 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:
+            import tempfile
+            xlf_cfg = '/etc/opt/ibmcmp/xlf/%s/xlf.cfg' % version
+            new_cfg = tempfile.mktemp()+'_xlf.cfg'
+            log.info('Creating '+new_cfg)
+            fi = open(xlf_cfg,'r')
+            fo = open(new_cfg,'w')
+            crt1_match = re.compile(r'\s*crt\s*[=]\s*(?P<path>.*)/crt1.o').match
+            for line in fi.readlines():
+                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 ['-O5']
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='ibm')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/intel.py b/numpy/distutils/fcompiler/intel.py
new file mode 100644
index 000000000..0e7375943
--- /dev/null
+++ b/numpy/distutils/fcompiler/intel.py
@@ -0,0 +1,174 @@
+# http://developer.intel.com/software/products/compilers/flin/
+
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler, dummy_fortran_file
+from scipy.distutils.exec_command import find_executable
+
+class IntelFCompiler(FCompiler):
+
+    compiler_type = 'intel'
+    version_pattern = r'Intel\(R\) Fortran Compiler for 32-bit '\
+                      'applications, Version (?P<version>[^\s*]*)'
+
+    for fc_exe in map(find_executable,['ifort','ifc']):
+        if os.path.isfile(fc_exe):
+            break
+
+    executables = {
+        'version_cmd'  : [fc_exe, "-FI -V -c %(fname)s.f -o %(fname)s.o" \
+                          % {'fname':dummy_fortran_file()}],
+        'compiler_f77' : [fc_exe,"-72","-w90","-w95"],
+        'compiler_fix' : [fc_exe,"-FI"],
+        'compiler_f90' : [fc_exe],
+        'linker_so'    : [fc_exe,"-shared"],
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"]
+        }
+
+    pic_flags = ['-KPIC']
+    module_dir_switch = '-module ' # Don't remove ending space!
+    module_include_switch = '-I'
+
+    def get_flags(self):
+        opt = self.pic_flags + ["-cm"]
+        return opt
+
+    def get_flags_free(self):
+        return ["-FR"]
+
+    def get_flags_opt(self):
+        return ['-O3','-unroll']
+
+    def get_flags_arch(self):
+        opt = []
+        if cpu.has_fdiv_bug():
+            opt.append('-fdiv_check')
+        if cpu.has_f00f_bug():
+            opt.append('-0f_check')
+        if cpu.is_PentiumPro() or cpu.is_PentiumII():
+            opt.extend(['-tpp6','-xi'])
+        elif cpu.is_PentiumIII():
+            opt.append('-tpp6')
+        elif cpu.is_Pentium():
+            opt.append('-tpp5')
+        elif cpu.is_PentiumIV() or cpu.is_XEON():
+            opt.extend(['-tpp7','-xW'])
+        if cpu.has_mmx():
+            opt.append('-xM')
+        return opt
+
+    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')
+        return opt
+
+class IntelItaniumFCompiler(IntelFCompiler):
+    compiler_type = 'intele'
+    version_pattern = r'Intel\(R\) Fortran 90 Compiler Itanium\(TM\) Compiler'\
+                      ' for the Itanium\(TM\)-based applications,'\
+                      ' Version (?P<version>[^\s*]*)'
+
+    for fc_exe in map(find_executable,['ifort','efort','efc']):
+        if os.path.isfile(fc_exe):
+            break
+
+    executables = {
+        'version_cmd'  : [fc_exe, "-FI -V -c %(fname)s.f -o %(fname)s.o" \
+                          % {'fname':dummy_fortran_file()}],
+        'compiler_f77' : [fc_exe,"-FI","-w90","-w95"],
+        'compiler_fix' : [fc_exe,"-FI"],
+        'compiler_f90' : [fc_exe],
+        'linker_so'    : [fc_exe,"-shared"],
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"]
+        }
+
+class IntelVisualFCompiler(FCompiler):
+
+    compiler_type = 'intelv'
+    version_pattern = r'Intel\(R\) Fortran Compiler for 32-bit applications, '\
+                      'Version (?P<version>[^\s*]*)'
+
+    ar_exe = 'lib.exe'
+    fc_exe = 'ifl'
+    if sys.platform=='win32':
+        from distutils.msvccompiler import MSVCCompiler
+        ar_exe = MSVCCompiler().lib
+
+    executables = {
+        'version_cmd'  : [fc_exe, "-FI -V -c %(fname)s.f -o %(fname)s.o" \
+                          % {'fname':dummy_fortran_file()}],
+        'compiler_f77' : [fc_exe,"-FI","-w90","-w95"],
+        'compiler_fix' : [fc_exe,"-FI","-4L72","-w"],
+        'compiler_f90' : [fc_exe],
+        'linker_so'    : [fc_exe,"-shared"],
+        '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','/Qlowercase','/us']
+        return opt
+
+    def get_flags_free(self):
+        return ["-FR"]
+
+    def get_flags_debug(self):
+        return ['/4Yb','/d2']
+
+    def get_flags_opt(self):
+        return ['/O3','/Qip','/Qipo','/Qipo_obj']
+
+    def get_flags_arch(self):
+        opt = []
+        if cpu.is_PentiumPro() or cpu.is_PentiumII():
+            opt.extend(['/G6','/Qaxi'])
+        elif cpu.is_PentiumIII():
+            opt.extend(['/G6','/QaxK'])
+        elif cpu.is_Pentium():
+            opt.append('/G5')
+        elif cpu.is_PentiumIV():
+            opt.extend(['/G7','/QaxW'])
+        if cpu.has_mmx():
+            opt.append('/QaxM')
+        return opt
+
+class IntelItaniumVisualFCompiler(IntelVisualFCompiler):
+
+    compiler_type = 'intelev'
+    version_pattern = r'Intel\(R\) Fortran 90 Compiler Itanium\(TM\) Compiler'\
+                      ' for the Itanium\(TM\)-based applications,'\
+                      ' Version (?P<version>[^\s*]*)'
+
+    fc_exe = 'efl' # XXX this is a wild guess
+    ar_exe = IntelVisualFCompiler.ar_exe
+
+    executables = {
+        'version_cmd'  : [fc_exe, "-FI -V -c %(fname)s.f -o %(fname)s.o" \
+                          % {'fname':dummy_fortran_file()}],
+        'compiler_f77' : [fc_exe,"-FI","-w90","-w95"],
+        'compiler_fix' : [fc_exe,"-FI","-4L72","-w"],
+        'compiler_f90' : [fc_exe],
+        'linker_so'    : [fc_exe,"-shared"],
+        'archiver'     : [ar_exe, "/verbose", "/OUT:"],
+        'ranlib'       : None
+        }
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='intel')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/lahey.py b/numpy/distutils/fcompiler/lahey.py
new file mode 100644
index 000000000..9b88cc264
--- /dev/null
+++ b/numpy/distutils/fcompiler/lahey.py
@@ -0,0 +1,46 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class LaheyFCompiler(FCompiler):
+
+    compiler_type = 'lahey'
+    version_pattern =  r'Lahey/Fujitsu Fortran 95 Compiler Release (?P<version>[^\s*]*)'
+
+    executables = {
+        'version_cmd'  : ["lf95", "--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 scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='lahey')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/mips.py b/numpy/distutils/fcompiler/mips.py
new file mode 100644
index 000000000..547e91423
--- /dev/null
+++ b/numpy/distutils/fcompiler/mips.py
@@ -0,0 +1,56 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class MipsFCompiler(FCompiler):
+
+    compiler_type = 'mips'
+    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 scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='mips')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/nag.py b/numpy/distutils/fcompiler/nag.py
new file mode 100644
index 000000000..e17d972c4
--- /dev/null
+++ b/numpy/distutils/fcompiler/nag.py
@@ -0,0 +1,39 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class NAGFCompiler(FCompiler):
+
+    compiler_type = 'nag'
+    version_pattern =  r'NAGWare Fortran 95 compiler Release (?P<version>[^\s]*)'
+
+    executables = {
+        'version_cmd'  : ["f95", "-V"],
+        'compiler_f77' : ["f95", "-fixed"],
+        'compiler_fix' : ["f95", "-fixed"],
+        'compiler_f90' : ["f95"],
+        'linker_so'    : ["f95"],
+        'archiver'     : ["ar", "-cr"],
+        'ranlib'       : ["ranlib"]
+        }
+
+    def get_flags_linker_so(self):
+        if sys.platform=='darwin':
+            return ['-unsharedf95','-Wl,-bundle,-flat_namespace,-undefined,suppress']
+        return ["-Wl,shared"]
+    def get_flags_opt(self):
+        return ['-O4']
+    def get_flags_arch(self):
+        return ['-target=native']
+    def get_flags_debug(self):
+        return ['-g','-gline','-g90','-nan','-C']
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='nag')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/none.py b/numpy/distutils/fcompiler/none.py
new file mode 100644
index 000000000..984ea7dda
--- /dev/null
+++ b/numpy/distutils/fcompiler/none.py
@@ -0,0 +1,24 @@
+
+from scipy.distutils.fcompiler import FCompiler
+
+class NoneFCompiler(FCompiler):
+
+    compiler_type = 'none'
+
+    executables = {'compiler_f77':['/path/to/nowhere/none'],
+                   'compiler_f90':['/path/to/nowhere/none'],
+                   'compiler_fix':['/path/to/nowhere/none'],
+                   'linker_so':['/path/to/nowhere/none'],
+                   'archiver':['/path/to/nowhere/none'],
+                   'ranlib':['/path/to/nowhere/none'],
+                   'version_cmd':['/path/to/nowhere/none'],
+                   }
+
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = NoneFCompiler()
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/pg.py b/numpy/distutils/fcompiler/pg.py
new file mode 100644
index 000000000..bfdf9752c
--- /dev/null
+++ b/numpy/distutils/fcompiler/pg.py
@@ -0,0 +1,42 @@
+
+# http://www.pgroup.com
+
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class PGroupFCompiler(FCompiler):
+
+    compiler_type = 'pg'
+    version_pattern =  r'\s*pg(f77|f90|hpf) (?P<version>[\d.-]+).*'
+
+    executables = {
+        'version_cmd'  : ["pgf77", "-V 2>/dev/null"],
+        'compiler_f77' : ["pgf77"],
+        'compiler_fix' : ["pgf90", "-Mfixed"],
+        'compiler_f90' : ["pgf90"],
+        'linker_so'    : ["pgf90","-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 __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='pg')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/sun.py b/numpy/distutils/fcompiler/sun.py
new file mode 100644
index 000000000..0c0599a06
--- /dev/null
+++ b/numpy/distutils/fcompiler/sun.py
@@ -0,0 +1,47 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler import FCompiler
+
+class SunFCompiler(FCompiler):
+
+    compiler_type = 'sun'
+    version_pattern = r'(f90|f95): (Sun|Forte Developer 7|WorkShop 6 update \d+) Fortran 95 (?P<version>[^\s]+).*'
+
+    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','f77compat'])
+        return opt
+
+if __name__ == '__main__':
+    from distutils import log
+    log.set_verbosity(2)
+    from scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='sun')
+    compiler.customize()
+    print compiler.get_version()
diff --git a/numpy/distutils/fcompiler/vast.py b/numpy/distutils/fcompiler/vast.py
new file mode 100644
index 000000000..1c6b40032
--- /dev/null
+++ b/numpy/distutils/fcompiler/vast.py
@@ -0,0 +1,50 @@
+import os
+import sys
+
+from scipy.distutils.cpuinfo import cpu
+from scipy.distutils.fcompiler.gnu import GnuFCompiler
+
+class VastFCompiler(GnuFCompiler):
+
+    compiler_type = 'vast'
+    version_pattern = r'\s*Pacific-Sierra Research vf90 '\
+                      '(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 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()
+        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 scipy.distutils.fcompiler import new_fcompiler
+    compiler = new_fcompiler(compiler='vast')
+    compiler.customize()
+    print compiler.get_version()