← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/configure

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2007-04-09 11:51:51 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070409115151-ql8cr0kalzx1jmla
Tags: 0.9i-20070324-2
Upload to unstable. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/configure
1
1
#! /bin/sh
2
 
# From configure.in Revision: 1.135 .
 
2
# From configure.in Revision: 1.142 .
3
3
# Guess values for system-dependent variables and create Makefiles.
4
 
# Generated by GNU Autoconf 2.60 for ecl 0.9i.
 
4
# Generated by GNU Autoconf 2.61 for ecl 0.9i.
5
5
#
6
6
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
7
7
# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
11
11
## M4sh Initialization.  ##
12
12
## --------------------- ##
13
13
 
14
 
# Be Bourne compatible
 
14
# Be more Bourne compatible
 
15
DUALCASE=1; export DUALCASE # for MKS sh
15
16
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
16
17
  emulate sh
17
18
  NULLCMD=:
20
21
  alias -g '${1+"$@"}'='"$@"'
21
22
  setopt NO_GLOB_SUBST
22
23
else
23
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
24
  case `(set -o) 2>/dev/null` in
 
25
  *posix*) set -o posix ;;
 
26
esac
 
27
 
24
28
fi
25
 
BIN_SH=xpg4; export BIN_SH # for Tru64
26
 
DUALCASE=1; export DUALCASE # for MKS sh
 
29
 
 
30
 
27
31
 
28
32
 
29
33
# PATH needs CR
216
220
else
217
221
  as_candidate_shells=
218
222
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
219
 
for as_dir in /usr/bin/posix$PATH_SEPARATOR/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
223
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
220
224
do
221
225
  IFS=$as_save_IFS
222
226
  test -z "$as_dir" && as_dir=.
234
238
         # Try only shells that exist, to save several forks.
235
239
         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
236
240
                { ("$as_shell") 2> /dev/null <<\_ASEOF
237
 
# Be Bourne compatible
238
241
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
239
242
  emulate sh
240
243
  NULLCMD=:
243
246
  alias -g '${1+"$@"}'='"$@"'
244
247
  setopt NO_GLOB_SUBST
245
248
else
246
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
249
  case `(set -o) 2>/dev/null` in
 
250
  *posix*) set -o posix ;;
 
251
esac
 
252
 
247
253
fi
248
 
BIN_SH=xpg4; export BIN_SH # for Tru64
249
 
DUALCASE=1; export DUALCASE # for MKS sh
 
254
 
250
255
 
251
256
:
252
257
_ASEOF
254
259
  CONFIG_SHELL=$as_shell
255
260
               as_have_required=yes
256
261
               if { "$as_shell" 2> /dev/null <<\_ASEOF
257
 
# Be Bourne compatible
258
262
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
259
263
  emulate sh
260
264
  NULLCMD=:
263
267
  alias -g '${1+"$@"}'='"$@"'
264
268
  setopt NO_GLOB_SUBST
265
269
else
266
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
270
  case `(set -o) 2>/dev/null` in
 
271
  *posix*) set -o posix ;;
 
272
esac
 
273
 
267
274
fi
268
 
BIN_SH=xpg4; export BIN_SH # for Tru64
269
 
DUALCASE=1; export DUALCASE # for MKS sh
 
275
 
270
276
 
271
277
:
272
278
(as_func_return () {
513
519
  as_mkdir_p=false
514
520
fi
515
521
 
516
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
517
 
# systems may use methods other than mode bits to determine executability.
518
 
cat >conf$$.file <<_ASEOF
519
 
#! /bin/sh
520
 
exit 0
521
 
_ASEOF
522
 
chmod +x conf$$.file
523
 
if test -x conf$$.file >/dev/null 2>&1; then
524
 
  as_executable_p="test -x"
 
522
if test -x / >/dev/null 2>&1; then
 
523
  as_test_x='test -x'
525
524
else
526
 
  as_executable_p=:
 
525
  if ls -dL / >/dev/null 2>&1; then
 
526
    as_ls_L_option=L
 
527
  else
 
528
    as_ls_L_option=
 
529
  fi
 
530
  as_test_x='
 
531
    eval sh -c '\''
 
532
      if test -d "$1"; then
 
533
        test -d "$1/.";
 
534
      else
 
535
        case $1 in
 
536
        -*)set "./$1";;
 
537
        esac;
 
538
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
539
        ???[sx]*):;;*)false;;esac;fi
 
540
    '\'' sh
 
541
  '
527
542
fi
528
 
rm -f conf$$.file
 
543
as_executable_p=$as_test_x
529
544
 
530
545
# Sed expression to map a string onto a valid CPP name.
531
546
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
566
581
# Factoring default headers for most tests.
567
582
ac_includes_default="\
568
583
#include <stdio.h>
569
 
#if HAVE_SYS_TYPES_H
 
584
#ifdef HAVE_SYS_TYPES_H
570
585
# include <sys/types.h>
571
586
#endif
572
 
#if HAVE_SYS_STAT_H
 
587
#ifdef HAVE_SYS_STAT_H
573
588
# include <sys/stat.h>
574
589
#endif
575
 
#if STDC_HEADERS
 
590
#ifdef STDC_HEADERS
576
591
# include <stdlib.h>
577
592
# include <stddef.h>
578
593
#else
579
 
# if HAVE_STDLIB_H
 
594
# ifdef HAVE_STDLIB_H
580
595
#  include <stdlib.h>
581
596
# endif
582
597
#endif
583
 
#if HAVE_STRING_H
584
 
# if !STDC_HEADERS && HAVE_MEMORY_H
 
598
#ifdef HAVE_STRING_H
 
599
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
585
600
#  include <memory.h>
586
601
# endif
587
602
# include <string.h>
588
603
#endif
589
 
#if HAVE_STRINGS_H
 
604
#ifdef HAVE_STRINGS_H
590
605
# include <strings.h>
591
606
#endif
592
 
#if HAVE_INTTYPES_H
 
607
#ifdef HAVE_INTTYPES_H
593
608
# include <inttypes.h>
594
609
#endif
595
 
#if HAVE_STDINT_H
 
610
#ifdef HAVE_STDINT_H
596
611
# include <stdint.h>
597
612
#endif
598
 
#if HAVE_UNISTD_H
 
613
#ifdef HAVE_UNISTD_H
599
614
# include <unistd.h>
600
615
#endif"
601
616
 
723
738
CC
724
739
CFLAGS
725
740
LDFLAGS
 
741
LIBS
726
742
CPPFLAGS
727
743
CXX
728
744
CXXFLAGS
834
850
  -disable-* | --disable-*)
835
851
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
836
852
    # Reject names that are not valid shell variable names.
837
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
853
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
838
854
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
839
855
   { (exit 1); exit 1; }; }
840
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
856
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
841
857
    eval enable_$ac_feature=no ;;
842
858
 
843
859
  -docdir | --docdir | --docdi | --doc | --do)
853
869
  -enable-* | --enable-*)
854
870
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
855
871
    # Reject names that are not valid shell variable names.
856
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
872
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
857
873
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
858
874
   { (exit 1); exit 1; }; }
859
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
875
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
860
876
    eval enable_$ac_feature=\$ac_optarg ;;
861
877
 
862
878
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1050
1066
  -with-* | --with-*)
1051
1067
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1052
1068
    # Reject names that are not valid shell variable names.
1053
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1069
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1054
1070
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1055
1071
   { (exit 1); exit 1; }; }
1056
 
    ac_package=`echo $ac_package| sed 's/-/_/g'`
 
1072
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1057
1073
    eval with_$ac_package=\$ac_optarg ;;
1058
1074
 
1059
1075
  -without-* | --without-*)
1060
1076
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1061
1077
    # Reject names that are not valid shell variable names.
1062
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1078
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1063
1079
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1064
1080
   { (exit 1); exit 1; }; }
1065
 
    ac_package=`echo $ac_package | sed 's/-/_/g'`
 
1081
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1066
1082
    eval with_$ac_package=no ;;
1067
1083
 
1068
1084
  --x)
1320
1336
  --enable-opcode8        interpreter uses 8-bit codes (default=NO, only works
1321
1337
                          on Intel)
1322
1338
  --enable-unicode        enable support for unicode (default=NO)
 
1339
  --enable-longdouble     include support for long double (default=NO)
 
1340
  --enable-c99-complex    include support for C complex type (default=NO)
 
1341
  --enable-hierarchical-packages
 
1342
                          hierarchical package names (default=YES)
1323
1343
 
1324
1344
Optional Packages:
1325
1345
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1352
1372
  CFLAGS      C compiler flags
1353
1373
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1354
1374
              nonstandard directory <lib dir>
 
1375
  LIBS        libraries to pass to the linker, e.g. -l<library>
1355
1376
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1356
1377
              you have headers in a nonstandard directory <include dir>
1357
1378
  CXX         C++ compiler command
1423
1444
if $ac_init_version; then
1424
1445
  cat <<\_ACEOF
1425
1446
ecl configure 0.9i
1426
 
generated by GNU Autoconf 2.60
 
1447
generated by GNU Autoconf 2.61
1427
1448
 
1428
1449
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1429
1450
2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
1437
1458
running configure, to aid debugging if configure makes a mistake.
1438
1459
 
1439
1460
It was created by ecl $as_me 0.9i, which was
1440
 
generated by GNU Autoconf 2.60.  Invocation command line was
 
1461
generated by GNU Autoconf 2.61.  Invocation command line was
1441
1462
 
1442
1463
  $ $0 $@
1443
1464
 
2044
2065
fi
2045
2066
 
2046
2067
 
 
2068
# Check whether --enable-longdouble was given.
 
2069
if test "${enable_longdouble+set}" = set; then
 
2070
  enableval=$enable_longdouble; enable_longdouble=${enableval}
 
2071
else
 
2072
  enable_longdouble=no
 
2073
fi
 
2074
 
 
2075
 
 
2076
# Check whether --enable-c99complex was given.
 
2077
if test "${enable_c99complex+set}" = set; then
 
2078
  enableval=$enable_c99complex; enable_c99complex=${enableval}
 
2079
else
 
2080
  enable_c99complex=no
 
2081
fi
 
2082
 
 
2083
 
 
2084
# Check whether --enable-hpack was given.
 
2085
if test "${enable_hpack+set}" = set; then
 
2086
  enableval=$enable_hpack; enable_hpack=${enableval}
 
2087
else
 
2088
  enable_hpack=yes
 
2089
fi
 
2090
 
 
2091
 
2047
2092
libdir="${libdir}/ecl"
2048
2093
includedir="${libdir}"
2049
2094
test -z "${docdir}" && docdir="${datadir}/doc/ecl"
2163
2208
  IFS=$as_save_IFS
2164
2209
  test -z "$as_dir" && as_dir=.
2165
2210
  for ac_exec_ext in '' $ac_executable_extensions; do
2166
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2211
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2167
2212
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2168
2213
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2169
2214
    break 2
2203
2248
  IFS=$as_save_IFS
2204
2249
  test -z "$as_dir" && as_dir=.
2205
2250
  for ac_exec_ext in '' $ac_executable_extensions; do
2206
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2251
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2207
2252
    ac_cv_prog_ac_ct_CC="gcc"
2208
2253
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2209
2254
    break 2
2260
2305
  IFS=$as_save_IFS
2261
2306
  test -z "$as_dir" && as_dir=.
2262
2307
  for ac_exec_ext in '' $ac_executable_extensions; do
2263
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2308
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2264
2309
    ac_cv_prog_CC="${ac_tool_prefix}cc"
2265
2310
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2266
2311
    break 2
2301
2346
  IFS=$as_save_IFS
2302
2347
  test -z "$as_dir" && as_dir=.
2303
2348
  for ac_exec_ext in '' $ac_executable_extensions; do
2304
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2349
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2305
2350
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2306
2351
       ac_prog_rejected=yes
2307
2352
       continue
2359
2404
  IFS=$as_save_IFS
2360
2405
  test -z "$as_dir" && as_dir=.
2361
2406
  for ac_exec_ext in '' $ac_executable_extensions; do
2362
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2407
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2363
2408
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2364
2409
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2365
2410
    break 2
2403
2448
  IFS=$as_save_IFS
2404
2449
  test -z "$as_dir" && as_dir=.
2405
2450
  for ac_exec_ext in '' $ac_executable_extensions; do
2406
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2451
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2407
2452
    ac_cv_prog_ac_ct_CC="$ac_prog"
2408
2453
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2409
2454
    break 2
2544
2589
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
2545
2590
# so that the user can short-circuit this test for compilers unknown to
2546
2591
# Autoconf.
2547
 
for ac_file in $ac_files
 
2592
for ac_file in $ac_files ''
2548
2593
do
2549
2594
  test -f "$ac_file" || continue
2550
2595
  case $ac_file in
2572
2617
test "$ac_cv_exeext" = no && ac_cv_exeext=
2573
2618
 
2574
2619
else
 
2620
  ac_file=''
 
2621
fi
 
2622
 
 
2623
{ echo "$as_me:$LINENO: result: $ac_file" >&5
 
2624
echo "${ECHO_T}$ac_file" >&6; }
 
2625
if test -z "$ac_file"; then
2575
2626
  echo "$as_me: failed program was:" >&5
2576
2627
sed 's/^/| /' conftest.$ac_ext >&5
2577
2628
 
2583
2634
fi
2584
2635
 
2585
2636
ac_exeext=$ac_cv_exeext
2586
 
{ echo "$as_me:$LINENO: result: $ac_file" >&5
2587
 
echo "${ECHO_T}$ac_file" >&6; }
2588
2637
 
2589
2638
# Check that the compiler produces executables we can run.  If not, either
2590
2639
# the compiler is broken, or we cross compile.
2762
2811
  rm -f conftest.er1
2763
2812
  cat conftest.err >&5
2764
2813
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2765
 
  (exit $ac_status); } &&
2766
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
2767
 
  { (case "(($ac_try" in
2768
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2769
 
  *) ac_try_echo=$ac_try;;
2770
 
esac
2771
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2772
 
  (eval "$ac_try") 2>&5
2773
 
  ac_status=$?
2774
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2775
 
  (exit $ac_status); }; } &&
2776
 
         { ac_try='test -s conftest.$ac_objext'
2777
 
  { (case "(($ac_try" in
2778
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2779
 
  *) ac_try_echo=$ac_try;;
2780
 
esac
2781
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2782
 
  (eval "$ac_try") 2>&5
2783
 
  ac_status=$?
2784
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2785
 
  (exit $ac_status); }; }; then
 
2814
  (exit $ac_status); } && {
 
2815
         test -z "$ac_c_werror_flag" ||
 
2816
         test ! -s conftest.err
 
2817
       } && test -s conftest.$ac_objext; then
2786
2818
  ac_compiler_gnu=yes
2787
2819
else
2788
2820
  echo "$as_me: failed program was:" >&5
2837
2869
  rm -f conftest.er1
2838
2870
  cat conftest.err >&5
2839
2871
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2840
 
  (exit $ac_status); } &&
2841
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
2842
 
  { (case "(($ac_try" in
2843
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2844
 
  *) ac_try_echo=$ac_try;;
2845
 
esac
2846
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2847
 
  (eval "$ac_try") 2>&5
2848
 
  ac_status=$?
2849
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2850
 
  (exit $ac_status); }; } &&
2851
 
         { ac_try='test -s conftest.$ac_objext'
2852
 
  { (case "(($ac_try" in
2853
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2854
 
  *) ac_try_echo=$ac_try;;
2855
 
esac
2856
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2857
 
  (eval "$ac_try") 2>&5
2858
 
  ac_status=$?
2859
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2860
 
  (exit $ac_status); }; }; then
 
2872
  (exit $ac_status); } && {
 
2873
         test -z "$ac_c_werror_flag" ||
 
2874
         test ! -s conftest.err
 
2875
       } && test -s conftest.$ac_objext; then
2861
2876
  ac_cv_prog_cc_g=yes
2862
2877
else
2863
2878
  echo "$as_me: failed program was:" >&5
2892
2907
  rm -f conftest.er1
2893
2908
  cat conftest.err >&5
2894
2909
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2895
 
  (exit $ac_status); } &&
2896
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
2897
 
  { (case "(($ac_try" in
2898
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2899
 
  *) ac_try_echo=$ac_try;;
2900
 
esac
2901
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2902
 
  (eval "$ac_try") 2>&5
2903
 
  ac_status=$?
2904
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2905
 
  (exit $ac_status); }; } &&
