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

Comparing hopm/trunk/configure (file contents):
Revision 5061 by michael, Mon Dec 22 14:00:18 2014 UTC vs.
Revision 8850 by michael, Sat Feb 9 18:34:12 2019 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8559 2018-09-23 09:25:41Z michael .
3   # Guess values for system-dependent variables and create Makefiles.
4 < # Generated by GNU Autoconf 2.69 for hopm 1.0.0beta1.
4 > # Generated by GNU Autoconf 2.69 for hopm TRUNK.
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 587 | Line 591 | MAKEFLAGS=
591   # Identity of this package.
592   PACKAGE_NAME='hopm'
593   PACKAGE_TARNAME='hopm'
594 < PACKAGE_VERSION='1.0.0beta1'
595 < PACKAGE_STRING='hopm 1.0.0beta1'
596 < PACKAGE_BUGREPORT=''
594 > PACKAGE_VERSION='TRUNK'
595 > PACKAGE_STRING='hopm TRUNK'
596 > PACKAGE_BUGREPORT='bugs@ircd-hybrid.org'
597   PACKAGE_URL=''
598  
599   ac_unique_file="src/opercmd.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 hopm 1.0.0beta1 to adapt to many kinds of systems.
1333 > \`configure' configures hopm TRUNK to adapt to many kinds of systems.
1334  
1335   Usage: $0 [OPTION]... [VAR=VALUE]...
1336  
# 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 hopm 1.0.0beta1:";;
1403 >     short | recursive ) echo "Configuration of hopm TRUNK:";;
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 < hopm configure 1.0.0beta1
1528 > hopm configure TRUNK
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 hopm $as_me 1.0.0beta1, which was
1806 > It was created by hopm $as_me TRUNK, 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 2981 | Line 2666 | fi
2666  
2667   # Define the identity of the package.
2668   PACKAGE='hopm'
2669 < VERSION='1.0.0beta1'
2669 > VERSION='TRUNK'
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.  */
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 > 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_search_getaddrinfo=no
12450 > fi
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 > 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.  */
12378 #include <stdlib.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 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12493 <  $EGREP "free" >/dev/null 2>&1; then :
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_header_stdc=no
12511 >  ac_cv_search_getnameinfo=no
12512   fi
12513 < rm -f conftest*
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 < if test $ac_cv_header_stdc = yes; then
12525 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
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.1d and above" >&5
12641 > $as_echo_n "checking for LibreSSL or OpenSSL 1.0.1d 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 >= 0x1000104fL));
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  
12788 < 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 >
12797 >  if test "$warnings" = "yes"; then :
12798 >
12799 >
12800  
12801  
12802 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
12803 < $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
12804 < if ${ac_cv_c_const+:} false; then :
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 < $as_echo "#define const /**/" >>confdefs.h
12837 > if ${CFLAGS+:} false; then :
12838  
12839 < fi
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 < ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
12849 < if test "x$ac_cv_type_size_t" = xyes; then :
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 < cat >>confdefs.h <<_ACEOF
12860 < #define size_t unsigned int
12861 < _ACEOF
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   fi
12867  
12868 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12869 < $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12870 < if ${ac_cv_header_time+:} false; then :
12868 > else
12869 >  :
12870 > fi
12871 >
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 +  ax_check_save_flags=$CFLAGS
12887 +  CFLAGS="$CFLAGS  $flag"
12888    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12889   /* end confdefs.h.  */
12571 #include <sys/types.h>
12572 #include <sys/time.h>
12573 #include <time.h>
12890  
12891   int
12892   main ()
12893   {
12894 < if ((struct tm *) 0)
12579 < return 0;
12894 >
12895    ;
12896    return 0;
12897   }
12898   _ACEOF
12899   if ac_fn_c_try_compile "$LINENO"; then :
12900 <  ac_cv_header_time=yes
12900 >  eval "$as_CACHEVAR=yes"
12901   else
12902 <  ac_cv_header_time=no
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 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12908 < $as_echo "$ac_cv_header_time" >&6; }
12909 < if test $ac_cv_header_time = yes; then
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 < $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
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 struct tm is in sys/time.h or time.h" >&5
12948 < $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
12949 < if ${ac_cv_struct_tm+:} 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.  */
12606 #include <sys/types.h>
12607 #include <time.h>
12965  
12966   int
12967   main ()
12968   {
12969 < struct tm tm;
12613 <                                     int *p = &tm.tm_sec;
12614 <                                     return !p;
12969 >
12970    ;
12971    return 0;
12972   }
12973   _ACEOF
12974   if ac_fn_c_try_compile "$LINENO"; then :
12975 <  ac_cv_struct_tm=time.h
12975 >  eval "$as_CACHEVAR=yes"
12976   else
12977 <  ac_cv_struct_tm=sys/time.h
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_struct_tm" >&5
12983 < $as_echo "$ac_cv_struct_tm" >&6; }
12984 < if test $ac_cv_struct_tm = sys/time.h; 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 TM_IN_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 + done
13023 +
13024  
13025 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking return type of signal handlers" >&5
13026 < $as_echo_n "checking return type of signal handlers... " >&6; }
13027 < if ${ac_cv_type_signal+:} false; then :
13025 >
13026 >
13027 >
13028 > for flag in -Wcast-qual; 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.  */
12642 #include <sys/types.h>
12643 #include <signal.h>
13040  
13041   int
13042   main ()
13043   {
13044 < return *(signal (0, 0)) (0) == 1;
13044 >
13045    ;
13046    return 0;
13047   }
13048   _ACEOF
13049   if ac_fn_c_try_compile "$LINENO"; then :
13050 <  ac_cv_type_signal=int
13050 >  eval "$as_CACHEVAR=yes"
13051   else
13052 <  ac_cv_type_signal=void
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_type_signal" >&5
13058 < $as_echo "$ac_cv_type_signal" >&6; }
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 < cat >>confdefs.h <<_ACEOF
12664 < #define RETSIGTYPE $ac_cv_type_signal
12665 < _ACEOF
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 < for ac_func in strftime
13074 < do :
13075 <  ac_fn_c_check_func "$LINENO" "strftime" "ac_cv_func_strftime"
13076 < if test "x$ac_cv_func_strftime" = xyes; then :
13077 <  cat >>confdefs.h <<_ACEOF
13078 < #define HAVE_STRFTIME 1
13079 < _ACEOF
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 <  # strftime is in -lintl on SCO UNIX.
13084 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for strftime in -lintl" >&5
13085 < $as_echo_n "checking for strftime in -lintl... " >&6; }
13086 < if ${ac_cv_lib_intl_strftime+:} false; then :
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 >
13103 > for flag in -Wclobbered; 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 <  ac_check_lib_save_LIBS=$LIBS
13111 < LIBS="-lintl  $LIBS"
13112 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13110 >
13111 >  ax_check_save_flags=$CFLAGS
13112 >  CFLAGS="$CFLAGS  $flag"
13113 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13114   /* end confdefs.h.  */
13115  
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 ();
13116   int
13117   main ()
13118   {
13119 < return strftime ();
13119 >
13120    ;
13121    return 0;
13122   }
13123   _ACEOF
13124 < if ac_fn_c_try_link "$LINENO"; then :
13125 <  ac_cv_lib_intl_strftime=yes
13124 > if ac_fn_c_try_compile "$LINENO"; then :
13125 >  eval "$as_CACHEVAR=yes"
13126   else
13127 <  ac_cv_lib_intl_strftime=no
13127 >  eval "$as_CACHEVAR=no"
13128   fi
13129 < rm -f core conftest.err conftest.$ac_objext \
13130 <    conftest$ac_exeext conftest.$ac_ext
12710 < LIBS=$ac_check_lib_save_LIBS
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_lib_intl_strftime" >&5
13133 < $as_echo "$ac_cv_lib_intl_strftime" >&6; }
13134 < if test "x$ac_cv_lib_intl_strftime" = xyes; then :
13135 <  $as_echo "#define HAVE_STRFTIME 1" >>confdefs.h
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 > 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 > 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  
12717 LIBS="-lintl $LIBS"
13166   fi
13167  
13168 + else
13169 +  :
13170   fi
13171 +
13172   done
13173  
13174  
13175  
13176 < for ac_prog in 'bison -y' byacc
13177 < do
13178 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13179 < set dummy $ac_prog; ac_word=$2
13180 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13181 < $as_echo_n "checking for $ac_word... " >&6; }
13182 < if ${ac_cv_prog_YACC+:} false; then :
13176 >
13177 >
13178 > for flag in -Wduplicated-cond; 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 <  if test -n "$YACC"; then
13186 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
13185 >
13186 >  ax_check_save_flags=$CFLAGS
13187 >  CFLAGS="$CFLAGS  $flag"
13188 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13189 > /* end confdefs.h.  */
13190 >
13191 > int
13192 > main ()
13193 > {
13194 >
13195 >  ;
13196 >  return 0;
13197 > }
13198 > _ACEOF
13199 > if ac_fn_c_try_compile "$LINENO"; then :
13200 >  eval "$as_CACHEVAR=yes"
13201   else
13202 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13203 < for as_dir in $PATH
13204 < do
13205 <  IFS=$as_save_IFS
13206 <  test -z "$as_dir" && as_dir=.
13207 <    for ac_exec_ext in '' $ac_executable_extensions; do
13208 <  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13209 <    ac_cv_prog_YACC="$ac_prog"
13210 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13211 <    break 2
13212 <  fi
13202 >  eval "$as_CACHEVAR=no"
13203 > fi
13204 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13205 >  CFLAGS=$ax_check_save_flags
13206 > fi
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 >
13241 > fi
13242 >
13243 > else
13244 >  :
13245 > fi
13246 >
13247   done
12749  done
12750 IFS=$as_save_IFS
13248  
13249 +
13250 +
13251 +
13252 +
13253 + for flag in -Wempty-body; 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 +
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 +  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 < YACC=$ac_cv_prog_YACC
13283 < if test -n "$YACC"; then
13284 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $YACC" >&5
13285 < $as_echo "$YACC" >&6; }
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 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13309 < $as_echo "no" >&6; }
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  
12764  test -n "$YACC" && break
13322   done
12766 test -n "$YACC" || YACC="yacc"
13323  
13324  
13325 < for ac_prog in flex lex
13326 < do
13327 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
13328 < set dummy $ac_prog; ac_word=$2
13329 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
13330 < $as_echo_n "checking for $ac_word... " >&6; }
13331 < if ${ac_cv_prog_LEX+:} false; then :
13325 >
13326 >
13327 >
13328 > for flag in -Wignored-qualifiers; 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 <  if test -n "$LEX"; then
13336 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
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 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13353 < for as_dir in $PATH
13354 < do
13355 <  IFS=$as_save_IFS
13356 <  test -z "$as_dir" && as_dir=.
13357 <    for ac_exec_ext in '' $ac_executable_extensions; do
13358 <  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13359 <    ac_cv_prog_LEX="$ac_prog"
13360 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
13361 <    break 2
13362 <  fi
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 > 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 >
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 >
13397   done
12793  done
12794 IFS=$as_save_IFS
13398  
13399 +
13400 +
13401 +
13402 +
13403 + for flag in -Wlogical-op; 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 +
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 +  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 < LEX=$ac_cv_prog_LEX
13433 < if test -n "$LEX"; then
13434 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LEX" >&5
13435 < $as_echo "$LEX" >&6; }
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 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
13459 < $as_echo "no" >&6; }
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  
12808  test -n "$LEX" && break
13472   done
12810 test -n "$LEX" || LEX=":"
13473  
13474 < if test "x$LEX" != "x:"; then
13475 <  cat >conftest.l <<_ACEOF
13476 < %%
13477 < a { ECHO; }
13478 < b { REJECT; }
13479 < c { yymore (); }
13480 < d { yyless (1); }
13481 < e { /* IRIX 6.5 flex 2.5.4 underquotes its yyless argument.  */
13482 <    yyless ((input () != 0)); }
13483 < f { unput (yytext[0]); }
13484 < . { BEGIN INITIAL; }
13485 < %%
13486 < #ifdef YYTEXT_POINTER
13487 < extern char *yytext;
13488 < #endif
13474 >
13475 >
13476 >
13477 >
13478 > for flag in -Wmissing-declarations; 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 (void)
13492 > main ()
13493   {
13494 <  return ! yylex () + ! yywrap ();
13494 >
13495 >  ;
13496 >  return 0;
13497   }
13498   _ACEOF
13499 < { { ac_try="$LEX conftest.l"
13500 < case "(($ac_try" in
13501 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13502 <  *) ac_try_echo=$ac_try;;
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 > 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 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
13532 < $as_echo "$ac_try_echo"; } >&5
13533 <  (eval "$LEX conftest.l") 2>&5
13531 >
13532 > else
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 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex output file root" >&5
13541 < $as_echo_n "checking lex output file root... " >&6; }
13542 < if ${ac_cv_prog_lex_root+:} false; then :
13540 >
13541 > fi
13542 >
13543 > else
13544 >  :
13545 > fi
13546 >
13547 > done
13548 >
13549 >
13550 >
13551 >
13552 >
13553 > for flag in -Wmissing-field-initializers; 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 < if test -f lex.yy.c; then
13562 <  ac_cv_prog_lex_root=lex.yy
13563 < elif test -f lexyy.c; then
13564 <  ac_cv_prog_lex_root=lexyy
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 ()
13568 > {
13569 >
13570 >  ;
13571 >  return 0;
13572 > }
13573 > _ACEOF
13574 > if ac_fn_c_try_compile "$LINENO"; then :
13575 >  eval "$as_CACHEVAR=yes"
13576   else
13577 <  as_fn_error $? "cannot find output from $LEX; giving up" "$LINENO" 5
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 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root" >&5
13583 < $as_echo "$ac_cv_prog_lex_root" >&6; }
13584 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
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 test -z "${LEXLIB+set}"; then
13588 <  { $as_echo "$as_me:${as_lineno-$LINENO}: checking lex library" >&5
13589 < $as_echo_n "checking lex library... " >&6; }
13590 < if ${ac_cv_lib_lex+:} false; then :
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 >
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 >
13616 > fi
13617 >
13618 > else
13619 >  :
13620 > fi
13621 >
13622 > done
13623 >
13624 >
13625 >
13626 >
13627 >
13628 > for flag in -Wmissing-include-dirs; 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 <    ac_save_LIBS=$LIBS
13637 <    ac_cv_lib_lex='none needed'
13638 <    for ac_lib in '' -lfl -ll; do
12872 <      LIBS="$ac_lib $ac_save_LIBS"
12873 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13636 >  ax_check_save_flags=$CFLAGS
13637 >  CFLAGS="$CFLAGS  $flag"
13638 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13639   /* end confdefs.h.  */
13640 < `cat $LEX_OUTPUT_ROOT.c`
13640 >
13641 > int
13642 > main ()
13643 > {
13644 >
13645 >  ;
13646 >  return 0;
13647 > }
13648   _ACEOF
13649 < if ac_fn_c_try_link "$LINENO"; then :
13650 <  ac_cv_lib_lex=$ac_lib
13649 > if ac_fn_c_try_compile "$LINENO"; then :
13650 >  eval "$as_CACHEVAR=yes"
13651 > else
13652 >  eval "$as_CACHEVAR=no"
13653   fi
13654 < rm -f core conftest.err conftest.$ac_objext \
13655 <    conftest$ac_exeext conftest.$ac_ext
13656 <      test "$ac_cv_lib_lex" != 'none needed' && break
13657 <    done
13658 <    LIBS=$ac_save_LIBS
13654 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13655 >  CFLAGS=$ax_check_save_flags
13656 > fi
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 ${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 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex" >&5
13693 < $as_echo "$ac_cv_lib_lex" >&6; }
13694 <  test "$ac_cv_lib_lex" != 'none needed' && LEXLIB=$ac_cv_lib_lex
13692 >
13693 > else
13694 >  :
13695   fi
13696  
13697 + done
13698  
13699 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer" >&5
13700 < $as_echo_n "checking whether yytext is a pointer... " >&6; }
13701 < if ${ac_cv_prog_lex_yytext_pointer+:} false; then :
13699 >
13700 >
13701 >
13702 >
13703 > for flag in -Wmissing-parameter-type; 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 <  # POSIX says lex can declare yytext either as a pointer or an array; the
13711 < # default is implementation-dependent.  Figure out which it is, since
13712 < # not all implementations provide the %pointer and %array declarations.
13713 < 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
13710 >
13711 >  ax_check_save_flags=$CFLAGS
13712 >  CFLAGS="$CFLAGS  $flag"
13713 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13714   /* end confdefs.h.  */
13715  
13716 <  #define YYTEXT_POINTER 1
13717 < `cat $LEX_OUTPUT_ROOT.c`
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_prog_lex_yytext_pointer=yes
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 < 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
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
13767  
13768 < $as_echo "#define YYTEXT_POINTER 1" >>confdefs.h
13768 > else
13769 >  :
13770 > fi
13771 >
13772 > done
13773 >
13774 >
13775  
13776 +
13777 +
13778 + for flag in -Wmissing-prototypes; 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 +
13786 +  ax_check_save_flags=$CFLAGS
13787 +  CFLAGS="$CFLAGS  $flag"
13788 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13789 + /* end confdefs.h.  */
13790 +
13791 + int
13792 + main ()
13793 + {
13794 +
13795 +  ;
13796 +  return 0;
13797 + }
13798 + _ACEOF
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 conftest.l $LEX_OUTPUT_ROOT.c
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
13842 < if test "$LEX" = :; then
13843 <  LEX=${am_missing_run}flex
13842 >
13843 > else
13844 >  :
13845   fi
13846  
13847 < ETR_SOCKET_NSL
13847 > done
13848  
13849 < for ac_func in inet_aton inet_pton socket strdup strstr
13850 < do :
13851 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
13852 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
13853 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
13854 <  cat >>confdefs.h <<_ACEOF
13855 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
13849 >
13850 >
13851 >
13852 >
13853 > for flag in -Wnested-externs; 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 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 +
13918 + else
13919 +  :
13920 + fi
13921 +
13922   done
13923  
13924  
13925 < for ac_func in gethostbyname gethostbyname2
13926 < do :
13927 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
13928 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
13929 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
13930 <  cat >>confdefs.h <<_ACEOF
13931 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
13925 >
13926 >
13927 >
13928 > for flag in -Wold-style-declaration; 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 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
14001 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
14002 < if ${ac_cv_c_bigendian+:} false; then :
14000 >
14001 >
14002 >
14003 > for flag in -Woverride-init; 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 <  ac_cv_c_bigendian=unknown
14011 <    # See if we're dealing with a universal compiler.
14012 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14010 >
14011 >  ax_check_save_flags=$CFLAGS
14012 >  CFLAGS="$CFLAGS  $flag"
14013 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14014   /* end confdefs.h.  */
12969 #ifndef __APPLE_CC__
12970               not a universal capable compiler
12971             #endif
12972             typedef int dummy;
14015  
14016 + int
14017 + main ()
14018 + {
14019 +
14020 +  ;
14021 +  return 0;
14022 + }
14023   _ACEOF
14024   if ac_fn_c_try_compile "$LINENO"; then :
14025 <
14026 <        # Check for potential -arch flags.  It is not universal unless
14027 <        # 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
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 <    if test $ac_cv_c_bigendian = unknown; then
14031 <      # See if sys/param.h defines the BYTE_ORDER macro.
14032 <      cat confdefs.h - <<_ACEOF >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 >
14076 >
14077 >
14078 > for flag in -Wpointer-arith; 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 >
14086 >  ax_check_save_flags=$CFLAGS
14087 >  CFLAGS="$CFLAGS  $flag"
14088 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14089   /* end confdefs.h.  */
13004 #include <sys/types.h>
13005             #include <sys/param.h>
14090  
14091   int
14092   main ()
14093   {
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
14094  
14095    ;
14096    return 0;
14097   }
14098   _ACEOF
14099   if ac_fn_c_try_compile "$LINENO"; then :
14100 <  # It does; now see whether it defined to BIG_ENDIAN or not.
14101 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
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 >  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 -Wredundant-decls; 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.  */
13024 #include <sys/types.h>
13025                #include <sys/param.h>
14165  
14166   int
14167   main ()
14168   {
13030 #if BYTE_ORDER != BIG_ENDIAN
13031                 not big endian
13032                #endif
14169  
14170    ;
14171    return 0;
14172   }
14173   _ACEOF
14174   if ac_fn_c_try_compile "$LINENO"; then :
14175 <  ac_cv_c_bigendian=yes
14175 >  eval "$as_CACHEVAR=yes"
14176   else
14177 <  ac_cv_c_bigendian=no
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 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14183 <    fi
14184 <    if test $ac_cv_c_bigendian = unknown; then
14185 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
14186 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
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 -Wshadow; 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.  */
13051 #include <limits.h>
14240  
14241   int
14242   main ()
14243   {
13056 #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13057              bogus endian macros
13058             #endif
14244  
14245    ;
14246    return 0;
14247   }
14248   _ACEOF
14249   if ac_fn_c_try_compile "$LINENO"; then :
14250 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
14251 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14250 >  eval "$as_CACHEVAR=yes"
14251 > else
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 > 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 -Wshift-negative-value; 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.  */
13068 #include <limits.h>
14315  
14316   int
14317   main ()
14318   {
13073 #ifndef _BIG_ENDIAN
13074                 not big endian
13075                #endif
14319  
14320    ;
14321    return 0;
14322   }
14323   _ACEOF
14324   if ac_fn_c_try_compile "$LINENO"; then :
14325 <  ac_cv_c_bigendian=yes
14325 >  eval "$as_CACHEVAR=yes"
14326   else
14327 <  ac_cv_c_bigendian=no
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 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14333 <    fi
14334 <    if test $ac_cv_c_bigendian = unknown; then
14335 <      # Compile a test program.
14336 <      if test "$cross_compiling" = yes; then :
14337 <  # Try to guess by grepping values from an object file.
14338 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
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 -Wsign-compare; 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.  */
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;
14390  
14391   int
14392   main ()
14393   {
14394 < return use_ascii (foo) == use_ebcdic (foo);
14394 >
14395    ;
14396    return 0;
14397   }
14398   _ACEOF
14399   if ac_fn_c_try_compile "$LINENO"; then :
14400 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
14401 <              ac_cv_c_bigendian=yes
14402 <            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
14400 >  eval "$as_CACHEVAR=yes"
14401 > else
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 + 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 -Wtype-limits; 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.  */
14465 < $ac_includes_default
14465 >
14466   int
14467   main ()
14468   {
14469  
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
14470    ;
14471    return 0;
14472   }
14473   _ACEOF
14474 < if ac_fn_c_try_run "$LINENO"; then :
14475 <  ac_cv_c_bigendian=no
14474 > if ac_fn_c_try_compile "$LINENO"; then :
14475 >  eval "$as_CACHEVAR=yes"
14476   else
14477 <  ac_cv_c_bigendian=yes
14477 >  eval "$as_CACHEVAR=no"
14478   fi
14479 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
14480 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
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  
13164    fi
14516   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)
14517  
14518 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
14518 > else
14519 >  :
14520 > fi
14521 >
14522 > done
14523 >
14524  
13178     ;; #(
13179   *)
13180     as_fn_error $? "unknown endianness
13181 presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13182 esac
14525  
14526  
14527 < # The cast to long int works around a bug in the HP C Compiler
14528 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14529 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14530 < # This bug is HP SR number 8606223364.
14531 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
14532 < $as_echo_n "checking size of int... " >&6; }
13191 < if ${ac_cv_sizeof_int+:} false; then :
14527 >
14528 > for flag in -Wundef; 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
13194  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
14535  
14536 +  ax_check_save_flags=$CFLAGS
14537 +  CFLAGS="$CFLAGS  $flag"
14538 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14539 + /* end confdefs.h.  */
14540 +
14541 + int
14542 + main ()
14543 + {
14544 +
14545 +  ;
14546 +  return 0;
14547 + }
14548 + _ACEOF
14549 + if ac_fn_c_try_compile "$LINENO"; then :
14550 +  eval "$as_CACHEVAR=yes"
14551   else
14552 <  if test "$ac_cv_type_int" = yes; then
13198 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13199 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13200 < as_fn_error 77 "cannot compute sizeof (int)
13201 < See \`config.log' for more details" "$LINENO" 5; }
13202 <   else
13203 <     ac_cv_sizeof_int=0
13204 <   fi
14552 >  eval "$as_CACHEVAR=no"
14553   fi
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  
14591   fi
14592 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
14593 < $as_echo "$ac_cv_sizeof_int" >&6; }
14592 >
14593 > else
14594 >  :
14595 > fi
14596 >
14597 > done
14598  
14599  
14600  
13213 cat >>confdefs.h <<_ACEOF
13214 #define SIZEOF_INT $ac_cv_sizeof_int
13215 _ACEOF
14601  
14602  
14603 < # The cast to long int works around a bug in the HP C Compiler
14604 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14605 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14606 < # This bug is HP SR number 8606223364.
14607 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13223 < $as_echo_n "checking size of short... " >&6; }
13224 < if ${ac_cv_sizeof_short+:} false; then :
14603 > for flag in -Wuninitialized; 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
13227  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$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_short" = 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 (short)
13234 < See \`config.log' for more details" "$LINENO" 5; }
13235 <   else
13236 <     ac_cv_sizeof_short=0
13237 <   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
13241 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13242 $as_echo "$ac_cv_sizeof_short" >&6; }
14667  
14668 + else
14669 +  :
14670 + fi
14671 +
14672 + done
14673  
14674  
13246 cat >>confdefs.h <<_ACEOF
13247 #define SIZEOF_SHORT $ac_cv_sizeof_short
13248 _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 long" >&5
14682 < $as_echo_n "checking size of long... " >&6; }
13257 < if ${ac_cv_sizeof_long+:} false; then :
14677 >
14678 > for flag in -Wwrite-strings; 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
14685 <  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$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 >  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 <  if test "$ac_cv_type_long" = yes; then
14734 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14735 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14736 < as_fn_error 77 "cannot compute sizeof (long)
14737 < See \`config.log' for more details" "$LINENO" 5; }
14738 <   else
14739 <     ac_cv_sizeof_long=0
14740 <   fi
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
14742  
14743 + else
14744 +  :
14745   fi
13274 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13275 $as_echo "$ac_cv_sizeof_long" >&6; }
14746  
14747 + done
14748  
14749  
14750 < cat >>confdefs.h <<_ACEOF
14751 < #define SIZEOF_LONG $ac_cv_sizeof_long
13281 < _ACEOF
14750 > fi
14751 >
14752  
14753 +  # Check whether --enable-efence was given.
14754 + if test "${enable_efence+set}" = set; then :
14755 +  enableval=$enable_efence; efence="$enableval"
14756 + else
14757 +  efence="no"
14758 + fi
14759  
14760  
14761 +  if test "$efence" = "yes"; then :
14762  
14763 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14764 + $as_echo_n "checking for library containing EF_Print... " >&6; }
14765 + if ${ac_cv_search_EF_Print+:} false; then :
14766 +  $as_echo_n "(cached) " >&6
14767 + else
14768 +  ac_func_search_save_LIBS=$LIBS
14769 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14770 + /* end confdefs.h.  */
14771  
14772 + /* Override any GCC internal prototype to avoid an error.
14773 +   Use char because int might match the return type of a GCC
14774 +   builtin and then its argument prototype would still apply.  */
14775 + #ifdef __cplusplus
14776 + extern "C"
14777 + #endif
14778 + char EF_Print ();
14779 + int
14780 + main ()
14781 + {
14782 + return EF_Print ();
14783 +  ;
14784 +  return 0;
14785 + }
14786 + _ACEOF
14787 + for ac_lib in '' efence; do
14788 +  if test -z "$ac_lib"; then
14789 +    ac_res="none required"
14790 +  else
14791 +    ac_res=-l$ac_lib
14792 +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14793 +  fi
14794 +  if ac_fn_c_try_link "$LINENO"; then :
14795 +  ac_cv_search_EF_Print=$ac_res
14796 + fi
14797 + rm -f core conftest.err conftest.$ac_objext \
14798 +    conftest$ac_exeext
14799 +  if ${ac_cv_search_EF_Print+:} false; then :
14800 +  break
14801 + fi
14802 + done
14803 + if ${ac_cv_search_EF_Print+:} false; then :
14804 +
14805 + else
14806 +  ac_cv_search_EF_Print=no
14807 + fi
14808 + rm conftest.$ac_ext
14809 + LIBS=$ac_func_search_save_LIBS
14810 + fi
14811 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14812 + $as_echo "$ac_cv_search_EF_Print" >&6; }
14813 + ac_res=$ac_cv_search_EF_Print
14814 + if test "$ac_res" != no; then :
14815 +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14816  
14817 + else
14818 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14819 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14820 + as_fn_error $? "Electric Fence 'efence' library not found
14821 + See \`config.log' for more details" "$LINENO" 5; }
14822 + fi
14823  
14824  
14825 < subdirs="$subdirs src/libopm"
14825 > fi
14826  
14827  
14828 + for ac_func in strlcpy strlcat
14829 + do :
14830 +  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14831 + ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14832 + if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14833 +  cat >>confdefs.h <<_ACEOF
14834 + #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14835 + _ACEOF
14836  
13294 # Check whether --with-werror was given.
13295 if test "${with_werror+set}" = set; then :
13296  withval=$with_werror; CFLAGS="$CFLAGS -Werror"
14837   fi
14838 + done
14839  
14840  
14841 < ac_config_files="$ac_config_files Makefile src/Makefile"
14841 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14842  
14843   cat >confcache <<\_ACEOF
14844   # This file is a shell script that caches the results of configure
# Line 13393 | Line 14934 | DEFS=-DHAVE_CONFIG_H
14934  
14935   ac_libobjs=
14936   ac_ltlibobjs=
14937 + U=
14938   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14939    # 1. Remove the extension, and $U if already installed.
14940    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
# Line 13436 | Line 14978 | if test -z "${am__fastdepCC_TRUE}" && te
14978   Usually this means the macro was only invoked conditionally." "$LINENO" 5
14979   fi
14980  
13439
14981   : "${CONFIG_STATUS=./config.status}"
14982   ac_write_fail=0
14983   ac_clean_files_save=$ac_clean_files
# Line 13833 | Line 15374 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15374   # report actual input values of CONFIG_FILES etc. instead of their
15375   # values after options handling.
15376   ac_log="
15377 < This file was extended by hopm $as_me 1.0.0beta1, which was
15377 > This file was extended by hopm $as_me TRUNK, which was
15378   generated by GNU Autoconf 2.69.  Invocation command line was
15379  
15380    CONFIG_FILES    = $CONFIG_FILES
# Line 13893 | Line 15434 | $config_headers
15434   Configuration commands:
15435   $config_commands
15436  
15437 < Report bugs to the package provider."
15437 > Report bugs to <bugs@ircd-hybrid.org>."
15438  
15439   _ACEOF
15440   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15441   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15442   ac_cs_version="\\
15443 < hopm config.status 1.0.0beta1
15443 > hopm config.status TRUNK
15444   configured by $0, generated by GNU Autoconf 2.69,
15445    with options \\"\$ac_cs_config\\"
15446  
# Line 14018 | Line 15559 | cat >>$CONFIG_STATUS <<_ACEOF || ac_writ
15559   #
15560   # INIT-COMMANDS
15561   #
15562 < AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
15562 > AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
15563  
15564  
15565   # The HP-UX ksh and POSIX shell print the target directory to stdout
# Line 14155 | Line 15696 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15696   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15697   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15698   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15699 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15699 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15700 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15701   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15702   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15703   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 14273 | Line 15815 | postinstall_cmds \
15815   postuninstall_cmds \
15816   finish_cmds \
15817   sys_lib_search_path_spec \
15818 < sys_lib_dlsearch_path_spec; do
15818 > configure_time_dlsearch_path \
15819 > configure_time_lt_sys_library_path; do
15820      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15821      *[\\\\\\\`\\"\\\$]*)
15822        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 14313 | Line 15856 | do
15856      "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
15857      "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
15858      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15859 +    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15860      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15861 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15862 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15863  
15864    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15865    esac
# Line 14913 | Line 16459 | $as_echo "$as_me: executing $ac_file com
16459    # Older Autoconf quotes --file arguments for eval, but not when files
16460    # are listed without --file.  Let's play safe and only enable the eval
16461    # if we detect the quoting.
16462 <  case $CONFIG_FILES in
16463 <  *\'*) eval set x "$CONFIG_FILES" ;;
16464 <  *)   set x $CONFIG_FILES ;;
16465 <  esac
16462 >  # TODO: see whether this extra hack can be removed once we start
16463 >  # requiring Autoconf 2.70 or later.
16464 >  case $CONFIG_FILES in #(
16465 >  *\'*) :
16466 >    eval set x "$CONFIG_FILES" ;; #(
16467 >  *) :
16468 >    set x $CONFIG_FILES ;; #(
16469 >  *) :
16470 >     ;;
16471 > esac
16472    shift
16473 <  for mf
16473 >  # Used to flag and report bootstrapping failures.
16474 >  am_rc=0
16475 >  for am_mf
16476    do
16477      # Strip MF so we end up with the name of the file.
16478 <    mf=`echo "$mf" | sed -e 's/:.*$//'`
16479 <    # Check whether this is an Automake generated Makefile or not.
16480 <    # We used to match only the files named 'Makefile.in', but
16481 <    # some people rename them; so instead we look at the file content.
14928 <    # Grep'ing the first line is not enough: some people post-process
14929 <    # each Makefile.in and add a new line on top of each file to say so.
14930 <    # Grep'ing the whole file is not good either: AIX grep has a line
16478 >    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
16479 >    # Check whether this is an Automake generated Makefile which includes
16480 >    # dependency-tracking related rules and includes.
16481 >    # Grep'ing the whole file directly is not great: AIX grep has a line
16482      # limit of 2048, but all sed's we know have understand at least 4000.
16483 <    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
16484 <      dirpart=`$as_dirname -- "$mf" ||
16485 < $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16486 <         X"$mf" : 'X\(//\)[^/]' \| \
16487 <         X"$mf" : 'X\(//\)$' \| \
16488 <         X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
16489 < $as_echo X"$mf" |
16483 >    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
16484 >      || continue
16485 >    am_dirpart=`$as_dirname -- "$am_mf" ||
16486 > $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16487 >         X"$am_mf" : 'X\(//\)[^/]' \| \
16488 >         X"$am_mf" : 'X\(//\)$' \| \
16489 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16490 > $as_echo X"$am_mf" |
16491      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
16492              s//\1/
16493              q
# Line 14953 | Line 16505 | $as_echo X"$mf" |
16505              q
16506            }
16507            s/.*/./; q'`
16508 <    else
16509 <      continue
16510 <    fi
16511 <    # Extract the definition of DEPDIR, am__include, and am__quote
16512 <    # from the Makefile without running 'make'.
16513 <    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
14962 <    test -z "$DEPDIR" && continue
14963 <    am__include=`sed -n 's/^am__include = //p' < "$mf"`
14964 <    test -z "$am__include" && continue
14965 <    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
14966 <    # Find all dependency output files, they are included files with
14967 <    # $(DEPDIR) in their names.  We invoke sed twice because it is the
14968 <    # simplest approach to changing $(DEPDIR) to its actual value in the
14969 <    # expansion.
14970 <    for file in `sed -n "
14971 <      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
14972 <         sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
14973 <      # Make sure the directory exists.
14974 <      test -f "$dirpart/$file" && continue
14975 <      fdir=`$as_dirname -- "$file" ||
14976 < $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14977 <         X"$file" : 'X\(//\)[^/]' \| \
14978 <         X"$file" : 'X\(//\)$' \| \
14979 <         X"$file" : 'X\(/\)' \| . 2>/dev/null ||
14980 < $as_echo X"$file" |
14981 <    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14982 <            s//\1/
14983 <            q
14984 <          }
14985 <          /^X\(\/\/\)[^/].*/{
16508 >    am_filepart=`$as_basename -- "$am_mf" ||
16509 > $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
16510 >         X"$am_mf" : 'X\(//\)$' \| \
16511 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16512 > $as_echo X/"$am_mf" |
16513 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
16514              s//\1/
16515              q
16516            }
16517 <          /^X\(\/\/\)$/{
16517 >          /^X\/\(\/\/\)$/{
16518              s//\1/
16519              q
16520            }
16521 <          /^X\(\/\).*/{
16521 >          /^X\/\(\/\).*/{
16522              s//\1/
16523              q
16524            }
16525            s/.*/./; q'`
16526 <      as_dir=$dirpart/$fdir; as_fn_mkdir_p
16527 <      # echo "creating $dirpart/$file"
16528 <      echo '# dummy' > "$dirpart/$file"
16529 <    done
16526 >    { echo "$as_me:$LINENO: cd "$am_dirpart" \
16527 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16528 >        | $MAKE -f - am--depfiles" >&5
16529 >   (cd "$am_dirpart" \
16530 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16531 >        | $MAKE -f - am--depfiles) >&5 2>&5
16532 >   ac_status=$?
16533 >   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16534 >   (exit $ac_status); } || am_rc=$?
16535    done
16536 +  if test $am_rc -ne 0; then
16537 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
16538 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
16539 + as_fn_error $? "Something went wrong bootstrapping makefile fragments
16540 +    for automatic dependency tracking.  Try re-running configure with the
16541 +    '--disable-dependency-tracking' option to at least be able to build
16542 +    the package (albeit without support for automatic dependency tracking).
16543 + See \`config.log' for more details" "$LINENO" 5; }
16544 +  fi
16545 +  { am_dirpart=; unset am_dirpart;}
16546 +  { am_filepart=; unset am_filepart;}
16547 +  { am_mf=; unset am_mf;}
16548 +  { am_rc=; unset am_rc;}
16549 +  rm -f conftest-deps.mk
16550   }
16551   ;;
16552      "libtool":C)
# Line 15049 | Line 16596 | $as_echo X"$file" |
16596   # The names of the tagged configurations supported by this script.
16597   available_tags=''
16598  
16599 + # Configured defaults for sys_lib_dlsearch_path munging.
16600 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16601 +
16602   # ### BEGIN LIBTOOL CONFIG
16603  
16604   # Which release of libtool.m4 was used?
# Line 15298 | Line 16848 | hardcode_into_libs=$hardcode_into_libs
16848   # Compile-time system search path for libraries.
16849   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16850  
16851 < # Run-time system search path for libraries.
16852 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16851 > # Detected run-time system search path for libraries.
16852 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16853 >
16854 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16855 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16856  
16857   # Whether dlopen is supported.
16858   dlopen_support=$enable_dlopen
# Line 15450 | Line 17003 | hardcode_action=$hardcode_action
17003  
17004   _LT_EOF
17005  
17006 +    cat <<'_LT_EOF' >> "$cfgfile"
17007 +
17008 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17009 +
17010 + # func_munge_path_list VARIABLE PATH
17011 + # -----------------------------------
17012 + # VARIABLE is name of variable containing _space_ separated list of
17013 + # directories to be munged by the contents of PATH, which is string
17014 + # having a format:
17015 + # "DIR[:DIR]:"
17016 + #       string "DIR[ DIR]" will be prepended to VARIABLE
17017 + # ":DIR[:DIR]"
17018 + #       string "DIR[ DIR]" will be appended to VARIABLE
17019 + # "DIRP[:DIRP]::[DIRA:]DIRA"
17020 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17021 + #       "DIRA[ DIRA]" will be appended to VARIABLE
17022 + # "DIR[:DIR]"
17023 + #       VARIABLE will be replaced by "DIR[ DIR]"
17024 + func_munge_path_list ()
17025 + {
17026 +    case x$2 in
17027 +    x)
17028 +        ;;
17029 +    *:)
17030 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17031 +        ;;
17032 +    x:*)
17033 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17034 +        ;;
17035 +    *::*)
17036 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17037 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17038 +        ;;
17039 +    *)
17040 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17041 +        ;;
17042 +    esac
17043 + }
17044 +
17045 +
17046 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17047 + func_cc_basename ()
17048 + {
17049 +    for cc_temp in $*""; do
17050 +      case $cc_temp in
17051 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17052 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17053 +        \-*) ;;
17054 +        *) break;;
17055 +      esac
17056 +    done
17057 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17058 + }
17059 +
17060 +
17061 + # ### END FUNCTIONS SHARED WITH CONFIGURE
17062 +
17063 + _LT_EOF
17064 +
17065    case $host_os in
17066    aix3*)
17067      cat <<\_LT_EOF >> "$cfgfile"
# Line 15513 | Line 17125 | if test "$no_create" != yes; then
17125    # would make configure fail if this is the last instruction.
17126    $ac_cs_success || as_fn_exit 1
17127   fi
15516
15517 #
15518 # CONFIG_SUBDIRS section.
15519 #
15520 if test "$no_recursion" != yes; then
15521
15522  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
15523  # so they do not pile up.
15524  ac_sub_configure_args=
15525  ac_prev=
15526  eval "set x $ac_configure_args"
15527  shift
15528  for ac_arg
15529  do
15530    if test -n "$ac_prev"; then
15531      ac_prev=
15532      continue
15533    fi
15534    case $ac_arg in
15535    -cache-file | --cache-file | --cache-fil | --cache-fi \
15536    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
15537      ac_prev=cache_file ;;
15538    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
15539    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
15540    | --c=*)
15541      ;;
15542    --config-cache | -C)
15543      ;;
15544    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
15545      ac_prev=srcdir ;;
15546    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
15547      ;;
15548    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
15549      ac_prev=prefix ;;
15550    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
15551      ;;
15552    --disable-option-checking)
15553      ;;
15554    *)
15555      case $ac_arg in
15556      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15557      esac
15558      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
15559    esac
15560  done
15561
15562  # Always prepend --prefix to ensure using the same prefix
15563  # in subdir configurations.
15564  ac_arg="--prefix=$prefix"
15565  case $ac_arg in
15566  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15567  esac
15568  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
15569
15570  # Pass --silent
15571  if test "$silent" = yes; then
15572    ac_sub_configure_args="--silent $ac_sub_configure_args"
15573  fi
15574
15575  # Always prepend --disable-option-checking to silence warnings, since
15576  # different subdirs can have different --enable and --with options.
15577  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
15578
15579  ac_popdir=`pwd`
15580  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
15581
15582    # Do not complain, so a configure script can configure whichever
15583    # parts of a large source tree are present.
15584    test -d "$srcdir/$ac_dir" || continue
15585
15586    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
15587    $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
15588    $as_echo "$ac_msg" >&6
15589    as_dir="$ac_dir"; as_fn_mkdir_p
15590    ac_builddir=.
15591
15592 case "$ac_dir" in
15593 .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
15594 *)
15595  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
15596  # A ".." for each directory in $ac_dir_suffix.
15597  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
15598  case $ac_top_builddir_sub in
15599  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
15600  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
15601  esac ;;
15602 esac
15603 ac_abs_top_builddir=$ac_pwd
15604 ac_abs_builddir=$ac_pwd$ac_dir_suffix
15605 # for backward compatibility:
15606 ac_top_builddir=$ac_top_build_prefix
15607
15608 case $srcdir in
15609  .)  # We are building in place.
15610    ac_srcdir=.
15611    ac_top_srcdir=$ac_top_builddir_sub
15612    ac_abs_top_srcdir=$ac_pwd ;;
15613  [\\/]* | ?:[\\/]* )  # Absolute name.
15614    ac_srcdir=$srcdir$ac_dir_suffix;
15615    ac_top_srcdir=$srcdir
15616    ac_abs_top_srcdir=$srcdir ;;
15617  *) # Relative name.
15618    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
15619    ac_top_srcdir=$ac_top_build_prefix$srcdir
15620    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
15621 esac
15622 ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
15623
15624
15625    cd "$ac_dir"
15626
15627    # Check for guested configure; otherwise get Cygnus style configure.
15628    if test -f "$ac_srcdir/configure.gnu"; then
15629      ac_sub_configure=$ac_srcdir/configure.gnu
15630    elif test -f "$ac_srcdir/configure"; then
15631      ac_sub_configure=$ac_srcdir/configure
15632    elif test -f "$ac_srcdir/configure.in"; then
15633      # This should be Cygnus configure.
15634      ac_sub_configure=$ac_aux_dir/configure
15635    else
15636      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
15637 $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
15638      ac_sub_configure=
15639    fi
15640
15641    # The recursion is here.
15642    if test -n "$ac_sub_configure"; then
15643      # Make the cache file name correct relative to the subdirectory.
15644      case $cache_file in
15645      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
15646      *) # Relative name.
15647        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
15648      esac
15649
15650      { $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
15651 $as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
15652      # The eval makes quoting arguments work.
15653      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
15654           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
15655        as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
15656    fi
15657
15658    cd "$ac_popdir"
15659  done
15660 fi
17128   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17129    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17130   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
# Line 15665 | Line 17132 | fi
17132  
17133  
17134  
17135 < echo "##############################################################################"
17136 < echo "Everything is now configured, but you can find some more (infrequently"
15670 < echo "changed) options in options.h.  To compile HOPM now, just type make.  It"
15671 < echo "requires GNU Make, which may be installed as gmake on your system."
17135 > echo "###############################################################################"
17136 > echo "Configuration complete.  Type make (or gmake on some *BSD machines) to compile."
17137   echo
17138 < echo "hopm will be installed in ${prefix}.  To change this, run:"
17138 > echo "HOPM will be installed in ${prefix}.  To change this, run:"
17139   echo "   ./configure --prefix=DIRECTORY"
17140 < echo "##############################################################################"
17140 > echo "###############################################################################"

Comparing hopm/trunk/configure (property svn:eol-style):
Revision 5061 by michael, Mon Dec 22 14:00:18 2014 UTC vs.
Revision 8850 by michael, Sat Feb 9 18:34:12 2019 UTC

# Line 0 | Line 1
1 + native

Comparing hopm/trunk/configure (property svn:keywords):
Revision 5061 by michael, Mon Dec 22 14:00:18 2014 UTC vs.
Revision 8850 by michael, Sat Feb 9 18:34:12 2019 UTC

# Line 0 | Line 1
1 + Id

Diff Legend

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