/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-07-29 09:16:26 UTC
  • Revision ID: edam@waxworlds.org-20100729091626-h8fmg0r74eyfo5ae
- fixed error caused by finialising in-progress queries during rollback that were later finaliased by RAII.

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=''
 
704
PACKAGE_URL='http://www.waxworlds.org/edam/software/sqlite3cc'
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
748
754
CPP
749
755
OTOOL64
750
756
OTOOL
767
773
am__fastdepCC_FALSE
768
774
am__fastdepCC_TRUE
769
775
CCDEPMODE
 
776
AMDEPBACKSLASH
 
777
AMDEP_FALSE
 
778
AMDEP_TRUE
 
779
am__quote
 
780
am__include
 
781
DEPDIR
 
782
OBJEXT
 
783
EXEEXT
770
784
ac_ct_CC
 
785
CPPFLAGS
 
786
LDFLAGS
771
787
CFLAGS
772
788
CC
773
789
host_os
779
795
build_cpu
780
796
build
781
797
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
821
822
target_alias
822
823
host_alias
823
824
build_alias
859
860
ac_subst_files=''
860
861
ac_user_opts='
861
862
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
867
868
with_gnu_ld
868
869
enable_libtool_lock
869
870
'
870
871
      ac_precious_vars='build_alias
871
872
host_alias
872
873
target_alias
873
 
CXX
874
 
CXXFLAGS
 
874
CC
 
875
CFLAGS
875
876
LDFLAGS
876
877
LIBS
877
878
CPPFLAGS
 
879
CPP
 
880
CXX
 
881
CXXFLAGS
878
882
CCC
879
 
CC
880
 
CFLAGS
881
 
CPP
882
883
CXXCPP'
883
884
 
884
885
 
1499
1500
  --disable-option-checking  ignore unrecognized --enable/--with options
1500
1501
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1501
1502
  --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
1504
1503
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1505
1504
  --enable-static[=PKGS]  build static libraries [default=yes]
1506
1505
  --enable-fast-install[=PKGS]
1507
1506
                          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
1508
1509
  --disable-libtool-lock  avoid locking (might break parallel builds)
1509
1510
 
1510
1511
Optional Packages:
1515
1516
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1516
1517
 
1517
1518
Some influential environment variables:
1518
 
  CXX         C++ compiler command
1519
 
  CXXFLAGS    C++ compiler flags
 
1519
  CC          C compiler command
 
1520
  CFLAGS      C compiler flags
1520
1521
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1521
1522
              nonstandard directory <lib dir>
1522
1523
  LIBS        libraries to pass to the linker, e.g. -l<library>
1523
1524
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1524
1525
              you have headers in a nonstandard directory <include dir>
1525
 
  CC          C compiler command
1526
 
  CFLAGS      C compiler flags
1527
1526
  CPP         C preprocessor
 
1527
  CXX         C++ compiler command
 
1528
  CXXFLAGS    C++ compiler flags
1528
1529
  CXXCPP      C++ preprocessor
1529
1530
 
