/sqlite3cc

To get this branch, use:
bzr branch http://bzr.ed.am/sqlite3cc

« back to all changes in this revision

Viewing changes to configure

  • Committer: edam
  • Date: 2010-02-07 14:39:18 UTC
  • Revision ID: edam@waxworlds.org-20100207143918-gi030ojecbska8hw
- updated README
- set up project for use with autotools

Show diffs side-by-side

added added

removed removed

Lines of Context:
701
701
PACKAGE_VERSION='0.1.0'
702
702
PACKAGE_STRING='sqlite3cc 0.1.0'
703
703
PACKAGE_BUGREPORT='edam@waxworlds.org'
704
 
PACKAGE_URL='http://www.waxworlds.org/edam/software/sqlite3cc'
 
704
PACKAGE_URL=''
705
705
 
706
706
ac_unique_file="src/database.cc"
707
707
# Factoring default headers for most tests.
745
745
LTLIBOBJS
746
746
LIBOBJS
747
747
CXXCPP
748
 
am__fastdepCXX_FALSE
749
 
am__fastdepCXX_TRUE
750
 
CXXDEPMODE
751
 
ac_ct_CXX
752
 
CXXFLAGS
753
 
CXX
754
748
CPP
755
749
OTOOL64
756
750
OTOOL
773
767
am__fastdepCC_FALSE
774
768
am__fastdepCC_TRUE
775
769
CCDEPMODE
776
 
AMDEPBACKSLASH
777
 
AMDEP_FALSE
778
 
AMDEP_TRUE
779
 
am__quote
780
 
am__include
781
 
DEPDIR
782
 
OBJEXT
783
 
EXEEXT
784
770
ac_ct_CC
785
 
CPPFLAGS
786
 
LDFLAGS
787
771
CFLAGS
788
772
CC
789
773
host_os
795
779
build_cpu
796
780
build
797
781
LIBTOOL
 
782
am__fastdepCXX_FALSE
 
783
am__fastdepCXX_TRUE
 
784
CXXDEPMODE
 
785
AMDEPBACKSLASH
 
786
AMDEP_FALSE
 
787
AMDEP_TRUE
 
788
am__quote
 
789
am__include
 
790
DEPDIR
 
791
OBJEXT
 
792
EXEEXT
 
793
ac_ct_CXX
 
794
CPPFLAGS
 
795
LDFLAGS
 
796
CXXFLAGS
 
797
CXX
798
798
am__untar
799
799
am__tar
800
800
AMTAR
818
818
INSTALL_DATA
819
819
INSTALL_SCRIPT
820
820
INSTALL_PROGRAM
821
 
LIBSQLITE3CC_INTERFACE
822
821
target_alias
823
822
host_alias
824
823
build_alias
860
859
ac_subst_files=''
861
860
ac_user_opts='
862
861
enable_option_checking
 
862
enable_dependency_tracking
863
863
enable_shared
864
864
enable_static
865
865
with_pic
866
866
enable_fast_install
867
 
enable_dependency_tracking
868
867
with_gnu_ld
869
868
enable_libtool_lock
870
869
'
871
870
      ac_precious_vars='build_alias
872
871
host_alias
873
872
target_alias
874
 
CC
875
 
CFLAGS
 
873
CXX
 
874
CXXFLAGS
876
875
LDFLAGS
877
876
LIBS
878
877
CPPFLAGS
879
 
CPP
880
 
CXX
881
 
CXXFLAGS
882
878
CCC
 
879
CC
 
880
CFLAGS
 
881
CPP
883
882
CXXCPP'
884
883
 
885
884
 
1500
1499
  --disable-option-checking  ignore unrecognized --enable/--with options
1501
1500
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1502
1501
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 
1502
  --disable-dependency-tracking  speeds up one-time build
 
1503
  --enable-dependency-tracking   do not reject slow dependency extractors
1503
1504
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1504
1505
  --enable-static[=PKGS]  build static libraries [default=yes]
1505
1506
  --enable-fast-install[=PKGS]
1506
1507
                          optimize for fast installation [default=yes]
1507
 
  --disable-dependency-tracking  speeds up one-time build
1508
 
  --enable-dependency-tracking   do not reject slow dependency extractors
1509
1508
  --disable-libtool-lock  avoid locking (might break parallel builds)
1510
1509
 
1511
1510
Optional Packages:
1516
1515
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1517
1516
 
1518
1517
Some influential environment variables:
1519
 
  CC          C compiler command
1520
 
  CFLAGS      C compiler flags
 
1518
  CXX         C++ compiler command
 
1519
  CXXFLAGS    C++ compiler flags
1521
1520
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1522
1521
              nonstandard directory <lib dir>
1523
1522
  LIBS        libraries to pass to the linker, e.g. -l<library>
1524
1523
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1525
1524
              you have headers in a nonstandard directory <include dir>
 
1525
  CC          C compiler command
 
1526
  CFLAGS      C compiler flags
1526
1527
  CPP         C preprocessor
1527
 
  CXX         C++ compiler command
1528
 
  CXXFLAGS    C++ compiler flags
1529
1528
  CXXCPP      C++ preprocessor
1530
1529
 
1531
1530
Use these variables to override the choices made by `configure' or to help
1532
1531
it to find libraries and programs with nonstandard names/locations.
1533
1532
 
1534
1533
Report bugs to <edam@waxworlds.org>.
1535
 
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>.
1536
1534
_ACEOF
1537
1535
ac_status=$?
1538
1536
fi
1609
1607
## Autoconf initialization. ##
1610
1608
## ------------------------ ##
1611
1609
 
 
1610
# ac_fn_cxx_try_compile LINENO
 
1611
# ----------------------------
 
1612
# Try to compile conftest.$ac_ext, and return whether this succeeded.
 
1613
ac_fn_cxx_try_compile ()
 
1614
{
 
1615
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 
1616
  rm -f conftest.$ac_objext
 
1617
  if { { ac_try="$ac_compile"
 
1618
case "(($ac_try" in
 
1619
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
1620
  *) ac_try_echo=$ac_try;;
 
1621
esac
 
1622
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
1623
$as_echo "$ac_try_echo"; } >&5
 
1624
  (eval "$ac_compile") 2>conftest.err
 
1625
  ac_status=$?
 
1626
  if test -s conftest.err; then
 
1627
    grep -v '^ *+' conftest.err >conftest.er1
 
1628
    cat conftest.er1 >&5
 
1629
    mv -f conftest.er1 conftest.err
 
1630
  fi
 
1631
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
1632
  test $ac_status = 0; } && {
 
1633
         test -z "$ac_cxx_werror_flag" ||
 
1634
         test ! -s conftest.err
 
1635
       } && test -s conftest.$ac_objext; then :
 
1636
  ac_retval=0
 
1637
else
 
1638
  $as_echo "$as_me: failed program was:" >&5
 
1639
sed 's/^/| /' conftest.$ac_ext >&5
 
1640
 
 
1641
        ac_retval=1
 
1642
fi
 
1643
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
1644
  return $ac_retval
 
1645
 
 
1646
} # ac_fn_cxx_try_compile
 
1647
 
1612
1648
# ac_fn_c_try_compile LINENO
1613
1649
# --------------------------
1614
1650
# Try to compile conftest.$ac_ext, and return whether this succeeded.
1870
1906
 
1871
1907
} # ac_fn_c_check_func
1872
1908
 
1873
 
# ac_fn_cxx_try_compile LINENO
1874
 
# ----------------------------
1875
 
# Try to compile conftest.$ac_ext, and return whether this succeeded.
1876
 
ac_fn_cxx_try_compile ()
1877
 
{
1878
 
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1879
 
  rm -f conftest.$ac_objext
1880
 
  if { { ac_try="$ac_compile"
1881
 
case "(($ac_try" in
1882
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1883
 
  *) ac_try_echo=$ac_try;;
1884
 
esac
1885
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1886
 
$as_echo "$ac_try_echo"; } >&5
1887
 
  (eval "$ac_compile") 2>conftest.err
1888
 
  ac_status=$?
1889
 
  if test -s conftest.err; then
1890
 
    grep -v '^ *+' conftest.err >conftest.er1
1891
 
    cat conftest.er1 >&5
1892
 
    mv -f conftest.er1 conftest.err
1893
 
  fi
1894
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1895
 
  test $ac_status = 0; } && {
1896
 
         test -z "$ac_cxx_werror_flag" ||
1897
 
         test ! -s conftest.err
1898
 
       } && test -s conftest.$ac_objext; then :
1899
 
  ac_retval=0
1900
 
else
1901
 
  $as_echo "$as_me: failed program was:" >&5
1902
 
sed 's/^/| /' conftest.$ac_ext >&5
1903
 
 
1904
 
        ac_retval=1
1905
 
fi
1906
 
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1907
 
  return $ac_retval
1908
 
 
1909
 
} # ac_fn_cxx_try_compile
1910
 
 
1911
1909
# ac_fn_cxx_try_cpp LINENO
1912
1910
# ------------------------
1913
1911
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2434
2432
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2435
2433
 
2436
2434
 
2437
 
LIBSQLITE3CC_INTERFACE=0:0:0
2438
 
 
2439
2435
ac_aux_dir=
2440
2436
for ac_dir in build-aux "$srcdir"/build-aux; do
2441
2437
  for ac_t in install-sh install.sh shtool; do
2941
2937
 
2942
2938
ac_config_headers="$ac_config_headers config.h"
2943
2939
 
2944
 
case `pwd` in
2945
 
  *\ * | *\     *)
2946
 
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
2947
 
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
2948
 
esac
2949
 
 
2950
 
 
2951
 
 
2952
 
macro_version='2.2.6'
2953
 
macro_revision='1.3012'
2954
 
 
2955
 
 
2956
 
 
2957
 
 
2958
 
 
2959
 
 
2960
 
 
2961
 
 
2962
 
 
2963
 
 
2964
 
 
2965
 
 
2966
 
 
2967
 
ltmain="$ac_aux_dir/ltmain.sh"
2968
 
 
2969
 
# Make sure we can run config.sub.
2970
 
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2971
 
  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2972
 
 
2973
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2974
 
$as_echo_n "checking build system type... " >&6; }
2975
 
if test "${ac_cv_build+set}" = set; then :
2976
 
  $as_echo_n "(cached) " >&6
2977
 
else
2978
 
  ac_build_alias=$build_alias
2979
 
test "x$ac_build_alias" = x &&
2980
 
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2981
 
test "x$ac_build_alias" = x &&
2982
 
  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
2983
 
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2984
 
  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2985
 
 
2986
 
fi
2987
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2988
 
$as_echo "$ac_cv_build" >&6; }
2989
 
case $ac_cv_build in
2990
 
*-*-*) ;;
2991
 
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
2992
 
esac
2993
 
build=$ac_cv_build
2994
 
ac_save_IFS=$IFS; IFS='-'
2995
 
set x $ac_cv_build
2996
 
shift
2997
 
build_cpu=$1
2998
 
build_vendor=$2
2999
 
shift; shift
3000
 
# Remember, the first character of IFS is used to create $*,
3001
 
# except with old shells:
3002
 
build_os=$*
3003
 
IFS=$ac_save_IFS
3004
 
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
3005
 
 
3006
 
 
3007
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
3008
 
$as_echo_n "checking host system type... " >&6; }
3009
 
if test "${ac_cv_host+set}" = set; then :
3010
 
  $as_echo_n "(cached) " >&6
3011
 
else
3012
 
  if test "x$host_alias" = x; then
3013
 
  ac_cv_host=$ac_cv_build
3014
 
else
3015
 
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
3016
 
    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
3017
 
fi
3018
 
 
3019
 
fi
3020
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
3021
 
$as_echo "$ac_cv_host" >&6; }
3022
 
case $ac_cv_host in
3023
 
*-*-*) ;;
3024
 
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
3025
 
esac
3026
 
host=$ac_cv_host
3027
 
ac_save_IFS=$IFS; IFS='-'
3028
 
set x $ac_cv_host
3029
 
shift
3030
 
host_cpu=$1
3031
 
host_vendor=$2
3032
 
shift; shift
3033
 
# Remember, the first character of IFS is used to create $*,
3034
 
# except with old shells:
3035
 
host_os=$*
3036
 
IFS=$ac_save_IFS
3037
 
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
3038
 
 
3039
 
 
3040
 
DEPDIR="${am__leading_dot}deps"
3041
 
 
3042
 
ac_config_commands="$ac_config_commands depfiles"
3043
 
 
3044
 
 
3045
 
am_make=${MAKE-make}
3046
 
cat > confinc << 'END'
3047
 
am__doit:
3048
 
        @echo this is the am__doit target
3049
 
.PHONY: am__doit
3050
 
END
3051
 
# If we don't find an include directive, just comment out the code.
3052
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
3053
 
$as_echo_n "checking for style of include used by $am_make... " >&6; }
3054
 
am__include="#"
3055
 
am__quote=
3056
 
_am_result=none
3057
 
# First try GNU make style include.
3058
 
echo "include confinc" > confmf
3059
 
# Ignore all kinds of additional output from `make'.
3060
 
case `$am_make -s -f confmf 2> /dev/null` in #(
3061
 
*the\ am__doit\ target*)
3062
 
  am__include=include
3063
 
  am__quote=
3064
 
  _am_result=GNU
3065
 
  ;;
3066
 
esac
3067
 
# Now try BSD make style include.
3068
 
if test "$am__include" = "#"; then
3069
 
   echo '.include "confinc"' > confmf
3070
 
   case `$am_make -s -f confmf 2> /dev/null` in #(
3071
 
   *the\ am__doit\ target*)
3072
 
     am__include=.include
3073
 
     am__quote="\""
3074
 
     _am_result=BSD
