TARGET_OS ==> HOST_OS
[ghc.git] / aclocal.m4
index edf8dac..ebe182d 100644 (file)
@@ -1,61 +1,89 @@
-dnl $Id: aclocal.m4,v 1.112 2003/01/26 12:56:00 panne Exp $
-dnl 
-dnl Extra autoconf macros for the Glasgow fptools
-dnl
-dnl To be a good autoconf citizen, names of local macros have
-dnl prefixed with FPTOOLS_ to ensure we don't clash
-dnl with any pre-supplied autoconf ones.
-
-dnl
-dnl Is timezone around? (in a header file)
-dnl 
-AC_DEFUN(FPTOOLS_HAVE_TIMEZONE,
-[AC_CACHE_CHECK([timezone], fptools_cv_have_timezone,
-[AC_TRY_COMPILE([#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif
-#endif
-], [return timezone;], 
-fptools_cv_have_timezone=yes, fptools_cv_have_timezone=no)])
-if test "$fptools_cv_have_timezone" = yes; then
-  AC_DEFINE(HAVE_TIMEZONE)
+# Extra autoconf macros for the Glasgow fptools
+#
+# To be a good autoconf citizen, names of local macros have prefixed with FP_ to
+# ensure we don't clash with any pre-supplied autoconf ones.
+
+
+# FP_EVAL_STDERR(COMMAND)
+# -----------------------
+# Eval COMMAND, save its stderr (without lines resulting from shell tracing)
+# into the file conftest.err and the exit status in the variable fp_status.
+AC_DEFUN([FP_EVAL_STDERR],
+[{ (eval $1) 2>conftest.er1
+  fp_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  (exit $fp_status); }[]dnl
+])# FP_EVAL_STDERR
+
+
+# FP_CHECK_FLAG(FLAG, [ACTION-IF-SUPPORTED], [ACTION-IF-NOT-SUPPORTED])
+# ---------------------------------------------------------------------
+# Check to see whether the compiler for the current language supports a
+# particular option.
+#
+# Implementation note: When given an unkown option, GCC issues an warning on
+# stderr only, but returns an exit value of 0 nevertheless. Consequently we have
+# to check stderr *and* the exit value.
+#
+# Used by ghc.
+AC_DEFUN([FP_CHECK_FLAG],
+[AC_LANG_COMPILER_REQUIRE()dnl
+AC_LANG_CASE([C],          [fp_compiler="$CC"  m4_pushdef([fp_Flags], [CFLAGS])],
+             [C++],        [fp_compiler="$CXX" m4_pushdef([fp_Flags], [CXXFLAGS])],
+             [Fortran 77], [fp_compiler="$F77" m4_pushdef([fp_Flags], [FFLAGS])])
+m4_pushdef([fp_Cache], [fp_cv_[]fp_Flags[]AS_TR_SH([$1])])[]dnl
+AC_CACHE_CHECK([whether $fp_compiler accepts $1], [fp_Cache],
+[AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
+fp_save_flags="$fp_Flags"
+fp_Flags="$fp_Flags $1"
+fp_Cache=no
+if FP_EVAL_STDERR([$ac_compile conftest.$ac_ext]) >/dev/null; then
+  test -s conftest.err || fp_Cache=yes
 fi
-])
+fp_Flags="$fp_save_flags"
+rm -f conftest.err conftest.$ac_ext])
+AS_IF([test $fp_Cache = yes], [$2], [$3])[]dnl
+m4_popdef([fp_Cache])[]dnl
+m4_popdef([fp_Flags])[]dnl
+])# FP_CHECK_FLAG
 
-dnl
-dnl Has timezone the type time_t or long (HP-UX 10.20 apparently
-dnl has `long'..)
-dnl 
-AC_DEFUN(FPTOOLS_TYPE_TIMEZONE,
-[AC_CACHE_CHECK([type of timezone], fptools_cv_type_timezone,
-[AC_TRY_COMPILE([#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif
-#endif
 
-extern time_t timezone;        
-],
-[int i;], fptools_cv_type_timezone=time_t, fptools_cv_type_timezone=long)])
-AC_DEFINE_UNQUOTED(TYPE_TIMEZONE, $fptools_cv_type_timezone)
-])
+# FP_PROG_CONTEXT_DIFF
+# --------------------
+# Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
+#
+# Note: NeXTStep thinks diff'ing a file against itself is "trouble".
+#
+# Used by ghc, glafp-utils/ltx, and glafp-utils/runstdtest.
+AC_DEFUN([FP_PROG_CONTEXT_DIFF],
+[AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
+[echo foo > conftest1
+echo foo > conftest2
+fp_cv_context_diff=no
+for fp_var in '-C 1' '-c1'
+do
+  if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
+    fp_cv_context_diff="diff $fp_var"
+    break
+  fi
+done])
+if test x"$fp_cv_context_diff" = xno; then
+   AC_MSG_ERROR([cannot figure out how to do context diffs])
+fi
+AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
+])# FP_PROG_CONTEXT_DIFF
+
 
-dnl *** Is altzone available? ***
-dnl 
-AC_DEFUN(FPTOOLS_ALTZONE,
-[AC_CACHE_CHECK([altzone], fptools_cv_altzone,
-[AC_TRY_LINK([#if TIME_WITH_SYS_TIME
+# FP_DECL_ALTZONE
+# ---------------
+# Defines HAVE_DECL_ALTZONE to 1 if declared, 0 otherwise.
+#
+# Used by base package.
+AC_DEFUN([FP_DECL_ALTZONE],
+[AC_REQUIRE([AC_HEADER_TIME])dnl
+AC_CHECK_HEADERS([sys/time.h])
+AC_CHECK_DECLS([altzone], [], [],[#if TIME_WITH_SYS_TIME
 # include <sys/time.h>
 # include <time.h>
 #else
@@ -64,75 +92,83 @@ AC_DEFUN(FPTOOLS_ALTZONE,
 # else
 #  include <time.h>
 # endif
-#endif
-], [return altzone;], 
-fptools_cv_altzone=yes, fptools_cv_altzone=no)])
-if test "$fptools_cv_altzone" = yes; then
-  AC_DEFINE(HAVE_ALTZONE)
-fi
-])
+#endif])
+])# FP_DECL_ALTZONE
 
 
-dnl *** Does libc contain GNU regex? ***
-dnl 
-AC_DEFUN(FPTOOLS_REGEX_IN_LIBC,
-[AC_CACHE_CHECK([for GNU regex in libc], fptools_cv_have_regex,
-[AC_TRY_LINK([#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <regex.h>
-],[ struct re_pattern_buffer patbuf; 
-    re_compile_pattern("",0,&patbuf);
-    re_search_2 (&patbuf, "", 0, "",0, 0,0,0,0); ],
-fptools_cv_have_regex=yes, fptools_cv_have_regex=no)])
-if test "$fptools_cv_have_regex" = yes; then
-       HaveGNURegex=YES
+# FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
+# --------------------------------------------------------
+# Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
+# compilation. Execute IF-FAILS when unable to determine the value. Works for
+# cross-compilation, too.
+#
+# Implementation note: We are lazy and use an internal autoconf macro, but it
+# is supported in autoconf versions 2.50 up to the actual 2.57, so there is
+# little risk.
+AC_DEFUN([FP_COMPUTE_INT],
+[_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
+])# FP_COMPUTE_INT
+
+
+# FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
+# ------------------------------------------------------------------
+# A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
+# given type. Defines ALIGNMENT_TYPE.
+AC_DEFUN([FP_CHECK_ALIGNMENT],
+[AS_LITERAL_IF([$1], [],
+               [AC_FATAL([$0: requires literal arguments])])[]dnl
+AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
+m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
+AC_CACHE_CHECK([alignment of $1], [fp_Cache],
+[if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
+  FP_COMPUTE_INT([(long) (&((struct { char c; $1 ty; } *)0)->ty)],
+                 [fp_Cache],
+                 [AC_INCLUDES_DEFAULT([$3])],
+                 [AC_MSG_ERROR([cannot compute alignment ($1)
+See `config.log' for more details.], [77])])
 else
-       HaveGNURegex=NO
-fi
-AC_SUBST(HaveGNURegex)
-])
-
-
-dnl ** check for leading underscores in symbol names
-dnl 
-dnl Test for determining whether symbol names have a leading
-dnl underscore.
-dnl 
-dnl We assume that they _haven't_ if anything goes wrong.
-dnl
-dnl Some nlist implementations seem to try to be compatible by ignoring
-dnl a leading underscore sometimes (eg. FreeBSD).  We therefore have
-dnl to work around this by checking for *no* leading underscore first.
-dnl Sigh.  --SDM
-dnl
-AC_DEFUN(FPTOOLS_UNDERSCORE,
-[AC_CHECK_LIB(elf, nlist, LIBS="-lelf $LIBS")dnl
-AC_CACHE_CHECK([leading underscore in symbol names], fptools_cv_lead_uscore,
-
-dnl
-dnl Hack!: nlist() under Digital UNIX insist on there being an _,
-dnl but symbol table listings shows none. What is going on here?!?
-dnl
-dnl Another hack: cygwin doesn't come with nlist.h , so we hardwire
-dnl the underscoredness of that "platform"
-changequote(<<, >>)dnl
-<<
+  fp_Cache=0
+fi])[]dnl
+AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
+m4_popdef([fp_Cache])[]dnl
+])# FP_CHECK_ALIGNMENT
+
+
+# FP_LEADING_UNDERSCORE
+# ---------------------
+# Test for determining whether symbol names have a leading underscore. We assume
+# that they _haven't_ if anything goes wrong. Sets the output variable
+# LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
+#
+# Some nlist implementations seem to try to be compatible by ignoring a leading
+# underscore sometimes (eg. FreeBSD). We therefore have to work around this by
+# checking for *no* leading underscore first. Sigh.  --SDM
+#
+# Similarly on OpenBSD, but this test doesn't help. -- dons
+AC_DEFUN([FP_LEADING_UNDERSCORE],
+[AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
+AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
+# Hack!: nlist() under Digital UNIX insist on there being an _,
+# but symbol table listings shows none. What is going on here?!?
+#
+# Another hack: cygwin doesn't come with nlist.h , so we hardwire
+# the underscoredness of that "platform"
 case $HostPlatform in
-alpha-dec-osf*) fptools_cv_lead_uscore='no';;
-*cygwin32) fptools_cv_lead_uscore='yes';;
-*mingw32) fptools_cv_lead_uscore='yes';;
-*) >>
-changequote([, ])dnl
-AC_TRY_RUN([#ifdef HAVE_NLIST_H
+*openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
+  case $build in
+    i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
+    *) fptools_cv_leading_underscore=no ;;
+  esac ;;
+alpha-dec-osf*) fptools_cv_leading_underscore=no;;
+*cygwin32) fptools_cv_leading_underscore=yes;;
+*mingw32) fptools_cv_leading_underscore=yes;;
+*) AC_RUN_IFELSE([AC_LANG_SOURCE([[#ifdef HAVE_NLIST_H
 #include <nlist.h>
-changequote(<<, >>)dnl
-<<
 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
 #endif
 
-main(argc, argv)
+int main(argc, argv)
 int argc;
 char **argv;
 {
@@ -140,72 +176,94 @@ char **argv;
     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
         exit(1);
     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
-        exit(0);>>
-changequote([, ])dnl
+        exit(0);
 #endif
     exit(1);
-}], fptools_cv_lead_uscore=yes, fptools_cv_lead_uscore=no, fptools_cv_lead_uscore=NO)
+}]])],[fptools_cv_leading_underscore=yes],[fptools_cv_leading_underscore=no],[fptools_cv_leading_underscore=no])
 ;;