1530
1531
Use these variables to override the choices made by `configure' or to help
1531
1532
it to find libraries and programs with nonstandard names/locations.
1532
1533
 
1533
1534
Report bugs to <edam@waxworlds.org>.
 
1535
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>.
1534
1536
_ACEOF
1535
1537
ac_status=$?
1536
1538
fi
1607
1609
## Autoconf initialization. ##
1608
1610
## ------------------------ ##
1609
1611
 
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
 
 
1648
1612
# ac_fn_c_try_compile LINENO
1649
1613
# --------------------------
1650
1614
# Try to compile conftest.$ac_ext, and return whether this succeeded.
1906
1870
 
1907
1871
} # ac_fn_c_check_func
1908
1872
 
 
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
 
1909
1911
# ac_fn_cxx_try_cpp LINENO
1910
1912
# ------------------------
1911
1913
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2432
2434
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2433
2435
 
2434
2436
 
 
2437
LIBSQLITE3CC_INTERFACE=0:0:0
 
2438
 
2435
2439
ac_aux_dir=
2436
2440
for ac_dir in build-aux "$srcdir"/build-aux; do
2437
2441
  for ac_t in install-sh install.sh shtool; do
2937
2941
 
2938
2942
ac_config_headers="$ac_config_headers config.h"
2939
2943
 
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
 
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=""
2950
3186
  else
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
 
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
2953
3299
  do
2954
3300
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2955
3301
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2956
3302
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957
3303
$as_echo_n "checking for $ac_word... " >&6; }
2958
 
if test "${ac_cv_prog_CXX+set}" = set; then :
 
3304
if test "${ac_cv_prog_CC+set}" = set; then :
2959
3305
  $as_echo_n "(cached) " >&6
2960
3306
else
2961
 
  if test -n "$CXX"; then
2962
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
3307
  if test -n "$CC"; then
 
3308
  ac_cv_prog_CC="$CC" # Let the user override the test.
2963
3309
else
2964
3310
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2965
3311
for as_dir in $PATH
2968
3314
  test -z "$as_dir" && as_dir=.
2969
3315
    for ac_exec_ext in '' $ac_executable_extensions; do
2970
3316
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2971
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
3317
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2972
3318
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973
3319
    break 2
2974
3320
  fi
2978
3324
 
2979
3325
fi
2980
3326
fi
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; }
 
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; }
2985
3331
else
2986
3332
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987
3333
$as_echo "no" >&6; }
2988
3334
fi
2989
3335
 
2990
3336
 
2991
 
    test -n "$CXX" && break
 
3337
    test -n "$CC" && break
2992
3338
  done
2993
3339
fi
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
 
3340
if test -z "$CC"; then
 
3341
  ac_ct_CC=$CC
 
3342
  for ac_prog in cl.exe
2997
3343
do
2998
3344
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2999
3345
set dummy $ac_prog; ac_word=$2
3000
3346
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3001
3347
$as_echo_n "checking for $ac_word... " >&6; }
3002
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
 
3348
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
3003
3349
  $as_echo_n "(cached) " >&6
3004
3350
else
3005
 
  if test -n "$ac_ct_CXX"; then
3006
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
3351
  if test -n "$ac_ct_CC"; then
 
3352
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3007
3353
else
3008
3354
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3009
3355
for as_dir in $PATH
3012
3358
  test -z "$as_dir" && as_dir=.
3013
3359
    for ac_exec_ext in '' $ac_executable_extensions; do
3014
3360
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3015
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
3361
    ac_cv_prog_ac_ct_CC="$ac_prog"
3016
3362
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3017
3363
    break 2
3018
3364
  fi
3022
3368
 
3023
3369
fi
3024
3370
fi
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; }
 
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; }
3029
3375
else
3030
3376
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3031
3377
$as_echo "no" >&6; }
3032
3378
fi
3033
3379
 
3034
3380
 
3035
 
  test -n "$ac_ct_CXX" && break
 
3381
  test -n "$ac_ct_CC" && break
3036
3382
done
3037
3383
 
3038
 
  if test "x$ac_ct_CXX" = x; then
3039
 
    CXX="g++"
 
3384
  if test "x$ac_ct_CC" = x; then
 
3385
    CC=""
3040
3386
  else
3041
3387
    case $cross_compiling:$ac_tool_warned in
3042
3388
yes:)
3044
3390
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3045
3391
ac_tool_warned=yes ;;
3046
3392
esac
3047
 
    CXX=$ac_ct_CXX
3048
 
  fi
3049
 
fi
3050
 
 
3051
 
  fi
3052
 
fi
 
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
 
3053
3405
# Provide some information about the compiler.
3054
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
 
3406
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3055
3407
set X $ac_compile
3056
3408
ac_compiler=$2
3057
3409
for ac_option in --version -v -V -qversion; do
3093
3445
# Try to create an executable without -o first, disregard a.out.
3094
3446
# It will help us diagnose broken compilers, and finding out an intuition
3095
3447
# of exeext.
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; }
 
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; }
3098
3450
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3099
3451
 
3100
3452
# The possible output files:
3165
3517
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3166
3518
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3167
3519
{ as_fn_set_status 77
3168
 
as_fn_error "C++ compiler cannot create executables
 
3520
as_fn_error "C compiler cannot create executables
3169
3521
See \`config.log' for more details." "$LINENO" 5; }; }
3170
3522
fi
3171
3523
ac_exeext=$ac_cv_exeext
3172
3524
 
3173
3525
# Check that the compiler produces executables we can run.  If not, either
3174
3526
# the compiler is broken, or we cross compile.
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; }
 
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; }
3177
3529
# If not cross compiling, check that we can run a simple program.
3178
3530
if test "$cross_compiling" != yes; then
3179
3531
  if { ac_try='./$ac_file'
3194
3546
    else
3195
3547
        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3196
3548
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3197
 
as_fn_error "cannot run C++ compiled programs.
 
3549
as_fn_error "cannot run C compiled programs.
3198
3550
If you meant to cross compile, use \`--host'.
3199
3551
See \`config.log' for more details." "$LINENO" 5; }
3200
3552
    fi
3302
3654
$as_echo "$ac_cv_objext" >&6; }
3303
3655
OBJEXT=$ac_cv_objext
3304
3656
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
 
 
4039
3657
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4040
3658
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4041
3659
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4959
4577
else
4960
4578
  lt_cv_nm_interface="BSD nm"
4961
4579
  echo "int some_variable = 0;" > conftest.$ac_ext
4962
 
  (eval echo "\"\$as_me:4962: $ac_compile\"" >&5)
 
4580
  (eval echo "\"\$as_me:4580: $ac_compile\"" >&5)
4963
4581
  (eval "$ac_compile" 2>conftest.err)
4964
4582
  cat conftest.err >&5
4965
 
  (eval echo "\"\$as_me:4965: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
 
4583
  (eval echo "\"\$as_me:4583: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
4966
4584
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
4967
4585
  cat conftest.err >&5
4968
 
  (eval echo "\"\$as_me:4968: output\"" >&5)
 
4586
  (eval echo "\"\$as_me:4586: output\"" >&5)
4969
4587
  cat conftest.out >&5
4970
4588
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
4971
4589
    lt_cv_nm_interface="MS dumpbin"
6171
5789
  ;;
6172
5790
*-*-irix6*)
6173
5791
  # Find out which ABI we are using.
6174
 
  echo '#line 6174 "configure"' > conftest.$ac_ext
 
5792
  echo '#line 5792 "configure"' > conftest.$ac_ext
6175
5793
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6176
5794
  (eval $ac_compile) 2>&5
6177
5795
  ac_status=$?
7201
6819
 
7202
6820
 
7203
6821
 
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
 
 
7731
6822
# Set options
7732
6823
 
7733
6824
 
8228
7319
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8229
7320
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8230
7321
   -e 's:$: $lt_compiler_flag:'`
