/sqlite3cc

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

« back to all changes in this revision

Viewing changes to configure

  • Committer: edam
  • Date: 2010-07-29 20:56:19 UTC
  • Revision ID: edam@waxworlds.org-20100729205619-a9yo4uzu647nvnsj
- renamed database to connection to better identify what it is (would database_connection be better though?)
- moved basic_statement and basic_transaction to sqlite::detail
- made sqlite::threadsafe() return the threading mode int, not a bool
- renamed row::index() to row_number() so it isn't confused with column index
- added typedef for deferred_transaction
- added early rollback method to transaction_guard
- allowed transaction_guard::~transaction_guard() to throw exceptions, since when it needs to, we're really screwed anyway
- bugfix: query::reset() didn't reset the internal row counter
- added query::num_results()
- added docs/design-notes
- reimplemented query::iterator so that increment() (which performs a step() on the query) now caches the returned row to be returned during dereference() (previously it stashed details and returned new row!?)
- bugfix: resetting active queries during rollbacks would hang!

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
2
# Guess values for system-dependent variables and create Makefiles.
3
 
# Generated by GNU Autoconf 2.64 for sqlite3cc 0.1.0.
 
3
# Generated by GNU Autoconf 2.65 for sqlite3cc 0.1.0.
4
4
#
5
5
# Report bugs to <edam@waxworlds.org>.
6
6
#
 
7
#
7
8
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
8
 
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
9
 
# Foundation, Inc.
 
9
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
 
10
# Inc.
 
11
#
10
12
#
11
13
# This configure script is free software; the Free Software Foundation
12
14
# gives unlimited permission to copy, distribute and modify it.
676
678
 
677
679
 
678
680
 
679
 
exec 7<&0 </dev/null 6>&1
 
681
test -n "$DJDIR" || exec 7<&0 </dev/null
 
682
exec 6>&1
680
683
 
681
684
# Name of the host.
682
685
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
701
704
PACKAGE_VERSION='0.1.0'
702
705
PACKAGE_STRING='sqlite3cc 0.1.0'
703
706
PACKAGE_BUGREPORT='edam@waxworlds.org'
704
 
PACKAGE_URL=''
 
707
PACKAGE_URL='http://www.waxworlds.org/edam/software/sqlite3cc'
705
708
 
706
 
ac_unique_file="src/database.cc"
 
709
ac_unique_file="src/command.cc"
707
710
# Factoring default headers for most tests.
708
711
ac_includes_default="\
709
712
#include <stdio.h>
745
748
LTLIBOBJS
746
749
LIBOBJS
747
750
CXXCPP
 
751
am__fastdepCXX_FALSE
 
752
am__fastdepCXX_TRUE
 
753
CXXDEPMODE
 
754
ac_ct_CXX
 
755
CXXFLAGS
 
756
CXX
748
757
CPP
749
758
OTOOL64
750
759
OTOOL
767
776
am__fastdepCC_FALSE
768
777
am__fastdepCC_TRUE
769
778
CCDEPMODE
 
779
AMDEPBACKSLASH
 
780
AMDEP_FALSE
 
781
AMDEP_TRUE
 
782
am__quote
 
783
am__include
 
784
DEPDIR
 
785
OBJEXT
 
786
EXEEXT
770
787
ac_ct_CC
 
788
CPPFLAGS
 
789
LDFLAGS
771
790
CFLAGS
772
791
CC
773
792
host_os
779
798
build_cpu
780
799
build
781
800
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
801
am__untar
799
802
am__tar
800
803
AMTAR
818
821
INSTALL_DATA
819
822
INSTALL_SCRIPT
820
823
INSTALL_PROGRAM
 
824
LIBSQLITE3CC_INTERFACE
821
825
target_alias
822
826
host_alias
823
827
build_alias
859
863
ac_subst_files=''
860
864
ac_user_opts='
861
865
enable_option_checking
862
 
enable_dependency_tracking
863
866
enable_shared
864
867
enable_static
865
868
with_pic
866
869
enable_fast_install
 
870
enable_dependency_tracking
867
871
with_gnu_ld
868
872
enable_libtool_lock
869
873
'
870
874
      ac_precious_vars='build_alias
871
875
host_alias
872
876
target_alias
873
 
CXX
874
 
CXXFLAGS
 
877
CC
 
878
CFLAGS
875
879
LDFLAGS
876
880
LIBS
877
881
CPPFLAGS
 
882
CPP
 
883
CXX
 
884
CXXFLAGS
878
885
CCC
879
 
CC
880
 
CFLAGS
881
 
CPP
882
886
CXXCPP'
883
887
 
884
888
 
1499
1503
  --disable-option-checking  ignore unrecognized --enable/--with options
1500
1504
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1501
1505
  --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
1506
  --enable-shared[=PKGS]  build shared libraries [default=yes]
1505
1507
  --enable-static[=PKGS]  build static libraries [default=yes]
1506
1508
  --enable-fast-install[=PKGS]
1507
1509
                          optimize for fast installation [default=yes]
 
1510
  --disable-dependency-tracking  speeds up one-time build
 
1511
  --enable-dependency-tracking   do not reject slow dependency extractors
1508
1512
  --disable-libtool-lock  avoid locking (might break parallel builds)
1509
1513
 
1510
1514
Optional Packages:
1515
1519
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1516
1520
 
1517
1521
Some influential environment variables:
1518
 
  CXX         C++ compiler command
1519
 
  CXXFLAGS    C++ compiler flags
 
1522
  CC          C compiler command
 
1523
  CFLAGS      C compiler flags
1520
1524
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1521
1525
              nonstandard directory <lib dir>
1522
1526
  LIBS        libraries to pass to the linker, e.g. -l<library>
1523
 
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
 
1527
  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1524
1528
              you have headers in a nonstandard directory <include dir>
1525
 
  CC          C compiler command
1526
 
  CFLAGS      C compiler flags
1527
1529
  CPP         C preprocessor
 
1530
  CXX         C++ compiler command
 
1531
  CXXFLAGS    C++ compiler flags
1528
1532
  CXXCPP      C++ preprocessor
1529
1533
 
