~ubuntu-branches/ubuntu/quantal/libgc/quantal

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Egger
  • Date: 2011-02-19 12:19:56 UTC
  • mfrom: (1.3.2 upstream) (0.1.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20110219121956-67rb69xlt5nud3v2
Tags: 1:7.1-5
Upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
 
# From configure.in Revision: 1.2 .
 
2
# From configure.ac Revision: 1.35 .
3
3
# Guess values for system-dependent variables and create Makefiles.
4
 
# Generated by GNU Autoconf 2.60a for gc 6.8.
 
4
# Generated by GNU Autoconf 2.61 for gc 7.1.
5
5
#
6
6
# Report bugs to <Hans.Boehm@hp.com>.
7
7
#
13
13
## M4sh Initialization.  ##
14
14
## --------------------- ##
15
15
 
16
 
# Be Bourne compatible
 
16
# Be more Bourne compatible
 
17
DUALCASE=1; export DUALCASE # for MKS sh
17
18
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
18
19
  emulate sh
19
20
  NULLCMD=:
22
23
  alias -g '${1+"$@"}'='"$@"'
23
24
  setopt NO_GLOB_SUBST
24
25
else
25
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
26
  case `(set -o) 2>/dev/null` in
 
27
  *posix*) set -o posix ;;
 
28
esac
 
29
 
26
30
fi
27
 
BIN_SH=xpg4; export BIN_SH # for Tru64
28
 
DUALCASE=1; export DUALCASE # for MKS sh
 
31
 
 
32
 
29
33
 
30
34
 
31
35
# PATH needs CR
218
222
else
219
223
  as_candidate_shells=
220
224
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
221
 
for as_dir in /usr/bin/posix$PATH_SEPARATOR/bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 
225
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
222
226
do
223
227
  IFS=$as_save_IFS
224
228
  test -z "$as_dir" && as_dir=.
236
240
         # Try only shells that exist, to save several forks.
237
241
         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
238
242
                { ("$as_shell") 2> /dev/null <<\_ASEOF
239
 
# Be Bourne compatible
240
243
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
241
244
  emulate sh
242
245
  NULLCMD=:
245
248
  alias -g '${1+"$@"}'='"$@"'
246
249
  setopt NO_GLOB_SUBST
247
250
else
248
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
251
  case `(set -o) 2>/dev/null` in
 
252
  *posix*) set -o posix ;;
 
253
esac
 
254
 
249
255
fi
250
 
BIN_SH=xpg4; export BIN_SH # for Tru64
251
 
DUALCASE=1; export DUALCASE # for MKS sh
 
256
 
252
257
 
253
258
:
254
259
_ASEOF
256
261
  CONFIG_SHELL=$as_shell
257
262
               as_have_required=yes
258
263
               if { "$as_shell" 2> /dev/null <<\_ASEOF
259
 
# Be Bourne compatible
260
264
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
261
265
  emulate sh
262
266
  NULLCMD=:
265
269
  alias -g '${1+"$@"}'='"$@"'
266
270
  setopt NO_GLOB_SUBST
267
271
else
268
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
272
  case `(set -o) 2>/dev/null` in
 
273
  *posix*) set -o posix ;;
 
274
esac
 
275
 
269
276
fi
270
 
BIN_SH=xpg4; export BIN_SH # for Tru64
271
 
DUALCASE=1; export DUALCASE # for MKS sh
 
277
 
272
278
 
273
279
:
274
280
(as_func_return () {
515
521
  as_mkdir_p=false
516
522
fi
517
523
 
518
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
519
 
# systems may use methods other than mode bits to determine executability.
520
 
cat >conf$$.file <<_ASEOF
521
 
#! /bin/sh
522
 
exit 0
523
 
_ASEOF
524
 
chmod +x conf$$.file
525
 
if test -x conf$$.file >/dev/null 2>&1; then
526
 
  as_executable_p="test -x"
 
524
if test -x / >/dev/null 2>&1; then
 
525
  as_test_x='test -x'
527
526
else
528
 
  as_executable_p=:
 
527
  if ls -dL / >/dev/null 2>&1; then
 
528
    as_ls_L_option=L
 
529
  else
 
530
    as_ls_L_option=
 
531
  fi
 
532
  as_test_x='
 
533
    eval sh -c '\''
 
534
      if test -d "$1"; then
 
535
        test -d "$1/.";
 
536
      else
 
537
        case $1 in
 
538
        -*)set "./$1";;
 
539
        esac;
 
540
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
541
        ???[sx]*):;;*)false;;esac;fi
 
542
    '\'' sh
 
543
  '
529
544
fi
530
 
rm -f conf$$.file
 
545
as_executable_p=$as_test_x
531
546
 
532
547
# Sed expression to map a string onto a valid CPP name.
533
548
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
714
729
# Identity of this package.
715
730
PACKAGE_NAME='gc'
716
731
PACKAGE_TARNAME='gc'
717
 
PACKAGE_VERSION='6.8'
718
 
PACKAGE_STRING='gc 6.8'
 
732
PACKAGE_VERSION='7.1'
 
733
PACKAGE_STRING='gc 7.1'
719
734
PACKAGE_BUGREPORT='Hans.Boehm@hp.com'
720
735
 
721
736
ac_unique_file="gcj_mlc.c"
825
840
AMTAR
826
841
am__tar
827
842
am__untar
 
843
MAINTAINER_MODE_TRUE
 
844
MAINTAINER_MODE_FALSE
 
845
MAINT
828
846
GC_VERSION
829
847
CC
830
848
CFLAGS
852
870
CCASFLAGS
853
871
AR
854
872
RANLIB
855
 
MAINTAINER_MODE_TRUE
856
 
MAINTAINER_MODE_FALSE
857
 
MAINT
858
873
GC_CFLAGS
859
874
THREADDLLIBS
860
 
POWERPC_DARWIN_TRUE
861
 
POWERPC_DARWIN_FALSE
 
875
THREADS_TRUE
 
876
THREADS_FALSE
 
877
PTHREADS_TRUE
 
878
PTHREADS_FALSE
 
879
DARWIN_THREADS_TRUE
 
880
DARWIN_THREADS_FALSE
 
881
WIN32_THREADS_TRUE
 
882
WIN32_THREADS_FALSE
862
883
COMPILER_XLC_TRUE
863
884
COMPILER_XLC_FALSE
 
885
AVOID_CPP_LIB_TRUE
 
886
AVOID_CPP_LIB_FALSE
 
887
extra_ldflags_libgc
864
888
EXTRA_TEST_LIBS
865
889
target_all
866
890
CPLUSPLUS_TRUE
868
892
INCLUDES
869
893
CXXINCLUDES
870
894
addobjs
871
 
addincludes
872
895
addlibs
873
 
addtests
874
896
GREP
875
897
EGREP
876
898
LN_S
881
903
FFLAGS
882
904
ac_ct_F77
883
905
LIBTOOL
884
 
MY_CFLAGS
 
906
ENABLE_GCJ_SUPPORT_TRUE
 
907
ENABLE_GCJ_SUPPORT_FALSE
885
908
UNWINDLIBS
886
909
USE_LIBDIR_TRUE
887
910
USE_LIBDIR_FALSE
 
911
subdirs
 
912
USE_INTERNAL_LIBATOMIC_OPS_TRUE
 
913
USE_INTERNAL_LIBATOMIC_OPS_FALSE
 
914
NEED_ATOMIC_OPS_ASM_TRUE
 
915
NEED_ATOMIC_OPS_ASM_FALSE
 
916
atomic_ops_libs
888
917
LIBOBJS
889
918
LTLIBOBJS'
890
919
ac_subst_files=''
894
923
CC
895
924
CFLAGS
896
925
LDFLAGS
 
926
LIBS
897
927
CPPFLAGS
898
928
CXX
899
929
CXXFLAGS
904
934
CXXCPP
905
935
F77
906
936
FFLAGS'
907
 
 
 
937
ac_subdirs_all='libatomic_ops'
908
938
 
909
939
# Initialize some variables set by options.
910
940
ac_init_help=
1009
1039
  -disable-* | --disable-*)
1010
1040
    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
1011
1041
    # Reject names that are not valid shell variable names.
1012
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1042
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1013
1043
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
1014
1044
   { (exit 1); exit 1; }; }
1015
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
1045
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
1016
1046
    eval enable_$ac_feature=no ;;
1017
1047
 
1018
1048
  -docdir | --docdir | --docdi | --doc | --do)
1028
1058
  -enable-* | --enable-*)
1029
1059
    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
1030
1060
    # Reject names that are not valid shell variable names.
1031
 
    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1061
    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1032
1062
      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
1033
1063
   { (exit 1); exit 1; }; }
1034
 
    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 
1064
    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
1035
1065
    eval enable_$ac_feature=\$ac_optarg ;;
1036
1066
 
1037
1067
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
1225
1255
  -with-* | --with-*)
1226
1256
    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1227
1257
    # Reject names that are not valid shell variable names.
1228
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1258
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1229
1259
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1230
1260
   { (exit 1); exit 1; }; }
1231
 
    ac_package=`echo $ac_package| sed 's/-/_/g'`
 
1261
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1232
1262
    eval with_$ac_package=\$ac_optarg ;;
1233
1263
 
1234
1264
  -without-* | --without-*)
1235
1265
    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1236
1266
    # Reject names that are not valid shell variable names.
1237
 
    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 
1267
    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1238
1268
      { echo "$as_me: error: invalid package name: $ac_package" >&2
1239
1269
   { (exit 1); exit 1; }; }
1240
 
    ac_package=`echo $ac_package | sed 's/-/_/g'`
 
1270
    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1241
1271
    eval with_$ac_package=no ;;
1242
1272
 
1243
1273
  --x)
1406
1436
  # Omit some internal or obsolete options to make the list less imposing.
1407
1437
  # This message is too long to be a string in the A/UX 3.1 sh.
1408
1438
  cat <<_ACEOF
1409
 
\`configure' configures gc 6.8 to adapt to many kinds of systems.
 
1439
\`configure' configures gc 7.1 to adapt to many kinds of systems.
1410
1440
 
1411
1441
Usage: $0 [OPTION]... [VAR=VALUE]...
1412
1442
 
1477
1507
 
1478
1508
if test -n "$ac_init_help"; then
1479
1509
  case $ac_init_help in
1480
 
     short | recursive ) echo "Configuration of gc 6.8:";;
 
1510
     short | recursive ) echo "Configuration of gc 7.1:";;
1481
1511
   esac
1482
1512
  cat <<\_ACEOF
1483
1513
 
1484
1514
Optional Features:
1485
1515
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1486
1516
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 
1517
  --enable-maintainer-mode  enable make rules and dependencies not useful
 
1518
                          (and sometimes confusing) to the casual installer
1487
1519
  --disable-dependency-tracking  speeds up one-time build
1488
1520
  --enable-dependency-tracking   do not reject slow dependency extractors
1489
 
  --enable-maintainer-mode  enable make rules and dependencies not useful
1490
 
                          (and sometimes confusing) to the casual installer
1491
1521
  --enable-threads=TYPE   choose threading package
1492
 
  --enable-parallel-mark        parallelize marking and free list construction
1493
 
  --enable-cplusplus            install C++ support
 
1522
  --enable-parallel-mark  parallelize marking and free list construction
 
1523
  --enable-cplusplus      install C++ support
1494
1524
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1495
1525
  --enable-static[=PKGS]  build static libraries [default=yes]
1496
1526
  --enable-fast-install[=PKGS]
1497
1527
                          optimize for fast installation [default=yes]
1498
1528
  --disable-libtool-lock  avoid locking (might break parallel builds)
1499
 
  --enable-full-debug   include full support for pointer backtracing etc.
1500
 
  --enable-redirect-malloc  redirect malloc and friends to GC routines
 
1529
  --disable-gcj-support   Disable support for gcj.
 
1530
  --disable-java-finalization
 
1531
                          Disable support for java finalization.
 
1532
  --disable-atomic-uncollectible
 
1533
                          Disable support for atomic uncollectible allocation.
 
1534
  --enable-redirect-malloc
 
1535
                          Redirect malloc and friends to GC routines
 
1536
  --enable-large-config   Optimize for large (> 100 MB) heap or root set
 
1537
  --enable-gc-debug       include full support for pointer backtracing etc.
1501
1538
  --enable-gc-assertions  collector-internal assertion checking
 
1539
  --enable-munmap=N       return page to the os if empty for N collections
1502
1540
 
1503
1541
Optional Packages:
1504
1542
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1517
1555
  CFLAGS      C compiler flags
1518
1556
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1519
1557
              nonstandard directory <lib dir>
 
1558
  LIBS        libraries to pass to the linker, e.g. -l<library>
1520
1559
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1521
1560
              you have headers in a nonstandard directory <include dir>
1522
1561
  CXX         C++ compiler command
1592
1631
test -n "$ac_init_help" && exit $ac_status
1593
1632
if $ac_init_version; then
1594
1633
  cat <<\_ACEOF
1595
 
gc configure 6.8
1596
 
generated by GNU Autoconf 2.60a
 
1634
gc configure 7.1
 
1635
generated by GNU Autoconf 2.61
1597
1636
 
1598
1637
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1599
1638
2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
1606
1645
This file contains any messages produced by compilers while
1607
1646
running configure, to aid debugging if configure makes a mistake.
1608
1647
 
1609
 
It was created by gc $as_me 6.8, which was
1610
 
generated by GNU Autoconf 2.60a.  Invocation command line was
 
1648
It was created by gc $as_me 7.1, which was
 
1649
generated by GNU Autoconf 2.61.  Invocation command line was
1611
1650
 
1612
1651
  $ $0 $@
1613
1652
 
2200
2239
    # by default.
2201
2240
    for ac_prog in ginstall scoinst install; do
2202
2241
      for ac_exec_ext in '' $ac_executable_extensions; do
2203
 
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; }; then
 
2242
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
2204
2243
          if test $ac_prog = install &&
2205
2244
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
2206
2245
            # AIX install.  It has an incompatible calling convention.
2366
2405
  IFS=$as_save_IFS
2367
2406
  test -z "$as_dir" && as_dir=.
2368
2407
  for ac_exec_ext in '' $ac_executable_extensions; do
2369
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2408
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2370
2409
    ac_cv_prog_AWK="$ac_prog"
2371
2410
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2372
2411
    break 2
2449
2488
 
2450
2489
# Define the identity of the package.
2451
2490
 PACKAGE='gc'
2452
 
 VERSION='6.8'
 
2491
 VERSION='7.1'
2453
2492
 
2454
2493
 
2455
2494
cat >>confdefs.h <<_ACEOF
2501
2540
  IFS=$as_save_IFS
2502
2541
  test -z "$as_dir" && as_dir=.
2503
2542
  for ac_exec_ext in '' $ac_executable_extensions; do
2504
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2543
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2505
2544
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2506
2545
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2507
2546
    break 2
2541
2580
  IFS=$as_save_IFS
2542
2581
  test -z "$as_dir" && as_dir=.
2543
2582
  for ac_exec_ext in '' $ac_executable_extensions; do
2544
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2583
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2545
2584
    ac_cv_prog_ac_ct_STRIP="strip"
2546
2585
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2547
2586
    break 2
2595
2634
 
2596
2635
 
2597
2636
 
2598
 
 
 
2637
{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
 
2638
echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
 
2639
    # Check whether --enable-maintainer-mode was given.
 
2640
if test "${enable_maintainer_mode+set}" = set; then
 
2641
  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
 
2642
else
 
2643
  USE_MAINTAINER_MODE=no
 
2644
fi
 
2645
 
 
2646
  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
 
2647
echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
 
2648
 
 
2649
 
 
2650
if test $USE_MAINTAINER_MODE = yes; then
 
2651
  MAINTAINER_MODE_TRUE=
 
2652
  MAINTAINER_MODE_FALSE='#'
 
2653
else
 
2654
  MAINTAINER_MODE_TRUE='#'
 
2655
  MAINTAINER_MODE_FALSE=
 
2656
fi
 
2657
 
 
2658
  MAINT=$MAINTAINER_MODE_TRUE
 
2659
 
 
2660
 
 
2661
 
 
2662
 
 
2663
 
 
2664
 
 
2665
DEPDIR="${am__leading_dot}deps"
 
2666
 
 
2667
ac_config_commands="$ac_config_commands depfiles"
 
2668
 
 
2669
 
 
2670
am_make=${MAKE-make}
 
2671
cat > confinc << 'END'
 
2672
am__doit:
 
2673
        @echo done
 
2674
.PHONY: am__doit
 
2675
END
 
2676
# If we don't find an include directive, just comment out the code.
 
2677
{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
 
2678
echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
 
2679
am__include="#"
 
2680
am__quote=
 
2681
_am_result=none
 
2682
# First try GNU make style include.
 
2683
echo "include confinc" > confmf
 
2684
# We grep out `Entering directory' and `Leaving directory'
 
2685
# messages which can occur if `w' ends up in MAKEFLAGS.
 
2686
# In particular we don't look at `^make:' because GNU make might
 
2687
# be invoked under some other name (usually "gmake"), in which
 
2688
# case it prints its new name instead of `make'.
 
2689
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
 
2690
   am__include=include
 
2691
   am__quote=
 
2692
   _am_result=GNU
 
2693
fi
 
2694
# Now try BSD make style include.
 
2695
if test "$am__include" = "#"; then
 
2696
   echo '.include "confinc"' > confmf
 
2697
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
 
2698
      am__include=.include
 
2699
      am__quote="\""
 
2700
      _am_result=BSD
 
2701
   fi
 
2702
fi
 
2703
 
 
2704
 
 
2705
{ echo "$as_me:$LINENO: result: $_am_result" >&5
 
2706
echo "${ECHO_T}$_am_result" >&6; }
 
2707
rm -f confinc confmf
 
2708
 
 
2709
# Check whether --enable-dependency-tracking was given.
 
2710
if test "${enable_dependency_tracking+set}" = set; then
 
2711
  enableval=$enable_dependency_tracking;
 
2712
fi
 
2713
 
 
2714
if test "x$enable_dependency_tracking" != xno; then
 
2715
  am_depcomp="$ac_aux_dir/depcomp"
 
2716
  AMDEPBACKSLASH='\'
 
2717
fi
 
2718
 
 
2719
 
 
2720
if test "x$enable_dependency_tracking" != xno; then
 
2721
  AMDEP_TRUE=
 
2722
  AMDEP_FALSE='#'
 
2723
else
 
2724
  AMDEP_TRUE='#'
 
2725
  AMDEP_FALSE=
 
2726
fi
2599
2727
 
2600
2728
 
2601
2729
 
2621
2749
  IFS=$as_save_IFS
2622
2750
  test -z "$as_dir" && as_dir=.
2623
2751
  for ac_exec_ext in '' $ac_executable_extensions; do
2624
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2752
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2625
2753
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
2626
2754
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2627
2755
    break 2
2661
2789
  IFS=$as_save_IFS
2662
2790
  test -z "$as_dir" && as_dir=.
2663
2791
  for ac_exec_ext in '' $ac_executable_extensions; do
2664
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2792
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2665
2793
    ac_cv_prog_ac_ct_CC="gcc"
2666
2794
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2667
2795
    break 2
2718
2846
  IFS=$as_save_IFS
2719
2847
  test -z "$as_dir" && as_dir=.
2720
2848
  for ac_exec_ext in '' $ac_executable_extensions; do
2721
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2849
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2722
2850
    ac_cv_prog_CC="${ac_tool_prefix}cc"
2723
2851
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2724
2852
    break 2
2759
2887
  IFS=$as_save_IFS
2760
2888
  test -z "$as_dir" && as_dir=.
2761
2889
  for ac_exec_ext in '' $ac_executable_extensions; do
2762
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2890
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2763
2891
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2764
2892
       ac_prog_rejected=yes
2765
2893
       continue
2817
2945
  IFS=$as_save_IFS
2818
2946
  test -z "$as_dir" && as_dir=.
2819
2947
  for ac_exec_ext in '' $ac_executable_extensions; do
2820
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2948
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2821
2949
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2822
2950
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2823
2951
    break 2
2861
2989
  IFS=$as_save_IFS
2862
2990
  test -z "$as_dir" && as_dir=.
2863
2991
  for ac_exec_ext in '' $ac_executable_extensions; do
2864
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2992
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2865
2993
    ac_cv_prog_ac_ct_CC="$ac_prog"
2866
2994
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2867
2995
    break 2
3224
3352
  rm -f conftest.er1
3225
3353
  cat conftest.err >&5
3226
3354
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3227
 
  (exit $ac_status); } &&
3228
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3229
 
  { (case "(($ac_try" in
3230
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3231
 
  *) ac_try_echo=$ac_try;;
3232
 
esac
3233
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3234
 
  (eval "$ac_try") 2>&5
3235
 
  ac_status=$?
3236
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3237
 
  (exit $ac_status); }; } &&
3238
 
         { ac_try='test -s conftest.$ac_objext'
3239
 
  { (case "(($ac_try" in
3240
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3241
 
  *) ac_try_echo=$ac_try;;
3242
 
esac
3243
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3244
 
  (eval "$ac_try") 2>&5
3245
 
  ac_status=$?
3246
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3247
 
  (exit $ac_status); }; }; then
 
3355
  (exit $ac_status); } && {
 
3356
         test -z "$ac_c_werror_flag" ||
 
3357
         test ! -s conftest.err
 
3358
       } && test -s conftest.$ac_objext; then
3248
3359
  ac_compiler_gnu=yes
3249
3360
else
3250
3361
  echo "$as_me: failed program was:" >&5
3299
3410
  rm -f conftest.er1
3300
3411
  cat conftest.err >&5
3301
3412
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3302
 
  (exit $ac_status); } &&
3303
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3304
 
  { (case "(($ac_try" in
3305
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3306
 
  *) ac_try_echo=$ac_try;;
3307
 
esac
3308
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3309
 
  (eval "$ac_try") 2>&5
3310
 
  ac_status=$?
3311
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3312
 
  (exit $ac_status); }; } &&
3313
 
         { ac_try='test -s conftest.$ac_objext'
3314
 
  { (case "(($ac_try" in
3315
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3316
 
  *) ac_try_echo=$ac_try;;
3317
 
esac
3318
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3319
 
  (eval "$ac_try") 2>&5
3320
 
  ac_status=$?
3321
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3322
 
  (exit $ac_status); }; }; then
 
3413
  (exit $ac_status); } && {
 
3414
         test -z "$ac_c_werror_flag" ||
 
3415
         test ! -s conftest.err
 
3416
       } && test -s conftest.$ac_objext; then
3323
3417
  ac_cv_prog_cc_g=yes
3324
3418
else
3325
3419
  echo "$as_me: failed program was:" >&5
3354
3448
  rm -f conftest.er1
3355
3449
  cat conftest.err >&5
3356
3450
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3357
 
  (exit $ac_status); } &&
3358
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3359
 
  { (case "(($ac_try" in
3360
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3361
 
  *) ac_try_echo=$ac_try;;
3362
 
esac
3363
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3364
 
  (eval "$ac_try") 2>&5
3365
 
  ac_status=$?
3366
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3367
 
  (exit $ac_status); }; } &&
3368
 
         { ac_try='test -s conftest.$ac_objext'
3369
 
  { (case "(($ac_try" in
3370
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3371
 
  *) ac_try_echo=$ac_try;;
3372
 
esac
3373
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3374
 
  (eval "$ac_try") 2>&5
3375
 
  ac_status=$?
3376
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3377
 
  (exit $ac_status); }; }; then
 
3451
  (exit $ac_status); } && {
 
3452
         test -z "$ac_c_werror_flag" ||
 
3453
         test ! -s conftest.err
 
3454
       } && test -s conftest.$ac_objext; then
3378
3455
  :
3379
3456
else
3380
3457
  echo "$as_me: failed program was:" >&5
3410
3487
  rm -f conftest.er1
3411
3488
  cat conftest.err >&5
3412
3489
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413
 
  (exit $ac_status); } &&
3414
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3415
 
  { (case "(($ac_try" in
3416
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3417
 
  *) ac_try_echo=$ac_try;;
3418
 
esac
3419
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3420
 
  (eval "$ac_try") 2>&5
3421
 
  ac_status=$?
3422
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3423
 
  (exit $ac_status); }; } &&
3424
 
         { ac_try='test -s conftest.$ac_objext'
3425
 
  { (case "(($ac_try" in
3426
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3427
 
  *) ac_try_echo=$ac_try;;
3428
 
esac
3429
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3430
 
  (eval "$ac_try") 2>&5
3431
 
  ac_status=$?
3432
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3433
 
  (exit $ac_status); }; }; then
 
3490
  (exit $ac_status); } && {
 
3491
         test -z "$ac_c_werror_flag" ||
 
3492
         test ! -s conftest.err
 
3493
       } && test -s conftest.$ac_objext; then
3434
3494
  ac_cv_prog_cc_g=yes
3435
3495
else
3436
3496
  echo "$as_me: failed program was:" >&5
3546
3606
  rm -f conftest.er1
3547
3607
  cat conftest.err >&5
3548
3608
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3549
 
  (exit $ac_status); } &&
3550
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
3551
 
  { (case "(($ac_try" in
3552
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3553
 
  *) ac_try_echo=$ac_try;;
3554
 
esac
3555
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3556
 
  (eval "$ac_try") 2>&5
3557
 
  ac_status=$?
3558
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3559
 
  (exit $ac_status); }; } &&
3560
 
         { ac_try='test -s conftest.$ac_objext'
3561
 
  { (case "(($ac_try" in
3562
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3563
 
  *) ac_try_echo=$ac_try;;
3564
 
esac
3565
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3566
 
  (eval "$ac_try") 2>&5
3567
 
  ac_status=$?
3568
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3569
 
  (exit $ac_status); }; }; then
 