8231
 
   (eval echo "\"\$as_me:8231: $lt_compile\"" >&5)
 
7322
   (eval echo "\"\$as_me:7322: $lt_compile\"" >&5)
8232
7323
   (eval "$lt_compile" 2>conftest.err)
8233
7324
   ac_status=$?
8234
7325
   cat conftest.err >&5
8235
 
   echo "$as_me:8235: \$? = $ac_status" >&5
 
7326
   echo "$as_me:7326: \$? = $ac_status" >&5
8236
7327
   if (exit $ac_status) && test -s "$ac_outfile"; then
8237
7328
     # The compiler can only warn and ignore the option if not recognized
8238
7329
     # So say no if there are warnings other than the usual output.
8567
7658
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8568
7659
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8569
7660
   -e 's:$: $lt_compiler_flag:'`
8570
 
   (eval echo "\"\$as_me:8570: $lt_compile\"" >&5)
 
7661
   (eval echo "\"\$as_me:7661: $lt_compile\"" >&5)
8571
7662
   (eval "$lt_compile" 2>conftest.err)
8572
7663
   ac_status=$?
8573
7664
   cat conftest.err >&5
8574
 
   echo "$as_me:8574: \$? = $ac_status" >&5
 
7665
   echo "$as_me:7665: \$? = $ac_status" >&5
8575
7666
   if (exit $ac_status) && test -s "$ac_outfile"; then
8576
7667
     # The compiler can only warn and ignore the option if not recognized
8577
7668
     # So say no if there are warnings other than the usual output.
8672
7763
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8673
7764
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8674
7765
   -e 's:$: $lt_compiler_flag:'`
