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

Comparing:
hopm/trunk/configure (file contents), Revision 5160 by michael, Fri Dec 26 17:23:48 2014 UTC vs.
hopm/branches/1.1.x/configure (file contents), Revision 8849 by michael, Sat Feb 9 18:33:17 2019 UTC

# Line 1 | Line 1
1   #! /bin/sh
2 + # From configure.ac Id: configure.ac 8848 2019-02-09 18:31:58Z michael .
3   # Guess values for system-dependent variables and create Makefiles.
4 < # Generated by GNU Autoconf 2.69 for hopm 1.0.0beta1.
4 > # Generated by GNU Autoconf 2.69 for hopm 1.1.6.
5 > #
6 > # Report bugs to <bugs@ircd-hybrid.org>.
7   #
8   #
9   # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
# Line 272 | Line 275 | fi
275      $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
276      $as_echo "$0: be upgraded to zsh 4.3.4 or later."
277    else
278 <    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
279 < $0: including any error possibly output before this
280 < $0: message. Then install a modern shell, or manually run
281 < $0: the script under such a shell if you do have one."
278 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and
279 > $0: bugs@ircd-hybrid.org about your system, including any
280 > $0: error possibly output before this message. Then install
281 > $0: a modern shell, or manually run the script under such a
282 > $0: shell if you do have one."
283    fi
284    exit 1
285   fi
# Line 587 | Line 591 | MAKEFLAGS=
591   # Identity of this package.
592   PACKAGE_NAME='hopm'
593   PACKAGE_TARNAME='hopm'
594 < PACKAGE_VERSION='1.0.0beta1'
595 < PACKAGE_STRING='hopm 1.0.0beta1'
596 < PACKAGE_BUGREPORT=''
594 > PACKAGE_VERSION='1.1.6'
595 > PACKAGE_STRING='hopm 1.1.6'
596 > PACKAGE_BUGREPORT='bugs@ircd-hybrid.org'
597   PACKAGE_URL=''
598  
599   ac_unique_file="src/opercmd.h"
# Line 630 | Line 634 | ac_includes_default="\
634   # include <unistd.h>
635   #endif"
636  
633 enable_option_checking=no
637   ac_subst_vars='am__EXEEXT_FALSE
638   am__EXEEXT_TRUE
639   LTLIBOBJS
640   LIBOBJS
638 subdirs
641   LEXLIB
642   LEX_OUTPUT_ROOT
643   LEX
644   YFLAGS
645   YACC
646   CPP
647 + LT_SYS_LIBRARY_PATH
648   OTOOL64
649   OTOOL
650   LIPO
# Line 678 | Line 681 | am__nodep
681   AMDEPBACKSLASH
682   AMDEP_FALSE
683   AMDEP_TRUE
681 am__quote
684   am__include
685   DEPDIR
686   OBJEXT
# Line 755 | Line 757 | PACKAGE_VERSION
757   PACKAGE_TARNAME
758   PACKAGE_NAME
759   PATH_SEPARATOR
760 < SHELL'
760 > SHELL
761 > am__quote'
762   ac_subst_files=''
763   ac_user_opts='
764   enable_option_checking
765   enable_silent_rules
766   enable_maintainer_mode
764 with_extra_fascism
767   enable_dependency_tracking
768   enable_shared
769   enable_static
# Line 771 | Line 773 | with_aix_soname
773   with_gnu_ld
774   with_sysroot
775   enable_libtool_lock
776 + enable_openssl
777 + enable_assert
778 + enable_warnings
779 + enable_efence
780   '
781        ac_precious_vars='build_alias
782   host_alias
# Line 780 | Line 786 | CFLAGS
786   LDFLAGS
787   LIBS
788   CPPFLAGS
789 + LT_SYS_LIBRARY_PATH
790   CPP
791   YACC
792   YFLAGS'
793 < ac_subdirs_all='src/libopm'
793 >
794  
795   # Initialize some variables set by options.
796   ac_init_help=
# Line 1323 | Line 1330 | if test "$ac_init_help" = "long"; then
1330    # Omit some internal or obsolete options to make the list less imposing.
1331    # This message is too long to be a string in the A/UX 3.1 sh.
1332    cat <<_ACEOF
1333 < \`configure' configures hopm 1.0.0beta1 to adapt to many kinds of systems.
1333 > \`configure' configures hopm 1.1.6 to adapt to many kinds of systems.
1334  
1335   Usage: $0 [OPTION]... [VAR=VALUE]...
1336  
# Line 1393 | Line 1400 | fi
1400  
1401   if test -n "$ac_init_help"; then
1402    case $ac_init_help in
1403 <     short | recursive ) echo "Configuration of hopm 1.0.0beta1:";;
1403 >     short | recursive ) echo "Configuration of hopm 1.1.6:";;
1404     esac
1405    cat <<\_ACEOF
1406  
# Line 1415 | Line 1422 | Optional Features:
1422    --enable-fast-install[=PKGS]
1423                            optimize for fast installation [default=yes]
1424    --disable-libtool-lock  avoid locking (might break parallel builds)
1425 +  --enable-openssl=DIR       Enable LibreSSL/OpenSSL support (DIR optional).
1426 +  --disable-openssl            Disable LibreSSL/OpenSSL support.
1427 +  --enable-assert         Enable assert() statements
1428 +  --enable-warnings       Enable compiler warnings.
1429 +  --enable-efence         Enable linking with Electric Fence 'efence' memory
1430 +                          debugger library.
1431  
1432   Optional Packages:
1433    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1434    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1422  --with-extra-fascism    Add extra gcc3-specific warning flags
1435    --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
1436                            both]
1437    --with-aix-soname=aix|svr4|both
# Line 1437 | Line 1449 | Some influential environment variables:
1449    LIBS        libraries to pass to the linker, e.g. -l<library>
1450    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1451                you have headers in a nonstandard directory <include dir>
1452 +  LT_SYS_LIBRARY_PATH
1453 +              User-defined run-time library search path.
1454    CPP         C preprocessor
1455    YACC        The `Yet Another Compiler Compiler' implementation to use.
1456                Defaults to the first program found out of: `bison -y', `byacc',
# Line 1448 | Line 1462 | Some influential environment variables:
1462   Use these variables to override the choices made by `configure' or to help
1463   it to find libraries and programs with nonstandard names/locations.
1464  
1465 < Report bugs to the package provider.
1465 > Report bugs to <bugs@ircd-hybrid.org>.
1466   _ACEOF
1467   ac_status=$?
1468   fi
# Line 1511 | Line 1525 | fi
1525   test -n "$ac_init_help" && exit $ac_status
1526   if $ac_init_version; then
1527    cat <<\_ACEOF
1528 < hopm configure 1.0.0beta1
1528 > hopm configure 1.1.6
1529   generated by GNU Autoconf 2.69
1530  
1531   Copyright (C) 2012 Free Software Foundation, Inc.
# Line 1785 | Line 1799 | $as_echo "$ac_res" >&6; }
1799    eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1800  
1801   } # ac_fn_c_check_func
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
1802   cat >config.log <<_ACEOF
1803   This file contains any messages produced by compilers while
1804   running configure, to aid debugging if configure makes a mistake.
1805  
1806 < It was created by hopm $as_me 1.0.0beta1, which was
1806 > It was created by hopm $as_me 1.1.6, which was
1807   generated by GNU Autoconf 2.69.  Invocation command line was
1808  
1809    $ $0 $@
# Line 2224 | Line 2151 | ac_link='$CC -o conftest$ac_exeext $CFLA
2151   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2152  
2153  
2154 <
2228 < ac_config_headers="$ac_config_headers src/setup.h"
2229 <
2230 < am__api_version='1.14'
2154 > am__api_version='1.16'
2155  
2156   ac_aux_dir=
2157   for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
# Line 2428 | Line 2352 | test "$program_suffix" != NONE &&
2352   ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
2353   program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
2354  
2355 < # expand $ac_aux_dir to an absolute path
2356 < am_aux_dir=`cd $ac_aux_dir && pwd`
2355 > # Expand $ac_aux_dir to an absolute path.
2356 > am_aux_dir=`cd "$ac_aux_dir" && pwd`
2357  
2358   if test x"${MISSING+set}" != xset; then
2359    case $am_aux_dir in
# Line 2448 | Line 2372 | else
2372   $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
2373   fi
2374  
2375 < if test x"${install_sh}" != xset; then
2375 > if test x"${install_sh+set}" != xset; then
2376    case $am_aux_dir in
2377    *\ * | *\     *)
2378      install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
# Line 2742 | Line 2666 | fi
2666  
2667   # Define the identity of the package.
2668   PACKAGE='hopm'
2669 < VERSION='1.0.0beta1'
2669 > VERSION='1.1.6'
2670  
2671  
2672   cat >>confdefs.h <<_ACEOF
# Line 2772 | Line 2696 | MAKEINFO=${MAKEINFO-"${am_missing_run}ma
2696  
2697   # For better backward compatibility.  To be removed once Automake 1.9.x
2698   # dies out for good.  For more background, see:
2699 < # <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700 < # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2699 > # <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
2700 > # <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
2701   mkdir_p='$(MKDIR_P)'
2702  
2703 < # We need awk for the "check" target.  The system "awk" is bad on
2704 < # some platforms.
2703 > # We need awk for the "check" target (and possibly the TAP driver).  The
2704 > # system "awk" is bad on some platforms.
2705   # Always define AMTAR for backward compatibility.  Yes, it's still used
2706   # in the wild :-(  We should find a proper way to deprecate it ...
2707   AMTAR='$${TAR-tar}'
# Line 2824 | Line 2748 | END
2748   Aborting the configuration process, to ensure you take notice of the issue.
2749  
2750   You can download and install GNU coreutils to get an 'rm' implementation
2751 < that behaves properly: <http://www.gnu.org/software/coreutils/>.
2751 > that behaves properly: <https://www.gnu.org/software/coreutils/>.
2752  
2753   If you want to complete the configuration process using your problematic
2754   'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
# Line 2859 | Line 2783 | fi
2783  
2784  
2785  
2786 <
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 <
2786 > ac_config_headers="$ac_config_headers src/setup.h"
2787  
2788  
2789  
# Line 2873 | Line 2792 | DEPDIR="${am__leading_dot}deps"
2792  
2793   ac_config_commands="$ac_config_commands depfiles"
2794  
2795 <
2796 < am_make=${MAKE-make}
2797 < cat > confinc << 'END'
2795 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
2796 > $as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
2797 > cat > confinc.mk << 'END'
2798   am__doit:
2799 <        @echo this is the am__doit target
2799 >        @echo this is the am__doit target >confinc.out
2800   .PHONY: am__doit
2801   END
2883 # If we don't find an include directive, just comment out the code.
2884 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
2885 $as_echo_n "checking for style of include used by $am_make... " >&6; }
2802   am__include="#"
2803   am__quote=
2804 < _am_result=none
2805 < # First try GNU make style include.
2806 < echo "include confinc" > confmf
2807 < # Ignore all kinds of additional output from 'make'.
2808 < case `$am_make -s -f confmf 2> /dev/null` in #(
2809 < *the\ am__doit\ target*)
2810 <  am__include=include
2811 <  am__quote=
2812 <  _am_result=GNU
2813 <  ;;
2814 < esac
2815 < # Now try BSD make style include.
2816 < if test "$am__include" = "#"; then
2817 <   echo '.include "confinc"' > confmf
2818 <   case `$am_make -s -f confmf 2> /dev/null` in #(
2819 <   *the\ am__doit\ target*)
2820 <     am__include=.include
2821 <     am__quote="\""
2822 <     _am_result=BSD
2804 > # BSD make does it like this.
2805 > echo '.include "confinc.mk" # ignored' > confmf.BSD
2806 > # Other make implementations (GNU, Solaris 10, AIX) do it like this.
2807 > echo 'include confinc.mk # ignored' > confmf.GNU
2808 > _am_result=no
2809 > for s in GNU BSD; do
2810 >  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
2811 >   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
2812 >   ac_status=$?
2813 >   echo "$as_me:$LINENO: \$? = $ac_status" >&5
2814 >   (exit $ac_status); }
2815 >  case $?:`cat confinc.out 2>/dev/null` in #(
2816 >  '0:this is the am__doit target') :
2817 >    case $s in #(
2818 >  BSD) :
2819 >    am__include='.include' am__quote='"' ;; #(
2820 >  *) :
2821 >    am__include='include' am__quote='' ;;
2822 > esac ;; #(
2823 >  *) :
2824       ;;
2825 <   esac
2826 < fi
2827 <
2828 <
2829 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
2830 < $as_echo "$_am_result" >&6; }
2831 < rm -f confinc confmf
2825 > esac
2826 >  if test "$am__include" != "#"; then
2827 >    _am_result="yes ($s style)"
2828 >    break
2829 >  fi
2830 > done
2831 > rm -f confinc.* confmf.*
2832 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
2833 > $as_echo "${_am_result}" >&6; }
2834  
2835   # Check whether --enable-dependency-tracking was given.
2836   if test "${enable_dependency_tracking+set}" = set; then :
# Line 4096 | Line 4015 | esac
4015  
4016  
4017  
4018 < macro_version='2.4.4'
4019 < macro_revision='2.4.4'
4018 > macro_version='2.4.6'
4019 > macro_revision='2.4.6'
4020  
4021  
4022  
# Line 6520 | Line 6439 | $as_echo "$lt_cv_truncate_bin" >&6; }
6439  
6440  
6441  
6442 +
6443 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
6444 + func_cc_basename ()
6445 + {
6446 +    for cc_temp in $*""; do
6447 +      case $cc_temp in
6448 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
6449 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
6450 +        \-*) ;;
6451 +        *) break;;
6452 +      esac
6453 +    done
6454 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
6455 + }
6456 +
6457   # Check whether --enable-libtool-lock was given.
6458   if test "${enable_libtool_lock+set}" = set; then :
6459    enableval=$enable_libtool_lock;
# Line 7527 | Line 7461 | $as_echo "$lt_cv_ld_force_load" >&6; }
7461      ;;
7462    esac
7463  
7464 + # func_munge_path_list VARIABLE PATH
7465 + # -----------------------------------
7466 + # VARIABLE is name of variable containing _space_ separated list of
7467 + # directories to be munged by the contents of PATH, which is string
7468 + # having a format:
7469 + # "DIR[:DIR]:"
7470 + #       string "DIR[ DIR]" will be prepended to VARIABLE
7471 + # ":DIR[:DIR]"
7472 + #       string "DIR[ DIR]" will be appended to VARIABLE
7473 + # "DIRP[:DIRP]::[DIRA:]DIRA"
7474 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
7475 + #       "DIRA[ DIRA]" will be appended to VARIABLE
7476 + # "DIR[:DIR]"
7477 + #       VARIABLE will be replaced by "DIR[ DIR]"
7478 + func_munge_path_list ()
7479 + {
7480 +    case x$2 in
7481 +    x)
7482 +        ;;
7483 +    *:)
7484 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
7485 +        ;;
7486 +    x:*)
7487 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
7488 +        ;;
7489 +    *::*)
7490 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
7491 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
7492 +        ;;
7493 +    *)
7494 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
7495 +        ;;
7496 +    esac
7497 + }
7498 +
7499   ac_ext=c
7500   ac_cpp='$CPP $CPPFLAGS'
7501   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 8114 | Line 8083 | test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
8083   test -z "$LD" && LD=ld
8084   test -z "$ac_objext" && ac_objext=o
8085  
8086 < for cc_temp in $compiler""; do
8087 <  case $cc_temp in
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-%%"`
8086 > func_cc_basename $compiler
8087 > cc_basename=$func_cc_basename_result
8088  
8089  
8090   # Only perform the check for file, if the check method requires it
# Line 8322 | Line 8284 | _lt_linker_boilerplate=`cat conftest.err
8284   $RM -r conftest*
8285  
8286  
8287 + ## CAVEAT EMPTOR:
8288 + ## There is no encapsulation within the following macros, do not change
8289 + ## the running order or otherwise move them around unless you know exactly
8290 + ## what you are doing...
8291   if test -n "$compiler"; then
8292  
8293   lt_prog_compiler_no_builtin_flag=
# Line 10577 | Line 10543 | hardcode_into_libs=no
10543   # flags to be left without arguments
10544   need_version=unknown
10545  
10546 +
10547 +
10548   case $host_os in
10549   aix3*)
10550    version_type=linux # correct to gnu/linux during the next big refactor
# Line 10865 | Line 10833 | freebsd* | dragonfly*)
10833    case $version_type in
10834      freebsd-elf*)
10835        library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
10836 +      soname_spec='$libname$release$shared_ext$major'
10837        need_version=no
10838        need_lib_prefix=no
10839        ;;
# Line 10924 | Line 10893 | hpux9* | hpux10* | hpux11*)
10893      soname_spec='$libname$release$shared_ext$major'
10894      if test 32 = "$HPUX_IA64_MODE"; then
10895        sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
10896 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
10897      else
10898        sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
10899 +      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
10900      fi
10930    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
10901      ;;
10902    hppa*64*)
10903      shrext_cmds='.sl'
# Line 11079 | Line 11049 | fi
11049    # before this can be enabled.
11050    hardcode_into_libs=yes
11051  
11052 <  # Append ld.so.conf contents to the search path
11052 >  # Ideally, we could use ldconfig to report *all* directores which are
11053 >  # searched for libraries, however this is still not possible.  Aside from not
11054 >  # being certain /sbin/ldconfig is available, command
11055 >  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
11056 >  # even though it is searched at run-time.  Try to do the best guess by
11057 >  # appending ld.so.conf contents (and includes) to the search path.
11058    if test -f /etc/ld.so.conf; then
11059      lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[       ]*hwcap[        ]/d;s/[:,      ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
11060      sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
# Line 11304 | Line 11279 | fi
11279   if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
11280    sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
11281   fi
11282 +
11283   if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
11284    sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
11285   fi
11286  
11287 + # remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
11288 + configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
11289 +
11290 + # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
11291 + func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
11292 +
11293 + # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
11294 + configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
11295 +
11296 +
11297 +
11298 +
11299 +
11300 +
11301  
11302  
11303  
# Line 12088 | Line 12078 | CC=$lt_save_CC
12078  
12079  
12080  
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
12081   for ac_prog in 'bison -y' byacc
12082   do
12083    # Extract the first word of "$ac_prog", so it can be a program name with args.
# Line 12509 | Line 12285 | if test "$LEX" = :; then
12285    LEX=${am_missing_run}flex
12286   fi
12287  
12288 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12289 < $as_echo_n "checking for library containing socket... " >&6; }
12290 < if ${ac_cv_search_socket+:} false; then :
12288 >
12289 >
12290 >  if test "X$CC" != "X"; then
12291 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector-strong" >&5
12292 > $as_echo_n "checking whether ${CC} accepts -fstack-protector-strong... " >&6; }
12293 > if ${ssp_cv_cc+:} false; then :
12294    $as_echo_n "(cached) " >&6
12295   else
12296 <  ac_func_search_save_LIBS=$LIBS
12297 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12296 >  ssp_old_cflags="$CFLAGS"
12297 >       CFLAGS="$CFLAGS -fstack-protector-strong"
12298 >       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12299   /* end confdefs.h.  */
12300  
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 ();
12301   int
12302   main ()
12303   {
12304 < return socket ();
12304 >
12305    ;
12306    return 0;
12307   }
12308   _ACEOF
12309 < for ac_lib in '' socket; do
12310 <  if test -z "$ac_lib"; then
12311 <    ac_res="none required"
12312 <  else
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
12309 > if ac_fn_c_try_compile "$LINENO"; then :
12310 >  ssp_cv_cc=yes
12311 > else
12312 >  ssp_cv_cc=no
12313   fi
12314 < rm -f core conftest.err conftest.$ac_objext \
12315 <    conftest$ac_exeext
12316 <  if ${ac_cv_search_socket+:} false; then :
12549 <  break
12314 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12315 >       CFLAGS="$ssp_old_cflags"
12316 >
12317   fi
12318 < done
12319 < if ${ac_cv_search_socket+:} false; then :
12318 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12319 > $as_echo "$ssp_cv_cc" >&6; }
12320 >    if test $ssp_cv_cc = yes; then
12321 >      CFLAGS="$CFLAGS -fstack-protector-strong"
12322 >
12323 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12324  
12325 +    else
12326 +      unset ssp_cv_cc
12327 +      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fstack-protector" >&5
12328 + $as_echo_n "checking whether ${CC} accepts -fstack-protector... " >&6; }
12329 + if ${ssp_cv_cc+:} false; then :
12330 +  $as_echo_n "(cached) " >&6
12331   else
12332 <  ac_cv_search_socket=no
12332 >  ssp_old_cflags="$CFLAGS"
12333 >         CFLAGS="$CFLAGS -fstack-protector"
12334 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12335 > /* end confdefs.h.  */
12336 >
12337 > int
12338 > main ()
12339 > {
12340 >
12341 >  ;
12342 >  return 0;
12343 > }
12344 > _ACEOF
12345 > if ac_fn_c_try_compile "$LINENO"; then :
12346 >  ssp_cv_cc=yes
12347 > else
12348 >  ssp_cv_cc=no
12349   fi
12350 < rm conftest.$ac_ext
12351 < LIBS=$ac_func_search_save_LIBS
12350 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12351 >         CFLAGS="$ssp_old_cflags"
12352 >
12353   fi
12354 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12355 < $as_echo "$ac_cv_search_socket" >&6; }
12356 < ac_res=$ac_cv_search_socket
12357 < if test "$ac_res" != no; then :
12358 <  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12354 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_cc" >&5
12355 > $as_echo "$ssp_cv_cc" >&6; }
12356 >      if test $ssp_cv_cc = yes; then
12357 >        CFLAGS="$CFLAGS -fstack-protector"
12358 >
12359 > $as_echo "#define ENABLE_SSP_CC 1" >>confdefs.h
12360 >
12361 >      fi
12362 >    fi
12363 >  fi
12364  
12365 +
12366 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether libssp exists" >&5
12367 + $as_echo_n "checking whether libssp exists... " >&6; }
12368 + if ${ssp_cv_lib+:} false; then :
12369 +  $as_echo_n "(cached) " >&6
12370   else
12371 <  as_fn_error $? "socket library not found" "$LINENO" 5
12371 >  ssp_old_libs="$LIBS"
12372 >     LIBS="$LIBS -lssp"
12373 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12374 > /* end confdefs.h.  */
12375 >
12376 > int
12377 > main ()
12378 > {
12379 >
12380 >  ;
12381 >  return 0;
12382 > }
12383 > _ACEOF
12384 > if ac_fn_c_try_link "$LINENO"; then :
12385 >  ssp_cv_lib=yes
12386 > else
12387 >  ssp_cv_lib=no
12388 > fi
12389 > rm -f core conftest.err conftest.$ac_objext \
12390 >    conftest$ac_exeext conftest.$ac_ext
12391 >     LIBS="$ssp_old_libs"
12392 >
12393   fi
12394 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ssp_cv_lib" >&5
12395 + $as_echo "$ssp_cv_lib" >&6; }
12396 +  if test $ssp_cv_lib = yes; then
12397 +    LIBS="$LIBS -lssp"
12398 +  fi
12399 +
12400  
12401 < ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12401 >
12402 >  ac_fn_c_check_func "$LINENO" "getaddrinfo" "ac_cv_func_getaddrinfo"
12403   if test "x$ac_cv_func_getaddrinfo" = xyes; then :
12404  
12405   else
# Line 12629 | Line 12461 | fi
12461  
12462   fi
12463  
12464 < ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12464 >  ac_fn_c_check_func "$LINENO" "getnameinfo" "ac_cv_func_getnameinfo"
12465   if test "x$ac_cv_func_getnameinfo" = xyes; then :
12466  
12467   else
# Line 12691 | Line 12523 | fi
12523  
12524   fi
12525  
12526 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing socket" >&5
12527 + $as_echo_n "checking for library containing socket... " >&6; }
12528 + if ${ac_cv_search_socket+:} false; then :
12529 +  $as_echo_n "(cached) " >&6
12530 + else
12531 +  ac_func_search_save_LIBS=$LIBS
12532 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12533 + /* end confdefs.h.  */
12534  
12535 < for ac_func in strlcpy strlcat inet_aton inet_pton socket strdup strstr
12536 < do :
12537 <  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
12538 < ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
12539 < if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
12535 > /* Override any GCC internal prototype to avoid an error.
12536 >   Use char because int might match the return type of a GCC
12537 >   builtin and then its argument prototype would still apply.  */
12538 > #ifdef __cplusplus
12539 > extern "C"
12540 > #endif
12541 > char socket ();
12542 > int
12543 > main ()
12544 > {
12545 > return socket ();
12546 >  ;
12547 >  return 0;
12548 > }
12549 > _ACEOF
12550 > for ac_lib in '' socket; do
12551 >  if test -z "$ac_lib"; then
12552 >    ac_res="none required"
12553 >  else
12554 >    ac_res=-l$ac_lib
12555 >    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
12556 >  fi
12557 >  if ac_fn_c_try_link "$LINENO"; then :
12558 >  ac_cv_search_socket=$ac_res
12559 > fi
12560 > rm -f core conftest.err conftest.$ac_objext \
12561 >    conftest$ac_exeext
12562 >  if ${ac_cv_search_socket+:} false; then :
12563 >  break
12564 > fi
12565 > done
12566 > if ${ac_cv_search_socket+:} false; then :
12567 >
12568 > else
12569 >  ac_cv_search_socket=no
12570 > fi
12571 > rm conftest.$ac_ext
12572 > LIBS=$ac_func_search_save_LIBS
12573 > fi
12574 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_socket" >&5
12575 > $as_echo "$ac_cv_search_socket" >&6; }
12576 > ac_res=$ac_cv_search_socket
12577 > if test "$ac_res" != no; then :
12578 >  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
12579 >
12580 > else
12581 >  as_fn_error $? "socket library not found" "$LINENO" 5
12582 > fi
12583 >
12584 >
12585 >
12586 > # Check whether --enable-openssl was given.
12587 > if test "${enable_openssl+set}" = set; then :
12588 >  enableval=$enable_openssl;  cf_enable_openssl=$enableval
12589 > else
12590 >   cf_enable_openssl="auto"
12591 > fi
12592 >
12593 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL/OpenSSL" >&5
12594 > $as_echo_n "checking for LibreSSL/OpenSSL... " >&6; }
12595 > if test "$cf_enable_openssl" != "no"; then
12596 >  cf_openssl_basedir=""
12597 >  if test "$cf_enable_openssl" != "auto" &&
12598 >     test "$cf_enable_openssl" != "yes"; then
12599 >          cf_openssl_basedir="${cf_enable_openssl}"
12600 >  else
12601 >        for dirs in /usr/local/ssl /usr/pkg /usr/local /usr/lib /usr/lib/ssl\
12602 >                /opt /opt/openssl /usr/local/openssl; do
12603 >      if test -f "${dirs}/include/openssl/opensslv.h"; then
12604 >        cf_openssl_basedir="${dirs}"
12605 >        break
12606 >      fi
12607 >    done
12608 >    unset dirs
12609 >  fi
12610 >
12611 >    if test ! -z "$cf_openssl_basedir"; then
12612 >    if test -f "${cf_openssl_basedir}/include/openssl/opensslv.h"; then
12613 >      CPPFLAGS="-I${cf_openssl_basedir}/include $CPPFLAGS"
12614 >      LDFLAGS="-L${cf_openssl_basedir}/lib $LDFLAGS"
12615 >    else
12616 >                  cf_openssl_basedir=""
12617 >    fi
12618 >  else
12619 >                            if test -f "/usr/include/openssl/opensslv.h"; then
12620 >      cf_openssl_basedir="/usr"
12621 >    fi
12622 >  fi
12623 >
12624 >      if test ! -z "$cf_openssl_basedir"; then
12625 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cf_openssl_basedir" >&5
12626 > $as_echo "$cf_openssl_basedir" >&6; }
12627 >    cf_enable_openssl="yes"
12628 >  else
12629 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found. Please check your path." >&5
12630 > $as_echo "not found. Please check your path." >&6; }
12631 >    cf_enable_openssl="no"
12632 >  fi
12633 >  unset cf_openssl_basedir
12634 > else
12635 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: disabled" >&5
12636 > $as_echo "disabled" >&6; }
12637 > fi
12638 >
12639 > if test "$cf_enable_openssl" != "no"; then :
12640 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LibreSSL or OpenSSL 1.0.1d and above" >&5
12641 > $as_echo_n "checking for LibreSSL or OpenSSL 1.0.1d and above... " >&6; }
12642 >  if test "$cross_compiling" = yes; then :
12643 >  cf_openssl_version_ok=no
12644 > else
12645 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12646 > /* end confdefs.h.  */
12647 >
12648 >
12649 >    #include <openssl/opensslv.h>
12650 >    #include <stdlib.h>
12651 > int
12652 > main ()
12653 > {
12654 > exit(!(OPENSSL_VERSION_NUMBER >= 0x1000104fL));
12655 >  ;
12656 >  return 0;
12657 > }
12658 > _ACEOF
12659 > if ac_fn_c_try_run "$LINENO"; then :
12660 >  cf_openssl_version_ok=yes
12661 > else
12662 >  cf_openssl_version_ok=no
12663 > fi
12664 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
12665 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
12666 > fi
12667 >
12668 >
12669 >  if test "$cf_openssl_version_ok" = "yes"; then :
12670 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
12671 > $as_echo "found" >&6; }
12672 >
12673 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RSA_free in -lcrypto" >&5
12674 > $as_echo_n "checking for RSA_free in -lcrypto... " >&6; }
12675 > if ${ac_cv_lib_crypto_RSA_free+:} false; then :
12676 >  $as_echo_n "(cached) " >&6
12677 > else
12678 >  ac_check_lib_save_LIBS=$LIBS
12679 > LIBS="-lcrypto  $LIBS"
12680 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12681 > /* end confdefs.h.  */
12682 >
12683 > /* Override any GCC internal prototype to avoid an error.
12684 >   Use char because int might match the return type of a GCC
12685 >   builtin and then its argument prototype would still apply.  */
12686 > #ifdef __cplusplus
12687 > extern "C"
12688 > #endif
12689 > char RSA_free ();
12690 > int
12691 > main ()
12692 > {
12693 > return RSA_free ();
12694 >  ;
12695 >  return 0;
12696 > }
12697 > _ACEOF
12698 > if ac_fn_c_try_link "$LINENO"; then :
12699 >  ac_cv_lib_crypto_RSA_free=yes
12700 > else
12701 >  ac_cv_lib_crypto_RSA_free=no
12702 > fi
12703 > rm -f core conftest.err conftest.$ac_objext \
12704 >    conftest$ac_exeext conftest.$ac_ext
12705 > LIBS=$ac_check_lib_save_LIBS
12706 > fi
12707 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_RSA_free" >&5
12708 > $as_echo "$ac_cv_lib_crypto_RSA_free" >&6; }
12709 > if test "x$ac_cv_lib_crypto_RSA_free" = xyes; then :
12710    cat >>confdefs.h <<_ACEOF
12711 < #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
12711 > #define HAVE_LIBCRYPTO 1
12712   _ACEOF
12713  
12714 +  LIBS="-lcrypto $LIBS"
12715 +
12716   fi
12705 done
12717  
12718 +    if test "$ac_cv_lib_crypto_RSA_free" = "yes"; then :
12719 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SSL_connect in -lssl" >&5
12720 + $as_echo_n "checking for SSL_connect in -lssl... " >&6; }
12721 + if ${ac_cv_lib_ssl_SSL_connect+:} false; then :
12722 +  $as_echo_n "(cached) " >&6
12723 + else
12724 +  ac_check_lib_save_LIBS=$LIBS
12725 + LIBS="-lssl  $LIBS"
12726 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12727 + /* end confdefs.h.  */
12728  
12729 < for ac_func in gethostbyname
12730 < do :
12731 <  ac_fn_c_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
12732 < if test "x$ac_cv_func_gethostbyname" = xyes; then :
12729 > /* Override any GCC internal prototype to avoid an error.
12730 >   Use char because int might match the return type of a GCC
12731 >   builtin and then its argument prototype would still apply.  */
12732 > #ifdef __cplusplus
12733 > extern "C"
12734 > #endif
12735 > char SSL_connect ();
12736 > int
12737 > main ()
12738 > {
12739 > return SSL_connect ();
12740 >  ;
12741 >  return 0;
12742 > }
12743 > _ACEOF
12744 > if ac_fn_c_try_link "$LINENO"; then :
12745 >  ac_cv_lib_ssl_SSL_connect=yes
12746 > else
12747 >  ac_cv_lib_ssl_SSL_connect=no
12748 > fi
12749 > rm -f core conftest.err conftest.$ac_objext \
12750 >    conftest$ac_exeext conftest.$ac_ext
12751 > LIBS=$ac_check_lib_save_LIBS
12752 > fi
12753 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ssl_SSL_connect" >&5
12754 > $as_echo "$ac_cv_lib_ssl_SSL_connect" >&6; }
12755 > if test "x$ac_cv_lib_ssl_SSL_connect" = xyes; then :
12756    cat >>confdefs.h <<_ACEOF
12757 < #define HAVE_GETHOSTBYNAME 1
12757 > #define HAVE_LIBSSL 1
12758 > _ACEOF
12759 >
12760 >  LIBS="-lssl $LIBS"
12761 >
12762 > fi
12763 >
12764 > fi
12765 >
12766 > else
12767 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no - LibreSSL/OpenSSL support disabled" >&5
12768 > $as_echo "no - LibreSSL/OpenSSL support disabled" >&6; }
12769 >    cf_enable_openssl="no"
12770 > fi
12771 > fi
12772 >
12773 >
12774 >  # Check whether --enable-assert was given.
12775 > if test "${enable_assert+set}" = set; then :
12776 >  enableval=$enable_assert; assert=$enableval
12777 > else
12778 >  assert=no
12779 > fi
12780 >
12781 >
12782 >  if test "$assert" = "no"; then :
12783 >
12784 > $as_echo "#define NDEBUG 1" >>confdefs.h
12785 >
12786 > fi
12787 >
12788 >
12789 >  # Check whether --enable-warnings was given.
12790 > if test "${enable_warnings+set}" = set; then :
12791 >  enableval=$enable_warnings; warnings="$enableval"
12792 > else
12793 >  warnings="no"
12794 > fi
12795 >
12796 >
12797 >  if test "$warnings" = "yes"; then :
12798 >
12799 >
12800 >
12801 >
12802 >
12803 > for flag in -Wall; do
12804 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12805 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12806 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12807 > if eval \${$as_CACHEVAR+:} false; then :
12808 >  $as_echo_n "(cached) " >&6
12809 > else
12810 >
12811 >  ax_check_save_flags=$CFLAGS
12812 >  CFLAGS="$CFLAGS  $flag"
12813 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12814 > /* end confdefs.h.  */
12815 >
12816 > int
12817 > main ()
12818 > {
12819 >
12820 >  ;
12821 >  return 0;
12822 > }
12823   _ACEOF
12824 + if ac_fn_c_try_compile "$LINENO"; then :
12825 +  eval "$as_CACHEVAR=yes"
12826 + else
12827 +  eval "$as_CACHEVAR=no"
12828 + fi
12829 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12830 +  CFLAGS=$ax_check_save_flags
12831 + fi
12832 + eval ac_res=\$$as_CACHEVAR
12833 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12834 + $as_echo "$ac_res" >&6; }
12835 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12836 +
12837 + if ${CFLAGS+:} false; then :
12838 +
12839 +  case " $CFLAGS " in #(
12840 +  *" $flag "*) :
12841 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12842 +  (: CFLAGS already contains $flag) 2>&5
12843 +  ac_status=$?
12844 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12845 +  test $ac_status = 0; } ;; #(
12846 +  *) :
12847 +
12848 +     as_fn_append CFLAGS " $flag"
12849 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12850 +  (: CFLAGS="$CFLAGS") 2>&5
12851 +  ac_status=$?
12852 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12853 +  test $ac_status = 0; }
12854 +     ;;
12855 + esac
12856 +
12857 + else
12858 +
12859 +  CFLAGS=$flag
12860 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12861 +  (: CFLAGS="$CFLAGS") 2>&5
12862 +  ac_status=$?
12863 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12864 +  test $ac_status = 0; }
12865 +
12866 + fi
12867  
12868 + else
12869 +  :
12870   fi
12871 +
12872   done
12873  
12874  
12875 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
12876 < $as_echo_n "checking whether byte ordering is bigendian... " >&6; }
12877 < if ${ac_cv_c_bigendian+:} false; then :
12875 >
12876 >
12877 >
12878 > for flag in -Wbad-function-cast; do
12879 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12880 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12881 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12882 > if eval \${$as_CACHEVAR+:} false; then :
12883    $as_echo_n "(cached) " >&6
12884   else
12885 <  ac_cv_c_bigendian=unknown
12886 <    # See if we're dealing with a universal compiler.
12887 <    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12885 >
12886 >  ax_check_save_flags=$CFLAGS
12887 >  CFLAGS="$CFLAGS  $flag"
12888 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12889   /* end confdefs.h.  */
12729 #ifndef __APPLE_CC__
12730               not a universal capable compiler
12731             #endif
12732             typedef int dummy;
12890  
12891 + int
12892 + main ()
12893 + {
12894 +
12895 +  ;
12896 +  return 0;
12897 + }
12898   _ACEOF
12899   if ac_fn_c_try_compile "$LINENO"; then :
12900 +  eval "$as_CACHEVAR=yes"
12901 + else
12902 +  eval "$as_CACHEVAR=no"
12903 + fi
12904 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12905 +  CFLAGS=$ax_check_save_flags
12906 + fi
12907 + eval ac_res=\$$as_CACHEVAR
12908 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12909 + $as_echo "$ac_res" >&6; }
12910 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12911  
12912 <        # Check for potential -arch flags.  It is not universal unless
12913 <        # there are at least two -arch flags with different values.
12914 <        ac_arch=
12915 <        ac_prev=
12916 <        for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
12917 <         if test -n "$ac_prev"; then
12918 <           case $ac_word in
12919 <             i?86 | x86_64 | ppc | ppc64)
12920 <               if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
12921 <                 ac_arch=$ac_word
12922 <               else
12923 <                 ac_cv_c_bigendian=universal
12924 <                 break
12925 <               fi
12926 <               ;;
12927 <           esac
12928 <           ac_prev=
12929 <         elif test "x$ac_word" = "x-arch"; then
12930 <           ac_prev=arch
12931 <         fi
12932 <       done
12912 > if ${CFLAGS+:} false; then :
12913 >
12914 >  case " $CFLAGS " in #(
12915 >  *" $flag "*) :
12916 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12917 >  (: CFLAGS already contains $flag) 2>&5
12918 >  ac_status=$?
12919 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12920 >  test $ac_status = 0; } ;; #(
12921 >  *) :
12922 >
12923 >     as_fn_append CFLAGS " $flag"
12924 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12925 >  (: CFLAGS="$CFLAGS") 2>&5
12926 >  ac_status=$?
12927 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12928 >  test $ac_status = 0; }
12929 >     ;;
12930 > esac
12931 >
12932 > else
12933 >
12934 >  CFLAGS=$flag
12935 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
12936 >  (: CFLAGS="$CFLAGS") 2>&5
12937 >  ac_status=$?
12938 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12939 >  test $ac_status = 0; }
12940 >
12941 > fi
12942 >
12943 > else
12944 >  :
12945 > fi
12946 >
12947 > done
12948 >
12949 >
12950 >
12951 >
12952 >
12953 > for flag in -Wcast-align; do
12954 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
12955 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
12956 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
12957 > if eval \${$as_CACHEVAR+:} false; then :
12958 >  $as_echo_n "(cached) " >&6
12959 > else
12960 >
12961 >  ax_check_save_flags=$CFLAGS
12962 >  CFLAGS="$CFLAGS  $flag"
12963 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12964 > /* end confdefs.h.  */
12965 >
12966 > int
12967 > main ()
12968 > {
12969 >
12970 >  ;
12971 >  return 0;
12972 > }
12973 > _ACEOF
12974 > if ac_fn_c_try_compile "$LINENO"; then :
12975 >  eval "$as_CACHEVAR=yes"
12976 > else
12977 >  eval "$as_CACHEVAR=no"
12978   fi
12979   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12980 <    if test $ac_cv_c_bigendian = unknown; then
12981 <      # See if sys/param.h defines the BYTE_ORDER macro.
12982 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
12980 >  CFLAGS=$ax_check_save_flags
12981 > fi
12982 > eval ac_res=\$$as_CACHEVAR
12983 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
12984 > $as_echo "$ac_res" >&6; }
12985 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
12986 >
12987 > if ${CFLAGS+:} false; then :
12988 >
12989 >  case " $CFLAGS " in #(
12990 >  *" $flag "*) :
12991 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
12992 >  (: CFLAGS already contains $flag) 2>&5
12993 >  ac_status=$?
12994 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
12995 >  test $ac_status = 0; } ;; #(
12996 >  *) :
12997 >
12998 >     as_fn_append CFLAGS " $flag"
12999 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13000 >  (: CFLAGS="$CFLAGS") 2>&5
13001 >  ac_status=$?
13002 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13003 >  test $ac_status = 0; }
13004 >     ;;
13005 > esac
13006 >
13007 > else
13008 >
13009 >  CFLAGS=$flag
13010 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13011 >  (: CFLAGS="$CFLAGS") 2>&5
13012 >  ac_status=$?
13013 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13014 >  test $ac_status = 0; }
13015 >
13016 > fi
13017 >
13018 > else
13019 >  :
13020 > fi
13021 >
13022 > done
13023 >
13024 >
13025 >
13026 >
13027 >
13028 > for flag in -Wcast-qual; do
13029 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13030 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13031 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13032 > if eval \${$as_CACHEVAR+:} false; then :
13033 >  $as_echo_n "(cached) " >&6
13034 > else
13035 >
13036 >  ax_check_save_flags=$CFLAGS
13037 >  CFLAGS="$CFLAGS  $flag"
13038 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13039   /* end confdefs.h.  */
12764 #include <sys/types.h>
12765             #include <sys/param.h>
13040  
13041   int
13042   main ()
13043   {
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
13044  
13045    ;
13046    return 0;
13047   }
13048   _ACEOF
13049   if ac_fn_c_try_compile "$LINENO"; then :
13050 <  # It does; now see whether it defined to BIG_ENDIAN or not.
13051 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13050 >  eval "$as_CACHEVAR=yes"
13051 > else
13052 >  eval "$as_CACHEVAR=no"
13053 > fi
13054 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13055 >  CFLAGS=$ax_check_save_flags
13056 > fi
13057 > eval ac_res=\$$as_CACHEVAR
13058 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13059 > $as_echo "$ac_res" >&6; }
13060 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13061 >
13062 > if ${CFLAGS+:} false; then :
13063 >
13064 >  case " $CFLAGS " in #(
13065 >  *" $flag "*) :
13066 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13067 >  (: CFLAGS already contains $flag) 2>&5
13068 >  ac_status=$?
13069 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13070 >  test $ac_status = 0; } ;; #(
13071 >  *) :
13072 >
13073 >     as_fn_append CFLAGS " $flag"
13074 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13075 >  (: CFLAGS="$CFLAGS") 2>&5
13076 >  ac_status=$?
13077 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13078 >  test $ac_status = 0; }
13079 >     ;;
13080 > esac
13081 >
13082 > else
13083 >
13084 >  CFLAGS=$flag
13085 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13086 >  (: CFLAGS="$CFLAGS") 2>&5
13087 >  ac_status=$?
13088 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13089 >  test $ac_status = 0; }
13090 >
13091 > fi
13092 >
13093 > else
13094 >  :
13095 > fi
13096 >
13097 > done
13098 >
13099 >
13100 >
13101 >
13102 >
13103 > for flag in -Wclobbered; do
13104 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13105 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13106 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13107 > if eval \${$as_CACHEVAR+:} false; then :
13108 >  $as_echo_n "(cached) " >&6
13109 > else
13110 >
13111 >  ax_check_save_flags=$CFLAGS
13112 >  CFLAGS="$CFLAGS  $flag"
13113 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13114   /* end confdefs.h.  */
12784 #include <sys/types.h>
12785                #include <sys/param.h>
13115  
13116   int
13117   main ()
13118   {
12790 #if BYTE_ORDER != BIG_ENDIAN
12791                 not big endian
12792                #endif
13119  
13120    ;
13121    return 0;
13122   }
13123   _ACEOF
13124   if ac_fn_c_try_compile "$LINENO"; then :
13125 <  ac_cv_c_bigendian=yes
13125 >  eval "$as_CACHEVAR=yes"
13126   else
13127 <  ac_cv_c_bigendian=no
13127 >  eval "$as_CACHEVAR=no"
13128   fi
13129   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13130 +  CFLAGS=$ax_check_save_flags
13131 + fi
13132 + eval ac_res=\$$as_CACHEVAR
13133 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13134 + $as_echo "$ac_res" >&6; }
13135 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13136 +
13137 + if ${CFLAGS+:} false; then :
13138 +
13139 +  case " $CFLAGS " in #(
13140 +  *" $flag "*) :
13141 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13142 +  (: CFLAGS already contains $flag) 2>&5
13143 +  ac_status=$?
13144 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13145 +  test $ac_status = 0; } ;; #(
13146 +  *) :
13147 +
13148 +     as_fn_append CFLAGS " $flag"
13149 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13150 +  (: CFLAGS="$CFLAGS") 2>&5
13151 +  ac_status=$?
13152 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13153 +  test $ac_status = 0; }
13154 +     ;;
13155 + esac
13156 +
13157 + else
13158 +
13159 +  CFLAGS=$flag
13160 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13161 +  (: CFLAGS="$CFLAGS") 2>&5
13162 +  ac_status=$?
13163 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13164 +  test $ac_status = 0; }
13165 +
13166 + fi
13167 +
13168 + else
13169 +  :
13170 + fi
13171 +
13172 + done
13173 +
13174 +
13175 +
13176 +
13177 +
13178 + for flag in -Wduplicated-cond; do
13179 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13180 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13181 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13182 + if eval \${$as_CACHEVAR+:} false; then :
13183 +  $as_echo_n "(cached) " >&6
13184 + else
13185 +
13186 +  ax_check_save_flags=$CFLAGS
13187 +  CFLAGS="$CFLAGS  $flag"
13188 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13189 + /* end confdefs.h.  */
13190 +
13191 + int
13192 + main ()
13193 + {
13194 +
13195 +  ;
13196 +  return 0;
13197 + }
13198 + _ACEOF
13199 + if ac_fn_c_try_compile "$LINENO"; then :
13200 +  eval "$as_CACHEVAR=yes"
13201 + else
13202 +  eval "$as_CACHEVAR=no"
13203   fi
13204   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13205 <    fi
13206 <    if test $ac_cv_c_bigendian = unknown; then
13207 <      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
13208 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13205 >  CFLAGS=$ax_check_save_flags
13206 > fi
13207 > eval ac_res=\$$as_CACHEVAR
13208 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13209 > $as_echo "$ac_res" >&6; }
13210 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13211 >
13212 > if ${CFLAGS+:} false; then :
13213 >
13214 >  case " $CFLAGS " in #(
13215 >  *" $flag "*) :
13216 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13217 >  (: CFLAGS already contains $flag) 2>&5
13218 >  ac_status=$?
13219 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13220 >  test $ac_status = 0; } ;; #(
13221 >  *) :
13222 >
13223 >     as_fn_append CFLAGS " $flag"
13224 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13225 >  (: CFLAGS="$CFLAGS") 2>&5
13226 >  ac_status=$?
13227 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13228 >  test $ac_status = 0; }
13229 >     ;;
13230 > esac
13231 >
13232 > else
13233 >
13234 >  CFLAGS=$flag
13235 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13236 >  (: CFLAGS="$CFLAGS") 2>&5
13237 >  ac_status=$?
13238 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13239 >  test $ac_status = 0; }
13240 >
13241 > fi
13242 >
13243 > else
13244 >  :
13245 > fi
13246 >
13247 > done
13248 >
13249 >
13250 >
13251 >
13252 >
13253 > for flag in -Wempty-body; do
13254 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13255 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13256 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13257 > if eval \${$as_CACHEVAR+:} false; then :
13258 >  $as_echo_n "(cached) " >&6
13259 > else
13260 >
13261 >  ax_check_save_flags=$CFLAGS
13262 >  CFLAGS="$CFLAGS  $flag"
13263 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13264   /* end confdefs.h.  */
12811 #include <limits.h>
13265  
13266   int
13267   main ()
13268   {
12816 #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
12817              bogus endian macros
12818             #endif
13269  
13270    ;
13271    return 0;
13272   }
13273   _ACEOF
13274   if ac_fn_c_try_compile "$LINENO"; then :
13275 <  # It does; now see whether it defined to _BIG_ENDIAN or not.
13276 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13275 >  eval "$as_CACHEVAR=yes"
13276 > else
13277 >  eval "$as_CACHEVAR=no"
13278 > fi
13279 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13280 >  CFLAGS=$ax_check_save_flags
13281 > fi
13282 > eval ac_res=\$$as_CACHEVAR
13283 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13284 > $as_echo "$ac_res" >&6; }
13285 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13286 >
13287 > if ${CFLAGS+:} false; then :
13288 >
13289 >  case " $CFLAGS " in #(
13290 >  *" $flag "*) :
13291 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13292 >  (: CFLAGS already contains $flag) 2>&5
13293 >  ac_status=$?
13294 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13295 >  test $ac_status = 0; } ;; #(
13296 >  *) :
13297 >
13298 >     as_fn_append CFLAGS " $flag"
13299 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13300 >  (: CFLAGS="$CFLAGS") 2>&5
13301 >  ac_status=$?
13302 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13303 >  test $ac_status = 0; }
13304 >     ;;
13305 > esac
13306 >
13307 > else
13308 >
13309 >  CFLAGS=$flag
13310 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13311 >  (: CFLAGS="$CFLAGS") 2>&5
13312 >  ac_status=$?
13313 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13314 >  test $ac_status = 0; }
13315 >
13316 > fi
13317 >
13318 > else
13319 >  :
13320 > fi
13321 >
13322 > done
13323 >
13324 >
13325 >
13326 >
13327 >
13328 > for flag in -Wignored-qualifiers; do
13329 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13330 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13331 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13332 > if eval \${$as_CACHEVAR+:} false; then :
13333 >  $as_echo_n "(cached) " >&6
13334 > else
13335 >
13336 >  ax_check_save_flags=$CFLAGS
13337 >  CFLAGS="$CFLAGS  $flag"
13338 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13339   /* end confdefs.h.  */
12828 #include <limits.h>
13340  
13341   int
13342   main ()
13343   {
12833 #ifndef _BIG_ENDIAN
12834                 not big endian
12835                #endif
13344  
13345    ;
13346    return 0;
13347   }
13348   _ACEOF
13349   if ac_fn_c_try_compile "$LINENO"; then :
13350 <  ac_cv_c_bigendian=yes
13350 >  eval "$as_CACHEVAR=yes"
13351   else
13352 <  ac_cv_c_bigendian=no
13352 >  eval "$as_CACHEVAR=no"
13353   fi
13354   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13355 +  CFLAGS=$ax_check_save_flags
13356 + fi
13357 + eval ac_res=\$$as_CACHEVAR
13358 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13359 + $as_echo "$ac_res" >&6; }
13360 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13361 +
13362 + if ${CFLAGS+:} false; then :
13363 +
13364 +  case " $CFLAGS " in #(
13365 +  *" $flag "*) :
13366 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13367 +  (: CFLAGS already contains $flag) 2>&5
13368 +  ac_status=$?
13369 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13370 +  test $ac_status = 0; } ;; #(
13371 +  *) :
13372 +
13373 +     as_fn_append CFLAGS " $flag"
13374 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13375 +  (: CFLAGS="$CFLAGS") 2>&5
13376 +  ac_status=$?
13377 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13378 +  test $ac_status = 0; }
13379 +     ;;
13380 + esac
13381 +
13382 + else
13383 +
13384 +  CFLAGS=$flag
13385 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13386 +  (: CFLAGS="$CFLAGS") 2>&5
13387 +  ac_status=$?
13388 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13389 +  test $ac_status = 0; }
13390 +
13391 + fi
13392 +
13393 + else
13394 +  :
13395 + fi
13396 +
13397 + done
13398 +
13399 +
13400 +
13401 +
13402 +
13403 + for flag in -Wlogical-op; do
13404 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13405 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13406 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13407 + if eval \${$as_CACHEVAR+:} false; then :
13408 +  $as_echo_n "(cached) " >&6
13409 + else
13410 +
13411 +  ax_check_save_flags=$CFLAGS
13412 +  CFLAGS="$CFLAGS  $flag"
13413 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13414 + /* end confdefs.h.  */
13415 +
13416 + int
13417 + main ()
13418 + {
13419 +
13420 +  ;
13421 +  return 0;
13422 + }
13423 + _ACEOF
13424 + if ac_fn_c_try_compile "$LINENO"; then :
13425 +  eval "$as_CACHEVAR=yes"
13426 + else
13427 +  eval "$as_CACHEVAR=no"
13428   fi
13429   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13430 <    fi
13431 <    if test $ac_cv_c_bigendian = unknown; then
13432 <      # Compile a test program.
13433 <      if test "$cross_compiling" = yes; then :
13434 <  # Try to guess by grepping values from an object file.
13435 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13430 >  CFLAGS=$ax_check_save_flags
13431 > fi
13432 > eval ac_res=\$$as_CACHEVAR
13433 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13434 > $as_echo "$ac_res" >&6; }
13435 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13436 >
13437 > if ${CFLAGS+:} false; then :
13438 >
13439 >  case " $CFLAGS " in #(
13440 >  *" $flag "*) :
13441 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13442 >  (: CFLAGS already contains $flag) 2>&5
13443 >  ac_status=$?
13444 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13445 >  test $ac_status = 0; } ;; #(
13446 >  *) :
13447 >
13448 >     as_fn_append CFLAGS " $flag"
13449 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13450 >  (: CFLAGS="$CFLAGS") 2>&5
13451 >  ac_status=$?
13452 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13453 >  test $ac_status = 0; }
13454 >     ;;
13455 > esac
13456 >
13457 > else
13458 >
13459 >  CFLAGS=$flag
13460 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13461 >  (: CFLAGS="$CFLAGS") 2>&5
13462 >  ac_status=$?
13463 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13464 >  test $ac_status = 0; }
13465 >
13466 > fi
13467 >
13468 > else
13469 >  :
13470 > fi
13471 >
13472 > done
13473 >
13474 >
13475 >
13476 >
13477 >
13478 > for flag in -Wmissing-declarations; do
13479 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13480 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13481 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13482 > if eval \${$as_CACHEVAR+:} false; then :
13483 >  $as_echo_n "(cached) " >&6
13484 > else
13485 >
13486 >  ax_check_save_flags=$CFLAGS
13487 >  CFLAGS="$CFLAGS  $flag"
13488 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13489   /* end confdefs.h.  */
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;
13490  
13491   int
13492   main ()
13493   {
13494 < return use_ascii (foo) == use_ebcdic (foo);
13494 >
13495    ;
13496    return 0;
13497   }
13498   _ACEOF
13499   if ac_fn_c_try_compile "$LINENO"; then :
13500 <  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
13501 <              ac_cv_c_bigendian=yes
13502 <            fi
13503 <            if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
13504 <              if test "$ac_cv_c_bigendian" = unknown; then
13505 <                ac_cv_c_bigendian=no
13506 <              else
13507 <                # finding both strings is unlikely to happen, but who knows?
13508 <                ac_cv_c_bigendian=unknown
13509 <              fi
13510 <            fi
13500 >  eval "$as_CACHEVAR=yes"
13501 > else
13502 >  eval "$as_CACHEVAR=no"
13503 > fi
13504 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13505 >  CFLAGS=$ax_check_save_flags
13506 > fi
13507 > eval ac_res=\$$as_CACHEVAR
13508 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13509 > $as_echo "$ac_res" >&6; }
13510 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13511 >
13512 > if ${CFLAGS+:} false; then :
13513 >
13514 >  case " $CFLAGS " in #(
13515 >  *" $flag "*) :
13516 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13517 >  (: CFLAGS already contains $flag) 2>&5
13518 >  ac_status=$?
13519 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13520 >  test $ac_status = 0; } ;; #(
13521 >  *) :
13522 >
13523 >     as_fn_append CFLAGS " $flag"
13524 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13525 >  (: CFLAGS="$CFLAGS") 2>&5
13526 >  ac_status=$?
13527 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13528 >  test $ac_status = 0; }
13529 >     ;;
13530 > esac
13531 >
13532 > else
13533 >
13534 >  CFLAGS=$flag
13535 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13536 >  (: CFLAGS="$CFLAGS") 2>&5
13537 >  ac_status=$?
13538 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13539 >  test $ac_status = 0; }
13540 >
13541 > fi
13542 >
13543 > else
13544 >  :
13545 > fi
13546 >
13547 > done
13548 >
13549 >
13550 >
13551 >
13552 >
13553 > for flag in -Wmissing-field-initializers; do
13554 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13555 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13556 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13557 > if eval \${$as_CACHEVAR+:} false; then :
13558 >  $as_echo_n "(cached) " >&6
13559 > else
13560 >
13561 >  ax_check_save_flags=$CFLAGS
13562 >  CFLAGS="$CFLAGS  $flag"
13563 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13564 > /* end confdefs.h.  */
13565 >
13566 > int
13567 > main ()
13568 > {
13569 >
13570 >  ;
13571 >  return 0;
13572 > }
13573 > _ACEOF
13574 > if ac_fn_c_try_compile "$LINENO"; then :
13575 >  eval "$as_CACHEVAR=yes"
13576 > else
13577 >  eval "$as_CACHEVAR=no"
13578   fi
13579   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13580 +  CFLAGS=$ax_check_save_flags
13581 + fi
13582 + eval ac_res=\$$as_CACHEVAR
13583 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13584 + $as_echo "$ac_res" >&6; }
13585 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13586 +
13587 + if ${CFLAGS+:} false; then :
13588 +
13589 +  case " $CFLAGS " in #(
13590 +  *" $flag "*) :
13591 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13592 +  (: CFLAGS already contains $flag) 2>&5
13593 +  ac_status=$?
13594 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13595 +  test $ac_status = 0; } ;; #(
13596 +  *) :
13597 +
13598 +     as_fn_append CFLAGS " $flag"
13599 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13600 +  (: CFLAGS="$CFLAGS") 2>&5
13601 +  ac_status=$?
13602 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13603 +  test $ac_status = 0; }
13604 +     ;;
13605 + esac
13606 +
13607 + else
13608 +
13609 +  CFLAGS=$flag
13610 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13611 +  (: CFLAGS="$CFLAGS") 2>&5
13612 +  ac_status=$?
13613 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13614 +  test $ac_status = 0; }
13615 +
13616 + fi
13617 +
13618   else
13619 +  :
13620 + fi
13621 +
13622 + done
13623 +
13624 +
13625 +
13626 +
13627 +
13628 + for flag in -Wmissing-include-dirs; do
13629 +  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13630 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13631 + $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13632 + if eval \${$as_CACHEVAR+:} false; then :
13633 +  $as_echo_n "(cached) " >&6
13634 + else
13635 +
13636 +  ax_check_save_flags=$CFLAGS
13637 +  CFLAGS="$CFLAGS  $flag"
13638    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13639   /* end confdefs.h.  */
13640 < $ac_includes_default
13640 >
13641   int
13642   main ()
13643   {
13644  
13645 <             /* Are we little or big endian?  From Harbison&Steele.  */
13646 <             union
13647 <             {
13648 <               long int l;
13649 <               char c[sizeof (long int)];
13650 <             } u;
13651 <             u.l = 1;
13652 <             return u.c[sizeof (long int) - 1] == 1;
13645 >  ;
13646 >  return 0;
13647 > }
13648 > _ACEOF
13649 > if ac_fn_c_try_compile "$LINENO"; then :
13650 >  eval "$as_CACHEVAR=yes"
13651 > else
13652 >  eval "$as_CACHEVAR=no"
13653 > fi
13654 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13655 >  CFLAGS=$ax_check_save_flags
13656 > fi
13657 > eval ac_res=\$$as_CACHEVAR
13658 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13659 > $as_echo "$ac_res" >&6; }
13660 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13661 >
13662 > if ${CFLAGS+:} false; then :
13663 >
13664 >  case " $CFLAGS " in #(
13665 >  *" $flag "*) :
13666 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13667 >  (: CFLAGS already contains $flag) 2>&5
13668 >  ac_status=$?
13669 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13670 >  test $ac_status = 0; } ;; #(
13671 >  *) :
13672 >
13673 >     as_fn_append CFLAGS " $flag"
13674 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13675 >  (: CFLAGS="$CFLAGS") 2>&5
13676 >  ac_status=$?
13677 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13678 >  test $ac_status = 0; }
13679 >     ;;
13680 > esac
13681 >
13682 > else
13683 >
13684 >  CFLAGS=$flag
13685 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13686 >  (: CFLAGS="$CFLAGS") 2>&5
13687 >  ac_status=$?
13688 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13689 >  test $ac_status = 0; }
13690 >
13691 > fi
13692 >
13693 > else
13694 >  :
13695 > fi
13696 >
13697 > done
13698 >
13699 >
13700 >
13701 >
13702 >
13703 > for flag in -Wmissing-parameter-type; do
13704 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13705 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13706 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13707 > if eval \${$as_CACHEVAR+:} false; then :
13708 >  $as_echo_n "(cached) " >&6
13709 > else
13710 >
13711 >  ax_check_save_flags=$CFLAGS
13712 >  CFLAGS="$CFLAGS  $flag"
13713 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13714 > /* end confdefs.h.  */
13715 >
13716 > int
13717 > main ()
13718 > {
13719  
13720    ;
13721    return 0;
13722   }
13723   _ACEOF
13724 < if ac_fn_c_try_run "$LINENO"; then :
13725 <  ac_cv_c_bigendian=no
13724 > if ac_fn_c_try_compile "$LINENO"; then :
13725 >  eval "$as_CACHEVAR=yes"
13726   else
13727 <  ac_cv_c_bigendian=yes
13727 >  eval "$as_CACHEVAR=no"
13728   fi
13729 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
13730 <  conftest.$ac_objext conftest.beam conftest.$ac_ext
13729 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13730 >  CFLAGS=$ax_check_save_flags
13731   fi
13732 + eval ac_res=\$$as_CACHEVAR
13733 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13734 + $as_echo "$ac_res" >&6; }
13735 + if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13736 +
13737 + if ${CFLAGS+:} false; then :
13738 +
13739 +  case " $CFLAGS " in #(
13740 +  *" $flag "*) :
13741 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13742 +  (: CFLAGS already contains $flag) 2>&5
13743 +  ac_status=$?
13744 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13745 +  test $ac_status = 0; } ;; #(
13746 +  *) :
13747 +
13748 +     as_fn_append CFLAGS " $flag"
13749 +     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13750 +  (: CFLAGS="$CFLAGS") 2>&5
13751 +  ac_status=$?
13752 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13753 +  test $ac_status = 0; }
13754 +     ;;
13755 + esac
13756 +
13757 + else
13758 +
13759 +  CFLAGS=$flag
13760 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13761 +  (: CFLAGS="$CFLAGS") 2>&5
13762 +  ac_status=$?
13763 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13764 +  test $ac_status = 0; }
13765  
12924    fi
13766   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)
13767  
13768 < $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
13768 > else
13769 >  :
13770 > fi
13771 >
13772 > done
13773 >
13774 >
13775 >
13776 >
13777 >
13778 > for flag in -Wmissing-prototypes; do
13779 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13780 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13781 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13782 > if eval \${$as_CACHEVAR+:} false; then :
13783 >  $as_echo_n "(cached) " >&6
13784 > else
13785 >
13786 >  ax_check_save_flags=$CFLAGS
13787 >  CFLAGS="$CFLAGS  $flag"
13788 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13789 > /* end confdefs.h.  */
13790 >
13791 > int
13792 > main ()
13793 > {
13794 >
13795 >  ;
13796 >  return 0;
13797 > }
13798 > _ACEOF
13799 > if ac_fn_c_try_compile "$LINENO"; then :
13800 >  eval "$as_CACHEVAR=yes"
13801 > else
13802 >  eval "$as_CACHEVAR=no"
13803 > fi
13804 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13805 >  CFLAGS=$ax_check_save_flags
13806 > fi
13807 > eval ac_res=\$$as_CACHEVAR
13808 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13809 > $as_echo "$ac_res" >&6; }
13810 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13811 >
13812 > if ${CFLAGS+:} false; then :
13813 >
13814 >  case " $CFLAGS " in #(
13815 >  *" $flag "*) :
13816 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13817 >  (: CFLAGS already contains $flag) 2>&5
13818 >  ac_status=$?
13819 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13820 >  test $ac_status = 0; } ;; #(
13821 >  *) :
13822 >
13823 >     as_fn_append CFLAGS " $flag"
13824 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13825 >  (: CFLAGS="$CFLAGS") 2>&5
13826 >  ac_status=$?
13827 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13828 >  test $ac_status = 0; }
13829 >     ;;
13830 > esac
13831 >
13832 > else
13833 >
13834 >  CFLAGS=$flag
13835 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13836 >  (: CFLAGS="$CFLAGS") 2>&5
13837 >  ac_status=$?
13838 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13839 >  test $ac_status = 0; }
13840 >
13841 > fi
13842 >
13843 > else
13844 >  :
13845 > fi
13846 >
13847 > done
13848 >
13849 >
13850 >
13851 >
13852 >
13853 > for flag in -Wnested-externs; do
13854 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13855 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13856 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13857 > if eval \${$as_CACHEVAR+:} false; then :
13858 >  $as_echo_n "(cached) " >&6
13859 > else
13860 >
13861 >  ax_check_save_flags=$CFLAGS
13862 >  CFLAGS="$CFLAGS  $flag"
13863 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13864 > /* end confdefs.h.  */
13865 >
13866 > int
13867 > main ()
13868 > {
13869 >
13870 >  ;
13871 >  return 0;
13872 > }
13873 > _ACEOF
13874 > if ac_fn_c_try_compile "$LINENO"; then :
13875 >  eval "$as_CACHEVAR=yes"
13876 > else
13877 >  eval "$as_CACHEVAR=no"
13878 > fi
13879 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13880 >  CFLAGS=$ax_check_save_flags
13881 > fi
13882 > eval ac_res=\$$as_CACHEVAR
13883 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13884 > $as_echo "$ac_res" >&6; }
13885 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13886 >
13887 > if ${CFLAGS+:} false; then :
13888 >
13889 >  case " $CFLAGS " in #(
13890 >  *" $flag "*) :
13891 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13892 >  (: CFLAGS already contains $flag) 2>&5
13893 >  ac_status=$?
13894 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13895 >  test $ac_status = 0; } ;; #(
13896 >  *) :
13897 >
13898 >     as_fn_append CFLAGS " $flag"
13899 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13900 >  (: CFLAGS="$CFLAGS") 2>&5
13901 >  ac_status=$?
13902 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13903 >  test $ac_status = 0; }
13904 >     ;;
13905 > esac
13906 >
13907 > else
13908 >
13909 >  CFLAGS=$flag
13910 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13911 >  (: CFLAGS="$CFLAGS") 2>&5
13912 >  ac_status=$?
13913 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13914 >  test $ac_status = 0; }
13915 >
13916 > fi
13917 >
13918 > else
13919 >  :
13920 > fi
13921 >
13922 > done
13923 >
13924 >
13925 >
13926 >
13927 >
13928 > for flag in -Wold-style-declaration; do
13929 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
13930 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
13931 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
13932 > if eval \${$as_CACHEVAR+:} false; then :
13933 >  $as_echo_n "(cached) " >&6
13934 > else
13935 >
13936 >  ax_check_save_flags=$CFLAGS
13937 >  CFLAGS="$CFLAGS  $flag"
13938 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
13939 > /* end confdefs.h.  */
13940 >
13941 > int
13942 > main ()
13943 > {
13944 >
13945 >  ;
13946 >  return 0;
13947 > }
13948 > _ACEOF
13949 > if ac_fn_c_try_compile "$LINENO"; then :
13950 >  eval "$as_CACHEVAR=yes"
13951 > else
13952 >  eval "$as_CACHEVAR=no"
13953 > fi
13954 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
13955 >  CFLAGS=$ax_check_save_flags
13956 > fi
13957 > eval ac_res=\$$as_CACHEVAR
13958 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
13959 > $as_echo "$ac_res" >&6; }
13960 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
13961 >
13962 > if ${CFLAGS+:} false; then :
13963 >
13964 >  case " $CFLAGS " in #(
13965 >  *" $flag "*) :
13966 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
13967 >  (: CFLAGS already contains $flag) 2>&5
13968 >  ac_status=$?
13969 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13970 >  test $ac_status = 0; } ;; #(
13971 >  *) :
13972 >
13973 >     as_fn_append CFLAGS " $flag"
13974 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13975 >  (: CFLAGS="$CFLAGS") 2>&5
13976 >  ac_status=$?
13977 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13978 >  test $ac_status = 0; }
13979 >     ;;
13980 > esac
13981 >
13982 > else
13983 >
13984 >  CFLAGS=$flag
13985 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
13986 >  (: CFLAGS="$CFLAGS") 2>&5
13987 >  ac_status=$?
13988 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
13989 >  test $ac_status = 0; }
13990 >
13991 > fi
13992 >
13993 > else
13994 >  :
13995 > fi
13996 >
13997 > done
13998 >
13999 >
14000 >
14001 >
14002 >
14003 > for flag in -Woverride-init; do
14004 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14005 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14006 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14007 > if eval \${$as_CACHEVAR+:} false; then :
14008 >  $as_echo_n "(cached) " >&6
14009 > else
14010 >
14011 >  ax_check_save_flags=$CFLAGS
14012 >  CFLAGS="$CFLAGS  $flag"
14013 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14014 > /* end confdefs.h.  */
14015 >
14016 > int
14017 > main ()
14018 > {
14019 >
14020 >  ;
14021 >  return 0;
14022 > }
14023 > _ACEOF
14024 > if ac_fn_c_try_compile "$LINENO"; then :
14025 >  eval "$as_CACHEVAR=yes"
14026 > else
14027 >  eval "$as_CACHEVAR=no"
14028 > fi
14029 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14030 >  CFLAGS=$ax_check_save_flags
14031 > fi
14032 > eval ac_res=\$$as_CACHEVAR
14033 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14034 > $as_echo "$ac_res" >&6; }
14035 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14036 >
14037 > if ${CFLAGS+:} false; then :
14038 >
14039 >  case " $CFLAGS " in #(
14040 >  *" $flag "*) :
14041 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14042 >  (: CFLAGS already contains $flag) 2>&5
14043 >  ac_status=$?
14044 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14045 >  test $ac_status = 0; } ;; #(
14046 >  *) :
14047 >
14048 >     as_fn_append CFLAGS " $flag"
14049 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14050 >  (: CFLAGS="$CFLAGS") 2>&5
14051 >  ac_status=$?
14052 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14053 >  test $ac_status = 0; }
14054 >     ;;
14055 > esac
14056 >
14057 > else
14058 >
14059 >  CFLAGS=$flag
14060 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14061 >  (: CFLAGS="$CFLAGS") 2>&5
14062 >  ac_status=$?
14063 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14064 >  test $ac_status = 0; }
14065 >
14066 > fi
14067 >
14068 > else
14069 >  :
14070 > fi
14071 >
14072 > done
14073 >
14074 >
14075 >
14076 >
14077 >
14078 > for flag in -Wpointer-arith; do
14079 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14080 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14081 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14082 > if eval \${$as_CACHEVAR+:} false; then :
14083 >  $as_echo_n "(cached) " >&6
14084 > else
14085 >
14086 >  ax_check_save_flags=$CFLAGS
14087 >  CFLAGS="$CFLAGS  $flag"
14088 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14089 > /* end confdefs.h.  */
14090 >
14091 > int
14092 > main ()
14093 > {
14094 >
14095 >  ;
14096 >  return 0;
14097 > }
14098 > _ACEOF
14099 > if ac_fn_c_try_compile "$LINENO"; then :
14100 >  eval "$as_CACHEVAR=yes"
14101 > else
14102 >  eval "$as_CACHEVAR=no"
14103 > fi
14104 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14105 >  CFLAGS=$ax_check_save_flags
14106 > fi
14107 > eval ac_res=\$$as_CACHEVAR
14108 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14109 > $as_echo "$ac_res" >&6; }
14110 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14111 >
14112 > if ${CFLAGS+:} false; then :
14113 >
14114 >  case " $CFLAGS " in #(
14115 >  *" $flag "*) :
14116 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14117 >  (: CFLAGS already contains $flag) 2>&5
14118 >  ac_status=$?
14119 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14120 >  test $ac_status = 0; } ;; #(
14121 >  *) :
14122 >
14123 >     as_fn_append CFLAGS " $flag"
14124 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14125 >  (: CFLAGS="$CFLAGS") 2>&5
14126 >  ac_status=$?
14127 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14128 >  test $ac_status = 0; }
14129 >     ;;
14130 > esac
14131 >
14132 > else
14133 >
14134 >  CFLAGS=$flag
14135 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14136 >  (: CFLAGS="$CFLAGS") 2>&5
14137 >  ac_status=$?
14138 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14139 >  test $ac_status = 0; }
14140 >
14141 > fi
14142 >
14143 > else
14144 >  :
14145 > fi
14146 >
14147 > done
14148 >
14149 >
14150 >
14151 >
14152 >
14153 > for flag in -Wredundant-decls; do
14154 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14155 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14156 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14157 > if eval \${$as_CACHEVAR+:} false; then :
14158 >  $as_echo_n "(cached) " >&6
14159 > else
14160 >
14161 >  ax_check_save_flags=$CFLAGS
14162 >  CFLAGS="$CFLAGS  $flag"
14163 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14164 > /* end confdefs.h.  */
14165 >
14166 > int
14167 > main ()
14168 > {
14169 >
14170 >  ;
14171 >  return 0;
14172 > }
14173 > _ACEOF
14174 > if ac_fn_c_try_compile "$LINENO"; then :
14175 >  eval "$as_CACHEVAR=yes"
14176 > else
14177 >  eval "$as_CACHEVAR=no"
14178 > fi
14179 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14180 >  CFLAGS=$ax_check_save_flags
14181 > fi
14182 > eval ac_res=\$$as_CACHEVAR
14183 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14184 > $as_echo "$ac_res" >&6; }
14185 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14186 >
14187 > if ${CFLAGS+:} false; then :
14188 >
14189 >  case " $CFLAGS " in #(
14190 >  *" $flag "*) :
14191 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14192 >  (: CFLAGS already contains $flag) 2>&5
14193 >  ac_status=$?
14194 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14195 >  test $ac_status = 0; } ;; #(
14196 >  *) :
14197 >
14198 >     as_fn_append CFLAGS " $flag"
14199 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14200 >  (: CFLAGS="$CFLAGS") 2>&5
14201 >  ac_status=$?
14202 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14203 >  test $ac_status = 0; }
14204 >     ;;
14205 > esac
14206 >
14207 > else
14208 >
14209 >  CFLAGS=$flag
14210 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14211 >  (: CFLAGS="$CFLAGS") 2>&5
14212 >  ac_status=$?
14213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14214 >  test $ac_status = 0; }
14215 >
14216 > fi
14217 >
14218 > else
14219 >  :
14220 > fi
14221 >
14222 > done
14223 >
14224 >
14225 >
14226 >
14227 >
14228 > for flag in -Wshadow; do
14229 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14230 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14231 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14232 > if eval \${$as_CACHEVAR+:} false; then :
14233 >  $as_echo_n "(cached) " >&6
14234 > else
14235 >
14236 >  ax_check_save_flags=$CFLAGS
14237 >  CFLAGS="$CFLAGS  $flag"
14238 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14239 > /* end confdefs.h.  */
14240 >
14241 > int
14242 > main ()
14243 > {
14244 >
14245 >  ;
14246 >  return 0;
14247 > }
14248 > _ACEOF
14249 > if ac_fn_c_try_compile "$LINENO"; then :
14250 >  eval "$as_CACHEVAR=yes"
14251 > else
14252 >  eval "$as_CACHEVAR=no"
14253 > fi
14254 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14255 >  CFLAGS=$ax_check_save_flags
14256 > fi
14257 > eval ac_res=\$$as_CACHEVAR
14258 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14259 > $as_echo "$ac_res" >&6; }
14260 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14261 >
14262 > if ${CFLAGS+:} false; then :
14263 >
14264 >  case " $CFLAGS " in #(
14265 >  *" $flag "*) :
14266 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14267 >  (: CFLAGS already contains $flag) 2>&5
14268 >  ac_status=$?
14269 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14270 >  test $ac_status = 0; } ;; #(
14271 >  *) :
14272 >
14273 >     as_fn_append CFLAGS " $flag"
14274 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14275 >  (: CFLAGS="$CFLAGS") 2>&5
14276 >  ac_status=$?
14277 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14278 >  test $ac_status = 0; }
14279 >     ;;
14280 > esac
14281 >
14282 > else
14283 >
14284 >  CFLAGS=$flag
14285 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14286 >  (: CFLAGS="$CFLAGS") 2>&5
14287 >  ac_status=$?
14288 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14289 >  test $ac_status = 0; }
14290 >
14291 > fi
14292 >
14293 > else
14294 >  :
14295 > fi
14296 >
14297 > done
14298 >
14299 >
14300 >
14301 >
14302 >
14303 > for flag in -Wshift-negative-value; do
14304 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14305 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14306 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14307 > if eval \${$as_CACHEVAR+:} false; then :
14308 >  $as_echo_n "(cached) " >&6
14309 > else
14310 >
14311 >  ax_check_save_flags=$CFLAGS
14312 >  CFLAGS="$CFLAGS  $flag"
14313 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14314 > /* end confdefs.h.  */
14315 >
14316 > int
14317 > main ()
14318 > {
14319 >
14320 >  ;
14321 >  return 0;
14322 > }
14323 > _ACEOF
14324 > if ac_fn_c_try_compile "$LINENO"; then :
14325 >  eval "$as_CACHEVAR=yes"
14326 > else
14327 >  eval "$as_CACHEVAR=no"
14328 > fi
14329 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14330 >  CFLAGS=$ax_check_save_flags
14331 > fi
14332 > eval ac_res=\$$as_CACHEVAR
14333 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14334 > $as_echo "$ac_res" >&6; }
14335 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14336 >
14337 > if ${CFLAGS+:} false; then :
14338 >
14339 >  case " $CFLAGS " in #(
14340 >  *" $flag "*) :
14341 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14342 >  (: CFLAGS already contains $flag) 2>&5
14343 >  ac_status=$?
14344 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14345 >  test $ac_status = 0; } ;; #(
14346 >  *) :
14347 >
14348 >     as_fn_append CFLAGS " $flag"
14349 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14350 >  (: CFLAGS="$CFLAGS") 2>&5
14351 >  ac_status=$?
14352 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14353 >  test $ac_status = 0; }
14354 >     ;;
14355 > esac
14356 >
14357 > else
14358 >
14359 >  CFLAGS=$flag
14360 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14361 >  (: CFLAGS="$CFLAGS") 2>&5
14362 >  ac_status=$?
14363 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14364 >  test $ac_status = 0; }
14365 >
14366 > fi
14367 >
14368 > else
14369 >  :
14370 > fi
14371 >
14372 > done
14373 >
14374 >
14375 >
14376 >
14377 >
14378 > for flag in -Wsign-compare; do
14379 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14380 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14381 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14382 > if eval \${$as_CACHEVAR+:} false; then :
14383 >  $as_echo_n "(cached) " >&6
14384 > else
14385 >
14386 >  ax_check_save_flags=$CFLAGS
14387 >  CFLAGS="$CFLAGS  $flag"
14388 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14389 > /* end confdefs.h.  */
14390 >
14391 > int
14392 > main ()
14393 > {
14394 >
14395 >  ;
14396 >  return 0;
14397 > }
14398 > _ACEOF
14399 > if ac_fn_c_try_compile "$LINENO"; then :
14400 >  eval "$as_CACHEVAR=yes"
14401 > else
14402 >  eval "$as_CACHEVAR=no"
14403 > fi
14404 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14405 >  CFLAGS=$ax_check_save_flags
14406 > fi
14407 > eval ac_res=\$$as_CACHEVAR
14408 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14409 > $as_echo "$ac_res" >&6; }
14410 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14411 >
14412 > if ${CFLAGS+:} false; then :
14413 >
14414 >  case " $CFLAGS " in #(
14415 >  *" $flag "*) :
14416 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14417 >  (: CFLAGS already contains $flag) 2>&5
14418 >  ac_status=$?
14419 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14420 >  test $ac_status = 0; } ;; #(
14421 >  *) :
14422 >
14423 >     as_fn_append CFLAGS " $flag"
14424 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14425 >  (: CFLAGS="$CFLAGS") 2>&5
14426 >  ac_status=$?
14427 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14428 >  test $ac_status = 0; }
14429 >     ;;
14430 > esac
14431 >
14432 > else
14433 >
14434 >  CFLAGS=$flag
14435 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14436 >  (: CFLAGS="$CFLAGS") 2>&5
14437 >  ac_status=$?
14438 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14439 >  test $ac_status = 0; }
14440 >
14441 > fi
14442 >
14443 > else
14444 >  :
14445 > fi
14446 >
14447 > done
14448 >
14449 >
14450 >
14451 >
14452 >
14453 > for flag in -Wtype-limits; do
14454 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14455 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14456 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14457 > if eval \${$as_CACHEVAR+:} false; then :
14458 >  $as_echo_n "(cached) " >&6
14459 > else
14460 >
14461 >  ax_check_save_flags=$CFLAGS
14462 >  CFLAGS="$CFLAGS  $flag"
14463 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14464 > /* end confdefs.h.  */
14465 >
14466 > int
14467 > main ()
14468 > {
14469 >
14470 >  ;
14471 >  return 0;
14472 > }
14473 > _ACEOF
14474 > if ac_fn_c_try_compile "$LINENO"; then :
14475 >  eval "$as_CACHEVAR=yes"
14476 > else
14477 >  eval "$as_CACHEVAR=no"
14478 > fi
14479 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14480 >  CFLAGS=$ax_check_save_flags
14481 > fi
14482 > eval ac_res=\$$as_CACHEVAR
14483 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14484 > $as_echo "$ac_res" >&6; }
14485 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14486 >
14487 > if ${CFLAGS+:} false; then :
14488 >
14489 >  case " $CFLAGS " in #(
14490 >  *" $flag "*) :
14491 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14492 >  (: CFLAGS already contains $flag) 2>&5
14493 >  ac_status=$?
14494 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14495 >  test $ac_status = 0; } ;; #(
14496 >  *) :
14497 >
14498 >     as_fn_append CFLAGS " $flag"
14499 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14500 >  (: CFLAGS="$CFLAGS") 2>&5
14501 >  ac_status=$?
14502 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14503 >  test $ac_status = 0; }
14504 >     ;;
14505 > esac
14506 >
14507 > else
14508 >
14509 >  CFLAGS=$flag
14510 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14511 >  (: CFLAGS="$CFLAGS") 2>&5
14512 >  ac_status=$?
14513 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14514 >  test $ac_status = 0; }
14515 >
14516 > fi
14517 >
14518 > else
14519 >  :
14520 > fi
14521 >
14522 > done
14523 >
14524 >
14525 >
14526 >
14527 >
14528 > for flag in -Wundef; do
14529 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14530 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14531 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14532 > if eval \${$as_CACHEVAR+:} false; then :
14533 >  $as_echo_n "(cached) " >&6
14534 > else
14535 >
14536 >  ax_check_save_flags=$CFLAGS
14537 >  CFLAGS="$CFLAGS  $flag"
14538 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14539 > /* end confdefs.h.  */
14540 >
14541 > int
14542 > main ()
14543 > {
14544 >
14545 >  ;
14546 >  return 0;
14547 > }
14548 > _ACEOF
14549 > if ac_fn_c_try_compile "$LINENO"; then :
14550 >  eval "$as_CACHEVAR=yes"
14551 > else
14552 >  eval "$as_CACHEVAR=no"
14553 > fi
14554 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14555 >  CFLAGS=$ax_check_save_flags
14556 > fi
14557 > eval ac_res=\$$as_CACHEVAR
14558 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14559 > $as_echo "$ac_res" >&6; }
14560 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14561 >
14562 > if ${CFLAGS+:} false; then :
14563 >
14564 >  case " $CFLAGS " in #(
14565 >  *" $flag "*) :
14566 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14567 >  (: CFLAGS already contains $flag) 2>&5
14568 >  ac_status=$?
14569 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14570 >  test $ac_status = 0; } ;; #(
14571 >  *) :
14572 >
14573 >     as_fn_append CFLAGS " $flag"
14574 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14575 >  (: CFLAGS="$CFLAGS") 2>&5
14576 >  ac_status=$?
14577 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14578 >  test $ac_status = 0; }
14579 >     ;;
14580 > esac
14581 >
14582 > else
14583 >
14584 >  CFLAGS=$flag
14585 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14586 >  (: CFLAGS="$CFLAGS") 2>&5
14587 >  ac_status=$?
14588 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14589 >  test $ac_status = 0; }
14590 >
14591 > fi
14592 >
14593 > else
14594 >  :
14595 > fi
14596 >
14597 > done
14598 >
14599 >
14600 >
14601 >
14602 >
14603 > for flag in -Wuninitialized; do
14604 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14605 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14606 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14607 > if eval \${$as_CACHEVAR+:} false; then :
14608 >  $as_echo_n "(cached) " >&6
14609 > else
14610 >
14611 >  ax_check_save_flags=$CFLAGS
14612 >  CFLAGS="$CFLAGS  $flag"
14613 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14614 > /* end confdefs.h.  */
14615 >
14616 > int
14617 > main ()
14618 > {
14619 >
14620 >  ;
14621 >  return 0;
14622 > }
14623 > _ACEOF
14624 > if ac_fn_c_try_compile "$LINENO"; then :
14625 >  eval "$as_CACHEVAR=yes"
14626 > else
14627 >  eval "$as_CACHEVAR=no"
14628 > fi
14629 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14630 >  CFLAGS=$ax_check_save_flags
14631 > fi
14632 > eval ac_res=\$$as_CACHEVAR
14633 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14634 > $as_echo "$ac_res" >&6; }
14635 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14636 >
14637 > if ${CFLAGS+:} false; then :
14638 >
14639 >  case " $CFLAGS " in #(
14640 >  *" $flag "*) :
14641 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14642 >  (: CFLAGS already contains $flag) 2>&5
14643 >  ac_status=$?
14644 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14645 >  test $ac_status = 0; } ;; #(
14646 >  *) :
14647 >
14648 >     as_fn_append CFLAGS " $flag"
14649 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14650 >  (: CFLAGS="$CFLAGS") 2>&5
14651 >  ac_status=$?
14652 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14653 >  test $ac_status = 0; }
14654 >     ;;
14655 > esac
14656 >
14657 > else
14658 >
14659 >  CFLAGS=$flag
14660 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14661 >  (: CFLAGS="$CFLAGS") 2>&5
14662 >  ac_status=$?
14663 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14664 >  test $ac_status = 0; }
14665 >
14666 > fi
14667 >
14668 > else
14669 >  :
14670 > fi
14671 >
14672 > done
14673 >
14674 >
14675 >
14676 >
14677 >
14678 > for flag in -Wwrite-strings; do
14679 >  as_CACHEVAR=`$as_echo "ax_cv_check_cflags__$flag" | $as_tr_sh`
14680 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts $flag" >&5
14681 > $as_echo_n "checking whether C compiler accepts $flag... " >&6; }
14682 > if eval \${$as_CACHEVAR+:} false; then :
14683 >  $as_echo_n "(cached) " >&6
14684 > else
14685 >
14686 >  ax_check_save_flags=$CFLAGS
14687 >  CFLAGS="$CFLAGS  $flag"
14688 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14689 > /* end confdefs.h.  */
14690 >
14691 > int
14692 > main ()
14693 > {
14694 >
14695 >  ;
14696 >  return 0;
14697 > }
14698 > _ACEOF
14699 > if ac_fn_c_try_compile "$LINENO"; then :
14700 >  eval "$as_CACHEVAR=yes"
14701 > else
14702 >  eval "$as_CACHEVAR=no"
14703 > fi
14704 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
14705 >  CFLAGS=$ax_check_save_flags
14706 > fi
14707 > eval ac_res=\$$as_CACHEVAR
14708 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
14709 > $as_echo "$ac_res" >&6; }
14710 > if eval test \"x\$"$as_CACHEVAR"\" = x"yes"; then :
14711 >
14712 > if ${CFLAGS+:} false; then :
14713 >
14714 >  case " $CFLAGS " in #(
14715 >  *" $flag "*) :
14716 >    { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS already contains \$flag"; } >&5
14717 >  (: CFLAGS already contains $flag) 2>&5
14718 >  ac_status=$?
14719 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14720 >  test $ac_status = 0; } ;; #(
14721 >  *) :
14722 >
14723 >     as_fn_append CFLAGS " $flag"
14724 >     { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14725 >  (: CFLAGS="$CFLAGS") 2>&5
14726 >  ac_status=$?
14727 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14728 >  test $ac_status = 0; }
14729 >     ;;
14730 > esac
14731 >
14732 > else
14733 >
14734 >  CFLAGS=$flag
14735 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: : CFLAGS=\"\$CFLAGS\""; } >&5
14736 >  (: CFLAGS="$CFLAGS") 2>&5
14737 >  ac_status=$?
14738 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
14739 >  test $ac_status = 0; }
14740 >
14741 > fi
14742 >
14743 > else
14744 >  :
14745 > fi
14746 >
14747 > done
14748  
12938     ;; #(
12939   *)
12940     as_fn_error $? "unknown endianness
12941 presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
12942 esac
14749  
14750 + fi
14751 +
14752 +
14753 +  # Check whether --enable-efence was given.
14754 + if test "${enable_efence+set}" = set; then :
14755 +  enableval=$enable_efence; efence="$enableval"
14756 + else
14757 +  efence="no"
14758 + fi
14759 +
14760 +
14761 +  if test "$efence" = "yes"; then :
14762 +
14763 +    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing EF_Print" >&5
14764 + $as_echo_n "checking for library containing EF_Print... " >&6; }
14765 + if ${ac_cv_search_EF_Print+:} false; then :
14766 +  $as_echo_n "(cached) " >&6
14767 + else
14768 +  ac_func_search_save_LIBS=$LIBS
14769 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
14770 + /* end confdefs.h.  */
14771 +
14772 + /* Override any GCC internal prototype to avoid an error.
14773 +   Use char because int might match the return type of a GCC
14774 +   builtin and then its argument prototype would still apply.  */
14775 + #ifdef __cplusplus
14776 + extern "C"
14777 + #endif
14778 + char EF_Print ();
14779 + int
14780 + main ()
14781 + {
14782 + return EF_Print ();
14783 +  ;
14784 +  return 0;
14785 + }
14786 + _ACEOF
14787 + for ac_lib in '' efence; do
14788 +  if test -z "$ac_lib"; then
14789 +    ac_res="none required"
14790 +  else
14791 +    ac_res=-l$ac_lib
14792 +    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
14793 +  fi
14794 +  if ac_fn_c_try_link "$LINENO"; then :
14795 +  ac_cv_search_EF_Print=$ac_res
14796 + fi
14797 + rm -f core conftest.err conftest.$ac_objext \
14798 +    conftest$ac_exeext
14799 +  if ${ac_cv_search_EF_Print+:} false; then :
14800 +  break
14801 + fi
14802 + done
14803 + if ${ac_cv_search_EF_Print+:} false; then :
14804  
14805 + else
14806 +  ac_cv_search_EF_Print=no
14807 + fi
14808 + rm conftest.$ac_ext
14809 + LIBS=$ac_func_search_save_LIBS
14810 + fi
14811 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_EF_Print" >&5
14812 + $as_echo "$ac_cv_search_EF_Print" >&6; }
14813 + ac_res=$ac_cv_search_EF_Print
14814 + if test "$ac_res" != no; then :
14815 +  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
14816  
14817 + else
14818 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
14819 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
14820 + as_fn_error $? "Electric Fence 'efence' library not found
14821 + See \`config.log' for more details" "$LINENO" 5; }
14822 + fi
14823  
14824  
14825 < subdirs="$subdirs src/libopm"
14825 > fi
14826  
14827  
14828 < ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile"
14828 > for ac_func in strlcpy strlcat
14829 > do :
14830 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
14831 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
14832 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
14833 >  cat >>confdefs.h <<_ACEOF
14834 > #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
14835 > _ACEOF
14836 >
14837 > fi
14838 > done
14839 >
14840 >
14841 > ac_config_files="$ac_config_files Makefile doc/Makefile src/Makefile src/libopm/Makefile src/libopm/src/Makefile"
14842  
14843   cat >confcache <<\_ACEOF
14844   # This file is a shell script that caches the results of configure
# Line 13088 | Line 14978 | if test -z "${am__fastdepCC_TRUE}" && te
14978   Usually this means the macro was only invoked conditionally." "$LINENO" 5
14979   fi
14980  
13091
14981   : "${CONFIG_STATUS=./config.status}"
14982   ac_write_fail=0
14983   ac_clean_files_save=$ac_clean_files
# Line 13485 | Line 15374 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_wri
15374   # report actual input values of CONFIG_FILES etc. instead of their
15375   # values after options handling.
15376   ac_log="
15377 < This file was extended by hopm $as_me 1.0.0beta1, which was
15377 > This file was extended by hopm $as_me 1.1.6, which was
15378   generated by GNU Autoconf 2.69.  Invocation command line was
15379  
15380    CONFIG_FILES    = $CONFIG_FILES
# Line 13545 | Line 15434 | $config_headers
15434   Configuration commands:
15435   $config_commands
15436  
15437 < Report bugs to the package provider."
15437 > Report bugs to <bugs@ircd-hybrid.org>."
15438  
15439   _ACEOF
15440   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
15441   ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
15442   ac_cs_version="\\
15443 < hopm config.status 1.0.0beta1
15443 > hopm config.status 1.1.6
15444   configured by $0, generated by GNU Autoconf 2.69,
15445    with options \\"\$ac_cs_config\\"
15446  
# Line 13670 | Line 15559 | cat >>$CONFIG_STATUS <<_ACEOF || ac_writ
15559   #
15560   # INIT-COMMANDS
15561   #
15562 < AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
15562 > AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
15563  
15564  
15565   # The HP-UX ksh and POSIX shell print the target directory to stdout
# Line 13807 | Line 15696 | finish_cmds='`$ECHO "$finish_cmds" | $SE
15696   finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
15697   hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
15698   sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
15699 < sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
15699 > configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
15700 > configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
15701   hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
15702   enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
15703   enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
# Line 13925 | Line 15815 | postinstall_cmds \
15815   postuninstall_cmds \
15816   finish_cmds \
15817   sys_lib_search_path_spec \
15818 < sys_lib_dlsearch_path_spec; do
15818 > configure_time_dlsearch_path \
15819 > configure_time_lt_sys_library_path; do
15820      case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
15821      *[\\\\\\\`\\"\\\$]*)
15822        eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
# Line 13967 | Line 15858 | do
15858      "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
15859      "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
15860      "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
15861 +    "src/libopm/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/Makefile" ;;
15862 +    "src/libopm/src/Makefile") CONFIG_FILES="$CONFIG_FILES src/libopm/src/Makefile" ;;
15863  
15864    *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
15865    esac
# Line 14566 | Line 16459 | $as_echo "$as_me: executing $ac_file com
16459    # Older Autoconf quotes --file arguments for eval, but not when files
16460    # are listed without --file.  Let's play safe and only enable the eval
16461    # if we detect the quoting.
16462 <  case $CONFIG_FILES in
16463 <  *\'*) eval set x "$CONFIG_FILES" ;;
16464 <  *)   set x $CONFIG_FILES ;;
16465 <  esac
16462 >  # TODO: see whether this extra hack can be removed once we start
16463 >  # requiring Autoconf 2.70 or later.
16464 >  case $CONFIG_FILES in #(
16465 >  *\'*) :
16466 >    eval set x "$CONFIG_FILES" ;; #(
16467 >  *) :
16468 >    set x $CONFIG_FILES ;; #(
16469 >  *) :
16470 >     ;;
16471 > esac
16472    shift
16473 <  for mf
16473 >  # Used to flag and report bootstrapping failures.
16474 >  am_rc=0
16475 >  for am_mf
16476    do
16477      # Strip MF so we end up with the name of the file.
16478 <    mf=`echo "$mf" | sed -e 's/:.*$//'`
16479 <    # Check whether this is an Automake generated Makefile or not.
16480 <    # We used to match only the files named 'Makefile.in', but
16481 <    # some people rename them; so instead we look at the file content.
14581 <    # Grep'ing the first line is not enough: some people post-process
14582 <    # each Makefile.in and add a new line on top of each file to say so.
14583 <    # Grep'ing the whole file is not good either: AIX grep has a line
16478 >    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
16479 >    # Check whether this is an Automake generated Makefile which includes
16480 >    # dependency-tracking related rules and includes.
16481 >    # Grep'ing the whole file directly is not great: AIX grep has a line
16482      # limit of 2048, but all sed's we know have understand at least 4000.
16483 <    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
16484 <      dirpart=`$as_dirname -- "$mf" ||
16485 < $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16486 <         X"$mf" : 'X\(//\)[^/]' \| \
16487 <         X"$mf" : 'X\(//\)$' \| \
16488 <         X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
16489 < $as_echo X"$mf" |
16483 >    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
16484 >      || continue
16485 >    am_dirpart=`$as_dirname -- "$am_mf" ||
16486 > $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
16487 >         X"$am_mf" : 'X\(//\)[^/]' \| \
16488 >         X"$am_mf" : 'X\(//\)$' \| \
16489 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16490 > $as_echo X"$am_mf" |
16491      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
16492              s//\1/
16493              q
# Line 14606 | Line 16505 | $as_echo X"$mf" |
16505              q
16506            }
16507            s/.*/./; q'`
16508 <    else
16509 <      continue
16510 <    fi
16511 <    # Extract the definition of DEPDIR, am__include, and am__quote
16512 <    # from the Makefile without running 'make'.
16513 <    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
14615 <    test -z "$DEPDIR" && continue
14616 <    am__include=`sed -n 's/^am__include = //p' < "$mf"`
14617 <    test -z "$am__include" && continue
14618 <    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
14619 <    # Find all dependency output files, they are included files with
14620 <    # $(DEPDIR) in their names.  We invoke sed twice because it is the
14621 <    # simplest approach to changing $(DEPDIR) to its actual value in the
14622 <    # expansion.
14623 <    for file in `sed -n "
14624 <      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
14625 <         sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
14626 <      # Make sure the directory exists.
14627 <      test -f "$dirpart/$file" && continue
14628 <      fdir=`$as_dirname -- "$file" ||
14629 < $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14630 <         X"$file" : 'X\(//\)[^/]' \| \
14631 <         X"$file" : 'X\(//\)$' \| \
14632 <         X"$file" : 'X\(/\)' \| . 2>/dev/null ||
14633 < $as_echo X"$file" |
14634 <    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14635 <            s//\1/
14636 <            q
14637 <          }
14638 <          /^X\(\/\/\)[^/].*/{
16508 >    am_filepart=`$as_basename -- "$am_mf" ||
16509 > $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
16510 >         X"$am_mf" : 'X\(//\)$' \| \
16511 >         X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
16512 > $as_echo X/"$am_mf" |
16513 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
16514              s//\1/
16515              q
16516            }
16517 <          /^X\(\/\/\)$/{
16517 >          /^X\/\(\/\/\)$/{
16518              s//\1/
16519              q
16520            }
16521 <          /^X\(\/\).*/{
16521 >          /^X\/\(\/\).*/{
16522              s//\1/
16523              q
16524            }
16525            s/.*/./; q'`
16526 <      as_dir=$dirpart/$fdir; as_fn_mkdir_p
16527 <      # echo "creating $dirpart/$file"
16528 <      echo '# dummy' > "$dirpart/$file"
16529 <    done
16526 >    { echo "$as_me:$LINENO: cd "$am_dirpart" \
16527 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16528 >        | $MAKE -f - am--depfiles" >&5
16529 >   (cd "$am_dirpart" \
16530 >      && sed -e '/# am--include-marker/d' "$am_filepart" \
16531 >        | $MAKE -f - am--depfiles) >&5 2>&5
16532 >   ac_status=$?
16533 >   echo "$as_me:$LINENO: \$? = $ac_status" >&5
16534 >   (exit $ac_status); } || am_rc=$?
16535    done
16536 +  if test $am_rc -ne 0; then
16537 +    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
16538 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
16539 + as_fn_error $? "Something went wrong bootstrapping makefile fragments
16540 +    for automatic dependency tracking.  Try re-running configure with the
16541 +    '--disable-dependency-tracking' option to at least be able to build
16542 +    the package (albeit without support for automatic dependency tracking).
16543 + See \`config.log' for more details" "$LINENO" 5; }
16544 +  fi
16545 +  { am_dirpart=; unset am_dirpart;}
16546 +  { am_filepart=; unset am_filepart;}
16547 +  { am_mf=; unset am_mf;}
16548 +  { am_rc=; unset am_rc;}
16549 +  rm -f conftest-deps.mk
16550   }
16551   ;;
16552      "libtool":C)
# Line 14702 | Line 16596 | $as_echo X"$file" |
16596   # The names of the tagged configurations supported by this script.
16597   available_tags=''
16598  
16599 + # Configured defaults for sys_lib_dlsearch_path munging.
16600 + : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
16601 +
16602   # ### BEGIN LIBTOOL CONFIG
16603  
16604   # Which release of libtool.m4 was used?
# Line 14951 | Line 16848 | hardcode_into_libs=$hardcode_into_libs
16848   # Compile-time system search path for libraries.
16849   sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
16850  
16851 < # Run-time system search path for libraries.
16852 < sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
16851 > # Detected run-time system search path for libraries.
16852 > sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
16853 >
16854 > # Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
16855 > configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
16856  
16857   # Whether dlopen is supported.
16858   dlopen_support=$enable_dlopen
# Line 15103 | Line 17003 | hardcode_action=$hardcode_action
17003  
17004   _LT_EOF
17005  
17006 +    cat <<'_LT_EOF' >> "$cfgfile"
17007 +
17008 + # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
17009 +
17010 + # func_munge_path_list VARIABLE PATH
17011 + # -----------------------------------
17012 + # VARIABLE is name of variable containing _space_ separated list of
17013 + # directories to be munged by the contents of PATH, which is string
17014 + # having a format:
17015 + # "DIR[:DIR]:"
17016 + #       string "DIR[ DIR]" will be prepended to VARIABLE
17017 + # ":DIR[:DIR]"
17018 + #       string "DIR[ DIR]" will be appended to VARIABLE
17019 + # "DIRP[:DIRP]::[DIRA:]DIRA"
17020 + #       string "DIRP[ DIRP]" will be prepended to VARIABLE and string
17021 + #       "DIRA[ DIRA]" will be appended to VARIABLE
17022 + # "DIR[:DIR]"
17023 + #       VARIABLE will be replaced by "DIR[ DIR]"
17024 + func_munge_path_list ()
17025 + {
17026 +    case x$2 in
17027 +    x)
17028 +        ;;
17029 +    *:)
17030 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
17031 +        ;;
17032 +    x:*)
17033 +        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
17034 +        ;;
17035 +    *::*)
17036 +        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
17037 +        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
17038 +        ;;
17039 +    *)
17040 +        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
17041 +        ;;
17042 +    esac
17043 + }
17044 +
17045 +
17046 + # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
17047 + func_cc_basename ()
17048 + {
17049 +    for cc_temp in $*""; do
17050 +      case $cc_temp in
17051 +        compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
17052 +        distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
17053 +        \-*) ;;
17054 +        *) break;;
17055 +      esac
17056 +    done
17057 +    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
17058 + }
17059 +
17060 +
17061 + # ### END FUNCTIONS SHARED WITH CONFIGURE
17062 +
17063 + _LT_EOF
17064 +
17065    case $host_os in
17066    aix3*)
17067      cat <<\_LT_EOF >> "$cfgfile"
# Line 15166 | Line 17125 | if test "$no_create" != yes; then
17125    # would make configure fail if this is the last instruction.
17126    $ac_cs_success || as_fn_exit 1
17127   fi
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
17128   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
17129    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
17130   $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}

Diff Legend

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