+
+
+# 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
+ # 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
+
+
+dnl
+dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
+dnl values of the second argument to the result of running
+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_MSG_CHECKING([$1])
+ $3
+ AC_MSG_RESULT([$][$2])
+])
+
+dnl
+dnl FPTOOLS_GHC_VERSION(version)
+dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
+dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
+dnl
+dnl Test for version of installed ghc. Uses $GHC.
+dnl [original version pinched from c2hs]
+dnl
+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
+#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*
+ if test "[$]fptools_version_of_ghc" = ""
+ then
+ fptools_version_of_ghc='unknown'
+ fi
+fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
+fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
+fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
+#
+if test "[$]fptools_version_of_ghc[_pl]" = ""
+then
+ fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
+ fptools_version_of_ghc[_pl]="0"
+else
+ fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
+fi
+#
+ifelse($#, [1], [dnl
+[$1]="[$]fptools_version_of_ghc[_all]"
+], $#, [2], [dnl
+[$1]="[$]fptools_version_of_ghc[_major]"
+[$2]="[$]fptools_version_of_ghc[_minor]"
+], $#, [3], [dnl
+[$1]="[$]fptools_version_of_ghc[_major]"
+[$2]="[$]fptools_version_of_ghc[_minor]"
+[$3]="[$]fptools_version_of_ghc[_pl]"
+], $#, [4], [dnl
+[$1]="[$]fptools_version_of_ghc[_all]"
+[$2]="[$]fptools_version_of_ghc[_major]"
+[$3]="[$]fptools_version_of_ghc[_minor]"
+[$4]="[$]fptools_version_of_ghc[_pl]"
+])
+])
+])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,
+[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_CV_NAME_supported=yes
+fp_check_htype_save_cppflags="$CPPFLAGS"
+CPPFLAGS="$CPPFLAGS $X_CFLAGS"
+AC_TRY_RUN([#include <stdio.h>
+#include <stddef.h>
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
+
+#if HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#if HAVE_TIME_H
+# include <time.h>
+#endif
+
+#if HAVE_TERMIOS_H
+# include <termios.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+
+#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_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;
+
+main() {
+ FILE *f=fopen("conftestval", "w");
+ if (!f) exit(1);
+ if (((testing)((int)((testing)1.4))) == ((testing)1.4)) {
+ fprintf(f, "%s%d\n",
+ ((testing)(-1) < (testing)0) ? "Int" : "Word",
+ sizeof(testing)*8);
+ } else {
+ fprintf(f,"%s\n",
+ (sizeof(testing) > sizeof(double)) ? "LDouble" :
+ (sizeof(testing) == sizeof(double)) ? "Double" : "Float");
+ }
+ fclose(f);
+ exit(0);
+}],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))]) dnl
+CPPFLAGS="$fp_check_htype_save_cppflags"
+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
+])
+
+
+# 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
+
+
+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>
+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"
+fi
+])
+rm -rf conftest*
+if test $fptools_cv_sgml_catalog != "no"; then
+ $1=$fptools_cv_sgml_catalog
+fi
+])
+
+
+# FP_CHECK_WIN32
+# --------------
+# If Windows is the target platform (e.g. MinGW/MSYS or Cygwin with
+# -mno-cygwin), the variable "is_win32" is set to "yes", otherwise (e.g. *nix
+# systems or plain Cygwin) it is set to "no".
+AC_DEFUN([FP_CHECK_WIN32],
+[AC_CACHE_CHECK([for Windows environment], [fp_cv_is_win32],
+ [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
+#if !_WIN32
+ syntax error;
+#endif
+])], [fp_cv_is_win32=yes], [fp_cv_is_win32=no])])
+is_win32="$fp_cv_is_win32"[]dnl
+])# FP_CHECK_WIN32
+
+
+# FP_PATH_X
+# ---------
+# Same as AC_PATH_X, but works even for broken Cygwins which try to include the
+# non-existant <gl/mesa_wgl.h> header when -mno-cygwin is used.
+AC_DEFUN([FP_PATH_X],
+[AC_REQUIRE([FP_CHECK_WIN32])
+if test x"$is_win32" = xyes; then
+ no_x=yes
+else
+ AC_PATH_X
+fi
+])# FP_PATH_X
+
+
+# FP_PATH_XTRA
+# ------------
+# Same as AC_PATH_XTRA, but works even for broken Cygwins which try to include
+# the non-existant <gl/mesa_wgl.h> header when -mno-cygwin is used.
+AC_DEFUN([FP_PATH_XTRA],
+[AC_REQUIRE([FP_CHECK_WIN32])
+if test x"$is_win32" = xyes; then
+ no_x=yes
+else
+ AC_PATH_XTRA
+fi
+])# FP_PATH_XTRA
+
+
+# FP_CHECK_GL_HELPER(LIBNAME, LIBS, INCLUDES, FUNCTION-BODY)
+# ----------------------------------------------------------
+# Try each library in LIBS to successfully link INCLUDES plus FUNCTION-BODY,
+# setting LIBNAME_CFLAGS and LIBNAME_LIBS to the corresponding values. Sets
+# no_LIBNAME to "yes" if no suitable library was found. (LIBNAME_CFLAGS0
+# contains the value of LIBNAME_CFLAGS without CPPFLAGS, and LIBNAME_LIBS0
+# contains the value of LIBNAME_LIBS without LDFLAGS, but these are only
+# used internally.)
+AC_DEFUN([FP_CHECK_GL_HELPER],
+[AC_CACHE_CHECK([for $1 library], [fp_cv_check_$1_lib],
+ [fp_cv_check_$1_lib="no"
+ fp_save_CPPFLAGS="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS ${$1_CFLAGS}"
+ fp_save_LIBS="$LIBS"
+ for fp_try_lib in $2; do
+ # transform "-lfoo" to "foo.lib" when using cl
+ if test x"$CC" = xcl; then
+ fp_try_lib=`echo $fp_try_lib | sed -e 's/^-l//' -e 's/$/.lib/'`
+ fi
+ LIBS="$fp_try_lib ${$1_LIBS} $fp_save_LIBS"
+ AC_TRY_LINK([$3], [$4], [fp_cv_check_$1_lib="$fp_try_lib ${$1_LIBS}"; break])
+ done
+ LIBS="$fp_save_LIBS"
+ CPPFLAGS="$fp_save_CPPFLAGS"])
+
+ if test x"$fp_cv_check_$1_lib" = xno; then
+ no_$1=yes
+ $1_CFLAGS=
+ $1_LIBS=
+ else
+ $1_CFLAGS0="${$1_CFLAGS}"
+ $1_CFLAGS="$CPPFLAGS ${$1_CFLAGS0}"
+ $1_LIBS0="$fp_cv_check_$1_lib"
+ $1_LIBS="$LDFLAGS ${$1_LIBS0}"
+ fi
+])# FP_CHECK_GL_HELPER
+
+
+# FP_CHECK_GL
+# -----------
+AC_DEFUN([FP_CHECK_GL],
+[AC_REQUIRE([FP_PATH_X])
+AC_REQUIRE([AC_CANONICAL_SYSTEM])
+
+AC_ARG_ENABLE([hopengl],
+ [AC_HELP_STRING([--enable-hopengl],
+ [build a Haskell binding for OpenGL (GL/GLU). On Mac OS X, use
+ --enable-hopengl=x11 to use X11 instead of the "native" libraries.
+ (default=no)])],
+ [enable_opengl=$enableval], [enable_opengl=no])
+
+if test x"$enable_opengl" = xno; then
+ no_GL=yes
+else
+ use_quartz_opengl=no
+ case $target_os in
+ darwin*)
+ if test x"$enable_opengl" != xx11; then
+ AC_DEFINE([USE_QUARTZ_OPENGL], [1],
+ [Define to 1 if native OpenGL should be used on Mac OS X])
+ use_quartz_opengl=yes
+ fi
+ ;;
+ esac
+
+ if test x"$use_quartz_opengl" != xyes; then
+ AC_CHECK_LIB([m], [atan], [GL_LIBS="-lm $GL_LIBS"])
+
+ if test x"$no_x" != xyes; then
+ test -n "$x_includes" && GL_CFLAGS="-I$x_includes $GL_CFLAGS"
+ test -n "$x_libraries" && GL_LIBS="-L$x_libraries -lX11 $GL_LIBS"
+ fi
+
+ FP_CHECK_GL_HELPER([GL], [-lGL -lopengl32], [@%:@include <GL/gl.h>], [glEnd()])
+
+ if test x"$no_GL" != xyes; then
+ # Ugly: To get wglGetProcAddress on Windows, we have to link with
+ # opengl32.dll, too, even when we are using Cygwin with X11.
+ case "$GL_LIBS" in
+ *-lopengl32*|*opengl32.lib*) ;;
+ *) fp_save_LIBS="$LIBS"
+ LIBS="$LIBS -lopengl32"
+ AC_TRY_LINK([@%:@include <GL/gl.h>], [glEnd()],
+ [GL_LIBS="$GL_LIBS -lopengl32"; GL_LIBS0="$GL_LIBS0 -lopengl32"])
+ LIBS="$fp_save_LIBS"
+ ;;
+ esac
+ fi
+ fi
+fi
+
+AC_SUBST([GL_CFLAGS])
+AC_SUBST([GL_LIBS])
+])# FP_CHECK_GL
+
+
+# FP_CHECK_GLU
+# ------------
+AC_DEFUN([FP_CHECK_GLU],
+[AC_REQUIRE([FP_CHECK_GL])dnl
+GLU_CFLAGS="$GL_CFLAGS0"
+GLU_LIBS="$GL_LIBS0"
+
+if test x"$enable_opengl" = xno; then
+ no_GLU=yes
+elif test x"$use_quartz_opengl" != xyes; then
+ FP_CHECK_GL_HELPER([GLU], [-lglu32 -lGLU], [@%:@include <GL/glu.h>], [gluNewQuadric()])
+fi
+
+AC_SUBST([GLU_CFLAGS])
+AC_SUBST([GLU_LIBS])
+])# FP_CHECK_GLU
+
+
+# FP_CHECK_GLUT
+# -------------
+AC_DEFUN([FP_CHECK_GLUT],
+[AC_REQUIRE([FP_CHECK_GLU])
+FP_PATH_XTRA
+
+if test x"$enable_opengl" = xno; then
+ no_GLUT=yes
+elif test x"$use_quartz_opengl" != xyes; then
+ GLUT_CFLAGS="$GLU_CFLAGS0"
+ GLUT_LIBS="$GLU_LIBS0"
+
+ if test x"$no_x" != xyes; then
+ GLUT_LIBS="$X_PRE_LIBS -lXmu -lXi $X_EXTRA_LIBS $GLUT_LIBS"
+ fi
+
+ AC_CHECK_HEADERS([windows.h GL/glut.h])
+ # Note 1: On Cygwin with X11, GL/GLU functions use the "normal" calling
+ # convention, but GLUT functions use stdcall. To get this right, it is
+ # necessary to include <windows.h> first.
+ # Note 2: MinGW/MSYS comes without a GLUT header, so we use Cygwin's one in
+ # that case.
+ FP_CHECK_GL_HELPER([GLUT], [-lglut32 -lglut], [
+#if HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+#if HAVE_GL_GLUT_H
+#include <GL/glut.h>
+#else
+#include "glut_local.h"
+#endif
+ ], [glutMainLoop()])
+fi
+
+AC_SUBST([GLUT_CFLAGS])
+AC_SUBST([GLUT_LIBS])
+])# FP_CHECK_GLUT
+
+
+dnl @synopsis FP_EMPTY_STRUCTS
+dnl
+dnl Check whether empty structs is accepted by CC.
+dnl
+AC_DEFUN(FP_EMPTY_STRUCTS,
+[AC_CACHE_CHECK(empty struct support, fptools_cv_empty_structs,
+[AC_TRY_COMPILE([
+typedef struct { /*empty*/ } StgFoo;
+],
+[int i;],
+fptools_cv_empty_structs=yes,
+fptools_cv_empty_structs=no)])
+if test "$fptools_cv_empty_structs" = yes; then
+AC_DEFINE([SUPPORTS_EMPTY_STRUCTS], [1], [Define to 1 if C compiler supports declaration of empty structure types.])
+fi
+])
+
+# LocalWords: fi