3609
  (exit $ac_status); } && {
 
3610
         test -z "$ac_c_werror_flag" ||
 
3611
         test ! -s conftest.err
 
3612
       } && test -s conftest.$ac_objext; then
3570
3613
  ac_cv_prog_cc_c89=$ac_arg
3571
3614
else
3572
3615
  echo "$as_me: failed program was:" >&5
3602
3645
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3603
3646
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3604
3647
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3605
 
DEPDIR="${am__leading_dot}deps"
3606
 
 
3607
 
ac_config_commands="$ac_config_commands depfiles"
3608
 
 
3609
 
 
3610
 
am_make=${MAKE-make}
3611
 
cat > confinc << 'END'
3612
 
am__doit:
3613
 
        @echo done
3614
 
.PHONY: am__doit
3615
 
END
3616
 
# If we don't find an include directive, just comment out the code.
3617
 
{ echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3618
 
echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6; }
3619
 
am__include="#"
3620
 
am__quote=
3621
 
_am_result=none
3622
 
# First try GNU make style include.
3623
 
echo "include confinc" > confmf
3624
 
# We grep out `Entering directory' and `Leaving directory'
3625
 
# messages which can occur if `w' ends up in MAKEFLAGS.
3626
 
# In particular we don't look at `^make:' because GNU make might
3627
 
# be invoked under some other name (usually "gmake"), in which
3628
 
# case it prints its new name instead of `make'.
3629
 
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3630
 
   am__include=include
3631
 
   am__quote=
3632
 
   _am_result=GNU
3633
 
fi
3634
 
# Now try BSD make style include.
3635
 
if test "$am__include" = "#"; then
3636
 
   echo '.include "confinc"' > confmf
3637
 
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3638
 
      am__include=.include
3639
 
      am__quote="\""
3640
 
      _am_result=BSD
3641
 
   fi
3642
 
fi
3643
 
 
3644
 
 
3645
 
{ echo "$as_me:$LINENO: result: $_am_result" >&5
3646
 
echo "${ECHO_T}$_am_result" >&6; }
3647
 
rm -f confinc confmf
3648
 
 
3649
 
# Check whether --enable-dependency-tracking was given.
3650
 
if test "${enable_dependency_tracking+set}" = set; then
3651
 
  enableval=$enable_dependency_tracking;
3652
 
fi
3653
 
 
3654
 
if test "x$enable_dependency_tracking" != xno; then
3655
 
  am_depcomp="$ac_aux_dir/depcomp"
3656
 
  AMDEPBACKSLASH='\'
3657
 
fi
3658
 
 
3659
 
 
3660
 
if test "x$enable_dependency_tracking" != xno; then
3661
 
  AMDEP_TRUE=
3662
 
  AMDEP_FALSE='#'
3663
 
else
3664
 
  AMDEP_TRUE='#'
3665
 
  AMDEP_FALSE=
3666
 
fi
3667
 
 
3668
 
 
3669
 
 
3670
3648
 
3671
3649
depcc="$CC"   am_compiler_list=
3672
3650
 
3777
3755
fi
3778
3756
 
3779
3757
 
 
3758
if test "x$CC" != xcc; then
 
3759
  { echo "$as_me:$LINENO: checking whether $CC and cc understand -c and -o together" >&5
 
3760
echo $ECHO_N "checking whether $CC and cc understand -c and -o together... $ECHO_C" >&6; }
 
3761
else
 
3762
  { echo "$as_me:$LINENO: checking whether cc understands -c and -o together" >&5
 
3763
echo $ECHO_N "checking whether cc understands -c and -o together... $ECHO_C" >&6; }
 
3764
fi
 
3765
set dummy $CC; ac_cc=`echo $2 |
 
3766
                      sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
 
3767
if { as_var=ac_cv_prog_cc_${ac_cc}_c_o; eval "test \"\${$as_var+set}\" = set"; }; then
 
3768
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3769
else
 
3770
  cat >conftest.$ac_ext <<_ACEOF
 
3771
/* confdefs.h.  */
 
3772
_ACEOF
 
3773
cat confdefs.h >>conftest.$ac_ext
 
3774
cat >>conftest.$ac_ext <<_ACEOF
 
3775
/* end confdefs.h.  */
 
3776
 
 
3777
int
 
3778
main ()
 
3779
{
 
3780
 
 
3781
  ;
 
3782
  return 0;
 
3783
}
 
3784
_ACEOF
 
3785
# Make sure it works both with $CC and with simple cc.
 
3786
# We do the test twice because some compilers refuse to overwrite an
 
3787
# existing .o file with -o, though they will create one.
 
3788
ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
 
3789
rm -f conftest2.*
 
3790
if { (case "(($ac_try" in
 
3791
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3792
  *) ac_try_echo=$ac_try;;
 
3793
esac
 
3794
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3795
  (eval "$ac_try") 2>&5
 
3796
  ac_status=$?
 
3797
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3798
  (exit $ac_status); } &&
 
3799
   test -f conftest2.$ac_objext && { (case "(($ac_try" in
 
3800
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3801
  *) ac_try_echo=$ac_try;;
 
3802
esac
 
3803
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3804
  (eval "$ac_try") 2>&5
 
3805
  ac_status=$?
 
3806
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3807
  (exit $ac_status); };
 
3808
then
 
3809
  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
 
3810
  if test "x$CC" != xcc; then
 
3811
    # Test first that cc exists at all.
 
3812
    if { ac_try='cc -c conftest.$ac_ext >&5'
 
3813
  { (case "(($ac_try" in
 
3814
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3815
  *) ac_try_echo=$ac_try;;
 
3816
esac
 
3817
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3818
  (eval "$ac_try") 2>&5
 
3819
  ac_status=$?
 
3820
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3821
  (exit $ac_status); }; }; then
 
3822
      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
 
3823
      rm -f conftest2.*
 
3824
      if { (case "(($ac_try" in
 
3825
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3826
  *) ac_try_echo=$ac_try;;
 
3827
esac
 
3828
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3829
  (eval "$ac_try") 2>&5
 
3830
  ac_status=$?
 
3831
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3832
  (exit $ac_status); } &&
 
3833
         test -f conftest2.$ac_objext && { (case "(($ac_try" in
 
3834
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3835
  *) ac_try_echo=$ac_try;;
 
3836
esac
 
3837
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
3838
  (eval "$ac_try") 2>&5
 
3839
  ac_status=$?
 
3840
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3841
  (exit $ac_status); };
 
3842
      then
 
3843
        # cc works too.
 
3844
        :
 
3845
      else
 
3846
        # cc exists but doesn't like -o.
 
3847
        eval ac_cv_prog_cc_${ac_cc}_c_o=no
 
3848
      fi
 
3849
    fi
 
3850
  fi
 
3851
else
 
3852
  eval ac_cv_prog_cc_${ac_cc}_c_o=no
 
3853
fi
 
3854
rm -f core conftest*
 
3855
 
 
3856
fi
 
3857
if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
 
3858
  { echo "$as_me:$LINENO: result: yes" >&5
 
3859
echo "${ECHO_T}yes" >&6; }
 
3860
else
 
3861
  { echo "$as_me:$LINENO: result: no" >&5
 
3862
echo "${ECHO_T}no" >&6; }
 
3863
 
 
3864
cat >>confdefs.h <<\_ACEOF
 
3865
#define NO_MINUS_C_MINUS_O 1
 
3866
_ACEOF
 
3867
 
 
3868
fi
 
3869
 
 
3870
# FIXME: we rely on the cache variable name because
 
3871
# there is no other way.
 
3872
set dummy $CC
 
3873
ac_cc=`echo $2 | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
 
3874
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" != yes"; then
 
3875
   # Losing compiler, so override with the script.
 
3876
   # FIXME: It is wrong to rewrite CC.
 
3877
   # But if we don't then we get into trouble of one sort or another.
 
3878
   # A longer-term fix would be to have automake use am__CC in this case,
 
3879
   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
 
3880
   CC="$am_aux_dir/compile $CC"
 
3881
fi
 
3882
 
3780
3883
ac_ext=cpp
3781
3884
ac_cpp='$CXXCPP $CPPFLAGS'
3782
3885
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3805
3908
  IFS=$as_save_IFS
3806
3909
  test -z "$as_dir" && as_dir=.
3807
3910
  for ac_exec_ext in '' $ac_executable_extensions; do
3808
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3911
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3809
3912
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3810
3913
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3811
3914
    break 2
3849
3952
  IFS=$as_save_IFS
3850
3953
  test -z "$as_dir" && as_dir=.
3851
3954
  for ac_exec_ext in '' $ac_executable_extensions; do
3852
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3955
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3853
3956
    ac_cv_prog_ac_ct_CXX="$ac_prog"
3854
3957
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3855
3958
    break 2
3962
4065
  rm -f conftest.er1
3963
4066
  cat conftest.err >&5
3964
4067
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965
 
  (exit $ac_status); } &&
3966
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
3967
 
  { (case "(($ac_try" in
3968
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3969
 
  *) ac_try_echo=$ac_try;;
3970
 
esac
3971
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3972
 
  (eval "$ac_try") 2>&5
3973
 
  ac_status=$?
3974
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975
 
  (exit $ac_status); }; } &&
3976
 
         { ac_try='test -s conftest.$ac_objext'
3977
 
  { (case "(($ac_try" in
3978
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3979
 
  *) ac_try_echo=$ac_try;;
3980
 
esac
3981
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3982
 
  (eval "$ac_try") 2>&5
3983
 
  ac_status=$?
3984
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3985
 
  (exit $ac_status); }; }; then
 
4068
  (exit $ac_status); } && {
 
4069
         test -z "$ac_cxx_werror_flag" ||
 
4070
         test ! -s conftest.err
 
4071
       } && test -s conftest.$ac_objext; then
3986
4072
  ac_compiler_gnu=yes
3987
4073
else
3988
4074
  echo "$as_me: failed program was:" >&5
4037
4123
  rm -f conftest.er1
4038
4124
  cat conftest.err >&5
4039
4125
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4040
 
  (exit $ac_status); } &&
4041
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
4042
 
  { (case "(($ac_try" in
4043
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4044
 
  *) ac_try_echo=$ac_try;;
4045
 
esac
4046
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4047
 
  (eval "$ac_try") 2>&5
4048
 
  ac_status=$?
4049
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4050
 
  (exit $ac_status); }; } &&
4051
 
         { ac_try='test -s conftest.$ac_objext'
4052
 
  { (case "(($ac_try" in
4053
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4054
 
  *) ac_try_echo=$ac_try;;
4055
 
esac
4056
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4057
 
  (eval "$ac_try") 2>&5
4058
 
  ac_status=$?
4059
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4060
 
  (exit $ac_status); }; }; then
 
4126
  (exit $ac_status); } && {
 
4127
         test -z "$ac_cxx_werror_flag" ||
 
4128
         test ! -s conftest.err
 
4129
       } && test -s conftest.$ac_objext; then
4061
4130
  ac_cv_prog_cxx_g=yes
4062
4131
else
4063
4132
  echo "$as_me: failed program was:" >&5
4092
4161
  rm -f conftest.er1
4093
4162
  cat conftest.err >&5
4094
4163
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4095
 
  (exit $ac_status); } &&
4096
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
4097
 
  { (case "(($ac_try" in
4098
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4099
 
  *) ac_try_echo=$ac_try;;
4100
 
esac
4101
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4102
 
  (eval "$ac_try") 2>&5
4103
 
  ac_status=$?
4104
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4105
 
  (exit $ac_status); }; } &&
4106
 
         { ac_try='test -s conftest.$ac_objext'
4107
 
  { (case "(($ac_try" in
4108
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4109
 
  *) ac_try_echo=$ac_try;;
4110
 
esac
4111
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4112
 
  (eval "$ac_try") 2>&5
4113
 
  ac_status=$?
4114
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4115
 
  (exit $ac_status); }; }; then
 
4164
  (exit $ac_status); } && {
 
4165
         test -z "$ac_cxx_werror_flag" ||
 
4166
         test ! -s conftest.err
 
4167
       } && test -s conftest.$ac_objext; then
4116
4168
  :
4117
4169
else
4118
4170
  echo "$as_me: failed program was:" >&5
4148
4200
  rm -f conftest.er1
4149
4201
  cat conftest.err >&5
4150
4202
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4151
 
  (exit $ac_status); } &&
4152
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
4153
 
  { (case "(($ac_try" in
4154
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4155
 
  *) ac_try_echo=$ac_try;;
4156
 
esac
4157
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4158
 
  (eval "$ac_try") 2>&5
4159
 
  ac_status=$?
4160
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4161
 
  (exit $ac_status); }; } &&
4162
 
         { ac_try='test -s conftest.$ac_objext'
4163
 
  { (case "(($ac_try" in
4164
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4165
 
  *) ac_try_echo=$ac_try;;
4166
 
esac
4167
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4168
 
  (eval "$ac_try") 2>&5
4169
 
  ac_status=$?
4170
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4171
 
  (exit $ac_status); }; }; then
 
4203
  (exit $ac_status); } && {
 
4204
         test -z "$ac_cxx_werror_flag" ||
 
4205
         test ! -s conftest.err
 
4206
       } && test -s conftest.$ac_objext; then
4172
4207
  ac_cv_prog_cxx_g=yes
4173
4208
else
4174
4209
  echo "$as_me: failed program was:" >&5
4326
4361
 
4327
4362
 
4328
4363
 
 
4364
## FIXME: really needed? (AC_LIBTOOL already provides this)
4329
4365
if test -n "$ac_tool_prefix"; then
4330
4366
  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
4331
4367
set dummy ${ac_tool_prefix}ar; ac_word=$2
4343
4379
  IFS=$as_save_IFS
4344
4380
  test -z "$as_dir" && as_dir=.
4345
4381
  for ac_exec_ext in '' $ac_executable_extensions; do
4346
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4382
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4347
4383
    ac_cv_prog_AR="${ac_tool_prefix}ar"
4348
4384
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4349
4385
    break 2
4383
4419
  IFS=$as_save_IFS
4384
4420
  test -z "$as_dir" && as_dir=.
4385
4421
  for ac_exec_ext in '' $ac_executable_extensions; do
4386
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4422
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4387
4423
    ac_cv_prog_ac_ct_AR="ar"
4388
4424
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4389
4425
    break 2
4439
4475
  IFS=$as_save_IFS
4440
4476
  test -z "$as_dir" && as_dir=.
4441
4477
  for ac_exec_ext in '' $ac_executable_extensions; do
4442
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4478
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4443
4479
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4444
4480
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4445
4481
    break 2
4479
4515
  IFS=$as_save_IFS
4480
4516
  test -z "$as_dir" && as_dir=.
4481
4517
  for ac_exec_ext in '' $ac_executable_extensions; do
4482
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
4518
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4483
4519
    ac_cv_prog_ac_ct_RANLIB="ranlib"
4484
4520
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4485
4521
    break 2
4555
4591
    # by default.
4556
4592
    for ac_prog in ginstall scoinst install; do
4557
4593
      for ac_exec_ext in '' $ac_executable_extensions; do
4558
 
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; }; then
 
4594
        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
4559
4595
          if test $ac_prog = install &&
4560
4596
            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4561
4597
            # AIX install.  It has an incompatible calling convention.
4600
4636
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
4601
4637
 
4602
4638
 
4603
 
{ echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
4604
 
echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6; }
4605
 
    # Check whether --enable-maintainer-mode was given.
4606
 
if test "${enable_maintainer_mode+set}" = set; then
4607
 
  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
4608
 
else
4609
 
  USE_MAINTAINER_MODE=no
4610
 
fi
4611
 
 
4612
 
  { echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
4613
 
echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6; }
4614
 
 
4615
 
 
4616
 
if test $USE_MAINTAINER_MODE = yes; then
4617
 
  MAINTAINER_MODE_TRUE=
4618
 
  MAINTAINER_MODE_FALSE='#'
4619
 
else
4620
 
  MAINTAINER_MODE_TRUE='#'
4621
 
  MAINTAINER_MODE_FALSE=
4622
 
fi
4623
 
 
4624
 
  MAINT=$MAINTAINER_MODE_TRUE
4625
 
 
4626
 
 
4627
 
 
4628
4639
. ${srcdir}/configure.host
4629
4640
 
4630
4641
GC_CFLAGS=${gc_cflags}
4666
4677
 
4667
4678
INCLUDES=-I${srcdir}/include
4668
4679
THREADDLLIBS=
 
4680
need_atomic_ops_asm=false
4669
4681
## Libraries needed to support dynamic loading and/or threads.
4670
4682
case "$THREADS" in
4671
4683
 no | none | single)
4675
4687
    THREADS=posix
4676
4688
    THREADDLLIBS=-lpthread
4677
4689
    case "$host" in
 
4690
     x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* | alpha-*-linux*)
 
4691
        cat >>confdefs.h <<\_ACEOF
 
4692
#define GC_LINUX_THREADS 1
 
4693
_ACEOF
 
4694
 
 
4695
        cat >>confdefs.h <<\_ACEOF
 
4696
#define _REENTRANT 1
 
4697
_ACEOF
 
4698
 
 
4699
        if test "${enable_parallel_mark}" = yes; then
 
4700
          cat >>confdefs.h <<\_ACEOF
 
4701
#define PARALLEL_MARK 1
 
4702
_ACEOF
 
4703
 
 
4704
        fi
 
4705
        cat >>confdefs.h <<\_ACEOF
 
4706
#define THREAD_LOCAL_ALLOC 1
 
4707
_ACEOF
 
4708
 
 
4709
        { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
 
4710
echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
 
4711
        ;;
4678
4712
     *-*-linux*)
4679
4713
        cat >>confdefs.h <<\_ACEOF
4680
4714
#define GC_LINUX_THREADS 1
4684
4718
#define _REENTRANT 1
4685
4719
_ACEOF
4686
4720
 
4687
 
        if test "${enable_parallel_mark}" = yes; then
4688
 
          cat >>confdefs.h <<\_ACEOF
4689
 
#define PARALLEL_MARK 1
4690
 
_ACEOF
4691
 
 
4692
 
        fi
4693
 
        cat >>confdefs.h <<\_ACEOF
4694
 
#define THREAD_LOCAL_ALLOC 1
4695
 
_ACEOF
4696
 
 
4697
4721
        ;;
4698
4722
     *-*-aix*)
4699
4723
        cat >>confdefs.h <<\_ACEOF
4706
4730
 
4707
4731
        ;;
4708
4732
     *-*-hpux11*)
4709
 
        { echo "$as_me:$LINENO: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&5
4710
 
echo "$as_me: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&2;}
 
4733
        { echo "$as_me:$LINENO: WARNING: \"Only HP/UX 11 POSIX threads are supported.\"" >&5
 
4734
echo "$as_me: WARNING: \"Only HP/UX 11 POSIX threads are supported.\"" >&2;}
4711
4735
        cat >>confdefs.h <<\_ACEOF
4712
4736
#define GC_HPUX_THREADS 1
4713
4737
_ACEOF
4726
4750
#define THREAD_LOCAL_ALLOC 1
4727
4751
_ACEOF
4728
4752
 
 
4753
        { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
 
4754
echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
4729
4755
        THREADDLLIBS="-lpthread -lrt"
4730
4756
        # HPUX needs REENTRANT for the _r calls.
4731
4757
 
4733
4759
#define _REENTRANT 1
4734
4760
_ACEOF
4735
4761
 
4736
 
        ;;
 
4762
        ;;
4737
4763
     *-*-hpux10*)
4738
4764
        { echo "$as_me:$LINENO: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&5
4739
4765
echo "$as_me: WARNING: \"Only HP-UX 11 POSIX threads are supported.\"" >&2;}
4746
4772
_ACEOF
4747
4773
 
4748
4774
        INCLUDES="$INCLUDES -pthread"
4749
 
        THREADDLLIBS=-pthread
4750
4775
        ;;
4751
4776
     *-*-kfreebsd*-gnu)
4752
4777
        cat >>confdefs.h <<\_ACEOF
4774
4799
_ACEOF
4775
4800
 
4776
4801
        ;;
 
4802
     *-*-gnu*)
 
4803
        cat >>confdefs.h <<\_ACEOF
 
4804
#define GC_GNU_THREADS 1
 
4805
_ACEOF
 
4806
 
 
4807
        cat >>confdefs.h <<\_ACEOF
 
4808
#define _REENTRANT 1
 
4809
_ACEOF
 
4810
 
 
4811
        cat >>confdefs.h <<\_ACEOF
 
4812
#define THREAD_LOCAL_ALLOC 1
 
4813
_ACEOF
 
4814
 
 
4815
        ;;
4777
4816
     *-*-netbsd*)
4778
4817
        { echo "$as_me:$LINENO: WARNING: \"Only on NetBSD 2.0 or later.\"" >&5
4779
4818
echo "$as_me: WARNING: \"Only on NetBSD 2.0 or later.\"" >&2;}
4797
4836
_ACEOF
4798
4837
 
4799
4838
        cat >>confdefs.h <<\_ACEOF
4800
 
#define GC_SOLARIS_PTHREADS 1
 
4839
#define THREAD_LOCAL_ALLOC 1
4801
4840
_ACEOF
4802
4841
 
 
4842
        THREADDLLIBS="-lpthread -lrt"
 
4843
        if test "$GCC" != yes; then
 
4844
          CFLAGS="$CFLAGS -O"
 
4845
          need_atomic_ops_asm=true
 
4846
        fi
4803
4847
        ;;
4804
4848
     *-*-irix*)
4805
4849
        cat >>confdefs.h <<\_ACEOF
4812
4856
#define GC_WIN32_THREADS 1
4813
4857
_ACEOF
4814
4858
 
 
4859
        cat >>confdefs.h <<\_ACEOF
 
4860
#define THREAD_LOCAL_ALLOC 1
 
4861
_ACEOF
 
4862
 
 
4863
        win32_threads=true
4815
4864
        ;;
4816
4865
     *-*-darwin*)
4817
4866
        cat >>confdefs.h <<\_ACEOF
4822
4871
#define THREAD_LOCAL_ALLOC 1
4823
4872
_ACEOF
4824
4873
 
4825
 
        if test "${enable_parallel_mark}" = yes; then
4826
 
          cat >>confdefs.h <<\_ACEOF
4827
 
#define PARALLEL_MARK 1
4828
 
_ACEOF
4829
 
 
4830
 
        fi
 
4874
        { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
 
4875
echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
 
4876
        # Parallel-mark is currently unreliable on Darwin; ignore request
 
4877
        # if test "${enable_parallel_mark}" = yes; then
 
4878
        #   AC_DEFINE(PARALLEL_MARK)
 
4879
        # fi
 
4880
        darwin_threads=true
4831
4881
        ;;
4832
4882
     *-*-osf*)
4833
4883
        cat >>confdefs.h <<\_ACEOF
4843
4893
#define THREAD_LOCAL_ALLOC 1
4844
4894
_ACEOF
4845
4895
 
 
4896
          { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
 
4897
echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
4846
4898
          # May want to enable it in other cases, too.
4847
4899
          # Measurements havent yet been done.
4848
4900
        fi
4882
4934
#define THREAD_LOCAL_ALLOC 1
4883
4935
_ACEOF
4884
4936
 
 
4937
    { echo "$as_me:$LINENO: WARNING: \"Explict GC_INIT() calls may be required.\"" >&5
 
4938
echo "$as_me: WARNING: \"Explict GC_INIT() calls may be required.\"" >&2;};
4885
4939
    cat >>confdefs.h <<\_ACEOF
4886
4940
#define GC_DGUX386_THREADS 1
4887
4941
_ACEOF
4918
4972
esac
4919
4973
 
4920
4974
 
 
4975
 
 
4976
if test x$THREADS != xnone; then
 
4977
  THREADS_TRUE=
 
4978
  THREADS_FALSE='#'
 
4979
else
 
4980
  THREADS_TRUE='#'
 
4981
  THREADS_FALSE=
 
4982
fi
 
4983
 
 
4984
 
 
4985
 
 
4986
if test x$THREADS = xposix; then
 
4987
  PTHREADS_TRUE=
 
4988
  PTHREADS_FALSE='#'
 
4989
else
 
4990
  PTHREADS_TRUE='#'
 
4991
  PTHREADS_FALSE=
 
4992
fi
 
4993
 
 
4994
 
 
4995
 
 
4996
if test x$darwin_threads = xtrue; then
 
4997
  DARWIN_THREADS_TRUE=
 
4998
  DARWIN_THREADS_FALSE='#'
 
4999
else
 
5000
  DARWIN_THREADS_TRUE='#'
 
5001
  DARWIN_THREADS_FALSE=
 
5002
fi
 
5003
 
 
5004
 
 
5005
 
 
5006
if test x$win32_threads = xtrue; then
 
5007
  WIN32_THREADS_TRUE=
 
5008
  WIN32_THREADS_FALSE='#'
 
5009
else
 
5010
  WIN32_THREADS_TRUE='#'
 
5011
  WIN32_THREADS_FALSE=
 
5012
fi
 
5013
 
 
5014
 
4921
5015
case "$host" in
4922
5016
   powerpc-*-darwin*)
4923
5017
      powerpc_darwin=true
4924
5018
      ;;
4925
5019
esac
4926
5020
 
4927
 
 
4928
 
if test x$powerpc_darwin = xtrue; then
4929
 
  POWERPC_DARWIN_TRUE=
4930
 
  POWERPC_DARWIN_FALSE='#'
4931
 