1530
1534
Use these variables to override the choices made by `configure' or to help
1531
1535
it to find libraries and programs with nonstandard names/locations.
1532
1536
 
1533
1537
Report bugs to <edam@waxworlds.org>.
 
1538
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>.
1534
1539
_ACEOF
1535
1540
ac_status=$?
1536
1541
fi
1594
1599
if $ac_init_version; then
1595
1600
  cat <<\_ACEOF
1596
1601
sqlite3cc configure 0.1.0
1597
 
generated by GNU Autoconf 2.64
 
1602
generated by GNU Autoconf 2.65
1598
1603
 
1599
1604
Copyright (C) 2009 Free Software Foundation, Inc.
1600
1605
This configure script is free software; the Free Software Foundation
1607
1612
## Autoconf initialization. ##
1608
1613
## ------------------------ ##
1609
1614
 
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
1615
# ac_fn_c_try_compile LINENO
1649
1616
# --------------------------
1650
1617
# Try to compile conftest.$ac_ext, and return whether this succeeded.
1679
1646
        ac_retval=1
1680
1647
fi
1681
1648
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1682
 
  return $ac_retval
 
1649
  as_fn_set_status $ac_retval
1683
1650
 
1684
1651
} # ac_fn_c_try_compile
1685
1652
 
1725
1692
  # left behind by Apple's compiler.  We do this before executing the actions.
1726
1693
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1727
1694
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1728
 
  return $ac_retval
 
1695
  as_fn_set_status $ac_retval
1729
1696
 
1730
1697
} # ac_fn_c_try_link
1731
1698
 
1793
1760
    ac_retval=1
1794
1761
fi
1795
1762
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1796
 
  return $ac_retval
 
1763
  as_fn_set_status $ac_retval
1797
1764
 
1798
1765
} # ac_fn_c_try_cpp
1799
1766
 
1835
1802
fi
1836
1803
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1837
1804
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1838
 
  return $ac_retval
 
1805
  as_fn_set_status $ac_retval
1839
1806
 
1840
1807
} # ac_fn_c_try_run
1841
1808
 
1906
1873
 
1907
1874
} # ac_fn_c_check_func
1908
1875
 
 
1876
# ac_fn_cxx_try_compile LINENO
 
1877
# ----------------------------
 
1878
# Try to compile conftest.$ac_ext, and return whether this succeeded.
 
1879
ac_fn_cxx_try_compile ()
 
1880
{
 
1881
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
 
1882
  rm -f conftest.$ac_objext
 
1883
  if { { ac_try="$ac_compile"
 
1884
case "(($ac_try" in
 
1885
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
1886
  *) ac_try_echo=$ac_try;;
 
1887
esac
 
1888
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
1889
$as_echo "$ac_try_echo"; } >&5
 
1890
  (eval "$ac_compile") 2>conftest.err
 
1891
  ac_status=$?
 
1892
  if test -s conftest.err; then
 
1893
    grep -v '^ *+' conftest.err >conftest.er1
 
1894
    cat conftest.er1 >&5
 
1895
    mv -f conftest.er1 conftest.err
 
1896
  fi
 
1897
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
1898
  test $ac_status = 0; } && {
 
1899
         test -z "$ac_cxx_werror_flag" ||
 
1900
         test ! -s conftest.err
 
1901
       } && test -s conftest.$ac_objext; then :
 
1902
  ac_retval=0
 
1903
else
 
1904
  $as_echo "$as_me: failed program was:" >&5
 
1905
sed 's/^/| /' conftest.$ac_ext >&5
 
1906
 
 
1907
        ac_retval=1
 
1908
fi
 
1909
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
1910
  as_fn_set_status $ac_retval
 
1911
 
 
1912
} # ac_fn_cxx_try_compile
 
1913
 
1909
1914
# ac_fn_cxx_try_cpp LINENO
1910
1915
# ------------------------
1911
1916
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1939
1944
    ac_retval=1
1940
1945
fi
1941
1946
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1942
 
  return $ac_retval
 
1947
  as_fn_set_status $ac_retval
1943
1948
 
1944
1949
} # ac_fn_cxx_try_cpp
1945
1950
 
1985
1990
  # left behind by Apple's compiler.  We do this before executing the actions.
1986
1991
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1987
1992
  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1988
 
  return $ac_retval
 
1993
  as_fn_set_status $ac_retval
1989
1994
 
1990
1995
} # ac_fn_cxx_try_link
1991
1996
 
2086
2091
running configure, to aid debugging if configure makes a mistake.
2087
2092
 
2088
2093
It was created by sqlite3cc $as_me 0.1.0, which was
2089
 
generated by GNU Autoconf 2.64.  Invocation command line was
 
2094
generated by GNU Autoconf 2.65.  Invocation command line was
2090
2095
 
2091
2096
  $ $0 $@
2092
2097
 
2339
2344
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2340
2345
do
2341
2346
  test "x$ac_site_file" = xNONE && continue
2342
 
  if test -r "$ac_site_file"; then
 
2347
  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2343
2348
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2344
2349
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
2345
2350
    sed 's/^/| /' "$ac_site_file" >&5
2348
2353
done
2349
2354
 
2350
2355
if test -r "$cache_file"; then
2351
 
  # Some versions of bash will fail to source /dev/null (special
2352
 
  # files actually), so we avoid doing that.
2353
 
  if test -f "$cache_file"; then
 
2356
  # Some versions of bash will fail to source /dev/null (special files
 
2357
  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
 
2358
  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2354
2359
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2355
2360
$as_echo "$as_me: loading cache $cache_file" >&6;}
2356
2361
    case $cache_file in
2432
2437
ac_compiler_gnu=$ac_cv_c_compiler_gnu
2433
2438
 
2434
2439
 
 
2440
LIBSQLITE3CC_INTERFACE=0:0:0
 
2441
 
2435
2442
ac_aux_dir=
2436
2443
for ac_dir in build-aux "$srcdir"/build-aux; do
2437
2444
  for ac_t in install-sh install.sh shtool; do
2770
2777
 
2771
2778
fi
2772
2779
 
 
2780
  test -d ./--version && rmdir ./--version
2773
2781
  if test "${ac_cv_path_mkdir+set}" = set; then
2774
2782
    MKDIR_P="$ac_cv_path_mkdir -p"
2775
2783
  else
2777
2785
    # value for MKDIR_P within a source directory, because that will
2778
2786
    # break other packages using the cache if that directory is
2779
2787
    # removed, or if the value is a relative name.
2780
 
    test -d ./--version && rmdir ./--version
2781
2788
    MKDIR_P="$ac_install_sh -d"
2782
2789
  fi
2783
2790
fi
2937
2944
 
2938
2945
ac_config_headers="$ac_config_headers config.h"
2939
2946
 
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
2950
 
  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
2953
 
  do
2954
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2955
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2956
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957
 
$as_echo_n "checking for $ac_word... " >&6; }
2958
 
if test "${ac_cv_prog_CXX+set}" = set; then :
2959
 
  $as_echo_n "(cached) " >&6
2960
 
else
2961
 
  if test -n "$CXX"; then
2962
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2963
 
else
2964
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2965
 
for as_dir in $PATH
2966
 
do
2967
 
  IFS=$as_save_IFS
2968
 
  test -z "$as_dir" && as_dir=.
2969
 
    for ac_exec_ext in '' $ac_executable_extensions; do
2970
 
  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"
2972
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973
 
    break 2
2974
 
  fi
2975
 
done
2976
 
  done
2977
 
IFS=$as_save_IFS
2978
 
 
2979
 
fi
2980
 
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; }
2985
 
else
2986
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987
 
$as_echo "no" >&6; }
2988
 
fi
2989
 
 
2990
 
 
2991
 
    test -n "$CXX" && break
2992
 
  done
2993
 
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
2997
 
do
2998
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2999
 
set dummy $ac_prog; ac_word=$2
3000
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3001
 
$as_echo_n "checking for $ac_word... " >&6; }
3002
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3003
 
  $as_echo_n "(cached) " >&6
3004
 
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.
3007
 
else
3008
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3009
 
for as_dir in $PATH
3010
 
do
3011
 
  IFS=$as_save_IFS
3012
 
  test -z "$as_dir" && as_dir=.
3013
 
    for ac_exec_ext in '' $ac_executable_extensions; do
3014
 
  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"
3016
 
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3017
 
    break 2
3018
 
  fi
3019
 
done
3020
 
  done
3021
 
IFS=$as_save_IFS
3022
 
 
3023
 
fi
3024
 
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; }
3029
 
else
3030
 
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3031
 
$as_echo "no" >&6; }
3032
 
fi
3033
 
 
3034
 
 
3035
 
  test -n "$ac_ct_CXX" && break
3036
 
done
3037
 
 
3038
 
  if test "x$ac_ct_CXX" = x; then
3039
 
    CXX="g++"
3040
 
  else
3041
 
    case $cross_compiling:$ac_tool_warned in
3042
 
yes:)
3043
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3044
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3045
 
ac_tool_warned=yes ;;
3046
 
esac
3047
 
    CXX=$ac_ct_CXX
3048
 
  fi
3049
 
fi
3050
 
 
3051
 
  fi
3052
 
fi
3053
 
# Provide some information about the compiler.
3054
 
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3055
 
set X $ac_compile
3056
 
ac_compiler=$2
3057
 
for ac_option in --version -v -V -qversion; do
3058
 
  { { ac_try="$ac_compiler $ac_option >&5"
3059
 
case "(($ac_try" in
3060
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3061
 
  *) ac_try_echo=$ac_try;;
3062
 
esac
3063
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3064
 
$as_echo "$ac_try_echo"; } >&5
3065
 
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3066
 
  ac_status=$?
3067
 
  if test -s conftest.err; then
3068
 
    sed '10a\
3069
 
... rest of stderr output deleted ...
3070
 
         10q' conftest.err >conftest.er1
3071
 
    cat conftest.er1 >&5
3072
 
    rm -f conftest.er1 conftest.err
3073
 
  fi
3074
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3075
 
  test $ac_status = 0; }
3076
 
done
3077
 
 
3078
 
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3079
 
/* end confdefs.h.  */
3080
 
#include <stdio.h>
3081
 
int
3082
 
main ()
3083
 
{
3084
 
FILE *f = fopen ("conftest.out", "w");
3085
 
 return ferror (f) || fclose (f) != 0;
3086
 
 
3087
 
  ;
3088
 
  return 0;
3089
 
}
3090
 
_ACEOF
3091
 
ac_clean_files_save=$ac_clean_files
3092
 
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out conftest.out"
3093
 
# Try to create an executable without -o first, disregard a.out.
3094
 
# It will help us diagnose broken compilers, and finding out an intuition
3095
 
# 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; }
3098
 
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3099
 
 
3100
 
# The possible output files:
3101
 
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3102
 
 
3103
 
ac_rmfiles=
3104
 
for ac_file in $ac_files
3105
 
do
3106
 
  case $ac_file in
3107
 
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3108
 
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3109
 
  esac
3110
 
done
3111
 
rm -f $ac_rmfiles
3112
 
 
3113
 
if { { ac_try="$ac_link_default"
3114
 
case "(($ac_try" in
3115
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3116
 
  *) ac_try_echo=$ac_try;;
3117
 
esac
3118
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3119
 
$as_echo "$ac_try_echo"; } >&5
3120
 
  (eval "$ac_link_default") 2>&5
3121
 
  ac_status=$?
3122
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3123
 
  test $ac_status = 0; }; then :
3124
 
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3125
 
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3126
 
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
3127
 
# so that the user can short-circuit this test for compilers unknown to
3128
 
# Autoconf.
3129
 
for ac_file in $ac_files ''
3130
 
do
3131
 
  test -f "$ac_file" || continue
3132
 
  case $ac_file in
3133
 
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3134
 
        ;;
3135
 
    [ab].out )
3136
 
        # We found the default executable, but exeext='' is most
3137
 
        # certainly right.
3138
 
        break;;
3139
 
    *.* )
3140
 
        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3141
 
        then :; else
3142
 
           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3143
 
        fi
3144
 
        # We set ac_cv_exeext here because the later test for it is not
3145
 
        # safe: cross compilers may not add the suffix if given an `-o'
3146
 
        # argument, so we may need to know it at that point already.
3147
 
        # Even if this section looks crufty: it has the advantage of
3148
 
        # actually working.
3149
 
        break;;
3150
 
    * )
3151
 
        break;;
3152
 
  esac
3153
 
done
3154
 
test "$ac_cv_exeext" = no && ac_cv_exeext=
3155
 
 
3156
 
else
3157
 
  ac_file=''
3158
 
fi
3159
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3160
 
$as_echo "$ac_file" >&6; }
3161
 
if test -z "$ac_file"; then :
3162
 
  $as_echo "$as_me: failed program was:" >&5
3163
 
sed 's/^/| /' conftest.$ac_ext >&5
3164
 
 
3165
 
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3166
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3167
 
{ as_fn_set_status 77
3168
 
as_fn_error "C++ compiler cannot create executables
3169
 
See \`config.log' for more details." "$LINENO" 5; }; }
3170
 
fi
3171
 
ac_exeext=$ac_cv_exeext
3172
 
 
3173
 
# Check that the compiler produces executables we can run.  If not, either
3174
 
# 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; }
3177
 
# If not cross compiling, check that we can run a simple program.
3178
 
if test "$cross_compiling" != yes; then
3179
 
  if { ac_try='./$ac_file'
3180
 
  { { case "(($ac_try" in
3181
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3182
 
  *) ac_try_echo=$ac_try;;
3183
 
esac
3184
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3185
 
$as_echo "$ac_try_echo"; } >&5
3186
 
  (eval "$ac_try") 2>&5
3187
 
  ac_status=$?
3188
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3189
 
  test $ac_status = 0; }; }; then
3190
 
    cross_compiling=no
3191
 
  else
3192
 
    if test "$cross_compiling" = maybe; then
3193
 
        cross_compiling=yes
3194
 
    else
3195
 
        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3196
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3197
 
as_fn_error "cannot run C++ compiled programs.
3198
 
If you meant to cross compile, use \`--host'.
3199
 
See \`config.log' for more details." "$LINENO" 5; }
3200
 
    fi
3201
 
  fi
3202
 
fi
3203
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3204
 
$as_echo "yes" >&6; }
3205
 
 
3206
 
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out conftest.out
3207
 
ac_clean_files=$ac_clean_files_save
3208
 
# Check that the compiler produces executables we can run.  If not, either
3209
 
# the compiler is broken, or we cross compile.
3210
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3211
 
$as_echo_n "checking whether we are cross compiling... " >&6; }
3212
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3213
 
$as_echo "$cross_compiling" >&6; }
3214
 
 
3215
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3216
 
$as_echo_n "checking for suffix of executables... " >&6; }
3217
 
if { { ac_try="$ac_link"
3218
 
case "(($ac_try" in
3219
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3220
 
  *) ac_try_echo=$ac_try;;
3221
 
esac
3222
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3223
 
$as_echo "$ac_try_echo"; } >&5
3224
 
  (eval "$ac_link") 2>&5
3225
 
  ac_status=$?
3226
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3227
 
  test $ac_status = 0; }; then :
3228
 
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3229
 
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3230
 
# work properly (i.e., refer to `conftest.exe'), while it won't with
3231
 
# `rm'.
3232
 
for ac_file in conftest.exe conftest conftest.*; do
3233
 
  test -f "$ac_file" || continue
3234
 
  case $ac_file in
3235
 
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3236
 
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3237
 
          break;;
3238
 
    * ) break;;
3239
 
  esac
3240
 
done
3241
 
else
3242
 
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3243
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3244
 
as_fn_error "cannot compute suffix of executables: cannot compile and link
3245
 