3075
 
     ;;
3076
 
   esac
3077
 
fi
3078
 
 
3079
 
 
3080
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
3081
 
$as_echo "$_am_result" >&6; }
3082
 
rm -f confinc confmf
3083
 
 
3084
 
# Check whether --enable-dependency-tracking was given.
3085
 
if test "${enable_dependency_tracking+set}" = set; then :
3086
 
  enableval=$enable_dependency_tracking;
3087
 
fi
3088
 
 
3089
 
if test "x$enable_dependency_tracking" != xno; then
3090
 
  am_depcomp="$ac_aux_dir/depcomp"
3091
 
  AMDEPBACKSLASH='\'
3092
 
fi
3093
 
 if test "x$enable_dependency_tracking" != xno; then
3094
 
  AMDEP_TRUE=
3095
 
  AMDEP_FALSE='#'
3096
 
else
3097
 
  AMDEP_TRUE='#'
3098
 
  AMDEP_FALSE=
3099
 
fi
3100
 
 
3101
 
 
3102
 
ac_ext=c
3103
 
ac_cpp='$CPP $CPPFLAGS'
3104
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3105
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3106
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3107
 
if test -n "$ac_tool_prefix"; then
3108
 
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
3109
 
set dummy ${ac_tool_prefix}gcc; ac_word=$2
3110
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3111
 
$as_echo_n "checking for $ac_word... " >&6; }
3112
 
if test "${ac_cv_prog_CC+set}" = set; then :
3113
 
  $as_echo_n "(cached) " >&6
3114
 
else
3115
 
  if test -n "$CC"; then
3116
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3117
 
else
3118
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3119
 
for as_dir in $PATH
3120
 
do
3121
 
  IFS=$as_save_IFS
3122
 
  test -z "$as_dir" && as_dir=.
3123
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3124
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3125
 
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
3126
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3127
 
    break 2
3128
 
  fi
3129
 
done
3130
 
  done
3131
 
IFS=$as_save_IFS
3132
 
 
3133
 
fi
3134
 
fi
3135
 
CC=$ac_cv_prog_CC
3136
 
if test -n "$CC"; then
3137
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3138
 
$as_echo "$CC" >&6; }
3139
 
else
3140
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3141
 
$as_echo "no" >&6; }
3142
 
fi
3143
 
 
3144
 
 
3145
 
fi
3146
 
if test -z "$ac_cv_prog_CC"; then
3147
 
  ac_ct_CC=$CC
3148
 
  # Extract the first word of "gcc", so it can be a program name with args.
3149
 
set dummy gcc; ac_word=$2
3150
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3151
 
$as_echo_n "checking for $ac_word... " >&6; }
3152
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
3153
 
  $as_echo_n "(cached) " >&6
3154
 
else
3155
 
  if test -n "$ac_ct_CC"; then
3156
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3157
 
else
3158
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3159
 
for as_dir in $PATH
3160
 
do
3161
 
  IFS=$as_save_IFS
3162
 
  test -z "$as_dir" && as_dir=.
3163
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3164
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3165
 
    ac_cv_prog_ac_ct_CC="gcc"
3166
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3167
 
    break 2
3168
 
  fi
3169
 
done
3170
 
  done
3171
 
IFS=$as_save_IFS
3172
 
 
3173
 
fi
3174
 
fi
3175
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3176
 
if test -n "$ac_ct_CC"; then
3177
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3178
 
$as_echo "$ac_ct_CC" >&6; }
3179
 
else
3180
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3181
 
$as_echo "no" >&6; }
3182
 
fi
3183
 
 
3184
 
  if test "x$ac_ct_CC" = x; then
3185
 
    CC=""
 
2940
 
 
2941
# checks for programs.
 
2942
ac_ext=cpp
 
2943
ac_cpp='$CXXCPP $CPPFLAGS'
 
2944
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2945
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2946
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
2947
if test -z "$CXX"; then
 
2948
  if test -n "$CCC"; then
 
2949
    CXX=$CCC
3186
2950
  else
3187
 
    case $cross_compiling:$ac_tool_warned in
3188
 
yes:)
3189
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3190
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3191
 
ac_tool_warned=yes ;;
3192
 
esac
3193
 
    CC=$ac_ct_CC
3194
 
  fi
3195
 
else
3196
 
  CC="$ac_cv_prog_CC"
3197
 
fi
3198
 
 
3199
 
if test -z "$CC"; then
3200
 
          if test -n "$ac_tool_prefix"; then
3201
 
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3202
 
set dummy ${ac_tool_prefix}cc; ac_word=$2
3203
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3204
 
$as_echo_n "checking for $ac_word... " >&6; }
3205
 
if test "${ac_cv_prog_CC+set}" = set; then :
3206
 
  $as_echo_n "(cached) " >&6
3207
 
else
3208
 
  if test -n "$CC"; then
3209
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3210
 
else
3211
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3212
 
for as_dir in $PATH
3213
 
do
3214
 
  IFS=$as_save_IFS
3215
 
  test -z "$as_dir" && as_dir=.
3216
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3217
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3218
 
    ac_cv_prog_CC="${ac_tool_prefix}cc"
3219
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3220
 
    break 2
3221
 
  fi
3222
 
done
3223
 
  done
3224
 
IFS=$as_save_IFS
3225
 
 
3226
 
fi
3227
 
fi
3228
 
CC=$ac_cv_prog_CC
3229
 
if test -n "$CC"; then
3230
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3231
 
$as_echo "$CC" >&6; }
3232
 
else
3233
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3234
 
$as_echo "no" >&6; }
3235
 
fi
3236
 
 
3237
 
 
3238
 
  fi
3239
 
fi
3240
 
if test -z "$CC"; then
3241
 
  # Extract the first word of "cc", so it can be a program name with args.
3242
 
set dummy cc; ac_word=$2
3243
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3244
 
$as_echo_n "checking for $ac_word... " >&6; }
3245
 
if test "${ac_cv_prog_CC+set}" = set; then :
3246
 
  $as_echo_n "(cached) " >&6
3247
 
else
3248
 
  if test -n "$CC"; then
3249
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3250
 
else
3251
 
  ac_prog_rejected=no
3252
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3253
 
for as_dir in $PATH
3254
 
do
3255
 
  IFS=$as_save_IFS
3256
 
  test -z "$as_dir" && as_dir=.
3257
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3258
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3259
 
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3260
 
       ac_prog_rejected=yes
3261
 
       continue
3262
 
     fi
3263
 
    ac_cv_prog_CC="cc"
3264
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3265
 
    break 2
3266
 
  fi
3267
 
done
3268
 
  done
3269
 
IFS=$as_save_IFS
3270
 
 
3271
 
if test $ac_prog_rejected = yes; then
3272
 
  # We found a bogon in the path, so make sure we never use it.
3273
 
  set dummy $ac_cv_prog_CC
3274
 
  shift
3275
 
  if test $# != 0; then
3276
 
    # We chose a different compiler from the bogus one.
3277
 
    # However, it has the same basename, so the bogon will be chosen
3278
 
    # first if we set CC to just the basename; use the full file name.
3279
 
    shift
3280
 
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3281
 
  fi
3282
 
fi
3283
 
fi
3284
 
fi
3285
 
CC=$ac_cv_prog_CC
3286
 
if test -n "$CC"; then
3287
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3288
 
$as_echo "$CC" >&6; }
3289
 
else
3290
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3291
 
$as_echo "no" >&6; }
3292
 
fi
3293
 
 
3294
 
 
3295
 
fi
3296
 
if test -z "$CC"; then
3297
 
  if test -n "$ac_tool_prefix"; then
3298
 
  for ac_prog in cl.exe
 
2951
    if test -n "$ac_tool_prefix"; then
 
2952
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3299
2953
  do
3300
2954
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3301
2955
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3302
2956
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3303
2957
$as_echo_n "checking for $ac_word... " >&6; }
3304
 
if test "${ac_cv_prog_CC+set}" = set; then :
 
2958
if test "${ac_cv_prog_CXX+set}" = set; then :
3305
2959
  $as_echo_n "(cached) " >&6
3306
2960
else
3307
 
  if test -n "$CC"; then
3308
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
2961
  if test -n "$CXX"; then
 
2962
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
3309
2963
else
3310
2964
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3311
2965
for as_dir in $PATH
3314
2968
  test -z "$as_dir" && as_dir=.
3315
2969
    for ac_exec_ext in '' $ac_executable_extensions; do
3316
2970
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3317
 
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
2971
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3318
2972
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3319
2973
    break 2
3320
2974
  fi
3324
2978
 
3325
2979
fi
3326
2980
fi
3327
 
CC=$ac_cv_prog_CC
3328
 
if test -n "$CC"; then
3329
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3330
 
$as_echo "$CC" >&6; }
 
2981
CXX=$ac_cv_prog_CXX
 
2982
if test -n "$CXX"; then
 
2983
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
 
2984
$as_echo "$CXX" >&6; }
3331
2985
else
3332
2986
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3333
2987
$as_echo "no" >&6; }
3334
2988
fi
3335
2989
 
3336
2990
 
3337
 
    test -n "$CC" && break
 
2991
    test -n "$CXX" && break
3338
2992
  done
3339
2993
fi
3340
 
if test -z "$CC"; then
3341
 
  ac_ct_CC=$CC
3342
 
  for ac_prog in cl.exe
 
2994
if test -z "$CXX"; then
 
2995
  ac_ct_CXX=$CXX
 
2996
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3343
2997
do
3344
2998
  # Extract the first word of "$ac_prog", so it can be a program name with args.
3345
2999
set dummy $ac_prog; ac_word=$2
3346
3000
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3347
3001
$as_echo_n "checking for $ac_word... " >&6; }
3348
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
 
3002
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3349
3003
  $as_echo_n "(cached) " >&6
3350
3004
else
3351
 
  if test -n "$ac_ct_CC"; then
3352
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3005
  if test -n "$ac_ct_CXX"; then
 
3006
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3353
3007
else
3354
3008
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3355
3009
for as_dir in $PATH
3358
3012
  test -z "$as_dir" && as_dir=.
3359
3013
    for ac_exec_ext in '' $ac_executable_extensions; do
3360
3014
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3361
 
    ac_cv_prog_ac_ct_CC="$ac_prog"
 
3015
    ac_cv_prog_ac_ct_CXX="$ac_prog"
3362
3016
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3363
3017
    break 2
3364
3018
  fi
3368
3022
 
3369
3023
fi
3370
3024
fi
3371
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3372
 
if test -n "$ac_ct_CC"; then
3373
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3374
 
$as_echo "$ac_ct_CC" >&6; }
 
3025
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 
3026
if test -n "$ac_ct_CXX"; then
 
3027
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
 
3028
$as_echo "$ac_ct_CXX" >&6; }
3375
3029
else
3376
3030
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3377
3031
$as_echo "no" >&6; }
3378
3032
fi
3379
3033
 
3380
3034
 
3381
 
  test -n "$ac_ct_CC" && break
 
3035
  test -n "$ac_ct_CXX" && break
3382
3036
done
3383
3037
 
3384
 
  if test "x$ac_ct_CC" = x; then
3385
 
    CC=""
 
3038
  if test "x$ac_ct_CXX" = x; then
 
3039
    CXX="g++"
3386
3040
  else
3387
3041
    case $cross_compiling:$ac_tool_warned in
3388
3042
yes:)
3390
3044
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3391
3045
ac_tool_warned=yes ;;
3392
3046
esac
3393
 
    CC=$ac_ct_CC
3394
 
  fi
3395
 
fi
3396
 
 
3397
 
fi
3398
 
 
3399
 
 
3400
 
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3401
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3402
 
as_fn_error "no acceptable C compiler found in \$PATH
3403
 