-esac);
-LeadingUnderscore=`echo $fptools_cv_lead_uscore | sed 'y/yesno/YESNO/'`
-AC_SUBST(LeadingUnderscore)
-case $LeadingUnderscore in
-YES) AC_DEFINE(LEADING_UNDERSCORE);;
-esac
-])
+esac]);
+AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
+if test x"$fptools_cv_leading_underscore" = xyes; then
+   AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
+fi])# FP_LEADING_UNDERSCORE
+
+
+# FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+# ----------------------------------------------------------------------------------
+# Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
+# to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
+AC_DEFUN([FP_COMPARE_VERSIONS],
+[fp_version1=$1; fp_version2=$3
+fp_save_IFS=$IFS; IFS='.'
+while test x"$fp_version1" != x || test x"$fp_version2" != x
+do
+
+  set dummy $fp_version1; shift
+  fp_num1=""
+  test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
+  test x"$fp_num1" = x && fp_num1="0"
+  fp_version1="[$]*"
+
+  set dummy $fp_version2; shift
+  fp_num2=""
+  test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
+  test x"$fp_num2" = x && fp_num2="0"
+  fp_version2="[$]*"
+
+  test "$fp_num1" = "$fp_num2" || break;
+done
+IFS=$fp_save_IFS
+AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
+])# FP_COMPARE_VERSIONS
+
 
 dnl
-dnl FPTOOLS_PROG_CHECK_VERSION(VERSIONSTR1, TEST, VERSIONSTR2,
-dnl                            ACTION-IF-TRUE [, ACTION-IF-FALSE])
-dnl
-dnl compare versions field-wise (separator is '.')
-dnl TEST is one of {-lt,-le,-eq,-ge,-gt}
-dnl
-dnl quite shell-independant and SUSv2 compliant code
-dnl
-dnl NOTE: the loop could be unrolled within autoconf, but the
-dnl       macro code would be a) longer and b) harder to debug... ;)
+dnl Check for GreenCard and version.
 dnl