See \`config.log' for more details." "$LINENO" 5; }
3246
 
fi
3247
 
rm -f conftest$ac_cv_exeext
3248
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3249
 
$as_echo "$ac_cv_exeext" >&6; }
3250
 
 
3251
 
rm -f conftest.$ac_ext
3252
 
EXEEXT=$ac_cv_exeext
3253
 
ac_exeext=$EXEEXT
3254
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3255
 
$as_echo_n "checking for suffix of object files... " >&6; }
3256
 
if test "${ac_cv_objext+set}" = set; then :
3257
 
  $as_echo_n "(cached) " >&6
3258
 
else
3259
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3260
 
/* end confdefs.h.  */
3261
 
 
3262
 
int
3263
 
main ()
3264
 
{
3265
 
 
3266
 
  ;
3267
 
  return 0;
3268
 
}
3269
 
_ACEOF
3270
 
rm -f conftest.o conftest.obj
3271
 
if { { ac_try="$ac_compile"
3272
 
case "(($ac_try" in
3273
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3274
 
  *) ac_try_echo=$ac_try;;
3275
 
esac
3276
 
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3277
 
$as_echo "$ac_try_echo"; } >&5
3278
 
  (eval "$ac_compile") 2>&5
3279
 
  ac_status=$?
3280
 
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3281
 
  test $ac_status = 0; }; then :
3282
 
  for ac_file in conftest.o conftest.obj conftest.*; do
3283
 
  test -f "$ac_file" || continue;
3284
 
  case $ac_file in
3285
 
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3286
 
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3287
 
       break;;
3288
 
  esac
3289
 
done
3290
 
else
3291
 
  $as_echo "$as_me: failed program was:" >&5
3292
 
sed 's/^/| /' conftest.$ac_ext >&5
3293
 
 
3294
 
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3295
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3296
 
as_fn_error "cannot compute suffix of object files: cannot compile
3297
 
See \`config.log' for more details." "$LINENO" 5; }
3298
 
fi
3299
 
rm -f conftest.$ac_cv_objext conftest.$ac_ext
3300
 
fi
3301
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3302
 
$as_echo "$ac_cv_objext" >&6; }
3303
 
OBJEXT=$ac_cv_objext
3304
 
ac_objext=$OBJEXT
3305
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3306
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3307
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3308
 
  $as_echo_n "(cached) " >&6
3309
 
else
3310
 
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3311
 
/* end confdefs.h.  */
3312
 
 
3313
 
int
3314
 
main ()
3315
 
{
3316
 
#ifndef __GNUC__
3317
 
       choke me
3318
 
#endif
3319
 
 
3320
 
  ;
3321
 
  return 0;
3322
 
}
3323
 
_ACEOF
3324
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3325
 
  ac_compiler_gnu=yes
3326
 
else
3327
 
  ac_compiler_gnu=no
3328
 
fi
3329
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3330
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3331
 
 
3332
 
fi
3333
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3334
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3335
 
if test $ac_compiler_gnu = yes; then
3336
 
  GXX=yes
3337
 
else
3338
 
  GXX=
3339
 
fi
3340
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
3341
 
ac_save_CXXFLAGS=$CXXFLAGS
3342
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3343
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
3344
 
if test "${ac_cv_prog_cxx_g+set}" = set; then :
3345
 
  $as_echo_n "(cached) " >&6
3346
 
else
3347
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3348
 
   ac_cxx_werror_flag=yes
3349
 
   ac_cv_prog_cxx_g=no
3350
 
   CXXFLAGS="-g"
3351
 
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3352
 
/* end confdefs.h.  */
3353
 
 
3354
 
int
3355
 
main ()
3356
 
{
3357
 
 
3358
 
  ;
3359
 
  return 0;
3360
 
}
3361
 
_ACEOF
3362
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3363
 
  ac_cv_prog_cxx_g=yes
3364
 
else
3365
 
  CXXFLAGS=""
3366
 
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3367
 
/* end confdefs.h.  */
3368
 
 
3369
 
int
3370
 
main ()
3371
 
{
3372
 
 
3373
 
  ;
3374
 
  return 0;
3375
 
}
3376
 
_ACEOF
3377
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3378
 
 
3379
 
else
3380
 
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3381
 
         CXXFLAGS="-g"
3382
 
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3383
 
/* end confdefs.h.  */
3384
 
 
3385
 
int
3386
 
main ()
3387
 
{
3388
 
 
3389
 
  ;
3390
 
  return 0;
3391
 
}
3392
 
_ACEOF
3393
 
if ac_fn_cxx_try_compile "$LINENO"; then :
3394
 
  ac_cv_prog_cxx_g=yes
3395
 
fi
3396
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3397
 
fi
3398
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3399
 
fi
3400
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3401
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3402
 
fi
3403
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3404
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
3405
 
if test "$ac_test_CXXFLAGS" = set; then
3406
 
  CXXFLAGS=$ac_save_CXXFLAGS
3407
 
elif test $ac_cv_prog_cxx_g = yes; then
3408
 
  if test "$GXX" = yes; then
3409
 
    CXXFLAGS="-g -O2"
3410
 
  else
3411
 
    CXXFLAGS="-g"
3412
 
  fi
3413
 
else
3414
 
  if test "$GXX" = yes; then
3415
 
    CXXFLAGS="-O2"
3416
 
  else
3417
 
    CXXFLAGS=
3418
 
  fi
3419
 
fi
3420
 
ac_ext=c
3421
 
ac_cpp='$CPP $CPPFLAGS'
3422
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3423
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3424
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2947
case `pwd` in
 
2948
  *\ * | *\     *)
 
2949
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
 
2950
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
 
2951
esac
 
2952
 
 
2953
 
 
2954
 
 
2955
macro_version='2.2.6b'
 
2956
macro_revision='1.3017'
 
2957
 
 
2958
 
 
2959
 
 
2960
 
 
2961
 
 
2962
 
 
2963
 
 
2964
 
 
2965
 
 
2966
 
 
2967
 
 
2968
 
 
2969
 
 
2970
ltmain="$ac_aux_dir/ltmain.sh"
 
2971
 
 
2972
# Make sure we can run config.sub.
 
2973
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
 
2974
  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
 
2975
 
 
2976
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
 
2977
$as_echo_n "checking build system type... " >&6; }
 
2978
if test "${ac_cv_build+set}" = set; then :
 
2979
  $as_echo_n "(cached) " >&6
 
2980
else
 
2981
  ac_build_alias=$build_alias
 
2982
test "x$ac_build_alias" = x &&
 
2983
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
 
2984
test "x$ac_build_alias" = x &&
 
2985
  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
 
2986
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
 
2987
  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
 
2988
 
 
2989
fi
 
2990
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
 
2991
$as_echo "$ac_cv_build" >&6; }
 
2992
case $ac_cv_build in
 
2993
*-*-*) ;;
 
2994
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
 
2995
esac
 
2996
build=$ac_cv_build
 
2997
ac_save_IFS=$IFS; IFS='-'
 
2998
set x $ac_cv_build
 
2999
shift
 
3000
build_cpu=$1
 
3001
build_vendor=$2
 
3002
shift; shift
 
3003
# Remember, the first character of IFS is used to create $*,
 
3004
# except with old shells:
 
3005
build_os=$*
 
3006
IFS=$ac_save_IFS
 
3007
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
 
3008
 
 
3009
 
 
3010
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
 
3011
$as_echo_n "checking host system type... " >&6; }
 
3012
if test "${ac_cv_host+set}" = set; then :
 
3013
  $as_echo_n "(cached) " >&6
 
3014
else
 
3015
  if test "x$host_alias" = x; then
 
3016
  ac_cv_host=$ac_cv_build
 
3017
else
 
3018
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
 
3019
    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
 
3020
fi
 
3021
 
 
3022
fi
 
3023
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
 
3024
$as_echo "$ac_cv_host" >&6; }
 
3025
case $ac_cv_host in
 
3026
*-*-*) ;;
 
3027
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
 
3028
esac
 
3029
host=$ac_cv_host
 
3030
ac_save_IFS=$IFS; IFS='-'
 
3031
set x $ac_cv_host
 
3032
shift
 
3033
host_cpu=$1
 
3034
host_vendor=$2
 
3035
shift; shift
 
3036
# Remember, the first character of IFS is used to create $*,
 
3037
# except with old shells:
 
3038
host_os=$*
 
3039
IFS=$ac_save_IFS
 
3040
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
 
3041
 
 
3042
 
3425
3043
DEPDIR="${am__leading_dot}deps"
3426
3044
 
3427
3045
ac_config_commands="$ac_config_commands depfiles"
3484
3102
fi
3485
3103
 
3486
3104
 
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
3105
ac_ext=c
3712
3106
ac_cpp='$CPP $CPPFLAGS'
3713
3107
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4030
3424
... rest of stderr output deleted ...
4031
3425
         10q' conftest.err >conftest.er1
4032
3426
    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
 
 
 
3427
  fi
 
3428
  rm -f conftest.er1 conftest.err
 
3429
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3430
  test $ac_status = 0; }
 
3431
done
 
3432
 
 
3433
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3434
/* end confdefs.h.  */
 
3435
 
 
3436
int
 
3437
main ()
 
3438
{
 
3439
 
 
3440
  ;
 
3441
  return 0;
 
3442
}
 
3443
_ACEOF
 
3444
ac_clean_files_save=$ac_clean_files
 
3445
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
 
3446
# Try to create an executable without -o first, disregard a.out.
 
3447
# It will help us diagnose broken compilers, and finding out an intuition
 
3448
# of exeext.
 
3449
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
 
3450
$as_echo_n "checking whether the C compiler works... " >&6; }
 
3451
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
 
3452
 
 
3453
# The possible output files:
 
3454
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
 
3455
 
 
3456
ac_rmfiles=
 
3457
for ac_file in $ac_files
 
3458
do
 
3459
  case $ac_file in
 
3460
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
 
3461
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
 
3462
  esac
 
3463
done
 
3464
rm -f $ac_rmfiles
 
3465
 
 
3466
if { { ac_try="$ac_link_default"
 
3467
case "(($ac_try" in
 
3468
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3469
  *) ac_try_echo=$ac_try;;
 
3470
esac
 
3471
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
3472
$as_echo "$ac_try_echo"; } >&5
 
3473
  (eval "$ac_link_default") 2>&5
 
3474
  ac_status=$?
 
3475
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3476
  test $ac_status = 0; }; then :
 
3477
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
 
3478
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
 
3479
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
 
3480
# so that the user can short-circuit this test for compilers unknown to
 
3481
# Autoconf.
 
3482
for ac_file in $ac_files ''
 
3483
do
 
3484
  test -f "$ac_file" || continue
 
3485
  case $ac_file in
 
3486
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
 
3487
        ;;
 
3488
    [ab].out )
 
3489
        # We found the default executable, but exeext='' is most
 
3490
        # certainly right.
 
3491
        break;;
 
3492
    *.* )
 
3493
        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
 
3494
        then :; else
 
3495
           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
3496
        fi
 
3497
        # We set ac_cv_exeext here because the later test for it is not
 
3498
        # safe: cross compilers may not add the suffix if given an `-o'
 
3499
        # argument, so we may need to know it at that point already.
 
3500
        # Even if this section looks crufty: it has the advantage of
 
3501
        # actually working.
 