See \`config.log' for more details." "$LINENO" 5; }
3404
 
 
 
3047
    CXX=$ac_ct_CXX
 
3048
  fi
 
3049
fi
 
3050
 
 
3051
  fi
 
3052
fi
3405
3053
# Provide some information about the compiler.
3406
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
 
3054
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3407
3055
set X $ac_compile
3408
3056
ac_compiler=$2
3409
3057
for ac_option in --version -v -V -qversion; do
3445
3093
# Try to create an executable without -o first, disregard a.out.
3446
3094
# It will help us diagnose broken compilers, and finding out an intuition
3447
3095
# of exeext.
3448
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
3449
 
$as_echo_n "checking for C compiler default output file name... " >&6; }
 
3096
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
 
3097
$as_echo_n "checking for C++ compiler default output file name... " >&6; }
3450
3098
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3451
3099
 
3452
3100
# The possible output files:
3517
3165
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3518
3166
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3519
3167
{ as_fn_set_status 77
3520
 
as_fn_error "C compiler cannot create executables
 
3168
as_fn_error "C++ compiler cannot create executables
3521
3169
See \`config.log' for more details." "$LINENO" 5; }; }
3522
3170
fi
3523
3171
ac_exeext=$ac_cv_exeext
3524
3172
 
3525
3173
# Check that the compiler produces executables we can run.  If not, either
3526
3174
# the compiler is broken, or we cross compile.
3527
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
3528
 
$as_echo_n "checking whether the C compiler works... " >&6; }
 
3175
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
 
3176
$as_echo_n "checking whether the C++ compiler works... " >&6; }
3529
3177
# If not cross compiling, check that we can run a simple program.
3530
3178
if test "$cross_compiling" != yes; then
3531
3179
  if { ac_try='./$ac_file'
3546
3194
    else
3547
3195
        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3548
3196
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3549
 
as_fn_error "cannot run C compiled programs.
 
3197
as_fn_error "cannot run C++ compiled programs.
3550
3198
If you meant to cross compile, use \`--host'.
3551
3199
See \`config.log' for more details." "$LINENO" 5; }
3552
3200
    fi
3654
3302
$as_echo "$ac_cv_objext" >&6; }
3655
3303
OBJEXT=$ac_cv_objext
3656
3304
ac_objext=$OBJEXT
 
3305
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
 
3306
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
 
3307
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
 
3308
  $as_echo_n "(cached) " >&6
 
3309
else
 
3310
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3311
/* end confdefs.h.  */
 
3312
 
 
3313
int
 
3314
main ()
 
3315
{
 
3316
#ifndef __GNUC__
 
3317
       choke me
 
3318
#endif
 
3319
 
 
3320
  ;
 
3321
  return 0;
 
3322
}
 
3323
_ACEOF
 
3324
if ac_fn_cxx_try_compile "$LINENO"; then :
 
3325
  ac_compiler_gnu=yes
 
3326
else
 
3327
  ac_compiler_gnu=no
 
3328
fi
 
3329
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
3330
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
 
3331
 
 
3332
fi
 
3333
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
 
3334
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
 
3335
if test $ac_compiler_gnu = yes; then
 
3336
  GXX=yes
 
3337
else
 
3338
  GXX=
 
3339
fi
 
3340
ac_test_CXXFLAGS=${CXXFLAGS+set}
 
3341
ac_save_CXXFLAGS=$CXXFLAGS
 
3342
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
 
3343
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
 
3344
if test "${ac_cv_prog_cxx_g+set}" = set; then :
 
3345
  $as_echo_n "(cached) " >&6
 
3346
else
 
3347
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
 
3348
   ac_cxx_werror_flag=yes
 
3349
   ac_cv_prog_cxx_g=no
 
3350
   CXXFLAGS="-g"
 
3351
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3352
/* end confdefs.h.  */
 
3353
 
 
3354
int
 
3355
main ()
 
3356
{
 
3357
 
 
3358
  ;
 
3359
  return 0;
 
3360
}
 
3361
_ACEOF
 
3362
if ac_fn_cxx_try_compile "$LINENO"; then :
 
3363
  ac_cv_prog_cxx_g=yes
 
3364
else
 
3365
  CXXFLAGS=""
 
3366
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3367
/* end confdefs.h.  */
 
3368
 
 
3369
int
 
3370
main ()
 
3371
{
 
3372
 
 
3373
  ;
 
3374
  return 0;
 
3375
}
 
3376
_ACEOF
 
3377
if ac_fn_cxx_try_compile "$LINENO"; then :
 
3378
 
 
3379
else
 
3380
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
3381
         CXXFLAGS="-g"
 
3382
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3383
/* end confdefs.h.  */
 
3384
 
 
3385
int
 
3386
main ()
 
3387
{
 
3388
 
 
3389
  ;
 
3390
  return 0;
 
3391
}
 
3392
_ACEOF
 
3393
if ac_fn_cxx_try_compile "$LINENO"; then :
 
3394
  ac_cv_prog_cxx_g=yes
 
3395
fi
 
3396
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
3397
fi
 
3398
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
3399
fi
 
3400
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
3401
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
3402
fi
 
3403
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
 
3404
$as_echo "$ac_cv_prog_cxx_g" >&6; }
 
3405
if test "$ac_test_CXXFLAGS" = set; then
 
3406
  CXXFLAGS=$ac_save_CXXFLAGS
 
3407
elif test $ac_cv_prog_cxx_g = yes; then
 
3408
  if test "$GXX" = yes; then
 
3409
    CXXFLAGS="-g -O2"
 
3410
  else
 
3411
    CXXFLAGS="-g"
 
3412
  fi
 
3413
else
 
3414
  if test "$GXX" = yes; then
 
3415
    CXXFLAGS="-O2"
 
3416
  else
 
3417
    CXXFLAGS=
 
3418
  fi
 
3419
fi
 
3420
ac_ext=c
 
3421
ac_cpp='$CPP $CPPFLAGS'
 
3422
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3423
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3424
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3425
DEPDIR="${am__leading_dot}deps"
 
3426
 
 
3427
ac_config_commands="$ac_config_commands depfiles"
 
3428
 
 
3429
 
 
3430
am_make=${MAKE-make}
 
3431
cat > confinc << 'END'
 
3432
am__doit:
 
3433
        @echo this is the am__doit target
 
3434
.PHONY: am__doit
 
3435
END
 
3436
# If we don't find an include directive, just comment out the code.
 
3437
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
 
3438
$as_echo_n "checking for style of include used by $am_make... " >&6; }
 
3439
am__include="#"
 
3440
am__quote=
 
3441
_am_result=none
 
3442
# First try GNU make style include.
 
3443
echo "include confinc" > confmf
 
3444
# Ignore all kinds of additional output from `make'.
 
3445
case `$am_make -s -f confmf 2> /dev/null` in #(
 
3446
*the\ am__doit\ target*)
 
3447
  am__include=include
 
3448
  am__quote=
 
3449
  _am_result=GNU
 
3450
  ;;
 
3451
esac
 
3452
# Now try BSD make style include.
 
3453
if test "$am__include" = "#"; then
 
3454
   echo '.include "confinc"' > confmf
 
3455
   case `$am_make -s -f confmf 2> /dev/null` in #(
 
3456
   *the\ am__doit\ target*)
 
3457
     am__include=.include
 
3458
     am__quote="\""
 
3459
     _am_result=BSD
 
3460
     ;;
 
3461
   esac
 
3462
fi
 
3463
 
 
3464
 
 
3465
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
 
3466
$as_echo "$_am_result" >&6; }
 
3467
rm -f confinc confmf
 
3468
 
 
3469
# Check whether --enable-dependency-tracking was given.
 
3470
if test "${enable_dependency_tracking+set}" = set; then :
 
3471
  enableval=$enable_dependency_tracking;
 
3472
fi
 
3473
 
 
3474
if test "x$enable_dependency_tracking" != xno; then
 
3475
  am_depcomp="$ac_aux_dir/depcomp"
 
3476
  AMDEPBACKSLASH='\'
 
3477
fi
 
3478
 if test "x$enable_dependency_tracking" != xno; then
 
3479
  AMDEP_TRUE=
 
3480
  AMDEP_FALSE='#'
 
3481
else
 
3482
  AMDEP_TRUE='#'
 
3483
  AMDEP_FALSE=
 
3484
fi
 
3485
 
 
3486
 
 
3487
 
 
3488
depcc="$CXX"  am_compiler_list=
 
3489
 
 
3490
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
 
3491
$as_echo_n "checking dependency style of $depcc... " >&6; }
 
3492
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
 
3493
  $as_echo_n "(cached) " >&6
 
3494
else
 
3495
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
3496
  # We make a subdir and do the tests there.  Otherwise we can end up
 
3497
  # making bogus files that we don't know about and never remove.  For
 
3498
  # instance it was reported that on HP-UX the gcc test will end up
 
3499
  # making a dummy file named `D' -- because `-MD' means `put the output
 
3500
  # in D'.
 
3501
  mkdir conftest.dir
 
3502
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
3503
  # using a relative directory.
 
3504
  cp "$am_depcomp" conftest.dir
 
3505
  cd conftest.dir
 
3506
  # We will build objects and dependencies in a subdirectory because
 
3507
  # it helps to detect inapplicable dependency modes.  For instance
 
3508
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
3509
  # side effect of compilation, but ICC will put the dependencies in
 
3510
  # the current directory while Tru64 will put them in the object
 
3511
  # directory.
 
3512
  mkdir sub
 
3513
 
 
3514
  am_cv_CXX_dependencies_compiler_type=none
 
3515
  if test "$am_compiler_list" = ""; then
 
3516
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
3517
  fi
 
3518
  am__universal=false
 
3519
  case " $depcc " in #(
 
3520
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
 
3521
     esac
 
3522
 
 
3523
  for depmode in $am_compiler_list; do
 
3524
    # Setup a source with many dependencies, because some compilers
 
3525
    # like to wrap large dependency lists on column 80 (with \), and
 
3526
    # we should not choose a depcomp mode which is confused by this.
 
3527
    #
 
3528
    # We need to recreate these files for each test, as the compiler may
 
3529
    # overwrite some of them when testing with obscure command lines.
 
3530
    # This happens at least with the AIX C compiler.
 
3531
    : > sub/conftest.c
 
3532
    for i in 1 2 3 4 5 6; do
 
3533
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
3534
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
3535
      # Solaris 8's {/usr,}/bin/sh.
 
3536
      touch sub/conftst$i.h
 
3537
    done
 
3538
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
3539
 
 
3540
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
3541
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
3542
    # handle `-M -o', and we need to detect this.  Also, some Intel
 
3543
    # versions had trouble with output in subdirs
 
3544
    am__obj=sub/conftest.${OBJEXT-o}
 
3545
    am__minus_obj="-o $am__obj"
 
3546
    case $depmode in
 
3547
    gcc)
 
3548
      # This depmode causes a compiler race in universal mode.
 
3549
      test "$am__universal" = false || continue
 
3550
      ;;
 
3551
    nosideeffect)
 
3552
      # after this tag, mechanisms are not by side-effect, so they'll
 
3553
      # only be used when explicitly requested
 
3554
      if test "x$enable_dependency_tracking" = xyes; then
 
3555
        continue
 
3556
      else
 
3557
        break
 
3558
      fi
 
3559
      ;;
 
3560
    msvisualcpp | msvcmsys)
 
3561
      # This compiler won't grok `-c -o', but also, the minuso test has
 
3562
      # not run yet.  These depmodes are late enough in the game, and
 
3563
      # so weak that their functioning should not be impacted.
 
3564
      am__obj=conftest.${OBJEXT-o}
 
3565
      am__minus_obj=
 
3566
      ;;
 
3567
    none) break ;;
 
3568
    esac
 
3569
    if depmode=$depmode \
 
3570
       source=sub/conftest.c object=$am__obj \
 
3571
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
3572
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
 
3573
         >/dev/null 2>conftest.err &&
 
3574
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
 
3575
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
3576
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
 
3577
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
3578
      # icc doesn't choke on unknown options, it will just issue warnings
 
3579
      # or remarks (even with -Werror).  So we grep stderr for any message
 
3580
      # that says an option was ignored or not supported.
 
3581
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
3582
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
3583
      # The diagnosis changed in icc 8.0:
 
3584
      #   icc: Command line remark: option '-MP' not supported
 
3585
      if (grep 'ignoring option' conftest.err ||
 
3586
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
3587
        am_cv_CXX_dependencies_compiler_type=$depmode
 
3588
        break
 
3589
      fi
 
3590
    fi
 
3591
  done
 
3592
 
 
3593
  cd ..
 
3594
  rm -rf conftest.dir
 
3595
else
 
3596
  am_cv_CXX_dependencies_compiler_type=none
 
3597
fi
 
3598
 
 
3599
fi
 
3600
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
 
3601
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
 
3602
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
 
3603
 
 
3604
 if
 
3605
  test "x$enable_dependency_tracking" != xno \
 
3606
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
 
3607
  am__fastdepCXX_TRUE=
 
3608
  am__fastdepCXX_FALSE='#'
 
3609
else
 
3610
  am__fastdepCXX_TRUE='#'
 
3611
  am__fastdepCXX_FALSE=
 
3612
fi
 
3613
 
 
3614
 
 
3615
case `pwd` in
 
3616
  *\ * | *\     *)
 
3617
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
 
3618
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
 
3619
esac
 
3620
 
 
3621
 
 
3622
 
 
3623
macro_version='2.2.6'
 
3624
macro_revision='1.3012'
 
3625
 
 
3626
 
 
3627
 
 
3628
 
 
3629
 
 
3630
 
 
3631
 
 
3632
 
 
3633
 
 
3634
 
 
3635
 
 
3636
 
 
3637
 
 
3638
ltmain="$ac_aux_dir/ltmain.sh"
 
3639
 
 
3640
# Make sure we can run config.sub.
 
3641
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
 
3642
  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
 
3643
 
 
3644
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
 
3645
$as_echo_n "checking build system type... " >&6; }
 
3646
if test "${ac_cv_build+set}" = set; then :
 
3647
  $as_echo_n "(cached) " >&6
 
3648
else
 
3649
  ac_build_alias=$build_alias
 
3650
test "x$ac_build_alias" = x &&
 
3651
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
 
3652
test "x$ac_build_alias" = x &&
 
3653
  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
 
3654
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
 
3655
  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
 
3656
 
 
3657
fi
 
3658
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
 
3659
$as_echo "$ac_cv_build" >&6; }
 
3660
case $ac_cv_build in
 
3661
*-*-*) ;;
 
3662
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
 
3663
esac
 
3664
build=$ac_cv_build
 
3665
ac_save_IFS=$IFS; IFS='-'
 
3666
set x $ac_cv_build
 
3667
shift
 
3668
build_cpu=$1
 
3669
build_vendor=$2
 
3670
shift; shift
 
3671
# Remember, the first character of IFS is used to create $*,
 
3672
# except with old shells:
 
3673
build_os=$*
 
3674
IFS=$ac_save_IFS
 
3675
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
 
3676
 
 
3677
 
 
3678
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
 
3679
$as_echo_n "checking host system type... " >&6; }
 
3680
if test "${ac_cv_host+set}" = set; then :
 
3681
  $as_echo_n "(cached) " >&6
 
3682
else
 
3683
  if test "x$host_alias" = x; then
 
3684
  ac_cv_host=$ac_cv_build
 
3685
else
 
3686
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
 
3687
    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
 
3688
fi
 
3689
 
 
3690
fi
 
3691
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
 
3692
$as_echo "$ac_cv_host" >&6; }
 
3693
case $ac_cv_host in
 
3694
*-*-*) ;;
 