-AC_DEFUN(FPTOOLS_PROG_CHECK_VERSION,
-[if ( IFS=".";
-      a="[$1]";  b="[$3]";
-      while test -n "$a$b"
-      do
-              set -- [$]a;  h1="[$]1";  shift 2>/dev/null;  a="[$]*"
-              set -- [$]b;  h2="[$]1";  shift 2>/dev/null;  b="[$]*"
-              test -n "[$]h1" || h1=0;  test -n "[$]h2" || h2=0
-              test [$]{h1} -eq [$]{h2} || break
-      done
-      test [$]{h1} [$2] [$]{h2}
-    )
-then ifelse([$4],,[:],[
-  $4])
-ifelse([$5],,,
-[else
-  $5])
+AC_DEFUN([FPTOOLS_GREENCARD],
+[
+AC_PATH_PROG(GreenCardCmd,greencard)
+AC_CACHE_CHECK([for version of greencard], fptools_cv_greencard_version,
+changequote(, )dnl
+[if test x"$GreenCardCmd" != x; then
+   fptools_cv_greencard_version="`$GreenCardCmd --version |
+                         grep 'version' | sed -e 's/greencard. version \([^ ]*\).*/\1/g'`"
+else
+   fptools_cv_greencard_version=""
 fi
-])])dnl
-
+changequote([, ])dnl
+])
+FP_COMPARE_VERSIONS([$fptools_cv_greencard_version],[-lt],[$1],
+  [AC_MSG_ERROR([greencard version $1 or later is required (found '$fptools_cv_greencard_version')])])[]dnl
+GreenCardVersion=$fptools_cv_greencard_version
+AC_SUBST(GreenCardVersion)
+])
 
 dnl
 dnl Check for Happy and version.  If we're building GHC, then we need
-dnl at least Happy version 1.13.  If there's no installed Happy, we look
+dnl at least Happy version 1.14.  If there's no installed Happy, we look
 dnl for a happy source tree and point the build system at that instead.
 dnl
-AC_DEFUN(FPTOOLS_HAPPY,
+AC_DEFUN([FPTOOLS_HAPPY],
 [
 if test -d $srcdir/happy; then
    SrcTreeHappyCmd=$hardtop/happy/src/happy-inplace
+else
+   SrcTreeHappyCmd=""
 fi
 if test x"$UseSrcTreeHappy" = xYES; then
-  HappyCmd=$SrcTreeHappyCmd
+  if test x"$SrcTreeHappyCmd" != x; then
+     HappyCmd=$SrcTreeHappyCmd
+  else
+     AC_MSG_ERROR([--enable-src-tree-happy given, but happy not found in source tree])
+  fi
 else
   AC_PATH_PROG(HappyCmd,happy,$SrcTreeHappyCmd)
 fi
 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
 changequote(, )dnl
-[if test x"$HappyCmd" = x"$SrcTreeHappyCmd"; then
-   fptools_cv_happy_version=`grep '^ProjectVersion[    ]*=' $srcdir/happy/mk/version.mk | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`;
+[if test x"$HappyCmd" = x"$SrcTreeHappyCmd" -a -e $srcdir/happy/mk/version.mk; then
+   fptools_cv_happy_version=`grep '^ProjectVersion[    ]*=' $srcdir/happy/mk/version.mk | sed 's/[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`;
 elif test x"$HappyCmd" != x; then
    fptools_cv_happy_version="`$HappyCmd -v |
                          grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'`" ;
@@ -215,8 +273,8 @@ fi;
 changequote([, ])dnl
 ])
 if test -d $srcdir/ghc -a ! -f $srcdir/ghc/compiler/parser/Parser.hs; then
-  FPTOOLS_PROG_CHECK_VERSION([$fptools_cv_happy_version],-lt,[1.13],
-  [AC_MSG_ERROR([Happy version 1.13 or later is required to compile GHC.])])dnl
+  FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.15],
+  [AC_MSG_ERROR([Happy version 1.15 or later is required to compile GHC.])])[]dnl
 fi
 HappyVersion=$fptools_cv_happy_version;
 AC_SUBST(HappyVersion)
@@ -226,13 +284,19 @@ dnl
 dnl Check for Haddock and version.  If there's no installed Haddock, we look
 dnl for a haddock source tree and point the build system at that instead.
 dnl
-AC_DEFUN(FPTOOLS_HADDOCK,
+AC_DEFUN([FPTOOLS_HADDOCK],
 [
 if test -d $srcdir/haddock; then
    SrcTreeHaddockCmd=$hardtop/haddock/src/haddock-inplace
+else
+   SrcTreeHaddockCmd=""
 fi
 if test x"$UseSrcTreeHaddock" = xYES; then
-  HaddockCmd=$SrcTreeHaddockCmd
+  if test x"$SrcTreeHaddockCmd" != x; then
+     HaddockCmd=$SrcTreeHaddockCmd
+  else
+     AC_MSG_ERROR([--enable-src-tree-haddock given, but haddock not found in source tree])
+  fi
 else
   AC_PATH_PROG(HaddockCmd,haddock,$SrcTreeHaddockCmd)
 fi
@@ -243,153 +307,241 @@ dnl do without it for now.
 ])
 
 dnl
-dnl What's the best way of doing context diffs?
-dnl
-dnl (NB: NeXTStep thinks diff'ing a file against itself is "trouble")
+dnl Check for Alex and version.  If we're building GHC, then we need
+dnl at least Alex version 2.0.  If there's no installed Alex, we look
+dnl for a alex source tree and point the build system at that instead.
 dnl
-AC_DEFUN(FPTOOLS_PROG_DIFF,
-[AC_CACHE_CHECK([for ok way to do context diffs], fptools_cv_context_diffs,
-[echo foo > conftest1
-echo foo > conftest2
-if diff -C 1 conftest1 conftest2 > /dev/null 2>&1 ; then
-    fptools_cv_context_diffs='diff -C 1'
+AC_DEFUN([FPTOOLS_ALEX],
+[
+if test -d $srcdir/alex; then
+   SrcTreeAlexCmd=$hardtop/alex/src/alex-inplace
 else
-    if diff -c1 conftest1 conftest2 > /dev/null 2>&1 ; then
-        fptools_cv_context_diffs='diff -c1'
-    else
-        echo "Can't figure out how to do context diffs."
-        echo "Neither \`diff -C 1' nor \`diff -c1' works."
-        exit 1
-    fi
+   SrcTreeAlexCmd=""
 fi
-rm -f conftest1 conftest2
-])
-ContextDiffCmd=$fptools_cv_context_diffs
-AC_SUBST(ContextDiffCmd)
-])
-
-dnl
-dnl Check whether ld supports -x
-dnl
-AC_DEFUN(FPTOOLS_LD_X,
-[AC_CACHE_CHECK([whether ld understands -x], fptools_cv_ld_x,
-[
-echo 'foo() {}' > conftest.c
-${CC-cc} -c conftest.c
-if ${LdCmd} -r -x -o foo.o conftest.o; then
-   fptools_cv_ld_x=yes
+if test x"$UseSrcTreeAlex" = xYES; then
+  if test x"$SrcTreeAlexCmd" != x; then
+     AlexCmd=$SrcTreeAlexCmd
+  else
+     AC_MSG_ERROR([--enable-src-tree-alex given, but alex not found in source tree])
+  fi
 else
-   fptools_cv_ld_x=no
+  AC_PATH_PROG(AlexCmd,alex,$SrcTreeAlexCmd)
 fi
-rm -rf conftest.c conftest.o foo.o
-])
-if test "$fptools_cv_ld_x" = yes; then
-       LdXFlag=-x
+AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
+changequote(, )dnl
+[if test x"$AlexCmd" = x"$SrcTreeAlexCmd"; then
+   fptools_cv_alex_version=`grep '^ProjectVersion[     ]*=' $srcdir/alex/mk/version.mk | sed 's/[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`;
+elif test x"$AlexCmd" != x; then
+   fptools_cv_alex_version="`$AlexCmd -v |
+                         grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'`" ;
 else
-       LdXFlag=
+   fptools_cv_alex_version="";
+fi;
+changequote([, ])dnl
+])
+if test -d $srcdir/ghc -a ! -f $srcdir/ghc/compiler/parser/Lexer.hs; then
+  FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[2.0],
+  [AC_MSG_ERROR([Alex version 2.0 or later is required to compile GHC.])])[]dnl
 fi
-AC_SUBST(LdXFlag)
+AlexVersion=$fptools_cv_alex_version;
+AC_SUBST(AlexVersion)
 ])
 
-dnl
-dnl Finding the Right Yacc
-dnl
-AC_DEFUN(FPTOOLS_PROG_YACCY,
-[AC_PROG_YACC
-if test "$YACC" = "yacc"; then
-   AC_CACHE_CHECK([if it is an OK yacc], ac_cv_prog_yacc,
-   [AC_CHECK_PROG(WhatCmd, what, what, :)
-    $WhatCmd $YACC > conftest.out
-    if egrep 'y1\.c 1\..*SMI' conftest.out >/dev/null 2>&1; then
-        echo "I don't trust your $YaccCmd; it looks like an old Sun yacc"
-        if test -f /usr/lang/yacc; then
-           echo "I'm going to use /usr/lang/yacc instead"
-           ac_cv_prog_yacc=/usr/lang/yacc
-        else
-           echo "I'm assuming the worst...no parser generator at all"
-           ac_cv_prog_yacc=:
-        fi
-    elif egrep 'y1\.c.*Revision: 4\.2\.6\.3.*DEC' conftest.out >/dev/null 2>&1; then
-        echo "I don't trust your $YaccCmd; it looks like a lame DEC yacc"
-        echo "I'm assuming the worst...no parser generator at all"
-        ac_cv_prog_yacc=:
-    else
-       ac_cv_prog_yacc=$YACC
-    fi
-    rm -fr conftest*
-])
+
+# FP_PROG_LD
+# ----------
+# Sets the output variable LdCmd to the (non-Cygwin version of the) full path
+# of ld. Exits if no ld can be found
+AC_DEFUN([FP_PROG_LD],
+[AC_PATH_PROG([fp_prog_ld_raw], [ld])
+if test -z "$fp_prog_ld_raw"; then
+  AC_MSG_ERROR([cannot find ld in your PATH, no idea how to link])
+fi
+LdCmd=$fp_prog_ld_raw
+case $HostPlatform in
+  *mingw32) if test x${OSTYPE} != xmsys; then
+             LdCmd="`cygpath -w ${fp_prog_ld_raw} | sed -e 's@\\\\@/@g'`"
+              AC_MSG_NOTICE([normalized ld command to $LdCmd])
+            fi
+           # Insist on >= ld-2.15.x, since earlier versions doesn't handle
+           # the generation of relocatable object files with large amounts
+           # of relocations correctly. (cf. HSbase.o splittage-hack)
+           fp_prog_ld_version=`${LdCmd} --version | sed -n '/GNU ld/p' | tr -cd 0-9 | cut -b1-3`
+           FP_COMPARE_VERSIONS([$fp_prog_ld_version],[-lt],[214],
+                                [AC_MSG_ERROR([GNU ld version later than 2.14 required to compile GHC on Windows.])])[]dnl
+            ;;
+esac
+AC_SUBST([LdCmd])
+])# FP_PROG_LD
+
+
+# FP_PROG_LD_X
+# ------------
+# Sets the output variable LdXFlag to -x if ld supports this flag, otherwise the
+# variable's value is empty.
+AC_DEFUN([FP_PROG_LD_X],
+[AC_REQUIRE([FP_PROG_LD])
+AC_CACHE_CHECK([whether ld understands -x], [fp_cv_ld_x],
+[echo 'foo() {}' > conftest.c
+${CC-cc} -c conftest.c
+if ${LdCmd} -r -x -o conftest2.o conftest.o > /dev/null 2>&1; then
+   fp_cv_ld_x=yes
 else
-    ac_cv_prog_yacc=$YACC
+   fp_cv_ld_x=no
 fi
-YaccCmd=$ac_cv_prog_yacc
-AC_SUBST(YaccCmd)
-])
-
-dnl *** Checking for ar and its arguments + whether we need ranlib.
-dnl
-dnl ArCmd, ArSupportsInput and RANLIB are AC_SUBST'ed
-dnl On Digital UNIX, we test for the -Z (compress) and
-dnl -input (take list of files from external file) flags.
-dnl 
-AC_DEFUN(FPTOOLS_PROG_AR_AND_RANLIB,
-[AC_PATH_PROG(ArCmdRaw,ar)
-if test -z "$ArCmdRaw"; then
-    echo "You don't seem to have ar in your PATH...I have no idea how to make a library"
-    exit 1;
+rm -rf conftest*])
+if test "$fp_cv_ld_x" = yes; then
+  LdXFlag=-x
+else
+  LdXFlag=
 fi
-if $ArCmdRaw clqsZ conftest.a >/dev/null 2>/dev/null; then
-    ArCmdArgs="clqsZ"
-    NeedRanLib=''
-elif $ArCmdRaw clqs conftest.a >/dev/null 2>/dev/null; then
-    ArCmdArgs="clqs"
-    NeedRanLib=''
-elif $ArCmdRaw cqs conftest.a >/dev/null 2>/dev/null; then
-    ArCmdArgs="cqs"
-    NeedRanLib=''
-elif $ArCmdRaw clq conftest.a >/dev/null 2>/dev/null; then
-    ArCmdArgs="clq"
-    NeedRanLib='YES'
-elif $ArCmdRaw cq conftest.a >/dev/null 2>/dev/null; then
-    ArCmdArgs="cq"
-    NeedRanLib='YES'
-elif $ArCmdRaw cq conftest.a 2>&1 | grep 'no archive members specified' >/dev/null 2>/dev/null; then
-    ArCmdArgs="cq"
-    NeedRanLib='YES'
+AC_SUBST([LdXFlag])
+])# FP_PROG_LD_X
+
+
+# FP_PROG_LD_IS_GNU
+# -----------------
+# Sets the output variable LdIsGNULd to YES or NO, depending on whether it is
+# GNU ld or not.
+AC_DEFUN([FP_PROG_LD_IS_GNU],
+[AC_REQUIRE([FP_PROG_LD])
+AC_CACHE_CHECK([whether ld is GNU ld], [fp_cv_gnu_ld],
+[if ${LdCmd} --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
+  fp_cv_gnu_ld=yes
 else
-    echo "I can't figure out how to use your $ArCmd"
-    exit 1
+  fp_cv_gnu_ld=no
+fi])
+AC_SUBST([LdIsGNULd], [`echo $fp_cv_gnu_ld | sed 'y/yesno/YESNO/'`])
+])# FP_PROG_LD_IS_GNU
+
+
+# FP_PROG_AR
+# ----------
+# Sets fp_prog_ar_raw to the full path of ar and fp_prog_ar to a non-Cygwin
+# version of it. Exits if no ar can be found
+AC_DEFUN([FP_PROG_AR],
+[AC_PATH_PROG([fp_prog_ar_raw], [ar])
+if test -z "$fp_prog_ar_raw"; then
+  AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
 fi
-rm -rf conftest*
+fp_prog_ar=$fp_prog_ar_raw
 case $HostPlatform in
- *mingw32) 
-         ArCmd="`cygpath -w ${ArCmdRaw} | sed -e 's@\\\\@/@g' ` ${ArCmdArgs}"
-         ;;
- *) ArCmd="${ArCmdRaw} ${ArCmdArgs}"
-    ;;
+  *mingw32) if test x${OSTYPE} != xmsys; then
+             fp_prog_ar="`cygpath -w ${fp_prog_ar_raw} | sed -e 's@\\\\@/@g'`"
+              AC_MSG_NOTICE([normalized ar command to $fp_prog_ar])
+            fi
+            ;;
 esac
-test -n "$ArCmd" && test -n "$verbose" && echo "        setting ArCmd to $ArCmd"
-AC_SUBST(ArCmd)
-if $ArCmd conftest.a -input /dev/null >/dev/null 2>/dev/null; then
-    ArSupportsInput='-input'
+])# FP_PROG_AR
+
+
+# FP_PROG_AR_IS_GNU
+# -----------------
+# Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
+AC_DEFUN([FP_PROG_AR_IS_GNU],
+[AC_REQUIRE([FP_PROG_AR])
+AC_CACHE_CHECK([whether $fp_prog_ar_raw is GNU ar], [fp_cv_prog_ar_is_gnu],
+[if $fp_prog_ar_raw --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
+  fp_cv_prog_ar_is_gnu=yes
 else
-    ArSupportsInput=''
+  fp_cv_prog_ar_is_gnu=no
+fi])
+fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
+])# FP_PROG_AR_IS_GNU
+
+
+# FP_PROG_AR_ARGS
+# ---------------
+# Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
+# to a non-Cygwin invocation of ar including these arguments.
+AC_DEFUN([FP_PROG_AR_ARGS],
+[AC_REQUIRE([FP_PROG_AR_IS_GNU])
+AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
+[
+# GNU ar needs special treatment: it appears to have problems with
+# object files with the same name if you use the 's' modifier, but
+# simple 'ar q' works fine, and doesn't need a separate ranlib.
+if test $fp_prog_ar_is_gnu = yes; then
+  fp_cv_prog_ar_args="q"
+else
+  touch conftest.dummy
+  for fp_var in clqsZ clqs cqs clq cq ; do
+     rm -f conftest.a
+     if $fp_prog_ar_raw $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
+        fp_cv_prog_ar_args=$fp_var
+        break
+     fi
+  done
+  rm -f conftest*
+  if test -z "$fp_cv_prog_ar_args"; then
+    AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar_raw])
+  fi
+fi])
+fp_prog_ar_args=$fp_cv_prog_ar_args
+AC_SUBST([ArCmd], ["$fp_prog_ar $fp_prog_ar_args"])
+
+])# FP_PROG_AR_ARGS
+
+
+# FP_PROG_AR_NEEDS_RANLIB
+# -----------------------
+# Sets the output variable RANLIB to "ranlib" if it is needed and found,
+# to ":" otherwise.
+AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],
+[AC_REQUIRE([FP_PROG_AR_IS_GNU])
+AC_REQUIRE([FP_PROG_AR_ARGS])
+AC_REQUIRE([AC_PROG_CC])
+AC_CACHE_CHECK([whether ranlib is needed], [fp_cv_prog_ar_needs_ranlib],
+[if test $fp_prog_ar_is_gnu = yes; then
+  fp_cv_prog_ar_needs_ranlib=no
+elif echo $TargetPlatform | grep "^.*-apple-darwin$"  > /dev/null 2> /dev/null; then
+  # It's quite tedious to check for Apple's crazy timestamps in .a files,
+  # so we hardcode it.
+  fp_cv_prog_ar_needs_ranlib=yes
+elif echo $fp_prog_ar_args | grep "s" > /dev/null 2> /dev/null; then
+  fp_cv_prog_ar_needs_ranlib=no
+else
+  fp_cv_prog_ar_needs_ranlib=yes
+fi])
+if test $fp_cv_prog_ar_needs_ranlib = yes; then
+   AC_PROG_RANLIB
+else
+  RANLIB=":"
+  AC_SUBST([RANLIB])
 fi
-rm -rf conftest*
-test -n "$ArSupportsInput" && test -n "$verbose" && echo "        setting ArSupportsInput to $ArSupportsInput"
-AC_SUBST(ArSupportsInput)
-if test -z "$NeedRanLib"; then
-    RANLIB=':'
-    test -n "$verbose" && echo "        setting RANLIB to $RANLIB"
-    AC_SUBST(RANLIB)
+])# FP_PROG_AR_NEEDS_RANLIB
+
+
+# FP_PROG_AR_SUPPORTS_INPUT
+# -------------------------
+# Sets the output variable ArSupportsInput to "-input" or "", depending on
+# whether ar supports -input flag is supported or not.
+AC_DEFUN([FP_PROG_AR_SUPPORTS_INPUT],
+[AC_REQUIRE([FP_PROG_AR_IS_GNU])
+AC_REQUIRE([FP_PROG_AR_ARGS])
+AC_CACHE_CHECK([whether $fp_prog_ar_raw supports -input], [fp_cv_prog_ar_supports_input],
+[fp_cv_prog_ar_supports_input=no
+if test $fp_prog_ar_is_gnu = no; then
+  rm -f conftest*
+  touch conftest.lst
+  if FP_EVAL_STDERR([$fp_prog_ar_raw $fp_prog_ar_args conftest.a -input conftest.lst]) >/dev/null; then
+    test -s conftest.err || fp_cv_prog_ar_supports_input=yes
+  fi
+  rm -f conftest*
+fi])
+if test $fp_cv_prog_ar_supports_input = yes; then
+    ArSupportsInput="-input"
 else
-    AC_PROG_RANLIB
+    ArSupportsInput=""
 fi
-])
+AC_SUBST([ArSupportsInput])
+])# FP_PROG_AR_SUPPORTS_INPUT
+
 
 dnl
 dnl AC_SHEBANG_PERL - can we she-bang perl?
 dnl