3502
        break;;
 
3503
    * )
 
3504
        break;;
 
3505
  esac
 
3506
done
 
3507
test "$ac_cv_exeext" = no && ac_cv_exeext=
 
3508
 
 
3509
else
 
3510
  ac_file=''
 
3511
fi
 
3512
if test -z "$ac_file"; then :
 
3513
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
3514
$as_echo "no" >&6; }
 
3515
$as_echo "$as_me: failed program was:" >&5
 
3516
sed 's/^/| /' conftest.$ac_ext >&5
 
3517
 
 
3518
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
3519
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
3520
{ as_fn_set_status 77
 
3521
as_fn_error "C compiler cannot create executables
 
3522
See \`config.log' for more details." "$LINENO" 5; }; }
 
3523
else
 
3524
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 
3525
$as_echo "yes" >&6; }
 
3526
fi
 
3527
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
 
3528
$as_echo_n "checking for C compiler default output file name... " >&6; }
 
3529
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
 
3530
$as_echo "$ac_file" >&6; }
 
3531
ac_exeext=$ac_cv_exeext
 
3532
 
 
3533
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
 
3534
ac_clean_files=$ac_clean_files_save
 
3535
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
 
3536
$as_echo_n "checking for suffix of executables... " >&6; }
 
3537
if { { ac_try="$ac_link"
 
3538
case "(($ac_try" in
 
3539
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3540
  *) ac_try_echo=$ac_try;;
 
3541
esac
 
3542
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
3543
$as_echo "$ac_try_echo"; } >&5
 
3544
  (eval "$ac_link") 2>&5
 
3545
  ac_status=$?
 
3546
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3547
  test $ac_status = 0; }; then :
 
3548
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
 
3549
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
 
3550
# work properly (i.e., refer to `conftest.exe'), while it won't with
 
3551
# `rm'.
 
3552
for ac_file in conftest.exe conftest conftest.*; do
 
3553
  test -f "$ac_file" || continue
 
3554
  case $ac_file in
 
3555
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
 
3556
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
 
3557
          break;;
 
3558
    * ) break;;
 
3559
  esac
 
3560
done
 
3561
else
 
3562
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
3563
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
3564
as_fn_error "cannot compute suffix of executables: cannot compile and link
 
3565
See \`config.log' for more details." "$LINENO" 5; }
 
3566
fi
 
3567
rm -f conftest conftest$ac_cv_exeext
 
3568
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
 
3569
$as_echo "$ac_cv_exeext" >&6; }
 
3570
 
 
3571
rm -f conftest.$ac_ext
 
3572
EXEEXT=$ac_cv_exeext
 
3573
ac_exeext=$EXEEXT
 
3574
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3575
/* end confdefs.h.  */
 
3576
#include <stdio.h>
 
3577
int
 
3578
main ()
 
3579
{
 
3580
FILE *f = fopen ("conftest.out", "w");
 
3581
 return ferror (f) || fclose (f) != 0;
 
3582
 
 
3583
  ;
 
3584
  return 0;
 
3585
}
 
3586
_ACEOF
 
3587
ac_clean_files="$ac_clean_files conftest.out"
 
3588
# Check that the compiler produces executables we can run.  If not, either
 
3589
# the compiler is broken, or we cross compile.
 
3590
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
 
3591
$as_echo_n "checking whether we are cross compiling... " >&6; }
 
3592
if test "$cross_compiling" != yes; then
 
3593
  { { ac_try="$ac_link"
 
3594
case "(($ac_try" in
 
3595
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3596
  *) ac_try_echo=$ac_try;;
 
3597
esac
 
3598
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
3599
$as_echo "$ac_try_echo"; } >&5
 
3600
  (eval "$ac_link") 2>&5
 
3601
  ac_status=$?
 
3602
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3603
  test $ac_status = 0; }
 
3604
  if { ac_try='./conftest$ac_cv_exeext'
 
3605
  { { case "(($ac_try" in
 
3606
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3607
  *) ac_try_echo=$ac_try;;
 
3608
esac
 
3609
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
3610
$as_echo "$ac_try_echo"; } >&5
 
3611
  (eval "$ac_try") 2>&5
 
3612
  ac_status=$?
 
3613
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3614
  test $ac_status = 0; }; }; then
 
3615
    cross_compiling=no
 
3616
  else
 
3617
    if test "$cross_compiling" = maybe; then
 
3618
        cross_compiling=yes
 
3619
    else
 
3620
        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
3621
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
3622
as_fn_error "cannot run C compiled programs.
 
3623
If you meant to cross compile, use \`--host'.
 
3624
See \`config.log' for more details." "$LINENO" 5; }
 
3625
    fi
 
3626
  fi
 
3627
fi
 
3628
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
 
3629
$as_echo "$cross_compiling" >&6; }
 
3630
 
 
3631
rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
 
3632
ac_clean_files=$ac_clean_files_save
 
3633
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
 
3634
$as_echo_n "checking for suffix of object files... " >&6; }
 
3635
if test "${ac_cv_objext+set}" = set; then :
 
3636
  $as_echo_n "(cached) " >&6
 
3637
else
 
3638
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
3639
/* end confdefs.h.  */
 
3640
 
 
3641
int
 
3642
main ()
 
3643
{
 
3644
 
 
3645
  ;
 
3646
  return 0;
 
3647
}
 
3648
_ACEOF
 
3649
rm -f conftest.o conftest.obj
 
3650
if { { ac_try="$ac_compile"
 
3651
case "(($ac_try" in
 
3652
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
3653
  *) ac_try_echo=$ac_try;;
 
3654
esac
 
3655
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
3656
$as_echo "$ac_try_echo"; } >&5
 
3657
  (eval "$ac_compile") 2>&5
 
3658
  ac_status=$?
 
3659
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
3660
  test $ac_status = 0; }; then :
 
3661
  for ac_file in conftest.o conftest.obj conftest.*; do
 
3662
  test -f "$ac_file" || continue;
 
3663
  case $ac_file in
 
3664
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
 
3665
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
 
3666
       break;;
 
3667
  esac
 
3668
done
 
3669
else
 
3670
  $as_echo "$as_me: failed program was:" >&5
 
3671
sed 's/^/| /' conftest.$ac_ext >&5
 
3672
 
 
3673
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
3674
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
3675
as_fn_error "cannot compute suffix of object files: cannot compile
 
3676
See \`config.log' for more details." "$LINENO" 5; }
 
3677
fi
 
3678
rm -f conftest.$ac_cv_objext conftest.$ac_ext
 
3679
fi
 
3680
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
 
3681
$as_echo "$ac_cv_objext" >&6; }
 
3682
OBJEXT=$ac_cv_objext
 
3683
ac_objext=$OBJEXT
4039
3684
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4040
3685
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4041
3686
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4959
4604
else
4960
4605
  lt_cv_nm_interface="BSD nm"
4961
4606
  echo "int some_variable = 0;" > conftest.$ac_ext
4962
 
  (eval echo "\"\$as_me:4962: $ac_compile\"" >&5)
 
4607
  (eval echo "\"\$as_me:4607: $ac_compile\"" >&5)
4963
4608
  (eval "$ac_compile" 2>conftest.err)
4964
4609
  cat conftest.err >&5
4965
 
  (eval echo "\"\$as_me:4965: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
 
4610
  (eval echo "\"\$as_me:4610: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
4966
4611
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
4967
4612
  cat conftest.err >&5
4968
 
  (eval echo "\"\$as_me:4968: output\"" >&5)
 
4613
  (eval echo "\"\$as_me:4613: output\"" >&5)
4969
4614
  cat conftest.out >&5
4970
4615
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
4971
4616
    lt_cv_nm_interface="MS dumpbin"
6171
5816
  ;;
6172
5817
*-*-irix6*)
6173
5818
  # Find out which ABI we are using.
6174
 
  echo '#line 6174 "configure"' > conftest.$ac_ext
 
5819
  echo '#line 5819 "configure"' > conftest.$ac_ext
6175
5820
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
6176
5821
  (eval $ac_compile) 2>&5
6177
5822
  ac_status=$?
7201
6846
 
7202
6847
 
7203
6848
 
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
6849
# Set options
7732
6850
 
7733
6851
 
8228
7346
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8229
7347
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8230
7348
   -e 's:$: $lt_compiler_flag:'`
8231
 
   (eval echo "\"\$as_me:8231: $lt_compile\"" >&5)
 
7349
   (eval echo "\"\$as_me:7349: $lt_compile\"" >&5)
8232
7350
   (eval "$lt_compile" 2>conftest.err)
8233
7351
   ac_status=$?
8234
7352
   cat conftest.err >&5
8235
 
   echo "$as_me:8235: \$? = $ac_status" >&5
 
7353
   echo "$as_me:7353: \$? = $ac_status" >&5
8236
7354
   if (exit $ac_status) && test -s "$ac_outfile"; then
8237
7355
     # The compiler can only warn and ignore the option if not recognized
8238
7356
     # So say no if there are warnings other than the usual output.
8567
7685
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8568
7686
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8569
7687
   -e 's:$: $lt_compiler_flag:'`
8570
 
   (eval echo "\"\$as_me:8570: $lt_compile\"" >&5)
 
7688
   (eval echo "\"\$as_me:7688: $lt_compile\"" >&5)
8571
7689
   (eval "$lt_compile" 2>conftest.err)
8572
7690
   ac_status=$?
8573
7691
   cat conftest.err >&5
8574
 
   echo "$as_me:8574: \$? = $ac_status" >&5
 
7692
   echo "$as_me:7692: \$? = $ac_status" >&5
8575
7693
   if (exit $ac_status) && test -s "$ac_outfile"; then
8576
7694
     # The compiler can only warn and ignore the option if not recognized
8577
7695
     # So say no if there are warnings other than the usual output.
8672
7790
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8673
7791
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8674
7792
   -e 's:$: $lt_compiler_flag:'`
8675
 
   (eval echo "\"\$as_me:8675: $lt_compile\"" >&5)
 
7793
   (eval echo "\"\$as_me:7793: $lt_compile\"" >&5)
8676
7794
   (eval "$lt_compile" 2>out/conftest.err)
8677
7795
   ac_status=$?
8678
7796
   cat out/conftest.err >&5
8679
 
   echo "$as_me:8679: \$? = $ac_status" >&5
 
7797
   echo "$as_me:7797: \$? = $ac_status" >&5
8680
7798
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8681
7799
   then
8682
7800
     # The compiler can only warn and ignore the option if not recognized