3695
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
 
3696
esac
 
3697
host=$ac_cv_host
 
3698
ac_save_IFS=$IFS; IFS='-'
 
3699
set x $ac_cv_host
 
3700
shift
 
3701
host_cpu=$1
 
3702
host_vendor=$2
 
3703
shift; shift
 
3704
# Remember, the first character of IFS is used to create $*,
 
3705
# except with old shells:
 
3706
host_os=$*
 
3707
IFS=$ac_save_IFS
 
3708
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
 
3709
 
 
3710
 
 
3711
ac_ext=c
 
3712
ac_cpp='$CPP $CPPFLAGS'
 
3713
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3714
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3715
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3716
if test -n "$ac_tool_prefix"; then
 
3717
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 
3718
set dummy ${ac_tool_prefix}gcc; ac_word=$2
 
3719
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3720
$as_echo_n "checking for $ac_word... " >&6; }
 
3721
if test "${ac_cv_prog_CC+set}" = set; then :
 
3722
  $as_echo_n "(cached) " >&6
 
3723
else
 
3724
  if test -n "$CC"; then
 
3725
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3726
else
 
3727
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3728
for as_dir in $PATH
 
3729
do
 
3730
  IFS=$as_save_IFS
 
3731
  test -z "$as_dir" && as_dir=.
 
3732
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3733
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3734
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
 
3735
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3736
    break 2
 
3737
  fi
 
3738
done
 
3739
  done
 
3740
IFS=$as_save_IFS
 
3741
 
 
3742
fi
 
3743
fi
 
3744
CC=$ac_cv_prog_CC
 
3745
if test -n "$CC"; then
 
3746
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
 
3747
$as_echo "$CC" >&6; }
 
3748
else
 
3749
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3750
$as_echo "no" >&6; }
 
3751
fi
 
3752
 
 
3753
 
 
3754
fi
 
3755
if test -z "$ac_cv_prog_CC"; then
 
3756
  ac_ct_CC=$CC
 
3757
  # Extract the first word of "gcc", so it can be a program name with args.
 
3758
set dummy gcc; ac_word=$2
 
3759
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3760
$as_echo_n "checking for $ac_word... " >&6; }
 
3761
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
 
3762
  $as_echo_n "(cached) " >&6
 
3763
else
 
3764
  if test -n "$ac_ct_CC"; then
 
3765
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3766
else
 
3767
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3768
for as_dir in $PATH
 
3769
do
 
3770
  IFS=$as_save_IFS
 
3771
  test -z "$as_dir" && as_dir=.
 
3772
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3773
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3774
    ac_cv_prog_ac_ct_CC="gcc"
 
3775
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3776
    break 2
 
3777
  fi
 
3778
done
 
3779
  done
 
3780
IFS=$as_save_IFS
 
3781
 
 
3782
fi
 
3783
fi
 
3784
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
3785
if test -n "$ac_ct_CC"; then
 
3786
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
 
3787
$as_echo "$ac_ct_CC" >&6; }
 
3788
else
 
3789
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3790
$as_echo "no" >&6; }
 
3791
fi
 
3792
 
 
3793
  if test "x$ac_ct_CC" = x; then
 
3794
    CC=""
 
3795
  else
 
3796
    case $cross_compiling:$ac_tool_warned in
 
3797
yes:)
 
3798
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
 
3799
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
3800
ac_tool_warned=yes ;;
 
3801
esac
 
3802
    CC=$ac_ct_CC
 
3803
  fi
 
3804
else
 
3805
  CC="$ac_cv_prog_CC"
 
3806
fi
 
3807
 
 
3808
if test -z "$CC"; then
 
3809
          if test -n "$ac_tool_prefix"; then
 
3810
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 
3811
set dummy ${ac_tool_prefix}cc; ac_word=$2
 
3812
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3813
$as_echo_n "checking for $ac_word... " >&6; }
 
3814
if test "${ac_cv_prog_CC+set}" = set; then :
 
3815
  $as_echo_n "(cached) " >&6
 
3816
else
 
3817
  if test -n "$CC"; then
 
3818
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3819
else
 
3820
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3821
for as_dir in $PATH
 
3822
do
 
3823
  IFS=$as_save_IFS
 
3824
  test -z "$as_dir" && as_dir=.
 
3825
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3826
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3827
    ac_cv_prog_CC="${ac_tool_prefix}cc"
 
3828
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3829
    break 2
 
3830
  fi
 
3831
done
 
3832
  done
 
3833
IFS=$as_save_IFS
 
3834
 
 
3835
fi
 
3836
fi
 
3837
CC=$ac_cv_prog_CC
 
3838
if test -n "$CC"; then
 
3839
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
 
3840
$as_echo "$CC" >&6; }
 
3841
else
 
3842
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3843
$as_echo "no" >&6; }
 
3844
fi
 
3845
 
 
3846
 
 
3847
  fi
 
3848
fi
 
3849
if test -z "$CC"; then
 
3850
  # Extract the first word of "cc", so it can be a program name with args.
 
3851
set dummy cc; ac_word=$2
 
3852
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3853
$as_echo_n "checking for $ac_word... " >&6; }
 
3854
if test "${ac_cv_prog_CC+set}" = set; then :
 
3855
  $as_echo_n "(cached) " >&6
 
3856
else
 
3857
  if test -n "$CC"; then
 
3858
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3859
else
 
3860
  ac_prog_rejected=no
 
3861
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3862
for as_dir in $PATH
 
3863
do
 
3864
  IFS=$as_save_IFS
 
3865
  test -z "$as_dir" && as_dir=.
 
3866
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3867
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3868
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
 
3869
       ac_prog_rejected=yes
 
3870
       continue
 
3871
     fi
 
3872
    ac_cv_prog_CC="cc"
 
3873
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3874
    break 2
 
3875
  fi
 
3876
done
 
3877
  done
 
3878
IFS=$as_save_IFS
 
3879
 
 
3880
if test $ac_prog_rejected = yes; then
 
3881
  # We found a bogon in the path, so make sure we never use it.
 
3882
  set dummy $ac_cv_prog_CC
 
3883
  shift
 
3884
  if test $# != 0; then
 
3885
    # We chose a different compiler from the bogus one.
 
3886
    # However, it has the same basename, so the bogon will be chosen
 
3887
    # first if we set CC to just the basename; use the full file name.
 
3888
    shift
 
3889
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
 
3890
  fi
 
3891
fi
 
3892
fi
 
3893
fi
 
3894
CC=$ac_cv_prog_CC
 
3895
if test -n "$CC"; then
 
3896
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
 
3897
$as_echo "$CC" >&6; }
 
3898
else
 
3899
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3900
$as_echo "no" >&6; }
 
3901
fi
 
3902
 
 
3903
 
 
3904
fi
 
3905
if test -z "$CC"; then
 
3906
  if test -n "$ac_tool_prefix"; then
 
3907
  for ac_prog in cl.exe
 
3908
  do
 
3909
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
3910
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
3911
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3912
$as_echo_n "checking for $ac_word... " >&6; }
 
3913
if test "${ac_cv_prog_CC+set}" = set; then :
 
3914
  $as_echo_n "(cached) " >&6
 
3915
else
 
3916
  if test -n "$CC"; then
 
3917
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3918
else
 
3919
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3920
for as_dir in $PATH
 
3921
do
 
3922
  IFS=$as_save_IFS
 
3923
  test -z "$as_dir" && as_dir=.
 
3924
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3925
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3926
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
3927
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3928
    break 2
 
3929
  fi
 
3930
done
 
3931
  done
 
3932
IFS=$as_save_IFS
 
3933
 
 
3934
fi
 
3935
fi
 
3936
CC=$ac_cv_prog_CC
 
3937
if test -n "$CC"; then
 
3938
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
 
3939
$as_echo "$CC" >&6; }
 
3940
else
 
3941
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3942
$as_echo "no" >&6; }
 
3943
fi
 
3944
 
 
3945
 
 
3946
    test -n "$CC" && break
 
3947
  done
 
3948
fi
 
3949
if test -z "$CC"; then
 
3950
  ac_ct_CC=$CC
 
3951
  for ac_prog in cl.exe
 
3952
do
 
3953
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
3954
set dummy $ac_prog; ac_word=$2
 
3955
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
3956
$as_echo_n "checking for $ac_word... " >&6; }
 
3957
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
 
3958
  $as_echo_n "(cached) " >&6
 
3959
else
 
3960
  if test -n "$ac_ct_CC"; then
 
3961
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3962
else
 
3963
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3964
for as_dir in $PATH
 
3965
do
 
3966
  IFS=$as_save_IFS
 
3967
  test -z "$as_dir" && as_dir=.
 
3968
    for ac_exec_ext in '' $ac_executable_extensions; do
 
3969
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
3970
    ac_cv_prog_ac_ct_CC="$ac_prog"
 
3971
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3972
    break 2
 
3973
  fi
 
3974
done
 
3975
  done
 
3976
IFS=$as_save_IFS
 
3977
 
 
3978
fi
 
3979
fi
 
3980
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
3981
if test -n "$ac_ct_CC"; then
 
3982
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
 
3983
$as_echo "$ac_ct_CC" >&6; }
 
3984
else
 
3985
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3986
$as_echo "no" >&6; }
 
3987
fi
 
3988
 
 
3989
 
 
3990
  test -n "$ac_ct_CC" && break
 
3991
done
 
3992
 
 
3993
  if test "x$ac_ct_CC" = x; then
 
3994
    CC=""
 
3995
  else
 
3996
    case $cross_compiling:$ac_tool_warned in
 
3997
yes:)
 
3998
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
 
3999
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
4000
ac_tool_warned=yes ;;
 
4001
esac
 
4002
    CC=$ac_ct_CC
 
4003
  fi
 
4004
fi
 
4005
 
 
4006
fi
 
4007
 
 
4008
 
 
4009
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
4010
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
4011
as_fn_error "no acceptable C compiler found in \$PATH
 
