diff --git a/m4/fortran.m4 b/m4/fortran.m4
new file mode 100644
index 0000000000000000000000000000000000000000..11822fbd683251a6eb57595297bb98c6482cd67d
--- /dev/null
+++ b/m4/fortran.m4
@@ -0,0 +1,811 @@
+# This file is part of Autoconf.                       -*- Autoconf -*-
+# Fortran languages support.
+# Copyright 2001
+# Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+#
+# As a special exception, the Free Software Foundation gives unlimited
+# permission to copy, distribute and modify the configure scripts that
+# are the output of Autoconf.  You need not follow the terms of the GNU
+# General Public License when using or distributing such scripts, even
+# though portions of the text of Autoconf appear in them.  The GNU
+# General Public License (GPL) does govern all other use of the material
+# that constitutes the Autoconf program.
+#
+# Certain portions of the Autoconf source text are designed to be copied
+# (in certain cases, depending on the input) into the output of
+# Autoconf.  We call these the "data" portions.  The rest of the Autoconf
+# source text consists of comments plus executable code that decides which
+# of the data portions to output in any given case.  We call these
+# comments and executable code the "non-data" portions.  Autoconf never
+# copies any of the non-data portions into its output.
+#
+# This special exception to the GPL applies to versions of Autoconf
+# released by the Free Software Foundation.  When you make and
+# distribute a modified version of Autoconf, you may extend this special
+# exception to the GPL to apply to your modified version as well, *unless*
+# your modified version has the potential to copy into its output some
+# of the text that was the non-data portion of the version that you started
+# with.  (In other words, unless your change moves or copies text from
+# the non-data portions to the data portions.)  If your modification has
+# such potential, you must delete any notice of this special exception
+# to the GPL from your modified version.
+#
+# Written by David MacKenzie, with help from
+# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
+# Roland McGrath, Noah Friedman, david d zuhn, and many others.
+
+
+# _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# ---------------------------------------------------------------------------
+#
+# Processing the elements of a list is tedious in shell programming,
+# as lists tend to be implemented as space delimited strings.
+#
+# This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
+# if ELEMENT is a member of LIST, otherwise it executes
+# ACTION-IF-NOT-FOUND.
+AC_DEFUN([_AC_LIST_MEMBER_IF],
+[dnl Do some sanity checking of the arguments.
+m4_if([$1], , [AC_FATAL([$0: missing argument 1])])dnl
+m4_if([$2], , [AC_FATAL([$0: missing argument 2])])dnl
+  ac_exists=false
+  for ac_i in $2; do
+    if test x"$1" = x"$ac_i"; then
+      ac_exists=true
+      break
+    fi
+  done
+
+  AS_IF([test x"$ac_exists" = xtrue], [$3], [$4])[]dnl
+])# _AC_LIST_MEMBER_IF
+
+
+# _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
+# -------------------------------------------------
+#
+# Specifying options to the compiler (whether it be the C, C++ or
+# Fortran 77 compiler) that are meant for the linker is compiler
+# dependent.  This macro lets you give options to the compiler that
+# are meant for the linker in a portable, compiler-independent way.
+#
+# This macro take two arguments, a list of linker options that the
+# compiler should pass to the linker (LINKER-OPTIONS) and the name of
+# a shell variable (SHELL-VARIABLE).  The list of linker options are
+# appended to the shell variable in a compiler-dependent way.
+#
+# For example, if the selected language is C, then this:
+#
+#   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
+#
+# will expand into this if the selected C compiler is gcc:
+#
+#   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
+#
+# otherwise, it will expand into this:
+#
+#   foo_LDFLAGS"-R /usr/local/lib/foo"
+#
+# You are encouraged to add support for compilers that this macro
+# doesn't currently support.
+# FIXME: Get rid of this macro.
+AC_DEFUN([_AC_LINKER_OPTION],
+[if test "$ac_compiler_gnu" = yes; then
+  for ac_link_opt in $1; do
+    $2="[$]$2 -Xlinker $ac_link_opt"
+  done
+else
+  $2="[$]$2 $1"
+fi[]dnl
+])# _AC_LINKER_OPTION
+
+
+
+## ----------------------- ##
+## 1. Language selection.  ##
+## ----------------------- ##
+
+
+# ----------------------------- #
+# 1d. The Fortran 77 language.  #
+# ----------------------------- #
+
+
+# AC_LANG(Fortran 77)
+# -------------------
+m4_define([AC_LANG(Fortran 77)],
+[ac_ext=f
+ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
+ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
+ac_compiler_gnu=$ac_cv_f77_compiler_gnu
+])
+
+
+# AC_LANG_FORTRAN77
+# -----------------
+AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)])
+
+
+# _AC_LANG_ABBREV(Fortran 77)
+# ---------------------------
+m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77])
+
+
+
+## ---------------------- ##
+## 2.Producing programs.  ##
+## ---------------------- ##
+
+
+# ------------------------ #
+# 2d. Fortran 77 sources.  #
+# ------------------------ #
+
+# AC_LANG_SOURCE(Fortran 77)(BODY)
+# --------------------------------
+# FIXME: Apparently, according to former AC_TRY_COMPILER, the CPP
+# directives must not be included.  But AC_TRY_RUN_NATIVE was not
+# avoiding them, so?
+m4_define([AC_LANG_SOURCE(Fortran 77)],
+[$1])
+
+
+# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY])
+# -----------------------------------------------
+# Yes, we discard the PROLOGUE.
+m4_define([AC_LANG_PROGRAM(Fortran 77)],
+[m4_ifval([$1],
+       [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl
+      program main
+$2
+      end])
+
+
+# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION)
+# --------------------------------------------
+# FIXME: This is a guess, help!
+m4_define([AC_LANG_CALL(Fortran 77)],
+[AC_LANG_PROGRAM([$1],
+[      call $2])])
+
+
+
+
+## -------------------------------------------- ##
+## 3. Looking for Compilers and Preprocessors.  ##
+## -------------------------------------------- ##
+
+
+# ----------------------------- #
+# 3d. The Fortran 77 compiler.  #
+# ----------------------------- #
+
+
+# AC_LANG_PREPROC(Fortran 77)
+# ---------------------------
+# Find the Fortran 77 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
+AC_DEFUN([AC_LANG_PREPROC(Fortran 77)],
+[m4_warn([syntax],
+         [$0: No preprocessor defined for ]_AC_LANG)])
+
+
+# AC_LANG_COMPILER(Fortran 77)
+# ----------------------------
+# Find the Fortran 77 compiler.  Must be AC_DEFUN'd to be
+# AC_REQUIRE'able.
+AC_DEFUN([AC_LANG_COMPILER(Fortran 77)],
+[AC_REQUIRE([AC_PROG_F77])])
+
+
+# ac_cv_prog_g77
+# --------------
+# We used to name the cache variable this way.
+AU_DEFUN([ac_cv_prog_g77],
+[ac_cv_f77_compiler_gnu])
+
+
+# AC_PROG_F77([COMPILERS...])
+# ---------------------------
+# COMPILERS is a space separated list of Fortran 77 compilers to search
+# for.  Fortran 95 isn't strictly backwards-compatible with Fortran 77,
+# but `f95' is worth trying.
+#
+# Compilers are ordered by
+#  1. F77, F90, F95
+#  2. Good/tested native compilers, bad/untested native compilers
+#  3. Wrappers around f2c go last.
+#
+# `fort77' is a wrapper around `f2c'.
+# It is believed that under HP-UX `fort77' is the name of the native
+# compiler.  On some Cray systems, fort77 is a native compiler.
+# frt is the Fujitsu F77 compiler.
+# pgf77 and pgf90 are the Portland Group F77 and F90 compilers.
+# xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers.
+# lf95 is the Lahey-Fujitsu compiler.
+# fl32 is the Microsoft Fortran "PowerStation" compiler.
+# af77 is the Apogee F77 compiler for Intergraph hardware running CLIX.
+# epcf90 is the "Edinburgh Portable Compiler" F90.
+# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
+AC_DEFUN([AC_PROG_F77],
+[AC_LANG_PUSH(Fortran 77)dnl
+AC_ARG_VAR([F77],    [Fortran 77 compiler command])dnl
+AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl
+_AC_ARG_VAR_LDFLAGS()dnl
+AC_CHECK_TOOLS(F77,
+      [m4_default([$1],
+                  [g77 f77 xlf frt pgf77 fl32 af77 fort77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 lf95 g95])])
+
+# Provide some information about the compiler.
+echo "$as_me:__oline__:" \
+     "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD
+ac_compiler=`set X $ac_compile; echo $[2]`
+_AC_EVAL([$ac_compiler --version </dev/null >&AS_MESSAGE_LOG_FD])
+_AC_EVAL([$ac_compiler -v </dev/null >&AS_MESSAGE_LOG_FD])
+_AC_EVAL([$ac_compiler -V </dev/null >&AS_MESSAGE_LOG_FD])
+
+m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
+m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
+# If we don't use `.F' as extension, the preprocessor is not run on the
+# input file.
+ac_save_ext=$ac_ext
+ac_ext=F
+_AC_LANG_COMPILER_GNU
+ac_ext=$ac_save_ext
+G77=`test $ac_compiler_gnu = yes && echo yes`
+_AC_PROG_F77_G
+AC_LANG_POP(Fortran 77)dnl
+])# AC_PROG_F77
+
+
+# _AC_PROG_F77_G
+# --------------
+# Check whether -g works, even if FFLAGS is set, in case the package
+# plays around with FFLAGS (such as to build both debugging and normal
+# versions of a library), tasteless as that idea is.
+m4_define([_AC_PROG_F77_G],
+[ac_test_FFLAGS=${FFLAGS+set}
+ac_save_FFLAGS=$FFLAGS
+FFLAGS=
+AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g,
+[FFLAGS=-g
+_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
+[ac_cv_prog_f77_g=yes],
+[ac_cv_prog_f77_g=no])
+])
+if test "$ac_test_FFLAGS" = set; then
+  FFLAGS=$ac_save_FFLAGS
+elif test $ac_cv_prog_f77_g = yes; then
+  if test "$G77" = yes; then
+    FFLAGS="-g -O2"
+  else
+    FFLAGS="-g"
+  fi
+else
+  if test "$G77" = yes; then
+    FFLAGS="-O2"
+  else
+    FFLAGS=
+  fi
+fi[]dnl
+])# _AC_PROG_F77_G
+
+
+# AC_PROG_F77_C_O
+# ---------------
+# Test if the Fortran 77 compiler accepts the options `-c' and `-o'
+# simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not.
+#
+# The usefulness of this macro is questionable, as I can't really see
+# why anyone would use it.  The only reason I include it is for
+# completeness, since a similar test exists for the C compiler.
+AC_DEFUN([AC_PROG_F77_C_O],
+[AC_REQUIRE([AC_PROG_F77])dnl
+AC_CACHE_CHECK([whether $F77 understand -c and -o together],
+               [ac_cv_prog_f77_c_o],
+[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+# We test twice because some compilers refuse to overwrite an existing
+# `.o' file with `-o', although they will create one.
+ac_try='$F77 $FFLAGS -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
+if AC_TRY_EVAL(ac_try) &&
+     test -f conftest.$ac_objext &&
+     AC_TRY_EVAL(ac_try); then
+  ac_cv_prog_f77_c_o=yes
+else
+  ac_cv_prog_f77_c_o=no
+fi
+rm -f conftest*])
+if test $ac_cv_prog_f77_c_o = no; then
+  AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1,
+            [Define to 1 if your Fortran 77 compiler doesn't accept
+             -c and -o together.])
+fi
+])# AC_PROG_F77_C_O
+
+
+
+
+
+## ------------------------------- ##
+## 4. Compilers' characteristics.  ##
+## ------------------------------- ##
+
+
+# ---------------------------------------- #
+# 4d. Fortran 77 compiler characteristics. #
+# ---------------------------------------- #
+
+
+# _AC_PROG_F77_V_OUTPUT([FLAG = $ac_cv_prog_f77_v])
+# -------------------------------------------------
+# Link a trivial Fortran program, compiling with a verbose output FLAG
+# (which default value, $ac_cv_prog_f77_v, is computed by
+# _AC_PROG_F77_V), and return the output in $ac_f77_v_output.  This
+# output is processed in the way expected by AC_F77_LIBRARY_LDFLAGS,
+# so that any link flags that are echoed by the compiler appear as
+# space-separated items.
+AC_DEFUN([_AC_PROG_F77_V_OUTPUT],
+[AC_REQUIRE([AC_PROG_F77])dnl
+AC_LANG_PUSH(Fortran 77)dnl
+
+AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+
+# Compile and link our simple test program by passing a flag (argument
+# 1 to this macro) to the Fortran 77 compiler in order to get
+# "verbose" output that we can then parse for the Fortran 77 linker
+# flags.
+ac_save_FFLAGS=$FFLAGS
+FFLAGS="$FFLAGS m4_default([$1], [$ac_cv_prog_f77_v])"
+(eval echo $as_me:__oline__: \"$ac_link\") >&AS_MESSAGE_LOG_FD
+ac_f77_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | grep -v 'Driving:'`
+echo "$ac_f77_v_output" >&AS_MESSAGE_LOG_FD
+FFLAGS=$ac_save_FFLAGS
+
+rm -f conftest*
+AC_LANG_POP(Fortran 77)dnl
+
+# If we are using xlf then replace all the commas with spaces.
+if echo $ac_f77_v_output | grep xlfentry >/dev/null 2>&1; then
+  ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'`
+fi
+
+# On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
+# /foo, /bar, and /baz are search directories for the Fortran linker.
+# Here, we change these into -L/foo -L/bar -L/baz (and put it first):
+ac_f77_v_output="`echo $ac_f77_v_output |
+	grep 'LPATH is:' |
+	sed 's,.*LPATH is\(: *[[^ ]]*\).*,\1,;s,: */, -L/,g'` $ac_f77_v_output"
+
+# If we are using Cray Fortran then delete quotes.
+# Use "\"" instead of '"' for font-lock-mode.
+# FIXME: a more general fix for quoted arguments with spaces?
+if echo $ac_f77_v_output | grep cft90 >/dev/null 2>&1; then
+  ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"`
+fi[]dnl
+])# _AC_PROG_F77_V_OUTPUT
+
+
+# _AC_PROG_F77_V
+# --------------
+#
+# Determine the flag that causes the Fortran 77 compiler to print
+# information of library and object files (normally -v)
+# Needed for AC_F77_LIBRARY_FLAGS
+# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
+AC_DEFUN([_AC_PROG_F77_V],
+[AC_CACHE_CHECK([how to get verbose linking output from $F77],
+                [ac_cv_prog_f77_v],
+[AC_LANG_ASSERT(Fortran 77)
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
+[ac_cv_prog_f77_v=
+# Try some options frequently used verbose output
+for ac_verb in -v -verbose --verbose -V -\#\#\#; do
+  _AC_PROG_F77_V_OUTPUT($ac_verb)
+  # look for -l* and *.a constructs in the output
+  for ac_arg in $ac_f77_v_output; do
+     case $ac_arg in
+        [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*)
+          ac_cv_prog_f77_v=$ac_verb
+          break 2 ;;
+     esac
+  done
+done
+if test -z "$ac_cv_prog_f77_v"; then
+   AC_MSG_WARN([cannot determine how to obtain linking information from $F77])
+fi],
+                  [AC_MSG_WARN([compilation failed])])
+])])# _AC_PROG_F77_V
+
+
+# AC_F77_LIBRARY_LDFLAGS
+# ----------------------
+#
+# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 77
+# intrinsic and run-time libraries that are required to successfully
+# link a Fortran 77 program or shared library.  The output variable
+# FLIBS is set to these flags.
+#
+# This macro is intended to be used in those situations when it is
+# necessary to mix, e.g. C++ and Fortran 77, source code into a single
+# program or shared library.
+#
+# For example, if object files from a C++ and Fortran 77 compiler must
+# be linked together, then the C++ compiler/linker must be used for
+# linking (since special C++-ish things need to happen at link time
+# like calling global constructors, instantiating templates, enabling
+# exception support, etc.).
+#
+# However, the Fortran 77 intrinsic and run-time libraries must be
+# linked in as well, but the C++ compiler/linker doesn't know how to
+# add these Fortran 77 libraries.  Hence, the macro
+# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran 77
+# libraries.
+#
+# This macro was packaged in its current form by Matthew D. Langston.
+# However, nearly all of this macro came from the "OCTAVE_FLIBS" macro
+# in "octave-2.0.13/aclocal.m4", and full credit should go to John
+# W. Eaton for writing this extremely useful macro.  Thank you John.
+AC_DEFUN([AC_F77_LIBRARY_LDFLAGS],
+[AC_LANG_PUSH(Fortran 77)dnl
+_AC_PROG_F77_V
+AC_CACHE_CHECK([for Fortran 77 libraries], ac_cv_flibs,
+[if test "x$FLIBS" != "x"; then
+  ac_cv_flibs="$FLIBS" # Let the user override the test.
+else
+
+_AC_PROG_F77_V_OUTPUT
+
+ac_cv_flibs=
+
+# Save positional arguments (if any)
+ac_save_positional="$[@]"
+
+set X $ac_f77_v_output
+while test $[@%:@] != 1; do
+  shift
+  ac_arg=$[1]
+  case $ac_arg in
+        [[\\/]]*.a | ?:[[\\/]]*.a)
+          _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_flibs, ,
+              ac_cv_flibs="$ac_cv_flibs $ac_arg")
+          ;;
+        -bI:*)
+          _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_flibs, ,
+             [_AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)])
+          ;;
+          # Ignore these flags.
+#        -lang* | -lcrt[[0-9]].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
+        -lang* | -lcrt[[0-9]].o | -lc | -lgcc | -libmil | -LANG:=*)
+          ;;
+        -lkernel32)
+          test x"$CYGWIN" != xyes && ac_cv_flibs="$ac_cv_flibs $ac_arg"
+          ;;
+        -[[LRuY]])
+          # These flags, when seen by themselves, take an argument.
+          # We remove the space between option and argument and re-iterate
+          # unless we find an empty arg or a new option (starting with -)
+	  case $[2] in
+             "" | -*);;
+             *)
+		ac_arg="$ac_arg$[2]"
+		shift; shift
+		set X $ac_arg "$[@]"
+		;;
+	  esac
+          ;;
+        -YP,*)
+          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
+            _AC_LIST_MEMBER_IF($ac_j, $ac_cv_flibs, ,
+                               [ac_arg="$ac_arg $ac_j"
+                               ac_cv_flibs="$ac_cv_flibs $ac_j"])
+          done
+          ;;
+        -[[lLR]]*)
+          _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_flibs, ,
+                             ac_cv_flibs="$ac_cv_flibs $ac_arg")
+          ;;
+          # Ignore everything else.
+  esac
+done
+# restore positional arguments
+set X $ac_save_positional; shift
+
+# We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
+# then we insist that the "run path" must be an absolute path (i.e. it
+# must begin with a "/").
+case `(uname -sr) 2>/dev/null` in
+   "SunOS 5"*)
+      ac_ld_run_path=`echo $ac_f77_v_output |
+                        sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'`
+      test "x$ac_ld_run_path" != x &&
+        _AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_flibs)
+      ;;
+esac
+fi # test "x$FLIBS" = "x"
+])
+FLIBS="$ac_cv_flibs"
+AC_SUBST(FLIBS)
+AC_LANG_POP(Fortran 77)dnl
+])# AC_F77_LIBRARY_LDFLAGS
+
+
+# AC_F77_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# -----------------------------------------------------------
+#
+# Detect name of dummy main routine required by the Fortran libraries,
+# (if any) and define F77_DUMMY_MAIN to this name (which should be
+# used for a dummy declaration, if it is defined).  On some systems,
+# linking a C program to the Fortran library does not work unless you
+# supply a dummy function called something like MAIN__.
+#
+# Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C
+# program with the F77 libs is found; default to exiting with an error
+# message.  Execute ACTION-IF-FOUND if a dummy routine name is needed
+# and found or if it is not needed (default to defining F77_DUMMY_MAIN
+# when needed).
+#
+# What is technically happening is that the Fortran libraries provide
+# their own main() function, which usually initializes Fortran I/O and
+# similar stuff, and then calls MAIN__, which is the entry point of
+# your program.  Usually, a C program will override this with its own
+# main() routine, but the linker sometimes complain if you don't
+# provide a dummy (never-called) MAIN__ routine anyway.
+#
+# Of course, programs that want to allow Fortran subroutines to do
+# I/O, etcetera, should call their main routine MAIN__() (or whatever)
+# instead of main().  A separate autoconf test (AC_F77_MAIN) checks
+# for the routine to use in this case (since the semantics of the test
+# are slightly different).  To link to e.g. purely numerical
+# libraries, this is normally not necessary, however, and most C/C++
+# programs are reluctant to turn over so much control to Fortran.  =)
+#
+# The name variants we check for are (in order):
+#   MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional)
+#   MAIN_, __main (SunOS)
+#   MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too)
+AC_DEFUN([AC_F77_DUMMY_MAIN],
+[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
+m4_define([_AC_LANG_PROGRAM_C_F77_HOOKS],
+[#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
+])
+AC_CACHE_CHECK([for dummy main to link with Fortran 77 libraries],
+               ac_cv_f77_dummy_main,
+[AC_LANG_PUSH(C)dnl
+ ac_f77_dm_save_LIBS=$LIBS
+ LIBS="$LIBS $FLIBS"
+
+ # First, try linking without a dummy main:
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
+                [ac_cv_f77_dummy_main=none],
+                [ac_cv_f77_dummy_main=unknown])
+
+ if test $ac_cv_f77_dummy_main = unknown; then
+   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
+     AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@define F77_DUMMY_MAIN $ac_func]])],
+                    [ac_cv_f77_dummy_main=$ac_func; break])
+   done
+ fi
+ rm -f conftest*
+ LIBS=$ac_f77_dm_save_LIBS
+ AC_LANG_POP(C)dnl
+])
+F77_DUMMY_MAIN=$ac_cv_f77_dummy_main
+AS_IF([test "$F77_DUMMY_MAIN" != unknown],
+      [m4_default([$1],
+[if test $F77_DUMMY_MAIN != none; then
+  AC_DEFINE_UNQUOTED([F77_DUMMY_MAIN], $F77_DUMMY_MAIN,
+                     [Define to dummy `main' function (if any) required to
+                      link to the Fortran 77 libraries.])
+fi])],
+      [m4_default([$2],
+            [AC_MSG_FAILURE([linking to Fortran libraries from C fails])])])
+])# AC_F77_DUMMY_MAIN
+
+
+# AC_F77_MAIN
+# -----------
+# Define F77_MAIN to name of alternate main() function for use with
+# the Fortran libraries.  (Typically, the libraries may define their
+# own main() to initialize I/O, etcetera, that then call your own
+# routine called MAIN__ or whatever.)  See AC_F77_DUMMY_MAIN, above.
+# If no such alternate name is found, just define F77_MAIN to main.
+#
+AC_DEFUN([AC_F77_MAIN],
+[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
+AC_CACHE_CHECK([for alternate main to link with Fortran 77 libraries],
+               ac_cv_f77_main,
+[AC_LANG_PUSH(C)dnl
+ ac_f77_m_save_LIBS=$LIBS
+ LIBS="$LIBS $FLIBS"
+ ac_cv_f77_main="main" # default entry point name
+
+ for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
+   AC_LINK_IFELSE([AC_LANG_PROGRAM([@%:@undef F77_DUMMY_MAIN
+@%:@define main $ac_func])],
+                  [ac_cv_f77_main=$ac_func; break])
+ done
+ rm -f conftest*
+ LIBS=$ac_f77_m_save_LIBS
+ AC_LANG_POP(C)dnl
+])
+AC_DEFINE_UNQUOTED([F77_MAIN], $ac_cv_f77_main,
+                   [Define to alternate name for `main' routine that is
+                    called from a `main' in the Fortran libraries.])
+])# AC_F77_MAIN
+
+
+# _AC_F77_NAME_MANGLING
+# ---------------------
+# Test for the name mangling scheme used by the Fortran 77 compiler.
+#
+# Sets ac_cv_f77_mangling. The value contains three fields, separated
+# by commas:
+#
+# lower case / upper case:
+#    case translation of the Fortran 77 symbols
+# underscore / no underscore:
+#    whether the compiler appends "_" to symbol names
+# extra underscore / no extra underscore:
+#    whether the compiler appends an extra "_" to symbol names already
+#    containing at least one underscore
+#
+AC_DEFUN([_AC_F77_NAME_MANGLING],
+[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
+AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl
+AC_CACHE_CHECK([for Fortran 77 name-mangling scheme],
+               ac_cv_f77_mangling,
+[AC_LANG_PUSH(Fortran 77)dnl
+AC_COMPILE_IFELSE(
+[      subroutine foobar()
+      return
+      end
+      subroutine foo_bar()
+      return
+      end],
+[mv conftest.$ac_objext cf77_test.$ac_objext
+
+  AC_LANG_PUSH(C)dnl
+
+  ac_save_LIBS=$LIBS
+  LIBS="cf77_test.$ac_objext $LIBS $FLIBS"
+
+  ac_success=no
+  for ac_foobar in foobar FOOBAR; do
+    for ac_underscore in "" "_"; do
+      ac_func="$ac_foobar$ac_underscore"
+      AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])],
+                     [ac_success=yes; break 2])
+    done
+  done
+
+  if test "$ac_success" = "yes"; then
+     case $ac_foobar in
+        foobar)
+           ac_case=lower
+           ac_foo_bar=foo_bar
+           ;;
+        FOOBAR)
+           ac_case=upper
+           ac_foo_bar=FOO_BAR
+           ;;
+     esac
+
+     ac_success_extra=no
+     for ac_extra in "" "_"; do
+        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
+        AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])],
+                       [ac_success_extra=yes; break])
+     done
+
+     if test "$ac_success_extra" = "yes"; then
+	ac_cv_f77_mangling="$ac_case case"
+        if test -z "$ac_underscore"; then
+           ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore"
+	else
+           ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore"
+        fi
+        if test -z "$ac_extra"; then
+           ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore"
+	else
+           ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore"
+        fi
+      else
+	ac_cv_f77_mangling="unknown"
+      fi
+  else
+     ac_cv_f77_mangling="unknown"
+  fi
+
+  LIBS=$ac_save_LIBS
+  AC_LANG_POP(C)dnl
+  rm -f cf77_test* conftest*],
+  [AC_MSG_FAILURE([cannot compile a simple Fortran program])])
+AC_LANG_POP(Fortran 77)dnl
+])
+])# _AC_F77_NAME_MANGLING
+
+# The replacement is empty.
+AU_DEFUN([AC_F77_NAME_MANGLING], [])
+
+
+# AC_F77_WRAPPERS
+# ---------------
+# Defines C macros F77_FUNC(name,NAME) and F77_FUNC_(name,NAME) to
+# properly mangle the names of C identifiers, and C identifiers with
+# underscores, respectively, so that they match the name mangling
+# scheme used by the Fortran 77 compiler.
+AC_DEFUN([AC_F77_WRAPPERS],
+[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
+AH_TEMPLATE([F77_FUNC],
+    [Define to a macro mangling the given C identifier (in lower and upper
+     case), which must not contain underscores, for linking with Fortran.])dnl
+AH_TEMPLATE([F77_FUNC_],
+    [As F77_FUNC, but for C identifiers containing underscores.])dnl
+case $ac_cv_f77_mangling in
+  "lower case, no underscore, no extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [name])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [name]) ;;
+  "lower case, no underscore, extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [name])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
+  "lower case, underscore, no extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [name ## _])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;;
+  "lower case, underscore, extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [name ## _])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [name ## __]) ;;
+  "upper case, no underscore, no extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [NAME])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [NAME]) ;;
+  "upper case, no underscore, extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [NAME])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
+  "upper case, underscore, no extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [NAME ## _])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;;
+  "upper case, underscore, extra underscore")
+          AC_DEFINE([F77_FUNC(name,NAME)],  [NAME ## _])
+          AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## __]) ;;
+  *)
+          AC_MSG_WARN([unknown Fortran 77 name-mangling scheme])
+          ;;
+esac
+])# AC_F77_WRAPPERS
+
+
+# AC_F77_FUNC(NAME, [SHELLVAR = NAME])
+# ------------------------------------
+# For a Fortran subroutine of given NAME, define a shell variable
+# $SHELLVAR to the Fortran-77 mangled name.  If the SHELLVAR
+# argument is not supplied, it defaults to NAME.
+AC_DEFUN([AC_F77_FUNC],
+[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
+case $ac_cv_f77_mangling in
+  upper*) ac_val="m4_toupper([$1])" ;;
+  lower*) ac_val="m4_tolower([$1])" ;;
+  *)      ac_val="unknown" ;;
+esac
+case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
+m4_if(m4_index([$1],[_]),-1,[],
+[case $ac_cv_f77_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac
+])
+m4_default([$2],[$1])="$ac_val"
+])# AC_F77_FUNC