2906
 
         { ac_try='test -s conftest.$ac_objext'
2907
 
  { (case "(($ac_try" in
2908
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2909
 
  *) ac_try_echo=$ac_try;;
2910
 
esac
2911
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2912
 
  (eval "$ac_try") 2>&5
2913
 
  ac_status=$?
2914
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2915
 
  (exit $ac_status); }; }; then
 
2910
  (exit $ac_status); } && {
 
2911
         test -z "$ac_c_werror_flag" ||
 
2912
         test ! -s conftest.err
 
2913
       } && test -s conftest.$ac_objext; then
2916
2914
  :
2917
2915
else
2918
2916
  echo "$as_me: failed program was:" >&5
2948
2946
  rm -f conftest.er1
2949
2947
  cat conftest.err >&5
2950
2948
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2951
 
  (exit $ac_status); } &&
2952
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
2953
 
  { (case "(($ac_try" in
2954
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2955
 
  *) ac_try_echo=$ac_try;;
2956
 
esac
2957
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2958
 
  (eval "$ac_try") 2>&5
2959
 
  ac_status=$?
2960
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2961
 
  (exit $ac_status); }; } &&
2962
 
         { ac_try='test -s conftest.$ac_objext'
2963
 
  { (case "(($ac_try" in
2964
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2965
 
  *) ac_try_echo=$ac_try;;
2966
 
esac
2967
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
2968
 
  (eval "$ac_try") 2>&5
2969
 
  ac_status=$?
2970
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2971
 
  (exit $ac_status); }; }; then
 
2949
  (exit $ac_status); } && {
 
2950
         test -z "$ac_c_werror_flag" ||
 
2951
         test ! -s conftest.err
 
2952
       } && test -s conftest.$ac_objext; then
2972
2953
  ac_cv_prog_cc_g=yes
2973
2954
else
2974
2955
  echo "$as_me: failed program was:" >&5
3084
3065
  rm -f conftest.er1
3085
3066
  cat conftest.err >&5
3086
3067
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3087
 
  (exit $ac_status); } &&
3088
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3089
 
  { (case "(($ac_try" in
3090
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3091
 
  *) ac_try_echo=$ac_try;;
3092
 
esac
3093
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3094
 
  (eval "$ac_try") 2>&5
3095
 
  ac_status=$?
3096
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3097
 
  (exit $ac_status); }; } &&
3098
 
         { ac_try='test -s conftest.$ac_objext'
3099
 
  { (case "(($ac_try" in
3100
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3101
 
  *) ac_try_echo=$ac_try;;
3102
 
esac
3103
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3104
 
  (eval "$ac_try") 2>&5
3105
 
  ac_status=$?
3106
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3107
 
  (exit $ac_status); }; }; then
 
3068
  (exit $ac_status); } && {
 
3069
         test -z "$ac_c_werror_flag" ||
 
3070
         test ! -s conftest.err
 
3071
       } && test -s conftest.$ac_objext; then
3108
3072
  ac_cv_prog_cc_c89=$ac_arg
3109
3073
else
3110
3074
  echo "$as_me: failed program was:" >&5
3169
3133
  IFS=$as_save_IFS
3170
3134
  test -z "$as_dir" && as_dir=.
3171
3135
  for ac_exec_ext in '' $ac_executable_extensions; do
3172
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3136
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3173
3137
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3174
3138
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3175
3139
    break 2
3213
3177
  IFS=$as_save_IFS
3214
3178
  test -z "$as_dir" && as_dir=.
3215
3179
  for ac_exec_ext in '' $ac_executable_extensions; do
3216
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3180
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3217
3181
    ac_cv_prog_ac_ct_CXX="$ac_prog"
3218
3182
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3219
3183
    break 2
3326
3290
  rm -f conftest.er1
3327
3291
  cat conftest.err >&5
3328
3292
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3329
 
  (exit $ac_status); } &&
3330
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
3331
 
  { (case "(($ac_try" in
3332
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3333
 
  *) ac_try_echo=$ac_try;;
3334
 
esac
3335
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3336
 
  (eval "$ac_try") 2>&5
3337
 
  ac_status=$?
3338
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3339
 
  (exit $ac_status); }; } &&
3340
 
         { ac_try='test -s conftest.$ac_objext'
3341
 
  { (case "(($ac_try" in
3342
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3343
 
  *) ac_try_echo=$ac_try;;
3344
 
esac
3345
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3346
 
  (eval "$ac_try") 2>&5
3347
 
  ac_status=$?
3348
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3349
 
  (exit $ac_status); }; }; then
 
3293
  (exit $ac_status); } && {
 
3294
         test -z "$ac_cxx_werror_flag" ||
 
3295
         test ! -s conftest.err
 
3296
       } && test -s conftest.$ac_objext; then
3350
3297
  ac_compiler_gnu=yes
3351
3298
else
3352
3299
  echo "$as_me: failed program was:" >&5
3401
3348
  rm -f conftest.er1
3402
3349
  cat conftest.err >&5
3403
3350
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3404
 
  (exit $ac_status); } &&
3405
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
3406
 
  { (case "(($ac_try" in
3407
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3408
 
  *) ac_try_echo=$ac_try;;
3409
 
esac
3410
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3411
 
  (eval "$ac_try") 2>&5
3412
 
  ac_status=$?
3413
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3414
 
  (exit $ac_status); }; } &&
3415
 
         { ac_try='test -s conftest.$ac_objext'
3416
 
  { (case "(($ac_try" in
3417
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3418
 
  *) ac_try_echo=$ac_try;;
3419
 
esac
3420
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3421
 
  (eval "$ac_try") 2>&5
3422
 
  ac_status=$?
3423
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3424
 
  (exit $ac_status); }; }; then
 
3351
  (exit $ac_status); } && {
 
3352
         test -z "$ac_cxx_werror_flag" ||
 
3353
         test ! -s conftest.err
 
3354
       } && test -s conftest.$ac_objext; then
3425
3355
  ac_cv_prog_cxx_g=yes
3426
3356
else
3427
3357
  echo "$as_me: failed program was:" >&5
3456
3386
  rm -f conftest.er1
3457
3387
  cat conftest.err >&5
3458
3388
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3459
 
  (exit $ac_status); } &&
3460
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
3461
 
  { (case "(($ac_try" in
3462
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3463
 
  *) ac_try_echo=$ac_try;;
3464
 
esac
3465
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3466
 
  (eval "$ac_try") 2>&5
3467
 
  ac_status=$?
3468
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3469
 
  (exit $ac_status); }; } &&
3470
 
         { ac_try='test -s conftest.$ac_objext'
3471
 
  { (case "(($ac_try" in
3472
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3473
 
  *) ac_try_echo=$ac_try;;
3474
 
esac
3475
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3476
 
  (eval "$ac_try") 2>&5
3477
 
  ac_status=$?
3478
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3479
 
  (exit $ac_status); }; }; then
 
3389
  (exit $ac_status); } && {
 
3390
         test -z "$ac_cxx_werror_flag" ||
 
3391
         test ! -s conftest.err
 
3392
       } && test -s conftest.$ac_objext; then
3480
3393
  :
3481
3394
else
3482
3395
  echo "$as_me: failed program was:" >&5
3512
3425
  rm -f conftest.er1
3513
3426
  cat conftest.err >&5
3514
3427
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3515
 
  (exit $ac_status); } &&
3516
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
3517
 
  { (case "(($ac_try" in
3518
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3519
 
  *) ac_try_echo=$ac_try;;
3520
 
esac
3521
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3522
 
  (eval "$ac_try") 2>&5
3523
 
  ac_status=$?
3524
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3525
 
  (exit $ac_status); }; } &&
3526
 
         { ac_try='test -s conftest.$ac_objext'
3527
 
  { (case "(($ac_try" in
3528
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3529
 
  *) ac_try_echo=$ac_try;;
3530
 
esac
3531
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3532
 
  (eval "$ac_try") 2>&5
3533
 
  ac_status=$?
3534
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3535
 
  (exit $ac_status); }; }; then
 
3428
  (exit $ac_status); } && {
 
3429
         test -z "$ac_cxx_werror_flag" ||
 
3430
         test ! -s conftest.err
 
3431
       } && test -s conftest.$ac_objext; then
3536
3432
  ac_cv_prog_cxx_g=yes
3537
3433
else
3538
3434
  echo "$as_me: failed program was:" >&5
3625
3521
  rm -f conftest.er1
3626
3522
  cat conftest.err >&5
3627
3523
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3628
 
  (exit $ac_status); } >/dev/null; then
3629
 
  if test -s conftest.err; then
3630
 
    ac_cpp_err=$ac_c_preproc_warn_flag
3631
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3632
 
  else
3633
 
    ac_cpp_err=
3634
 
  fi
3635
 
else
3636
 
  ac_cpp_err=yes
3637
 
fi
3638
 
if test -z "$ac_cpp_err"; then
 
3524
  (exit $ac_status); } >/dev/null && {
 
3525
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3526
         test ! -s conftest.err
 
3527
       }; then
3639
3528
  :
3640
3529
else
3641
3530
  echo "$as_me: failed program was:" >&5
3669
3558
  rm -f conftest.er1
3670
3559
  cat conftest.err >&5
3671
3560
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3672
 
  (exit $ac_status); } >/dev/null; then
3673
 
  if test -s conftest.err; then
3674
 
    ac_cpp_err=$ac_c_preproc_warn_flag
3675
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3676
 
  else
3677
 
    ac_cpp_err=
3678
 
  fi
3679
 
else
3680
 
  ac_cpp_err=yes
3681
 
fi
3682
 
if test -z "$ac_cpp_err"; then
 
3561
  (exit $ac_status); } >/dev/null && {
 
3562
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3563
         test ! -s conftest.err
 
3564
       }; then
3683
3565
  # Broken: success on invalid input.
3684
3566
continue
3685
3567
else
3744
3626
  rm -f conftest.er1
3745
3627
  cat conftest.err >&5
3746
3628
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3747
 
  (exit $ac_status); } >/dev/null; then
3748
 
  if test -s conftest.err; then
3749
 
    ac_cpp_err=$ac_c_preproc_warn_flag
3750
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3751
 
  else
3752
 
    ac_cpp_err=
3753
 
  fi
3754
 
else
3755
 
  ac_cpp_err=yes
3756
 
fi
3757
 
if test -z "$ac_cpp_err"; then
 
3629
  (exit $ac_status); } >/dev/null && {
 
3630
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3631
         test ! -s conftest.err
 
3632
       }; then
3758
3633
  :
3759
3634
else
3760
3635
  echo "$as_me: failed program was:" >&5
3788
3663
  rm -f conftest.er1
3789
3664
  cat conftest.err >&5
3790
3665
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791
 
  (exit $ac_status); } >/dev/null; then
3792
 
  if test -s conftest.err; then
3793
 
    ac_cpp_err=$ac_c_preproc_warn_flag
3794
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3795
 
  else
3796
 
    ac_cpp_err=
3797
 
  fi
3798
 
else
3799
 
  ac_cpp_err=yes
3800
 
fi
3801
 
if test -z "$ac_cpp_err"; then
 
3666
  (exit $ac_status); } >/dev/null && {
 
3667
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
3668
         test ! -s conftest.err
 
3669
       }; then
3802
3670
  # Broken: success on invalid input.
3803
3671
continue
3804
3672
else
3848
3716
  IFS=$as_save_IFS
3849
3717
  test -z "$as_dir" && as_dir=.
3850
3718
  for ac_exec_ext in '' $ac_executable_extensions; do
3851
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3719
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3852
3720
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3853
3721
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3854
3722
    break 2
3888
3756
  IFS=$as_save_IFS
3889
3757
  test -z "$as_dir" && as_dir=.
3890
3758
  for ac_exec_ext in '' $ac_executable_extensions; do
3891
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3759
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3892
3760
    ac_cv_prog_ac_ct_RANLIB="ranlib"
3893
3761
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3894
3762
    break 2
3963
3831
    # by default.
3964
3832
    for ac_prog in ginstall scoinst install; do
3965
3833
      for ac_exec_ext in '' $ac_executable_extensions; do
3966
 
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; }; then
 
3834
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
3967
3835
          if test $ac_prog = install &&
3968
3836
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3969
3837
            # AIX install.  It has an incompatible calling convention.
4225
4093
                LDRPATH='-Wl,--rpath,/usr/lib/ecl/'
4226
4094
                clibs="-ldl"
4227
4095
                # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ???
 
4096
                CFLAGS="-D_GNU_SOURCE ${CFLAGS}"
 
4097
                ;;
 
4098
        gnu*)
 
4099
                thehost='gnu'
 
4100
                THREAD_CFLAGS='-D_THREAD_SAFE'
 
4101
                THREAD_LIBS='-lpthread'
 
4102
                SHARED_LDFLAGS="-shared ${LDFLAGS}"
 
4103
                BUNDLE_LDFLAGS="-shared ${LDFLAGS}"
 
4104
                LDRPATH='-Wl,--rpath,~A'
 
4105
                clibs="-ldl"
 
4106
                CFLAGS="-D_GNU_SOURCE ${CFLAGS}"
4228
4107
                ;;
4229
4108
        kfreebsd*-gnu)
4230
4109
                thehost='kfreebsd'
4234
4113
                BUNDLE_LDFLAGS="-shared ${LDFLAGS}"
4235
4114
                LDRPATH='-Wl,--rpath,/usr/lib/ecl/'
4236
4115
                clibs="-ldl"
4237
 
                # Maybe CFLAGS="-D_ISOC99_SOURCE ${CFLAGS}" ???
 
4116
                CFLAGS="-D_GNU_SOURCE ${CFLAGS}"
4238
4117
                ;;
4239
4118
        freebsd*)
4240
4119
                thehost='freebsd'
4306
4185
                if test "`uname -m`" = i386; then
4307
4186
                  gmp_build=none-apple-${host_os}
4308
4187
                fi
 
4188
                # ECL, due to some of the libraries, does not build on
 
4189
                # 64 bit mode on OSX. We prevent GMP using that mode.
 
4190
                export ABI=mode32
 
4191
                ;;
 
4192
        nsk*)
 
4193
                # HP Non-Stop platform
 
4194
                thehost='nonstop'
 
4195
                shared='yes'
 
4196
                PICFLAG='-call_shared'
 
4197
                THREAD_CFLAGS='-spthread'
 
4198
                SHARED_LDFLAGS="-shared ${LDFLAGS}"
 
4199
                BUNDLE_LDFLAGS="-shared ${LDFLAGS}"
 
4200
                LDRPATH='-Wld=\"-rld_l ~A\"'
 
4201
                clibs="-Wld=-lrld"
4309
4202
                ;;
4310
4203
        *)
4311
4204
                Thehost="$host_os"
4376
4269
  rm -f conftest.er1
4377
4270
  cat conftest.err >&5
4378
4271
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4379
 
  (exit $ac_status); } &&
4380
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4381
 
  { (case "(($ac_try" in
4382
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4383
 
  *) ac_try_echo=$ac_try;;
4384
 
esac
4385
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4386
 
  (eval "$ac_try") 2>&5
4387
 
  ac_status=$?
4388
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4389
 
  (exit $ac_status); }; } &&
4390
 
         { ac_try='test -s conftest.$ac_objext'
4391
 
  { (case "(($ac_try" in
4392
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4393
 
  *) ac_try_echo=$ac_try;;
4394
 
esac
4395
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4396
 
  (eval "$ac_try") 2>&5
4397
 
  ac_status=$?
4398
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4399
 
  (exit $ac_status); }; }; then
 
4272
  (exit $ac_status); } && {
 
4273
         test -z "$ac_c_werror_flag" ||
 
4274
         test ! -s conftest.err
 
4275
       } && test -s conftest.$ac_objext; then
4400
4276
  ac_cv_ecl___thread=yes
4401
4277
else
4402
4278
  echo "$as_me: failed program was:" >&5
4433
4309
  IFS=$as_save_IFS
4434
4310
  test -z "$as_dir" && as_dir=.
4435
4311
  for ac_exec_ext in '' $ac_executable_extensions; do
4436
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4312
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4437
4313
    ac_cv_path_INSTALL_INFO="$as_dir/$ac_word$ac_exec_ext"
4438
4314
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4439
4315
    break 2
4507
4383
  rm -f conftest.er1
4508
4384
  cat conftest.err >&5
4509
4385
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4510
 
  (exit $ac_status); } &&