else
4932
 
  POWERPC_DARWIN_TRUE='#'
4933
 
  POWERPC_DARWIN_FALSE=
4934
 
fi
4935
 
 
 
5021
# Darwin needs a few extra special tests to deal with variation in the
 
5022
# system headers.
 
5023
case "$host" in
 
5024
  powerpc*-*-darwin*)
 
5025
 
 
5026
{ echo "$as_me:$LINENO: checking for ppc_thread_state_t.r0" >&5
 
5027
echo $ECHO_N "checking for ppc_thread_state_t.r0... $ECHO_C" >&6; }
 
5028
if test "${ac_cv_member_ppc_thread_state_t_r0+set}" = set; then
 
5029
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5030
else
 
5031
  cat >conftest.$ac_ext <<_ACEOF
 
5032
/* confdefs.h.  */
 
5033
_ACEOF
 
5034
cat confdefs.h >>conftest.$ac_ext
 
5035
cat >>conftest.$ac_ext <<_ACEOF
 
5036
/* end confdefs.h.  */
 
5037
#include <mach/thread_status.h>
 
5038
 
 
5039
int
 
5040
main ()
 
5041
{
 
5042
static ppc_thread_state_t ac_aggr;
 
5043
if (ac_aggr.r0)
 
5044
return 0;
 
5045
  ;
 
5046
  return 0;
 
5047
}
 
5048
_ACEOF
 
5049
rm -f conftest.$ac_objext
 
5050
if { (ac_try="$ac_compile"
 
5051
case "(($ac_try" in
 
5052
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5053
  *) ac_try_echo=$ac_try;;
 
5054
esac
 
5055
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5056
  (eval "$ac_compile") 2>conftest.er1
 
5057
  ac_status=$?
 
5058
  grep -v '^ *+' conftest.er1 >conftest.err
 
5059
  rm -f conftest.er1
 
5060
  cat conftest.err >&5
 
5061
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5062
  (exit $ac_status); } && {
 
5063
         test -z "$ac_c_werror_flag" ||
 
5064
         test ! -s conftest.err
 
5065
       } && test -s conftest.$ac_objext; then
 
5066
  ac_cv_member_ppc_thread_state_t_r0=yes
 
5067
else
 
5068
  echo "$as_me: failed program was:" >&5
 
5069
sed 's/^/| /' conftest.$ac_ext >&5
 
5070
 
 
5071
        cat >conftest.$ac_ext <<_ACEOF
 
5072
/* confdefs.h.  */
 
5073
_ACEOF
 
5074
cat confdefs.h >>conftest.$ac_ext
 
5075
cat >>conftest.$ac_ext <<_ACEOF
 
5076
/* end confdefs.h.  */
 
5077
#include <mach/thread_status.h>
 
5078
 
 
5079
int
 
5080
main ()
 
5081
{
 
5082
static ppc_thread_state_t ac_aggr;
 
5083
if (sizeof ac_aggr.r0)
 
5084
return 0;
 
5085
  ;
 
5086
  return 0;
 
5087
}
 
5088
_ACEOF
 
5089
rm -f conftest.$ac_objext
 
5090
if { (ac_try="$ac_compile"
 
5091
case "(($ac_try" in
 
5092
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5093
  *) ac_try_echo=$ac_try;;
 
5094
esac
 
5095
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5096
  (eval "$ac_compile") 2>conftest.er1
 
5097
  ac_status=$?
 
5098
  grep -v '^ *+' conftest.er1 >conftest.err
 
5099
  rm -f conftest.er1
 
5100
  cat conftest.err >&5
 
5101
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5102
  (exit $ac_status); } && {
 
5103
         test -z "$ac_c_werror_flag" ||
 
5104
         test ! -s conftest.err
 
5105
       } && test -s conftest.$ac_objext; then
 
5106
  ac_cv_member_ppc_thread_state_t_r0=yes
 
5107
else
 
5108
  echo "$as_me: failed program was:" >&5
 
5109
sed 's/^/| /' conftest.$ac_ext >&5
 
5110
 
 
5111
        ac_cv_member_ppc_thread_state_t_r0=no
 
5112
fi
 
5113
 
 
5114
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5115
fi
 
5116
 
 
5117
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5118
fi
 
5119
{ echo "$as_me:$LINENO: result: $ac_cv_member_ppc_thread_state_t_r0" >&5
 
5120
echo "${ECHO_T}$ac_cv_member_ppc_thread_state_t_r0" >&6; }
 
5121
if test $ac_cv_member_ppc_thread_state_t_r0 = yes; then
 
5122
 
 
5123
cat >>confdefs.h <<\_ACEOF
 
5124
#define HAS_PPC_THREAD_STATE_R0 1
 
5125
_ACEOF
 
5126
 
 
5127
fi
 
5128
 
 
5129
    { echo "$as_me:$LINENO: checking for ppc_thread_state_t.__r0" >&5
 
5130
echo $ECHO_N "checking for ppc_thread_state_t.__r0... $ECHO_C" >&6; }
 
5131
if test "${ac_cv_member_ppc_thread_state_t___r0+set}" = set; then
 
5132
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5133
else
 
5134
  cat >conftest.$ac_ext <<_ACEOF
 
5135
/* confdefs.h.  */
 
5136
_ACEOF
 
5137
cat confdefs.h >>conftest.$ac_ext
 
5138
cat >>conftest.$ac_ext <<_ACEOF
 
5139
/* end confdefs.h.  */
 
5140
#include <mach/thread_status.h>
 
5141
 
 
5142
int
 
5143
main ()
 
5144
{
 
5145
static ppc_thread_state_t ac_aggr;
 
5146
if (ac_aggr.__r0)
 
5147
return 0;
 
5148
  ;
 
5149
  return 0;
 
5150
}
 
5151
_ACEOF
 
5152
rm -f conftest.$ac_objext
 
5153
if { (ac_try="$ac_compile"
 
5154
case "(($ac_try" in
 
5155
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5156
  *) ac_try_echo=$ac_try;;
 
5157
esac
 
5158
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5159
  (eval "$ac_compile") 2>conftest.er1
 
5160
  ac_status=$?
 
5161
  grep -v '^ *+' conftest.er1 >conftest.err
 
5162
  rm -f conftest.er1
 
5163
  cat conftest.err >&5
 
5164
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5165
  (exit $ac_status); } && {
 
5166
         test -z "$ac_c_werror_flag" ||
 
5167
         test ! -s conftest.err
 
5168
       } && test -s conftest.$ac_objext; then
 
5169
  ac_cv_member_ppc_thread_state_t___r0=yes
 
5170
else
 
5171
  echo "$as_me: failed program was:" >&5
 
5172
sed 's/^/| /' conftest.$ac_ext >&5
 
5173
 
 
5174
        cat >conftest.$ac_ext <<_ACEOF
 
5175
/* confdefs.h.  */
 
5176
_ACEOF
 
5177
cat confdefs.h >>conftest.$ac_ext
 
5178
cat >>conftest.$ac_ext <<_ACEOF
 
5179
/* end confdefs.h.  */
 
5180
#include <mach/thread_status.h>
 
5181
 
 
5182
int
 
5183
main ()
 
5184
{
 
5185
static ppc_thread_state_t ac_aggr;
 
5186
if (sizeof ac_aggr.__r0)
 
5187
return 0;
 
5188
  ;
 
5189
  return 0;
 
5190
}
 
5191
_ACEOF
 
5192
rm -f conftest.$ac_objext
 
5193
if { (ac_try="$ac_compile"
 
5194
case "(($ac_try" in
 
5195
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5196
  *) ac_try_echo=$ac_try;;
 
5197
esac
 
5198
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5199
  (eval "$ac_compile") 2>conftest.er1
 
5200
  ac_status=$?
 
5201
  grep -v '^ *+' conftest.er1 >conftest.err
 
5202
  rm -f conftest.er1
 
5203
  cat conftest.err >&5
 
5204
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5205
  (exit $ac_status); } && {
 
5206
         test -z "$ac_c_werror_flag" ||
 
5207
         test ! -s conftest.err
 
5208
       } && test -s conftest.$ac_objext; then
 
5209
  ac_cv_member_ppc_thread_state_t___r0=yes
 
5210
else
 
5211
  echo "$as_me: failed program was:" >&5
 
5212
sed 's/^/| /' conftest.$ac_ext >&5
 
5213
 
 
5214
        ac_cv_member_ppc_thread_state_t___r0=no
 
5215
fi
 
5216
 
 
5217
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5218
fi
 
5219
 
 
5220
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5221
fi
 
5222
{ echo "$as_me:$LINENO: result: $ac_cv_member_ppc_thread_state_t___r0" >&5
 
5223
echo "${ECHO_T}$ac_cv_member_ppc_thread_state_t___r0" >&6; }
 
5224
if test $ac_cv_member_ppc_thread_state_t___r0 = yes; then
 
5225
 
 
5226
cat >>confdefs.h <<\_ACEOF
 
5227
#define HAS_PPC_THREAD_STATE___R0 1
 
5228
_ACEOF
 
5229
 
 
5230
fi
 
5231
 
 
5232
    { echo "$as_me:$LINENO: checking for ppc_thread_state64_t.r0" >&5
 
5233
echo $ECHO_N "checking for ppc_thread_state64_t.r0... $ECHO_C" >&6; }
 
5234
if test "${ac_cv_member_ppc_thread_state64_t_r0+set}" = set; then
 
5235
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5236
else
 
5237
  cat >conftest.$ac_ext <<_ACEOF
 
5238
/* confdefs.h.  */
 
5239
_ACEOF
 
5240
cat confdefs.h >>conftest.$ac_ext
 
5241
cat >>conftest.$ac_ext <<_ACEOF
 
5242
/* end confdefs.h.  */
 
5243
#include <mach/thread_status.h>
 
5244
 
 
5245
int
 
5246
main ()
 
5247
{
 
5248
static ppc_thread_state64_t ac_aggr;
 
5249
if (ac_aggr.r0)
 
5250
return 0;
 
5251
  ;
 
5252
  return 0;
 
5253
}
 
5254
_ACEOF
 
5255
rm -f conftest.$ac_objext
 
5256
if { (ac_try="$ac_compile"
 
5257
case "(($ac_try" in
 
5258
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5259
  *) ac_try_echo=$ac_try;;
 
5260
esac
 
5261
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5262
  (eval "$ac_compile") 2>conftest.er1
 
5263
  ac_status=$?
 
5264
  grep -v '^ *+' conftest.er1 >conftest.err
 
5265
  rm -f conftest.er1
 
5266
  cat conftest.err >&5
 
5267
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5268
  (exit $ac_status); } && {
 
5269
         test -z "$ac_c_werror_flag" ||
 
5270
         test ! -s conftest.err
 
5271
       } && test -s conftest.$ac_objext; then
 
5272
  ac_cv_member_ppc_thread_state64_t_r0=yes
 
5273
else
 
5274
  echo "$as_me: failed program was:" >&5
 
5275
sed 's/^/| /' conftest.$ac_ext >&5
 
5276
 
 
5277
        cat >conftest.$ac_ext <<_ACEOF
 
5278
/* confdefs.h.  */
 
5279
_ACEOF
 
5280
cat confdefs.h >>conftest.$ac_ext
 
5281
cat >>conftest.$ac_ext <<_ACEOF
 
5282
/* end confdefs.h.  */
 
5283
#include <mach/thread_status.h>
 
5284
 
 
5285
int
 
5286
main ()
 
5287
{
 
5288
static ppc_thread_state64_t ac_aggr;
 
5289
if (sizeof ac_aggr.r0)
 
5290
return 0;
 
5291
  ;
 
5292
  return 0;
 
5293
}
 
5294
_ACEOF
 
5295
rm -f conftest.$ac_objext
 
5296
if { (ac_try="$ac_compile"
 
5297
case "(($ac_try" in
 
5298
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5299
  *) ac_try_echo=$ac_try;;
 
5300
esac
 
5301
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5302
  (eval "$ac_compile") 2>conftest.er1
 
5303
  ac_status=$?
 
5304
  grep -v '^ *+' conftest.er1 >conftest.err
 
5305
  rm -f conftest.er1
 
5306
  cat conftest.err >&5
 
5307
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5308
  (exit $ac_status); } && {
 
5309
         test -z "$ac_c_werror_flag" ||
 
5310
         test ! -s conftest.err
 
5311
       } && test -s conftest.$ac_objext; then
 
5312
  ac_cv_member_ppc_thread_state64_t_r0=yes
 
5313
else
 
5314
  echo "$as_me: failed program was:" >&5
 
5315
sed 's/^/| /' conftest.$ac_ext >&5
 
5316
 
 
5317
        ac_cv_member_ppc_thread_state64_t_r0=no
 
5318
fi
 
5319
 
 
5320
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5321
fi
 
5322
 
 
5323
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5324
fi
 
5325
{ echo "$as_me:$LINENO: result: $ac_cv_member_ppc_thread_state64_t_r0" >&5
 
5326
echo "${ECHO_T}$ac_cv_member_ppc_thread_state64_t_r0" >&6; }
 
5327
if test $ac_cv_member_ppc_thread_state64_t_r0 = yes; then
 
5328
 
 
5329
cat >>confdefs.h <<\_ACEOF
 
5330
#define HAS_PPC_THREAD_STATE64_R0 1
 
5331
_ACEOF
 
5332
 
 
5333
fi
 
5334
 
 
5335
    { echo "$as_me:$LINENO: checking for ppc_thread_state64_t.__r0" >&5
 
5336
echo $ECHO_N "checking for ppc_thread_state64_t.__r0... $ECHO_C" >&6; }
 
5337
if test "${ac_cv_member_ppc_thread_state64_t___r0+set}" = set; then
 
5338
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5339
else
 
5340
  cat >conftest.$ac_ext <<_ACEOF
 
5341
/* confdefs.h.  */
 
5342
_ACEOF
 
5343
cat confdefs.h >>conftest.$ac_ext
 
5344
cat >>conftest.$ac_ext <<_ACEOF
 
5345
/* end confdefs.h.  */
 
5346
#include <mach/thread_status.h>
 
5347
 
 
5348
int
 
5349
main ()
 
5350
{
 
5351
static ppc_thread_state64_t ac_aggr;
 
5352
if (ac_aggr.__r0)
 
5353
return 0;
 
5354
  ;
 
5355
  return 0;
 
5356
}
 
5357
_ACEOF
 
5358
rm -f conftest.$ac_objext
 
5359
if { (ac_try="$ac_compile"
 
5360
case "(($ac_try" in
 
5361
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5362
  *) ac_try_echo=$ac_try;;
 
5363
esac
 
5364
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5365
  (eval "$ac_compile") 2>conftest.er1
 
5366
  ac_status=$?
 
5367
  grep -v '^ *+' conftest.er1 >conftest.err
 
5368
  rm -f conftest.er1
 
5369
  cat conftest.err >&5
 
5370
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5371
  (exit $ac_status); } && {
 
5372
         test -z "$ac_c_werror_flag" ||
 
5373
         test ! -s conftest.err
 
5374
       } && test -s conftest.$ac_objext; then
 
5375
  ac_cv_member_ppc_thread_state64_t___r0=yes
 
5376
else
 
5377
  echo "$as_me: failed program was:" >&5
 
5378
sed 's/^/| /' conftest.$ac_ext >&5
 
5379
 
 
5380
        cat >conftest.$ac_ext <<_ACEOF
 
5381
/* confdefs.h.  */
 
5382
_ACEOF
 
5383
cat confdefs.h >>conftest.$ac_ext
 
5384
cat >>conftest.$ac_ext <<_ACEOF
 
5385
/* end confdefs.h.  */
 
5386
#include <mach/thread_status.h>
 
5387
 
 
5388
int
 
5389
main ()
 
5390
{
 
5391
static ppc_thread_state64_t ac_aggr;
 
5392
if (sizeof ac_aggr.__r0)
 
5393
return 0;
 
5394
  ;
 
5395
  return 0;
 
5396
}
 
5397
_ACEOF
 
5398
rm -f conftest.$ac_objext
 
5399
if { (ac_try="$ac_compile"
 
5400
case "(($ac_try" in
 
5401
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5402
  *) ac_try_echo=$ac_try;;
 
5403
esac
 
5404
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5405
  (eval "$ac_compile") 2>conftest.er1
 
5406
  ac_status=$?
 
5407
  grep -v '^ *+' conftest.er1 >conftest.err
 
5408
  rm -f conftest.er1
 
5409
  cat conftest.err >&5
 
5410
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5411
  (exit $ac_status); } && {
 
5412
         test -z "$ac_c_werror_flag" ||
 
5413
         test ! -s conftest.err
 
5414
       } && test -s conftest.$ac_objext; then
 
5415
  ac_cv_member_ppc_thread_state64_t___r0=yes
 
5416
else
 
5417
  echo "$as_me: failed program was:" >&5
 
5418
sed 's/^/| /' conftest.$ac_ext >&5
 
5419
 
 
5420
        ac_cv_member_ppc_thread_state64_t___r0=no
 
5421
fi
 
5422
 
 
5423
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5424
fi
 
5425
 
 
5426
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5427
fi
 
5428
{ echo "$as_me:$LINENO: result: $ac_cv_member_ppc_thread_state64_t___r0" >&5
 
5429
echo "${ECHO_T}$ac_cv_member_ppc_thread_state64_t___r0" >&6; }
 
5430
if test $ac_cv_member_ppc_thread_state64_t___r0 = yes; then
 
5431
 
 
5432
cat >>confdefs.h <<\_ACEOF
 
5433
#define HAS_PPC_THREAD_STATE64___R0 1
 
5434
_ACEOF
 
5435
 
 
5436
fi
 
5437
 
 
5438
    ;;
 
5439
  i?86*-*-darwin*)
 
5440
    { echo "$as_me:$LINENO: checking for x86_thread_state32_t.eax" >&5
 
5441
echo $ECHO_N "checking for x86_thread_state32_t.eax... $ECHO_C" >&6; }
 
5442
if test "${ac_cv_member_x86_thread_state32_t_eax+set}" = set; then
 
5443
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5444
else
 
5445
  cat >conftest.$ac_ext <<_ACEOF
 
5446
/* confdefs.h.  */
 
5447
_ACEOF
 
5448
cat confdefs.h >>conftest.$ac_ext
 
5449
cat >>conftest.$ac_ext <<_ACEOF
 
5450
/* end confdefs.h.  */
 
5451
#include <sys/cdefs.h>
 
5452
      #include <mach/thread_status.h>
 
5453
 
 
5454
int
 
5455
main ()
 
5456
{
 
5457
static x86_thread_state32_t ac_aggr;
 
5458
if (ac_aggr.eax)
 
5459
return 0;
 
5460
  ;
 
5461
  return 0;
 
5462
}
 
5463
_ACEOF
 
5464
rm -f conftest.$ac_objext
 
5465
if { (ac_try="$ac_compile"
 
5466
case "(($ac_try" in
 
5467
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5468
  *) ac_try_echo=$ac_try;;
 
5469
esac
 
5470
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5471
  (eval "$ac_compile") 2>conftest.er1
 
5472
  ac_status=$?
 
5473
  grep -v '^ *+' conftest.er1 >conftest.err
 
5474
  rm -f conftest.er1
 
5475
  cat conftest.err >&5
 
5476
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5477
  (exit $ac_status); } && {
 
5478
         test -z "$ac_c_werror_flag" ||
 
5479
         test ! -s conftest.err
 
5480
       } && test -s conftest.$ac_objext; then
 
5481
  ac_cv_member_x86_thread_state32_t_eax=yes
 
5482
else
 
5483
  echo "$as_me: failed program was:" >&5
 
5484
sed 's/^/| /' conftest.$ac_ext >&5
 
5485
 
 
5486
        cat >conftest.$ac_ext <<_ACEOF
 
5487
/* confdefs.h.  */
 
5488
_ACEOF
 
5489
cat confdefs.h >>conftest.$ac_ext
 
5490
cat >>conftest.$ac_ext <<_ACEOF
 
5491
/* end confdefs.h.  */
 
5492
#include <sys/cdefs.h>
 
5493
      #include <mach/thread_status.h>
 
5494
 
 
5495
int
 
5496
main ()
 
5497
{
 
5498
static x86_thread_state32_t ac_aggr;
 
5499
if (sizeof ac_aggr.eax)
 
5500
return 0;
 
5501
  ;
 
5502
  return 0;
 
5503
}
 
5504
_ACEOF
 
5505
rm -f conftest.$ac_objext
 
5506
if { (ac_try="$ac_compile"
 
5507
case "(($ac_try" in
 
5508
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5509
  *) ac_try_echo=$ac_try;;
 
5510
esac
 
5511
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5512
  (eval "$ac_compile") 2>conftest.er1
 
5513
  ac_status=$?
 
5514
  grep -v '^ *+' conftest.er1 >conftest.err
 
5515
  rm -f conftest.er1
 
5516
  cat conftest.err >&5
 
5517
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5518
  (exit $ac_status); } && {
 
5519
         test -z "$ac_c_werror_flag" ||
 
5520
         test ! -s conftest.err
 
5521
       } && test -s conftest.$ac_objext; then
 
5522
  ac_cv_member_x86_thread_state32_t_eax=yes
 
5523
else
 
5524
  echo "$as_me: failed program was:" >&5
 
5525
sed 's/^/| /' conftest.$ac_ext >&5
 
5526
 
 
5527
        ac_cv_member_x86_thread_state32_t_eax=no
 
5528
fi
 
5529
 
 
5530
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5531
fi
 
5532
 
 
5533
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5534
fi
 
5535
{ echo "$as_me:$LINENO: result: $ac_cv_member_x86_thread_state32_t_eax" >&5
 
5536
echo "${ECHO_T}$ac_cv_member_x86_thread_state32_t_eax" >&6; }
 
5537
if test $ac_cv_member_x86_thread_state32_t_eax = yes; then
 
5538
 
 
5539
cat >>confdefs.h <<\_ACEOF
 
5540
#define HAS_X86_THREAD_STATE32_EAX 1
 
5541
_ACEOF
 
5542
 
 
5543
fi
 
5544
 
 
5545
    { echo "$as_me:$LINENO: checking for x86_thread_state32_t.__eax" >&5
 
5546
echo $ECHO_N "checking for x86_thread_state32_t.__eax... $ECHO_C" >&6; }
 
5547
if test "${ac_cv_member_x86_thread_state32_t___eax+set}" = set; then
 
5548
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5549
else
 
5550
  cat >conftest.$ac_ext <<_ACEOF
 
5551
/* confdefs.h.  */
 
5552
_ACEOF
 
5553
cat confdefs.h >>conftest.$ac_ext
 
5554
cat >>conftest.$ac_ext <<_ACEOF
 
5555
/* end confdefs.h.  */
 
5556
#include <sys/cdefs.h>
 
5557
      #include <mach/thread_status.h>
 
5558
 
 
5559
int
 
5560
main ()
 
5561
{
 
5562
static x86_thread_state32_t ac_aggr;
 
5563
if (ac_aggr.__eax)
 
5564
return 0;
 
5565
  ;
 
5566
  return 0;
 
5567
}
 
5568
_ACEOF
 
5569
rm -f conftest.$ac_objext
 
5570
if { (ac_try="$ac_compile"
 
5571
case "(($ac_try" in
 
5572
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5573
  *) ac_try_echo=$ac_try;;
 
5574
esac
 
5575
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5576
  (eval "$ac_compile") 2>conftest.er1
 
5577
  ac_status=$?
 
5578
  grep -v '^ *+' conftest.er1 >conftest.err
 
5579
  rm -f conftest.er1
 
5580
  cat conftest.err >&5
 
5581
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5582
  (exit $ac_status); } && {
 
5583
         test -z "$ac_c_werror_flag" ||
 
5584
         test ! -s conftest.err
 
5585
       } && test -s conftest.$ac_objext; then
 
5586
  ac_cv_member_x86_thread_state32_t___eax=yes
 
5587
else
 
5588
  echo "$as_me: failed program was:" >&5
 
5589
sed 's/^/| /' conftest.$ac_ext >&5
 
5590
 
 
5591
        cat >conftest.$ac_ext <<_ACEOF
 
5592
/* confdefs.h.  */
 
5593
_ACEOF
 
5594
cat confdefs.h >>conftest.$ac_ext
 
5595
cat >>conftest.$ac_ext <<_ACEOF
 
5596
/* end confdefs.h.  */
 
5597
#include <sys/cdefs.h>
 
5598
      #include <mach/thread_status.h>
 
5599
 
 
5600
int
 
5601
main ()
 
5602
{
 
5603
static x86_thread_state32_t ac_aggr;
 
5604
if (sizeof ac_aggr.__eax)
 
5605
return 0;
 
5606
  ;
 
5607
  return 0;
 
5608
}
 
5609
_ACEOF
 
5610
rm -f conftest.$ac_objext
 
5611
if { (ac_try="$ac_compile"
 
5612
case "(($ac_try" in
 
5613
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5614
  *) ac_try_echo=$ac_try;;
 
5615
esac
 
5616
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5617
  (eval "$ac_compile") 2>conftest.er1
 
5618
  ac_status=$?
 
5619
  grep -v '^ *+' conftest.er1 >conftest.err
 
5620
  rm -f conftest.er1
 
5621
  cat conftest.err >&5
 
5622
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5623
  (exit $ac_status); } && {
 
5624
         test -z "$ac_c_werror_flag" ||
 
5625
         test ! -s conftest.err
 
5626
       } && test -s conftest.$ac_objext; then
 
5627
  ac_cv_member_x86_thread_state32_t___eax=yes
 
5628
else
 
5629
  echo "$as_me: failed program was:" >&5
 