4012
See \`config.log' for more details." "$LINENO" 5; }
 
4013
 
 
4014
# Provide some information about the compiler.
 
4015
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
 
4016
set X $ac_compile
 
4017
ac_compiler=$2
 
4018
for ac_option in --version -v -V -qversion; do
 
4019
  { { ac_try="$ac_compiler $ac_option >&5"
 
4020
case "(($ac_try" in
 
4021
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
4022
  *) ac_try_echo=$ac_try;;
 
4023
esac
 
4024
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
4025
$as_echo "$ac_try_echo"; } >&5
 
4026
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
 
4027
  ac_status=$?
 
4028
  if test -s conftest.err; then
 
4029
    sed '10a\
 
4030
... rest of stderr output deleted ...
 
4031
         10q' conftest.err >conftest.er1
 
4032
    cat conftest.er1 >&5
 
4033
    rm -f conftest.er1 conftest.err
 
4034
  fi
 
4035
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
4036
  test $ac_status = 0; }
 
4037
done
 
4038
 
3657
4039
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3658
4040
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3659
4041
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4577
4959
else
4578
4960
  lt_cv_nm_interface="BSD nm"
4579
4961
  echo "int some_variable = 0;" > conftest.$ac_ext
4580
 
  (eval echo "\"\$as_me:4580: $ac_compile\"" >&5)
 
4962
  (eval echo "\"\$as_me:4962: $ac_compile\"" >&5)
4581
4963
  (eval "$ac_compile" 2>conftest.err)
4582
4964
  cat conftest.err >&5
4583
 
  (eval echo "\"\$as_me:4583: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
 
4965
  (eval echo "\"\$as_me:4965: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
4584
4966
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
4585
4967
  cat conftest.err >&5
4586
 
  (eval echo "\"\$as_me:4586: output\"" >&5)
 
4968
  (eval echo "\"\$as_me:4968: output\"" >&5)
4587
4969
  cat conftest.out >&5
4588
4970
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
4589
4971
    lt_cv_nm_interface="MS dumpbin"
5789
6171
  ;;
5790
6172
*-*-irix6*)
5791
6173
  # Find out which ABI we are using.
5792
 
  echo '#line 5792 "configure"' > conftest.$ac_ext
 
6174
  echo '#line 6174 "configure"' > conftest.$ac_ext
5793
6175
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
5794
6176
  (eval $ac_compile) 2>&5
5795
6177
  ac_status=$?
6819
7201
 
6820
7202
 
6821
7203
 
 
7204
ac_ext=cpp
 
7205
ac_cpp='$CXXCPP $CPPFLAGS'
 
7206
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
7207
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
7208
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
7209
if test -z "$CXX"; then
 
7210
  if test -n "$CCC"; then
 
7211
    CXX=$CCC
 
7212
  else
 
7213
    if test -n "$ac_tool_prefix"; then
 
7214
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
7215
  do
 
7216
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
7217
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
7218
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
7219
$as_echo_n "checking for $ac_word... " >&6; }
 
7220
if test "${ac_cv_prog_CXX+set}" = set; then :
 
7221
  $as_echo_n "(cached) " >&6
 
7222
else
 
7223
  if test -n "$CXX"; then
 
7224
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
7225
else
 
7226
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
7227
for as_dir in $PATH
 
7228
do
 
7229
  IFS=$as_save_IFS
 
7230
  test -z "$as_dir" && as_dir=.
 
7231
    for ac_exec_ext in '' $ac_executable_extensions; do
 
7232
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7233
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
7234
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
7235
    break 2
 
7236
  fi
 
7237
done
 
7238
  done
 
7239
IFS=$as_save_IFS
 
7240
 
 
7241
fi
 
7242
fi
 
7243
CXX=$ac_cv_prog_CXX
 
7244
if test -n "$CXX"; then
 
7245
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
 
7246
$as_echo "$CXX" >&6; }
 
7247
else
 
7248
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
7249
$as_echo "no" >&6; }
 
7250
fi
 
7251
 
 
7252
 
 
7253
    test -n "$CXX" && break
 
7254
  done
 
7255
fi
 
7256
if test -z "$CXX"; then
 
7257
  ac_ct_CXX=$CXX
 
7258
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
7259
do
 
7260
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
7261
set dummy $ac_prog; ac_word=$2
 
7262
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
7263
$as_echo_n "checking for $ac_word... " >&6; }
 
7264
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
 
7265
  $as_echo_n "(cached) " >&6
 
7266
else
 
7267
  if test -n "$ac_ct_CXX"; then
 
7268
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
7269
else
 
7270
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
7271
for as_dir in $PATH
 
7272
do
 
7273
  IFS=$as_save_IFS
 
7274
  test -z "$as_dir" && as_dir=.
 
7275
    for ac_exec_ext in '' $ac_executable_extensions; do
 
7276
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
7277
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
7278
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
7279
    break 2
 
7280
  fi
 
7281
done
 
7282
  done
 
7283
IFS=$as_save_IFS
 
7284
 
 
7285
fi
 
7286
fi
 
7287
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 
7288
if test -n "$ac_ct_CXX"; then
 
7289
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
 
7290
$as_echo "$ac_ct_CXX" >&6; }
 
7291
else
 
7292
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
7293
$as_echo "no" >&6; }
 
7294
fi
 
7295
 
 
7296
 
 
7297
  test -n "$ac_ct_CXX" && break
 
7298
done
 
7299
 
 
7300
  if test "x$ac_ct_CXX" = x; then
 
7301
    CXX="g++"
 
7302
  else
 
7303
    case $cross_compiling:$ac_tool_warned in
 
7304
yes:)
 
7305
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
 
7306
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
7307
ac_tool_warned=yes ;;
 
7308
esac
 
7309
    CXX=$ac_ct_CXX
 
7310
  fi
 
7311
fi
 
7312
 
 
7313
  fi
 
7314
fi
 
7315
# Provide some information about the compiler.
 
7316
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
 
7317
set X $ac_compile
 
7318
ac_compiler=$2
 
7319
for ac_option in --version -v -V -qversion; do
 
7320
  { { ac_try="$ac_compiler $ac_option >&5"
 
7321
case "(($ac_try" in
 
7322
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
7323
  *) ac_try_echo=$ac_try;;
 
7324
esac
 
7325
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
7326
$as_echo "$ac_try_echo"; } >&5
 
7327
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
 
7328
  ac_status=$?
 
7329
  if test -s conftest.err; then
 
7330
    sed '10a\
 
7331
... rest of stderr output deleted ...
 
7332
         10q' conftest.err >conftest.er1
 
7333
    cat conftest.er1 >&5
 
7334
    rm -f conftest.er1 conftest.err
 
7335
  fi
 
7336
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
7337
  test $ac_status = 0; }
 
7338
done
 
7339
 
 
7340
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
 
7341
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
 
7342
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
 
7343
  $as_echo_n "(cached) " >&6
 
7344
else
 
7345
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7346
/* end confdefs.h.  */
 
7347
 
 
7348
int
 
7349
main ()
 
7350
{
 
7351
#ifndef __GNUC__
 
7352
       choke me
 
7353
#endif
 
7354
 
 
7355
  ;
 
7356
  return 0;
 
7357
}
 
7358
_ACEOF
 
7359
if ac_fn_cxx_try_compile "$LINENO"; then :
 
7360
  ac_compiler_gnu=yes
 
7361
else
 
7362
  ac_compiler_gnu=no
 
7363
fi
 
7364
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7365
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
 
7366
 
 
7367
fi
 
7368
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
 
7369
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
 
7370
if test $ac_compiler_gnu = yes; then
 
7371
  GXX=yes
 
7372
else
 
7373
  GXX=
 
7374
fi
 
7375
ac_test_CXXFLAGS=${CXXFLAGS+set}
 
7376
ac_save_CXXFLAGS=$CXXFLAGS
 
7377
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
 
7378
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
 
7379
if test "${ac_cv_prog_cxx_g+set}" = set; then :
 
7380
  $as_echo_n "(cached) " >&6
 
7381
else
 
7382
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
 
7383
   ac_cxx_werror_flag=yes
 
7384
   ac_cv_prog_cxx_g=no
 
7385
   CXXFLAGS="-g"
 
7386
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7387
/* end confdefs.h.  */
 
7388
 
 
7389
int
 
7390
main ()
 
7391
{
 
7392
 
 
7393
  ;
 
7394
  return 0;
 
7395
}
 
7396
_ACEOF
 
7397
if ac_fn_cxx_try_compile "$LINENO"; then :
 
7398
  ac_cv_prog_cxx_g=yes
 
7399
else
 
7400
  CXXFLAGS=""
 
7401
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7402
/* end confdefs.h.  */
 
7403
 
 
7404
int
 
7405
main ()
 
7406
{
 
7407
 
 
7408
  ;
 
7409
  return 0;
 
7410
}
 
7411
_ACEOF
 
7412
if ac_fn_cxx_try_compile "$LINENO"; then :
 
7413
 
 
7414
else
 
7415
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
7416
         CXXFLAGS="-g"
 
7417
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7418
/* end confdefs.h.  */
 
7419
 
 
7420
int
 
7421
main ()
 
7422
{
 
7423
 
 
7424
  ;
 
7425
  return 0;
 
7426
}
 
7427
_ACEOF
 
7428
if ac_fn_cxx_try_compile "$LINENO"; then :
 
7429
  ac_cv_prog_cxx_g=yes
 
7430
fi
 
7431
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7432
fi
 
7433
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7434
fi
 
7435
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
7436
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
7437
fi
 
7438
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
 
7439
$as_echo "$ac_cv_prog_cxx_g" >&6; }
 
7440
if test "$ac_test_CXXFLAGS" = set; then
 
7441
  CXXFLAGS=$ac_save_CXXFLAGS
 
7442
elif test $ac_cv_prog_cxx_g = yes; then
 
7443
  if test "$GXX" = yes; then
 
7444
    CXXFLAGS="-g -O2"
 
7445
  else
 
7446
    CXXFLAGS="-g"
 
7447
  fi
 
7448
else
 
7449
  if test "$GXX" = yes; then
 
7450
    CXXFLAGS="-O2"
 
7451
  else
 
7452
    CXXFLAGS=
 
7453
  fi
 
7454
fi
 
7455
ac_ext=c
 
7456
ac_cpp='$CPP $CPPFLAGS'
 
7457
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
7458
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
7459
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
7460
 
 
7461
depcc="$CXX"  am_compiler_list=
 
7462
 
 
7463
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
 
7464
$as_echo_n "checking dependency style of $depcc... " >&6; }
 
7465
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
 
7466
  $as_echo_n "(cached) " >&6
 
7467
else
 
7468
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
7469
  # We make a subdir and do the tests there.  Otherwise we can end up
 
7470
  # making bogus files that we don't know about and never remove.  For
 
7471
  # instance it was reported that on HP-UX the gcc test will end up
 
7472
  # making a dummy file named `D' -- because `-MD' means `put the output
 
7473
  # in D'.
 
7474
  mkdir conftest.dir
 
7475
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
7476
  # using a relative directory.
 
7477
  cp "$am_depcomp" conftest.dir
 
7478
  cd conftest.dir
 
7479
  # We will build objects and dependencies in a subdirectory because
 
7480
  # it helps to detect inapplicable dependency modes.  For instance
 
7481
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
7482
  # side effect of compilation, but ICC will put the dependencies in
 
7483
  # the current directory while Tru64 will put them in the object
 
7484
  # directory.
 
7485
  mkdir sub
 
7486
 
 
7487
  am_cv_CXX_dependencies_compiler_type=none
 
7488
  if test "$am_compiler_list" = ""; then
 
7489
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
7490
  fi
 
7491
  am__universal=false
 
7492
  case " $depcc " in #(
 
7493
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
 
7494
     esac
 
7495
 
 
7496
  for depmode in $am_compiler_list; do
 
7497
    # Setup a source with many dependencies, because some compilers
 
7498
    # like to wrap large dependency lists on column 80 (with \), and
 
7499
    # we should not choose a depcomp mode which is confused by this.
 
7500
    #
 
7501
    # We need to recreate these files for each test, as the compiler may
 
7502
    # overwrite some of them when testing with obscure command lines.
 
7503
    # This happens at least with the AIX C compiler.
 
7504
    : > sub/conftest.c
 
7505
    for i in 1 2 3 4 5 6; do
 
7506
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
7507
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
7508
      # Solaris 8's {/usr,}/bin/sh.
 
7509
      touch sub/conftst$i.h
 
7510
    done
 
7511
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
7512
 
 
7513
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
7514
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
7515
    # handle `-M -o', and we need to detect this.  Also, some Intel
 
7516
    # versions had trouble with output in subdirs
 
7517
    am__obj=sub/conftest.${OBJEXT-o}
 
7518
    am__minus_obj="-o $am__obj"
 
7519
    case $depmode in
 
7520
    gcc)
 
7521
      # This depmode causes a compiler race in universal mode.
 
7522
      test "$am__universal" = false || continue
 
7523
      ;;
 
7524
    nosideeffect)
 
7525
      # after this tag, mechanisms are not by side-effect, so they'll
 
7526
      # only be used when explicitly requested
 
7527
      if test "x$enable_dependency_tracking" = xyes; then
 
7528
        continue
 
7529
      else
 
7530
        break
 
7531
      fi
 
7532
      ;;
 
7533
    msvisualcpp | msvcmsys)
 
7534
      # This compiler won't grok `-c -o', but also, the minuso test has
 
7535
      # not run yet.  These depmodes are late enough in the game, and
 
7536
      # so weak that their functioning should not be impacted.
 
7537
      am__obj=conftest.${OBJEXT-o}
 
7538
      am__minus_obj=
 
7539
      ;;
 
7540
    none) break ;;
 
7541
    esac
 
7542
    if depmode=$depmode \
 
7543
       source=sub/conftest.c object=$am__obj \
 
7544
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
7545
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
 
7546
         >/dev/null 2>conftest.err &&
 
7547
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
 
7548
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
7549
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
 
7550
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
7551
      # icc doesn't choke on unknown options, it will just issue warnings
 
7552
      # or remarks (even with -Werror).  So we grep stderr for any message
 
7553
      # that says an option was ignored or not supported.
 
7554
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
7555
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
7556
      # The diagnosis changed in icc 8.0:
 
7557
      #   icc: Command line remark: option '-MP' not supported
 
7558
      if (grep 'ignoring option' conftest.err ||
 
7559
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
7560
        am_cv_CXX_dependencies_compiler_type=$depmode
 
7561
        break
 
7562
      fi
 
7563
    fi
 
7564
  done
 
7565
 
 
7566
  cd ..
 
7567
  rm -rf conftest.dir
 
7568
else
 
7569
  am_cv_CXX_dependencies_compiler_type=none
 
7570
fi
 
7571
 
 
7572
fi
 
7573
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
 
7574
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
 
7575
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
 
7576
 
 
7577
 if
 
7578
  test "x$enable_dependency_tracking" != xno \
 
7579
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
 
7580
  am__fastdepCXX_TRUE=
 
7581
  am__fastdepCXX_FALSE='#'
 
7582
else
 
7583
  am__fastdepCXX_TRUE='#'
 
7584
  am__fastdepCXX_FALSE=
 
7585
fi
 
7586
 
 
7587
 
 
7588
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
 
7589
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
 
7590
    (test "X$CXX" != "Xg++"))) ; then
 
7591
  ac_ext=cpp
 
7592
ac_cpp='$CXXCPP $CPPFLAGS'
 
7593
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
7594
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
7595
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
7596
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
 
7597
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
 
7598
if test -z "$CXXCPP"; then
 
7599
  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
 
7600
  $as_echo_n "(cached) " >&6
 
7601
else
 
7602
      # Double quotes because CXXCPP needs to be expanded
 
7603
    for CXXCPP in "$CXX -E" "/lib/cpp"
 
7604
    do
 
7605
      ac_preproc_ok=false
 
7606
for ac_cxx_preproc_warn_flag in '' yes
 
7607
do
 
7608
  # Use a header file that comes with gcc, so configuring glibc
 
7609
  # with a fresh cross-compiler works.
 
7610
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
7611
  # <limits.h> exists even on freestanding compilers.
 
7612
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
7613
  # not just through cpp. "Syntax error" is here to catch this case.
 
7614
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7615
/* end confdefs.h.  */
 
7616
#ifdef __STDC__
 
7617
# include <limits.h>
 
7618
#else
 
7619
# include <assert.h>
 
7620
#endif
 
7621
                     Syntax error
 
7622
_ACEOF
 
7623
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
7624
 
 
7625
else
 
7626
  # Broken: fails on valid input.
 
7627
continue
 
7628
fi
 
7629
rm -f conftest.err conftest.$ac_ext
 
7630
 
 
7631
  # OK, works on sane cases.  Now check whether nonexistent headers
 
7632
  # can be detected and how.
 
7633
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7634
/* end confdefs.h.  */
 
7635
#include <ac_nonexistent.h>
 
7636
_ACEOF
 
7637
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
7638
  # Broken: success on invalid input.
 
7639
continue
 
7640
else
 
7641
  # Passes both tests.
 
7642
ac_preproc_ok=:
 
7643
break
 
7644
fi
 
7645
rm -f conftest.err conftest.$ac_ext
 
7646
 
 
7647
done
 
7648
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
7649
rm -f conftest.err conftest.$ac_ext
 
7650
if $ac_preproc_ok; then :
 
7651
  break
 
