/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 15:28:23 UTC
  • Revision ID: edam@waxworlds.org-20100207152823-42k206h6gwy7vla4
- fixed .am files so the library gets built!

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
748
754
CPP
749
755
OTOOL64
750
756
OTOOL
767
773
am__fastdepCC_FALSE
768
774
am__fastdepCC_TRUE
769
775
CCDEPMODE
 
776
AMDEPBACKSLASH
 
777
AMDEP_FALSE
 
778
AMDEP_TRUE
 
779
am__quote
 
780
am__include
 
781
DEPDIR
 
782
OBJEXT
 
783
EXEEXT
770
784
ac_ct_CC
 
785
CPPFLAGS
 
786
LDFLAGS
771
787
CFLAGS
772
788
CC
773
789
host_os
779
795
build_cpu
780
796
build
781
797
LIBTOOL
782
 
am__fastdepCXX_FALSE
783
 
am__fastdepCXX_TRUE
784
 
CXXDEPMODE
785
 
AMDEPBACKSLASH
786
 
AMDEP_FALSE
787
 
AMDEP_TRUE
788
 
am__quote
789
 
am__include
790
 
DEPDIR
791
 
OBJEXT
792
 
EXEEXT
793
 
ac_ct_CXX
794
 
CPPFLAGS
795
 
LDFLAGS
796
 
CXXFLAGS
797
 
CXX
798
798
am__untar
799
799
am__tar
800
800
AMTAR
859
859
ac_subst_files=''
860
860
ac_user_opts='
861
861
enable_option_checking
862
 
enable_dependency_tracking
863
862
enable_shared
864
863
enable_static
865
864
with_pic
866
865
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
 
CXX
874
 
CXXFLAGS
 
873
CC
 
874
CFLAGS
875
875
LDFLAGS
876
876
LIBS
877
877
CPPFLAGS
 
878
CPP
 
879
CXX
 
880
CXXFLAGS
878
881
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
1504
1502
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1505
1503
  --enable-static[=PKGS]  build static libraries [default=yes]
1506
1504
  --enable-fast-install[=PKGS]
1507
1505
                          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
 
  CXX         C++ compiler command
1519
 
  CXXFLAGS    C++ compiler flags
 
1518
  CC          C compiler command
 
1519
  CFLAGS      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
1527
1525
  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
 
 
1648
1610
# ac_fn_c_try_compile LINENO
1649
1611
# --------------------------
1650
1612
# Try to compile conftest.$ac_ext, and return whether this succeeded.
1906
1868
 
1907
1869
} # ac_fn_c_check_func
1908
1870
 
 
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
 
 
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
 
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=""
2950
3182
  else
2951
 
    if test -n "$ac_tool_prefix"; then
2952
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
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
2953
3295
  do
2954
3296
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2955
3297
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2956
3298
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957
3299
$as_echo_n "checking for $ac_word... " >&6; }
2958
 
if test "${ac_cv_prog_CXX+set}" = set; then :
 
3300
if test "${ac_cv_prog_CC+set}" = set; then :
2959
3301
  $as_echo_n "(cached) " >&6
2960
3302
else
2961
 
  if test -n "$CXX"; then
2962
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
3303
  if test -n "$CC"; then
 
3304
  ac_cv_prog_CC="$CC" # Let the user override the test.
2963
3305
else
2964
3306
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2965
3307
for as_dir in $PATH
2968
3310
  test -z "$as_dir" && as_dir=.
2969
3311
    for ac_exec_ext in '' $ac_executable_extensions; do
2970
3312
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2971
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
3313
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2972
3314
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973
3315
    break 2
2974
3316
  fi
2978
3320
 
2979
3321
fi
2980
3322
fi
2981
 
CXX=$ac_cv_prog_CXX
2982
 
if test -n "$CXX"; then
2983
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
2984
 
$as_echo "$CXX" >&6; }
 
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; }
2985
3327
else
2986
3328
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987
3329
$as_echo "no" >&6; }
2988
3330
fi
2989
3331
 
2990
3332
 
2991
 
    test -n "$CXX" && break
 
3333
    test -n "$CC" && break
2992
3334
  done
2993
3335
fi
2994
 
if test -z "$CXX"; then
2995
 
  ac_ct_CXX=$CXX
2996
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
3336
if test -z "$CC"; then
 
3337
  ac_ct_CC=$CC
 
3338
  for ac_prog in cl.exe
2997
3339
do
2998
3340
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2999
3341
set dummy $ac_prog; ac_word=$2
3000
3342
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3001
3343
$as_echo_n "checking for $ac_word... " >&6; }
3002
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
 
3344
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
3003
3345
  $as_echo_n "(cached) " >&6
3004
3346
else
3005
 
  if test -n "$ac_ct_CXX"; then
3006
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
3347
  if test -n "$ac_ct_CC"; then
 
3348
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3007
3349
else
3008
3350
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3009
3351
for as_dir in $PATH
3012
3354
  test -z "$as_dir" && as_dir=.
3013
3355
    for ac_exec_ext in '' $ac_executable_extensions; do
3014
3356
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3015
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
3357
    ac_cv_prog_ac_ct_CC="$ac_prog"
3016
3358
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3017
3359
    break 2
3018
3360
  fi
3022
3364
 
3023
3365
fi
3024
3366
fi
3025
 
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3026
 
if test -n "$ac_ct_CXX"; then
3027
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
3028
 
$as_echo "$ac_ct_CXX" >&6; }
 
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; }
3029
3371
else
3030
3372
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3031
3373
$as_echo "no" >&6; }
3032
3374
fi
3033
3375
 
3034
3376
 
3035
 
  test -n "$ac_ct_CXX" && break
 
3377
  test -n "$ac_ct_CC" && break
3036
3378
done
3037
3379
 
3038
 
  if test "x$ac_ct_CXX" = x; then
3039
 
    CXX="g++"
 
3380
  if test "x$ac_ct_CC" = x; then
 
3381
    CC=""
3040
3382
  else
3041
3383
    case $cross_compiling:$ac_tool_warned in
3042
3384
yes:)
3044
3386
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3045
3387
ac_tool_warned=yes ;;
3046
3388
esac
3047
 
    CXX=$ac_ct_CXX
3048
 
  fi
3049
 
fi
3050
 
 
3051
 
  fi
3052
 
fi
 
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
 
3053
3401
# Provide some information about the compiler.
3054
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
 
3402
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3055
3403
set X $ac_compile
3056
3404
ac_compiler=$2
3057
3405
for ac_option in --version -v -V -qversion; do
3093
3441
# Try to create an executable without -o first, disregard a.out.
3094
3442
# It will help us diagnose broken compilers, and finding out an intuition
3095
3443
# of exeext.
3096
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3097
 
$as_echo_n "checking for C++ compiler default output file name... " >&6; }
 
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; }
3098
3446
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3099
3447
 