5630
sed 's/^/| /' conftest.$ac_ext >&5
 
5631
 
 
5632
        ac_cv_member_x86_thread_state32_t___eax=no
 
5633
fi
 
5634
 
 
5635
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5636
fi
 
5637
 
 
5638
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5639
fi
 
5640
{ echo "$as_me:$LINENO: result: $ac_cv_member_x86_thread_state32_t___eax" >&5
 
5641
echo "${ECHO_T}$ac_cv_member_x86_thread_state32_t___eax" >&6; }
 
5642
if test $ac_cv_member_x86_thread_state32_t___eax = yes; then
 
5643
 
 
5644
cat >>confdefs.h <<\_ACEOF
 
5645
#define HAS_X86_THREAD_STATE32___EAX 1
 
5646
_ACEOF
 
5647
 
 
5648
fi
 
5649
 
 
5650
    ;;
 
5651
  x86_64-*-darwin*)
 
5652
    { echo "$as_me:$LINENO: checking for x86_thread_state64_t.rax" >&5
 
5653
echo $ECHO_N "checking for x86_thread_state64_t.rax... $ECHO_C" >&6; }
 
5654
if test "${ac_cv_member_x86_thread_state64_t_rax+set}" = set; then
 
5655
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5656
else
 
5657
  cat >conftest.$ac_ext <<_ACEOF
 
5658
/* confdefs.h.  */
 
5659
_ACEOF
 
5660
cat confdefs.h >>conftest.$ac_ext
 
5661
cat >>conftest.$ac_ext <<_ACEOF
 
5662
/* end confdefs.h.  */
 
5663
#include <sys/cdefs.h>
 
5664
      #include <mach/thread_status.h>
 
5665
 
 
5666
int
 
5667
main ()
 
5668
{
 
5669
static x86_thread_state64_t ac_aggr;
 
5670
if (ac_aggr.rax)
 
5671
return 0;
 
5672
  ;
 
5673
  return 0;
 
5674
}
 
5675
_ACEOF
 
5676
rm -f conftest.$ac_objext
 
5677
if { (ac_try="$ac_compile"
 
5678
case "(($ac_try" in
 
5679
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5680
  *) ac_try_echo=$ac_try;;
 
5681
esac
 
5682
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5683
  (eval "$ac_compile") 2>conftest.er1
 
5684
  ac_status=$?
 
5685
  grep -v '^ *+' conftest.er1 >conftest.err
 
5686
  rm -f conftest.er1
 
5687
  cat conftest.err >&5
 
5688
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5689
  (exit $ac_status); } && {
 
5690
         test -z "$ac_c_werror_flag" ||
 
5691
         test ! -s conftest.err
 
5692
       } && test -s conftest.$ac_objext; then
 
5693
  ac_cv_member_x86_thread_state64_t_rax=yes
 
5694
else
 
5695
  echo "$as_me: failed program was:" >&5
 
5696
sed 's/^/| /' conftest.$ac_ext >&5
 
5697
 
 
5698
        cat >conftest.$ac_ext <<_ACEOF
 
5699
/* confdefs.h.  */
 
5700
_ACEOF
 
5701
cat confdefs.h >>conftest.$ac_ext
 
5702
cat >>conftest.$ac_ext <<_ACEOF
 
5703
/* end confdefs.h.  */
 
5704
#include <sys/cdefs.h>
 
5705
      #include <mach/thread_status.h>
 
5706
 
 
5707
int
 
5708
main ()
 
5709
{
 
5710
static x86_thread_state64_t ac_aggr;
 
5711
if (sizeof ac_aggr.rax)
 
5712
return 0;
 
5713
  ;
 
5714
  return 0;
 
5715
}
 
5716
_ACEOF
 
5717
rm -f conftest.$ac_objext
 
5718
if { (ac_try="$ac_compile"
 
5719
case "(($ac_try" in
 
5720
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5721
  *) ac_try_echo=$ac_try;;
 
5722
esac
 
5723
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5724
  (eval "$ac_compile") 2>conftest.er1
 
5725
  ac_status=$?
 
5726
  grep -v '^ *+' conftest.er1 >conftest.err
 
5727
  rm -f conftest.er1
 
5728
  cat conftest.err >&5
 
5729
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5730
  (exit $ac_status); } && {
 
5731
         test -z "$ac_c_werror_flag" ||
 
5732
         test ! -s conftest.err
 
5733
       } && test -s conftest.$ac_objext; then
 
5734
  ac_cv_member_x86_thread_state64_t_rax=yes
 
5735
else
 
5736
  echo "$as_me: failed program was:" >&5
 
5737
sed 's/^/| /' conftest.$ac_ext >&5
 
5738
 
 
5739
        ac_cv_member_x86_thread_state64_t_rax=no
 
5740
fi
 
5741
 
 
5742
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5743
fi
 
5744
 
 
5745
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5746
fi
 
5747
{ echo "$as_me:$LINENO: result: $ac_cv_member_x86_thread_state64_t_rax" >&5
 
5748
echo "${ECHO_T}$ac_cv_member_x86_thread_state64_t_rax" >&6; }
 
5749
if test $ac_cv_member_x86_thread_state64_t_rax = yes; then
 
5750
 
 
5751
cat >>confdefs.h <<\_ACEOF
 
5752
#define HAS_X86_THREAD_STATE64_RAX 1
 
5753
_ACEOF
 
5754
 
 
5755
fi
 
5756
 
 
5757
    { echo "$as_me:$LINENO: checking for x86_thread_state64_t.__rax" >&5
 
5758
echo $ECHO_N "checking for x86_thread_state64_t.__rax... $ECHO_C" >&6; }
 
5759
if test "${ac_cv_member_x86_thread_state64_t___rax+set}" = set; then
 
5760
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5761
else
 
5762
  cat >conftest.$ac_ext <<_ACEOF
 
5763
/* confdefs.h.  */
 
5764
_ACEOF
 
5765
cat confdefs.h >>conftest.$ac_ext
 
5766
cat >>conftest.$ac_ext <<_ACEOF
 
5767
/* end confdefs.h.  */
 
5768
#include <sys/cdefs.h>
 
5769
      #include <mach/thread_status.h>
 
5770
 
 
5771
int
 
5772
main ()
 
5773
{
 
5774
static x86_thread_state64_t ac_aggr;
 
5775
if (ac_aggr.__rax)
 
5776
return 0;
 
5777
  ;
 
5778
  return 0;
 
5779
}
 
5780
_ACEOF
 
5781
rm -f conftest.$ac_objext
 
5782
if { (ac_try="$ac_compile"
 
5783
case "(($ac_try" in
 
5784
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5785
  *) ac_try_echo=$ac_try;;
 
5786
esac
 
5787
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5788
  (eval "$ac_compile") 2>conftest.er1
 
5789
  ac_status=$?
 
5790
  grep -v '^ *+' conftest.er1 >conftest.err
 
5791
  rm -f conftest.er1
 
5792
  cat conftest.err >&5
 
5793
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5794
  (exit $ac_status); } && {
 
5795
         test -z "$ac_c_werror_flag" ||
 
5796
         test ! -s conftest.err
 
5797
       } && test -s conftest.$ac_objext; then
 
5798
  ac_cv_member_x86_thread_state64_t___rax=yes
 
5799
else
 
5800
  echo "$as_me: failed program was:" >&5
 
5801
sed 's/^/| /' conftest.$ac_ext >&5
 
5802
 
 
5803
        cat >conftest.$ac_ext <<_ACEOF
 
5804
/* confdefs.h.  */
 
5805
_ACEOF
 
5806
cat confdefs.h >>conftest.$ac_ext
 
5807
cat >>conftest.$ac_ext <<_ACEOF
 
5808
/* end confdefs.h.  */
 
5809
#include <sys/cdefs.h>
 
5810
      #include <mach/thread_status.h>
 
5811
 
 
5812
int
 
5813
main ()
 
5814
{
 
5815
static x86_thread_state64_t ac_aggr;
 
5816
if (sizeof ac_aggr.__rax)
 
5817
return 0;
 
5818
  ;
 
5819
  return 0;
 
5820
}
 
5821
_ACEOF
 
5822
rm -f conftest.$ac_objext
 
5823
if { (ac_try="$ac_compile"
 
5824
case "(($ac_try" in
 
5825
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
5826
  *) ac_try_echo=$ac_try;;
 
5827
esac
 
5828
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
5829
  (eval "$ac_compile") 2>conftest.er1
 
5830
  ac_status=$?
 
5831
  grep -v '^ *+' conftest.er1 >conftest.err
 
5832
  rm -f conftest.er1
 
5833
  cat conftest.err >&5
 
5834
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5835
  (exit $ac_status); } && {
 
5836
         test -z "$ac_c_werror_flag" ||
 
5837
         test ! -s conftest.err
 
5838
       } && test -s conftest.$ac_objext; then
 
5839
  ac_cv_member_x86_thread_state64_t___rax=yes
 
5840
else
 
5841
  echo "$as_me: failed program was:" >&5
 
5842
sed 's/^/| /' conftest.$ac_ext >&5
 
5843
 
 
5844
        ac_cv_member_x86_thread_state64_t___rax=no
 
5845
fi
 
5846
 
 
5847
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5848
fi
 
5849
 
 
5850
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
5851
fi
 
5852
{ echo "$as_me:$LINENO: result: $ac_cv_member_x86_thread_state64_t___rax" >&5
 
5853
echo "${ECHO_T}$ac_cv_member_x86_thread_state64_t___rax" >&6; }
 
5854
if test $ac_cv_member_x86_thread_state64_t___rax = yes; then
 
5855
 
 
5856
cat >>confdefs.h <<\_ACEOF
 
5857
#define HAS_X86_THREAD_STATE64___RAX 1
 
5858
_ACEOF
 
5859
 
 
5860
fi
 
5861
 
 
5862
     ;;
 
5863
  *) ;;
 
5864
esac
4936
5865
 
4937
5866
{ echo "$as_me:$LINENO: checking for xlc" >&5
4938
5867
echo $ECHO_N "checking for xlc... $ECHO_C" >&6; }
4939
 
 
4940
5868
cat >conftest.$ac_ext <<_ACEOF
4941
5869
/* confdefs.h.  */
4942
5870
_ACEOF
4969
5897
  rm -f conftest.er1
4970
5898
  cat conftest.err >&5
4971
5899
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4972
 
  (exit $ac_status); } &&
4973
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
4974
 
  { (case "(($ac_try" in
4975
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4976
 
  *) ac_try_echo=$ac_try;;
4977
 
esac
4978
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4979
 
  (eval "$ac_try") 2>&5
4980
 
  ac_status=$?
4981
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4982
 
  (exit $ac_status); }; } &&
4983
 
         { ac_try='test -s conftest.$ac_objext'
4984
 
  { (case "(($ac_try" in
4985
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4986
 
  *) ac_try_echo=$ac_try;;
4987
 
esac
4988
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4989
 
  (eval "$ac_try") 2>&5
4990
 
  ac_status=$?
4991
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4992
 
  (exit $ac_status); }; }; then
 
5900
  (exit $ac_status); } && {
 
5901
         test -z "$ac_c_werror_flag" ||
 
5902
         test ! -s conftest.err
 
5903
       } && test -s conftest.$ac_objext; then
4993
5904
  compiler_xlc=yes
4994
5905
else
4995
5906
  echo "$as_me: failed program was:" >&5
5066
5977
  rm -f conftest.er1
5067
5978
  cat conftest.err >&5
5068
5979
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5069
 
  (exit $ac_status); } &&
5070
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
5071
 
  { (case "(($ac_try" in
5072
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5073
 
  *) ac_try_echo=$ac_try;;
5074
 
esac
5075
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5076
 
  (eval "$ac_try") 2>&5
5077
 
  ac_status=$?
5078
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5079
 
  (exit $ac_status); }; } &&
5080
 
         { ac_try='test -s conftest$ac_exeext'
5081
 
  { (case "(($ac_try" in
5082
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5083
 
  *) ac_try_echo=$ac_try;;
5084
 
esac
5085
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5086
 
  (eval "$ac_try") 2>&5
5087
 
  ac_status=$?
5088
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5089
 
  (exit $ac_status); }; }; then
 
5980
  (exit $ac_status); } && {
 
5981
         test -z "$ac_c_werror_flag" ||
 
5982
         test ! -s conftest.err
 
5983
       } && test -s conftest$ac_exeext &&
 
5984
       $as_test_x conftest$ac_exeext; then
5090
5985
  ac_cv_lib_dl_dlopen=yes
5091
5986
else
5092
5987
  echo "$as_me: failed program was:" >&5
5108
6003
    ;;
5109
6004
esac
5110
6005
 
 
6006
case "$host" in
 
6007
  *-*-hpux*)
 
6008
    avoid_cpp_lib=yes;;
 
6009
  *)
 
6010
    avoid_cpp_lib=no;
 
6011
    ;;
 
6012
esac
 
6013
 
 
6014
 
 
6015
if test $avoid_cpp_lib = yes; then
 
6016
  AVOID_CPP_LIB_TRUE=
 
6017
  AVOID_CPP_LIB_FALSE='#'
 
6018
else
 
6019
  AVOID_CPP_LIB_TRUE='#'
 
6020
  AVOID_CPP_LIB_FALSE=
 
6021
fi
 
6022
 
 
6023
 
 
6024
# extra LD Flags which are required for targets
 
6025
case "${host}" in
 
6026
  *-*-darwin*)
 
6027
    extra_ldflags_libgc=-Wl,-single_module
 
6028
    ;;
 
6029
esac
 
6030
 
 
6031
 
5111
6032
 
5112
6033
 
5113
6034
target_all=libgc.la
5124
6045
 
5125
6046
addobjs=
5126
6047
addlibs=
5127
 
addincludes=
5128
 
addtests=
5129
6048
CXXINCLUDES=
5130
6049
case "$TARGET_ECOS" in
5131
6050
   no)
5140
6059
      ;;
5141
6060
esac
5142
6061
 
5143
 
if test "${enable_cplusplus}" = yes; then
5144
 
      addincludes="$addincludes include/gc_cpp.h include/gc_allocator.h"
5145
 
      addtests="$addtests test_cpp"
5146
 
fi
5147
 
 
5148
6062
 
5149
6063
 
5150
6064
if test "${enable_cplusplus}" = yes; then
5193
6107
case "$host" in
5194
6108
 alpha-*-openbsd*)
5195
6109
     enable_shared=no
5196
 
     { echo "$as_me:$LINENO: result: no" >&5
5197
 
echo "${ECHO_T}no" >&6; }
5198
6110
     ;;
5199
6111
 *)
5200
 
     { echo "$as_me:$LINENO: result: yes" >&5
5201
 
echo "${ECHO_T}yes" >&6; }
5202
6112
     ;;
5203
6113
esac
5204
6114
 
 
6115
{ echo "$as_me:$LINENO: result: $enable_shared" >&5
 
6116
echo "${ECHO_T}$enable_shared" >&6; }
 
6117
 
5205
6118
# Configuration of machine-dependent code
5206
6119
#
5207
6120
{ echo "$as_me:$LINENO: checking which machine-dependent code should be used" >&5
5209
6122
machdep=
5210
6123
case "$host" in
5211
6124
 alpha-*-openbsd*)
5212
 
    machdep="alpha_mach_dep.lo"
 
6125
    machdep="mach_dep.lo"
5213
6126
    if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then
5214
6127
       { echo "$as_me:$LINENO: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&5
5215
6128
echo "$as_me: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&2;}
5216
6129
    fi
5217
6130
    ;;
5218
6131
 alpha*-*-linux*)
5219
 
    machdep="alpha_mach_dep.lo"
 
6132
    machdep="mach_dep.lo"
5220
6133
    ;;
5221
6134
 i?86-*-solaris2.[89] | i?86-*-solaris2.1?)
5222
6135
    cat >>confdefs.h <<\_ACEOF
5225
6138
 
5226
6139
    ;;
5227
6140
 mipstx39-*-elf*)
5228
 
    machdep="mips_ultrix_mach_dep.lo"
 
6141
    machdep="mach_dep.lo"
5229
6142
    cat >>confdefs.h <<\_ACEOF
5230
6143
#define STACKBASE __stackbase
5231
6144
_ACEOF
5236
6149
 
5237
6150
    ;;
5238
6151
 mips-dec-ultrix*)
5239
 
    machdep="mips_ultrix_mach-dep.lo"
 
6152
    machdep="mach-dep.lo"
5240
6153
    ;;
5241
6154
 mips-nec-sysv*|mips-unknown-sysv*)
5242
6155
    ;;
5243
6156
 mips*-*-linux*)
5244
6157
    ;;
5245
6158
 mips-*-*)
5246
 
    machdep="mips_sgi_mach_dep.lo"
5247
 
    cat >>confdefs.h <<\_ACEOF
5248
 
#define NO_EXECUTE_PERMISSION 1
5249
 
_ACEOF
5250
 
 
5251
 
    ;;
 
6159
    machdep="mach_dep.lo"
 
6160
                ;;
5252
6161
 sparc-*-netbsd*)
5253
 
    machdep="sparc_netbsd_mach_dep.lo"
 
6162
    machdep="mach_dep.lo sparc_netbsd_mach_dep.lo"
5254
6163
    ;;
5255
6164
 sparc-sun-solaris2.3)
5256
 
    machdep="sparc_mach_dep.lo"
 
6165
    machdep="mach_dep.lo sparc_mach_dep.lo"
5257
6166
    cat >>confdefs.h <<\_ACEOF
5258
6167
#define SUNOS53_SHARED_LIB 1
5259
6168
_ACEOF
5260
6169
 
5261
6170
    ;;
5262
6171
 sparc*-sun-solaris2.*)
5263
 
    machdep="sparc_mach_dep.lo"
 
6172
    machdep="mach_dep.lo sparc_mach_dep.lo"
5264
6173
    ;;
5265
6174
 ia64-*-*)
5266
6175
    machdep="mach_dep.lo ia64_save_regs_in_stack.lo"
5275
6184
 
5276
6185
 
5277
6186
 
5278
 
 
5279
 
 
5280
6187
# Check whether --enable-static was given.
5281
6188
if test "${enable_static+set}" = set; then
5282
6189
  enableval=$enable_static; p=${PACKAGE-default}
5403
6310
  for ac_prog in grep ggrep; do
5404
6311
  for ac_exec_ext in '' $ac_executable_extensions; do
5405
6312
    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
5406
 
    { test -f "$ac_path_GREP" && $as_executable_p "$ac_path_GREP"; } || continue
 
6313
    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
5407
6314
    # Check for GNU ac_path_GREP and select it if it is found.
5408
6315
  # Check for GNU $ac_path_GREP
5409
6316
case `"$ac_path_GREP" --version 2>&1` in
5485
6392
  for ac_prog in egrep; do
5486
6393
  for ac_exec_ext in '' $ac_executable_extensions; do
5487
6394
    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
5488
 
    { test -f "$ac_path_EGREP" && $as_executable_p "$ac_path_EGREP"; } || continue
 
6395
    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
5489
6396
    # Check for GNU ac_path_EGREP and select it if it is found.
5490
6397
  # Check for GNU $ac_path_EGREP
5491
6398
case `"$ac_path_EGREP" --version 2>&1` in
5791
6698
  lt_cv_deplibs_check_method=pass_all
5792
6699
  ;;
5793
6700
 
5794
 
freebsd* | dragonfly*)
 
6701
freebsd* | kfreebsd*-gnu | dragonfly*)
5795
6702
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
5796
6703
    case $host_cpu in
5797
6704
    i*86 )
5845
6752
  ;;
5846
6753
 
5847
6754
# This must be Linux ELF.
5848
 
linux* | k*bsd*-gnu)
 
6755
linux*)
5849
6756
  lt_cv_deplibs_check_method=pass_all
5850
6757
  ;;
5851
6758
 
5852
 
netbsd* | netbsdelf*-gnu)
 
6759
netbsd*)
5853
6760
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
5854
6761
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
5855
6762
  else
5965
6872
  ;;
5966
6873
*-*-irix6*)
5967
6874
  # Find out which ABI we are using.
5968
 
  echo '#line 5978 "configure"' > conftest.$ac_ext
 
6875
  echo '#line 6875 "configure"' > conftest.$ac_ext
5969
6876
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5970
6877
  (eval $ac_compile) 2>&5
5971
6878
  ac_status=$?
6089
6996
  rm -f conftest.er1
6090
6997
  cat conftest.err >&5
6091
6998
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6092
 
  (exit $ac_status); } &&
6093
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6094
 
  { (case "(($ac_try" in
6095
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6096
 
  *) ac_try_echo=$ac_try;;
6097
 
esac
6098
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6099
 
  (eval "$ac_try") 2>&5
6100
 
  ac_status=$?
6101
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6102
 
  (exit $ac_status); }; } &&
6103
 
         { ac_try='test -s conftest$ac_exeext'
6104
 
  { (case "(($ac_try" in
6105
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6106
 
  *) ac_try_echo=$ac_try;;
6107
 
esac
6108
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6109
 
  (eval "$ac_try") 2>&5
6110
 
  ac_status=$?
6111
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6112
 
  (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_exeext &&
 
7003
       $as_test_x conftest$ac_exeext; then
6113
7004
  lt_cv_cc_needs_belf=yes
6114
7005
else
6115
7006
  echo "$as_me: failed program was:" >&5
6212
7103
  rm -f conftest.er1
6213
7104
  cat conftest.err >&5
6214
7105
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6215
 
  (exit $ac_status); } >/dev/null; then
6216
 
  if test -s conftest.err; then
6217
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6218
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6219
 
  else
6220
 
    ac_cpp_err=
6221
 
  fi
6222
 
else
6223
 
  ac_cpp_err=yes
6224
 
fi
6225
 
if test -z "$ac_cpp_err"; then
 
7106
  (exit $ac_status); } >/dev/null && {
 
7107
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7108
         test ! -s conftest.err
 
7109
       }; then
6226
7110
  :
6227
7111
else
6228
7112
  echo "$as_me: failed program was:" >&5
6256
7140
  rm -f conftest.er1
6257
7141
  cat conftest.err >&5
6258
7142
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6259
 
  (exit $ac_status); } >/dev/null; then
6260
 
  if test -s conftest.err; then
6261
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6262
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6263
 
  else
6264
 
    ac_cpp_err=
6265
 
  fi
6266
 
else
6267
 
  ac_cpp_err=yes
6268
 
fi
6269
 
if test -z "$ac_cpp_err"; then
 
7143
  (exit $ac_status); } >/dev/null && {
 
7144
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7145
         test ! -s conftest.err
 
7146
       }; then
6270
7147
  # Broken: success on invalid input.
6271
7148
continue
6272
7149
else
6331
7208
  rm -f conftest.er1
6332
7209
  cat conftest.err >&5
6333
7210
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6334
 
  (exit $ac_status); } >/dev/null; then
6335
 
  if test -s conftest.err; then
6336
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6337
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6338
 
  else
6339
 
    ac_cpp_err=
6340
 
  fi
6341
 
else
6342
 
  ac_cpp_err=yes
6343
 
fi
6344
 
if test -z "$ac_cpp_err"; then
 
7211
  (exit $ac_status); } >/dev/null && {
 
7212
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7213
         test ! -s conftest.err
 
7214
       }; then
6345
7215
  :
6346
7216
else
6347
7217
  echo "$as_me: failed program was:" >&5
6375
7245
  rm -f conftest.er1
6376
7246
  cat conftest.err >&5
6377
7247
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6378
 
  (exit $ac_status); } >/dev/null; then
6379
 
  if test -s conftest.err; then
6380
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6381
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6382
 
  else
6383
 
    ac_cpp_err=
6384
 
  fi
6385
 
else
6386
 
  ac_cpp_err=yes
6387
 
fi
6388
 
if test -z "$ac_cpp_err"; then
 
7248
  (exit $ac_status); } >/dev/null && {
 
7249
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7250
         test ! -s conftest.err
 
7251
       }; then
6389
7252
  # Broken: success on invalid input.
6390
7253
continue
6391
7254
else
6456
7319
  rm -f conftest.er1
6457
7320
  cat conftest.err >&5
6458
7321
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6459
 
  (exit $ac_status); } &&
6460
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6461
 
  { (case "(($ac_try" in
6462
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6463
 
  *) ac_try_echo=$ac_try;;
6464
 
esac
6465
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6466
 
  (eval "$ac_try") 2>&5
6467
 
  ac_status=$?
6468
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6469
 
  (exit $ac_status); }; } &&
6470
 
         { ac_try='test -s conftest.$ac_objext'
6471
 
  { (case "(($ac_try" in
6472
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6473
 
  *) ac_try_echo=$ac_try;;
6474
 
esac
6475
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6476
 
  (eval "$ac_try") 2>&5
6477
 
  ac_status=$?
6478
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6479
 
  (exit $ac_status); }; }; then
 
7322
  (exit $ac_status); } && {
 
7323
         test -z "$ac_c_werror_flag" ||
 
7324
         test ! -s conftest.err
 
7325
       } && test -s conftest.$ac_objext; then
6480
7326
  ac_cv_header_stdc=yes
6481
7327
else
6482
7328
  echo "$as_me: failed program was:" >&5
6652
7498
  rm -f conftest.er1
6653
7499
  cat conftest.err >&5
6654
7500
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6655
 
  (exit $ac_status); } &&
6656
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6657
 
  { (case "(($ac_try" in
6658
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6659
 
  *) ac_try_echo=$ac_try;;
6660
 
esac
6661
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6662
 
  (eval "$ac_try") 2>&5
6663
 
  ac_status=$?
6664
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6665
 
  (exit $ac_status); }; } &&
