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

Comparing hopm/trunk/configure (file contents):
Revision 5062 by michael, Mon Dec 22 14:07:15 2014 UTC vs.
Revision 8578 by michael, Sun Oct 14 09:32:34 2018 UTC

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

Comparing hopm/trunk/configure (property svn:eol-style):
Revision 5062 by michael, Mon Dec 22 14:07:15 2014 UTC vs.
Revision 8578 by michael, Sun Oct 14 09:32:34 2018 UTC

# Line 0 | Line 1
1 + native

Comparing hopm/trunk/configure (property svn:keywords):
Revision 5062 by michael, Mon Dec 22 14:07:15 2014 UTC vs.
Revision 8578 by michael, Sun Oct 14 09:32:34 2018 UTC

# Line 0 | Line 1
1 + Id

Diff Legend

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