4511
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4512
 
  { (case "(($ac_try" in
4513
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4514
 
  *) ac_try_echo=$ac_try;;
4515
 
esac
4516
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4517
 
  (eval "$ac_try") 2>&5
4518
 
  ac_status=$?
4519
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4520
 
  (exit $ac_status); }; } &&
4521
 
         { ac_try='test -s conftest$ac_exeext'
4522
 
  { (case "(($ac_try" in
4523
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4524
 
  *) ac_try_echo=$ac_try;;
4525
 
esac
4526
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4527
 
  (eval "$ac_try") 2>&5
4528
 
  ac_status=$?
4529
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4530
 
  (exit $ac_status); }; }; then
 
4386
  (exit $ac_status); } && {
 
4387
         test -z "$ac_c_werror_flag" ||
 
4388
         test ! -s conftest.err
 
4389
       } && test -s conftest$ac_exeext &&
 
4390
       $as_test_x conftest$ac_exeext; then
4531
4391
  ac_cv_lib_sun_getpwnam=yes
4532
4392
else
4533
4393
  echo "$as_me: failed program was:" >&5
4536
4396
        ac_cv_lib_sun_getpwnam=no
4537
4397
fi
4538
4398
 
4539
 
rm -f core conftest.err conftest.$ac_objext \
 
4399
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4540
4400
      conftest$ac_exeext conftest.$ac_ext
4541
4401
LIBS=$ac_check_lib_save_LIBS
4542
4402
fi
4599
4459
  rm -f conftest.er1
4600
4460
  cat conftest.err >&5
4601
4461
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602
 
  (exit $ac_status); } &&
4603
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4604
 
  { (case "(($ac_try" in
4605
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4606
 
  *) ac_try_echo=$ac_try;;
4607
 
esac
4608
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4609
 
  (eval "$ac_try") 2>&5
4610
 
  ac_status=$?
4611
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4612
 
  (exit $ac_status); }; } &&
4613
 
         { ac_try='test -s conftest$ac_exeext'
4614
 
  { (case "(($ac_try" in
4615
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4616
 
  *) ac_try_echo=$ac_try;;
4617
 
esac
4618
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4619
 
  (eval "$ac_try") 2>&5
4620
 
  ac_status=$?
4621
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4622
 
  (exit $ac_status); }; }; then
 
4462
  (exit $ac_status); } && {
 
4463
         test -z "$ac_c_werror_flag" ||
 
4464
         test ! -s conftest.err
 
4465
       } && test -s conftest$ac_exeext &&
 
4466
       $as_test_x conftest$ac_exeext; then
4623
4467
  ac_cv_search_strerror=$ac_res
4624
4468
else
4625
4469
  echo "$as_me: failed program was:" >&5
4628
4472
 
4629
4473
fi
4630
4474
 
4631
 
rm -f core conftest.err conftest.$ac_objext \
 
4475
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4632
4476
      conftest$ac_exeext
4633
4477
  if test "${ac_cv_search_strerror+set}" = set; then
4634
4478
  break
4738
4582
  rm -f conftest.er1
4739
4583
  cat conftest.err >&5
4740
4584
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4741
 
  (exit $ac_status); } &&
4742
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4743
 
  { (case "(($ac_try" in
4744
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4745
 
  *) ac_try_echo=$ac_try;;
4746
 
esac
4747
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4748
 
  (eval "$ac_try") 2>&5
4749
 
  ac_status=$?
4750
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4751
 
  (exit $ac_status); }; } &&
4752
 
         { ac_try='test -s conftest$ac_exeext'
4753
 
  { (case "(($ac_try" in
4754
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4755
 
  *) ac_try_echo=$ac_try;;
4756
 
esac
4757
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4758
 
  (eval "$ac_try") 2>&5
4759
 
  ac_status=$?
4760
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4761
 
  (exit $ac_status); }; }; then
 
4585
  (exit $ac_status); } && {
 
4586
         test -z "$ac_c_werror_flag" ||
 
4587
         test ! -s conftest.err
 
4588
       } && test -s conftest$ac_exeext &&
 
4589
       $as_test_x conftest$ac_exeext; then
4762
4590
  ac_cv_lib_gc_GC_malloc=yes
4763
4591
else
4764
4592
  echo "$as_me: failed program was:" >&5
4767
4595
        ac_cv_lib_gc_GC_malloc=no
4768
4596
fi
4769
4597
 
4770
 
rm -f core conftest.err conftest.$ac_objext \
 
4598
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4771
4599
      conftest$ac_exeext conftest.$ac_ext
4772
4600
LIBS=$ac_check_lib_save_LIBS
4773
4601
fi
4824
4652
  rm -f conftest.er1
4825
4653
  cat conftest.err >&5
4826
4654
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4827
 
  (exit $ac_status); } &&
4828
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4829
 
  { (case "(($ac_try" in
4830
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4831
 
  *) ac_try_echo=$ac_try;;
4832
 
esac
4833
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4834
 
  (eval "$ac_try") 2>&5
4835
 
  ac_status=$?
4836
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4837
 
  (exit $ac_status); }; } &&
4838
 
         { ac_try='test -s conftest$ac_exeext'
4839
 
  { (case "(($ac_try" in
4840
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4841
 
  *) ac_try_echo=$ac_try;;
4842
 
esac
4843
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4844
 
  (eval "$ac_try") 2>&5
4845
 
  ac_status=$?
4846
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4847
 
  (exit $ac_status); }; }; then
 
4655
  (exit $ac_status); } && {
 
4656
         test -z "$ac_c_werror_flag" ||
 
4657
         test ! -s conftest.err
 
4658
       } && test -s conftest$ac_exeext &&
 
4659
       $as_test_x conftest$ac_exeext; then
4848
4660
  ac_cv_lib_gc_GC_malloc=yes
4849
4661
else
4850
4662
  echo "$as_me: failed program was:" >&5
4853
4665
        ac_cv_lib_gc_GC_malloc=no
4854
4666
fi
4855
4667
 
4856
 
rm -f core conftest.err conftest.$ac_objext \
 
4668
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4857
4669
      conftest$ac_exeext conftest.$ac_ext
4858
4670
LIBS=$ac_check_lib_save_LIBS
4859
4671
fi
4869
4681
 
4870
4682
    { echo "$as_me:$LINENO: checking if we need to copy GC private headers " >&5
4871
4683
echo $ECHO_N "checking if we need to copy GC private headers ... $ECHO_C" >&6; }
 
4684
 
 
4685
cat >>confdefs.h <<\_ACEOF
 
4686
#define GBC_BOEHM 1
 
4687
_ACEOF
 
4688
 
4872
4689
  else
4873
4690
    enable_boehm="included"
4874
4691
    SUBDIRS="${SUBDIRS} gc"
4876
4693
    if test "${enable_shared}" = "no"; then
4877
4694
      LIBRARIES="${LIBRARIES} ${LIBPREFIX}eclgc.${LIBEXT}"
4878
4695
    fi
 
4696
 
 
4697
cat >>confdefs.h <<\_ACEOF
 
4698
#define GBC_BOEHM 0
 
4699
_ACEOF
 
4700
 
4879
4701
  fi
4880
4702
  EXTRA_OBJS="${EXTRA_OBJS} alloc_2.${OBJEXT}"
4881
 
 
4882
 
cat >>confdefs.h <<\_ACEOF
4883
 
#define GBC_BOEHM 1
4884
 
_ACEOF
4885
 
 
4886
4703
fi
4887
4704
 
4888
4705
 
4935
4752
  rm -f conftest.er1
4936
4753
  cat conftest.err >&5
4937
4754
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4938
 
  (exit $ac_status); } &&
4939
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4940
 
  { (case "(($ac_try" in
4941
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4942
 
  *) ac_try_echo=$ac_try;;
4943
 
esac
4944
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4945
 
  (eval "$ac_try") 2>&5
4946
 
  ac_status=$?
4947
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4948
 
  (exit $ac_status); }; } &&
4949
 
         { ac_try='test -s conftest$ac_exeext'
4950
 
  { (case "(($ac_try" in
4951
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4952
 
  *) ac_try_echo=$ac_try;;
4953
 
esac
4954
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4955
 
  (eval "$ac_try") 2>&5
4956
 
  ac_status=$?
4957
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4958
 
  (exit $ac_status); }; }; then
 
4755
  (exit $ac_status); } && {
 
4756
         test -z "$ac_c_werror_flag" ||
 
4757
         test ! -s conftest.err
 
4758
       } && test -s conftest$ac_exeext &&
 
4759
       $as_test_x conftest$ac_exeext; then
4959
4760
  ac_cv_lib_gmp___gmpz_init=yes
4960
4761
else
4961
4762
  echo "$as_me: failed program was:" >&5
4964
4765
        ac_cv_lib_gmp___gmpz_init=no
4965
4766
fi
4966
4767
 
4967
 
rm -f core conftest.err conftest.$ac_objext \
 
4768
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
4968
4769
      conftest$ac_exeext conftest.$ac_ext
4969
4770
LIBS=$ac_check_lib_save_LIBS
4970
4771
fi
5021
4822
  rm -f conftest.er1
5022
4823
  cat conftest.err >&5
5023
4824
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5024
 
  (exit $ac_status); } &&
5025
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5026
 
  { (case "(($ac_try" in
5027
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5028
 
  *) ac_try_echo=$ac_try;;
5029
 
esac
5030
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5031
 
  (eval "$ac_try") 2>&5
5032
 
  ac_status=$?
5033
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5034
 
  (exit $ac_status); }; } &&
5035
 
         { ac_try='test -s conftest$ac_exeext'
5036
 
  { (case "(($ac_try" in
5037
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5038
 
  *) ac_try_echo=$ac_try;;
5039
 
esac
5040
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5041
 
  (eval "$ac_try") 2>&5
5042
 
  ac_status=$?
5043
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5044
 
  (exit $ac_status); }; }; then
 
4825
  (exit $ac_status); } && {
 
4826
         test -z "$ac_c_werror_flag" ||
 
4827
         test ! -s conftest.err
 
4828
       } && test -s conftest$ac_exeext &&
 
4829
       $as_test_x conftest$ac_exeext; then
5045
4830
  ac_cv_lib_gmp___gmpz_init=yes
5046
4831
else
5047
4832
  echo "$as_me: failed program was:" >&5
5050
4835
        ac_cv_lib_gmp___gmpz_init=no
5051
4836
fi
5052
4837
 
5053
 
rm -f core conftest.err conftest.$ac_objext \
 
4838
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5054
4839
      conftest$ac_exeext conftest.$ac_ext
5055
4840
LIBS=$ac_check_lib_save_LIBS
5056
4841
fi
5197
4982
  rm -f conftest.er1
5198
4983
  cat conftest.err >&5
5199
4984
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5200
 
  (exit $ac_status); } >/dev/null; then
5201
 
  if test -s conftest.err; then
5202
 
    ac_cpp_err=$ac_c_preproc_warn_flag
5203
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5204
 
  else
5205
 
    ac_cpp_err=
5206
 
  fi
5207
 
else
5208
 
  ac_cpp_err=yes
5209
 
fi
5210
 
if test -z "$ac_cpp_err"; then
 
4985
  (exit $ac_status); } >/dev/null && {
 
4986
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
4987
         test ! -s conftest.err
 
4988
       }; then
5211
4989
  # We can compile using X headers with no special include directory.
5212
4990
ac_x_includes=
5213
4991
else
5230
5008
  # See if we find them without any special options.
5231
5009
  # Don't add to $LIBS permanently.
5232
5010
  ac_save_LIBS=$LIBS
5233
 
  LIBS="-lXt $LIBS"
 
5011
  LIBS="-lX11 $LIBS"
5234
5012
  cat >conftest.$ac_ext <<_ACEOF
5235
5013
/* confdefs.h.  */
5236
5014
_ACEOF
5259
5037
  rm -f conftest.er1
5260
5038
  cat conftest.err >&5
5261
5039
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5262
 
  (exit $ac_status); } &&
5263
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5264
 
  { (case "(($ac_try" in
5265
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5266
 
  *) ac_try_echo=$ac_try;;
5267
 
esac
5268
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5269
 
  (eval "$ac_try") 2>&5
5270
 
  ac_status=$?
5271
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5272
 
  (exit $ac_status); }; } &&
5273
 
         { ac_try='test -s conftest$ac_exeext'
5274
 
  { (case "(($ac_try" in
5275
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5276
 
  *) ac_try_echo=$ac_try;;
5277
 
esac
5278
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5279
 
  (eval "$ac_try") 2>&5
5280
 
  ac_status=$?
5281
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5282
 
  (exit $ac_status); }; }; then
 
5040
  (exit $ac_status); } && {
 
5041
         test -z "$ac_c_werror_flag" ||
 
5042
         test ! -s conftest.err
 
5043
       } && test -s conftest$ac_exeext &&
 
5044
       $as_test_x conftest$ac_exeext; then
5283
5045
  LIBS=$ac_save_LIBS
5284
5046
# We can link X programs with no special library path.
5285
5047
ac_x_libraries=
5292
5054
do
5293
5055
  # Don't even attempt the hair of trying to link an X program!
5294
5056
  for ac_extension in a so sl; do
5295
 
    if test -r "$ac_dir/libXt.$ac_extension"; then
 
5057
    if test -r "$ac_dir/libX11.$ac_extension"; then
5296
5058
      ac_x_libraries=$ac_dir
5297
5059
      break 2
5298
5060
    fi
5300
5062
done
5301
5063
fi
5302
5064
 
5303
 
rm -f core conftest.err conftest.$ac_objext \
 
5065
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5304
5066
      conftest$ac_exeext conftest.$ac_ext
5305
5067
fi # $ac_x_libraries = no
5306
5068
 
5381
5143
  rm -f conftest.er1
5382
5144
  cat conftest.err >&5
5383
5145
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5384
 
  (exit $ac_status); } &&
5385
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5386
 
  { (case "(($ac_try" in
5387
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5388
 
  *) ac_try_echo=$ac_try;;
5389
 
esac
5390
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5391
 
  (eval "$ac_try") 2>&5
5392
 
  ac_status=$?
5393
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5394
 
  (exit $ac_status); }; } &&
5395
 
         { ac_try='test -s conftest.$ac_objext'
5396
 
  { (case "(($ac_try" in
5397
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5398
 
  *) ac_try_echo=$ac_try;;
5399
 
esac
5400
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5401
 
  (eval "$ac_try") 2>&5
5402
 
  ac_status=$?
5403
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5404
 
  (exit $ac_status); }; }; then
 
5146
  (exit $ac_status); } && {
 
5147
         test -z "$ac_c_werror_flag" ||
 
5148
         test ! -s conftest.err
 
5149
       } && test -s conftest.$ac_objext; then
5405
5150
  eval "$as_ac_Header=yes"
5406
5151
else
5407
5152
  echo "$as_me: failed program was:" >&5
5474
5219
  rm -f conftest.er1
5475
5220
  cat conftest.err >&5
5476
5221
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5477
 
  (exit $ac_status); } &&
5478
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5479
 
  { (case "(($ac_try" in
5480
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5481
 
  *) ac_try_echo=$ac_try;;
5482
 
esac
5483
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5484
 
  (eval "$ac_try") 2>&5
5485
 
  ac_status=$?
5486
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5487
 
  (exit $ac_status); }; } &&
5488
 
         { ac_try='test -s conftest$ac_exeext'
5489
 
  { (case "(($ac_try" in
5490
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5491
 
  *) ac_try_echo=$ac_try;;
5492
 
esac
5493
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5494
 
  (eval "$ac_try") 2>&5
5495
 
  ac_status=$?
5496
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5497
 
  (exit $ac_status); }; }; then
 
5222
  (exit $ac_status); } && {
 
5223
         test -z "$ac_c_werror_flag" ||
 
5224
         test ! -s conftest.err
 
5225
       } && test -s conftest$ac_exeext &&
 
5226
       $as_test_x conftest$ac_exeext; then
5498
5227
  ac_cv_search_opendir=$ac_res
5499
5228
else
5500
5229
  echo "$as_me: failed program was:" >&5
5503
5232
 
5504
5233
fi
5505
5234
 
5506
 
rm -f core conftest.err conftest.$ac_objext \
 
5235
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5507
5236
      conftest$ac_exeext
5508
5237
  if test "${ac_cv_search_opendir+set}" = set; then
5509
5238
  break
5574
5303
  rm -f conftest.er1
5575
5304
  cat conftest.err >&5
5576
5305
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5577
 
  (exit $ac_status); } &&
