[project @ 2004-09-18 12:49:55 by panne]
[ghc.git] / aclocal.m4
1 # Extra autoconf macros for the Glasgow fptools
2 #
3 # To be a good autoconf citizen, names of local macros have prefixed with FP_ to
4 # ensure we don't clash with any pre-supplied autoconf ones.
5
6
7 # FP_EVAL_STDERR(COMMAND)
8 # -----------------------
9 # Eval COMMAND, save its stderr (without lines resulting from shell tracing)
10 # into the file conftest.err and the exit status in the variable fp_status.
11 AC_DEFUN([FP_EVAL_STDERR],
12 [{ (eval $1) 2>conftest.er1
13   fp_status=$?
14   grep -v '^ *+' conftest.er1 >conftest.err
15   rm -f conftest.er1
16   (exit $fp_status); }[]dnl
17 ])# FP_EVAL_STDERR
18
19
20 # FP_CHECK_FLAG(FLAG, [ACTION-IF-SUPPORTED], [ACTION-IF-NOT-SUPPORTED])
21 # ---------------------------------------------------------------------
22 # Check to see whether the compiler for the current language supports a
23 # particular option.
24 #
25 # Implementation note: When given an unkown option, GCC issues an warning on
26 # stderr only, but returns an exit value of 0 nevertheless. Consequently we have
27 # to check stderr *and* the exit value.
28 #
29 # Used by ghc.
30 AC_DEFUN(FP_CHECK_FLAG,
31 [AC_LANG_COMPILER_REQUIRE()dnl
32 AC_LANG_CASE([C],          [fp_compiler="$CC"  m4_pushdef([fp_Flags], [CFLAGS])],
33              [C++],        [fp_compiler="$CXX" m4_pushdef([fp_Flags], [CXXFLAGS])],
34              [Fortran 77], [fp_compiler="$F77" m4_pushdef([fp_Flags], [FFLAGS])])
35 m4_pushdef([fp_Cache], [fp_cv_[]fp_Flags[]AS_TR_SH([$1])])[]dnl
36 AC_CACHE_CHECK([whether $fp_compiler accepts $1], [fp_Cache],
37 [AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
38 fp_save_flags="$fp_Flags"
39 fp_Flags="$fp_Flags $1"
40 fp_Cache=no
41 if FP_EVAL_STDERR([$ac_compile conftest.$ac_ext]) >/dev/null; then
42   test -s conftest.err || fp_Cache=yes
43 fi
44 fp_Flags="$fp_save_flags"
45 rm -f conftest.err conftest.$ac_ext])
46 AS_IF([test $fp_Cache = yes], [$2], [$3])[]dnl
47 m4_popdef([fp_Cache])[]dnl
48 m4_popdef([fp_Flags])[]dnl
49 ])# FP_CHECK_FLAG
50
51
52 # FP_PROG_CONTEXT_DIFF
53 # --------------------
54 # Figure out how to do context diffs. Sets the output variable ContextDiffCmd.
55 #
56 # Note: NeXTStep thinks diff'ing a file against itself is "trouble".
57 #
58 # Used by ghc, glafp-utils/ltx, and glafp-utils/runstdtest.
59 AC_DEFUN([FP_PROG_CONTEXT_DIFF],
60 [AC_CACHE_CHECK([for a working context diff], [fp_cv_context_diff],
61 [echo foo > conftest1
62 echo foo > conftest2
63 fp_cv_context_diff=no
64 for fp_var in '-C 1' '-c1'
65 do
66   if diff $fp_var conftest1 conftest2 > /dev/null 2>&1; then
67     fp_cv_context_diff="diff $fp_var"
68     break
69   fi
70 done])
71 if test x"$fp_cv_context_diff" = xno; then
72    AC_MSG_ERROR([cannot figure out how to do context diffs])
73 fi
74 AC_SUBST(ContextDiffCmd, [$fp_cv_context_diff])
75 ])# FP_PROG_CONTEXT_DIFF
76
77
78 # FP_DECL_ALTZONE
79 # ---------------
80 # Defines HAVE_DECL_ALTZONE to 1 if declared, 0 otherwise.
81 #
82 # Used by base package.
83 AC_DEFUN([FP_DECL_ALTZONE],
84 [AC_REQUIRE([AC_HEADER_TIME])dnl
85 AC_CHECK_HEADERS([sys/time.h])
86 AC_CHECK_DECLS([altzone], [], [],[#if TIME_WITH_SYS_TIME
87 # include <sys/time.h>
88 # include <time.h>
89 #else
90 # if HAVE_SYS_TIME_H
91 #  include <sys/time.h>
92 # else
93 #  include <time.h>
94 # endif
95 #endif])
96 ])# FP_DECL_ALTZONE
97
98
99 # FP_COMPUTE_INT(EXPRESSION, VARIABLE, INCLUDES, IF-FAILS)
100 # --------------------------------------------------------
101 # Assign VARIABLE the value of the compile-time EXPRESSION using INCLUDES for
102 # compilation. Execute IF-FAILS when unable to determine the value. Works for
103 # cross-compilation, too.
104 #
105 # Implementation note: We are lazy and use an internal autoconf macro, but it
106 # is supported in autoconf versions 2.50 up to the actual 2.57, so there is
107 # little risk.
108 AC_DEFUN([FP_COMPUTE_INT],
109 [_AC_COMPUTE_INT([$1], [$2], [$3], [$4])[]dnl
110 ])# FP_COMPUTE_INT
111
112
113 # FP_CHECK_ALIGNMENT(TYPE, [IGNORED], [INCLUDES = DEFAULT-INCLUDES])
114 # ------------------------------------------------------------------
115 # A variation of AC_CHECK_SIZEOF for computing the alignment restrictions of a
116 # given type. Defines ALIGNMENT_TYPE.
117 AC_DEFUN([FP_CHECK_ALIGNMENT],
118 [AS_LITERAL_IF([$1], [],
119                [AC_FATAL([$0: requires literal arguments])])[]dnl
120 AC_CHECK_TYPE([$1], [], [], [$3])[]dnl
121 m4_pushdef([fp_Cache], [AS_TR_SH([fp_cv_alignment_$1])])[]dnl
122 AC_CACHE_CHECK([alignment of $1], [fp_Cache],
123 [if test "$AS_TR_SH([ac_cv_type_$1])" = yes; then
124   FP_COMPUTE_INT([(long) (&((struct { char c; $1 ty; } *)0)->ty)],
125                  [fp_Cache],
126                  [AC_INCLUDES_DEFAULT([$3])],
127                  [AC_MSG_ERROR([cannot compute alignment ($1)
128 See `config.log' for more details.], [77])])
129 else
130   fp_Cache=0
131 fi])[]dnl
132 AC_DEFINE_UNQUOTED(AS_TR_CPP(alignment_$1), $fp_Cache, [The alignment of a `$1'.])[]dnl
133 m4_popdef([fp_Cache])[]dnl
134 ])# FP_CHECK_ALIGNMENT
135
136
137 # FP_CHECK_CONST(EXPRESSION, [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1])
138 # -------------------------------------------------------------------------------
139 # Defines CONST_EXPRESSION to the value of the compile-time EXPRESSION, using
140 # INCLUDES. If the value cannot be determined, use VALUE-IF-FAIL.
141 AC_DEFUN([FP_CHECK_CONST],
142 [AS_VAR_PUSHDEF([fp_Cache], [fp_cv_const_$1])[]dnl
143 AC_CACHE_CHECK([value of $1], fp_Cache,
144 [FP_COMPUTE_INT([$1], fp_check_const_result, [AC_INCLUDES_DEFAULT([$2])],
145                 [fp_check_const_result=m4_default([$3], ['-1'])])
146 AS_VAR_SET(fp_Cache, [$fp_check_const_result])])[]dnl
147 AC_DEFINE_UNQUOTED(AS_TR_CPP([CONST_$1]), AS_VAR_GET(fp_Cache), [The value of $1.])[]dnl
148 AS_VAR_POPDEF([fp_Cache])[]dnl
149 ])# FP_CHECK_CONST
150
151
152 # FP_CHECK_CONSTS_TEMPLATE(EXPRESSION...)
153 # ---------------------------------------
154 # autoheader helper for FP_CHECK_CONSTS
155 m4_define([FP_CHECK_CONSTS_TEMPLATE],
156 [AC_FOREACH([fp_Const], [$1],
157   [AH_TEMPLATE(AS_TR_CPP(CONST_[]fp_Const),
158                [The value of ]fp_Const[.])])[]dnl
159 ])# FP_CHECK_CONSTS_TEMPLATE
160
161
162 # FP_CHECK_CONSTS(EXPRESSION..., [INCLUDES = DEFAULT-INCLUDES], [VALUE-IF-FAIL = -1])
163 # -----------------------------------------------------------------------------------
164 # List version of FP_CHECK_CONST
165 AC_DEFUN(FP_CHECK_CONSTS,
166 [FP_CHECK_CONSTS_TEMPLATE([$1])dnl
167 for fp_const_name in $1
168 do
169 FP_CHECK_CONST([$fp_const_name], [$2], [$3])
170 done
171 ])# FP_CHECK_CONSTS
172
173
174 # FP_LEADING_UNDERSCORE
175 # ---------------------
176 # Test for determining whether symbol names have a leading underscore. We assume
177 # that they _haven't_ if anything goes wrong. Sets the output variable
178 # LeadingUnderscore to YES or NO and defines LEADING_UNDERSCORE correspondingly.
179 #
180 # Some nlist implementations seem to try to be compatible by ignoring a leading
181 # underscore sometimes (eg. FreeBSD). We therefore have to work around this by
182 # checking for *no* leading underscore first. Sigh.  --SDM
183 #
184 # Similarly on OpenBSD, but this test doesn't help. -- dons
185 AC_DEFUN([FP_LEADING_UNDERSCORE],
186 [AC_CHECK_LIB([elf], [nlist], [LIBS="-lelf $LIBS"])
187 AC_CACHE_CHECK([leading underscore in symbol names], [fptools_cv_leading_underscore], [
188 # Hack!: nlist() under Digital UNIX insist on there being an _,
189 # but symbol table listings shows none. What is going on here?!?
190 #
191 # Another hack: cygwin doesn't come with nlist.h , so we hardwire
192 # the underscoredness of that "platform"
193 case $HostPlatform in
194 *openbsd*) # x86 openbsd is ELF from 3.4 >, meaning no leading uscore
195   case $build in
196     i386-*2\.@<:@0-9@:>@ | i386-*3\.@<:@0-3@:>@ ) fptools_cv_leading_underscore=yes ;;
197     *) fptools_cv_leading_underscore=no ;;
198   esac ;;
199 alpha-dec-osf*) fptools_cv_leading_underscore=no;;
200 *cygwin32) fptools_cv_leading_underscore=yes;;
201 *mingw32) fptools_cv_leading_underscore=yes;;
202 *) AC_TRY_RUN([#ifdef HAVE_NLIST_H
203 #include <nlist.h>
204 struct nlist xYzzY1[] = {{"xYzzY1", 0},{0}};
205 struct nlist xYzzY2[] = {{"_xYzzY2", 0},{0}};
206 #endif
207
208 int main(argc, argv)
209 int argc;
210 char **argv;
211 {
212 #ifdef HAVE_NLIST_H
213     if(nlist(argv[0], xYzzY1) == 0 && xYzzY1[0].n_value != 0)
214         exit(1);
215     if(nlist(argv[0], xYzzY2) == 0 && xYzzY2[0].n_value != 0)
216         exit(0);
217 #endif
218     exit(1);
219 }], [fptools_cv_leading_underscore=yes], [fptools_cv_leading_underscore=no], [fptools_cv_leading_underscore=no])
220 ;;
221 esac]);
222 AC_SUBST([LeadingUnderscore], [`echo $fptools_cv_leading_underscore | sed 'y/yesno/YESNO/'`])
223 if test x"$fptools_cv_leading_underscore" = xyes; then
224    AC_DEFINE([LEADING_UNDERSCORE], [1], [Define to 1 if C symbols have a leading underscore added by the compiler.])
225 fi])# FP_LEADING_UNDERSCORE
226
227
228 # FP_COMPARE_VERSIONS(VERSION1, TEST, VERSION2, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
229 # ----------------------------------------------------------------------------------
230 # Compare dotted version numbers VERSION1 and VERSION2 lexicographically according
231 # to TEST (one of -eq, -ne, -lt, -le, -gt, or -ge).
232 AC_DEFUN([FP_COMPARE_VERSIONS],
233 [fp_version1=$1; fp_version2=$3
234 fp_save_IFS=$IFS; IFS='.'
235 while test x"$fp_version1" != x || test x"$fp_version2" != x
236 do
237
238   set dummy $fp_version1; shift
239   fp_num1=""
240   test $[@%:@] = 0 || { fp_num1="[$]1"; shift; }
241   test x"$fp_num1" = x && fp_num1="0"
242   fp_version1="[$]*"
243
244   set dummy $fp_version2; shift
245   fp_num2=""
246   test $[@%:@] = 0 || { fp_num2="[$]1"; shift; }
247   test x"$fp_num2" = x && fp_num2="0"
248   fp_version2="[$]*"
249
250   test "$fp_num1" = "$fp_num2" || break;
251 done
252 IFS=$fp_save_IFS
253 AS_IF([test "$fp_num1" $2 "$fp_num2"], [$4], [$5])[]dnl
254 ])# FP_COMPARE_VERSIONS
255
256
257 dnl
258 dnl Check for GreenCard and version.
259 dnl
260 AC_DEFUN(FPTOOLS_GREENCARD,
261 [
262 AC_PATH_PROG(GreenCardCmd,greencard)
263 AC_CACHE_CHECK([for version of greencard], fptools_cv_greencard_version,
264 changequote(, )dnl
265 [if test x"$GreenCardCmd" != x; then
266    fptools_cv_greencard_version="`$GreenCardCmd --version |
267                           grep 'version' | sed -e 's/greencard. version \([^ ]*\).*/\1/g'`"
268 else
269    fptools_cv_greencard_version=""
270 fi
271 changequote([, ])dnl
272 ])
273 FP_COMPARE_VERSIONS([$fptools_cv_greencard_version],[-lt],[$1],
274   [AC_MSG_ERROR([greencard version $1 or later is required (found '$fptools_cv_greencard_version')])])[]dnl
275 GreenCardVersion=$fptools_cv_greencard_version
276 AC_SUBST(GreenCardVersion)
277 ])
278
279 dnl
280 dnl Check for Happy and version.  If we're building GHC, then we need
281 dnl at least Happy version 1.14.  If there's no installed Happy, we look
282 dnl for a happy source tree and point the build system at that instead.
283 dnl
284 AC_DEFUN(FPTOOLS_HAPPY,
285 [
286 if test -d $srcdir/happy; then
287    SrcTreeHappyCmd=$hardtop/happy/src/happy-inplace
288 fi
289 if test x"$UseSrcTreeHappy" = xYES; then
290   HappyCmd=$SrcTreeHappyCmd
291 else
292   AC_PATH_PROG(HappyCmd,happy,$SrcTreeHappyCmd)
293 fi
294 AC_CACHE_CHECK([for version of happy], fptools_cv_happy_version,
295 changequote(, )dnl
296 [if test x"$HappyCmd" = x"$SrcTreeHappyCmd" -a -e $srcdir/happy/mk/version.mk; then
297    fptools_cv_happy_version=`grep '^ProjectVersion[     ]*=' $srcdir/happy/mk/version.mk | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`;
298 elif test x"$HappyCmd" != x; then
299    fptools_cv_happy_version="`$HappyCmd -v |
300                           grep 'Happy Version' | sed -e 's/Happy Version \([^ ]*\).*/\1/g'`" ;
301 else
302    fptools_cv_happy_version="";
303 fi;
304 changequote([, ])dnl
305 ])
306 if test -d $srcdir/ghc -a ! -f $srcdir/ghc/compiler/parser/Parser.hs; then
307   FP_COMPARE_VERSIONS([$fptools_cv_happy_version],[-lt],[1.14],
308   [AC_MSG_ERROR([Happy version 1.14 or later is required to compile GHC.])])[]dnl
309 fi
310 HappyVersion=$fptools_cv_happy_version;
311 AC_SUBST(HappyVersion)
312 ])
313
314 dnl
315 dnl Check for Haddock and version.  If there's no installed Haddock, we look
316 dnl for a haddock source tree and point the build system at that instead.
317 dnl
318 AC_DEFUN(FPTOOLS_HADDOCK,
319 [
320 if test -d $srcdir/haddock; then
321    SrcTreeHaddockCmd=$hardtop/haddock/src/haddock-inplace
322 fi
323 if test x"$UseSrcTreeHaddock" = xYES; then
324   HaddockCmd=$SrcTreeHaddockCmd
325 else
326   AC_PATH_PROG(HaddockCmd,haddock,$SrcTreeHaddockCmd)
327 fi
328 dnl Darn, I forgot to make Haddock print out its version number when
329 dnl invoked with -v.  We could try generating some HTML and grepping
330 dnl through that to find the version number, but I think we'll make
331 dnl do without it for now.
332 ])
333
334 dnl
335 dnl Check for Alex and version.  If we're building GHC, then we need
336 dnl at least Alex version 2.0.  If there's no installed Alex, we look
337 dnl for a alex source tree and point the build system at that instead.
338 dnl
339 AC_DEFUN(FPTOOLS_ALEX,
340 [
341 if test -d $srcdir/alex; then
342    SrcTreeAlexCmd=$hardtop/alex/src/alex-inplace
343 fi
344 if test x"$UseSrcTreeAlex" = xYES; then
345   AlexCmd=$SrcTreeAlexCmd
346 else
347   AC_PATH_PROG(AlexCmd,alex,$SrcTreeAlexCmd)
348 fi
349 AC_CACHE_CHECK([for version of alex], fptools_cv_alex_version,
350 changequote(, )dnl
351 [if test x"$AlexCmd" = x"$SrcTreeAlexCmd"; then
352    fptools_cv_alex_version=`grep '^ProjectVersion[      ]*=' $srcdir/alex/mk/version.mk | sed 's/.*\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/g'`;
353 elif test x"$AlexCmd" != x; then
354    fptools_cv_alex_version="`$AlexCmd -v |
355                           grep 'Alex [Vv]ersion' | sed -e 's/Alex [Vv]ersion \([0-9\.]*\).*/\1/g'`" ;
356 else
357    fptools_cv_alex_version="";
358 fi;
359 changequote([, ])dnl
360 ])
361 if test -d $srcdir/ghc -a ! -f $srcdir/ghc/compiler/parser/Lexer.hs; then
362   FP_COMPARE_VERSIONS([$fptools_cv_alex_version],[-lt],[2.0],
363   [AC_MSG_ERROR([Alex version 2.0 or later is required to compile GHC.])])[]dnl
364 fi
365 AlexVersion=$fptools_cv_alex_version;
366 AC_SUBST(AlexVersion)
367 ])
368
369
370 dnl
371 dnl Check whether ld supports -x
372 dnl
373 AC_DEFUN(FPTOOLS_LD_X,
374 [AC_CACHE_CHECK([whether ld understands -x], fptools_cv_ld_x,
375 [
376 echo 'foo() {}' > conftest.c
377 ${CC-cc} -c conftest.c
378 if ${LdCmd} -r -x -o foo.o conftest.o; then
379    fptools_cv_ld_x=yes
380 else
381    fptools_cv_ld_x=no
382 fi
383 rm -rf conftest.c conftest.o foo.o
384 ])
385 if test "$fptools_cv_ld_x" = yes; then
386         LdXFlag=-x
387 else
388         LdXFlag=
389 fi
390 AC_SUBST(LdXFlag)
391 ])
392
393
394 # FP_PROG_AR
395 # ----------
396 # Sets fp_prog_ar_raw to the full path of ar and fp_prog_ar to a non-Cygwin
397 # version of it. Exits if no ar can be found
398 AC_DEFUN([FP_PROG_AR],
399 [AC_PATH_PROG([fp_prog_ar_raw], [ar])
400 if test -z "$fp_prog_ar_raw"; then
401   AC_MSG_ERROR([cannot find ar in your PATH, no idea how to make a library])
402 fi
403 fp_prog_ar=$fp_prog_ar_raw
404 case $HostPlatform in
405   *mingw32) if test x${OSTYPE} != xmsys; then
406               fp_prog_ar="`cygpath -w ${fp_prog_ar_raw} | sed -e 's@\\\\@/@g'`"
407               AC_MSG_NOTICE([normalized ar command to $fp_prog_ar])
408             fi
409             ;;
410 esac
411 ])# FP_PROG_AR
412
413
414 # FP_PROG_AR_IS_GNU
415 # -----------------
416 # Sets fp_prog_ar_is_gnu to yes or no, depending on whether it is GNU ar or not.
417 AC_DEFUN([FP_PROG_AR_IS_GNU],
418 [AC_REQUIRE([FP_PROG_AR])
419 AC_CACHE_CHECK([whether $fp_prog_ar_raw is GNU ar], [fp_cv_prog_ar_is_gnu],
420 [if $fp_prog_ar_raw --version 2> /dev/null | grep "GNU" > /dev/null 2>&1; then
421   fp_cv_prog_ar_is_gnu=yes
422 else
423   fp_cv_prog_ar_is_gnu=no
424 fi])
425 fp_prog_ar_is_gnu=$fp_cv_prog_ar_is_gnu
426 ])# FP_PROG_AR_IS_GNU
427
428
429 # FP_PROG_AR_ARGS
430 # ---------------
431 # Sets fp_prog_ar_args to the arguments for ar and the output variable ArCmd
432 # to a non-Cygwin invocation of ar including these arguments.
433 AC_DEFUN([FP_PROG_AR_ARGS],
434 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
435 AC_CACHE_CHECK([for ar arguments], [fp_cv_prog_ar_args],
436 [
437 # GNU ar needs special treatment: it appears to have problems with
438 # object files with the same name if you use the 's' modifier, but
439 # simple 'ar q' works fine, and doesn't need a separate ranlib.
440 if test $fp_prog_ar_is_gnu = yes; then
441   fp_cv_prog_ar_args="q"
442 else
443   touch conftest.dummy
444   for fp_var in clqsZ clqs cqs clq cq ; do
445      rm -f conftest.a
446      if $fp_prog_ar_raw $fp_var conftest.a conftest.dummy > /dev/null 2> /dev/null; then
447         fp_cv_prog_ar_args=$fp_var
448         break
449      fi
450   done
451   rm -f conftest*
452   if test -z "$fp_cv_prog_ar_args"; then
453     AC_MSG_ERROR([cannot figure out how to use your $fp_prog_ar_raw])
454   fi
455 fi])
456 fp_prog_ar_args=$fp_cv_prog_ar_args
457 AC_SUBST([ArCmd], ["$fp_prog_ar $fp_prog_ar_args"])
458
459 ])# FP_PROG_AR_ARGS
460
461
462 # FP_PROG_AR_NEEDS_RANLIB
463 # -----------------------
464 # Sets the output variable RANLIB to "ranlib" if it is needed and found,
465 # to ":" otherwise.
466 AC_DEFUN([FP_PROG_AR_NEEDS_RANLIB],
467 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
468 AC_REQUIRE([FP_PROG_AR_ARGS])
469 AC_CACHE_CHECK([whether ranlib is needed], [fp_cv_prog_ar_needs_ranlib],
470 [if test $fp_prog_ar_is_gnu = yes; then
471   fp_cv_prog_ar_needs_ranlib=no
472 elif echo $fp_prog_ar_args | grep "s" > /dev/null 2> /dev/null; then
473   fp_cv_prog_ar_needs_ranlib=no
474 else
475   fp_cv_prog_ar_needs_ranlib=yes
476 fi])
477 if test $fp_cv_prog_ar_needs_ranlib = yes; then
478    AC_PROG_RANLIB
479 else
480   RANLIB=":"
481   AC_SUBST([RANLIB])
482 fi
483 ])# FP_PROG_AR_NEEDS_RANLIB
484
485
486 # FP_PROG_AR_SUPPORTS_INPUT
487 # -------------------------
488 # Sets the output variable ArSupportsInput to "-input" or "", depending on
489 # whether ar supports -input flag is supported or not.
490 AC_DEFUN([FP_PROG_AR_SUPPORTS_INPUT],
491 [AC_REQUIRE([FP_PROG_AR_IS_GNU])
492 AC_REQUIRE([FP_PROG_AR_ARGS])
493 AC_CACHE_CHECK([whether $fp_prog_ar_raw supports -input], [fp_cv_prog_ar_supports_input],
494 [fp_cv_prog_ar_supports_input=no
495 if test $fp_prog_ar_is_gnu = no; then
496   rm -f conftest*
497   touch conftest.lst
498   if FP_EVAL_STDERR([$fp_prog_ar_raw $fp_prog_ar_args conftest.a -input conftest.lst]) >/dev/null; then
499     test -s conftest.err || fp_cv_prog_ar_supports_input=yes
500   fi
501   rm -f conftest*
502 fi])
503 if test $fp_cv_prog_ar_supports_input = yes; then
504     ArSupportsInput="-input"
505 else
506     ArSupportsInput=""
507 fi
508 AC_SUBST([ArSupportsInput])
509 ])# FP_PROG_AR_SUPPORTS_INPUT
510
511
512 dnl
513 dnl AC_SHEBANG_PERL - can we she-bang perl?
514 dnl
515 AC_DEFUN(FPTOOLS_SHEBANG_PERL,
516 [AC_CACHE_CHECK([if your perl works in shell scripts], fptools_cv_shebang_perl,
517 [echo "#!$PerlCmd"'
518 exit $1;
519 ' > conftest
520 chmod u+x conftest
521 (SHELL=/bin/sh; export SHELL; ./conftest 69 > /dev/null)
522 if test $? -ne 69; then
523    fptools_cv_shebang_perl=yes
524 else
525    fptools_cv_shebang_perl=no
526 fi
527 rm -f conftest
528 ])])
529
530 dnl
531 dnl Extra testing of the result AC_PROG_CC, testing the gcc version no.
532 dnl *Must* be called after AC_PROG_CC
533 dnl
534 AC_DEFUN(FPTOOLS_HAVE_GCC,
535 [AC_CACHE_CHECK([whether you have an ok gcc], fptools_cv_have_gcc,
536 [if test -z "$GCC"; then
537     echo ''
538     echo "You would be better off with gcc"
539     echo "Perhaps it is already installed, but not in your PATH?"
540     fptools_cv_have_gcc='no'
541 else
542 changequote(, )dnl
543     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' `"
544 changequote([, ])dnl
545     fptools_cv_have_gcc='yes'
546     FP_COMPARE_VERSIONS([$gcc_version_str], [-lt], [2.0],
547         [fptools_cv_have_gcc='no'
548         echo ""
549         echo "your gcc version appears to be ..."
550         $CC --version
551         echo "gcc prior to 2.0 and have never worked with ghc."
552         echo "we recommend 2.95.3, although versions back to 2.7.2 should be ok."
553         AC_MSG_ERROR([gcc 1.X has never been supported])])
554 fi
555 ])
556 HaveGcc=`echo $fptools_cv_have_gcc | sed 'y/yesno/YESNO/'`
557 AC_SUBST(HaveGcc)
558 GccVersion=`gcc --version | grep mingw | cut -f 3 -d ' '`
559 AC_SUBST(GccVersion)
560 ])
561
562 dnl
563 dnl Some OSs (Mandrake Linux, in particular) configure GCC with
564 dnl -momit-leaf-frame-pointer on by default.  If this is the case, we
565 dnl need to turn it off for mangling to work.  The test is currently a bit
566 dnl crude, using only the version number of gcc.
567 dnl
568 AC_DEFUN([FPTOOLS_GCC_NEEDS_NO_OMIT_LFPTR],
569 [AC_CACHE_CHECK([whether gcc needs -mno-omit-leaf-frame-pointer], [fptools_cv_gcc_needs_no_omit_lfptr],
570 [FP_COMPARE_VERSIONS([$gcc_version_str], [-ge], [3.2],
571   [fptools_cv_gcc_needs_no_omit_lfptr=yes],
572   [fptools_cv_gcc_needs_no_omit_lfptr=no])])
573 if test "$fptools_cv_gcc_needs_no_omit_lfptr" = "yes"; then
574    AC_DEFINE([HAVE_GCC_MNO_OMIT_LFPTR], [1], [Define to 1 if gcc supports -mno-omit-leaf-frame-pointer.])
575 fi])# FPTOOLS_GCC_NEEDS_NO_OMIT_LFPTR
576
577
578 dnl Small feature test for perl version. Assumes PerlCmd
579 dnl contains path to perl binary
580 dnl
581 AC_DEFUN(FPTOOLS_CHECK_PERL_VERSION,
582 [$PerlCmd -v >conftest.out 2>&1
583 if grep "version 5" conftest.out >/dev/null 2>&1; then
584    :
585 else
586    if grep "v5.6" conftest.out >/dev/null 2>&1; then
587       :
588    else
589       if grep "v5.8" conftest.out >/dev/null 2>&1; then
590          :
591       else
592          if grep "version 6" conftest.out >/dev/null 2>&1; then
593             :
594          else
595             echo "Your version of perl probably won't work."
596          fi  
597       fi
598    fi
599 fi
600 rm -fr conftest*
601 ])
602
603
604 # FP_CHECK_PROG(VARIABLE, PROG-TO-CHECK-FOR,
605 #               [VALUE-IF-NOT-FOUND], [PATH], [REJECT])
606 # -----------------------------------------------------
607 # HACK: A small wrapper around AC_CHECK_PROG, setting VARIABLE to the full path
608 # of PROG-TO-CHECK-FOR when found.
609 AC_DEFUN([FP_CHECK_PROG],
610 [AC_CHECK_PROG([$1], [$2], [$as_dir/$ac_word$ac_exec_ext], [$3], [$4], [$5])][]dnl
611 )# FP_CHECK_PROC
612
613
614 # FP_PROG_FIND
615 # ------------
616 # Find a non-WinDoze version of the "find" utility.
617 AC_DEFUN([FP_PROG_FIND],
618 [AC_PATH_PROG([fp_prog_find], [find])
619 echo foo > conftest.txt
620 $fp_prog_find conftest.txt -print > conftest.out 2>&1
621 if grep '^conftest.txt$' conftest.out > /dev/null 2>&1 ; then
622   # OK, looks like a real "find".
623   FindCmd="$fp_prog_find"
624 else
625   # Found a poor WinDoze version of "find", ignore it.
626   AC_MSG_WARN([$fp_prog_find looks like a non-*nix find, ignoring it])
627   FP_CHECK_PROG([FindCmd], [find], [], [], [$fp_prog_find])
628 fi
629 rm -f conftest.txt conftest.out
630 AC_SUBST([FindCmd])[]dnl
631 ])# FP_PROG_FIND
632
633
634 dnl
635 dnl FPTOOLS_NOCACHE_CHECK prints a message, then sets the
636 dnl values of the second argument to the result of running
637 dnl the commands given by the third. It does not cache its
638 dnl result, so it is suitable for checks which should be
639 dnl run every time.
640 dnl
641 AC_DEFUN(FPTOOLS_NOCACHE_CHECK,
642 [AC_MSG_CHECKING([$1])
643  $3
644  AC_MSG_RESULT([$][$2])
645 ])
646
647 dnl
648 dnl FPTOOLS_GHC_VERSION(version)
649 dnl FPTOOLS_GHC_VERSION(major, minor [, patchlevel])
650 dnl FPTOOLS_GHC_VERSION(version, major, minor, patchlevel)
651 dnl
652 dnl Test for version of installed ghc.  Uses $GHC.
653 dnl [original version pinched from c2hs]
654 dnl
655 AC_DEFUN(FPTOOLS_GHC_VERSION,
656 [FPTOOLS_NOCACHE_CHECK([version of ghc], [fptools_version_of_ghc],
657 ["${WithGhc-ghc}" --version > conftestghc 2>&1
658   cat conftestghc >&AS_MESSAGE_LOG_FD
659 #Useless Use Of cat award...
660   fptools_version_of_ghc=`cat conftestghc | sed -n -e 's/, patchlevel *\([[0-9]]\)/.\1/;s/.* version \([[0-9]][[0-9.]]*\).*/\1/p'`
661   rm -fr conftest*
662   if test "[$]fptools_version_of_ghc" = ""
663   then
664     fptools_version_of_ghc='unknown'
665   fi
666 fptools_version_of_ghc[_major]=`echo [$]fptools_version_of_ghc | sed -e 's/^\([[0-9]]\).*/\1/'`
667 fptools_version_of_ghc[_minor]=`echo [$]fptools_version_of_ghc | sed -e 's/^[[0-9]]\.\([[0-9]]*\).*/\1/'`
668 fptools_version_of_ghc[_pl]=`echo [$]fptools_version_of_ghc | sed -n -e 's/^[[0-9]]\.[[0-9]]*\.\([[0-9]]*\)/\1/p'`
669 #
670 if test "[$]fptools_version_of_ghc[_pl]" = ""
671 then
672   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor]"
673   fptools_version_of_ghc[_pl]="0"
674 else
675   fptools_version_of_ghc[_all]="[$]fptools_version_of_ghc[_major].[$]fptools_version_of_ghc[_minor].[$]fptools_version_of_ghc[_pl]"
676 fi
677 #
678 ifelse($#, [1], [dnl
679 [$1]="[$]fptools_version_of_ghc[_all]"
680 ], $#, [2], [dnl
681 [$1]="[$]fptools_version_of_ghc[_major]"
682 [$2]="[$]fptools_version_of_ghc[_minor]"
683 ], $#, [3], [dnl
684 [$1]="[$]fptools_version_of_ghc[_major]"
685 [$2]="[$]fptools_version_of_ghc[_minor]"
686 [$3]="[$]fptools_version_of_ghc[_pl]"
687 ], $#, [4], [dnl
688 [$1]="[$]fptools_version_of_ghc[_all]"
689 [$2]="[$]fptools_version_of_ghc[_major]"
690 [$3]="[$]fptools_version_of_ghc[_minor]"
691 [$4]="[$]fptools_version_of_ghc[_pl]"
692 ])
693 ])
694 ])dnl
695
696
697 dnl ** Map an arithmetic C type to a Haskell type.
698 dnl    Based on autconf's AC_CHECK_SIZEOF.
699
700 dnl FPTOOLS_CHECK_HTYPE(TYPE [, DEFAULT_VALUE, [, VALUE-FOR-CROSS-COMPILATION])
701 AC_DEFUN(FPTOOLS_CHECK_HTYPE,
702 [changequote(<<, >>)dnl
703 dnl The name to #define.
704 define(<<AC_TYPE_NAME>>, translit(htype_$1, [a-z *], [A-Z_P]))dnl
705 dnl The cache variable name.
706 define(<<AC_CV_NAME>>, translit(fptools_cv_htype_$1, [ *], [_p]))dnl
707 define(<<AC_CV_NAME_supported>>, translit(fptools_cv_htype_sup_$1, [ *], [_p]))dnl
708 changequote([, ])dnl
709 AC_MSG_CHECKING(Haskell type for $1)
710 AC_CACHE_VAL(AC_CV_NAME,
711 [AC_CV_NAME_supported=yes
712 fp_check_htype_save_cppflags="$CPPFLAGS"
713 CPPFLAGS="$CPPFLAGS $X_CFLAGS"
714 AC_TRY_RUN([#include <stdio.h>
715 #include <stddef.h>
716
717 #if HAVE_SYS_TYPES_H
718 # include <sys/types.h>
719 #endif
720
721 #if HAVE_UNISTD_H
722 # include <unistd.h>
723 #endif
724
725 #if HAVE_SYS_STAT_H
726 # include <sys/stat.h>
727 #endif
728
729 #if HAVE_FCNTL_H
730 # include <fcntl.h>
731 #endif
732
733 #if HAVE_SIGNAL_H
734 # include <signal.h>
735 #endif
736
737 #if HAVE_TIME_H
738 # include <time.h>
739 #endif
740
741 #if HAVE_TERMIOS_H
742 # include <termios.h>
743 #endif
744
745 #if HAVE_STRING_H
746 # include <string.h>
747 #endif
748
749 #if HAVE_CTYPE_H
750 # include <ctype.h>
751 #endif
752
753 #if defined(HAVE_GL_GL_H)
754 # include <GL/gl.h>
755 #elif defined(HAVE_OPENGL_GL_H)
756 # include <OpenGL/gl.h>
757 #endif
758
759 #if defined(HAVE_AL_ALC_H)
760 # include <AL/alc.h>
761 #elif defined(HAVE_OPENAL_ALC_H)
762 # include <OpenAL/alc.h>
763 #endif
764
765 #if HAVE_SYS_RESOURCE_H
766 # include <sys/resource.h>
767 #endif
768
769 typedef $1 testing;
770
771 main() {
772   FILE *f=fopen("conftestval", "w");
773   if (!f) exit(1);
774   if (((testing)((int)((testing)1.4))) == ((testing)1.4)) {
775     fprintf(f, "%s%d\n",
776            ((testing)(-1) < (testing)0) ? "Int" : "Word",
777            sizeof(testing)*8);
778   } else {
779     fprintf(f,"%s\n",
780            (sizeof(testing) >  sizeof(double)) ? "LDouble" :
781            (sizeof(testing) == sizeof(double)) ? "Double"  : "Float");
782   }
783   fclose(f);
784   exit(0);
785 }],AC_CV_NAME=`cat conftestval`,
786 ifelse([$2], , [AC_CV_NAME=NotReallyAType; AC_CV_NAME_supported=no], AC_CV_NAME=$2),
787 ifelse([$3], , [AC_CV_NAME=NotReallyATypeCross; AC_CV_NAME_supported=no], AC_CV_NAME=$3))]) dnl
788 CPPFLAGS="$fp_check_htype_save_cppflags"
789 if test "$AC_CV_NAME_supported" = yes; then
790   AC_MSG_RESULT($AC_CV_NAME)
791   AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to Haskell type for $1])
792 else
793   AC_MSG_RESULT([not supported])
794 fi
795 undefine([AC_TYPE_NAME])dnl
796 undefine([AC_CV_NAME])dnl
797 undefine([AC_CV_NAME_supported])dnl
798 ])
799
800
801 # FP_CHECK_FUNC(FUNCTION, PROLOGUE, BODY, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
802 # ---------------------------------------------------------------------------------
803 # A variant of AC_CHECK_FUNCS, limited to a single FUNCTION, but with the
804 # additional flexibility of specifying the PROLOGUE and BODY.
805 AC_DEFUN([FP_CHECK_FUNC],
806 [AS_VAR_PUSHDEF([fp_func], [fp_cv_func_$1])dnl
807 AC_CACHE_CHECK([for $1], fp_func,
808 [AC_LINK_IFELSE([AC_LANG_PROGRAM([$2], [$3])],
809                 [AS_VAR_SET(fp_func, yes)],
810                 [AS_VAR_SET(fp_func, no)])])
811 AS_IF([test AS_VAR_GET(fp_func) = yes],
812       [AC_DEFINE(AS_TR_CPP(HAVE_$1), [1],
813                 [Define to 1 if you have the `]$1[' function.]) $4],
814       [$5])dnl
815 AS_VAR_POPDEF([fp_func])dnl
816 ])# FP_CHECK_FUNC
817
818
819 # FP_GEN_DOCBOOK_XML
820 # ------------------
821 # Generates a DocBook XML V4.2 document in conftest.xml.
822 AC_DEFUN([FP_GEN_DOCBOOK_XML],
823 [rm -f conftest.xml
824 cat > conftest.xml << EOF
825 <?xml version="1.0" encoding="iso-8859-1"?>
826 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
827    "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
828 <book id="test">
829   <title>A DocBook Test Document</title>
830   <chapter id="id-one">
831     <title>A Chapter Title</title>
832     <para>This is a paragraph, referencing <xref linkend="id-two"/>.</para>
833   </chapter>
834   <chapter id="id-two">
835     <title>Another Chapter Title</title>
836     <para>This is another paragraph, referencing <xref linkend="id-one"/>.</para>
837   </chapter>
838 </book>
839 EOF
840 ]) # FP_GEN_DOCBOOK_XML
841
842
843 # FP_PROG_XSLTPROC
844 # ----------------
845 # Sets the output variable XsltprocCmd to the full path of the XSLT processor
846 # xsltproc. XsltprocCmd is empty if xsltproc could not be found.
847 AC_DEFUN([FP_PROG_XSLTPROC],
848 [AC_PATH_PROG([XsltprocCmd], [xsltproc])
849 if test -z "$XsltprocCmd"; then
850   AC_MSG_WARN([cannot find xsltproc in your PATH, you will not be able to build the documentation])
851 fi
852 ])# FP_PROG_XSLTPROC
853
854
855 # FP_DIR_DOCBOOK_XSL(XSL-DIRS)
856 # ----------------------------
857 # Check which of the directories XSL-DIRS contains DocBook XSL stylesheets. The
858 # output variable DIR_DOCBOOK_XSL will contain the first usable directory or
859 # will be empty if none could be found.
860 AC_DEFUN([FP_DIR_DOCBOOK_XSL],
861 [AC_REQUIRE([FP_PROG_XSLTPROC])dnl
862 if test -n "$XsltprocCmd"; then
863   AC_CACHE_CHECK([for DocBook XSL stylesheet directory], fp_cv_dir_docbook_xsl,
864   [FP_GEN_DOCBOOK_XML
865   fp_cv_dir_docbook_xsl=no
866   for fp_var in $1; do
867      if $XsltprocCmd ${fp_var}/html/docbook.xsl conftest.xml > /dev/null 2>&1; then
868         fp_cv_dir_docbook_xsl=$fp_var
869         break
870      fi
871   done
872   rm -rf conftest*])
873 fi
874 if test x"$fp_cv_dir_docbook_xsl" = xno; then
875   AC_MSG_WARN([cannot find DocBook XSL stylesheets, you will not be able to build the documentation])
876   DIR_DOCBOOK_XSL=
877 else
878   DIR_DOCBOOK_XSL=$fp_cv_dir_docbook_xsl
879 fi
880 AC_SUBST([DIR_DOCBOOK_XSL])
881 ])# FP_DIR_DOCBOOK_XSL
882
883
884 # FP_PROG_XMLLINT
885 # ----------------
886 # Sets the output variable XmllintCmd to the full path of the XSLT processor
887 # xmllint. XmllintCmd is empty if xmllint could not be found.
888 AC_DEFUN([FP_PROG_XMLLINT],
889 [AC_PATH_PROG([XmllintCmd], [xmllint])
890 if test -z "$XmllintCmd"; then
891   AC_MSG_WARN([cannot find xmllint in your PATH, you will not be able to validate your documentation])
892 fi
893 ])# FP_PROG_XMLLINT
894
895
896 # FP_CHECK_DOCBOOK_DTD
897 # --------------------
898 AC_DEFUN([FP_CHECK_DOCBOOK_DTD],
899 [AC_REQUIRE([FP_PROG_XMLLINT])dnl
900 if test -n "$XmllintCmd"; then
901   AC_MSG_CHECKING([for DocBook DTD])
902   FP_GEN_DOCBOOK_XML
903   if $XmllintCmd --valid --noout conftest.xml > /dev/null 2>&1; then
904     AC_MSG_RESULT([ok])
905   else
906     AC_MSG_RESULT([failed])
907     AC_MSG_WARN([cannot find a DTD for DocBook XML V4.2, you will not be able to validate your documentation])
908     AC_MSG_WARN([check your XML_CATALOG_FILES environment variable and/or /etc/xml/catalog])
909   fi
910   rm -rf conftest*
911 fi
912 ])# FP_CHECK_DOCBOOK_DTD
913
914
915 # FP_GEN_FO
916 # ------------------
917 # Generates a formatting objects document in conftest.fo.
918 AC_DEFUN([FP_GEN_FO],
919 [rm -f conftest.fo
920 cat > conftest.fo << EOF
921 <?xml version="1.0"?>
922 <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
923   <fo:layout-master-set>
924     <fo:simple-page-master master-name="blank">
925       <fo:region-body/>
926     </fo:simple-page-master>
927   </fo:layout-master-set>
928   <fo:page-sequence master-reference="blank">
929     <fo:flow flow-name="xsl-region-body">
930       <fo:block>
931         Test!
932       </fo:block>
933     </fo:flow>
934   </fo:page-sequence>
935 </fo:root>
936 EOF
937 ]) # FP_GEN_FO
938
939
940 # FP_PROG_FOP
941 # -----------
942 # Set the output variable 'FopCmd' to the first working 'fop' in the current
943 # 'PATH'. Note that /usr/bin/fop is broken in SuSE 9.1 (unpatched), so try
944 # /usr/share/fop/fop.sh in that case (or no 'fop'), too.
945 AC_DEFUN([FP_PROG_FOP],
946 [AC_PATH_PROGS([FopCmd1], [fop])
947 if test -n "$FopCmd1"; then
948   AC_CACHE_CHECK([for $FopCmd1 usability], [fp_cv_fop_usability],
949     [FP_GEN_FO
950     if "$FopCmd1" -fo conftest.fo -ps conftest.ps > /dev/null 2>&1; then
951       fp_cv_fop_usability=yes
952     else
953       fp_cv_fop_usability=no
954     fi
955     rm -rf conftest*])
956   if test x"$fp_cv_fop_usability" = xyes; then
957      FopCmd=$FopCmd1
958   fi
959 fi
960 if test -z "$FopCmd"; then
961   AC_PATH_PROGS([FopCmd2], [fop.sh], , [/usr/share/fop])
962   FopCmd=$FopCmd2
963 fi
964 AC_SUBST([FopCmd])
965 ])# FP_PROG_FOP
966
967
968 # FP_PROG_FO_PROCESSOR
969 # --------------------
970 # Try to find an FO processor. PassiveTeX output is sometimes a bit strange, so
971 # try FOP first. Sets the output variables FopCmd, XmltexCmd, DvipsCmd, and
972 # PdfxmltexCmd.
973 AC_DEFUN([FP_PROG_FO_PROCESSOR],
974 [AC_REQUIRE([FP_PROG_FOP])
975 AC_PATH_PROG([XmltexCmd], [xmltex])
976 AC_PATH_PROG([DvipsCmd], [dvips])
977 if test -z "$FopCmd"; then
978   if test -z "$XmltexCmd"; then
979     AC_MSG_WARN([cannot find an FO => DVI converter, you will not be able to build DVI or PostScript documentation])
980   else
981     if test -z "$DvipsCmd"; then
982       AC_MSG_WARN([cannot find a DVI  => PS converter, you will not be able to build PostScript documentation])
983     fi
984   fi
985   AC_PATH_PROG([PdfxmltexCmd], [pdfxmltex])
986   if test -z "$PdfxmltexCmd"; then
987     AC_MSG_WARN([cannot find an FO => PDF converter, you will not be able to build PDF documentation])
988   fi
989 elif test -z "$XmltexCmd"; then
990   AC_MSG_WARN([cannot find an FO => DVI converter, you will not be able to build DVI documentation])
991 fi
992 ])# FP_PROG_FO_PROCESSOR
993
994
995 # FP_PROG_GHC_PKG
996 # ----------------
997 # Try to find a ghc-pkg matching the ghc mentioned in the environment variable
998 # WithGhc. If the latter is unset or no matching ghc-pkg can be found, try to
999 # find a plain ghc-pkg. Sets the output variable GhcPkgCmd.
1000 AC_DEFUN([FP_PROG_GHC_PKG],
1001 [AC_CACHE_CHECK([for ghc-pkg matching $WithGhc], fp_cv_matching_ghc_pkg,
1002 [fp_ghc_pkg_guess=`echo $WithGhc | sed 's,ghc\(@<:@^/\\@:>@*\)$,ghc-pkg\1,'`
1003 if "$fp_ghc_pkg_guess" -l > /dev/null 2>&1; then
1004   fp_cv_matching_ghc_pkg=$fp_ghc_pkg_guess
1005 else
1006   fp_cv_matching_ghc_pkg=no
1007 fi])
1008 if test x"$fp_cv_matching_ghc_pkg" = xno; then
1009   AC_PATH_PROG([GhcPkgCmd], [ghc-pkg])
1010 else
1011   GhcPkgCmd=$fp_cv_matching_ghc_pkg
1012 fi])# FP_PROG_GHC_PKG
1013
1014
1015 # FP_CHECK_WIN32
1016 # --------------
1017 # If Windows is the target platform (e.g. MinGW/MSYS or Cygwin with
1018 # -mno-cygwin), the variable "is_win32" is set to "yes", otherwise (e.g. *nix
1019 # systems or plain Cygwin) it is set to "no".
1020 AC_DEFUN([FP_CHECK_WIN32],
1021 [AC_CACHE_CHECK([for Windows environment], [fp_cv_is_win32],
1022   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1023 #if !_WIN32
1024    syntax error;
1025 #endif
1026 ])], [fp_cv_is_win32=yes], [fp_cv_is_win32=no])])
1027 is_win32="$fp_cv_is_win32"[]dnl
1028 ])# FP_CHECK_WIN32
1029
1030
1031 # FP_PATH_X
1032 # ---------
1033 # Same as AC_PATH_X, but works even for broken Cygwins which try to include the
1034 # non-existant <gl/mesa_wgl.h> header when -mno-cygwin is used.
1035 AC_DEFUN([FP_PATH_X],
1036 [AC_REQUIRE([FP_CHECK_WIN32])
1037 if test x"$is_win32" = xyes; then
1038   no_x=yes
1039 else
1040   AC_PATH_X
1041 fi
1042 ])# FP_PATH_X
1043
1044
1045 # FP_PATH_XTRA
1046 # ------------
1047 # Same as AC_PATH_XTRA, but works even for broken Cygwins which try to include
1048 # the non-existant <gl/mesa_wgl.h> header when -mno-cygwin is used.
1049 AC_DEFUN([FP_PATH_XTRA],
1050 [AC_REQUIRE([FP_CHECK_WIN32])
1051 if test x"$is_win32" = xyes; then
1052   no_x=yes
1053 else
1054   AC_PATH_XTRA
1055 fi
1056 ])# FP_PATH_XTRA
1057
1058
1059 # FP_CHECK_GL_HELPER(LIBNAME, LIBS, INCLUDES, FUNCTION-BODY)
1060 # ----------------------------------------------------------
1061 # Try each library in LIBS to successfully link INCLUDES plus FUNCTION-BODY,
1062 # setting LIBNAME_CFLAGS and LIBNAME_LIBS to the corresponding values. Sets
1063 # no_LIBNAME to "yes" if no suitable library was found. (LIBNAME_CFLAGS0
1064 # contains the value of LIBNAME_CFLAGS without CPPFLAGS, and LIBNAME_LIBS0
1065 # contains the value of LIBNAME_LIBS without LDFLAGS, but these are only
1066 # used internally.)
1067 AC_DEFUN([FP_CHECK_GL_HELPER],
1068 [AC_CACHE_CHECK([for $1 library], [fp_cv_check_$1_lib],
1069   [fp_cv_check_$1_lib="no"
1070   fp_save_CPPFLAGS="$CPPFLAGS"
1071   CPPFLAGS="$CPPFLAGS ${$1_CFLAGS}"
1072   fp_save_LIBS="$LIBS"
1073   for fp_try_lib in $2; do
1074     # transform "-lfoo" to "foo.lib" when using cl
1075     if test x"$CC" = xcl; then
1076       fp_try_lib=`echo $fp_try_lib | sed -e 's/^-l//' -e 's/$/.lib/'`
1077     fi
1078     LIBS="$fp_try_lib ${$1_LIBS} $fp_save_LIBS"
1079     AC_TRY_LINK([$3], [$4], [fp_cv_check_$1_lib="$fp_try_lib ${$1_LIBS}"; break])
1080   done
1081   LIBS="$fp_save_LIBS"
1082   CPPFLAGS="$fp_save_CPPFLAGS"])
1083
1084   if test x"$fp_cv_check_$1_lib" = xno; then
1085     no_$1=yes
1086     $1_CFLAGS=
1087     $1_LIBS=
1088   else
1089     $1_CFLAGS0="${$1_CFLAGS}"
1090     $1_CFLAGS="$CPPFLAGS ${$1_CFLAGS0}"
1091     $1_LIBS0="$fp_cv_check_$1_lib"
1092     $1_LIBS="$LDFLAGS ${$1_LIBS0}"
1093   fi
1094 ])# FP_CHECK_GL_HELPER
1095
1096
1097 # FP_CHECK_GL
1098 # -----------
1099 AC_DEFUN([FP_CHECK_GL],
1100 [AC_REQUIRE([FP_PATH_X])
1101 AC_REQUIRE([AC_CANONICAL_TARGET])
1102
1103 AC_ARG_ENABLE([hopengl],
1104   [AC_HELP_STRING([--enable-hopengl],
1105     [build a Haskell binding for OpenGL (GL/GLU). On Mac OS X, use
1106      --enable-hopengl=x11 to use X11 instead of the "native" libraries.
1107      (default=no)])],
1108   [enable_opengl=$enableval], [enable_opengl=no])
1109
1110 if test x"$enable_opengl" = xno; then
1111    no_GL=yes
1112 else
1113   use_quartz_opengl=no
1114   case $target_os in
1115   darwin*)
1116     if test x"$enable_opengl" != xx11; then
1117       AC_DEFINE([USE_QUARTZ_OPENGL], [1],
1118                 [Define to 1 if native OpenGL should be used on Mac OS X])
1119       use_quartz_opengl=yes
1120     fi
1121     ;;
1122   esac
1123
1124   if test x"$use_quartz_opengl" != xyes; then
1125     AC_CHECK_LIB([m], [atan], [GL_LIBS="-lm $GL_LIBS"])
1126
1127     if test x"$no_x" != xyes; then
1128       test -n "$x_includes" && GL_CFLAGS="-I$x_includes $GL_CFLAGS"
1129       test -n "$x_libraries" && GL_LIBS="-L$x_libraries -lX11 $GL_LIBS"
1130     fi
1131
1132     FP_CHECK_GL_HELPER([GL], [-lGL -lopengl32], [@%:@include <GL/gl.h>], [glEnd()])
1133
1134     if test x"$no_GL" != xyes; then
1135       # Ugly: To get wglGetProcAddress on Windows, we have to link with
1136       # opengl32.dll, too, even when we are using Cygwin with X11.
1137       case "$GL_LIBS" in
1138         *-lopengl32*|*opengl32.lib*) ;;
1139         *) fp_save_LIBS="$LIBS"
1140            LIBS="$LIBS -lopengl32"
1141            AC_TRY_LINK([@%:@include <GL/gl.h>], [glEnd()],
1142              [GL_LIBS="$GL_LIBS -lopengl32"; GL_LIBS0="$GL_LIBS0 -lopengl32"])
1143            LIBS="$fp_save_LIBS"
1144            ;;
1145       esac
1146     fi
1147   fi
1148 fi
1149
1150 AC_SUBST([GL_CFLAGS])
1151 AC_SUBST([GL_LIBS])
1152 ])# FP_CHECK_GL
1153
1154
1155 # FP_CHECK_GLU
1156 # ------------
1157 AC_DEFUN([FP_CHECK_GLU],
1158 [AC_REQUIRE([FP_CHECK_GL])dnl
1159 GLU_CFLAGS="$GL_CFLAGS0"
1160 GLU_LIBS="$GL_LIBS0"
1161
1162 if test x"$enable_opengl" = xno; then
1163    no_GLU=yes
1164 elif test x"$use_quartz_opengl" != xyes; then
1165   FP_CHECK_GL_HELPER([GLU], [-lglu32 -lGLU], [@%:@include <GL/glu.h>], [gluNewQuadric()])
1166 fi
1167
1168 AC_SUBST([GLU_CFLAGS])
1169 AC_SUBST([GLU_LIBS])
1170 ])# FP_CHECK_GLU
1171
1172
1173 # FP_CHECK_GLUT
1174 # -------------
1175 AC_DEFUN([FP_CHECK_GLUT],
1176 [AC_REQUIRE([FP_CHECK_GLU])
1177 FP_PATH_XTRA
1178
1179 if test x"$enable_opengl" = xno; then
1180    no_GLUT=yes
1181 elif test x"$use_quartz_opengl" != xyes; then
1182   GLUT_CFLAGS="$GLU_CFLAGS0"
1183   GLUT_LIBS="$GLU_LIBS0"
1184
1185   if test x"$no_x" != xyes; then
1186     GLUT_LIBS="$X_PRE_LIBS -lXmu -lXi $X_EXTRA_LIBS $GLUT_LIBS"
1187   fi
1188
1189   AC_CHECK_HEADERS([windows.h GL/glut.h])
1190   # Note 1: On Cygwin with X11, GL/GLU functions use the "normal" calling
1191   # convention, but GLUT functions use stdcall. To get this right, it is
1192   # necessary to include <windows.h> first.
1193   # Note 2: MinGW/MSYS comes without a GLUT header, so we use Cygwin's one in
1194   # that case.
1195   FP_CHECK_GL_HELPER([GLUT], [-lglut32 -lglut], [
1196 #if HAVE_WINDOWS_H
1197 #include <windows.h>
1198 #endif
1199 #if HAVE_GL_GLUT_H
1200 #include <GL/glut.h>
1201 #else
1202 #include "glut_local.h"
1203 #endif
1204     ], [glutMainLoop()])
1205 fi
1206
1207 AC_SUBST([GLUT_CFLAGS])
1208 AC_SUBST([GLUT_LIBS])
1209 ])# FP_CHECK_GLUT
1210
1211
1212 dnl @synopsis FP_EMPTY_STRUCTS
1213 dnl 
1214 dnl Check whether empty structs is accepted by CC.
1215 dnl
1216 AC_DEFUN(FP_EMPTY_STRUCTS,
1217 [AC_CACHE_CHECK(empty struct support, fptools_cv_empty_structs,
1218 [AC_TRY_COMPILE([
1219 typedef struct { /*empty*/ } StgFoo;
1220 ],
1221 [int i;], 
1222 fptools_cv_empty_structs=yes,
1223 fptools_cv_empty_structs=no)])
1224 if test "$fptools_cv_empty_structs" = yes; then
1225 AC_DEFINE([SUPPORTS_EMPTY_STRUCTS], [1], [Define to 1 if C compiler supports declaration of empty structure types.])
1226 fi
1227 ])
1228
1229
1230 # LocalWords:  fi