7652
fi
 
7653
 
 
7654
    done
 
7655
    ac_cv_prog_CXXCPP=$CXXCPP
 
7656
 
 
7657
fi
 
7658
  CXXCPP=$ac_cv_prog_CXXCPP
 
7659
else
 
7660
  ac_cv_prog_CXXCPP=$CXXCPP
 
7661
fi
 
7662
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
 
7663
$as_echo "$CXXCPP" >&6; }
 
7664
ac_preproc_ok=false
 
7665
for ac_cxx_preproc_warn_flag in '' yes
 
7666
do
 
7667
  # Use a header file that comes with gcc, so configuring glibc
 
7668
  # with a fresh cross-compiler works.
 
7669
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
7670
  # <limits.h> exists even on freestanding compilers.
 
7671
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
7672
  # not just through cpp. "Syntax error" is here to catch this case.
 
7673
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7674
/* end confdefs.h.  */
 
7675
#ifdef __STDC__
 
7676
# include <limits.h>
 
7677
#else
 
7678
# include <assert.h>
 
7679
#endif
 
7680
                     Syntax error
 
7681
_ACEOF
 
7682
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
7683
 
 
7684
else
 
7685
  # Broken: fails on valid input.
 
7686
continue
 
7687
fi
 
7688
rm -f conftest.err conftest.$ac_ext
 
7689
 
 
7690
  # OK, works on sane cases.  Now check whether nonexistent headers
 
7691
  # can be detected and how.
 
7692
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
7693
/* end confdefs.h.  */
 
7694
#include <ac_nonexistent.h>
 
7695
_ACEOF
 
7696
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
7697
  # Broken: success on invalid input.
 
7698
continue
 
7699
else
 
7700
  # Passes both tests.
 
7701
ac_preproc_ok=:
 
7702
break
 
7703
fi
 
7704
rm -f conftest.err conftest.$ac_ext
 
7705
 
 
7706
done
 
7707
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
7708
rm -f conftest.err conftest.$ac_ext
 
7709
if $ac_preproc_ok; then :
 
7710
 
 
7711
else
 
7712
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
7713
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
7714
_lt_caught_CXX_error=yes; }
 
7715
fi
 
7716
 
 
7717
ac_ext=c
 
7718
ac_cpp='$CPP $CPPFLAGS'
 
7719
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
7720
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
7721
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
7722
 
 
7723
else
 
7724
  _lt_caught_CXX_error=yes
 
7725
fi
 
7726
 
 
7727
 
 
7728
 
 
7729
 
 
7730
 
6822
7731
# Set options
6823
7732
 
6824
7733
 
7319
8228
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
7320
8229
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
7321
8230
   -e 's:$: $lt_compiler_flag:'`
7322
 
   (eval echo "\"\$as_me:7322: $lt_compile\"" >&5)
 
8231
   (eval echo "\"\$as_me:8231: $lt_compile\"" >&5)
7323
8232
   (eval "$lt_compile" 2>conftest.err)
7324
8233
   ac_status=$?
7325
8234
   cat conftest.err >&5
7326
 
   echo "$as_me:7326: \$? = $ac_status" >&5
 
8235
   echo "$as_me:8235: \$? = $ac_status" >&5
7327
8236
   if (exit $ac_status) && test -s "$ac_outfile"; then
7328
8237
     # The compiler can only warn and ignore the option if not recognized
7329
8238
     # So say no if there are warnings other than the usual output.
7658
8567
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
7659
8568
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
7660
8569
   -e 's:$: $lt_compiler_flag:'`
7661
 
   (eval echo "\"\$as_me:7661: $lt_compile\"" >&5)
 
8570
   (eval echo "\"\$as_me:8570: $lt_compile\"" >&5)
7662
8571
   (eval "$lt_compile" 2>conftest.err)
7663
8572
   ac_status=$?
7664
8573
   cat conftest.err >&5
7665
 
   echo "$as_me:7665: \$? = $ac_status" >&5
 
8574
   echo "$as_me:8574: \$? = $ac_status" >&5
7666
8575
   if (exit $ac_status) && test -s "$ac_outfile"; then
7667
8576
     # The compiler can only warn and ignore the option if not recognized
7668
8577
     # So say no if there are warnings other than the usual output.
7763
8672
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
7764
8673
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
7765
8674
   -e 's:$: $lt_compiler_flag:'`
7766
 
   (eval echo "\"\$as_me:7766: $lt_compile\"" >&5)
 
8675
   (eval echo "\"\$as_me:8675: $lt_compile\"" >&5)
7767
8676
   (eval "$lt_compile" 2>out/conftest.err)
7768
8677
   ac_status=$?
7769
8678
   cat out/conftest.err >&5
7770
 
   echo "$as_me:7770: \$? = $ac_status" >&5
 
8679
   echo "$as_me:8679: \$? = $ac_status" >&5
7771
8680
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
7772
8681
   then
7773
8682
     # The compiler can only warn and ignore the option if not recognized
7818
8727
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
7819
8728
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
7820
8729
   -e 's:$: $lt_compiler_flag:'`
7821
 
   (eval echo "\"\$as_me:7821: $lt_compile\"" >&5)
 
8730
   (eval echo "\"\$as_me:8730: $lt_compile\"" >&5)
7822
8731
   (eval "$lt_compile" 2>out/conftest.err)
7823
8732
   ac_status=$?
7824
8733
   cat out/conftest.err >&5
7825
 
   echo "$as_me:7825: \$? = $ac_status" >&5
 
8734
   echo "$as_me:8734: \$? = $ac_status" >&5
7826
8735
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
7827
8736
   then
7828
8737
     # The compiler can only warn and ignore the option if not recognized
10201
11110
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
10202
11111
  lt_status=$lt_dlunknown
10203
11112
  cat > conftest.$ac_ext <<_LT_EOF
10204
 
#line 10204 "configure"
 
11113
#line 11113 "configure"
10205
11114
#include "confdefs.h"
10206
11115
 
10207
11116
#if HAVE_DLFCN_H
10297
11206
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
10298
11207
  lt_status=$lt_dlunknown
10299
11208
  cat > conftest.$ac_ext <<_LT_EOF
10300
 
#line 10300 "configure"
 
11209
#line 11209 "configure"
10301
11210
#include "confdefs.h"
10302
11211
 
10303
11212
#if HAVE_DLFCN_H
10505
11414
CC="$lt_save_CC"
10506
11415
 
10507
11416
 
10508
 
 
10509
 
 
10510
 
 
10511
 
 
10512
 
 
10513
 
 
10514
 
 
10515
 
 
10516
 
 
10517
 
 
10518
 
 
10519
 
        ac_config_commands="$ac_config_commands libtool"
10520
 
 
10521
 
 
10522
 
 
10523
 
 
10524
 
# Only expand once:
10525
 
 
10526
 
 
10527
 
 
10528
 
# checks for programs.
10529
 
ac_ext=cpp
10530
 
ac_cpp='$CXXCPP $CPPFLAGS'
10531
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10532
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10533
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10534
 
if test -z "$CXX"; then
10535
 
  if test -n "$CCC"; then
10536
 
    CXX=$CCC
10537
 
  else
10538
 
    if test -n "$ac_tool_prefix"; then
10539
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
10540
 
  do
10541
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
10542
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
10543
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10544
 
$as_echo_n "checking for $ac_word... " >&6; }
10545
 
if test "${ac_cv_prog_CXX+set}" = set; then :
10546
 
  $as_echo_n "(cached) " >&6
10547
 
else
10548
 
  if test -n "$CXX"; then
10549
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
10550
 
else
10551
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10552
 
for as_dir in $PATH
10553
 
do
10554
 
  IFS=$as_save_IFS
10555
 
  test -z "$as_dir" && as_dir=.
10556
 
    for ac_exec_ext in '' $ac_executable_extensions; do
10557
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
10558
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
10559
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10560
 
    break 2
10561
 
  fi
10562
 
done
10563
 
  done
10564
 
IFS=$as_save_IFS
10565
 
 
10566
 
fi
10567
 
fi
10568
 
CXX=$ac_cv_prog_CXX
10569
 
if test -n "$CXX"; then
10570
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
10571
 
$as_echo "$CXX" >&6; }
10572
 
else
10573
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10574
 
$as_echo "no" >&6; }
10575
 
fi
10576
 
 
10577
 
 
10578
 
    test -n "$CXX" && break
10579
 
  done
10580
 
fi
10581
 
if test -z "$CXX"; then
10582
 
  ac_ct_CXX=$CXX
10583
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
10584
 
do
10585
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
10586
 
set dummy $ac_prog; ac_word=$2
10587
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10588
 
$as_echo_n "checking for $ac_word... " >&6; }
10589
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
10590
 
  $as_echo_n "(cached) " >&6
10591
 
else
10592
 
  if test -n "$ac_ct_CXX"; then
10593
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
10594
 
else
10595
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10596
 
for as_dir in $PATH
10597
 
do
10598
 
  IFS=$as_save_IFS
10599
 
  test -z "$as_dir" && as_dir=.
10600
 
    for ac_exec_ext in '' $ac_executable_extensions; do
10601
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
10602
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
10603
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10604
 
    break 2
10605
 
  fi
10606
 
done
10607
 
  done
10608
 
IFS=$as_save_IFS
10609
 
 
10610
 
fi
10611
 
fi
10612
 
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
10613
 
if test -n "$ac_ct_CXX"; then
10614
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
10615
 
$as_echo "$ac_ct_CXX" >&6; }
10616
 
else
10617
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10618
 
$as_echo "no" >&6; }
10619
 
fi
10620
 
 
10621
 
 
10622
 
  test -n "$ac_ct_CXX" && break
10623
 
done
10624
 
 
10625
 
  if test "x$ac_ct_CXX" = x; then
10626
 
    CXX="g++"
10627
 
  else
10628
 
    case $cross_compiling:$ac_tool_warned in
10629
 
yes:)
10630
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
10631
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
10632
 
ac_tool_warned=yes ;;
10633
 
esac
10634
 
    CXX=$ac_ct_CXX
10635
 
  fi
10636
 
fi
10637
 
 
10638
 
  fi
10639
 
fi
10640
 
# Provide some information about the compiler.
10641
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
10642
 
set X $ac_compile
10643
 
ac_compiler=$2
10644
 
for ac_option in --version -v -V -qversion; do
10645
 
  { { ac_try="$ac_compiler $ac_option >&5"
10646
 
case "(($ac_try" in
10647
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10648
 
  *) ac_try_echo=$ac_try;;
10649
 
esac
10650
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
10651
 
$as_echo "$ac_try_echo"; } >&5
10652
 
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
10653
 
  ac_status=$?
10654
 
  if test -s conftest.err; then
10655
 
    sed '10a\
10656
 
... rest of stderr output deleted ...
10657
 
         10q' conftest.err >conftest.er1
10658
 
    cat conftest.er1 >&5
10659
 
    rm -f conftest.er1 conftest.err
10660
 
  fi
10661
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10662
 
  test $ac_status = 0; }
10663
 
done
10664
 
 
10665
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
10666
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
10667
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
10668
 
  $as_echo_n "(cached) " >&6
10669
 
else
10670
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10671
 
/* end confdefs.h.  */
10672
 
 
10673
 
int
10674
 
main ()
10675
 
{
10676
 
#ifndef __GNUC__
10677
 
       choke me
10678
 
#endif
10679
 
 
10680
 
  ;
10681
 
  return 0;
10682
 
}
10683
 
_ACEOF
10684
 
if ac_fn_cxx_try_compile "$LINENO"; then :
10685
 
  ac_compiler_gnu=yes
10686
 
else
10687
 
  ac_compiler_gnu=no
10688
 
fi
10689
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10690
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
10691
 
 
10692
 
fi
10693
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
10694
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
10695
 
if test $ac_compiler_gnu = yes; then
10696
 
  GXX=yes
10697
 
else
10698
 
  GXX=
10699
 
fi
10700
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
10701
 
ac_save_CXXFLAGS=$CXXFLAGS
10702
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
10703
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
10704
 
if test "${ac_cv_prog_cxx_g+set}" = set; then :
10705
 
  $as_echo_n "(cached) " >&6
10706
 
else
10707
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
10708
 
   ac_cxx_werror_flag=yes
10709
 
   ac_cv_prog_cxx_g=no
10710
 
   CXXFLAGS="-g"
10711
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10712
 
/* end confdefs.h.  */
10713
 
 
10714
 
int
10715
 
main ()
10716
 
{
10717
 
 
10718
 
  ;
10719
 
  return 0;
10720
 
}
10721
 
_ACEOF
10722
 
if ac_fn_cxx_try_compile "$LINENO"; then :
10723
 
  ac_cv_prog_cxx_g=yes
10724
 
else
10725
 
  CXXFLAGS=""
10726
 
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10727
 
/* end confdefs.h.  */
10728
 
 
10729
 
int
10730
 
main ()
10731
 
{
10732
 
 
10733
 
  ;
10734
 
  return 0;
10735
 
}
10736
 
_ACEOF
10737
 
if ac_fn_cxx_try_compile "$LINENO"; then :
10738
 
 
10739
 
else
10740
 
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
10741
 
         CXXFLAGS="-g"
10742
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10743
 
/* end confdefs.h.  */
10744
 
 
10745
 
int
10746
 
main ()
10747
 
{
10748
 
 
10749
 
  ;
10750
 
  return 0;
10751
 
}
10752
 
_ACEOF
10753
 
if ac_fn_cxx_try_compile "$LINENO"; then :
10754
 
  ac_cv_prog_cxx_g=yes
10755
 
fi
10756
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10757
 
fi
10758
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10759
 
fi
10760
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10761
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
10762
 