5578
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5579
 
  { (case "(($ac_try" in
5580
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5581
 
  *) ac_try_echo=$ac_try;;
5582
 
esac
5583
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5584
 
  (eval "$ac_try") 2>&5
5585
 
  ac_status=$?
5586
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5587
 
  (exit $ac_status); }; } &&
5588
 
         { ac_try='test -s conftest$ac_exeext'
5589
 
  { (case "(($ac_try" in
5590
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5591
 
  *) ac_try_echo=$ac_try;;
5592
 
esac
5593
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5594
 
  (eval "$ac_try") 2>&5
5595
 
  ac_status=$?
5596
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5597
 
  (exit $ac_status); }; }; then
 
5306
  (exit $ac_status); } && {
 
5307
         test -z "$ac_c_werror_flag" ||
 
5308
         test ! -s conftest.err
 
5309
       } && test -s conftest$ac_exeext &&
 
5310
       $as_test_x conftest$ac_exeext; then
5598
5311
  ac_cv_search_opendir=$ac_res
5599
5312
else
5600
5313
  echo "$as_me: failed program was:" >&5
5603
5316
 
5604
5317
fi
5605
5318
 
5606
 
rm -f core conftest.err conftest.$ac_objext \
 
5319
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
5607
5320
      conftest$ac_exeext
5608
5321
  if test "${ac_cv_search_opendir+set}" = set; then
5609
5322
  break
5648
5361
  for ac_prog in grep ggrep; do
5649
5362
  for ac_exec_ext in '' $ac_executable_extensions; do
5650
5363
    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
5651
 
    { test -f "$ac_path_GREP" && $as_executable_p "$ac_path_GREP"; } || continue
 
5364
    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
5652
5365
    # Check for GNU ac_path_GREP and select it if it is found.
5653
5366
  # Check for GNU $ac_path_GREP
5654
5367
case `"$ac_path_GREP" --version 2>&1` in
5730
5443
  for ac_prog in egrep; do
5731
5444
  for ac_exec_ext in '' $ac_executable_extensions; do
5732
5445
    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
5733
 
    { test -f "$ac_path_EGREP" && $as_executable_p "$ac_path_EGREP"; } || continue
 
5446
    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
5734
5447
    # Check for GNU ac_path_EGREP and select it if it is found.
5735
5448
  # Check for GNU $ac_path_EGREP
5736
5449
case `"$ac_path_EGREP" --version 2>&1` in
5826
5539
  rm -f conftest.er1
5827
5540
  cat conftest.err >&5
5828
5541
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5829
 
  (exit $ac_status); } &&
5830
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5831
 
  { (case "(($ac_try" in
5832
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5833
 
  *) ac_try_echo=$ac_try;;
5834
 
esac
5835
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5836
 
  (eval "$ac_try") 2>&5
5837
 
  ac_status=$?
5838
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5839
 
  (exit $ac_status); }; } &&
5840
 
         { ac_try='test -s conftest.$ac_objext'
5841
 
  { (case "(($ac_try" in
5842
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5843
 
  *) ac_try_echo=$ac_try;;
5844
 
esac
5845
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5846
 
  (eval "$ac_try") 2>&5
5847
 
  ac_status=$?
5848
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5849
 
  (exit $ac_status); }; }; then
 
5542
  (exit $ac_status); } && {
 
5543
         test -z "$ac_c_werror_flag" ||
 
5544
         test ! -s conftest.err
 
5545
       } && test -s conftest.$ac_objext; then
5850
5546
  ac_cv_header_stdc=yes
5851
5547
else
5852
5548
  echo "$as_me: failed program was:" >&5
6022
5718
  rm -f conftest.er1
6023
5719
  cat conftest.err >&5
6024
5720
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6025
 
  (exit $ac_status); } &&
6026
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6027
 
  { (case "(($ac_try" in
6028
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6029
 
  *) ac_try_echo=$ac_try;;
6030
 
esac
6031
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6032
 
  (eval "$ac_try") 2>&5
6033
 
  ac_status=$?
6034
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6035
 
  (exit $ac_status); }; } &&
6036
 
         { ac_try='test -s conftest.$ac_objext'
6037
 
  { (case "(($ac_try" in
6038
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6039
 
  *) ac_try_echo=$ac_try;;
6040
 
esac
6041
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6042
 
  (eval "$ac_try") 2>&5
6043
 
  ac_status=$?
6044
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6045
 
  (exit $ac_status); }; }; then
 
5721
  (exit $ac_status); } && {
 
5722
         test -z "$ac_c_werror_flag" ||
 
5723
         test ! -s conftest.err
 
5724
       } && test -s conftest.$ac_objext; then
6046
5725
  eval "$as_ac_Header=yes"
6047
5726
else
6048
5727
  echo "$as_me: failed program was:" >&5
6166
5845
  rm -f conftest.er1
6167
5846
  cat conftest.err >&5
6168
5847
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6169
 
  (exit $ac_status); } &&
6170
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6171
 
  { (case "(($ac_try" in
6172
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6173
 
  *) ac_try_echo=$ac_try;;
6174
 
esac
6175
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6176
 
  (eval "$ac_try") 2>&5
6177
 
  ac_status=$?
6178
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6179
 
  (exit $ac_status); }; } &&
6180
 
         { ac_try='test -s conftest.$ac_objext'
6181
 
  { (case "(($ac_try" in
6182
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6183
 
  *) ac_try_echo=$ac_try;;
6184
 
esac
6185
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6186
 
  (eval "$ac_try") 2>&5
6187
 
  ac_status=$?
6188
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6189
 
  (exit $ac_status); }; }; then
 
5848
  (exit $ac_status); } && {
 
5849
         test -z "$ac_c_werror_flag" ||
 
5850
         test ! -s conftest.err
 
5851
       } && test -s conftest.$ac_objext; then
6190
5852
  ac_cv_header_stdbool_h=yes
6191
5853
else
6192
5854
  echo "$as_me: failed program was:" >&5
6236
5898
  rm -f conftest.er1
6237
5899
  cat conftest.err >&5
6238
5900
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6239
 
  (exit $ac_status); } &&
6240
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6241
 
  { (case "(($ac_try" in
6242
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6243
 
  *) ac_try_echo=$ac_try;;
6244
 
esac
6245
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6246
 
  (eval "$ac_try") 2>&5
6247
 
  ac_status=$?
6248
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6249
 
  (exit $ac_status); }; } &&
6250
 
         { ac_try='test -s conftest.$ac_objext'
6251
 
  { (case "(($ac_try" in
6252
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6253
 
  *) ac_try_echo=$ac_try;;
6254
 
esac
6255
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6256
 
  (eval "$ac_try") 2>&5
6257
 
  ac_status=$?
6258
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6259
 
  (exit $ac_status); }; }; then
 
5901
  (exit $ac_status); } && {
 
5902
         test -z "$ac_c_werror_flag" ||
 
5903
         test ! -s conftest.err
 
5904
       } && test -s conftest.$ac_objext; then
6260
5905
  ac_cv_type__Bool=yes
6261
5906
else
6262
5907
  echo "$as_me: failed program was:" >&5
6323
5968
  rm -f conftest.er1
6324
5969
  cat conftest.err >&5
6325
5970
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6326
 
  (exit $ac_status); } &&
6327
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6328
 
  { (case "(($ac_try" in
6329
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6330
 
  *) ac_try_echo=$ac_try;;
6331
 
esac
6332
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6333
 
  (eval "$ac_try") 2>&5
6334
 
  ac_status=$?
6335
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6336
 
  (exit $ac_status); }; } &&
6337
 
         { ac_try='test -s conftest.$ac_objext'
6338
 
  { (case "(($ac_try" in
6339
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6340
 
  *) ac_try_echo=$ac_try;;
6341
 
esac
6342
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6343
 
  (eval "$ac_try") 2>&5
6344
 
  ac_status=$?
6345
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6346
 
  (exit $ac_status); }; }; then
 
5971
  (exit $ac_status); } && {
 
5972
         test -z "$ac_c_werror_flag" ||
 
5973
         test ! -s conftest.err
 
5974
       } && test -s conftest.$ac_objext; then
6347
5975
  ac_cv_header_stdc=yes
6348
5976
else
6349
5977
  echo "$as_me: failed program was:" >&5
6514
6142
  rm -f conftest.er1
6515
6143
  cat conftest.err >&5
6516
6144
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6517
 
  (exit $ac_status); } &&
6518
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6519
 
  { (case "(($ac_try" in
6520
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6521
 
  *) ac_try_echo=$ac_try;;
6522
 
esac
6523
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6524
 
  (eval "$ac_try") 2>&5
6525
 
  ac_status=$?
6526
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6527
 
  (exit $ac_status); }; } &&
6528
 
         { ac_try='test -s conftest.$ac_objext'
6529
 
  { (case "(($ac_try" in
6530
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6531
 
  *) ac_try_echo=$ac_try;;
6532
 
esac
6533
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6534
 
  (eval "$ac_try") 2>&5
6535
 
  ac_status=$?
6536
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6537
 
  (exit $ac_status); }; }; then
 
6145
  (exit $ac_status); } && {
 
6146
         test -z "$ac_c_werror_flag" ||
 
6147
         test ! -s conftest.err
 
6148
       } && test -s conftest.$ac_objext; then
6538
6149
  ac_cv_header_time=yes
6539
6150
else
6540
6151
  echo "$as_me: failed program was:" >&5
6608
6219
  rm -f conftest.er1
6609
6220
  cat conftest.err >&5
6610
6221
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6611
 
  (exit $ac_status); } &&
6612
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6613
 
  { (case "(($ac_try" in
6614
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6615
 
  *) ac_try_echo=$ac_try;;
6616
 
esac
6617
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6618
 
  (eval "$ac_try") 2>&5
6619
 
  ac_status=$?
6620
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6621
 
  (exit $ac_status); }; } &&
6622
 
         { ac_try='test -s conftest.$ac_objext'
6623
 
  { (case "(($ac_try" in
6624
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6625
 
  *) ac_try_echo=$ac_try;;
6626
 
esac
6627
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6628
 
  (eval "$ac_try") 2>&5
6629
 
  ac_status=$?
6630
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6631
 
  (exit $ac_status); }; }; then
 
6222
  (exit $ac_status); } && {
 
6223
         test -z "$ac_c_werror_flag" ||
 
6224
         test ! -s conftest.err
 
6225
       } && test -s conftest.$ac_objext; then
6632
6226
  ac_header_compiler=yes
6633
6227
else
6634
6228
  echo "$as_me: failed program was:" >&5
6664
6258
  rm -f conftest.er1
6665
6259
  cat conftest.err >&5
6666
6260
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6667
 
  (exit $ac_status); } >/dev/null; then
6668
 
  if test -s conftest.err; then
6669
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6670
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6671
 
  else
6672
 
    ac_cpp_err=
6673
 
  fi
6674
 
else
6675
 
  ac_cpp_err=yes
6676
 
fi
6677
 
if test -z "$ac_cpp_err"; then
 
6261
  (exit $ac_status); } >/dev/null && {
 
6262
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
6263
         test ! -s conftest.err
 
6264
       }; then
6678
6265
  ac_header_preproc=yes
6679
6266
else
6680
6267
  echo "$as_me: failed program was:" >&5
6744
6331
 
6745
6332
 
6746
6333
 
 
6334
 
6747
6335
for ac_header in sys/resource.h sys/utsname.h float.h pwd.h dlfcn.h link.h \
6748
 
                  mach-o/dyld.h ulimit.h dirent.h sys/ioctl.h
 
6336
                  mach-o/dyld.h ulimit.h dirent.h sys/ioctl.h sys/select.h
6749
6337
do
6750
6338
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6751
6339
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6783
6371
  rm -f conftest.er1
6784
6372
  cat conftest.err >&5
6785
6373
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6786
 
  (exit $ac_status); } &&
6787
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6788
 
  { (case "(($ac_try" in
6789
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6790
 
  *) ac_try_echo=$ac_try;;
6791
 
esac
6792
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6793
 
  (eval "$ac_try") 2>&5
6794
 
  ac_status=$?
6795
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6796
 
  (exit $ac_status); }; } &&
6797
 
         { ac_try='test -s conftest.$ac_objext'
6798
 
  { (case "(($ac_try" in
6799
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6800
 
  *) ac_try_echo=$ac_try;;
6801
 
esac
6802
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6803
 
  (eval "$ac_try") 2>&5
6804
 
  ac_status=$?
6805
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6806
 
  (exit $ac_status); }; }; then
 
6374
  (exit $ac_status); } && {
 
6375
         test -z "$ac_c_werror_flag" ||
 
6376
         test ! -s conftest.err
 
6377
       } && test -s conftest.$ac_objext; then
6807
6378
  ac_header_compiler=yes
6808
6379
else
6809
6380
  echo "$as_me: failed program was:" >&5
6839
6410
  rm -f conftest.er1
6840
6411
  cat conftest.err >&5
6841
6412
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6842
 
  (exit $ac_status); } >/dev/null; then
6843
 
  if test -s conftest.err; then
6844
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6845
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6846
 
  else
6847
 
    ac_cpp_err=
6848
 
  fi
6849
 
else
6850
 
  ac_cpp_err=yes
6851
 
fi
6852
 
if test -z "$ac_cpp_err"; then
 
6413
  (exit $ac_status); } >/dev/null && {
 
6414
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
6415
         test ! -s conftest.err
 
6416
       }; then
6853
6417
  ac_header_preproc=yes
6854
6418
else
6855
6419
  echo "$as_me: failed program was:" >&5
6929
6493
#ifndef __cplusplus
6930
6494
  /* Ultrix mips cc rejects this.  */
6931
6495
  typedef int charset[2];
6932
 
  const charset x;
 
6496
  const charset cs;
6933
6497
  /* SunOS 4.1.1 cc rejects this.  */
6934
 
  char const *const *ccp;
6935
 
  char **p;
 
6498
  char const *const *pcpcc;
 
6499
  char **ppc;
6936
6500
  /* NEC SVR4.0.2 mips cc rejects this.  */
6937
6501
  struct point {int x, y;};
6938
6502
  static struct point const zero = {0,0};
6941
6505
     an arm of an if-expression whose if-part is not a constant
6942
6506
     expression */
6943
6507
  const char *g = "string";
6944
 
  ccp = &g + (g ? g-g : 0);
 
6508
  pcpcc = &g + (g ? g-g : 0);
6945
6509
  /* HPUX 7.0 cc rejects these. */
6946
 
  ++ccp;
6947
 
  p = (char**) ccp;
6948
 
  ccp = (char const *const *) p;
 
6510
  ++pcpcc;
 
6511
  ppc = (char**) pcpcc;
 
6512
  pcpcc = (char const *const *) ppc;
6949
6513
  { /* SCO 3.2v4 cc rejects this.  */
6950
6514
    char *t;
6951
6515
    char const *s = 0 ? (char *) 0 : (char const *) 0;
6972
6536
    const int foo = 10;
6973
6537
    if (!foo) return 0;
6974
6538
  }
6975
 
  return !x[0] && !zero.x;
 
6539
  return !cs[0] && !zero.x;
6976
6540
#endif
6977
6541
 
6978
6542
  ;
6992
6556
  rm -f conftest.er1
6993
6557
  cat conftest.err >&5
6994
6558
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6995
 
  (exit $ac_status); } &&
6996
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6997
 
  { (case "(($ac_try" in
6998
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6999
 
  *) ac_try_echo=$ac_try;;
7000
 
esac
7001
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7002
 
  (eval "$ac_try") 2>&5
7003
 
  ac_status=$?
7004
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7005
 
  (exit $ac_status); }; } &&
7006
 
         { ac_try='test -s conftest.$ac_objext'
7007
 
  { (case "(($ac_try" in
7008
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7009
 
  *) ac_try_echo=$ac_try;;
7010
 
esac
7011
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7012
 
  (eval "$ac_try") 2>&5
7013
 
  ac_status=$?
7014
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7015
 
  (exit $ac_status); }; }; then
 
6559
  (exit $ac_status); } && {
 
6560
         test -z "$ac_c_werror_flag" ||
 
6561
         test ! -s conftest.err
 
6562
       } && test -s conftest.$ac_objext; then
7016
6563
  ac_cv_c_const=yes
7017
6564
else
7018
6565
  echo "$as_me: failed program was:" >&5
7065
6612
  rm -f conftest.er1
7066
6613
  cat conftest.err >&5
7067
6614
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7068
 
  (exit $ac_status); } &&
