text: """ Modified version of build_ext that handles fortran source files.
  
  """
  import os
  import subprocess
  from glob import glob
  
  from distutils.dep_util import newer_group
  from distutils.command.build_ext import build_ext as old_build_ext
  from distutils.errors import DistutilsFileError, DistutilsSetupError,\
      DistutilsError
  from distutils.file_util import copy_file
  
  from numpy.distutils import log
  from numpy.distutils.exec_command import filepath_from_subprocess_output
  from numpy.distutils.system_info import combine_paths
  from numpy.distutils.misc_util import (
      filter_sources, get_ext_source_files, get_numpy_include_dirs,
      has_cxx_sources, has_f_sources, is_sequence
  )
  from numpy.distutils.command.config_compiler import show_fortran_compilers
  from numpy.distutils.ccompiler_opt import new_ccompiler_opt, CCompilerOpt
  
  class build_ext (old_build_ext):
  
      description = "build C/C++/F extensions (compile/link to build directory)"
  
      user_options = old_build_ext.user_options + [
          ('fcompiler=', None,
           "specify the Fortran compiler type"),
          ('parallel=', 'j',
           "number of parallel jobs"),
          ('warn-error', None,
           "turn all warnings into errors (-Werror)"),
          ('cpu-baseline=', None,
           "specify a list of enabled baseline CPU optimizations"),
          ('cpu-dispatch=', None,
           "specify a list of dispatched CPU optimizations"),
          ('disable-optimization', None,
           "disable CPU optimized code(dispatch,simd,fast...)"),
          ('simd-test=', None,
           "specify a list of CPU optimizations to be tested against NumPy SIMD interface"),
      ]
  
      help_options = old_build_ext.help_options + [
          ('help-fcompiler', None, "list available Fortran compilers",
           show_fortran_compilers),
      ]
  
      boolean_options = old_build_ext.boolean_options + ['warn-error', 'disable-optimization']
  
      def initialize_options(self):
          old_build_ext.initialize_options(self)
          self.fcompiler = None
          self.parallel = None
          self.warn_error = None
          self.cpu_baseline = None
          self.cpu_dispatch = None
          self.disable_optimization = None
          self.simd_test = None
  
      def finalize_options(self):
          if self.parallel:
              try:
                  self.parallel = int(self.parallel)
              except ValueError as e:
                  raise ValueError("--parallel/-j argument must be an integer") from e
  
          # Ensure that self.include_dirs and self.distribution.include_dirs
          # refer to the same list object. finalize_options will modify
          # self.include_dirs, but self.distribution.include_dirs is used
          # during the actual build.
          # self.include_dirs is None unless paths are specified with
          # --include-dirs.
          # The include paths will be passed to the compiler in the order:
          # numpy paths, --include-dirs paths, Python include path.
          if isinstance(self.include_dirs, str):
              self.include_dirs = self.include_dirs.split(os.pathsep)
          incl_dirs = self.include_dirs or []
          if self.distribution.include_dirs is None:
              self.distribution.include_dirs = []
          self.include_dirs = self.distribution.include_dirs
          self.include_dirs.extend(incl_dirs)
  
          old_build_ext.finalize_options(self)
          self.set_undefined_options('build',
                                          ('parallel', 'parallel'),
                                          ('warn_error', 'warn_error'),
                                          ('cpu_baseline', 'cpu_baseline'),
                                          ('cpu_dispatch', 'cpu_dispatch'),
                                          ('disable_optimization', 'disable_optimization'),
                                          ('simd_test', 'simd_test')
                                    )
          CCompilerOpt.conf_target_groups["simd_test"] = self.simd_test
  
      def run(self):
          if not self.extensions:
              return
  
          # Make sure that extension sources are complete.
          self.run_command('build_src')
  
          if self.distribution.has_c_libraries():
              if self.inplace:
                  if self.distribution.have_run.get('build_clib'):
                      log.warn('build_clib already run, it is too late to '
                               'ensure in-place build of build_clib')
                      build_clib = self.distribution.get_command_obj(
                          'build_clib')
                  else:
                      build_clib = self.distribution.get_command_obj(
                          'build_clib')
                      build_clib.inplace = 1
                      build_clib.ensure_finalized()
                      build_clib.run()
                      self.distribution.have_run['build_clib'] = 1
  
              else:
                  self.run_command('build_clib')
                  build_clib = self.get_finalized_command('build_clib')
              self.library_dirs.append(build_clib.build_clib)
          else:
              build_clib = None
  
          # Not including C libraries to the list of
          # extension libraries automatically to prevent
          # bogus linking commands. Extensions must
          # explicitly specify the C libraries that they use.
  
          from distutils.ccompiler import new_compiler
          from numpy.distutils.fcompiler import new_fcompiler
  
          compiler_type = self.compiler
          # Initialize C compiler:
          self.compiler = new_compiler(compiler=compiler_type,
                                       verbose=self.verbose,
                                       dry_run=self.dry_run,
                                       force=self.force)
          self.compiler.customize(self.distribution)
          self.compiler.customize_cmd(self)
  
          if self.warn_error:
              self.compiler.compiler.append('-Werror')
              self.compiler.compiler_so.append('-Werror')
  
          self.compiler.show_customization()
  
          if not self.disable_optimization:
              dispatch_hpath = os.path.join("numpy", "distutils", "include", "npy_cpu_dispatch_config.h")
              dispatch_hpath = os.path.join(self.get_finalized_command("build_src").build_src, dispatch_hpath)
              opt_cache_path = os.path.abspath(
                  os.path.join(self.build_temp, 'ccompiler_opt_cache_ext.py')
              )
              self.compiler_opt = new_ccompiler_opt(
                  compiler=self.compiler, dispatch_hpath=dispatch_hpath,
                  cpu_baseline=self.cpu_baseline, cpu_dispatch=self.cpu_dispatch,
                  cache_path=opt_cache_path
              )
              if not self.compiler_opt.is_cached():
                  log.info("Detected changes on compiler optimizations, force rebuilding")
                  self.force = True
  
              import atexit
              def report():
                  log.info("\n########### EXT COMPILER OPTIMIZATION ###########")
                  log.info(self.compiler_opt.report(full=True))
              atexit.register(report)
  
          # Setup directory for storing generated extra DLL files on Windows
          self.extra_dll_dir = os.path.join(self.build_temp, '.libs')
          if not os.path.isdir(self.extra_dll_dir):
              os.makedirs(self.extra_dll_dir)
  
          # Create mapping of libraries built by build_clib:
          clibs = {}
          if build_clib is not None:
              for libname, build_info in build_clib.libraries or []:
                  if libname in clibs and clibs[libname] != build_info:
                      log.warn('library %r defined more than once,'
                               ' overwriting build_info\n%s... \nwith\n%s...'
                               % (libname, repr(clibs[libname])[:300], repr(build_info)[:300]))
                  clibs[libname] = build_info
          # .. and distribution libraries:
          for libname, build_info in self.distribution.libraries or []:
              if libname in clibs:
                  # build_clib libraries have a precedence before distribution ones
                  continue
              clibs[libname] = build_info
  
          # Determine if C++/Fortran 77/Fortran 90 compilers are needed.
          # Update extension libraries, library_dirs, and macros.
          all_languages = set()
          for ext in self.extensions:
              ext_languages = set()
              c_libs = []
              c_lib_dirs = []
              macros = []
              for libname in ext.libraries:
                  if libname in clibs:
                      binfo = clibs[libname]
                      c_libs += binfo.get('libraries', [])
                      c_lib_dirs += binfo.get('library_dirs', [])
                      for m in binfo.get('macros', []):
                          if m not in macros:
                              macros.append(m)
  
                  for l in clibs.get(libname, {}).get('source_languages', []):
                      ext_languages.add(l)
              if c_libs:
                  new_c_libs = ext.libraries + c_libs
                  log.info('updating extension %r libraries from %r to %r'
                           % (ext.name, ext.libraries, new_c_libs))
                  ext.libraries = new_c_libs
                  ext.library_dirs = ext.library_dirs + c_lib_dirs
              if macros:
                  log.info('extending extension %r defined_macros with %r'
                           % (ext.name, macros))
                  ext.define_macros = ext.define_macros + macros
  
              # determine extension languages
              if has_f_sources(ext.sources):
                  ext_languages.add('f77')
              if has_cxx_sources(ext.sources):
                  ext_languages.add('c++')
              l = ext.language or self.compiler.detect_language(ext.sources)
              if l:
                  ext_languages.add(l)
              # reset language attribute for choosing proper linker
              if 'c++' in ext_languages:
                  ext_language = 'c++'
              elif 'f90' in ext_languages:
                  ext_language = 'f90'
              elif 'f77' in ext_languages:
                  ext_language = 'f77'
              else:
                  ext_language = 'c'  # default
              if l and l != ext_language and ext.language:
                  log.warn('resetting extension %r language from %r to %r.' %
                           (ext.name, l, ext_language))
              ext.language = ext_language
              # global language
              all_languages.update(ext_languages)
  
          need_f90_compiler = 'f90' in all_languages
          need_f77_compiler = 'f77' in all_languages
          need_cxx_compiler = 'c++' in all_languages
  
          # Initialize C++ compiler:
          if need_cxx_compiler:
              self._cxx_compiler = new_compiler(compiler=compiler_type,
                                                verbose=self.verbose,
                                                dry_run=self.dry_run,
                                                force=self.force)
              compiler = self._cxx_compiler
              compiler.customize(self.distribution, need_cxx=need_cxx_compiler)
              compiler.customize_cmd(self)
              compiler.show_customization()
              self._cxx_compiler = compiler.cxx_compiler()
          else:
              self._cxx_compiler = None
  
          # Initialize Fortran 77 compiler:
          if need_f77_compiler:
              ctype = self.fcompiler
              self._f77_compiler = new_fcompiler(compiler=self.fcompiler,
                                                 verbose=self.verbose,
                                                 dry_run=self.dry_run,
                                                 force=self.force,
                                                 requiref90=False,
                                                 c_compiler=self.compiler)
              fcompiler = self._f77_compiler
              if fcompiler:
                  ctype = fcompiler.compiler_type
                  fcompiler.customize(self.distribution)
              if fcompiler and fcompiler.get_version():
                  fcompiler.customize_cmd(self)
                  fcompiler.show_customization()
              else:
                  self.warn('f77_compiler=%s is not available.' %
                            (ctype))
                  self._f77_compiler = None
          else:
              self._f77_compiler = None
  
          # Initialize Fortran 90 compiler:
          if need_f90_compiler:
              ctype = self.fcompiler
              self._f90_compiler = new_fcompiler(compiler=self.fcompiler,
                                                 verbose=self.verbose,
                                                 dry_run=self.dry_run,
                                                 force=self.force,
                                                 requiref90=True,
                                                 c_compiler=self.compiler)
              fcompiler = self._f90_compiler
              if fcompiler:
                  ctype = fcompiler.compiler_type
                  fcompiler.customize(self.distribution)
              if fcompiler and fcompiler.get_version():
                  fcompiler.customize_cmd(self)
                  fcompiler.show_customization()
              else:
                  self.warn('f90_compiler=%s is not available.' %
                            (ctype))
                  self._f90_compiler = None
          else:
              self._f90_compiler = None
  
          # Build extensions
          self.build_extensions()
  
          # Copy over any extra DLL files
          # FIXME: In the case where there are more than two packages,
          # we blindly assume that both packages need all of the libraries,
          # resulting in a larger wheel than is required. This should be fixed,
          # but it's so rare that I won't bother to handle it.
          pkg_roots = {
              self.get_ext_fullname(ext.name).split('.')[0]
              for ext in self.extensions
          }
          for pkg_root in pkg_roots:
              shared_lib_dir = os.path.join(pkg_root, '.libs')
              if not self.inplace:
                  shared_lib_dir = os.path.join(self.build_lib, shared_lib_dir)
              for fn in os.listdir(self.extra_dll_dir):
                  if not os.path.isdir(shared_lib_dir):
                      os.makedirs(shared_lib_dir)
                  if not fn.lower().endswith('.dll'):
                      continue
                  runtime_lib = os.path.join(self.extra_dll_dir, fn)
                  copy_file(runtime_lib, shared_lib_dir)
  
      def swig_sources(self, sources, extensions=None):
          # Do nothing. Swig sources have been handled in build_src command.
          return sources
  
      def build_extension(self, ext):
          sources = ext.sources
          if sources is None or not is_sequence(sources):
              raise DistutilsSetupError(
                  ("in 'ext_modules' option (extension '%s'), " +
                   "'sources' must be present and must be " +
                   "a list of source filenames") % ext.name)
          sources = list(sources)
  
          if not sources:
              return
  
          fullname = self.get_ext_fullname(ext.name)
          if self.inplace:
              modpath = fullname.split('.')
              package = '.'.join(modpath[0:-1])
              base = modpath[-1]
              build_py = self.get_finalized_command('build_py')
              package_dir = build_py.get_package_dir(package)
              ext_filename = os.path.join(package_dir,
                                          self.get_ext_filename(base))
          else:
              ext_filename = os.path.join(self.build_lib,
                                          self.get_ext_filename(fullname))
          depends = sources + ext.depends
  
          if not (self.force or newer_group(depends, ext_filename, 'newer')):
              log.debug("skipping '%s' extension (up-to-date)", ext.name)
              return
          else:
              log.info("building '%s' extension", ext.name)
  
          extra_args = ext.extra_compile_args or []
          macros = ext.define_macros[:]
          for undef in ext.undef_macros:
              macros.append((undef,))
  
          c_sources, cxx_sources, f_sources, fmodule_sources = \
              filter_sources(ext.sources)
  
          if self.compiler.compiler_type == 'msvc':
              if cxx_sources:
                  # Needed to compile kiva.agg._agg extension.
                  extra_args.append('/Zm1000')
              # this hack works around the msvc compiler attributes
              # problem, msvc uses its own convention :(
              c_sources += cxx_sources
              cxx_sources = []
  
          # Set Fortran/C++ compilers for compilation and linking.
          if ext.language == 'f90':
              fcompiler = self._f90_compiler
          elif ext.language == 'f77':
              fcompiler = self._f77_compiler
          else:  # in case ext.language is c++, for instance
              fcompiler = self._f90_compiler or self._f77_compiler
          if fcompiler is not None:
              fcompiler.extra_f77_compile_args = (ext.extra_f77_compile_args or []) if hasattr(
                  ext, 'extra_f77_compile_args') else []
              fcompiler.extra_f90_compile_args = (ext.extra_f90_compile_args or []) if hasattr(
                  ext, 'extra_f90_compile_args') else []
          cxx_compiler = self._cxx_compiler
  
          # check for the availability of required compilers
          if cxx_sources and cxx_compiler is None:
              raise DistutilsError("extension %r has C++ sources"
                                   "but no C++ compiler found" % (ext.name))
          if (f_sources or fmodule_sources) and fcompiler is None:
              raise DistutilsError("extension %r has Fortran sources "
                                   "but no Fortran compiler found" % (ext.name))
          if ext.language in ['f77', 'f90'] and fcompiler is None:
              self.warn("extension %r has Fortran libraries "
                        "but no Fortran linker found, using default linker" % (ext.name))
          if ext.language == 'c++' and cxx_compiler is None:
              self.warn("extension %r has C++ libraries "
                        "but no C++ linker found, using default linker" % (ext.name))
  
          kws = {'depends': ext.depends}
          output_dir = self.build_temp
  
          include_dirs = ext.include_dirs + get_numpy_include_dirs()
  
          # filtering C dispatch-table sources when optimization is not disabled,
          # otherwise treated as normal sources.
          copt_c_sources = []
          copt_baseline_flags = []
          copt_macros = []
          if not self.disable_optimization:
              bsrc_dir = self.get_finalized_command("build_src").build_src
              dispatch_hpath = os.path.join("numpy", "distutils", "include")
              dispatch_hpath = os.path.join(bsrc_dir, dispatch_hpath)
              include_dirs.append(dispatch_hpath)
  
              copt_build_src = None if self.inplace else bsrc_dir
              copt_c_sources = [
                  c_sources.pop(c_sources.index(src))
                  for src in c_sources[:] if src.endswith(".dispatch.c")
              ]
              copt_baseline_flags = self.compiler_opt.cpu_baseline_flags()
          else:
              copt_macros.append(("NPY_DISABLE_OPTIMIZATION", 1))
  
          c_objects = []
          if copt_c_sources:
              log.info("compiling C dispatch-able sources")
              c_objects += self.compiler_opt.try_dispatch(copt_c_sources,
                                                          output_dir=output_dir,
                                                          src_dir=copt_build_src,
                                                          macros=macros + copt_macros,
                                                          include_dirs=include_dirs,
                                                          debug=self.debug,
                                                          extra_postargs=extra_args,
                                                          **kws)
          if c_sources:
              log.info("compiling C sources")
              c_objects += self.compiler.compile(c_sources,
                                                 output_dir=output_dir,
                                                 macros=macros + copt_macros,
                                                 include_dirs=include_dirs,
                                                 debug=self.debug,
                                                 extra_postargs=extra_args + copt_baseline_flags,
                                                 **kws)
          if cxx_sources:
              log.info("compiling C++ sources")
              c_objects += cxx_compiler.compile(cxx_sources,
                                                output_dir=output_dir,
                                                macros=macros + copt_macros,
                                                include_dirs=include_dirs,
                                                debug=self.debug,
                                                extra_postargs=extra_args + copt_baseline_flags,
                                                **kws)
  
          extra_postargs = []
          f_objects = []
          if fmodule_sources:
              log.info("compiling Fortran 90 module sources")
              module_dirs = ext.module_dirs[:]
              module_build_dir = os.path.join(
                  self.build_temp, os.path.dirname(
                      self.get_ext_filename(fullname)))
  
              self.mkpath(module_build_dir)
              if fcompiler.module_dir_switch is None:
                  existing_modules = glob('*.mod')
              extra_postargs += fcompiler.module_options(
                  module_dirs, module_build_dir)
              f_objects += fcompiler.compile(fmodule_sources,
                                             output_dir=self.build_temp,
                                             macros=macros,
                                             include_dirs=include_dirs,
                                             debug=self.debug,
                                             extra_postargs=extra_postargs,
                                             depends=ext.depends)
  
              if fcompiler.module_dir_switch is None:
                  for f in glob('*.mod'):
                      if f in existing_modules:
                          continue
                      t = os.path.join(module_build_dir, f)
                      if os.path.abspath(f) == os.path.abspath(t):
                          continue
                      if os.path.isfile(t):
                          os.remove(t)
                      try:
                          self.move_file(f, module_build_dir)
                      except DistutilsFileError:
                          log.warn('failed to move %r to %r' %
                                   (f, module_build_dir))
          if f_sources:
              log.info("compiling Fortran sources")
              f_objects += fcompiler.compile(f_sources,
                                             output_dir=self.build_temp,
                                             macros=macros,
                                             include_dirs=include_dirs,
                                             debug=self.debug,
                                             extra_postargs=extra_postargs,
                                             depends=ext.depends)
  
          if f_objects and not fcompiler.can_ccompiler_link(self.compiler):
              unlinkable_fobjects = f_objects
              objects = c_objects
          else:
              unlinkable_fobjects = []
              objects = c_objects + f_objects
  
          if ext.extra_objects:
              objects.extend(ext.extra_objects)
          extra_args = ext.extra_link_args or []
          libraries = self.get_libraries(ext)[:]
          library_dirs = ext.library_dirs[:]
  
          linker = self.compiler.link_shared_object
          # Always use system linker when using MSVC compiler.
          if self.compiler.compiler_type in ('msvc', 'intelw', 'intelemw'):
              # expand libraries with fcompiler libraries as we are
              # not using fcompiler linker
              self._libs_with_msvc_and_fortran(
                  fcompiler, libraries, library_dirs)
  
          elif ext.language in ['f77', 'f90'] and fcompiler is not None:
              linker = fcompiler.link_shared_object
          if ext.language == 'c++' and cxx_compiler is not None:
              linker = cxx_compiler.link_shared_object
  
          if fcompiler is not None:
              objects, libraries = self._process_unlinkable_fobjects(
                      objects, libraries,
                      fcompiler, library_dirs,
                      unlinkable_fobjects)
  
          linker(objects, ext_filename,
                 libraries=libraries,
                 library_dirs=library_dirs,
                 runtime_library_dirs=ext.runtime_library_dirs,
                 extra_postargs=extra_args,
                 export_symbols=self.get_export_symbols(ext),
                 debug=self.debug,
                 build_temp=self.build_temp,
                 target_lang=ext.language)
  
      def _add_dummy_mingwex_sym(self, c_sources):
          build_src = self.get_finalized_command("build_src").build_src
          build_clib = self.get_finalized_command("build_clib").build_clib
          objects = self.compiler.compile([os.path.join(build_src,
                                                        "gfortran_vs2003_hack.c")],
                                          output_dir=self.build_temp)
          self.compiler.create_static_lib(
              objects, "_gfortran_workaround", output_dir=build_clib, debug=self.debug)
  
      def _process_unlinkable_fobjects(self, objects, libraries,
                                       fcompiler, library_dirs,
                                       unlinkable_fobjects):
          libraries = list(libraries)
          objects = list(objects)
          unlinkable_fobjects = list(unlinkable_fobjects)
  
          # Expand possible fake static libraries to objects
          for lib in libraries:
              for libdir in library_dirs:
                  fake_lib = os.path.join(libdir, lib + '.fobjects')
                  if os.path.isfile(fake_lib):
                      # Replace fake static library
                      libraries.remove(lib)
                      with open(fake_lib, 'r') as f:
                          unlinkable_fobjects.extend(f.read().splitlines())
  
                      # Expand C objects
                      c_lib = os.path.join(libdir, lib + '.cobjects')
                      with open(c_lib, 'r') as f:
                          objects.extend(f.read().splitlines())
  
          # Wrap unlinkable objects to a linkable one
          if unlinkable_fobjects:
              fobjects = [os.path.abspath(obj) for obj in unlinkable_fobjects]
              wrapped = fcompiler.wrap_unlinkable_objects(
                      fobjects, output_dir=self.build_temp,
                      extra_dll_dir=self.extra_dll_dir)
              objects.extend(wrapped)
  
          return objects, libraries
  
      def _libs_with_msvc_and_fortran(self, fcompiler, c_libraries,
                                      c_library_dirs):
          if fcompiler is None:
              return
  
          for libname in c_libraries:
              if libname.startswith('msvc'):
                  continue
              fileexists = False
              for libdir in c_library_dirs or []:
                  libfile = os.path.join(libdir, '%s.lib' % (libname))
                  if os.path.isfile(libfile):
                      fileexists = True
                      break
              if fileexists:
                  continue
              # make g77-compiled static libs available to MSVC
              fileexists = False
              for libdir in c_library_dirs:
                  libfile = os.path.join(libdir, 'lib%s.a' % (libname))
                  if os.path.isfile(libfile):
                      # copy libname.a file to name.lib so that MSVC linker
                      # can find it
                      libfile2 = os.path.join(self.build_temp, libname + '.lib')
                      copy_file(libfile, libfile2)
                      if self.build_temp not in c_library_dirs:
                          c_library_dirs.append(self.build_temp)
                      fileexists = True
                      break
              if fileexists:
                  continue
              log.warn('could not find library %r in directories %s'
                       % (libname, c_library_dirs))
  
          # Always use system linker when using MSVC compiler.
          f_lib_dirs = []
          for dir in fcompiler.library_dirs:
              # correct path when compiling in Cygwin but with normal Win
              # Python
              if dir.startswith('/usr/lib'):
                  try:
                      dir = subprocess.check_output(['cygpath', '-w', dir])
                  except (OSError, subprocess.CalledProcessError):
                      pass
                  else:
                      dir = filepath_from_subprocess_output(dir)
              f_lib_dirs.append(dir)
          c_library_dirs.extend(f_lib_dirs)
  
          # make g77-compiled static libs available to MSVC
          for lib in fcompiler.libraries:
              if not lib.startswith('msvc'):
                  c_libraries.append(lib)
                  p = combine_paths(f_lib_dirs, 'lib' + lib + '.a')
                  if p:
                      dst_name = os.path.join(self.build_temp, lib + '.lib')
                      if not os.path.isfile(dst_name):
                          copy_file(p[0], dst_name)
                      if self.build_temp not in c_library_dirs:
                          c_library_dirs.append(self.build_temp)
  
      def get_source_files(self):
          self.check_extensions_list(self.extensions)
          filenames = []
          for ext in self.extensions:
              filenames.extend(get_ext_source_files(ext))
          return filenames
  
      def get_outputs(self):
          self.check_extensions_list(self.extensions)
  
          outputs = []
          for ext in self.extensions:
              if not ext.sources:
                  continue
              fullname = self.get_ext_fullname(ext.name)
              outputs.append(os.path.join(self.build_lib,
                                          self.get_ext_filename(fullname)))
          return outputs
  