fi
10763
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
10764
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
10765
 
if test "$ac_test_CXXFLAGS" = set; then
10766
 
  CXXFLAGS=$ac_save_CXXFLAGS
10767
 
elif test $ac_cv_prog_cxx_g = yes; then
10768
 
  if test "$GXX" = yes; then
10769
 
    CXXFLAGS="-g -O2"
10770
 
  else
10771
 
    CXXFLAGS="-g"
10772
 
  fi
10773
 
else
10774
 
  if test "$GXX" = yes; then
10775
 
    CXXFLAGS="-O2"
10776
 
  else
10777
 
    CXXFLAGS=
10778
 
  fi
10779
 
fi
10780
 
ac_ext=c
10781
 
ac_cpp='$CPP $CPPFLAGS'
10782
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10783
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10784
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
10785
 
 
10786
 
depcc="$CXX"  am_compiler_list=
10787
 
 
10788
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
10789
 
$as_echo_n "checking dependency style of $depcc... " >&6; }
10790
 
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
10791
 
  $as_echo_n "(cached) " >&6
10792
 
else
10793
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
10794
 
  # We make a subdir and do the tests there.  Otherwise we can end up
10795
 
  # making bogus files that we don't know about and never remove.  For
10796
 
  # instance it was reported that on HP-UX the gcc test will end up
10797
 
  # making a dummy file named `D' -- because `-MD' means `put the output
10798
 
  # in D'.
10799
 
  mkdir conftest.dir
10800
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
10801
 
  # using a relative directory.
10802
 
  cp "$am_depcomp" conftest.dir
10803
 
  cd conftest.dir
10804
 
  # We will build objects and dependencies in a subdirectory because
10805
 
  # it helps to detect inapplicable dependency modes.  For instance
10806
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
10807
 
  # side effect of compilation, but ICC will put the dependencies in
10808
 
  # the current directory while Tru64 will put them in the object
10809
 
  # directory.
10810
 
  mkdir sub
10811
 
 
10812
 
  am_cv_CXX_dependencies_compiler_type=none
10813
 
  if test "$am_compiler_list" = ""; then
10814
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
10815
 
  fi
10816
 
  am__universal=false
10817
 
  case " $depcc " in #(
10818
 
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
10819
 
     esac
10820
 
 
10821
 
  for depmode in $am_compiler_list; do
10822
 
    # Setup a source with many dependencies, because some compilers
10823
 
    # like to wrap large dependency lists on column 80 (with \), and
10824
 
    # we should not choose a depcomp mode which is confused by this.
10825
 
    #
10826
 
    # We need to recreate these files for each test, as the compiler may
10827
 
    # overwrite some of them when testing with obscure command lines.
10828
 
    # This happens at least with the AIX C compiler.
10829
 
    : > sub/conftest.c
10830
 
    for i in 1 2 3 4 5 6; do
10831
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
10832
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
10833
 
      # Solaris 8's {/usr,}/bin/sh.
10834
 
      touch sub/conftst$i.h
10835
 
    done
10836
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
10837
 
 
10838
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
10839
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
10840
 
    # handle `-M -o', and we need to detect this.  Also, some Intel
10841
 
    # versions had trouble with output in subdirs
10842
 
    am__obj=sub/conftest.${OBJEXT-o}
10843
 
    am__minus_obj="-o $am__obj"
10844
 
    case $depmode in
10845
 
    gcc)
10846
 
      # This depmode causes a compiler race in universal mode.
10847
 
      test "$am__universal" = false || continue
10848
 
      ;;
10849
 
    nosideeffect)
10850
 
      # after this tag, mechanisms are not by side-effect, so they'll
10851
 
      # only be used when explicitly requested
10852
 
      if test "x$enable_dependency_tracking" = xyes; then
10853
 
        continue
10854
 
      else
10855
 
        break
10856
 
      fi
10857
 
      ;;
10858
 
    msvisualcpp | msvcmsys)
10859
 
      # This compiler won't grok `-c -o', but also, the minuso test has
10860
 
      # not run yet.  These depmodes are late enough in the game, and
10861
 
      # so weak that their functioning should not be impacted.
10862
 
      am__obj=conftest.${OBJEXT-o}
10863
 
      am__minus_obj=
10864
 
      ;;
10865
 
    none) break ;;
10866
 
    esac
10867
 
    if depmode=$depmode \
10868
 
       source=sub/conftest.c object=$am__obj \
10869
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
10870
 
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
10871
 
         >/dev/null 2>conftest.err &&
10872
 
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
10873
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
10874
 
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
10875
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
10876
 
      # icc doesn't choke on unknown options, it will just issue warnings
10877
 
      # or remarks (even with -Werror).  So we grep stderr for any message
10878
 
      # that says an option was ignored or not supported.
10879
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
10880
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
10881
 
      # The diagnosis changed in icc 8.0:
10882
 
      #   icc: Command line remark: option '-MP' not supported
10883
 
      if (grep 'ignoring option' conftest.err ||
10884
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
10885
 
        am_cv_CXX_dependencies_compiler_type=$depmode
10886
 
        break
10887
 
      fi
10888
 
    fi
10889
 
  done
10890
 
 
10891
 
  cd ..
10892
 
  rm -rf conftest.dir
10893
 
else
10894
 
  am_cv_CXX_dependencies_compiler_type=none
10895
 
fi
10896
 
 
10897
 
fi
10898
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
10899
 
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
10900
 
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
10901
 
 
10902
 
 if
10903
 
  test "x$enable_dependency_tracking" != xno \
10904
 
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
10905
 
  am__fastdepCXX_TRUE=
10906
 
  am__fastdepCXX_FALSE='#'
10907
 
else
10908
 
  am__fastdepCXX_TRUE='#'
10909
 
  am__fastdepCXX_FALSE=
10910
 
fi
10911
 
 
10912
 
 
10913
 
 
10914
 
ac_ext=cpp
10915
 
ac_cpp='$CXXCPP $CPPFLAGS'
10916
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10917
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10918
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10919
 
if test -z "$CXX"; then
10920
 
  if test -n "$CCC"; then
10921
 
    CXX=$CCC
10922
 
  else
10923
 
    if test -n "$ac_tool_prefix"; then
10924
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
10925
 
  do
10926
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
10927
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
10928
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10929
 
$as_echo_n "checking for $ac_word... " >&6; }
10930
 
if test "${ac_cv_prog_CXX+set}" = set; then :
10931
 
  $as_echo_n "(cached) " >&6
10932
 
else
10933
 
  if test -n "$CXX"; then
10934
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
10935
 
else
10936
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10937
 
for as_dir in $PATH
10938
 
do
10939
 
  IFS=$as_save_IFS
10940
 
  test -z "$as_dir" && as_dir=.
10941
 
    for ac_exec_ext in '' $ac_executable_extensions; do
10942
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
10943
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
10944
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10945
 
    break 2
10946
 
  fi
10947
 
done
10948
 
  done
10949
 
IFS=$as_save_IFS
10950
 
 
10951
 
fi
10952
 
fi
10953
 
CXX=$ac_cv_prog_CXX
10954
 
if test -n "$CXX"; then
10955
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
10956
 
$as_echo "$CXX" >&6; }
10957
 
else
10958
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10959
 
$as_echo "no" >&6; }
10960
 
fi
10961
 
 
10962
 
 
10963
 
    test -n "$CXX" && break
10964
 
  done
10965
 
fi
10966
 
if test -z "$CXX"; then
10967
 
  ac_ct_CXX=$CXX
10968
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
10969
 
do
10970
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
10971
 
set dummy $ac_prog; ac_word=$2
10972
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
10973
 
$as_echo_n "checking for $ac_word... " >&6; }
10974
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
10975
 
  $as_echo_n "(cached) " >&6
10976
 
else
10977
 
  if test -n "$ac_ct_CXX"; then
10978
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
10979
 
else
10980
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10981
 
for as_dir in $PATH
10982
 
do
10983
 
  IFS=$as_save_IFS
10984
 
  test -z "$as_dir" && as_dir=.
10985
 
    for ac_exec_ext in '' $ac_executable_extensions; do
10986
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
10987
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
10988
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
10989
 
    break 2
10990
 
  fi
10991
 
done
10992
 
  done
10993
 
IFS=$as_save_IFS
10994
 
 
10995
 
fi
10996
 
fi
10997
 
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
10998
 
if test -n "$ac_ct_CXX"; then
10999
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
11000
 
$as_echo "$ac_ct_CXX" >&6; }
11001
 
else
11002
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11003
 
$as_echo "no" >&6; }
11004
 
fi
11005
 
 
11006
 
 
11007
 
  test -n "$ac_ct_CXX" && break
11008
 
done
11009
 
 
11010
 
  if test "x$ac_ct_CXX" = x; then
11011
 
    CXX="g++"
11012
 
  else
11013
 
    case $cross_compiling:$ac_tool_warned in
11014
 
yes:)
11015
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
11016
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
11017
 
ac_tool_warned=yes ;;
11018
 
esac
11019
 
    CXX=$ac_ct_CXX
11020
 
  fi
11021
 
fi
11022
 
 
11023
 
  fi
11024
 
fi
11025
 
# Provide some information about the compiler.
11026
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
11027
 
set X $ac_compile
11028
 
ac_compiler=$2
11029
 
for ac_option in --version -v -V -qversion; do
11030
 
  { { ac_try="$ac_compiler $ac_option >&5"
11031
 
case "(($ac_try" in
11032
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11033
 
  *) ac_try_echo=$ac_try;;
11034
 
esac
11035
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
11036
 
$as_echo "$ac_try_echo"; } >&5
11037
 
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
11038
 
  ac_status=$?
11039
 
  if test -s conftest.err; then
11040
 
    sed '10a\
11041
 
... rest of stderr output deleted ...
11042
 
         10q' conftest.err >conftest.er1
11043
 
    cat conftest.er1 >&5
11044
 
    rm -f conftest.er1 conftest.err
11045
 
  fi
11046
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
11047
 
  test $ac_status = 0; }
11048
 
done
11049
 
 
11050
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
11051
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
11052
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
11053
 
  $as_echo_n "(cached) " >&6
11054
 
else
11055
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11056
 
/* end confdefs.h.  */
11057
 
 
11058
 
int
11059
 
main ()
11060
 
{
11061
 
#ifndef __GNUC__
11062
 
       choke me
11063
 
#endif
11064
 
 
11065
 
  ;
11066
 
  return 0;
11067
 
}
11068
 
_ACEOF
11069
 
if ac_fn_cxx_try_compile "$LINENO"; then :
11070
 
  ac_compiler_gnu=yes
11071
 
else
11072
 
  ac_compiler_gnu=no
11073
 
fi
11074
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11075
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
11076
 
 
11077
 
fi
11078
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
11079
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
11080
 
if test $ac_compiler_gnu = yes; then
11081
 
  GXX=yes
11082
 
else
11083
 
  GXX=
11084
 
fi
11085
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
11086
 
ac_save_CXXFLAGS=$CXXFLAGS
11087
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
11088
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
11089
 
if test "${ac_cv_prog_cxx_g+set}" = set; then :
11090
 
  $as_echo_n "(cached) " >&6
11091
 
else
11092
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
11093
 
   ac_cxx_werror_flag=yes
11094
 
   ac_cv_prog_cxx_g=no
11095
 
   CXXFLAGS="-g"
11096
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11097
 
/* end confdefs.h.  */
11098
 
 
11099
 
int
11100
 
main ()
11101
 
{
11102
 
 
11103
 
  ;
11104
 
  return 0;
11105
 
}
11106
 
_ACEOF
11107
 
if ac_fn_cxx_try_compile "$LINENO"; then :
11108
 
  ac_cv_prog_cxx_g=yes
11109
 
else
11110
 
  CXXFLAGS=""
11111
 
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11112
 
/* end confdefs.h.  */
11113
 
 
11114
 
int
11115
 
main ()
11116
 
{
11117
 
 
11118
 
  ;
11119
 
  return 0;
11120
 
}
11121
 
_ACEOF
11122
 
if ac_fn_cxx_try_compile "$LINENO"; then :
11123
 
 
11124
 
else
11125
 
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
11126
 
         CXXFLAGS="-g"
11127
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11128
 
/* end confdefs.h.  */
11129
 
 
11130
 
int
11131
 
main ()
11132
 
{
11133
 
 
11134
 
  ;
11135
 
  return 0;
11136
 
}
11137
 
_ACEOF
11138
 
if ac_fn_cxx_try_compile "$LINENO"; then :
11139
 
  ac_cv_prog_cxx_g=yes
11140
 
fi
11141
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11142
 
fi
11143
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11144
 
fi
11145
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11146
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
11147
 
fi
11148
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
11149
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
11150
 
if test "$ac_test_CXXFLAGS" = set; then
11151
 
  CXXFLAGS=$ac_save_CXXFLAGS
11152
 
elif test $ac_cv_prog_cxx_g = yes; then
11153
 
  if test "$GXX" = yes; then
11154
 
    CXXFLAGS="-g -O2"
11155
 
  else
11156
 
    CXXFLAGS="-g"
11157
 
  fi
11158
 
else
11159
 
  if test "$GXX" = yes; then
11160
 
    CXXFLAGS="-O2"
11161
 
  else
11162
 
    CXXFLAGS=
11163
 
  fi
11164
 
fi
11165
 
ac_ext=c
11166
 
ac_cpp='$CPP $CPPFLAGS'
11167
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11168
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11169
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
11170
 
 
11171
 
depcc="$CXX"  am_compiler_list=
11172
 
 
11173
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
11174
 
$as_echo_n "checking dependency style of $depcc... " >&6; }
11175
 
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
11176
 
  $as_echo_n "(cached) " >&6
11177
 