7069
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7070
 
  { (case "(($ac_try" in
7071
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7072
 
  *) ac_try_echo=$ac_try;;
7073
 
esac
7074
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7075
 
  (eval "$ac_try") 2>&5
7076
 
  ac_status=$?
7077
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7078
 
  (exit $ac_status); }; } &&
7079
 
         { ac_try='test -s conftest.$ac_objext'
7080
 
  { (case "(($ac_try" in
7081
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7082
 
  *) ac_try_echo=$ac_try;;
7083
 
esac
7084
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7085
 
  (eval "$ac_try") 2>&5
7086
 
  ac_status=$?
7087
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7088
 
  (exit $ac_status); }; }; then
 
6615
  (exit $ac_status); } && {
 
6616
         test -z "$ac_c_werror_flag" ||
 
6617
         test ! -s conftest.err
 
6618
       } && test -s conftest.$ac_objext; then
7089
6619
  ac_cv_c_inline=$ac_kw
7090
6620
else
7091
6621
  echo "$as_me: failed program was:" >&5
7155
6685
  rm -f conftest.er1
7156
6686
  cat conftest.err >&5
7157
6687
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7158
 
  (exit $ac_status); } &&
7159
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7160
 
  { (case "(($ac_try" in
7161
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7162
 
  *) ac_try_echo=$ac_try;;
7163
 
esac
7164
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7165
 
  (eval "$ac_try") 2>&5
7166
 
  ac_status=$?
7167
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168
 
  (exit $ac_status); }; } &&
7169
 
         { ac_try='test -s conftest.$ac_objext'
7170
 
  { (case "(($ac_try" in
7171
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7172
 
  *) ac_try_echo=$ac_try;;
7173
 
esac
7174
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7175
 
  (eval "$ac_try") 2>&5
7176
 
  ac_status=$?
7177
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7178
 
  (exit $ac_status); }; }; then
 
6688
  (exit $ac_status); } && {
 
6689
         test -z "$ac_c_werror_flag" ||
 
6690
         test ! -s conftest.err
 
6691
       } && test -s conftest.$ac_objext; then
7179
6692
  ac_cv_type_size_t=yes
7180
6693
else
7181
6694
  echo "$as_me: failed program was:" >&5
7214
6727
int
7215
6728
main ()
7216
6729
{
7217
 
struct tm *tp; tp->tm_sec;
 
6730
struct tm tm;
 
6731
                                     int *p = &tm.tm_sec;
 
6732
                                     return !p;
7218
6733
  ;
7219
6734
  return 0;
7220
6735
}
7232
6747
  rm -f conftest.er1
7233
6748
  cat conftest.err >&5
7234
6749
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7235
 
  (exit $ac_status); } &&
7236
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7237
 
  { (case "(($ac_try" in
7238
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7239
 
  *) ac_try_echo=$ac_try;;
7240
 
esac
7241
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7242
 
  (eval "$ac_try") 2>&5
7243
 
  ac_status=$?
7244
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7245
 
  (exit $ac_status); }; } &&
7246
 
         { ac_try='test -s conftest.$ac_objext'
7247
 
  { (case "(($ac_try" in
7248
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7249
 
  *) ac_try_echo=$ac_try;;
7250
 
esac
7251
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7252
 
  (eval "$ac_try") 2>&5
7253
 
  ac_status=$?
7254
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7255
 
  (exit $ac_status); }; }; then
 
6750
  (exit $ac_status); } && {
 
6751
         test -z "$ac_c_werror_flag" ||
 
6752
         test ! -s conftest.err
 
6753
       } && test -s conftest.$ac_objext; then
7256
6754
  ac_cv_struct_tm=time.h
7257
6755
else
7258
6756
  echo "$as_me: failed program was:" >&5
7309
6807
  rm -f conftest.er1
7310
6808
  cat conftest.err >&5
7311
6809
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7312
 
  (exit $ac_status); } &&
7313
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7314
 
  { (case "(($ac_try" in
7315
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7316
 
  *) ac_try_echo=$ac_try;;
7317
 
esac
7318
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7319
 
  (eval "$ac_try") 2>&5
7320
 
  ac_status=$?
7321
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7322
 
  (exit $ac_status); }; } &&
7323
 
         { ac_try='test -s conftest.$ac_objext'
7324
 
  { (case "(($ac_try" in
7325
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7326
 
  *) ac_try_echo=$ac_try;;
7327
 
esac
7328
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7329
 
  (eval "$ac_try") 2>&5
7330
 
  ac_status=$?
7331
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7332
 
  (exit $ac_status); }; }; then
 
6810
  (exit $ac_status); } && {
 
6811
         test -z "$ac_c_werror_flag" ||
 
6812
         test ! -s conftest.err
 
6813
       } && test -s conftest.$ac_objext; then
7333
6814
  ac_cv_c_volatile=yes
7334
6815
else
7335
6816
  echo "$as_me: failed program was:" >&5
7387
6868
  rm -f conftest.er1
7388
6869
  cat conftest.err >&5
7389
6870
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7390
 
  (exit $ac_status); } &&
7391
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7392
 
  { (case "(($ac_try" in
7393
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7394
 
  *) ac_try_echo=$ac_try;;
7395
 
esac
7396
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7397
 
  (eval "$ac_try") 2>&5
7398
 
  ac_status=$?
7399
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7400
 
  (exit $ac_status); }; } &&
7401
 
         { ac_try='test -s conftest.$ac_objext'
7402
 
  { (case "(($ac_try" in
7403
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7404
 
  *) ac_try_echo=$ac_try;;
7405
 
esac
7406
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7407
 
  (eval "$ac_try") 2>&5
7408
 
  ac_status=$?
7409
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7410
 
  (exit $ac_status); }; }; then
 
6871
  (exit $ac_status); } && {
 
6872
         test -z "$ac_c_werror_flag" ||
 
6873
         test ! -s conftest.err
 
6874
       } && test -s conftest.$ac_objext; then
7411
6875
  ac_cv_type_ptrdiff_t=yes
7412
6876
else
7413
6877
  echo "$as_me: failed program was:" >&5
7465
6929
  rm -f conftest.er1
7466
6930
  cat conftest.err >&5
7467
6931
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7468
 
  (exit $ac_status); } &&
7469
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7470
 
  { (case "(($ac_try" in
7471
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7472
 
  *) ac_try_echo=$ac_try;;
7473
 
esac
7474
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7475
 
  (eval "$ac_try") 2>&5
7476
 
  ac_status=$?
7477
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7478
 
  (exit $ac_status); }; } &&
7479
 
         { ac_try='test -s conftest.$ac_objext'
7480
 
  { (case "(($ac_try" in
7481
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7482
 
  *) ac_try_echo=$ac_try;;
7483
 
esac
7484
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7485
 
  (eval "$ac_try") 2>&5
7486
 
  ac_status=$?
7487
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7488
 
  (exit $ac_status); }; }; then
 
6932
  (exit $ac_status); } && {
 
6933
         test -z "$ac_c_werror_flag" ||
 
6934
         test ! -s conftest.err
 
6935
       } && test -s conftest.$ac_objext; then
7489
6936
  ac_cv_c_long_long=yes
7490
6937
else
7491
6938
  echo "$as_me: failed program was:" >&5
7527
6974
int
7528
6975
main ()
7529
6976
{
7530
 
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
 
6977
#if  ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
 
6978
        && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
7531
6979
 bogus endian macros
7532
6980
#endif
7533
6981
 
7548
6996
  rm -f conftest.er1
7549
6997
  cat conftest.err >&5
7550
6998
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7551
 
  (exit $ac_status); } &&
7552
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7553
 
  { (case "(($ac_try" in
7554
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7555
 
  *) ac_try_echo=$ac_try;;
7556
 
esac
7557
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7558
 
  (eval "$ac_try") 2>&5
7559
 
  ac_status=$?
7560
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7561
 
  (exit $ac_status); }; } &&
7562
 
         { ac_try='test -s conftest.$ac_objext'
7563
 
  { (case "(($ac_try" in
7564
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7565
 
  *) ac_try_echo=$ac_try;;
7566
 
esac
7567
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7568
 
  (eval "$ac_try") 2>&5
7569
 
  ac_status=$?
7570
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7571
 
  (exit $ac_status); }; }; then
 
6999
  (exit $ac_status); } && {
 
7000
         test -z "$ac_c_werror_flag" ||
 
7001
         test ! -s conftest.err
 
7002
       } && test -s conftest.$ac_objext; then
7572
7003
  # It does; now see whether it defined to BIG_ENDIAN or not.
7573
7004
cat >conftest.$ac_ext <<_ACEOF
7574
7005
/* confdefs.h.  */
7603
7034
  rm -f conftest.er1
7604
7035
  cat conftest.err >&5
7605
7036
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7606
 
  (exit $ac_status); } &&
7607
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7608
 
  { (case "(($ac_try" in
7609
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7610
 
  *) ac_try_echo=$ac_try;;
7611
 
esac
7612
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7613
 
  (eval "$ac_try") 2>&5
7614
 
  ac_status=$?
7615
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7616
 
  (exit $ac_status); }; } &&
7617
 
         { ac_try='test -s conftest.$ac_objext'
7618
 
  { (case "(($ac_try" in
7619
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7620
 
  *) ac_try_echo=$ac_try;;
7621
 
esac
7622
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7623
 
  (eval "$ac_try") 2>&5
7624
 
  ac_status=$?
7625
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7626
 
  (exit $ac_status); }; }; then
 
7037
  (exit $ac_status); } && {
 
7038
         test -z "$ac_c_werror_flag" ||
 
7039
         test ! -s conftest.err
 
7040
       } && test -s conftest.$ac_objext; then
7627
7041
  ac_cv_c_bigendian=yes
7628
7042
else
7629
7043
  echo "$as_me: failed program was:" >&5
7674
7088
  rm -f conftest.er1
7675
7089
  cat conftest.err >&5
7676
7090
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7677
 
  (exit $ac_status); } &&
7678
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7679
 
  { (case "(($ac_try" in
7680
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7681
 
  *) ac_try_echo=$ac_try;;
7682
 
esac
7683
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7684
 
  (eval "$ac_try") 2>&5
7685
 
  ac_status=$?
7686
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7687
 
  (exit $ac_status); }; } &&
7688
 
         { ac_try='test -s conftest.$ac_objext'
7689
 
  { (case "(($ac_try" in
7690
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7691
 
  *) ac_try_echo=$ac_try;;
7692
 
esac
7693
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7694
 
  (eval "$ac_try") 2>&5
7695
 
  ac_status=$?
7696
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7697
 
  (exit $ac_status); }; }; then
 
7091
  (exit $ac_status); } && {
 
7092
         test -z "$ac_c_werror_flag" ||
 
7093
         test ! -s conftest.err
 
7094
       } && test -s conftest.$ac_objext; then
7698
7095
  if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
7699
7096
  ac_cv_c_bigendian=yes
7700
7097
fi
7965
7362
  rm -f conftest.er1
7966
7363
  cat conftest.err >&5
7967
7364
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968
 
  (exit $ac_status); } &&
7969
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
7970
 
  { (case "(($ac_try" in
7971
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7972
 
  *) ac_try_echo=$ac_try;;
7973
 
esac
7974
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7975
 
  (eval "$ac_try") 2>&5
7976
 
  ac_status=$?
7977
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7978
 
  (exit $ac_status); }; } &&
7979
 
         { ac_try='test -s conftest$ac_exeext'
7980
 
  { (case "(($ac_try" in
7981
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7982
 
  *) ac_try_echo=$ac_try;;
7983
 
esac
7984
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7985
 
  (eval "$ac_try") 2>&5
7986
 
  ac_status=$?
7987
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7988
 
  (exit $ac_status); }; }; then
 
7365
  (exit $ac_status); } && {
 
7366
         test -z "$ac_c_werror_flag" ||
 
7367
         test ! -s conftest.err
 
7368
       } && test -s conftest$ac_exeext &&
 
7369
       $as_test_x conftest$ac_exeext; then
7989
7370
  ac_cv_func__longjmp=yes
7990
7371
else
7991
7372
  echo "$as_me: failed program was:" >&5
7994
7375
        ac_cv_func__longjmp=no
7995
7376
fi
7996
7377
 
7997
 
rm -f core conftest.err conftest.$ac_objext \
 
7378
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7998
7379
      conftest$ac_exeext conftest.$ac_ext
7999
7380
fi
8000
7381
{ echo "$as_me:$LINENO: result: $ac_cv_func__longjmp" >&5
8042
7423
  rm -f conftest.er1
8043
7424
  cat conftest.err >&5
8044
7425
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8045
 
  (exit $ac_status); } &&
8046
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8047
 
  { (case "(($ac_try" in
8048
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8049
 
  *) ac_try_echo=$ac_try;;
8050
 
esac
8051
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8052
 
  (eval "$ac_try") 2>&5
8053
 
  ac_status=$?
8054
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8055
 
  (exit $ac_status); }; } &&
8056
 
         { ac_try='test -s conftest.$ac_objext'
8057
 
  { (case "(($ac_try" in
8058
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8059
 
  *) ac_try_echo=$ac_try;;
8060
 
esac
8061
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8062
 
  (eval "$ac_try") 2>&5
8063
 
  ac_status=$?
8064
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8065
 
  (exit $ac_status); }; }; then
 
7426
  (exit $ac_status); } && {
 
7427
         test -z "$ac_c_werror_flag" ||
 
7428
         test ! -s conftest.err
 
7429
       } && test -s conftest.$ac_objext; then
8066
7430
  ECL_FILE_CNT=1
8067
7431
else
8068
7432
  echo "$as_me: failed program was:" >&5
8105
7469
  rm -f conftest.er1
8106
7470
  cat conftest.err >&5
8107
7471
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8108
 
  (exit $ac_status); } &&
8109
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8110
 
  { (case "(($ac_try" in
8111
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8112
 
  *) ac_try_echo=$ac_try;;
8113
 
esac
8114
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8115
 
  (eval "$ac_try") 2>&5
8116
 
  ac_status=$?
8117
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8118
 
  (exit $ac_status); }; } &&
8119
 
         { ac_try='test -s conftest.$ac_objext'
8120
 
  { (case "(($ac_try" in
8121
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8122
 
  *) ac_try_echo=$ac_try;;
8123
 
esac
8124
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8125
 
  (eval "$ac_try") 2>&5
8126
 
  ac_status=$?
8127
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8128
 
  (exit $ac_status); }; }; then
 
7472
  (exit $ac_status); } && {
 
7473
         test -z "$ac_c_werror_flag" ||
 
7474
         test ! -s conftest.err
 
7475
       } && test -s conftest.$ac_objext; then
8129
7476
  ECL_FILE_CNT=2
8130
7477
else
8131
7478
  echo "$as_me: failed program was:" >&5
8168
7515
  rm -f conftest.er1
8169
7516
  cat conftest.err >&5
8170
7517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8171
 
  (exit $ac_status); } &&
8172
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8173
 
  { (case "(($ac_try" in
8174
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8175
 
  *) ac_try_echo=$ac_try;;
8176
 
esac
8177
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8178
 
  (eval "$ac_try") 2>&5
8179
 
  ac_status=$?
8180
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8181
 
  (exit $ac_status); }; } &&
8182
 
         { ac_try='test -s conftest.$ac_objext'
8183
 
  { (case "(($ac_try" in
8184
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8185
 
  *) ac_try_echo=$ac_try;;
8186
 
esac
8187
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8188
 
  (eval "$ac_try") 2>&5
8189
 
  ac_status=$?
8190
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8191
 
  (exit $ac_status); }; }; then
 
7518
  (exit $ac_status); } && {
 
7519
         test -z "$ac_c_werror_flag" ||
 
7520
         test ! -s conftest.err
 
7521
       } && test -s conftest.$ac_objext; then
8192
7522
  ECL_FILE_CNT=3
8193
7523
else
8194
7524
  echo "$as_me: failed program was:" >&5
8208
7538
        EXTRA_OBJS="${EXTRA_OBJS} ffi_x86.o"
8209
7539
        dynamic_ffi=yes
8210
7540
        ;;
 
7541
   x86_64 )
 
7542
        EXTRA_OBJS="${EXTRA_OBJS} ffi_x86_64.o"
 
7543
        dynamic_ffi=yes
 
7544
        ;;
8211
7545
   *)
8212
7546
        dynamic_ffi=no
8213
7547
        ;;