-AC_DEFUN(FPTOOLS_SHEBANG_PERL,
+AC_DEFUN([FPTOOLS_SHEBANG_PERL],
 [AC_CACHE_CHECK([if your perl works in shell scripts], fptools_cv_shebang_perl,
 [echo "#!$PerlCmd"'
 exit $1;
@@ -404,63 +556,53 @@ fi
 rm -f conftest
 ])])
 
-dnl
-dnl Extra testing of the result AC_PROG_CC, testing the gcc version no.
-dnl *Must* be called after AC_PROG_CC
-dnl
-AC_DEFUN(FPTOOLS_HAVE_GCC,
-[AC_CACHE_CHECK([whether you have an ok gcc], fptools_cv_have_gcc,
-[if test -z "$GCC"; then
-    echo ''
-    echo "You would be better off with gcc"
-    echo "Perhaps it is already installed, but not in your PATH?"
-    fptools_cv_have_gcc='no'
+
+# FP_HAVE_GCC
+# -----------
+# Extra testing of the result AC_PROG_CC, testing the gcc version no. Sets the
+# output variables HaveGcc and GccVersion.
+AC_DEFUN([FP_HAVE_GCC],
+[AC_REQUIRE([AC_PROG_CC])
+if test -z "$GCC"; then
+   fp_have_gcc=NO
 else
-changequote(, )dnl
-    gcc_version_str="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [^0-9]*\([0-9][0-9]*\)\.\([0-9][0-9]*\).*/\1\.\2/g' `"
-changequote([, ])dnl
-    fptools_cv_have_gcc='yes'
-    FPTOOLS_PROG_CHECK_VERSION($gcc_version_str, -lt, "2.0",
-        fptools_cv_have_gcc='no'
-        echo ""
-       echo "your gcc version appears to be ..."
-        $CC --version
-        echo "gcc prior to 2.0 and have never worked with ghc."
-        echo "we recommend 2.95.3, although versions back to 2.7.2 should be ok."
-        AC_MSG_ERROR([gcc 1.X has never been supported])
-    )
+   fp_have_gcc=YES
 fi
+if test "$fp_have_gcc" = "NO" -a -d $srcdir/ghc; then
+  AC_MSG_ERROR([gcc is required])
+fi
+AC_CACHE_CHECK([version of gcc], [fp_gcc_version],
+[if test "$fp_have_gcc" = "YES"; then
+   fp_gcc_version="`$CC -v 2>&1 | grep 'version ' | sed -e 's/.*version [[^0-9]]*\([[0-9.]]*\).*/\1/g'`"
+   FP_COMPARE_VERSIONS([$fp_gcc_version], [-lt], [2.0],
+     [AC_MSG_ERROR([Need at least gcc version 2.0 (3.4+ recommended)])])
+ else
+   fp_gcc_version="not-installed"
+ fi
 ])
-HaveGcc=`echo $fptools_cv_have_gcc | sed 'y/yesno/YESNO/'`
-AC_SUBST(HaveGcc)
-])
+AC_SUBST([HaveGcc], [$fp_have_gcc])
+AC_SUBST([GccVersion], [$fp_gcc_version])
+])# FP_HAVE_GCC
 
-dnl
-dnl Some OSs (Mandrake Linux, in particular) configure GCC with
-dnl -momit-leaf-frame-pointer on by default.  If this is the case, we
-dnl need to turn it off for mangling to work.  The test is currently a bit
-dnl crude, using only the version number of gcc.
-dnl
-AC_DEFUN(FPTOOLS_GCC_NEEDS_NO_OMIT_LFPTR,
-[AC_CACHE_CHECK([whether gcc needs -mno-omit-leaf-frame-pointer], fptools_cv_gcc_needs_no_omit_lfptr,
+AC_DEFUN([FP_MINGW_GCC],
 [
- fptools_cv_gcc_needs_no_omit_lfptr='no'
- FPTOOLS_PROG_CHECK_VERSION($gcc_version_str, -ge, "3.2",
-     fptools_cv_gcc_needs_no_omit_lfptr='yes')
-])
-if test "$fptools_cv_gcc_needs_no_omit_lfptr" = "yes"; then
-   AC_DEFINE(HAVE_GCC_MNO_OMIT_LFPTR)
-fi
+  case $HostOS_CPP in
+    mingw*)  AC_MSG_CHECKING([whether $CC is a mingw gcc])
+            if $CC -v 2>&1 | grep mingw >/dev/null; then
+               AC_MSG_RESULT([yes])
+            else
+               AC_MSG_RESULT([no])
+               AC_MSG_ERROR([Please use --with-gcc to specify a mingw gcc])
+            fi;;
+    *) ;;      
+  esac
 ])
 
 dnl Small feature test for perl version. Assumes PerlCmd
 dnl contains path to perl binary
 dnl
-AC_DEFUN(FPTOOLS_CHECK_PERL_VERSION,
+AC_DEFUN([FPTOOLS_CHECK_PERL_VERSION],
 [$PerlCmd -v >conftest.out 2>&1
-if grep "version 5" conftest.out >/dev/null 2>&1; then
-   :
-else
    if grep "v5.6" conftest.out >/dev/null 2>&1; then
       :
    else
@@ -470,36 +612,62 @@ else
          if grep "version 6" conftest.out >/dev/null 2>&1; then
             :
          else
-            echo "Your version of perl probably won't work."
-         fi  
+            AC_MSG_ERROR([your version of perl probably won't work, try upgrading it.])
+         fi
       fi
    fi
-fi
 rm -fr conftest*
 ])
 
-dnl
-dnl Getting at the right version of 'find'
-dnl (i.e., not the MS util on a Win32 box).
-dnl
-AC_DEFUN(FPTOOLS_FIND_FIND,
-[
-AC_PATH_PROG(Find2Cmd, find)
-$Find2Cmd --version > conftest.out 2>&1 
-if grep "FIND: Parameter format" conftest.out >/dev/null 2>&1 ; then
-   # Encountered MS' find utility, which is not what we're after.
-   #
-   # HACK - AC_CHECK_PROG is useful here in that does let you reject
-   # an (absolute) entry in the path (Find2Cmd). It is not so useful
-   # in that it doesn't let you (AFAIU) set VARIABLE equal to the 
-   # absolute path eventually found. So, hack around this by inspecting
-   # what variables hold the abs. path & use them directly.
-   AC_CHECK_PROG(FindCmd,find,`echo $ac_dir/$ac_word`,find,,$Find2Cmd)
+
+# FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
+#               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
+# -----------------------------------------------------
+# HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
+# of PROG-TO-CHECK-FOR when found.
+AC_DEFUN([FP_CHECK_PROG],
+[AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
+)# FP_CHECK_PROC
+
+
+# FP_PROG_FIND
+# ------------
+# Find a non-WinDoze version of the "find" utility.
+AC_DEFUN([FP_PROG_FIND],
+[AC_PATH_PROG([fp_prog_find], [find])
+echo foo > conftest.txt
+$fp_prog_find conftest.txt -print > conftest.out 2>&1
+if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
+  # OK, looks like a real "find".
+  FindCmd="$fp_prog_find"
 else
-FindCmd=$Find2Cmd
-AC_SUBST(FindCmd)
+  # Found a poor WinDoze version of "find", ignore it.
+  AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
+  FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
 fi
-])
+rm -f conftest.txt conftest.out
+AC_SUBST([FindCmd])[]dnl
+])# FP_PROG_FIND
+
+
+# FP_PROG_SORT
+# ------------
+# Find a Unix-like sort
+AC_DEFUN([FP_PROG_SORT],
+[AC_PATH_PROG([fp_prog_sort], [sort])
+echo conwip > conftest.txt
+$fp_prog_sort -f conftest.txt > conftest.out 2>&1
+if grep 'conwip' conftest.out > /dev/null 2>&1 ; then
+  # The goods
+  SortCmd="$fp_prog_sort"
+else
+  # Summink else..pick next one.
+  AC_MSG_WARN([$fp_prog_sort looks like a non-*nix sort, ignoring it])
+  FP_CHECK_PROG([SortCmd], [sort], [], [], [$fp_prog_sort])
+fi
+rm -f conftest.txt conftest.out
+AC_SUBST([SortCmd])[]dnl
+])# FP_PROG_SORT
 
 dnl
 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
@@ -508,7 +676,7 @@ dnl the commands given by the third. It does not cache its
 dnl result, so it is suitable for checks which should be
 dnl run every time.
 dnl
-AC_DEFUN(FPTOOLS_NOCACHE_CHECK,
+AC_DEFUN([FPTOOLS_NOCACHE_CHECK],
 [AC_MSG_CHECKING([$1])
  $3
  AC_MSG_RESULT([$][$2])
@@ -522,10 +690,10 @@ dnl
 dnl Test for version of installed ghc.  Uses $GHC.
 dnl [original version pinched from c2hs]
 dnl
-AC_DEFUN(FPTOOLS_GHC_VERSION,
+AC_DEFUN([FPTOOLS_GHC_VERSION],
 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
 ["${WithGhc-ghc}" --version > conftestghc 2>&1
-  cat conftestghc >&AC_FD_CC
+  cat conftestghc >&AS_MESSAGE_LOG_FD
 #Useless Use Of cat award...
   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
   rm -fr conftest*
@@ -564,103 +732,82 @@ ifelse($#, [1], [dnl
 ])dnl
 
 
-dnl ** figure out the alignment restriction of a type
-dnl    (required SIZEOF test but AC_CHECK_SIZEOF doesn't call PROVIDE
-dnl     so we can't call REQUIRE)
-
-dnl FPTOOLS_CHECK_ALIGNMENT(TYPE)
-AC_DEFUN(FPTOOLS_CHECK_ALIGNMENT,
-[changequote(<<, >>)dnl
-dnl The name to #define.
-define(<<AC_TYPE_NAME>>, translit(alignment_$1, [a-z *], [A-Z_P]))dnl
-dnl The cache variable name.
-define(<<AC_CV_NAME>>, translit(ac_cv_alignment_$1, [ *], [_p]))dnl
-dnl The name of the corresponding size.
-define(<<AC_CV_SIZEOF_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
-changequote([, ])dnl
-AC_MSG_CHECKING(alignment of $1)
-AC_CACHE_VAL(AC_CV_NAME,
-[AC_TRY_RUN([
-#include <stdio.h>
-#if HAVE_STDDEF_H
-#include <stddef.h>
-#endif
-#ifndef offsetof
-#define offsetof(ty,field) ((size_t)((char *)&((ty *)0)->field - (char *)(ty *)0))
-#endif
-int
-main()
-{
-  FILE *f=fopen("conftestval", "w");
-  if (!f) exit(1);
-  fprintf(f, "%d", offsetof(struct { char c; $1 ty;},ty));
-  exit(0);
-}],
-AC_CV_NAME=`cat conftestval`,
-AC_CV_NAME=$AC_CV_SIZEOF_NAME,
-AC_CV_NAME=$AC_CV_SIZEOF_NAME)])
-AC_MSG_RESULT($AC_CV_NAME)
-AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME)
-AC_PROVIDE($AC_TYPE_NAME)
-undefine([AC_TYPE_NAME])dnl
-undefine([AC_CV_NAME])dnl
-undefine([AC_CV_SIZEOF_NAME])dnl
-])
-
 dnl ** Map an arithmetic C type to a Haskell type.
 dnl    Based on autconf's AC_CHECK_SIZEOF.
 
 dnl FPTOOLS_CHECK_HTYPE(TYPE [, DEFAULT_VALUE, [, VALUE-FOR-CROSS-COMPILATION])
-AC_DEFUN(FPTOOLS_CHECK_HTYPE,
+AC_DEFUN([FPTOOLS_CHECK_HTYPE],
 [changequote(<<, >>)dnl
 dnl The name to #define.
 define(<<AC_TYPE_NAME>>, translit(htype_$1, [a-z *], [A-Z_P]))dnl
 dnl The cache variable name.
 define(<<AC_CV_NAME>>, translit(fptools_cv_htype_$1, [ *], [_p]))dnl
+define(<<AC_CV_NAME_supported>>, translit(fptools_cv_htype_sup_$1, [ *], [_p]))dnl
 changequote([, ])dnl
 AC_MSG_CHECKING(Haskell type for $1)
 AC_CACHE_VAL(AC_CV_NAME,
-[AC_TRY_RUN([#include <stdio.h>
+[AC_CV_NAME_supported=yes
+fp_check_htype_save_cppflags="$CPPFLAGS"
+CPPFLAGS="$CPPFLAGS $X_CFLAGS"
+AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdio.h>
 #include <stddef.h>
 
-#ifdef HAVE_SYS_TYPES_H
+#if HAVE_SYS_TYPES_H
 # include <sys/types.h>
 #endif
 
-#ifdef HAVE_UNISTD_H
+#if HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 
-#ifdef HAVE_SYS_STAT_H
+#if HAVE_SYS_STAT_H
 # include <sys/stat.h>
 #endif
 
-#ifdef HAVE_FCNTL_H
+#if HAVE_FCNTL_H
 # include <fcntl.h>
 #endif
 
-#ifdef HAVE_SIGNAL_H
+#if HAVE_SIGNAL_H
 # include <signal.h>
 #endif
 
-#ifdef HAVE_TIME_H
+#if HAVE_TIME_H
 # include <time.h>
 #endif
 
-#ifdef HAVE_TERMIOS_H
+#if HAVE_TERMIOS_H
 # include <termios.h>
 #endif
 
-#ifdef HAVE_STRING_H
+#if HAVE_STRING_H
 # include <string.h>
 #endif
 
-#ifdef HAVE_CTYPE_H
+#if HAVE_CTYPE_H
 # include <ctype.h>
 #endif
 
-#ifdef HAVE_GL_GL_H
+#if defined(HAVE_GL_GL_H)
 # include <GL/gl.h>
+#elif defined(HAVE_OPENGL_GL_H)
+# include <OpenGL/gl.h>
+#endif
+
+#if defined(HAVE_AL_AL_H)
+# include <AL/al.h>
+#elif defined(HAVE_OPENAL_AL_H)
+# include <OpenAL/al.h>
+#endif
+
+#if defined(HAVE_AL_ALC_H)
+# include <AL/alc.h>
+#elif defined(HAVE_OPENAL_ALC_H)
+# include <OpenAL/alc.h>
+#endif
+
+#if HAVE_SYS_RESOURCE_H
+# include <sys/resource.h>
 #endif
 
 typedef $1 testing;
@@ -679,648 +826,306 @@ main() {
   }
   fclose(f);
   exit(0);
-}], AC_CV_NAME=`cat conftestval`,
-ifelse([$2], , AC_CV_NAME=NotReallyAType,      AC_CV_NAME=$2),
-ifelse([$3], , AC_CV_NAME=NotReallyATypeCross, AC_CV_NAME=$3))]) dnl
-AC_MSG_RESULT($AC_CV_NAME)
-AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME)
+}]])],[AC_CV_NAME=`cat conftestval`],
+[ifelse([$2], , [AC_CV_NAME=NotReallyAType; AC_CV_NAME_supported=no], [AC_CV_NAME=$2])],
+[ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], [AC_CV_NAME=$3])])
+CPPFLAGS="$fp_check_htype_save_cppflags"]) dnl
+if test "$AC_CV_NAME_supported" = yes; then
+  AC_MSG_RESULT($AC_CV_NAME)
+  AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to Haskell type for $1])
+else
+  AC_MSG_RESULT([not supported])
+fi
 undefine([AC_TYPE_NAME])dnl
 undefine([AC_CV_NAME])dnl
+undefine([AC_CV_NAME_supported])dnl
 ])
 
-dnl ** figure out whether C compiler supports 'long long's
-dnl    (Closely based on Andreas Zeller's macro for testing
-dnl     for this under C++)
-dnl
-dnl    If the C compiler supports `long long' types,
-dnl    define `HAVE_LONG_LONG'.
-dnl
-AC_DEFUN(FPTOOLS_C_LONG_LONG,
-[
-AC_REQUIRE([AC_PROG_CC])
-AC_MSG_CHECKING(whether ${CC} supports long long types)
-AC_CACHE_VAL(fptools_cv_have_long_long,
-[
-AC_LANG_SAVE
-AC_LANG_C
-AC_TRY_COMPILE(,[long long a;],
-fptools_cv_have_long_long=yes,
-fptools_cv_have_long_long=no)
-AC_LANG_RESTORE
-])
-AC_MSG_RESULT($fptools_cv_have_long_long)
-if test "$fptools_cv_have_long_long" = yes; then
-AC_DEFINE(HAVE_LONG_LONG)
-fi
-])
 
-dnl ** Obtain the value of a C constant.
-dnl    The value will be `(-1)' if the constant is undefined.
-dnl
-dnl    This is set up so that the argument can be a shell variable.
-dnl
-AC_DEFUN(FPTOOLS_CHECK_CCONST,
-[
-eval "cv_name=ac_cv_cconst_$1"
-AC_MSG_CHECKING(value of $1)
-AC_CACHE_VAL($cv_name,
-[AC_TRY_RUN([#include <stdio.h>
-#include <errno.h>
-main()
-{
-  FILE *f=fopen("conftestval", "w");
-  if (!f) exit(1);
-  fprintf(f, "%d\n", $1);
-  exit(0);
-}], 
-eval "$cv_name=`cat conftestval`",
-eval "$cv_name=-1",
-eval "$cv_name=-1")])dnl
-eval "fptools_check_cconst_result=`echo '$'{$cv_name}`"
-AC_MSG_RESULT($fptools_check_cconst_result)
-AC_DEFINE_UNQUOTED(CCONST_$1, $fptools_check_cconst_result)
-unset fptools_check_cconst_result
-])
-
-dnl ** Invoke AC_CHECK_CCONST on each argument (which have to separate with 
-dnl    spaces)
-dnl
-AC_DEFUN(FPTOOLS_CHECK_CCONSTS,
-[for ac_const_name in $1
-do
-FPTOOLS_CHECK_CCONST($ac_const_name)dnl
-done
-])
+# FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# ---------------------------------------------------------------------------------
+# A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
+# additional flexibility of specifying the PROLOGUE and BODY.
+AC_DEFUN([FP_CHECK_FUNC],
+[AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
+AC_CACHE_CHECK([for $1], fp_func,
+[AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
+                [AS_VAR_SET(fp_func, yes)],
+                [AS_VAR_SET(fp_func, no)])])
+AS_IF([test AS_VAR_GET(fp_func) = yes],
+      [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
+                [Define to 1 if you have the `]$1[' function.]) $4],
+      [$5])dnl
+AS_VAR_POPDEF([fp_func])dnl
+])# FP_CHECK_FUNC
+
+
+# FP_GEN_DOCBOOK_XML
+# ------------------
+# Generates a DocBook XML V4.2 document in conftest.xml.
+AC_DEFUN([FP_GEN_DOCBOOK_XML],
+[rm -f conftest.xml
+cat > conftest.xml << EOF
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
+   "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
+<book id="test">
+  <title>A DocBook Test Document</title>
+  <chapter id="id-one">
+    <title>A Chapter Title</title>
+    <para>This is a paragraph, referencing <xref linkend="id-two"/>.</para>
+  </chapter>
+  <chapter id="id-two">
+    <title>Another Chapter Title</title>
+    <para>This is another paragraph, referencing <xref linkend="id-one"/>.</para>
+  </chapter>
+</book>
+EOF
+]) # FP_GEN_DOCBOOK_XML
 
 
-dnl *** Can we open files in binary mode? ***
-dnl 
-AC_DEFUN(FPTOOLS_O_BINARY,
-[
-AC_REQUIRE([AC_PROG_CC])
-AC_MSG_CHECKING(whether we can open files in binary mode)
-AC_CACHE_VAL(fptools_cv_have_o_binary,
-[
-AC_LANG_SAVE
-AC_LANG_C
-AC_TRY_COMPILE(,
-[#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-int x = O_BINARY;],
-fptools_cv_have_o_binary=yes,
-fptools_cv_have_o_binary=no)
-AC_LANG_RESTORE
-])
-AC_MSG_RESULT($fptools_cv_have_o_binary)
-if test "$fptools_cv_have_o_binary" = yes; then
-AC_DEFINE(HAVE_O_BINARY)
+# FP_PROG_XSLTPROC
+# ----------------
+# Sets the output variable XsltprocCmd to the full path of the XSLT processor
+# xsltproc. XsltprocCmd is empty if xsltproc could not be found.
+AC_DEFUN([FP_PROG_XSLTPROC],
+[AC_PATH_PROG([XsltprocCmd], [xsltproc])
+if test -z "$XsltprocCmd"; then
+  AC_MSG_WARN([cannot find xsltproc in your PATH, you will not be able to build the documentation])
 fi
-])
-
-dnl *** Helper function **
-dnl 
-AC_DEFUN(FPTOOLS_IN_SCOPE,
-[AC_TRY_LINK([extern char* $1;],[return (int)&$2], $3=yes, $3=no)
-])
-
-
-dnl Based on AC_TRY_LINK - run iftrue if links cleanly with no warning
-
-dnl FPTOOLS_TRY_LINK_NOWARN(flags,main?,iftrue,iffalse)
-
-AC_DEFUN(FPTOOLS_TRY_LINK_NOWARN,
-[
-ac_save_LIBS="$LIBS"
-LIBS=[$1];
-cat > conftest.$ac_ext <<EOF
-dnl This sometimes fails to find confdefs.h, for some reason.
-dnl [#]line __oline__ "[$]0"
-[#]line __oline__ "configure"
-#include "confdefs.h"
-[$2]
-int t() { return 0; }
-EOF
-if AC_TRY_EVAL(ac_link); then
-  ifelse([$3], , :, [
-    LIBS="$ac_save_LIBS"
-    rm -rf conftest*
-    $3])
-  ifelse([$4], , , [else
-    LIBS="$ac_save_LIBS"
-    rm -rf conftest*
-    $4
-])dnl
+])# FP_PROG_XSLTPROC
+
+
+# FP_DIR_DOCBOOK_XSL(XSL-DIRS)
+# ----------------------------
+# Check which of the directories XSL-DIRS contains DocBook XSL stylesheets. The
+# output variable DIR_DOCBOOK_XSL will contain the first usable directory or
+# will be empty if none could be found.
+AC_DEFUN([FP_DIR_DOCBOOK_XSL],
+[AC_REQUIRE([FP_PROG_XSLTPROC])dnl
+if test -n "$XsltprocCmd"; then
+  AC_CACHE_CHECK([for DocBook XSL stylesheet directory], fp_cv_dir_docbook_xsl,
+  [FP_GEN_DOCBOOK_XML
+  fp_cv_dir_docbook_xsl=no
+  for fp_var in $1; do
+     if $XsltprocCmd ${fp_var}/html/docbook.xsl conftest.xml > /dev/null 2>&1; then
+        fp_cv_dir_docbook_xsl=$fp_var
+        break
+     fi
+  done
+  rm -rf conftest*])
 fi
-rm -f conftest*
-]
-)
-
-dnl Loosely based on AC_CHECK_LIB in acgeneral.m4 in autoconf distribution
-
-dnl FPTOOLS_CHECK_FLAG_NOWARN(NAME, FLAG, CODE, iftrue, iffalse)
-
-AC_DEFUN(FPTOOLS_CHECK_FLAG_NOWARN,
-[AC_MSG_CHECKING([for $1])
- AC_CACHE_VAL(ac_cv_flag_$1,
-   [FPTOOLS_TRY_LINK_NOWARN("$2", [main() { $3; exit(0); } ],
-     eval "ac_cv_flag_$1=yes",
-     eval "ac_cv_flag_$1=no"
-   )]
- )
-if eval "test \"`echo '$ac_cv_flag_'$1`\" = yes"; then
-  AC_MSG_RESULT(yes)
-  LIBS="$2 $LIBS"
-  $4
+if test x"$fp_cv_dir_docbook_xsl" = xno; then
+  AC_MSG_WARN([cannot find DocBook XSL stylesheets, you will not be able to build the documentation])
+  DIR_DOCBOOK_XSL=
 else
-  AC_MSG_RESULT(no)
-  $5
+  DIR_DOCBOOK_XSL=$fp_cv_dir_docbook_xsl
 fi
-])
-
-dnl FPTOOLS_CHECK_LIB_NOWARN(LIBRARY, FUNCTION)
-
-AC_DEFUN(FPTOOLS_CHECK_LIB_NOWARN,
-[FPTOOLS_CHECK_FLAG_NOWARN([function_$2],[],[extern char $2(); $2();],
-[changequote(, )dnl
-  ac_tr_lib=HAVE_LIB`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
- changequote([, ])dnl
- AC_DEFINE_UNQUOTED($ac_tr_lib)
-],
-[FPTOOLS_CHECK_FLAG_NOWARN([library_$1],[-l$1],[extern char $2(); $2();],
-[changequote(, )dnl
-  ac_tr_lib=HAVE_LIB`echo $1 | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
- changequote([, ])dnl
- AC_DEFINE_UNQUOTED($ac_tr_lib)
-],
-[]
-)])]
-)
-
-dnl check for prototypes
-dnl
-AC_DEFUN([AC_C_PROTOTYPES],
-[AC_CACHE_CHECK([prototypes], ac_cv_prototypes,
-[AC_TRY_COMPILE([
-void foo(int);
-void foo(i)
-int i; { 
-return;
-}
-],
-[int i;], 
-ac_cv_prototypes=yes,
-ac_cv_prototypes=no)])
-if test "$ac_cv_prototypes" = yes; then
-AC_DEFINE([HAVE_PROTOTYPES])
+AC_SUBST([DIR_DOCBOOK_XSL])
+])# FP_DIR_DOCBOOK_XSL
+
+
+# FP_PROG_XMLLINT
+# ----------------
+# Sets the output variable XmllintCmd to the full path of the XSLT processor
+# xmllint. XmllintCmd is empty if xmllint could not be found.
+AC_DEFUN([FP_PROG_XMLLINT],
+[AC_PATH_PROG([XmllintCmd], [xmllint])
+if test -z "$XmllintCmd"; then
+  AC_MSG_WARN([cannot find xmllint in your PATH, you will not be able to validate your documentation])
 fi
-])
-
-dnl ** Check which CATALOG file we have to use with DocBook SGML.
-dnl
-dnl FPTOOLS_DOCBOOK_CATALOG(VARIABLE, JADE, STYLESHEET, CATALOGS-TO-CHECK-FOR)
-dnl
-dnl If any of the catalogs given in CATALOGS-TO-CHECK-FOR works on this
-dnl platform, let VARIABLE refer to this catalog; otherwise, VARIABLE
-dnl is set to "no".  JADE is the jade executable and STYLESHEET
-dnl a DocBook style sheet.
-dnl
-AC_DEFUN(FPTOOLS_DOCBOOK_CATALOG,
-[AC_CACHE_CHECK([for DocBook CATALOG], fptools_cv_sgml_catalog,
-[
-cat > conftest.sgml << EOF
-<!DOCTYPE Article PUBLIC "-//OASIS//DTD DocBook V3.1//EN">
-<Article>
-<ArtHeader>
-<Title>Test</Title>
-<Author><OtherName>Test</OtherName></Author>
-<Address>Test</Address>
-<PubDate>Test</PubDate>
-</ArtHeader>
-<Sect1><Title>Test</Title>
-<Para>
-Test.
-</Para>
-</Sect1>
-</Article>
+])# FP_PROG_XMLLINT
+
+
+# FP_CHECK_DOCBOOK_DTD
+# --------------------
+AC_DEFUN([FP_CHECK_DOCBOOK_DTD],
+[AC_REQUIRE([FP_PROG_XMLLINT])dnl
+if test -n "$XmllintCmd"; then
+  AC_MSG_CHECKING([for DocBook DTD])
+  FP_GEN_DOCBOOK_XML
+  if $XmllintCmd --valid --noout conftest.xml > /dev/null 2>&1; then
+    AC_MSG_RESULT([ok])
+  else
+    AC_MSG_RESULT([failed])
+    AC_MSG_WARN([cannot find a DTD for DocBook XML V4.2, you will not be able to validate your documentation])
+    AC_MSG_WARN([check your XML_CATALOG_FILES environment variable and/or /etc/xml/catalog])
+  fi
+  rm -rf conftest*
+fi
+])# FP_CHECK_DOCBOOK_DTD
+
+
+# FP_GEN_FO
+# ------------------
+# Generates a formatting objects document in conftest.fo.
+AC_DEFUN([FP_GEN_FO],
+[rm -f conftest.fo
+cat > conftest.fo << EOF
+<?xml version="1.0"?>
+<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
+  <fo:layout-master-set>
+    <fo:simple-page-master master-name="blank">
+      <fo:region-body/>
+    </fo:simple-page-master>
+  </fo:layout-master-set>
+  <fo:page-sequence master-reference="blank">
+    <fo:flow flow-name="xsl-region-body">
+      <fo:block>
+        Test!
+      </fo:block>
+    </fo:flow>
+  </fo:page-sequence>
+</fo:root>
 EOF
-fptools_cv_sgml_catalog=no
-if test -z "$SGML_CATALOG_FILES" ; then
- for fptools_catalog in $4; do
-   ac_try="$2 -t rtf -d $3#print -c $fptools_catalog conftest.sgml"
-   if AC_TRY_EVAL(ac_try); then
-     fptools_cv_sgml_catalog=[$]fptools_catalog
-     break
-   fi
- done
-else
-# If the env var SGML_CATALOG_FILES is defined, assume things are cool.
-  fptools_cv_sgml_catalog="yes"
+]) # FP_GEN_FO
+
+
+# FP_PROG_FOP
+# -----------
+# Set the output variable 'FopCmd' to the first working 'fop' in the current
+# 'PATH'. Note that /usr/bin/fop is broken in SuSE 9.1 (unpatched), so try
+# /usr/share/fop/fop.sh in that case (or no 'fop'), too.
+AC_DEFUN([FP_PROG_FOP],
+[AC_PATH_PROGS([FopCmd1], [fop])
+if test -n "$FopCmd1"; then
+  AC_CACHE_CHECK([for $FopCmd1 usability], [fp_cv_fop_usability],
+    [FP_GEN_FO
+    if "$FopCmd1" -fo conftest.fo -ps conftest.ps > /dev/null 2>&1; then
+      fp_cv_fop_usability=yes
+    else
+      fp_cv_fop_usability=no
+    fi
+    rm -rf conftest*])
+  if test x"$fp_cv_fop_usability" = xyes; then
+     FopCmd=$FopCmd1
+  fi
 fi
-])
-rm -rf conftest*
-if test $fptools_cv_sgml_catalog != "no"; then
-  $1=$fptools_cv_sgml_catalog
+if test -z "$FopCmd"; then
+  AC_PATH_PROGS([FopCmd2], [fop.sh], , [/usr/share/fop])
+  FopCmd=$FopCmd2
 fi
-])
-
-dnl ######################################################################
-dnl FPTOOLS_SEARCH_LIBS(INCLUDES, FUNCTION, SEARCH-LIBS [, ACTION-IF-FOUND
-dnl                     [, ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
-dnl Search for a library defining FUNC, if it's not already available.
-dnl This is almost the same as AC_SEARCH_LIBS, but the INCLUDES can be
-dnl specified.
-dnl ######################################################################
-
-AC_DEFUN(FPTOOLS_SEARCH_LIBS,
-[AC_PREREQ([2.13])
-AC_CACHE_CHECK([for library containing $2], [ac_cv_search_$2],
-[ac_func_search_save_LIBS="$LIBS"
-ac_cv_search_$2="no"
-AC_TRY_LINK([$1], [$2()], [ac_cv_search_$2="none required"])
-test "$ac_cv_search_$2" = "no" && for i in $3; do
-LIBS="-l$i $6 $ac_func_search_save_LIBS"
-AC_TRY_LINK([$1], [$2()],
-[ac_cv_search_$2="-l$i"
-break])
-done
-LIBS="$ac_func_search_save_LIBS"])
-if test "$ac_cv_search_$2" != "no"; then
-  test "$ac_cv_search_$2" = "none required" || LIBS="$ac_cv_search_$2 $LIBS"
-  $4
-else :
-  $5
-fi])
-
-dnl ####################### -*- Mode: M4 -*- ###########################
-dnl Copyright (C) 98, 1999 Matthew D. Langston <langston@SLAC.Stanford.EDU>
-dnl
-dnl This file is free software; you can redistribute it and/or modify it
-dnl under the terms of the GNU General Public License as published by
-dnl the Free Software Foundation; either version 2 of the License, or
-dnl (at your option) any later version.
-dnl
-dnl This file is distributed in the hope that it will be useful, but
-dnl WITHOUT ANY WARRANTY; without even the implied warranty of
-dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-dnl General Public License for more details.
-dnl
-dnl You should have received a copy of the GNU General Public License
-dnl along with this file; if not, write to:
-dnl
-dnl   Free Software Foundation, Inc.
-dnl   Suite 330
-dnl   59 Temple Place
-dnl   Boston, MA 02111-1307, USA.
-dnl ####################################################################
-
-
-dnl @synopsis FPTOOLS_CHECK_LIBM
-dnl 
-dnl Search for math library (typically -lm).
-dnl
-dnl The variable LIBM (which is not an output variable by default) is
-dnl set to a value which is suitable for use in a Makefile (for example,
-dnl in make's LOADLIBES macro) provided you AC_SUBST it first.
-dnl
-dnl @author Matthew D. Langston <langston@SLAC.Stanford.EDU>
-
-# FPTOOLS_CHECK_LIBM - check for math library
-AC_DEFUN(FPTOOLS_CHECK_LIBM,
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-LIBM=
-case "$host" in
-*-*-beos*)
-  # These system don't have libm
-  ;;
-*-ncr-sysv4.3*)
-  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
-  AC_CHECK_LIB(m, main, LIBM="$LIBM -lm")
-  ;;
-*)
-  AC_CHECK_LIB(m, main, LIBM="-lm")
-  ;;
-esac
-])
-
-dnl ######################################################################
-dnl Some notes about the heavily changed OpenGL test below:
-dnl  * Caching has been completely rewritten, but is still no perfect yet.
-dnl  * Version detection for GL and GLU has been added.
-dnl ######################################################################
-
-dnl ########################### -*- Mode: M4 -*- #######################
-dnl Copyright (C) 98, 1999 Matthew D. Langston <langston@SLAC.Stanford.EDU>
-dnl
-dnl This file is free software; you can redistribute it and/or modify it
-dnl under the terms of the GNU General Public License as published by
-dnl the Free Software Foundation; either version 2 of the License, or
-dnl (at your option) any later version.
-dnl
-dnl This file is distributed in the hope that it will be useful, but
-dnl WITHOUT ANY WARRANTY; without even the implied warranty of
-dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-dnl General Public License for more details.
-dnl
-dnl You should have received a copy of the GNU General Public License
-dnl along with this file; if not, write to:
-dnl
-dnl   Free Software Foundation, Inc.
-dnl   Suite 330
-dnl   59 Temple Place
-dnl   Boston, MA 02111-1307, USA.
-dnl ####################################################################
-
-dnl @synopsis FPTOOLS_HAVE_OPENGL
-dnl 
-dnl Search for OpenGL.  We search first for Mesa (a GPL'ed version of
-dnl OpenGL) before a vendor's version of OpenGL if we were specifically
-dnl asked to with `--with-Mesa=yes' or `--with-Mesa'.
-dnl
-dnl The four "standard" OpenGL libraries are searched for: "-lGL",
-dnl "-lGLU", "-lGLX" (or "-lMesaGL", "-lMesaGLU" as the case may be) and
-dnl "-lglut".
-dnl
-dnl All of the libraries that are found (since "-lglut" or "-lGLX" might
-dnl be missing) are added to the shell output variable "GL_LIBS", along
-dnl with any other libraries that are necessary to successfully link an
-dnl OpenGL application (e.g. the X11 libraries).  Care has been taken to
-dnl make sure that all of the libraries in "GL_LIBS" are listed in the
-dnl proper order.
-dnl
-dnl Additionally, the shell output variable "GL_CFLAGS" is set to any
-dnl flags (e.g. "-I" flags) that are necessary to successfully compile
-dnl an OpenGL application.
-dnl
-dnl The following shell variable (which are not output variables) are
-dnl also set to either "yes" or "no" (depending on which libraries were
-dnl found) to help you determine exactly what was found.
-dnl
-dnl   have_GL
-dnl   have_GLU
-dnl   have_GLX
-dnl   have_glut
-dnl
-dnl A complete little toy "Automake `make distcheck'" package of how to
-dnl use this macro is available at:
-dnl
-dnl   ftp://ftp.slac.stanford.edu/users/langston/autoconf/ac_opengl-0.01.tar.gz
-dnl
-dnl Please note that as the ac_opengl macro and the toy example evolves,
-dnl the version number increases, so you may have to adjust the above
-dnl URL accordingly.
-dnl
-dnl @author Matthew D. Langston <langston@SLAC.Stanford.EDU>
-
-AC_DEFUN(FPTOOLS_HAVE_OPENGL,
-[
-  AC_REQUIRE([AC_PROG_CC])
-  AC_REQUIRE([AC_PATH_X])
-  AC_REQUIRE([AC_PATH_XTRA])
-  AC_REQUIRE([FPTOOLS_CHECK_LIBM])
-
-dnl Check for Mesa first if we were asked to.
-  AC_ARG_ENABLE(Mesa,
-                AC_HELP_STRING([--enable-Mesa],
-                               [Prefer Mesa over a vendor's native OpenGL library (default=no)]),
-                use_Mesa=$enableval,
-                use_Mesa=no)
-
-  if test x"$use_Mesa" = xyes; then
-     GL_search_list="MesaGL  GL  opengl32"
-    GLU_search_list="MesaGLU GLU glu32"
-    GLX_search_list="MesaGLX GLX"
+AC_SUBST([FopCmd])
+])# FP_PROG_FOP
+
+
+# FP_PROG_FO_PROCESSOR
+# --------------------
+# Try to find an FO processor. PassiveTeX output is sometimes a bit strange, so
+# try FOP first. Sets the output variables FopCmd, XmltexCmd, DvipsCmd, and
+# PdfxmltexCmd.
+AC_DEFUN([FP_PROG_FO_PROCESSOR],
+[AC_REQUIRE([FP_PROG_FOP])
+AC_PATH_PROG([XmltexCmd], [xmltex])
+AC_PATH_PROG([DvipsCmd], [dvips])
+if test -z "$FopCmd"; then
+  if test -z "$XmltexCmd"; then
+    AC_MSG_WARN([cannot find an FO => DVI converter, you will not be able to build DVI or PostScript documentation])
   else
-     GL_search_list="GL  opengl32 MesaGL"
-    GLU_search_list="GLU glu32    MesaGLU"
-    GLX_search_list="GLX          MesaGLX"
-  fi      
-
-  AC_LANG_SAVE
-  AC_LANG_C
-
-dnl If we are running under X11 then add in the appropriate libraries.
-  if test x"$no_x" != xyes; then
-dnl Add everything we need to compile and link X programs to GL_CFLAGS
-dnl and GL_X_LIBS.
-    GL_CFLAGS="$CPPFLAGS $X_CFLAGS"
-    GL_X_LIBS="$X_PRE_LIBS $X_LIBS -lX11 -lXext -lXmu -lXt -lXi $X_EXTRA_LIBS $LIBM"
-  fi
-  GL_save_CPPFLAGS="$CPPFLAGS"
-  CPPFLAGS="$GL_CFLAGS"
-
-  GL_save_LIBS="$LIBS"
-  LIBS="$GL_X_LIBS"
-
-  dnl Including <GL/glut.h> instead of plain <GL/gl.h> avoids problems on
-  dnl platforms like WinDoze where special headers like <windows.h> or
-  dnl some macro trickery would be needed
-  FPTOOLS_SEARCH_LIBS([#include <GL/glut.h>], glEnd, $GL_search_list, have_GL=yes, have_GL=no)
-
-  dnl TODO: The tests for GL features should better be cascaded and the
-  dnl results should be cached. A new macro would be helpful here.
-
-  AC_MSG_CHECKING(glTexSubImage1D)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glTexSubImage1D(GL_TEXTURE_1D,0,0,2,GL_INTENSITY,GL_BYTE,(void*)0)],
-              fptools_gl_texsubimage1d=yes,
-              fptools_gl_texsubimage1d=no);
-  AC_MSG_RESULT($fptools_gl_texsubimage1d)
-
-  AC_MSG_CHECKING(glDrawRangeElements)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glDrawRangeElements(GL_QUADS,0,0,0,GL_UNSIGNED_BYTE,(void*)0)],
-              fptools_gl_drawrangeelements=yes,
-              fptools_gl_drawrangeelements=no);
-  AC_MSG_RESULT($fptools_gl_drawrangeelements)
-
-  AC_MSG_CHECKING(glActiveTexture)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glActiveTexture(GL_TEXTURE1)],
-              fptools_gl_activetexture=yes,
-              fptools_gl_activetexture=no);
-  AC_MSG_RESULT($fptools_gl_activetexture)
-
-  AC_MSG_CHECKING(glMultiDrawArrays)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glMultiDrawArrays(GL_TRIANGLES, (GLint*)0, (GLsizei*)0, 0)],
-              fptools_gl_multidrawarrays=yes,
-              fptools_gl_multidrawarrays=no);
-  AC_MSG_RESULT($fptools_gl_multidrawarrays)
-
-  if test x"$fptools_gl_texsubimage1d" != xyes; then
-    fptools_gl_version=1.0
-  else
-     if test x"$fptools_gl_drawrangeelements" != xyes; then
-        fptools_gl_version=1.1
-     else
-       if test x"$fptools_gl_activetexture" != xyes; then
-          fptools_gl_version=1.2
-       else
-         if test x"$fptools_gl_multidrawarrays" != xyes; then
-            fptools_gl_version=1.3
-         else
-            fptools_gl_version=1.4
-         fi
-       fi
-     fi
+    if test -z "$DvipsCmd"; then
+      AC_MSG_WARN([cannot find a DVI  => PS converter, you will not be able to build PostScript documentation])
+    fi
   fi
-  AC_MSG_NOTICE([It looks like GL version ${fptools_gl_version}])
-
-  dnl TODO: Cache the results of the tests for the imaging subset.
-
-  AC_MSG_CHECKING(EXT_blend_color)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glBlendColorEXT((GLclampf)0.0,(GLclampf)0.0,(GLclampf)0.0,(GLclampf)0.0)],
-              hopengl_EXT_blend_color=yes,
-              hopengl_EXT_blend_color=no);
-  AC_MSG_RESULT($hopengl_EXT_blend_color)
-
-  AC_MSG_CHECKING(EXT_blend_minmax)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glBlendEquationEXT(GL_FUNC_ADD_EXT)],
-              hopengl_EXT_blend_minmax=yes,
-              hopengl_EXT_blend_minmax=no);
-  AC_MSG_RESULT($hopengl_EXT_blend_minmax)
-
-  AC_MSG_CHECKING(EXT_blend_subtract)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [glBlendEquationEXT(GL_FUNC_SUBTRACT_EXT)],
-              hopengl_EXT_blend_subtract=yes,
-              hopengl_EXT_blend_subtract=no);
-  AC_MSG_RESULT($hopengl_EXT_blend_subtract)
-
-  FPTOOLS_SEARCH_LIBS([#include <GL/glu.h>], gluNewQuadric, $GLU_search_list, have_GLU=yes,  have_GLU=no)
-
-  dnl TODO: Cascade and cache...
-
-  AC_MSG_CHECKING(gluGetString)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [gluGetString(GLU_EXTENSIONS)],
-              fptools_glu_getstring=yes,
-              fptools_glu_getstring=no);
-  AC_MSG_RESULT($fptools_glu_getstring)
-
-  AC_MSG_CHECKING(gluTessEndPolygon)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [gluTessEndPolygon((GLUtesselator*)0)],
-              fptools_glu_tessendpolygon=yes,
-              fptools_glu_tessendpolygon=no);
-  AC_MSG_RESULT($fptools_glu_tessendpolygon)
-
-  AC_MSG_CHECKING(gluUnProject4)
-  AC_TRY_LINK([#include <GL/glut.h>],
-              [gluUnProject4(0.0,0.0,0.0,0.0,(GLdouble*)0,(GLdouble*)0,(GLint*)0,0.0,0.0,(GLdouble*)0,(GLdouble*)0,(GLdouble*)0,(GLdouble*)0)],
-              fptools_glu_unproject4=yes,
-              fptools_glu_unproject4=no);
-  AC_MSG_RESULT($fptools_glu_unproject4)
-
-  if test x"$fptools_glu_getstring" != xyes; then
-    fptools_glu_version=1.0
-  else
-     if test x"$fptools_glu_tessendpolygon" != xyes; then
-        fptools_glu_version=1.1
-     else
-       if test x"$fptools_glu_unproject4" != xyes; then
-          fptools_glu_version=1.2
-       else
-            fptools_glu_version=1.3
-       fi
-     fi
+  AC_PATH_PROG([PdfxmltexCmd], [pdfxmltex])
+  if test -z "$PdfxmltexCmd"; then
+    AC_MSG_WARN([cannot find an FO => PDF converter, you will not be able to build PDF documentation])
   fi
-  AC_MSG_NOTICE([It looks like GLU version ${fptools_glu_version}])
+elif test -z "$XmltexCmd"; then
+  AC_MSG_WARN([cannot find an FO => DVI converter, you will not be able to build DVI documentation])
+fi
+])# FP_PROG_FO_PROCESSOR
+
+
+# FP_PROG_GHC_PKG
+# ----------------
+# Try to find a ghc-pkg matching the ghc mentioned in the environment variable
+# WithGhc. If the latter is unset or no matching ghc-pkg can be found, try to
+# find a plain ghc-pkg. Sets the output variable GhcPkgCmd.
+AC_DEFUN([FP_PROG_GHC_PKG],
+[AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
+[fp_ghc_pkg_guess=`echo $WithGhc | sed 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
+if "$fp_ghc_pkg_guess" -l > /dev/null 2>&1; then
+  fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
+else
+  fp_cv_matching_ghc_pkg=no
+fi])
+if test x"$fp_cv_matching_ghc_pkg" = xno; then
+  AC_PATH_PROG([GhcPkgCmd], [ghc-pkg])
+else
+  GhcPkgCmd=$fp_cv_matching_ghc_pkg
+fi])# FP_PROG_GHC_PKG
 
-  FPTOOLS_SEARCH_LIBS([#include <GL/glx.h>],  glXWaitX,      $GLX_search_list, have_GLX=yes,  have_GLX=no)
-  FPTOOLS_SEARCH_LIBS([#include <GL/glut.h>], glutMainLoop,  glut32 glut,      have_glut=yes, have_glut=no)
 
-  if test -n "$LIBS"; then
-    GL_LIBS="$LDFLAGS $LIBS"
-  else
-    GL_LIBS="$LDFLAGS"
-    GL_CFLAGS=
-  fi
+# FP_GHC_HAS_READLINE
+# -------------------
+AC_DEFUN([FP_GHC_HAS_READLINE],
+[AC_REQUIRE([FP_PROG_GHC_PKG])
+AC_CACHE_CHECK([whether ghc has readline package], [fp_cv_ghc_has_readline],
+[if "${GhcPkgCmd-ghc-pkg}" --show-package readline >/dev/null 2>&1; then
+  fp_cv_ghc_has_readline=yes
+else
+  fp_cv_ghc_has_readline=no
+ fi])
+AC_SUBST([GhcHasReadline], [`echo $fp_cv_ghc_has_readline | sed 'y/yesno/YESNO/'`])
+])# FP_GHC_HAS_READLINE
+
+
+# FP_GCC_NEEDS_NO_OMIT_LFPTR
+# --------------------------
+# Some OSs (Mandrake Linux, in particular) configure GCC with
+# -momit-leaf-frame-pointer on by default. If this is the case, we need to turn
+# it off for mangling to work. The test is currently a bit crude, using only the
+# version number of gcc. Defines HAVE_GCC_MNO_OMIT_LFPTR.
+AC_DEFUN([FP_GCC_NEEDS_NO_OMIT_LFPTR],
+[AC_REQUIRE([FP_HAVE_GCC])
+AC_CACHE_CHECK([whether gcc needs -mno-omit-leaf-frame-pointer], [fp_cv_gcc_needs_no_omit_lfptr],
+[FP_COMPARE_VERSIONS([$fp_gcc_version], [-ge], [3.2],
+  [fp_cv_gcc_needs_no_omit_lfptr=yes],
+  [fp_cv_gcc_needs_no_omit_lfptr=no])])
+if test "$fp_cv_gcc_needs_no_omit_lfptr" = "yes"; then
+   AC_DEFINE([HAVE_GCC_MNO_OMIT_LFPTR], [1], [Define to 1 if gcc supports -mno-omit-leaf-frame-pointer.])
+fi])# FP_GCC_NEEDS_NO_OMIT_LFPTR
+
+# FP_GCC_HAS_NO_UNIT_AT_A_TIME
+# --------------------------
+AC_DEFUN([FP_GCC_HAS_NO_UNIT_AT_A_TIME],
+[AC_REQUIRE([FP_HAVE_GCC])
+AC_CACHE_CHECK([whether gcc has -fno-unit-at-a-time], [fp_cv_gcc_has_no_unit_at_a_time],
+[FP_COMPARE_VERSIONS([$fp_gcc_version], [-ge], [3.4],
+  [fp_cv_gcc_has_no_unit_at_a_time=yes],
+  [fp_cv_gcc_has_no_unit_at_a_time=no])])
+if test "$fp_cv_gcc_has_no_unit_at_a_time" = "yes"; then
+   AC_DEFINE([HAVE_GCC_HAS_NO_UNIT_AT_A_TIME], [1], [Define to 1 if gcc supports -fno-unit-at-a-time.])
+fi])
 
-  AC_CACHE_CHECK([OpenGL flags], mdl_cv_gl_cflags, [mdl_cv_gl_cflags="$GL_CFLAGS"])
-  GL_CFLAGS="$mdl_cv_gl_cflags"
-  AC_SUBST(GL_CFLAGS)
-  AC_CACHE_CHECK([OpenGL libs],  mdl_cv_gl_libs,   [mdl_cv_gl_libs="$GL_LIBS"])
-  GL_LIBS="$mdl_cv_gl_libs"
-  AC_SUBST(GL_LIBS)
+# FP_SETUP_PROJECT_VERSION
+# ---------------------
+AC_DEFUN([FP_SETUP_PROJECT_VERSION],
+[# Some renamings
+AC_SUBST([ProjectName], [$PACKAGE_NAME])
+AC_SUBST([ProjectVersion], [$PACKAGE_VERSION])
+
+# Split PACKAGE_VERSION into (possibly empty) parts
+VERSION_MAJOR=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
+VERSION_TMP=`echo $PACKAGE_VERSION | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
+VERSION_MINOR=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\1'/`
+ProjectPatchLevel=`echo $VERSION_TMP | sed 's/^\(@<:@^.@:>@*\)\(\.\{0,1\}\(.*\)\)$/\3'/`
+
+# Calculate project version as an integer, using 2 digits for minor version
+case $VERSION_MINOR in
+  ?) ProjectVersionInt=${VERSION_MAJOR}0${VERSION_MINOR} ;;
+  ??) ProjectVersionInt=${VERSION_MAJOR}${VERSION_MINOR} ;;
+  *) AC_MSG_ERROR([bad minor version in $PACKAGE_VERSION]) ;;
+esac
+AC_SUBST([ProjectVersionInt])
 