6666
 
         { ac_try='test -s conftest.$ac_objext'
6667
 
  { (case "(($ac_try" in
6668
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6669
 
  *) ac_try_echo=$ac_try;;
6670
 
esac
6671
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6672
 
  (eval "$ac_try") 2>&5
6673
 
  ac_status=$?
6674
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6675
 
  (exit $ac_status); }; }; then
 
7501
  (exit $ac_status); } && {
 
7502
         test -z "$ac_c_werror_flag" ||
 
7503
         test ! -s conftest.err
 
7504
       } && test -s conftest.$ac_objext; then
6676
7505
  eval "$as_ac_Header=yes"
6677
7506
else
6678
7507
  echo "$as_me: failed program was:" >&5
6735
7564
  rm -f conftest.er1
6736
7565
  cat conftest.err >&5
6737
7566
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6738
 
  (exit $ac_status); } &&
6739
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
6740
 
  { (case "(($ac_try" in
6741
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6742
 
  *) ac_try_echo=$ac_try;;
6743
 
esac
6744
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6745
 
  (eval "$ac_try") 2>&5
6746
 
  ac_status=$?
6747
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6748
 
  (exit $ac_status); }; } &&
6749
 
         { ac_try='test -s conftest.$ac_objext'
6750
 
  { (case "(($ac_try" in
6751
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6752
 
  *) ac_try_echo=$ac_try;;
6753
 
esac
6754
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6755
 
  (eval "$ac_try") 2>&5
6756
 
  ac_status=$?
6757
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6758
 
  (exit $ac_status); }; }; then
 
7567
  (exit $ac_status); } && {
 
7568
         test -z "$ac_c_werror_flag" ||
 
7569
         test ! -s conftest.err
 
7570
       } && test -s conftest.$ac_objext; then
6759
7571
  ac_header_compiler=yes
6760
7572
else
6761
7573
  echo "$as_me: failed program was:" >&5
6791
7603
  rm -f conftest.er1
6792
7604
  cat conftest.err >&5
6793
7605
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6794
 
  (exit $ac_status); } >/dev/null; then
6795
 
  if test -s conftest.err; then
6796
 
    ac_cpp_err=$ac_c_preproc_warn_flag
6797
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6798
 
  else
6799
 
    ac_cpp_err=
6800
 
  fi
6801
 
else
6802
 
  ac_cpp_err=yes
6803
 
fi
6804
 
if test -z "$ac_cpp_err"; then
 
7606
  (exit $ac_status); } >/dev/null && {
 
7607
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
7608
         test ! -s conftest.err
 
7609
       }; then
6805
7610
  ac_header_preproc=yes
6806
7611
else
6807
7612
  echo "$as_me: failed program was:" >&5
6918
7723
  rm -f conftest.er1
6919
7724
  cat conftest.err >&5
6920
7725
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6921
 
  (exit $ac_status); } >/dev/null; then
6922
 
  if test -s conftest.err; then
6923
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
6924
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6925
 
  else
6926
 
    ac_cpp_err=
6927
 
  fi
6928
 
else
6929
 
  ac_cpp_err=yes
6930
 
fi
6931
 
if test -z "$ac_cpp_err"; then
 
7726
  (exit $ac_status); } >/dev/null && {
 
7727
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
7728
         test ! -s conftest.err
 
7729
       }; then
6932
7730
  :
6933
7731
else
6934
7732
  echo "$as_me: failed program was:" >&5
6962
7760
  rm -f conftest.er1
6963
7761
  cat conftest.err >&5
6964
7762
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6965
 
  (exit $ac_status); } >/dev/null; then
6966
 
  if test -s conftest.err; then
6967
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
6968
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
6969
 
  else
6970
 
    ac_cpp_err=
6971
 
  fi
6972
 
else
6973
 
  ac_cpp_err=yes
6974
 
fi
6975
 
if test -z "$ac_cpp_err"; then
 
7763
  (exit $ac_status); } >/dev/null && {
 
7764
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
7765
         test ! -s conftest.err
 
7766
       }; then
6976
7767
  # Broken: success on invalid input.
6977
7768
continue
6978
7769
else
7037
7828
  rm -f conftest.er1
7038
7829
  cat conftest.err >&5
7039
7830
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040
 
  (exit $ac_status); } >/dev/null; then
7041
 
  if test -s conftest.err; then
7042
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7043
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7044
 
  else
7045
 
    ac_cpp_err=
7046
 
  fi
7047
 
else
7048
 
  ac_cpp_err=yes
7049
 
fi
7050
 
if test -z "$ac_cpp_err"; then
 
7831
  (exit $ac_status); } >/dev/null && {
 
7832
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
7833
         test ! -s conftest.err
 
7834
       }; then
7051
7835
  :
7052
7836
else
7053
7837
  echo "$as_me: failed program was:" >&5
7081
7865
  rm -f conftest.er1
7082
7866
  cat conftest.err >&5
7083
7867
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7084
 
  (exit $ac_status); } >/dev/null; then
7085
 
  if test -s conftest.err; then
7086
 
    ac_cpp_err=$ac_cxx_preproc_warn_flag
7087
 
    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
7088
 
  else
7089
 
    ac_cpp_err=
7090
 
  fi
7091
 
else
7092
 
  ac_cpp_err=yes
7093
 
fi
7094
 
if test -z "$ac_cpp_err"; then
 
7868
  (exit $ac_status); } >/dev/null && {
 
7869
         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
 
7870
         test ! -s conftest.err
 
7871
       }; then
7095
7872
  # Broken: success on invalid input.
7096
7873
continue
7097
7874
else
7132
7909
ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7133
7910
ac_compiler_gnu=$ac_cv_f77_compiler_gnu
7134
7911
if test -n "$ac_tool_prefix"; then
7135
 
  for ac_prog in g77 f77 xlf frt pgf77 cf77 fort77 fl32 af77 f90 xlf90 pgf90 pghpf epcf90 gfortran g95 f95 fort xlf95 ifort ifc efc pgf95 lf95 ftn
 
7912
  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
7136
7913
  do
7137
7914
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
7138
7915
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
7150
7927
  IFS=$as_save_IFS
7151
7928
  test -z "$as_dir" && as_dir=.
7152
7929
  for ac_exec_ext in '' $ac_executable_extensions; do
7153
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7930
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7154
7931
    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
7155
7932
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7156
7933
    break 2
7176
7953
fi
7177
7954
if test -z "$F77"; then
7178
7955
  ac_ct_F77=$F77
7179
 
  for ac_prog in g77 f77 xlf frt pgf77 cf77 fort77 fl32 af77 f90 xlf90 pgf90 pghpf epcf90 gfortran g95 f95 fort xlf95 ifort ifc efc pgf95 lf95 ftn
 
7956
  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
7180
7957
do
7181
7958
  # Extract the first word of "$ac_prog", so it can be a program name with args.
7182
7959
set dummy $ac_prog; ac_word=$2
7194
7971
  IFS=$as_save_IFS
7195
7972
  test -z "$as_dir" && as_dir=.
7196
7973
  for ac_exec_ext in '' $ac_executable_extensions; do
7197
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7974
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7198
7975
    ac_cv_prog_ac_ct_F77="$ac_prog"
7199
7976
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7200
7977
    break 2
7301
8078
  rm -f conftest.er1
7302
8079
  cat conftest.err >&5
7303
8080
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7304
 
  (exit $ac_status); } &&
7305
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
7306
 
  { (case "(($ac_try" in
7307
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7308
 
  *) ac_try_echo=$ac_try;;
7309
 
esac
7310
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7311
 
  (eval "$ac_try") 2>&5
7312
 
  ac_status=$?
7313
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7314
 
  (exit $ac_status); }; } &&
7315
 
         { ac_try='test -s conftest.$ac_objext'
7316
 
  { (case "(($ac_try" in
7317
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7318
 
  *) ac_try_echo=$ac_try;;
7319
 
esac
7320
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7321
 
  (eval "$ac_try") 2>&5
7322
 
  ac_status=$?
7323
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7324
 
  (exit $ac_status); }; }; then
 
8081
  (exit $ac_status); } && {
 
8082
         test -z "$ac_f77_werror_flag" ||
 
8083
         test ! -s conftest.err
 
8084
       } && test -s conftest.$ac_objext; then
7325
8085
  ac_compiler_gnu=yes
7326
8086
else
7327
8087
  echo "$as_me: failed program was:" >&5
7364
8124
  rm -f conftest.er1
7365
8125
  cat conftest.err >&5
7366
8126
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7367
 
  (exit $ac_status); } &&
7368
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
7369
 
  { (case "(($ac_try" in
7370
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7371
 
  *) ac_try_echo=$ac_try;;
7372
 
esac
7373
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7374
 
  (eval "$ac_try") 2>&5
7375
 
  ac_status=$?
7376
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7377
 
  (exit $ac_status); }; } &&
7378
 
         { ac_try='test -s conftest.$ac_objext'
7379
 
  { (case "(($ac_try" in
7380
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7381
 
  *) ac_try_echo=$ac_try;;
7382
 
esac
7383
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7384
 
  (eval "$ac_try") 2>&5
7385
 
  ac_status=$?
7386
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7387
 
  (exit $ac_status); }; }; then
 
8127
  (exit $ac_status); } && {
 
8128
         test -z "$ac_f77_werror_flag" ||
 
8129
         test ! -s conftest.err
 
8130
       } && test -s conftest.$ac_objext; then
7388
8131
  ac_cv_prog_f77_g=yes
7389
8132
else
7390
8133
  echo "$as_me: failed program was:" >&5
7582
8325
  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
7583
8326
  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
7584
8327
  ;;
7585
 
linux* | k*bsd*-gnu)
 
8328
linux*)
7586
8329
  if test "$host_cpu" = ia64; then
7587
8330
    symcode='[ABCDGIRSTW]'
7588
8331
    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
7839
8582
  IFS=$as_save_IFS
7840
8583
  test -z "$as_dir" && as_dir=.
7841
8584
  for ac_exec_ext in '' $ac_executable_extensions; do
7842
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8585
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7843
8586
    ac_cv_prog_AR="${ac_tool_prefix}ar"
7844
8587
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7845
8588
    break 2
7879
8622
  IFS=$as_save_IFS
7880
8623
  test -z "$as_dir" && as_dir=.
7881
8624
  for ac_exec_ext in '' $ac_executable_extensions; do
7882
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8625
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7883
8626
    ac_cv_prog_ac_ct_AR="ar"
7884
8627
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7885
8628
    break 2
7935
8678
  IFS=$as_save_IFS
7936
8679
  test -z "$as_dir" && as_dir=.
7937
8680
  for ac_exec_ext in '' $ac_executable_extensions; do
7938
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8681
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7939
8682
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
7940
8683
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7941
8684
    break 2
7975
8718
  IFS=$as_save_IFS
7976
8719
  test -z "$as_dir" && as_dir=.
7977
8720
  for ac_exec_ext in '' $ac_executable_extensions; do
7978
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8721
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7979
8722
    ac_cv_prog_ac_ct_RANLIB="ranlib"
7980
8723
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7981
8724
    break 2
8031
8774
  IFS=$as_save_IFS
8032
8775
  test -z "$as_dir" && as_dir=.
8033
8776
  for ac_exec_ext in '' $ac_executable_extensions; do
8034
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8777
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8035
8778
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
8036
8779
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8037
8780
    break 2
8071
8814
  IFS=$as_save_IFS
8072
8815
  test -z "$as_dir" && as_dir=.
8073
8816
  for ac_exec_ext in '' $ac_executable_extensions; do
8074
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; }; then
 
8817
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
8075
8818
    ac_cv_prog_ac_ct_STRIP="strip"
8076
8819
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8077
8820
    break 2
8363
9106
$rm conftest*
8364
9107
 
8365
9108
 
 
9109
## CAVEAT EMPTOR:
 
9110
## There is no encapsulation within the following macros, do not change
 
9111
## the running order or otherwise move them around unless you know exactly
 
9112
## what you are doing...
8366
9113
 
8367
9114
lt_prog_compiler_no_builtin_flag=
8368
9115
 
8388
9135
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8389
9136
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8390
9137
   -e 's:$: $lt_compiler_flag:'`
8391
 
   (eval echo "\"\$as_me:8401: $lt_compile\"" >&5)
 
9138
   (eval echo "\"\$as_me:9138: $lt_compile\"" >&5)
8392
9139
   (eval "$lt_compile" 2>conftest.err)
8393
9140
   ac_status=$?
8394
9141
   cat conftest.err >&5
8395
 
   echo "$as_me:8405: \$? = $ac_status" >&5
 
9142
   echo "$as_me:9142: \$? = $ac_status" >&5
8396
9143
   if (exit $ac_status) && test -s "$ac_outfile"; then
8397
9144
     # The compiler can only warn and ignore the option if not recognized
8398
9145
     # So say no if there are warnings other than the usual output.
8550
9297
      lt_prog_compiler_static='-Bstatic'
8551
9298
      ;;
8552
9299
 
8553
 
    linux* | k*bsd*-gnu)
 
9300
    linux*)
8554
9301
      case $cc_basename in
8555
9302
      icc* | ecc*)
8556
9303
        lt_prog_compiler_wl='-Wl,'
8656
9403
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8657
9404
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8658
9405
   -e 's:$: $lt_compiler_flag:'`
8659
 
   (eval echo "\"\$as_me:8669: $lt_compile\"" >&5)
 
9406
   (eval echo "\"\$as_me:9406: $lt_compile\"" >&5)
8660
9407
   (eval "$lt_compile" 2>conftest.err)
8661
9408
   ac_status=$?
8662
9409
   cat conftest.err >&5
8663
 
   echo "$as_me:8673: \$? = $ac_status" >&5
 
9410
   echo "$as_me:9410: \$? = $ac_status" >&5
8664
9411
   if (exit $ac_status) && test -s "$ac_outfile"; then
8665
9412
     # The compiler can only warn and ignore the option if not recognized
8666
9413
     # So say no if there are warnings other than the usual output.
8760
9507
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8761
9508
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8762
9509
   -e 's:$: $lt_compiler_flag:'`
8763
 
   (eval echo "\"\$as_me:8773: $lt_compile\"" >&5)
 
9510
   (eval echo "\"\$as_me:9510: $lt_compile\"" >&5)
8764
9511
   (eval "$lt_compile" 2>out/conftest.err)
8765
9512
   ac_status=$?
8766
9513
   cat out/conftest.err >&5
8767
 
   echo "$as_me:8777: \$? = $ac_status" >&5
 
9514
   echo "$as_me:9514: \$? = $ac_status" >&5
8768
9515
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8769
9516
   then
8770
9517
     # The compiler can only warn and ignore the option if not recognized
8989
9736
      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
8990
9737
      ;;
8991
9738
 
8992
 
    linux* | k*bsd*-gnu)
 
9739
    linux*)
8993
9740
      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
8994
9741
        tmp_addflag=
8995
9742
        case $cc_basename,$host_cpu in
9015
9762
  $echo "local: *; };" >> $output_objdir/$libname.ver~
9016
9763
          $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
9017
9764
        fi
9018
 
        link_all_deplibs=no
9019
9765
      else
9020
9766
        ld_shlibs=no
9021
9767
      fi
9022
9768
      ;;
9023
9769
 
9024
 
    netbsd* | netbsdelf*-gnu)
 
9770
    netbsd*)
9025
9771
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
9026
9772
        archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
9027
9773
        wlarc=
9241
9987
  rm -f conftest.er1
9242
9988
  cat conftest.err >&5
9243
9989
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9244
 
  (exit $ac_status); } &&
9245
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9246
 
  { (case "(($ac_try" in
9247
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9248
 
  *) ac_try_echo=$ac_try;;
9249
 
esac
9250
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9251
 
  (eval "$ac_try") 2>&5
9252
 
  ac_status=$?
9253
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9254
 
  (exit $ac_status); }; } &&
9255
 
         { ac_try='test -s conftest$ac_exeext'
9256
 
  { (case "(($ac_try" in
9257
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9258
 
  *) ac_try_echo=$ac_try;;
9259
 
esac
9260
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9261
 
  (eval "$ac_try") 2>&5
9262
 
  ac_status=$?
9263
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9264
 
  (exit $ac_status); }; }; then
 
9990
  (exit $ac_status); } && {
 
9991
         test -z "$ac_c_werror_flag" ||
 
9992
         test ! -s conftest.err
 
9993
       } && test -s conftest$ac_exeext &&
 
9994
       $as_test_x conftest$ac_exeext; then
9265
9995
 
9266
9996
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
9267
9997
}'`
9316
10046
  rm -f conftest.er1
9317
10047
  cat conftest.err >&5
9318
10048
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9319
 
  (exit $ac_status); } &&
9320
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
9321
 
  { (case "(($ac_try" in
9322
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9323
 
  *) ac_try_echo=$ac_try;;
9324
 
esac
9325
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9326
 
  (eval "$ac_try") 2>&5
9327
 
  ac_status=$?
9328
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9329
 
  (exit $ac_status); }; } &&
9330
 
         { ac_try='test -s conftest$ac_exeext'
9331
 
  { (case "(($ac_try" in
9332
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9333
 
  *) ac_try_echo=$ac_try;;
9334
 
esac
9335
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9336
 
  (eval "$ac_try") 2>&5
9337
 
  ac_status=$?
9338
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9339
 
  (exit $ac_status); }; }; then
 
10049
  (exit $ac_status); } && {
 
10050
         test -z "$ac_c_werror_flag" ||
 
10051
         test ! -s conftest.err
 
10052
       } && test -s conftest$ac_exeext &&
 
10053
       $as_test_x conftest$ac_exeext; then
9340
10054
 
9341
10055
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
9342
10056
}'`
9481
10195
      ;;
9482
10196
 
9483
10197
    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
9484
 
    freebsd* | dragonfly*)
 
10198
    freebsd* | kfreebsd*-gnu | dragonfly*)
9485
10199
      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
9486
10200
      hardcode_libdir_flag_spec='-R$libdir'
9487
10201
      hardcode_direct=yes
9583
10297
      link_all_deplibs=yes
9584
10298
      ;;
9585
10299
 
9586
 
    netbsd* | netbsdelf*-gnu)
 
10300
    netbsd*)
9587
10301
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
9588
10302
        archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
9589
10303
      else
10073
10787
  dynamic_linker=no
10074
10788
  ;;
10075
10789
 
 
10790
kfreebsd*-gnu)
 
10791
  version_type=linux
 
10792
  need_lib_prefix=no
 
10793
  need_version=no
 
10794
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
10795
  soname_spec='${libname}${release}${shared_ext}$major'
 
10796
  shlibpath_var=LD_LIBRARY_PATH
 
10797
  shlibpath_overrides_runpath=no
 
10798
  hardcode_into_libs=yes
 
10799
  dynamic_linker='GNU ld.so'
 
10800
  ;;
 
10801
 
10076
10802
freebsd* | dragonfly*)
10077
10803
  # DragonFly does not have aout.  When/if they implement a new
10078
10804
  # versioning mechanism, adjust this.
10228
10954
  ;;
10229
10955
 
10230
10956
# This must be Linux ELF.
10231
 
linux* | k*bsd*-gnu)
 
10957
linux*)
10232
10958
  version_type=linux
10233
10959
  need_lib_prefix=no
10234
10960
  need_version=no
10257
10983
  dynamic_linker='GNU/Linux ld.so'
10258
10984
  ;;
10259
10985
 
10260
 
netbsdelf*-gnu)
 
10986
knetbsd*-gnu)
10261
10987
  version_type=linux
10262
10988
  need_lib_prefix=no
10263
10989
  need_version=no
10266
10992
  shlibpath_var=LD_LIBRARY_PATH
10267
10993
  shlibpath_overrides_runpath=no
10268
10994
  hardcode_into_libs=yes
10269
 
  dynamic_linker='NetBSD ld.elf_so'
 
10995
  dynamic_linker='GNU ld.so'
10270
10996
  ;;
10271
10997
 
10272
10998
netbsd*)
10586
11312
  rm -f conftest.er1
10587
11313
  cat conftest.err >&5
10588
11314
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10589
 
  (exit $ac_status); } &&
10590
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10591
 
  { (case "(($ac_try" in
10592
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10593
 
  *) ac_try_echo=$ac_try;;
10594
 
esac
10595
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10596
 
  (eval "$ac_try") 2>&5
10597
 
  ac_status=$?
10598
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10599
 
  (exit $ac_status); }; } &&
10600
 
         { ac_try='test -s conftest$ac_exeext'
10601
 
  { (case "(($ac_try" in
10602
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10603
 
  *) ac_try_echo=$ac_try;;
10604
 
esac
10605
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10606
 
  (eval "$ac_try") 2>&5
10607
 
  ac_status=$?
10608
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10609
 
  (exit $ac_status); }; }; then
 
11315
  (exit $ac_status); } && {
 
11316
         test -z "$ac_c_werror_flag" ||
 
11317
         test ! -s conftest.err
 
11318
       } && test -s conftest$ac_exeext &&
 
11319
       $as_test_x conftest$ac_exeext; then
10610
11320
  ac_cv_lib_dl_dlopen=yes
10611
11321
else
10612
11322
  echo "$as_me: failed program was:" >&5
10697
11407
  rm -f conftest.er1
10698
11408
  cat conftest.err >&5
10699
11409
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10700
 
  (exit $ac_status); } &&
10701
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10702
 
  { (case "(($ac_try" in
10703
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10704
 
  *) ac_try_echo=$ac_try;;
10705
 
esac
10706
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10707
 
  (eval "$ac_try") 2>&5
10708
 
  ac_status=$?
10709
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10710
 
  (exit $ac_status); }; } &&
10711
 
         { ac_try='test -s conftest$ac_exeext'
10712
 
  { (case "(($ac_try" in
10713
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10714
 
  *) ac_try_echo=$ac_try;;
10715
 
esac
10716
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10717
 
  (eval "$ac_try") 2>&5
10718
 
  ac_status=$?
10719
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10720
 
  (exit $ac_status); }; }; then
 
11410
  (exit $ac_status); } && {
 
11411
         test -z "$ac_c_werror_flag" ||
 
11412
         test ! -s conftest.err
 
11413
       } && test -s conftest$ac_exeext &&
 
11414
       $as_test_x conftest$ac_exeext; then
10721
11415
  ac_cv_func_shl_load=yes
10722
11416
else
10723
11417
  echo "$as_me: failed program was:" >&5
10776
11470
  rm -f conftest.er1
10777
11471
  cat conftest.err >&5
10778
11472
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10779
 
  (exit $ac_status); } &&
10780
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10781
 
  { (case "(($ac_try" in
10782
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10783
 
  *) ac_try_echo=$ac_try;;
10784
 
esac
10785
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10786
 
  (eval "$ac_try") 2>&5
10787
 
  ac_status=$?
10788
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10789
 
  (exit $ac_status); }; } &&
10790
 
         { ac_try='test -s conftest$ac_exeext'
10791
 
  { (case "(($ac_try" in
10792
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10793
 
  *) ac_try_echo=$ac_try;;
10794
 
esac
10795
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10796
 
  (eval "$ac_try") 2>&5
10797
 
  ac_status=$?
10798
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10799
 
  (exit $ac_status); }; }; then
 
11473
  (exit $ac_status); } && {
 
11474
         test -z "$ac_c_werror_flag" ||
 
11475
         test ! -s conftest.err
 
11476
       } && test -s conftest$ac_exeext &&
 
11477
       $as_test_x conftest$ac_exeext; then
10800
11478
  ac_cv_lib_dld_shl_load=yes
10801
11479
else
10802
11480
  echo "$as_me: failed program was:" >&5
10877
11555
  rm -f conftest.er1
10878
11556
  cat conftest.err >&5
10879
11557
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880
 
  (exit $ac_status); } &&
10881
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10882
 
  { (case "(($ac_try" in
10883
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10884
 
  *) ac_try_echo=$ac_try;;
10885
 
esac
10886
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10887
 
  (eval "$ac_try") 2>&5
10888
 
  ac_status=$?
10889
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10890
 
  (exit $ac_status); }; } &&
10891
 
         { ac_try='test -s conftest$ac_exeext'
10892
 
  { (case "(($ac_try" in
10893
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10894
 
  *) ac_try_echo=$ac_try;;
10895
 
esac
10896
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10897
 
  (eval "$ac_try") 2>&5
10898
 
  ac_status=$?
10899
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10900
 
  (exit $ac_status); }; }; then
 
11558
  (exit $ac_status); } && {
 
11559
         test -z "$ac_c_werror_flag" ||
 
11560
         test ! -s conftest.err
 
11561
       } && test -s conftest$ac_exeext &&
 
11562
       $as_test_x conftest$ac_exeext; then
10901
11563
  ac_cv_func_dlopen=yes
10902
11564
else
10903
11565
  echo "$as_me: failed program was:" >&5
10956
11618
  rm -f conftest.er1
10957
11619
  cat conftest.err >&5
10958
11620
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10959
 
  (exit $ac_status); } &&
10960
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
10961
 
  { (case "(($ac_try" in
10962
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10963
 
  *) ac_try_echo=$ac_try;;
10964
 
esac
10965
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10966
 
  (eval "$ac_try") 2>&5
10967
 
  ac_status=$?
10968
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10969
 
  (exit $ac_status); }; } &&
10970
 
         { ac_try='test -s conftest$ac_exeext'
10971
 
  { (case "(($ac_try" in
10972
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10973
 
  *) ac_try_echo=$ac_try;;
10974
 
esac
10975
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10976
 
  (eval "$ac_try") 2>&5
10977
 
  ac_status=$?
10978
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10979
 
  (exit $ac_status); }; }; then
 