3100
3448
# The possible output files:
3165
3513
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3166
3514
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3167
3515
{ as_fn_set_status 77
3168
 
as_fn_error "C++ compiler cannot create executables
 
3516
as_fn_error "C compiler cannot create executables
3169
3517
See \`config.log' for more details." "$LINENO" 5; }; }
3170
3518
fi
3171
3519
ac_exeext=$ac_cv_exeext
3172
3520
 
3173
3521
# Check that the compiler produces executables we can run.  If not, either
3174
3522
# the compiler is broken, or we cross compile.
3175
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3176
 
$as_echo_n "checking whether the C++ compiler works... " >&6; }
 
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; }
3177
3525
# If not cross compiling, check that we can run a simple program.
3178
3526
if test "$cross_compiling" != yes; then
3179
3527
  if { ac_try='./$ac_file'
3194
3542
    else
3195
3543
        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3196
3544
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3197
 
as_fn_error "cannot run C++ compiled programs.
 
3545
as_fn_error "cannot run C compiled programs.
3198
3546
If you meant to cross compile, use \`--host'.
3199
3547
See \`config.log' for more details." "$LINENO" 5; }
3200
3548
    fi
3302
3650
$as_echo "$ac_cv_objext" >&6; }
3303
3651
OBJEXT=$ac_cv_objext
3304
3652
ac_objext=$OBJEXT
3305
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3306
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3307
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3308
 
  $as_echo_n "(cached) " >&6
3309
 
else
3310
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3311
 
/* end confdefs.h.  */
3312
 
 
3313
 
int
3314
 
main ()
3315
 
{
3316
 
#ifndef __GNUC__
3317
 
       choke me
3318
 
#endif
3319
 
 
3320
 
  ;
3321
 
  return 0;
3322
 
}
3323
 
_ACEOF
3324
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3325
 
  ac_compiler_gnu=yes
3326
 
else
3327
 
  ac_compiler_gnu=no
3328
 
fi
3329
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3330
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3331
 
 
3332
 
fi
3333
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3334
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3335
 
if test $ac_compiler_gnu = yes; then
3336
 
  GXX=yes
3337
 
else
3338
 
  GXX=
3339
 
fi
3340
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
3341
 
ac_save_CXXFLAGS=$CXXFLAGS
3342
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3343
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
3344
 
if test "${ac_cv_prog_cxx_g+set}" = set; then :
3345
 
  $as_echo_n "(cached) " >&6
3346
 
else
3347
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3348
 
   ac_cxx_werror_flag=yes
3349
 
   ac_cv_prog_cxx_g=no
3350
 
   CXXFLAGS="-g"
3351
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3352
 
/* end confdefs.h.  */
3353
 
 
3354
 
int
3355
 
main ()
3356
 
{
3357
 
 
3358
 
  ;
3359
 
  return 0;
3360
 
}
3361
 
_ACEOF
3362
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3363
 
  ac_cv_prog_cxx_g=yes
3364
 
else
3365
 
  CXXFLAGS=""
3366
 
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3367
 
/* end confdefs.h.  */
3368
 
 
3369
 
int
3370
 
main ()
3371
 
{
3372
 
 
3373
 
  ;
3374
 
  return 0;
3375
 
}
3376
 
_ACEOF
3377
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3378
 
 
3379
 
else
3380
 
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3381
 
         CXXFLAGS="-g"
3382
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3383
 
/* end confdefs.h.  */
3384
 
 
3385
 
int
3386
 
main ()
3387
 
{
3388
 
 
3389
 
  ;
3390
 
  return 0;
3391
 
}
3392
 
_ACEOF
3393
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3394
 
  ac_cv_prog_cxx_g=yes
3395
 
fi
3396
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3397
 
fi
3398
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3399
 
fi
3400
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3401
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3402
 
fi
3403
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3404
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
3405
 
if test "$ac_test_CXXFLAGS" = set; then
3406
 
  CXXFLAGS=$ac_save_CXXFLAGS
3407
 
elif test $ac_cv_prog_cxx_g = yes; then
3408
 
  if test "$GXX" = yes; then
3409
 
    CXXFLAGS="-g -O2"
3410
 
  else
3411
 
    CXXFLAGS="-g"
3412
 
  fi
3413
 
else
3414
 
  if test "$GXX" = yes; then
3415
 
    CXXFLAGS="-O2"
3416
 
  else
3417
 
    CXXFLAGS=
3418
 
  fi
3419
 
fi
3420
 
ac_ext=c
3421
 
ac_cpp='$CPP $CPPFLAGS'
3422
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3423
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3424
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3425
 
DEPDIR="${am__leading_dot}deps"
3426
 
 
3427
 
ac_config_commands="$ac_config_commands depfiles"
3428
 
 
3429
 
 
3430
 
am_make=${MAKE-make}
3431
 
cat > confinc << 'END'
3432
 
am__doit:
3433
 
        @echo this is the am__doit target
3434
 
.PHONY: am__doit
3435
 
END
3436
 
# If we don't find an include directive, just comment out the code.
3437
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
3438
 
$as_echo_n "checking for style of include used by $am_make... " >&6; }
3439
 
am__include="#"
3440
 
am__quote=
3441
 
_am_result=none
3442
 
# First try GNU make style include.
3443
 
echo "include confinc" > confmf
3444
 
# Ignore all kinds of additional output from `make'.
3445
 
case `$am_make -s -f confmf 2> /dev/null` in #(
3446
 
*the\ am__doit\ target*)
3447
 
  am__include=include
3448
 
  am__quote=
3449
 
  _am_result=GNU
3450
 
  ;;
3451
 
esac
3452
 
# Now try BSD make style include.
3453
 
if test "$am__include" = "#"; then
3454
 
   echo '.include "confinc"' > confmf
3455
 
   case `$am_make -s -f confmf 2> /dev/null` in #(
3456
 
   *the\ am__doit\ target*)
3457
 
     am__include=.include
3458
 
     am__quote="\""
3459
 
     _am_result=BSD
3460
 
     ;;
3461
 
   esac
3462
 
fi
3463
 
 
3464
 
 
3465
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
3466
 
$as_echo "$_am_result" >&6; }
3467
 
rm -f confinc confmf
3468
 
 
3469
 
# Check whether --enable-dependency-tracking was given.
3470
 
if test "${enable_dependency_tracking+set}" = set; then :
3471
 
  enableval=$enable_dependency_tracking;
3472
 
fi
3473
 
 
3474
 
if test "x$enable_dependency_tracking" != xno; then
3475
 
  am_depcomp="$ac_aux_dir/depcomp"
3476
 
  AMDEPBACKSLASH='\'
3477
 
fi
3478
 
 if test "x$enable_dependency_tracking" != xno; then
3479
 
  AMDEP_TRUE=
3480
 
  AMDEP_FALSE='#'
3481
 
else
3482
 
  AMDEP_TRUE='#'
3483
 
  AMDEP_FALSE=
3484
 
fi
3485
 
 
3486
 
 
3487
 
 
3488
 
depcc="$CXX"  am_compiler_list=
3489
 
 
3490
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
3491
 
$as_echo_n "checking dependency style of $depcc... " >&6; }
3492
 
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
3493
 
  $as_echo_n "(cached) " >&6
3494
 
else
3495
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3496
 
  # We make a subdir and do the tests there.  Otherwise we can end up
3497
 
  # making bogus files that we don't know about and never remove.  For
3498
 
  # instance it was reported that on HP-UX the gcc test will end up
3499
 
  # making a dummy file named `D' -- because `-MD' means `put the output