8230
7564
        { echo "$as_me:$LINENO: result: x86" >&5
8231
7565
echo "${ECHO_T}x86" >&6; }
8232
7566
        ;;
 
7567
   x86_64* )
 
7568
        ECL_FPE_CODE="arch/fpe_x86.c"
 
7569
        { echo "$as_me:$LINENO: result: x86_64" >&5
 
7570
echo "${ECHO_T}x86_64" >&6; }
 
7571
        ;;
8233
7572
   *)
8234
7573
        ECL_FPE_CODE="arch/fpe_none.c"
8235
7574
        { echo "$as_me:$LINENO: result: not available" >&5
8239
7578
 
8240
7579
 
8241
7580
 
 
7581
if test "$enable_longdouble" != "no" ; then
 
7582
{ echo "$as_me:$LINENO: checking for long double" >&5
 
7583
echo $ECHO_N "checking for long double... $ECHO_C" >&6; }
 
7584
if test "${ac_cv_type_long_double+set}" = set; then
 
7585
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7586
else
 
7587
  cat >conftest.$ac_ext <<_ACEOF
 
7588
/* confdefs.h.  */
 
7589
_ACEOF
 
7590
cat confdefs.h >>conftest.$ac_ext
 
7591
cat >>conftest.$ac_ext <<_ACEOF
 
7592
/* end confdefs.h.  */
 
7593
$ac_includes_default
 
7594
typedef long double ac__type_new_;
 
7595
int
 
7596
main ()
 
7597
{
 
7598
if ((ac__type_new_ *) 0)
 
7599
  return 0;
 
7600
if (sizeof (ac__type_new_))
 
7601
  return 0;
 
7602
  ;
 
7603
  return 0;
 
7604
}
 
7605
_ACEOF
 
7606
rm -f conftest.$ac_objext
 
7607
if { (ac_try="$ac_compile"
 
7608
case "(($ac_try" in
 
7609
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7610
  *) ac_try_echo=$ac_try;;
 
7611
esac
 
7612
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
7613
  (eval "$ac_compile") 2>conftest.er1
 
7614
  ac_status=$?
 
7615
  grep -v '^ *+' conftest.er1 >conftest.err
 
7616
  rm -f conftest.er1
 
7617
  cat conftest.err >&5
 
7618
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7619
  (exit $ac_status); } && {
 
7620
         test -z "$ac_c_werror_flag" ||
 
7621
         test ! -s conftest.err
 
7622
       } && test -s conftest.$ac_objext; then
 
7623
  ac_cv_type_long_double=yes
 
7624
else
 
7625
  echo "$as_me: failed program was:" >&5
 
7626
sed 's/^/| /' conftest.$ac_ext >&5
 
7627
 
 
7628
        ac_cv_type_long_double=no
 
7629
fi
 
7630
 
 
7631
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7632
fi
 
7633
{ echo "$as_me:$LINENO: result: $ac_cv_type_long_double" >&5
 
7634
echo "${ECHO_T}$ac_cv_type_long_double" >&6; }
 
7635
if test $ac_cv_type_long_double = yes; then
 
7636
 
 
7637
cat >>confdefs.h <<_ACEOF
 
7638
#define HAVE_LONG_DOUBLE 1
 
7639
_ACEOF
 
7640
 
 
7641
 
 
7642
fi
 
7643
 
 
7644
fi
 
7645
if test "$enable_c99complex" != "no" ; then
 
7646
{ echo "$as_me:$LINENO: checking for double complex" >&5
 
7647
echo $ECHO_N "checking for double complex... $ECHO_C" >&6; }
 
7648
if test "${ac_cv_type_double_complex+set}" = set; then
 
7649
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7650
else
 
7651
  cat >conftest.$ac_ext <<_ACEOF
 
7652
/* confdefs.h.  */
 
7653
_ACEOF
 
7654
cat confdefs.h >>conftest.$ac_ext
 
7655
cat >>conftest.$ac_ext <<_ACEOF
 
7656
/* end confdefs.h.  */
 
7657
#include <complex.h>
 
7658
 
 
7659
typedef double complex ac__type_new_;
 
7660
int
 
7661
main ()
 
7662
{
 
7663
if ((ac__type_new_ *) 0)
 
7664
  return 0;
 
7665
if (sizeof (ac__type_new_))
 
7666
  return 0;
 
7667
  ;
 
7668
  return 0;
 
7669
}
 
7670
_ACEOF
 
7671
rm -f conftest.$ac_objext
 
7672
if { (ac_try="$ac_compile"
 
7673
case "(($ac_try" in
 
7674
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7675
  *) ac_try_echo=$ac_try;;
 
7676
esac
 
7677
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
7678
  (eval "$ac_compile") 2>conftest.er1
 
7679
  ac_status=$?
 
7680
  grep -v '^ *+' conftest.er1 >conftest.err
 
7681
  rm -f conftest.er1
 
7682
  cat conftest.err >&5
 
7683
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7684
  (exit $ac_status); } && {
 
7685
         test -z "$ac_c_werror_flag" ||
 
7686
         test ! -s conftest.err
 
7687
       } && test -s conftest.$ac_objext; then
 
7688
  ac_cv_type_double_complex=yes
 
7689
else
 
7690
  echo "$as_me: failed program was:" >&5
 
7691
sed 's/^/| /' conftest.$ac_ext >&5
 
7692
 
 
7693
        ac_cv_type_double_complex=no
 
7694
fi
 
7695
 
 
7696
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7697
fi
 
7698
{ echo "$as_me:$LINENO: result: $ac_cv_type_double_complex" >&5
 
7699
echo "${ECHO_T}$ac_cv_type_double_complex" >&6; }
 
7700
if test $ac_cv_type_double_complex = yes; then
 
7701
 
 
7702
cat >>confdefs.h <<_ACEOF
 
7703
#define HAVE_DOUBLE_COMPLEX 1
 
7704
_ACEOF
 
7705
 
 
7706
 
 
7707
fi
 
7708
{ echo "$as_me:$LINENO: checking for float complex" >&5
 
7709
echo $ECHO_N "checking for float complex... $ECHO_C" >&6; }
 
7710
if test "${ac_cv_type_float_complex+set}" = set; then
 
7711
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7712
else
 
7713
  cat >conftest.$ac_ext <<_ACEOF
 
7714
/* confdefs.h.  */
 
7715
_ACEOF
 
7716
cat confdefs.h >>conftest.$ac_ext
 
7717
cat >>conftest.$ac_ext <<_ACEOF
 
7718
/* end confdefs.h.  */
 
7719
#include <complex.h>
 
7720
 
 
7721
typedef float complex ac__type_new_;
 
7722
int
 
7723
main ()
 
7724
{
 
7725
if ((ac__type_new_ *) 0)
 
7726
  return 0;
 
7727
if (sizeof (ac__type_new_))
 
7728
  return 0;
 
7729
  ;
 
7730
  return 0;
 
7731
}
 
7732
_ACEOF
 
7733
rm -f conftest.$ac_objext
 
7734
if { (ac_try="$ac_compile"
 
7735
case "(($ac_try" in
 
7736
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7737
  *) ac_try_echo=$ac_try;;
 
7738
esac
 
7739
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
7740
  (eval "$ac_compile") 2>conftest.er1
 
7741
  ac_status=$?
 
7742
  grep -v '^ *+' conftest.er1 >conftest.err
 
7743
  rm -f conftest.er1
 
7744
  cat conftest.err >&5
 
7745
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7746
  (exit $ac_status); } && {
 
7747
         test -z "$ac_c_werror_flag" ||
 
7748
         test ! -s conftest.err
 
7749
       } && test -s conftest.$ac_objext; then
 
7750
  ac_cv_type_float_complex=yes
 
7751
else
 
7752
  echo "$as_me: failed program was:" >&5
 
7753
sed 's/^/| /' conftest.$ac_ext >&5
 
7754
 
 
7755
        ac_cv_type_float_complex=no
 
7756
fi
 
7757
 
 
7758
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7759
fi
 
7760
{ echo "$as_me:$LINENO: result: $ac_cv_type_float_complex" >&5
 
7761
echo "${ECHO_T}$ac_cv_type_float_complex" >&6; }
 
7762
if test $ac_cv_type_float_complex = yes; then
 
7763
 
 
7764
cat >>confdefs.h <<_ACEOF
 
7765
#define HAVE_FLOAT_COMPLEX 1
 
7766
_ACEOF
 
7767
 
 
7768
 
 
7769
fi
 
7770
 
 
7771
fi
 
7772
 
8242
7773
 
8243
7774
  { echo "$as_me:$LINENO: checking whether stack growns downwards" >&5
8244
7775
echo $ECHO_N "checking whether stack growns downwards... $ECHO_C" >&6; }
8509
8040
cat confdefs.h >>conftest.$ac_ext
8510
8041
cat >>conftest.$ac_ext <<_ACEOF
8511
8042
/* end confdefs.h.  */
8512
 
$ac_includes_default
 
8043
#include <error.h>
8513
8044
int
8514
8045
main ()
8515
8046
{
8516
 
error_at_line (0, 0, "", 0, "");
 
8047
error_at_line (0, 0, "", 0, "an error occurred");
8517
8048
  ;
8518
8049
  return 0;
8519
8050
}
8531
8062
  rm -f conftest.er1
8532
8063
  cat conftest.err >&5
8533
8064
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8534
 
  (exit $ac_status); } &&
8535
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8536
 
  { (case "(($ac_try" in
8537
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8538
 
  *) ac_try_echo=$ac_try;;
8539
 
esac
8540
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8541
 
  (eval "$ac_try") 2>&5
8542
 
  ac_status=$?
8543
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8544
 
  (exit $ac_status); }; } &&
8545
 
         { ac_try='test -s conftest$ac_exeext'
8546
 
  { (case "(($ac_try" in
8547
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8548
 
  *) ac_try_echo=$ac_try;;
8549
 
esac
8550
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8551
 
  (eval "$ac_try") 2>&5
8552
 
  ac_status=$?
8553
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8554
 
  (exit $ac_status); }; }; then
 
8065
  (exit $ac_status); } && {
 
8066
         test -z "$ac_c_werror_flag" ||
 
8067
         test ! -s conftest.err
 
8068
       } && test -s conftest$ac_exeext &&
 
8069
       $as_test_x conftest$ac_exeext; then
8555
8070
  ac_cv_lib_error_at_line=yes
8556
8071
else
8557
8072
  echo "$as_me: failed program was:" >&5
8560
8075
        ac_cv_lib_error_at_line=no
8561
8076
fi
8562
8077
 
8563
 
rm -f core conftest.err conftest.$ac_objext \
 
8078
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8564
8079
      conftest$ac_exeext conftest.$ac_ext
8565
8080
fi
8566
8081
{ echo "$as_me:$LINENO: result: $ac_cv_lib_error_at_line" >&5
8611
8126
  rm -f conftest.er1
8612
8127
  cat conftest.err >&5
8613
8128
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8614
 
  (exit $ac_status); } &&
8615
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8616
 
  { (case "(($ac_try" in
8617
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8618
 
  *) ac_try_echo=$ac_try;;
8619
 
esac
8620
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8621
 
  (eval "$ac_try") 2>&5
8622
 
  ac_status=$?
8623
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8624
 
  (exit $ac_status); }; } &&
8625
 
         { ac_try='test -s conftest.$ac_objext'
8626
 
  { (case "(($ac_try" in
8627
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8628
 
  *) ac_try_echo=$ac_try;;
8629
 
esac
8630
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8631
 
  (eval "$ac_try") 2>&5
8632
 
  ac_status=$?
8633
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8634
 
  (exit $ac_status); }; }; then
 
8129
  (exit $ac_status); } && {
 
8130
         test -z "$ac_c_werror_flag" ||
 
8131
         test ! -s conftest.err
 
8132
       } && test -s conftest.$ac_objext; then
8635
8133
  ac_cv_type_pid_t=yes
8636
8134
else
8637
8135
  echo "$as_me: failed program was:" >&5
8693
8191
  rm -f conftest.er1
8694
8192
  cat conftest.err >&5
8695
8193
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8696
 
  (exit $ac_status); } &&
8697
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8698
 
  { (case "(($ac_try" in
8699
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8700
 
  *) ac_try_echo=$ac_try;;
8701
 
esac
8702
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8703
 
  (eval "$ac_try") 2>&5
8704
 
  ac_status=$?
8705
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8706
 
  (exit $ac_status); }; } &&
8707
 
         { ac_try='test -s conftest.$ac_objext'
8708
 
  { (case "(($ac_try" in
8709
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8710
 
  *) ac_try_echo=$ac_try;;
8711
 
esac
8712
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8713
 
  (eval "$ac_try") 2>&5
8714
 
  ac_status=$?
8715
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8716
 
  (exit $ac_status); }; }; then
 
8194
  (exit $ac_status); } && {
 
8195
         test -z "$ac_c_werror_flag" ||
 
8196
         test ! -s conftest.err
 
8197
       } && test -s conftest.$ac_objext; then
8717
8198
  ac_header_compiler=yes
8718
8199
else
8719
8200
  echo "$as_me: failed program was:" >&5
8749
8230
  rm -f conftest.er1
8750
8231
  cat conftest.err >&5
8751
8232
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8752
 
  (exit $ac_status); } >/dev/null; then
8753
 
  if test -s conftest.err; then
8754
 
    ac_cpp_err=$ac_c_preproc_warn_flag
8755
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8756
 
  else
8757
 
    ac_cpp_err=
8758
 
  fi
8759
 
else
8760
 
  ac_cpp_err=yes
8761
 
fi
8762
 
if test -z "$ac_cpp_err"; then
 
8233
  (exit $ac_status); } >/dev/null && {
 
8234
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
8235
         test ! -s conftest.err
 
8236
       }; then
8763
8237
  ac_header_preproc=yes
8764
8238
else
8765
8239
  echo "$as_me: failed program was:" >&5
8886
8360
  rm -f conftest.er1
8887
8361
  cat conftest.err >&5
8888
8362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8889
 
  (exit $ac_status); } &&
8890
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
8891
 
  { (case "(($ac_try" in
8892
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8893
 
  *) ac_try_echo=$ac_try;;
8894
 
esac
8895
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8896
 
  (eval "$ac_try") 2>&5
8897
 
  ac_status=$?
8898
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8899
 
  (exit $ac_status); }; } &&
8900
 
         { ac_try='test -s conftest$ac_exeext'
8901
 
  { (case "(($ac_try" in
8902
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8903
 
  *) ac_try_echo=$ac_try;;
8904
 
esac
8905
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8906
 
  (eval "$ac_try") 2>&5
8907
 
  ac_status=$?
8908
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8909
 
  (exit $ac_status); }; }; then
 
8363
  (exit $ac_status); } && {
 
8364
         test -z "$ac_c_werror_flag" ||
 
8365
         test ! -s conftest.err
 
8366
       } && test -s conftest$ac_exeext &&
 
8367
       $as_test_x conftest$ac_exeext; then
8910
8368
  eval "$as_ac_var=yes"
8911
8369
else
8912
8370
  echo "$as_me: failed program was:" >&5
8915
8373
        eval "$as_ac_var=no"
8916
8374
fi
8917
8375
 
8918
 
rm -f core conftest.err conftest.$ac_objext \
 
8376
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8919
8377
      conftest$ac_exeext conftest.$ac_ext
8920
8378
fi
8921
8379
ac_res=`eval echo '${'$as_ac_var'}'`
9028
8486
/* Thanks to Paul Eggert for this test.  */
9029
8487
$ac_includes_default
9030
8488
#include <sys/wait.h>
9031
 
#if HAVE_VFORK_H
 