11621
  (exit $ac_status); } && {
 
11622
         test -z "$ac_c_werror_flag" ||
 
11623
         test ! -s conftest.err
 
11624
       } && test -s conftest$ac_exeext &&
 
11625
       $as_test_x conftest$ac_exeext; then
10980
11626
  ac_cv_lib_dl_dlopen=yes
10981
11627
else
10982
11628
  echo "$as_me: failed program was:" >&5
11036
11682
  rm -f conftest.er1
11037
11683
  cat conftest.err >&5
11038
11684
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11039
 
  (exit $ac_status); } &&
11040
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
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); }; } &&
11050
 
         { ac_try='test -s conftest$ac_exeext'
11051
 
  { (case "(($ac_try" in
11052
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11053
 
  *) ac_try_echo=$ac_try;;
11054
 
esac
11055
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11056
 
  (eval "$ac_try") 2>&5
11057
 
  ac_status=$?
11058
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11059
 
  (exit $ac_status); }; }; then
 
11685
  (exit $ac_status); } && {
 
11686
         test -z "$ac_c_werror_flag" ||
 
11687
         test ! -s conftest.err
 
11688
       } && test -s conftest$ac_exeext &&
 
11689
       $as_test_x conftest$ac_exeext; then
11060
11690
  ac_cv_lib_svld_dlopen=yes
11061
11691
else
11062
11692
  echo "$as_me: failed program was:" >&5
11116
11746
  rm -f conftest.er1
11117
11747
  cat conftest.err >&5
11118
11748
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11119
 
  (exit $ac_status); } &&
11120
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
11121
 
  { (case "(($ac_try" in
11122
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11123
 
  *) ac_try_echo=$ac_try;;
11124
 
esac
11125
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11126
 
  (eval "$ac_try") 2>&5
11127
 
  ac_status=$?
11128
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11129
 
  (exit $ac_status); }; } &&
11130
 
         { ac_try='test -s conftest$ac_exeext'
11131
 
  { (case "(($ac_try" in
11132
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11133
 
  *) ac_try_echo=$ac_try;;
11134
 
esac
11135
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11136
 
  (eval "$ac_try") 2>&5
11137
 
  ac_status=$?
11138
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11139
 
  (exit $ac_status); }; }; then
 
11749
  (exit $ac_status); } && {
 
11750
         test -z "$ac_c_werror_flag" ||
 
11751
         test ! -s conftest.err
 
11752
       } && test -s conftest$ac_exeext &&
 
11753
       $as_test_x conftest$ac_exeext; then
11140
11754
  ac_cv_lib_dld_dld_link=yes
11141
11755
else
11142
11756
  echo "$as_me: failed program was:" >&5
11201
11815
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11202
11816
  lt_status=$lt_dlunknown
11203
11817
  cat > conftest.$ac_ext <<EOF
11204
 
#line 11214 "configure"
 
11818
#line 11818 "configure"
11205
11819
#include "confdefs.h"
11206
11820
 
11207
11821
#if HAVE_DLFCN_H
11301
11915
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11302
11916
  lt_status=$lt_dlunknown
11303
11917
  cat > conftest.$ac_ext <<EOF
11304
 
#line 11314 "configure"
 
11918
#line 11918 "configure"
11305
11919
#include "confdefs.h"
11306
11920
 
11307
11921
#if HAVE_DLFCN_H
12388
13002
  rm -f conftest.er1
12389
13003
  cat conftest.err >&5
12390
13004
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12391
 
  (exit $ac_status); } &&
12392
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
12393
 
  { (case "(($ac_try" in
12394
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12395
 
  *) ac_try_echo=$ac_try;;
12396
 
esac
12397
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12398
 
  (eval "$ac_try") 2>&5
12399
 
  ac_status=$?
12400
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12401
 
  (exit $ac_status); }; } &&
12402
 
         { ac_try='test -s conftest$ac_exeext'
12403
 
  { (case "(($ac_try" in
12404
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12405
 
  *) ac_try_echo=$ac_try;;
12406
 
esac
12407
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12408
 
  (eval "$ac_try") 2>&5
12409
 
  ac_status=$?
12410
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12411
 
  (exit $ac_status); }; }; then
 
13005
  (exit $ac_status); } && {
 
13006
         test -z "$ac_cxx_werror_flag" ||
 
13007
         test ! -s conftest.err
 
13008
       } && test -s conftest$ac_exeext &&
 
13009
       $as_test_x conftest$ac_exeext; then
12412
13010
 
12413
13011
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
12414
13012
}'`
12464
13062
  rm -f conftest.er1
12465
13063
  cat conftest.err >&5
12466
13064
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12467
 
  (exit $ac_status); } &&
12468
 
         { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
12469
 
  { (case "(($ac_try" in
12470
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12471
 
  *) ac_try_echo=$ac_try;;
12472
 
esac
12473
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12474
 
  (eval "$ac_try") 2>&5
12475
 
  ac_status=$?
12476
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12477
 
  (exit $ac_status); }; } &&
12478
 
         { ac_try='test -s conftest$ac_exeext'
12479
 
  { (case "(($ac_try" in
12480
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12481
 
  *) ac_try_echo=$ac_try;;
12482
 
esac
12483
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12484
 
  (eval "$ac_try") 2>&5
12485
 
  ac_status=$?
12486
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12487
 
  (exit $ac_status); }; }; then
 
13065
  (exit $ac_status); } && {
 
13066
         test -z "$ac_cxx_werror_flag" ||
 
13067
         test ! -s conftest.err
 
13068
       } && test -s conftest$ac_exeext &&
 
13069
       $as_test_x conftest$ac_exeext; then
12488
13070
 
12489
13071
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
12490
13072
}'`
12646
13228
  freebsd-elf*)
12647
13229
    archive_cmds_need_lc_CXX=no
12648
13230
    ;;
12649
 
  freebsd* | dragonfly*)
 
13231
  freebsd* | kfreebsd*-gnu | dragonfly*)
12650
13232
    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
12651
13233
    # conventions
12652
13234
    ld_shlibs_CXX=yes
12805
13387
    hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
12806
13388
    hardcode_libdir_separator_CXX=:
12807
13389
    ;;
12808
 
  linux* | k*bsd*-gnu)
 
13390
  linux*)
12809
13391
    case $cc_basename in
12810
13392
      KCC*)
12811
13393
        # Kuck and Associates, Inc. (KAI) C++ Compiler
12907
13489
        ;;
12908
13490
    esac
12909
13491
    ;;
12910
 
  netbsd* | netbsdelf*-gnu)
 
13492
  netbsd*)
12911
13493
    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
12912
13494
      archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
12913
13495
      wlarc=
13236
13818
GCC_CXX="$GXX"
13237
13819
LD_CXX="$LD"
13238
13820
 
 
13821
## CAVEAT EMPTOR:
 
13822
## There is no encapsulation within the following macros, do not change
 
13823
## the running order or otherwise move them around unless you know exactly
 
13824
## what you are doing...
13239
13825
 
13240
13826
cat > conftest.$ac_ext <<EOF
13241
13827
class Foo
13474
14060
            ;;
13475
14061
        esac
13476
14062
        ;;
13477
 
      freebsd* | dragonfly*)
 
14063
      freebsd* | kfreebsd*-gnu | dragonfly*)
13478
14064
        # FreeBSD uses GNU C++
13479
14065
        ;;
13480
14066
      hpux9* | hpux10* | hpux11*)
13517
14103
            ;;
13518
14104
        esac
13519
14105
        ;;
13520
 
      linux* | k*bsd*-gnu)
 
14106
      linux*)
13521
14107
        case $cc_basename in
13522
14108
          KCC*)
13523
14109
            # KAI C++ Compiler
13560
14146
            ;;
13561
14147
        esac
13562
14148
        ;;
13563
 
      netbsd* | netbsdelf*-gnu)
 
14149
      netbsd*)
13564
14150
        ;;
13565
14151
      osf3* | osf4* | osf5*)
13566
14152
        case $cc_basename in
13669
14255
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13670
14256
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13671
14257
   -e 's:$: $lt_compiler_flag:'`
13672
 
   (eval echo "\"\$as_me:13682: $lt_compile\"" >&5)
 
14258
   (eval echo "\"\$as_me:14258: $lt_compile\"" >&5)
13673
14259
   (eval "$lt_compile" 2>conftest.err)
13674
14260
   ac_status=$?
13675
14261
   cat conftest.err >&5
13676
 
   echo "$as_me:13686: \$? = $ac_status" >&5
 
14262
   echo "$as_me:14262: \$? = $ac_status" >&5
13677
14263
   if (exit $ac_status) && test -s "$ac_outfile"; then
13678
14264
     # The compiler can only warn and ignore the option if not recognized
13679
14265
     # So say no if there are warnings other than the usual output.
13773
14359
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13774
14360
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13775
14361
   -e 's:$: $lt_compiler_flag:'`
13776
 
   (eval echo "\"\$as_me:13786: $lt_compile\"" >&5)
 
14362
   (eval echo "\"\$as_me:14362: $lt_compile\"" >&5)
13777
14363
   (eval "$lt_compile" 2>out/conftest.err)
13778
14364
   ac_status=$?
13779
14365
   cat out/conftest.err >&5
13780
 
   echo "$as_me:13790: \$? = $ac_status" >&5
 
14366
   echo "$as_me:14366: \$? = $ac_status" >&5
13781
14367
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13782
14368
   then
13783
14369
     # The compiler can only warn and ignore the option if not recognized
13845
14431
  cygwin* | mingw*)
13846
14432
    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS] /s/.* \([^ ]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([^ ]*\) [^ ]*/\1 DATA/;/^I /d;/^[AITW] /s/.* //'\'' | sort | uniq > $export_symbols'
13847
14433
  ;;
13848
 
  linux* | k*bsd*-gnu)
13849
 
    link_all_deplibs_CXX=no
13850
 
  ;;
13851
14434
  *)
13852
14435
    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
13853
14436
  ;;
14127
14710
  dynamic_linker=no
14128
14711
  ;;
14129
14712
 
 
14713
kfreebsd*-gnu)
 
14714
  version_type=linux
 
14715
  need_lib_prefix=no
 
14716
  need_version=no
 
14717
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
14718
  soname_spec='${libname}${release}${shared_ext}$major'
 
14719
  shlibpath_var=LD_LIBRARY_PATH
 
14720
  shlibpath_overrides_runpath=no
 
14721
  hardcode_into_libs=yes
 
14722
  dynamic_linker='GNU ld.so'
 
14723
  ;;
 
14724
 
14130
14725
freebsd* | dragonfly*)
14131
14726
  # DragonFly does not have aout.  When/if they implement a new
14132
14727
  # versioning mechanism, adjust this.
14282
14877
  ;;
14283
14878
 
14284
14879
# This must be Linux ELF.
14285
 
linux* | k*bsd*-gnu)
 
14880
linux*)
14286
14881
  version_type=linux
14287
14882
  need_lib_prefix=no
14288
14883
  need_version=no
14311
14906
  dynamic_linker='GNU/Linux ld.so'
14312
14907
  ;;
14313
14908
 
14314
 
netbsdelf*-gnu)
 
14909
knetbsd*-gnu)
14315
14910
  version_type=linux
14316
14911
  need_lib_prefix=no
14317
14912
  need_version=no
14320
14915
  shlibpath_var=LD_LIBRARY_PATH
14321
14916
  shlibpath_overrides_runpath=no
14322
14917
  hardcode_into_libs=yes
14323
 
  dynamic_linker='NetBSD ld.elf_so'
 
14918
  dynamic_linker='GNU ld.so'
14324
14919
  ;;
14325
14920
 
14326
14921
netbsd*)
15228
15823
      lt_prog_compiler_static_F77='-Bstatic'
15229
15824
      ;;
15230
15825
 
15231
 
    linux* | k*bsd*-gnu)
 
15826
    linux*)
15232
15827
      case $cc_basename in
15233
15828
      icc* | ecc*)
15234
15829
        lt_prog_compiler_wl_F77='-Wl,'
15334
15929
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15335
15930
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15336
15931
   -e 's:$: $lt_compiler_flag:'`
15337
 
   (eval echo "\"\$as_me:15347: $lt_compile\"" >&5)
 
15932
   (eval echo "\"\$as_me:15932: $lt_compile\"" >&5)
15338
15933
   (eval "$lt_compile" 2>conftest.err)
15339
15934
   ac_status=$?
15340
15935
   cat conftest.err >&5
15341
 
   echo "$as_me:15351: \$? = $ac_status" >&5
 
15936
   echo "$as_me:15936: \$? = $ac_status" >&5
15342
15937
   if (exit $ac_status) && test -s "$ac_outfile"; then
15343
15938
     # The compiler can only warn and ignore the option if not recognized
15344
15939
     # So say no if there are warnings other than the usual output.
15438
16033
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
15439
16034
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
15440
16035
   -e 's:$: $lt_compiler_flag:'`
15441
 
   (eval echo "\"\$as_me:15451: $lt_compile\"" >&5)
 
16036
   (eval echo "\"\$as_me:16036: $lt_compile\"" >&5)
15442
16037
   (eval "$lt_compile" 2>out/conftest.err)
15443
16038
   ac_status=$?
15444
16039
   cat out/conftest.err >&5
15445
 
   echo "$as_me:15455: \$? = $ac_status" >&5
 
16040
   echo "$as_me:16040: \$? = $ac_status" >&5
15446
16041
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
15447
16042
   then
15448
16043
     # The compiler can only warn and ignore the option if not recognized
15667
16262
      archive_expsym_cmds_F77='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
15668
16263
      ;;
15669
16264
 
15670
 
    linux* | k*bsd*-gnu)
 
16265
    linux*)
15671
16266
      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
15672
16267
        tmp_addflag=
15673
16268
        case $cc_basename,$host_cpu in
15693
16288
  $echo "local: *; };" >> $output_objdir/$libname.ver~
15694
16289
          $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
15695
16290
        fi
15696
 
        link_all_deplibs_F77=no
15697
16291
      else
15698
16292
        ld_shlibs_F77=no
15699
16293
      fi
15700
16294
      ;;
15701
16295
 
15702
 
    netbsd* | netbsdelf*-gnu)
 
16296
    netbsd*)
15703
16297
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
15704
16298
        archive_cmds_F77='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
15705
16299
        wlarc=
15909
16503
  rm -f conftest.er1
15910
16504
  cat conftest.err >&5
15911
16505
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15912
 
  (exit $ac_status); } &&
15913
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
15914
 
  { (case "(($ac_try" in
15915
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
15916
 
  *) ac_try_echo=$ac_try;;
15917
 
esac
15918
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
15919
 
  (eval "$ac_try") 2>&5
15920
 
  ac_status=$?
15921
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15922
 
  (exit $ac_status); }; } &&
15923
 
         { ac_try='test -s conftest$ac_exeext'
15924
 
  { (case "(($ac_try" in
15925
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
15926
 
  *) ac_try_echo=$ac_try;;
15927
 
esac
15928
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
15929
 
  (eval "$ac_try") 2>&5
15930
 
  ac_status=$?
15931
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15932
 
  (exit $ac_status); }; }; then
 
16506
  (exit $ac_status); } && {
 
16507
         test -z "$ac_f77_werror_flag" ||
 
16508
         test ! -s conftest.err
 
16509
       } && test -s conftest$ac_exeext &&
 
16510
       $as_test_x conftest$ac_exeext; then
15933
16511
 
15934
16512
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
15935
16513
}'`
15974
16552
  rm -f conftest.er1
15975
16553
  cat conftest.err >&5
15976
16554
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15977
 
  (exit $ac_status); } &&
15978
 
         { ac_try='test -z "$ac_f77_werror_flag" || test ! -s conftest.err'
15979
 
  { (case "(($ac_try" in
15980
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
15981
 
  *) ac_try_echo=$ac_try;;
15982
 
esac
15983
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
15984
 
  (eval "$ac_try") 2>&5
15985
 
  ac_status=$?
15986
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15987
 
  (exit $ac_status); }; } &&
15988
 
         { ac_try='test -s conftest$ac_exeext'
15989
 
  { (case "(($ac_try" in
15990
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
15991
 
  *) ac_try_echo=$ac_try;;
15992
 
esac
15993
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
15994
 
  (eval "$ac_try") 2>&5
15995
 
  ac_status=$?
15996
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
15997
 
  (exit $ac_status); }; }; then
 
16555
  (exit $ac_status); } && {
 
16556
         test -z "$ac_f77_werror_flag" ||
 
16557
         test ! -s conftest.err
 
16558
       } && test -s conftest$ac_exeext &&
 
16559
       $as_test_x conftest$ac_exeext; then
15998
16560
 
15999
16561
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
16000
16562
}'`
16139
16701
      ;;
16140
16702
 
16141
16703
    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
16142
 
    freebsd* | dragonfly*)
 
16704
    freebsd* | kfreebsd*-gnu | dragonfly*)
16143
16705
      archive_cmds_F77='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
16144
16706
      hardcode_libdir_flag_spec_F77='-R$libdir'
16145
16707
      hardcode_direct_F77=yes
16241
16803
      link_all_deplibs_F77=yes
16242
16804
      ;;
16243
16805
 
16244
 
    netbsd* | netbsdelf*-gnu)
 
16806
    netbsd*)
16245
16807
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
16246
16808
        archive_cmds_F77='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
16247
16809
      else
16731
17293
  dynamic_linker=no
16732
17294
  ;;
16733
17295
 
 
17296
kfreebsd*-gnu)
 
17297
  version_type=linux
 
17298
  need_lib_prefix=no
 
17299
  need_version=no
 
17300
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
17301
  soname_spec='${libname}${release}${shared_ext}$major'
 
17302
  shlibpath_var=LD_LIBRARY_PATH
 
17303
  shlibpath_overrides_runpath=no
 
17304
  hardcode_into_libs=yes
 
17305
  dynamic_linker='GNU ld.so'
 
17306
  ;;
 
17307
 
16734
17308
freebsd* | dragonfly*)
16735
17309
  # DragonFly does not have aout.  When/if they implement a new
16736
17310
  # versioning mechanism, adjust this.
16886
17460
  ;;
16887
17461
 
16888
17462
# This must be Linux ELF.
16889
 
linux* | k*bsd*-gnu)
 
17463
linux*)
16890
17464
  version_type=linux
16891
17465
  need_lib_prefix=no
16892
17466
  need_version=no
16915
17489
  dynamic_linker='GNU/Linux ld.so'
16916
17490
  ;;
16917
17491
 
16918
 
netbsdelf*-gnu)
 
17492
knetbsd*-gnu)
16919
17493
  version_type=linux
16920
17494
  need_lib_prefix=no
16921
17495
  need_version=no
16924
17498
  shlibpath_var=LD_LIBRARY_PATH
16925
17499
  shlibpath_overrides_runpath=no
16926
17500
  hardcode_into_libs=yes
16927
 
  dynamic_linker='NetBSD ld.elf_so'
 
17501
  dynamic_linker='GNU ld.so'
16928
17502
  ;;
16929
17503
 
16930
17504
netbsd*)
17632
18206
 
17633
18207
old_archive_cmds_GCJ=$old_archive_cmds
17634
18208
 
 
18209
## CAVEAT EMPTOR:
 
18210
## There is no encapsulation within the following macros, do not change
 
18211
## the running order or otherwise move them around unless you know exactly
 
18212
## what you are doing...
17635
18213
 
17636
18214
lt_prog_compiler_no_builtin_flag_GCJ=
17637
18215
 
17657
18235
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17658
18236
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17659
18237
   -e 's:$: $lt_compiler_flag:'`
17660
 
   (eval echo "\"\$as_me:17670: $lt_compile\"" >&5)
 
18238
   (eval echo "\"\$as_me:18238: $lt_compile\"" >&5)
17661
18239
   (eval "$lt_compile" 2>conftest.err)
17662
18240
   ac_status=$?
17663
18241
   cat conftest.err >&5
17664
 
   echo "$as_me:17674: \$? = $ac_status" >&5
 
18242
   echo "$as_me:18242: \$? = $ac_status" >&5
17665
18243
   if (exit $ac_status) && test -s "$ac_outfile"; then
17666
18244
     # The compiler can only warn and ignore the option if not recognized
17667
18245
     # So say no if there are warnings other than the usual output.
17819
18397
      lt_prog_compiler_static_GCJ='-Bstatic'
17820
18398
      ;;
17821
18399
 
17822
 
    linux* | k*bsd*-gnu)
 
18400
    linux*)
17823
18401
      case $cc_basename in
17824
18402
      icc* | ecc*)
17825
18403
        lt_prog_compiler_wl_GCJ='-Wl,'
17925
18503
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
17926
18504
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
17927
18505
   -e 's:$: $lt_compiler_flag:'`
17928
 
   (eval echo "\"\$as_me:17938: $lt_compile\"" >&5)
 
18506
   (eval echo "\"\$as_me:18506: $lt_compile\"" >&5)
17929
18507
   (eval "$lt_compile" 2>conftest.err)
17930
18508
   ac_status=$?
17931
18509
   cat conftest.err >&5
17932
 
   echo "$as_me:17942: \$? = $ac_status" >&5
 
18510
   echo "$as_me:18510: \$? = $ac_status" >&5
17933
18511
   if (exit $ac_status) && test -s "$ac_outfile"; then
17934
18512
     # The compiler can only warn and ignore the option if not recognized
17935
18513
     # So say no if there are warnings other than the usual output.
18029
18607
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
18030
18608
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
18031
18609
   -e 's:$: $lt_compiler_flag:'`
18032
 
   (eval echo "\"\$as_me:18042: $lt_compile\"" >&5)
 
18610
   (eval echo "\"\$as_me:18610: $lt_compile\"" >&5)
18033
18611
   (eval "$lt_compile" 2>out/conftest.err)
18034
18612
   ac_status=$?
18035
18613
   cat out/conftest.err >&5
18036
 
   echo "$as_me:18046: \$? = $ac_status" >&5
 
18614
   echo "$as_me:18614: \$? = $ac_status" >&5
18037
18615
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
18038
18616
   then
18039
18617
     # The compiler can only warn and ignore the option if not recognized
18258
18836
      archive_expsym_cmds_GCJ='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
18259
18837
      ;;
18260
18838
 
18261
 
    linux* | k*bsd*-gnu)
 
18839
    linux*)
18262
18840
      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
18263
18841
        tmp_addflag=
18264
18842
        case $cc_basename,$host_cpu in
18284
18862
  $echo "local: *; };" >> $output_objdir/$libname.ver~
18285
18863
          $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
18286
18864
        fi
18287
 
        link_all_deplibs_GCJ=no
18288
18865
      else
18289
18866
        ld_shlibs_GCJ=no
18290
18867
      fi
18291
18868
      ;;
18292
18869
 
18293
 
    netbsd* | netbsdelf*-gnu)
 
18870
    netbsd*)
18294
18871
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
18295
18872
        archive_cmds_GCJ='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
18296
18873
        wlarc=
18510
19087
  rm -f conftest.er1
18511
19088
  cat conftest.err >&5
18512
19089
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18513
 
  (exit $ac_status); } &&
18514
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
18515
 
  { (case "(($ac_try" in
18516
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18517
 
  *) ac_try_echo=$ac_try;;
18518
 
esac
18519
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18520
 
  (eval "$ac_try") 2>&5
18521
 
  ac_status=$?
18522
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18523
 
  (exit $ac_status); }; } &&
18524
 
         { ac_try='test -s conftest$ac_exeext'
18525
 
  { (case "(($ac_try" in
18526
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18527
 
  *) ac_try_echo=$ac_try;;
18528
 
esac
18529
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18530
 
  (eval "$ac_try") 2>&5
18531
 
  ac_status=$?
18532
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18533
 
  (exit $ac_status); }; }; then
 
19090
  (exit $ac_status); } && {
 
19091
         test -z "$ac_c_werror_flag" ||
 
19092
         test ! -s conftest.err
 
19093
       } && test -s conftest$ac_exeext &&
 
19094
       $as_test_x conftest$ac_exeext; then
18534
19095
 
18535
19096
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
18536
19097
}'`
18585
19146
  rm -f conftest.er1
18586
19147
  cat conftest.err >&5
18587
19148
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18588
 
  (exit $ac_status); } &&
18589
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
18590
 
  { (case "(($ac_try" in
18591
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18592
 
  *) ac_try_echo=$ac_try;;
18593
 
esac
18594
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18595
 
  (eval "$ac_try") 2>&5
18596
 
  ac_status=$?
18597
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18598
 
  (exit $ac_status); }; } &&
18599
 
         { ac_try='test -s conftest$ac_exeext'
18600
 
  { (case "(($ac_try" in
18601
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
18602
 
  *) ac_try_echo=$ac_try;;
18603
 
esac
18604
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
18605
 
  (eval "$ac_try") 2>&5
18606
 
  ac_status=$?
18607
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
18608
 
  (exit $ac_status); }; }; then
 
19149
  (exit $ac_status); } && {
 
19150
         test -z "$ac_c_werror_flag" ||
 
19151
         test ! -s conftest.err
 
19152
       } && test -s conftest$ac_exeext &&
 
19153
       $as_test_x conftest$ac_exeext; then
18609
19154
 
18610
19155
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
18611
19156
}'`
18750
19295
      ;;
18751
19296
 
18752
19297
    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
18753
 
    freebsd* | dragonfly*)
 
19298
    freebsd* | kfreebsd*-gnu | dragonfly*)
18754
19299
      archive_cmds_GCJ='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
18755
19300
      hardcode_libdir_flag_spec_GCJ='-R$libdir'
18756
19301
      hardcode_direct_GCJ=yes