3500
 
  # in D'.
3501
 
  mkdir conftest.dir
3502
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
3503
 
  # using a relative directory.
3504
 
  cp "$am_depcomp" conftest.dir
3505
 
  cd conftest.dir
3506
 
  # We will build objects and dependencies in a subdirectory because
3507
 
  # it helps to detect inapplicable dependency modes.  For instance
3508
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
3509
 
  # side effect of compilation, but ICC will put the dependencies in
3510
 
  # the current directory while Tru64 will put them in the object
3511
 
  # directory.
3512
 
  mkdir sub
3513
 
 
3514
 
  am_cv_CXX_dependencies_compiler_type=none
3515
 
  if test "$am_compiler_list" = ""; then
3516
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3517
 
  fi
3518
 
  am__universal=false
3519
 
  case " $depcc " in #(
3520
 
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
3521
 
     esac
3522
 
 
3523
 
  for depmode in $am_compiler_list; do
3524
 
    # Setup a source with many dependencies, because some compilers
3525
 
    # like to wrap large dependency lists on column 80 (with \), and
3526
 
    # we should not choose a depcomp mode which is confused by this.
3527
 
    #
3528
 
    # We need to recreate these files for each test, as the compiler may
3529
 
    # overwrite some of them when testing with obscure command lines.
3530
 
    # This happens at least with the AIX C compiler.
3531
 
    : > sub/conftest.c
3532
 
    for i in 1 2 3 4 5 6; do
3533
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
3534
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3535
 
      # Solaris 8's {/usr,}/bin/sh.
3536
 
      touch sub/conftst$i.h
3537
 
    done
3538
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3539
 
 
3540
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
3541
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
3542
 
    # handle `-M -o', and we need to detect this.  Also, some Intel
3543
 
    # versions had trouble with output in subdirs
3544
 
    am__obj=sub/conftest.${OBJEXT-o}
3545
 
    am__minus_obj="-o $am__obj"
3546
 
    case $depmode in
3547
 
    gcc)
3548
 
      # This depmode causes a compiler race in universal mode.
3549
 
      test "$am__universal" = false || continue
3550
 
      ;;
3551
 
    nosideeffect)
3552
 
      # after this tag, mechanisms are not by side-effect, so they'll
3553
 
      # only be used when explicitly requested
3554
 
      if test "x$enable_dependency_tracking" = xyes; then
3555
 
        continue
3556
 
      else
3557
 
        break
3558
 
      fi
3559
 
      ;;
3560
 
    msvisualcpp | msvcmsys)
3561
 
      # This compiler won't grok `-c -o', but also, the minuso test has
3562
 
      # not run yet.  These depmodes are late enough in the game, and
3563
 
      # so weak that their functioning should not be impacted.
3564
 
      am__obj=conftest.${OBJEXT-o}
3565
 
      am__minus_obj=
3566
 
      ;;
3567
 
    none) break ;;
3568
 
    esac
3569
 
    if depmode=$depmode \
3570
 
       source=sub/conftest.c object=$am__obj \
3571
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
3572
 
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
3573
 
         >/dev/null 2>conftest.err &&
3574
 
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
3575
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
3576
 
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
3577
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
3578
 
      # icc doesn't choke on unknown options, it will just issue warnings
3579
 
      # or remarks (even with -Werror).  So we grep stderr for any message
3580
 
      # that says an option was ignored or not supported.
3581
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
3582
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
3583
 
      # The diagnosis changed in icc 8.0:
3584
 
      #   icc: Command line remark: option '-MP' not supported
3585
 
      if (grep 'ignoring option' conftest.err ||
3586
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
3587
 
        am_cv_CXX_dependencies_compiler_type=$depmode
3588
 
        break
3589
 
      fi
3590
 
    fi
3591
 
  done
3592
 
 
3593
 
  cd ..
3594
 
  rm -rf conftest.dir
3595
 
else
3596
 
  am_cv_CXX_dependencies_compiler_type=none
3597
 
fi
3598
 
 
3599
 
fi
3600
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
3601
 
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
3602
 
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
3603
 
 
3604
 
 if
3605
 
  test "x$enable_dependency_tracking" != xno \
3606
 
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
3607
 
  am__fastdepCXX_TRUE=
3608
 
  am__fastdepCXX_FALSE='#'
3609
 
else
3610
 
  am__fastdepCXX_TRUE='#'
3611
 
  am__fastdepCXX_FALSE=
3612
 
fi
3613
 
 
3614
 
 
3615
 
case `pwd` in
3616
 
  *\ * | *\     *)
3617
 
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
3618
 
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
3619
 
esac
3620
 
 
3621
 
 
3622
 
 
3623
 
macro_version='2.2.6'
3624
 
macro_revision='1.3012'
3625
 
 
3626
 
 
3627
 
 
3628
 
 
3629
 
 
3630
 
 
3631
 
 
3632
 
 
3633
 
 
3634
 
 
3635
 
 
3636
 
 
3637
 
 
3638
 
ltmain="$ac_aux_dir/ltmain.sh"
3639
 
 
3640
 
# Make sure we can run config.sub.
3641
 
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
3642
 
  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
3643
 
 
3644
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
3645
 
$as_echo_n "checking build system type... " >&6; }
3646
 
if test "${ac_cv_build+set}" = set; then :
3647
 
  $as_echo_n "(cached) " >&6
3648
 
else
3649
 
  ac_build_alias=$build_alias
3650
 
test "x$ac_build_alias" = x &&
3651
 
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
3652
 
test "x$ac_build_alias" = x &&
3653
 
  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
3654
 
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
3655
 
  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
3656
 
 
3657
 
fi
3658
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
3659
 
$as_echo "$ac_cv_build" >&6; }
3660
 
case $ac_cv_build in
3661
 
*-*-*) ;;
3662
 
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
3663
 
esac
3664
 
build=$ac_cv_build
3665
 
ac_save_IFS=$IFS; IFS='-'
3666
 
set x $ac_cv_build
3667
 
shift
3668
 
build_cpu=$1
3669
 
build_vendor=$2
3670
 
shift; shift
3671
 
# Remember, the first character of IFS is used to create $*,
3672
 
# except with old shells:
3673
 
build_os=$*
3674
 
IFS=$ac_save_IFS
3675
 
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
3676
 
 
3677
 
 
3678
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
3679
 
$as_echo_n "checking host system type... " >&6; }
3680
 
if test "${ac_cv_host+set}" = set; then :
3681
 
  $as_echo_n "(cached) " >&6
3682
 
else
3683
 
  if test "x$host_alias" = x; then
3684
 
  ac_cv_host=$ac_cv_build
3685
 
else
3686
 
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
3687
 
    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
3688
 
fi
3689
 
 
3690
 
fi
3691
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
3692
 
$as_echo "$ac_cv_host" >&6; }
3693
 
case $ac_cv_host in
3694
 
*-*-*) ;;
3695
 
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
3696
 
esac
3697
 
host=$ac_cv_host
3698
 
ac_save_IFS=$IFS; IFS='-'
3699
 
set x $ac_cv_host
3700
 
shift
3701
 
host_cpu=$1
3702
 
host_vendor=$2
3703
 
shift; shift
3704
 
