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 8856 by michael, Sat Feb 9 18:53:33 2019 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8848 2019-02-09 18:31:58Z 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.6.
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.6'
595 > PACKAGE_STRING='hopm 1.1.6'
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
638 subdirs
641   LEXLIB
642   LEX_OUTPUT_ROOT
643   LEX
644   YFLAGS
645   YACC
646   CPP
647 + LT_SYS_LIBRARY_PATH
648   OTOOL64
649   OTOOL
650   LIPO
# Line 678 | Line 681 | am__nodep
681   AMDEPBACKSLASH
682   AMDEP_FALSE
683   AMDEP_TRUE
681 am__quote
684   am__include
685   DEPDIR
686   OBJEXT
# Line 755 | Line 757 | PACKAGE_VERSION
757   PACKAGE_TARNAME
758   PACKAGE_NAME
759   PATH_SEPARATOR
760 < SHELL'
760 > SHELL
761 > am__quote'
762   ac_subst_files=''
763   ac_user_opts='
764   enable_option_checking
765   enable_silent_rules
766   enable_maintainer_mode
764 with_extra_fascism
767   enable_dependency_tracking
768   enable_shared
769   enable_static
# Line 771 | Line 773 | with_aix_soname
773   with_gnu_ld
774   with_sysroot
775   enable_libtool_lock
776 < with_werror
776 > enable_openssl
777 > enable_assert
778 > enable_warnings
779 > enable_efence
780   '
781        ac_precious_vars='build_alias
782   host_alias
# Line 781 | Line 786 | CFLAGS
786   LDFLAGS
787   LIBS
788   CPPFLAGS
789 + LT_SYS_LIBRARY_PATH
790   CPP
791   YACC
792   YFLAGS'
793 < ac_subdirs_all='src/libopm'
793 >
794  
795   # Initialize some variables set by options.
796   ac_init_help=
# Line 1324 | Line 1330 | if test "$ac_init_help" = "long"; then
1330    # Omit some internal or obsolete options to make the list less imposing.
1331    # This message is too long to be a string in the A/UX 3.1 sh.
1332    cat <<_ACEOF
1333 < \`configure' configures bopm 3.1.3 to adapt to many kinds of systems.
1333 > \`configure' configures hopm 1.1.6 to adapt to many kinds of systems.
1334  
1335   Usage: $0 [OPTION]... [VAR=VALUE]...
1336  
# Line 1372 | Line 1378 | Fine tuning of the installation director
1378    --infodir=DIR           info documentation [DATAROOTDIR/info]
1379    --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1380    --mandir=DIR            man documentation [DATAROOTDIR/man]
1381 <  --docdir=DIR            documentation root [DATAROOTDIR/doc/bopm]
1381 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/hopm]
1382    --htmldir=DIR           html documentation [DOCDIR]
1383    --dvidir=DIR            dvi documentation [DOCDIR]
1384    --pdfdir=DIR            pdf documentation [DOCDIR]
# Line 1394 | Line 1400 | fi
1400  
1401   if test -n "$ac_init_help"; then
1402    case $ac_init_help in
1403 <     short | recursive ) echo "Configuration of bopm 3.1.3:";;
1403 >     short | recursive ) echo "Configuration of hopm 1.1.6:";;
1404     esac
1405    cat <<\_ACEOF
1406  
# Line 1416 | Line 1422 | Optional Features:
1422    --enable-fast-install[=PKGS]
1423                            optimize for fast installation [default=yes]
1424    --disable-libtool-lock  avoid locking (might break parallel builds)
1425 +  --enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1426 +  --disable-openssl            Disable LibreSSL/OpenSSL support.
1427 +  --enable-assert         Enable assert() statements
1428 +  --enable-warnings       Enable compiler warnings.
1429 +  --enable-efence         Enable linking with Electric Fence 'efence' memory
1430 +                          debugger library.
1431  
1432   Optional Packages:
1433    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1434    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1423  --with-extra-fascism    Add extra gcc3-specific warning flags
1435    --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1436                            both]
1437    --with-aix-soname=aix|svr4|both
# Line 1429 | Line 1440 | Optional Packages:
1440    --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
1441    --with-sysroot[=DIR]    Search for dependent libraries within DIR (or the
1442                            compiler's sysroot if not specified).
1432  --with-werror           use -Werror to abort compilation on any warning
1443  
1444   Some influential environment variables:
1445    CC          C compiler command
# Line 1439 | Line 1449 | Some influential environment variables:
1449    LIBS        libraries to pass to the linker, e.g. -l<library>
1450    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1451                you have headers in a nonstandard directory <include dir>
1452 +  LT_SYS_LIBRARY_PATH
1453 +              User-defined run-time library search path.
1454    CPP         C preprocessor
1455    YACC        The `Yet Another Compiler Compiler' implementation to use.
1456                Defaults to the first program found out of: `bison -y', `byacc',
# Line 1450 | Line 1462 | Some influential environment variables:
1462   Use these variables to override the choices made by `configure' or to help
1463   it to find libraries and programs with nonstandard names/locations.
1464  
1465 < Report bugs to the package provider.
1465 > Report bugs to <bugs@ircd-hybrid.org>.
1466   _ACEOF
1467   ac_status=$?
1468   fi
# Line 1513 | Line 1525 | fi
1525   test -n "$ac_init_help" && exit $ac_status
1526   if $ac_init_version; then
1527    cat <<\_ACEOF
1528 < bopm configure 3.1.3
1528 > hopm configure 1.1.6
1529   generated by GNU Autoconf 2.69
1530  
1531   Copyright (C) 2012 Free Software Foundation, Inc.
# Line 1787 | Line 1799 | $as_echo "$ac_res" >&6; }
1799    eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1800  
1801   } # 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
1802   cat >config.log <<_ACEOF
1803   This file contains any messages produced by compilers while
1804   running configure, to aid debugging if configure makes a mistake.
1805  
1806 < It was created by bopm $as_me 3.1.3, which was
1806 > It was created by hopm $as_me 1.1.6, which was
1807   generated by GNU Autoconf 2.69.  Invocation command line was
1808  
1809    $ $0 $@
# Line 2463 | Line 2151 | ac_link='$CC -o conftest$ac_exeext $CFLA
2151   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2152  
2153  
2154 <
2467 < ac_config_headers="$ac_config_headers src/setup.h"
2468 <
2469 < am__api_version='1.14'
2154 > am__api_version='1.16'
2155  
2156   ac_aux_dir=
2157   for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
# Line 2667 | Line 2352 | test "$program_suffix" != NONE &&
2352   ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2353   program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2354  
2355 < # expand $ac_aux_dir to an absolute path
2356 < am_aux_dir=`cd $ac_aux_dir && pwd`
2355 > # Expand $ac_aux_dir to an absolute path.
2356 > am_aux_dir=`cd "$ac_aux_dir" && pwd`
2357  
2358   if test x"${MISSING+set}" != xset; then
2359    case $am_aux_dir in
# Line 2687 | Line 2372 | else
2372   $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2373   fi
2374  
2375 < if test x"${install_sh}" != xset; then
2375 > if test x"${install_sh+set}" != xset; then
2376    case $am_aux_dir in
2377    *\ * | *\     *)
2378      install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
# Line 2980 | Line 2665 | fi
2665  
2666  
2667   # Define the identity of the package.
2668 < PACKAGE='bopm'
2669 < VERSION='3.1.3'
2668 > PACKAGE='hopm'
2669 > VERSION='1.1.6'
2670  
2671  
2672   cat >>confdefs.h <<_ACEOF
# Line 3011 | Line 2696 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2696  
2697   # For better backward compatibility.  To be removed once Automake 1.9.x
2698   # dies out for good.  For more background, see:
2699 < # <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700 < # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2699 > # <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700 > # <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2701   mkdir_p='$(MKDIR_P)'
2702  
2703 < # We need awk for the "check" target.  The system "awk" is bad on
2704 < # some platforms.
2703 > # We need awk for the "check" target (and possibly the TAP driver).  The
2704 > # system "awk" is bad on some platforms.
2705   # Always define AMTAR for backward compatibility.  Yes, it's still used
2706   # in the wild :-(  We should find a proper way to deprecate it ...
2707   AMTAR='$${TAR-tar}'
# Line 3063 | Line 2748 | END
2748   Aborting the configuration process, to ensure you take notice of the issue.
2749  
2750   You can download and install GNU coreutils to get an 'rm' implementation
2751 < that behaves properly: <http://www.gnu.org/software/coreutils/>.
2751 > that behaves properly: <https://www.gnu.org/software/coreutils/>.
2752  
2753   If you want to complete the configuration process using your problematic
2754   'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
# Line 3098 | Line 2783 | fi
2783  
2784  
2785  
2786 <
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 <
2786 > ac_config_headers="$ac_config_headers src/setup.h"
2787  
2788  
2789  
# Line 3112 | Line 2792 | DEPDIR="${am__leading_dot}deps"
2792  
2793   ac_config_commands="$ac_config_commands depfiles"
2794  
2795 <
2796 < am_make=${MAKE-make}
2797 < cat > confinc << 'END'
2795 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
2796 > $as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
2797 > cat > confinc.mk << 'END'
2798   am__doit:
2799 <        @echo this is the am__doit target
2799 >        @echo this is the am__doit target >confinc.out
2800   .PHONY: am__doit
2801   END
3122 # If we don't find an include directive, just comment out the code.
3123 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
3124 $as_echo_n "checking for style of include used by $am_make... " >&6; }
2802   am__include="#"
2803   am__quote=
2804 < _am_result=none
2805 < # First try GNU make style include.
2806 < echo "include confinc" > confmf
2807 < # Ignore all kinds of additional output from 'make'.
2808 < case `$am_make -s -f confmf 2> /dev/null` in #(
2809 < *the\ am__doit\ target*)
2810 <  am__include=include
2811 <  am__quote=
2812 <  _am_result=GNU
2813 <  ;;
2814 < esac
2815 < # Now try BSD make style include.
2816 < if test "$am__include" = "#"; then
2817 <   echo '.include "confinc"' > confmf
2818 <   case `$am_make -s -f confmf 2> /dev/null` in #(
2819 <   *the\ am__doit\ target*)
2820 <     am__include=.include
2821 <     am__quote="\""
2822 <     _am_result=BSD
2804 > # BSD make does it like this.
2805 > echo '.include "confinc.mk" # ignored' > confmf.BSD
2806 > # Other make implementations (GNU, Solaris 10, AIX) do it like this.
2807 > echo 'include confinc.mk # ignored' > confmf.GNU
2808 > _am_result=no
2809 > for s in GNU BSD; do
2810 >  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
2811 >   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
2812 >   ac_status=$?
2813 >   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2814 >   (exit $ac_status); }
2815 >  case $?:`cat confinc.out 2>/dev/null` in #(
2816 >  '0:this is the am__doit target') :
2817 >    case $s in #(
2818 >  BSD) :
2819 >    am__include='.include' am__quote='"' ;; #(
2820 >  *) :
2821 >    am__include='include' am__quote='' ;;
2822 > esac ;; #(
2823 >  *) :
2824       ;;
2825 <   esac
2826 < fi
2827 <
2828 <
2829 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
2830 < $as_echo "$_am_result" >&6; }
2831 < rm -f confinc confmf
2825 > esac
2826 >  if test "$am__include" != "#"; then
2827 >    _am_result="yes ($s style)"
2828 >    break
2829 >  fi
2830 > done
2831 > rm -f confinc.* confmf.*
2832 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
2833 > $as_echo "${_am_result}" >&6; }
2834  
2835   # Check whether --enable-dependency-tracking was given.
2836   if test "${enable_dependency_tracking+set}" = set; then :
# Line 4335 | Line 4015 | esac
4015  
4016  
4017  
4018 < macro_version='2.4.4'
4019 < macro_revision='2.4.4'
4018 > macro_version='2.4.6'
4019 > macro_revision='2.4.6'
4020  
4021  
4022  
# Line 6759 | Line 6439 | $as_echo "$lt_cv_truncate_bin" >&6; }
6439  
6440  
6441  
6442 +
6443 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6444 + func_cc_basename ()
6445 + {
6446 +    for cc_temp in $*""; do
6447 +      case $cc_temp in
6448 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6449 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6450 +        \-*) ;;
6451 +        *) break;;
6452 +      esac
6453 +    done
6454 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6455 + }
6456 +
6457   # Check whether --enable-libtool-lock was given.
6458   if test "${enable_libtool_lock+set}" = set; then :
6459    enableval=$enable_libtool_lock;
# Line 7766 | Line 7461 | $as_echo "$lt_cv_ld_force_load" >&6; }
7461      ;;
7462    esac
7463  
7464 + # func_munge_path_list VARIABLE PATH
7465 + # -----------------------------------
7466 + # VARIABLE is name of variable containing _space_ separated list of
7467 + # directories to be munged by the contents of PATH, which is string
7468 + # having a format:
7469 + # "DIR[:DIR]:"
7470 + #       string "DIR[ DIR]" will be prepended to VARIABLE
7471 + # ":DIR[:DIR]"
7472 + #       string "DIR[ DIR]" will be appended to VARIABLE
7473 + # "DIRP[:DIRP]::[DIRA:]DIRA"
7474 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7475 + #       "DIRA[ DIRA]" will be appended to VARIABLE
7476 + # "DIR[:DIR]"
7477 + #       VARIABLE will be replaced by "DIR[ DIR]"
7478 + func_munge_path_list ()
7479 + {
7480 +    case x$2 in
7481 +    x)
7482 +        ;;
7483 +    *:)
7484 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7485 +        ;;
7486 +    x:*)
7487 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7488 +        ;;
7489 +    *::*)
7490 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7491 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7492 +        ;;
7493 +    *)
7494 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7495 +        ;;
7496 +    esac
7497 + }
7498 +
7499   ac_ext=c
7500   ac_cpp='$CPP $CPPFLAGS'
7501   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8353 | Line 8083 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8083   test -z "$LD" && LD=ld
8084   test -z "$ac_objext" && ac_objext=o
8085  
8086 < for cc_temp in $compiler""; do
8087 <  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-%%"`
8086 > func_cc_basename $compiler
8087 > cc_basename=$func_cc_basename_result
8088  
8089  
8090   # Only perform the check for file, if the check method requires it
# Line 8561 | Line 8284 | _lt_linker_boilerplate=`cat conftest.err
8284   $RM -r conftest*
8285  
8286  
8287 + ## CAVEAT EMPTOR:
8288 + ## There is no encapsulation within the following macros, do not change
8289 + ## the running order or otherwise move them around unless you know exactly
8290 + ## what you are doing...
8291   if test -n "$compiler"; then
8292  
8293   lt_prog_compiler_no_builtin_flag=
# Line 10816 | Line 10543 | hardcode_into_libs=no
10543   # flags to be left without arguments
10544   need_version=unknown
10545  
10546 +
10547 +
10548   case $host_os in
10549   aix3*)
10550    version_type=linux # correct to gnu/linux during the next big refactor
# Line 11104 | Line 10833 | freebsd* | dragonfly*)
10833    case $version_type in
10834      freebsd-elf*)
10835        library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10836 +      soname_spec='$libname$release$shared_ext$major'
10837        need_version=no
10838        need_lib_prefix=no
10839        ;;
# Line 11163 | Line 10893 | hpux9* | hpux10* | hpux11*)
10893      soname_spec='$libname$release$shared_ext$major'
10894      if test 32 = "$HPUX_IA64_MODE"; then
10895        sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10896 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10897      else
10898        sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10899 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10900      fi
11169    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10901      ;;
10902    hppa*64*)
10903      shrext_cmds='.sl'
# Line 11318 | Line 11049 | fi
11049    # before this can be enabled.
11050    hardcode_into_libs=yes
11051  
11052 <  # Append ld.so.conf contents to the search path
11052 >  # Ideally, we could use ldconfig to report *all* directores which are
11053 >  # searched for libraries, however this is still not possible.  Aside from not
11054 >  # being certain /sbin/ldconfig is available, command
11055 >  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11056 >  # even though it is searched at run-time.  Try to do the best guess by
11057 >  # appending ld.so.conf contents (and includes) to the search path.
11058    if test -f /etc/ld.so.conf; then
11059      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' ' '`
11060      sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
# Line 11543 | Line 11279 | fi
11279   if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11280    sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11281   fi
11282 +
11283   if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11284    sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11285   fi
11286  
11287 + # remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11288 + configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11289 +
11290 + # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11291 + func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11292 +
11293 + # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11294 + configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11295 +
11296 +
11297 +
11298 +
11299 +
11300 +
11301  
11302  
11303  
# Line 12327 | Line 12078 | CC=$lt_save_CC
12078  
12079  
12080  
12081 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
12082 < $as_echo_n "checking for ANSI C header files... " >&6; }
12083 < if ${ac_cv_header_stdc+:} false; then :
12081 > for ac_prog in 'bison -y' byacc
12082 > do
12083 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
12084 > set dummy $ac_prog; ac_word=$2
12085 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12086 > $as_echo_n "checking for $ac_word... " >&6; }
12087 > if ${ac_cv_prog_YACC+:} false; then :
12088    $as_echo_n "(cached) " >&6
12089   else
12090 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12090 >  if test -n "$YACC"; then
12091 >  ac_cv_prog_YACC="$YACC" # Let the user override the test.
12092 > else
12093 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12094 > for as_dir in $PATH
12095 > do
12096 >  IFS=$as_save_IFS
12097 >  test -z "$as_dir" && as_dir=.
12098 >    for ac_exec_ext in '' $ac_executable_extensions; do
12099 >  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12100 >    ac_cv_prog_YACC="$ac_prog"
12101 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12102 >    break 2
12103 >  fi
12104 > done
12105 >  done
12106 > IFS=$as_save_IFS
12107 >
12108 > fi
12109 > fi
12110 > YACC=$ac_cv_prog_YACC
12111 > if test -n "$YACC"; then
12112 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
12113 > $as_echo "$YACC" >&6; }
12114 > else
12115 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12116 > $as_echo "no" >&6; }
12117 > fi
12118 >
12119 >
12120 >  test -n "$YACC" && break
12121 > done
12122 > test -n "$YACC" || YACC="yacc"
12123 >
12124 >
12125 > for ac_prog in flex lex
12126 > do
12127 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
12128 > set dummy $ac_prog; ac_word=$2
12129 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
12130 > $as_echo_n "checking for $ac_word... " >&6; }
12131 > if ${ac_cv_prog_LEX+:} false; then :
12132 >  $as_echo_n "(cached) " >&6
12133 > else
12134 >  if test -n "$LEX"; then
12135 >  ac_cv_prog_LEX="$LEX" # Let the user override the test.
12136 > else
12137 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12138 > for as_dir in $PATH
12139 > do
12140 >  IFS=$as_save_IFS
12141 >  test -z "$as_dir" && as_dir=.
12142 >    for ac_exec_ext in '' $ac_executable_extensions; do
12143 >  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
12144 >    ac_cv_prog_LEX="$ac_prog"
12145 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
12146 >    break 2
12147 >  fi
12148 > done
12149 >  done
12150 > IFS=$as_save_IFS
12151 >
12152 > fi
12153 > fi
12154 > LEX=$ac_cv_prog_LEX
12155 > if test -n "$LEX"; then
12156 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
12157 > $as_echo "$LEX" >&6; }
12158 > else
12159 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
12160 > $as_echo "no" >&6; }
12161 > fi
12162 >
12163 >
12164 >  test -n "$LEX" && break
12165 > done
12166 > test -n "$LEX" || LEX=":"
12167 >
12168 > if test "x$LEX" != "x:"; then
12169 >  cat >conftest.l <<_ACEOF
12170 > %%
12171 > a { ECHO; }
12172 > b { REJECT; }
12173 > c { yymore (); }
12174 > d { yyless (1); }
12175 > e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
12176 >    yyless ((input () != 0)); }
12177 > f { unput (yytext[0]); }
12178 > . { BEGIN INITIAL; }
12179 > %%
12180 > #ifdef YYTEXT_POINTER
12181 > extern char *yytext;
12182 > #endif
12183 > int
12184 > main (void)
12185 > {
12186 >  return ! yylex () + ! yywrap ();
12187 > }
12188 > _ACEOF
12189 > { { ac_try="$LEX conftest.l"
12190 > case "(($ac_try" in
12191 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12192 >  *) ac_try_echo=$ac_try;;
12193 > esac
12194 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
12195 > $as_echo "$ac_try_echo"; } >&5
12196 >  (eval "$LEX conftest.l") 2>&5
12197 >  ac_status=$?
12198 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12199 >  test $ac_status = 0; }
12200 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
12201 > $as_echo_n "checking lex output file root... " >&6; }
12202 > if ${ac_cv_prog_lex_root+:} false; then :
12203 >  $as_echo_n "(cached) " >&6
12204 > else
12205 >
12206 > if test -f lex.yy.c; then
12207 >  ac_cv_prog_lex_root=lex.yy
12208 > elif test -f lexyy.c; then
12209 >  ac_cv_prog_lex_root=lexyy
12210 > else
12211 >  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
12212 > fi
12213 > fi
12214 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
12215 > $as_echo "$ac_cv_prog_lex_root" >&6; }
12216 > LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
12217 >
12218 > if test -z "${LEXLIB+set}"; then
12219 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
12220 > $as_echo_n "checking lex library... " >&6; }
12221 > if ${ac_cv_lib_lex+:} false; then :
12222 >  $as_echo_n "(cached) " >&6
12223 > else
12224 >
12225 >    ac_save_LIBS=$LIBS
12226 >    ac_cv_lib_lex='none needed'
12227 >    for ac_lib in '' -lfl -ll; do
12228 >      LIBS="$ac_lib $ac_save_LIBS"
12229 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12230 > /* end confdefs.h.  */
12231 > `cat $LEX_OUTPUT_ROOT.c`
12232 > _ACEOF
12233 > if ac_fn_c_try_link "$LINENO"; then :
12234 >  ac_cv_lib_lex=$ac_lib
12235 > fi
12236 > rm -f core conftest.err conftest.$ac_objext \
12237 >    conftest$ac_exeext conftest.$ac_ext
12238 >      test "$ac_cv_lib_lex" != 'none needed' && break
12239 >    done
12240 >    LIBS=$ac_save_LIBS
12241 >
12242 > fi
12243 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
12244 > $as_echo "$ac_cv_lib_lex" >&6; }
12245 >  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
12246 > fi
12247 >
12248 >
12249 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
12250 > $as_echo_n "checking whether yytext is a pointer... " >&6; }
12251 > if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
12252 >  $as_echo_n "(cached) " >&6
12253 > else
12254 >  # POSIX says lex can declare yytext either as a pointer or an array; the
12255 > # default is implementation-dependent.  Figure out which it is, since
12256 > # not all implementations provide the %pointer and %array declarations.
12257 > ac_cv_prog_lex_yytext_pointer=no
12258 > ac_save_LIBS=$LIBS
12259 > LIBS="$LEXLIB $ac_save_LIBS"
12260 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12261 > /* end confdefs.h.  */
12262 >
12263 >  #define YYTEXT_POINTER 1
12264 > `cat $LEX_OUTPUT_ROOT.c`
12265 > _ACEOF
12266 > if ac_fn_c_try_link "$LINENO"; then :
12267 >  ac_cv_prog_lex_yytext_pointer=yes
12268 > fi
12269 > rm -f core conftest.err conftest.$ac_objext \
12270 >    conftest$ac_exeext conftest.$ac_ext
12271 > LIBS=$ac_save_LIBS
12272 >
12273 > fi
12274 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
12275 > $as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
12276 > if test $ac_cv_prog_lex_yytext_pointer = yes; then
12277 >
12278 > $as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
12279 >
12280 > fi
12281 > rm -f conftest.l $LEX_OUTPUT_ROOT.c
12282 >
12283 > fi
12284 > if test "$LEX" = :; then
12285 >  LEX=${am_missing_run}flex
12286 > fi
12287 >
12288 >
12289 >
12290 >  if test "X$CC" != "X"; then
12291 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12292 > $as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12293 > if ${ssp_cv_cc+:} false; then :
12294 >  $as_echo_n "(cached) " >&6
12295 > else
12296 >  ssp_old_cflags="$CFLAGS"
12297 >       CFLAGS="$CFLAGS -fstack-protector-strong"
12298 >       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12299   /* end confdefs.h.  */
12337 #include <stdlib.h>
12338 #include <stdarg.h>
12339 #include <string.h>
12340 #include <float.h>
12300  
12301   int
12302   main ()
# Line 12348 | Line 12307 | main ()
12307   }
12308   _ACEOF
12309   if ac_fn_c_try_compile "$LINENO"; then :
12310 <  ac_cv_header_stdc=yes
12310 >  ssp_cv_cc=yes
12311   else
12312 <  ac_cv_header_stdc=no
12312 >  ssp_cv_cc=no
12313   fi
12314   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12315 +       CFLAGS="$ssp_old_cflags"
12316  
12317 < if test $ac_cv_header_stdc = yes; then
12318 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
12319 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12317 > fi
12318 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12319 > $as_echo "$ssp_cv_cc" >&6; }
12320 >    if test $ssp_cv_cc = yes; then
12321 >      CFLAGS="$CFLAGS -fstack-protector-strong"
12322 >
12323 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12324 >
12325 >    else
12326 >      unset ssp_cv_cc
12327 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12328 > $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12329 > if ${ssp_cv_cc+:} false; then :
12330 >  $as_echo_n "(cached) " >&6
12331 > else
12332 >  ssp_old_cflags="$CFLAGS"
12333 >         CFLAGS="$CFLAGS -fstack-protector"
12334 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12335   /* end confdefs.h.  */
12361 #include <string.h>
12336  
12337 + int
12338 + main ()
12339 + {
12340 +
12341 +  ;
12342 +  return 0;
12343 + }
12344   _ACEOF
12345 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12346 <  $EGREP "memchr" >/dev/null 2>&1; then :
12345 > if ac_fn_c_try_compile "$LINENO"; then :
12346 >  ssp_cv_cc=yes
12347 > else
12348 >  ssp_cv_cc=no
12349 > fi
12350 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12351 >         CFLAGS="$ssp_old_cflags"
12352  
12353 + fi
12354 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12355 + $as_echo "$ssp_cv_cc" >&6; }
12356 +      if test $ssp_cv_cc = yes; then
12357 +        CFLAGS="$CFLAGS -fstack-protector"
12358 +
12359 + $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12360 +
12361 +      fi
12362 +    fi
12363 +  fi
12364 +
12365 +
12366 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12367 + $as_echo_n "checking whether libssp exists... " >&6; }
12368 + if ${ssp_cv_lib+:} false; then :
12369 +  $as_echo_n "(cached) " >&6
12370   else
12371 <  ac_cv_header_stdc=no
12371 >  ssp_old_libs="$LIBS"
12372 >     LIBS="$LIBS -lssp"
12373 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12374 > /* end confdefs.h.  */
12375 >
12376 > int
12377 > main ()
12378 > {
12379 >
12380 >  ;
12381 >  return 0;
12382 > }
12383 > _ACEOF
12384 > if ac_fn_c_try_link "$LINENO"; then :
12385 >  ssp_cv_lib=yes
12386 > else
12387 >  ssp_cv_lib=no
12388   fi
12389 < rm -f conftest*
12389 > rm -f core conftest.err conftest.$ac_objext \
12390 >    conftest$ac_exeext conftest.$ac_ext
12391 >     LIBS="$ssp_old_libs"
12392  
12393   fi
12394 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12395 + $as_echo "$ssp_cv_lib" >&6; }
12396 +  if test $ssp_cv_lib = yes; then
12397 +    LIBS="$LIBS -lssp"
12398 +  fi
12399  
12400 < if test $ac_cv_header_stdc = yes; then
12401 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
12402 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12400 >
12401 >
12402 >  ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12403 > if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12404 >
12405 > else
12406 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing getaddrinfo" >&5
12407 > $as_echo_n "checking for library containing getaddrinfo... " >&6; }
12408 > if ${ac_cv_search_getaddrinfo+:} false; then :
12409 >  $as_echo_n "(cached) " >&6
12410 > else
12411 >  ac_func_search_save_LIBS=$LIBS
12412 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12413   /* end confdefs.h.  */
12378 #include <stdlib.h>
12414  
12415 + /* Override any GCC internal prototype to avoid an error.
12416 +   Use char because int might match the return type of a GCC
12417 +   builtin and then its argument prototype would still apply.  */
12418 + #ifdef __cplusplus
12419 + extern "C"
12420 + #endif
12421 + char getaddrinfo ();
12422 + int
12423 + main ()
12424 + {
12425 + return getaddrinfo ();
12426 +  ;
12427 +  return 0;
12428 + }
12429   _ACEOF
12430 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12431 <  $EGREP "free" >/dev/null 2>&1; then :
12430 > for ac_lib in '' nsl; do
12431 >  if test -z "$ac_lib"; then
12432 >    ac_res="none required"
12433 >  else
12434 >    ac_res=-l$ac_lib
12435 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12436 >  fi
12437 >  if ac_fn_c_try_link "$LINENO"; then :
12438 >  ac_cv_search_getaddrinfo=$ac_res
12439 > fi
12440 > rm -f core conftest.err conftest.$ac_objext \
12441 >    conftest$ac_exeext
12442 >  if ${ac_cv_search_getaddrinfo+:} false; then :
12443 >  break
12444 > fi
12445 > done
12446 > if ${ac_cv_search_getaddrinfo+:} false; then :
12447  
12448   else
12449 <  ac_cv_header_stdc=no
12449 >  ac_cv_search_getaddrinfo=no
12450   fi
12451 < rm -f conftest*
12451 > rm conftest.$ac_ext
12452 > LIBS=$ac_func_search_save_LIBS
12453 > fi
12454 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getaddrinfo" >&5
12455 > $as_echo "$ac_cv_search_getaddrinfo" >&6; }
12456 > ac_res=$ac_cv_search_getaddrinfo
12457 > if test "$ac_res" != no; then :
12458 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12459  
12460   fi
12461  
12462 < if test $ac_cv_header_stdc = yes; then
12463 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
12462 > fi
12463 >
12464 >  ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12465 > if test "x$ac_cv_func_getnameinfo" = xyes; then :
12466 >
12467 > else
12468 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing getnameinfo" >&5
12469 > $as_echo_n "checking for library containing getnameinfo... " >&6; }
12470 > if ${ac_cv_search_getnameinfo+:} false; then :
12471 >  $as_echo_n "(cached) " >&6
12472 > else
12473 >  ac_func_search_save_LIBS=$LIBS
12474 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12475 > /* end confdefs.h.  */
12476 >
12477 > /* Override any GCC internal prototype to avoid an error.
12478 >   Use char because int might match the return type of a GCC
12479 >   builtin and then its argument prototype would still apply.  */
12480 > #ifdef __cplusplus
12481 > extern "C"
12482 > #endif
12483 > char getnameinfo ();
12484 > int
12485 > main ()
12486 > {
12487 > return getnameinfo ();
12488 >  ;
12489 >  return 0;
12490 > }
12491 > _ACEOF
12492 > for ac_lib in '' nsl; do
12493 >  if test -z "$ac_lib"; then
12494 >    ac_res="none required"
12495 >  else
12496 >    ac_res=-l$ac_lib
12497 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12498 >  fi
12499 >  if ac_fn_c_try_link "$LINENO"; then :
12500 >  ac_cv_search_getnameinfo=$ac_res
12501 > fi
12502 > rm -f core conftest.err conftest.$ac_objext \
12503 >    conftest$ac_exeext
12504 >  if ${ac_cv_search_getnameinfo+:} false; then :
12505 >  break
12506 > fi
12507 > done
12508 > if ${ac_cv_search_getnameinfo+:} false; then :
12509 >
12510 > else
12511 >  ac_cv_search_getnameinfo=no
12512 > fi
12513 > rm conftest.$ac_ext
12514 > LIBS=$ac_func_search_save_LIBS
12515 > fi
12516 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getnameinfo" >&5
12517 > $as_echo "$ac_cv_search_getnameinfo" >&6; }
12518 > ac_res=$ac_cv_search_getnameinfo
12519 > if test "$ac_res" != no; then :
12520 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12521 >
12522 > fi
12523 >
12524 > fi
12525 >
12526 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12527 > $as_echo_n "checking for library containing socket... " >&6; }
12528 > if ${ac_cv_search_socket+:} false; then :
12529 >  $as_echo_n "(cached) " >&6
12530 > else
12531 >  ac_func_search_save_LIBS=$LIBS
12532 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12533 > /* end confdefs.h.  */
12534 >
12535 > /* Override any GCC internal prototype to avoid an error.
12536 >   Use char because int might match the return type of a GCC
12537 >   builtin and then its argument prototype would still apply.  */
12538 > #ifdef __cplusplus
12539 > extern "C"
12540 > #endif
12541 > char socket ();
12542 > int
12543 > main ()
12544 > {
12545 > return socket ();
12546 >  ;
12547 >  return 0;
12548 > }
12549 > _ACEOF
12550 > for ac_lib in '' socket; do
12551 >  if test -z "$ac_lib"; then
12552 >    ac_res="none required"
12553 >  else
12554 >    ac_res=-l$ac_lib
12555 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12556 >  fi
12557 >  if ac_fn_c_try_link "$LINENO"; then :
12558 >  ac_cv_search_socket=$ac_res
12559 > fi
12560 > rm -f core conftest.err conftest.$ac_objext \
12561 >    conftest$ac_exeext
12562 >  if ${ac_cv_search_socket+:} false; then :
12563 >  break
12564 > fi
12565 > done
12566 > if ${ac_cv_search_socket+:} false; then :
12567 >
12568 > else
12569 >  ac_cv_search_socket=no
12570 > fi
12571 > rm conftest.$ac_ext
12572 > LIBS=$ac_func_search_save_LIBS
12573 > fi
12574 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12575 > $as_echo "$ac_cv_search_socket" >&6; }
12576 > ac_res=$ac_cv_search_socket
12577 > if test "$ac_res" != no; then :
12578 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12579 >
12580 > else
12581 >  as_fn_error $? "socket library not found" "$LINENO" 5
12582 > fi
12583 >
12584 >
12585 >
12586 > # Check whether --enable-openssl was given.
12587 > if test "${enable_openssl+set}" = set; then :
12588 >  enableval=$enable_openssl;  cf_enable_openssl=$enableval
12589 > else
12590 >   cf_enable_openssl="auto"
12591 > fi
12592 >
12593 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12594 > $as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12595 > if test "$cf_enable_openssl" != "no"; then
12596 >  cf_openssl_basedir=""
12597 >  if test "$cf_enable_openssl" != "auto" &&
12598 >     test "$cf_enable_openssl" != "yes"; then
12599 >          cf_openssl_basedir="${cf_enable_openssl}"
12600 >  else
12601 >        for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12602 >                /opt /opt/openssl /usr/local/openssl; do
12603 >      if test -f "${dirs}/include/openssl/opensslv.h"; then
12604 >        cf_openssl_basedir="${dirs}"
12605 >        break
12606 >      fi
12607 >    done
12608 >    unset dirs
12609 >  fi
12610 >
12611 >    if test ! -z "$cf_openssl_basedir"; then
12612 >    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12613 >      CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12614 >      LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12615 >    else
12616 >                  cf_openssl_basedir=""
12617 >    fi
12618 >  else
12619 >                            if test -f "/usr/include/openssl/opensslv.h"; then
12620 >      cf_openssl_basedir="/usr"
12621 >    fi
12622 >  fi
12623 >
12624 >      if test ! -z "$cf_openssl_basedir"; then
12625 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12626 > $as_echo "$cf_openssl_basedir" >&6; }
12627 >    cf_enable_openssl="yes"
12628 >  else
12629 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12630 > $as_echo "not found. Please check your path." >&6; }
12631 >    cf_enable_openssl="no"
12632 >  fi
12633 >  unset cf_openssl_basedir
12634 > else
12635 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12636 > $as_echo "disabled" >&6; }
12637 > fi
12638 >
12639 > if test "$cf_enable_openssl" != "no"; then :
12640 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 1.0.1f and above" >&5
12641 > $as_echo_n "checking for LibreSSL or OpenSSL 1.0.1f and above... " >&6; }
12642    if test "$cross_compiling" = yes; then :
12643 <  :
12643 >  cf_openssl_version_ok=no
12644   else
12645    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12646   /* 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
12647  
12648 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
12648 >
12649 >    #include <openssl/opensslv.h>
12650 >    #include <stdlib.h>
12651   int
12652   main ()
12653   {
12654 <  int i;
12655 <  for (i = 0; i < 256; i++)
12417 <    if (XOR (islower (i), ISLOWER (i))
12418 <        || toupper (i) != TOUPPER (i))
12419 <      return 2;
12654 > exit(!(OPENSSL_VERSION_NUMBER >= 0x1000106fL));
12655 >  ;
12656    return 0;
12657   }
12658   _ACEOF
12659   if ac_fn_c_try_run "$LINENO"; then :
12660 <
12660 >  cf_openssl_version_ok=yes
12661   else
12662 <  ac_cv_header_stdc=no
12662 >  cf_openssl_version_ok=no
12663   fi
12664   rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12665    conftest.$ac_objext conftest.beam conftest.$ac_ext
12666   fi
12667  
12668 +
12669 +  if test "$cf_openssl_version_ok" = "yes"; then :
12670 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12671 + $as_echo "found" >&6; }
12672 +
12673 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12674 + $as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12675 + if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12676 +  $as_echo_n "(cached) " >&6
12677 + else
12678 +  ac_check_lib_save_LIBS=$LIBS
12679 + LIBS="-lcrypto  $LIBS"
12680 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12681 + /* end confdefs.h.  */
12682 +
12683 + /* Override any GCC internal prototype to avoid an error.
12684 +   Use char because int might match the return type of a GCC
12685 +   builtin and then its argument prototype would still apply.  */
12686 + #ifdef __cplusplus
12687 + extern "C"
12688 + #endif
12689 + char RSA_free ();
12690 + int
12691 + main ()
12692 + {
12693 + return RSA_free ();
12694 +  ;
12695 +  return 0;
12696 + }
12697 + _ACEOF
12698 + if ac_fn_c_try_link "$LINENO"; then :
12699 +  ac_cv_lib_crypto_RSA_free=yes
12700 + else
12701 +  ac_cv_lib_crypto_RSA_free=no
12702   fi
12703 + rm -f core conftest.err conftest.$ac_objext \
12704 +    conftest$ac_exeext conftest.$ac_ext
12705 + LIBS=$ac_check_lib_save_LIBS
12706   fi
12707 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
12708 < $as_echo "$ac_cv_header_stdc" >&6; }
12709 < if test $ac_cv_header_stdc = yes; then
12707 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12708 > $as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12709 > if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12710 >  cat >>confdefs.h <<_ACEOF
12711 > #define HAVE_LIBCRYPTO 1
12712 > _ACEOF
12713  
12714 < $as_echo "#define STDC_HEADERS 1" >>confdefs.h
12714 >  LIBS="-lcrypto $LIBS"
12715  
12716   fi
12717  
12718 +    if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12719 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12720 + $as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12721 + if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12722 +  $as_echo_n "(cached) " >&6
12723 + else
12724 +  ac_check_lib_save_LIBS=$LIBS
12725 + LIBS="-lssl  $LIBS"
12726 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12727 + /* end confdefs.h.  */
12728  
12729 < for ac_header in sys/poll.h
12730 < do :
12731 <  ac_fn_c_check_header_mongrel "$LINENO" "sys/poll.h" "ac_cv_header_sys_poll_h" "$ac_includes_default"
12732 < if test "x$ac_cv_header_sys_poll_h" = xyes; then :
12729 > /* Override any GCC internal prototype to avoid an error.
12730 >   Use char because int might match the return type of a GCC
12731 >   builtin and then its argument prototype would still apply.  */
12732 > #ifdef __cplusplus
12733 > extern "C"
12734 > #endif
12735 > char SSL_connect ();
12736 > int
12737 > main ()
12738 > {
12739 > return SSL_connect ();
12740 >  ;
12741 >  return 0;
12742 > }
12743 > _ACEOF
12744 > if ac_fn_c_try_link "$LINENO"; then :
12745 >  ac_cv_lib_ssl_SSL_connect=yes
12746 > else
12747 >  ac_cv_lib_ssl_SSL_connect=no
12748 > fi
12749 > rm -f core conftest.err conftest.$ac_objext \
12750 >    conftest$ac_exeext conftest.$ac_ext
12751 > LIBS=$ac_check_lib_save_LIBS
12752 > fi
12753 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12754 > $as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12755 > if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12756    cat >>confdefs.h <<_ACEOF
12757 < #define HAVE_SYS_POLL_H 1
12757 > #define HAVE_LIBSSL 1
12758   _ACEOF
12759 < have_poll_sys_h=yes
12759 >
12760 >  LIBS="-lssl $LIBS"
12761 >
12762 > fi
12763 >
12764 > fi
12765 >
12766   else
12767 <  have_sys_poll_h=no
12767 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12768 > $as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12769 >    cf_enable_openssl="no"
12770 > fi
12771   fi
12772  
12455 done
12773  
12774 +  # Check whether --enable-assert was given.
12775 + if test "${enable_assert+set}" = set; then :
12776 +  enableval=$enable_assert; assert=$enableval
12777 + else
12778 +  assert=no
12779 + fi
12780  
12781 < for ac_header in fcntl.h sys/time.h unistd.h strings.h
12782 < do :
12783 <  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
12784 < 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 >  if test "$assert" = "no"; then :
12783 >
12784 > $as_echo "#define NDEBUG 1" >>confdefs.h
12785  
12786   fi
12787  
12469 done
12788  
12789 +  # Check whether --enable-warnings was given.
12790 + if test "${enable_warnings+set}" = set; then :
12791 +  enableval=$enable_warnings; warnings="$enableval"
12792 + else
12793 +  warnings="no"
12794 + fi
12795  
12796 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
12797 < $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
12798 < if ${ac_cv_c_const+:} false; then :
12796 >
12797 >  if test "$warnings" = "yes"; then :
12798 >
12799 >
12800 >
12801 >
12802 >
12803 > for flag in -Wall; do
12804 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12805 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12806 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12807 > if eval \${$as_CACHEVAR+:} false; then :
12808    $as_echo_n "(cached) " >&6
12809   else
12810 +
12811 +  ax_check_save_flags=$CFLAGS
12812 +  CFLAGS="$CFLAGS  $flag"
12813    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12814   /* end confdefs.h.  */
12815  
# Line 12481 | Line 12817 | int
12817   main ()
12818   {
12819  
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
12820    ;
12821    return 0;
12822   }
12823   _ACEOF
12824   if ac_fn_c_try_compile "$LINENO"; then :
12825 <  ac_cv_c_const=yes
12825 >  eval "$as_CACHEVAR=yes"
12826   else
12827 <  ac_cv_c_const=no
12827 >  eval "$as_CACHEVAR=no"
12828   fi
12829   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12830 +  CFLAGS=$ax_check_save_flags
12831   fi
12832 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
12833 < $as_echo "$ac_cv_c_const" >&6; }
12834 < if test $ac_cv_c_const = no; then
12832 > eval ac_res=\$$as_CACHEVAR
12833 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12834 > $as_echo "$ac_res" >&6; }
12835 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12836 >
12837 > if ${CFLAGS+:} false; then :
12838 >
12839 >  case " $CFLAGS " in #(
12840 >  *" $flag "*) :
12841 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12842 >  (: CFLAGS already contains $flag) 2>&5
12843 >  ac_status=$?
12844 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12845 >  test $ac_status = 0; } ;; #(
12846 >  *) :
12847 >
12848 >     as_fn_append CFLAGS " $flag"
12849 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12850 >  (: CFLAGS="$CFLAGS") 2>&5
12851 >  ac_status=$?
12852 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12853 >  test $ac_status = 0; }
12854 >     ;;
12855 > esac
12856 >
12857 > else
12858 >
12859 >  CFLAGS=$flag
12860 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12861 >  (: CFLAGS="$CFLAGS") 2>&5
12862 >  ac_status=$?
12863 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12864 >  test $ac_status = 0; }
12865  
12866 < $as_echo "#define const /**/" >>confdefs.h
12866 > fi
12867  
12868 + else
12869 +  :
12870   fi
12871  
12872 < ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
12873 < if test "x$ac_cv_type_size_t" = xyes; then :
12872 > done
12873 >
12874  
12875 +
12876 +
12877 +
12878 + for flag in -Wbad-function-cast; do
12879 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12880 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12881 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12882 + if eval \${$as_CACHEVAR+:} false; then :
12883 +  $as_echo_n "(cached) " >&6
12884   else
12885  
12886 < cat >>confdefs.h <<_ACEOF
12887 < #define size_t unsigned int
12886 >  ax_check_save_flags=$CFLAGS
12887 >  CFLAGS="$CFLAGS  $flag"
12888 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12889 > /* end confdefs.h.  */
12890 >
12891 > int
12892 > main ()
12893 > {
12894 >
12895 >  ;
12896 >  return 0;
12897 > }
12898   _ACEOF
12899 + if ac_fn_c_try_compile "$LINENO"; then :
12900 +  eval "$as_CACHEVAR=yes"
12901 + else
12902 +  eval "$as_CACHEVAR=no"
12903 + fi
12904 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12905 +  CFLAGS=$ax_check_save_flags
12906 + fi
12907 + eval ac_res=\$$as_CACHEVAR
12908 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12909 + $as_echo "$ac_res" >&6; }
12910 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12911 +
12912 + if ${CFLAGS+:} false; then :
12913 +
12914 +  case " $CFLAGS " in #(
12915 +  *" $flag "*) :
12916 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12917 +  (: CFLAGS already contains $flag) 2>&5
12918 +  ac_status=$?
12919 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12920 +  test $ac_status = 0; } ;; #(
12921 +  *) :
12922  
12923 +     as_fn_append CFLAGS " $flag"
12924 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12925 +  (: CFLAGS="$CFLAGS") 2>&5
12926 +  ac_status=$?
12927 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12928 +  test $ac_status = 0; }
12929 +     ;;
12930 + esac
12931 +
12932 + else
12933 +
12934 +  CFLAGS=$flag
12935 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12936 +  (: CFLAGS="$CFLAGS") 2>&5
12937 +  ac_status=$?
12938 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12939 +  test $ac_status = 0; }
12940 +
12941 + fi
12942 +
12943 + else
12944 +  :
12945   fi
12946  
12947 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12948 < $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12949 < if ${ac_cv_header_time+:} false; then :
12947 > done
12948 >
12949 >
12950 >
12951 >
12952 >
12953 > for flag in -Wcast-align; do
12954 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12955 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12956 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12957 > if eval \${$as_CACHEVAR+:} false; then :
12958    $as_echo_n "(cached) " >&6
12959   else
12960 +
12961 +  ax_check_save_flags=$CFLAGS
12962 +  CFLAGS="$CFLAGS  $flag"
12963    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12964   /* end confdefs.h.  */
12571 #include <sys/types.h>
12572 #include <sys/time.h>
12573 #include <time.h>
12965  
12966   int
12967   main ()
12968   {
12969 < if ((struct tm *) 0)
12579 < return 0;
12969 >
12970    ;
12971    return 0;
12972   }
12973   _ACEOF
12974   if ac_fn_c_try_compile "$LINENO"; then :
12975 <  ac_cv_header_time=yes
12975 >  eval "$as_CACHEVAR=yes"
12976   else
12977 <  ac_cv_header_time=no
12977 >  eval "$as_CACHEVAR=no"
12978   fi
12979   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12980 +  CFLAGS=$ax_check_save_flags
12981   fi
12982 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12983 < $as_echo "$ac_cv_header_time" >&6; }
12984 < if test $ac_cv_header_time = yes; then
12982 > eval ac_res=\$$as_CACHEVAR
12983 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12984 > $as_echo "$ac_res" >&6; }
12985 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12986  
12987 < $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
12987 > if ${CFLAGS+:} false; then :
12988  
12989 +  case " $CFLAGS " in #(
12990 +  *" $flag "*) :
12991 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12992 +  (: CFLAGS already contains $flag) 2>&5
12993 +  ac_status=$?
12994 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12995 +  test $ac_status = 0; } ;; #(
12996 +  *) :
12997 +
12998 +     as_fn_append CFLAGS " $flag"
12999 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13000 +  (: CFLAGS="$CFLAGS") 2>&5
13001 +  ac_status=$?
13002 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13003 +  test $ac_status = 0; }
13004 +     ;;
13005 + esac
13006 +
13007 + else
13008 +
13009 +  CFLAGS=$flag
13010 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13011 +  (: CFLAGS="$CFLAGS") 2>&5
13012 +  ac_status=$?
13013 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13014 +  test $ac_status = 0; }
13015 +
13016 + fi
13017 +
13018 + else
13019 +  :
13020   fi
13021  
13022 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
13023 < $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
13024 < if ${ac_cv_struct_tm+:} false; then :
13022 > done
13023 >
13024 >
13025 >
13026 >
13027 >
13028 > for flag in -Wcast-function-type; do
13029 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13030 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13031 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13032 > if eval \${$as_CACHEVAR+:} false; then :
13033    $as_echo_n "(cached) " >&6
13034   else
13035 +
13036 +  ax_check_save_flags=$CFLAGS
13037 +  CFLAGS="$CFLAGS  $flag"
13038    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13039   /* end confdefs.h.  */
12606 #include <sys/types.h>
12607 #include <time.h>
13040  
13041   int
13042   main ()
13043   {
13044 < struct tm tm;
12613 <                                     int *p = &tm.tm_sec;
12614 <                                     return !p;
13044 >
13045    ;
13046    return 0;
13047   }
13048   _ACEOF
13049   if ac_fn_c_try_compile "$LINENO"; then :
13050 <  ac_cv_struct_tm=time.h
13050 >  eval "$as_CACHEVAR=yes"
13051   else
13052 <  ac_cv_struct_tm=sys/time.h
13052 >  eval "$as_CACHEVAR=no"
13053   fi
13054   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13055 +  CFLAGS=$ax_check_save_flags
13056   fi
13057 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
13058 < $as_echo "$ac_cv_struct_tm" >&6; }
13059 < if test $ac_cv_struct_tm = sys/time.h; then
13057 > eval ac_res=\$$as_CACHEVAR
13058 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13059 > $as_echo "$ac_res" >&6; }
13060 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13061  
13062 < $as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
13062 > if ${CFLAGS+:} false; then :
13063  
13064 +  case " $CFLAGS " in #(
13065 +  *" $flag "*) :
13066 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13067 +  (: CFLAGS already contains $flag) 2>&5
13068 +  ac_status=$?
13069 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13070 +  test $ac_status = 0; } ;; #(
13071 +  *) :
13072 +
13073 +     as_fn_append CFLAGS " $flag"
13074 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13075 +  (: CFLAGS="$CFLAGS") 2>&5
13076 +  ac_status=$?
13077 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13078 +  test $ac_status = 0; }
13079 +     ;;
13080 + esac
13081 +
13082 + else
13083 +
13084 +  CFLAGS=$flag
13085 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13086 +  (: CFLAGS="$CFLAGS") 2>&5
13087 +  ac_status=$?
13088 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13089 +  test $ac_status = 0; }
13090 +
13091 + fi
13092 +
13093 + else
13094 +  :
13095   fi
13096  
13097 + done
13098 +
13099 +
13100 +
13101  
13102 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5
13103 < $as_echo_n "checking return type of signal handlers... " >&6; }
13104 < if ${ac_cv_type_signal+:} false; then :
13102 >
13103 > for flag in -Wcast-qual; do
13104 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13105 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13106 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13107 > if eval \${$as_CACHEVAR+:} false; then :
13108    $as_echo_n "(cached) " >&6
13109   else
13110 +
13111 +  ax_check_save_flags=$CFLAGS
13112 +  CFLAGS="$CFLAGS  $flag"
13113    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13114   /* end confdefs.h.  */
12642 #include <sys/types.h>
12643 #include <signal.h>
13115  
13116   int
13117   main ()
13118   {
13119 < return *(signal (0, 0)) (0) == 1;
13119 >
13120    ;
13121    return 0;
13122   }
13123   _ACEOF
13124   if ac_fn_c_try_compile "$LINENO"; then :
13125 <  ac_cv_type_signal=int
13125 >  eval "$as_CACHEVAR=yes"
13126   else
13127 <  ac_cv_type_signal=void
13127 >  eval "$as_CACHEVAR=no"
13128   fi
13129   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13130 +  CFLAGS=$ax_check_save_flags
13131   fi
13132 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal" >&5
13133 < $as_echo "$ac_cv_type_signal" >&6; }
13132 > eval ac_res=\$$as_CACHEVAR
13133 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13134 > $as_echo "$ac_res" >&6; }
13135 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13136  
13137 < cat >>confdefs.h <<_ACEOF
13138 < #define RETSIGTYPE $ac_cv_type_signal
13139 < _ACEOF
13137 > if ${CFLAGS+:} false; then :
13138 >
13139 >  case " $CFLAGS " in #(
13140 >  *" $flag "*) :
13141 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13142 >  (: CFLAGS already contains $flag) 2>&5
13143 >  ac_status=$?
13144 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13145 >  test $ac_status = 0; } ;; #(
13146 >  *) :
13147  
13148 +     as_fn_append CFLAGS " $flag"
13149 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13150 +  (: CFLAGS="$CFLAGS") 2>&5
13151 +  ac_status=$?
13152 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13153 +  test $ac_status = 0; }
13154 +     ;;
13155 + esac
13156  
13157 < for ac_func in strftime
13158 < do :
13159 <  ac_fn_c_check_func "$LINENO" "strftime" "ac_cv_func_strftime"
13160 < if test "x$ac_cv_func_strftime" = xyes; then :
13161 <  cat >>confdefs.h <<_ACEOF
13162 < #define HAVE_STRFTIME 1
13163 < _ACEOF
13157 > else
13158 >
13159 >  CFLAGS=$flag
13160 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13161 >  (: CFLAGS="$CFLAGS") 2>&5
13162 >  ac_status=$?
13163 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13164 >  test $ac_status = 0; }
13165 >
13166 > fi
13167  
13168   else
13169 <  # strftime is in -lintl on SCO UNIX.
13170 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strftime in -lintl" >&5
13171 < $as_echo_n "checking for strftime in -lintl... " >&6; }
13172 < if ${ac_cv_lib_intl_strftime+:} false; then :
13169 >  :
13170 > fi
13171 >
13172 > done
13173 >
13174 >
13175 >
13176 >
13177 >
13178 > for flag in -Wclobbered; do
13179 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13180 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13181 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13182 > if eval \${$as_CACHEVAR+:} false; then :
13183    $as_echo_n "(cached) " >&6
13184   else
13185 <  ac_check_lib_save_LIBS=$LIBS
13186 < LIBS="-lintl  $LIBS"
13187 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13185 >
13186 >  ax_check_save_flags=$CFLAGS
13187 >  CFLAGS="$CFLAGS  $flag"
13188 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13189   /* end confdefs.h.  */
13190  
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 ();
13191   int
13192   main ()
13193   {
13194 < return strftime ();
13194 >
13195    ;
13196    return 0;
13197   }
13198   _ACEOF
13199 < if ac_fn_c_try_link "$LINENO"; then :
13200 <  ac_cv_lib_intl_strftime=yes
13199 > if ac_fn_c_try_compile "$LINENO"; then :
13200 >  eval "$as_CACHEVAR=yes"
13201   else
13202 <  ac_cv_lib_intl_strftime=no
13202 >  eval "$as_CACHEVAR=no"
13203   fi
13204 < rm -f core conftest.err conftest.$ac_objext \
13205 <    conftest$ac_exeext conftest.$ac_ext
12710 < LIBS=$ac_check_lib_save_LIBS
13204 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13205 >  CFLAGS=$ax_check_save_flags
13206   fi
13207 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_intl_strftime" >&5
13208 < $as_echo "$ac_cv_lib_intl_strftime" >&6; }
13209 < if test "x$ac_cv_lib_intl_strftime" = xyes; then :
13210 <  $as_echo "#define HAVE_STRFTIME 1" >>confdefs.h
13207 > eval ac_res=\$$as_CACHEVAR
13208 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13209 > $as_echo "$ac_res" >&6; }
13210 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13211 >
13212 > if ${CFLAGS+:} false; then :
13213 >
13214 >  case " $CFLAGS " in #(
13215 >  *" $flag "*) :
13216 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13217 >  (: CFLAGS already contains $flag) 2>&5
13218 >  ac_status=$?
13219 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13220 >  test $ac_status = 0; } ;; #(
13221 >  *) :
13222 >
13223 >     as_fn_append CFLAGS " $flag"
13224 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13225 >  (: CFLAGS="$CFLAGS") 2>&5
13226 >  ac_status=$?
13227 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13228 >  test $ac_status = 0; }
13229 >     ;;
13230 > esac
13231 >
13232 > else
13233 >
13234 >  CFLAGS=$flag
13235 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13236 >  (: CFLAGS="$CFLAGS") 2>&5
13237 >  ac_status=$?
13238 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13239 >  test $ac_status = 0; }
13240  
12717 LIBS="-lintl $LIBS"
13241   fi
13242  
13243 + else
13244 +  :
13245   fi
13246 +
13247   done
13248  
13249  
13250  
13251 < for ac_prog in 'bison -y' byacc
13252 < do
13253 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13254 < set dummy $ac_prog; ac_word=$2
13255 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13256 < $as_echo_n "checking for $ac_word... " >&6; }
13257 < if ${ac_cv_prog_YACC+:} false; then :
13251 >
13252 >
13253 > for flag in -Wduplicated-cond; do
13254 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13255 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13256 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13257 > if eval \${$as_CACHEVAR+:} false; then :
13258    $as_echo_n "(cached) " >&6
13259   else
13260 <  if test -n "$YACC"; then
13261 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
13260 >
13261 >  ax_check_save_flags=$CFLAGS
13262 >  CFLAGS="$CFLAGS  $flag"
13263 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13264 > /* end confdefs.h.  */
13265 >
13266 > int
13267 > main ()
13268 > {
13269 >
13270 >  ;
13271 >  return 0;
13272 > }
13273 > _ACEOF
13274 > if ac_fn_c_try_compile "$LINENO"; then :
13275 >  eval "$as_CACHEVAR=yes"
13276   else
13277 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13278 < for as_dir in $PATH
13279 < do
13280 <  IFS=$as_save_IFS
13281 <  test -z "$as_dir" && as_dir=.
13282 <    for ac_exec_ext in '' $ac_executable_extensions; do
13283 <  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13284 <    ac_cv_prog_YACC="$ac_prog"
13285 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13286 <    break 2
13287 <  fi
13277 >  eval "$as_CACHEVAR=no"
13278 > fi
13279 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13280 >  CFLAGS=$ax_check_save_flags
13281 > fi
13282 > eval ac_res=\$$as_CACHEVAR
13283 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13284 > $as_echo "$ac_res" >&6; }
13285 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13286 >
13287 > if ${CFLAGS+:} false; then :
13288 >
13289 >  case " $CFLAGS " in #(
13290 >  *" $flag "*) :
13291 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13292 >  (: CFLAGS already contains $flag) 2>&5
13293 >  ac_status=$?
13294 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13295 >  test $ac_status = 0; } ;; #(
13296 >  *) :
13297 >
13298 >     as_fn_append CFLAGS " $flag"
13299 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13300 >  (: CFLAGS="$CFLAGS") 2>&5
13301 >  ac_status=$?
13302 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13303 >  test $ac_status = 0; }
13304 >     ;;
13305 > esac
13306 >
13307 > else
13308 >
13309 >  CFLAGS=$flag
13310 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13311 >  (: CFLAGS="$CFLAGS") 2>&5
13312 >  ac_status=$?
13313 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13314 >  test $ac_status = 0; }
13315 >
13316 > fi
13317 >
13318 > else
13319 >  :
13320 > fi
13321 >
13322   done
12749  done
12750 IFS=$as_save_IFS
13323  
13324 +
13325 +
13326 +
13327 +
13328 + for flag in -Wempty-body; do
13329 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13330 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13331 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13332 + if eval \${$as_CACHEVAR+:} false; then :
13333 +  $as_echo_n "(cached) " >&6
13334 + else
13335 +
13336 +  ax_check_save_flags=$CFLAGS
13337 +  CFLAGS="$CFLAGS  $flag"
13338 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13339 + /* end confdefs.h.  */
13340 +
13341 + int
13342 + main ()
13343 + {
13344 +
13345 +  ;
13346 +  return 0;
13347 + }
13348 + _ACEOF
13349 + if ac_fn_c_try_compile "$LINENO"; then :
13350 +  eval "$as_CACHEVAR=yes"
13351 + else
13352 +  eval "$as_CACHEVAR=no"
13353   fi
13354 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13355 +  CFLAGS=$ax_check_save_flags
13356   fi
13357 < YACC=$ac_cv_prog_YACC
13358 < if test -n "$YACC"; then
13359 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
13360 < $as_echo "$YACC" >&6; }
13357 > eval ac_res=\$$as_CACHEVAR
13358 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13359 > $as_echo "$ac_res" >&6; }
13360 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13361 >
13362 > if ${CFLAGS+:} false; then :
13363 >
13364 >  case " $CFLAGS " in #(
13365 >  *" $flag "*) :
13366 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13367 >  (: CFLAGS already contains $flag) 2>&5
13368 >  ac_status=$?
13369 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13370 >  test $ac_status = 0; } ;; #(
13371 >  *) :
13372 >
13373 >     as_fn_append CFLAGS " $flag"
13374 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13375 >  (: CFLAGS="$CFLAGS") 2>&5
13376 >  ac_status=$?
13377 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13378 >  test $ac_status = 0; }
13379 >     ;;
13380 > esac
13381 >
13382   else
13383 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13384 < $as_echo "no" >&6; }
13383 >
13384 >  CFLAGS=$flag
13385 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13386 >  (: CFLAGS="$CFLAGS") 2>&5
13387 >  ac_status=$?
13388 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13389 >  test $ac_status = 0; }
13390 >
13391   fi
13392  
13393 + else
13394 +  :
13395 + fi
13396  
12764  test -n "$YACC" && break
13397   done
12766 test -n "$YACC" || YACC="yacc"
13398  
13399  
13400 < for ac_prog in flex lex
13401 < do
13402 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13403 < set dummy $ac_prog; ac_word=$2
13404 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13405 < $as_echo_n "checking for $ac_word... " >&6; }
13406 < if ${ac_cv_prog_LEX+:} false; then :
13400 >
13401 >
13402 >
13403 > for flag in -Wignored-qualifiers; do
13404 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13405 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13406 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13407 > if eval \${$as_CACHEVAR+:} false; then :
13408    $as_echo_n "(cached) " >&6
13409   else
13410 <  if test -n "$LEX"; then
13411 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
13410 >
13411 >  ax_check_save_flags=$CFLAGS
13412 >  CFLAGS="$CFLAGS  $flag"
13413 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13414 > /* end confdefs.h.  */
13415 >
13416 > int
13417 > main ()
13418 > {
13419 >
13420 >  ;
13421 >  return 0;
13422 > }
13423 > _ACEOF
13424 > if ac_fn_c_try_compile "$LINENO"; then :
13425 >  eval "$as_CACHEVAR=yes"
13426   else
13427 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13428 < for as_dir in $PATH
13429 < do
13430 <  IFS=$as_save_IFS
13431 <  test -z "$as_dir" && as_dir=.
13432 <    for ac_exec_ext in '' $ac_executable_extensions; do
13433 <  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13434 <    ac_cv_prog_LEX="$ac_prog"
13435 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13436 <    break 2
13437 <  fi
13427 >  eval "$as_CACHEVAR=no"
13428 > fi
13429 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13430 >  CFLAGS=$ax_check_save_flags
13431 > fi
13432 > eval ac_res=\$$as_CACHEVAR
13433 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13434 > $as_echo "$ac_res" >&6; }
13435 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13436 >
13437 > if ${CFLAGS+:} false; then :
13438 >
13439 >  case " $CFLAGS " in #(
13440 >  *" $flag "*) :
13441 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13442 >  (: CFLAGS already contains $flag) 2>&5
13443 >  ac_status=$?
13444 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13445 >  test $ac_status = 0; } ;; #(
13446 >  *) :
13447 >
13448 >     as_fn_append CFLAGS " $flag"
13449 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13450 >  (: CFLAGS="$CFLAGS") 2>&5
13451 >  ac_status=$?
13452 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13453 >  test $ac_status = 0; }
13454 >     ;;
13455 > esac
13456 >
13457 > else
13458 >
13459 >  CFLAGS=$flag
13460 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13461 >  (: CFLAGS="$CFLAGS") 2>&5
13462 >  ac_status=$?
13463 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13464 >  test $ac_status = 0; }
13465 >
13466 > fi
13467 >
13468 > else
13469 >  :
13470 > fi
13471 >
13472   done
12793  done
12794 IFS=$as_save_IFS
13473  
13474 +
13475 +
13476 +
13477 +
13478 + for flag in -Wlogical-op; do
13479 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13480 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13481 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13482 + if eval \${$as_CACHEVAR+:} false; then :
13483 +  $as_echo_n "(cached) " >&6
13484 + else
13485 +
13486 +  ax_check_save_flags=$CFLAGS
13487 +  CFLAGS="$CFLAGS  $flag"
13488 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13489 + /* end confdefs.h.  */
13490 +
13491 + int
13492 + main ()
13493 + {
13494 +
13495 +  ;
13496 +  return 0;
13497 + }
13498 + _ACEOF
13499 + if ac_fn_c_try_compile "$LINENO"; then :
13500 +  eval "$as_CACHEVAR=yes"
13501 + else
13502 +  eval "$as_CACHEVAR=no"
13503   fi
13504 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13505 +  CFLAGS=$ax_check_save_flags
13506   fi
13507 < LEX=$ac_cv_prog_LEX
13508 < if test -n "$LEX"; then
13509 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
13510 < $as_echo "$LEX" >&6; }
13507 > eval ac_res=\$$as_CACHEVAR
13508 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13509 > $as_echo "$ac_res" >&6; }
13510 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13511 >
13512 > if ${CFLAGS+:} false; then :
13513 >
13514 >  case " $CFLAGS " in #(
13515 >  *" $flag "*) :
13516 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13517 >  (: CFLAGS already contains $flag) 2>&5
13518 >  ac_status=$?
13519 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13520 >  test $ac_status = 0; } ;; #(
13521 >  *) :
13522 >
13523 >     as_fn_append CFLAGS " $flag"
13524 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13525 >  (: CFLAGS="$CFLAGS") 2>&5
13526 >  ac_status=$?
13527 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13528 >  test $ac_status = 0; }
13529 >     ;;
13530 > esac
13531 >
13532   else
13533 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13534 < $as_echo "no" >&6; }
13533 >
13534 >  CFLAGS=$flag
13535 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13536 >  (: CFLAGS="$CFLAGS") 2>&5
13537 >  ac_status=$?
13538 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13539 >  test $ac_status = 0; }
13540 >
13541   fi
13542  
13543 + else
13544 +  :
13545 + fi
13546  
12808  test -n "$LEX" && break
13547   done
12810 test -n "$LEX" || LEX=":"
13548  
13549 < if test "x$LEX" != "x:"; then
13550 <  cat >conftest.l <<_ACEOF
13551 < %%
13552 < a { ECHO; }
13553 < b { REJECT; }
13554 < c { yymore (); }
13555 < d { yyless (1); }
13556 < e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
13557 <    yyless ((input () != 0)); }
13558 < f { unput (yytext[0]); }
13559 < . { BEGIN INITIAL; }
13560 < %%
13561 < #ifdef YYTEXT_POINTER
13562 < extern char *yytext;
13563 < #endif
13549 >
13550 >
13551 >
13552 >
13553 > for flag in -Wmissing-declarations; do
13554 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13555 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13556 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13557 > if eval \${$as_CACHEVAR+:} false; then :
13558 >  $as_echo_n "(cached) " >&6
13559 > else
13560 >
13561 >  ax_check_save_flags=$CFLAGS
13562 >  CFLAGS="$CFLAGS  $flag"
13563 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13564 > /* end confdefs.h.  */
13565 >
13566   int
13567 < main (void)
13567 > main ()
13568   {
13569 <  return ! yylex () + ! yywrap ();
13569 >
13570 >  ;
13571 >  return 0;
13572   }
13573   _ACEOF
13574 < { { ac_try="$LEX conftest.l"
13575 < case "(($ac_try" in
13576 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13577 <  *) ac_try_echo=$ac_try;;
13574 > if ac_fn_c_try_compile "$LINENO"; then :
13575 >  eval "$as_CACHEVAR=yes"
13576 > else
13577 >  eval "$as_CACHEVAR=no"
13578 > fi
13579 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13580 >  CFLAGS=$ax_check_save_flags
13581 > fi
13582 > eval ac_res=\$$as_CACHEVAR
13583 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13584 > $as_echo "$ac_res" >&6; }
13585 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13586 >
13587 > if ${CFLAGS+:} false; then :
13588 >
13589 >  case " $CFLAGS " in #(
13590 >  *" $flag "*) :
13591 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13592 >  (: CFLAGS already contains $flag) 2>&5
13593 >  ac_status=$?
13594 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13595 >  test $ac_status = 0; } ;; #(
13596 >  *) :
13597 >
13598 >     as_fn_append CFLAGS " $flag"
13599 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13600 >  (: CFLAGS="$CFLAGS") 2>&5
13601 >  ac_status=$?
13602 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13603 >  test $ac_status = 0; }
13604 >     ;;
13605   esac
13606 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
13607 < $as_echo "$ac_try_echo"; } >&5
13608 <  (eval "$LEX conftest.l") 2>&5
13606 >
13607 > else
13608 >
13609 >  CFLAGS=$flag
13610 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13611 >  (: CFLAGS="$CFLAGS") 2>&5
13612    ac_status=$?
13613    $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13614    test $ac_status = 0; }
13615 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
13616 < $as_echo_n "checking lex output file root... " >&6; }
13617 < if ${ac_cv_prog_lex_root+:} false; then :
13615 >
13616 > fi
13617 >
13618 > else
13619 >  :
13620 > fi
13621 >
13622 > done
13623 >
13624 >
13625 >
13626 >
13627 >
13628 > for flag in -Wmissing-field-initializers; do
13629 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13630 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13631 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13632 > if eval \${$as_CACHEVAR+:} false; then :
13633    $as_echo_n "(cached) " >&6
13634   else
13635  
13636 < if test -f lex.yy.c; then
13637 <  ac_cv_prog_lex_root=lex.yy
13638 < elif test -f lexyy.c; then
13639 <  ac_cv_prog_lex_root=lexyy
13636 >  ax_check_save_flags=$CFLAGS
13637 >  CFLAGS="$CFLAGS  $flag"
13638 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13639 > /* end confdefs.h.  */
13640 >
13641 > int
13642 > main ()
13643 > {
13644 >
13645 >  ;
13646 >  return 0;
13647 > }
13648 > _ACEOF
13649 > if ac_fn_c_try_compile "$LINENO"; then :
13650 >  eval "$as_CACHEVAR=yes"
13651   else
13652 <  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
13652 >  eval "$as_CACHEVAR=no"
13653   fi
13654 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13655 +  CFLAGS=$ax_check_save_flags
13656   fi
13657 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
13658 < $as_echo "$ac_cv_prog_lex_root" >&6; }
13659 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
13657 > eval ac_res=\$$as_CACHEVAR
13658 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13659 > $as_echo "$ac_res" >&6; }
13660 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13661  
13662 < if test -z "${LEXLIB+set}"; then
13663 <  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
13664 < $as_echo_n "checking lex library... " >&6; }
13665 < if ${ac_cv_lib_lex+:} false; then :
13662 > if ${CFLAGS+:} false; then :
13663 >
13664 >  case " $CFLAGS " in #(
13665 >  *" $flag "*) :
13666 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13667 >  (: CFLAGS already contains $flag) 2>&5
13668 >  ac_status=$?
13669 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13670 >  test $ac_status = 0; } ;; #(
13671 >  *) :
13672 >
13673 >     as_fn_append CFLAGS " $flag"
13674 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13675 >  (: CFLAGS="$CFLAGS") 2>&5
13676 >  ac_status=$?
13677 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13678 >  test $ac_status = 0; }
13679 >     ;;
13680 > esac
13681 >
13682 > else
13683 >
13684 >  CFLAGS=$flag
13685 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13686 >  (: CFLAGS="$CFLAGS") 2>&5
13687 >  ac_status=$?
13688 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13689 >  test $ac_status = 0; }
13690 >
13691 > fi
13692 >
13693 > else
13694 >  :
13695 > fi
13696 >
13697 > done
13698 >
13699 >
13700 >
13701 >
13702 >
13703 > for flag in -Wmissing-include-dirs; do
13704 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13705 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13706 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13707 > if eval \${$as_CACHEVAR+:} false; then :
13708    $as_echo_n "(cached) " >&6
13709   else
13710  
13711 <    ac_save_LIBS=$LIBS
13712 <    ac_cv_lib_lex='none needed'
13713 <    for ac_lib in '' -lfl -ll; do
12872 <      LIBS="$ac_lib $ac_save_LIBS"
12873 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13711 >  ax_check_save_flags=$CFLAGS
13712 >  CFLAGS="$CFLAGS  $flag"
13713 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13714   /* end confdefs.h.  */
13715 < `cat $LEX_OUTPUT_ROOT.c`
13715 >
13716 > int
13717 > main ()
13718 > {
13719 >
13720 >  ;
13721 >  return 0;
13722 > }
13723   _ACEOF
13724 < if ac_fn_c_try_link "$LINENO"; then :
13725 <  ac_cv_lib_lex=$ac_lib
13724 > if ac_fn_c_try_compile "$LINENO"; then :
13725 >  eval "$as_CACHEVAR=yes"
13726 > else
13727 >  eval "$as_CACHEVAR=no"
13728   fi
13729 < rm -f core conftest.err conftest.$ac_objext \
13730 <    conftest$ac_exeext conftest.$ac_ext
13731 <      test "$ac_cv_lib_lex" != 'none needed' && break
13732 <    done
13733 <    LIBS=$ac_save_LIBS
13729 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13730 >  CFLAGS=$ax_check_save_flags
13731 > fi
13732 > eval ac_res=\$$as_CACHEVAR
13733 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13734 > $as_echo "$ac_res" >&6; }
13735 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13736 >
13737 > if ${CFLAGS+:} false; then :
13738 >
13739 >  case " $CFLAGS " in #(
13740 >  *" $flag "*) :
13741 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13742 >  (: CFLAGS already contains $flag) 2>&5
13743 >  ac_status=$?
13744 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13745 >  test $ac_status = 0; } ;; #(
13746 >  *) :
13747 >
13748 >     as_fn_append CFLAGS " $flag"
13749 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13750 >  (: CFLAGS="$CFLAGS") 2>&5
13751 >  ac_status=$?
13752 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13753 >  test $ac_status = 0; }
13754 >     ;;
13755 > esac
13756 >
13757 > else
13758 >
13759 >  CFLAGS=$flag
13760 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13761 >  (: CFLAGS="$CFLAGS") 2>&5
13762 >  ac_status=$?
13763 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13764 >  test $ac_status = 0; }
13765  
13766   fi
13767 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
13768 < $as_echo "$ac_cv_lib_lex" >&6; }
13769 <  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
13767 >
13768 > else
13769 >  :
13770   fi
13771  
13772 + done
13773  
13774 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
13775 < $as_echo_n "checking whether yytext is a pointer... " >&6; }
13776 < if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
13774 >
13775 >
13776 >
13777 >
13778 > for flag in -Wmissing-parameter-type; do
13779 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13780 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13781 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13782 > if eval \${$as_CACHEVAR+:} false; then :
13783    $as_echo_n "(cached) " >&6
13784   else
13785 <  # POSIX says lex can declare yytext either as a pointer or an array; the
13786 < # default is implementation-dependent.  Figure out which it is, since
13787 < # not all implementations provide the %pointer and %array declarations.
13788 < 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
13785 >
13786 >  ax_check_save_flags=$CFLAGS
13787 >  CFLAGS="$CFLAGS  $flag"
13788 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13789   /* end confdefs.h.  */
13790  
13791 <  #define YYTEXT_POINTER 1
13792 < `cat $LEX_OUTPUT_ROOT.c`
13791 > int
13792 > main ()
13793 > {
13794 >
13795 >  ;
13796 >  return 0;
13797 > }
13798   _ACEOF
13799 < if ac_fn_c_try_link "$LINENO"; then :
13800 <  ac_cv_prog_lex_yytext_pointer=yes
13799 > if ac_fn_c_try_compile "$LINENO"; then :
13800 >  eval "$as_CACHEVAR=yes"
13801 > else
13802 >  eval "$as_CACHEVAR=no"
13803   fi
13804 < rm -f core conftest.err conftest.$ac_objext \
13805 <    conftest$ac_exeext conftest.$ac_ext
13806 < LIBS=$ac_save_LIBS
13804 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13805 >  CFLAGS=$ax_check_save_flags
13806 > fi
13807 > eval ac_res=\$$as_CACHEVAR
13808 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13809 > $as_echo "$ac_res" >&6; }
13810 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13811 >
13812 > if ${CFLAGS+:} false; then :
13813 >
13814 >  case " $CFLAGS " in #(
13815 >  *" $flag "*) :
13816 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13817 >  (: CFLAGS already contains $flag) 2>&5
13818 >  ac_status=$?
13819 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13820 >  test $ac_status = 0; } ;; #(
13821 >  *) :
13822 >
13823 >     as_fn_append CFLAGS " $flag"
13824 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13825 >  (: CFLAGS="$CFLAGS") 2>&5
13826 >  ac_status=$?
13827 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13828 >  test $ac_status = 0; }
13829 >     ;;
13830 > esac
13831 >
13832 > else
13833 >
13834 >  CFLAGS=$flag
13835 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13836 >  (: CFLAGS="$CFLAGS") 2>&5
13837 >  ac_status=$?
13838 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13839 >  test $ac_status = 0; }
13840  
13841   fi
12918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer" >&5
12919 $as_echo "$ac_cv_prog_lex_yytext_pointer" >&6; }
12920 if test $ac_cv_prog_lex_yytext_pointer = yes; then
13842  
13843 < $as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
13843 > else
13844 >  :
13845 > fi
13846 >
13847 > done
13848 >
13849 >
13850 >
13851 >
13852  
13853 + for flag in -Wmissing-prototypes; do
13854 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13855 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13856 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13857 + if eval \${$as_CACHEVAR+:} false; then :
13858 +  $as_echo_n "(cached) " >&6
13859 + else
13860 +
13861 +  ax_check_save_flags=$CFLAGS
13862 +  CFLAGS="$CFLAGS  $flag"
13863 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13864 + /* end confdefs.h.  */
13865 +
13866 + int
13867 + main ()
13868 + {
13869 +
13870 +  ;
13871 +  return 0;
13872 + }
13873 + _ACEOF
13874 + if ac_fn_c_try_compile "$LINENO"; then :
13875 +  eval "$as_CACHEVAR=yes"
13876 + else
13877 +  eval "$as_CACHEVAR=no"
13878   fi
13879 < rm -f conftest.l $LEX_OUTPUT_ROOT.c
13879 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13880 >  CFLAGS=$ax_check_save_flags
13881 > fi
13882 > eval ac_res=\$$as_CACHEVAR
13883 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13884 > $as_echo "$ac_res" >&6; }
13885 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13886 >
13887 > if ${CFLAGS+:} false; then :
13888 >
13889 >  case " $CFLAGS " in #(
13890 >  *" $flag "*) :
13891 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13892 >  (: CFLAGS already contains $flag) 2>&5
13893 >  ac_status=$?
13894 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13895 >  test $ac_status = 0; } ;; #(
13896 >  *) :
13897 >
13898 >     as_fn_append CFLAGS " $flag"
13899 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13900 >  (: CFLAGS="$CFLAGS") 2>&5
13901 >  ac_status=$?
13902 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13903 >  test $ac_status = 0; }
13904 >     ;;
13905 > esac
13906 >
13907 > else
13908 >
13909 >  CFLAGS=$flag
13910 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13911 >  (: CFLAGS="$CFLAGS") 2>&5
13912 >  ac_status=$?
13913 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13914 >  test $ac_status = 0; }
13915  
13916   fi
13917 < if test "$LEX" = :; then
13918 <  LEX=${am_missing_run}flex
13917 >
13918 > else
13919 >  :
13920   fi
13921  
13922 < ETR_SOCKET_NSL
13922 > done
13923  
13924 < for ac_func in inet_aton inet_pton socket strdup strstr
13925 < do :
13926 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
13927 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
13928 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
13929 <  cat >>confdefs.h <<_ACEOF
13930 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
13924 >
13925 >
13926 >
13927 >
13928 > for flag in -Wnested-externs; do
13929 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13930 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13931 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13932 > if eval \${$as_CACHEVAR+:} false; then :
13933 >  $as_echo_n "(cached) " >&6
13934 > else
13935 >
13936 >  ax_check_save_flags=$CFLAGS
13937 >  CFLAGS="$CFLAGS  $flag"
13938 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13939 > /* end confdefs.h.  */
13940 >
13941 > int
13942 > main ()
13943 > {
13944 >
13945 >  ;
13946 >  return 0;
13947 > }
13948   _ACEOF
13949 + if ac_fn_c_try_compile "$LINENO"; then :
13950 +  eval "$as_CACHEVAR=yes"
13951 + else
13952 +  eval "$as_CACHEVAR=no"
13953 + fi
13954 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13955 +  CFLAGS=$ax_check_save_flags
13956 + fi
13957 + eval ac_res=\$$as_CACHEVAR
13958 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13959 + $as_echo "$ac_res" >&6; }
13960 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13961  
13962 + if ${CFLAGS+:} false; then :
13963 +
13964 +  case " $CFLAGS " in #(
13965 +  *" $flag "*) :
13966 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13967 +  (: CFLAGS already contains $flag) 2>&5
13968 +  ac_status=$?
13969 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13970 +  test $ac_status = 0; } ;; #(
13971 +  *) :
13972 +
13973 +     as_fn_append CFLAGS " $flag"
13974 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13975 +  (: CFLAGS="$CFLAGS") 2>&5
13976 +  ac_status=$?
13977 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13978 +  test $ac_status = 0; }
13979 +     ;;
13980 + esac
13981 +
13982 + else
13983 +
13984 +  CFLAGS=$flag
13985 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13986 +  (: CFLAGS="$CFLAGS") 2>&5
13987 +  ac_status=$?
13988 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13989 +  test $ac_status = 0; }
13990 +
13991 + fi
13992 +
13993 + else
13994 +  :
13995   fi
13996 +
13997   done
13998  
13999  
14000 < for ac_func in gethostbyname gethostbyname2
14001 < do :
14002 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14003 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14004 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14005 <  cat >>confdefs.h <<_ACEOF
14006 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14000 >
14001 >
14002 >
14003 > for flag in -Wold-style-declaration; do
14004 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14005 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14006 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14007 > if eval \${$as_CACHEVAR+:} false; then :
14008 >  $as_echo_n "(cached) " >&6
14009 > else
14010 >
14011 >  ax_check_save_flags=$CFLAGS
14012 >  CFLAGS="$CFLAGS  $flag"
14013 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14014 > /* end confdefs.h.  */
14015 >
14016 > int
14017 > main ()
14018 > {
14019 >
14020 >  ;
14021 >  return 0;
14022 > }
14023   _ACEOF
14024 + if ac_fn_c_try_compile "$LINENO"; then :
14025 +  eval "$as_CACHEVAR=yes"
14026 + else
14027 +  eval "$as_CACHEVAR=no"
14028 + fi
14029 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14030 +  CFLAGS=$ax_check_save_flags
14031 + fi
14032 + eval ac_res=\$$as_CACHEVAR
14033 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14034 + $as_echo "$ac_res" >&6; }
14035 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14036 +
14037 + if ${CFLAGS+:} false; then :
14038 +
14039 +  case " $CFLAGS " in #(
14040 +  *" $flag "*) :
14041 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14042 +  (: CFLAGS already contains $flag) 2>&5
14043 +  ac_status=$?
14044 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14045 +  test $ac_status = 0; } ;; #(
14046 +  *) :
14047 +
14048 +     as_fn_append CFLAGS " $flag"
14049 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14050 +  (: CFLAGS="$CFLAGS") 2>&5
14051 +  ac_status=$?
14052 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14053 +  test $ac_status = 0; }
14054 +     ;;
14055 + esac
14056 +
14057 + else
14058 +
14059 +  CFLAGS=$flag
14060 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14061 +  (: CFLAGS="$CFLAGS") 2>&5
14062 +  ac_status=$?
14063 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14064 +  test $ac_status = 0; }
14065  
14066   fi
14067 +
14068 + else
14069 +  :
14070 + fi
14071 +
14072   done
14073  
14074  
14075 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
14076 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
14077 < if ${ac_cv_c_bigendian+:} false; then :
14075 >
14076 >
14077 >
14078 > for flag in -Woverride-init; do
14079 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14080 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14081 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14082 > if eval \${$as_CACHEVAR+:} false; then :
14083    $as_echo_n "(cached) " >&6
14084   else
14085 <  ac_cv_c_bigendian=unknown
14086 <    # See if we're dealing with a universal compiler.
14087 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14085 >
14086 >  ax_check_save_flags=$CFLAGS
14087 >  CFLAGS="$CFLAGS  $flag"
14088 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14089   /* end confdefs.h.  */
12969 #ifndef __APPLE_CC__
12970               not a universal capable compiler
12971             #endif
12972             typedef int dummy;
14090  
14091 + int
14092 + main ()
14093 + {
14094 +
14095 +  ;
14096 +  return 0;
14097 + }
14098   _ACEOF
14099   if ac_fn_c_try_compile "$LINENO"; then :
14100 <
14101 <        # Check for potential -arch flags.  It is not universal unless
14102 <        # 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
14100 >  eval "$as_CACHEVAR=yes"
14101 > else
14102 >  eval "$as_CACHEVAR=no"
14103   fi
14104   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14105 <    if test $ac_cv_c_bigendian = unknown; then
14106 <      # See if sys/param.h defines the BYTE_ORDER macro.
14107 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14105 >  CFLAGS=$ax_check_save_flags
14106 > fi
14107 > eval ac_res=\$$as_CACHEVAR
14108 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14109 > $as_echo "$ac_res" >&6; }
14110 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14111 >
14112 > if ${CFLAGS+:} false; then :
14113 >
14114 >  case " $CFLAGS " in #(
14115 >  *" $flag "*) :
14116 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14117 >  (: CFLAGS already contains $flag) 2>&5
14118 >  ac_status=$?
14119 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14120 >  test $ac_status = 0; } ;; #(
14121 >  *) :
14122 >
14123 >     as_fn_append CFLAGS " $flag"
14124 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14125 >  (: CFLAGS="$CFLAGS") 2>&5
14126 >  ac_status=$?
14127 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14128 >  test $ac_status = 0; }
14129 >     ;;
14130 > esac
14131 >
14132 > else
14133 >
14134 >  CFLAGS=$flag
14135 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14136 >  (: CFLAGS="$CFLAGS") 2>&5
14137 >  ac_status=$?
14138 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14139 >  test $ac_status = 0; }
14140 >
14141 > fi
14142 >
14143 > else
14144 >  :
14145 > fi
14146 >
14147 > done
14148 >
14149 >
14150 >
14151 >
14152 >
14153 > for flag in -Wpointer-arith; do
14154 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14155 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14156 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14157 > if eval \${$as_CACHEVAR+:} false; then :
14158 >  $as_echo_n "(cached) " >&6
14159 > else
14160 >
14161 >  ax_check_save_flags=$CFLAGS
14162 >  CFLAGS="$CFLAGS  $flag"
14163 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14164   /* end confdefs.h.  */
13004 #include <sys/types.h>
13005             #include <sys/param.h>
14165  
14166   int
14167   main ()
14168   {
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
14169  
14170    ;
14171    return 0;
14172   }
14173   _ACEOF
14174   if ac_fn_c_try_compile "$LINENO"; then :
14175 <  # It does; now see whether it defined to BIG_ENDIAN or not.
14176 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14175 >  eval "$as_CACHEVAR=yes"
14176 > else
14177 >  eval "$as_CACHEVAR=no"
14178 > fi
14179 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14180 >  CFLAGS=$ax_check_save_flags
14181 > fi
14182 > eval ac_res=\$$as_CACHEVAR
14183 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14184 > $as_echo "$ac_res" >&6; }
14185 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14186 >
14187 > if ${CFLAGS+:} false; then :
14188 >
14189 >  case " $CFLAGS " in #(
14190 >  *" $flag "*) :
14191 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14192 >  (: CFLAGS already contains $flag) 2>&5
14193 >  ac_status=$?
14194 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14195 >  test $ac_status = 0; } ;; #(
14196 >  *) :
14197 >
14198 >     as_fn_append CFLAGS " $flag"
14199 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14200 >  (: CFLAGS="$CFLAGS") 2>&5
14201 >  ac_status=$?
14202 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14203 >  test $ac_status = 0; }
14204 >     ;;
14205 > esac
14206 >
14207 > else
14208 >
14209 >  CFLAGS=$flag
14210 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14211 >  (: CFLAGS="$CFLAGS") 2>&5
14212 >  ac_status=$?
14213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14214 >  test $ac_status = 0; }
14215 >
14216 > fi
14217 >
14218 > else
14219 >  :
14220 > fi
14221 >
14222 > done
14223 >
14224 >
14225 >
14226 >
14227 >
14228 > for flag in -Wredundant-decls; do
14229 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14230 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14231 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14232 > if eval \${$as_CACHEVAR+:} false; then :
14233 >  $as_echo_n "(cached) " >&6
14234 > else
14235 >
14236 >  ax_check_save_flags=$CFLAGS
14237 >  CFLAGS="$CFLAGS  $flag"
14238 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14239   /* end confdefs.h.  */
13024 #include <sys/types.h>
13025                #include <sys/param.h>
14240  
14241   int
14242   main ()
14243   {
13030 #if BYTE_ORDER != BIG_ENDIAN
13031                 not big endian
13032                #endif
14244  
14245    ;
14246    return 0;
14247   }
14248   _ACEOF
14249   if ac_fn_c_try_compile "$LINENO"; then :
14250 <  ac_cv_c_bigendian=yes
14250 >  eval "$as_CACHEVAR=yes"
14251   else
14252 <  ac_cv_c_bigendian=no
14252 >  eval "$as_CACHEVAR=no"
14253   fi
14254   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14255 +  CFLAGS=$ax_check_save_flags
14256   fi
14257 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14258 <    fi
14259 <    if test $ac_cv_c_bigendian = unknown; then
14260 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
14261 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14257 > eval ac_res=\$$as_CACHEVAR
14258 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14259 > $as_echo "$ac_res" >&6; }
14260 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14261 >
14262 > if ${CFLAGS+:} false; then :
14263 >
14264 >  case " $CFLAGS " in #(
14265 >  *" $flag "*) :
14266 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14267 >  (: CFLAGS already contains $flag) 2>&5
14268 >  ac_status=$?
14269 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14270 >  test $ac_status = 0; } ;; #(
14271 >  *) :
14272 >
14273 >     as_fn_append CFLAGS " $flag"
14274 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14275 >  (: CFLAGS="$CFLAGS") 2>&5
14276 >  ac_status=$?
14277 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14278 >  test $ac_status = 0; }
14279 >     ;;
14280 > esac
14281 >
14282 > else
14283 >
14284 >  CFLAGS=$flag
14285 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14286 >  (: CFLAGS="$CFLAGS") 2>&5
14287 >  ac_status=$?
14288 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14289 >  test $ac_status = 0; }
14290 >
14291 > fi
14292 >
14293 > else
14294 >  :
14295 > fi
14296 >
14297 > done
14298 >
14299 >
14300 >
14301 >
14302 >
14303 > for flag in -Wshadow; do
14304 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14305 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14306 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14307 > if eval \${$as_CACHEVAR+:} false; then :
14308 >  $as_echo_n "(cached) " >&6
14309 > else
14310 >
14311 >  ax_check_save_flags=$CFLAGS
14312 >  CFLAGS="$CFLAGS  $flag"
14313 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14314   /* end confdefs.h.  */
13051 #include <limits.h>
14315  
14316   int
14317   main ()
14318   {
13056 #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13057              bogus endian macros
13058             #endif
14319  
14320    ;
14321    return 0;
14322   }
14323   _ACEOF
14324   if ac_fn_c_try_compile "$LINENO"; then :
14325 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
14326 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14325 >  eval "$as_CACHEVAR=yes"
14326 > else
14327 >  eval "$as_CACHEVAR=no"
14328 > fi
14329 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14330 >  CFLAGS=$ax_check_save_flags
14331 > fi
14332 > eval ac_res=\$$as_CACHEVAR
14333 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14334 > $as_echo "$ac_res" >&6; }
14335 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14336 >
14337 > if ${CFLAGS+:} false; then :
14338 >
14339 >  case " $CFLAGS " in #(
14340 >  *" $flag "*) :
14341 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14342 >  (: CFLAGS already contains $flag) 2>&5
14343 >  ac_status=$?
14344 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14345 >  test $ac_status = 0; } ;; #(
14346 >  *) :
14347 >
14348 >     as_fn_append CFLAGS " $flag"
14349 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14350 >  (: CFLAGS="$CFLAGS") 2>&5
14351 >  ac_status=$?
14352 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14353 >  test $ac_status = 0; }
14354 >     ;;
14355 > esac
14356 >
14357 > else
14358 >
14359 >  CFLAGS=$flag
14360 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14361 >  (: CFLAGS="$CFLAGS") 2>&5
14362 >  ac_status=$?
14363 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14364 >  test $ac_status = 0; }
14365 >
14366 > fi
14367 >
14368 > else
14369 >  :
14370 > fi
14371 >
14372 > done
14373 >
14374 >
14375 >
14376 >
14377 >
14378 > for flag in -Wshift-negative-value; do
14379 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14380 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14381 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14382 > if eval \${$as_CACHEVAR+:} false; then :
14383 >  $as_echo_n "(cached) " >&6
14384 > else
14385 >
14386 >  ax_check_save_flags=$CFLAGS
14387 >  CFLAGS="$CFLAGS  $flag"
14388 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14389   /* end confdefs.h.  */
13068 #include <limits.h>
14390  
14391   int
14392   main ()
14393   {
13073 #ifndef _BIG_ENDIAN
13074                 not big endian
13075                #endif
14394  
14395    ;
14396    return 0;
14397   }
14398   _ACEOF
14399   if ac_fn_c_try_compile "$LINENO"; then :
14400 <  ac_cv_c_bigendian=yes
14400 >  eval "$as_CACHEVAR=yes"
14401   else
14402 <  ac_cv_c_bigendian=no
14402 >  eval "$as_CACHEVAR=no"
14403   fi
14404   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14405 +  CFLAGS=$ax_check_save_flags
14406   fi
14407 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14408 <    fi
14409 <    if test $ac_cv_c_bigendian = unknown; then
14410 <      # Compile a test program.
14411 <      if test "$cross_compiling" = yes; then :
14412 <  # Try to guess by grepping values from an object file.
14413 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14407 > eval ac_res=\$$as_CACHEVAR
14408 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14409 > $as_echo "$ac_res" >&6; }
14410 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14411 >
14412 > if ${CFLAGS+:} false; then :
14413 >
14414 >  case " $CFLAGS " in #(
14415 >  *" $flag "*) :
14416 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14417 >  (: CFLAGS already contains $flag) 2>&5
14418 >  ac_status=$?
14419 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14420 >  test $ac_status = 0; } ;; #(
14421 >  *) :
14422 >
14423 >     as_fn_append CFLAGS " $flag"
14424 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14425 >  (: CFLAGS="$CFLAGS") 2>&5
14426 >  ac_status=$?
14427 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14428 >  test $ac_status = 0; }
14429 >     ;;
14430 > esac
14431 >
14432 > else
14433 >
14434 >  CFLAGS=$flag
14435 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14436 >  (: CFLAGS="$CFLAGS") 2>&5
14437 >  ac_status=$?
14438 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14439 >  test $ac_status = 0; }
14440 >
14441 > fi
14442 >
14443 > else
14444 >  :
14445 > fi
14446 >
14447 > done
14448 >
14449 >
14450 >
14451 >
14452 >
14453 > for flag in -Wsign-compare; do
14454 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14455 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14456 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14457 > if eval \${$as_CACHEVAR+:} false; then :
14458 >  $as_echo_n "(cached) " >&6
14459 > else
14460 >
14461 >  ax_check_save_flags=$CFLAGS
14462 >  CFLAGS="$CFLAGS  $flag"
14463 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14464   /* 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;
14465  
14466   int
14467   main ()
14468   {
14469 < return use_ascii (foo) == use_ebcdic (foo);
14469 >
14470    ;
14471    return 0;
14472   }
14473   _ACEOF
14474   if ac_fn_c_try_compile "$LINENO"; then :
14475 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
14476 <              ac_cv_c_bigendian=yes
14477 <            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
14475 >  eval "$as_CACHEVAR=yes"
14476 > else
14477 >  eval "$as_CACHEVAR=no"
14478   fi
14479   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14480 +  CFLAGS=$ax_check_save_flags
14481 + fi
14482 + eval ac_res=\$$as_CACHEVAR
14483 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14484 + $as_echo "$ac_res" >&6; }
14485 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14486 +
14487 + if ${CFLAGS+:} false; then :
14488 +
14489 +  case " $CFLAGS " in #(
14490 +  *" $flag "*) :
14491 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14492 +  (: CFLAGS already contains $flag) 2>&5
14493 +  ac_status=$?
14494 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14495 +  test $ac_status = 0; } ;; #(
14496 +  *) :
14497 +
14498 +     as_fn_append CFLAGS " $flag"
14499 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14500 +  (: CFLAGS="$CFLAGS") 2>&5
14501 +  ac_status=$?
14502 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14503 +  test $ac_status = 0; }
14504 +     ;;
14505 + esac
14506 +
14507   else
14508 +
14509 +  CFLAGS=$flag
14510 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14511 +  (: CFLAGS="$CFLAGS") 2>&5
14512 +  ac_status=$?
14513 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14514 +  test $ac_status = 0; }
14515 +
14516 + fi
14517 +
14518 + else
14519 +  :
14520 + fi
14521 +
14522 + done
14523 +
14524 +
14525 +
14526 +
14527 +
14528 + for flag in -Wtype-limits; do
14529 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14530 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14531 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14532 + if eval \${$as_CACHEVAR+:} false; then :
14533 +  $as_echo_n "(cached) " >&6
14534 + else
14535 +
14536 +  ax_check_save_flags=$CFLAGS
14537 +  CFLAGS="$CFLAGS  $flag"
14538    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14539   /* end confdefs.h.  */
14540 < $ac_includes_default
14540 >
14541   int
14542   main ()
14543   {
14544  
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
14545    ;
14546    return 0;
14547   }
14548   _ACEOF
14549 < if ac_fn_c_try_run "$LINENO"; then :
14550 <  ac_cv_c_bigendian=no
14549 > if ac_fn_c_try_compile "$LINENO"; then :
14550 >  eval "$as_CACHEVAR=yes"
14551   else
14552 <  ac_cv_c_bigendian=yes
14552 >  eval "$as_CACHEVAR=no"
14553   fi
14554 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
14555 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
14554 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14555 >  CFLAGS=$ax_check_save_flags
14556   fi
14557 + eval ac_res=\$$as_CACHEVAR
14558 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14559 + $as_echo "$ac_res" >&6; }
14560 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14561 +
14562 + if ${CFLAGS+:} false; then :
14563 +
14564 +  case " $CFLAGS " in #(
14565 +  *" $flag "*) :
14566 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14567 +  (: CFLAGS already contains $flag) 2>&5
14568 +  ac_status=$?
14569 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14570 +  test $ac_status = 0; } ;; #(
14571 +  *) :
14572 +
14573 +     as_fn_append CFLAGS " $flag"
14574 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14575 +  (: CFLAGS="$CFLAGS") 2>&5
14576 +  ac_status=$?
14577 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14578 +  test $ac_status = 0; }
14579 +     ;;
14580 + esac
14581 +
14582 + else
14583 +
14584 +  CFLAGS=$flag
14585 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14586 +  (: CFLAGS="$CFLAGS") 2>&5
14587 +  ac_status=$?
14588 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14589 +  test $ac_status = 0; }
14590  
13164    fi
14591   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)
14592  
14593 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
14593 > else
14594 >  :
14595 > fi
14596  
14597 <     ;; #(
13179 <   *)
13180 <     as_fn_error $? "unknown endianness
13181 < presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13182 < esac
14597 > done
14598  
14599  
14600 < # The cast to long int works around a bug in the HP C Compiler
14601 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14602 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14603 < # This bug is HP SR number 8606223364.
14604 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
14605 < $as_echo_n "checking size of int... " >&6; }
14606 < if ${ac_cv_sizeof_int+:} false; then :
14600 >
14601 >
14602 >
14603 > for flag in -Wundef; do
14604 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14605 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14606 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14607 > if eval \${$as_CACHEVAR+:} false; then :
14608    $as_echo_n "(cached) " >&6
14609   else
13194  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
14610  
14611 +  ax_check_save_flags=$CFLAGS
14612 +  CFLAGS="$CFLAGS  $flag"
14613 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14614 + /* end confdefs.h.  */
14615 +
14616 + int
14617 + main ()
14618 + {
14619 +
14620 +  ;
14621 +  return 0;
14622 + }
14623 + _ACEOF
14624 + if ac_fn_c_try_compile "$LINENO"; then :
14625 +  eval "$as_CACHEVAR=yes"
14626   else
14627 <  if test "$ac_cv_type_int" = yes; then
14628 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14629 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14630 < as_fn_error 77 "cannot compute sizeof (int)
14631 < See \`config.log' for more details" "$LINENO" 5; }
14632 <   else
14633 <     ac_cv_sizeof_int=0
14634 <   fi
14627 >  eval "$as_CACHEVAR=no"
14628 > fi
14629 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14630 >  CFLAGS=$ax_check_save_flags
14631 > fi
14632 > eval ac_res=\$$as_CACHEVAR
14633 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14634 > $as_echo "$ac_res" >&6; }
14635 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14636 >
14637 > if ${CFLAGS+:} false; then :
14638 >
14639 >  case " $CFLAGS " in #(
14640 >  *" $flag "*) :
14641 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14642 >  (: CFLAGS already contains $flag) 2>&5
14643 >  ac_status=$?
14644 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14645 >  test $ac_status = 0; } ;; #(
14646 >  *) :
14647 >
14648 >     as_fn_append CFLAGS " $flag"
14649 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14650 >  (: CFLAGS="$CFLAGS") 2>&5
14651 >  ac_status=$?
14652 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14653 >  test $ac_status = 0; }
14654 >     ;;
14655 > esac
14656 >
14657 > else
14658 >
14659 >  CFLAGS=$flag
14660 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14661 >  (: CFLAGS="$CFLAGS") 2>&5
14662 >  ac_status=$?
14663 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14664 >  test $ac_status = 0; }
14665 >
14666   fi
14667  
14668 + else
14669 +  :
14670   fi
13208 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
13209 $as_echo "$ac_cv_sizeof_int" >&6; }
14671  
14672 + done
14673  
14674  
13213 cat >>confdefs.h <<_ACEOF
13214 #define SIZEOF_INT $ac_cv_sizeof_int
13215 _ACEOF
14675  
14676  
14677 < # The cast to long int works around a bug in the HP C Compiler
14678 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14679 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14680 < # This bug is HP SR number 8606223364.
14681 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
14682 < $as_echo_n "checking size of short... " >&6; }
13224 < if ${ac_cv_sizeof_short+:} false; then :
14677 >
14678 > for flag in -Wuninitialized; do
14679 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14680 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14681 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14682 > if eval \${$as_CACHEVAR+:} false; then :
14683    $as_echo_n "(cached) " >&6
14684   else
13227  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
14685  
14686 +  ax_check_save_flags=$CFLAGS
14687 +  CFLAGS="$CFLAGS  $flag"
14688 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14689 + /* end confdefs.h.  */
14690 +
14691 + int
14692 + main ()
14693 + {
14694 +
14695 +  ;
14696 +  return 0;
14697 + }
14698 + _ACEOF
14699 + if ac_fn_c_try_compile "$LINENO"; then :
14700 +  eval "$as_CACHEVAR=yes"
14701   else
14702 <  if test "$ac_cv_type_short" = yes; then
13231 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13232 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13233 < as_fn_error 77 "cannot compute sizeof (short)
13234 < See \`config.log' for more details" "$LINENO" 5; }
13235 <   else
13236 <     ac_cv_sizeof_short=0
13237 <   fi
14702 >  eval "$as_CACHEVAR=no"
14703   fi
14704 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14705 +  CFLAGS=$ax_check_save_flags
14706 + fi
14707 + eval ac_res=\$$as_CACHEVAR
14708 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14709 + $as_echo "$ac_res" >&6; }
14710 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14711 +
14712 + if ${CFLAGS+:} false; then :
14713 +
14714 +  case " $CFLAGS " in #(
14715 +  *" $flag "*) :
14716 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14717 +  (: CFLAGS already contains $flag) 2>&5
14718 +  ac_status=$?
14719 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14720 +  test $ac_status = 0; } ;; #(
14721 +  *) :
14722 +
14723 +     as_fn_append CFLAGS " $flag"
14724 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14725 +  (: CFLAGS="$CFLAGS") 2>&5
14726 +  ac_status=$?
14727 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14728 +  test $ac_status = 0; }
14729 +     ;;
14730 + esac
14731 +
14732 + else
14733 +
14734 +  CFLAGS=$flag
14735 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14736 +  (: CFLAGS="$CFLAGS") 2>&5
14737 +  ac_status=$?
14738 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14739 +  test $ac_status = 0; }
14740  
14741   fi
13241 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13242 $as_echo "$ac_cv_sizeof_short" >&6; }
14742  
14743 + else
14744 +  :
14745 + fi
14746 +
14747 + done
14748  
14749  
13246 cat >>confdefs.h <<_ACEOF
13247 #define SIZEOF_SHORT $ac_cv_sizeof_short
13248 _ACEOF
14750  
14751  
14752 < # The cast to long int works around a bug in the HP C Compiler
14753 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14754 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14755 < # This bug is HP SR number 8606223364.
14756 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
14757 < $as_echo_n "checking size of long... " >&6; }
13257 < if ${ac_cv_sizeof_long+:} false; then :
14752 >
14753 > for flag in -Wwrite-strings; do
14754 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14755 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14756 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14757 > if eval \${$as_CACHEVAR+:} false; then :
14758    $as_echo_n "(cached) " >&6
14759   else
13260  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
14760  
14761 +  ax_check_save_flags=$CFLAGS
14762 +  CFLAGS="$CFLAGS  $flag"
14763 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14764 + /* end confdefs.h.  */
14765 +
14766 + int
14767 + main ()
14768 + {
14769 +
14770 +  ;
14771 +  return 0;
14772 + }
14773 + _ACEOF
14774 + if ac_fn_c_try_compile "$LINENO"; then :
14775 +  eval "$as_CACHEVAR=yes"
14776   else
14777 <  if test "$ac_cv_type_long" = yes; then
14778 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14779 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14780 < as_fn_error 77 "cannot compute sizeof (long)
14781 < See \`config.log' for more details" "$LINENO" 5; }
14782 <   else
14783 <     ac_cv_sizeof_long=0
14784 <   fi
14777 >  eval "$as_CACHEVAR=no"
14778 > fi
14779 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14780 >  CFLAGS=$ax_check_save_flags
14781 > fi
14782 > eval ac_res=\$$as_CACHEVAR
14783 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14784 > $as_echo "$ac_res" >&6; }
14785 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14786 >
14787 > if ${CFLAGS+:} false; then :
14788 >
14789 >  case " $CFLAGS " in #(
14790 >  *" $flag "*) :
14791 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14792 >  (: CFLAGS already contains $flag) 2>&5
14793 >  ac_status=$?
14794 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14795 >  test $ac_status = 0; } ;; #(
14796 >  *) :
14797 >
14798 >     as_fn_append CFLAGS " $flag"
14799 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14800 >  (: CFLAGS="$CFLAGS") 2>&5
14801 >  ac_status=$?
14802 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14803 >  test $ac_status = 0; }
14804 >     ;;
14805 > esac
14806 >
14807 > else
14808 >
14809 >  CFLAGS=$flag
14810 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14811 >  (: CFLAGS="$CFLAGS") 2>&5
14812 >  ac_status=$?
14813 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14814 >  test $ac_status = 0; }
14815 >
14816   fi
14817  
14818 + else
14819 +  :
14820   fi
13274 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13275 $as_echo "$ac_cv_sizeof_long" >&6; }
14821  
14822 + done
14823  
14824  
14825 < cat >>confdefs.h <<_ACEOF
13280 < #define SIZEOF_LONG $ac_cv_sizeof_long
13281 < _ACEOF
14825 > fi
14826  
14827  
14828 +  # Check whether --enable-efence was given.
14829 + if test "${enable_efence+set}" = set; then :
14830 +  enableval=$enable_efence; efence="$enableval"
14831 + else
14832 +  efence="no"
14833 + fi
14834  
14835  
14836 +  if test "$efence" = "yes"; then :
14837  
14838 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14839 + $as_echo_n "checking for library containing EF_Print... " >&6; }
14840 + if ${ac_cv_search_EF_Print+:} false; then :
14841 +  $as_echo_n "(cached) " >&6
14842 + else
14843 +  ac_func_search_save_LIBS=$LIBS
14844 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14845 + /* end confdefs.h.  */
14846 +
14847 + /* Override any GCC internal prototype to avoid an error.
14848 +   Use char because int might match the return type of a GCC
14849 +   builtin and then its argument prototype would still apply.  */
14850 + #ifdef __cplusplus
14851 + extern "C"
14852 + #endif
14853 + char EF_Print ();
14854 + int
14855 + main ()
14856 + {
14857 + return EF_Print ();
14858 +  ;
14859 +  return 0;
14860 + }
14861 + _ACEOF
14862 + for ac_lib in '' efence; do
14863 +  if test -z "$ac_lib"; then
14864 +    ac_res="none required"
14865 +  else
14866 +    ac_res=-l$ac_lib
14867 +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14868 +  fi
14869 +  if ac_fn_c_try_link "$LINENO"; then :
14870 +  ac_cv_search_EF_Print=$ac_res
14871 + fi
14872 + rm -f core conftest.err conftest.$ac_objext \
14873 +    conftest$ac_exeext
14874 +  if ${ac_cv_search_EF_Print+:} false; then :
14875 +  break
14876 + fi
14877 + done
14878 + if ${ac_cv_search_EF_Print+:} false; then :
14879  
14880 + else
14881 +  ac_cv_search_EF_Print=no
14882 + fi
14883 + rm conftest.$ac_ext
14884 + LIBS=$ac_func_search_save_LIBS
14885 + fi
14886 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14887 + $as_echo "$ac_cv_search_EF_Print" >&6; }
14888 + ac_res=$ac_cv_search_EF_Print
14889 + if test "$ac_res" != no; then :
14890 +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14891  
14892 + else
14893 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14894 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14895 + as_fn_error $? "Electric Fence 'efence' library not found
14896 + See \`config.log' for more details" "$LINENO" 5; }
14897 + fi
14898  
14899  
14900 < subdirs="$subdirs src/libopm"
14900 > fi
14901  
14902  
14903 + for ac_func in strlcpy strlcat
14904 + do :
14905 +  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14906 + ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14907 + if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14908 +  cat >>confdefs.h <<_ACEOF
14909 + #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14910 + _ACEOF
14911  
13295 # Check whether --with-werror was given.
13296 if test "${with_werror+set}" = set; then :
13297  withval=$with_werror; CFLAGS="$CFLAGS -Werror"
14912   fi
14913 + done
14914  
14915  
14916 < ac_config_files="$ac_config_files Makefile src/Makefile"
14916 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14917  
14918   cat >confcache <<\_ACEOF
14919   # This file is a shell script that caches the results of configure
# Line 13394 | Line 15009 | DEFS=-DHAVE_CONFIG_H
15009  
15010   ac_libobjs=
15011   ac_ltlibobjs=
15012 + U=
15013   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
15014    # 1. Remove the extension, and $U if already installed.
15015    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
# Line 13437 | Line 15053 | if test -z "${am__fastdepCC_TRUE}" && te
15053   Usually this means the macro was only invoked conditionally." "$LINENO" 5
15054   fi
15055  
13440
15056   : "${CONFIG_STATUS=./config.status}"
15057   ac_write_fail=0
15058   ac_clean_files_save=$ac_clean_files
# Line 13834 | Line 15449 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15449   # report actual input values of CONFIG_FILES etc. instead of their
15450   # values after options handling.
15451   ac_log="
15452 < This file was extended by bopm $as_me 3.1.3, which was
15452 > This file was extended by hopm $as_me 1.1.6, which was
15453   generated by GNU Autoconf 2.69.  Invocation command line was
15454  
15455    CONFIG_FILES    = $CONFIG_FILES
# Line 13894 | Line 15509 | $config_headers
15509   Configuration commands:
15510   $config_commands
15511  
15512 < Report bugs to the package provider."
15512 > Report bugs to <bugs@ircd-hybrid.org>."
15513  
15514   _ACEOF
15515   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15516   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15517   ac_cs_version="\\
15518 < bopm config.status 3.1.3
15518 > hopm config.status 1.1.6
15519   configured by $0, generated by GNU Autoconf 2.69,
15520    with options \\"\$ac_cs_config\\"
15521  
# Line 14019 | Line 15634 | cat >>$CONFIG_STATUS <<_ACEOF || ac_writ
15634   #
15635   # INIT-COMMANDS
15636   #
15637 < AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
15637 > AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
15638  
15639  
15640   # The HP-UX ksh and POSIX shell print the target directory to stdout
# Line 14156 | Line 15771 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15771   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15772   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15773   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15774 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15774 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15775 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15776   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15777   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15778   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 14274 | Line 15890 | postinstall_cmds \
15890   postuninstall_cmds \
15891   finish_cmds \
15892   sys_lib_search_path_spec \
15893 < sys_lib_dlsearch_path_spec; do
15893 > configure_time_dlsearch_path \
15894 > configure_time_lt_sys_library_path; do
15895      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15896      *[\\\\\\\`\\"\\\$]*)
15897        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 15931 | do
15931      "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
15932      "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15933      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15934 +    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15935      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15936 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15937 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15938  
15939    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15940    esac
# Line 14914 | Line 16534 | $as_echo "$as_me: executing $ac_file com
16534    # Older Autoconf quotes --file arguments for eval, but not when files
16535    # are listed without --file.  Let's play safe and only enable the eval
16536    # if we detect the quoting.
16537 <  case $CONFIG_FILES in
16538 <  *\'*) eval set x "$CONFIG_FILES" ;;
16539 <  *)   set x $CONFIG_FILES ;;
16540 <  esac
16537 >  # TODO: see whether this extra hack can be removed once we start
16538 >  # requiring Autoconf 2.70 or later.
16539 >  case $CONFIG_FILES in #(
16540 >  *\'*) :
16541 >    eval set x "$CONFIG_FILES" ;; #(
16542 >  *) :
16543 >    set x $CONFIG_FILES ;; #(
16544 >  *) :
16545 >     ;;
16546 > esac
16547    shift
16548 <  for mf
16548 >  # Used to flag and report bootstrapping failures.
16549 >  am_rc=0
16550 >  for am_mf
16551    do
16552      # Strip MF so we end up with the name of the file.
16553 <    mf=`echo "$mf" | sed -e 's/:.*$//'`
16554 <    # Check whether this is an Automake generated Makefile or not.
16555 <    # We used to match only the files named 'Makefile.in', but
16556 <    # some people rename them; so instead we look at the file content.
14929 <    # Grep'ing the first line is not enough: some people post-process
14930 <    # each Makefile.in and add a new line on top of each file to say so.
14931 <    # Grep'ing the whole file is not good either: AIX grep has a line
16553 >    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
16554 >    # Check whether this is an Automake generated Makefile which includes
16555 >    # dependency-tracking related rules and includes.
16556 >    # Grep'ing the whole file directly is not great: AIX grep has a line
16557      # limit of 2048, but all sed's we know have understand at least 4000.
16558 <    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
16559 <      dirpart=`$as_dirname -- "$mf" ||
16560 < $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16561 <         X"$mf" : 'X\(//\)[^/]' \| \
16562 <         X"$mf" : 'X\(//\)$' \| \
16563 <         X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
16564 < $as_echo X"$mf" |
16558 >    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
16559 >      || continue
16560 >    am_dirpart=`$as_dirname -- "$am_mf" ||
16561 > $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16562 >         X"$am_mf" : 'X\(//\)[^/]' \| \
16563 >         X"$am_mf" : 'X\(//\)$' \| \
16564 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16565 > $as_echo X"$am_mf" |
16566      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
16567              s//\1/
16568              q
# Line 14954 | Line 16580 | $as_echo X"$mf" |
16580              q
16581            }
16582            s/.*/./; q'`
16583 <    else
16584 <      continue
16585 <    fi
16586 <    # Extract the definition of DEPDIR, am__include, and am__quote
16587 <    # from the Makefile without running 'make'.
16588 <    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
14963 <    test -z "$DEPDIR" && continue
14964 <    am__include=`sed -n 's/^am__include = //p' < "$mf"`
14965 <    test -z "$am__include" && continue
14966 <    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
14967 <    # Find all dependency output files, they are included files with
14968 <    # $(DEPDIR) in their names.  We invoke sed twice because it is the
14969 <    # simplest approach to changing $(DEPDIR) to its actual value in the
14970 <    # expansion.
14971 <    for file in `sed -n "
14972 <      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
14973 <         sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
14974 <      # Make sure the directory exists.
14975 <      test -f "$dirpart/$file" && continue
14976 <      fdir=`$as_dirname -- "$file" ||
14977 < $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14978 <         X"$file" : 'X\(//\)[^/]' \| \
14979 <         X"$file" : 'X\(//\)$' \| \
14980 <         X"$file" : 'X\(/\)' \| . 2>/dev/null ||
14981 < $as_echo X"$file" |
14982 <    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14983 <            s//\1/
14984 <            q
14985 <          }
14986 <          /^X\(\/\/\)[^/].*/{
16583 >    am_filepart=`$as_basename -- "$am_mf" ||
16584 > $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
16585 >         X"$am_mf" : 'X\(//\)$' \| \
16586 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16587 > $as_echo X/"$am_mf" |
16588 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
16589              s//\1/
16590              q
16591            }
16592 <          /^X\(\/\/\)$/{
16592 >          /^X\/\(\/\/\)$/{
16593              s//\1/
16594              q
16595            }
16596 <          /^X\(\/\).*/{
16596 >          /^X\/\(\/\).*/{
16597              s//\1/
16598              q
16599            }
16600            s/.*/./; q'`
16601 <      as_dir=$dirpart/$fdir; as_fn_mkdir_p
16602 <      # echo "creating $dirpart/$file"
16603 <      echo '# dummy' > "$dirpart/$file"
16604 <    done
16601 >    { echo "$as_me:$LINENO: cd "$am_dirpart" \
16602 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16603 >        | $MAKE -f - am--depfiles" >&5
16604 >   (cd "$am_dirpart" \
16605 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16606 >        | $MAKE -f - am--depfiles) >&5 2>&5
16607 >   ac_status=$?
16608 >   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16609 >   (exit $ac_status); } || am_rc=$?
16610    done
16611 +  if test $am_rc -ne 0; then
16612 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
16613 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
16614 + as_fn_error $? "Something went wrong bootstrapping makefile fragments
16615 +    for automatic dependency tracking.  Try re-running configure with the
16616 +    '--disable-dependency-tracking' option to at least be able to build
16617 +    the package (albeit without support for automatic dependency tracking).
16618 + See \`config.log' for more details" "$LINENO" 5; }
16619 +  fi
16620 +  { am_dirpart=; unset am_dirpart;}
16621 +  { am_filepart=; unset am_filepart;}
16622 +  { am_mf=; unset am_mf;}
16623 +  { am_rc=; unset am_rc;}
16624 +  rm -f conftest-deps.mk
16625   }
16626   ;;
16627      "libtool":C)
# Line 15050 | Line 16671 | $as_echo X"$file" |
16671   # The names of the tagged configurations supported by this script.
16672   available_tags=''
16673  
16674 + # Configured defaults for sys_lib_dlsearch_path munging.
16675 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16676 +
16677   # ### BEGIN LIBTOOL CONFIG
16678  
16679   # Which release of libtool.m4 was used?
# Line 15299 | Line 16923 | hardcode_into_libs=$hardcode_into_libs
16923   # Compile-time system search path for libraries.
16924   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16925  
16926 < # Run-time system search path for libraries.
16927 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16926 > # Detected run-time system search path for libraries.
16927 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16928 >
16929 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16930 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16931  
16932   # Whether dlopen is supported.
16933   dlopen_support=$enable_dlopen
# Line 15451 | Line 17078 | hardcode_action=$hardcode_action
17078  
17079   _LT_EOF
17080  
17081 +    cat <<'_LT_EOF' >> "$cfgfile"
17082 +
17083 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17084 +
17085 + # func_munge_path_list VARIABLE PATH
17086 + # -----------------------------------
17087 + # VARIABLE is name of variable containing _space_ separated list of
17088 + # directories to be munged by the contents of PATH, which is string
17089 + # having a format:
17090 + # "DIR[:DIR]:"
17091 + #       string "DIR[ DIR]" will be prepended to VARIABLE
17092 + # ":DIR[:DIR]"
17093 + #       string "DIR[ DIR]" will be appended to VARIABLE
17094 + # "DIRP[:DIRP]::[DIRA:]DIRA"
17095 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17096 + #       "DIRA[ DIRA]" will be appended to VARIABLE
17097 + # "DIR[:DIR]"
17098 + #       VARIABLE will be replaced by "DIR[ DIR]"
17099 + func_munge_path_list ()
17100 + {
17101 +    case x$2 in
17102 +    x)
17103 +        ;;
17104 +    *:)
17105 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17106 +        ;;
17107 +    x:*)
17108 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17109 +        ;;
17110 +    *::*)
17111 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17112 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17113 +        ;;
17114 +    *)
17115 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17116 +        ;;
17117 +    esac
17118 + }
17119 +
17120 +
17121 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17122 + func_cc_basename ()
17123 + {
17124 +    for cc_temp in $*""; do
17125 +      case $cc_temp in
17126 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17127 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17128 +        \-*) ;;
17129 +        *) break;;
17130 +      esac
17131 +    done
17132 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17133 + }
17134 +
17135 +
17136 + # ### END FUNCTIONS SHARED WITH CONFIGURE
17137 +
17138 + _LT_EOF
17139 +
17140    case $host_os in
17141    aix3*)
17142      cat <<\_LT_EOF >> "$cfgfile"
# Line 15514 | Line 17200 | if test "$no_create" != yes; then
17200    # would make configure fail if this is the last instruction.
17201    $ac_cs_success || as_fn_exit 1
17202   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
17203   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17204    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17205   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
# Line 15666 | Line 17207 | fi
17207  
17208  
17209  
17210 < echo "##############################################################################"
17211 < 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."
17210 > echo "###############################################################################"
17211 > echo "Configuration complete.  Type make (or gmake on some *BSD machines) to compile."
17212   echo
17213 < echo "bopm will be installed in ${prefix}.  To change this, run:"
17213 > echo "HOPM will be installed in ${prefix}.  To change this, run:"
17214   echo "   ./configure --prefix=DIRECTORY"
17215 < echo "##############################################################################"
15677 < echo
17215 > 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 8856 by michael, Sat Feb 9 18:53:33 2019 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 8856 by michael, Sat Feb 9 18:53:33 2019 UTC

# Line 0 | Line 1
1 + Id

Diff Legend

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