18852
19397
      link_all_deplibs_GCJ=yes
18853
19398
      ;;
18854
19399
 
18855
 
    netbsd* | netbsdelf*-gnu)
 
19400
    netbsd*)
18856
19401
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
18857
19402
        archive_cmds_GCJ='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
18858
19403
      else
19342
19887
  dynamic_linker=no
19343
19888
  ;;
19344
19889
 
 
19890
kfreebsd*-gnu)
 
19891
  version_type=linux
 
19892
  need_lib_prefix=no
 
19893
  need_version=no
 
19894
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
19895
  soname_spec='${libname}${release}${shared_ext}$major'
 
19896
  shlibpath_var=LD_LIBRARY_PATH
 
19897
  shlibpath_overrides_runpath=no
 
19898
  hardcode_into_libs=yes
 
19899
  dynamic_linker='GNU ld.so'
 
19900
  ;;
 
19901
 
19345
19902
freebsd* | dragonfly*)
19346
19903
  # DragonFly does not have aout.  When/if they implement a new
19347
19904
  # versioning mechanism, adjust this.
19497
20054
  ;;
19498
20055
 
19499
20056
# This must be Linux ELF.
19500
 
linux* | k*bsd*-gnu)
 
20057
linux*)
19501
20058
  version_type=linux
19502
20059
  need_lib_prefix=no
19503
20060
  need_version=no
19526
20083
  dynamic_linker='GNU/Linux ld.so'
19527
20084
  ;;
19528
20085
 
19529
 
netbsdelf*-gnu)
 
20086
knetbsd*-gnu)
19530
20087
  version_type=linux
19531
20088
  need_lib_prefix=no
19532
20089
  need_version=no
19535
20092
  shlibpath_var=LD_LIBRARY_PATH
19536
20093
  shlibpath_overrides_runpath=no
19537
20094
  hardcode_into_libs=yes
19538
 
  dynamic_linker='NetBSD ld.elf_so'
 
20095
  dynamic_linker='GNU ld.so'
19539
20096
  ;;
19540
20097
 
19541
20098
netbsd*)
20751
21308
  rm -f conftest.er1
20752
21309
  cat conftest.err >&5
20753
21310
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20754
 
  (exit $ac_status); } &&
20755
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
20756
 
  { (case "(($ac_try" in
20757
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
20758
 
  *) ac_try_echo=$ac_try;;
20759
 
esac
20760
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
20761
 
  (eval "$ac_try") 2>&5
20762
 
  ac_status=$?
20763
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20764
 
  (exit $ac_status); }; } &&
20765
 
         { ac_try='test -s conftest.$ac_objext'
20766
 
  { (case "(($ac_try" in
20767
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
20768
 
  *) ac_try_echo=$ac_try;;
20769
 
esac
20770
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
20771
 
  (eval "$ac_try") 2>&5
20772
 
  ac_status=$?
20773
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20774
 
  (exit $ac_status); }; }; then
 
21311
  (exit $ac_status); } && {
 
21312
         test -z "$ac_c_werror_flag" ||
 
21313
         test ! -s conftest.err
 
21314
       } && test -s conftest.$ac_objext; then
20775
21315
  ac_header_compiler=yes
20776
21316
else
20777
21317
  echo "$as_me: failed program was:" >&5
20807
21347
  rm -f conftest.er1
20808
21348
  cat conftest.err >&5
20809
21349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
20810
 
  (exit $ac_status); } >/dev/null; then
20811
 
  if test -s conftest.err; then
20812
 
    ac_cpp_err=$ac_c_preproc_warn_flag
20813
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
20814
 
  else
20815
 
    ac_cpp_err=
20816
 
  fi
20817
 
else
20818
 
  ac_cpp_err=yes
20819
 
fi
20820
 
if test -z "$ac_cpp_err"; then
 
21350
  (exit $ac_status); } >/dev/null && {
 
21351
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
21352
         test ! -s conftest.err
 
21353
       }; then
20821
21354
  ac_header_preproc=yes
20822
21355
else
20823
21356
  echo "$as_me: failed program was:" >&5
20941
21474
echo "${ECHO_T}no" >&6; } ;;
20942
21475
esac
20943
21476
 
20944
 
MY_CFLAGS="$CFLAGS"
20945
 
 
20946
 
 
20947
 
cat >>confdefs.h <<\_ACEOF
20948
 
#define SILENT 1
20949
 
_ACEOF
20950
 
 
20951
 
cat >>confdefs.h <<\_ACEOF
20952
 
#define NO_SIGNALS 1
20953
 
_ACEOF
20954
 
 
20955
21477
cat >>confdefs.h <<\_ACEOF
20956
21478
#define NO_EXECUTE_PERMISSION 1
20957
21479
_ACEOF
20961
21483
_ACEOF
20962
21484
 
20963
21485
 
 
21486
 
 
21487
# Check whether --enable-gcj-support was given.
 
21488
if test "${enable_gcj_support+set}" = set; then
 
21489
  enableval=$enable_gcj_support;
 
21490
fi
 
21491
 
 
21492
 
 
21493
 
 
21494
if test x"$enable_gcj_support" != xno; then
 
21495
  ENABLE_GCJ_SUPPORT_TRUE=
 
21496
  ENABLE_GCJ_SUPPORT_FALSE='#'
 
21497
else
 
21498
  ENABLE_GCJ_SUPPORT_TRUE='#'
 
21499
  ENABLE_GCJ_SUPPORT_FALSE=
 
21500
fi
 
21501
 
 
21502
if test x"$enable_gcj_support" != xno; then
 
21503
 
20964
21504
cat >>confdefs.h <<\_ACEOF
 
21505
#define GC_GCJ_SUPPORT 1
 
21506
_ACEOF
 
21507
 
 
21508
fi
 
21509
 
 
21510
# Check whether --enable-java-finalization was given.
 
21511
if test "${enable_java_finalization+set}" = set; then
 
21512
  enableval=$enable_java_finalization;
 
21513
fi
 
21514
 
 
21515
if test x"$enable_java_finalization" != xno; then
 
21516
    cat >>confdefs.h <<\_ACEOF
20965
21517
#define JAVA_FINALIZATION 1
20966
21518
_ACEOF
20967
21519
 
20968
 
cat >>confdefs.h <<\_ACEOF
20969
 
#define GC_GCJ_SUPPORT 1
20970
 
_ACEOF
 
21520
fi
 
21521
 
 
21522
# Check whether --enable-atomic-uncollectable was given.
 
21523
if test "${enable_atomic_uncollectable+set}" = set; then
 
21524
  enableval=$enable_atomic_uncollectable;
 
21525
fi
 
21526
 
 
21527
if test x"$enable_atomic_uncollectible" != x"no"; then
20971
21528
 
20972
21529
cat >>confdefs.h <<\_ACEOF
20973
21530
#define ATOMIC_UNCOLLECTABLE 1
20974
21531
_ACEOF
20975
21532
 
 
21533
fi
 
21534
 
 
21535
# Check whether --enable-redirect-malloc was given.
 
21536
if test "${enable_redirect_malloc+set}" = set; then
 
21537
  enableval=$enable_redirect_malloc;
 
21538
fi
 
21539
 
 
21540
 
 
21541
if test "${enable_redirect_malloc}" = yes; then
 
21542
    if test "${enable_full_debug}" = yes; then
 
21543
        cat >>confdefs.h <<\_ACEOF
 
21544
#define REDIRECT_MALLOC GC_debug_malloc_replacement
 
21545
_ACEOF
 
21546
 
 
21547
        cat >>confdefs.h <<\_ACEOF
 
21548
#define REDIRECT_REALLOC GC_debug_realloc_replacement
 
21549
_ACEOF
 
21550
 
 
21551
        cat >>confdefs.h <<\_ACEOF
 
21552
#define REDIRECT_FREE GC_debug_free
 
21553
_ACEOF
 
21554
 
 
21555
    else
 
21556
        cat >>confdefs.h <<\_ACEOF
 
21557
#define REDIRECT_MALLOC GC_malloc
 
21558
_ACEOF
 
21559
 
 
21560
    fi
 
21561
    cat >>confdefs.h <<\_ACEOF
 
21562
#define GC_USE_DLOPEN_WRAP 1
 
21563
_ACEOF
 
21564
 
 
21565
fi
 
21566
 
 
21567
# Check whether --enable-large-config was given.
 
21568
if test "${enable_large_config+set}" = set; then
 
21569
  enableval=$enable_large_config;
 
21570
fi
 
21571
 
 
21572
 
 
21573
if test "${enable_large_config}" = yes; then
 
21574
 
 
21575
cat >>confdefs.h <<\_ACEOF
 
21576
#define LARGE_CONFIG 1
 
21577
_ACEOF
 
21578
 
 
21579
fi
20976
21580
 
20977
21581
if test -n "${with_cross_host}"; then
20978
21582
   cat >>confdefs.h <<\_ACEOF
20979
 
#define NO_SIGSET 1
20980
 
_ACEOF
20981
 
 
20982
 
   cat >>confdefs.h <<\_ACEOF
20983
21583
#define NO_CLOCK 1
20984
21584
_ACEOF
20985
21585
 
20993
21593
 
20994
21594
fi
20995
21595
 
 
21596
 
 
21597
 
20996
21598
UNWINDLIBS=
20997
 
# Check whether --enable-full-debug was given.
20998
 
if test "${enable_full_debug+set}" = set; then
20999
 
  enableval=$enable_full_debug;  if test "$enable_full_debug" = "yes"; then
 
21599
# Check whether --enable-gc-debug was given.
 
21600
if test "${enable_gc_debug+set}" = set; then
 
21601
  enableval=$enable_gc_debug;  if test "$enable_gc_debug" = "yes"; then
21000
21602
    { echo "$as_me:$LINENO: WARNING: \"Should define GC_DEBUG and use debug alloc. in clients.\"" >&5
21001
21603
echo "$as_me: WARNING: \"Should define GC_DEBUG and use debug alloc. in clients.\"" >&2;}
21002
21604
    cat >>confdefs.h <<\_ACEOF
21059
21661
  rm -f conftest.er1
21060
21662
  cat conftest.err >&5
21061
21663
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21062
 
  (exit $ac_status); } &&
21063
 
         { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
21064
 
  { (case "(($ac_try" in
21065
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21066
 
  *) ac_try_echo=$ac_try;;
21067
 
esac
21068
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21069
 
  (eval "$ac_try") 2>&5
21070
 
  ac_status=$?
21071
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21072
 
  (exit $ac_status); }; } &&
21073
 
         { ac_try='test -s conftest$ac_exeext'
21074
 
  { (case "(($ac_try" in
21075
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
21076
 
  *) ac_try_echo=$ac_try;;
21077
 
esac
21078
 
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
21079
 
  (eval "$ac_try") 2>&5
21080
 
  ac_status=$?
21081
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
21082
 
  (exit $ac_status); }; }; then
 
21664
  (exit $ac_status); } && {
 
21665
         test -z "$ac_c_werror_flag" ||
 
21666
         test ! -s conftest.err
 
21667
       } && test -s conftest$ac_exeext &&
 
21668
       $as_test_x conftest$ac_exeext; then
21083
21669
  ac_cv_lib_unwind_backtrace=yes
21084
21670
else
21085
21671
  echo "$as_me: failed program was:" >&5
21132
21718
 
21133
21719
 
21134
21720
 
21135
 
# Check whether --enable-redirect-malloc was given.
21136
 
if test "${enable_redirect_malloc+set}" = set; then
21137
 
  enableval=$enable_redirect_malloc;
21138
 
fi
21139
 
 
21140
 
 
21141
 
if test "${enable_redirect_malloc}" = yes; then
21142
 
    if test "${enable_full_debug}" = yes; then
21143
 
        cat >>confdefs.h <<\_ACEOF
21144
 
#define REDIRECT_MALLOC GC_debug_malloc_replacement
21145
 
_ACEOF
21146
 
 
21147
 
        cat >>confdefs.h <<\_ACEOF
21148
 
#define REDIRECT_REALLOC GC_debug_realloc_replacement
21149
 
_ACEOF
21150
 
 
21151
 
        cat >>confdefs.h <<\_ACEOF
21152
 
#define REDIRECT_FREE GC_debug_free
21153
 
_ACEOF
21154
 
 
21155
 
    else
21156
 
        cat >>confdefs.h <<\_ACEOF
21157
 
#define REDIRECT_MALLOC GC_malloc
21158
 
_ACEOF
21159
 
 
21160
 
    fi
21161
 
fi
21162
 
 
21163
21721
# Check whether --enable-gc-assertions was given.
21164
21722
if test "${enable_gc_assertions+set}" = set; then
21165
21723
  enableval=$enable_gc_assertions;
21172
21730
 
21173
21731
fi
21174
21732
 
 
21733
# Check whether --enable-munmap was given.
 
21734
if test "${enable_munmap+set}" = set; then
 
21735
  enableval=$enable_munmap; MUNMAP_THRESHOLD=$enableval;
 
21736
   case "$MMAP" in
 
21737
      no)
 
21738
        { { echo "$as_me:$LINENO: error: --enable-munmap requires --enable-mmap" >&5
 
21739
echo "$as_me: error: --enable-munmap requires --enable-mmap" >&2;}
 
21740
   { (exit 1); exit 1; }; }
 
21741
        ;;
 
21742
    esac
 
21743
 
 
21744
fi
 
21745
 
 
21746
if test "${enable_munmap}" != ""; then
 
21747
    cat >>confdefs.h <<\_ACEOF
 
21748
#define USE_MMAP 1
 
21749
_ACEOF
 
21750
 
 
21751
    cat >>confdefs.h <<\_ACEOF
 
21752
#define USE_MUNMAP 1
 
21753
_ACEOF
 
21754
 
 
21755
    if test "${MUNMAP_THRESHOLD}" = "yes"; then
 
21756
      MUNMAP_THRESHOLD=6
 
21757
    fi
 
21758
    cat >>confdefs.h <<_ACEOF
 
21759
#define MUNMAP_THRESHOLD ${MUNMAP_THRESHOLD}
 
21760
_ACEOF
 
21761
 
 
21762
fi
 
21763
 
21175
21764
 
21176
21765
 
21177
21766
if test -z "$with_cross_host"; then
21183
21772
fi
21184
21773
 
21185
21774
 
21186
 
ac_config_files="$ac_config_files Makefile doc/Makefile include/Makefile"
 
21775
 
 
21776
 
 
21777
atomic_ops_libs=-latomic_ops
 
21778
if test "${ac_cv_header_atomic_ops_h+set}" = set; then
 
21779
  { echo "$as_me:$LINENO: checking for atomic_ops.h" >&5
 
21780
echo $ECHO_N "checking for atomic_ops.h... $ECHO_C" >&6; }
 
21781
if test "${ac_cv_header_atomic_ops_h+set}" = set; then
 
21782
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
21783
fi
 
21784
{ echo "$as_me:$LINENO: result: $ac_cv_header_atomic_ops_h" >&5
 
21785
echo "${ECHO_T}$ac_cv_header_atomic_ops_h" >&6; }
 
21786
else
 
21787
  # Is the header compilable?
 
21788
{ echo "$as_me:$LINENO: checking atomic_ops.h usability" >&5
 
21789
echo $ECHO_N "checking atomic_ops.h usability... $ECHO_C" >&6; }
 
21790
cat >conftest.$ac_ext <<_ACEOF
 
21791
/* confdefs.h.  */
 
21792
_ACEOF
 
21793
cat confdefs.h >>conftest.$ac_ext
 
21794
cat >>conftest.$ac_ext <<_ACEOF
 
21795
/* end confdefs.h.  */
 
21796
$ac_includes_default
 
21797
#include <atomic_ops.h>
 
21798
_ACEOF
 
21799
rm -f conftest.$ac_objext
 
21800
if { (ac_try="$ac_compile"
 
21801
case "(($ac_try" in
 
21802
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
21803
  *) ac_try_echo=$ac_try;;
 
21804
esac
 
21805
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
21806
  (eval "$ac_compile") 2>conftest.er1
 
21807
  ac_status=$?
 
21808
  grep -v '^ *+' conftest.er1 >conftest.err
 
21809
  rm -f conftest.er1
 
21810
  cat conftest.err >&5
 
21811
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
21812
  (exit $ac_status); } && {
 
21813
         test -z "$ac_c_werror_flag" ||
 
21814
         test ! -s conftest.err
 
21815
       } && test -s conftest.$ac_objext; then
 
21816
  ac_header_compiler=yes
 
21817
else
 
21818
  echo "$as_me: failed program was:" >&5
 
21819
sed 's/^/| /' conftest.$ac_ext >&5
 
21820
 
 
21821
        ac_header_compiler=no
 
21822
fi
 
21823
 
 
21824
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
21825
{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
 
21826
echo "${ECHO_T}$ac_header_compiler" >&6; }
 
21827
 
 
21828
# Is the header present?
 
21829
{ echo "$as_me:$LINENO: checking atomic_ops.h presence" >&5
 
21830
echo $ECHO_N "checking atomic_ops.h presence... $ECHO_C" >&6; }
 
21831
cat >conftest.$ac_ext <<_ACEOF
 
21832
/* confdefs.h.  */
 
21833
_ACEOF
 
21834
cat confdefs.h >>conftest.$ac_ext
 
21835
cat >>conftest.$ac_ext <<_ACEOF
 
21836
/* end confdefs.h.  */
 
21837
#include <atomic_ops.h>
 
21838
_ACEOF
 
21839
if { (ac_try="$ac_cpp conftest.$ac_ext"
 
21840
case "(($ac_try" in
 
21841
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
21842
  *) ac_try_echo=$ac_try;;
 
21843
esac
 
21844
eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
 
21845
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
 
21846
  ac_status=$?
 
21847
  grep -v '^ *+' conftest.er1 >conftest.err
 
21848
  rm -f conftest.er1
 
21849
  cat conftest.err >&5
 
21850
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
21851
  (exit $ac_status); } >/dev/null && {
 
21852
         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
 
21853
         test ! -s conftest.err
 
21854
       }; then
 
21855
  ac_header_preproc=yes
 
21856
else
 
21857
  echo "$as_me: failed program was:" >&5
 
21858
sed 's/^/| /' conftest.$ac_ext >&5
 
21859
 
 
21860
  ac_header_preproc=no
 
21861
fi
 
21862
 
 
21863
rm -f conftest.err conftest.$ac_ext
 
21864
{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
 
21865
echo "${ECHO_T}$ac_header_preproc" >&6; }
 
21866
 
 
21867
# So?  What about this header?
 
21868
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
 
21869
  yes:no: )
 
21870
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: accepted by the compiler, rejected by the preprocessor!" >&5
 
21871
echo "$as_me: WARNING: atomic_ops.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
 
21872
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: proceeding with the compiler's result" >&5
 
21873
echo "$as_me: WARNING: atomic_ops.h: proceeding with the compiler's result" >&2;}
 
21874
    ac_header_preproc=yes
 
21875
    ;;
 
21876
  no:yes:* )
 
21877
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: present but cannot be compiled" >&5
 
21878
echo "$as_me: WARNING: atomic_ops.h: present but cannot be compiled" >&2;}
 
21879
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h:     check for missing prerequisite headers?" >&5
 
21880
echo "$as_me: WARNING: atomic_ops.h:     check for missing prerequisite headers?" >&2;}
 
21881
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: see the Autoconf documentation" >&5
 
21882
echo "$as_me: WARNING: atomic_ops.h: see the Autoconf documentation" >&2;}
 
21883
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h:     section \"Present But Cannot Be Compiled\"" >&5
 
21884
echo "$as_me: WARNING: atomic_ops.h:     section \"Present But Cannot Be Compiled\"" >&2;}
 
21885
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: proceeding with the preprocessor's result" >&5
 
21886
echo "$as_me: WARNING: atomic_ops.h: proceeding with the preprocessor's result" >&2;}
 
21887
    { echo "$as_me:$LINENO: WARNING: atomic_ops.h: in the future, the compiler will take precedence" >&5
 
21888
echo "$as_me: WARNING: atomic_ops.h: in the future, the compiler will take precedence" >&2;}
 
21889
    ( cat <<\_ASBOX
 
21890
## -------------------------------- ##
 
21891
## Report this to Hans.Boehm@hp.com ##
 
21892
## -------------------------------- ##
 
21893
_ASBOX
 
21894
     ) | sed "s/^/$as_me: WARNING:     /" >&2
 
21895
    ;;
 
21896
esac
 
21897
{ echo "$as_me:$LINENO: checking for atomic_ops.h" >&5
 
21898
echo $ECHO_N "checking for atomic_ops.h... $ECHO_C" >&6; }
 
21899
if test "${ac_cv_header_atomic_ops_h+set}" = set; then
 
21900
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
21901
else
 
21902
  ac_cv_header_atomic_ops_h=$ac_header_preproc
 
21903
fi
 
21904
{ echo "$as_me:$LINENO: result: $ac_cv_header_atomic_ops_h" >&5
 
21905
echo "${ECHO_T}$ac_cv_header_atomic_ops_h" >&6; }
 
21906
 
 
21907
fi
 
21908
if test $ac_cv_header_atomic_ops_h = yes; then
 
21909
   { echo "$as_me:$LINENO: Using pre-installed libatomic_ops" >&5
 
21910
echo "$as_me: Using pre-installed libatomic_ops" >&6;}
 
21911
else
 
21912
   ao_dir=
 
21913
    for candidate in ${srcdir}/libatomic_ops*; do
 
21914
        case $candidate in
 
21915
            *.tar.gz)
 
21916
                ;;
 
21917
            *install)
 
21918
                                ;;
 
21919
            *)
 
21920
                if test -e "$candidate"; then
 
21921
                    ao_dir="$candidate"
 
21922
                fi
 
21923
                ;;
 
21924
        esac
 
21925
    done
 
21926
    if test -z "$ao_dir"; then
 
21927
        { { echo "$as_me:$LINENO: error: Missig libatomic_ops." >&5
 
21928
echo "$as_me: error: Missig libatomic_ops." >&2;}
 
21929
   { (exit 1); exit 1; }; }
 
21930
    fi
 
21931
    ao_version="${ao_dir#*libatomic_ops-}"
 
21932
    { echo "$as_me:$LINENO: Using internal version of libatomic_ops" >&5
 
21933
echo "$as_me: Using internal version of libatomic_ops" >&6;}
 
21934
 
 
21935
        test -e libatomic_ops \
 
21936
        || ln -s ${ao_dir} libatomic_ops
 
21937
    subdirs="$subdirs libatomic_ops"
 
21938
 
 
21939
 
 
21940
        test -e atomic_ops.c \
 
21941
        || ln -s libatomic_ops/src/atomic_ops.c \
 
21942
                 atomic_ops.c
 
21943
 
 
21944
    test -e atomic_ops_sysdeps.S \
 
21945
        || ln -s libatomic_ops/src/atomic_ops_sysdeps.S \
 
21946
                 atomic_ops_sysdeps.S
 
21947
 
 
21948
            GC_CFLAGS="${GC_CFLAGS} -I libatomic_ops/src"
 
21949
    maybe_libatomic_ops="libatomic_ops"
 
21950
 
 
21951
fi
 
21952
 
 
21953
 
 
21954
 
 
21955
 
 
21956
 
 
21957
if test -n "$maybe_libatomic_ops" -a "$THREADS" != "none"; then
 
21958
  USE_INTERNAL_LIBATOMIC_OPS_TRUE=
 
21959
  USE_INTERNAL_LIBATOMIC_OPS_FALSE='#'
 
21960
else
 
21961
  USE_INTERNAL_LIBATOMIC_OPS_TRUE='#'
 
21962
  USE_INTERNAL_LIBATOMIC_OPS_FALSE=
 
21963
fi
 
21964
 
 
21965
 
 
21966
 
 
21967
if test -n "$maybe_libatomic_ops" -a x$need_atomic_ops_asm = xtrue; then
 
21968
  NEED_ATOMIC_OPS_ASM_TRUE=
 
21969
  NEED_ATOMIC_OPS_ASM_FALSE='#'
 
21970
else
 
21971
  NEED_ATOMIC_OPS_ASM_TRUE='#'
 
21972
  NEED_ATOMIC_OPS_ASM_FALSE=
 
21973
fi
 
21974
 
 
21975
 
 
21976
 
 
21977
 
 
21978
ac_config_files="$ac_config_files Makefile bdw-gc.pc"
 
21979
 
21187
21980
 
21188
21981
ac_config_commands="$ac_config_commands default"
21189
21982
 
 
21983
 
21190
21984
cat >confcache <<\_ACEOF
21191
21985
# This file is a shell script that caches the results of configure
21192
21986
# tests run on this system so they can be shared between configure
21313
22107
LTLIBOBJS=$ac_ltlibobjs
21314
22108
 
21315
22109
 
 
22110
if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
 
22111
  { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
 
22112
Usually this means the macro was only invoked conditionally." >&5
 
22113
echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
 
22114
Usually this means the macro was only invoked conditionally." >&2;}
 
22115
   { (exit 1); exit 1; }; }
 
22116
fi
21316
22117
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
21317
22118
  { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
21318
22119
Usually this means the macro was only invoked conditionally." >&5
21334
22135
Usually this means the macro was only invoked conditionally." >&2;}
21335
22136
   { (exit 1); exit 1; }; }
21336
22137
fi
21337
 
if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
21338
 
  { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
21339
 
Usually this means the macro was only invoked conditionally." >&5
21340
 
echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
21341
 
Usually this means the macro was only invoked conditionally." >&2;}
21342
 
   { (exit 1); exit 1; }; }
21343
 
fi
21344
 