# Remember, the first character of IFS is used to create $*,
3705
 
# except with old shells:
3706
 
host_os=$*
3707
 
IFS=$ac_save_IFS
3708
 
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
3709
 
 
3710
 
 
3711
 
ac_ext=c
3712
 
ac_cpp='$CPP $CPPFLAGS'
3713
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3714
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3715
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3716
 
if test -n "$ac_tool_prefix"; then
3717
 
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
3718
 
set dummy ${ac_tool_prefix}gcc; ac_word=$2
3719
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3720
 
$as_echo_n "checking for $ac_word... " >&6; }
3721
 
if test "${ac_cv_prog_CC+set}" = set; then :
3722
 
  $as_echo_n "(cached) " >&6
3723
 
else
3724
 
  if test -n "$CC"; then
3725
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3726
 
else
3727
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3728
 
for as_dir in $PATH
3729
 
do
3730
 
  IFS=$as_save_IFS
3731
 
  test -z "$as_dir" && as_dir=.
3732
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3733
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3734
 
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
3735
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3736
 
    break 2
3737
 
  fi
3738
 
done
3739
 
  done
3740
 
IFS=$as_save_IFS
3741
 
 
3742
 
fi
3743
 
fi
3744
 
CC=$ac_cv_prog_CC
3745
 
if test -n "$CC"; then
3746
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3747
 
$as_echo "$CC" >&6; }
3748
 
else
3749
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3750
 
$as_echo "no" >&6; }
3751
 
fi
3752
 
 
3753
 
 
3754
 
fi
3755
 
if test -z "$ac_cv_prog_CC"; then
3756
 
  ac_ct_CC=$CC
3757
 
  # Extract the first word of "gcc", so it can be a program name with args.
3758
 
set dummy gcc; ac_word=$2
3759
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3760
 
$as_echo_n "checking for $ac_word... " >&6; }
3761
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
3762
 
  $as_echo_n "(cached) " >&6
3763
 
else
3764
 
  if test -n "$ac_ct_CC"; then
3765
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3766
 
else
3767
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3768
 
for as_dir in $PATH
3769
 
do
3770
 
  IFS=$as_save_IFS
3771
 
  test -z "$as_dir" && as_dir=.
3772
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3773
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3774
 
    ac_cv_prog_ac_ct_CC="gcc"
3775
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3776
 
    break 2
3777
 
  fi
3778
 
done
3779
 
  done
3780
 
IFS=$as_save_IFS
3781
 
 
3782
 
fi
3783
 
fi
3784
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3785
 
if test -n "$ac_ct_CC"; then
3786
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3787
 
$as_echo "$ac_ct_CC" >&6; }
3788
 
else
3789
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3790
 
$as_echo "no" >&6; }
3791
 
fi
3792
 
 
3793
 
  if test "x$ac_ct_CC" = x; then
3794
 
    CC=""
3795
 
  else
3796
 
    case $cross_compiling:$ac_tool_warned in
3797
 
yes:)
3798
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3799
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3800
 
ac_tool_warned=yes ;;
3801
 
esac
3802
 
    CC=$ac_ct_CC
3803
 
  fi
3804
 
else
3805
 
  CC="$ac_cv_prog_CC"
3806
 
fi
3807
 
 
3808
 
if test -z "$CC"; then
3809
 
          if test -n "$ac_tool_prefix"; then
3810
 
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3811
 
set dummy ${ac_tool_prefix}cc; ac_word=$2
3812
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3813
 
$as_echo_n "checking for $ac_word... " >&6; }
3814
 
if test "${ac_cv_prog_CC+set}" = set; then :
3815
 
  $as_echo_n "(cached) " >&6
3816
 
else
3817
 
  if test -n "$CC"; then
3818
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3819
 
else
3820
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3821
 
for as_dir in $PATH
3822
 
do
3823
 
  IFS=$as_save_IFS
3824
 
  test -z "$as_dir" && as_dir=.
3825
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3826
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3827
 
    ac_cv_prog_CC="${ac_tool_prefix}cc"
3828
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3829
 
    break 2
3830
 
  fi
3831
 
done
3832
 
  done
3833
 
IFS=$as_save_IFS
3834
 
 
3835
 
fi
3836
 
fi
3837
 
CC=$ac_cv_prog_CC
3838
 
if test -n "$CC"; then
3839
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3840
 
$as_echo "$CC" >&6; }
3841
 
else
3842
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3843
 
$as_echo "no" >&6; }
3844
 
fi
3845
 
 
3846
 
 
3847
 
  fi
3848
 
fi
3849
 
if test -z "$CC"; then
3850
 
  # Extract the first word of "cc", so it can be a program name with args.
3851
 
set dummy cc; ac_word=$2
3852
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3853
 
$as_echo_n "checking for $ac_word... " >&6; }
3854
 
if test "${ac_cv_prog_CC+set}" = set; then :
3855
 
  $as_echo_n "(cached) " >&6
3856
 
else
3857
 
  if test -n "$CC"; then
3858
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3859
 
else
3860
 
  ac_prog_rejected=no
3861
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3862
 
for as_dir in $PATH
3863
 
do
3864
 
  IFS=$as_save_IFS
3865
 
  test -z "$as_dir" && as_dir=.
3866
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3867
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3868
 
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3869
 
       ac_prog_rejected=yes
3870
 
       continue
3871
 
     fi
3872
 
    ac_cv_prog_CC="cc"
3873
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3874
 
    break 2
3875
 
  fi
3876
 
done
3877
 
  done
3878
 
IFS=$as_save_IFS
3879
 
 
3880
 
if test $ac_prog_rejected = yes; then
3881
 
  # We found a bogon in the path, so make sure we never use it.
3882
 
  set dummy $ac_cv_prog_CC
3883
 
  shift
3884
 
  if test $# != 0; then
3885
 
    # We chose a different compiler from the bogus one.
3886
 
    # However, it has the same basename, so the bogon will be chosen
3887
 
    # first if we set CC to just the basename; use the full file name.
3888
 
    shift
3889
 
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3890
 
  fi
3891
 
fi
3892
 
fi
3893
 
fi
3894
 
CC=$ac_cv_prog_CC
3895
 
if test -n "$CC"; then
3896
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3897
 
$as_echo "$CC" >&6; }
3898
 
else
3899
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3900
 
$as_echo "no" >&6; }
3901
 
fi
3902
 
 
3903
 
 
3904
 
fi
3905
 
if test -z "$CC"; then
3906
 
  if test -n "$ac_tool_prefix"; then
3907
 
  for ac_prog in cl.exe
3908
 
  do
3909
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3910
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3911
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3912
 
$as_echo_n "checking for $ac_word... " >&6; }
3913
 
if test "${ac_cv_prog_CC+set}" = set; then :
3914
 
  $as_echo_n "(cached) " >&6
3915
 
else
3916
 
  if test -n "$CC"; then
3917
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3918
 
else
3919
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3920
 
for as_dir in $PATH
3921
 
do
3922
 
  IFS=$as_save_IFS
3923
 
  test -z "$as_dir" && as_dir=.
3924
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3925
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3926
 
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3927
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3928
 
    break 2
3929
 
  fi
3930
 
done
3931
 
  done
3932
 