8675
 
   (eval echo "\"\$as_me:8675: $lt_compile\"" >&5)
 
7766
   (eval echo "\"\$as_me:7766: $lt_compile\"" >&5)
8676
7767
   (eval "$lt_compile" 2>out/conftest.err)
8677
7768
   ac_status=$?
8678
7769
   cat out/conftest.err >&5
8679
 
   echo "$as_me:8679: \$? = $ac_status" >&5
 
7770
   echo "$as_me:7770: \$? = $ac_status" >&5
8680
7771
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8681
7772
   then
8682
7773
     # The compiler can only warn and ignore the option if not recognized
8727
7818
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8728
7819
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8729
7820
   -e 's:$: $lt_compiler_flag:'`
8730
 
   (eval echo "\"\$as_me:8730: $lt_compile\"" >&5)
 
7821
   (eval echo "\"\$as_me:7821: $lt_compile\"" >&5)
8731
7822
   (eval "$lt_compile" 2>out/conftest.err)
8732
7823
   ac_status=$?
8733
7824
   cat out/conftest.err >&5
8734
 
   echo "$as_me:8734: \$? = $ac_status" >&5
 
7825
   echo "$as_me:7825: \$? = $ac_status" >&5
8735
7826
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8736
7827
   then
8737
7828
     # The compiler can only warn and ignore the option if not recognized
11110
10201
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11111
10202
  lt_status=$lt_dlunknown
11112
10203
  cat > conftest.$ac_ext <<_LT_EOF
11113
 
#line 11113 "configure"
 
10204
#line 10204 "configure"
11114
10205
#include "confdefs.h"
11115
10206
 
11116
10207
#if HAVE_DLFCN_H
11206
10297
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11207
10298
  lt_status=$lt_dlunknown
11208
10299
  cat > conftest.$ac_ext <<_LT_EOF
11209
 
#line 11209 "configure"
 
10300
#line 10300 "configure"
11210
10301
#include "confdefs.h"
11211
10302
 
11212
10303
#if HAVE_DLFCN_H
11414
10505
CC="$lt_save_CC"
11415
10506
 
11416
10507
 
 
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
 
11417
11440
ac_ext=cpp
11418
11441
ac_cpp='$CXXCPP $CPPFLAGS'
11419
11442
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13162
13185
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13163
13186
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13164
13187
   -e 's:$: $lt_compiler_flag:'`
13165
 
   (eval echo "\"\$as_me:13165: $lt_compile\"" >&5)
 
13188
   (eval echo "\"\$as_me:13188: $lt_compile\"" >&5)
13166
13189
   (eval "$lt_compile" 2>conftest.err)
13167
13190
   ac_status=$?
13168
13191
   cat conftest.err >&5
13169
 
   echo "$as_me:13169: \$? = $ac_status" >&5
 
13192
   echo "$as_me:13192: \$? = $ac_status" >&5
13170
13193
   if (exit $ac_status) && test -s "$ac_outfile"; then
13171
13194
     # The compiler can only warn and ignore the option if not recognized
13172
13195
     # So say no if there are warnings other than the usual output.
13261
13284
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13262
13285
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13263
13286
   -e 's:$: $lt_compiler_flag:'`
13264
 
   (eval echo "\"\$as_me:13264: $lt_compile\"" >&5)
 
13287
   (eval echo "\"\$as_me:13287: $lt_compile\"" >&5)
13265
13288
   (eval "$lt_compile" 2>out/conftest.err)
13266
13289
   ac_status=$?
13267
13290
   cat out/conftest.err >&5
13268
 
   echo "$as_me:13268: \$? = $ac_status" >&5
 
13291
   echo "$as_me:13291: \$? = $ac_status" >&5
13269
13292
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13270
13293
   then
13271
13294
     # The compiler can only warn and ignore the option if not recognized
13313
13336
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13314
13337
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13315
13338
   -e 's:$: $lt_compiler_flag:'`
13316
 
   (eval echo "\"\$as_me:13316: $lt_compile\"" >&5)
 