if test -z "${POWERPC_DARWIN_TRUE}" && test -z "${POWERPC_DARWIN_FALSE}"; then
21345
 
  { { echo "$as_me:$LINENO: error: conditional \"POWERPC_DARWIN\" was never defined.
21346
 
Usually this means the macro was only invoked conditionally." >&5
21347
 
echo "$as_me: error: conditional \"POWERPC_DARWIN\" was never defined.
 
22138
if test -z "${THREADS_TRUE}" && test -z "${THREADS_FALSE}"; then
 
22139
  { { echo "$as_me:$LINENO: error: conditional \"THREADS\" was never defined.
 
22140
Usually this means the macro was only invoked conditionally." >&5
 
22141
echo "$as_me: error: conditional \"THREADS\" was never defined.
 
22142
Usually this means the macro was only invoked conditionally." >&2;}
 
22143
   { (exit 1); exit 1; }; }
 
22144
fi
 
22145
if test -z "${PTHREADS_TRUE}" && test -z "${PTHREADS_FALSE}"; then
 
22146
  { { echo "$as_me:$LINENO: error: conditional \"PTHREADS\" was never defined.
 
22147
Usually this means the macro was only invoked conditionally." >&5
 
22148
echo "$as_me: error: conditional \"PTHREADS\" was never defined.
 
22149
Usually this means the macro was only invoked conditionally." >&2;}
 
22150
   { (exit 1); exit 1; }; }
 
22151
fi
 
22152
if test -z "${DARWIN_THREADS_TRUE}" && test -z "${DARWIN_THREADS_FALSE}"; then
 
22153
  { { echo "$as_me:$LINENO: error: conditional \"DARWIN_THREADS\" was never defined.
 
22154
Usually this means the macro was only invoked conditionally." >&5
 
22155
echo "$as_me: error: conditional \"DARWIN_THREADS\" was never defined.
 
22156
Usually this means the macro was only invoked conditionally." >&2;}
 
22157
   { (exit 1); exit 1; }; }
 
22158
fi
 
22159
if test -z "${WIN32_THREADS_TRUE}" && test -z "${WIN32_THREADS_FALSE}"; then
 
22160
  { { echo "$as_me:$LINENO: error: conditional \"WIN32_THREADS\" was never defined.
 
22161
Usually this means the macro was only invoked conditionally." >&5
 
22162
echo "$as_me: error: conditional \"WIN32_THREADS\" was never defined.
21348
22163
Usually this means the macro was only invoked conditionally." >&2;}
21349
22164
   { (exit 1); exit 1; }; }
21350
22165
fi
21355
22170
Usually this means the macro was only invoked conditionally." >&2;}
21356
22171
   { (exit 1); exit 1; }; }
21357
22172
fi
 
22173
if test -z "${AVOID_CPP_LIB_TRUE}" && test -z "${AVOID_CPP_LIB_FALSE}"; then
 
22174
  { { echo "$as_me:$LINENO: error: conditional \"AVOID_CPP_LIB\" was never defined.
 
22175
Usually this means the macro was only invoked conditionally." >&5
 
22176
echo "$as_me: error: conditional \"AVOID_CPP_LIB\" was never defined.
 
22177
Usually this means the macro was only invoked conditionally." >&2;}
 
22178
   { (exit 1); exit 1; }; }
 
22179
fi
21358
22180
if test -z "${CPLUSPLUS_TRUE}" && test -z "${CPLUSPLUS_FALSE}"; then
21359
22181
  { { echo "$as_me:$LINENO: error: conditional \"CPLUSPLUS\" was never defined.
21360
22182
Usually this means the macro was only invoked conditionally." >&5
21362
22184
Usually this means the macro was only invoked conditionally." >&2;}
21363
22185
   { (exit 1); exit 1; }; }
21364
22186
fi
 
22187
if test -z "${ENABLE_GCJ_SUPPORT_TRUE}" && test -z "${ENABLE_GCJ_SUPPORT_FALSE}"; then
 
22188
  { { echo "$as_me:$LINENO: error: conditional \"ENABLE_GCJ_SUPPORT\" was never defined.
 
22189
Usually this means the macro was only invoked conditionally." >&5
 
22190
echo "$as_me: error: conditional \"ENABLE_GCJ_SUPPORT\" was never defined.
 
22191
Usually this means the macro was only invoked conditionally." >&2;}
 
22192
   { (exit 1); exit 1; }; }
 
22193
fi
21365
22194
if test -z "${USE_LIBDIR_TRUE}" && test -z "${USE_LIBDIR_FALSE}"; then
21366
22195
  { { echo "$as_me:$LINENO: error: conditional \"USE_LIBDIR\" was never defined.
21367
22196
Usually this means the macro was only invoked conditionally." >&5
21369
22198
Usually this means the macro was only invoked conditionally." >&2;}
21370
22199
   { (exit 1); exit 1; }; }
21371
22200
fi
 
22201
if test -z "${USE_INTERNAL_LIBATOMIC_OPS_TRUE}" && test -z "${USE_INTERNAL_LIBATOMIC_OPS_FALSE}"; then
 
22202
  { { echo "$as_me:$LINENO: error: conditional \"USE_INTERNAL_LIBATOMIC_OPS\" was never defined.
 
22203
Usually this means the macro was only invoked conditionally." >&5
 
22204
echo "$as_me: error: conditional \"USE_INTERNAL_LIBATOMIC_OPS\" was never defined.
 
22205
Usually this means the macro was only invoked conditionally." >&2;}
 
22206
   { (exit 1); exit 1; }; }
 
22207
fi
 
22208
if test -z "${NEED_ATOMIC_OPS_ASM_TRUE}" && test -z "${NEED_ATOMIC_OPS_ASM_FALSE}"; then
 
22209
  { { echo "$as_me:$LINENO: error: conditional \"NEED_ATOMIC_OPS_ASM\" was never defined.
 
22210
Usually this means the macro was only invoked conditionally." >&5
 
22211
echo "$as_me: error: conditional \"NEED_ATOMIC_OPS_ASM\" was never defined.
 
22212
Usually this means the macro was only invoked conditionally." >&2;}
 
22213
   { (exit 1); exit 1; }; }
 
22214
fi
21372
22215
 
21373
22216
: ${CONFIG_STATUS=./config.status}
21374
22217
ac_clean_files_save=$ac_clean_files
21393
22236
## M4sh Initialization.  ##
21394
22237
## --------------------- ##
21395
22238
 
21396
 
# Be Bourne compatible
 
22239
# Be more Bourne compatible
 
22240
DUALCASE=1; export DUALCASE # for MKS sh
21397
22241
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
21398
22242
  emulate sh
21399
22243
  NULLCMD=:
21402
22246
  alias -g '${1+"$@"}'='"$@"'
21403
22247
  setopt NO_GLOB_SUBST
21404
22248
else
21405
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
22249
  case `(set -o) 2>/dev/null` in
 
22250
  *posix*) set -o posix ;;
 
22251
esac
 
22252
 
21406
22253
fi
21407
 
BIN_SH=xpg4; export BIN_SH # for Tru64
21408
 
DUALCASE=1; export DUALCASE # for MKS sh
 
22254
 
 
22255
 
21409
22256
 
21410
22257
 
21411
22258
# PATH needs CR
21629
22476
  as_mkdir_p=false
21630
22477
fi
21631
22478
 
21632
 
# Find out whether ``test -x'' works.  Don't use a zero-byte file, as
21633
 
# systems may use methods other than mode bits to determine executability.
21634
 
cat >conf$$.file <<_ASEOF
21635
 
#! /bin/sh
21636
 
exit 0
21637
 
_ASEOF
21638
 
chmod +x conf$$.file
21639
 
if test -x conf$$.file >/dev/null 2>&1; then
21640
 
  as_executable_p="test -x"
 
22479
if test -x / >/dev/null 2>&1; then
 
22480
  as_test_x='test -x'
21641
22481
else
21642
 
  as_executable_p=:
 
22482
  if ls -dL / >/dev/null 2>&1; then
 
22483
    as_ls_L_option=L
 
22484
  else
 
22485
    as_ls_L_option=
 
22486
  fi
 
22487
  as_test_x='
 
22488
    eval sh -c '\''
 
22489
      if test -d "$1"; then
 
22490
        test -d "$1/.";
 
22491
      else
 
22492
        case $1 in
 
22493
        -*)set "./$1";;
 
22494
        esac;
 
22495
        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
 
22496
        ???[sx]*):;;*)false;;esac;fi
 
22497
    '\'' sh
 
22498
  '
21643
22499
fi
21644
 
rm -f conf$$.file
 
22500
as_executable_p=$as_test_x
21645
22501
 
21646
22502
# Sed expression to map a string onto a valid CPP name.
21647
22503
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
21656
22512
# report actual input values of CONFIG_FILES etc. instead of their
21657
22513
# values after options handling.
21658
22514
ac_log="
21659
 
This file was extended by gc $as_me 6.8, which was
21660
 
generated by GNU Autoconf 2.60a.  Invocation command line was
 
22515
This file was extended by gc $as_me 7.1, which was
 
22516
generated by GNU Autoconf 2.61.  Invocation command line was
21661
22517
 
21662
22518
  CONFIG_FILES    = $CONFIG_FILES
21663
22519
  CONFIG_HEADERS  = $CONFIG_HEADERS
21703
22559
_ACEOF
21704
22560
cat >>$CONFIG_STATUS <<_ACEOF
21705
22561
ac_cs_version="\\
21706
 
gc config.status 6.8
21707
 
configured by $0, generated by GNU Autoconf 2.60a,
 
22562
gc config.status 7.1
 
22563
configured by $0, generated by GNU Autoconf 2.61,
21708
22564
  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
21709
22565
 
21710
22566
Copyright (C) 2006 Free Software Foundation, Inc.
21798
22654
# INIT-COMMANDS
21799
22655
#
21800
22656
AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
21801
 
srcdir=${srcdir}
21802
 
host=${host}
21803
 
CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
21804
 
CC="${CC}"
21805
 
DEFS="$DEFS"
21806
 
 
 
22657
 srcdir=${srcdir}
 
22658
    host=${host}
 
22659
    CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
 
22660
    CC="${CC}"
 
22661
    DEFS="$DEFS"
21807
22662
 
21808
22663
_ACEOF
21809
22664
 
21815
22670
  case $ac_config_target in
21816
22671
    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
21817
22672
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
21818
 
    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
21819
 
    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
 
22673
    "bdw-gc.pc") CONFIG_FILES="$CONFIG_FILES bdw-gc.pc" ;;
21820
22674
    "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
21821
22675
 
21822
22676
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
21949
22803
AMTAR!$AMTAR$ac_delim
21950
22804
am__tar!$am__tar$ac_delim
21951
22805
am__untar!$am__untar$ac_delim
 
22806
MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
 
22807
MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
 
22808
MAINT!$MAINT$ac_delim
21952
22809
GC_VERSION!$GC_VERSION$ac_delim
21953
22810
CC!$CC$ac_delim
21954
22811
CFLAGS!$CFLAGS$ac_delim
21973
22830
am__fastdepCXX_TRUE!$am__fastdepCXX_TRUE$ac_delim
21974
22831
am__fastdepCXX_FALSE!$am__fastdepCXX_FALSE$ac_delim
21975
22832
CCAS!$CCAS$ac_delim
 
22833
_ACEOF
 
22834
 
 
22835
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
 
22836
    break
 
22837
  elif $ac_last_try; then
 
22838
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
 
22839
echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
 
22840
   { (exit 1); exit 1; }; }
 
22841
  else
 
22842
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
 
22843
  fi
 
22844
done
 
22845
 
 
22846
ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
 
22847
if test -n "$ac_eof"; then
 
22848
  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
 
22849
  ac_eof=`expr $ac_eof + 1`
 
22850
fi
 
22851
 
 
22852
cat >>$CONFIG_STATUS <<_ACEOF
 
22853
cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
 
22854
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 
22855
_ACEOF
 
22856
sed '
 
22857
s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
 
22858
s/^/s,@/; s/!/@,|#_!!_#|/
 
22859
:n
 
22860
t n
 
22861
s/'"$ac_delim"'$/,g/; t
 
22862
s/$/\\/; p
 
22863
N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
 
22864
' >>$CONFIG_STATUS <conf$$subs.sed
 
22865
rm -f conf$$subs.sed
 
22866
cat >>$CONFIG_STATUS <<_ACEOF
 
22867
CEOF$ac_eof
 
22868
_ACEOF
 
22869
 
 
22870
 
 
22871
ac_delim='%!_!# '
 
22872
for ac_last_try in false false false false false :; do
 
22873
  cat >conf$$subs.sed <<_ACEOF
21976
22874
CCASFLAGS!$CCASFLAGS$ac_delim
21977
22875
AR!$AR$ac_delim
21978
22876
RANLIB!$RANLIB$ac_delim
21979
 
_ACEOF
21980
 
 
21981
 
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
21982
 
    break
21983
 
  elif $ac_last_try; then
21984
 
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
21985
 
echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
21986
 
   { (exit 1); exit 1; }; }
21987
 
  else
21988
 
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
21989
 
  fi
21990
 
done
21991
 
 
21992
 
ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
21993
 
if test -n "$ac_eof"; then
21994
 
  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
21995
 
  ac_eof=`expr $ac_eof + 1`
21996
 
fi
21997
 
 
21998
 
cat >>$CONFIG_STATUS <<_ACEOF
21999
 
cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
22000
 
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
22001
 
_ACEOF
22002
 
sed '
22003
 
s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
22004
 
s/^/s,@/; s/!/@,|#_!!_#|/
22005
 
:n
22006
 
t n
22007
 
s/'"$ac_delim"'$/,g/; t
22008
 
s/$/\\/; p
22009
 
N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
22010
 
' >>$CONFIG_STATUS <conf$$subs.sed
22011
 
rm -f conf$$subs.sed
22012
 
cat >>$CONFIG_STATUS <<_ACEOF
22013
 
CEOF$ac_eof
22014
 
_ACEOF
22015
 
 
22016
 
 
22017
 
ac_delim='%!_!# '
22018
 
for ac_last_try in false false false false false :; do
22019
 
  cat >conf$$subs.sed <<_ACEOF
22020
 
MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim
22021
 
MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim
22022
 
MAINT!$MAINT$ac_delim
22023
22877
GC_CFLAGS!$GC_CFLAGS$ac_delim
22024
22878
THREADDLLIBS!$THREADDLLIBS$ac_delim
22025
 
POWERPC_DARWIN_TRUE!$POWERPC_DARWIN_TRUE$ac_delim
22026
 
POWERPC_DARWIN_FALSE!$POWERPC_DARWIN_FALSE$ac_delim
 
22879
THREADS_TRUE!$THREADS_TRUE$ac_delim
 
22880
THREADS_FALSE!$THREADS_FALSE$ac_delim
 
22881
PTHREADS_TRUE!$PTHREADS_TRUE$ac_delim
 
22882
PTHREADS_FALSE!$PTHREADS_FALSE$ac_delim
 
22883
DARWIN_THREADS_TRUE!$DARWIN_THREADS_TRUE$ac_delim
 
22884
DARWIN_THREADS_FALSE!$DARWIN_THREADS_FALSE$ac_delim
 
22885
WIN32_THREADS_TRUE!$WIN32_THREADS_TRUE$ac_delim
 
22886
WIN32_THREADS_FALSE!$WIN32_THREADS_FALSE$ac_delim
22027
22887
COMPILER_XLC_TRUE!$COMPILER_XLC_TRUE$ac_delim
22028
22888
COMPILER_XLC_FALSE!$COMPILER_XLC_FALSE$ac_delim
 
22889
AVOID_CPP_LIB_TRUE!$AVOID_CPP_LIB_TRUE$ac_delim
 
22890
AVOID_CPP_LIB_FALSE!$AVOID_CPP_LIB_FALSE$ac_delim
 
22891
extra_ldflags_libgc!$extra_ldflags_libgc$ac_delim
22029
22892
EXTRA_TEST_LIBS!$EXTRA_TEST_LIBS$ac_delim
22030
22893
target_all!$target_all$ac_delim
22031
22894
CPLUSPLUS_TRUE!$CPLUSPLUS_TRUE$ac_delim
22033
22896
INCLUDES!$INCLUDES$ac_delim
22034
22897
CXXINCLUDES!$CXXINCLUDES$ac_delim
22035
22898
addobjs!$addobjs$ac_delim
22036
 
addincludes!$addincludes$ac_delim
22037
22899
addlibs!$addlibs$ac_delim
22038
 
addtests!$addtests$ac_delim
22039
22900
GREP!$GREP$ac_delim
22040
22901
EGREP!$EGREP$ac_delim
22041
22902
LN_S!$LN_S$ac_delim
22046
22907
FFLAGS!$FFLAGS$ac_delim
22047
22908
ac_ct_F77!$ac_ct_F77$ac_delim
22048
22909
LIBTOOL!$LIBTOOL$ac_delim
22049
 
MY_CFLAGS!$MY_CFLAGS$ac_delim
 
22910
ENABLE_GCJ_SUPPORT_TRUE!$ENABLE_GCJ_SUPPORT_TRUE$ac_delim
 
22911
ENABLE_GCJ_SUPPORT_FALSE!$ENABLE_GCJ_SUPPORT_FALSE$ac_delim
22050
22912
UNWINDLIBS!$UNWINDLIBS$ac_delim
22051
22913
USE_LIBDIR_TRUE!$USE_LIBDIR_TRUE$ac_delim
22052
22914
USE_LIBDIR_FALSE!$USE_LIBDIR_FALSE$ac_delim
 
22915
subdirs!$subdirs$ac_delim
 
22916
USE_INTERNAL_LIBATOMIC_OPS_TRUE!$USE_INTERNAL_LIBATOMIC_OPS_TRUE$ac_delim
 
22917
USE_INTERNAL_LIBATOMIC_OPS_FALSE!$USE_INTERNAL_LIBATOMIC_OPS_FALSE$ac_delim
 
22918
NEED_ATOMIC_OPS_ASM_TRUE!$NEED_ATOMIC_OPS_ASM_TRUE$ac_delim
 
22919
NEED_ATOMIC_OPS_ASM_FALSE!$NEED_ATOMIC_OPS_ASM_FALSE$ac_delim
 
22920
atomic_ops_libs!$atomic_ops_libs$ac_delim
22053
22921
LIBOBJS!$LIBOBJS$ac_delim
22054
22922
LTLIBOBJS!$LTLIBOBJS$ac_delim
22055
22923
_ACEOF
22056
22924
 
22057
 
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 35; then
 
22925
  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 49; then
22058
22926
    break
22059
22927
  elif $ac_last_try; then
22060
22928
    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
22515
23383
  $ac_cs_success || { (exit 1); exit 1; }
22516
23384
fi
22517
23385
 
 
23386
#
 
23387
# CONFIG_SUBDIRS section.
 
23388
#
 
23389
if test "$no_recursion" != yes; then
 
23390
 
 
23391
  # Remove --cache-file and --srcdir arguments so they do not pile up.
 
23392
  ac_sub_configure_args=
 
23393
  ac_prev=
 
23394
  eval "set x $ac_configure_args"
 
23395
  shift
 
23396
  for ac_arg
 
23397
  do
 
23398
    if test -n "$ac_prev"; then
 
23399
      ac_prev=
 
23400
      continue
 
23401
    fi
 
23402
    case $ac_arg in
 
23403
    -cache-file | --cache-file | --cache-fil | --cache-fi \
 
23404
    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 
23405
      ac_prev=cache_file ;;
 
23406
    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 
23407
    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
 
23408
    | --c=*)
 
23409
      ;;
 
23410
    --config-cache | -C)
 
23411
      ;;
 
23412
    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 
23413
      ac_prev=srcdir ;;
 
23414
    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 
23415
      ;;
 
23416
    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 
23417
      ac_prev=prefix ;;
 
23418
    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 
23419
      ;;
 
23420
    *)
 
23421
      case $ac_arg in
 
23422
      *\'*) ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
 
23423
      esac
 
23424
      ac_sub_configure_args="$ac_sub_configure_args '$ac_arg'" ;;
 
23425
    esac
 
23426
  done
 
23427
 
 
23428
  # Always prepend --prefix to ensure using the same prefix
 
23429
  # in subdir configurations.
 
23430
  ac_arg="--prefix=$prefix"
 
23431
  case $ac_arg in
 
23432
  *\'*) ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
 
23433
  esac
 
23434
  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
 
23435
 
 
23436
  # Pass --silent
 
23437
  if test "$silent" = yes; then
 
23438
    ac_sub_configure_args="--silent $ac_sub_configure_args"
 
23439
  fi
 
23440
 
 
23441
  ac_popdir=`pwd`
 
23442
  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
 
23443
 
 
23444
    # Do not complain, so a configure script can configure whichever
 
23445
    # parts of a large source tree are present.
 
23446
    test -d "$srcdir/$ac_dir" || continue
 
23447
 
 
23448
    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
 
23449
    echo "$as_me:$LINENO: $ac_msg" >&5
 
23450
    echo "$ac_msg" >&6
 
23451
    { as_dir="$ac_dir"
 
23452
  case $as_dir in #(
 
23453
  -*) as_dir=./$as_dir;;
 
23454
  esac
 
23455
  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
 
23456
    as_dirs=
 
23457
    while :; do
 
23458
      case $as_dir in #(
 
23459
      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
 
23460
      *) as_qdir=$as_dir;;
 
23461
      esac
 
23462
      as_dirs="'$as_qdir' $as_dirs"
 
23463
      as_dir=`$as_dirname -- "$as_dir" ||
 
23464
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 
23465
         X"$as_dir" : 'X\(//\)[^/]' \| \
 
23466
         X"$as_dir" : 'X\(//\)$' \| \
 
23467
         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
 
23468
echo X"$as_dir" |
 
23469
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 
23470
            s//\1/
 
23471
            q
 
23472
          }
 
23473
          /^X\(\/\/\)[^/].*/{
 
23474
            s//\1/
 
23475
            q
 
23476
          }
 
23477
          /^X\(\/\/\)$/{
 
23478
            s//\1/
 
23479
            q
 
23480
          }
 
23481
          /^X\(\/\).*/{
 
23482
            s//\1/
 
23483
            q
 
23484
          }
 
23485
          s/.*/./; q'`
 
23486
      test -d "$as_dir" && break
 
23487
    done
 
23488
    test -z "$as_dirs" || eval "mkdir $as_dirs"
 
23489
  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
 
23490
echo "$as_me: error: cannot create directory $as_dir" >&2;}
 
23491
   { (exit 1); exit 1; }; }; }
 
23492
    ac_builddir=.
 
23493
 
 
23494
case "$ac_dir" in
 
23495
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
 
23496
*)
 
23497
  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
 
23498
  # A ".." for each directory in $ac_dir_suffix.
 
23499
  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
 
23500
  case $ac_top_builddir_sub in
 
23501
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
 
23502
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
 
23503
  esac ;;
 
23504
esac
 
23505
ac_abs_top_builddir=$ac_pwd
 
23506
ac_abs_builddir=$ac_pwd$ac_dir_suffix
 
23507
# for backward compatibility:
 
23508
ac_top_builddir=$ac_top_build_prefix
 
23509
 
 
23510
case $srcdir in
 
23511
  .)  # We are building in place.
 
23512
    ac_srcdir=.
 
23513
    ac_top_srcdir=$ac_top_builddir_sub
 
23514
    ac_abs_top_srcdir=$ac_pwd ;;
 
23515
  [\\/]* | ?:[\\/]* )  # Absolute name.
 
23516
    ac_srcdir=$srcdir$ac_dir_suffix;
 
23517
    ac_top_srcdir=$srcdir
 
23518
    ac_abs_top_srcdir=$srcdir ;;
 
23519
  *) # Relative name.
 
23520
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
 
23521
    ac_top_srcdir=$ac_top_build_prefix$srcdir
 
23522
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
 
23523
esac
 
23524
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
 
23525
 
 
23526
 
 
23527
    cd "$ac_dir"
 
23528
 
 
23529
    # Check for guested configure; otherwise get Cygnus style configure.
 
23530
    if test -f "$ac_srcdir/configure.gnu"; then
 
23531
      ac_sub_configure=$ac_srcdir/configure.gnu
 
23532
    elif test -f "$ac_srcdir/configure"; then
 
23533
      ac_sub_configure=$ac_srcdir/configure
 
23534
    elif test -f "$ac_srcdir/configure.in"; then
 
23535
      # This should be Cygnus configure.
 
23536
      ac_sub_configure=$ac_aux_dir/configure
 
23537
    else
 
23538
      { echo "$as_me:$LINENO: WARNING: no configuration information is in $ac_dir" >&5
 
23539
echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
 
23540
      ac_sub_configure=
 
23541
    fi
 
23542
 
 
23543
    # The recursion is here.
 
23544
    if test -n "$ac_sub_configure"; then
 
23545
      # Make the cache file name correct relative to the subdirectory.
 
23546
      case $cache_file in
 
23547
      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
 
23548
      *) # Relative name.
 
23549
        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
 
23550
      esac
 
23551
 
 
23552
      { echo "$as_me:$LINENO: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
 
23553
echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
 
23554
      # The eval makes quoting arguments work.
 
23555
      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
 
23556
           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
 
23557
        { { echo "$as_me:$LINENO: error: $ac_sub_configure failed for $ac_dir" >&5
 
23558
echo "$as_me: error: $ac_sub_configure failed for $ac_dir" >&2;}
 
23559
   { (exit 1); exit 1; }; }
 
23560
    fi
 
23561
 
 
23562
    cd "$ac_popdir"
 
23563
  done
 
23564
fi
 
23565