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

Comparing:
hopm/trunk/configure (file contents), Revision 5135 by michael, Thu Dec 25 18:51:51 2014 UTC vs.
hopm/branches/1.1.x/configure (file contents), Revision 8558 by michael, Sun Sep 23 09:25:22 2018 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8549 2018-09-22 20:55:30Z 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 1.1.5.
5 > #
6 > # Report bugs to <bugs@ircd-hybrid.org>.
7   #
8   #
9   # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
# Line 272 | Line 275 | fi
275      $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
276      $as_echo "$0: be upgraded to zsh 4.3.4 or later."
277    else
278 <    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
279 < $0: including any error possibly output before this
280 < $0: message. Then install a modern shell, or manually run
281 < $0: the script under such a shell if you do have one."
278 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and
279 > $0: bugs@ircd-hybrid.org about your system, including any
280 > $0: error possibly output before this message. Then install
281 > $0: a modern shell, or manually run the script under such a
282 > $0: shell if you do have one."
283    fi
284    exit 1
285   fi
# Line 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='1.1.5'
595 > PACKAGE_STRING='hopm 1.1.5'
596 > PACKAGE_BUGREPORT='bugs@ircd-hybrid.org'
597   PACKAGE_URL=''
598  
599   ac_unique_file="src/opercmd.h"
# Line 630 | Line 634 | ac_includes_default="\
634   # include <unistd.h>
635   #endif"
636  
633 – enable_option_checking=no
637   ac_subst_vars='am__EXEEXT_FALSE
638   am__EXEEXT_TRUE
639   LTLIBOBJS
640   LIBOBJS
641 < subdirs
641 > ENABLE_SSL_FALSE
642 > ENABLE_SSL_TRUE
643   LEXLIB
644   LEX_OUTPUT_ROOT
645   LEX
646   YFLAGS
647   YACC
648   CPP
649 + LT_SYS_LIBRARY_PATH
650   OTOOL64
651   OTOOL
652   LIPO
# Line 761 | Line 766 | ac_user_opts='
766   enable_option_checking
767   enable_silent_rules
768   enable_maintainer_mode
764 – with_extra_fascism
769   enable_dependency_tracking
770   enable_shared
771   enable_static
# Line 771 | Line 775 | with_aix_soname
775   with_gnu_ld
776   with_sysroot
777   enable_libtool_lock
778 + enable_openssl
779 + enable_assert
780 + enable_warnings
781 + enable_efence
782   '
783        ac_precious_vars='build_alias
784   host_alias
# Line 780 | Line 788 | CFLAGS
788   LDFLAGS
789   LIBS
790   CPPFLAGS
791 + LT_SYS_LIBRARY_PATH
792   CPP
793   YACC
794   YFLAGS'
795 < ac_subdirs_all='src/libopm'
795 >
796  
797   # Initialize some variables set by options.
798   ac_init_help=
# Line 1323 | Line 1332 | if test "$ac_init_help" = "long"; then
1332    # Omit some internal or obsolete options to make the list less imposing.
1333    # This message is too long to be a string in the A/UX 3.1 sh.
1334    cat <<_ACEOF
1335 < \`configure' configures hopm 1.0.0beta1 to adapt to many kinds of systems.
1335 > \`configure' configures hopm 1.1.5 to adapt to many kinds of systems.
1336  
1337   Usage: $0 [OPTION]... [VAR=VALUE]...
1338  
# Line 1393 | Line 1402 | fi
1402  
1403   if test -n "$ac_init_help"; then
1404    case $ac_init_help in
1405 <     short | recursive ) echo "Configuration of hopm 1.0.0beta1:";;
1405 >     short | recursive ) echo "Configuration of hopm 1.1.5:";;
1406     esac
1407    cat <<\_ACEOF
1408  
# Line 1415 | Line 1424 | Optional Features:
1424    --enable-fast-install[=PKGS]
1425                            optimize for fast installation [default=yes]
1426    --disable-libtool-lock  avoid locking (might break parallel builds)
1427 +  --enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1428 +  --disable-openssl            Disable LibreSSL/OpenSSL support.
1429 +  --enable-assert         Enable assert() statements
1430 +  --enable-warnings       Enable compiler warnings.
1431 +  --enable-efence         Enable linking with Electric Fence 'efence' memory
1432 +                          debugger library.
1433  
1434   Optional Packages:
1435    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1436    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1422 –  --with-extra-fascism    Add extra gcc3-specific warning flags
1437    --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1438                            both]
1439    --with-aix-soname=aix|svr4|both
# Line 1437 | Line 1451 | Some influential environment variables:
1451    LIBS        libraries to pass to the linker, e.g. -l<library>
1452    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1453                you have headers in a nonstandard directory <include dir>
1454 +  LT_SYS_LIBRARY_PATH
1455 +              User-defined run-time library search path.
1456    CPP         C preprocessor
1457    YACC        The `Yet Another Compiler Compiler' implementation to use.
1458                Defaults to the first program found out of: `bison -y', `byacc',
# Line 1448 | Line 1464 | Some influential environment variables:
1464   Use these variables to override the choices made by `configure' or to help
1465   it to find libraries and programs with nonstandard names/locations.
1466  
1467 < Report bugs to the package provider.
1467 > Report bugs to <bugs@ircd-hybrid.org>.
1468   _ACEOF
1469   ac_status=$?
1470   fi
# Line 1511 | Line 1527 | fi
1527   test -n "$ac_init_help" && exit $ac_status
1528   if $ac_init_version; then
1529    cat <<\_ACEOF
1530 < hopm configure 1.0.0beta1
1530 > hopm configure 1.1.5
1531   generated by GNU Autoconf 2.69
1532  
1533   Copyright (C) 2012 Free Software Foundation, Inc.
# Line 1785 | Line 1801 | $as_echo "$ac_res" >&6; }
1801    eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1802  
1803   } # ac_fn_c_check_func
1788 –
1789 – # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1790 – # -------------------------------------------------------
1791 – # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1792 – # the include files in INCLUDES and setting the cache variable VAR
1793 – # accordingly.
1794 – ac_fn_c_check_header_mongrel ()
1795 – {
1796 –  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1797 –  if eval \${$3+:} false; then :
1798 –  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1799 – $as_echo_n "checking for $2... " >&6; }
1800 – if eval \${$3+:} false; then :
1801 –  $as_echo_n "(cached) " >&6
1802 – fi
1803 – eval ac_res=\$$3
1804 –               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1805 – $as_echo "$ac_res" >&6; }
1806 – else
1807 –  # Is the header compilable?
1808 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1809 – $as_echo_n "checking $2 usability... " >&6; }
1810 – cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1811 – /* end confdefs.h.  */
1812 – $4
1813 – #include <$2>
1814 – _ACEOF
1815 – if ac_fn_c_try_compile "$LINENO"; then :
1816 –  ac_header_compiler=yes
1817 – else
1818 –  ac_header_compiler=no
1819 – fi
1820 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1821 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1822 – $as_echo "$ac_header_compiler" >&6; }
1823 –
1824 – # Is the header present?
1825 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1826 – $as_echo_n "checking $2 presence... " >&6; }
1827 – cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1828 – /* end confdefs.h.  */
1829 – #include <$2>
1830 – _ACEOF
1831 – if ac_fn_c_try_cpp "$LINENO"; then :
1832 –  ac_header_preproc=yes
1833 – else
1834 –  ac_header_preproc=no
1835 – fi
1836 – rm -f conftest.err conftest.i conftest.$ac_ext
1837 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1838 – $as_echo "$ac_header_preproc" >&6; }
1839 –
1840 – # So?  What about this header?
1841 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1842 –  yes:no: )
1843 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1844 – $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1845 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1846 – $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1847 –    ;;
1848 –  no:yes:* )
1849 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1850 – $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1851 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1852 – $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1853 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1854 – $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1855 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1856 – $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1857 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1858 – $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1859 –    ;;
1860 – esac
1861 –  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1862 – $as_echo_n "checking for $2... " >&6; }
1863 – if eval \${$3+:} false; then :
1864 –  $as_echo_n "(cached) " >&6
1865 – else
1866 –  eval "$3=\$ac_header_compiler"
1867 – fi
1868 – eval ac_res=\$$3
1869 –               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1870 – $as_echo "$ac_res" >&6; }
1871 – fi
1872 –  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1873 –
1874 – } # ac_fn_c_check_header_mongrel
1875 –
1876 – # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
1877 – # -------------------------------------------
1878 – # Tests whether TYPE exists after having included INCLUDES, setting cache
1879 – # variable VAR accordingly.
1880 – ac_fn_c_check_type ()
1881 – {
1882 –  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1883 –  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1884 – $as_echo_n "checking for $2... " >&6; }
1885 – if eval \${$3+:} false; then :
1886 –  $as_echo_n "(cached) " >&6
1887 – else
1888 –  eval "$3=no"
1889 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1890 – /* end confdefs.h.  */
1891 – $4
1892 – int
1893 – main ()
1894 – {
1895 – if (sizeof ($2))
1896 –         return 0;
1897 –  ;
1898 –  return 0;
1899 – }
1900 – _ACEOF
1901 – if ac_fn_c_try_compile "$LINENO"; then :
1902 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1903 – /* end confdefs.h.  */
1904 – $4
1905 – int
1906 – main ()
1907 – {
1908 – if (sizeof (($2)))
1909 –            return 0;
1910 –  ;
1911 –  return 0;
1912 – }
1913 – _ACEOF
1914 – if ac_fn_c_try_compile "$LINENO"; then :
1915 –
1916 – else
1917 –  eval "$3=yes"
1918 – fi
1919 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1920 – fi
1921 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1922 – fi
1923 – eval ac_res=\$$3
1924 –               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1925 – $as_echo "$ac_res" >&6; }
1926 –  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1927 –
1928 – } # ac_fn_c_check_type
1929 –
1930 – # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES
1931 – # --------------------------------------------
1932 – # Tries to find the compile-time value of EXPR in a program that includes
1933 – # INCLUDES, setting VAR accordingly. Returns whether the value could be
1934 – # computed
1935 – ac_fn_c_compute_int ()
1936 – {
1937 –  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1938 –  if test "$cross_compiling" = yes; then
1939 –    # Depending upon the size, compute the lo and hi bounds.
1940 – cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1941 – /* end confdefs.h.  */
1942 – $4
1943 – int
1944 – main ()
1945 – {
1946 – static int test_array [1 - 2 * !(($2) >= 0)];
1947 – test_array [0] = 0;
1948 – return test_array [0];
1949 –
1950 –  ;
1951 –  return 0;
1952 – }
1953 – _ACEOF
1954 – if ac_fn_c_try_compile "$LINENO"; then :
1955 –  ac_lo=0 ac_mid=0
1956 –  while :; do
1957 –    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1958 – /* end confdefs.h.  */
1959 – $4
1960 – int
1961 – main ()
1962 – {
1963 – static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1964 – test_array [0] = 0;
1965 – return test_array [0];
1966 –
1967 –  ;
1968 –  return 0;
1969 – }
1970 – _ACEOF
1971 – if ac_fn_c_try_compile "$LINENO"; then :
1972 –  ac_hi=$ac_mid; break
1973 – else
1974 –  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
1975 –                        if test $ac_lo -le $ac_mid; then
1976 –                          ac_lo= ac_hi=
1977 –                          break
1978 –                        fi
1979 –                        as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
1980 – fi
1981 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1982 –  done
1983 – else
1984 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1985 – /* end confdefs.h.  */
1986 – $4
1987 – int
1988 – main ()
1989 – {
1990 – static int test_array [1 - 2 * !(($2) < 0)];
1991 – test_array [0] = 0;
1992 – return test_array [0];
1993 –
1994 –  ;
1995 –  return 0;
1996 – }
1997 – _ACEOF
1998 – if ac_fn_c_try_compile "$LINENO"; then :
1999 –  ac_hi=-1 ac_mid=-1
2000 –  while :; do
2001 –    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2002 – /* end confdefs.h.  */
2003 – $4
2004 – int
2005 – main ()
2006 – {
2007 – static int test_array [1 - 2 * !(($2) >= $ac_mid)];
2008 – test_array [0] = 0;
2009 – return test_array [0];
2010 –
2011 –  ;
2012 –  return 0;
2013 – }
2014 – _ACEOF
2015 – if ac_fn_c_try_compile "$LINENO"; then :
2016 –  ac_lo=$ac_mid; break
2017 – else
2018 –  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
2019 –                        if test $ac_mid -le $ac_hi; then
2020 –                          ac_lo= ac_hi=
2021 –                          break
2022 –                        fi
2023 –                        as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
2024 – fi
2025 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2026 –  done
2027 – else
2028 –  ac_lo= ac_hi=
2029 – fi
2030 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2031 – fi
2032 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2033 – # Binary search between lo and hi bounds.
2034 – while test "x$ac_lo" != "x$ac_hi"; do
2035 –  as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
2036 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2037 – /* end confdefs.h.  */
2038 – $4
2039 – int
2040 – main ()
2041 – {
2042 – static int test_array [1 - 2 * !(($2) <= $ac_mid)];
2043 – test_array [0] = 0;
2044 – return test_array [0];
2045 –
2046 –  ;
2047 –  return 0;
2048 – }
2049 – _ACEOF
2050 – if ac_fn_c_try_compile "$LINENO"; then :
2051 –  ac_hi=$ac_mid
2052 – else
2053 –  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
2054 – fi
2055 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2056 – done
2057 – case $ac_lo in #((
2058 – ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
2059 – '') ac_retval=1 ;;
2060 – esac
2061 –  else
2062 –    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2063 – /* end confdefs.h.  */
2064 – $4
2065 – static long int longval () { return $2; }
2066 – static unsigned long int ulongval () { return $2; }
2067 – #include <stdio.h>
2068 – #include <stdlib.h>
2069 – int
2070 – main ()
2071 – {
2072 –
2073 –  FILE *f = fopen ("conftest.val", "w");
2074 –  if (! f)
2075 –    return 1;
2076 –  if (($2) < 0)
2077 –    {
2078 –      long int i = longval ();
2079 –      if (i != ($2))
2080 –        return 1;
2081 –      fprintf (f, "%ld", i);
2082 –    }
2083 –  else
2084 –    {
2085 –      unsigned long int i = ulongval ();
2086 –      if (i != ($2))
2087 –        return 1;
2088 –      fprintf (f, "%lu", i);
2089 –    }
2090 –  /* Do not output a trailing newline, as this causes \r\n confusion
2091 –     on some platforms.  */
2092 –  return ferror (f) || fclose (f) != 0;
2093 –
2094 –  ;
2095 –  return 0;
2096 – }
2097 – _ACEOF
2098 – if ac_fn_c_try_run "$LINENO"; then :
2099 –  echo >>conftest.val; read $3 <conftest.val; ac_retval=0
2100 – else
2101 –  ac_retval=1
2102 – fi
2103 – rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
2104 –  conftest.$ac_objext conftest.beam conftest.$ac_ext
2105 – rm -f conftest.val
2106 –
2107 –  fi
2108 –  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2109 –  as_fn_set_status $ac_retval
2110 –
2111 – } # ac_fn_c_compute_int
1804   cat >config.log <<_ACEOF
1805   This file contains any messages produced by compilers while
1806   running configure, to aid debugging if configure makes a mistake.
1807  
1808 < It was created by hopm $as_me 1.0.0beta1, which was
1808 > It was created by hopm $as_me 1.1.5, which was
1809   generated by GNU Autoconf 2.69.  Invocation command line was
1810  
1811    $ $0 $@
# Line 2461 | Line 2153 | ac_link='$CC -o conftest$ac_exeext $CFLA
2153   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2154  
2155  
2156 <
2465 < ac_config_headers="$ac_config_headers src/setup.h"
2466 <
2467 < am__api_version='1.14'
2156 > am__api_version='1.15'
2157  
2158   ac_aux_dir=
2159   for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
# Line 2665 | Line 2354 | test "$program_suffix" != NONE &&
2354   ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2355   program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2356  
2357 < # expand $ac_aux_dir to an absolute path
2358 < am_aux_dir=`cd $ac_aux_dir && pwd`
2357 > # Expand $ac_aux_dir to an absolute path.
2358 > am_aux_dir=`cd "$ac_aux_dir" && pwd`
2359  
2360   if test x"${MISSING+set}" != xset; then
2361    case $am_aux_dir in
# Line 2685 | Line 2374 | else
2374   $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2375   fi
2376  
2377 < if test x"${install_sh}" != xset; then
2377 > if test x"${install_sh+set}" != xset; then
2378    case $am_aux_dir in
2379    *\ * | *\     *)
2380      install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
# Line 2979 | Line 2668 | fi
2668  
2669   # Define the identity of the package.
2670   PACKAGE='hopm'
2671 < VERSION='1.0.0beta1'
2671 > VERSION='1.1.5'
2672  
2673  
2674   cat >>confdefs.h <<_ACEOF
# Line 3013 | Line 2702 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2702   # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2703   mkdir_p='$(MKDIR_P)'
2704  
2705 < # We need awk for the "check" target.  The system "awk" is bad on
2706 < # some platforms.
2705 > # We need awk for the "check" target (and possibly the TAP driver).  The
2706 > # system "awk" is bad on some platforms.
2707   # Always define AMTAR for backward compatibility.  Yes, it's still used
2708   # in the wild :-(  We should find a proper way to deprecate it ...
2709   AMTAR='$${TAR-tar}'
# Line 3096 | Line 2785 | fi
2785  
2786  
2787  
2788 <
3100 < # Check whether --with-extra-fascism was given.
3101 < if test "${with_extra_fascism+set}" = set; then :
3102 <  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"
3103 < fi
3104 <
2788 > ac_config_headers="$ac_config_headers src/setup.h"
2789  
2790  
2791  
# Line 4333 | Line 4017 | esac
4017  
4018  
4019  
4020 < macro_version='2.4.4'
4021 < macro_revision='2.4.4'
4020 > macro_version='2.4.6'
4021 > macro_revision='2.4.6'
4022  
4023  
4024  
# Line 6757 | Line 6441 | $as_echo "$lt_cv_truncate_bin" >&6; }
6441  
6442  
6443  
6444 +
6445 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6446 + func_cc_basename ()
6447 + {
6448 +    for cc_temp in $*""; do
6449 +      case $cc_temp in
6450 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6451 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6452 +        \-*) ;;
6453 +        *) break;;
6454 +      esac
6455 +    done
6456 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6457 + }
6458 +
6459   # Check whether --enable-libtool-lock was given.
6460   if test "${enable_libtool_lock+set}" = set; then :
6461    enableval=$enable_libtool_lock;
# Line 7764 | Line 7463 | $as_echo "$lt_cv_ld_force_load" >&6; }
7463      ;;
7464    esac
7465  
7466 + # func_munge_path_list VARIABLE PATH
7467 + # -----------------------------------
7468 + # VARIABLE is name of variable containing _space_ separated list of
7469 + # directories to be munged by the contents of PATH, which is string
7470 + # having a format:
7471 + # "DIR[:DIR]:"
7472 + #       string "DIR[ DIR]" will be prepended to VARIABLE
7473 + # ":DIR[:DIR]"
7474 + #       string "DIR[ DIR]" will be appended to VARIABLE
7475 + # "DIRP[:DIRP]::[DIRA:]DIRA"
7476 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7477 + #       "DIRA[ DIRA]" will be appended to VARIABLE
7478 + # "DIR[:DIR]"
7479 + #       VARIABLE will be replaced by "DIR[ DIR]"
7480 + func_munge_path_list ()
7481 + {
7482 +    case x$2 in
7483 +    x)
7484 +        ;;
7485 +    *:)
7486 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7487 +        ;;
7488 +    x:*)
7489 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7490 +        ;;
7491 +    *::*)
7492 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7493 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7494 +        ;;
7495 +    *)
7496 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7497 +        ;;
7498 +    esac
7499 + }
7500 +
7501   ac_ext=c
7502   ac_cpp='$CPP $CPPFLAGS'
7503   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8351 | Line 8085 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8085   test -z "$LD" && LD=ld
8086   test -z "$ac_objext" && ac_objext=o
8087  
8088 < for cc_temp in $compiler""; do
8089 <  case $cc_temp in
8356 <    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
8357 <    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
8358 <    \-*) ;;
8359 <    *) break;;
8360 <  esac
8361 < done
8362 < cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
8088 > func_cc_basename $compiler
8089 > cc_basename=$func_cc_basename_result
8090  
8091  
8092   # Only perform the check for file, if the check method requires it
# Line 8559 | Line 8286 | _lt_linker_boilerplate=`cat conftest.err
8286   $RM -r conftest*
8287  
8288  
8289 + ## CAVEAT EMPTOR:
8290 + ## There is no encapsulation within the following macros, do not change
8291 + ## the running order or otherwise move them around unless you know exactly
8292 + ## what you are doing...
8293   if test -n "$compiler"; then
8294  
8295   lt_prog_compiler_no_builtin_flag=
# Line 10814 | Line 10545 | hardcode_into_libs=no
10545   # flags to be left without arguments
10546   need_version=unknown
10547  
10548 +
10549 +
10550   case $host_os in
10551   aix3*)
10552    version_type=linux # correct to gnu/linux during the next big refactor
# Line 11102 | Line 10835 | freebsd* | dragonfly*)
10835    case $version_type in
10836      freebsd-elf*)
10837        library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10838 +      soname_spec='$libname$release$shared_ext$major'
10839        need_version=no
10840        need_lib_prefix=no
10841        ;;
# Line 11161 | Line 10895 | hpux9* | hpux10* | hpux11*)
10895      soname_spec='$libname$release$shared_ext$major'
10896      if test 32 = "$HPUX_IA64_MODE"; then
10897        sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10898 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10899      else
10900        sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10901 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10902      fi
11167 –    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10903      ;;
10904    hppa*64*)
10905      shrext_cmds='.sl'
# Line 11316 | Line 11051 | fi
11051    # before this can be enabled.
11052    hardcode_into_libs=yes
11053  
11054 <  # Append ld.so.conf contents to the search path
11054 >  # Ideally, we could use ldconfig to report *all* directores which are
11055 >  # searched for libraries, however this is still not possible.  Aside from not
11056 >  # being certain /sbin/ldconfig is available, command
11057 >  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11058 >  # even though it is searched at run-time.  Try to do the best guess by
11059 >  # appending ld.so.conf contents (and includes) to the search path.
11060    if test -f /etc/ld.so.conf; then
11061      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' ' '`
11062      sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
# Line 11541 | Line 11281 | fi
11281   if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11282    sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11283   fi
11284 +
11285   if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11286    sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11287   fi
11288  
11289 + # remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11290 + configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11291 +
11292 + # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11293 + func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11294 +
11295 + # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11296 + configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11297 +
11298 +
11299 +
11300 +
11301 +
11302 +
11303  
11304  
11305  
# Line 12325 | Line 12080 | CC=$lt_save_CC
12080  
12081  
12082  
12328 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
12329 – $as_echo_n "checking for ANSI C header files... " >&6; }
12330 – if ${ac_cv_header_stdc+:} false; then :
12331 –  $as_echo_n "(cached) " >&6
12332 – else
12333 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12334 – /* end confdefs.h.  */
12335 – #include <stdlib.h>
12336 – #include <stdarg.h>
12337 – #include <string.h>
12338 – #include <float.h>
12339 –
12340 – int
12341 – main ()
12342 – {
12343 –
12344 –  ;
12345 –  return 0;
12346 – }
12347 – _ACEOF
12348 – if ac_fn_c_try_compile "$LINENO"; then :
12349 –  ac_cv_header_stdc=yes
12350 – else
12351 –  ac_cv_header_stdc=no
12352 – fi
12353 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12354 –
12355 – if test $ac_cv_header_stdc = yes; then
12356 –  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
12357 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12358 – /* end confdefs.h.  */
12359 – #include <string.h>
12360 –
12361 – _ACEOF
12362 – if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12363 –  $EGREP "memchr" >/dev/null 2>&1; then :
12364 –
12365 – else
12366 –  ac_cv_header_stdc=no
12367 – fi
12368 – rm -f conftest*
12369 –
12370 – fi
12371 –
12372 – if test $ac_cv_header_stdc = yes; then
12373 –  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
12374 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12375 – /* end confdefs.h.  */
12376 – #include <stdlib.h>
12377 –
12378 – _ACEOF
12379 – if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12380 –  $EGREP "free" >/dev/null 2>&1; then :
12381 –
12382 – else
12383 –  ac_cv_header_stdc=no
12384 – fi
12385 – rm -f conftest*
12386 –
12387 – fi
12388 –
12389 – if test $ac_cv_header_stdc = yes; then
12390 –  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
12391 –  if test "$cross_compiling" = yes; then :
12392 –  :
12393 – else
12394 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12395 – /* end confdefs.h.  */
12396 – #include <ctype.h>
12397 – #include <stdlib.h>
12398 – #if ((' ' & 0x0FF) == 0x020)
12399 – # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
12400 – # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
12401 – #else
12402 – # define ISLOWER(c) \
12403 –                   (('a' <= (c) && (c) <= 'i') \
12404 –                     || ('j' <= (c) && (c) <= 'r') \
12405 –                     || ('s' <= (c) && (c) <= 'z'))
12406 – # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
12407 – #endif
12408 –
12409 – #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
12410 – int
12411 – main ()
12412 – {
12413 –  int i;
12414 –  for (i = 0; i < 256; i++)
12415 –    if (XOR (islower (i), ISLOWER (i))
12416 –        || toupper (i) != TOUPPER (i))
12417 –      return 2;
12418 –  return 0;
12419 – }
12420 – _ACEOF
12421 – if ac_fn_c_try_run "$LINENO"; then :
12422 –
12423 – else
12424 –  ac_cv_header_stdc=no
12425 – fi
12426 – rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12427 –  conftest.$ac_objext conftest.beam conftest.$ac_ext
12428 – fi
12429 –
12430 – fi
12431 – fi
12432 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
12433 – $as_echo "$ac_cv_header_stdc" >&6; }
12434 – if test $ac_cv_header_stdc = yes; then
12435 –
12436 – $as_echo "#define STDC_HEADERS 1" >>confdefs.h
12437 –
12438 – fi
12439 –
12440 –
12441 – for ac_header in sys/poll.h
12442 – do :
12443 –  ac_fn_c_check_header_mongrel "$LINENO" "sys/poll.h" "ac_cv_header_sys_poll_h" "$ac_includes_default"
12444 – if test "x$ac_cv_header_sys_poll_h" = xyes; then :
12445 –  cat >>confdefs.h <<_ACEOF
12446 – #define HAVE_SYS_POLL_H 1
12447 – _ACEOF
12448 – have_poll_sys_h=yes
12449 – else
12450 –  have_sys_poll_h=no
12451 – fi
12452 –
12453 – done
12454 –
12455 –
12456 – for ac_header in fcntl.h sys/time.h unistd.h strings.h
12457 – do :
12458 –  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
12459 – ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
12460 – if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
12461 –  cat >>confdefs.h <<_ACEOF
12462 – #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
12463 – _ACEOF
12464 –
12465 – fi
12466 –
12467 – done
12468 –
12469 –
12470 – ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
12471 – if test "x$ac_cv_type_size_t" = xyes; then :
12472 –
12473 – else
12474 –
12475 – cat >>confdefs.h <<_ACEOF
12476 – #define size_t unsigned int
12477 – _ACEOF
12478 –
12479 – fi
12480 –
12481 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12482 – $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12483 – if ${ac_cv_header_time+:} false; then :
12484 –  $as_echo_n "(cached) " >&6
12485 – else
12486 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12487 – /* end confdefs.h.  */
12488 – #include <sys/types.h>
12489 – #include <sys/time.h>
12490 – #include <time.h>
12491 –
12492 – int
12493 – main ()
12494 – {
12495 – if ((struct tm *) 0)
12496 – return 0;
12497 –  ;
12498 –  return 0;
12499 – }
12500 – _ACEOF
12501 – if ac_fn_c_try_compile "$LINENO"; then :
12502 –  ac_cv_header_time=yes
12503 – else
12504 –  ac_cv_header_time=no
12505 – fi
12506 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12507 – fi
12508 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12509 – $as_echo "$ac_cv_header_time" >&6; }
12510 – if test $ac_cv_header_time = yes; then
12511 –
12512 – $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
12513 –
12514 – fi
12515 –
12516 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
12517 – $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
12518 – if ${ac_cv_struct_tm+:} false; then :
12519 –  $as_echo_n "(cached) " >&6
12520 – else
12521 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12522 – /* end confdefs.h.  */
12523 – #include <sys/types.h>
12524 – #include <time.h>
12525 –
12526 – int
12527 – main ()
12528 – {
12529 – struct tm tm;
12530 –                                     int *p = &tm.tm_sec;
12531 –                                     return !p;
12532 –  ;
12533 –  return 0;
12534 – }
12535 – _ACEOF
12536 – if ac_fn_c_try_compile "$LINENO"; then :
12537 –  ac_cv_struct_tm=time.h
12538 – else
12539 –  ac_cv_struct_tm=sys/time.h
12540 – fi
12541 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12542 – fi
12543 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
12544 – $as_echo "$ac_cv_struct_tm" >&6; }
12545 – if test $ac_cv_struct_tm = sys/time.h; then
12546 –
12547 – $as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
12548 –
12549 – fi
12550 –
12551 –
12552 –
12083   for ac_prog in 'bison -y' byacc
12084   do
12085    # Extract the first word of "$ac_prog", so it can be a program name with args.
# Line 12757 | Line 12287 | if test "$LEX" = :; then
12287    LEX=${am_missing_run}flex
12288   fi
12289  
12290 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12291 < $as_echo_n "checking for library containing socket... " >&6; }
12292 < if ${ac_cv_search_socket+:} false; then :
12290 >
12291 >
12292 >  if test "X$CC" != "X"; then
12293 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12294 > $as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12295 > if ${ssp_cv_cc+:} false; then :
12296    $as_echo_n "(cached) " >&6
12297   else
12298 <  ac_func_search_save_LIBS=$LIBS
12299 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12298 >  ssp_old_cflags="$CFLAGS"
12299 >       CFLAGS="$CFLAGS -fstack-protector-strong"
12300 >       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12301   /* end confdefs.h.  */
12302  
12769 – /* Override any GCC internal prototype to avoid an error.
12770 –   Use char because int might match the return type of a GCC
12771 –   builtin and then its argument prototype would still apply.  */
12772 – #ifdef __cplusplus
12773 – extern "C"
12774 – #endif
12775 – char socket ();
12303   int
12304   main ()
12305   {
12306 < return socket ();
12306 >
12307    ;
12308    return 0;
12309   }
12310   _ACEOF
12311 < for ac_lib in '' socket; do
12312 <  if test -z "$ac_lib"; then
12313 <    ac_res="none required"
12314 <  else
12788 <    ac_res=-l$ac_lib
12789 <    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12790 <  fi
12791 <  if ac_fn_c_try_link "$LINENO"; then :
12792 <  ac_cv_search_socket=$ac_res
12311 > if ac_fn_c_try_compile "$LINENO"; then :
12312 >  ssp_cv_cc=yes
12313 > else
12314 >  ssp_cv_cc=no
12315   fi
12316 < rm -f core conftest.err conftest.$ac_objext \
12317 <    conftest$ac_exeext
12318 <  if ${ac_cv_search_socket+:} false; then :
12797 <  break
12316 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12317 >       CFLAGS="$ssp_old_cflags"
12318 >
12319   fi
12320 < done
12321 < if ${ac_cv_search_socket+:} false; then :
12320 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12321 > $as_echo "$ssp_cv_cc" >&6; }
12322 >    if test $ssp_cv_cc = yes; then
12323 >      CFLAGS="$CFLAGS -fstack-protector-strong"
12324 >
12325 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12326  
12327 +    else
12328 +      unset ssp_cv_cc
12329 +      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12330 + $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12331 + if ${ssp_cv_cc+:} false; then :
12332 +  $as_echo_n "(cached) " >&6
12333   else
12334 <  ac_cv_search_socket=no
12334 >  ssp_old_cflags="$CFLAGS"
12335 >         CFLAGS="$CFLAGS -fstack-protector"
12336 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12337 > /* end confdefs.h.  */
12338 >
12339 > int
12340 > main ()
12341 > {
12342 >
12343 >  ;
12344 >  return 0;
12345 > }
12346 > _ACEOF
12347 > if ac_fn_c_try_compile "$LINENO"; then :
12348 >  ssp_cv_cc=yes
12349 > else
12350 >  ssp_cv_cc=no
12351   fi
12352 < rm conftest.$ac_ext
12353 < LIBS=$ac_func_search_save_LIBS
12352 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12353 >         CFLAGS="$ssp_old_cflags"
12354 >
12355   fi
12356 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12357 < $as_echo "$ac_cv_search_socket" >&6; }
12358 < ac_res=$ac_cv_search_socket
12359 < if test "$ac_res" != no; then :
12812 <  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12356 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12357 > $as_echo "$ssp_cv_cc" >&6; }
12358 >      if test $ssp_cv_cc = yes; then
12359 >        CFLAGS="$CFLAGS -fstack-protector"
12360  
12361 + $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12362 +
12363 +      fi
12364 +    fi
12365 +  fi
12366 +
12367 +
12368 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12369 + $as_echo_n "checking whether libssp exists... " >&6; }
12370 + if ${ssp_cv_lib+:} false; then :
12371 +  $as_echo_n "(cached) " >&6
12372   else
12373 <  as_fn_error $? "socket library not found" "$LINENO" 5
12373 >  ssp_old_libs="$LIBS"
12374 >     LIBS="$LIBS -lssp"
12375 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12376 > /* end confdefs.h.  */
12377 >
12378 > int
12379 > main ()
12380 > {
12381 >
12382 >  ;
12383 >  return 0;
12384 > }
12385 > _ACEOF
12386 > if ac_fn_c_try_link "$LINENO"; then :
12387 >  ssp_cv_lib=yes
12388 > else
12389 >  ssp_cv_lib=no
12390 > fi
12391 > rm -f core conftest.err conftest.$ac_objext \
12392 >    conftest$ac_exeext conftest.$ac_ext
12393 >     LIBS="$ssp_old_libs"
12394 >
12395   fi
12396 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12397 + $as_echo "$ssp_cv_lib" >&6; }
12398 +  if test $ssp_cv_lib = yes; then
12399 +    LIBS="$LIBS -lssp"
12400 +  fi
12401  
12402 < ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12402 >
12403 >
12404 >  ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12405   if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12406  
12407   else
# Line 12877 | Line 12463 | fi
12463  
12464   fi
12465  
12466 < ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12466 >  ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12467   if test "x$ac_cv_func_getnameinfo" = xyes; then :
12468  
12469   else
# Line 12939 | Line 12525 | fi
12525  
12526   fi
12527  
12528 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12529 + $as_echo_n "checking for library containing socket... " >&6; }
12530 + if ${ac_cv_search_socket+:} false; then :
12531 +  $as_echo_n "(cached) " >&6
12532 + else
12533 +  ac_func_search_save_LIBS=$LIBS
12534 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12535 + /* end confdefs.h.  */
12536  
12537 < for ac_func in strlcpy strlcat inet_aton inet_pton socket strdup strstr
12538 < do :
12539 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12540 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12541 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12537 > /* Override any GCC internal prototype to avoid an error.
12538 >   Use char because int might match the return type of a GCC
12539 >   builtin and then its argument prototype would still apply.  */
12540 > #ifdef __cplusplus
12541 > extern "C"
12542 > #endif
12543 > char socket ();
12544 > int
12545 > main ()
12546 > {
12547 > return socket ();
12548 >  ;
12549 >  return 0;
12550 > }
12551 > _ACEOF
12552 > for ac_lib in '' socket; do
12553 >  if test -z "$ac_lib"; then
12554 >    ac_res="none required"
12555 >  else
12556 >    ac_res=-l$ac_lib
12557 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12558 >  fi
12559 >  if ac_fn_c_try_link "$LINENO"; then :
12560 >  ac_cv_search_socket=$ac_res
12561 > fi
12562 > rm -f core conftest.err conftest.$ac_objext \
12563 >    conftest$ac_exeext
12564 >  if ${ac_cv_search_socket+:} false; then :
12565 >  break
12566 > fi
12567 > done
12568 > if ${ac_cv_search_socket+:} false; then :
12569 >
12570 > else
12571 >  ac_cv_search_socket=no
12572 > fi
12573 > rm conftest.$ac_ext
12574 > LIBS=$ac_func_search_save_LIBS
12575 > fi
12576 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12577 > $as_echo "$ac_cv_search_socket" >&6; }
12578 > ac_res=$ac_cv_search_socket
12579 > if test "$ac_res" != no; then :
12580 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12581 >
12582 > else
12583 >  as_fn_error $? "socket library not found" "$LINENO" 5
12584 > fi
12585 >
12586 >
12587 >
12588 > # Check whether --enable-openssl was given.
12589 > if test "${enable_openssl+set}" = set; then :
12590 >  enableval=$enable_openssl;  cf_enable_openssl=$enableval
12591 > else
12592 >   cf_enable_openssl="auto"
12593 > fi
12594 >
12595 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12596 > $as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12597 > if test "$cf_enable_openssl" != "no"; then
12598 >  cf_openssl_basedir=""
12599 >  if test "$cf_enable_openssl" != "auto" &&
12600 >     test "$cf_enable_openssl" != "yes"; then
12601 >          cf_openssl_basedir="${cf_enable_openssl}"
12602 >  else
12603 >        for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12604 >                /opt /opt/openssl /usr/local/openssl; do
12605 >      if test -f "${dirs}/include/openssl/opensslv.h"; then
12606 >        cf_openssl_basedir="${dirs}"
12607 >        break
12608 >      fi
12609 >    done
12610 >    unset dirs
12611 >  fi
12612 >
12613 >    if test ! -z "$cf_openssl_basedir"; then
12614 >    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12615 >      CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12616 >      LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12617 >    else
12618 >                  cf_openssl_basedir=""
12619 >    fi
12620 >  else
12621 >                            if test -f "/usr/include/openssl/opensslv.h"; then
12622 >      cf_openssl_basedir="/usr"
12623 >    fi
12624 >  fi
12625 >
12626 >      if test ! -z "$cf_openssl_basedir"; then
12627 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12628 > $as_echo "$cf_openssl_basedir" >&6; }
12629 >    cf_enable_openssl="yes"
12630 >  else
12631 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12632 > $as_echo "not found. Please check your path." >&6; }
12633 >    cf_enable_openssl="no"
12634 >  fi
12635 >  unset cf_openssl_basedir
12636 > else
12637 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12638 > $as_echo "disabled" >&6; }
12639 > fi
12640 >
12641 > if test "$cf_enable_openssl" != "no"; then :
12642 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 0.9.8o and above" >&5
12643 > $as_echo_n "checking for LibreSSL or OpenSSL 0.9.8o and above... " >&6; }
12644 >  if test "$cross_compiling" = yes; then :
12645 >  cf_openssl_version_ok=no
12646 > else
12647 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12648 > /* end confdefs.h.  */
12649 >
12650 >
12651 >    #include <openssl/opensslv.h>
12652 >    #include <stdlib.h>
12653 > int
12654 > main ()
12655 > {
12656 > exit(!(OPENSSL_VERSION_NUMBER >= 0x009080ffL));
12657 >  ;
12658 >  return 0;
12659 > }
12660 > _ACEOF
12661 > if ac_fn_c_try_run "$LINENO"; then :
12662 >  cf_openssl_version_ok=yes
12663 > else
12664 >  cf_openssl_version_ok=no
12665 > fi
12666 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12667 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
12668 > fi
12669 >
12670 >
12671 >  if test "$cf_openssl_version_ok" = "yes"; then :
12672 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12673 > $as_echo "found" >&6; }
12674 >
12675 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12676 > $as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12677 > if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12678 >  $as_echo_n "(cached) " >&6
12679 > else
12680 >  ac_check_lib_save_LIBS=$LIBS
12681 > LIBS="-lcrypto  $LIBS"
12682 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12683 > /* end confdefs.h.  */
12684 >
12685 > /* Override any GCC internal prototype to avoid an error.
12686 >   Use char because int might match the return type of a GCC
12687 >   builtin and then its argument prototype would still apply.  */
12688 > #ifdef __cplusplus
12689 > extern "C"
12690 > #endif
12691 > char RSA_free ();
12692 > int
12693 > main ()
12694 > {
12695 > return RSA_free ();
12696 >  ;
12697 >  return 0;
12698 > }
12699 > _ACEOF
12700 > if ac_fn_c_try_link "$LINENO"; then :
12701 >  ac_cv_lib_crypto_RSA_free=yes
12702 > else
12703 >  ac_cv_lib_crypto_RSA_free=no
12704 > fi
12705 > rm -f core conftest.err conftest.$ac_objext \
12706 >    conftest$ac_exeext conftest.$ac_ext
12707 > LIBS=$ac_check_lib_save_LIBS
12708 > fi
12709 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12710 > $as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12711 > if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12712    cat >>confdefs.h <<_ACEOF
12713 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12713 > #define HAVE_LIBCRYPTO 1
12714   _ACEOF
12715  
12716 +  LIBS="-lcrypto $LIBS"
12717 +
12718   fi
12953 – done
12719  
12720 +    if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12721 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12722 + $as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12723 + if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12724 +  $as_echo_n "(cached) " >&6
12725 + else
12726 +  ac_check_lib_save_LIBS=$LIBS
12727 + LIBS="-lssl  $LIBS"
12728 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12729 + /* end confdefs.h.  */
12730  
12731 < for ac_func in gethostbyname
12732 < do :
12733 <  ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
12734 < if test "x$ac_cv_func_gethostbyname" = xyes; then :
12731 > /* Override any GCC internal prototype to avoid an error.
12732 >   Use char because int might match the return type of a GCC
12733 >   builtin and then its argument prototype would still apply.  */
12734 > #ifdef __cplusplus
12735 > extern "C"
12736 > #endif
12737 > char SSL_connect ();
12738 > int
12739 > main ()
12740 > {
12741 > return SSL_connect ();
12742 >  ;
12743 >  return 0;
12744 > }
12745 > _ACEOF
12746 > if ac_fn_c_try_link "$LINENO"; then :
12747 >  ac_cv_lib_ssl_SSL_connect=yes
12748 > else
12749 >  ac_cv_lib_ssl_SSL_connect=no
12750 > fi
12751 > rm -f core conftest.err conftest.$ac_objext \
12752 >    conftest$ac_exeext conftest.$ac_ext
12753 > LIBS=$ac_check_lib_save_LIBS
12754 > fi
12755 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12756 > $as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12757 > if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12758    cat >>confdefs.h <<_ACEOF
12759 < #define HAVE_GETHOSTBYNAME 1
12759 > #define HAVE_LIBSSL 1
12760 > _ACEOF
12761 >
12762 >  LIBS="-lssl $LIBS"
12763 >
12764 > fi
12765 >
12766 > fi
12767 >
12768 > else
12769 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12770 > $as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12771 >    cf_enable_openssl="no"
12772 > fi
12773 > fi
12774 >
12775 > if test "$ac_cv_lib_ssl_SSL_connect" = yes; then
12776 >  ENABLE_SSL_TRUE=
12777 >  ENABLE_SSL_FALSE='#'
12778 > else
12779 >  ENABLE_SSL_TRUE='#'
12780 >  ENABLE_SSL_FALSE=
12781 > fi
12782 >
12783 >
12784 >
12785 >  # Check whether --enable-assert was given.
12786 > if test "${enable_assert+set}" = set; then :
12787 >  enableval=$enable_assert; assert=$enableval
12788 > else
12789 >  assert=no
12790 > fi
12791 >
12792 >
12793 >  if test "$assert" = "no"; then :
12794 >
12795 > $as_echo "#define NDEBUG 1" >>confdefs.h
12796 >
12797 > fi
12798 >
12799 >
12800 >  # Check whether --enable-warnings was given.
12801 > if test "${enable_warnings+set}" = set; then :
12802 >  enableval=$enable_warnings; warnings="$enableval"
12803 > else
12804 >  warnings="no"
12805 > fi
12806 >
12807 >
12808 >  if test "$warnings" = "yes"; then :
12809 >
12810 >
12811 >
12812 >
12813 >
12814 > for flag in -Wall; do
12815 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12816 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12817 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12818 > if eval \${$as_CACHEVAR+:} false; then :
12819 >  $as_echo_n "(cached) " >&6
12820 > else
12821 >
12822 >  ax_check_save_flags=$CFLAGS
12823 >  CFLAGS="$CFLAGS  $flag"
12824 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12825 > /* end confdefs.h.  */
12826 >
12827 > int
12828 > main ()
12829 > {
12830 >
12831 >  ;
12832 >  return 0;
12833 > }
12834   _ACEOF
12835 + if ac_fn_c_try_compile "$LINENO"; then :
12836 +  eval "$as_CACHEVAR=yes"
12837 + else
12838 +  eval "$as_CACHEVAR=no"
12839 + fi
12840 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12841 +  CFLAGS=$ax_check_save_flags
12842 + fi
12843 + eval ac_res=\$$as_CACHEVAR
12844 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12845 + $as_echo "$ac_res" >&6; }
12846 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12847 +
12848 + if ${CFLAGS+:} false; then :
12849 +
12850 +  case " $CFLAGS " in #(
12851 +  *" $flag "*) :
12852 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12853 +  (: CFLAGS already contains $flag) 2>&5
12854 +  ac_status=$?
12855 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12856 +  test $ac_status = 0; } ;; #(
12857 +  *) :
12858  
12859 +     as_fn_append 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 + esac
12867 +
12868 + else
12869 +
12870 +  CFLAGS=$flag
12871 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12872 +  (: CFLAGS="$CFLAGS") 2>&5
12873 +  ac_status=$?
12874 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12875 +  test $ac_status = 0; }
12876 +
12877 + fi
12878 +
12879 + else
12880 +  :
12881   fi
12882 +
12883   done
12884  
12885  
12886 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
12887 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
12888 < if ${ac_cv_c_bigendian+:} false; then :
12886 >
12887 >
12888 >
12889 > for flag in -Wbad-function-cast; do
12890 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12891 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12892 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12893 > if eval \${$as_CACHEVAR+:} false; then :
12894    $as_echo_n "(cached) " >&6
12895   else
12896 <  ac_cv_c_bigendian=unknown
12897 <    # See if we're dealing with a universal compiler.
12898 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12896 >
12897 >  ax_check_save_flags=$CFLAGS
12898 >  CFLAGS="$CFLAGS  $flag"
12899 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12900   /* end confdefs.h.  */
12977 – #ifndef __APPLE_CC__
12978 –               not a universal capable compiler
12979 –             #endif
12980 –             typedef int dummy;
12901  
12902 + int
12903 + main ()
12904 + {
12905 +
12906 +  ;
12907 +  return 0;
12908 + }
12909   _ACEOF
12910   if ac_fn_c_try_compile "$LINENO"; then :
12911 +  eval "$as_CACHEVAR=yes"
12912 + else
12913 +  eval "$as_CACHEVAR=no"
12914 + fi
12915 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12916 +  CFLAGS=$ax_check_save_flags
12917 + fi
12918 + eval ac_res=\$$as_CACHEVAR
12919 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12920 + $as_echo "$ac_res" >&6; }
12921 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12922  
12923 <        # Check for potential -arch flags.  It is not universal unless
12924 <        # there are at least two -arch flags with different values.
12925 <        ac_arch=
12926 <        ac_prev=
12927 <        for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12928 <         if test -n "$ac_prev"; then
12929 <           case $ac_word in
12930 <             i?86 | x86_64 | ppc | ppc64)
12931 <               if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12932 <                 ac_arch=$ac_word
12933 <               else
12934 <                 ac_cv_c_bigendian=universal
12935 <                 break
12936 <               fi
12937 <               ;;
12938 <           esac
12939 <           ac_prev=
12940 <         elif test "x$ac_word" = "x-arch"; then
12941 <           ac_prev=arch
12942 <         fi
12943 <       done
12923 > if ${CFLAGS+:} false; then :
12924 >
12925 >  case " $CFLAGS " in #(
12926 >  *" $flag "*) :
12927 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12928 >  (: CFLAGS already contains $flag) 2>&5
12929 >  ac_status=$?
12930 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12931 >  test $ac_status = 0; } ;; #(
12932 >  *) :
12933 >
12934 >     as_fn_append 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 > esac
12942 >
12943 > else
12944 >
12945 >  CFLAGS=$flag
12946 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12947 >  (: CFLAGS="$CFLAGS") 2>&5
12948 >  ac_status=$?
12949 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12950 >  test $ac_status = 0; }
12951 >
12952 > fi
12953 >
12954 > else
12955 >  :
12956 > fi
12957 >
12958 > done
12959 >
12960 >
12961 >
12962 >
12963 >
12964 > for flag in -Wcast-align; do
12965 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12966 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12967 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12968 > if eval \${$as_CACHEVAR+:} false; then :
12969 >  $as_echo_n "(cached) " >&6
12970 > else
12971 >
12972 >  ax_check_save_flags=$CFLAGS
12973 >  CFLAGS="$CFLAGS  $flag"
12974 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12975 > /* end confdefs.h.  */
12976 >
12977 > int
12978 > main ()
12979 > {
12980 >
12981 >  ;
12982 >  return 0;
12983 > }
12984 > _ACEOF
12985 > if ac_fn_c_try_compile "$LINENO"; then :
12986 >  eval "$as_CACHEVAR=yes"
12987 > else
12988 >  eval "$as_CACHEVAR=no"
12989   fi
12990   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12991 <    if test $ac_cv_c_bigendian = unknown; then
12992 <      # See if sys/param.h defines the BYTE_ORDER macro.
12993 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12991 >  CFLAGS=$ax_check_save_flags
12992 > fi
12993 > eval ac_res=\$$as_CACHEVAR
12994 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12995 > $as_echo "$ac_res" >&6; }
12996 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12997 >
12998 > if ${CFLAGS+:} false; then :
12999 >
13000 >  case " $CFLAGS " in #(
13001 >  *" $flag "*) :
13002 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13003 >  (: CFLAGS already contains $flag) 2>&5
13004 >  ac_status=$?
13005 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13006 >  test $ac_status = 0; } ;; #(
13007 >  *) :
13008 >
13009 >     as_fn_append 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 > esac
13017 >
13018 > else
13019 >
13020 >  CFLAGS=$flag
13021 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13022 >  (: CFLAGS="$CFLAGS") 2>&5
13023 >  ac_status=$?
13024 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13025 >  test $ac_status = 0; }
13026 >
13027 > fi
13028 >
13029 > else
13030 >  :
13031 > fi
13032 >
13033 > done
13034 >
13035 >
13036 >
13037 >
13038 >
13039 > for flag in -Wcast-qual; do
13040 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13041 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13042 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13043 > if eval \${$as_CACHEVAR+:} false; then :
13044 >  $as_echo_n "(cached) " >&6
13045 > else
13046 >
13047 >  ax_check_save_flags=$CFLAGS
13048 >  CFLAGS="$CFLAGS  $flag"
13049 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13050   /* end confdefs.h.  */
13012 – #include <sys/types.h>
13013 –             #include <sys/param.h>
13051  
13052   int
13053   main ()
13054   {
13018 – #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
13019 –                     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
13020 –                     && LITTLE_ENDIAN)
13021 –              bogus endian macros
13022 –             #endif
13055  
13056    ;
13057    return 0;
13058   }
13059   _ACEOF
13060   if ac_fn_c_try_compile "$LINENO"; then :
13061 <  # It does; now see whether it defined to BIG_ENDIAN or not.
13062 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13061 >  eval "$as_CACHEVAR=yes"
13062 > else
13063 >  eval "$as_CACHEVAR=no"
13064 > fi
13065 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13066 >  CFLAGS=$ax_check_save_flags
13067 > fi
13068 > eval ac_res=\$$as_CACHEVAR
13069 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13070 > $as_echo "$ac_res" >&6; }
13071 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13072 >
13073 > if ${CFLAGS+:} false; then :
13074 >
13075 >  case " $CFLAGS " in #(
13076 >  *" $flag "*) :
13077 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13078 >  (: CFLAGS already contains $flag) 2>&5
13079 >  ac_status=$?
13080 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13081 >  test $ac_status = 0; } ;; #(
13082 >  *) :
13083 >
13084 >     as_fn_append 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 > esac
13092 >
13093 > else
13094 >
13095 >  CFLAGS=$flag
13096 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13097 >  (: CFLAGS="$CFLAGS") 2>&5
13098 >  ac_status=$?
13099 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13100 >  test $ac_status = 0; }
13101 >
13102 > fi
13103 >
13104 > else
13105 >  :
13106 > fi
13107 >
13108 > done
13109 >
13110 >
13111 >
13112 >
13113 >
13114 > for flag in -Wclobbered; do
13115 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13116 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13117 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13118 > if eval \${$as_CACHEVAR+:} false; then :
13119 >  $as_echo_n "(cached) " >&6
13120 > else
13121 >
13122 >  ax_check_save_flags=$CFLAGS
13123 >  CFLAGS="$CFLAGS  $flag"
13124 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13125   /* end confdefs.h.  */
13032 – #include <sys/types.h>
13033 –                #include <sys/param.h>
13126  
13127   int
13128   main ()
13129   {
13038 – #if BYTE_ORDER != BIG_ENDIAN
13039 –                 not big endian
13040 –                #endif
13130  
13131    ;
13132    return 0;
13133   }
13134   _ACEOF
13135   if ac_fn_c_try_compile "$LINENO"; then :
13136 <  ac_cv_c_bigendian=yes
13136 >  eval "$as_CACHEVAR=yes"
13137   else
13138 <  ac_cv_c_bigendian=no
13138 >  eval "$as_CACHEVAR=no"
13139   fi
13140   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13141 +  CFLAGS=$ax_check_save_flags
13142 + fi
13143 + eval ac_res=\$$as_CACHEVAR
13144 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13145 + $as_echo "$ac_res" >&6; }
13146 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13147 +
13148 + if ${CFLAGS+:} false; then :
13149 +
13150 +  case " $CFLAGS " in #(
13151 +  *" $flag "*) :
13152 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13153 +  (: CFLAGS already contains $flag) 2>&5
13154 +  ac_status=$?
13155 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13156 +  test $ac_status = 0; } ;; #(
13157 +  *) :
13158 +
13159 +     as_fn_append CFLAGS " $flag"
13160 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13161 +  (: CFLAGS="$CFLAGS") 2>&5
13162 +  ac_status=$?
13163 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13164 +  test $ac_status = 0; }
13165 +     ;;
13166 + esac
13167 +
13168 + else
13169 +
13170 +  CFLAGS=$flag
13171 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13172 +  (: CFLAGS="$CFLAGS") 2>&5
13173 +  ac_status=$?
13174 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13175 +  test $ac_status = 0; }
13176 +
13177 + fi
13178 +
13179 + else
13180 +  :
13181 + fi
13182 +
13183 + done
13184 +
13185 +
13186 +
13187 +
13188 +
13189 + for flag in -Wduplicated-cond; do
13190 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13191 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13192 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13193 + if eval \${$as_CACHEVAR+:} false; then :
13194 +  $as_echo_n "(cached) " >&6
13195 + else
13196 +
13197 +  ax_check_save_flags=$CFLAGS
13198 +  CFLAGS="$CFLAGS  $flag"
13199 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13200 + /* end confdefs.h.  */
13201 +
13202 + int
13203 + main ()
13204 + {
13205 +
13206 +  ;
13207 +  return 0;
13208 + }
13209 + _ACEOF
13210 + if ac_fn_c_try_compile "$LINENO"; then :
13211 +  eval "$as_CACHEVAR=yes"
13212 + else
13213 +  eval "$as_CACHEVAR=no"
13214   fi
13215   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13216 <    fi
13217 <    if test $ac_cv_c_bigendian = unknown; then
13218 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13219 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13216 >  CFLAGS=$ax_check_save_flags
13217 > fi
13218 > eval ac_res=\$$as_CACHEVAR
13219 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13220 > $as_echo "$ac_res" >&6; }
13221 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13222 >
13223 > if ${CFLAGS+:} false; then :
13224 >
13225 >  case " $CFLAGS " in #(
13226 >  *" $flag "*) :
13227 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13228 >  (: CFLAGS already contains $flag) 2>&5
13229 >  ac_status=$?
13230 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13231 >  test $ac_status = 0; } ;; #(
13232 >  *) :
13233 >
13234 >     as_fn_append 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 > esac
13242 >
13243 > else
13244 >
13245 >  CFLAGS=$flag
13246 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13247 >  (: CFLAGS="$CFLAGS") 2>&5
13248 >  ac_status=$?
13249 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13250 >  test $ac_status = 0; }
13251 >
13252 > fi
13253 >
13254 > else
13255 >  :
13256 > fi
13257 >
13258 > done
13259 >
13260 >
13261 >
13262 >
13263 >
13264 > for flag in -Wempty-body; do
13265 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13266 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13267 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13268 > if eval \${$as_CACHEVAR+:} false; then :
13269 >  $as_echo_n "(cached) " >&6
13270 > else
13271 >
13272 >  ax_check_save_flags=$CFLAGS
13273 >  CFLAGS="$CFLAGS  $flag"
13274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13275   /* end confdefs.h.  */
13059 – #include <limits.h>
13276  
13277   int
13278   main ()
13279   {
13064 – #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
13065 –              bogus endian macros
13066 –             #endif
13280  
13281    ;
13282    return 0;
13283   }
13284   _ACEOF
13285   if ac_fn_c_try_compile "$LINENO"; then :
13286 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
13287 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13286 >  eval "$as_CACHEVAR=yes"
13287 > else
13288 >  eval "$as_CACHEVAR=no"
13289 > fi
13290 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13291 >  CFLAGS=$ax_check_save_flags
13292 > fi
13293 > eval ac_res=\$$as_CACHEVAR
13294 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13295 > $as_echo "$ac_res" >&6; }
13296 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13297 >
13298 > if ${CFLAGS+:} false; then :
13299 >
13300 >  case " $CFLAGS " in #(
13301 >  *" $flag "*) :
13302 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13303 >  (: CFLAGS already contains $flag) 2>&5
13304 >  ac_status=$?
13305 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13306 >  test $ac_status = 0; } ;; #(
13307 >  *) :
13308 >
13309 >     as_fn_append 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 > esac
13317 >
13318 > else
13319 >
13320 >  CFLAGS=$flag
13321 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13322 >  (: CFLAGS="$CFLAGS") 2>&5
13323 >  ac_status=$?
13324 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13325 >  test $ac_status = 0; }
13326 >
13327 > fi
13328 >
13329 > else
13330 >  :
13331 > fi
13332 >
13333 > done
13334 >
13335 >
13336 >
13337 >
13338 >
13339 > for flag in -Wignored-qualifiers; do
13340 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13341 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13342 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13343 > if eval \${$as_CACHEVAR+:} false; then :
13344 >  $as_echo_n "(cached) " >&6
13345 > else
13346 >
13347 >  ax_check_save_flags=$CFLAGS
13348 >  CFLAGS="$CFLAGS  $flag"
13349 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13350   /* end confdefs.h.  */
13076 – #include <limits.h>
13351  
13352   int
13353   main ()
13354   {
13081 – #ifndef _BIG_ENDIAN
13082 –                 not big endian
13083 –                #endif
13355  
13356    ;
13357    return 0;
13358   }
13359   _ACEOF
13360   if ac_fn_c_try_compile "$LINENO"; then :
13361 <  ac_cv_c_bigendian=yes
13361 >  eval "$as_CACHEVAR=yes"
13362   else
13363 <  ac_cv_c_bigendian=no
13363 >  eval "$as_CACHEVAR=no"
13364   fi
13365   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13366 +  CFLAGS=$ax_check_save_flags
13367 + fi
13368 + eval ac_res=\$$as_CACHEVAR
13369 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13370 + $as_echo "$ac_res" >&6; }
13371 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13372 +
13373 + if ${CFLAGS+:} false; then :
13374 +
13375 +  case " $CFLAGS " in #(
13376 +  *" $flag "*) :
13377 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13378 +  (: CFLAGS already contains $flag) 2>&5
13379 +  ac_status=$?
13380 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13381 +  test $ac_status = 0; } ;; #(
13382 +  *) :
13383 +
13384 +     as_fn_append 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 + esac
13392 +
13393 + else
13394 +
13395 +  CFLAGS=$flag
13396 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13397 +  (: CFLAGS="$CFLAGS") 2>&5
13398 +  ac_status=$?
13399 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13400 +  test $ac_status = 0; }
13401 +
13402 + fi
13403 +
13404 + else
13405 +  :
13406 + fi
13407 +
13408 + done
13409 +
13410 +
13411 +
13412 +
13413 +
13414 + for flag in -Wlogical-op; do
13415 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13416 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13417 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13418 + if eval \${$as_CACHEVAR+:} false; then :
13419 +  $as_echo_n "(cached) " >&6
13420 + else
13421 +
13422 +  ax_check_save_flags=$CFLAGS
13423 +  CFLAGS="$CFLAGS  $flag"
13424 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13425 + /* end confdefs.h.  */
13426 +
13427 + int
13428 + main ()
13429 + {
13430 +
13431 +  ;
13432 +  return 0;
13433 + }
13434 + _ACEOF
13435 + if ac_fn_c_try_compile "$LINENO"; then :
13436 +  eval "$as_CACHEVAR=yes"
13437 + else
13438 +  eval "$as_CACHEVAR=no"
13439   fi
13440   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13441 <    fi
13442 <    if test $ac_cv_c_bigendian = unknown; then
13443 <      # Compile a test program.
13444 <      if test "$cross_compiling" = yes; then :
13445 <  # Try to guess by grepping values from an object file.
13446 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13441 >  CFLAGS=$ax_check_save_flags
13442 > fi
13443 > eval ac_res=\$$as_CACHEVAR
13444 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13445 > $as_echo "$ac_res" >&6; }
13446 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13447 >
13448 > if ${CFLAGS+:} false; then :
13449 >
13450 >  case " $CFLAGS " in #(
13451 >  *" $flag "*) :
13452 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13453 >  (: CFLAGS already contains $flag) 2>&5
13454 >  ac_status=$?
13455 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13456 >  test $ac_status = 0; } ;; #(
13457 >  *) :
13458 >
13459 >     as_fn_append 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 > esac
13467 >
13468 > else
13469 >
13470 >  CFLAGS=$flag
13471 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13472 >  (: CFLAGS="$CFLAGS") 2>&5
13473 >  ac_status=$?
13474 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13475 >  test $ac_status = 0; }
13476 >
13477 > fi
13478 >
13479 > else
13480 >  :
13481 > fi
13482 >
13483 > done
13484 >
13485 >
13486 >
13487 >
13488 >
13489 > for flag in -Wmissing-declarations; do
13490 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13491 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13492 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13493 > if eval \${$as_CACHEVAR+:} false; then :
13494 >  $as_echo_n "(cached) " >&6
13495 > else
13496 >
13497 >  ax_check_save_flags=$CFLAGS
13498 >  CFLAGS="$CFLAGS  $flag"
13499 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13500   /* end confdefs.h.  */
13104 – short int ascii_mm[] =
13105 –                  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
13106 –                short int ascii_ii[] =
13107 –                  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
13108 –                int use_ascii (int i) {
13109 –                  return ascii_mm[i] + ascii_ii[i];
13110 –                }
13111 –                short int ebcdic_ii[] =
13112 –                  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
13113 –                short int ebcdic_mm[] =
13114 –                  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
13115 –                int use_ebcdic (int i) {
13116 –                  return ebcdic_mm[i] + ebcdic_ii[i];
13117 –                }
13118 –                extern int foo;
13501  
13502   int
13503   main ()
13504   {
13505 < return use_ascii (foo) == use_ebcdic (foo);
13505 >
13506    ;
13507    return 0;
13508   }
13509   _ACEOF
13510   if ac_fn_c_try_compile "$LINENO"; then :
13511 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
13512 <              ac_cv_c_bigendian=yes
13513 <            fi
13132 <            if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
13133 <              if test "$ac_cv_c_bigendian" = unknown; then
13134 <                ac_cv_c_bigendian=no
13135 <              else
13136 <                # finding both strings is unlikely to happen, but who knows?
13137 <                ac_cv_c_bigendian=unknown
13138 <              fi
13139 <            fi
13511 >  eval "$as_CACHEVAR=yes"
13512 > else
13513 >  eval "$as_CACHEVAR=no"
13514   fi
13515   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13516 +  CFLAGS=$ax_check_save_flags
13517 + fi
13518 + eval ac_res=\$$as_CACHEVAR
13519 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13520 + $as_echo "$ac_res" >&6; }
13521 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13522 +
13523 + if ${CFLAGS+:} false; then :
13524 +
13525 +  case " $CFLAGS " in #(
13526 +  *" $flag "*) :
13527 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13528 +  (: CFLAGS already contains $flag) 2>&5
13529 +  ac_status=$?
13530 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13531 +  test $ac_status = 0; } ;; #(
13532 +  *) :
13533 +
13534 +     as_fn_append CFLAGS " $flag"
13535 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13536 +  (: CFLAGS="$CFLAGS") 2>&5
13537 +  ac_status=$?
13538 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13539 +  test $ac_status = 0; }
13540 +     ;;
13541 + esac
13542 +
13543 + else
13544 +
13545 +  CFLAGS=$flag
13546 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13547 +  (: CFLAGS="$CFLAGS") 2>&5
13548 +  ac_status=$?
13549 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13550 +  test $ac_status = 0; }
13551 +
13552 + fi
13553 +
13554   else
13555 +  :
13556 + fi
13557 +
13558 + done
13559 +
13560 +
13561 +
13562 +
13563 +
13564 + for flag in -Wmissing-field-initializers; do
13565 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13566 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13567 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13568 + if eval \${$as_CACHEVAR+:} false; then :
13569 +  $as_echo_n "(cached) " >&6
13570 + else
13571 +
13572 +  ax_check_save_flags=$CFLAGS
13573 +  CFLAGS="$CFLAGS  $flag"
13574    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13575   /* end confdefs.h.  */
13576 < $ac_includes_default
13576 >
13577   int
13578   main ()
13579   {
13580  
13581 <             /* Are we little or big endian?  From Harbison&Steele.  */
13582 <             union
13583 <             {
13584 <               long int l;
13585 <               char c[sizeof (long int)];
13586 <             } u;
13587 <             u.l = 1;
13588 <             return u.c[sizeof (long int) - 1] == 1;
13581 >  ;
13582 >  return 0;
13583 > }
13584 > _ACEOF
13585 > if ac_fn_c_try_compile "$LINENO"; then :
13586 >  eval "$as_CACHEVAR=yes"
13587 > else
13588 >  eval "$as_CACHEVAR=no"
13589 > fi
13590 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13591 >  CFLAGS=$ax_check_save_flags
13592 > fi
13593 > eval ac_res=\$$as_CACHEVAR
13594 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13595 > $as_echo "$ac_res" >&6; }
13596 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13597 >
13598 > if ${CFLAGS+:} false; then :
13599 >
13600 >  case " $CFLAGS " in #(
13601 >  *" $flag "*) :
13602 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13603 >  (: CFLAGS already contains $flag) 2>&5
13604 >  ac_status=$?
13605 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13606 >  test $ac_status = 0; } ;; #(
13607 >  *) :
13608 >
13609 >     as_fn_append 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 > esac
13617 >
13618 > else
13619 >
13620 >  CFLAGS=$flag
13621 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13622 >  (: CFLAGS="$CFLAGS") 2>&5
13623 >  ac_status=$?
13624 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13625 >  test $ac_status = 0; }
13626 >
13627 > fi
13628 >
13629 > else
13630 >  :
13631 > fi
13632 >
13633 > done
13634 >
13635 >
13636 >
13637 >
13638 >
13639 > for flag in -Wmissing-include-dirs; do
13640 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13641 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13642 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13643 > if eval \${$as_CACHEVAR+:} false; then :
13644 >  $as_echo_n "(cached) " >&6
13645 > else
13646 >
13647 >  ax_check_save_flags=$CFLAGS
13648 >  CFLAGS="$CFLAGS  $flag"
13649 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13650 > /* end confdefs.h.  */
13651 >
13652 > int
13653 > main ()
13654 > {
13655  
13656    ;
13657    return 0;
13658   }
13659   _ACEOF
13660 < if ac_fn_c_try_run "$LINENO"; then :
13661 <  ac_cv_c_bigendian=no
13660 > if ac_fn_c_try_compile "$LINENO"; then :
13661 >  eval "$as_CACHEVAR=yes"
13662   else
13663 <  ac_cv_c_bigendian=yes
13663 >  eval "$as_CACHEVAR=no"
13664   fi
13665 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
13666 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
13665 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13666 >  CFLAGS=$ax_check_save_flags
13667   fi
13668 + eval ac_res=\$$as_CACHEVAR
13669 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13670 + $as_echo "$ac_res" >&6; }
13671 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13672 +
13673 + if ${CFLAGS+:} false; then :
13674 +
13675 +  case " $CFLAGS " in #(
13676 +  *" $flag "*) :
13677 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13678 +  (: CFLAGS already contains $flag) 2>&5
13679 +  ac_status=$?
13680 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13681 +  test $ac_status = 0; } ;; #(
13682 +  *) :
13683 +
13684 +     as_fn_append 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 + esac
13692 +
13693 + else
13694 +
13695 +  CFLAGS=$flag
13696 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13697 +  (: CFLAGS="$CFLAGS") 2>&5
13698 +  ac_status=$?
13699 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13700 +  test $ac_status = 0; }
13701  
13172 –    fi
13702   fi
13174 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
13175 – $as_echo "$ac_cv_c_bigendian" >&6; }
13176 – case $ac_cv_c_bigendian in #(
13177 –   yes)
13178 –     $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
13179 – ;; #(
13180 –   no)
13181 –      ;; #(
13182 –   universal)
13703  
13704 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13704 > else
13705 >  :
13706 > fi
13707 >
13708 > done
13709 >
13710  
13186 –     ;; #(
13187 –   *)
13188 –     as_fn_error $? "unknown endianness
13189 – presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
13190 – esac
13711  
13712  
13713 < # The cast to long int works around a bug in the HP C Compiler
13714 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13715 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13716 < # This bug is HP SR number 8606223364.
13717 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int" >&5
13718 < $as_echo_n "checking size of int... " >&6; }
13199 < if ${ac_cv_sizeof_int+:} false; then :
13713 >
13714 > for flag in -Wmissing-parameter-type; do
13715 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13716 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13717 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13718 > if eval \${$as_CACHEVAR+:} false; then :
13719    $as_echo_n "(cached) " >&6
13720   else
13721 <  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (int))" "ac_cv_sizeof_int"        "$ac_includes_default"; then :
13721 >
13722 >  ax_check_save_flags=$CFLAGS
13723 >  CFLAGS="$CFLAGS  $flag"
13724 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13725 > /* end confdefs.h.  */
13726 >
13727 > int
13728 > main ()
13729 > {
13730 >
13731 >  ;
13732 >  return 0;
13733 > }
13734 > _ACEOF
13735 > if ac_fn_c_try_compile "$LINENO"; then :
13736 >  eval "$as_CACHEVAR=yes"
13737 > else
13738 >  eval "$as_CACHEVAR=no"
13739 > fi
13740 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13741 >  CFLAGS=$ax_check_save_flags
13742 > fi
13743 > eval ac_res=\$$as_CACHEVAR
13744 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13745 > $as_echo "$ac_res" >&6; }
13746 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13747 >
13748 > if ${CFLAGS+:} false; then :
13749 >
13750 >  case " $CFLAGS " in #(
13751 >  *" $flag "*) :
13752 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13753 >  (: CFLAGS already contains $flag) 2>&5
13754 >  ac_status=$?
13755 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13756 >  test $ac_status = 0; } ;; #(
13757 >  *) :
13758 >
13759 >     as_fn_append 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 > esac
13767  
13768   else
13769 <  if test "$ac_cv_type_int" = yes; then
13770 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13771 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13772 < as_fn_error 77 "cannot compute sizeof (int)
13773 < See \`config.log' for more details" "$LINENO" 5; }
13774 <   else
13775 <     ac_cv_sizeof_int=0
13776 <   fi
13769 >
13770 >  CFLAGS=$flag
13771 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13772 >  (: CFLAGS="$CFLAGS") 2>&5
13773 >  ac_status=$?
13774 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13775 >  test $ac_status = 0; }
13776 >
13777   fi
13778  
13779 + else
13780 +  :
13781   fi
13782 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int" >&5
13783 < $as_echo "$ac_cv_sizeof_int" >&6; }
13782 >
13783 > done
13784  
13785  
13786  
13787 < cat >>confdefs.h <<_ACEOF
13788 < #define SIZEOF_INT $ac_cv_sizeof_int
13787 >
13788 >
13789 > for flag in -Wmissing-prototypes; do
13790 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13791 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13792 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13793 > if eval \${$as_CACHEVAR+:} false; then :
13794 >  $as_echo_n "(cached) " >&6
13795 > else
13796 >
13797 >  ax_check_save_flags=$CFLAGS
13798 >  CFLAGS="$CFLAGS  $flag"
13799 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13800 > /* end confdefs.h.  */
13801 >
13802 > int
13803 > main ()
13804 > {
13805 >
13806 >  ;
13807 >  return 0;
13808 > }
13809 > _ACEOF
13810 > if ac_fn_c_try_compile "$LINENO"; then :
13811 >  eval "$as_CACHEVAR=yes"
13812 > else
13813 >  eval "$as_CACHEVAR=no"
13814 > fi
13815 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13816 >  CFLAGS=$ax_check_save_flags
13817 > fi
13818 > eval ac_res=\$$as_CACHEVAR
13819 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13820 > $as_echo "$ac_res" >&6; }
13821 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13822 >
13823 > if ${CFLAGS+:} false; then :
13824 >
13825 >  case " $CFLAGS " in #(
13826 >  *" $flag "*) :
13827 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13828 >  (: CFLAGS already contains $flag) 2>&5
13829 >  ac_status=$?
13830 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13831 >  test $ac_status = 0; } ;; #(
13832 >  *) :
13833 >
13834 >     as_fn_append 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 > esac
13842 >
13843 > else
13844 >
13845 >  CFLAGS=$flag
13846 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13847 >  (: CFLAGS="$CFLAGS") 2>&5
13848 >  ac_status=$?
13849 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13850 >  test $ac_status = 0; }
13851 >
13852 > fi
13853 >
13854 > else
13855 >  :
13856 > fi
13857 >
13858 > done
13859 >
13860 >
13861 >
13862 >
13863 >
13864 > for flag in -Wnested-externs; do
13865 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13866 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13867 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13868 > if eval \${$as_CACHEVAR+:} false; then :
13869 >  $as_echo_n "(cached) " >&6
13870 > else
13871 >
13872 >  ax_check_save_flags=$CFLAGS
13873 >  CFLAGS="$CFLAGS  $flag"
13874 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13875 > /* end confdefs.h.  */
13876 >
13877 > int
13878 > main ()
13879 > {
13880 >
13881 >  ;
13882 >  return 0;
13883 > }
13884   _ACEOF
13885 + if ac_fn_c_try_compile "$LINENO"; then :
13886 +  eval "$as_CACHEVAR=yes"
13887 + else
13888 +  eval "$as_CACHEVAR=no"
13889 + fi
13890 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13891 +  CFLAGS=$ax_check_save_flags
13892 + fi
13893 + eval ac_res=\$$as_CACHEVAR
13894 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13895 + $as_echo "$ac_res" >&6; }
13896 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13897 +
13898 + if ${CFLAGS+:} false; then :
13899 +
13900 +  case " $CFLAGS " in #(
13901 +  *" $flag "*) :
13902 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13903 +  (: CFLAGS already contains $flag) 2>&5
13904 +  ac_status=$?
13905 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13906 +  test $ac_status = 0; } ;; #(
13907 +  *) :
13908 +
13909 +     as_fn_append 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 + esac
13917 +
13918 + else
13919 +
13920 +  CFLAGS=$flag
13921 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13922 +  (: CFLAGS="$CFLAGS") 2>&5
13923 +  ac_status=$?
13924 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13925 +  test $ac_status = 0; }
13926 +
13927 + fi
13928 +
13929 + else
13930 +  :
13931 + fi
13932 +
13933 + done
13934  
13935  
13936 < # The cast to long int works around a bug in the HP C Compiler
13937 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
13938 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
13939 < # This bug is HP SR number 8606223364.
13940 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of short" >&5
13941 < $as_echo_n "checking size of short... " >&6; }
13942 < if ${ac_cv_sizeof_short+:} false; then :
13936 >
13937 >
13938 >
13939 > for flag in -Wold-style-declaration; do
13940 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13941 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13942 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13943 > if eval \${$as_CACHEVAR+:} false; then :
13944    $as_echo_n "(cached) " >&6
13945   else
13235 –  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (short))" "ac_cv_sizeof_short"        "$ac_includes_default"; then :
13946  
13947 +  ax_check_save_flags=$CFLAGS
13948 +  CFLAGS="$CFLAGS  $flag"
13949 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13950 + /* end confdefs.h.  */
13951 +
13952 + int
13953 + main ()
13954 + {
13955 +
13956 +  ;
13957 +  return 0;
13958 + }
13959 + _ACEOF
13960 + if ac_fn_c_try_compile "$LINENO"; then :
13961 +  eval "$as_CACHEVAR=yes"
13962   else
13963 <  if test "$ac_cv_type_short" = yes; then
13964 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
13965 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
13966 < as_fn_error 77 "cannot compute sizeof (short)
13242 < See \`config.log' for more details" "$LINENO" 5; }
13243 <   else
13244 <     ac_cv_sizeof_short=0
13245 <   fi
13963 >  eval "$as_CACHEVAR=no"
13964 > fi
13965 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13966 >  CFLAGS=$ax_check_save_flags
13967   fi
13968 + eval ac_res=\$$as_CACHEVAR
13969 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13970 + $as_echo "$ac_res" >&6; }
13971 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13972 +
13973 + if ${CFLAGS+:} false; then :
13974 +
13975 +  case " $CFLAGS " in #(
13976 +  *" $flag "*) :
13977 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13978 +  (: CFLAGS already contains $flag) 2>&5
13979 +  ac_status=$?
13980 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13981 +  test $ac_status = 0; } ;; #(
13982 +  *) :
13983 +
13984 +     as_fn_append 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 + esac
13992 +
13993 + else
13994 +
13995 +  CFLAGS=$flag
13996 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13997 +  (: CFLAGS="$CFLAGS") 2>&5
13998 +  ac_status=$?
13999 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14000 +  test $ac_status = 0; }
14001  
14002   fi
13249 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_short" >&5
13250 – $as_echo "$ac_cv_sizeof_short" >&6; }
14003  
14004 + else
14005 +  :
14006 + fi
14007 +
14008 + done
14009  
14010  
14011 < cat >>confdefs.h <<_ACEOF
14012 < #define SIZEOF_SHORT $ac_cv_sizeof_short
14011 >
14012 >
14013 >
14014 > for flag in -Woverride-init; do
14015 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14016 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14017 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14018 > if eval \${$as_CACHEVAR+:} false; then :
14019 >  $as_echo_n "(cached) " >&6
14020 > else
14021 >
14022 >  ax_check_save_flags=$CFLAGS
14023 >  CFLAGS="$CFLAGS  $flag"
14024 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14025 > /* end confdefs.h.  */
14026 >
14027 > int
14028 > main ()
14029 > {
14030 >
14031 >  ;
14032 >  return 0;
14033 > }
14034   _ACEOF
14035 + if ac_fn_c_try_compile "$LINENO"; then :
14036 +  eval "$as_CACHEVAR=yes"
14037 + else
14038 +  eval "$as_CACHEVAR=no"
14039 + fi
14040 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14041 +  CFLAGS=$ax_check_save_flags
14042 + fi
14043 + eval ac_res=\$$as_CACHEVAR
14044 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14045 + $as_echo "$ac_res" >&6; }
14046 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14047  
14048 + if ${CFLAGS+:} false; then :
14049 +
14050 +  case " $CFLAGS " in #(
14051 +  *" $flag "*) :
14052 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14053 +  (: CFLAGS already contains $flag) 2>&5
14054 +  ac_status=$?
14055 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14056 +  test $ac_status = 0; } ;; #(
14057 +  *) :
14058  
14059 < # The cast to long int works around a bug in the HP C Compiler
14060 < # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
14061 < # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
14062 < # This bug is HP SR number 8606223364.
14063 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of long" >&5
14064 < $as_echo_n "checking size of long... " >&6; }
14065 < if ${ac_cv_sizeof_long+:} false; then :
14059 >     as_fn_append 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 > esac
14067 >
14068 > else
14069 >
14070 >  CFLAGS=$flag
14071 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14072 >  (: CFLAGS="$CFLAGS") 2>&5
14073 >  ac_status=$?
14074 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14075 >  test $ac_status = 0; }
14076 >
14077 > fi
14078 >
14079 > else
14080 >  :
14081 > fi
14082 >
14083 > done
14084 >
14085 >
14086 >
14087 >
14088 >
14089 > for flag in -Wpointer-arith; do
14090 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14091 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14092 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14093 > if eval \${$as_CACHEVAR+:} false; then :
14094    $as_echo_n "(cached) " >&6
14095   else
13268 –  if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (long))" "ac_cv_sizeof_long"        "$ac_includes_default"; then :
14096  
14097 +  ax_check_save_flags=$CFLAGS
14098 +  CFLAGS="$CFLAGS  $flag"
14099 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14100 + /* end confdefs.h.  */
14101 +
14102 + int
14103 + main ()
14104 + {
14105 +
14106 +  ;
14107 +  return 0;
14108 + }
14109 + _ACEOF
14110 + if ac_fn_c_try_compile "$LINENO"; then :
14111 +  eval "$as_CACHEVAR=yes"
14112   else
14113 <  if test "$ac_cv_type_long" = yes; then
14114 <     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14115 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14116 < as_fn_error 77 "cannot compute sizeof (long)
14117 < See \`config.log' for more details" "$LINENO" 5; }
14118 <   else
14119 <     ac_cv_sizeof_long=0
14120 <   fi
14113 >  eval "$as_CACHEVAR=no"
14114 > fi
14115 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14116 >  CFLAGS=$ax_check_save_flags
14117 > fi
14118 > eval ac_res=\$$as_CACHEVAR
14119 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14120 > $as_echo "$ac_res" >&6; }
14121 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14122 >
14123 > if ${CFLAGS+:} false; then :
14124 >
14125 >  case " $CFLAGS " in #(
14126 >  *" $flag "*) :
14127 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14128 >  (: CFLAGS already contains $flag) 2>&5
14129 >  ac_status=$?
14130 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14131 >  test $ac_status = 0; } ;; #(
14132 >  *) :
14133 >
14134 >     as_fn_append 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 > esac
14142 >
14143 > else
14144 >
14145 >  CFLAGS=$flag
14146 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14147 >  (: CFLAGS="$CFLAGS") 2>&5
14148 >  ac_status=$?
14149 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14150 >  test $ac_status = 0; }
14151 >
14152   fi
14153  
14154 + else
14155 +  :
14156   fi
13282 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_long" >&5
13283 – $as_echo "$ac_cv_sizeof_long" >&6; }
14157  
14158 + done
14159  
14160  
14161 < cat >>confdefs.h <<_ACEOF
14162 < #define SIZEOF_LONG $ac_cv_sizeof_long
14161 >
14162 >
14163 >
14164 > for flag in -Wredundant-decls; do
14165 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14166 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14167 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14168 > if eval \${$as_CACHEVAR+:} false; then :
14169 >  $as_echo_n "(cached) " >&6
14170 > else
14171 >
14172 >  ax_check_save_flags=$CFLAGS
14173 >  CFLAGS="$CFLAGS  $flag"
14174 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14175 > /* end confdefs.h.  */
14176 >
14177 > int
14178 > main ()
14179 > {
14180 >
14181 >  ;
14182 >  return 0;
14183 > }
14184 > _ACEOF
14185 > if ac_fn_c_try_compile "$LINENO"; then :
14186 >  eval "$as_CACHEVAR=yes"
14187 > else
14188 >  eval "$as_CACHEVAR=no"
14189 > fi
14190 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14191 >  CFLAGS=$ax_check_save_flags
14192 > fi
14193 > eval ac_res=\$$as_CACHEVAR
14194 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14195 > $as_echo "$ac_res" >&6; }
14196 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14197 >
14198 > if ${CFLAGS+:} false; then :
14199 >
14200 >  case " $CFLAGS " in #(
14201 >  *" $flag "*) :
14202 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14203 >  (: CFLAGS already contains $flag) 2>&5
14204 >  ac_status=$?
14205 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14206 >  test $ac_status = 0; } ;; #(
14207 >  *) :
14208 >
14209 >     as_fn_append 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 > esac
14217 >
14218 > else
14219 >
14220 >  CFLAGS=$flag
14221 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14222 >  (: CFLAGS="$CFLAGS") 2>&5
14223 >  ac_status=$?
14224 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14225 >  test $ac_status = 0; }
14226 >
14227 > fi
14228 >
14229 > else
14230 >  :
14231 > fi
14232 >
14233 > done
14234 >
14235 >
14236 >
14237 >
14238 >
14239 > for flag in -Wshadow; do
14240 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14241 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14242 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14243 > if eval \${$as_CACHEVAR+:} false; then :
14244 >  $as_echo_n "(cached) " >&6
14245 > else
14246 >
14247 >  ax_check_save_flags=$CFLAGS
14248 >  CFLAGS="$CFLAGS  $flag"
14249 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14250 > /* end confdefs.h.  */
14251 >
14252 > int
14253 > main ()
14254 > {
14255 >
14256 >  ;
14257 >  return 0;
14258 > }
14259 > _ACEOF
14260 > if ac_fn_c_try_compile "$LINENO"; then :
14261 >  eval "$as_CACHEVAR=yes"
14262 > else
14263 >  eval "$as_CACHEVAR=no"
14264 > fi
14265 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14266 >  CFLAGS=$ax_check_save_flags
14267 > fi
14268 > eval ac_res=\$$as_CACHEVAR
14269 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14270 > $as_echo "$ac_res" >&6; }
14271 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14272 >
14273 > if ${CFLAGS+:} false; then :
14274 >
14275 >  case " $CFLAGS " in #(
14276 >  *" $flag "*) :
14277 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14278 >  (: CFLAGS already contains $flag) 2>&5
14279 >  ac_status=$?
14280 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14281 >  test $ac_status = 0; } ;; #(
14282 >  *) :
14283 >
14284 >     as_fn_append 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 > esac
14292 >
14293 > else
14294 >
14295 >  CFLAGS=$flag
14296 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14297 >  (: CFLAGS="$CFLAGS") 2>&5
14298 >  ac_status=$?
14299 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14300 >  test $ac_status = 0; }
14301 >
14302 > fi
14303 >
14304 > else
14305 >  :
14306 > fi
14307 >
14308 > done
14309 >
14310 >
14311 >
14312 >
14313 >
14314 > for flag in -Wshift-negative-value; do
14315 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14316 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14317 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14318 > if eval \${$as_CACHEVAR+:} false; then :
14319 >  $as_echo_n "(cached) " >&6
14320 > else
14321 >
14322 >  ax_check_save_flags=$CFLAGS
14323 >  CFLAGS="$CFLAGS  $flag"
14324 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14325 > /* end confdefs.h.  */
14326 >
14327 > int
14328 > main ()
14329 > {
14330 >
14331 >  ;
14332 >  return 0;
14333 > }
14334 > _ACEOF
14335 > if ac_fn_c_try_compile "$LINENO"; then :
14336 >  eval "$as_CACHEVAR=yes"
14337 > else
14338 >  eval "$as_CACHEVAR=no"
14339 > fi
14340 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14341 >  CFLAGS=$ax_check_save_flags
14342 > fi
14343 > eval ac_res=\$$as_CACHEVAR
14344 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14345 > $as_echo "$ac_res" >&6; }
14346 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14347 >
14348 > if ${CFLAGS+:} false; then :
14349 >
14350 >  case " $CFLAGS " in #(
14351 >  *" $flag "*) :
14352 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14353 >  (: CFLAGS already contains $flag) 2>&5
14354 >  ac_status=$?
14355 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14356 >  test $ac_status = 0; } ;; #(
14357 >  *) :
14358 >
14359 >     as_fn_append 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 > esac
14367 >
14368 > else
14369 >
14370 >  CFLAGS=$flag
14371 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14372 >  (: CFLAGS="$CFLAGS") 2>&5
14373 >  ac_status=$?
14374 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14375 >  test $ac_status = 0; }
14376 >
14377 > fi
14378 >
14379 > else
14380 >  :
14381 > fi
14382 >
14383 > done
14384 >
14385 >
14386 >
14387 >
14388 >
14389 > for flag in -Wsign-compare; do
14390 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14391 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14392 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14393 > if eval \${$as_CACHEVAR+:} false; then :
14394 >  $as_echo_n "(cached) " >&6
14395 > else
14396 >
14397 >  ax_check_save_flags=$CFLAGS
14398 >  CFLAGS="$CFLAGS  $flag"
14399 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14400 > /* end confdefs.h.  */
14401 >
14402 > int
14403 > main ()
14404 > {
14405 >
14406 >  ;
14407 >  return 0;
14408 > }
14409 > _ACEOF
14410 > if ac_fn_c_try_compile "$LINENO"; then :
14411 >  eval "$as_CACHEVAR=yes"
14412 > else
14413 >  eval "$as_CACHEVAR=no"
14414 > fi
14415 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14416 >  CFLAGS=$ax_check_save_flags
14417 > fi
14418 > eval ac_res=\$$as_CACHEVAR
14419 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14420 > $as_echo "$ac_res" >&6; }
14421 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14422 >
14423 > if ${CFLAGS+:} false; then :
14424 >
14425 >  case " $CFLAGS " in #(
14426 >  *" $flag "*) :
14427 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14428 >  (: CFLAGS already contains $flag) 2>&5
14429 >  ac_status=$?
14430 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14431 >  test $ac_status = 0; } ;; #(
14432 >  *) :
14433 >
14434 >     as_fn_append 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 > esac
14442 >
14443 > else
14444 >
14445 >  CFLAGS=$flag
14446 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14447 >  (: CFLAGS="$CFLAGS") 2>&5
14448 >  ac_status=$?
14449 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14450 >  test $ac_status = 0; }
14451 >
14452 > fi
14453 >
14454 > else
14455 >  :
14456 > fi
14457 >
14458 > done
14459 >
14460 >
14461 >
14462 >
14463 >
14464 > for flag in -Wtype-limits; do
14465 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14466 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14467 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14468 > if eval \${$as_CACHEVAR+:} false; then :
14469 >  $as_echo_n "(cached) " >&6
14470 > else
14471 >
14472 >  ax_check_save_flags=$CFLAGS
14473 >  CFLAGS="$CFLAGS  $flag"
14474 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14475 > /* end confdefs.h.  */
14476 >
14477 > int
14478 > main ()
14479 > {
14480 >
14481 >  ;
14482 >  return 0;
14483 > }
14484 > _ACEOF
14485 > if ac_fn_c_try_compile "$LINENO"; then :
14486 >  eval "$as_CACHEVAR=yes"
14487 > else
14488 >  eval "$as_CACHEVAR=no"
14489 > fi
14490 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14491 >  CFLAGS=$ax_check_save_flags
14492 > fi
14493 > eval ac_res=\$$as_CACHEVAR
14494 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14495 > $as_echo "$ac_res" >&6; }
14496 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14497 >
14498 > if ${CFLAGS+:} false; then :
14499 >
14500 >  case " $CFLAGS " in #(
14501 >  *" $flag "*) :
14502 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14503 >  (: CFLAGS already contains $flag) 2>&5
14504 >  ac_status=$?
14505 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14506 >  test $ac_status = 0; } ;; #(
14507 >  *) :
14508 >
14509 >     as_fn_append CFLAGS " $flag"
14510 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14511 >  (: CFLAGS="$CFLAGS") 2>&5
14512 >  ac_status=$?
14513 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14514 >  test $ac_status = 0; }
14515 >     ;;
14516 > esac
14517 >
14518 > else
14519 >
14520 >  CFLAGS=$flag
14521 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14522 >  (: CFLAGS="$CFLAGS") 2>&5
14523 >  ac_status=$?
14524 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14525 >  test $ac_status = 0; }
14526 >
14527 > fi
14528 >
14529 > else
14530 >  :
14531 > fi
14532 >
14533 > done
14534 >
14535 >
14536 >
14537 >
14538 >
14539 > for flag in -Wundef; do
14540 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14541 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14542 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14543 > if eval \${$as_CACHEVAR+:} false; then :
14544 >  $as_echo_n "(cached) " >&6
14545 > else
14546 >
14547 >  ax_check_save_flags=$CFLAGS
14548 >  CFLAGS="$CFLAGS  $flag"
14549 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14550 > /* end confdefs.h.  */
14551 >
14552 > int
14553 > main ()
14554 > {
14555 >
14556 >  ;
14557 >  return 0;
14558 > }
14559 > _ACEOF
14560 > if ac_fn_c_try_compile "$LINENO"; then :
14561 >  eval "$as_CACHEVAR=yes"
14562 > else
14563 >  eval "$as_CACHEVAR=no"
14564 > fi
14565 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14566 >  CFLAGS=$ax_check_save_flags
14567 > fi
14568 > eval ac_res=\$$as_CACHEVAR
14569 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14570 > $as_echo "$ac_res" >&6; }
14571 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14572 >
14573 > if ${CFLAGS+:} false; then :
14574 >
14575 >  case " $CFLAGS " in #(
14576 >  *" $flag "*) :
14577 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14578 >  (: CFLAGS already contains $flag) 2>&5
14579 >  ac_status=$?
14580 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14581 >  test $ac_status = 0; } ;; #(
14582 >  *) :
14583 >
14584 >     as_fn_append 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 > esac
14592 >
14593 > else
14594 >
14595 >  CFLAGS=$flag
14596 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14597 >  (: CFLAGS="$CFLAGS") 2>&5
14598 >  ac_status=$?
14599 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14600 >  test $ac_status = 0; }
14601 >
14602 > fi
14603 >
14604 > else
14605 >  :
14606 > fi
14607 >
14608 > done
14609 >
14610 >
14611 >
14612 >
14613 >
14614 > for flag in -Wuninitialized; do
14615 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14616 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14617 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14618 > if eval \${$as_CACHEVAR+:} false; then :
14619 >  $as_echo_n "(cached) " >&6
14620 > else
14621 >
14622 >  ax_check_save_flags=$CFLAGS
14623 >  CFLAGS="$CFLAGS  $flag"
14624 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14625 > /* end confdefs.h.  */
14626 >
14627 > int
14628 > main ()
14629 > {
14630 >
14631 >  ;
14632 >  return 0;
14633 > }
14634 > _ACEOF
14635 > if ac_fn_c_try_compile "$LINENO"; then :
14636 >  eval "$as_CACHEVAR=yes"
14637 > else
14638 >  eval "$as_CACHEVAR=no"
14639 > fi
14640 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14641 >  CFLAGS=$ax_check_save_flags
14642 > fi
14643 > eval ac_res=\$$as_CACHEVAR
14644 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14645 > $as_echo "$ac_res" >&6; }
14646 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14647 >
14648 > if ${CFLAGS+:} false; then :
14649 >
14650 >  case " $CFLAGS " in #(
14651 >  *" $flag "*) :
14652 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14653 >  (: CFLAGS already contains $flag) 2>&5
14654 >  ac_status=$?
14655 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14656 >  test $ac_status = 0; } ;; #(
14657 >  *) :
14658 >
14659 >     as_fn_append 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 > esac
14667 >
14668 > else
14669 >
14670 >  CFLAGS=$flag
14671 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14672 >  (: CFLAGS="$CFLAGS") 2>&5
14673 >  ac_status=$?
14674 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14675 >  test $ac_status = 0; }
14676 >
14677 > fi
14678 >
14679 > else
14680 >  :
14681 > fi
14682 >
14683 > done
14684 >
14685 >
14686 >
14687 >
14688 >
14689 > for flag in -Wwrite-strings; do
14690 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14691 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14692 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14693 > if eval \${$as_CACHEVAR+:} false; then :
14694 >  $as_echo_n "(cached) " >&6
14695 > else
14696 >
14697 >  ax_check_save_flags=$CFLAGS
14698 >  CFLAGS="$CFLAGS  $flag"
14699 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14700 > /* end confdefs.h.  */
14701 >
14702 > int
14703 > main ()
14704 > {
14705 >
14706 >  ;
14707 >  return 0;
14708 > }
14709   _ACEOF
14710 + if ac_fn_c_try_compile "$LINENO"; then :
14711 +  eval "$as_CACHEVAR=yes"
14712 + else
14713 +  eval "$as_CACHEVAR=no"
14714 + fi
14715 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14716 +  CFLAGS=$ax_check_save_flags
14717 + fi
14718 + eval ac_res=\$$as_CACHEVAR
14719 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14720 + $as_echo "$ac_res" >&6; }
14721 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14722  
14723 + if ${CFLAGS+:} false; then :
14724 +
14725 +  case " $CFLAGS " in #(
14726 +  *" $flag "*) :
14727 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14728 +  (: CFLAGS already contains $flag) 2>&5
14729 +  ac_status=$?
14730 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14731 +  test $ac_status = 0; } ;; #(
14732 +  *) :
14733 +
14734 +     as_fn_append 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 + esac
14742 +
14743 + else
14744 +
14745 +  CFLAGS=$flag
14746 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14747 +  (: CFLAGS="$CFLAGS") 2>&5
14748 +  ac_status=$?
14749 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14750 +  test $ac_status = 0; }
14751 +
14752 + fi
14753 +
14754 + else
14755 +  :
14756 + fi
14757 +
14758 + done
14759 +
14760 +
14761 + fi
14762 +
14763 +
14764 +  # Check whether --enable-efence was given.
14765 + if test "${enable_efence+set}" = set; then :
14766 +  enableval=$enable_efence; efence="$enableval"
14767 + else
14768 +  efence="no"
14769 + fi
14770 +
14771 +
14772 +  if test "$efence" = "yes"; then :
14773 +
14774 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14775 + $as_echo_n "checking for library containing EF_Print... " >&6; }
14776 + if ${ac_cv_search_EF_Print+:} false; then :
14777 +  $as_echo_n "(cached) " >&6
14778 + else
14779 +  ac_func_search_save_LIBS=$LIBS
14780 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14781 + /* end confdefs.h.  */
14782 +
14783 + /* Override any GCC internal prototype to avoid an error.
14784 +   Use char because int might match the return type of a GCC
14785 +   builtin and then its argument prototype would still apply.  */
14786 + #ifdef __cplusplus
14787 + extern "C"
14788 + #endif
14789 + char EF_Print ();
14790 + int
14791 + main ()
14792 + {
14793 + return EF_Print ();
14794 +  ;
14795 +  return 0;
14796 + }
14797 + _ACEOF
14798 + for ac_lib in '' efence; do
14799 +  if test -z "$ac_lib"; then
14800 +    ac_res="none required"
14801 +  else
14802 +    ac_res=-l$ac_lib
14803 +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14804 +  fi
14805 +  if ac_fn_c_try_link "$LINENO"; then :
14806 +  ac_cv_search_EF_Print=$ac_res
14807 + fi
14808 + rm -f core conftest.err conftest.$ac_objext \
14809 +    conftest$ac_exeext
14810 +  if ${ac_cv_search_EF_Print+:} false; then :
14811 +  break
14812 + fi
14813 + done
14814 + if ${ac_cv_search_EF_Print+:} false; then :
14815  
14816 + else
14817 +  ac_cv_search_EF_Print=no
14818 + fi
14819 + rm conftest.$ac_ext
14820 + LIBS=$ac_func_search_save_LIBS
14821 + fi
14822 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14823 + $as_echo "$ac_cv_search_EF_Print" >&6; }
14824 + ac_res=$ac_cv_search_EF_Print
14825 + if test "$ac_res" != no; then :
14826 +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14827  
14828 + else
14829 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14830 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14831 + as_fn_error $? "Electric Fence 'efence' library not found
14832 + See \`config.log' for more details" "$LINENO" 5; }
14833 + fi
14834  
14835  
14836 + fi
14837  
14838  
14839 + for ac_func in strlcpy strlcat
14840 + do :
14841 +  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14842 + ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14843 + if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14844 +  cat >>confdefs.h <<_ACEOF
14845 + #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14846 + _ACEOF
14847  
14848 < subdirs="$subdirs src/libopm"
14848 > fi
14849 > done
14850  
14851  
14852 < ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile"
14852 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14853  
14854   cat >confcache <<\_ACEOF
14855   # This file is a shell script that caches the results of configure
# Line 13394 | Line 14945 | DEFS=-DHAVE_CONFIG_H
14945  
14946   ac_libobjs=
14947   ac_ltlibobjs=
14948 + U=
14949   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14950    # 1. Remove the extension, and $U if already installed.
14951    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
# Line 13436 | Line 14988 | if test -z "${am__fastdepCC_TRUE}" && te
14988    as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
14989   Usually this means the macro was only invoked conditionally." "$LINENO" 5
14990   fi
14991 <
14991 > if test -z "${ENABLE_SSL_TRUE}" && test -z "${ENABLE_SSL_FALSE}"; then
14992 >  as_fn_error $? "conditional \"ENABLE_SSL\" was never defined.
14993 > Usually this means the macro was only invoked conditionally." "$LINENO" 5
14994 > fi
14995  
14996   : "${CONFIG_STATUS=./config.status}"
14997   ac_write_fail=0
# Line 13834 | Line 15389 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15389   # report actual input values of CONFIG_FILES etc. instead of their
15390   # values after options handling.
15391   ac_log="
15392 < This file was extended by hopm $as_me 1.0.0beta1, which was
15392 > This file was extended by hopm $as_me 1.1.5, which was
15393   generated by GNU Autoconf 2.69.  Invocation command line was
15394  
15395    CONFIG_FILES    = $CONFIG_FILES
# Line 13894 | Line 15449 | $config_headers
15449   Configuration commands:
15450   $config_commands
15451  
15452 < Report bugs to the package provider."
15452 > Report bugs to <bugs@ircd-hybrid.org>."
15453  
15454   _ACEOF
15455   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15456   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15457   ac_cs_version="\\
15458 < hopm config.status 1.0.0beta1
15458 > hopm config.status 1.1.5
15459   configured by $0, generated by GNU Autoconf 2.69,
15460    with options \\"\$ac_cs_config\\"
15461  
# Line 14156 | Line 15711 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15711   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15712   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15713   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15714 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15714 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15715 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15716   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15717   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15718   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 14274 | Line 15830 | postinstall_cmds \
15830   postuninstall_cmds \
15831   finish_cmds \
15832   sys_lib_search_path_spec \
15833 < sys_lib_dlsearch_path_spec; do
15833 > configure_time_dlsearch_path \
15834 > configure_time_lt_sys_library_path; do
15835      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15836      *[\\\\\\\`\\"\\\$]*)
15837        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 14316 | Line 15873 | do
15873      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15874      "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15875      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15876 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15877 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15878  
15879    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15880    esac
# Line 15051 | Line 16610 | $as_echo X"$file" |
16610   # The names of the tagged configurations supported by this script.
16611   available_tags=''
16612  
16613 + # Configured defaults for sys_lib_dlsearch_path munging.
16614 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16615 +
16616   # ### BEGIN LIBTOOL CONFIG
16617  
16618   # Which release of libtool.m4 was used?
# Line 15300 | Line 16862 | hardcode_into_libs=$hardcode_into_libs
16862   # Compile-time system search path for libraries.
16863   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16864  
16865 < # Run-time system search path for libraries.
16866 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16865 > # Detected run-time system search path for libraries.
16866 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16867 >
16868 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16869 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16870  
16871   # Whether dlopen is supported.
16872   dlopen_support=$enable_dlopen
# Line 15452 | Line 17017 | hardcode_action=$hardcode_action
17017  
17018   _LT_EOF
17019  
17020 +    cat <<'_LT_EOF' >> "$cfgfile"
17021 +
17022 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17023 +
17024 + # func_munge_path_list VARIABLE PATH
17025 + # -----------------------------------
17026 + # VARIABLE is name of variable containing _space_ separated list of
17027 + # directories to be munged by the contents of PATH, which is string
17028 + # having a format:
17029 + # "DIR[:DIR]:"
17030 + #       string "DIR[ DIR]" will be prepended to VARIABLE
17031 + # ":DIR[:DIR]"
17032 + #       string "DIR[ DIR]" will be appended to VARIABLE
17033 + # "DIRP[:DIRP]::[DIRA:]DIRA"
17034 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17035 + #       "DIRA[ DIRA]" will be appended to VARIABLE
17036 + # "DIR[:DIR]"
17037 + #       VARIABLE will be replaced by "DIR[ DIR]"
17038 + func_munge_path_list ()
17039 + {
17040 +    case x$2 in
17041 +    x)
17042 +        ;;
17043 +    *:)
17044 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17045 +        ;;
17046 +    x:*)
17047 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17048 +        ;;
17049 +    *::*)
17050 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17051 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17052 +        ;;
17053 +    *)
17054 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17055 +        ;;
17056 +    esac
17057 + }
17058 +
17059 +
17060 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17061 + func_cc_basename ()
17062 + {
17063 +    for cc_temp in $*""; do
17064 +      case $cc_temp in
17065 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17066 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17067 +        \-*) ;;
17068 +        *) break;;
17069 +      esac
17070 +    done
17071 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17072 + }
17073 +
17074 +
17075 + # ### END FUNCTIONS SHARED WITH CONFIGURE
17076 +
17077 + _LT_EOF
17078 +
17079    case $host_os in
17080    aix3*)
17081      cat <<\_LT_EOF >> "$cfgfile"
# Line 15515 | Line 17139 | if test "$no_create" != yes; then
17139    # would make configure fail if this is the last instruction.
17140    $ac_cs_success || as_fn_exit 1
17141   fi
15518 –
15519 – #
15520 – # CONFIG_SUBDIRS section.
15521 – #
15522 – if test "$no_recursion" != yes; then
15523 –
15524 –  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
15525 –  # so they do not pile up.
15526 –  ac_sub_configure_args=
15527 –  ac_prev=
15528 –  eval "set x $ac_configure_args"
15529 –  shift
15530 –  for ac_arg
15531 –  do
15532 –    if test -n "$ac_prev"; then
15533 –      ac_prev=
15534 –      continue
15535 –    fi
15536 –    case $ac_arg in
15537 –    -cache-file | --cache-file | --cache-fil | --cache-fi \
15538 –    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
15539 –      ac_prev=cache_file ;;
15540 –    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
15541 –    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
15542 –    | --c=*)
15543 –      ;;
15544 –    --config-cache | -C)
15545 –      ;;
15546 –    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
15547 –      ac_prev=srcdir ;;
15548 –    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
15549 –      ;;
15550 –    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
15551 –      ac_prev=prefix ;;
15552 –    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
15553 –      ;;
15554 –    --disable-option-checking)
15555 –      ;;
15556 –    *)
15557 –      case $ac_arg in
15558 –      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15559 –      esac
15560 –      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
15561 –    esac
15562 –  done
15563 –
15564 –  # Always prepend --prefix to ensure using the same prefix
15565 –  # in subdir configurations.
15566 –  ac_arg="--prefix=$prefix"
15567 –  case $ac_arg in
15568 –  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15569 –  esac
15570 –  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
15571 –
15572 –  # Pass --silent
15573 –  if test "$silent" = yes; then
15574 –    ac_sub_configure_args="--silent $ac_sub_configure_args"
15575 –  fi
15576 –
15577 –  # Always prepend --disable-option-checking to silence warnings, since
15578 –  # different subdirs can have different --enable and --with options.
15579 –  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
15580 –
15581 –  ac_popdir=`pwd`
15582 –  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
15583 –
15584 –    # Do not complain, so a configure script can configure whichever
15585 –    # parts of a large source tree are present.
15586 –    test -d "$srcdir/$ac_dir" || continue
15587 –
15588 –    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
15589 –    $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
15590 –    $as_echo "$ac_msg" >&6
15591 –    as_dir="$ac_dir"; as_fn_mkdir_p
15592 –    ac_builddir=.
15593 –
15594 – case "$ac_dir" in
15595 – .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
15596 – *)
15597 –  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
15598 –  # A ".." for each directory in $ac_dir_suffix.
15599 –  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
15600 –  case $ac_top_builddir_sub in
15601 –  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
15602 –  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
15603 –  esac ;;
15604 – esac
15605 – ac_abs_top_builddir=$ac_pwd
15606 – ac_abs_builddir=$ac_pwd$ac_dir_suffix
15607 – # for backward compatibility:
15608 – ac_top_builddir=$ac_top_build_prefix
15609 –
15610 – case $srcdir in
15611 –  .)  # We are building in place.
15612 –    ac_srcdir=.
15613 –    ac_top_srcdir=$ac_top_builddir_sub
15614 –    ac_abs_top_srcdir=$ac_pwd ;;
15615 –  [\\/]* | ?:[\\/]* )  # Absolute name.
15616 –    ac_srcdir=$srcdir$ac_dir_suffix;
15617 –    ac_top_srcdir=$srcdir
15618 –    ac_abs_top_srcdir=$srcdir ;;
15619 –  *) # Relative name.
15620 –    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
15621 –    ac_top_srcdir=$ac_top_build_prefix$srcdir
15622 –    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
15623 – esac
15624 – ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
15625 –
15626 –
15627 –    cd "$ac_dir"
15628 –
15629 –    # Check for guested configure; otherwise get Cygnus style configure.
15630 –    if test -f "$ac_srcdir/configure.gnu"; then
15631 –      ac_sub_configure=$ac_srcdir/configure.gnu
15632 –    elif test -f "$ac_srcdir/configure"; then
15633 –      ac_sub_configure=$ac_srcdir/configure
15634 –    elif test -f "$ac_srcdir/configure.in"; then
15635 –      # This should be Cygnus configure.
15636 –      ac_sub_configure=$ac_aux_dir/configure
15637 –    else
15638 –      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
15639 – $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
15640 –      ac_sub_configure=
15641 –    fi
15642 –
15643 –    # The recursion is here.
15644 –    if test -n "$ac_sub_configure"; then
15645 –      # Make the cache file name correct relative to the subdirectory.
15646 –      case $cache_file in
15647 –      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
15648 –      *) # Relative name.
15649 –        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
15650 –      esac
15651 –
15652 –      { $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
15653 – $as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
15654 –      # The eval makes quoting arguments work.
15655 –      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
15656 –           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
15657 –        as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
15658 –    fi
15659 –
15660 –    cd "$ac_popdir"
15661 –  done
15662 – fi
17142   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17143    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17144   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}

Diff Legend

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