13339
   (eval echo "\"\$as_me:13339: $lt_compile\"" >&5)
13317
13340
   (eval "$lt_compile" 2>out/conftest.err)
13318
13341
   ac_status=$?
13319
13342
   cat out/conftest.err >&5
13320
 
   echo "$as_me:13320: \$? = $ac_status" >&5
 
13343
   echo "$as_me:13343: \$? = $ac_status" >&5
13321
13344
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13322
13345
   then
13323
13346
     # The compiler can only warn and ignore the option if not recognized
14263
14286
 
14264
14287
 
14265
14288
 
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
 
 
14285
14289
# checks for libraries.
 
14290
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lboost_filesystem-mt" >&5
 
14291
$as_echo_n "checking for main in -lboost_filesystem-mt... " >&6; }
 
14292
if test "${ac_cv_lib_boost_filesystem_mt_main+set}" = set; then :
 
14293
  $as_echo_n "(cached) " >&6
 
14294
else
 
14295
  ac_check_lib_save_LIBS=$LIBS
 
14296
LIBS="-lboost_filesystem-mt  $LIBS"
 
14297
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14298
/* end confdefs.h.  */
 
14299
 
 
14300
 
 
14301
int
 
14302
main ()
 
14303
{
 
14304
return main ();
 
14305
  ;
 
14306
  return 0;
 
14307
}
 
14308
_ACEOF
 
14309
if ac_fn_c_try_link "$LINENO"; then :
 
14310
  ac_cv_lib_boost_filesystem_mt_main=yes
 
14311
else
 
14312
  ac_cv_lib_boost_filesystem_mt_main=no
 
14313
fi
 
14314
rm -f core conftest.err conftest.$ac_objext \
 
14315
    conftest$ac_exeext conftest.$ac_ext
 
14316
LIBS=$ac_check_lib_save_LIBS
 
14317
fi
 
14318
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_boost_filesystem_mt_main" >&5
 
14319
$as_echo "$ac_cv_lib_boost_filesystem_mt_main" >&6; }
 
14320
if test "x$ac_cv_lib_boost_filesystem_mt_main" = x""yes; then :
 
14321
  cat >>confdefs.h <<_ACEOF
 
14322
#define HAVE_LIBBOOST_FILESYSTEM_MT 1
 
14323
_ACEOF
 
14324
 
 
14325
  LIBS="-lboost_filesystem-mt $LIBS"
 
14326
 
 
14327
else
 
14328
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to find Boost Filesystem library - the library tests may not compile!" >&5
 
14329
$as_echo "$as_me: WARNING: Unable to find Boost Filesystem library - the library tests may not compile!" >&2;}
 
14330
fi
 
14331
 
 
14332
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lboost_thread-mt" >&5
 
14333
$as_echo_n "checking for main in -lboost_thread-mt... " >&6; }
 
14334
if test "${ac_cv_lib_boost_thread_mt_main+set}" = set; then :
 
14335
  $as_echo_n "(cached) " >&6
 
14336
else
 
14337
  ac_check_lib_save_LIBS=$LIBS
 
14338
LIBS="-lboost_thread-mt  $LIBS"
 
14339
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14340
/* end confdefs.h.  */
 
14341
 
 
14342
 
 
14343
int
 
14344
main ()
 
14345
{
 
14346
return main ();
 
14347
  ;
 
14348
  return 0;
 
14349
}
 
14350
_ACEOF
 
14351
if ac_fn_c_try_link "$LINENO"; then :
 
14352
  ac_cv_lib_boost_thread_mt_main=yes
 
14353
else
 
14354
  ac_cv_lib_boost_thread_mt_main=no
 
14355
fi
 
14356
rm -f core conftest.err conftest.$ac_objext \
 
14357
    conftest$ac_exeext conftest.$ac_ext
 
14358
LIBS=$ac_check_lib_save_LIBS
 
14359
fi
 
14360
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_boost_thread_mt_main" >&5
 
14361
$as_echo "$ac_cv_lib_boost_thread_mt_main" >&6; }
 
14362
if test "x$ac_cv_lib_boost_thread_mt_main" = x""yes; then :
 
14363
  cat >>confdefs.h <<_ACEOF
 
