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 5167 by michael, Fri Dec 26 18:58:49 2014 UTC vs.
Revision 8559 by michael, Sun Sep 23 09:25:41 2018 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8550 2018-09-22 20:55:46Z 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
641 < subdirs
641 > ENABLE_SSL_FALSE
642 > ENABLE_SSL_TRUE
643   LEXLIB
644   LEX_OUTPUT_ROOT
645   LEX
646   YFLAGS
647   YACC
648   CPP
649 + LT_SYS_LIBRARY_PATH
650   OTOOL64
651   OTOOL
652   LIPO
# Line 761 | Line 766 | ac_user_opts='
766   enable_option_checking
767   enable_silent_rules
768   enable_maintainer_mode
764 – with_extra_fascism
769   enable_dependency_tracking
770   enable_shared
771   enable_static
# Line 771 | Line 775 | with_aix_soname
775   with_gnu_ld
776   with_sysroot
777   enable_libtool_lock
778 + enable_openssl
779 + enable_assert
780 + enable_warnings
781 + enable_efence
782   '
783        ac_precious_vars='build_alias
784   host_alias
# Line 780 | Line 788 | CFLAGS
788   LDFLAGS
789   LIBS
790   CPPFLAGS
791 + LT_SYS_LIBRARY_PATH
792   CPP
793   YACC
794   YFLAGS'
795 < ac_subdirs_all='src/libopm'
795 >
796  
797   # Initialize some variables set by options.
798   ac_init_help=
# Line 1323 | Line 1332 | if test "$ac_init_help" = "long"; then
1332    # Omit some internal or obsolete options to make the list less imposing.
1333    # This message is too long to be a string in the A/UX 3.1 sh.
1334    cat <<_ACEOF
1335 < \`configure' configures hopm 1.0.0beta1 to adapt to many kinds of systems.
1335 > \`configure' configures hopm TRUNK to adapt to many kinds of systems.
1336  
1337   Usage: $0 [OPTION]... [VAR=VALUE]...
1338  
# Line 1393 | Line 1402 | fi
1402  
1403   if test -n "$ac_init_help"; then
1404    case $ac_init_help in
1405 <     short | recursive ) echo "Configuration of hopm 1.0.0beta1:";;
1405 >     short | recursive ) echo "Configuration of hopm TRUNK:";;
1406     esac
1407    cat <<\_ACEOF
1408  
# Line 1415 | Line 1424 | Optional Features:
1424    --enable-fast-install[=PKGS]
1425                            optimize for fast installation [default=yes]
1426    --disable-libtool-lock  avoid locking (might break parallel builds)
1427 +  --enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1428 +  --disable-openssl            Disable LibreSSL/OpenSSL support.
1429 +  --enable-assert         Enable assert() statements
1430 +  --enable-warnings       Enable compiler warnings.
1431 +  --enable-efence         Enable linking with Electric Fence 'efence' memory
1432 +                          debugger library.
1433  
1434   Optional Packages:
1435    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1436    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1422 –  --with-extra-fascism    Add extra gcc3-specific warning flags
1437    --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1438                            both]
1439    --with-aix-soname=aix|svr4|both
# Line 1437 | Line 1451 | Some influential environment variables:
1451    LIBS        libraries to pass to the linker, e.g. -l<library>
1452    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1453                you have headers in a nonstandard directory <include dir>
1454 +  LT_SYS_LIBRARY_PATH
1455 +              User-defined run-time library search path.
1456    CPP         C preprocessor
1457    YACC        The `Yet Another Compiler Compiler' implementation to use.
1458                Defaults to the first program found out of: `bison -y', `byacc',
# Line 1448 | Line 1464 | Some influential environment variables:
1464   Use these variables to override the choices made by `configure' or to help
1465   it to find libraries and programs with nonstandard names/locations.
1466  
1467 < Report bugs to the package provider.
1467 > Report bugs to <bugs@ircd-hybrid.org>.
1468   _ACEOF
1469   ac_status=$?
1470   fi
# Line 1511 | Line 1527 | fi
1527   test -n "$ac_init_help" && exit $ac_status
1528   if $ac_init_version; then
1529    cat <<\_ACEOF
1530 < hopm configure 1.0.0beta1
1530 > hopm configure TRUNK
1531   generated by GNU Autoconf 2.69
1532  
1533   Copyright (C) 2012 Free Software Foundation, Inc.
# Line 1785 | Line 1801 | $as_echo "$ac_res" >&6; }
1801    eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1802  
1803   } # ac_fn_c_check_func
1788 –
1789 – # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1790 – # -------------------------------------------------------
1791 – # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1792 – # the include files in INCLUDES and setting the cache variable VAR
1793 – # accordingly.
1794 – ac_fn_c_check_header_mongrel ()
1795 – {
1796 –  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1797 –  if eval \${$3+:} false; then :
1798 –  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1799 – $as_echo_n "checking for $2... " >&6; }
1800 – if eval \${$3+:} false; then :
1801 –  $as_echo_n "(cached) " >&6
1802 – fi
1803 – eval ac_res=\$$3
1804 –               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1805 – $as_echo "$ac_res" >&6; }
1806 – else
1807 –  # Is the header compilable?
1808 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1809 – $as_echo_n "checking $2 usability... " >&6; }
1810 – cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1811 – /* end confdefs.h.  */
1812 – $4
1813 – #include <$2>
1814 – _ACEOF
1815 – if ac_fn_c_try_compile "$LINENO"; then :
1816 –  ac_header_compiler=yes
1817 – else
1818 –  ac_header_compiler=no
1819 – fi
1820 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1821 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1822 – $as_echo "$ac_header_compiler" >&6; }
1823 –
1824 – # Is the header present?
1825 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1826 – $as_echo_n "checking $2 presence... " >&6; }
1827 – cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1828 – /* end confdefs.h.  */
1829 – #include <$2>
1830 – _ACEOF
1831 – if ac_fn_c_try_cpp "$LINENO"; then :
1832 –  ac_header_preproc=yes
1833 – else
1834 –  ac_header_preproc=no
1835 – fi
1836 – rm -f conftest.err conftest.i conftest.$ac_ext
1837 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1838 – $as_echo "$ac_header_preproc" >&6; }
1839 –
1840 – # So?  What about this header?
1841 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1842 –  yes:no: )
1843 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1844 – $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1845 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1846 – $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1847 –    ;;
1848 –  no:yes:* )
1849 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1850 – $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1851 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1852 – $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1853 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1854 – $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1855 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1856 – $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1857 –    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1858 – $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1859 –    ;;
1860 – esac
1861 –  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1862 – $as_echo_n "checking for $2... " >&6; }
1863 – if eval \${$3+:} false; then :
1864 –  $as_echo_n "(cached) " >&6
1865 – else
1866 –  eval "$3=\$ac_header_compiler"
1867 – fi
1868 – eval ac_res=\$$3
1869 –               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1870 – $as_echo "$ac_res" >&6; }
1871 – fi
1872 –  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1873 –
1874 – } # ac_fn_c_check_header_mongrel
1804   cat >config.log <<_ACEOF
1805   This file contains any messages produced by compilers while
1806   running configure, to aid debugging if configure makes a mistake.
1807  
1808 < It was created by hopm $as_me 1.0.0beta1, which was
1808 > It was created by hopm $as_me TRUNK, which was
1809   generated by GNU Autoconf 2.69.  Invocation command line was
1810  
1811    $ $0 $@
# Line 2224 | Line 2153 | ac_link='$CC -o conftest$ac_exeext $CFLA
2153   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2154  
2155  
2156 <
2228 < ac_config_headers="$ac_config_headers src/setup.h"
2229 <
2230 < am__api_version='1.14'
2156 > am__api_version='1.15'
2157  
2158   ac_aux_dir=
2159   for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
# Line 2428 | Line 2354 | test "$program_suffix" != NONE &&
2354   ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2355   program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2356  
2357 < # expand $ac_aux_dir to an absolute path
2358 < am_aux_dir=`cd $ac_aux_dir && pwd`
2357 > # Expand $ac_aux_dir to an absolute path.
2358 > am_aux_dir=`cd "$ac_aux_dir" && pwd`
2359  
2360   if test x"${MISSING+set}" != xset; then
2361    case $am_aux_dir in
# Line 2448 | Line 2374 | else
2374   $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2375   fi
2376  
2377 < if test x"${install_sh}" != xset; then
2377 > if test x"${install_sh+set}" != xset; then
2378    case $am_aux_dir in
2379    *\ * | *\     *)
2380      install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
# Line 2742 | Line 2668 | fi
2668  
2669   # Define the identity of the package.
2670   PACKAGE='hopm'
2671 < VERSION='1.0.0beta1'
2671 > VERSION='TRUNK'
2672  
2673  
2674   cat >>confdefs.h <<_ACEOF
# Line 2776 | Line 2702 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2702   # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2703   mkdir_p='$(MKDIR_P)'
2704  
2705 < # We need awk for the "check" target.  The system "awk" is bad on
2706 < # some platforms.
2705 > # We need awk for the "check" target (and possibly the TAP driver).  The
2706 > # system "awk" is bad on some platforms.
2707   # Always define AMTAR for backward compatibility.  Yes, it's still used
2708   # in the wild :-(  We should find a proper way to deprecate it ...
2709   AMTAR='$${TAR-tar}'
# Line 2859 | Line 2785 | fi
2785  
2786  
2787  
2788 <
2863 < # Check whether --with-extra-fascism was given.
2864 < if test "${with_extra_fascism+set}" = set; then :
2865 <  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"
2866 < fi
2867 <
2788 > ac_config_headers="$ac_config_headers src/setup.h"
2789  
2790  
2791  
# Line 4096 | Line 4017 | esac
4017  
4018  
4019  
4020 < macro_version='2.4.4'
4021 < macro_revision='2.4.4'
4020 > macro_version='2.4.6'
4021 > macro_revision='2.4.6'
4022  
4023  
4024  
# Line 6520 | Line 6441 | $as_echo "$lt_cv_truncate_bin" >&6; }
6441  
6442  
6443  
6444 +
6445 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6446 + func_cc_basename ()
6447 + {
6448 +    for cc_temp in $*""; do
6449 +      case $cc_temp in
6450 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6451 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6452 +        \-*) ;;
6453 +        *) break;;
6454 +      esac
6455 +    done
6456 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6457 + }
6458 +
6459   # Check whether --enable-libtool-lock was given.
6460   if test "${enable_libtool_lock+set}" = set; then :
6461    enableval=$enable_libtool_lock;
# Line 7527 | Line 7463 | $as_echo "$lt_cv_ld_force_load" >&6; }
7463      ;;
7464    esac
7465  
7466 + # func_munge_path_list VARIABLE PATH
7467 + # -----------------------------------
7468 + # VARIABLE is name of variable containing _space_ separated list of
7469 + # directories to be munged by the contents of PATH, which is string
7470 + # having a format:
7471 + # "DIR[:DIR]:"
7472 + #       string "DIR[ DIR]" will be prepended to VARIABLE
7473 + # ":DIR[:DIR]"
7474 + #       string "DIR[ DIR]" will be appended to VARIABLE
7475 + # "DIRP[:DIRP]::[DIRA:]DIRA"
7476 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7477 + #       "DIRA[ DIRA]" will be appended to VARIABLE
7478 + # "DIR[:DIR]"
7479 + #       VARIABLE will be replaced by "DIR[ DIR]"
7480 + func_munge_path_list ()
7481 + {
7482 +    case x$2 in
7483 +    x)
7484 +        ;;
7485 +    *:)
7486 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7487 +        ;;
7488 +    x:*)
7489 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7490 +        ;;
7491 +    *::*)
7492 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7493 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7494 +        ;;
7495 +    *)
7496 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7497 +        ;;
7498 +    esac
7499 + }
7500 +
7501   ac_ext=c
7502   ac_cpp='$CPP $CPPFLAGS'
7503   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8114 | Line 8085 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8085   test -z "$LD" && LD=ld
8086   test -z "$ac_objext" && ac_objext=o
8087  
8088 < for cc_temp in $compiler""; do
8089 <  case $cc_temp in
8119 <    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
8120 <    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
8121 <    \-*) ;;
8122 <    *) break;;
8123 <  esac
8124 < done
8125 < cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
8088 > func_cc_basename $compiler
8089 > cc_basename=$func_cc_basename_result
8090  
8091  
8092   # Only perform the check for file, if the check method requires it
# Line 8322 | Line 8286 | _lt_linker_boilerplate=`cat conftest.err
8286   $RM -r conftest*
8287  
8288  
8289 + ## CAVEAT EMPTOR:
8290 + ## There is no encapsulation within the following macros, do not change
8291 + ## the running order or otherwise move them around unless you know exactly
8292 + ## what you are doing...
8293   if test -n "$compiler"; then
8294  
8295   lt_prog_compiler_no_builtin_flag=
# Line 10577 | Line 10545 | hardcode_into_libs=no
10545   # flags to be left without arguments
10546   need_version=unknown
10547  
10548 +
10549 +
10550   case $host_os in
10551   aix3*)
10552    version_type=linux # correct to gnu/linux during the next big refactor
# Line 10865 | Line 10835 | freebsd* | dragonfly*)
10835    case $version_type in
10836      freebsd-elf*)
10837        library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10838 +      soname_spec='$libname$release$shared_ext$major'
10839        need_version=no
10840        need_lib_prefix=no
10841        ;;
# Line 10924 | Line 10895 | hpux9* | hpux10* | hpux11*)
10895      soname_spec='$libname$release$shared_ext$major'
10896      if test 32 = "$HPUX_IA64_MODE"; then
10897        sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10898 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10899      else
10900        sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10901 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10902      fi
10930 –    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10903      ;;
10904    hppa*64*)
10905      shrext_cmds='.sl'
# Line 11079 | Line 11051 | fi
11051    # before this can be enabled.
11052    hardcode_into_libs=yes
11053  
11054 <  # Append ld.so.conf contents to the search path
11054 >  # Ideally, we could use ldconfig to report *all* directores which are
11055 >  # searched for libraries, however this is still not possible.  Aside from not
11056 >  # being certain /sbin/ldconfig is available, command
11057 >  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11058 >  # even though it is searched at run-time.  Try to do the best guess by
11059 >  # appending ld.so.conf contents (and includes) to the search path.
11060    if test -f /etc/ld.so.conf; then
11061      lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[       ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
11062      sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
# Line 11304 | Line 11281 | fi
11281   if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11282    sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11283   fi
11284 +
11285   if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11286    sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11287   fi
11288  
11289 + # remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11290 + configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11291 +
11292 + # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11293 + func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11294 +
11295 + # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11296 + configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11297 +
11298 +
11299 +
11300 +
11301 +
11302 +
11303  
11304  
11305  
# Line 12088 | Line 12080 | CC=$lt_save_CC
12080  
12081  
12082  
12091 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
12092 – $as_echo_n "checking for ANSI C header files... " >&6; }
12093 – if ${ac_cv_header_stdc+:} false; then :
12094 –  $as_echo_n "(cached) " >&6
12095 – else
12096 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12097 – /* end confdefs.h.  */
12098 – #include <stdlib.h>
12099 – #include <stdarg.h>
12100 – #include <string.h>
12101 – #include <float.h>
12102 –
12103 – int
12104 – main ()
12105 – {
12106 –
12107 –  ;
12108 –  return 0;
12109 – }
12110 – _ACEOF
12111 – if ac_fn_c_try_compile "$LINENO"; then :
12112 –  ac_cv_header_stdc=yes
12113 – else
12114 –  ac_cv_header_stdc=no
12115 – fi
12116 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12117 –
12118 – if test $ac_cv_header_stdc = yes; then
12119 –  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
12120 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12121 – /* end confdefs.h.  */
12122 – #include <string.h>
12123 –
12124 – _ACEOF
12125 – if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12126 –  $EGREP "memchr" >/dev/null 2>&1; then :
12127 –
12128 – else
12129 –  ac_cv_header_stdc=no
12130 – fi
12131 – rm -f conftest*
12132 –
12133 – fi
12134 –
12135 – if test $ac_cv_header_stdc = yes; then
12136 –  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
12137 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12138 – /* end confdefs.h.  */
12139 – #include <stdlib.h>
12140 –
12141 – _ACEOF
12142 – if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
12143 –  $EGREP "free" >/dev/null 2>&1; then :
12144 –
12145 – else
12146 –  ac_cv_header_stdc=no
12147 – fi
12148 – rm -f conftest*
12149 –
12150 – fi
12151 –
12152 – if test $ac_cv_header_stdc = yes; then
12153 –  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
12154 –  if test "$cross_compiling" = yes; then :
12155 –  :
12156 – else
12157 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12158 – /* end confdefs.h.  */
12159 – #include <ctype.h>
12160 – #include <stdlib.h>
12161 – #if ((' ' & 0x0FF) == 0x020)
12162 – # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
12163 – # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
12164 – #else
12165 – # define ISLOWER(c) \
12166 –                   (('a' <= (c) && (c) <= 'i') \
12167 –                     || ('j' <= (c) && (c) <= 'r') \
12168 –                     || ('s' <= (c) && (c) <= 'z'))
12169 – # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
12170 – #endif
12171 –
12172 – #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
12173 – int
12174 – main ()
12175 – {
12176 –  int i;
12177 –  for (i = 0; i < 256; i++)
12178 –    if (XOR (islower (i), ISLOWER (i))
12179 –        || toupper (i) != TOUPPER (i))
12180 –      return 2;
12181 –  return 0;
12182 – }
12183 – _ACEOF
12184 – if ac_fn_c_try_run "$LINENO"; then :
12185 –
12186 – else
12187 –  ac_cv_header_stdc=no
12188 – fi
12189 – rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12190 –  conftest.$ac_objext conftest.beam conftest.$ac_ext
12191 – fi
12192 –
12193 – fi
12194 – fi
12195 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
12196 – $as_echo "$ac_cv_header_stdc" >&6; }
12197 – if test $ac_cv_header_stdc = yes; then
12198 –
12199 – $as_echo "#define STDC_HEADERS 1" >>confdefs.h
12200 –
12201 – fi
12202 –
12203 –
12204 – for ac_header in sys/poll.h
12205 – do :
12206 –  ac_fn_c_check_header_mongrel "$LINENO" "sys/poll.h" "ac_cv_header_sys_poll_h" "$ac_includes_default"
12207 – if test "x$ac_cv_header_sys_poll_h" = xyes; then :
12208 –  cat >>confdefs.h <<_ACEOF
12209 – #define HAVE_SYS_POLL_H 1
12210 – _ACEOF
12211 – have_poll_sys_h=yes
12212 – else
12213 –  have_sys_poll_h=no
12214 – fi
12215 –
12216 – done
12217 –
12218 –
12219 – for ac_header in fcntl.h sys/time.h unistd.h strings.h
12220 – do :
12221 –  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
12222 – ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
12223 – if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
12224 –  cat >>confdefs.h <<_ACEOF
12225 – #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
12226 – _ACEOF
12227 –
12228 – fi
12229 –
12230 – done
12231 –
12232 –
12233 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
12234 – $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
12235 – if ${ac_cv_header_time+:} false; then :
12236 –  $as_echo_n "(cached) " >&6
12237 – else
12238 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12239 – /* end confdefs.h.  */
12240 – #include <sys/types.h>
12241 – #include <sys/time.h>
12242 – #include <time.h>
12243 –
12244 – int
12245 – main ()
12246 – {
12247 – if ((struct tm *) 0)
12248 – return 0;
12249 –  ;
12250 –  return 0;
12251 – }
12252 – _ACEOF
12253 – if ac_fn_c_try_compile "$LINENO"; then :
12254 –  ac_cv_header_time=yes
12255 – else
12256 –  ac_cv_header_time=no
12257 – fi
12258 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12259 – fi
12260 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
12261 – $as_echo "$ac_cv_header_time" >&6; }
12262 – if test $ac_cv_header_time = yes; then
12263 –
12264 – $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
12265 –
12266 – fi
12267 –
12268 – { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5
12269 – $as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; }
12270 – if ${ac_cv_struct_tm+:} false; then :
12271 –  $as_echo_n "(cached) " >&6
12272 – else
12273 –  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12274 – /* end confdefs.h.  */
12275 – #include <sys/types.h>
12276 – #include <time.h>
12277 –
12278 – int
12279 – main ()
12280 – {
12281 – struct tm tm;
12282 –                                     int *p = &tm.tm_sec;
12283 –                                     return !p;
12284 –  ;
12285 –  return 0;
12286 – }
12287 – _ACEOF
12288 – if ac_fn_c_try_compile "$LINENO"; then :
12289 –  ac_cv_struct_tm=time.h
12290 – else
12291 –  ac_cv_struct_tm=sys/time.h
12292 – fi
12293 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12294 – fi
12295 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5
12296 – $as_echo "$ac_cv_struct_tm" >&6; }
12297 – if test $ac_cv_struct_tm = sys/time.h; then
12298 –
12299 – $as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h
12300 –
12301 – fi
12302 –
12303 –
12304 –
12083   for ac_prog in 'bison -y' byacc
12084   do
12085    # Extract the first word of "$ac_prog", so it can be a program name with args.
# Line 12509 | Line 12287 | if test "$LEX" = :; then
12287    LEX=${am_missing_run}flex
12288   fi
12289  
12290 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12291 < $as_echo_n "checking for library containing socket... " >&6; }
12292 < if ${ac_cv_search_socket+:} false; then :
12290 >
12291 >
12292 >  if test "X$CC" != "X"; then
12293 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12294 > $as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12295 > if ${ssp_cv_cc+:} false; then :
12296    $as_echo_n "(cached) " >&6
12297   else
12298 <  ac_func_search_save_LIBS=$LIBS
12299 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12298 >  ssp_old_cflags="$CFLAGS"
12299 >       CFLAGS="$CFLAGS -fstack-protector-strong"
12300 >       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12301   /* end confdefs.h.  */
12302  
12521 – /* Override any GCC internal prototype to avoid an error.
12522 –   Use char because int might match the return type of a GCC
12523 –   builtin and then its argument prototype would still apply.  */
12524 – #ifdef __cplusplus
12525 – extern "C"
12526 – #endif
12527 – char socket ();
12303   int
12304   main ()
12305   {
12306 < return socket ();
12306 >
12307    ;
12308    return 0;
12309   }
12310   _ACEOF
12311 < for ac_lib in '' socket; do
12312 <  if test -z "$ac_lib"; then
12313 <    ac_res="none required"
12314 <  else
12540 <    ac_res=-l$ac_lib
12541 <    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12542 <  fi
12543 <  if ac_fn_c_try_link "$LINENO"; then :
12544 <  ac_cv_search_socket=$ac_res
12311 > if ac_fn_c_try_compile "$LINENO"; then :
12312 >  ssp_cv_cc=yes
12313 > else
12314 >  ssp_cv_cc=no
12315   fi
12316 < rm -f core conftest.err conftest.$ac_objext \
12317 <    conftest$ac_exeext
12318 <  if ${ac_cv_search_socket+:} false; then :
12549 <  break
12316 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12317 >       CFLAGS="$ssp_old_cflags"
12318 >
12319   fi
12320 < done
12321 < if ${ac_cv_search_socket+:} false; then :
12320 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12321 > $as_echo "$ssp_cv_cc" >&6; }
12322 >    if test $ssp_cv_cc = yes; then
12323 >      CFLAGS="$CFLAGS -fstack-protector-strong"
12324 >
12325 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12326  
12327 +    else
12328 +      unset ssp_cv_cc
12329 +      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12330 + $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12331 + if ${ssp_cv_cc+:} false; then :
12332 +  $as_echo_n "(cached) " >&6
12333   else
12334 <  ac_cv_search_socket=no
12334 >  ssp_old_cflags="$CFLAGS"
12335 >         CFLAGS="$CFLAGS -fstack-protector"
12336 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12337 > /* end confdefs.h.  */
12338 >
12339 > int
12340 > main ()
12341 > {
12342 >
12343 >  ;
12344 >  return 0;
12345 > }
12346 > _ACEOF
12347 > if ac_fn_c_try_compile "$LINENO"; then :
12348 >  ssp_cv_cc=yes
12349 > else
12350 >  ssp_cv_cc=no
12351   fi
12352 < rm conftest.$ac_ext
12353 < LIBS=$ac_func_search_save_LIBS
12352 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12353 >         CFLAGS="$ssp_old_cflags"
12354 >
12355   fi
12356 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12357 < $as_echo "$ac_cv_search_socket" >&6; }
12358 < ac_res=$ac_cv_search_socket
12359 < if test "$ac_res" != no; then :
12360 <  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12356 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12357 > $as_echo "$ssp_cv_cc" >&6; }
12358 >      if test $ssp_cv_cc = yes; then
12359 >        CFLAGS="$CFLAGS -fstack-protector"
12360 >
12361 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12362 >
12363 >      fi
12364 >    fi
12365 >  fi
12366  
12367 +
12368 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12369 + $as_echo_n "checking whether libssp exists... " >&6; }
12370 + if ${ssp_cv_lib+:} false; then :
12371 +  $as_echo_n "(cached) " >&6
12372   else
12373 <  as_fn_error $? "socket library not found" "$LINENO" 5
12373 >  ssp_old_libs="$LIBS"
12374 >     LIBS="$LIBS -lssp"
12375 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12376 > /* end confdefs.h.  */
12377 >
12378 > int
12379 > main ()
12380 > {
12381 >
12382 >  ;
12383 >  return 0;
12384 > }
12385 > _ACEOF
12386 > if ac_fn_c_try_link "$LINENO"; then :
12387 >  ssp_cv_lib=yes
12388 > else
12389 >  ssp_cv_lib=no
12390   fi
12391 + rm -f core conftest.err conftest.$ac_objext \
12392 +    conftest$ac_exeext conftest.$ac_ext
12393 +     LIBS="$ssp_old_libs"
12394 +
12395 + fi
12396 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12397 + $as_echo "$ssp_cv_lib" >&6; }
12398 +  if test $ssp_cv_lib = yes; then
12399 +    LIBS="$LIBS -lssp"
12400 +  fi
12401 +
12402  
12403 < ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12403 >
12404 >  ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12405   if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12406  
12407   else
# Line 12629 | Line 12463 | fi
12463  
12464   fi
12465  
12466 < ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12466 >  ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12467   if test "x$ac_cv_func_getnameinfo" = xyes; then :
12468  
12469   else
# Line 12691 | Line 12525 | fi
12525  
12526   fi
12527  
12528 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12529 + $as_echo_n "checking for library containing socket... " >&6; }
12530 + if ${ac_cv_search_socket+:} false; then :
12531 +  $as_echo_n "(cached) " >&6
12532 + else
12533 +  ac_func_search_save_LIBS=$LIBS
12534 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12535 + /* end confdefs.h.  */
12536  
12537 < for ac_func in strlcpy strlcat inet_aton socket strdup strstr
12538 < do :
12539 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12540 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12541 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12537 > /* Override any GCC internal prototype to avoid an error.
12538 >   Use char because int might match the return type of a GCC
12539 >   builtin and then its argument prototype would still apply.  */
12540 > #ifdef __cplusplus
12541 > extern "C"
12542 > #endif
12543 > char socket ();
12544 > int
12545 > main ()
12546 > {
12547 > return socket ();
12548 >  ;
12549 >  return 0;
12550 > }
12551 > _ACEOF
12552 > for ac_lib in '' socket; do
12553 >  if test -z "$ac_lib"; then
12554 >    ac_res="none required"
12555 >  else
12556 >    ac_res=-l$ac_lib
12557 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12558 >  fi
12559 >  if ac_fn_c_try_link "$LINENO"; then :
12560 >  ac_cv_search_socket=$ac_res
12561 > fi
12562 > rm -f core conftest.err conftest.$ac_objext \
12563 >    conftest$ac_exeext
12564 >  if ${ac_cv_search_socket+:} false; then :
12565 >  break
12566 > fi
12567 > done
12568 > if ${ac_cv_search_socket+:} false; then :
12569 >
12570 > else
12571 >  ac_cv_search_socket=no
12572 > fi
12573 > rm conftest.$ac_ext
12574 > LIBS=$ac_func_search_save_LIBS
12575 > fi
12576 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12577 > $as_echo "$ac_cv_search_socket" >&6; }
12578 > ac_res=$ac_cv_search_socket
12579 > if test "$ac_res" != no; then :
12580 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12581 >
12582 > else
12583 >  as_fn_error $? "socket library not found" "$LINENO" 5
12584 > fi
12585 >
12586 >
12587 >
12588 > # Check whether --enable-openssl was given.
12589 > if test "${enable_openssl+set}" = set; then :
12590 >  enableval=$enable_openssl;  cf_enable_openssl=$enableval
12591 > else
12592 >   cf_enable_openssl="auto"
12593 > fi
12594 >
12595 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12596 > $as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12597 > if test "$cf_enable_openssl" != "no"; then
12598 >  cf_openssl_basedir=""
12599 >  if test "$cf_enable_openssl" != "auto" &&
12600 >     test "$cf_enable_openssl" != "yes"; then
12601 >          cf_openssl_basedir="${cf_enable_openssl}"
12602 >  else
12603 >        for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12604 >                /opt /opt/openssl /usr/local/openssl; do
12605 >      if test -f "${dirs}/include/openssl/opensslv.h"; then
12606 >        cf_openssl_basedir="${dirs}"
12607 >        break
12608 >      fi
12609 >    done
12610 >    unset dirs
12611 >  fi
12612 >
12613 >    if test ! -z "$cf_openssl_basedir"; then
12614 >    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12615 >      CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12616 >      LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12617 >    else
12618 >                  cf_openssl_basedir=""
12619 >    fi
12620 >  else
12621 >                            if test -f "/usr/include/openssl/opensslv.h"; then
12622 >      cf_openssl_basedir="/usr"
12623 >    fi
12624 >  fi
12625 >
12626 >      if test ! -z "$cf_openssl_basedir"; then
12627 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12628 > $as_echo "$cf_openssl_basedir" >&6; }
12629 >    cf_enable_openssl="yes"
12630 >  else
12631 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12632 > $as_echo "not found. Please check your path." >&6; }
12633 >    cf_enable_openssl="no"
12634 >  fi
12635 >  unset cf_openssl_basedir
12636 > else
12637 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12638 > $as_echo "disabled" >&6; }
12639 > fi
12640 >
12641 > if test "$cf_enable_openssl" != "no"; then :
12642 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 0.9.8o and above" >&5
12643 > $as_echo_n "checking for LibreSSL or OpenSSL 0.9.8o and above... " >&6; }
12644 >  if test "$cross_compiling" = yes; then :
12645 >  cf_openssl_version_ok=no
12646 > else
12647 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12648 > /* end confdefs.h.  */
12649 >
12650 >
12651 >    #include <openssl/opensslv.h>
12652 >    #include <stdlib.h>
12653 > int
12654 > main ()
12655 > {
12656 > exit(!(OPENSSL_VERSION_NUMBER >= 0x009080ffL));
12657 >  ;
12658 >  return 0;
12659 > }
12660 > _ACEOF
12661 > if ac_fn_c_try_run "$LINENO"; then :
12662 >  cf_openssl_version_ok=yes
12663 > else
12664 >  cf_openssl_version_ok=no
12665 > fi
12666 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12667 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
12668 > fi
12669 >
12670 >
12671 >  if test "$cf_openssl_version_ok" = "yes"; then :
12672 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12673 > $as_echo "found" >&6; }
12674 >
12675 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12676 > $as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12677 > if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12678 >  $as_echo_n "(cached) " >&6
12679 > else
12680 >  ac_check_lib_save_LIBS=$LIBS
12681 > LIBS="-lcrypto  $LIBS"
12682 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12683 > /* end confdefs.h.  */
12684 >
12685 > /* Override any GCC internal prototype to avoid an error.
12686 >   Use char because int might match the return type of a GCC
12687 >   builtin and then its argument prototype would still apply.  */
12688 > #ifdef __cplusplus
12689 > extern "C"
12690 > #endif
12691 > char RSA_free ();
12692 > int
12693 > main ()
12694 > {
12695 > return RSA_free ();
12696 >  ;
12697 >  return 0;
12698 > }
12699 > _ACEOF
12700 > if ac_fn_c_try_link "$LINENO"; then :
12701 >  ac_cv_lib_crypto_RSA_free=yes
12702 > else
12703 >  ac_cv_lib_crypto_RSA_free=no
12704 > fi
12705 > rm -f core conftest.err conftest.$ac_objext \
12706 >    conftest$ac_exeext conftest.$ac_ext
12707 > LIBS=$ac_check_lib_save_LIBS
12708 > fi
12709 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12710 > $as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12711 > if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12712    cat >>confdefs.h <<_ACEOF
12713 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12713 > #define HAVE_LIBCRYPTO 1
12714   _ACEOF
12715  
12716 +  LIBS="-lcrypto $LIBS"
12717 +
12718   fi
12705 – done
12719  
12720 +    if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12721 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12722 + $as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12723 + if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12724 +  $as_echo_n "(cached) " >&6
12725 + else
12726 +  ac_check_lib_save_LIBS=$LIBS
12727 + LIBS="-lssl  $LIBS"
12728 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12729 + /* end confdefs.h.  */
12730  
12731 < for ac_func in gethostbyname
12732 < do :
12733 <  ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
12734 < if test "x$ac_cv_func_gethostbyname" = xyes; then :
12731 > /* Override any GCC internal prototype to avoid an error.
12732 >   Use char because int might match the return type of a GCC
12733 >   builtin and then its argument prototype would still apply.  */
12734 > #ifdef __cplusplus
12735 > extern "C"
12736 > #endif
12737 > char SSL_connect ();
12738 > int
12739 > main ()
12740 > {
12741 > return SSL_connect ();
12742 >  ;
12743 >  return 0;
12744 > }
12745 > _ACEOF
12746 > if ac_fn_c_try_link "$LINENO"; then :
12747 >  ac_cv_lib_ssl_SSL_connect=yes
12748 > else
12749 >  ac_cv_lib_ssl_SSL_connect=no
12750 > fi
12751 > rm -f core conftest.err conftest.$ac_objext \
12752 >    conftest$ac_exeext conftest.$ac_ext
12753 > LIBS=$ac_check_lib_save_LIBS
12754 > fi
12755 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12756 > $as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12757 > if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12758    cat >>confdefs.h <<_ACEOF
12759 < #define HAVE_GETHOSTBYNAME 1
12759 > #define HAVE_LIBSSL 1
12760 > _ACEOF
12761 >
12762 >  LIBS="-lssl $LIBS"
12763 >
12764 > fi
12765 >
12766 > fi
12767 >
12768 > else
12769 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12770 > $as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12771 >    cf_enable_openssl="no"
12772 > fi
12773 > fi
12774 >
12775 > if test "$ac_cv_lib_ssl_SSL_connect" = yes; then
12776 >  ENABLE_SSL_TRUE=
12777 >  ENABLE_SSL_FALSE='#'
12778 > else
12779 >  ENABLE_SSL_TRUE='#'
12780 >  ENABLE_SSL_FALSE=
12781 > fi
12782 >
12783 >
12784 >
12785 >  # Check whether --enable-assert was given.
12786 > if test "${enable_assert+set}" = set; then :
12787 >  enableval=$enable_assert; assert=$enableval
12788 > else
12789 >  assert=no
12790 > fi
12791 >
12792 >
12793 >  if test "$assert" = "no"; then :
12794 >
12795 > $as_echo "#define NDEBUG 1" >>confdefs.h
12796 >
12797 > fi
12798 >
12799 >
12800 >  # Check whether --enable-warnings was given.
12801 > if test "${enable_warnings+set}" = set; then :
12802 >  enableval=$enable_warnings; warnings="$enableval"
12803 > else
12804 >  warnings="no"
12805 > fi
12806 >
12807 >
12808 >  if test "$warnings" = "yes"; then :
12809 >
12810 >
12811 >
12812 >
12813 >
12814 > for flag in -Wall; do
12815 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12816 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12817 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12818 > if eval \${$as_CACHEVAR+:} false; then :
12819 >  $as_echo_n "(cached) " >&6
12820 > else
12821 >
12822 >  ax_check_save_flags=$CFLAGS
12823 >  CFLAGS="$CFLAGS  $flag"
12824 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12825 > /* end confdefs.h.  */
12826 >
12827 > int
12828 > main ()
12829 > {
12830 >
12831 >  ;
12832 >  return 0;
12833 > }
12834   _ACEOF
12835 + if ac_fn_c_try_compile "$LINENO"; then :
12836 +  eval "$as_CACHEVAR=yes"
12837 + else
12838 +  eval "$as_CACHEVAR=no"
12839 + fi
12840 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12841 +  CFLAGS=$ax_check_save_flags
12842 + fi
12843 + eval ac_res=\$$as_CACHEVAR
12844 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12845 + $as_echo "$ac_res" >&6; }
12846 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12847 +
12848 + if ${CFLAGS+:} false; then :
12849  
12850 +  case " $CFLAGS " in #(
12851 +  *" $flag "*) :
12852 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12853 +  (: CFLAGS already contains $flag) 2>&5
12854 +  ac_status=$?
12855 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12856 +  test $ac_status = 0; } ;; #(
12857 +  *) :
12858 +
12859 +     as_fn_append CFLAGS " $flag"
12860 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12861 +  (: CFLAGS="$CFLAGS") 2>&5
12862 +  ac_status=$?
12863 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12864 +  test $ac_status = 0; }
12865 +     ;;
12866 + esac
12867 +
12868 + else
12869 +
12870 +  CFLAGS=$flag
12871 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12872 +  (: CFLAGS="$CFLAGS") 2>&5
12873 +  ac_status=$?
12874 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12875 +  test $ac_status = 0; }
12876 +
12877 + fi
12878 +
12879 + else
12880 +  :
12881   fi
12882 +
12883   done
12884  
12885  
12886 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
12887 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
12888 < if ${ac_cv_c_bigendian+:} false; then :
12886 >
12887 >
12888 >
12889 > for flag in -Wbad-function-cast; do
12890 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12891 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12892 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12893 > if eval \${$as_CACHEVAR+:} false; then :
12894    $as_echo_n "(cached) " >&6
12895   else
12896 <  ac_cv_c_bigendian=unknown
12897 <    # See if we're dealing with a universal compiler.
12898 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12896 >
12897 >  ax_check_save_flags=$CFLAGS
12898 >  CFLAGS="$CFLAGS  $flag"
12899 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12900   /* end confdefs.h.  */
12729 – #ifndef __APPLE_CC__
12730 –               not a universal capable compiler
12731 –             #endif
12732 –             typedef int dummy;
12901  
12902 + int
12903 + main ()
12904 + {
12905 +
12906 +  ;
12907 +  return 0;
12908 + }
12909   _ACEOF
12910   if ac_fn_c_try_compile "$LINENO"; then :
12911 +  eval "$as_CACHEVAR=yes"
12912 + else
12913 +  eval "$as_CACHEVAR=no"
12914 + fi
12915 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12916 +  CFLAGS=$ax_check_save_flags
12917 + fi
12918 + eval ac_res=\$$as_CACHEVAR
12919 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12920 + $as_echo "$ac_res" >&6; }
12921 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12922 +
12923 + if ${CFLAGS+:} false; then :
12924 +
12925 +  case " $CFLAGS " in #(
12926 +  *" $flag "*) :
12927 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12928 +  (: CFLAGS already contains $flag) 2>&5
12929 +  ac_status=$?
12930 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12931 +  test $ac_status = 0; } ;; #(
12932 +  *) :
12933 +
12934 +     as_fn_append CFLAGS " $flag"
12935 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12936 +  (: CFLAGS="$CFLAGS") 2>&5
12937 +  ac_status=$?
12938 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12939 +  test $ac_status = 0; }
12940 +     ;;
12941 + esac
12942 +
12943 + else
12944 +
12945 +  CFLAGS=$flag
12946 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12947 +  (: CFLAGS="$CFLAGS") 2>&5
12948 +  ac_status=$?
12949 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12950 +  test $ac_status = 0; }
12951  
12952 <        # Check for potential -arch flags.  It is not universal unless
12953 <        # there are at least two -arch flags with different values.
12954 <        ac_arch=
12955 <        ac_prev=
12956 <        for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12957 <         if test -n "$ac_prev"; then
12958 <           case $ac_word in
12959 <             i?86 | x86_64 | ppc | ppc64)
12960 <               if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12961 <                 ac_arch=$ac_word
12962 <               else
12963 <                 ac_cv_c_bigendian=universal
12964 <                 break
12965 <               fi
12966 <               ;;
12967 <           esac
12968 <           ac_prev=
12969 <         elif test "x$ac_word" = "x-arch"; then
12970 <           ac_prev=arch
12971 <         fi
12972 <       done
12952 > fi
12953 >
12954 > else
12955 >  :
12956 > fi
12957 >
12958 > done
12959 >
12960 >
12961 >
12962 >
12963 >
12964 > for flag in -Wcast-align; do
12965 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12966 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12967 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12968 > if eval \${$as_CACHEVAR+:} false; then :
12969 >  $as_echo_n "(cached) " >&6
12970 > else
12971 >
12972 >  ax_check_save_flags=$CFLAGS
12973 >  CFLAGS="$CFLAGS  $flag"
12974 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12975 > /* end confdefs.h.  */
12976 >
12977 > int
12978 > main ()
12979 > {
12980 >
12981 >  ;
12982 >  return 0;
12983 > }
12984 > _ACEOF
12985 > if ac_fn_c_try_compile "$LINENO"; then :
12986 >  eval "$as_CACHEVAR=yes"
12987 > else
12988 >  eval "$as_CACHEVAR=no"
12989   fi
12990   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12991 <    if test $ac_cv_c_bigendian = unknown; then
12992 <      # See if sys/param.h defines the BYTE_ORDER macro.
12993 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12991 >  CFLAGS=$ax_check_save_flags
12992 > fi
12993 > eval ac_res=\$$as_CACHEVAR
12994 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12995 > $as_echo "$ac_res" >&6; }
12996 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12997 >
12998 > if ${CFLAGS+:} false; then :
12999 >
13000 >  case " $CFLAGS " in #(
13001 >  *" $flag "*) :
13002 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13003 >  (: CFLAGS already contains $flag) 2>&5
13004 >  ac_status=$?
13005 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13006 >  test $ac_status = 0; } ;; #(
13007 >  *) :
13008 >
13009 >     as_fn_append CFLAGS " $flag"
13010 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13011 >  (: CFLAGS="$CFLAGS") 2>&5
13012 >  ac_status=$?
13013 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13014 >  test $ac_status = 0; }
13015 >     ;;
13016 > esac
13017 >
13018 > else
13019 >
13020 >  CFLAGS=$flag
13021 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13022 >  (: CFLAGS="$CFLAGS") 2>&5
13023 >  ac_status=$?
13024 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13025 >  test $ac_status = 0; }
13026 >
13027 > fi
13028 >
13029 > else
13030 >  :
13031 > fi
13032 >
13033 > done
13034 >
13035 >
13036 >
13037 >
13038 >
13039 > for flag in -Wcast-qual; do
13040 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13041 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13042 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13043 > if eval \${$as_CACHEVAR+:} false; then :
13044 >  $as_echo_n "(cached) " >&6
13045 > else
13046 >
13047 >  ax_check_save_flags=$CFLAGS
13048 >  CFLAGS="$CFLAGS  $flag"
13049 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13050   /* end confdefs.h.  */
12764 – #include <sys/types.h>
12765 –             #include <sys/param.h>
13051  
13052   int
13053   main ()
13054   {
12770 – #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
12771 –                     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
12772 –                     && LITTLE_ENDIAN)
12773 –              bogus endian macros
12774 –             #endif
13055  
13056    ;
13057    return 0;
13058   }
13059   _ACEOF
13060   if ac_fn_c_try_compile "$LINENO"; then :
13061 <  # It does; now see whether it defined to BIG_ENDIAN or not.
13062 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13061 >  eval "$as_CACHEVAR=yes"
13062 > else
13063 >  eval "$as_CACHEVAR=no"
13064 > fi
13065 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13066 >  CFLAGS=$ax_check_save_flags
13067 > fi
13068 > eval ac_res=\$$as_CACHEVAR
13069 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13070 > $as_echo "$ac_res" >&6; }
13071 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13072 >
13073 > if ${CFLAGS+:} false; then :
13074 >
13075 >  case " $CFLAGS " in #(
13076 >  *" $flag "*) :
13077 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13078 >  (: CFLAGS already contains $flag) 2>&5
13079 >  ac_status=$?
13080 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13081 >  test $ac_status = 0; } ;; #(
13082 >  *) :
13083 >
13084 >     as_fn_append CFLAGS " $flag"
13085 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13086 >  (: CFLAGS="$CFLAGS") 2>&5
13087 >  ac_status=$?
13088 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13089 >  test $ac_status = 0; }
13090 >     ;;
13091 > esac
13092 >
13093 > else
13094 >
13095 >  CFLAGS=$flag
13096 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13097 >  (: CFLAGS="$CFLAGS") 2>&5
13098 >  ac_status=$?
13099 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13100 >  test $ac_status = 0; }
13101 >
13102 > fi
13103 >
13104 > else
13105 >  :
13106 > fi
13107 >
13108 > done
13109 >
13110 >
13111 >
13112 >
13113 >
13114 > for flag in -Wclobbered; do
13115 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13116 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13117 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13118 > if eval \${$as_CACHEVAR+:} false; then :
13119 >  $as_echo_n "(cached) " >&6
13120 > else
13121 >
13122 >  ax_check_save_flags=$CFLAGS
13123 >  CFLAGS="$CFLAGS  $flag"
13124 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13125   /* end confdefs.h.  */
12784 – #include <sys/types.h>
12785 –                #include <sys/param.h>
13126  
13127   int
13128   main ()
13129   {
12790 – #if BYTE_ORDER != BIG_ENDIAN
12791 –                 not big endian
12792 –                #endif
13130  
13131    ;
13132    return 0;
13133   }
13134   _ACEOF
13135   if ac_fn_c_try_compile "$LINENO"; then :
13136 <  ac_cv_c_bigendian=yes
13136 >  eval "$as_CACHEVAR=yes"
13137   else
13138 <  ac_cv_c_bigendian=no
13138 >  eval "$as_CACHEVAR=no"
13139   fi
13140   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13141 +  CFLAGS=$ax_check_save_flags
13142 + fi
13143 + eval ac_res=\$$as_CACHEVAR
13144 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13145 + $as_echo "$ac_res" >&6; }
13146 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13147 +
13148 + if ${CFLAGS+:} false; then :
13149 +
13150 +  case " $CFLAGS " in #(
13151 +  *" $flag "*) :
13152 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13153 +  (: CFLAGS already contains $flag) 2>&5
13154 +  ac_status=$?
13155 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13156 +  test $ac_status = 0; } ;; #(
13157 +  *) :
13158 +
13159 +     as_fn_append CFLAGS " $flag"
13160 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13161 +  (: CFLAGS="$CFLAGS") 2>&5
13162 +  ac_status=$?
13163 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13164 +  test $ac_status = 0; }
13165 +     ;;
13166 + esac
13167 +
13168 + else
13169 +
13170 +  CFLAGS=$flag
13171 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13172 +  (: CFLAGS="$CFLAGS") 2>&5
13173 +  ac_status=$?
13174 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13175 +  test $ac_status = 0; }
13176 +
13177 + fi
13178 +
13179 + else
13180 +  :
13181 + fi
13182 +
13183 + done
13184 +
13185 +
13186 +
13187 +
13188 +
13189 + for flag in -Wduplicated-cond; do
13190 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13191 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13192 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13193 + if eval \${$as_CACHEVAR+:} false; then :
13194 +  $as_echo_n "(cached) " >&6
13195 + else
13196 +
13197 +  ax_check_save_flags=$CFLAGS
13198 +  CFLAGS="$CFLAGS  $flag"
13199 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13200 + /* end confdefs.h.  */
13201 +
13202 + int
13203 + main ()
13204 + {
13205 +
13206 +  ;
13207 +  return 0;
13208 + }
13209 + _ACEOF
13210 + if ac_fn_c_try_compile "$LINENO"; then :
13211 +  eval "$as_CACHEVAR=yes"
13212 + else
13213 +  eval "$as_CACHEVAR=no"
13214   fi
13215   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13216 <    fi
13217 <    if test $ac_cv_c_bigendian = unknown; then
13218 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13219 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13216 >  CFLAGS=$ax_check_save_flags
13217 > fi
13218 > eval ac_res=\$$as_CACHEVAR
13219 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13220 > $as_echo "$ac_res" >&6; }
13221 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13222 >
13223 > if ${CFLAGS+:} false; then :
13224 >
13225 >  case " $CFLAGS " in #(
13226 >  *" $flag "*) :
13227 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13228 >  (: CFLAGS already contains $flag) 2>&5
13229 >  ac_status=$?
13230 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13231 >  test $ac_status = 0; } ;; #(
13232 >  *) :
13233 >
13234 >     as_fn_append CFLAGS " $flag"
13235 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13236 >  (: CFLAGS="$CFLAGS") 2>&5
13237 >  ac_status=$?
13238 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13239 >  test $ac_status = 0; }
13240 >     ;;
13241 > esac
13242 >
13243 > else
13244 >
13245 >  CFLAGS=$flag
13246 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13247 >  (: CFLAGS="$CFLAGS") 2>&5
13248 >  ac_status=$?
13249 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13250 >  test $ac_status = 0; }
13251 >
13252 > fi
13253 >
13254 > else
13255 >  :
13256 > fi
13257 >
13258 > done
13259 >
13260 >
13261 >
13262 >
13263 >
13264 > for flag in -Wempty-body; do
13265 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13266 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13267 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13268 > if eval \${$as_CACHEVAR+:} false; then :
13269 >  $as_echo_n "(cached) " >&6
13270 > else
13271 >
13272 >  ax_check_save_flags=$CFLAGS
13273 >  CFLAGS="$CFLAGS  $flag"
13274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13275   /* end confdefs.h.  */
12811 – #include <limits.h>
13276  
13277   int
13278   main ()
13279   {
12816 – #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
12817 –              bogus endian macros
12818 –             #endif
13280  
13281    ;
13282    return 0;
13283   }
13284   _ACEOF
13285   if ac_fn_c_try_compile "$LINENO"; then :
13286 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
13287 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13286 >  eval "$as_CACHEVAR=yes"
13287 > else
13288 >  eval "$as_CACHEVAR=no"
13289 > fi
13290 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13291 >  CFLAGS=$ax_check_save_flags
13292 > fi
13293 > eval ac_res=\$$as_CACHEVAR
13294 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13295 > $as_echo "$ac_res" >&6; }
13296 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13297 >
13298 > if ${CFLAGS+:} false; then :
13299 >
13300 >  case " $CFLAGS " in #(
13301 >  *" $flag "*) :
13302 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13303 >  (: CFLAGS already contains $flag) 2>&5
13304 >  ac_status=$?
13305 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13306 >  test $ac_status = 0; } ;; #(
13307 >  *) :
13308 >
13309 >     as_fn_append CFLAGS " $flag"
13310 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13311 >  (: CFLAGS="$CFLAGS") 2>&5
13312 >  ac_status=$?
13313 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13314 >  test $ac_status = 0; }
13315 >     ;;
13316 > esac
13317 >
13318 > else
13319 >
13320 >  CFLAGS=$flag
13321 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13322 >  (: CFLAGS="$CFLAGS") 2>&5
13323 >  ac_status=$?
13324 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13325 >  test $ac_status = 0; }
13326 >
13327 > fi
13328 >
13329 > else
13330 >  :
13331 > fi
13332 >
13333 > done
13334 >
13335 >
13336 >
13337 >
13338 >
13339 > for flag in -Wignored-qualifiers; do
13340 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13341 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13342 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13343 > if eval \${$as_CACHEVAR+:} false; then :
13344 >  $as_echo_n "(cached) " >&6
13345 > else
13346 >
13347 >  ax_check_save_flags=$CFLAGS
13348 >  CFLAGS="$CFLAGS  $flag"
13349 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13350   /* end confdefs.h.  */
12828 – #include <limits.h>
13351  
13352   int
13353   main ()
13354   {
12833 – #ifndef _BIG_ENDIAN
12834 –                 not big endian
12835 –                #endif
13355  
13356    ;
13357    return 0;
13358   }
13359   _ACEOF
13360   if ac_fn_c_try_compile "$LINENO"; then :
13361 <  ac_cv_c_bigendian=yes
13361 >  eval "$as_CACHEVAR=yes"
13362   else
13363 <  ac_cv_c_bigendian=no
13363 >  eval "$as_CACHEVAR=no"
13364   fi
13365   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13366 +  CFLAGS=$ax_check_save_flags
13367 + fi
13368 + eval ac_res=\$$as_CACHEVAR
13369 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13370 + $as_echo "$ac_res" >&6; }
13371 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13372 +
13373 + if ${CFLAGS+:} false; then :
13374 +
13375 +  case " $CFLAGS " in #(
13376 +  *" $flag "*) :
13377 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13378 +  (: CFLAGS already contains $flag) 2>&5
13379 +  ac_status=$?
13380 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13381 +  test $ac_status = 0; } ;; #(
13382 +  *) :
13383 +
13384 +     as_fn_append CFLAGS " $flag"
13385 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13386 +  (: CFLAGS="$CFLAGS") 2>&5
13387 +  ac_status=$?
13388 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13389 +  test $ac_status = 0; }
13390 +     ;;
13391 + esac
13392 +
13393 + else
13394 +
13395 +  CFLAGS=$flag
13396 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13397 +  (: CFLAGS="$CFLAGS") 2>&5
13398 +  ac_status=$?
13399 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13400 +  test $ac_status = 0; }
13401 +
13402 + fi
13403 +
13404 + else
13405 +  :
13406 + fi
13407 +
13408 + done
13409 +
13410 +
13411 +
13412 +
13413 +
13414 + for flag in -Wlogical-op; do
13415 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13416 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13417 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13418 + if eval \${$as_CACHEVAR+:} false; then :
13419 +  $as_echo_n "(cached) " >&6
13420 + else
13421 +
13422 +  ax_check_save_flags=$CFLAGS
13423 +  CFLAGS="$CFLAGS  $flag"
13424 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13425 + /* end confdefs.h.  */
13426 +
13427 + int
13428 + main ()
13429 + {
13430 +
13431 +  ;
13432 +  return 0;
13433 + }
13434 + _ACEOF
13435 + if ac_fn_c_try_compile "$LINENO"; then :
13436 +  eval "$as_CACHEVAR=yes"
13437 + else
13438 +  eval "$as_CACHEVAR=no"
13439   fi
13440   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13441 <    fi
13442 <    if test $ac_cv_c_bigendian = unknown; then
13443 <      # Compile a test program.
13444 <      if test "$cross_compiling" = yes; then :
13445 <  # Try to guess by grepping values from an object file.
13446 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13441 >  CFLAGS=$ax_check_save_flags
13442 > fi
13443 > eval ac_res=\$$as_CACHEVAR
13444 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13445 > $as_echo "$ac_res" >&6; }
13446 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13447 >
13448 > if ${CFLAGS+:} false; then :
13449 >
13450 >  case " $CFLAGS " in #(
13451 >  *" $flag "*) :
13452 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13453 >  (: CFLAGS already contains $flag) 2>&5
13454 >  ac_status=$?
13455 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13456 >  test $ac_status = 0; } ;; #(
13457 >  *) :
13458 >
13459 >     as_fn_append CFLAGS " $flag"
13460 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13461 >  (: CFLAGS="$CFLAGS") 2>&5
13462 >  ac_status=$?
13463 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13464 >  test $ac_status = 0; }
13465 >     ;;
13466 > esac
13467 >
13468 > else
13469 >
13470 >  CFLAGS=$flag
13471 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13472 >  (: CFLAGS="$CFLAGS") 2>&5
13473 >  ac_status=$?
13474 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13475 >  test $ac_status = 0; }
13476 >
13477 > fi
13478 >
13479 > else
13480 >  :
13481 > fi
13482 >
13483 > done
13484 >
13485 >
13486 >
13487 >
13488 >
13489 > for flag in -Wmissing-declarations; do
13490 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13491 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13492 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13493 > if eval \${$as_CACHEVAR+:} false; then :
13494 >  $as_echo_n "(cached) " >&6
13495 > else
13496 >
13497 >  ax_check_save_flags=$CFLAGS
13498 >  CFLAGS="$CFLAGS  $flag"
13499 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13500   /* end confdefs.h.  */
12856 – short int ascii_mm[] =
12857 –                  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
12858 –                short int ascii_ii[] =
12859 –                  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
12860 –                int use_ascii (int i) {
12861 –                  return ascii_mm[i] + ascii_ii[i];
12862 –                }
12863 –                short int ebcdic_ii[] =
12864 –                  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
12865 –                short int ebcdic_mm[] =
12866 –                  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
12867 –                int use_ebcdic (int i) {
12868 –                  return ebcdic_mm[i] + ebcdic_ii[i];
12869 –                }
12870 –                extern int foo;
13501  
13502   int
13503   main ()
13504   {
13505 < return use_ascii (foo) == use_ebcdic (foo);
13505 >
13506    ;
13507    return 0;
13508   }
13509   _ACEOF
13510   if ac_fn_c_try_compile "$LINENO"; then :
13511 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
13512 <              ac_cv_c_bigendian=yes
13513 <            fi
13514 <            if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
13515 <              if test "$ac_cv_c_bigendian" = unknown; then
13516 <                ac_cv_c_bigendian=no
13517 <              else
13518 <                # finding both strings is unlikely to happen, but who knows?
13519 <                ac_cv_c_bigendian=unknown
13520 <              fi
13521 <            fi
13511 >  eval "$as_CACHEVAR=yes"
13512 > else
13513 >  eval "$as_CACHEVAR=no"
13514 > fi
13515 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13516 >  CFLAGS=$ax_check_save_flags
13517 > fi
13518 > eval ac_res=\$$as_CACHEVAR
13519 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13520 > $as_echo "$ac_res" >&6; }
13521 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13522 >
13523 > if ${CFLAGS+:} false; then :
13524 >
13525 >  case " $CFLAGS " in #(
13526 >  *" $flag "*) :
13527 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13528 >  (: CFLAGS already contains $flag) 2>&5
13529 >  ac_status=$?
13530 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13531 >  test $ac_status = 0; } ;; #(
13532 >  *) :
13533 >
13534 >     as_fn_append CFLAGS " $flag"
13535 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13536 >  (: CFLAGS="$CFLAGS") 2>&5
13537 >  ac_status=$?
13538 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13539 >  test $ac_status = 0; }
13540 >     ;;
13541 > esac
13542 >
13543 > else
13544 >
13545 >  CFLAGS=$flag
13546 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13547 >  (: CFLAGS="$CFLAGS") 2>&5
13548 >  ac_status=$?
13549 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13550 >  test $ac_status = 0; }
13551 >
13552 > fi
13553 >
13554 > else
13555 >  :
13556 > fi
13557 >
13558 > done
13559 >
13560 >
13561 >
13562 >
13563 >
13564 > for flag in -Wmissing-field-initializers; do
13565 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13566 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13567 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13568 > if eval \${$as_CACHEVAR+:} false; then :
13569 >  $as_echo_n "(cached) " >&6
13570 > else
13571 >
13572 >  ax_check_save_flags=$CFLAGS
13573 >  CFLAGS="$CFLAGS  $flag"
13574 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13575 > /* end confdefs.h.  */
13576 >
13577 > int
13578 > main ()
13579 > {
13580 >
13581 >  ;
13582 >  return 0;
13583 > }
13584 > _ACEOF
13585 > if ac_fn_c_try_compile "$LINENO"; then :
13586 >  eval "$as_CACHEVAR=yes"
13587 > else
13588 >  eval "$as_CACHEVAR=no"
13589   fi
13590   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13591 +  CFLAGS=$ax_check_save_flags
13592 + fi
13593 + eval ac_res=\$$as_CACHEVAR
13594 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13595 + $as_echo "$ac_res" >&6; }
13596 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13597 +
13598 + if ${CFLAGS+:} false; then :
13599 +
13600 +  case " $CFLAGS " in #(
13601 +  *" $flag "*) :
13602 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13603 +  (: CFLAGS already contains $flag) 2>&5
13604 +  ac_status=$?
13605 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13606 +  test $ac_status = 0; } ;; #(
13607 +  *) :
13608 +
13609 +     as_fn_append CFLAGS " $flag"
13610 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13611 +  (: CFLAGS="$CFLAGS") 2>&5
13612 +  ac_status=$?
13613 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13614 +  test $ac_status = 0; }
13615 +     ;;
13616 + esac
13617 +
13618 + else
13619 +
13620 +  CFLAGS=$flag
13621 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13622 +  (: CFLAGS="$CFLAGS") 2>&5
13623 +  ac_status=$?
13624 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13625 +  test $ac_status = 0; }
13626 +
13627 + fi
13628 +
13629 + else
13630 +  :
13631 + fi
13632 +
13633 + done
13634 +
13635 +
13636 +
13637 +
13638 +
13639 + for flag in -Wmissing-include-dirs; do
13640 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13641 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13642 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13643 + if eval \${$as_CACHEVAR+:} false; then :
13644 +  $as_echo_n "(cached) " >&6
13645   else
13646 +
13647 +  ax_check_save_flags=$CFLAGS
13648 +  CFLAGS="$CFLAGS  $flag"
13649    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13650   /* end confdefs.h.  */
13651 < $ac_includes_default
13651 >
13652   int
13653   main ()
13654   {
13655  
13656 <             /* Are we little or big endian?  From Harbison&Steele.  */
13657 <             union
13658 <             {
13659 <               long int l;
13660 <               char c[sizeof (long int)];
13661 <             } u;
13662 <             u.l = 1;
13663 <             return u.c[sizeof (long int) - 1] == 1;
13656 >  ;
13657 >  return 0;
13658 > }
13659 > _ACEOF
13660 > if ac_fn_c_try_compile "$LINENO"; then :
13661 >  eval "$as_CACHEVAR=yes"
13662 > else
13663 >  eval "$as_CACHEVAR=no"
13664 > fi
13665 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13666 >  CFLAGS=$ax_check_save_flags
13667 > fi
13668 > eval ac_res=\$$as_CACHEVAR
13669 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13670 > $as_echo "$ac_res" >&6; }
13671 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13672 >
13673 > if ${CFLAGS+:} false; then :
13674 >
13675 >  case " $CFLAGS " in #(
13676 >  *" $flag "*) :
13677 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13678 >  (: CFLAGS already contains $flag) 2>&5
13679 >  ac_status=$?
13680 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13681 >  test $ac_status = 0; } ;; #(
13682 >  *) :
13683 >
13684 >     as_fn_append CFLAGS " $flag"
13685 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13686 >  (: CFLAGS="$CFLAGS") 2>&5
13687 >  ac_status=$?
13688 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13689 >  test $ac_status = 0; }
13690 >     ;;
13691 > esac
13692 >
13693 > else
13694 >
13695 >  CFLAGS=$flag
13696 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13697 >  (: CFLAGS="$CFLAGS") 2>&5
13698 >  ac_status=$?
13699 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13700 >  test $ac_status = 0; }
13701 >
13702 > fi
13703 >
13704 > else
13705 >  :
13706 > fi
13707 >
13708 > done
13709 >
13710 >
13711 >
13712 >
13713 >
13714 > for flag in -Wmissing-parameter-type; do
13715 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13716 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13717 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13718 > if eval \${$as_CACHEVAR+:} false; then :
13719 >  $as_echo_n "(cached) " >&6
13720 > else
13721 >
13722 >  ax_check_save_flags=$CFLAGS
13723 >  CFLAGS="$CFLAGS  $flag"
13724 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13725 > /* end confdefs.h.  */
13726 >
13727 > int
13728 > main ()
13729 > {
13730  
13731    ;
13732    return 0;
13733   }
13734   _ACEOF
13735 < if ac_fn_c_try_run "$LINENO"; then :
13736 <  ac_cv_c_bigendian=no
13735 > if ac_fn_c_try_compile "$LINENO"; then :
13736 >  eval "$as_CACHEVAR=yes"
13737   else
13738 <  ac_cv_c_bigendian=yes
13738 >  eval "$as_CACHEVAR=no"
13739   fi
13740 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
13741 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
13740 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13741 >  CFLAGS=$ax_check_save_flags
13742   fi
13743 + eval ac_res=\$$as_CACHEVAR
13744 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13745 + $as_echo "$ac_res" >&6; }
13746 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13747 +
13748 + if ${CFLAGS+:} false; then :
13749 +
13750 +  case " $CFLAGS " in #(
13751 +  *" $flag "*) :
13752 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13753 +  (: CFLAGS already contains $flag) 2>&5
13754 +  ac_status=$?
13755 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13756 +  test $ac_status = 0; } ;; #(
13757 +  *) :
13758 +
13759 +     as_fn_append CFLAGS " $flag"
13760 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13761 +  (: CFLAGS="$CFLAGS") 2>&5
13762 +  ac_status=$?
13763 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13764 +  test $ac_status = 0; }
13765 +     ;;
13766 + esac
13767 +
13768 + else
13769 +
13770 +  CFLAGS=$flag
13771 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13772 +  (: CFLAGS="$CFLAGS") 2>&5
13773 +  ac_status=$?
13774 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13775 +  test $ac_status = 0; }
13776  
12924 –    fi
13777   fi
12926 – { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
12927 – $as_echo "$ac_cv_c_bigendian" >&6; }
12928 – case $ac_cv_c_bigendian in #(
12929 –   yes)
12930 –     $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h
12931 – ;; #(
12932 –   no)
12933 –      ;; #(
12934 –   universal)
13778  
13779 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13779 > else
13780 >  :
13781 > fi
13782 >
13783 > done
13784 >
13785 >
13786 >
13787 >
13788 >
13789 > for flag in -Wmissing-prototypes; do
13790 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13791 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13792 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13793 > if eval \${$as_CACHEVAR+:} false; then :
13794 >  $as_echo_n "(cached) " >&6
13795 > else
13796 >
13797 >  ax_check_save_flags=$CFLAGS
13798 >  CFLAGS="$CFLAGS  $flag"
13799 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13800 > /* end confdefs.h.  */
13801 >
13802 > int
13803 > main ()
13804 > {
13805 >
13806 >  ;
13807 >  return 0;
13808 > }
13809 > _ACEOF
13810 > if ac_fn_c_try_compile "$LINENO"; then :
13811 >  eval "$as_CACHEVAR=yes"
13812 > else
13813 >  eval "$as_CACHEVAR=no"
13814 > fi
13815 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13816 >  CFLAGS=$ax_check_save_flags
13817 > fi
13818 > eval ac_res=\$$as_CACHEVAR
13819 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13820 > $as_echo "$ac_res" >&6; }
13821 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13822 >
13823 > if ${CFLAGS+:} false; then :
13824 >
13825 >  case " $CFLAGS " in #(
13826 >  *" $flag "*) :
13827 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13828 >  (: CFLAGS already contains $flag) 2>&5
13829 >  ac_status=$?
13830 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13831 >  test $ac_status = 0; } ;; #(
13832 >  *) :
13833 >
13834 >     as_fn_append CFLAGS " $flag"
13835 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13836 >  (: CFLAGS="$CFLAGS") 2>&5
13837 >  ac_status=$?
13838 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13839 >  test $ac_status = 0; }
13840 >     ;;
13841 > esac
13842 >
13843 > else
13844 >
13845 >  CFLAGS=$flag
13846 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13847 >  (: CFLAGS="$CFLAGS") 2>&5
13848 >  ac_status=$?
13849 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13850 >  test $ac_status = 0; }
13851 >
13852 > fi
13853 >
13854 > else
13855 >  :
13856 > fi
13857 >
13858 > done
13859 >
13860 >
13861 >
13862 >
13863 >
13864 > for flag in -Wnested-externs; do
13865 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13866 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13867 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13868 > if eval \${$as_CACHEVAR+:} false; then :
13869 >  $as_echo_n "(cached) " >&6
13870 > else
13871 >
13872 >  ax_check_save_flags=$CFLAGS
13873 >  CFLAGS="$CFLAGS  $flag"
13874 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13875 > /* end confdefs.h.  */
13876 >
13877 > int
13878 > main ()
13879 > {
13880 >
13881 >  ;
13882 >  return 0;
13883 > }
13884 > _ACEOF
13885 > if ac_fn_c_try_compile "$LINENO"; then :
13886 >  eval "$as_CACHEVAR=yes"
13887 > else
13888 >  eval "$as_CACHEVAR=no"
13889 > fi
13890 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13891 >  CFLAGS=$ax_check_save_flags
13892 > fi
13893 > eval ac_res=\$$as_CACHEVAR
13894 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13895 > $as_echo "$ac_res" >&6; }
13896 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13897 >
13898 > if ${CFLAGS+:} false; then :
13899 >
13900 >  case " $CFLAGS " in #(
13901 >  *" $flag "*) :
13902 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13903 >  (: CFLAGS already contains $flag) 2>&5
13904 >  ac_status=$?
13905 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13906 >  test $ac_status = 0; } ;; #(
13907 >  *) :
13908 >
13909 >     as_fn_append CFLAGS " $flag"
13910 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13911 >  (: CFLAGS="$CFLAGS") 2>&5
13912 >  ac_status=$?
13913 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13914 >  test $ac_status = 0; }
13915 >     ;;
13916 > esac
13917 >
13918 > else
13919 >
13920 >  CFLAGS=$flag
13921 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13922 >  (: CFLAGS="$CFLAGS") 2>&5
13923 >  ac_status=$?
13924 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13925 >  test $ac_status = 0; }
13926 >
13927 > fi
13928 >
13929 > else
13930 >  :
13931 > fi
13932 >
13933 > done
13934 >
13935 >
13936 >
13937 >
13938 >
13939 > for flag in -Wold-style-declaration; do
13940 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13941 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13942 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13943 > if eval \${$as_CACHEVAR+:} false; then :
13944 >  $as_echo_n "(cached) " >&6
13945 > else
13946 >
13947 >  ax_check_save_flags=$CFLAGS
13948 >  CFLAGS="$CFLAGS  $flag"
13949 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13950 > /* end confdefs.h.  */
13951 >
13952 > int
13953 > main ()
13954 > {
13955 >
13956 >  ;
13957 >  return 0;
13958 > }
13959 > _ACEOF
13960 > if ac_fn_c_try_compile "$LINENO"; then :
13961 >  eval "$as_CACHEVAR=yes"
13962 > else
13963 >  eval "$as_CACHEVAR=no"
13964 > fi
13965 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13966 >  CFLAGS=$ax_check_save_flags
13967 > fi
13968 > eval ac_res=\$$as_CACHEVAR
13969 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13970 > $as_echo "$ac_res" >&6; }
13971 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13972 >
13973 > if ${CFLAGS+:} false; then :
13974 >
13975 >  case " $CFLAGS " in #(
13976 >  *" $flag "*) :
13977 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13978 >  (: CFLAGS already contains $flag) 2>&5
13979 >  ac_status=$?
13980 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13981 >  test $ac_status = 0; } ;; #(
13982 >  *) :
13983 >
13984 >     as_fn_append CFLAGS " $flag"
13985 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13986 >  (: CFLAGS="$CFLAGS") 2>&5
13987 >  ac_status=$?
13988 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13989 >  test $ac_status = 0; }
13990 >     ;;
13991 > esac
13992 >
13993 > else
13994 >
13995 >  CFLAGS=$flag
13996 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13997 >  (: CFLAGS="$CFLAGS") 2>&5
13998 >  ac_status=$?
13999 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14000 >  test $ac_status = 0; }
14001 >
14002 > fi
14003 >
14004 > else
14005 >  :
14006 > fi
14007 >
14008 > done
14009 >
14010 >
14011 >
14012 >
14013 >
14014 > for flag in -Woverride-init; do
14015 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14016 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14017 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14018 > if eval \${$as_CACHEVAR+:} false; then :
14019 >  $as_echo_n "(cached) " >&6
14020 > else
14021 >
14022 >  ax_check_save_flags=$CFLAGS
14023 >  CFLAGS="$CFLAGS  $flag"
14024 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14025 > /* end confdefs.h.  */
14026 >
14027 > int
14028 > main ()
14029 > {
14030 >
14031 >  ;
14032 >  return 0;
14033 > }
14034 > _ACEOF
14035 > if ac_fn_c_try_compile "$LINENO"; then :
14036 >  eval "$as_CACHEVAR=yes"
14037 > else
14038 >  eval "$as_CACHEVAR=no"
14039 > fi
14040 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14041 >  CFLAGS=$ax_check_save_flags
14042 > fi
14043 > eval ac_res=\$$as_CACHEVAR
14044 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14045 > $as_echo "$ac_res" >&6; }
14046 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14047 >
14048 > if ${CFLAGS+:} false; then :
14049 >
14050 >  case " $CFLAGS " in #(
14051 >  *" $flag "*) :
14052 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14053 >  (: CFLAGS already contains $flag) 2>&5
14054 >  ac_status=$?
14055 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14056 >  test $ac_status = 0; } ;; #(
14057 >  *) :
14058 >
14059 >     as_fn_append CFLAGS " $flag"
14060 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14061 >  (: CFLAGS="$CFLAGS") 2>&5
14062 >  ac_status=$?
14063 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14064 >  test $ac_status = 0; }
14065 >     ;;
14066 > esac
14067 >
14068 > else
14069 >
14070 >  CFLAGS=$flag
14071 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14072 >  (: CFLAGS="$CFLAGS") 2>&5
14073 >  ac_status=$?
14074 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14075 >  test $ac_status = 0; }
14076 >
14077 > fi
14078 >
14079 > else
14080 >  :
14081 > fi
14082 >
14083 > done
14084 >
14085 >
14086 >
14087 >
14088 >
14089 > for flag in -Wpointer-arith; do
14090 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14091 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14092 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14093 > if eval \${$as_CACHEVAR+:} false; then :
14094 >  $as_echo_n "(cached) " >&6
14095 > else
14096 >
14097 >  ax_check_save_flags=$CFLAGS
14098 >  CFLAGS="$CFLAGS  $flag"
14099 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14100 > /* end confdefs.h.  */
14101 >
14102 > int
14103 > main ()
14104 > {
14105 >
14106 >  ;
14107 >  return 0;
14108 > }
14109 > _ACEOF
14110 > if ac_fn_c_try_compile "$LINENO"; then :
14111 >  eval "$as_CACHEVAR=yes"
14112 > else
14113 >  eval "$as_CACHEVAR=no"
14114 > fi
14115 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14116 >  CFLAGS=$ax_check_save_flags
14117 > fi
14118 > eval ac_res=\$$as_CACHEVAR
14119 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14120 > $as_echo "$ac_res" >&6; }
14121 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14122 >
14123 > if ${CFLAGS+:} false; then :
14124 >
14125 >  case " $CFLAGS " in #(
14126 >  *" $flag "*) :
14127 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14128 >  (: CFLAGS already contains $flag) 2>&5
14129 >  ac_status=$?
14130 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14131 >  test $ac_status = 0; } ;; #(
14132 >  *) :
14133 >
14134 >     as_fn_append CFLAGS " $flag"
14135 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14136 >  (: CFLAGS="$CFLAGS") 2>&5
14137 >  ac_status=$?
14138 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14139 >  test $ac_status = 0; }
14140 >     ;;
14141 > esac
14142 >
14143 > else
14144 >
14145 >  CFLAGS=$flag
14146 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14147 >  (: CFLAGS="$CFLAGS") 2>&5
14148 >  ac_status=$?
14149 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14150 >  test $ac_status = 0; }
14151 >
14152 > fi
14153 >
14154 > else
14155 >  :
14156 > fi
14157 >
14158 > done
14159 >
14160 >
14161 >
14162 >
14163 >
14164 > for flag in -Wredundant-decls; do
14165 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14166 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14167 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14168 > if eval \${$as_CACHEVAR+:} false; then :
14169 >  $as_echo_n "(cached) " >&6
14170 > else
14171 >
14172 >  ax_check_save_flags=$CFLAGS
14173 >  CFLAGS="$CFLAGS  $flag"
14174 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14175 > /* end confdefs.h.  */
14176 >
14177 > int
14178 > main ()
14179 > {
14180 >
14181 >  ;
14182 >  return 0;
14183 > }
14184 > _ACEOF
14185 > if ac_fn_c_try_compile "$LINENO"; then :
14186 >  eval "$as_CACHEVAR=yes"
14187 > else
14188 >  eval "$as_CACHEVAR=no"
14189 > fi
14190 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14191 >  CFLAGS=$ax_check_save_flags
14192 > fi
14193 > eval ac_res=\$$as_CACHEVAR
14194 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14195 > $as_echo "$ac_res" >&6; }
14196 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14197 >
14198 > if ${CFLAGS+:} false; then :
14199 >
14200 >  case " $CFLAGS " in #(
14201 >  *" $flag "*) :
14202 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14203 >  (: CFLAGS already contains $flag) 2>&5
14204 >  ac_status=$?
14205 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14206 >  test $ac_status = 0; } ;; #(
14207 >  *) :
14208 >
14209 >     as_fn_append CFLAGS " $flag"
14210 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14211 >  (: CFLAGS="$CFLAGS") 2>&5
14212 >  ac_status=$?
14213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14214 >  test $ac_status = 0; }
14215 >     ;;
14216 > esac
14217 >
14218 > else
14219 >
14220 >  CFLAGS=$flag
14221 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14222 >  (: CFLAGS="$CFLAGS") 2>&5
14223 >  ac_status=$?
14224 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14225 >  test $ac_status = 0; }
14226 >
14227 > fi
14228 >
14229 > else
14230 >  :
14231 > fi
14232 >
14233 > done
14234 >
14235 >
14236 >
14237 >
14238 >
14239 > for flag in -Wshadow; do
14240 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14241 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14242 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14243 > if eval \${$as_CACHEVAR+:} false; then :
14244 >  $as_echo_n "(cached) " >&6
14245 > else
14246 >
14247 >  ax_check_save_flags=$CFLAGS
14248 >  CFLAGS="$CFLAGS  $flag"
14249 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14250 > /* end confdefs.h.  */
14251 >
14252 > int
14253 > main ()
14254 > {
14255 >
14256 >  ;
14257 >  return 0;
14258 > }
14259 > _ACEOF
14260 > if ac_fn_c_try_compile "$LINENO"; then :
14261 >  eval "$as_CACHEVAR=yes"
14262 > else
14263 >  eval "$as_CACHEVAR=no"
14264 > fi
14265 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14266 >  CFLAGS=$ax_check_save_flags
14267 > fi
14268 > eval ac_res=\$$as_CACHEVAR
14269 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14270 > $as_echo "$ac_res" >&6; }
14271 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14272 >
14273 > if ${CFLAGS+:} false; then :
14274 >
14275 >  case " $CFLAGS " in #(
14276 >  *" $flag "*) :
14277 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14278 >  (: CFLAGS already contains $flag) 2>&5
14279 >  ac_status=$?
14280 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14281 >  test $ac_status = 0; } ;; #(
14282 >  *) :
14283 >
14284 >     as_fn_append CFLAGS " $flag"
14285 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14286 >  (: CFLAGS="$CFLAGS") 2>&5
14287 >  ac_status=$?
14288 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14289 >  test $ac_status = 0; }
14290 >     ;;
14291 > esac
14292 >
14293 > else
14294 >
14295 >  CFLAGS=$flag
14296 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14297 >  (: CFLAGS="$CFLAGS") 2>&5
14298 >  ac_status=$?
14299 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14300 >  test $ac_status = 0; }
14301 >
14302 > fi
14303 >
14304 > else
14305 >  :
14306 > fi
14307 >
14308 > done
14309 >
14310 >
14311 >
14312 >
14313 >
14314 > for flag in -Wshift-negative-value; do
14315 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14316 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14317 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14318 > if eval \${$as_CACHEVAR+:} false; then :
14319 >  $as_echo_n "(cached) " >&6
14320 > else
14321 >
14322 >  ax_check_save_flags=$CFLAGS
14323 >  CFLAGS="$CFLAGS  $flag"
14324 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14325 > /* end confdefs.h.  */
14326 >
14327 > int
14328 > main ()
14329 > {
14330 >
14331 >  ;
14332 >  return 0;
14333 > }
14334 > _ACEOF
14335 > if ac_fn_c_try_compile "$LINENO"; then :
14336 >  eval "$as_CACHEVAR=yes"
14337 > else
14338 >  eval "$as_CACHEVAR=no"
14339 > fi
14340 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14341 >  CFLAGS=$ax_check_save_flags
14342 > fi
14343 > eval ac_res=\$$as_CACHEVAR
14344 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14345 > $as_echo "$ac_res" >&6; }
14346 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14347 >
14348 > if ${CFLAGS+:} false; then :
14349 >
14350 >  case " $CFLAGS " in #(
14351 >  *" $flag "*) :
14352 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14353 >  (: CFLAGS already contains $flag) 2>&5
14354 >  ac_status=$?
14355 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14356 >  test $ac_status = 0; } ;; #(
14357 >  *) :
14358 >
14359 >     as_fn_append CFLAGS " $flag"
14360 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14361 >  (: CFLAGS="$CFLAGS") 2>&5
14362 >  ac_status=$?
14363 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14364 >  test $ac_status = 0; }
14365 >     ;;
14366 > esac
14367 >
14368 > else
14369 >
14370 >  CFLAGS=$flag
14371 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14372 >  (: CFLAGS="$CFLAGS") 2>&5
14373 >  ac_status=$?
14374 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14375 >  test $ac_status = 0; }
14376 >
14377 > fi
14378 >
14379 > else
14380 >  :
14381 > fi
14382 >
14383 > done
14384 >
14385 >
14386 >
14387 >
14388 >
14389 > for flag in -Wsign-compare; do
14390 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14391 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14392 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14393 > if eval \${$as_CACHEVAR+:} false; then :
14394 >  $as_echo_n "(cached) " >&6
14395 > else
14396 >
14397 >  ax_check_save_flags=$CFLAGS
14398 >  CFLAGS="$CFLAGS  $flag"
14399 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14400 > /* end confdefs.h.  */
14401 >
14402 > int
14403 > main ()
14404 > {
14405 >
14406 >  ;
14407 >  return 0;
14408 > }
14409 > _ACEOF
14410 > if ac_fn_c_try_compile "$LINENO"; then :
14411 >  eval "$as_CACHEVAR=yes"
14412 > else
14413 >  eval "$as_CACHEVAR=no"
14414 > fi
14415 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14416 >  CFLAGS=$ax_check_save_flags
14417 > fi
14418 > eval ac_res=\$$as_CACHEVAR
14419 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14420 > $as_echo "$ac_res" >&6; }
14421 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14422 >
14423 > if ${CFLAGS+:} false; then :
14424 >
14425 >  case " $CFLAGS " in #(
14426 >  *" $flag "*) :
14427 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14428 >  (: CFLAGS already contains $flag) 2>&5
14429 >  ac_status=$?
14430 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14431 >  test $ac_status = 0; } ;; #(
14432 >  *) :
14433 >
14434 >     as_fn_append CFLAGS " $flag"
14435 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14436 >  (: CFLAGS="$CFLAGS") 2>&5
14437 >  ac_status=$?
14438 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14439 >  test $ac_status = 0; }
14440 >     ;;
14441 > esac
14442 >
14443 > else
14444 >
14445 >  CFLAGS=$flag
14446 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14447 >  (: CFLAGS="$CFLAGS") 2>&5
14448 >  ac_status=$?
14449 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14450 >  test $ac_status = 0; }
14451 >
14452 > fi
14453 >
14454 > else
14455 >  :
14456 > fi
14457 >
14458 > done
14459 >
14460 >
14461 >
14462 >
14463 >
14464 > for flag in -Wtype-limits; do
14465 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14466 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14467 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14468 > if eval \${$as_CACHEVAR+:} false; then :
14469 >  $as_echo_n "(cached) " >&6
14470 > else
14471 >
14472 >  ax_check_save_flags=$CFLAGS
14473 >  CFLAGS="$CFLAGS  $flag"
14474 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14475 > /* end confdefs.h.  */
14476 >
14477 > int
14478 > main ()
14479 > {
14480 >
14481 >  ;
14482 >  return 0;
14483 > }
14484 > _ACEOF
14485 > if ac_fn_c_try_compile "$LINENO"; then :
14486 >  eval "$as_CACHEVAR=yes"
14487 > else
14488 >  eval "$as_CACHEVAR=no"
14489 > fi
14490 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14491 >  CFLAGS=$ax_check_save_flags
14492 > fi
14493 > eval ac_res=\$$as_CACHEVAR
14494 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14495 > $as_echo "$ac_res" >&6; }
14496 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14497 >
14498 > if ${CFLAGS+:} false; then :
14499 >
14500 >  case " $CFLAGS " in #(
14501 >  *" $flag "*) :
14502 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14503 >  (: CFLAGS already contains $flag) 2>&5
14504 >  ac_status=$?
14505 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14506 >  test $ac_status = 0; } ;; #(
14507 >  *) :
14508 >
14509 >     as_fn_append CFLAGS " $flag"
14510 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14511 >  (: CFLAGS="$CFLAGS") 2>&5
14512 >  ac_status=$?
14513 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14514 >  test $ac_status = 0; }
14515 >     ;;
14516 > esac
14517 >
14518 > else
14519 >
14520 >  CFLAGS=$flag
14521 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14522 >  (: CFLAGS="$CFLAGS") 2>&5
14523 >  ac_status=$?
14524 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14525 >  test $ac_status = 0; }
14526 >
14527 > fi
14528 >
14529 > else
14530 >  :
14531 > fi
14532 >
14533 > done
14534 >
14535 >
14536 >
14537 >
14538 >
14539 > for flag in -Wundef; do
14540 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14541 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14542 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14543 > if eval \${$as_CACHEVAR+:} false; then :
14544 >  $as_echo_n "(cached) " >&6
14545 > else
14546 >
14547 >  ax_check_save_flags=$CFLAGS
14548 >  CFLAGS="$CFLAGS  $flag"
14549 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14550 > /* end confdefs.h.  */
14551 >
14552 > int
14553 > main ()
14554 > {
14555 >
14556 >  ;
14557 >  return 0;
14558 > }
14559 > _ACEOF
14560 > if ac_fn_c_try_compile "$LINENO"; then :
14561 >  eval "$as_CACHEVAR=yes"
14562 > else
14563 >  eval "$as_CACHEVAR=no"
14564 > fi
14565 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14566 >  CFLAGS=$ax_check_save_flags
14567 > fi
14568 > eval ac_res=\$$as_CACHEVAR
14569 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14570 > $as_echo "$ac_res" >&6; }
14571 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14572 >
14573 > if ${CFLAGS+:} false; then :
14574 >
14575 >  case " $CFLAGS " in #(
14576 >  *" $flag "*) :
14577 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14578 >  (: CFLAGS already contains $flag) 2>&5
14579 >  ac_status=$?
14580 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14581 >  test $ac_status = 0; } ;; #(
14582 >  *) :
14583 >
14584 >     as_fn_append CFLAGS " $flag"
14585 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14586 >  (: CFLAGS="$CFLAGS") 2>&5
14587 >  ac_status=$?
14588 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14589 >  test $ac_status = 0; }
14590 >     ;;
14591 > esac
14592 >
14593 > else
14594 >
14595 >  CFLAGS=$flag
14596 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14597 >  (: CFLAGS="$CFLAGS") 2>&5
14598 >  ac_status=$?
14599 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14600 >  test $ac_status = 0; }
14601 >
14602 > fi
14603 >
14604 > else
14605 >  :
14606 > fi
14607 >
14608 > done
14609 >
14610 >
14611 >
14612 >
14613 >
14614 > for flag in -Wuninitialized; do
14615 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14616 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14617 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14618 > if eval \${$as_CACHEVAR+:} false; then :
14619 >  $as_echo_n "(cached) " >&6
14620 > else
14621 >
14622 >  ax_check_save_flags=$CFLAGS
14623 >  CFLAGS="$CFLAGS  $flag"
14624 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14625 > /* end confdefs.h.  */
14626 >
14627 > int
14628 > main ()
14629 > {
14630 >
14631 >  ;
14632 >  return 0;
14633 > }
14634 > _ACEOF
14635 > if ac_fn_c_try_compile "$LINENO"; then :
14636 >  eval "$as_CACHEVAR=yes"
14637 > else
14638 >  eval "$as_CACHEVAR=no"
14639 > fi
14640 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14641 >  CFLAGS=$ax_check_save_flags
14642 > fi
14643 > eval ac_res=\$$as_CACHEVAR
14644 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14645 > $as_echo "$ac_res" >&6; }
14646 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14647 >
14648 > if ${CFLAGS+:} false; then :
14649 >
14650 >  case " $CFLAGS " in #(
14651 >  *" $flag "*) :
14652 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14653 >  (: CFLAGS already contains $flag) 2>&5
14654 >  ac_status=$?
14655 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14656 >  test $ac_status = 0; } ;; #(
14657 >  *) :
14658 >
14659 >     as_fn_append CFLAGS " $flag"
14660 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14661 >  (: CFLAGS="$CFLAGS") 2>&5
14662 >  ac_status=$?
14663 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14664 >  test $ac_status = 0; }
14665 >     ;;
14666 > esac
14667 >
14668 > else
14669 >
14670 >  CFLAGS=$flag
14671 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14672 >  (: CFLAGS="$CFLAGS") 2>&5
14673 >  ac_status=$?
14674 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14675 >  test $ac_status = 0; }
14676 >
14677 > fi
14678 >
14679 > else
14680 >  :
14681 > fi
14682 >
14683 > done
14684 >
14685 >
14686 >
14687 >
14688 >
14689 > for flag in -Wwrite-strings; do
14690 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14691 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14692 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14693 > if eval \${$as_CACHEVAR+:} false; then :
14694 >  $as_echo_n "(cached) " >&6
14695 > else
14696 >
14697 >  ax_check_save_flags=$CFLAGS
14698 >  CFLAGS="$CFLAGS  $flag"
14699 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14700 > /* end confdefs.h.  */
14701 >
14702 > int
14703 > main ()
14704 > {
14705 >
14706 >  ;
14707 >  return 0;
14708 > }
14709 > _ACEOF
14710 > if ac_fn_c_try_compile "$LINENO"; then :
14711 >  eval "$as_CACHEVAR=yes"
14712 > else
14713 >  eval "$as_CACHEVAR=no"
14714 > fi
14715 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14716 >  CFLAGS=$ax_check_save_flags
14717 > fi
14718 > eval ac_res=\$$as_CACHEVAR
14719 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14720 > $as_echo "$ac_res" >&6; }
14721 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14722 >
14723 > if ${CFLAGS+:} false; then :
14724 >
14725 >  case " $CFLAGS " in #(
14726 >  *" $flag "*) :
14727 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14728 >  (: CFLAGS already contains $flag) 2>&5
14729 >  ac_status=$?
14730 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14731 >  test $ac_status = 0; } ;; #(
14732 >  *) :
14733 >
14734 >     as_fn_append CFLAGS " $flag"
14735 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14736 >  (: CFLAGS="$CFLAGS") 2>&5
14737 >  ac_status=$?
14738 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14739 >  test $ac_status = 0; }
14740 >     ;;
14741 > esac
14742 >
14743 > else
14744  
14745 <     ;; #(
14746 <   *)
14747 <     as_fn_error $? "unknown endianness
14748 < presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
14749 < esac
14745 >  CFLAGS=$flag
14746 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14747 >  (: CFLAGS="$CFLAGS") 2>&5
14748 >  ac_status=$?
14749 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14750 >  test $ac_status = 0; }
14751  
14752 + fi
14753  
14754 + else
14755 +  :
14756 + fi
14757  
14758 + done
14759  
14760  
14761 < subdirs="$subdirs src/libopm"
14761 > fi
14762  
14763  
14764 < ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile"
14764 >  # Check whether --enable-efence was given.
14765 > if test "${enable_efence+set}" = set; then :
14766 >  enableval=$enable_efence; efence="$enableval"
14767 > else
14768 >  efence="no"
14769 > fi
14770 >
14771 >
14772 >  if test "$efence" = "yes"; then :
14773 >
14774 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14775 > $as_echo_n "checking for library containing EF_Print... " >&6; }
14776 > if ${ac_cv_search_EF_Print+:} false; then :
14777 >  $as_echo_n "(cached) " >&6
14778 > else
14779 >  ac_func_search_save_LIBS=$LIBS
14780 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14781 > /* end confdefs.h.  */
14782 >
14783 > /* Override any GCC internal prototype to avoid an error.
14784 >   Use char because int might match the return type of a GCC
14785 >   builtin and then its argument prototype would still apply.  */
14786 > #ifdef __cplusplus
14787 > extern "C"
14788 > #endif
14789 > char EF_Print ();
14790 > int
14791 > main ()
14792 > {
14793 > return EF_Print ();
14794 >  ;
14795 >  return 0;
14796 > }
14797 > _ACEOF
14798 > for ac_lib in '' efence; do
14799 >  if test -z "$ac_lib"; then
14800 >    ac_res="none required"
14801 >  else
14802 >    ac_res=-l$ac_lib
14803 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14804 >  fi
14805 >  if ac_fn_c_try_link "$LINENO"; then :
14806 >  ac_cv_search_EF_Print=$ac_res
14807 > fi
14808 > rm -f core conftest.err conftest.$ac_objext \
14809 >    conftest$ac_exeext
14810 >  if ${ac_cv_search_EF_Print+:} false; then :
14811 >  break
14812 > fi
14813 > done
14814 > if ${ac_cv_search_EF_Print+:} false; then :
14815 >
14816 > else
14817 >  ac_cv_search_EF_Print=no
14818 > fi
14819 > rm conftest.$ac_ext
14820 > LIBS=$ac_func_search_save_LIBS
14821 > fi
14822 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14823 > $as_echo "$ac_cv_search_EF_Print" >&6; }
14824 > ac_res=$ac_cv_search_EF_Print
14825 > if test "$ac_res" != no; then :
14826 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14827 >
14828 > else
14829 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14830 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14831 > as_fn_error $? "Electric Fence 'efence' library not found
14832 > See \`config.log' for more details" "$LINENO" 5; }
14833 > fi
14834 >
14835 >
14836 > fi
14837 >
14838 >
14839 > for ac_func in strlcpy strlcat
14840 > do :
14841 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14842 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14843 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14844 >  cat >>confdefs.h <<_ACEOF
14845 > #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14846 > _ACEOF
14847 >
14848 > fi
14849 > done
14850 >
14851 >
14852 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14853  
14854   cat >confcache <<\_ACEOF
14855   # This file is a shell script that caches the results of configure
# Line 13087 | Line 14988 | if test -z "${am__fastdepCC_TRUE}" && te
14988    as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
14989   Usually this means the macro was only invoked conditionally." "$LINENO" 5
14990   fi
14991 <
14991 > if test -z "${ENABLE_SSL_TRUE}" && test -z "${ENABLE_SSL_FALSE}"; then
14992 >  as_fn_error $? "conditional \"ENABLE_SSL\" was never defined.
14993 > Usually this means the macro was only invoked conditionally." "$LINENO" 5
14994 > fi
14995  
14996   : "${CONFIG_STATUS=./config.status}"
14997   ac_write_fail=0
# Line 13485 | Line 15389 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15389   # report actual input values of CONFIG_FILES etc. instead of their
15390   # values after options handling.
15391   ac_log="
15392 < This file was extended by hopm $as_me 1.0.0beta1, which was
15392 > This file was extended by hopm $as_me TRUNK, which was
15393   generated by GNU Autoconf 2.69.  Invocation command line was
15394  
15395    CONFIG_FILES    = $CONFIG_FILES
# Line 13545 | Line 15449 | $config_headers
15449   Configuration commands:
15450   $config_commands
15451  
15452 < Report bugs to the package provider."
15452 > Report bugs to <bugs@ircd-hybrid.org>."
15453  
15454   _ACEOF
15455   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15456   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15457   ac_cs_version="\\
15458 < hopm config.status 1.0.0beta1
15458 > hopm config.status TRUNK
15459   configured by $0, generated by GNU Autoconf 2.69,
15460    with options \\"\$ac_cs_config\\"
15461  
# Line 13807 | Line 15711 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15711   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15712   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15713   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15714 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15714 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15715 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15716   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15717   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15718   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 13925 | Line 15830 | postinstall_cmds \
15830   postuninstall_cmds \
15831   finish_cmds \
15832   sys_lib_search_path_spec \
15833 < sys_lib_dlsearch_path_spec; do
15833 > configure_time_dlsearch_path \
15834 > configure_time_lt_sys_library_path; do
15835      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15836      *[\\\\\\\`\\"\\\$]*)
15837        eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
# Line 13967 | Line 15873 | do
15873      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15874      "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15875      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15876 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15877 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15878  
15879    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15880    esac
# Line 14702 | Line 16610 | $as_echo X"$file" |
16610   # The names of the tagged configurations supported by this script.
16611   available_tags=''
16612  
16613 + # Configured defaults for sys_lib_dlsearch_path munging.
16614 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16615 +
16616   # ### BEGIN LIBTOOL CONFIG
16617  
16618   # Which release of libtool.m4 was used?
# Line 14951 | Line 16862 | hardcode_into_libs=$hardcode_into_libs
16862   # Compile-time system search path for libraries.
16863   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16864  
16865 < # Run-time system search path for libraries.
16866 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16865 > # Detected run-time system search path for libraries.
16866 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16867 >
16868 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16869 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16870  
16871   # Whether dlopen is supported.
16872   dlopen_support=$enable_dlopen
# Line 15103 | Line 17017 | hardcode_action=$hardcode_action
17017  
17018   _LT_EOF
17019  
17020 +    cat <<'_LT_EOF' >> "$cfgfile"
17021 +
17022 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17023 +
17024 + # func_munge_path_list VARIABLE PATH
17025 + # -----------------------------------
17026 + # VARIABLE is name of variable containing _space_ separated list of
17027 + # directories to be munged by the contents of PATH, which is string
17028 + # having a format:
17029 + # "DIR[:DIR]:"
17030 + #       string "DIR[ DIR]" will be prepended to VARIABLE
17031 + # ":DIR[:DIR]"
17032 + #       string "DIR[ DIR]" will be appended to VARIABLE
17033 + # "DIRP[:DIRP]::[DIRA:]DIRA"
17034 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17035 + #       "DIRA[ DIRA]" will be appended to VARIABLE
17036 + # "DIR[:DIR]"
17037 + #       VARIABLE will be replaced by "DIR[ DIR]"
17038 + func_munge_path_list ()
17039 + {
17040 +    case x$2 in
17041 +    x)
17042 +        ;;
17043 +    *:)
17044 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17045 +        ;;
17046 +    x:*)
17047 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17048 +        ;;
17049 +    *::*)
17050 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17051 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17052 +        ;;
17053 +    *)
17054 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17055 +        ;;
17056 +    esac
17057 + }
17058 +
17059 +
17060 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17061 + func_cc_basename ()
17062 + {
17063 +    for cc_temp in $*""; do
17064 +      case $cc_temp in
17065 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17066 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17067 +        \-*) ;;
17068 +        *) break;;
17069 +      esac
17070 +    done
17071 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17072 + }
17073 +
17074 +
17075 + # ### END FUNCTIONS SHARED WITH CONFIGURE
17076 +
17077 + _LT_EOF
17078 +
17079    case $host_os in
17080    aix3*)
17081      cat <<\_LT_EOF >> "$cfgfile"
# Line 15166 | Line 17139 | if test "$no_create" != yes; then
17139    # would make configure fail if this is the last instruction.
17140    $ac_cs_success || as_fn_exit 1
17141   fi
15169 –
15170 – #
15171 – # CONFIG_SUBDIRS section.
15172 – #
15173 – if test "$no_recursion" != yes; then
15174 –
15175 –  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
15176 –  # so they do not pile up.
15177 –  ac_sub_configure_args=
15178 –  ac_prev=
15179 –  eval "set x $ac_configure_args"
15180 –  shift
15181 –  for ac_arg
15182 –  do
15183 –    if test -n "$ac_prev"; then
15184 –      ac_prev=
15185 –      continue
15186 –    fi
15187 –    case $ac_arg in
15188 –    -cache-file | --cache-file | --cache-fil | --cache-fi \
15189 –    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
15190 –      ac_prev=cache_file ;;
15191 –    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
15192 –    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
15193 –    | --c=*)
15194 –      ;;
15195 –    --config-cache | -C)
15196 –      ;;
15197 –    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
15198 –      ac_prev=srcdir ;;
15199 –    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
15200 –      ;;
15201 –    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
15202 –      ac_prev=prefix ;;
15203 –    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
15204 –      ;;
15205 –    --disable-option-checking)
15206 –      ;;
15207 –    *)
15208 –      case $ac_arg in
15209 –      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15210 –      esac
15211 –      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
15212 –    esac
15213 –  done
15214 –
15215 –  # Always prepend --prefix to ensure using the same prefix
15216 –  # in subdir configurations.
15217 –  ac_arg="--prefix=$prefix"
15218 –  case $ac_arg in
15219 –  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
15220 –  esac
15221 –  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
15222 –
15223 –  # Pass --silent
15224 –  if test "$silent" = yes; then
15225 –    ac_sub_configure_args="--silent $ac_sub_configure_args"
15226 –  fi
15227 –
15228 –  # Always prepend --disable-option-checking to silence warnings, since
15229 –  # different subdirs can have different --enable and --with options.
15230 –  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
15231 –
15232 –  ac_popdir=`pwd`
15233 –  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
15234 –
15235 –    # Do not complain, so a configure script can configure whichever
15236 –    # parts of a large source tree are present.
15237 –    test -d "$srcdir/$ac_dir" || continue
15238 –
15239 –    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
15240 –    $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
15241 –    $as_echo "$ac_msg" >&6
15242 –    as_dir="$ac_dir"; as_fn_mkdir_p
15243 –    ac_builddir=.
15244 –
15245 – case "$ac_dir" in
15246 – .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
15247 – *)
15248 –  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
15249 –  # A ".." for each directory in $ac_dir_suffix.
15250 –  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
15251 –  case $ac_top_builddir_sub in
15252 –  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
15253 –  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
15254 –  esac ;;
15255 – esac
15256 – ac_abs_top_builddir=$ac_pwd
15257 – ac_abs_builddir=$ac_pwd$ac_dir_suffix
15258 – # for backward compatibility:
15259 – ac_top_builddir=$ac_top_build_prefix
15260 –
15261 – case $srcdir in
15262 –  .)  # We are building in place.
15263 –    ac_srcdir=.
15264 –    ac_top_srcdir=$ac_top_builddir_sub
15265 –    ac_abs_top_srcdir=$ac_pwd ;;
15266 –  [\\/]* | ?:[\\/]* )  # Absolute name.
15267 –    ac_srcdir=$srcdir$ac_dir_suffix;
15268 –    ac_top_srcdir=$srcdir
15269 –    ac_abs_top_srcdir=$srcdir ;;
15270 –  *) # Relative name.
15271 –    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
15272 –    ac_top_srcdir=$ac_top_build_prefix$srcdir
15273 –    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
15274 – esac
15275 – ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
15276 –
15277 –
15278 –    cd "$ac_dir"
15279 –
15280 –    # Check for guested configure; otherwise get Cygnus style configure.
15281 –    if test -f "$ac_srcdir/configure.gnu"; then
15282 –      ac_sub_configure=$ac_srcdir/configure.gnu
15283 –    elif test -f "$ac_srcdir/configure"; then
15284 –      ac_sub_configure=$ac_srcdir/configure
15285 –    elif test -f "$ac_srcdir/configure.in"; then
15286 –      # This should be Cygnus configure.
15287 –      ac_sub_configure=$ac_aux_dir/configure
15288 –    else
15289 –      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
15290 – $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
15291 –      ac_sub_configure=
15292 –    fi
15293 –
15294 –    # The recursion is here.
15295 –    if test -n "$ac_sub_configure"; then
15296 –      # Make the cache file name correct relative to the subdirectory.
15297 –      case $cache_file in
15298 –      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
15299 –      *) # Relative name.
15300 –        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
15301 –      esac
15302 –
15303 –      { $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
15304 – $as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
15305 –      # The eval makes quoting arguments work.
15306 –      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
15307 –           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
15308 –        as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
15309 –    fi
15310 –
15311 –    cd "$ac_popdir"
15312 –  done
15313 – fi
17142   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17143    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17144   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}

Diff Legend

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