IFS=$as_save_IFS
3933
 
 
3934
 
fi
3935
 
fi
3936
 
CC=$ac_cv_prog_CC
3937
 
if test -n "$CC"; then
3938
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3939
 
$as_echo "$CC" >&6; }
3940
 
else
3941
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3942
 
$as_echo "no" >&6; }
3943
 
fi
3944
 
 
3945
 
 
3946
 
    test -n "$CC" && break
3947
 
  done
3948
 
fi
3949
 
if test -z "$CC"; then
3950
 
  ac_ct_CC=$CC
3951
 
  for ac_prog in cl.exe
3952
 
do
3953
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
3954
 
set dummy $ac_prog; ac_word=$2
3955
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3956
 
$as_echo_n "checking for $ac_word... " >&6; }
3957
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
3958
 
  $as_echo_n "(cached) " >&6
3959
 
else
3960
 
  if test -n "$ac_ct_CC"; then
3961
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3962
 
else
3963
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3964
 
for as_dir in $PATH
3965
 
do
3966
 
  IFS=$as_save_IFS
3967
 
  test -z "$as_dir" && as_dir=.
3968
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3969
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3970
 
    ac_cv_prog_ac_ct_CC="$ac_prog"
3971
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3972
 
    break 2
3973
 
  fi
3974
 
done
3975
 
  done
3976
 
IFS=$as_save_IFS
3977
 
 
3978
 
fi
3979
 
fi
3980
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3981
 
if test -n "$ac_ct_CC"; then
3982
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3983
 
$as_echo "$ac_ct_CC" >&6; }
3984
 
else
3985
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3986
 
$as_echo "no" >&6; }
3987
 
fi
3988
 
 
3989
 
 
3990
 
  test -n "$ac_ct_CC" && break
3991
 
done
3992
 
 
3993
 
  if test "x$ac_ct_CC" = x; then
3994
 
    CC=""
3995
 
  else
3996
 
    case $cross_compiling:$ac_tool_warned in
3997
 
yes:)
3998
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3999
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4000
 
ac_tool_warned=yes ;;
4001
 
esac
4002
 
    CC=$ac_ct_CC
4003
 
  fi
4004
 
fi
4005
 
 
4006
 
fi
4007
 
 
4008
 
 
4009
 
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4010
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4011
 
as_fn_error "no acceptable C compiler found in \$PATH
4012
 