8727
7845
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
8728
7846
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
8729
7847
   -e 's:$: $lt_compiler_flag:'`
8730
 
   (eval echo "\"\$as_me:8730: $lt_compile\"" >&5)
 
7848
   (eval echo "\"\$as_me:7848: $lt_compile\"" >&5)
8731
7849
   (eval "$lt_compile" 2>out/conftest.err)
8732
7850
   ac_status=$?
8733
7851
   cat out/conftest.err >&5
8734
 
   echo "$as_me:8734: \$? = $ac_status" >&5
 
7852
   echo "$as_me:7852: \$? = $ac_status" >&5
8735
7853
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
8736
7854
   then
8737
7855
     # The compiler can only warn and ignore the option if not recognized
11110
10228
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11111
10229
  lt_status=$lt_dlunknown
11112
10230
  cat > conftest.$ac_ext <<_LT_EOF
11113
 
#line 11113 "configure"
 
10231
#line 10231 "configure"
11114
10232
#include "confdefs.h"
11115
10233
 
11116
10234
#if HAVE_DLFCN_H
11206
10324
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
11207
10325
  lt_status=$lt_dlunknown
11208
10326
  cat > conftest.$ac_ext <<_LT_EOF
11209
 
#line 11209 "configure"
 
10327
#line 10327 "configure"
11210
10328
#include "confdefs.h"
11211
10329
 
11212
10330
#if HAVE_DLFCN_H
11414
10532
CC="$lt_save_CC"
11415
10533
 
11416
10534
 
 
10535
 
 
10536
 
 
10537
 
 
10538
 
 
10539
 
 
10540
 
 
10541
 
 
10542
 
 
10543
 
 
10544
 
 
10545
 
 
10546
        ac_config_commands="$ac_config_commands libtool"
 
10547
 
 
10548
 
 
10549
 
 
10550
 
 
10551
# Only expand once:
 
10552
 
 
10553
 
 
10554
 
 
10555
# checks for programs.
 
10556
ac_ext=cpp
 
10557
ac_cpp='$CXXCPP $CPPFLAGS'
 
10558
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
10559
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
10560
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
10561
if test -z "$CXX"; then
 
10562
  if test -n "$CCC"; then
 
10563
    CXX=$CCC
 
10564
  else
 
10565
    if test -n "$ac_tool_prefix"; then
 
10566
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
10567
  do
 
10568
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
10569
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
10570
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
10571
$as_echo_n "checking for $ac_word... " >&6; }
 
10572
if test "${ac_cv_prog_CXX+set}" = set; then :
 
10573
  $as_echo_n "(cached) " >&6
 
10574
else
 
10575
  if test -n "$CXX"; then
 
10576
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
10577
else
 
10578
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
10579
for as_dir in $PATH
 
10580
do
 
10581
  IFS=$as_save_IFS
 
10582
  test -z "$as_dir" && as_dir=.
 
10583
    for ac_exec_ext in '' $ac_executable_extensions; do
 
10584
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
10585
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
10586
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
10587
    break 2
 
10588
  fi
 
10589
done
 
10590
  done
 
10591
IFS=$as_save_IFS
 
10592
 
 
10593
fi
 
10594
fi
 
10595
CXX=$ac_cv_prog_CXX
 
10596
if test -n "$CXX"; then
 
10597
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
 
10598
$as_echo "$CXX" >&6; }
 
10599
else
 
10600
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
10601
$as_echo "no" >&6; }
 
10602
fi
 
10603
 
 
10604
 
 
10605
    test -n "$CXX" && break
 
10606
  done
 
10607
fi
 
10608
if test -z "$CXX"; then
 
10609
  ac_ct_CXX=$CXX
 
10610
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
10611
do
 
10612
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
10613
set dummy $ac_prog; ac_word=$2
 
10614
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
10615
$as_echo_n "checking for $ac_word... " >&6; }
 
10616
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
 
10617
  $as_echo_n "(cached) " >&6
 
10618
else
 
10619
  if test -n "$ac_ct_CXX"; then
 
10620
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
10621
else
 
10622
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
10623
for as_dir in $PATH
 
10624
do
 
10625
  IFS=$as_save_IFS
 
10626
  test -z "$as_dir" && as_dir=.
 
10627
    for ac_exec_ext in '' $ac_executable_extensions; do
 
10628
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
10629
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
10630
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
10631
    break 2
 
10632
  fi
 
10633
done
 
10634
  done
 
10635
IFS=$as_save_IFS
 
10636
 
 
10637
fi
 
10638
fi
 
10639
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 
10640
if test -n "$ac_ct_CXX"; then
 
10641
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
 
10642
$as_echo "$ac_ct_CXX" >&6; }
 
10643
else
 
10644
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
10645
$as_echo "no" >&6; }
 
10646
fi
 
10647
 
 
10648
 
 
10649
  test -n "$ac_ct_CXX" && break
 
10650
done
 
10651
 
 
10652
  if test "x$ac_ct_CXX" = x; then
 
10653
    CXX="g++"
 
10654
  else
 
10655
    case $cross_compiling:$ac_tool_warned in
 
10656
yes:)
 
10657
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
 
10658
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
10659
ac_tool_warned=yes ;;
 
10660
esac
 
10661
    CXX=$ac_ct_CXX
 
10662
  fi
 
10663
fi
 
10664
 
 
10665
  fi
 
10666
fi
 
10667
# Provide some information about the compiler.
 
10668
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
 
10669
set X $ac_compile
 
10670
ac_compiler=$2
 
10671
for ac_option in --version -v -V -qversion; do
 
10672
  { { ac_try="$ac_compiler $ac_option >&5"
 
10673
case "(($ac_try" in
 
10674
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
10675
  *) ac_try_echo=$ac_try;;
 
10676
esac
 
10677
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
10678
$as_echo "$ac_try_echo"; } >&5
 
10679
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
 
10680
  ac_status=$?
 
10681
  if test -s conftest.err; then
 
10682
    sed '10a\
 
10683
... rest of stderr output deleted ...
 
10684
         10q' conftest.err >conftest.er1
 
10685
    cat conftest.er1 >&5
 
10686
  fi
 
10687
  rm -f conftest.er1 conftest.err
 
10688
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
10689
  test $ac_status = 0; }
 
10690
done
 
10691
 
 
10692
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
 
10693
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
 
10694
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
 
10695
  $as_echo_n "(cached) " >&6
 
10696
else
 
10697
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
10698
/* end confdefs.h.  */
 
10699
 
 
10700
int
 
10701
main ()
 
10702
{
 
10703
#ifndef __GNUC__
 
10704
       choke me
 
10705
#endif
 
10706
 
 
10707
  ;
 
10708
  return 0;
 
10709
}
 
10710
_ACEOF
 
10711
if ac_fn_cxx_try_compile "$LINENO"; then :
 
10712
  ac_compiler_gnu=yes
 
10713
else
 
10714
  ac_compiler_gnu=no
 
10715
fi
 
10716
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
10717
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
 
10718
 
 
10719
fi
 
10720
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
 
10721
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
 
10722
if test $ac_compiler_gnu = yes; then
 
10723
  GXX=yes
 
10724
else
 
10725
  GXX=
 
10726
fi
 
10727
ac_test_CXXFLAGS=${CXXFLAGS+set}
 
10728
ac_save_CXXFLAGS=$CXXFLAGS
 
10729
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
 
10730
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
 
10731
if test "${ac_cv_prog_cxx_g+set}" = set; then :
 
10732
  $as_echo_n "(cached) " >&6
 
10733
else
 
10734
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
 
10735
   ac_cxx_werror_flag=yes
 
10736
   ac_cv_prog_cxx_g=no
 
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
else
 
10752
  CXXFLAGS=""
 
10753
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
10754
/* end confdefs.h.  */
 
10755
 
 
10756
int
 
10757
main ()
 
10758
{
 
10759
 
 
10760
  ;
 
10761
  return 0;
 
10762
}
 
10763
_ACEOF
 
10764
if ac_fn_cxx_try_compile "$LINENO"; then :
 
10765
 
 
10766
else
 
10767
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
10768
         CXXFLAGS="-g"
 
10769
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
10770
/* end confdefs.h.  */
 
10771
 
 
10772
int
 
10773
main ()
 
10774
{
 
10775
 
 
10776
  ;
 
10777
  return 0;
 
10778
}
 
10779
_ACEOF
 
10780
if ac_fn_cxx_try_compile "$LINENO"; then :
 
10781
  ac_cv_prog_cxx_g=yes
 
10782
fi
 
10783
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
10784
fi
 
10785
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
10786
fi
 
10787
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
10788
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
10789
fi
 
10790
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
 
10791
$as_echo "$ac_cv_prog_cxx_g" >&6; }
 
10792
if test "$ac_test_CXXFLAGS" = set; then
 
10793
  CXXFLAGS=$ac_save_CXXFLAGS
 
10794
elif test $ac_cv_prog_cxx_g = yes; then
 
10795
  if test "$GXX" = yes; then
 
10796
    CXXFLAGS="-g -O2"
 
10797
  else
 
10798
    CXXFLAGS="-g"
 
10799
  fi
 
10800
else
 
10801
  if test "$GXX" = yes; then
 
10802
    CXXFLAGS="-O2"
 
10803
  else
 
10804
    CXXFLAGS=
 
10805
  fi
 
10806
fi
 
10807
ac_ext=c
 
10808
ac_cpp='$CPP $CPPFLAGS'
 
10809
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
10810
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
10811
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
10812
 
 
10813
depcc="$CXX"  am_compiler_list=
 
10814
 
 
10815
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
 
10816
$as_echo_n "checking dependency style of $depcc... " >&6; }
 
10817
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
 
10818
  $as_echo_n "(cached) " >&6
 
10819
else
 
10820
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
10821
  # We make a subdir and do the tests there.  Otherwise we can end up
 
10822
  # making bogus files that we don't know about and never remove.  For
 
10823
  # instance it was reported that on HP-UX the gcc test will end up
 
10824
  # making a dummy file named `D' -- because `-MD' means `put the output
 
10825
  # in D'.
 
10826
  mkdir conftest.dir
 
10827
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
10828
  # using a relative directory.
 
10829
  cp "$am_depcomp" conftest.dir
 
10830
  cd conftest.dir
 
10831
  # We will build objects and dependencies in a subdirectory because
 
10832
  # it helps to detect inapplicable dependency modes.  For instance
 
10833
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
10834
  # side effect of compilation, but ICC will put the dependencies in
 
10835
  # the current directory while Tru64 will put them in the object
 
10836
  # directory.
 
10837
  mkdir sub
 
10838
 
 
10839
  am_cv_CXX_dependencies_compiler_type=none
 
10840
  if test "$am_compiler_list" = ""; then
 
10841
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
10842
  fi
 
10843
  am__universal=false
 
10844
  case " $depcc " in #(
 
10845
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
 
10846
     esac
 
10847
 
 
10848
  for depmode in $am_compiler_list; do
 
10849
    # Setup a source with many dependencies, because some compilers
 
10850
    # like to wrap large dependency lists on column 80 (with \), and
 
10851
    # we should not choose a depcomp mode which is confused by this.
 
10852
    #
 
10853
    # We need to recreate these files for each test, as the compiler may
 
10854
    # overwrite some of them when testing with obscure command lines.
 
10855
    # This happens at least with the AIX C compiler.
 
10856
    : > sub/conftest.c
 
10857
    for i in 1 2 3 4 5 6; do
 
10858
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
10859
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
10860
      # Solaris 8's {/usr,}/bin/sh.
 
10861
      touch sub/conftst$i.h
 
10862
    done
 
10863
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
10864
 
 
10865
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
10866
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
10867
    # handle `-M -o', and we need to detect this.  Also, some Intel
 