-dnl Reset GL_X_LIBS regardless, since it was just a temporary variable
-dnl and we don't want to be global namespace polluters.
-  GL_X_LIBS=
+# The project patchlevel is zero unless stated otherwise
+test -z "$ProjectPatchLevel" && ProjectPatchLevel=0
 
-  LIBS="$GL_save_LIBS"
-  CPPFLAGS="$GL_save_CPPFLAGS"
+# Remove dots from the patch level; this allows us to have versions like 6.4.1.20050508
+ProjectPatchLevel=`echo $ProjectPatchLevel | sed 's/\.//'`
 
-  AC_LANG_RESTORE
-])
+AC_SUBST([ProjectPatchLevel])
+])# FP_SETUP_PROJECT_VERSION
 
 # LocalWords:  fi
-
-dnl 
-dnl acspecific.m4's defn of AC_PROG_LEX is a bit too permissive, as it
-dnl defaults to 'lex' if 'flex' isn't found (without checking whether
-dnl 'lex' is actually present along the user's PATH).
-dnl
-AC_DEFUN(AC_PROG_LEX_STRICT,
-[AC_CHECK_PROG(LEX, flex, flex)
-if test -z "$LEX"
-then
-  AC_CHECK_PROG(LEX,lex,lex)
-  test -z "$LEX" && AC_MSG_ERROR(['lex' or 'flex' is required to compile GHC.])
-fi
-])
-
-dnl
-dnl Check to see whether CC (gcc) supports a particular option.
-dnl 
-AC_DEFUN(FPTOOLS_CC_FLAG,
-[
-AC_CACHE_CHECK([whether $CC accepts $1], [ac_cv_cc_$2],
-[save_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS $1"
- AC_LANG_C
- AC_TRY_COMPILE(,[int main(){return(0);}],
-                 [ac_cv_cc_$2=yes],
-                [ac_cv_cc_$2=no])
- CFLAGS="$save_CFLAGS"
-])
-if test "$ac_cv_cc_$2"x = "yesx"; then
-  $2=$1;
-else
-  $2="";
-fi;
-])
-
-dnl
-dnl Check to see whether 'struct msghdr' contains msg_control
-dnl 
-AC_DEFUN(FPTOOLS_MSGHDR_MSG_CONTROL,
-[AC_CACHE_CHECK([for msg_control in struct msghdr], fptools_cv_struct_msghdr_msg_control,
-[AC_TRY_COMPILE([#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/socket.h>], [struct msghdr m; m.msg_control;],
-fptools_cv_struct_msghdr_msg_control=yes, fptools_cv_struct_msghdr_msg_control=no)])
-if test $fptools_cv_struct_msghdr_msg_control = yes; then
-  AC_DEFINE(HAVE_MSGHDR_MSG_CONTROL)
-fi
-AC_SUBST(HAVE_MSGHDR_MSG_CONTROL)dnl
-])
-
-dnl
-dnl Check to see whether 'struct msghdr' contains msg_accrights
-dnl 
-AC_DEFUN(FPTOOLS_MSGHDR_MSG_ACCRIGHTS,
-[AC_CACHE_CHECK([for msg_accrights in struct msghdr], fptools_cv_struct_msghdr_msg_accrights,
-[AC_TRY_COMPILE([#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/socket.h>], [struct msghdr m; m.msg_accrights;],
-fptools_cv_struct_msghdr_msg_accrights=yes, fptools_cv_struct_msghdr_msg_accrights=no)])
-if test $fptools_cv_struct_msghdr_msg_accrights = yes; then
-  AC_DEFINE(HAVE_MSGHDR_MSG_ACCRIGHTS)
-fi
-AC_SUBST(HAVE_MSGHDR_MSG_ACCRIGHTS)dnl
-])
-