See \`config.log' for more details." "$LINENO" 5; }
4013
 
 
4014
 
# Provide some information about the compiler.
4015
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4016
 
set X $ac_compile
4017
 
ac_compiler=$2
4018
 
for ac_option in --version -v -V -qversion; do
4019
 
  { { ac_try="$ac_compiler $ac_option >&5"
4020
 
case "(($ac_try" in
4021
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4022
 
  *) ac_try_echo=$ac_try;;
4023
 
esac
4024
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4025
 
$as_echo "$ac_try_echo"; } >&5
4026
 
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
4027
 
  ac_status=$?
4028
 
  if test -s conftest.err; then
4029
 
    sed '10a\
4030
 
... rest of stderr output deleted ...
4031
 
         10q' conftest.err >conftest.er1
4032
 
    cat conftest.er1 >&5
4033
 
    rm -f conftest.er1 conftest.err
4034
 
  fi
4035
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4036
 
  test $ac_status = 0; }
4037
 
done
4038
 
 
4039
3653
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4040
3654
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4041
3655
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4959
4573
else
4960
4574
  lt_cv_nm_interface="BSD nm"
4961
4575
  echo "int some_variable = 0;" > conftest.$ac_ext
4962
 
  (eval echo "\"\$as_me:4962: $ac_compile\"" >&5)
 
4576
  (eval echo "\"\$as_me:4576: $ac_compile\"" >&5)
4963
4577
  (eval "$ac_compile" 2>conftest.err)
4964
4578
  cat conftest.err >&5
4965
 
  (eval echo "\"\$as_me:4965: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
 
4579
  (eval echo "\"\$as_me:4579: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
4966
4580
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
4967
4581
  cat conftest.err >&5
4968
 
  (eval echo "\"\$as_me:4968: output\"" >&5)
 
4582
  (eval echo "\"\$as_me:4582: output\"" >&5)
4969
4583
  cat conftest.out >&5
4970
4584
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
4971
4585
    lt_cv_nm_interface="MS dumpbin"
6171
5785
  ;;
6172
5786
*-*-irix6*)
6173
5787
  # Find out which ABI we are using.
6174
 
  echo '#line 6174 "configure"' > conftest.$ac_ext
 
5788
  echo '#line 5788 "configure"' > conftest.$ac_ext
6175
5789
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6176
5790
  (eval $ac_compile) 2>&5
6177
5791
  ac_status=$?
7201
6815
 
7202
6816
 
7203
6817
 
7204
 
ac_ext=cpp
7205
 
ac_cpp='$CXXCPP $CPPFLAGS'
7206
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7207
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7208
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7209
 
if test -z "$CXX"; then
7210
 
  if test -n "$CCC"; then
7211
 
    CXX=$CCC
7212
 
  else
7213
 
    if test -n "$ac_tool_prefix"; then
7214
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
7215
 
  do
7216
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
7217
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
7218
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7219
 
$as_echo_n "checking for $ac_word... " >&6; }
7220
 
if test "${ac_cv_prog_CXX+set}" = set; then :
7221
 
  $as_echo_n "(cached) " >&6
7222
 
else
7223
 
  if test -n "$CXX"; then
7224
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
7225
 
else
7226
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7227
 
for as_dir in $PATH
7228
 
do
7229
 
  IFS=$as_save_IFS
7230
 
  test -z "$as_dir" && as_dir=.
7231
 
    for ac_exec_ext in '' $ac_executable_extensions; do
7232
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7233
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
7234
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7235
 
    break 2
7236
 
  fi
7237
 
done
7238
 
  done
7239
 
IFS=$as_save_IFS
7240
 
 
7241
 
fi
7242
 
fi
7243
 
CXX=$ac_cv_prog_CXX
7244
 
if test -n "$CXX"; then
7245
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
7246
 
$as_echo "$CXX" >&6; }
7247
 
else
7248
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7249
 
$as_echo "no" >&6; }
7250
 
fi
7251
 
 
7252
 
 
7253
 
    test -n "$CXX" && break
7254
 
  done
7255
 
fi
7256
 
if test -z "$CXX"; then
7257
 
  ac_ct_CXX=$CXX
7258
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
7259
 
do
7260
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
7261
 
set dummy $ac_prog; ac_word=$2
7262
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7263
 
$as_echo_n "checking for $ac_word... " >&6; }
7264
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
7265
 
  $as_echo_n "(cached) " >&6
7266
 
else
7267
 
  if test -n "$ac_ct_CXX"; then
7268
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
7269
 
else
7270
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7271
 
for as_dir in $PATH
7272
 
do
7273
 
  IFS=$as_save_IFS
7274
 
  test -z "$as_dir" && as_dir=.
7275
 
    for ac_exec_ext in '' $ac_executable_extensions; do
7276
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7277
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
7278
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7279
 
    break 2
7280
 
  fi
7281
 
done
7282
 
  done
7283
 
IFS=$as_save_IFS
7284
 
 
7285
 
fi
7286
 
fi
7287
 
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
7288
 
if test -n "$ac_ct_CXX"; then
7289
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
7290
 
$as_echo "$ac_ct_CXX" >&6; }
7291
 
else
7292
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7293
 
$as_echo "no" >&6; }
7294
 
fi
7295
 
 
7296
 
 
7297
 
  test -n "$ac_ct_CXX" && break
7298
 
done
7299
 
 
7300
 
  if test "x$ac_ct_CXX" = x; then
7301
 
    CXX="g++"
7302
 
  else
7303
 
    case $cross_compiling:$ac_tool_warned in
7304
 
yes:)
7305
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
7306
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
7307
 
ac_tool_warned=yes ;;
7308
 
esac
7309
 
    CXX=$ac_ct_CXX
7310
 
  fi
7311
 
fi
7312
 
 
7313
 
  fi
7314
 
fi
7315
 
# Provide some information about the compiler.
7316
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
7317
 
set X $ac_compile
7318
 
ac_compiler=$2
7319
 
for ac_option in --version -v -V -qversion; do
7320
 
  { { ac_try="$ac_compiler $ac_option >&5"
7321
 
case "(($ac_try" in
7322
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7323
 
  *) ac_try_echo=$ac_try;;
7324
 
esac
7325
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
7326
 
$as_echo "$ac_try_echo"; } >&5
7327
 
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
7328
 
  ac_status=$?
7329
 
  if test -s conftest.err; then
7330
 
    sed '10a\
7331
 
... rest of stderr output deleted ...
7332
 
         10q' conftest.err >conftest.er1
7333
 
    cat conftest.er1 >&5
7334
 
    rm -f conftest.er1 conftest.err
7335
 
  fi
7336
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
7337
 
  test $ac_status = 0; }
7338
 
done
7339
 
 
7340
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
7341
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
7342
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
7343
 
  $as_echo_n "(cached) " >&6
7344
 
else
7345
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7346
 
/* end confdefs.h.  */
7347
 
 
7348
 
int
7349
 
main ()
7350
 
{
7351
 
#ifndef __GNUC__
7352
 
       choke me
7353
 
#endif
7354
 
 
7355
 
  ;
7356
 
  return 0;
7357
 
}
7358
 
_ACEOF
7359
 
if ac_fn_cxx_try_compile "$LINENO"; then :
7360
 
  ac_compiler_gnu=yes
7361
 
else
7362
 
  ac_compiler_gnu=no
7363
 
fi
7364
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7365
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
7366
 
 
7367
 
fi
7368
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
7369
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
7370
 
if test $ac_compiler_gnu = yes; then
7371
 
  GXX=yes
7372
 
else
7373
 
  GXX=
7374
 
fi
7375
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
7376
 
ac_save_CXXFLAGS=$CXXFLAGS
7377
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
7378
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
7379
 
if test "${ac_cv_prog_cxx_g+set}" = set; then :
7380
 
  $as_echo_n "(cached) " >&6
7381
 
else
7382
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
7383
 
   ac_cxx_werror_flag=yes
7384
 
   ac_cv_prog_cxx_g=no
7385
 
   CXXFLAGS="-g"
7386
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7387
 
/* end confdefs.h.  */
7388
 
 
7389
 
int
7390
 
main ()
7391
 
{
7392
 
 
7393
 
  ;
7394
 
  return 0;
7395
 
}
7396
 
_ACEOF
7397
 
if ac_fn_cxx_try_compile "$LINENO"; then :
7398
 
  ac_cv_prog_cxx_g=yes
7399
 
else
7400
 
  CXXFLAGS=""
7401
 
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7402
 
/* end confdefs.h.  */
7403
 
 
7404
 
int
7405
 
main ()
7406
 
{
7407
 
 
7408
 
  ;
7409
 
  return 0;
7410
 
}
7411
 
_ACEOF
7412
 
if ac_fn_cxx_try_compile "$LINENO"; then :
7413
 
 
7414
 
else
7415
 
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
7416
 
         CXXFLAGS="-g"
7417
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7418
 
/* end confdefs.h.  */
7419
 
 
7420
 
int
7421
 
main ()
7422
 
{
7423
 
 
7424
 
  ;
7425
 
  return 0;
7426
 
}
7427
 
_ACEOF
7428
 
if ac_fn_cxx_try_compile "$LINENO"; then :
7429
 
  ac_cv_prog_cxx_g=yes
7430
 
fi
7431
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7432
 
fi
7433
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7434
 
fi
7435
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7436
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
7437
 
fi
7438
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
7439
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
7440
 
if test "$ac_test_CXXFLAGS" = set; then
7441
 
  CXXFLAGS=$ac_save_CXXFLAGS
7442
 
elif test $ac_cv_prog_cxx_g = yes; then
7443
 
  if test "$GXX" = yes; then
7444
 
    CXXFLAGS="-g -O2"
7445
 
  else
7446
 
    CXXFLAGS="-g"
7447
 
  fi
7448
 
else
7449
 
  if test "$GXX" = yes; then
7450
 
    CXXFLAGS="-O2"
7451
 
  else
7452
 
    CXXFLAGS=
7453
 
  fi
7454
 
fi
7455
 
ac_ext=c
7456
 
ac_cpp='$CPP $CPPFLAGS'
7457
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7458
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7459
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
7460
 
 
7461
 
depcc="$CXX"  am_compiler_list=
7462
 
 
7463
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
7464
 
$as_echo_n "checking dependency style of $depcc... " >&6; }
7465
 
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
7466
 
  $as_echo_n "(cached) " >&6
7467
 
else
7468
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
7469
 
  # We make a subdir and do the tests there.  Otherwise we can end up
7470
 
  # making bogus files that we don't know about and never remove.  For
7471
 
  # instance it was reported that on HP-UX the gcc test will end up
7472
 
  # making a dummy file named `D' -- because `-MD' means `put the output
7473
 
  # in D'.
7474
 
  mkdir conftest.dir
7475
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
7476
 
  # using a relative directory.
7477
 
  cp "$am_depcomp" conftest.dir
7478
 
  cd conftest.dir
7479
 
  # We will build objects and dependencies in a subdirectory because
7480
 
  # it helps to detect inapplicable dependency modes.  For instance
7481
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
7482
 
  # side effect of compilation, but ICC will put the dependencies in
7483
 
  # the current directory while Tru64 will put them in the object
7484
 
  # directory.
7485
 
  mkdir sub
7486
 
 
7487
 
  am_cv_CXX_dependencies_compiler_type=none
7488
 
  if test "$am_compiler_list" = ""; then
7489
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
7490
 
  fi
7491
 
  am__universal=false
7492
 
  case " $depcc " in #(
7493
 
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
7494
 
     esac
7495
 
 
7496
 
  for depmode in $am_compiler_list; do
7497
 
    # Setup a source with many dependencies, because some compilers
7498
 
    # like to wrap large dependency lists on column 80 (with \), and
7499
 
    # we should not choose a depcomp mode which is confused by this.
7500
 
    #
7501
 
    # We need to recreate these files for each test, as the compiler may
7502
 
    # overwrite some of them when testing with obscure command lines.
7503
 
    # This happens at least with the AIX C compiler.
7504
 
    : > sub/conftest.c
7505
 
    for i in 1 2 3 4 5 6; do
7506
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
7507
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
7508
 
      # Solaris 8's {/usr,}/bin/sh.
7509
 
      touch sub/conftst$i.h
7510
 
    done
7511
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
7512
 
 
7513
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
7514
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
7515
 
    # handle `-M -o', and we need to detect this.  Also, some Intel