10868
    # versions had trouble with output in subdirs
 
10869
    am__obj=sub/conftest.${OBJEXT-o}
 
10870
    am__minus_obj="-o $am__obj"
 
10871
    case $depmode in
 
10872
    gcc)
 
10873
      # This depmode causes a compiler race in universal mode.
 
10874
      test "$am__universal" = false || continue
 
10875
      ;;
 
10876
    nosideeffect)
 
10877
      # after this tag, mechanisms are not by side-effect, so they'll
 
10878
      # only be used when explicitly requested
 
10879
      if test "x$enable_dependency_tracking" = xyes; then
 
10880
        continue
 
10881
      else
 
10882
        break
 
10883
      fi
 
10884
      ;;
 
10885
    msvisualcpp | msvcmsys)
 
10886
      # This compiler won't grok `-c -o', but also, the minuso test has
 
10887
      # not run yet.  These depmodes are late enough in the game, and
 
10888
      # so weak that their functioning should not be impacted.
 
10889
      am__obj=conftest.${OBJEXT-o}
 
10890
      am__minus_obj=
 
10891
      ;;
 
10892
    none) break ;;
 
10893
    esac
 
10894
    if depmode=$depmode \
 
10895
       source=sub/conftest.c object=$am__obj \
 
10896
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
10897
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
 
10898
         >/dev/null 2>conftest.err &&
 
10899
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
 
10900
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
10901
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
 
10902
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
10903
      # icc doesn't choke on unknown options, it will just issue warnings
 
10904
      # or remarks (even with -Werror).  So we grep stderr for any message
 
10905
      # that says an option was ignored or not supported.
 
10906
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
10907
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
10908
      # The diagnosis changed in icc 8.0:
 
10909
      #   icc: Command line remark: option '-MP' not supported
 
10910
      if (grep 'ignoring option' conftest.err ||
 
10911
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
10912
        am_cv_CXX_dependencies_compiler_type=$depmode
 
10913
        break
 
10914
      fi
 
10915
    fi
 
10916
  done
 
10917
 
 
10918
  cd ..
 
10919
  rm -rf conftest.dir
 
10920
else
 
10921
  am_cv_CXX_dependencies_compiler_type=none
 
10922
fi
 
10923
 
 
10924
fi
 
10925
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
 
10926
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
 
10927
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
 
10928
 
 
10929
 if
 
10930
  test "x$enable_dependency_tracking" != xno \
 
10931
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
 
10932
  am__fastdepCXX_TRUE=
 
10933
  am__fastdepCXX_FALSE='#'
 
10934
else
 
10935
  am__fastdepCXX_TRUE='#'
 
10936
  am__fastdepCXX_FALSE=
 
10937
fi
 
10938
 
 
10939
 
 
10940
 
 
10941
ac_ext=cpp
 
10942
ac_cpp='$CXXCPP $CPPFLAGS'
 
10943
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
10944
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
10945
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
10946
if test -z "$CXX"; then
 
10947
  if test -n "$CCC"; then
 
10948
    CXX=$CCC
 
10949
  else
 
10950
    if test -n "$ac_tool_prefix"; then
 
10951
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
10952
  do
 
10953
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
10954
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
10955
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
10956
$as_echo_n "checking for $ac_word... " >&6; }
 
10957
if test "${ac_cv_prog_CXX+set}" = set; then :
 
10958
  $as_echo_n "(cached) " >&6
 
10959
else
 
10960
  if test -n "$CXX"; then
 
10961
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
10962
else
 
10963
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
10964
for as_dir in $PATH
 
10965
do
 
10966
  IFS=$as_save_IFS
 
10967
  test -z "$as_dir" && as_dir=.
 
10968
    for ac_exec_ext in '' $ac_executable_extensions; do
 
10969
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
10970
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
10971
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
10972
    break 2
 
10973
  fi
 
10974
done
 
10975
  done
 
10976
IFS=$as_save_IFS
 
10977
 
 
10978
fi
 
10979
fi
 
10980
CXX=$ac_cv_prog_CXX
 
10981
if test -n "$CXX"; then
 
10982
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
 
10983
$as_echo "$CXX" >&6; }
 
10984
else
 
10985
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
10986
$as_echo "no" >&6; }
 
10987
fi
 
10988
 
 
10989
 
 
10990
    test -n "$CXX" && break
 
10991
  done
 
10992
fi
 
10993
if test -z "$CXX"; then
 
10994
  ac_ct_CXX=$CXX
 
10995
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
10996
do
 
10997
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
10998
set dummy $ac_prog; ac_word=$2
 
10999
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 
11000
$as_echo_n "checking for $ac_word... " >&6; }
 
11001
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
 
11002
  $as_echo_n "(cached) " >&6
 
11003
else
 
11004
  if test -n "$ac_ct_CXX"; then
 
11005
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
11006
else
 
11007
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
11008
for as_dir in $PATH
 
11009
do
 
11010
  IFS=$as_save_IFS
 
11011
  test -z "$as_dir" && as_dir=.
 
11012
    for ac_exec_ext in '' $ac_executable_extensions; do
 
11013
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
11014
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
11015
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
 
11016
    break 2
 
11017
  fi
 
11018
done
 
11019
  done
 
11020
IFS=$as_save_IFS
 
11021
 
 
11022
fi
 
11023
fi
 
11024
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
 
11025
if test -n "$ac_ct_CXX"; then
 
11026
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
 
11027
$as_echo "$ac_ct_CXX" >&6; }
 
11028
else
 
11029
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
 
11030
$as_echo "no" >&6; }
 
11031
fi
 
11032
 
 
11033
 
 
11034
  test -n "$ac_ct_CXX" && break
 
11035
done
 
11036
 
 
11037
  if test "x$ac_ct_CXX" = x; then
 
11038
    CXX="g++"
 
11039
  else
 
11040
    case $cross_compiling:$ac_tool_warned in
 
11041
yes:)
 
11042
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
 
11043
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
11044
ac_tool_warned=yes ;;
 
11045
esac
 
11046
    CXX=$ac_ct_CXX
 
11047
  fi
 
11048
fi
 
11049
 
 
11050
  fi
 
11051
fi
 
11052
# Provide some information about the compiler.
 
11053
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
 
11054
set X $ac_compile
 
11055
ac_compiler=$2
 
11056
for ac_option in --version -v -V -qversion; do
 
11057
  { { ac_try="$ac_compiler $ac_option >&5"
 
11058
case "(($ac_try" in
 
11059
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
 
11060
  *) ac_try_echo=$ac_try;;
 
11061
esac
 
11062
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
 
11063
$as_echo "$ac_try_echo"; } >&5
 
11064
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
 
11065
  ac_status=$?
 
11066
  if test -s conftest.err; then
 
11067
    sed '10a\
 
11068
... rest of stderr output deleted ...
 
11069
         10q' conftest.err >conftest.er1
 
11070
    cat conftest.er1 >&5
 
11071
  fi
 
11072
  rm -f conftest.er1 conftest.err
 
11073
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
 
11074
  test $ac_status = 0; }
 
11075
done
 
11076
 
 
11077
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
 
11078
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
 
11079
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
 
11080
  $as_echo_n "(cached) " >&6
 
11081
else
 
11082
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11083
/* end confdefs.h.  */
 
11084
 
 
11085
int
 
11086
main ()
 
11087
{
 
11088
#ifndef __GNUC__
 
11089
       choke me
 
11090
#endif
 
11091
 
 
11092
  ;
 
11093
  return 0;
 
11094
}
 
11095
_ACEOF
 
11096
if ac_fn_cxx_try_compile "$LINENO"; then :
 
11097
  ac_compiler_gnu=yes
 
11098
else
 
11099
  ac_compiler_gnu=no
 
11100
fi
 
11101
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
11102
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
 
11103
 
 
11104
fi
 
11105
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
 
11106
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
 
11107
if test $ac_compiler_gnu = yes; then
 
11108
  GXX=yes
 
11109
else
 
11110
  GXX=
 
11111
fi
 
11112
ac_test_CXXFLAGS=${CXXFLAGS+set}
 
11113
ac_save_CXXFLAGS=$CXXFLAGS
 
11114
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
 
11115
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
 
11116
if test "${ac_cv_prog_cxx_g+set}" = set; then :
 
11117
  $as_echo_n "(cached) " >&6
 
11118
else
 
11119
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
 
11120
   ac_cxx_werror_flag=yes
 
11121
   ac_cv_prog_cxx_g=no
 
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
else
 
11137
  CXXFLAGS=""
 
11138
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11139
/* end confdefs.h.  */
 
11140
 
 
11141
int
 
11142
main ()
 
11143
{
 
11144
 
 
11145
  ;
 
11146
  return 0;
 
11147
}
 
11148
_ACEOF
 
11149
if ac_fn_cxx_try_compile "$LINENO"; then :
 
11150
 
 
11151
else
 
11152
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
11153
         CXXFLAGS="-g"
 
11154
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11155
/* end confdefs.h.  */
 
11156
 
 
11157
int
 
11158
main ()
 
11159
{
 
11160
 
 
11161
  ;
 
11162
  return 0;
 
11163
}
 
11164
_ACEOF
 
11165
if ac_fn_cxx_try_compile "$LINENO"; then :
 
11166
  ac_cv_prog_cxx_g=yes
 
11167
fi
 
11168
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
11169
fi
 
11170
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
11171
fi
 
11172
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
11173
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 
11174
fi
 
11175
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
 
11176
$as_echo "$ac_cv_prog_cxx_g" >&6; }
 
11177
if test "$ac_test_CXXFLAGS" = set; then
 
11178
  CXXFLAGS=$ac_save_CXXFLAGS
 
11179
elif test $ac_cv_prog_cxx_g = yes; then
 
11180
  if test "$GXX" = yes; then
 
11181
    CXXFLAGS="-g -O2"
 
11182
  else
 
11183
    CXXFLAGS="-g"
 
11184
  fi
 
11185
else
 
11186
  if test "$GXX" = yes; then
 
11187
    CXXFLAGS="-O2"
 
11188
  else
 
11189
    CXXFLAGS=
 
11190
  fi
 
11191
fi
 
11192
ac_ext=c
 
11193
ac_cpp='$CPP $CPPFLAGS'
 
11194
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
11195
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
11196
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
11197
 
 
11198
depcc="$CXX"  am_compiler_list=
 
11199
 
 
11200
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
 
11201
$as_echo_n "checking dependency style of $depcc... " >&6; }
 
11202
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then :
 
11203
  $as_echo_n "(cached) " >&6
 
11204
else
 
11205
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
 
11206
  # We make a subdir and do the tests there.  Otherwise we can end up
 
11207
  # making bogus files that we don't know about and never remove.  For
 
11208
  # instance it was reported that on HP-UX the gcc test will end up
 
11209
  # making a dummy file named `D' -- because `-MD' means `put the output
 
11210
  # in D'.
 
11211
  mkdir conftest.dir
 