14364
#define HAVE_LIBBOOST_THREAD_MT 1
 
14365
_ACEOF
 
14366
 
 
14367
  LIBS="-lboost_thread-mt $LIBS"
 
14368
 
 
14369
else
 
14370
  as_fn_error "Unable to find Boost Thread library" "$LINENO" 5
 
14371
fi
 
14372
 
 
14373
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sqlite3_initialize in -lsqlite3" >&5
 
14374
$as_echo_n "checking for sqlite3_initialize in -lsqlite3... " >&6; }
 
14375
if test "${ac_cv_lib_sqlite3_sqlite3_initialize+set}" = set; then :
 
14376
  $as_echo_n "(cached) " >&6
 
14377
else
 
14378
  ac_check_lib_save_LIBS=$LIBS
 
14379
LIBS="-lsqlite3  $LIBS"
 
14380
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14381
/* end confdefs.h.  */
 
14382
 
 
14383
/* Override any GCC internal prototype to avoid an error.
 
14384
   Use char because int might match the return type of a GCC
 
14385
   builtin and then its argument prototype would still apply.  */
 
14386
#ifdef __cplusplus
 
14387
extern "C"
 
14388
#endif
 
14389
char sqlite3_initialize ();
 
14390
int
 
14391
main ()
 
14392
{
 
14393
return sqlite3_initialize ();
 
14394
  ;
 
14395
  return 0;
 
14396
}
 
14397
_ACEOF
 
14398
if ac_fn_c_try_link "$LINENO"; then :
 
14399
  ac_cv_lib_sqlite3_sqlite3_initialize=yes
 
14400
else
 
14401
  ac_cv_lib_sqlite3_sqlite3_initialize=no
 
14402
fi
 
14403
rm -f core conftest.err conftest.$ac_objext \
 
14404
    conftest$ac_exeext conftest.$ac_ext
 
14405
LIBS=$ac_check_lib_save_LIBS
 
14406
fi
 
14407
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_sqlite3_sqlite3_initialize" >&5
 
14408
$as_echo "$ac_cv_lib_sqlite3_sqlite3_initialize" >&6; }
 
14409
if test "x$ac_cv_lib_sqlite3_sqlite3_initialize" = x""yes; then :
 
14410
  cat >>confdefs.h <<_ACEOF
 
14411
#define HAVE_LIBSQLITE3 1
 
14412
_ACEOF
 
14413
 
 
14414
  LIBS="-lsqlite3 $LIBS"
 
14415
 
 
14416
else
 
14417
  as_fn_error "Unable to find SQLite3 library" "$LINENO" 5
 
14418
fi
 
14419
 
14286
14420
 
14287
14421
# checks for header files.
14288
14422
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
14414
14548
 
14415
14549
# checks for library functions.
14416
14550
 
14417
 
ac_config_files="$ac_config_files Makefile src/Makefile test/Makefile"
 
14551
ac_config_files="$ac_config_files Makefile src/Makefile include/Makefile test/Makefile"
14418
14552
 
14419
14553
cat >confcache <<\_ACEOF
14420
14554
# This file is a shell script that caches the results of configure
14525
14659
  as_fn_error "conditional \"AMDEP\" was never defined.
14526
14660
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14527
14661
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
14662
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
14533
14663
  as_fn_error "conditional \"am__fastdepCC\" was never defined.
14534
14664
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14537
14667
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
14538
14668
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14539
14669
fi
 
14670
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
 
14671
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
 
14672
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
14673
fi
14540
14674
 
14541
14675
: ${CONFIG_STATUS=./config.status}
14542
14676
ac_write_fail=0
15004
15138
Configuration commands:
15005
15139
$config_commands
15006
15140
 
15007
 
Report bugs to <edam@waxworlds.org>."
 
15141
Report bugs to <edam@waxworlds.org>.
 
15142
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>."
15008
15143
 
15009
15144
_ACEOF
15010
15145
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15486
15621
    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15487
15622
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15488
15623
    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
 
15624
    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
15489
15625
    "test/Makefile") CONFIG_FILES="$CONFIG_FILES test/Makefile" ;;
15490
15626
 
15491
15627
  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;