7516
 
    # versions had trouble with output in subdirs
7517
 
    am__obj=sub/conftest.${OBJEXT-o}
7518
 
    am__minus_obj="-o $am__obj"
7519
 
    case $depmode in
7520
 
    gcc)
7521
 
      # This depmode causes a compiler race in universal mode.
7522
 
      test "$am__universal" = false || continue
7523
 
      ;;
7524
 
    nosideeffect)
7525
 
      # after this tag, mechanisms are not by side-effect, so they'll
7526
 
      # only be used when explicitly requested
7527
 
      if test "x$enable_dependency_tracking" = xyes; then
7528
 
        continue
7529
 
      else
7530
 
        break
7531
 
      fi
7532
 
      ;;
7533
 
    msvisualcpp | msvcmsys)
7534
 
      # This compiler won't grok `-c -o', but also, the minuso test has
7535
 
      # not run yet.  These depmodes are late enough in the game, and
7536
 
      # so weak that their functioning should not be impacted.
7537
 
      am__obj=conftest.${OBJEXT-o}
7538
 
      am__minus_obj=
7539
 
      ;;
7540
 
    none) break ;;
7541
 
    esac
7542
 
    if depmode=$depmode \
7543
 
       source=sub/conftest.c object=$am__obj \
7544
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
7545
 
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
7546
 
         >/dev/null 2>conftest.err &&
7547
 
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
7548
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
7549
 
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
7550
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
7551
 
      # icc doesn't choke on unknown options, it will just issue warnings
7552
 
      # or remarks (even with -Werror).  So we grep stderr for any message
7553
 
      # that says an option was ignored or not supported.
7554
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
7555
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
7556
 
      # The diagnosis changed in icc 8.0:
7557
 
      #   icc: Command line remark: option '-MP' not supported
7558
 
      if (grep 'ignoring option' conftest.err ||
7559
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
7560
 
        am_cv_CXX_dependencies_compiler_type=$depmode
7561
 
        break
7562
 
      fi
7563
 
    fi
7564
 
  done
7565
 
 
7566
 
  cd ..
7567
 
  rm -rf conftest.dir
7568
 
else
7569
 
  am_cv_CXX_dependencies_compiler_type=none
7570
 
fi
7571
 
 
7572
 
fi
7573
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
7574
 
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
7575
 
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
7576
 
 
7577
 
 if
7578
 
  test "x$enable_dependency_tracking" != xno \
7579
 
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
7580
 
  am__fastdepCXX_TRUE=
7581
 
  am__fastdepCXX_FALSE='#'
7582
 
else
7583
 
  am__fastdepCXX_TRUE='#'
7584
 
  am__fastdepCXX_FALSE=
7585
 
fi
7586
 
 
7587
 
 
7588
 
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
7589
 
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
7590
 
    (test "X$CXX" != "Xg++"))) ; then
7591
 
  ac_ext=cpp
7592
 
ac_cpp='$CXXCPP $CPPFLAGS'
7593
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7594
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7595
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7596
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
7597
 
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
7598
 
if test -z "$CXXCPP"; then
7599
 
  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
7600
 
  $as_echo_n "(cached) " >&6
7601
 
else
7602
 
      # Double quotes because CXXCPP needs to be expanded
7603
 
    for CXXCPP in "$CXX -E" "/lib/cpp"
7604
 
    do
7605
 
      ac_preproc_ok=false
7606
 
for ac_cxx_preproc_warn_flag in '' yes
7607
 
do
7608
 
  # Use a header file that comes with gcc, so configuring glibc
7609
 
  # with a fresh cross-compiler works.
7610
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7611
 
  # <limits.h> exists even on freestanding compilers.
7612
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
7613
 
  # not just through cpp. "Syntax error" is here to catch this case.
7614
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7615
 
/* end confdefs.h.  */
7616
 
#ifdef __STDC__
7617
 
# include <limits.h>
7618
 
#else
7619
 
# include <assert.h>
7620
 
#endif
7621
 
                     Syntax error
7622
 
_ACEOF
7623
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
7624
 
 
7625
 
else
7626
 
  # Broken: fails on valid input.
7627
 
continue
7628
 
fi
7629
 
rm -f conftest.err conftest.$ac_ext
7630
 
 
7631
 
  # OK, works on sane cases.  Now check whether nonexistent headers
7632
 
  # can be detected and how.
7633
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7634
 
/* end confdefs.h.  */
7635
 
#include <ac_nonexistent.h>
7636
 
_ACEOF
7637
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
7638
 
  # Broken: success on invalid input.
7639
 
continue
7640
 
else
7641
 
  # Passes both tests.
7642
 
ac_preproc_ok=:
7643
 
break
7644
 
fi
7645
 
rm -f conftest.err conftest.$ac_ext
7646
 
 
7647
 
done
7648
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
7649
 
rm -f conftest.err conftest.$ac_ext
7650
 
if $ac_preproc_ok; then :
7651
 
  break
7652
 
fi
7653
 
 
7654
 
    done
7655
 
    ac_cv_prog_CXXCPP=$CXXCPP
7656
 
 
7657
 
fi
7658
 
  CXXCPP=$ac_cv_prog_CXXCPP
7659
 
else
7660
 
  ac_cv_prog_CXXCPP=$CXXCPP
7661
 
fi
7662
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
7663
 
$as_echo "$CXXCPP" >&6; }
7664
 
ac_preproc_ok=false
7665
 
for ac_cxx_preproc_warn_flag in '' yes
7666
 
do
7667
 
  # Use a header file that comes with gcc, so configuring glibc
7668
 
  # with a fresh cross-compiler works.
7669
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7670
 
  # <limits.h> exists even on freestanding compilers.
7671
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
7672
 
  # not just through cpp. "Syntax error" is here to catch this case.
7673
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7674
 
/* end confdefs.h.  */
7675
 
#ifdef __STDC__
7676
 
# include <limits.h>
7677
 
#else
7678
 
# include <assert.h>
7679
 
#endif
7680
 
                     Syntax error
7681
 
_ACEOF
7682
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
7683
 
 
7684
 
else
7685
 
  # Broken: fails on valid input.
7686
 
continue
7687
 
fi
7688
 
rm -f conftest.err conftest.$ac_ext
7689
 
 
7690
 
  # OK, works on sane cases.  Now check whether nonexistent headers
7691
 
  # can be detected and how.
7692
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7693
 
/* end confdefs.h.  */
7694
 
#include <ac_nonexistent.h>
7695
 
_ACEOF
7696
 
if ac_fn_cxx_try_cpp "$LINENO"; then :
7697
 
  # Broken: success on invalid input.
7698
 
continue
7699
 
else
7700
 
  # Passes both tests.
7701
 
ac_preproc_ok=:
7702
 
break
7703
 
fi
7704
 