11212
  # Copy depcomp to subdir because otherwise we won't find it if we're
 
11213
  # using a relative directory.
 
11214
  cp "$am_depcomp" conftest.dir
 
11215
  cd conftest.dir
 
11216
  # We will build objects and dependencies in a subdirectory because
 
11217
  # it helps to detect inapplicable dependency modes.  For instance
 
11218
  # both Tru64's cc and ICC support -MD to output dependencies as a
 
11219
  # side effect of compilation, but ICC will put the dependencies in
 
11220
  # the current directory while Tru64 will put them in the object
 
11221
  # directory.
 
11222
  mkdir sub
 
11223
 
 
11224
  am_cv_CXX_dependencies_compiler_type=none
 
11225
  if test "$am_compiler_list" = ""; then
 
11226
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
 
11227
  fi
 
11228
  am__universal=false
 
11229
  case " $depcc " in #(
 
11230
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
 
11231
     esac
 
11232
 
 
11233
  for depmode in $am_compiler_list; do
 
11234
    # Setup a source with many dependencies, because some compilers
 
11235
    # like to wrap large dependency lists on column 80 (with \), and
 
11236
    # we should not choose a depcomp mode which is confused by this.
 
11237
    #
 
11238
    # We need to recreate these files for each test, as the compiler may
 
11239
    # overwrite some of them when testing with obscure command lines.
 
11240
    # This happens at least with the AIX C compiler.
 
11241
    : > sub/conftest.c
 
11242
    for i in 1 2 3 4 5 6; do
 
11243
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
 
11244
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
 
11245
      # Solaris 8's {/usr,}/bin/sh.
 
11246
      touch sub/conftst$i.h
 
11247
    done
 
11248
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
 
11249
 
 
11250
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
 
11251
    # mode.  It turns out that the SunPro C++ compiler does not properly
 
11252
    # handle `-M -o', and we need to detect this.  Also, some Intel
 
11253
    # versions had trouble with output in subdirs
 
11254
    am__obj=sub/conftest.${OBJEXT-o}
 
11255
    am__minus_obj="-o $am__obj"
 
11256
    case $depmode in
 
11257
    gcc)
 
11258
      # This depmode causes a compiler race in universal mode.
 
11259
      test "$am__universal" = false || continue
 
11260
      ;;
 
11261
    nosideeffect)
 
11262
      # after this tag, mechanisms are not by side-effect, so they'll
 
11263
      # only be used when explicitly requested
 
11264
      if test "x$enable_dependency_tracking" = xyes; then
 
11265
        continue
 
11266
      else
 
11267
        break
 
11268
      fi
 
11269
      ;;
 
11270
    msvisualcpp | msvcmsys)
 
11271
      # This compiler won't grok `-c -o', but also, the minuso test has
 
11272
      # not run yet.  These depmodes are late enough in the game, and
 
11273
      # so weak that their functioning should not be impacted.
 
11274
      am__obj=conftest.${OBJEXT-o}
 
11275
      am__minus_obj=
 
11276
      ;;
 
11277
    none) break ;;
 
11278
    esac
 
11279
    if depmode=$depmode \
 
11280
       source=sub/conftest.c object=$am__obj \
 
11281
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
 
11282
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
 
11283
         >/dev/null 2>conftest.err &&
 
11284
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
 
11285
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
 
11286
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
 
11287
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
 
11288
      # icc doesn't choke on unknown options, it will just issue warnings
 
11289
      # or remarks (even with -Werror).  So we grep stderr for any message
 
11290
      # that says an option was ignored or not supported.
 
11291
      # When given -MP, icc 7.0 and 7.1 complain thusly:
 
11292
      #   icc: Command line warning: ignoring option '-M'; no argument required
 
11293
      # The diagnosis changed in icc 8.0:
 
11294
      #   icc: Command line remark: option '-MP' not supported
 
11295
      if (grep 'ignoring option' conftest.err ||
 
11296
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
 
11297
        am_cv_CXX_dependencies_compiler_type=$depmode
 
11298
        break
 
11299
      fi
 
11300
    fi
 
11301
  done
 
11302
 
 
11303
  cd ..
 
11304
  rm -rf conftest.dir
 
11305
else
 
11306
  am_cv_CXX_dependencies_compiler_type=none
 
11307
fi
 
11308
 
 
11309
fi
 
11310
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
 
11311
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
 
11312
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
 
11313
 
 
11314
 if
 
11315
  test "x$enable_dependency_tracking" != xno \
 
11316
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
 
11317
  am__fastdepCXX_TRUE=
 
11318
  am__fastdepCXX_FALSE='#'
 
11319
else
 
11320
  am__fastdepCXX_TRUE='#'
 
11321
  am__fastdepCXX_FALSE=
 
11322
fi
 
11323
 
 
11324
 
 
11325
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
 
11326
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
 
11327
    (test "X$CXX" != "Xg++"))) ; then
 
11328
  ac_ext=cpp
 
11329
ac_cpp='$CXXCPP $CPPFLAGS'
 
11330
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
11331
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
11332
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 
11333
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
 
11334
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
 
11335
if test -z "$CXXCPP"; then
 
11336
  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
 
11337
  $as_echo_n "(cached) " >&6
 
11338
else
 
11339
      # Double quotes because CXXCPP needs to be expanded
 
11340
    for CXXCPP in "$CXX -E" "/lib/cpp"
 
11341
    do
 
11342
      ac_preproc_ok=false
 
11343
for ac_cxx_preproc_warn_flag in '' yes
 
11344
do
 
11345
  # Use a header file that comes with gcc, so configuring glibc
 
11346
  # with a fresh cross-compiler works.
 
11347
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
11348
  # <limits.h> exists even on freestanding compilers.
 
11349
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
11350
  # not just through cpp. "Syntax error" is here to catch this case.
 
11351
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11352
/* end confdefs.h.  */
 
11353
#ifdef __STDC__
 
11354
# include <limits.h>
 
11355
#else
 
11356
# include <assert.h>
 
11357
#endif
 
11358
                     Syntax error
 
11359
_ACEOF
 
11360
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
11361
 
 
11362
else
 
11363
  # Broken: fails on valid input.
 
11364
continue
 
11365
fi
 
11366
rm -f conftest.err conftest.$ac_ext
 
11367
 
 
11368
  # OK, works on sane cases.  Now check whether nonexistent headers
 
11369
  # can be detected and how.
 
11370
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11371
/* end confdefs.h.  */
 
11372
#include <ac_nonexistent.h>
 
11373
_ACEOF
 
11374
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
11375
  # Broken: success on invalid input.
 
11376
continue
 
11377
else
 
11378
  # Passes both tests.
 
11379
ac_preproc_ok=:
 
11380
break
 
11381
fi
 
11382
rm -f conftest.err conftest.$ac_ext
 
11383
 
 
11384
done
 
11385
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
11386
rm -f conftest.err conftest.$ac_ext
 
11387
if $ac_preproc_ok; then :
 
11388
  break
 
11389
fi
 
11390
 
 
11391
    done
 
11392
    ac_cv_prog_CXXCPP=$CXXCPP
 
11393
 
 
11394
fi
 
11395
  CXXCPP=$ac_cv_prog_CXXCPP
 
11396
else
 
11397
  ac_cv_prog_CXXCPP=$CXXCPP
 
11398
fi
 
11399
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
 
11400
$as_echo "$CXXCPP" >&6; }
 
11401
ac_preproc_ok=false
 
11402
for ac_cxx_preproc_warn_flag in '' yes
 
11403
do
 
11404
  # Use a header file that comes with gcc, so configuring glibc
 
11405
  # with a fresh cross-compiler works.
 
11406
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
11407
  # <limits.h> exists even on freestanding compilers.
 
11408
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
11409
  # not just through cpp. "Syntax error" is here to catch this case.
 
11410
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11411
/* end confdefs.h.  */
 
11412
#ifdef __STDC__
 
11413
# include <limits.h>
 
11414
#else
 
11415
# include <assert.h>
 
11416
#endif
 
11417
                     Syntax error
 
11418
_ACEOF
 
11419
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
11420
 
 
11421
else
 
11422
  # Broken: fails on valid input.
 
11423
continue
 
11424
fi
 
11425
rm -f conftest.err conftest.$ac_ext
 
11426
 
 
11427
  # OK, works on sane cases.  Now check whether nonexistent headers
 
11428
  # can be detected and how.
 
11429
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
11430
/* end confdefs.h.  */
 
11431
#include <ac_nonexistent.h>
 
11432
_ACEOF
 
11433
if ac_fn_cxx_try_cpp "$LINENO"; then :
 
11434
  # Broken: success on invalid input.
 
11435
continue
 
11436
else
 
11437
  # Passes both tests.
 
11438
ac_preproc_ok=:
 
11439
break
 
11440
fi
 
11441
rm -f conftest.err conftest.$ac_ext
 
11442
 
 
11443
done
 
11444
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
11445
rm -f conftest.err conftest.$ac_ext
 
11446
if $ac_preproc_ok; then :
 
11447
 
 
11448
else
 
11449
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
 
11450
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
11451
_lt_caught_CXX_error=yes; }
 
11452
fi
 
11453
 
 
11454
ac_ext=c
 
11455
ac_cpp='$CPP $CPPFLAGS'
 
11456
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
11457
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
11458
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
11459
 
 
11460
else
 
11461
  _lt_caught_CXX_error=yes
 
11462
fi
 
11463
 
 
11464
 
 
11465
 
 
11466
 
11417
11467
ac_ext=cpp
11418
11468
ac_cpp='$CXXCPP $CPPFLAGS'
11419
11469
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13162
13212
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13163
13213
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13164
13214
   -e 's:$: $lt_compiler_flag:'`
13165
 
   (eval echo "\"\$as_me:13165: $lt_compile\"" >&5)
 
13215
   (eval echo "\"\$as_me:13215: $lt_compile\"" >&5)
13166
13216
   (eval "$lt_compile" 2>conftest.err)
13167
13217
   ac_status=$?
13168
13218
   cat conftest.err >&5
13169
 
   echo "$as_me:13169: \$? = $ac_status" >&5
 
13219
   echo "$as_me:13219: \$? = $ac_status" >&5
13170
13220
   if (exit $ac_status) && test -s "$ac_outfile"; then
13171
13221
     # The compiler can only warn and ignore the option if not recognized
13172
13222
     # So say no if there are warnings other than the usual output.
13261
13311
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13262
13312
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13263
13313
   -e 's:$: $lt_compiler_flag:'`
13264
 
   (eval echo "\"\$as_me:13264: $lt_compile\"" >&5)
 
13314
   (eval echo "\"\$as_me:13314: $lt_compile\"" >&5)
13265
13315
   (eval "$lt_compile" 2>out/conftest.err)
13266
13316
   ac_status=$?
13267
13317
   cat out/conftest.err >&5
13268
 
   echo "$as_me:13268: \$? = $ac_status" >&5
 
13318
   echo "$as_me:13318: \$? = $ac_status" >&5
13269
13319
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13270
13320
   then
13271
13321
     # The compiler can only warn and ignore the option if not recognized
