/sqlite3cc

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

« back to all changes in this revision

Viewing changes to configure

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

Show diffs side-by-side

added added

removed removed

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