ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/hopm/branches/1.1.x/configure
(Generate patch)

Comparing:
hopm/trunk/configure (file contents), Revision 5059 by michael, Mon Dec 22 13:43:00 2014 UTC vs.
hopm/branches/1.1.x/configure (file contents), Revision 8228 by michael, Mon Apr 17 14:10:34 2017 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8147 2017-04-05 12:37:06Z michael .
3   # Guess values for system-dependent variables and create Makefiles.
4 < # Generated by GNU Autoconf 2.69 for bopm 3.1.3.
4 > # Generated by GNU Autoconf 2.69 for hopm 1.1.5.
5 > #
6 > # Report bugs to <bugs@ircd-hybrid.org>.
7   #
8   #
9   # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
# Line 272 | Line 275 | fi
275      $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
276      $as_echo "$0: be upgraded to zsh 4.3.4 or later."
277    else
278 <    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
279 < $0: including any error possibly output before this
280 < $0: message. Then install a modern shell, or manually run
281 < $0: the script under such a shell if you do have one."
278 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and
279 > $0: bugs@ircd-hybrid.org about your system, including any
280 > $0: error possibly output before this message. Then install
281 > $0: a modern shell, or manually run the script under such a
282 > $0: shell if you do have one."
283    fi
284    exit 1
285   fi
# Line 585 | Line 589 | MFLAGS=
589   MAKEFLAGS=
590  
591   # Identity of this package.
592 < PACKAGE_NAME='bopm'
593 < PACKAGE_TARNAME='bopm'
594 < PACKAGE_VERSION='3.1.3'
595 < PACKAGE_STRING='bopm 3.1.3'
596 < PACKAGE_BUGREPORT=''
592 > PACKAGE_NAME='hopm'
593 > PACKAGE_TARNAME='hopm'
594 > PACKAGE_VERSION='1.1.5'
595 > PACKAGE_STRING='hopm 1.1.5'
596 > PACKAGE_BUGREPORT='bugs@ircd-hybrid.org'
597   PACKAGE_URL=''
598  
599   ac_unique_file="src/opercmd.h"
600 < ac_default_prefix=\${HOME}/bopm
600 > ac_default_prefix=\${HOME}/hopm
601   # Factoring default headers for most tests.
602   ac_includes_default="\
603   #include <stdio.h>
# Line 630 | Line 634 | ac_includes_default="\
634   # include <unistd.h>
635   #endif"
636  
633 enable_option_checking=no
637   ac_subst_vars='am__EXEEXT_FALSE
638   am__EXEEXT_TRUE
639   LTLIBOBJS
640   LIBOBJS
641 < subdirs
641 > ENABLE_SSL_FALSE
642 > ENABLE_SSL_TRUE
643   LEXLIB
644   LEX_OUTPUT_ROOT
645   LEX
646   YFLAGS
647   YACC
648   CPP
649 + LT_SYS_LIBRARY_PATH
650   OTOOL64
651   OTOOL
652   LIPO
# Line 761 | Line 766 | ac_user_opts='
766   enable_option_checking
767   enable_silent_rules
768   enable_maintainer_mode
764 with_extra_fascism
769   enable_dependency_tracking
770   enable_shared
771   enable_static
# Line 771 | Line 775 | with_aix_soname
775   with_gnu_ld
776   with_sysroot
777   enable_libtool_lock
778 < with_werror
778 > enable_openssl
779 > enable_assert
780 > enable_warnings
781   '
782        ac_precious_vars='build_alias
783   host_alias
# Line 781 | Line 787 | CFLAGS
787   LDFLAGS
788   LIBS
789   CPPFLAGS
790 + LT_SYS_LIBRARY_PATH
791   CPP
792   YACC
793   YFLAGS'
794 < ac_subdirs_all='src/libopm'
794 >
795  
796   # Initialize some variables set by options.
797   ac_init_help=
# Line 1324 | Line 1331 | if test "$ac_init_help" = "long"; then
1331    # Omit some internal or obsolete options to make the list less imposing.
1332    # This message is too long to be a string in the A/UX 3.1 sh.
1333    cat <<_ACEOF
1334 < \`configure' configures bopm 3.1.3 to adapt to many kinds of systems.
1334 > \`configure' configures hopm 1.1.5 to adapt to many kinds of systems.
1335  
1336   Usage: $0 [OPTION]... [VAR=VALUE]...
1337  
# Line 1372 | Line 1379 | Fine tuning of the installation director
1379    --infodir=DIR           info documentation [DATAROOTDIR/info]
1380    --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1381    --mandir=DIR            man documentation [DATAROOTDIR/man]
1382 <  --docdir=DIR            documentation root [DATAROOTDIR/doc/bopm]
1382 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/hopm]
1383    --htmldir=DIR           html documentation [DOCDIR]
1384    --dvidir=DIR            dvi documentation [DOCDIR]
1385    --pdfdir=DIR            pdf documentation [DOCDIR]
# Line 1394 | Line 1401 | fi
1401  
1402   if test -n "$ac_init_help"; then
1403    case $ac_init_help in
1404 <     short | recursive ) echo "Configuration of bopm 3.1.3:";;
1404 >     short | recursive ) echo "Configuration of hopm 1.1.5:";;
1405     esac
1406    cat <<\_ACEOF
1407  
# Line 1416 | Line 1423 | Optional Features:
1423    --enable-fast-install[=PKGS]
1424                            optimize for fast installation [default=yes]
1425    --disable-libtool-lock  avoid locking (might break parallel builds)
1426 +  --enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1427 +  --disable-openssl            Disable LibreSSL/OpenSSL support.
1428 +  --enable-assert         Enable assert() statements
1429 +  --enable-warnings       Enable compiler warnings.
1430  
1431   Optional Packages:
1432    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1433    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1423  --with-extra-fascism    Add extra gcc3-specific warning flags
1434    --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1435                            both]
1436    --with-aix-soname=aix|svr4|both
# Line 1429 | Line 1439 | Optional Packages:
1439    --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1440    --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
1441                            compiler's sysroot if not specified).
1432  --with-werror           use -Werror to abort compilation on any warning
1442  
1443   Some influential environment variables:
1444    CC          C compiler command
# Line 1439 | Line 1448 | Some influential environment variables:
1448    LIBS        libraries to pass to the linker, e.g. -l<library>
1449    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1450                you have headers in a nonstandard directory <include dir>
1451 +  LT_SYS_LIBRARY_PATH
1452 +              User-defined run-time library search path.
1453    CPP         C preprocessor
1454    YACC        The `Yet Another Compiler Compiler' implementation to use.
1455                Defaults to the first program found out of: `bison -y', `byacc',
# Line 1450 | Line 1461 | Some influential environment variables:
1461   Use these variables to override the choices made by `configure' or to help
1462   it to find libraries and programs with nonstandard names/locations.
1463  
1464 < Report bugs to the package provider.
1464 > Report bugs to <bugs@ircd-hybrid.org>.
1465   _ACEOF
1466   ac_status=$?
1467   fi
# Line 1513 | Line 1524 | fi
1524   test -n "$ac_init_help" && exit $ac_status
1525   if $ac_init_version; then
1526    cat <<\_ACEOF
1527 < bopm configure 3.1.3
1527 > hopm configure 1.1.5
1528   generated by GNU Autoconf 2.69
1529  
1530   Copyright (C) 2012 Free Software Foundation, Inc.
# Line 1787 | Line 1798 | $as_echo "$ac_res" >&6; }
1798    eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1799  
1800   } # ac_fn_c_check_func
1790
1791 # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1792 # -------------------------------------------------------
1793 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1794 # the include files in INCLUDES and setting the cache variable VAR
1795 # accordingly.
1796 ac_fn_c_check_header_mongrel ()
1797 {
1798  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1799  if eval \${$3+:} false; then :
1800  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1801 $as_echo_n "checking for $2... " >&6; }
1802 if eval \${$3+:} false; then :
1803  $as_echo_n "(cached) " >&6
1804 fi
1805 eval ac_res=\$$3
1806               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1807 $as_echo "$ac_res" >&6; }
1808 else
1809  # Is the header compilable?
1810 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1811 $as_echo_n "checking $2 usability... " >&6; }
1812 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1813 /* end confdefs.h.  */
1814 $4
1815 #include <$2>
1816 _ACEOF
1817 if ac_fn_c_try_compile "$LINENO"; then :
1818  ac_header_compiler=yes
1819 else
1820  ac_header_compiler=no
1821 fi
1822 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1823 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1824 $as_echo "$ac_header_compiler" >&6; }
1825
1826 # Is the header present?
1827 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1828 $as_echo_n "checking $2 presence... " >&6; }
1829 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1830 /* end confdefs.h.  */
1831 #include <$2>
1832 _ACEOF
1833 if ac_fn_c_try_cpp "$LINENO"; then :
1834  ac_header_preproc=yes
1835 else
1836  ac_header_preproc=no
1837 fi
1838 rm -f conftest.err conftest.i conftest.$ac_ext
1839 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1840 $as_echo "$ac_header_preproc" >&6; }
1841
1842 # So?  What about this header?
1843 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1844  yes:no: )
1845    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1846 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1847    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1848 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1849    ;;
1850  no:yes:* )
1851    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1852 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1853    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1854 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1855    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1856 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1857    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1858 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1859    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1860 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1861    ;;
1862 esac
1863  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1864 $as_echo_n "checking for $2... " >&6; }
1865 if eval \${$3+:} false; then :
1866  $as_echo_n "(cached) " >&6
1867 else
1868  eval "$3=\$ac_header_compiler"
1869 fi
1870 eval ac_res=\$$3
1871               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1872 $as_echo "$ac_res" >&6; }
1873 fi
1874  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1875
1876 } # ac_fn_c_check_header_mongrel
1877
1878 # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
1879 # -------------------------------------------
1880 # Tests whether TYPE exists after having included INCLUDES, setting cache
1881 # variable VAR accordingly.
1882 ac_fn_c_check_type ()
1883 {
1884  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1885  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1886 $as_echo_n "checking for $2... " >&6; }
1887 if eval \${$3+:} false; then :
1888  $as_echo_n "(cached) " >&6
1889 else
1890  eval "$3=no"
1891  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1892 /* end confdefs.h.  */
1893 $4
1894 int
1895 main ()
1896 {
1897 if (sizeof ($2))
1898         return 0;
1899  ;
1900  return 0;
1901 }
1902 _ACEOF
1903 if ac_fn_c_try_compile "$LINENO"; then :
1904  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1905 /* end confdefs.h.  */
1906 $4
1907 int
1908 main ()
1909 {
1910 if (sizeof (($2)))
1911            return 0;
1912  ;
1913  return 0;
1914 }
1915 _ACEOF
1916 if ac_fn_c_try_compile "$LINENO"; then :
1917
1918 else
1919  eval "$3=yes"
1920 fi
1921 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1922 fi
1923 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1924 fi
1925 eval ac_res=\$$3
1926               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1927 $as_echo "$ac_res" >&6; }
1928  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1929
1930 } # ac_fn_c_check_type
1931
1932 # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
1933 # --------------------------------------------
1934 # Tries to find the compile-time value of EXPR in a program that includes
1935 # INCLUDES, setting VAR accordingly. Returns whether the value could be
1936 # computed
1937 ac_fn_c_compute_int ()
1938 {
1939  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1940  if test "$cross_compiling" = yes; then
1941    # Depending upon the size, compute the lo and hi bounds.
1942 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1943 /* end confdefs.h.  */
1944 $4
1945 int
1946 main ()
1947 {
1948 static int test_array [1 - 2 * !(($2) >= 0)];
1949 test_array [0] = 0;
1950 return test_array [0];
1951
1952  ;
1953  return 0;
1954 }
1955 _ACEOF
1956 if ac_fn_c_try_compile "$LINENO"; then :
1957  ac_lo=0 ac_mid=0
1958  while :; do
1959    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1960 /* end confdefs.h.  */
1961 $4
1962 int
1963 main ()
1964 {
1965 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1966 test_array [0] = 0;
1967 return test_array [0];
1968
1969  ;
1970  return 0;
1971 }
1972 _ACEOF
1973 if ac_fn_c_try_compile "$LINENO"; then :
1974  ac_hi=$ac_mid; break
1975 else
1976  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
1977                        if test $ac_lo -le $ac_mid; then
1978                          ac_lo= ac_hi=
1979                          break
1980                        fi
1981                        as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
1982 fi
1983 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1984  done
1985 else
1986  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1987 /* end confdefs.h.  */
1988 $4
1989 int
1990 main ()
1991 {
1992 static int test_array [1 - 2 * !(($2) < 0)];
1993 test_array [0] = 0;
1994 return test_array [0];
1995
1996  ;
1997  return 0;
1998 }
1999 _ACEOF
2000 if ac_fn_c_try_compile "$LINENO"; then :
2001  ac_hi=-1 ac_mid=-1
2002  while :; do
2003    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2004 /* end confdefs.h.  */
2005 $4
2006 int
2007 main ()
2008 {
2009 static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2010 test_array [0] = 0;
2011 return test_array [0];
2012
2013  ;
2014  return 0;
2015 }
2016 _ACEOF
2017 if ac_fn_c_try_compile "$LINENO"; then :
2018  ac_lo=$ac_mid; break
2019 else
2020  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2021                        if test $ac_mid -le $ac_hi; then
2022                          ac_lo= ac_hi=
2023                          break
2024                        fi
2025                        as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2026 fi
2027 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2028  done
2029 else
2030  ac_lo= ac_hi=
2031 fi
2032 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2033 fi
2034 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2035 # Binary search between lo and hi bounds.
2036 while test "x$ac_lo" != "x$ac_hi"; do
2037  as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2038  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2039 /* end confdefs.h.  */
2040 $4
2041 int
2042 main ()
2043 {
2044 static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2045 test_array [0] = 0;
2046 return test_array [0];
2047
2048  ;
2049  return 0;
2050 }
2051 _ACEOF
2052 if ac_fn_c_try_compile "$LINENO"; then :
2053  ac_hi=$ac_mid
2054 else
2055  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2056 fi
2057 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2058 done
2059 case $ac_lo in #((
2060 ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2061 '') ac_retval=1 ;;
2062 esac
2063  else
2064    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2065 /* end confdefs.h.  */
2066 $4
2067 static long int longval () { return $2; }
2068 static unsigned long int ulongval () { return $2; }
2069 #include <stdio.h>
2070 #include <stdlib.h>
2071 int
2072 main ()
2073 {
2074
2075  FILE *f = fopen ("conftest.val", "w");
2076  if (! f)
2077    return 1;
2078  if (($2) < 0)
2079    {
2080      long int i = longval ();
2081      if (i != ($2))
2082        return 1;
2083      fprintf (f, "%ld", i);
2084    }
2085  else
2086    {
2087      unsigned long int i = ulongval ();
2088      if (i != ($2))
2089        return 1;
2090      fprintf (f, "%lu", i);
2091    }
2092  /* Do not output a trailing newline, as this causes \r\n confusion
2093     on some platforms.  */
2094  return ferror (f) || fclose (f) != 0;
2095
2096  ;
2097  return 0;
2098 }
2099 _ACEOF
2100 if ac_fn_c_try_run "$LINENO"; then :
2101  echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2102 else
2103  ac_retval=1
2104 fi
2105 rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2106  conftest.$ac_objext conftest.beam conftest.$ac_ext
2107 rm -f conftest.val
2108
2109  fi
2110  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2111  as_fn_set_status $ac_retval
2112
2113 } # ac_fn_c_compute_int
1801   cat >config.log <<_ACEOF
1802   This file contains any messages produced by compilers while
1803   running configure, to aid debugging if configure makes a mistake.
1804  
1805 < It was created by bopm $as_me 3.1.3, which was
1805 > It was created by hopm $as_me 1.1.5, which was
1806   generated by GNU Autoconf 2.69.  Invocation command line was
1807  
1808    $ $0 $@
# Line 2463 | Line 2150 | ac_link='$CC -o conftest$ac_exeext $CFLA
2150   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2151  
2152  
2153 <
2467 < ac_config_headers="$ac_config_headers src/setup.h"
2468 <
2469 < am__api_version='1.14'
2153 > am__api_version='1.15'
2154  
2155   ac_aux_dir=
2156   for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
# Line 2667 | Line 2351 | test "$program_suffix" != NONE &&
2351   ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2352   program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2353  
2354 < # expand $ac_aux_dir to an absolute path
2355 < am_aux_dir=`cd $ac_aux_dir && pwd`
2354 > # Expand $ac_aux_dir to an absolute path.
2355 > am_aux_dir=`cd "$ac_aux_dir" && pwd`
2356  
2357   if test x"${MISSING+set}" != xset; then
2358    case $am_aux_dir in
# Line 2687 | Line 2371 | else
2371   $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2372   fi
2373  
2374 < if test x"${install_sh}" != xset; then
2374 > if test x"${install_sh+set}" != xset; then
2375    case $am_aux_dir in
2376    *\ * | *\     *)
2377      install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
# Line 2980 | Line 2664 | fi
2664  
2665  
2666   # Define the identity of the package.
2667 < PACKAGE='bopm'
2668 < VERSION='3.1.3'
2667 > PACKAGE='hopm'
2668 > VERSION='1.1.5'
2669  
2670  
2671   cat >>confdefs.h <<_ACEOF
# Line 3015 | Line 2699 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2699   # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2700   mkdir_p='$(MKDIR_P)'
2701  
2702 < # We need awk for the "check" target.  The system "awk" is bad on
2703 < # some platforms.
2702 > # We need awk for the "check" target (and possibly the TAP driver).  The
2703 > # system "awk" is bad on some platforms.
2704   # Always define AMTAR for backward compatibility.  Yes, it's still used
2705   # in the wild :-(  We should find a proper way to deprecate it ...
2706   AMTAR='$${TAR-tar}'
# Line 3098 | Line 2782 | fi
2782  
2783  
2784  
2785 <
3102 < # Check whether --with-extra-fascism was given.
3103 < if test "${with_extra_fascism+set}" = set; then :
3104 <  withval=$with_extra_fascism; CFLAGS="$CFLAGS -g -O0 -W -Wall -Wfloat-equal -Wbad-function-cast -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls -Wnested-externs"
3105 < fi
3106 <
2785 > ac_config_headers="$ac_config_headers src/setup.h"
2786  
2787  
2788  
# Line 4335 | Line 4014 | esac
4014  
4015  
4016  
4017 < macro_version='2.4.4'
4018 < macro_revision='2.4.4'
4017 > macro_version='2.4.6'
4018 > macro_revision='2.4.6'
4019  
4020  
4021  
# Line 6759 | Line 6438 | $as_echo "$lt_cv_truncate_bin" >&6; }
6438  
6439  
6440  
6441 +
6442 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6443 + func_cc_basename ()
6444 + {
6445 +    for cc_temp in $*""; do
6446 +      case $cc_temp in
6447 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6448 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6449 +        \-*) ;;
6450 +        *) break;;
6451 +      esac
6452 +    done
6453 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6454 + }
6455 +
6456   # Check whether --enable-libtool-lock was given.
6457   if test "${enable_libtool_lock+set}" = set; then :
6458    enableval=$enable_libtool_lock;
# Line 7766 | Line 7460 | $as_echo "$lt_cv_ld_force_load" >&6; }
7460      ;;
7461    esac
7462  
7463 + # func_munge_path_list VARIABLE PATH
7464 + # -----------------------------------
7465 + # VARIABLE is name of variable containing _space_ separated list of
7466 + # directories to be munged by the contents of PATH, which is string
7467 + # having a format:
7468 + # "DIR[:DIR]:"
7469 + #       string "DIR[ DIR]" will be prepended to VARIABLE
7470 + # ":DIR[:DIR]"
7471 + #       string "DIR[ DIR]" will be appended to VARIABLE
7472 + # "DIRP[:DIRP]::[DIRA:]DIRA"
7473 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7474 + #       "DIRA[ DIRA]" will be appended to VARIABLE
7475 + # "DIR[:DIR]"
7476 + #       VARIABLE will be replaced by "DIR[ DIR]"
7477 + func_munge_path_list ()
7478 + {
7479 +    case x$2 in
7480 +    x)
7481 +        ;;
7482 +    *:)
7483 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7484 +        ;;
7485 +    x:*)
7486 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7487 +        ;;
7488 +    *::*)
7489 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7490 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7491 +        ;;
7492 +    *)
7493 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7494 +        ;;
7495 +    esac
7496 + }
7497 +
7498   ac_ext=c
7499   ac_cpp='$CPP $CPPFLAGS'
7500   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8353 | Line 8082 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8082   test -z "$LD" && LD=ld
8083   test -z "$ac_objext" && ac_objext=o
8084  
8085 < for cc_temp in $compiler""; do
8086 <  case $cc_temp in
8358 <    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
8359 <    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
8360 <    \-*) ;;
8361 <    *) break;;
8362 <  esac
8363 < done
8364 < cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
8085 > func_cc_basename $compiler
8086 > cc_basename=$func_cc_basename_result
8087  
8088  
8089   # Only perform the check for file, if the check method requires it
# Line 8561 | Line 8283 | _lt_linker_boilerplate=`cat conftest.err
8283   $RM -r conftest*
8284  
8285  
8286 + ## CAVEAT EMPTOR:
8287 + ## There is no encapsulation within the following macros, do not change
8288 + ## the running order or otherwise move them around unless you know exactly
8289 + ## what you are doing...
8290   if test -n "$compiler"; then
8291  
8292   lt_prog_compiler_no_builtin_flag=
# Line 10816 | Line 10542 | hardcode_into_libs=no
10542   # flags to be left without arguments
10543   need_version=unknown
10544  
10545 +
10546 +
10547   case $host_os in
10548   aix3*)
10549    version_type=linux # correct to gnu/linux during the next big refactor
# Line 11104 | Line 10832 | freebsd* | dragonfly*)
10832    case $version_type in
10833      freebsd-elf*)
10834        library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10835 +      soname_spec='$libname$release$shared_ext$major'
10836        need_version=no
10837        need_lib_prefix=no
10838        ;;
# Line 11163 | Line 10892 | hpux9* | hpux10* | hpux11*)
10892      soname_spec='$libname$release$shared_ext$major'
10893      if test 32 = "$HPUX_IA64_MODE"; then
10894        sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10895 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10896      else
10897        sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10898 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10899      fi
11169    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10900      ;;
10901    hppa*64*)
10902      shrext_cmds='.sl'
# Line 11318 | Line 11048 | fi
11048    # before this can be enabled.
11049    hardcode_into_libs=yes
11050  
11051 <  # Append ld.so.conf contents to the search path
11051 >  # Ideally, we could use ldconfig to report *all* directores which are
11052 >  # searched for libraries, however this is still not possible.  Aside from not
11053 >  # being certain /sbin/ldconfig is available, command
11054 >  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11055 >  # even though it is searched at run-time.  Try to do the best guess by
11056 >  # appending ld.so.conf contents (and includes) to the search path.
11057    if test -f /etc/ld.so.conf; then
11058      lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[       ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
11059      sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
# Line 11543 | Line 11278 | fi
11278   if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11279    sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11280   fi
11281 +
11282   if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11283    sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11284   fi
11285  
11286 + # remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11287 + configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11288 +
11289 + # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11290 + func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11291 +
11292 + # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11293 + configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11294 +
11295 +
11296 +
11297 +
11298 +
11299 +
11300  
11301  
11302  
# Line 12327 | Line 12077 | CC=$lt_save_CC
12077  
12078  
12079  
12080 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
12081 < $as_echo_n "checking for ANSI C header files... " >&6; }
12082 < if ${ac_cv_header_stdc+:} false; then :
12080 > for ac_prog in 'bison -y' byacc
12081 > do
12082 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
12083 > set dummy $ac_prog; ac_word=$2
12084 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12085 > $as_echo_n "checking for $ac_word... " >&6; }
12086 > if ${ac_cv_prog_YACC+:} false; then :
12087    $as_echo_n "(cached) " >&6
12088   else
12089 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12089 >  if test -n "$YACC"; then
12090 >  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12091 > else
12092 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12093 > for as_dir in $PATH
12094 > do
12095 >  IFS=$as_save_IFS
12096 >  test -z "$as_dir" && as_dir=.
12097 >    for ac_exec_ext in '' $ac_executable_extensions; do
12098 >  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12099 >    ac_cv_prog_YACC="$ac_prog"
12100 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12101 >    break 2
12102 >  fi
12103 > done
12104 >  done
12105 > IFS=$as_save_IFS
12106 >
12107 > fi
12108 > fi
12109 > YACC=$ac_cv_prog_YACC
12110 > if test -n "$YACC"; then
12111 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
12112 > $as_echo "$YACC" >&6; }
12113 > else
12114 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12115 > $as_echo "no" >&6; }
12116 > fi
12117 >
12118 >
12119 >  test -n "$YACC" && break
12120 > done
12121 > test -n "$YACC" || YACC="yacc"
12122 >
12123 >
12124 > for ac_prog in flex lex
12125 > do
12126 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
12127 > set dummy $ac_prog; ac_word=$2
12128 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12129 > $as_echo_n "checking for $ac_word... " >&6; }
12130 > if ${ac_cv_prog_LEX+:} false; then :
12131 >  $as_echo_n "(cached) " >&6
12132 > else
12133 >  if test -n "$LEX"; then
12134 >  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12135 > else
12136 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12137 > for as_dir in $PATH
12138 > do
12139 >  IFS=$as_save_IFS
12140 >  test -z "$as_dir" && as_dir=.
12141 >    for ac_exec_ext in '' $ac_executable_extensions; do
12142 >  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12143 >    ac_cv_prog_LEX="$ac_prog"
12144 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12145 >    break 2
12146 >  fi
12147 > done
12148 >  done
12149 > IFS=$as_save_IFS
12150 >
12151 > fi
12152 > fi
12153 > LEX=$ac_cv_prog_LEX
12154 > if test -n "$LEX"; then
12155 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
12156 > $as_echo "$LEX" >&6; }
12157 > else
12158 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12159 > $as_echo "no" >&6; }
12160 > fi
12161 >
12162 >
12163 >  test -n "$LEX" && break
12164 > done
12165 > test -n "$LEX" || LEX=":"
12166 >
12167 > if test "x$LEX" != "x:"; then
12168 >  cat >conftest.l <<_ACEOF
12169 > %%
12170 > a { ECHO; }
12171 > b { REJECT; }
12172 > c { yymore (); }
12173 > d { yyless (1); }
12174 > e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
12175 >    yyless ((input () != 0)); }
12176 > f { unput (yytext[0]); }
12177 > . { BEGIN INITIAL; }
12178 > %%
12179 > #ifdef YYTEXT_POINTER
12180 > extern char *yytext;
12181 > #endif
12182 > int
12183 > main (void)
12184 > {
12185 >  return ! yylex () + ! yywrap ();
12186 > }
12187 > _ACEOF
12188 > { { ac_try="$LEX conftest.l"
12189 > case "(($ac_try" in
12190 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12191 >  *) ac_try_echo=$ac_try;;
12192 > esac
12193 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
12194 > $as_echo "$ac_try_echo"; } >&5
12195 >  (eval "$LEX conftest.l") 2>&5
12196 >  ac_status=$?
12197 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12198 >  test $ac_status = 0; }
12199 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
12200 > $as_echo_n "checking lex output file root... " >&6; }
12201 > if ${ac_cv_prog_lex_root+:} false; then :
12202 >  $as_echo_n "(cached) " >&6
12203 > else
12204 >
12205 > if test -f lex.yy.c; then
12206 >  ac_cv_prog_lex_root=lex.yy
12207 > elif test -f lexyy.c; then
12208 >  ac_cv_prog_lex_root=lexyy
12209 > else
12210 >  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
12211 > fi
12212 > fi
12213 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
12214 > $as_echo "$ac_cv_prog_lex_root" >&6; }
12215 > LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12216 >
12217 > if test -z "${LEXLIB+set}"; then
12218 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
12219 > $as_echo_n "checking lex library... " >&6; }
12220 > if ${ac_cv_lib_lex+:} false; then :
12221 >  $as_echo_n "(cached) " >&6
12222 > else
12223 >
12224 >    ac_save_LIBS=$LIBS
12225 >    ac_cv_lib_lex='none needed'
12226 >    for ac_lib in '' -lfl -ll; do
12227 >      LIBS="$ac_lib $ac_save_LIBS"
12228 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12229 > /* end confdefs.h.  */
12230 > `cat $LEX_OUTPUT_ROOT.c`
12231 > _ACEOF
12232 > if ac_fn_c_try_link "$LINENO"; then :
12233 >  ac_cv_lib_lex=$ac_lib
12234 > fi
12235 > rm -f core conftest.err conftest.$ac_objext \
12236 >    conftest$ac_exeext conftest.$ac_ext
12237 >      test "$ac_cv_lib_lex" != 'none needed' && break
12238 >    done
12239 >    LIBS=$ac_save_LIBS
12240 >
12241 > fi
12242 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
12243 > $as_echo "$ac_cv_lib_lex" >&6; }
12244 >  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
12245 > fi
12246 >
12247 >
12248 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
12249 > $as_echo_n "checking whether yytext is a pointer... " >&6; }
12250 > if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
12251 >  $as_echo_n "(cached) " >&6
12252 > else
12253 >  # POSIX says lex can declare yytext either as a pointer or an array; the
12254 > # default is implementation-dependent.  Figure out which it is, since
12255 > # not all implementations provide the %pointer and %array declarations.
12256 > ac_cv_prog_lex_yytext_pointer=no
12257 > ac_save_LIBS=$LIBS
12258 > LIBS="$LEXLIB $ac_save_LIBS"
12259 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12260 > /* end confdefs.h.  */
12261 >
12262 >  #define YYTEXT_POINTER 1
12263 > `cat $LEX_OUTPUT_ROOT.c`
12264 > _ACEOF
12265 > if ac_fn_c_try_link "$LINENO"; then :
12266 >  ac_cv_prog_lex_yytext_pointer=yes
12267 > fi
12268 > rm -f core conftest.err conftest.$ac_objext \
12269 >    conftest$ac_exeext conftest.$ac_ext
12270 > LIBS=$ac_save_LIBS
12271 >
12272 > fi
12273 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
12274 > $as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
12275 > if test $ac_cv_prog_lex_yytext_pointer = yes; then
12276 >
12277 > $as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
12278 >
12279 > fi
12280 > rm -f conftest.l $LEX_OUTPUT_ROOT.c
12281 >
12282 > fi
12283 > if test "$LEX" = :; then
12284 >  LEX=${am_missing_run}flex
12285 > fi
12286 >
12287 >
12288 >
12289 >  if test "X$CC" != "X"; then
12290 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12291 > $as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12292 > if ${ssp_cv_cc+:} false; then :
12293 >  $as_echo_n "(cached) " >&6
12294 > else
12295 >  ssp_old_cflags="$CFLAGS"
12296 >       CFLAGS="$CFLAGS -fstack-protector-strong"
12297 >       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12298   /* end confdefs.h.  */
12337 #include <stdlib.h>
12338 #include <stdarg.h>
12339 #include <string.h>
12340 #include <float.h>
12299  
12300   int
12301   main ()
# Line 12348 | Line 12306 | main ()
12306   }
12307   _ACEOF
12308   if ac_fn_c_try_compile "$LINENO"; then :
12309 <  ac_cv_header_stdc=yes
12309 >  ssp_cv_cc=yes
12310   else
12311 <  ac_cv_header_stdc=no
12311 >  ssp_cv_cc=no
12312   fi
12313   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12314 +       CFLAGS="$ssp_old_cflags"
12315  
12316 < if test $ac_cv_header_stdc = yes; then
12317 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
12318 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12316 > fi
12317 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12318 > $as_echo "$ssp_cv_cc" >&6; }
12319 >    if test $ssp_cv_cc = yes; then
12320 >      CFLAGS="$CFLAGS -fstack-protector-strong"
12321 >
12322 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12323 >
12324 >    else
12325 >      unset ssp_cv_cc
12326 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12327 > $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12328 > if ${ssp_cv_cc+:} false; then :
12329 >  $as_echo_n "(cached) " >&6
12330 > else
12331 >  ssp_old_cflags="$CFLAGS"
12332 >         CFLAGS="$CFLAGS -fstack-protector"
12333 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12334   /* end confdefs.h.  */
12361 #include <string.h>
12335  
12336 + int
12337 + main ()
12338 + {
12339 +
12340 +  ;
12341 +  return 0;
12342 + }
12343   _ACEOF
12344 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12345 <  $EGREP "memchr" >/dev/null 2>&1; then :
12344 > if ac_fn_c_try_compile "$LINENO"; then :
12345 >  ssp_cv_cc=yes
12346 > else
12347 >  ssp_cv_cc=no
12348 > fi
12349 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12350 >         CFLAGS="$ssp_old_cflags"
12351  
12352 + fi
12353 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12354 + $as_echo "$ssp_cv_cc" >&6; }
12355 +      if test $ssp_cv_cc = yes; then
12356 +        CFLAGS="$CFLAGS -fstack-protector"
12357 +
12358 + $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12359 +
12360 +      fi
12361 +    fi
12362 +  fi
12363 +
12364 +
12365 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12366 + $as_echo_n "checking whether libssp exists... " >&6; }
12367 + if ${ssp_cv_lib+:} false; then :
12368 +  $as_echo_n "(cached) " >&6
12369   else
12370 <  ac_cv_header_stdc=no
12370 >  ssp_old_libs="$LIBS"
12371 >     LIBS="$LIBS -lssp"
12372 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12373 > /* end confdefs.h.  */
12374 >
12375 > int
12376 > main ()
12377 > {
12378 >
12379 >  ;
12380 >  return 0;
12381 > }
12382 > _ACEOF
12383 > if ac_fn_c_try_link "$LINENO"; then :
12384 >  ssp_cv_lib=yes
12385 > else
12386 >  ssp_cv_lib=no
12387   fi
12388 < rm -f conftest*
12388 > rm -f core conftest.err conftest.$ac_objext \
12389 >    conftest$ac_exeext conftest.$ac_ext
12390 >     LIBS="$ssp_old_libs"
12391  
12392   fi
12393 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12394 + $as_echo "$ssp_cv_lib" >&6; }
12395 +  if test $ssp_cv_lib = yes; then
12396 +    LIBS="$LIBS -lssp"
12397 +  fi
12398  
12399 < if test $ac_cv_header_stdc = yes; then
12400 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
12401 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12399 >
12400 >
12401 >  ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12402 > if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12403 >
12404 > else
12405 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing getaddrinfo" >&5
12406 > $as_echo_n "checking for library containing getaddrinfo... " >&6; }
12407 > if ${ac_cv_search_getaddrinfo+:} false; then :
12408 >  $as_echo_n "(cached) " >&6
12409 > else
12410 >  ac_func_search_save_LIBS=$LIBS
12411 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12412   /* end confdefs.h.  */
12378 #include <stdlib.h>
12413  
12414 + /* Override any GCC internal prototype to avoid an error.
12415 +   Use char because int might match the return type of a GCC
12416 +   builtin and then its argument prototype would still apply.  */
12417 + #ifdef __cplusplus
12418 + extern "C"
12419 + #endif
12420 + char getaddrinfo ();
12421 + int
12422 + main ()
12423 + {
12424 + return getaddrinfo ();
12425 +  ;
12426 +  return 0;
12427 + }
12428   _ACEOF
12429 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12430 <  $EGREP "free" >/dev/null 2>&1; then :
12429 > for ac_lib in '' nsl; do
12430 >  if test -z "$ac_lib"; then
12431 >    ac_res="none required"
12432 >  else
12433 >    ac_res=-l$ac_lib
12434 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12435 >  fi
12436 >  if ac_fn_c_try_link "$LINENO"; then :
12437 >  ac_cv_search_getaddrinfo=$ac_res
12438 > fi
12439 > rm -f core conftest.err conftest.$ac_objext \
12440 >    conftest$ac_exeext
12441 >  if ${ac_cv_search_getaddrinfo+:} false; then :
12442 >  break
12443 > fi
12444 > done
12445 > if ${ac_cv_search_getaddrinfo+:} false; then :
12446  
12447   else
12448 <  ac_cv_header_stdc=no
12448 >  ac_cv_search_getaddrinfo=no
12449   fi
12450 < rm -f conftest*
12450 > rm conftest.$ac_ext
12451 > LIBS=$ac_func_search_save_LIBS
12452 > fi
12453 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getaddrinfo" >&5
12454 > $as_echo "$ac_cv_search_getaddrinfo" >&6; }
12455 > ac_res=$ac_cv_search_getaddrinfo
12456 > if test "$ac_res" != no; then :
12457 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12458  
12459   fi
12460  
12461 < if test $ac_cv_header_stdc = yes; then
12462 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
12461 > fi
12462 >
12463 >  ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12464 > if test "x$ac_cv_func_getnameinfo" = xyes; then :
12465 >
12466 > else
12467 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing getnameinfo" >&5
12468 > $as_echo_n "checking for library containing getnameinfo... " >&6; }
12469 > if ${ac_cv_search_getnameinfo+:} false; then :
12470 >  $as_echo_n "(cached) " >&6
12471 > else
12472 >  ac_func_search_save_LIBS=$LIBS
12473 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12474 > /* end confdefs.h.  */
12475 >
12476 > /* Override any GCC internal prototype to avoid an error.
12477 >   Use char because int might match the return type of a GCC
12478 >   builtin and then its argument prototype would still apply.  */
12479 > #ifdef __cplusplus
12480 > extern "C"
12481 > #endif
12482 > char getnameinfo ();
12483 > int
12484 > main ()
12485 > {
12486 > return getnameinfo ();
12487 >  ;
12488 >  return 0;
12489 > }
12490 > _ACEOF
12491 > for ac_lib in '' nsl; do
12492 >  if test -z "$ac_lib"; then
12493 >    ac_res="none required"
12494 >  else
12495 >    ac_res=-l$ac_lib
12496 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12497 >  fi
12498 >  if ac_fn_c_try_link "$LINENO"; then :
12499 >  ac_cv_search_getnameinfo=$ac_res
12500 > fi
12501 > rm -f core conftest.err conftest.$ac_objext \
12502 >    conftest$ac_exeext
12503 >  if ${ac_cv_search_getnameinfo+:} false; then :
12504 >  break
12505 > fi
12506 > done
12507 > if ${ac_cv_search_getnameinfo+:} false; then :
12508 >
12509 > else
12510 >  ac_cv_search_getnameinfo=no
12511 > fi
12512 > rm conftest.$ac_ext
12513 > LIBS=$ac_func_search_save_LIBS
12514 > fi
12515 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getnameinfo" >&5
12516 > $as_echo "$ac_cv_search_getnameinfo" >&6; }
12517 > ac_res=$ac_cv_search_getnameinfo
12518 > if test "$ac_res" != no; then :
12519 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12520 >
12521 > fi
12522 >
12523 > fi
12524 >
12525 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12526 > $as_echo_n "checking for library containing socket... " >&6; }
12527 > if ${ac_cv_search_socket+:} false; then :
12528 >  $as_echo_n "(cached) " >&6
12529 > else
12530 >  ac_func_search_save_LIBS=$LIBS
12531 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12532 > /* end confdefs.h.  */
12533 >
12534 > /* Override any GCC internal prototype to avoid an error.
12535 >   Use char because int might match the return type of a GCC
12536 >   builtin and then its argument prototype would still apply.  */
12537 > #ifdef __cplusplus
12538 > extern "C"
12539 > #endif
12540 > char socket ();
12541 > int
12542 > main ()
12543 > {
12544 > return socket ();
12545 >  ;
12546 >  return 0;
12547 > }
12548 > _ACEOF
12549 > for ac_lib in '' socket; do
12550 >  if test -z "$ac_lib"; then
12551 >    ac_res="none required"
12552 >  else
12553 >    ac_res=-l$ac_lib
12554 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12555 >  fi
12556 >  if ac_fn_c_try_link "$LINENO"; then :
12557 >  ac_cv_search_socket=$ac_res
12558 > fi
12559 > rm -f core conftest.err conftest.$ac_objext \
12560 >    conftest$ac_exeext
12561 >  if ${ac_cv_search_socket+:} false; then :
12562 >  break
12563 > fi
12564 > done
12565 > if ${ac_cv_search_socket+:} false; then :
12566 >
12567 > else
12568 >  ac_cv_search_socket=no
12569 > fi
12570 > rm conftest.$ac_ext
12571 > LIBS=$ac_func_search_save_LIBS
12572 > fi
12573 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12574 > $as_echo "$ac_cv_search_socket" >&6; }
12575 > ac_res=$ac_cv_search_socket
12576 > if test "$ac_res" != no; then :
12577 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12578 >
12579 > else
12580 >  as_fn_error $? "socket library not found" "$LINENO" 5
12581 > fi
12582 >
12583 >
12584 >
12585 > # Check whether --enable-openssl was given.
12586 > if test "${enable_openssl+set}" = set; then :
12587 >  enableval=$enable_openssl;  cf_enable_openssl=$enableval
12588 > else
12589 >   cf_enable_openssl="auto"
12590 > fi
12591 >
12592 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12593 > $as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12594 > if test "$cf_enable_openssl" != "no"; then
12595 >  cf_openssl_basedir=""
12596 >  if test "$cf_enable_openssl" != "auto" &&
12597 >     test "$cf_enable_openssl" != "yes"; then
12598 >          cf_openssl_basedir="${cf_enable_openssl}"
12599 >  else
12600 >        for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12601 >                /opt /opt/openssl /usr/local/openssl; do
12602 >      if test -f "${dirs}/include/openssl/opensslv.h"; then
12603 >        cf_openssl_basedir="${dirs}"
12604 >        break
12605 >      fi
12606 >    done
12607 >    unset dirs
12608 >  fi
12609 >
12610 >    if test ! -z "$cf_openssl_basedir"; then
12611 >    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12612 >      CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12613 >      LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12614 >    else
12615 >                  cf_openssl_basedir=""
12616 >    fi
12617 >  else
12618 >                            if test -f "/usr/include/openssl/opensslv.h"; then
12619 >      cf_openssl_basedir="/usr"
12620 >    fi
12621 >  fi
12622 >
12623 >      if test ! -z "$cf_openssl_basedir"; then
12624 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12625 > $as_echo "$cf_openssl_basedir" >&6; }
12626 >    cf_enable_openssl="yes"
12627 >  else
12628 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12629 > $as_echo "not found. Please check your path." >&6; }
12630 >    cf_enable_openssl="no"
12631 >  fi
12632 >  unset cf_openssl_basedir
12633 > else
12634 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12635 > $as_echo "disabled" >&6; }
12636 > fi
12637 >
12638 > if test "$cf_enable_openssl" != "no"; then :
12639 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 0.9.8o and above" >&5
12640 > $as_echo_n "checking for LibreSSL or OpenSSL 0.9.8o and above... " >&6; }
12641    if test "$cross_compiling" = yes; then :
12642 <  :
12642 >  cf_openssl_version_ok=no
12643   else
12644    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12645   /* end confdefs.h.  */
12398 #include <ctype.h>
12399 #include <stdlib.h>
12400 #if ((' ' & 0x0FF) == 0x020)
12401 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
12402 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
12403 #else
12404 # define ISLOWER(c) \
12405                   (('a' <= (c) && (c) <= 'i') \
12406                     || ('j' <= (c) && (c) <= 'r') \
12407                     || ('s' <= (c) && (c) <= 'z'))
12408 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
12409 #endif
12646  
12647 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
12647 >
12648 >    #include <openssl/opensslv.h>
12649 >    #include <stdlib.h>
12650   int
12651   main ()
12652   {
12653 <  int i;
12654 <  for (i = 0; i < 256; i++)
12417 <    if (XOR (islower (i), ISLOWER (i))
12418 <        || toupper (i) != TOUPPER (i))
12419 <      return 2;
12653 > exit(!(OPENSSL_VERSION_NUMBER >= 0x009080ffL));
12654 >  ;
12655    return 0;
12656   }
12657   _ACEOF
12658   if ac_fn_c_try_run "$LINENO"; then :
12659 <
12659 >  cf_openssl_version_ok=yes
12660   else
12661 <  ac_cv_header_stdc=no
12661 >  cf_openssl_version_ok=no
12662   fi
12663   rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12664    conftest.$ac_objext conftest.beam conftest.$ac_ext
12665   fi
12666  
12667 +
12668 +  if test "$cf_openssl_version_ok" = "yes"; then :
12669 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12670 + $as_echo "found" >&6; }
12671 +
12672 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12673 + $as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12674 + if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12675 +  $as_echo_n "(cached) " >&6
12676 + else
12677 +  ac_check_lib_save_LIBS=$LIBS
12678 + LIBS="-lcrypto  $LIBS"
12679 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12680 + /* end confdefs.h.  */
12681 +
12682 + /* Override any GCC internal prototype to avoid an error.
12683 +   Use char because int might match the return type of a GCC
12684 +   builtin and then its argument prototype would still apply.  */
12685 + #ifdef __cplusplus
12686 + extern "C"
12687 + #endif
12688 + char RSA_free ();
12689 + int
12690 + main ()
12691 + {
12692 + return RSA_free ();
12693 +  ;
12694 +  return 0;
12695 + }
12696 + _ACEOF
12697 + if ac_fn_c_try_link "$LINENO"; then :
12698 +  ac_cv_lib_crypto_RSA_free=yes
12699 + else
12700 +  ac_cv_lib_crypto_RSA_free=no
12701   fi
12702 + rm -f core conftest.err conftest.$ac_objext \
12703 +    conftest$ac_exeext conftest.$ac_ext
12704 + LIBS=$ac_check_lib_save_LIBS
12705   fi
12706 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
12707 < $as_echo "$ac_cv_header_stdc" >&6; }
12708 < if test $ac_cv_header_stdc = yes; then
12706 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12707 > $as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12708 > if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12709 >  cat >>confdefs.h <<_ACEOF
12710 > #define HAVE_LIBCRYPTO 1
12711 > _ACEOF
12712  
12713 < $as_echo "#define STDC_HEADERS 1" >>confdefs.h
12713 >  LIBS="-lcrypto $LIBS"
12714  
12715   fi
12716  
12717 +    if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12718 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12719 + $as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12720 + if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12721 +  $as_echo_n "(cached) " >&6
12722 + else
12723 +  ac_check_lib_save_LIBS=$LIBS
12724 + LIBS="-lssl  $LIBS"
12725 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12726 + /* end confdefs.h.  */
12727  
12728 < for ac_header in sys/poll.h
12729 < do :
12730 <  ac_fn_c_check_header_mongrel "$LINENO" "sys/poll.h" "ac_cv_header_sys_poll_h" "$ac_includes_default"
12731 < if test "x$ac_cv_header_sys_poll_h" = xyes; then :
12728 > /* Override any GCC internal prototype to avoid an error.
12729 >   Use char because int might match the return type of a GCC
12730 >   builtin and then its argument prototype would still apply.  */
12731 > #ifdef __cplusplus
12732 > extern "C"
12733 > #endif
12734 > char SSL_connect ();
12735 > int
12736 > main ()
12737 > {
12738 > return SSL_connect ();
12739 >  ;
12740 >  return 0;
12741 > }
12742 > _ACEOF
12743 > if ac_fn_c_try_link "$LINENO"; then :
12744 >  ac_cv_lib_ssl_SSL_connect=yes
12745 > else
12746 >  ac_cv_lib_ssl_SSL_connect=no
12747 > fi
12748 > rm -f core conftest.err conftest.$ac_objext \
12749 >    conftest$ac_exeext conftest.$ac_ext
12750 > LIBS=$ac_check_lib_save_LIBS
12751 > fi
12752 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12753 > $as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12754 > if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12755    cat >>confdefs.h <<_ACEOF
12756 < #define HAVE_SYS_POLL_H 1
12756 > #define HAVE_LIBSSL 1
12757   _ACEOF
12758 < have_poll_sys_h=yes
12758 >
12759 >  LIBS="-lssl $LIBS"
12760 >
12761 > fi
12762 >
12763 > fi
12764 >
12765   else
12766 <  have_sys_poll_h=no
12766 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12767 > $as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12768 >    cf_enable_openssl="no"
12769 > fi
12770   fi
12771  
12772 < done
12772 > if test "$ac_cv_lib_ssl_SSL_connect" = yes; then
12773 >  ENABLE_SSL_TRUE=
12774 >  ENABLE_SSL_FALSE='#'
12775 > else
12776 >  ENABLE_SSL_TRUE='#'
12777 >  ENABLE_SSL_FALSE=
12778 > fi
12779  
12780  
12458 for ac_header in fcntl.h sys/time.h unistd.h strings.h
12459 do :
12460  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
12461 ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
12462 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
12463  cat >>confdefs.h <<_ACEOF
12464 #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
12465 _ACEOF
12781  
12782 +  # Check whether --enable-assert was given.
12783 + if test "${enable_assert+set}" = set; then :
12784 +  enableval=$enable_assert; assert=$enableval
12785 + else
12786 +  assert=no
12787   fi
12788  
12789 < done
12789 >
12790 >  if test "$assert" = "no"; then :
12791 >
12792 > $as_echo "#define NDEBUG 1" >>confdefs.h
12793 >
12794 > fi
12795  
12796  
12797 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
12798 < $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
12799 < if ${ac_cv_c_const+:} false; then :
12797 >  # Check whether --enable-warnings was given.
12798 > if test "${enable_warnings+set}" = set; then :
12799 >  enableval=$enable_warnings; warnings="$enableval"
12800 > else
12801 >  warnings="no"
12802 > fi
12803 >
12804 >
12805 >  if test "$warnings" = "yes"; then :
12806 >
12807 >
12808 >
12809 >
12810 >
12811 > for flag in -Wall; do
12812 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12813 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12814 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12815 > if eval \${$as_CACHEVAR+:} false; then :
12816    $as_echo_n "(cached) " >&6
12817   else
12818 +
12819 +  ax_check_save_flags=$CFLAGS
12820 +  CFLAGS="$CFLAGS  $flag"
12821    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12822   /* end confdefs.h.  */
12823  
# Line 12481 | Line 12825 | int
12825   main ()
12826   {
12827  
12484 #ifndef __cplusplus
12485  /* Ultrix mips cc rejects this sort of thing.  */
12486  typedef int charset[2];
12487  const charset cs = { 0, 0 };
12488  /* SunOS 4.1.1 cc rejects this.  */
12489  char const *const *pcpcc;
12490  char **ppc;
12491  /* NEC SVR4.0.2 mips cc rejects this.  */
12492  struct point {int x, y;};
12493  static struct point const zero = {0,0};
12494  /* AIX XL C 1.02.0.0 rejects this.
12495     It does not let you subtract one const X* pointer from another in
12496     an arm of an if-expression whose if-part is not a constant
12497     expression */
12498  const char *g = "string";
12499  pcpcc = &g + (g ? g-g : 0);
12500  /* HPUX 7.0 cc rejects these. */
12501  ++pcpcc;
12502  ppc = (char**) pcpcc;
12503  pcpcc = (char const *const *) ppc;
12504  { /* SCO 3.2v4 cc rejects this sort of thing.  */
12505    char tx;
12506    char *t = &tx;
12507    char const *s = 0 ? (char *) 0 : (char const *) 0;
12508
12509    *t++ = 0;
12510    if (s) return 0;
12511  }
12512  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
12513    int x[] = {25, 17};
12514    const int *foo = &x[0];
12515    ++foo;
12516  }
12517  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
12518    typedef const int *iptr;
12519    iptr p = 0;
12520    ++p;
12521  }
12522  { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
12523       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
12524    struct s { int j; const int *ap[3]; } bx;
12525    struct s *b = &bx; b->j = 5;
12526  }
12527  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
12528    const int foo = 10;
12529    if (!foo) return 0;
12530  }
12531  return !cs[0] && !zero.x;
12532 #endif
12533
12828    ;
12829    return 0;
12830   }
12831   _ACEOF
12832   if ac_fn_c_try_compile "$LINENO"; then :
12833 <  ac_cv_c_const=yes
12833 >  eval "$as_CACHEVAR=yes"
12834   else
12835 <  ac_cv_c_const=no
12835 >  eval "$as_CACHEVAR=no"
12836   fi
12837   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12838 +  CFLAGS=$ax_check_save_flags
12839   fi
12840 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
12841 < $as_echo "$ac_cv_c_const" >&6; }
12842 < if test $ac_cv_c_const = no; then
12840 > eval ac_res=\$$as_CACHEVAR
12841 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12842 > $as_echo "$ac_res" >&6; }
12843 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12844  
12845 < $as_echo "#define const /**/" >>confdefs.h
12845 > if ${CFLAGS+:} false; then :
12846  
12847 < fi
12847 >  case " $CFLAGS " in #(
12848 >  *" $flag "*) :
12849 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12850 >  (: CFLAGS already contains $flag) 2>&5
12851 >  ac_status=$?
12852 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12853 >  test $ac_status = 0; } ;; #(
12854 >  *) :
12855  
12856 < ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
12857 < if test "x$ac_cv_type_size_t" = xyes; then :
12856 >     as_fn_append CFLAGS " $flag"
12857 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12858 >  (: CFLAGS="$CFLAGS") 2>&5
12859 >  ac_status=$?
12860 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12861 >  test $ac_status = 0; }
12862 >     ;;
12863 > esac
12864  
12865   else
12866  
12867 < cat >>confdefs.h <<_ACEOF
12868 < #define size_t unsigned int
12869 < _ACEOF
12867 >  CFLAGS=$flag
12868 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12869 >  (: CFLAGS="$CFLAGS") 2>&5
12870 >  ac_status=$?
12871 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12872 >  test $ac_status = 0; }
12873 >
12874 > fi
12875  
12876 + else
12877 +  :
12878   fi
12879  
12880 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12881 < $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12882 < if ${ac_cv_header_time+:} false; then :
12880 > done
12881 >
12882 >
12883 >
12884 >
12885 >
12886 > for flag in -Wbad-function-cast; do
12887 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12888 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12889 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12890 > if eval \${$as_CACHEVAR+:} false; then :
12891    $as_echo_n "(cached) " >&6
12892   else
12893 +
12894 +  ax_check_save_flags=$CFLAGS
12895 +  CFLAGS="$CFLAGS  $flag"
12896    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12897   /* end confdefs.h.  */
12571 #include <sys/types.h>
12572 #include <sys/time.h>
12573 #include <time.h>
12898  
12899   int
12900   main ()
12901   {
12902 < if ((struct tm *) 0)
12579 < return 0;
12902 >
12903    ;
12904    return 0;
12905   }
12906   _ACEOF
12907   if ac_fn_c_try_compile "$LINENO"; then :
12908 <  ac_cv_header_time=yes
12908 >  eval "$as_CACHEVAR=yes"
12909   else
12910 <  ac_cv_header_time=no
12910 >  eval "$as_CACHEVAR=no"
12911   fi
12912   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12913 +  CFLAGS=$ax_check_save_flags
12914   fi
12915 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12916 < $as_echo "$ac_cv_header_time" >&6; }
12917 < if test $ac_cv_header_time = yes; then
12915 > eval ac_res=\$$as_CACHEVAR
12916 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12917 > $as_echo "$ac_res" >&6; }
12918 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12919 >
12920 > if ${CFLAGS+:} false; then :
12921 >
12922 >  case " $CFLAGS " in #(
12923 >  *" $flag "*) :
12924 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12925 >  (: CFLAGS already contains $flag) 2>&5
12926 >  ac_status=$?
12927 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12928 >  test $ac_status = 0; } ;; #(
12929 >  *) :
12930 >
12931 >     as_fn_append CFLAGS " $flag"
12932 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12933 >  (: CFLAGS="$CFLAGS") 2>&5
12934 >  ac_status=$?
12935 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12936 >  test $ac_status = 0; }
12937 >     ;;
12938 > esac
12939 >
12940 > else
12941 >
12942 >  CFLAGS=$flag
12943 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12944 >  (: CFLAGS="$CFLAGS") 2>&5
12945 >  ac_status=$?
12946 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12947 >  test $ac_status = 0; }
12948  
12949 < $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
12949 > fi
12950  
12951 + else
12952 +  :
12953   fi
12954  
12955 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
12956 < $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
12957 < if ${ac_cv_struct_tm+:} false; then :
12955 > done
12956 >
12957 >
12958 >
12959 >
12960 >
12961 > for flag in -Wcast-align; do
12962 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12963 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12964 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12965 > if eval \${$as_CACHEVAR+:} false; then :
12966    $as_echo_n "(cached) " >&6
12967   else
12968 +
12969 +  ax_check_save_flags=$CFLAGS
12970 +  CFLAGS="$CFLAGS  $flag"
12971    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12972   /* end confdefs.h.  */
12606 #include <sys/types.h>
12607 #include <time.h>
12973  
12974   int
12975   main ()
12976   {
12977 < struct tm tm;
12613 <                                     int *p = &tm.tm_sec;
12614 <                                     return !p;
12977 >
12978    ;
12979    return 0;
12980   }
12981   _ACEOF
12982   if ac_fn_c_try_compile "$LINENO"; then :
12983 <  ac_cv_struct_tm=time.h
12983 >  eval "$as_CACHEVAR=yes"
12984   else
12985 <  ac_cv_struct_tm=sys/time.h
12985 >  eval "$as_CACHEVAR=no"
12986   fi
12987   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12988 +  CFLAGS=$ax_check_save_flags
12989   fi
12990 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
12991 < $as_echo "$ac_cv_struct_tm" >&6; }
12992 < if test $ac_cv_struct_tm = sys/time.h; then
12990 > eval ac_res=\$$as_CACHEVAR
12991 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12992 > $as_echo "$ac_res" >&6; }
12993 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12994 >
12995 > if ${CFLAGS+:} false; then :
12996 >
12997 >  case " $CFLAGS " in #(
12998 >  *" $flag "*) :
12999 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13000 >  (: CFLAGS already contains $flag) 2>&5
13001 >  ac_status=$?
13002 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13003 >  test $ac_status = 0; } ;; #(
13004 >  *) :
13005 >
13006 >     as_fn_append CFLAGS " $flag"
13007 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13008 >  (: CFLAGS="$CFLAGS") 2>&5
13009 >  ac_status=$?
13010 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13011 >  test $ac_status = 0; }
13012 >     ;;
13013 > esac
13014 >
13015 > else
13016 >
13017 >  CFLAGS=$flag
13018 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13019 >  (: CFLAGS="$CFLAGS") 2>&5
13020 >  ac_status=$?
13021 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13022 >  test $ac_status = 0; }
13023  
13024 < $as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
13024 > fi
13025  
13026 + else
13027 +  :
13028   fi
13029  
13030 + done
13031 +
13032 +
13033  
13034 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5
13035 < $as_echo_n "checking return type of signal handlers... " >&6; }
13036 < if ${ac_cv_type_signal+:} false; then :
13034 >
13035 >
13036 > for flag in -Wcast-qual; do
13037 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13038 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13039 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13040 > if eval \${$as_CACHEVAR+:} false; then :
13041    $as_echo_n "(cached) " >&6
13042   else
13043 +
13044 +  ax_check_save_flags=$CFLAGS
13045 +  CFLAGS="$CFLAGS  $flag"
13046    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13047   /* end confdefs.h.  */
12642 #include <sys/types.h>
12643 #include <signal.h>
13048  
13049   int
13050   main ()
13051   {
13052 < return *(signal (0, 0)) (0) == 1;
13052 >
13053    ;
13054    return 0;
13055   }
13056   _ACEOF
13057   if ac_fn_c_try_compile "$LINENO"; then :
13058 <  ac_cv_type_signal=int
13058 >  eval "$as_CACHEVAR=yes"
13059   else
13060 <  ac_cv_type_signal=void
13060 >  eval "$as_CACHEVAR=no"
13061   fi
13062   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13063 +  CFLAGS=$ax_check_save_flags
13064   fi
13065 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal" >&5
13066 < $as_echo "$ac_cv_type_signal" >&6; }
13065 > eval ac_res=\$$as_CACHEVAR
13066 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13067 > $as_echo "$ac_res" >&6; }
13068 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13069  
13070 < cat >>confdefs.h <<_ACEOF
12664 < #define RETSIGTYPE $ac_cv_type_signal
12665 < _ACEOF
13070 > if ${CFLAGS+:} false; then :
13071  
13072 +  case " $CFLAGS " in #(
13073 +  *" $flag "*) :
13074 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13075 +  (: CFLAGS already contains $flag) 2>&5
13076 +  ac_status=$?
13077 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13078 +  test $ac_status = 0; } ;; #(
13079 +  *) :
13080  
13081 < for ac_func in strftime
13082 < do :
13083 <  ac_fn_c_check_func "$LINENO" "strftime" "ac_cv_func_strftime"
13084 < if test "x$ac_cv_func_strftime" = xyes; then :
13085 <  cat >>confdefs.h <<_ACEOF
13086 < #define HAVE_STRFTIME 1
13087 < _ACEOF
13081 >     as_fn_append CFLAGS " $flag"
13082 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13083 >  (: CFLAGS="$CFLAGS") 2>&5
13084 >  ac_status=$?
13085 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13086 >  test $ac_status = 0; }
13087 >     ;;
13088 > esac
13089  
13090   else
13091 <  # strftime is in -lintl on SCO UNIX.
13092 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strftime in -lintl" >&5
13093 < $as_echo_n "checking for strftime in -lintl... " >&6; }
13094 < if ${ac_cv_lib_intl_strftime+:} false; then :
13091 >
13092 >  CFLAGS=$flag
13093 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13094 >  (: CFLAGS="$CFLAGS") 2>&5
13095 >  ac_status=$?
13096 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13097 >  test $ac_status = 0; }
13098 >
13099 > fi
13100 >
13101 > else
13102 >  :
13103 > fi
13104 >
13105 > done
13106 >
13107 >
13108 >
13109 >
13110 >
13111 > for flag in -Wclobbered; do
13112 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13113 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13114 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13115 > if eval \${$as_CACHEVAR+:} false; then :
13116    $as_echo_n "(cached) " >&6
13117   else
13118 <  ac_check_lib_save_LIBS=$LIBS
13119 < LIBS="-lintl  $LIBS"
13120 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13118 >
13119 >  ax_check_save_flags=$CFLAGS
13120 >  CFLAGS="$CFLAGS  $flag"
13121 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13122   /* end confdefs.h.  */
13123  
12688 /* Override any GCC internal prototype to avoid an error.
12689   Use char because int might match the return type of a GCC
12690   builtin and then its argument prototype would still apply.  */
12691 #ifdef __cplusplus
12692 extern "C"
12693 #endif
12694 char strftime ();
13124   int
13125   main ()
13126   {
13127 < return strftime ();
13127 >
13128    ;
13129    return 0;
13130   }
13131   _ACEOF
13132 < if ac_fn_c_try_link "$LINENO"; then :
13133 <  ac_cv_lib_intl_strftime=yes
13132 > if ac_fn_c_try_compile "$LINENO"; then :
13133 >  eval "$as_CACHEVAR=yes"
13134   else
13135 <  ac_cv_lib_intl_strftime=no
13135 >  eval "$as_CACHEVAR=no"
13136   fi
13137 < rm -f core conftest.err conftest.$ac_objext \
13138 <    conftest$ac_exeext conftest.$ac_ext
12710 < LIBS=$ac_check_lib_save_LIBS
13137 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13138 >  CFLAGS=$ax_check_save_flags
13139   fi
13140 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_intl_strftime" >&5
13141 < $as_echo "$ac_cv_lib_intl_strftime" >&6; }
13142 < if test "x$ac_cv_lib_intl_strftime" = xyes; then :
13143 <  $as_echo "#define HAVE_STRFTIME 1" >>confdefs.h
13140 > eval ac_res=\$$as_CACHEVAR
13141 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13142 > $as_echo "$ac_res" >&6; }
13143 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13144 >
13145 > if ${CFLAGS+:} false; then :
13146 >
13147 >  case " $CFLAGS " in #(
13148 >  *" $flag "*) :
13149 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13150 >  (: CFLAGS already contains $flag) 2>&5
13151 >  ac_status=$?
13152 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13153 >  test $ac_status = 0; } ;; #(
13154 >  *) :
13155 >
13156 >     as_fn_append CFLAGS " $flag"
13157 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13158 >  (: CFLAGS="$CFLAGS") 2>&5
13159 >  ac_status=$?
13160 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13161 >  test $ac_status = 0; }
13162 >     ;;
13163 > esac
13164 >
13165 > else
13166 >
13167 >  CFLAGS=$flag
13168 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13169 >  (: CFLAGS="$CFLAGS") 2>&5
13170 >  ac_status=$?
13171 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13172 >  test $ac_status = 0; }
13173  
12717 LIBS="-lintl $LIBS"
13174   fi
13175  
13176 + else
13177 +  :
13178   fi
13179 +
13180   done
13181  
13182  
13183  
13184 < for ac_prog in 'bison -y' byacc
13185 < do
13186 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13187 < set dummy $ac_prog; ac_word=$2
13188 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13189 < $as_echo_n "checking for $ac_word... " >&6; }
13190 < if ${ac_cv_prog_YACC+:} false; then :
13184 >
13185 >
13186 > for flag in -Wempty-body; do
13187 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13188 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13189 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13190 > if eval \${$as_CACHEVAR+:} false; then :
13191    $as_echo_n "(cached) " >&6
13192   else
12734  if test -n "$YACC"; then
12735  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12736 else
12737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12738 for as_dir in $PATH
12739 do
12740  IFS=$as_save_IFS
12741  test -z "$as_dir" && as_dir=.
12742    for ac_exec_ext in '' $ac_executable_extensions; do
12743  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12744    ac_cv_prog_YACC="$ac_prog"
12745    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12746    break 2
12747  fi
12748 done
12749  done
12750 IFS=$as_save_IFS
13193  
13194 +  ax_check_save_flags=$CFLAGS
13195 +  CFLAGS="$CFLAGS  $flag"
13196 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13197 + /* end confdefs.h.  */
13198 +
13199 + int
13200 + main ()
13201 + {
13202 +
13203 +  ;
13204 +  return 0;
13205 + }
13206 + _ACEOF
13207 + if ac_fn_c_try_compile "$LINENO"; then :
13208 +  eval "$as_CACHEVAR=yes"
13209 + else
13210 +  eval "$as_CACHEVAR=no"
13211   fi
13212 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13213 +  CFLAGS=$ax_check_save_flags
13214   fi
13215 < YACC=$ac_cv_prog_YACC
13216 < if test -n "$YACC"; then
13217 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
13218 < $as_echo "$YACC" >&6; }
13215 > eval ac_res=\$$as_CACHEVAR
13216 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13217 > $as_echo "$ac_res" >&6; }
13218 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13219 >
13220 > if ${CFLAGS+:} false; then :
13221 >
13222 >  case " $CFLAGS " in #(
13223 >  *" $flag "*) :
13224 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13225 >  (: CFLAGS already contains $flag) 2>&5
13226 >  ac_status=$?
13227 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13228 >  test $ac_status = 0; } ;; #(
13229 >  *) :
13230 >
13231 >     as_fn_append CFLAGS " $flag"
13232 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13233 >  (: CFLAGS="$CFLAGS") 2>&5
13234 >  ac_status=$?
13235 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13236 >  test $ac_status = 0; }
13237 >     ;;
13238 > esac
13239 >
13240   else
13241 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13242 < $as_echo "no" >&6; }
13241 >
13242 >  CFLAGS=$flag
13243 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13244 >  (: CFLAGS="$CFLAGS") 2>&5
13245 >  ac_status=$?
13246 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13247 >  test $ac_status = 0; }
13248 >
13249   fi
13250  
13251 + else
13252 +  :
13253 + fi
13254  
12764  test -n "$YACC" && break
13255   done
12766 test -n "$YACC" || YACC="yacc"
13256  
13257  
13258 < for ac_prog in flex lex
13259 < do
13260 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13261 < set dummy $ac_prog; ac_word=$2
13262 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13263 < $as_echo_n "checking for $ac_word... " >&6; }
13264 < if ${ac_cv_prog_LEX+:} false; then :
13258 >
13259 >
13260 >
13261 > for flag in -Wignored-qualifiers; do
13262 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13263 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13264 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13265 > if eval \${$as_CACHEVAR+:} false; then :
13266    $as_echo_n "(cached) " >&6
13267   else
12778  if test -n "$LEX"; then
12779  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12780 else
12781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12782 for as_dir in $PATH
12783 do
12784  IFS=$as_save_IFS
12785  test -z "$as_dir" && as_dir=.
12786    for ac_exec_ext in '' $ac_executable_extensions; do
12787  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12788    ac_cv_prog_LEX="$ac_prog"
12789    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12790    break 2
12791  fi
12792 done
12793  done
12794 IFS=$as_save_IFS
13268  
13269 +  ax_check_save_flags=$CFLAGS
13270 +  CFLAGS="$CFLAGS  $flag"
13271 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13272 + /* end confdefs.h.  */
13273 +
13274 + int
13275 + main ()
13276 + {
13277 +
13278 +  ;
13279 +  return 0;
13280 + }
13281 + _ACEOF
13282 + if ac_fn_c_try_compile "$LINENO"; then :
13283 +  eval "$as_CACHEVAR=yes"
13284 + else
13285 +  eval "$as_CACHEVAR=no"
13286   fi
13287 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13288 +  CFLAGS=$ax_check_save_flags
13289   fi
13290 < LEX=$ac_cv_prog_LEX
13291 < if test -n "$LEX"; then
13292 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
13293 < $as_echo "$LEX" >&6; }
13290 > eval ac_res=\$$as_CACHEVAR
13291 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13292 > $as_echo "$ac_res" >&6; }
13293 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13294 >
13295 > if ${CFLAGS+:} false; then :
13296 >
13297 >  case " $CFLAGS " in #(
13298 >  *" $flag "*) :
13299 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13300 >  (: CFLAGS already contains $flag) 2>&5
13301 >  ac_status=$?
13302 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13303 >  test $ac_status = 0; } ;; #(
13304 >  *) :
13305 >
13306 >     as_fn_append CFLAGS " $flag"
13307 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13308 >  (: CFLAGS="$CFLAGS") 2>&5
13309 >  ac_status=$?
13310 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13311 >  test $ac_status = 0; }
13312 >     ;;
13313 > esac
13314 >
13315   else
13316 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13317 < $as_echo "no" >&6; }
13316 >
13317 >  CFLAGS=$flag
13318 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13319 >  (: CFLAGS="$CFLAGS") 2>&5
13320 >  ac_status=$?
13321 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13322 >  test $ac_status = 0; }
13323 >
13324   fi
13325  
13326 + else
13327 +  :
13328 + fi
13329  
12808  test -n "$LEX" && break
13330   done
12810 test -n "$LEX" || LEX=":"
13331  
13332 < if test "x$LEX" != "x:"; then
13333 <  cat >conftest.l <<_ACEOF
13334 < %%
13335 < a { ECHO; }
13336 < b { REJECT; }
13337 < c { yymore (); }
13338 < d { yyless (1); }
13339 < e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
13340 <    yyless ((input () != 0)); }
13341 < f { unput (yytext[0]); }
13342 < . { BEGIN INITIAL; }
13343 < %%
13344 < #ifdef YYTEXT_POINTER
13345 < extern char *yytext;
13346 < #endif
13332 >
13333 >
13334 >
13335 >
13336 > for flag in -Wlogical-op; do
13337 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13338 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13339 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13340 > if eval \${$as_CACHEVAR+:} false; then :
13341 >  $as_echo_n "(cached) " >&6
13342 > else
13343 >
13344 >  ax_check_save_flags=$CFLAGS
13345 >  CFLAGS="$CFLAGS  $flag"
13346 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13347 > /* end confdefs.h.  */
13348 >
13349   int
13350 < main (void)
13350 > main ()
13351   {
13352 <  return ! yylex () + ! yywrap ();
13352 >
13353 >  ;
13354 >  return 0;
13355   }
13356   _ACEOF
13357 < { { ac_try="$LEX conftest.l"
13358 < case "(($ac_try" in
13359 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13360 <  *) ac_try_echo=$ac_try;;
13357 > if ac_fn_c_try_compile "$LINENO"; then :
13358 >  eval "$as_CACHEVAR=yes"
13359 > else
13360 >  eval "$as_CACHEVAR=no"
13361 > fi
13362 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13363 >  CFLAGS=$ax_check_save_flags
13364 > fi
13365 > eval ac_res=\$$as_CACHEVAR
13366 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13367 > $as_echo "$ac_res" >&6; }
13368 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13369 >
13370 > if ${CFLAGS+:} false; then :
13371 >
13372 >  case " $CFLAGS " in #(
13373 >  *" $flag "*) :
13374 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13375 >  (: CFLAGS already contains $flag) 2>&5
13376 >  ac_status=$?
13377 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13378 >  test $ac_status = 0; } ;; #(
13379 >  *) :
13380 >
13381 >     as_fn_append CFLAGS " $flag"
13382 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13383 >  (: CFLAGS="$CFLAGS") 2>&5
13384 >  ac_status=$?
13385 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13386 >  test $ac_status = 0; }
13387 >     ;;
13388   esac
13389 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
13390 < $as_echo "$ac_try_echo"; } >&5
13391 <  (eval "$LEX conftest.l") 2>&5
13389 >
13390 > else
13391 >
13392 >  CFLAGS=$flag
13393 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13394 >  (: CFLAGS="$CFLAGS") 2>&5
13395    ac_status=$?
13396    $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13397    test $ac_status = 0; }
13398 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
13399 < $as_echo_n "checking lex output file root... " >&6; }
13400 < if ${ac_cv_prog_lex_root+:} false; then :
13398 >
13399 > fi
13400 >
13401 > else
13402 >  :
13403 > fi
13404 >
13405 > done
13406 >
13407 >
13408 >
13409 >
13410 >
13411 > for flag in -Wmissing-declarations; do
13412 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13413 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13414 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13415 > if eval \${$as_CACHEVAR+:} false; then :
13416    $as_echo_n "(cached) " >&6
13417   else
13418  
13419 < if test -f lex.yy.c; then
13420 <  ac_cv_prog_lex_root=lex.yy
13421 < elif test -f lexyy.c; then
13422 <  ac_cv_prog_lex_root=lexyy
13419 >  ax_check_save_flags=$CFLAGS
13420 >  CFLAGS="$CFLAGS  $flag"
13421 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13422 > /* end confdefs.h.  */
13423 >
13424 > int
13425 > main ()
13426 > {
13427 >
13428 >  ;
13429 >  return 0;
13430 > }
13431 > _ACEOF
13432 > if ac_fn_c_try_compile "$LINENO"; then :
13433 >  eval "$as_CACHEVAR=yes"
13434   else
13435 <  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
13435 >  eval "$as_CACHEVAR=no"
13436   fi
13437 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13438 +  CFLAGS=$ax_check_save_flags
13439   fi
13440 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
13441 < $as_echo "$ac_cv_prog_lex_root" >&6; }
13442 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13440 > eval ac_res=\$$as_CACHEVAR
13441 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13442 > $as_echo "$ac_res" >&6; }
13443 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13444  
13445 < if test -z "${LEXLIB+set}"; then
13446 <  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
13447 < $as_echo_n "checking lex library... " >&6; }
13448 < if ${ac_cv_lib_lex+:} false; then :
13445 > if ${CFLAGS+:} false; then :
13446 >
13447 >  case " $CFLAGS " in #(
13448 >  *" $flag "*) :
13449 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13450 >  (: CFLAGS already contains $flag) 2>&5
13451 >  ac_status=$?
13452 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13453 >  test $ac_status = 0; } ;; #(
13454 >  *) :
13455 >
13456 >     as_fn_append CFLAGS " $flag"
13457 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13458 >  (: CFLAGS="$CFLAGS") 2>&5
13459 >  ac_status=$?
13460 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13461 >  test $ac_status = 0; }
13462 >     ;;
13463 > esac
13464 >
13465 > else
13466 >
13467 >  CFLAGS=$flag
13468 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13469 >  (: CFLAGS="$CFLAGS") 2>&5
13470 >  ac_status=$?
13471 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13472 >  test $ac_status = 0; }
13473 >
13474 > fi
13475 >
13476 > else
13477 >  :
13478 > fi
13479 >
13480 > done
13481 >
13482 >
13483 >
13484 >
13485 >
13486 > for flag in -Wmissing-field-initializers; do
13487 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13488 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13489 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13490 > if eval \${$as_CACHEVAR+:} false; then :
13491    $as_echo_n "(cached) " >&6
13492   else
13493  
13494 <    ac_save_LIBS=$LIBS
13495 <    ac_cv_lib_lex='none needed'
13496 <    for ac_lib in '' -lfl -ll; do
12872 <      LIBS="$ac_lib $ac_save_LIBS"
12873 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13494 >  ax_check_save_flags=$CFLAGS
13495 >  CFLAGS="$CFLAGS  $flag"
13496 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13497   /* end confdefs.h.  */
13498 < `cat $LEX_OUTPUT_ROOT.c`
13498 >
13499 > int
13500 > main ()
13501 > {
13502 >
13503 >  ;
13504 >  return 0;
13505 > }
13506   _ACEOF
13507 < if ac_fn_c_try_link "$LINENO"; then :
13508 <  ac_cv_lib_lex=$ac_lib
13507 > if ac_fn_c_try_compile "$LINENO"; then :
13508 >  eval "$as_CACHEVAR=yes"
13509 > else
13510 >  eval "$as_CACHEVAR=no"
13511   fi
13512 < rm -f core conftest.err conftest.$ac_objext \
13513 <    conftest$ac_exeext conftest.$ac_ext
13514 <      test "$ac_cv_lib_lex" != 'none needed' && break
13515 <    done
13516 <    LIBS=$ac_save_LIBS
13512 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13513 >  CFLAGS=$ax_check_save_flags
13514 > fi
13515 > eval ac_res=\$$as_CACHEVAR
13516 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13517 > $as_echo "$ac_res" >&6; }
13518 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13519 >
13520 > if ${CFLAGS+:} false; then :
13521 >
13522 >  case " $CFLAGS " in #(
13523 >  *" $flag "*) :
13524 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13525 >  (: CFLAGS already contains $flag) 2>&5
13526 >  ac_status=$?
13527 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13528 >  test $ac_status = 0; } ;; #(
13529 >  *) :
13530 >
13531 >     as_fn_append CFLAGS " $flag"
13532 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13533 >  (: CFLAGS="$CFLAGS") 2>&5
13534 >  ac_status=$?
13535 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13536 >  test $ac_status = 0; }
13537 >     ;;
13538 > esac
13539 >
13540 > else
13541 >
13542 >  CFLAGS=$flag
13543 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13544 >  (: CFLAGS="$CFLAGS") 2>&5
13545 >  ac_status=$?
13546 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13547 >  test $ac_status = 0; }
13548  
13549   fi
13550 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
13551 < $as_echo "$ac_cv_lib_lex" >&6; }
13552 <  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
13550 >
13551 > else
13552 >  :
13553   fi
13554  
13555 + done
13556 +
13557  
13558 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
13559 < $as_echo_n "checking whether yytext is a pointer... " >&6; }
13560 < if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
13558 >
13559 >
13560 >
13561 > for flag in -Wmissing-include-dirs; do
13562 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13563 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13564 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13565 > if eval \${$as_CACHEVAR+:} false; then :
13566    $as_echo_n "(cached) " >&6
13567   else
13568 <  # POSIX says lex can declare yytext either as a pointer or an array; the
13569 < # default is implementation-dependent.  Figure out which it is, since
13570 < # not all implementations provide the %pointer and %array declarations.
13571 < ac_cv_prog_lex_yytext_pointer=no
12902 < ac_save_LIBS=$LIBS
12903 < LIBS="$LEXLIB $ac_save_LIBS"
12904 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13568 >
13569 >  ax_check_save_flags=$CFLAGS
13570 >  CFLAGS="$CFLAGS  $flag"
13571 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13572   /* end confdefs.h.  */
13573  
13574 <  #define YYTEXT_POINTER 1
13575 < `cat $LEX_OUTPUT_ROOT.c`
13574 > int
13575 > main ()
13576 > {
13577 >
13578 >  ;
13579 >  return 0;
13580 > }
13581   _ACEOF
13582 < if ac_fn_c_try_link "$LINENO"; then :
13583 <  ac_cv_prog_lex_yytext_pointer=yes
13582 > if ac_fn_c_try_compile "$LINENO"; then :
13583 >  eval "$as_CACHEVAR=yes"
13584 > else
13585 >  eval "$as_CACHEVAR=no"
13586   fi
13587 < rm -f core conftest.err conftest.$ac_objext \
13588 <    conftest$ac_exeext conftest.$ac_ext
12915 < LIBS=$ac_save_LIBS
12916 <
13587 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13588 >  CFLAGS=$ax_check_save_flags
13589   fi
13590 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
13591 < $as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
13592 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
13590 > eval ac_res=\$$as_CACHEVAR
13591 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13592 > $as_echo "$ac_res" >&6; }
13593 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13594  
13595 < $as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
13595 > if ${CFLAGS+:} false; then :
13596  
13597 < fi
13598 < rm -f conftest.l $LEX_OUTPUT_ROOT.c
13597 >  case " $CFLAGS " in #(
13598 >  *" $flag "*) :
13599 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13600 >  (: CFLAGS already contains $flag) 2>&5
13601 >  ac_status=$?
13602 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13603 >  test $ac_status = 0; } ;; #(
13604 >  *) :
13605 >
13606 >     as_fn_append CFLAGS " $flag"
13607 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13608 >  (: CFLAGS="$CFLAGS") 2>&5
13609 >  ac_status=$?
13610 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13611 >  test $ac_status = 0; }
13612 >     ;;
13613 > esac
13614 >
13615 > else
13616 >
13617 >  CFLAGS=$flag
13618 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13619 >  (: CFLAGS="$CFLAGS") 2>&5
13620 >  ac_status=$?
13621 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13622 >  test $ac_status = 0; }
13623  
13624   fi
13625 < if test "$LEX" = :; then
13626 <  LEX=${am_missing_run}flex
13625 >
13626 > else
13627 >  :
13628   fi
13629  
13630 < ETR_SOCKET_NSL
13630 > done
13631  
13632 < for ac_func in inet_aton inet_pton socket strdup strstr
13633 < do :
13634 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
13635 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
13636 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
13637 <  cat >>confdefs.h <<_ACEOF
13638 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
13632 >
13633 >
13634 >
13635 >
13636 > for flag in -Wmissing-parameter-type; do
13637 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13638 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13639 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13640 > if eval \${$as_CACHEVAR+:} false; then :
13641 >  $as_echo_n "(cached) " >&6
13642 > else
13643 >
13644 >  ax_check_save_flags=$CFLAGS
13645 >  CFLAGS="$CFLAGS  $flag"
13646 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13647 > /* end confdefs.h.  */
13648 >
13649 > int
13650 > main ()
13651 > {
13652 >
13653 >  ;
13654 >  return 0;
13655 > }
13656   _ACEOF
13657 + if ac_fn_c_try_compile "$LINENO"; then :
13658 +  eval "$as_CACHEVAR=yes"
13659 + else
13660 +  eval "$as_CACHEVAR=no"
13661 + fi
13662 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13663 +  CFLAGS=$ax_check_save_flags
13664 + fi
13665 + eval ac_res=\$$as_CACHEVAR
13666 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13667 + $as_echo "$ac_res" >&6; }
13668 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13669 +
13670 + if ${CFLAGS+:} false; then :
13671 +
13672 +  case " $CFLAGS " in #(
13673 +  *" $flag "*) :
13674 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13675 +  (: CFLAGS already contains $flag) 2>&5
13676 +  ac_status=$?
13677 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13678 +  test $ac_status = 0; } ;; #(
13679 +  *) :
13680 +
13681 +     as_fn_append CFLAGS " $flag"
13682 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13683 +  (: CFLAGS="$CFLAGS") 2>&5
13684 +  ac_status=$?
13685 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13686 +  test $ac_status = 0; }
13687 +     ;;
13688 + esac
13689 +
13690 + else
13691 +
13692 +  CFLAGS=$flag
13693 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13694 +  (: CFLAGS="$CFLAGS") 2>&5
13695 +  ac_status=$?
13696 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13697 +  test $ac_status = 0; }
13698  
13699   fi
13700 +
13701 + else
13702 +  :
13703 + fi
13704 +
13705   done
13706  
13707  
13708 < for ac_func in gethostbyname gethostbyname2
13709 < do :
13710 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
13711 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
13712 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
13713 <  cat >>confdefs.h <<_ACEOF
13714 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
13708 >
13709 >
13710 >
13711 > for flag in -Wmissing-prototypes; do
13712 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13713 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13714 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13715 > if eval \${$as_CACHEVAR+:} false; then :
13716 >  $as_echo_n "(cached) " >&6
13717 > else
13718 >
13719 >  ax_check_save_flags=$CFLAGS
13720 >  CFLAGS="$CFLAGS  $flag"
13721 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13722 > /* end confdefs.h.  */
13723 >
13724 > int
13725 > main ()
13726 > {
13727 >
13728 >  ;
13729 >  return 0;
13730 > }
13731   _ACEOF
13732 + if ac_fn_c_try_compile "$LINENO"; then :
13733 +  eval "$as_CACHEVAR=yes"
13734 + else
13735 +  eval "$as_CACHEVAR=no"
13736 + fi
13737 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13738 +  CFLAGS=$ax_check_save_flags
13739 + fi
13740 + eval ac_res=\$$as_CACHEVAR
13741 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13742 + $as_echo "$ac_res" >&6; }
13743 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13744 +
13745 + if ${CFLAGS+:} false; then :
13746 +
13747 +  case " $CFLAGS " in #(
13748 +  *" $flag "*) :
13749 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13750 +  (: CFLAGS already contains $flag) 2>&5
13751 +  ac_status=$?
13752 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13753 +  test $ac_status = 0; } ;; #(
13754 +  *) :
13755 +
13756 +     as_fn_append CFLAGS " $flag"
13757 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13758 +  (: CFLAGS="$CFLAGS") 2>&5
13759 +  ac_status=$?
13760 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13761 +  test $ac_status = 0; }
13762 +     ;;
13763 + esac
13764 +
13765 + else
13766 +
13767 +  CFLAGS=$flag
13768 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13769 +  (: CFLAGS="$CFLAGS") 2>&5
13770 +  ac_status=$?
13771 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13772 +  test $ac_status = 0; }
13773 +
13774 + fi
13775  
13776 + else
13777 +  :
13778   fi
13779 +
13780   done
13781  
13782  
13783 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
13784 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
13785 < if ${ac_cv_c_bigendian+:} false; then :
13783 >
13784 >
13785 >
13786 > for flag in -Wnested-externs; do
13787 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13788 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13789 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13790 > if eval \${$as_CACHEVAR+:} false; then :
13791    $as_echo_n "(cached) " >&6
13792   else
13793 <  ac_cv_c_bigendian=unknown
13794 <    # See if we're dealing with a universal compiler.
13795 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13793 >
13794 >  ax_check_save_flags=$CFLAGS
13795 >  CFLAGS="$CFLAGS  $flag"
13796 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13797   /* end confdefs.h.  */
12969 #ifndef __APPLE_CC__
12970               not a universal capable compiler
12971             #endif
12972             typedef int dummy;
13798  
13799 + int
13800 + main ()
13801 + {
13802 +
13803 +  ;
13804 +  return 0;
13805 + }
13806   _ACEOF
13807   if ac_fn_c_try_compile "$LINENO"; then :
13808 <
13809 <        # Check for potential -arch flags.  It is not universal unless
13810 <        # there are at least two -arch flags with different values.
12979 <        ac_arch=
12980 <        ac_prev=
12981 <        for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12982 <         if test -n "$ac_prev"; then
12983 <           case $ac_word in
12984 <             i?86 | x86_64 | ppc | ppc64)
12985 <               if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12986 <                 ac_arch=$ac_word
12987 <               else
12988 <                 ac_cv_c_bigendian=universal
12989 <                 break
12990 <               fi
12991 <               ;;
12992 <           esac
12993 <           ac_prev=
12994 <         elif test "x$ac_word" = "x-arch"; then
12995 <           ac_prev=arch
12996 <         fi
12997 <       done
13808 >  eval "$as_CACHEVAR=yes"
13809 > else
13810 >  eval "$as_CACHEVAR=no"
13811   fi
13812   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13813 <    if test $ac_cv_c_bigendian = unknown; then
13814 <      # See if sys/param.h defines the BYTE_ORDER macro.
13815 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13813 >  CFLAGS=$ax_check_save_flags
13814 > fi
13815 > eval ac_res=\$$as_CACHEVAR
13816 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13817 > $as_echo "$ac_res" >&6; }
13818 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13819 >
13820 > if ${CFLAGS+:} false; then :
13821 >
13822 >  case " $CFLAGS " in #(
13823 >  *" $flag "*) :
13824 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13825 >  (: CFLAGS already contains $flag) 2>&5
13826 >  ac_status=$?
13827 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13828 >  test $ac_status = 0; } ;; #(
13829 >  *) :
13830 >
13831 >     as_fn_append CFLAGS " $flag"
13832 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13833 >  (: CFLAGS="$CFLAGS") 2>&5
13834 >  ac_status=$?
13835 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13836 >  test $ac_status = 0; }
13837 >     ;;
13838 > esac
13839 >
13840 > else
13841 >
13842 >  CFLAGS=$flag
13843 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13844 >  (: CFLAGS="$CFLAGS") 2>&5
13845 >  ac_status=$?
13846 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13847 >  test $ac_status = 0; }
13848 >
13849 > fi
13850 >
13851 > else
13852 >  :
13853 > fi
13854 >
13855 > done
13856 >
13857 >
13858 >
13859 >
13860 >
13861 > for flag in -Wold-style-declaration; do
13862 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13863 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13864 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13865 > if eval \${$as_CACHEVAR+:} false; then :
13866 >  $as_echo_n "(cached) " >&6
13867 > else
13868 >
13869 >  ax_check_save_flags=$CFLAGS
13870 >  CFLAGS="$CFLAGS  $flag"
13871 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13872   /* end confdefs.h.  */
13004 #include <sys/types.h>
13005             #include <sys/param.h>
13873  
13874   int
13875   main ()
13876   {
13010 #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
13011                     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
13012                     && LITTLE_ENDIAN)
13013              bogus endian macros
13014             #endif
13877  
13878    ;
13879    return 0;
13880   }
13881   _ACEOF
13882   if ac_fn_c_try_compile "$LINENO"; then :
13883 <  # It does; now see whether it defined to BIG_ENDIAN or not.
13884 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13883 >  eval "$as_CACHEVAR=yes"
13884 > else
13885 >  eval "$as_CACHEVAR=no"
13886 > fi
13887 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13888 >  CFLAGS=$ax_check_save_flags
13889 > fi
13890 > eval ac_res=\$$as_CACHEVAR
13891 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13892 > $as_echo "$ac_res" >&6; }
13893 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13894 >
13895 > if ${CFLAGS+:} false; then :
13896 >
13897 >  case " $CFLAGS " in #(
13898 >  *" $flag "*) :
13899 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13900 >  (: CFLAGS already contains $flag) 2>&5
13901 >  ac_status=$?
13902 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13903 >  test $ac_status = 0; } ;; #(
13904 >  *) :
13905 >
13906 >     as_fn_append CFLAGS " $flag"
13907 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13908 >  (: CFLAGS="$CFLAGS") 2>&5
13909 >  ac_status=$?
13910 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13911 >  test $ac_status = 0; }
13912 >     ;;
13913 > esac
13914 >
13915 > else
13916 >
13917 >  CFLAGS=$flag
13918 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13919 >  (: CFLAGS="$CFLAGS") 2>&5
13920 >  ac_status=$?
13921 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13922 >  test $ac_status = 0; }
13923 >
13924 > fi
13925 >
13926 > else
13927 >  :
13928 > fi
13929 >
13930 > done
13931 >
13932 >
13933 >
13934 >
13935 >
13936 > for flag in -Woverride-init; do
13937 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13938 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13939 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13940 > if eval \${$as_CACHEVAR+:} false; then :
13941 >  $as_echo_n "(cached) " >&6
13942 > else
13943 >
13944 >  ax_check_save_flags=$CFLAGS
13945 >  CFLAGS="$CFLAGS  $flag"
13946 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13947   /* end confdefs.h.  */
13024 #include <sys/types.h>
13025                #include <sys/param.h>
13948  
13949   int
13950   main ()
13951   {
13030 #if BYTE_ORDER != BIG_ENDIAN
13031                 not big endian
13032                #endif
13952  
13953    ;
13954    return 0;
13955   }
13956   _ACEOF
13957   if ac_fn_c_try_compile "$LINENO"; then :
13958 <  ac_cv_c_bigendian=yes
13958 >  eval "$as_CACHEVAR=yes"
13959   else
13960 <  ac_cv_c_bigendian=no
13960 >  eval "$as_CACHEVAR=no"
13961   fi
13962   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13963 +  CFLAGS=$ax_check_save_flags
13964   fi
13965 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13966 <    fi
13967 <    if test $ac_cv_c_bigendian = unknown; then
13968 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13969 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13965 > eval ac_res=\$$as_CACHEVAR
13966 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13967 > $as_echo "$ac_res" >&6; }
13968 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13969 >
13970 > if ${CFLAGS+:} false; then :
13971 >
13972 >  case " $CFLAGS " in #(
13973 >  *" $flag "*) :
13974 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13975 >  (: CFLAGS already contains $flag) 2>&5
13976 >  ac_status=$?
13977 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13978 >  test $ac_status = 0; } ;; #(
13979 >  *) :
13980 >
13981 >     as_fn_append CFLAGS " $flag"
13982 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13983 >  (: CFLAGS="$CFLAGS") 2>&5
13984 >  ac_status=$?
13985 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13986 >  test $ac_status = 0; }
13987 >     ;;
13988 > esac
13989 >
13990 > else
13991 >
13992 >  CFLAGS=$flag
13993 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13994 >  (: CFLAGS="$CFLAGS") 2>&5
13995 >  ac_status=$?
13996 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13997 >  test $ac_status = 0; }
13998 >
13999 > fi
14000 >
14001 > else
14002 >  :
14003 > fi
14004 >
14005 > done
14006 >
14007 >
14008 >
14009 >
14010 >
14011 > for flag in -Wpointer-arith; do
14012 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14013 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14014 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14015 > if eval \${$as_CACHEVAR+:} false; then :
14016 >  $as_echo_n "(cached) " >&6
14017 > else
14018 >
14019 >  ax_check_save_flags=$CFLAGS
14020 >  CFLAGS="$CFLAGS  $flag"
14021 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14022   /* end confdefs.h.  */
13051 #include <limits.h>
14023  
14024   int
14025   main ()
14026   {
13056 #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13057              bogus endian macros
13058             #endif
14027  
14028    ;
14029    return 0;
14030   }
14031   _ACEOF
14032   if ac_fn_c_try_compile "$LINENO"; then :
14033 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
14034 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14033 >  eval "$as_CACHEVAR=yes"
14034 > else
14035 >  eval "$as_CACHEVAR=no"
14036 > fi
14037 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14038 >  CFLAGS=$ax_check_save_flags
14039 > fi
14040 > eval ac_res=\$$as_CACHEVAR
14041 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14042 > $as_echo "$ac_res" >&6; }
14043 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14044 >
14045 > if ${CFLAGS+:} false; then :
14046 >
14047 >  case " $CFLAGS " in #(
14048 >  *" $flag "*) :
14049 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14050 >  (: CFLAGS already contains $flag) 2>&5
14051 >  ac_status=$?
14052 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14053 >  test $ac_status = 0; } ;; #(
14054 >  *) :
14055 >
14056 >     as_fn_append CFLAGS " $flag"
14057 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14058 >  (: CFLAGS="$CFLAGS") 2>&5
14059 >  ac_status=$?
14060 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14061 >  test $ac_status = 0; }
14062 >     ;;
14063 > esac
14064 >
14065 > else
14066 >
14067 >  CFLAGS=$flag
14068 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14069 >  (: CFLAGS="$CFLAGS") 2>&5
14070 >  ac_status=$?
14071 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14072 >  test $ac_status = 0; }
14073 >
14074 > fi
14075 >
14076 > else
14077 >  :
14078 > fi
14079 >
14080 > done
14081 >
14082 >
14083 >
14084 >
14085 >
14086 > for flag in -Wredundant-decls; do
14087 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14088 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14089 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14090 > if eval \${$as_CACHEVAR+:} false; then :
14091 >  $as_echo_n "(cached) " >&6
14092 > else
14093 >
14094 >  ax_check_save_flags=$CFLAGS
14095 >  CFLAGS="$CFLAGS  $flag"
14096 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14097   /* end confdefs.h.  */
13068 #include <limits.h>
14098  
14099   int
14100   main ()
14101   {
13073 #ifndef _BIG_ENDIAN
13074                 not big endian
13075                #endif
14102  
14103    ;
14104    return 0;
14105   }
14106   _ACEOF
14107   if ac_fn_c_try_compile "$LINENO"; then :
14108 <  ac_cv_c_bigendian=yes
14108 >  eval "$as_CACHEVAR=yes"
14109   else
14110 <  ac_cv_c_bigendian=no
14110 >  eval "$as_CACHEVAR=no"
14111   fi
14112   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14113 +  CFLAGS=$ax_check_save_flags
14114   fi
14115 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14116 <    fi
14117 <    if test $ac_cv_c_bigendian = unknown; then
14118 <      # Compile a test program.
14119 <      if test "$cross_compiling" = yes; then :
14120 <  # Try to guess by grepping values from an object file.
14121 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14115 > eval ac_res=\$$as_CACHEVAR
14116 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14117 > $as_echo "$ac_res" >&6; }
14118 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14119 >
14120 > if ${CFLAGS+:} false; then :
14121 >
14122 >  case " $CFLAGS " in #(
14123 >  *" $flag "*) :
14124 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14125 >  (: CFLAGS already contains $flag) 2>&5
14126 >  ac_status=$?
14127 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14128 >  test $ac_status = 0; } ;; #(
14129 >  *) :
14130 >
14131 >     as_fn_append CFLAGS " $flag"
14132 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14133 >  (: CFLAGS="$CFLAGS") 2>&5
14134 >  ac_status=$?
14135 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14136 >  test $ac_status = 0; }
14137 >     ;;
14138 > esac
14139 >
14140 > else
14141 >
14142 >  CFLAGS=$flag
14143 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14144 >  (: CFLAGS="$CFLAGS") 2>&5
14145 >  ac_status=$?
14146 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14147 >  test $ac_status = 0; }
14148 >
14149 > fi
14150 >
14151 > else
14152 >  :
14153 > fi
14154 >
14155 > done
14156 >
14157 >
14158 >
14159 >
14160 >
14161 > for flag in -Wshadow; do
14162 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14163 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14164 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14165 > if eval \${$as_CACHEVAR+:} false; then :
14166 >  $as_echo_n "(cached) " >&6
14167 > else
14168 >
14169 >  ax_check_save_flags=$CFLAGS
14170 >  CFLAGS="$CFLAGS  $flag"
14171 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14172   /* end confdefs.h.  */
13096 short int ascii_mm[] =
13097                  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
13098                short int ascii_ii[] =
13099                  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
13100                int use_ascii (int i) {
13101                  return ascii_mm[i] + ascii_ii[i];
13102                }
13103                short int ebcdic_ii[] =
13104                  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
13105                short int ebcdic_mm[] =
13106                  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
13107                int use_ebcdic (int i) {
13108                  return ebcdic_mm[i] + ebcdic_ii[i];
13109                }
13110                extern int foo;
14173  
14174   int
14175   main ()
14176   {
14177 < return use_ascii (foo) == use_ebcdic (foo);
14177 >
14178    ;
14179    return 0;
14180   }
14181   _ACEOF
14182   if ac_fn_c_try_compile "$LINENO"; then :
14183 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
14184 <              ac_cv_c_bigendian=yes
14185 <            fi
13124 <            if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
13125 <              if test "$ac_cv_c_bigendian" = unknown; then
13126 <                ac_cv_c_bigendian=no
13127 <              else
13128 <                # finding both strings is unlikely to happen, but who knows?
13129 <                ac_cv_c_bigendian=unknown
13130 <              fi
13131 <            fi
14183 >  eval "$as_CACHEVAR=yes"
14184 > else
14185 >  eval "$as_CACHEVAR=no"
14186   fi
14187   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14188 +  CFLAGS=$ax_check_save_flags
14189 + fi
14190 + eval ac_res=\$$as_CACHEVAR
14191 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14192 + $as_echo "$ac_res" >&6; }
14193 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14194 +
14195 + if ${CFLAGS+:} false; then :
14196 +
14197 +  case " $CFLAGS " in #(
14198 +  *" $flag "*) :
14199 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14200 +  (: CFLAGS already contains $flag) 2>&5
14201 +  ac_status=$?
14202 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14203 +  test $ac_status = 0; } ;; #(
14204 +  *) :
14205 +
14206 +     as_fn_append CFLAGS " $flag"
14207 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14208 +  (: CFLAGS="$CFLAGS") 2>&5
14209 +  ac_status=$?
14210 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14211 +  test $ac_status = 0; }
14212 +     ;;
14213 + esac
14214 +
14215 + else
14216 +
14217 +  CFLAGS=$flag
14218 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14219 +  (: CFLAGS="$CFLAGS") 2>&5
14220 +  ac_status=$?
14221 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14222 +  test $ac_status = 0; }
14223 +
14224 + fi
14225 +
14226   else
14227 +  :
14228 + fi
14229 +
14230 + done
14231 +
14232 +
14233 +
14234 +
14235 +
14236 + for flag in -Wsign-compare; do
14237 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14238 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14239 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14240 + if eval \${$as_CACHEVAR+:} false; then :
14241 +  $as_echo_n "(cached) " >&6
14242 + else
14243 +
14244 +  ax_check_save_flags=$CFLAGS
14245 +  CFLAGS="$CFLAGS  $flag"
14246    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14247   /* end confdefs.h.  */
14248 < $ac_includes_default
14248 >
14249   int
14250   main ()
14251   {
14252  
13142             /* Are we little or big endian?  From Harbison&Steele.  */
13143             union
13144             {
13145               long int l;
13146               char c[sizeof (long int)];
13147             } u;
13148             u.l = 1;
13149             return u.c[sizeof (long int) - 1] == 1;
13150
14253    ;
14254    return 0;
14255   }
14256   _ACEOF
14257 < if ac_fn_c_try_run "$LINENO"; then :
14258 <  ac_cv_c_bigendian=no
14257 > if ac_fn_c_try_compile "$LINENO"; then :
14258 >  eval "$as_CACHEVAR=yes"
14259   else
14260 <  ac_cv_c_bigendian=yes
14260 >  eval "$as_CACHEVAR=no"
14261   fi
14262 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
14263 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
14262 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14263 >  CFLAGS=$ax_check_save_flags
14264   fi
14265 + eval ac_res=\$$as_CACHEVAR
14266 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14267 + $as_echo "$ac_res" >&6; }
14268 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14269 +
14270 + if ${CFLAGS+:} false; then :
14271 +
14272 +  case " $CFLAGS " in #(
14273 +  *" $flag "*) :
14274 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14275 +  (: CFLAGS already contains $flag) 2>&5
14276 +  ac_status=$?
14277 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14278 +  test $ac_status = 0; } ;; #(
14279 +  *) :
14280 +
14281 +     as_fn_append CFLAGS " $flag"
14282 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14283 +  (: CFLAGS="$CFLAGS") 2>&5
14284 +  ac_status=$?
14285 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14286 +  test $ac_status = 0; }
14287 +     ;;
14288 + esac
14289 +
14290 + else
14291 +
14292 +  CFLAGS=$flag
14293 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14294 +  (: CFLAGS="$CFLAGS") 2>&5
14295 +  ac_status=$?
14296 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14297 +  test $ac_status = 0; }
14298  
13164    fi
14299   fi
13166 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
13167 $as_echo "$ac_cv_c_bigendian" >&6; }
13168 case $ac_cv_c_bigendian in #(
13169   yes)
13170     $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
13171 ;; #(
13172   no)
13173      ;; #(
13174   universal)
14300  
14301 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
14301 > else
14302 >  :
14303 > fi
14304 >
14305 > done
14306  
13178     ;; #(
13179   *)
13180     as_fn_error $? "unknown endianness
13181 presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13182 esac
14307  
14308  
14309 < # The cast to long int works around a bug in the HP C Compiler
14310 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14311 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14312 < # This bug is HP SR number 8606223364.
14313 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
14314 < $as_echo_n "checking size of int... " >&6; }
14315 < if ${ac_cv_sizeof_int+:} false; then :
14309 >
14310 >
14311 > for flag in -Wtype-limits; do
14312 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14313 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14314 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14315 > if eval \${$as_CACHEVAR+:} false; then :
14316    $as_echo_n "(cached) " >&6
14317   else
13194  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
14318  
14319 +  ax_check_save_flags=$CFLAGS
14320 +  CFLAGS="$CFLAGS  $flag"
14321 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14322 + /* end confdefs.h.  */
14323 +
14324 + int
14325 + main ()
14326 + {
14327 +
14328 +  ;
14329 +  return 0;
14330 + }
14331 + _ACEOF
14332 + if ac_fn_c_try_compile "$LINENO"; then :
14333 +  eval "$as_CACHEVAR=yes"
14334   else
14335 <  if test "$ac_cv_type_int" = yes; then
14336 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14337 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14338 < as_fn_error 77 "cannot compute sizeof (int)
14339 < See \`config.log' for more details" "$LINENO" 5; }
14340 <   else
14341 <     ac_cv_sizeof_int=0
14342 <   fi
14335 >  eval "$as_CACHEVAR=no"
14336 > fi
14337 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14338 >  CFLAGS=$ax_check_save_flags
14339 > fi
14340 > eval ac_res=\$$as_CACHEVAR
14341 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14342 > $as_echo "$ac_res" >&6; }
14343 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14344 >
14345 > if ${CFLAGS+:} false; then :
14346 >
14347 >  case " $CFLAGS " in #(
14348 >  *" $flag "*) :
14349 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14350 >  (: CFLAGS already contains $flag) 2>&5
14351 >  ac_status=$?
14352 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14353 >  test $ac_status = 0; } ;; #(
14354 >  *) :
14355 >
14356 >     as_fn_append CFLAGS " $flag"
14357 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14358 >  (: CFLAGS="$CFLAGS") 2>&5
14359 >  ac_status=$?
14360 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14361 >  test $ac_status = 0; }
14362 >     ;;
14363 > esac
14364 >
14365 > else
14366 >
14367 >  CFLAGS=$flag
14368 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14369 >  (: CFLAGS="$CFLAGS") 2>&5
14370 >  ac_status=$?
14371 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14372 >  test $ac_status = 0; }
14373 >
14374   fi
14375  
14376 + else
14377 +  :
14378   fi
14379 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
14380 < $as_echo "$ac_cv_sizeof_int" >&6; }
14379 >
14380 > done
14381  
14382  
14383  
13213 cat >>confdefs.h <<_ACEOF
13214 #define SIZEOF_INT $ac_cv_sizeof_int
13215 _ACEOF
14384  
14385  
14386 < # The cast to long int works around a bug in the HP C Compiler
14387 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14388 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14389 < # This bug is HP SR number 8606223364.
14390 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13223 < $as_echo_n "checking size of short... " >&6; }
13224 < if ${ac_cv_sizeof_short+:} false; then :
14386 > for flag in -Wundef; do
14387 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14388 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14389 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14390 > if eval \${$as_CACHEVAR+:} false; then :
14391    $as_echo_n "(cached) " >&6
14392   else
13227  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
14393  
14394 +  ax_check_save_flags=$CFLAGS
14395 +  CFLAGS="$CFLAGS  $flag"
14396 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14397 + /* end confdefs.h.  */
14398 +
14399 + int
14400 + main ()
14401 + {
14402 +
14403 +  ;
14404 +  return 0;
14405 + }
14406 + _ACEOF
14407 + if ac_fn_c_try_compile "$LINENO"; then :
14408 +  eval "$as_CACHEVAR=yes"
14409   else
14410 <  if test "$ac_cv_type_short" = yes; then
14411 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14412 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14413 < as_fn_error 77 "cannot compute sizeof (short)
14414 < See \`config.log' for more details" "$LINENO" 5; }
14415 <   else
14416 <     ac_cv_sizeof_short=0
14417 <   fi
14410 >  eval "$as_CACHEVAR=no"
14411 > fi
14412 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14413 >  CFLAGS=$ax_check_save_flags
14414 > fi
14415 > eval ac_res=\$$as_CACHEVAR
14416 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14417 > $as_echo "$ac_res" >&6; }
14418 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14419 >
14420 > if ${CFLAGS+:} false; then :
14421 >
14422 >  case " $CFLAGS " in #(
14423 >  *" $flag "*) :
14424 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14425 >  (: CFLAGS already contains $flag) 2>&5
14426 >  ac_status=$?
14427 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14428 >  test $ac_status = 0; } ;; #(
14429 >  *) :
14430 >
14431 >     as_fn_append CFLAGS " $flag"
14432 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14433 >  (: CFLAGS="$CFLAGS") 2>&5
14434 >  ac_status=$?
14435 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14436 >  test $ac_status = 0; }
14437 >     ;;
14438 > esac
14439 >
14440 > else
14441 >
14442 >  CFLAGS=$flag
14443 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14444 >  (: CFLAGS="$CFLAGS") 2>&5
14445 >  ac_status=$?
14446 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14447 >  test $ac_status = 0; }
14448 >
14449   fi
14450  
14451 + else
14452 +  :
14453   fi
14454 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
14455 < $as_echo "$ac_cv_sizeof_short" >&6; }
14454 >
14455 > done
14456  
14457  
14458  
13246 cat >>confdefs.h <<_ACEOF
13247 #define SIZEOF_SHORT $ac_cv_sizeof_short
13248 _ACEOF
14459  
14460  
14461 < # The cast to long int works around a bug in the HP C Compiler
14462 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14463 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14464 < # This bug is HP SR number 8606223364.
14465 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
13256 < $as_echo_n "checking size of long... " >&6; }
13257 < if ${ac_cv_sizeof_long+:} false; then :
14461 > for flag in -Wuninitialized; do
14462 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14463 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14464 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14465 > if eval \${$as_CACHEVAR+:} false; then :
14466    $as_echo_n "(cached) " >&6
14467   else
14468 <  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
14468 >
14469 >  ax_check_save_flags=$CFLAGS
14470 >  CFLAGS="$CFLAGS  $flag"
14471 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14472 > /* end confdefs.h.  */
14473 >
14474 > int
14475 > main ()
14476 > {
14477 >
14478 >  ;
14479 >  return 0;
14480 > }
14481 > _ACEOF
14482 > if ac_fn_c_try_compile "$LINENO"; then :
14483 >  eval "$as_CACHEVAR=yes"
14484 > else
14485 >  eval "$as_CACHEVAR=no"
14486 > fi
14487 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14488 >  CFLAGS=$ax_check_save_flags
14489 > fi
14490 > eval ac_res=\$$as_CACHEVAR
14491 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14492 > $as_echo "$ac_res" >&6; }
14493 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14494 >
14495 > if ${CFLAGS+:} false; then :
14496 >
14497 >  case " $CFLAGS " in #(
14498 >  *" $flag "*) :
14499 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14500 >  (: CFLAGS already contains $flag) 2>&5
14501 >  ac_status=$?
14502 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14503 >  test $ac_status = 0; } ;; #(
14504 >  *) :
14505 >
14506 >     as_fn_append CFLAGS " $flag"
14507 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14508 >  (: CFLAGS="$CFLAGS") 2>&5
14509 >  ac_status=$?
14510 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14511 >  test $ac_status = 0; }
14512 >     ;;
14513 > esac
14514  
14515   else
14516 <  if test "$ac_cv_type_long" = yes; then
14517 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14518 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14519 < as_fn_error 77 "cannot compute sizeof (long)
14520 < See \`config.log' for more details" "$LINENO" 5; }
14521 <   else
14522 <     ac_cv_sizeof_long=0
14523 <   fi
14516 >
14517 >  CFLAGS=$flag
14518 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14519 >  (: CFLAGS="$CFLAGS") 2>&5
14520 >  ac_status=$?
14521 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14522 >  test $ac_status = 0; }
14523 >
14524   fi
14525  
14526 + else
14527 +  :
14528   fi
14529 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
14530 < $as_echo "$ac_cv_sizeof_long" >&6; }
14529 >
14530 > done
14531  
14532  
14533  
14534 < cat >>confdefs.h <<_ACEOF
14535 < #define SIZEOF_LONG $ac_cv_sizeof_long
14534 >
14535 >
14536 > for flag in -Wwrite-strings; do
14537 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14538 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14539 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14540 > if eval \${$as_CACHEVAR+:} false; then :
14541 >  $as_echo_n "(cached) " >&6
14542 > else
14543 >
14544 >  ax_check_save_flags=$CFLAGS
14545 >  CFLAGS="$CFLAGS  $flag"
14546 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14547 > /* end confdefs.h.  */
14548 >
14549 > int
14550 > main ()
14551 > {
14552 >
14553 >  ;
14554 >  return 0;
14555 > }
14556   _ACEOF
14557 + if ac_fn_c_try_compile "$LINENO"; then :
14558 +  eval "$as_CACHEVAR=yes"
14559 + else
14560 +  eval "$as_CACHEVAR=no"
14561 + fi
14562 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14563 +  CFLAGS=$ax_check_save_flags
14564 + fi
14565 + eval ac_res=\$$as_CACHEVAR
14566 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14567 + $as_echo "$ac_res" >&6; }
14568 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14569  
14570 + if ${CFLAGS+:} false; then :
14571  
14572 +  case " $CFLAGS " in #(
14573 +  *" $flag "*) :
14574 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14575 +  (: CFLAGS already contains $flag) 2>&5
14576 +  ac_status=$?
14577 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14578 +  test $ac_status = 0; } ;; #(
14579 +  *) :
14580  
14581 +     as_fn_append CFLAGS " $flag"
14582 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14583 +  (: CFLAGS="$CFLAGS") 2>&5
14584 +  ac_status=$?
14585 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14586 +  test $ac_status = 0; }
14587 +     ;;
14588 + esac
14589  
14590 + else
14591  
14592 +  CFLAGS=$flag
14593 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14594 +  (: CFLAGS="$CFLAGS") 2>&5
14595 +  ac_status=$?
14596 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14597 +  test $ac_status = 0; }
14598  
14599 + fi
14600  
14601 + else
14602 +  :
14603 + fi
14604  
14605 + done
14606  
13291 subdirs="$subdirs src/libopm"
14607  
14608 + fi
14609  
14610  
14611 < # Check whether --with-werror was given.
14612 < if test "${with_werror+set}" = set; then :
14613 <  withval=$with_werror; CFLAGS="$CFLAGS -Werror"
14611 > for ac_func in strlcpy strlcat
14612 > do :
14613 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14614 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14615 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14616 >  cat >>confdefs.h <<_ACEOF
14617 > #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14618 > _ACEOF
14619 >
14620   fi
14621 + done
14622  
14623  
14624 < ac_config_files="$ac_config_files Makefile src/Makefile"
14624 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14625  
14626   cat >confcache <<\_ACEOF
14627   # This file is a shell script that caches the results of configure
# Line 13394 | Line 14717 | DEFS=-DHAVE_CONFIG_H
14717  
14718   ac_libobjs=
14719   ac_ltlibobjs=
14720 + U=
14721   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14722    # 1. Remove the extension, and $U if already installed.
14723    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
# Line 13436 | Line 14760 | if test -z "${am__fastdepCC_TRUE}" && te
14760    as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
14761   Usually this means the macro was only invoked conditionally." "$LINENO" 5
14762   fi
14763 <
14763 > if test -z "${ENABLE_SSL_TRUE}" && test -z "${ENABLE_SSL_FALSE}"; then
14764 >  as_fn_error $? "conditional \"ENABLE_SSL\" was never defined.
14765 > Usually this means the macro was only invoked conditionally." "$LINENO" 5
14766 > fi
14767  
14768   : "${CONFIG_STATUS=./config.status}"
14769   ac_write_fail=0
# Line 13834 | Line 15161 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15161   # report actual input values of CONFIG_FILES etc. instead of their
15162   # values after options handling.
15163   ac_log="
15164 < This file was extended by bopm $as_me 3.1.3, which was
15164 > This file was extended by hopm $as_me 1.1.5, which was
15165   generated by GNU Autoconf 2.69.  Invocation command line was
15166  
15167    CONFIG_FILES    = $CONFIG_FILES
# Line 13894 | Line 15221 | $config_headers
15221   Configuration commands:
15222   $config_commands
15223  
15224 < Report bugs to the package provider."
15224 > Report bugs to <bugs@ircd-hybrid.org>."
15225  
15226   _ACEOF
15227   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15228   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15229   ac_cs_version="\\
15230 < bopm config.status 3.1.3
15230 > hopm config.status 1.1.5
15231   configured by $0, generated by GNU Autoconf 2.69,
15232    with options \\"\$ac_cs_config\\"
15233  
# Line 14156 | Line 15483 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15483   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15484   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15485   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15486 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15486 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15487 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15488   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15489   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15490   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 14274 | Line 15602 | postinstall_cmds \
15602   postuninstall_cmds \
15603   finish_cmds \
15604   sys_lib_search_path_spec \
15605 < sys_lib_dlsearch_path_spec; do
15605 > configure_time_dlsearch_path \
15606 > configure_time_lt_sys_library_path; do
15607      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15608      *[\\\\\\\`\\"\\\$]*)
15609        eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
# Line 14314 | Line 15643 | do
15643      "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
15644      "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15645      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15646 +    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15647      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15648 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15649 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15650  
15651    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15652    esac
# Line 15050 | Line 16382 | $as_echo X"$file" |
16382   # The names of the tagged configurations supported by this script.
16383   available_tags=''
16384  
16385 + # Configured defaults for sys_lib_dlsearch_path munging.
16386 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16387 +
16388   # ### BEGIN LIBTOOL CONFIG
16389  
16390   # Which release of libtool.m4 was used?
# Line 15299 | Line 16634 | hardcode_into_libs=$hardcode_into_libs
16634   # Compile-time system search path for libraries.
16635   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16636  
16637 < # Run-time system search path for libraries.
16638 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16637 > # Detected run-time system search path for libraries.
16638 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16639 >
16640 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16641 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16642  
16643   # Whether dlopen is supported.
16644   dlopen_support=$enable_dlopen
# Line 15451 | Line 16789 | hardcode_action=$hardcode_action
16789  
16790   _LT_EOF
16791  
16792 +    cat <<'_LT_EOF' >> "$cfgfile"
16793 +
16794 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
16795 +
16796 + # func_munge_path_list VARIABLE PATH
16797 + # -----------------------------------
16798 + # VARIABLE is name of variable containing _space_ separated list of
16799 + # directories to be munged by the contents of PATH, which is string
16800 + # having a format:
16801 + # "DIR[:DIR]:"
16802 + #       string "DIR[ DIR]" will be prepended to VARIABLE
16803 + # ":DIR[:DIR]"
16804 + #       string "DIR[ DIR]" will be appended to VARIABLE
16805 + # "DIRP[:DIRP]::[DIRA:]DIRA"
16806 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
16807 + #       "DIRA[ DIRA]" will be appended to VARIABLE
16808 + # "DIR[:DIR]"
16809 + #       VARIABLE will be replaced by "DIR[ DIR]"
16810 + func_munge_path_list ()
16811 + {
16812 +    case x$2 in
16813 +    x)
16814 +        ;;
16815 +    *:)
16816 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
16817 +        ;;
16818 +    x:*)
16819 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
16820 +        ;;
16821 +    *::*)
16822 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
16823 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
16824 +        ;;
16825 +    *)
16826 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
16827 +        ;;
16828 +    esac
16829 + }
16830 +
16831 +
16832 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
16833 + func_cc_basename ()
16834 + {
16835 +    for cc_temp in $*""; do
16836 +      case $cc_temp in
16837 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
16838 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
16839 +        \-*) ;;
16840 +        *) break;;
16841 +      esac
16842 +    done
16843 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
16844 + }
16845 +
16846 +
16847 + # ### END FUNCTIONS SHARED WITH CONFIGURE
16848 +
16849 + _LT_EOF
16850 +
16851    case $host_os in
16852    aix3*)
16853      cat <<\_LT_EOF >> "$cfgfile"
# Line 15514 | Line 16911 | if test "$no_create" != yes; then
16911    # would make configure fail if this is the last instruction.
16912    $ac_cs_success || as_fn_exit 1
16913   fi
15517
15518 #
15519 # CONFIG_SUBDIRS section.
15520 #
15521 if test "$no_recursion" != yes; then
15522
15523  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
15524  # so they do not pile up.
15525  ac_sub_configure_args=
15526  ac_prev=
15527  eval "set x $ac_configure_args"
15528  shift
15529  for ac_arg
15530  do
15531    if test -n "$ac_prev"; then
15532      ac_prev=
15533      continue
15534    fi
15535    case $ac_arg in
15536    -cache-file | --cache-file | --cache-fil | --cache-fi \
15537    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
15538      ac_prev=cache_file ;;
15539    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
15540    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
15541    | --c=*)
15542      ;;
15543    --config-cache | -C)
15544      ;;
15545    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
15546      ac_prev=srcdir ;;
15547    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
15548      ;;
15549    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
15550      ac_prev=prefix ;;
15551    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
15552      ;;
15553    --disable-option-checking)
15554      ;;
15555    *)
15556      case $ac_arg in
15557      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15558      esac
15559      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
15560    esac
15561  done
15562
15563  # Always prepend --prefix to ensure using the same prefix
15564  # in subdir configurations.
15565  ac_arg="--prefix=$prefix"
15566  case $ac_arg in
15567  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15568  esac
15569  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
15570
15571  # Pass --silent
15572  if test "$silent" = yes; then
15573    ac_sub_configure_args="--silent $ac_sub_configure_args"
15574  fi
15575
15576  # Always prepend --disable-option-checking to silence warnings, since
15577  # different subdirs can have different --enable and --with options.
15578  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
15579
15580  ac_popdir=`pwd`
15581  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
15582
15583    # Do not complain, so a configure script can configure whichever
15584    # parts of a large source tree are present.
15585    test -d "$srcdir/$ac_dir" || continue
15586
15587    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
15588    $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
15589    $as_echo "$ac_msg" >&6
15590    as_dir="$ac_dir"; as_fn_mkdir_p
15591    ac_builddir=.
15592
15593 case "$ac_dir" in
15594 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
15595 *)
15596  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
15597  # A ".." for each directory in $ac_dir_suffix.
15598  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
15599  case $ac_top_builddir_sub in
15600  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
15601  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
15602  esac ;;
15603 esac
15604 ac_abs_top_builddir=$ac_pwd
15605 ac_abs_builddir=$ac_pwd$ac_dir_suffix
15606 # for backward compatibility:
15607 ac_top_builddir=$ac_top_build_prefix
15608
15609 case $srcdir in
15610  .)  # We are building in place.
15611    ac_srcdir=.
15612    ac_top_srcdir=$ac_top_builddir_sub
15613    ac_abs_top_srcdir=$ac_pwd ;;
15614  [\\/]* | ?:[\\/]* )  # Absolute name.
15615    ac_srcdir=$srcdir$ac_dir_suffix;
15616    ac_top_srcdir=$srcdir
15617    ac_abs_top_srcdir=$srcdir ;;
15618  *) # Relative name.
15619    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
15620    ac_top_srcdir=$ac_top_build_prefix$srcdir
15621    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
15622 esac
15623 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
15624
15625
15626    cd "$ac_dir"
15627
15628    # Check for guested configure; otherwise get Cygnus style configure.
15629    if test -f "$ac_srcdir/configure.gnu"; then
15630      ac_sub_configure=$ac_srcdir/configure.gnu
15631    elif test -f "$ac_srcdir/configure"; then
15632      ac_sub_configure=$ac_srcdir/configure
15633    elif test -f "$ac_srcdir/configure.in"; then
15634      # This should be Cygnus configure.
15635      ac_sub_configure=$ac_aux_dir/configure
15636    else
15637      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
15638 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
15639      ac_sub_configure=
15640    fi
15641
15642    # The recursion is here.
15643    if test -n "$ac_sub_configure"; then
15644      # Make the cache file name correct relative to the subdirectory.
15645      case $cache_file in
15646      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
15647      *) # Relative name.
15648        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
15649      esac
15650
15651      { $as_echo "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
15652 $as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
15653      # The eval makes quoting arguments work.
15654      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
15655           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
15656        as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
15657    fi
15658
15659    cd "$ac_popdir"
15660  done
15661 fi
16914   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
16915    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
16916   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
# Line 15666 | Line 16918 | fi
16918  
16919  
16920  
16921 < echo "##############################################################################"
16922 < echo "Everything is now configured, but you can find some more (infrequently"
15671 < echo "changed) options in options.h.  To compile BOPM now, just type make.  It"
15672 < echo "requires GNU Make, which may be installed as gmake on your system."
16921 > echo "###############################################################################"
16922 > echo "Configuration complete.  Type make (or gmake on some *BSD machines) to compile."
16923   echo
16924 < echo "bopm will be installed in ${prefix}.  To change this, run:"
16924 > echo "HOPM will be installed in ${prefix}.  To change this, run:"
16925   echo "   ./configure --prefix=DIRECTORY"
16926 < echo "##############################################################################"
15677 < echo
16926 > echo "###############################################################################"

Comparing:
hopm/trunk/configure (property svn:eol-style), Revision 5059 by michael, Mon Dec 22 13:43:00 2014 UTC vs.
hopm/branches/1.1.x/configure (property svn:eol-style), Revision 8228 by michael, Mon Apr 17 14:10:34 2017 UTC

# Line 0 | Line 1
1 + native

Comparing:
hopm/trunk/configure (property svn:keywords), Revision 5059 by michael, Mon Dec 22 13:43:00 2014 UTC vs.
hopm/branches/1.1.x/configure (property svn:keywords), Revision 8228 by michael, Mon Apr 17 14:10:34 2017 UTC

# Line 0 | Line 1
1 + Id

Diff Legend

Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)