13313
13363
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
13314
13364
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
13315
13365
   -e 's:$: $lt_compiler_flag:'`
13316
 
   (eval echo "\"\$as_me:13316: $lt_compile\"" >&5)
 
13366
   (eval echo "\"\$as_me:13366: $lt_compile\"" >&5)
13317
13367
   (eval "$lt_compile" 2>out/conftest.err)
13318
13368
   ac_status=$?
13319
13369
   cat out/conftest.err >&5
13320
 
   echo "$as_me:13320: \$? = $ac_status" >&5
 
13370
   echo "$as_me:13370: \$? = $ac_status" >&5
13321
13371
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
13322
13372
   then
13323
13373
     # The compiler can only warn and ignore the option if not recognized
14263
14313
 
14264
14314
 
14265
14315
 
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
14316
# checks for libraries.
 
14317
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lboost_filesystem-mt" >&5
 
14318
$as_echo_n "checking for main in -lboost_filesystem-mt... " >&6; }
 
14319
if test "${ac_cv_lib_boost_filesystem_mt_main+set}" = set; then :
 
14320
  $as_echo_n "(cached) " >&6
 
14321
else
 
14322
  ac_check_lib_save_LIBS=$LIBS
 
14323
LIBS="-lboost_filesystem-mt  $LIBS"
 
14324
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14325
/* end confdefs.h.  */
 
14326
 
 
14327
 
 
14328
int
 
14329
main ()
 
14330
{
 
14331
return main ();
 
14332
  ;
 
14333
  return 0;
 
14334
}
 
14335
_ACEOF
 
14336
if ac_fn_c_try_link "$LINENO"; then :
 
14337
  ac_cv_lib_boost_filesystem_mt_main=yes
 
14338
else
 
14339
  ac_cv_lib_boost_filesystem_mt_main=no
 
14340
fi
 
14341
rm -f core conftest.err conftest.$ac_objext \
 
14342
    conftest$ac_exeext conftest.$ac_ext
 
14343
LIBS=$ac_check_lib_save_LIBS
 
14344
fi
 
14345
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_boost_filesystem_mt_main" >&5
 
14346
$as_echo "$ac_cv_lib_boost_filesystem_mt_main" >&6; }
 
14347
if test "x$ac_cv_lib_boost_filesystem_mt_main" = x""yes; then :
 
14348
  cat >>confdefs.h <<_ACEOF
 
14349
#define HAVE_LIBBOOST_FILESYSTEM_MT 1
 
14350
_ACEOF
 
14351
 
 
14352
  LIBS="-lboost_filesystem-mt $LIBS"
 
14353
 
 
14354
else
 
14355
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to find Boost Filesystem library - the library tests may not compile!" >&5
 
14356
$as_echo "$as_me: WARNING: Unable to find Boost Filesystem library - the library tests may not compile!" >&2;}
 
14357
fi
 
14358
 
 
14359
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lboost_thread-mt" >&5
 
14360
$as_echo_n "checking for main in -lboost_thread-mt... " >&6; }
 
14361
if test "${ac_cv_lib_boost_thread_mt_main+set}" = set; then :
 
14362
  $as_echo_n "(cached) " >&6
 
14363
else
 
14364
  ac_check_lib_save_LIBS=$LIBS
 
14365
LIBS="-lboost_thread-mt  $LIBS"
 
14366
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14367
/* end confdefs.h.  */
 
14368
 
 
14369
 
 
14370
int
 
14371
main ()
 
14372
{
 
14373
return main ();
 
14374
  ;
 
14375
  return 0;
 
14376
}
 
14377
_ACEOF
 
14378
if ac_fn_c_try_link "$LINENO"; then :
 
14379
  ac_cv_lib_boost_thread_mt_main=yes
 
14380
else
 
14381
  ac_cv_lib_boost_thread_mt_main=no
 
14382
fi
 
14383
rm -f core conftest.err conftest.$ac_objext \
 
14384
    conftest$ac_exeext conftest.$ac_ext
 
14385
LIBS=$ac_check_lib_save_LIBS
 
14386
fi
 
14387
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_boost_thread_mt_main" >&5
 
14388
$as_echo "$ac_cv_lib_boost_thread_mt_main" >&6; }
 
14389
if test "x$ac_cv_lib_boost_thread_mt_main" = x""yes; then :
 
14390
  cat >>confdefs.h <<_ACEOF
 
14391
#define HAVE_LIBBOOST_THREAD_MT 1
 
14392
_ACEOF
 
14393
 
 
14394
  LIBS="-lboost_thread-mt $LIBS"
 
14395
 
 
14396
else
 
14397
  as_fn_error "Unable to find Boost Thread library" "$LINENO" 5
 
14398
fi
 
14399
 
 
14400
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sqlite3_initialize in -lsqlite3" >&5
 
14401
$as_echo_n "checking for sqlite3_initialize in -lsqlite3... " >&6; }
 
14402
if test "${ac_cv_lib_sqlite3_sqlite3_initialize+set}" = set; then :
 
14403
  $as_echo_n "(cached) " >&6
 
14404
else
 
14405
  ac_check_lib_save_LIBS=$LIBS
 
14406
LIBS="-lsqlite3  $LIBS"
 
14407
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 
14408
/* end confdefs.h.  */
 
14409
 
 
14410
/* Override any GCC internal prototype to avoid an error.
 
14411
   Use char because int might match the return type of a GCC
 
14412
   builtin and then its argument prototype would still apply.  */
 
14413
#ifdef __cplusplus
 
14414
extern "C"
 
14415
#endif
 
14416
char sqlite3_initialize ();
 
14417
int
 
14418
main ()
 
14419
{
 
14420
return sqlite3_initialize ();
 
14421
  ;
 
14422
  return 0;
 
14423
}
 
14424
_ACEOF
 
14425
if ac_fn_c_try_link "$LINENO"; then :
 
14426
  ac_cv_lib_sqlite3_sqlite3_initialize=yes
 
14427
else
 
14428
  ac_cv_lib_sqlite3_sqlite3_initialize=no
 
14429
fi
 
14430
rm -f core conftest.err conftest.$ac_objext \
 
14431
    conftest$ac_exeext conftest.$ac_ext
 
14432
LIBS=$ac_check_lib_save_LIBS
 
14433
fi
 
14434
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_sqlite3_sqlite3_initialize" >&5
 
14435
$as_echo "$ac_cv_lib_sqlite3_sqlite3_initialize" >&6; }
 
14436
if test "x$ac_cv_lib_sqlite3_sqlite3_initialize" = x""yes; then :
 
14437
  cat >>confdefs.h <<_ACEOF
 
14438
#define HAVE_LIBSQLITE3 1
 
14439
_ACEOF
 
14440
 
 
14441
  LIBS="-lsqlite3 $LIBS"
 
14442
 
 
14443
else
 
14444
  as_fn_error "Unable to find SQLite3 library" "$LINENO" 5
 
14445
fi
 
14446
 
14286
14447
 
14287
14448
# checks for header files.
14288
14449
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
14414
14575
 
14415
14576
# checks for library functions.
14416
14577
 
14417
 
ac_config_files="$ac_config_files Makefile src/Makefile test/Makefile"
 
14578
ac_config_files="$ac_config_files Makefile src/Makefile include/Makefile test/Makefile"
14418
14579
 
14419
14580
cat >confcache <<\_ACEOF
14420
14581
# This file is a shell script that caches the results of configure
14525
14686
  as_fn_error "conditional \"AMDEP\" was never defined.
14526
14687
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14527
14688
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
14689
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
14533
14690
  as_fn_error "conditional \"am__fastdepCC\" was never defined.
14534
14691
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14537
14694
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
14538
14695
Usually this means the macro was only invoked conditionally." "$LINENO" 5
14539
14696
fi
 
14697
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
 
14698
  as_fn_error "conditional \"am__fastdepCXX\" was never defined.
 
14699
Usually this means the macro was only invoked conditionally." "$LINENO" 5
 
14700
fi
14540
14701
 
14541
14702
: ${CONFIG_STATUS=./config.status}
14542
14703
ac_write_fail=0
14946
15107
# values after options handling.
14947
15108
ac_log="
14948
15109
This file was extended by sqlite3cc $as_me 0.1.0, which was
14949
 
generated by GNU Autoconf 2.64.  Invocation command line was
 
15110
generated by GNU Autoconf 2.65.  Invocation command line was
14950
15111
 
14951
15112
  CONFIG_FILES    = $CONFIG_FILES
14952
15113
  CONFIG_HEADERS  = $CONFIG_HEADERS
14986
15147
 
14987
15148
  -h, --help       print this help, then exit
14988
15149
  -V, --version    print version number and configuration settings, then exit
 
15150
      --config     print configuration, then exit
14989
15151
  -q, --quiet, --silent
14990
15152
                   do not print progress messages
14991
15153
  -d, --debug      don't remove temporary files
15004
15166
Configuration commands:
15005
15167
$config_commands
15006
15168
 
15007
 
Report bugs to <edam@waxworlds.org>."
 
15169
Report bugs to <edam@waxworlds.org>.
 
15170
sqlite3cc home page: <http://www.waxworlds.org/edam/software/sqlite3cc>."
15008
15171
 
15009
15172
_ACEOF
15010
15173
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 
15174
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15011
15175
ac_cs_version="\\
15012
15176
sqlite3cc config.status 0.1.0
15013
 
configured by $0, generated by GNU Autoconf 2.64,
15014
 
  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
 
15177
configured by $0, generated by GNU Autoconf 2.65,
 
15178
  with options \\"\$ac_cs_config\\"
15015
15179
 
15016
15180
Copyright (C) 2009 Free Software Foundation, Inc.
15017
15181
This config.status script is free software; the Free Software Foundation
15049
15213
    ac_cs_recheck=: ;;
15050
15214
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
15051
15215
    $as_echo "$ac_cs_version"; exit ;;
 
15216
  --config | --confi | --conf | --con | --co | --c )
 
15217
    $as_echo "$ac_cs_config"; exit ;;
15052
15218
  --debug | --debu | --deb | --de | --d | -d )
15053
15219
    debug=: ;;
15054
15220
  --file | --fil | --fi | --f )
15486
15652
    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15487
15653
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15488
15654
    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
 
15655
    "include/Makefile") CONFIG_FILES="$CONFIG_FILES include/Makefile" ;;
15489
15656
    "test/Makefile") CONFIG_FILES="$CONFIG_FILES test/Makefile" ;;
15490
15657
 
15491
15658
  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15590
15757
t delim
15591
15758
:nl
15592
15759
h
15593
 
s/\(.\{148\}\).*/\1/
 
15760
s/\(.\{148\}\)..*/\1/
15594
15761
t more1
15595
15762
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
15596
15763
p
15604
15771
t nl
15605
15772
:delim
15606
15773
h
15607
 
s/\(.\{148\}\).*/\1/
 
15774
s/\(.\{148\}\)..*/\1/
15608
15775
t more2
15609
15776
s/["\\]/\\&/g; s/^/"/; s/$/"/
15610
15777
p