else
11178
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
11179
 
  # We make a subdir and do the tests there.  Otherwise we can end up
11180
 
  # making bogus files that we don't know about and never remove.  For
11181
 
  # instance it was reported that on HP-UX the gcc test will end up
11182
 
  # making a dummy file named `D' -- because `-MD' means `put the output
11183
 
  # in D'.
11184
 
  mkdir conftest.dir
11185
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
11186
 
  # using a relative directory.
11187
 
  cp "$am_depcomp" conftest.dir
11188
 
  cd conftest.dir
11189
 
  # We will build objects and dependencies in a subdirectory because
11190
 
  # it helps to detect inapplicable dependency modes.  For instance
11191
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
11192
 
  # side effect of compilation, but ICC will put the dependencies in
11193
 
  # the current directory while Tru64 will put them in the object
11194
 
  # directory.
11195
 
  mkdir sub
11196
 
 
11197
 
  am_cv_CXX_dependencies_compiler_type=none
11198
 
  if test "$am_compiler_list" = ""; then
11199
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
11200
 
  fi
11201
 
  am__universal=false
11202
 
  case " $depcc " in #(
11203
 
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
11204
 
     esac
11205
 
 
11206
 
  for depmode in $am_compiler_list; do
11207
 
    # Setup a source with many dependencies, because some compilers
11208
 
    # like to wrap large dependency lists on column 80 (with \), and
11209
 
    # we should not choose a depcomp mode which is confused by this.
11210
 
    #
11211
 
    # We need to recreate these files for each test, as the compiler may
11212
 
    # overwrite some of them when testing with obscure command lines.
11213
 
    # This happens at least with the AIX C compiler.
11214
 
    : > sub/conftest.c
11215
 
    for i in 1 2 3 4 5 6; do
11216
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
11217
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
11218
 
      # Solaris 8's {/usr,}/bin/sh.
11219
 
      touch sub/conftst$i.h
11220
 
    done
11221
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
11222
 
 
11223
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
11224
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
11225
 
    # handle `-M -o', and we need to detect this.  Also, some Intel
11226
 
    # versions had trouble with output in subdirs
11227
 
    am__obj=sub/conftest.${OBJEXT-o}
11228
 
    am__minus_obj="-o $am__obj"
11229
 
    case $depmode in
11230
 
    gcc)
11231
 
      # This depmode causes a compiler race in universal mode.
11232
 
      test "$am__universal" = false || continue
11233
 
      ;;
11234
 
    nosideeffect)
11235
 
      # after this tag, mechanisms are not by side-effect, so they'll
11236
 
      # only be used when explicitly requested
11237
 
      if test "x$enable_dependency_tracking" = xyes; then
11238
 
        continue
11239
 
      else
11240
 
        break
11241
 
      fi
11242
 
      ;;
11243
 
    msvisualcpp | msvcmsys)
11244
 
      # This compiler won't grok `-c -o', but also, the minuso test has
11245
 
      # not run yet.  These depmodes are late enough in the game, and
11246
 
      # so weak that their functioning should not be impacted.
11247
 
      am__obj=conftest.${OBJEXT-o}
11248
 
      am__minus_obj=
11249
 
      ;;
11250
 
    none) break ;;
11251
 
    esac
11252
 
    if depmode=$depmode \
11253
 
       source=sub/conftest.c object=$am__obj \
11254
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
11255
 
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
11256
 
         >/dev/null 2>conftest.err &&
11257
 
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
11258
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
11259
 
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
11260
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
11261
 
      # icc doesn't choke on unknown options, it will just issue warnings
11262
 
      # or remarks (even with -Werror).  So we grep stderr for any message
11263
 
      # that says an option was ignored or not supported.
11264
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
11265
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
11266
 
      # The diagnosis changed in icc 8.0:
11267
 
      #   icc: Command line remark: option '-MP' not supported
11268
 
      if (grep 'ignoring option' conftest.err ||
11269
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
11270
 
        am_cv_CXX_dependencies_compiler_type=$depmode
11271
 
        break
11272
 
      fi
11273
 
    fi
11274
 
  done
11275
 
 
11276
 
  cd ..
11277
 
  rm -rf conftest.dir
11278
 
else
11279
 
  am_cv_CXX_dependencies_compiler_type=none
11280
 
fi
11281
 
 
11282
 
fi
11283
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
11284
 
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
11285
 
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
11286
 
 
11287
 
 if
11288
 
  test "x$enable_dependency_tracking" != xno \
11289
 
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
11290
 
  am__fastdepCXX_TRUE=
11291
 
  am__fastdepCXX_FALSE='#'
11292
 
else
11293
 
  am__fastdepCXX_TRUE='#'
11294
 
  am__fastdepCXX_FALSE=
11295
 
fi
11296
 
 
11297
 
 
11298
 
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
11299
 
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
11300
 
    (test "X$CXX" != "Xg++"))) ; then
11301
 
  ac_ext=cpp
11302
 
ac_cpp='$CXXCPP $CPPFLAGS'
11303
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11304
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11305
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11306
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
11307
 
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
11308
 
if test -z "$CXXCPP"; then
11309
 
  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
11310
 
  $as_echo_n "(cached) " >&6
11311
 
else
11312
 
      # Double quotes because CXXCPP needs to be expanded
11313
 
    for CXXCPP in "$CXX -E" "/lib/cpp"
11314
 
    do
11315
 
      ac_preproc_ok=false
11316
 
for ac_cxx_preproc_warn_flag in '' yes
11317
 
do
11318
 
  # Use a header file that comes with gcc, so configuring glibc
11319
 
  # with a fresh cross-compiler works.
11320
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11321
 
  # <limits.h> exists even on freestanding compilers.
11322
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
11323
 
  # not just through cpp. "Syntax error" is here to catch this case.
11324
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11325
 
/* end confdefs.h.  */
11326
 
#ifdef __STDC__
11327
 
# include <limits.h>
11328
 
#else
11329
 
# include <assert.h>
11330
 
#endif
11331
 
                     Syntax error
11332
 
_ACEOF
11333
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
11334
 
 
11335
 
else
11336
 
  # Broken: fails on valid input.
11337
 
continue
11338
 
fi
11339
 
rm -f conftest.err conftest.$ac_ext
11340
 
 
11341
 
  # OK, works on sane cases.  Now check whether nonexistent headers
11342
 
  # can be detected and how.
11343
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11344
 
/* end confdefs.h.  */
11345
 
#include <ac_nonexistent.h>
11346
 
_ACEOF
11347
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
11348
 
  # Broken: success on invalid input.
11349
 
continue
11350
 
else
11351
 
  # Passes both tests.
11352
 
ac_preproc_ok=:
11353
 
break
11354
 
fi
11355
 
rm -f conftest.err conftest.$ac_ext
11356
 
 
11357
 
done
11358
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
11359
 
rm -f conftest.err conftest.$ac_ext
11360
 
if $ac_preproc_ok; then :
11361
 
  break
11362
 
fi
11363
 
 
11364
 
    done
11365
 
    ac_cv_prog_CXXCPP=$CXXCPP
11366
 
 
11367
 
fi
11368
 
  CXXCPP=$ac_cv_prog_CXXCPP
11369
 
else
11370
 
  ac_cv_prog_CXXCPP=$CXXCPP
11371
 
fi
11372
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
11373
 
$as_echo "$CXXCPP" >&6; }
11374
 
ac_preproc_ok=false
11375
 
for ac_cxx_preproc_warn_flag in '' yes
11376
 
do
11377
 
  # Use a header file that comes with gcc, so configuring glibc
11378
 
  # with a fresh cross-compiler works.
11379
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11380
 
  # <limits.h> exists even on freestanding compilers.
11381
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
11382
 
  # not just through cpp. "Syntax error" is here to catch this case.
11383
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11384
 
/* end confdefs.h.  */
11385
 
#ifdef __STDC__
11386
 
# include <limits.h>
11387
 
#else
11388
 
# include <assert.h>
11389
 
#endif
11390
 
                     Syntax error
11391
 
_ACEOF
11392
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
11393
 
 
11394
 
else
11395
 
  # Broken: fails on valid input.
11396
 
continue
11397
 
fi
11398
 
rm -f conftest.err conftest.$ac_ext
11399
 
 
11400
 
  # OK, works on sane cases.  Now check whether nonexistent headers
11401
 
  # can be detected and how.
11402
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11403
 
/* end confdefs.h.  */
11404
 
#include <ac_nonexistent.h>
11405
 
_ACEOF
11406
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
11407
 
  # Broken: success on invalid input.
11408
 
continue
11409
 
else
11410
 
  # Passes both tests.
11411
 
ac_preproc_ok=:
11412
 
break
11413
 
fi
11414
 
rm -f conftest.err conftest.$ac_ext
11415
 
 
11416
 
done
11417
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
11418
 
rm -f conftest.err conftest.$ac_ext
11419
 
if $ac_preproc_ok; then :
11420
 
 
11421
 
else
11422
 
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
11423
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
11424
 
_lt_caught_CXX_error=yes; }
11425
 
fi
11426
 
 
11427
 
ac_ext=c
11428
 
ac_cpp='$CPP $CPPFLAGS'
11429
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11430
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11431
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
11432
 
 
11433
 
else
11434
 
  _lt_caught_CXX_error=yes
11435
 
fi
11436
 
 
11437
 
 
11438
 
 
11439
 
 
11440
11417
ac_ext=cpp
11441
11418
ac_cpp='$CXXCPP $CPPFLAGS'
11442
11419
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13185
13162
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13186
13163
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13187
13164
   -e 's:$: $lt_compiler_flag:'`
13188
 
   (eval echo "\"\$as_me:13188: $lt_compile\"" >&5)
 
13165
   (eval echo "\"\$as_me:13165: $lt_compile\"" >&5)
13189
13166
   (eval "$lt_compile" 2>conftest.err)
13190
13167
   ac_status=$?
13191
13168
   cat conftest.err >&5
13192
 
   echo "$as_me:13192: \$? = $ac_status" >&5
 
13169
   echo "$as_me:13169: \$? = $ac_status" >&5
13193
13170
   if (exit $ac_status) && test -s "$ac_outfile"; then
13194
13171
     # The compiler can only warn and ignore the option if not recognized
13195
13172
     # So say no if there are warnings other than the usual output.
13284
13261
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13285
13262
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13286
13263
   -e 's:$: $lt_compiler_flag:'`
13287
 
   (eval echo "\"\$as_me:13287: $lt_compile\"" >&5)
 
13264
   (eval echo "\"\$as_me:13264: $lt_compile\"" >&5)
13288
13265
   (eval "$lt_compile" 2>out/conftest.err)
13289
13266
   ac_status=$?
13290
13267
   cat out/conftest.err >&5
13291
 
   echo "$as_me:13291: \$? = $ac_status" >&5
 
13268
   echo "$as_me:13268: \$? = $ac_status" >&5
13292
13269
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13293
13270
   then
13294
13271
     # The compiler can only warn and ignore the option if not recognized
13336
13313
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13337
13314
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13338
13315
   -e 's:$: $lt_compiler_flag:'`
13339
 
   (eval echo "\"\$as_me:13339: $lt_compile\"" >&5)
 
13316
   (eval echo "\"\$as_me:13316: $lt_compile\"" >&5)
13340
13317
   (eval "$lt_compile" 2>out/conftest.err)
13341
13318
   ac_status=$?
13342
13319
   cat out/conftest.err >&5
13343
 
   echo "$as_me:13343: \$? = $ac_status" >&5
 
13320
   echo "$as_me:13320: \$? = $ac_status" >&5
13344
13321
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13345
13322
   then
13346
13323
     # The compiler can only warn and ignore the option if not recognized
14286
14263
 
14287
14264
 
14288
14265
 
 
14266
 
 
14267
 
 
14268
 
 
14269
 
 
14270
 
 
14271
 
 
14272
 
 
14273
 
 
14274
 
 
14275
        ac_config_commands="$ac_config_commands libtool"
 
14276
 
 
14277
 
 
14278
 
 
14279
 
 
14280
# Only expand once:
 
14281
 
 
14282
 
 
14283
 
 
14284
 
14289
14285
# checks for libraries.
14290
14286
 
14291
14287
# checks for header files.
14418
14414
 
14419
14415
# checks for library functions.
14420
14416
 
14421
 
ac_config_files="$ac_config_files Makefile src/Makefile include/Makefile test/Makefile"
 
14417
ac_config_files="$ac_config_files Makefile src/Makefile test/Makefile"
14422
14418
 
14423
14419
cat >confcache <<\_ACEOF
14424
14420
# This file is a shell script that caches the results of configure
14529
14525
  as_fn_error "conditional \"AMDEP\" was never defined.
14530
14526
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14531
14527
fi
 
14528
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
 
14529
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
 
14530
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
14531
fi
14532
14532
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
14533
14533
  as_fn_error "conditional \"am__fastdepCC\" was never defined.
14534
14534
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14537
14537
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
14538
14538
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14539
14539
fi
14540
 
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
14541
 
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
14542
 
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14543
 
fi
14544
14540
 
14545
14541
: ${CONFIG_STATUS=./config.status}
14546
14542
ac_write_fail=0
15008
15004
Configuration commands:
15009
15005
$config_commands
15010
15006
 
15011
 
Report bugs to <edam@waxworlds.org>.
15012
 
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>."
 
15007
Report bugs to <edam@waxworlds.org>."
15013
15008
 
15014
15009
_ACEOF
15015
15010
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15491
15486
    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15492
15487
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15493
15488
    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15494
 
    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
15495
15489
    "test/Makefile") CONFIG_FILES="$CONFIG_FILES test/Makefile" ;;
15496
15490
 
15497
15491
  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;