8489
#ifdef HAVE_VFORK_H
9032
8490
# include <vfork.h>
9033
8491
#endif
9034
8492
/* On some sparc systems, changes by the child to local and incoming
9269
8727
  rm -f conftest.er1
9270
8728
  cat conftest.err >&5
9271
8729
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9272
 
  (exit $ac_status); } &&
9273
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9274
 
  { (case "(($ac_try" in
9275
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9276
 
  *) ac_try_echo=$ac_try;;
9277
 
esac
9278
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9279
 
  (eval "$ac_try") 2>&5
9280
 
  ac_status=$?
9281
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9282
 
  (exit $ac_status); }; } &&
9283
 
         { ac_try='test -s conftest.$ac_objext'
9284
 
  { (case "(($ac_try" in
9285
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9286
 
  *) ac_try_echo=$ac_try;;
9287
 
esac
9288
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9289
 
  (eval "$ac_try") 2>&5
9290
 
  ac_status=$?
9291
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9292
 
  (exit $ac_status); }; }; then
 
8730
  (exit $ac_status); } && {
 
8731
         test -z "$ac_c_werror_flag" ||
 
8732
         test ! -s conftest.err
 
8733
       } && test -s conftest.$ac_objext; then
9293
8734
  ac_header_compiler=yes
9294
8735
else
9295
8736
  echo "$as_me: failed program was:" >&5
9325
8766
  rm -f conftest.er1
9326
8767
  cat conftest.err >&5
9327
8768
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9328
 
  (exit $ac_status); } >/dev/null; then
9329
 
  if test -s conftest.err; then
9330
 
    ac_cpp_err=$ac_c_preproc_warn_flag
9331
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9332
 
  else
9333
 
    ac_cpp_err=
9334
 
  fi
9335
 
else
9336
 
  ac_cpp_err=yes
9337
 
fi
9338
 
if test -z "$ac_cpp_err"; then
 
8769
  (exit $ac_status); } >/dev/null && {
 
8770
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
8771
         test ! -s conftest.err
 
8772
       }; then
9339
8773
  ac_header_preproc=yes
9340
8774
else
9341
8775
  echo "$as_me: failed program was:" >&5
9408
8842
cat confdefs.h >>conftest.$ac_ext
9409
8843
cat >>conftest.$ac_ext <<_ACEOF
9410
8844
/* end confdefs.h.  */
9411
 
#if STDC_HEADERS || HAVE_STDLIB_H
 
8845
#if defined STDC_HEADERS || defined HAVE_STDLIB_H
9412
8846
# include <stdlib.h>
9413
8847
#else
9414
8848
char *malloc ();
9614
9048
  rm -f conftest.er1
9615
9049
  cat conftest.err >&5
9616
9050
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9617
 
  (exit $ac_status); } &&
9618
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9619
 
  { (case "(($ac_try" in
9620
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9621
 
  *) ac_try_echo=$ac_try;;
9622
 
esac
9623
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9624
 
  (eval "$ac_try") 2>&5
9625
 
  ac_status=$?
9626
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9627
 
  (exit $ac_status); }; } &&
9628
 
         { ac_try='test -s conftest.$ac_objext'
9629
 
  { (case "(($ac_try" in
9630
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9631
 
  *) ac_try_echo=$ac_try;;
9632
 
esac
9633
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9634
 
  (eval "$ac_try") 2>&5
9635
 
  ac_status=$?
9636
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9637
 
  (exit $ac_status); }; }; then
 
9051
  (exit $ac_status); } && {
 
9052
         test -z "$ac_c_werror_flag" ||
 
9053
         test ! -s conftest.err
 
9054
       } && test -s conftest.$ac_objext; then
9638
9055
  ac_header_compiler=yes
9639
9056
else
9640
9057
  echo "$as_me: failed program was:" >&5
9670
9087
  rm -f conftest.er1
9671
9088
  cat conftest.err >&5
9672
9089
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9673
 
  (exit $ac_status); } >/dev/null; then
9674
 
  if test -s conftest.err; then
9675
 
    ac_cpp_err=$ac_c_preproc_warn_flag
9676
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9677
 
  else
9678
 
    ac_cpp_err=
9679
 
  fi
9680
 
else
9681
 
  ac_cpp_err=yes
9682
 
fi
9683
 
if test -z "$ac_cpp_err"; then
 
9090
  (exit $ac_status); } >/dev/null && {
 
9091
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
9092
         test ! -s conftest.err
 
9093
       }; then
9684
9094
  ac_header_preproc=yes
9685
9095
else
9686
9096
  echo "$as_me: failed program was:" >&5
9806
9216
  rm -f conftest.er1
9807
9217
  cat conftest.err >&5
9808
9218
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9809
 
  (exit $ac_status); } &&
9810
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9811
 
  { (case "(($ac_try" in
9812
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9813
 
  *) ac_try_echo=$ac_try;;
9814
 
esac
9815
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9816
 
  (eval "$ac_try") 2>&5
9817
 
  ac_status=$?
9818
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9819
 
  (exit $ac_status); }; } &&
9820
 
         { ac_try='test -s conftest$ac_exeext'
9821
 
  { (case "(($ac_try" in
9822
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9823
 
  *) ac_try_echo=$ac_try;;
9824
 
esac
9825
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9826
 
  (eval "$ac_try") 2>&5
9827
 
  ac_status=$?
9828
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9829
 
  (exit $ac_status); }; }; then
 
9219
  (exit $ac_status); } && {
 
9220
         test -z "$ac_c_werror_flag" ||
 
9221
         test ! -s conftest.err
 
9222
       } && test -s conftest$ac_exeext &&
 
9223
       $as_test_x conftest$ac_exeext; then
9830
9224
  eval "$as_ac_var=yes"
9831
9225
else
9832
9226
  echo "$as_me: failed program was:" >&5
9835
9229
        eval "$as_ac_var=no"
9836
9230
fi
9837
9231
 
9838
 
rm -f core conftest.err conftest.$ac_objext \
 
9232
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9839
9233
      conftest$ac_exeext conftest.$ac_ext
9840
9234
fi
9841
9235
ac_res=`eval echo '${'$as_ac_var'}'`
9892
9286
#include <fcntl.h>
9893
9287
#include <sys/mman.h>
9894
9288
 
9895
 
#if !STDC_HEADERS && !HAVE_STDLIB_H
 
9289
#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H
9896
9290
char *malloc ();
9897
9291
#endif
9898
9292
 
9899
9293
/* This mess was copied from the GNU getpagesize.h.  */
9900
 
#if !HAVE_GETPAGESIZE
 
9294
#ifndef HAVE_GETPAGESIZE
9901
9295
/* Assume that all systems that can run configure have sys/param.h.  */
9902
 
# if !HAVE_SYS_PARAM_H
 
9296
# ifndef HAVE_SYS_PARAM_H
9903
9297
#  define HAVE_SYS_PARAM_H 1
9904
9298
# endif
9905
9299
 
9906
9300
# ifdef _SC_PAGESIZE
9907
9301
#  define getpagesize() sysconf(_SC_PAGESIZE)
9908
9302
# else /* no _SC_PAGESIZE */
9909
 
#  if HAVE_SYS_PARAM_H
 
9303
#  ifdef HAVE_SYS_PARAM_H
9910
9304
#   include <sys/param.h>
9911
9305
#   ifdef EXEC_PAGESIZE
9912
9306
#    define getpagesize() EXEC_PAGESIZE
10074
9468
  rm -f conftest.er1
10075
9469
  cat conftest.err >&5
10076
9470
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10077
 
  (exit $ac_status); } &&
10078
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10079
 
  { (case "(($ac_try" in
10080
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10081
 
  *) ac_try_echo=$ac_try;;
10082
 
esac
10083
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10084
 
  (eval "$ac_try") 2>&5
10085
 
  ac_status=$?
10086
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10087
 
  (exit $ac_status); }; } &&
10088
 
         { ac_try='test -s conftest.$ac_objext'
10089
 
  { (case "(($ac_try" in
10090
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10091
 
  *) ac_try_echo=$ac_try;;
10092
 
esac
10093
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10094
 
  (eval "$ac_try") 2>&5
10095
 
  ac_status=$?
10096
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10097
 
  (exit $ac_status); }; }; then
 
9471
  (exit $ac_status); } && {
 
9472
         test -z "$ac_c_werror_flag" ||
 
9473
         test ! -s conftest.err
 
9474
       } && test -s conftest.$ac_objext; then
10098
9475
  ac_header_compiler=yes
10099
9476
else
10100
9477
  echo "$as_me: failed program was:" >&5
10130
9507
  rm -f conftest.er1
10131
9508
  cat conftest.err >&5
10132
9509
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10133
 
  (exit $ac_status); } >/dev/null; then
10134
 
  if test -s conftest.err; then
10135
 
    ac_cpp_err=$ac_c_preproc_warn_flag
10136
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10137
 
  else
10138
 
    ac_cpp_err=
10139
 
  fi
10140
 
else
10141
 
  ac_cpp_err=yes
10142
 
fi
10143
 
if test -z "$ac_cpp_err"; then
 
9510
  (exit $ac_status); } >/dev/null && {
 
9511
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
9512
         test ! -s conftest.err
 
9513
       }; then
10144
9514
  ac_header_preproc=yes
10145
9515
else
10146
9516
  echo "$as_me: failed program was:" >&5
10213
9583
cat confdefs.h >>conftest.$ac_ext
10214
9584
cat >>conftest.$ac_ext <<_ACEOF
10215
9585
/* end confdefs.h.  */
10216
 
#if STDC_HEADERS || HAVE_STDLIB_H
 
9586
#if defined STDC_HEADERS || defined HAVE_STDLIB_H
10217
9587
# include <stdlib.h>
10218
9588
#else
10219
9589
char *realloc ();
10329
9699
  rm -f conftest.er1
10330
9700
  cat conftest.err >&5
10331
9701
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10332
 
  (exit $ac_status); } &&
10333
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10334
 
  { (case "(($ac_try" in
10335
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10336
 
  *) ac_try_echo=$ac_try;;
10337
 
esac
10338
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10339
 
  (eval "$ac_try") 2>&5
10340
 
  ac_status=$?
10341
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10342
 
  (exit $ac_status); }; } &&
10343
 
         { ac_try='test -s conftest.$ac_objext'
10344
 
  { (case "(($ac_try" in
10345
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10346
 
  *) ac_try_echo=$ac_try;;
10347
 
esac
10348
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10349
 
  (eval "$ac_try") 2>&5
10350
 
  ac_status=$?
10351
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10352
 
  (exit $ac_status); }; }; then
 
9702
  (exit $ac_status); } && {
 
9703
         test -z "$ac_c_werror_flag" ||
 
9704
         test ! -s conftest.err
 
9705
       } && test -s conftest.$ac_objext; then
10353
9706
  ac_header_compiler=yes
10354
9707
else
10355
9708
  echo "$as_me: failed program was:" >&5
10385
9738
  rm -f conftest.er1
10386
9739
  cat conftest.err >&5
10387
9740
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10388
 
  (exit $ac_status); } >/dev/null; then
10389
 
  if test -s conftest.err; then
10390
 
    ac_cpp_err=$ac_c_preproc_warn_flag
10391
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10392
 
  else
10393
 
    ac_cpp_err=
10394
 
  fi
10395
 
else
10396
 
  ac_cpp_err=yes
10397
 
fi
10398
 
if test -z "$ac_cpp_err"; then
 
9741
  (exit $ac_status); } >/dev/null && {
 
9742
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
9743
         test ! -s conftest.err
 
9744
       }; then
10399
9745
  ac_header_preproc=yes
10400
9746
else
10401
9747
  echo "$as_me: failed program was:" >&5
10469
9815
cat >>conftest.$ac_ext <<_ACEOF
10470
9816
/* end confdefs.h.  */
10471
9817
$ac_includes_default
10472
 
#if HAVE_SYS_SELECT_H
 
9818
#ifdef HAVE_SYS_SELECT_H
10473
9819
# include <sys/select.h>
10474
9820
#endif
10475
 
#if HAVE_SYS_SOCKET_H
 
9821
#ifdef HAVE_SYS_SOCKET_H
10476
9822
# include <sys/socket.h>
10477
9823
#endif
10478
9824
 
10499
9845
  rm -f conftest.er1
10500
9846
  cat conftest.err >&5
10501
9847
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10502
 
  (exit $ac_status); } &&
10503
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10504
 
  { (case "(($ac_try" in
10505
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10506
 
  *) ac_try_echo=$ac_try;;
10507
 
esac
10508
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10509
 
  (eval "$ac_try") 2>&5
10510
 
  ac_status=$?
10511
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10512
 
  (exit $ac_status); }; } &&
10513
 
         { ac_try='test -s conftest.$ac_objext'
10514
 
  { (case "(($ac_try" in
10515
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10516
 
  *) ac_try_echo=$ac_try;;
10517
 
esac
10518
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10519
 
  (eval "$ac_try") 2>&5
10520
 
  ac_status=$?
10521
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522
 
  (exit $ac_status); }; }; then
 
9848
  (exit $ac_status); } && {
 
9849
         test -z "$ac_c_werror_flag" ||
 
9850
         test ! -s conftest.err
 
9851
       } && test -s conftest.$ac_objext; then
10523
9852
  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
10524
9853
else
10525
9854
  echo "$as_me: failed program was:" >&5
10594
9923
  rm -f conftest.er1
10595
9924
  cat conftest.err >&5
10596
9925
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10597
 
  (exit $ac_status); } &&
10598
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10599
 
  { (case "(($ac_try" in
10600
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10601
 
  *) ac_try_echo=$ac_try;;
10602
 
esac
10603
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10604
 
  (eval "$ac_try") 2>&5
10605
 
  ac_status=$?
10606
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10607
 
  (exit $ac_status); }; } &&
10608
 
         { ac_try='test -s conftest.$ac_objext'
10609
 
  { (case "(($ac_try" in
10610
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10611
 
  *) ac_try_echo=$ac_try;;
10612
 
esac
10613
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10614
 
  (eval "$ac_try") 2>&5
10615
 
  ac_status=$?
10616
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10617
 
  (exit $ac_status); }; }; then
 
9926
  (exit $ac_status); } && {
 
9927
         test -z "$ac_c_werror_flag" ||
 
9928
         test ! -s conftest.err
 
9929
       } && test -s conftest.$ac_objext; then
10618
9930
  ac_cv_type_signal=int
10619
9931
else
10620
9932
  echo "$as_me: failed program was:" >&5
10948
10260
  rm -f conftest.er1
10949
10261
  cat conftest.err >&5
10950
10262
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10951
 
  (exit $ac_status); } &&
10952
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10953
 
  { (case "(($ac_try" in
10954
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10955
 
  *) ac_try_echo=$ac_try;;
10956
 
esac
10957
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10958
 
  (eval "$ac_try") 2>&5
10959
 
  ac_status=$?
10960
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10961
 
  (exit $ac_status); }; } &&
10962
 
         { ac_try='test -s conftest$ac_exeext'
10963
 
  { (case "(($ac_try" in
10964
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10965
 
  *) ac_try_echo=$ac_try;;
10966
 
esac
10967
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10968
 
  (eval "$ac_try") 2>&5
10969
 
  ac_status=$?
10970
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10971
 
  (exit $ac_status); }; }; then
 
10263
  (exit $ac_status); } && {
 
10264
         test -z "$ac_c_werror_flag" ||
 
10265
         test ! -s conftest.err
 
10266
       } && test -s conftest$ac_exeext &&
 
10267
       $as_test_x conftest$ac_exeext; then
10972
10268
  ac_cv_func_pow=yes
10973
10269
else
10974
10270
  echo "$as_me: failed program was:" >&5
10977
10273
        ac_cv_func_pow=no
10978
10274
fi
10979
10275
 
10980
 
rm -f core conftest.err conftest.$ac_objext \
 
10276
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
10981
10277
      conftest$ac_exeext conftest.$ac_ext
10982
10278
fi
10983
10279
{ echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11026
10322
  rm -f conftest.er1
11027
10323
  cat conftest.err >&5
11028
10324
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11029
 
  (exit $ac_status); } &&
11030
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11031
 
  { (case "(($ac_try" in
11032
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11033
 
  *) ac_try_echo=$ac_try;;
11034
 
esac
11035
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11036
 
  (eval "$ac_try") 2>&5
11037
 
  ac_status=$?
11038
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11039
 
  (exit $ac_status); }; } &&
11040
 
         { ac_try='test -s conftest$ac_exeext'
11041
 
  { (case "(($ac_try" in
11042
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11043
 
  *) ac_try_echo=$ac_try;;
11044
 
esac
11045
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11046
 
  (eval "$ac_try") 2>&5
11047
 
  ac_status=$?
11048
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11049
 
  (exit $ac_status); }; }; then
 
10325
  (exit $ac_status); } && {
 
10326
         test -z "$ac_c_werror_flag" ||
 
10327
         test ! -s conftest.err
 
10328
       } && test -s conftest$ac_exeext &&
 
10329
       $as_test_x conftest$ac_exeext; then
11050
10330
  ac_cv_lib_m_pow=yes
11051
10331
else
11052
10332
  echo "$as_me: failed program was:" >&5
11055
10335
        ac_cv_lib_m_pow=no
11056
10336
fi
11057
10337
 
11058
 