rm -f conftest.err conftest.$ac_ext
7705
 
 
7706
 
done
7707
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
7708
 
rm -f conftest.err conftest.$ac_ext
7709
 
if $ac_preproc_ok; then :
7710
 
 
7711
 
else
7712
 
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7713
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7714
 
_lt_caught_CXX_error=yes; }
7715
 
fi
7716
 
 
7717
 
ac_ext=c
7718
 
ac_cpp='$CPP $CPPFLAGS'
7719
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7720
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7721
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
7722
 
 
7723
 
else
7724
 
  _lt_caught_CXX_error=yes
7725
 
fi
7726
 
 
7727
 
 
7728
 
 
7729
 
 
7730
 
 
7731
6818
# Set options
7732
6819
 
7733
6820
 
8228
7315
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8229
7316
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8230
7317
   -e 's:$: $lt_compiler_flag:'`
8231
 
   (eval echo "\"\$as_me:8231: $lt_compile\"" >&5)
 
7318
   (eval echo "\"\$as_me:7318: $lt_compile\"" >&5)
8232
7319
   (eval "$lt_compile" 2>conftest.err)
8233
7320
   ac_status=$?
8234
7321
   cat conftest.err >&5
8235
 
   echo "$as_me:8235: \$? = $ac_status" >&5
 
7322
   echo "$as_me:7322: \$? = $ac_status" >&5
8236
7323
   if (exit $ac_status) && test -s "$ac_outfile"; then
8237
7324
     # The compiler can only warn and ignore the option if not recognized
8238
7325
     # So say no if there are warnings other than the usual output.
8567
7654
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8568
7655
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8569
7656
   -e 's:$: $lt_compiler_flag:'`
8570
 
   (eval echo "\"\$as_me:8570: $lt_compile\"" >&5)
 
7657
   (eval echo "\"\$as_me:7657: $lt_compile\"" >&5)
8571
7658
   (eval "$lt_compile" 2>conftest.err)
8572
7659
   ac_status=$?
8573
7660
   cat conftest.err >&5
8574
 
   echo "$as_me:8574: \$? = $ac_status" >&5
 
7661
   echo "$as_me:7661: \$? = $ac_status" >&5
8575
7662
   if (exit $ac_status) && test -s "$ac_outfile"; then
8576
7663
     # The compiler can only warn and ignore the option if not recognized
8577
7664
     # So say no if there are warnings other than the usual output.
8672
7759
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8673
7760
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8674
7761
   -e 's:$: $lt_compiler_flag:'`
8675
 
   (eval echo "\"\$as_me:8675: $lt_compile\"" >&5)
 
7762
   (eval echo "\"\$as_me:7762: $lt_compile\"" >&5)
8676
7763
   (eval "$lt_compile" 2>out/conftest.err)
8677
7764
   ac_status=$?
8678
7765
   cat out/conftest.err >&5
8679
 
   echo "$as_me:8679: \$? = $ac_status" >&5
 
7766
   echo "$as_me:7766: \$? = $ac_status" >&5
8680
7767
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8681
7768
   then
8682
7769
     # The compiler can only warn and ignore the option if not recognized
8727
7814
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8728
7815
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8729
7816
   -e 's:$: $lt_compiler_flag:'`
8730
 
   (eval echo "\"\$as_me:8730: $lt_compile\"" >&5)
 
7817
   (eval echo "\"\$as_me:7817: $lt_compile\"" >&5)
8731
7818
   (eval "$lt_compile" 2>out/conftest.err)
8732
7819
   ac_status=$?
8733
7820
   cat out/conftest.err >&5
8734
 
   echo "$as_me:8734: \$? = $ac_status" >&5
 
7821
   echo "$as_me:7821: \$? = $ac_status" >&5
8735
7822
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8736
7823
   then
8737
7824
     # The compiler can only warn and ignore the option if not recognized
11110
10197
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11111
10198
  lt_status=$lt_dlunknown
11112
10199
  cat > conftest.$ac_ext <<_LT_EOF
11113
 
#line 11113 "configure"
 
10200
#line 10200 "configure"
11114
10201
#include "confdefs.h"
11115
10202
 
11116
10203
#if HAVE_DLFCN_H
11206
10293
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11207
10294
  lt_status=$lt_dlunknown
11208
10295
  cat > conftest.$ac_ext <<_LT_EOF
11209
 
#line 11209 "configure"
 
10296
#line 10296 "configure"
11210
10297
#include "confdefs.h"
11211
10298
 
11212
10299
#if HAVE_DLFCN_H
11414
10501
CC="$lt_save_CC"
11415
10502
 
11416
10503
 
 
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
 
11417
11436
ac_ext=cpp
11418
11437
ac_cpp='$CXXCPP $CPPFLAGS'
11419
11438
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13162
13181
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13163
13182
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13164
13183
   -e 's:$: $lt_compiler_flag:'`
13165
 
   (eval echo "\"\$as_me:13165: $lt_compile\"" >&5)
 
13184
   (eval echo "\"\$as_me:13184: $lt_compile\"" >&5)
13166
13185
   (eval "$lt_compile" 2>conftest.err)
13167
13186
   ac_status=$?
13168
13187
   cat conftest.err >&5
13169
 
   echo "$as_me:13169: \$? = $ac_status" >&5
 
13188
   echo "$as_me:13188: \$? = $ac_status" >&5
13170
13189
   if (exit $ac_status) && test -s "$ac_outfile"; then
13171
13190
     # The compiler can only warn and ignore the option if not recognized
13172
13191
     # So say no if there are warnings other than the usual output.
13261
13280
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13262
13281
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13263
13282
   -e 's:$: $lt_compiler_flag:'`
13264
 
   (eval echo "\"\$as_me:13264: $lt_compile\"" >&5)
 
13283
   (eval echo "\"\$as_me:13283: $lt_compile\"" >&5)
13265
13284
   (eval "$lt_compile" 2>out/conftest.err)
13266
13285
   ac_status=$?
13267
13286
   cat out/conftest.err >&5
13268
 
   echo "$as_me:13268: \$? = $ac_status" >&5
 
13287
   echo "$as_me:13287: \$? = $ac_status" >&5
13269
13288
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13270
13289
   then
13271
13290
     # The compiler can only warn and ignore the option if not recognized
13313
13332
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13314
13333
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13315
13334
   -e 's:$: $lt_compiler_flag:'`
13316
 
   (eval echo "\"\$as_me:13316: $lt_compile\"" >&5)
 
13335
   (eval echo "\"\$as_me:13335: $lt_compile\"" >&5)
13317
13336
   (eval "$lt_compile" 2>out/conftest.err)
13318
13337
   ac_status=$?
13319
13338
   cat out/conftest.err >&5
13320
 
   echo "$as_me:13320: \$? = $ac_status" >&5
 
13339
   echo "$as_me:13339: \$? = $ac_status" >&5
13321
13340
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13322
13341
   then
13323
13342
     # The compiler can only warn and ignore the option if not recognized
14263
14282
 
14264
14283
 
14265
14284
 
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
14532
14528
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
14533
14529
  as_fn_error "conditional \"am__fastdepCC\" was never defined.
14534
14530
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14537
14533
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
14538
14534
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14539
14535
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