rm -f core conftest.err conftest.$ac_objext \
 
10338
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11059
10339
      conftest$ac_exeext conftest.$ac_ext
11060
10340
LIBS=$ac_check_lib_save_LIBS
11061
10341
fi
11155
10435
  rm -f conftest.er1
11156
10436
  cat conftest.err >&5
11157
10437
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11158
 
  (exit $ac_status); } &&
11159
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11160
 
  { (case "(($ac_try" in
11161
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11162
 
  *) ac_try_echo=$ac_try;;
11163
 
esac
11164
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11165
 
  (eval "$ac_try") 2>&5
11166
 
  ac_status=$?
11167
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11168
 
  (exit $ac_status); }; } &&
11169
 
         { ac_try='test -s conftest$ac_exeext'
11170
 
  { (case "(($ac_try" in
11171
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11172
 
  *) ac_try_echo=$ac_try;;
11173
 
esac
11174
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11175
 
  (eval "$ac_try") 2>&5
11176
 
  ac_status=$?
11177
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11178
 
  (exit $ac_status); }; }; then
 
10438
  (exit $ac_status); } && {
 
10439
         test -z "$ac_c_werror_flag" ||
 
10440
         test ! -s conftest.err
 
10441
       } && test -s conftest$ac_exeext &&
 
10442
       $as_test_x conftest$ac_exeext; then
11179
10443
  eval "$as_ac_var=yes"
11180
10444
else
11181
10445
  echo "$as_me: failed program was:" >&5
11184
10448
        eval "$as_ac_var=no"
11185
10449
fi
11186
10450
 
11187
 
rm -f core conftest.err conftest.$ac_objext \
 
10451
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11188
10452
      conftest$ac_exeext conftest.$ac_ext
11189
10453
fi
11190
10454
ac_res=`eval echo '${'$as_ac_var'}'`
11279
10543
  rm -f conftest.er1
11280
10544
  cat conftest.err >&5
11281
10545
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11282
 
  (exit $ac_status); } &&
11283
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11284
 
  { (case "(($ac_try" in
11285
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11286
 
  *) ac_try_echo=$ac_try;;
11287
 
esac
11288
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11289
 
  (eval "$ac_try") 2>&5
11290
 
  ac_status=$?
11291
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11292
 
  (exit $ac_status); }; } &&
11293
 
         { ac_try='test -s conftest$ac_exeext'
11294
 
  { (case "(($ac_try" in
11295
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11296
 
  *) ac_try_echo=$ac_try;;
11297
 
esac
11298
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11299
 
  (eval "$ac_try") 2>&5
11300
 
  ac_status=$?
11301
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11302
 
  (exit $ac_status); }; }; then
11303
 
  eval "$as_ac_var=yes"
11304
 
else
11305
 
  echo "$as_me: failed program was:" >&5
11306
 
sed 's/^/| /' conftest.$ac_ext >&5
11307
 
 
11308
 
        eval "$as_ac_var=no"
11309
 
fi
11310
 
 
11311
 
rm -f core conftest.err conftest.$ac_objext \
 
10546
  (exit $ac_status); } && {
 
10547
         test -z "$ac_c_werror_flag" ||
 
10548
         test ! -s conftest.err
 
10549
       } && test -s conftest$ac_exeext &&
 
10550
       $as_test_x conftest$ac_exeext; then
 
10551
  eval "$as_ac_var=yes"
 
10552
else
 
10553
  echo "$as_me: failed program was:" >&5
 
10554
sed 's/^/| /' conftest.$ac_ext >&5
 
10555
 
 
10556
        eval "$as_ac_var=no"
 
10557
fi
 
10558
 
 
10559
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
 
10560
      conftest$ac_exeext conftest.$ac_ext
 
10561
fi
 
10562
ac_res=`eval echo '${'$as_ac_var'}'`
 
10563
               { echo "$as_me:$LINENO: result: $ac_res" >&5
 
10564
echo "${ECHO_T}$ac_res" >&6; }
 
10565
if test `eval echo '${'$as_ac_var'}'` = yes; then
 
10566
  cat >>confdefs.h <<_ACEOF
 
10567
#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
 
10568
_ACEOF
 
10569
 
 
10570
fi
 
10571
done
 
10572
 
 
10573
 
 
10574
 
 
10575
 
 
10576
 
 
10577
 
 
10578
 
 
10579
 
 
10580
 
 
10581
 
 
10582
 
 
10583
 
 
10584
 
 
10585
 
 
10586
 
 
10587
 
 
10588
for ac_func in expf logf sqrtf cosf sinf tanf sinhf coshf tanhf \
 
10589
                floorf ceilf fabsf frexpf ldexpf
 
10590
do
 
10591
as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
 
10592
{ echo "$as_me:$LINENO: checking for $ac_func" >&5
 
10593
echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
 
10594
if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
 
10595
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10596
else
 
10597
  cat >conftest.$ac_ext <<_ACEOF
 
10598
/* confdefs.h.  */
 
10599
_ACEOF
 
10600
cat confdefs.h >>conftest.$ac_ext
 
10601
cat >>conftest.$ac_ext <<_ACEOF
 
10602
/* end confdefs.h.  */
 
10603
/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
 
10604
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 
10605
#define $ac_func innocuous_$ac_func
 
10606
 
 
10607
/* System header to define __stub macros and hopefully few prototypes,
 
10608
    which can conflict with char $ac_func (); below.
 
10609
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
10610
    <limits.h> exists even on freestanding compilers.  */
 
10611
 
 
10612
#ifdef __STDC__
 
10613
# include <limits.h>
 
10614
#else
 
10615
# include <assert.h>
 
10616
#endif
 
10617
 
 
10618
#undef $ac_func
 
10619
 
 
10620
/* Override any GCC internal prototype to avoid an error.
 
10621
   Use char because int might match the return type of a GCC
 
10622
   builtin and then its argument prototype would still apply.  */
 
10623
#ifdef __cplusplus
 
10624
extern "C"
 
10625
#endif
 
10626
char $ac_func ();
 
10627
/* The GNU C library defines this for functions which it implements
 
10628
    to always fail with ENOSYS.  Some functions are actually named
 
10629
    something starting with __ and the normal name is an alias.  */
 
10630
#if defined __stub_$ac_func || defined __stub___$ac_func
 
10631
choke me
 
10632
#endif
 
10633
 
 
10634
int
 
10635
main ()
 
10636
{
 
10637
return $ac_func ();
 
10638
  ;
 
10639
  return 0;
 
10640
}
 
10641
_ACEOF
 
10642
rm -f conftest.$ac_objext conftest$ac_exeext
 
10643
if { (ac_try="$ac_link"
 
10644
case "(($ac_try" in
 
10645
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
10646
  *) ac_try_echo=$ac_try;;
 
10647
esac
 
10648
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
10649
  (eval "$ac_link") 2>conftest.er1
 
10650
  ac_status=$?
 
10651
  grep -v '^ *+' conftest.er1 >conftest.err
 
10652
  rm -f conftest.er1
 
10653
  cat conftest.err >&5
 
10654
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10655
  (exit $ac_status); } && {
 
10656
         test -z "$ac_c_werror_flag" ||
 
10657
         test ! -s conftest.err
 
10658
       } && test -s conftest$ac_exeext &&
 
10659
       $as_test_x conftest$ac_exeext; then
 
10660
  eval "$as_ac_var=yes"
 
10661
else
 
10662
  echo "$as_me: failed program was:" >&5
 
10663
sed 's/^/| /' conftest.$ac_ext >&5
 
10664
 
 
10665
        eval "$as_ac_var=no"
 
10666
fi
 
10667
 
 
10668
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11312
10669
      conftest$ac_exeext conftest.$ac_ext
11313
10670
fi
11314
10671
ac_res=`eval echo '${'$as_ac_var'}'`
11442
10799
 
11443
10800
fi
11444
10801
 
 
10802
if test "${enable_hpack}" = "yes"; then
 
10803
 
 
10804
cat >>confdefs.h <<\_ACEOF
 
10805
#define ECL_RELATIVE_PACKAGE_NAMES 1
 
10806
_ACEOF
 
10807
 
 
10808
fi
 
10809
 
11445
10810
 
11446
10811
case "${enable_boehm}" in
11447
10812
  included)
11496
10861
  rm -f conftest.er1
11497
10862
  cat conftest.err >&5
11498
10863
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11499
 
  (exit $ac_status); } &&
11500
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11501
 
  { (case "(($ac_try" in
11502
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11503
 
  *) ac_try_echo=$ac_try;;
11504
 
esac
11505
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11506
 
  (eval "$ac_try") 2>&5
11507
 
  ac_status=$?
11508
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11509
 
  (exit $ac_status); }; } &&
11510
 
         { ac_try='test -s conftest.$ac_objext'
11511
 
  { (case "(($ac_try" in
11512
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11513
 
  *) ac_try_echo=$ac_try;;
11514
 
esac
11515
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11516
 
  (eval "$ac_try") 2>&5
11517
 
  ac_status=$?
11518
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11519
 
  (exit $ac_status); }; }; then
 
10864
  (exit $ac_status); } && {
 
10865
         test -z "$ac_c_werror_flag" ||
 
10866
         test ! -s conftest.err
 
10867
       } && test -s conftest.$ac_objext; then
11520
10868
  ac_header_compiler=yes
11521
10869
else
11522
10870
  echo "$as_me: failed program was:" >&5
11552
10900
  rm -f conftest.er1
11553
10901
  cat conftest.err >&5
11554
10902
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11555
 
  (exit $ac_status); } >/dev/null; then
11556
 
  if test -s conftest.err; then
11557
 
    ac_cpp_err=$ac_c_preproc_warn_flag
11558
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11559
 
  else
11560
 
    ac_cpp_err=
11561
 
  fi
11562
 
else
11563
 
  ac_cpp_err=yes
11564
 
fi
11565
 
if test -z "$ac_cpp_err"; then
 
10903
  (exit $ac_status); } >/dev/null && {
 
10904
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
10905
         test ! -s conftest.err
 
10906
       }; then
11566
10907
  ac_header_preproc=yes
11567
10908
else
11568
10909
  echo "$as_me: failed program was:" >&5
11651
10992
  rm -f conftest.er1
11652
10993
  cat conftest.err >&5
11653
10994
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11654
 
  (exit $ac_status); } &&
11655
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11656
 
  { (case "(($ac_try" in
11657
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11658
 
  *) ac_try_echo=$ac_try;;
11659
 
esac
11660
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11661
 
  (eval "$ac_try") 2>&5
11662
 
  ac_status=$?
11663
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11664
 
  (exit $ac_status); }; } &&
11665
 
         { ac_try='test -s conftest.$ac_objext'
11666
 
  { (case "(($ac_try" in
11667
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11668
 
  *) ac_try_echo=$ac_try;;
11669
 
esac
11670
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11671
 
  (eval "$ac_try") 2>&5
11672
 
  ac_status=$?
11673
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11674
 
  (exit $ac_status); }; }; then
 
10995
  (exit $ac_status); } && {
 
10996
         test -z "$ac_c_werror_flag" ||
 
10997
         test ! -s conftest.err
 
10998
       } && test -s conftest.$ac_objext; then
11675
10999
  ac_header_compiler=yes
11676
11000
else
11677
11001
  echo "$as_me: failed program was:" >&5
11707
11031
  rm -f conftest.er1
11708
11032
  cat conftest.err >&5
11709
11033
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11710
 
  (exit $ac_status); } >/dev/null; then
11711
 
  if test -s conftest.err; then
11712
 
    ac_cpp_err=$ac_c_preproc_warn_flag
11713
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11714
 
  else
11715
 
    ac_cpp_err=
11716
 
  fi
11717
 
else
11718
 
  ac_cpp_err=yes
11719
 
fi
11720
 
if test -z "$ac_cpp_err"; then
 
11034
  (exit $ac_status); } >/dev/null && {
 
11035
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
11036
         test ! -s conftest.err
 
11037
       }; then
11721
11038
  ac_header_preproc=yes
11722
11039
else
11723
11040
  echo "$as_me: failed program was:" >&5
11809
11126
    fi
11810
11127
    if mkdir gmp; then
11811
11128
     ECL_GMP_HEADER='ecl/gmp.h'
11812
 
     (destdir=`${PWDCMD}`; cd gmp; CC="${CC} ${PICFLAG}" \
 
11129
          (destdir=`${PWDCMD}`; cd gmp; CC="${CC} ${PICFLAG}" \
11813
11130
       $srcdir/gmp/configure --disable-shared --prefix=${destdir} \
11814
 
        --infodir=${destdir}/doc --includedir=${destdir}/ecl \
 
11131
        --infodir=${destdir}/doc --includedir=${destdir}/ecl --with-pic \
11815
11132
        --libdir=${destdir} --build=${gmp_build} --host=${host_alias} $with_gmp)
11816
11133
    fi
11817
11134
  fi
11942
11259
## M4sh Initialization.  ##
11943
11260
## --------------------- ##
11944
11261
 
11945
 
# Be Bourne compatible
 
11262
# Be more Bourne compatible
 
11263
DUALCASE=1; export DUALCASE # for MKS sh
11946
11264
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11947
11265
  emulate sh
11948
11266
  NULLCMD=:
11951
11269
  alias -g '${1+"$@"}'='"$@"'
11952
11270
  setopt NO_GLOB_SUBST
11953
11271
else
11954
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
11272
  case `(set -o) 2>/dev/null` in
 
11273
  *posix*) set -o posix ;;
 
11274
esac
 
11275
 
11955
11276
fi
11956
 
BIN_SH=xpg4; export BIN_SH # for Tru64
11957
 
DUALCASE=1; export DUALCASE # for MKS sh
 
11277
 
 
11278
 
11958
11279
 
11959
11280
 
11960
11281
# PATH needs CR
12178
11499
  as_mkdir_p=false
12179
11500
fi
12180
11501
 
12181
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
12182
 
# systems may use methods other than mode bits to determine executability.
12183
 
cat >conf$$.file <<_ASEOF
12184
 
#! /bin/sh
12185
 
exit 0
12186
 
_ASEOF
12187
 
chmod +x conf$$.file
12188
 
if test -x conf$$.file >/dev/null 2>&1; then
12189
 
  as_executable_p="test -x"
 
11502
if test -x / >/dev/null 2>&1; then
 
11503
  as_test_x='test -x'
12190
11504
else
12191
 
  as_executable_p=:
 
11505
  if ls -dL / >/dev/null 2>&1; then
 
11506
    as_ls_L_option=L
 
11507
  else
 
11508
    as_ls_L_option=
 
11509
  fi
 
11510
  as_test_x='
 
11511
    eval sh -c '\''
 
11512
      if test -d "$1"; then
 
11513
        test -d "$1/.";
 
11514
      else
 
11515
        case $1 in
 
11516
        -*)set "./$1";;
 
11517
        esac;
 
11518
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
11519
        ???[sx]*):;;*)false;;esac;fi
 
11520
    '\'' sh
 
11521
  '
12192
11522
fi
12193
 
rm -f conf$$.file
 
11523
as_executable_p=$as_test_x
12194
11524
 
12195
11525
# Sed expression to map a string onto a valid CPP name.
12196
11526
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12206
11536
# values after options handling.
12207
11537
ac_log="
12208
11538
This file was extended by ecl $as_me 0.9i, which was
12209
 
generated by GNU Autoconf 2.60.  Invocation command line was
 
11539
generated by GNU Autoconf 2.61.  Invocation command line was
12210
11540
 
12211
11541
  CONFIG_FILES    = $CONFIG_FILES
12212
11542
  CONFIG_HEADERS  = $CONFIG_HEADERS
12234
11564
Usage: $0 [OPTIONS] [FILE]...
12235
11565
 
12236
11566
  -h, --help       print this help, then exit
12237
 
  -V, --version    print version number, then exit
 
11567
  -V, --version    print version number and configuration settings, then exit
12238
11568
  -q, --quiet      do not print progress messages
12239
11569
  -d, --debug      don't remove temporary files
12240
11570
      --recheck    update $as_me by reconfiguring in the same conditions
12255
11585
cat >>$CONFIG_STATUS <<_ACEOF
12256
11586
ac_cs_version="\\
12257
11587
ecl config.status 0.9i
12258
 
configured by $0, generated by GNU Autoconf 2.60,
 
11588
configured by $0, generated by GNU Autoconf 2.61,
12259
11589
  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
12260
11590
 
12261
11591
Copyright (C) 2006 Free Software Foundation, Inc.