"Fossies" - the Fresh Open Source Software Archive

Member "sitecopy-0.16.6/configure" (16 Jul 2008, 791706 Bytes) of archive /linux/www/sitecopy-0.16.6.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format (assuming markdown format). Alternatively you can here view or download the uninterpreted source code file. A member file download can also be achieved by clicking within a package contents listing on the according byte size field.

! /bin/sh

Guess values for system-dependent variables and create Makefiles.

Generated by GNU Autoconf 2.61 for sitecopy 0.16.6.

#

Report bugs to sitecopy@lyra.org.

#

Copyright © 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,

2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

This configure script is free software; the Free Software Foundation

gives unlimited permission to copy, distribute and modify it.

———————

M4sh Initialization.

———————

Be more Bourne compatible

DUALCASE=1; export DUALCASE # for MKS sh if test -n “${ZSH_VERSION+set}” && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs word splitting on ${1+“$@”}, which # is contrary to our usage. Disable this feature. alias -g ‘${1+“$@”}’=‘“$@”’ setopt NO_GLOB_SUBST else case (set -o) 2>/dev/null in posix) set -o posix ;; esac

fi

PATH needs CR

Avoid depending upon Character Ranges.

as_cr_letters=‘abcdefghijklmnopqrstuvwxyz’ as_cr_LETTERS=‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’ as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits=‘0123456789’ as_cr_alnum=$as_cr_Letters$as_cr_digits

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi

Support unset when possible.

if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then as_unset=unset else as_unset=false fi

IFS

We need space, tab and new line, in precisely that order. Quoting is

there to prevent editors from complaining about space-tab.

(If _AS_PATH_WALK were called with IFS unset, it would disable word

splitting by setting IFS to empty value.)

as_nl=‘ ’ IFS=“ ”“ $as_nl”

Find who we are. Look in the path if we contain no directory separator.

case $0 in [\/] ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. test -r “$as_dir/$0” && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS

 ;;

esac

We did not find ourselves, most probably we were run as `sh COMMAND'

in which case we are not to be found in the path.

if test “x$as_myself” = x; then as_myself=$0 fi if test ! -f “$as_myself”; then echo “$as_myself: error: cannot find myself; rerun with an absolute file name” >&2 { (exit 1); exit 1; } fi

Work around bugs in pre-3.0 UWIN ksh.

for as_var in ENV MAIL MAILPATH do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var done PS1=‘$ ’ PS2=‘> ’ PS4=‘+ ’

NLS nuisances.

for as_var in \ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ LC_TELEPHONE LC_TIME do if (set +x; test -z “(eval $as_var=C; export $as_var) 2>&1”); then eval $as_var=C; export $as_var else ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var fi done

Required to use basename.

if expr a : ‘(a)’ >/dev/null 2>&1 && test “Xexpr 00001 : '.*\(...\)'” = X001; then as_expr=expr else as_expr=false fi

if (basename – /) >/dev/null 2>&1 && test “Xbasename -- / 2>&1” = “X/”; then as_basename=basename else as_basename=false fi

Name of the executable.

as_me=$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'

CDPATH.

$as_unset CDPATH

if test “x$CONFIG_SHELL” = x; then if (eval “:”) 2>/dev/null; then as_have_required=yes else as_have_required=no fi

if test $as_have_required = yes && (eval “: (as_func_return () { (exit \$1) } as_func_success () { as_func_return 0 } as_func_failure () { as_func_return 1 } as_func_ret_success () { return 0 } as_func_ret_failure () { return 1 }

exitcode=0 if as_func_success; then : else exitcode=1 echo as_func_success failed. fi

if as_func_failure; then exitcode=1 echo as_func_failure succeeded. fi

if as_func_ret_success; then : else exitcode=1 echo as_func_ret_success failed. fi

if as_func_ret_failure; then exitcode=1 echo as_func_ret_failure succeeded. fi

if ( set x; as_func_ret_success y && test x = \“\$1\” ); then : else exitcode=1 echo positional parameters were not saved. fi

test \$exitcode = 0) || { (exit 1); exit 1; }

( as_lineno_1=\$LINENO as_lineno_2=\$LINENO test \“x\$as_lineno_1\” != \“x\$as_lineno_2\” && test \“x`expr \$as_lineno_1 + 1`\” = \“x\$as_lineno_2\”) || { (exit 1); exit 1; } “) 2> /dev/null; then : else as_candidate_shells= as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z ”$as_dir" && as_dir=. case $as_dir in /*) for as_base in sh bash ksh sh5; do as_candidate_shells=“$as_candidate_shells $as_dir/$as_base” done;; esac done IFS=$as_save_IFS

  for as_shell in $as_candidate_shells $SHELL; do
 # Try only shells that exist, to save several forks.
 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
    { ("$as_shell") 2> /dev/null <<\_ASEOF

if test -n “${ZSH_VERSION+set}” && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs word splitting on ${1+“$@”}, which # is contrary to our usage. Disable this feature. alias -g ‘${1+“$@”}’=‘“$@”’ setopt NO_GLOB_SUBST else case (set -o) 2>/dev/null in posix) set -o posix ;; esac

fi

: _ASEOF }; then CONFIG_SHELL=$as_shell as_have_required=yes if { “$as_shell” 2> /dev/null <<_ASEOF if test -n “${ZSH_VERSION+set}” && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs word splitting on ${1+“$@”}, which # is contrary to our usage. Disable this feature. alias -g ‘${1+“$@”}’=‘“$@”’ setopt NO_GLOB_SUBST else case (set -o) 2>/dev/null in posix) set -o posix ;; esac

fi

: (as_func_return () { (exit $1) } as_func_success () { as_func_return 0 } as_func_failure () { as_func_return 1 } as_func_ret_success () { return 0 } as_func_ret_failure () { return 1 }

exitcode=0 if as_func_success; then : else exitcode=1 echo as_func_success failed. fi

if as_func_failure; then exitcode=1 echo as_func_failure succeeded. fi

if as_func_ret_success; then : else exitcode=1 echo as_func_ret_success failed. fi

if as_func_ret_failure; then exitcode=1 echo as_func_ret_failure succeeded. fi

if ( set x; as_func_ret_success y && test x = “$1” ); then : else exitcode=1 echo positional parameters were not saved. fi

test $exitcode = 0) || { (exit 1); exit 1; }

( as_lineno_1=$LINENO as_lineno_2=$LINENO test “x$as_lineno_1” != “x$as_lineno_2” && test “xexpr $as_lineno_1 + 1” = “x$as_lineno_2”) || { (exit 1); exit 1; }

_ASEOF }; then break fi

fi

  done

  if test "x$CONFIG_SHELL" != x; then

for as_var in BASH_ENV ENV do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var done export CONFIG_SHELL exec “$CONFIG_SHELL” “$as_myself” ${1+“$@”} fi

if test $as_have_required = no; then

echo This script requires a shell more modern than all the echo shells that I found on your system. Please install a echo modern shell, or manually run the script under such a echo shell if you do have one. { (exit 1); exit 1; } fi

fi

fi

(eval “as_func_return () { (exit \$1) } as_func_success () { as_func_return 0 } as_func_failure () { as_func_return 1 } as_func_ret_success () { return 0 } as_func_ret_failure () { return 1 }

exitcode=0 if as_func_success; then : else exitcode=1 echo as_func_success failed. fi

if as_func_failure; then exitcode=1 echo as_func_failure succeeded. fi

if as_func_ret_success; then : else exitcode=1 echo as_func_ret_success failed. fi

if as_func_ret_failure; then exitcode=1 echo as_func_ret_failure succeeded. fi

if ( set x; as_func_ret_success y && test x = \“\$1\” ); then : else exitcode=1 echo positional parameters were not saved. fi

test \$exitcode = 0") || { echo No shell found that supports shell functions. echo Please tell autoconf@gnu.org about your system, echo including any error possibly output before this echo message }

as_lineno_1=$LINENO as_lineno_2=$LINENO test “x$as_lineno_1” != “x$as_lineno_2” && test “xexpr $as_lineno_1 + 1” = “x$as_lineno_2” || {

# Create $as_me.lineno as a copy of $as_myself, but with $LINENO # uniformly replaced by the line number. The first ‘sed’ inserts a # line-number line after each line using $LINENO; the second ‘sed’ # does the real work. The second script uses ‘N’ to pair each # line-number line with the line containing $LINENO, and appends # trailing ‘-’ during substitution so that $LINENO is not a special # case at line end. # (Raja R Harinath suggested sed ‘=’, and Paul Eggert wrote the # scripts with optimization help from Paolo Bonzini. Blame Lee # E. McMahon (1931-1989) for sed’s syntax. :-) sed -n ‘ p /[$]LINENO/= ’ <$as_myself | sed ‘ s/[$]LINENO./&-/ t lineno b :lineno N :loop s/[$]LINENO([^’$as_cr_alnum'_].\n)(.)/\2\1\2/ t loop s/-\n.// ‘ >$as_me.lineno && chmod +x “$as_me.lineno” || { echo “$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell” >&2 { (exit 1); exit 1; }; }

# Don’t try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . “./$as_me.lineno” # Exit status is that of the last command. exit }

if (as_dir=dirname -- / && test “X$as_dir” = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi

ECHO_C= ECHO_N= ECHO_T= case echo -n x in -n) case echo 'x\c' in c) ECHO_T=‘ ’;; # ECHO_T is single tab character. ) ECHO_C=‘\c’;; esac;; *) ECHO_N=‘-n’;; esac

if expr a : ‘(a)’ >/dev/null 2>&1 && test “Xexpr 00001 : '.*\(...\)'” = X001; then as_expr=expr else as_expr=false fi

rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir fi echo >conf$$.file if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s=‘ln -s’ # … but there are two gotchas: # 1) On MSYS, both ln -s file dir' andln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; ln -s' creates a wrapper executable. # In both cases, we have to default tocp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s=‘cp -p’ elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s=‘cp -p’ fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then as_mkdir_p=: else test -d ./-p && rmdir ./-p as_mkdir_p=false fi

if test -x / >/dev/null 2>&1; then as_test_x=‘test -x’ else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=‘ eval sh -c ’\‘’ if test -d “$1”; then test -d “$1/.”; else case $1 in -)set “./$1”;; esac; case ls -ld'$as_ls_L_option' "$1" 2>/dev/null in ???[sx]):;;*)false;;esac;fi ‘\’‘ sh ’ fi as_executable_p=$as_test_x

Sed expression to map a string onto a valid CPP name.

as_tr_cpp=“eval sed ‘y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^$as_cr_alnum]%%g’”

Sed expression to map a string onto a valid variable name.

as_tr_sh=“eval sed ‘y%*+%pp%;s%[^$as_cr_alnum]%%g’”

exec 7<&0 &1

Name of the host.

hostname on some systems (SVR3.2, Linux) returns a bogus exit status,

so uname gets run too.

ac_hostname=(hostname || uname -n) 2>/dev/null | sed 1q

#

Initializations.

# ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= SHELL=${CONFIG_SHELL-/bin/sh}

Identity of this package.

PACKAGE_NAME=‘sitecopy’ PACKAGE_TARNAME=‘sitecopy’ PACKAGE_VERSION=‘0.16.6’ PACKAGE_STRING=‘sitecopy 0.16.6’ PACKAGE_BUGREPORT=‘sitecopy@lyra.org’

ac_unique_file=“src/sites.c”

Factoring default headers for most tests.

ac_includes_default=“\

include <stdio.h>

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif

ifdef HAVE_SYS_STAT_H

include <sys/stat.h>

endif

ifdef STDC_HEADERS

include <stdlib.h>

include <stddef.h>

else

ifdef HAVE_STDLIB_H

include <stdlib.h>

endif

endif

ifdef HAVE_STRING_H

if !defined STDC_HEADERS && defined HAVE_MEMORY_H

include <memory.h>

endif

include <string.h>

endif

ifdef HAVE_STRINGS_H

include <strings.h>

endif

ifdef HAVE_INTTYPES_H

include <inttypes.h>

endif

ifdef HAVE_STDINT_H

include <stdint.h>

endif

ifdef HAVE_UNISTD_H

include <unistd.h>

endif"

gt_needs= ac_subst_vars=‘SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datarootdir datadir sysconfdir sharedstatedir localstatedir includedir oldincludedir docdir infodir htmldir dvidir pdfdir psdir libdir localedir mandir DEFS ECHO_C ECHO_N ECHO_T LIBS build_alias host_alias target_alias CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT SET_MAKE INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CPP GREP EGREP LIBOBJS NEON_CONFIG NE_FLAG_SSL NE_FLAG_ZLIB NE_FLAG_IPV6 NE_FLAG_LFS NE_FLAG_SOCKS NE_FLAG_TS_SSL PKG_CONFIG GNUTLS_CONFIG NEON_SUPPORTS_SSL KRB5_CONFIG NEON_CFLAGS NEON_LIBS NEON_LTLIBS NEON_BUILD_BUNDLED XML2_CONFIG AR RANLIB NE_FLAG_DAV NEON_TARGET NEON_OBJEXT NEONOBJS NEON_EXTRAOBJS NEON_LINK_FLAGS LIBGLADE_CONFIG LIBGLADE_CFLAGS LIBGLADE_LIBS mkdir_p USE_NLS GETTEXT_MACRO_VERSION MSGFMT GMSGFMT MSGFMT_015 GMSGFMT_015 XGETTEXT XGETTEXT_015 MSGMERGE XGETTEXT_EXTRA_OPTIONS build build_cpu build_vendor build_os host host_cpu host_vendor host_os GLIBC2 CFLAG_VISIBILITY HAVE_VISIBILITY ALLOCA PRI_MACROS_BROKEN LIBPTH LTLIBPTH LIBPTH_PREFIX LIBTHREAD LTLIBTHREAD LIBMULTITHREAD LTLIBMULTITHREAD LIBICONV LTLIBICONV INTLBISON GLIBC21 INTL_MACOSX_LIBS HAVE_POSIX_PRINTF HAVE_ASPRINTF HAVE_SNPRINTF HAVE_WPRINTF WOE32DLL WOE32 WINDRES LTLIBC BUILD_INCLUDED_LIBINTL USE_INCLUDED_LIBINTL CATOBJEXT DATADIRNAME INSTOBJEXT GENCAT INTLOBJS INTL_LIBTOOL_SUFFIX_PREFIX INTLLIBS LIBINTL LTLIBINTL POSUB GNOME_SC_HELPDIR XSC_HELP SHORTCUT_LOCATION EXTRAOBJS TARGET LTLIBOBJS’ ac_subst_files=‘’ ac_precious_vars=‘build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP’

Initialize some variables set by options.

ac_init_help= ac_init_version=false

The variables have the same names as the options, with

dashes changed to underlines.

cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE

Installation directory options.

These are left unexpanded so users can “make install exec_prefix=/foo”

and all the variables that are supposed to be based on exec_prefix

by default will actually change.

Use braces instead of parens because sh, perl, etc. also accept them.

(The list follows the same order as the GNU Coding Standards.)

bindir=‘${exec_prefix}/bin’ sbindir=‘${exec_prefix}/sbin’ libexecdir=‘${exec_prefix}/libexec’ datarootdir=‘${prefix}/share’ datadir=‘${datarootdir}’ sysconfdir=‘${prefix}/etc’ sharedstatedir=‘${prefix}/com’ localstatedir=‘${prefix}/var’ includedir=‘${prefix}/include’ oldincludedir=‘/usr/include’ docdir=‘${datarootdir}/doc/${PACKAGE_TARNAME}’ infodir=‘${datarootdir}/info’ htmldir=‘${docdir}’ dvidir=‘${docdir}’ pdfdir=‘${docdir}’ psdir=‘${docdir}’ libdir=‘${exec_prefix}/lib’ localedir=‘${datarootdir}/locale’ mandir=‘${datarootdir}/man’

ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n “$ac_prev”; then eval $ac_prev=\$ac_option ac_prev= continue fi

case $ac_option in =) ac_optarg=expr "X$ac_option" : '[^=]*=\(.*\)' ;; *) ac_optarg=yes ;; esac

# Accept the important Cygnus configure options, so we can diagnose typos.

case $ac_dashdash$ac_option in –) ac_dashdash=yes ;;

-bindir | –bindir | –bindi | –bind | –bin | –bi) ac_prev=bindir ;; -bindir= | –bindir= | –bindi= | –bind= | –bin= | –bi=) bindir=$ac_optarg ;;

-build | –build | –buil | –bui | –bu) ac_prev=build_alias ;; -build= | –build= | –buil= | –bui= | –bu=*) build_alias=$ac_optarg ;;

-cache-file | –cache-file | –cache-fil | –cache-fi \ | –cache-f | –cache- | –cache | –cach | –cac | –ca | –c) ac_prev=cache_file ;; -cache-file= | –cache-file= | –cache-fil= | –cache-fi= \ | –cache-f= | –cache-= | –cache= | –cach= | –cac= | –ca= | –c=*) cache_file=$ac_optarg ;;

–config-cache | -C) cache_file=config.cache ;;

-datadir | –datadir | –datadi | –datad) ac_prev=datadir ;; -datadir= | –datadir= | –datadi= | –datad=) datadir=$ac_optarg ;;

-datarootdir | –datarootdir | –datarootdi | –datarootd | –dataroot \ | –dataroo | –dataro | –datar) ac_prev=datarootdir ;; -datarootdir= | –datarootdir= | –datarootdi= | –datarootd= \ | –dataroot= | –dataroo= | –dataro= | –datar=) datarootdir=$ac_optarg ;;

-disable- | –disable-) ac_feature=expr "x$ac_option" : 'x-*disable-\(.*\)' # Reject names that are not valid shell variable names. expr “x$ac_feature” : “.*[^-.$as_cr_alnum]” >/dev/null && { echo “$as_me: error: invalid feature name: $ac_feature” >&2 { (exit 1); exit 1; }; } ac_feature=echo $ac_feature | sed 's/[-.]/_/g' eval enable$ac_feature=no ;;

-docdir | –docdir | –docdi | –doc | –do) ac_prev=docdir ;; -docdir= | –docdir= | –docdi= | –doc= | –do=*) docdir=$ac_optarg ;;

-dvidir | –dvidir | –dvidi | –dvid | –dvi | –dv) ac_prev=dvidir ;; -dvidir= | –dvidir= | –dvidi= | –dvid= | –dvi= | –dv=) dvidir=$ac_optarg ;;

-enable- | –enable-) ac_feature=expr "x$ac_option" : 'x-*enable-\([^=]*\)' # Reject names that are not valid shell variable names. expr “x$ac_feature” : “.*[^-.$as_cr_alnum]” >/dev/null && { echo “$as_me: error: invalid feature name: $ac_feature” >&2 { (exit 1); exit 1; }; } ac_feature=echo $ac_feature | sed 's/[-.]/_/g' eval enable$ac_feature=\$ac_optarg ;;

-exec-prefix | –exec_prefix | –exec-prefix | –exec-prefi \ | –exec-pref | –exec-pre | –exec-pr | –exec-p | –exec- \ | –exec | –exe | –ex) ac_prev=exec_prefix ;; -exec-prefix= | –exec_prefix= | –exec-prefix= | –exec-prefi= \ | –exec-pref= | –exec-pre= | –exec-pr= | –exec-p= | –exec-= \ | –exec= | –exe= | –ex=) exec_prefix=$ac_optarg ;;

-gas | –gas | –ga | –g) # Obsolete; use –with-gas. with_gas=yes ;;

-help | –help | –hel | –he | -h) ac_init_help=long ;; -help=r | –help=r | –hel=r | –he=r | -hr) ac_init_help=recursive ;; -help=s | –help=s | –hel=s | –he=s | -hs) ac_init_help=short ;;

-host | –host | –hos | –ho) ac_prev=host_alias ;; -host= | –host= | –hos= | –ho=) host_alias=$ac_optarg ;;

-htmldir | –htmldir | –htmldi | –htmld | –html | –htm | –ht) ac_prev=htmldir ;; -htmldir= | –htmldir= | –htmldi= | –htmld= | –html= | –htm= \ | –ht=*) htmldir=$ac_optarg ;;

-includedir | –includedir | –includedi | –included | –include \ | –includ | –inclu | –incl | –inc) ac_prev=includedir ;; -includedir= | –includedir= | –includedi= | –included= | –include= \ | –includ= | –inclu= | –incl= | –inc=*) includedir=$ac_optarg ;;

-infodir | –infodir | –infodi | –infod | –info | –inf) ac_prev=infodir ;; -infodir= | –infodir= | –infodi= | –infod= | –info= | –inf=) infodir=$ac_optarg ;;

-libdir | –libdir | –libdi | –libd) ac_prev=libdir ;; -libdir= | –libdir= | –libdi= | –libd=) libdir=$ac_optarg ;;

-libexecdir | –libexecdir | –libexecdi | –libexecd | –libexec \ | –libexe | –libex | –libe) ac_prev=libexecdir ;; -libexecdir= | –libexecdir= | –libexecdi= | –libexecd= | –libexec= \ | –libexe= | –libex= | –libe=) libexecdir=$ac_optarg ;;

-localedir | –localedir | –localedi | –localed | –locale) ac_prev=localedir ;; -localedir= | –localedir= | –localedi= | –localed= | –locale=*) localedir=$ac_optarg ;;

-localstatedir | –localstatedir | –localstatedi | –localstated \ | –localstate | –localstat | –localsta | –localst | –locals) ac_prev=localstatedir ;; -localstatedir= | –localstatedir= | –localstatedi= | –localstated= \ | –localstate= | –localstat= | –localsta= | –localst= | –locals=*) localstatedir=$ac_optarg ;;

-mandir | –mandir | –mandi | –mand | –man | –ma | –m) ac_prev=mandir ;; -mandir= | –mandir= | –mandi= | –mand= | –man= | –ma= | –m=*) mandir=$ac_optarg ;;

-nfp | –nfp | –nf) # Obsolete; use –without-fp. with_fp=no ;;

-no-create | –no-create | –no-creat | –no-crea | –no-cre \ | –no-cr | –no-c | -n) no_create=yes ;;

-no-recursion | –no-recursion | –no-recursio | –no-recursi \ | –no-recurs | –no-recur | –no-recu | –no-rec | –no-re | –no-r) no_recursion=yes ;;

-oldincludedir | –oldincludedir | –oldincludedi | –oldincluded \ | –oldinclude | –oldinclud | –oldinclu | –oldincl | –oldinc \ | –oldin | –oldi | –old | –ol | –o) ac_prev=oldincludedir ;; -oldincludedir= | –oldincludedir= | –oldincludedi= | –oldincluded= \ | –oldinclude= | –oldinclud= | –oldinclu= | –oldincl= | –oldinc= \ | –oldin= | –oldi= | –old= | –ol= | –o=) oldincludedir=$ac_optarg ;;

-prefix | –prefix | –prefi | –pref | –pre | –pr | –p) ac_prev=prefix ;; -prefix= | –prefix= | –prefi= | –pref= | –pre= | –pr= | –p=*) prefix=$ac_optarg ;;

-program-prefix | –program-prefix | –program-prefi | –program-pref \ | –program-pre | –program-pr | –program-p) ac_prev=program_prefix ;; -program-prefix= | –program-prefix= | –program-prefi= \ | –program-pref= | –program-pre= | –program-pr= | –program-p=*) program_prefix=$ac_optarg ;;

-program-suffix | –program-suffix | –program-suffi | –program-suff \ | –program-suf | –program-su | –program-s) ac_prev=program_suffix ;; -program-suffix= | –program-suffix= | –program-suffi= \ | –program-suff= | –program-suf= | –program-su= | –program-s=*) program_suffix=$ac_optarg ;;

-program-transform-name | –program-transform-name \ | –program-transform-nam | –program-transform-na \ | –program-transform-n | –program-transform- \ | –program-transform | –program-transfor \ | –program-transfo | –program-transf \ | –program-trans | –program-tran \ | –progr-tra | –program-tr | –program-t) ac_prev=program_transform_name ;; -program-transform-name= | –program-transform-name= \ | –program-transform-nam= | –program-transform-na= \ | –program-transform-n= | –program-transform-= \ | –program-transform= | –program-transfor= \ | –program-transfo= | –program-transf= \ | –program-trans= | –program-tran= \ | –progr-tra= | –program-tr= | –program-t=*) program_transform_name=$ac_optarg ;;

-pdfdir | –pdfdir | –pdfdi | –pdfd | –pdf | –pd) ac_prev=pdfdir ;; -pdfdir= | –pdfdir= | –pdfdi= | –pdfd= | –pdf= | –pd=) pdfdir=$ac_optarg ;;

-psdir | –psdir | –psdi | –psd | –ps) ac_prev=psdir ;; -psdir= | –psdir= | –psdi= | –psd= | –ps=*) psdir=$ac_optarg ;;

-q | -quiet | –quiet | –quie | –qui | –qu | –q \ | -silent | –silent | –silen | –sile | –sil) silent=yes ;;

-sbindir | –sbindir | –sbindi | –sbind | –sbin | –sbi | –sb) ac_prev=sbindir ;; -sbindir= | –sbindir= | –sbindi= | –sbind= | –sbin= \ | –sbi= | –sb=*) sbindir=$ac_optarg ;;

-sharedstatedir | –sharedstatedir | –sharedstatedi \ | –sharedstated | –sharedstate | –sharedstat | –sharedsta \ | –sharedst | –shareds | –shared | –share | –shar \ | –sha | –sh) ac_prev=sharedstatedir ;; -sharedstatedir= | –sharedstatedir= | –sharedstatedi= \ | –sharedstated= | –sharedstate= | –sharedstat= | –sharedsta= \ | –sharedst= | –shareds= | –shared= | –share= | –shar= \ | –sha= | –sh=) sharedstatedir=$ac_optarg ;;

-site | –site | –sit) ac_prev=site ;; -site= | –site= | –sit=*) site=$ac_optarg ;;

-srcdir | –srcdir | –srcdi | –srcd | –src | –sr) ac_prev=srcdir ;; -srcdir= | –srcdir= | –srcdi= | –srcd= | –src= | –sr=) srcdir=$ac_optarg ;;

-sysconfdir | –sysconfdir | –sysconfdi | –sysconfd | –sysconf \ | –syscon | –sysco | –sysc | –sys | –sy) ac_prev=sysconfdir ;; -sysconfdir= | –sysconfdir= | –sysconfdi= | –sysconfd= | –sysconf= \ | –syscon= | –sysco= | –sysc= | –sys= | –sy=) sysconfdir=$ac_optarg ;;

-target | –target | –targe | –targ | –tar | –ta | –t) ac_prev=target_alias ;; -target= | –target= | –targe= | –targ= | –tar= | –ta= | –t=*) target_alias=$ac_optarg ;;

-v | -verbose | –verbose | –verbos | –verbo | –verb) verbose=yes ;;

-version | –version | –versio | –versi | –vers | -V) ac_init_version=: ;;

-with- | –with-) ac_package=expr "x$ac_option" : 'x-*with-\([^=]*\)' # Reject names that are not valid shell variable names. expr “x$ac_package” : “.*[^-.$as_cr_alnum]” >/dev/null && { echo “$as_me: error: invalid package name: $ac_package” >&2 { (exit 1); exit 1; }; } ac_package=echo $ac_package | sed 's/[-.]/_/g' eval with$ac_package=\$ac_optarg ;;

-without- | –without-) ac_package=expr "x$ac_option" : 'x-*without-\(.*\)' # Reject names that are not valid shell variable names. expr “x$ac_package” : “.*[^-.$as_cr_alnum]” >/dev/null && { echo “$as_me: error: invalid package name: $ac_package” >&2 { (exit 1); exit 1; }; } ac_package=echo $ac_package | sed 's/[-.]/_/g' eval with$ac_package=no ;;

–x) # Obsolete; use –with-x. with_x=yes ;;

-x-includes | –x-includes | –x-include | –x-includ | –x-inclu \ | –x-incl | –x-inc | –x-in | –x-i) ac_prev=x_includes ;; -x-includes= | –x-includes= | –x-include= | –x-includ= | –x-inclu= \ | –x-incl= | –x-inc= | –x-in= | –x-i=*) x_includes=$ac_optarg ;;

-x-libraries | –x-libraries | –x-librarie | –x-librari \ | –x-librar | –x-libra | –x-libr | –x-lib | –x-li | –x-l) ac_prev=x_libraries ;; -x-libraries= | –x-libraries= | –x-librarie= | –x-librari= \ | –x-librar= | –x-libra= | –x-libr= | –x-lib= | –x-li= | –x-l=) x_libraries=$ac_optarg ;;

-*) { echo “$as_me: error: unrecognized option: $ac_option Try `$0 –help' for more information.” >&2 { (exit 1); exit 1; }; } ;;

=) ac_envvar=expr "x$ac_option" : 'x\([^=]*\)=' # Reject names that are not valid shell variable names. expr “x$ac_envvar” : “.*[^_$as_cr_alnum]” >/dev/null && { echo “$as_me: error: invalid variable name: $ac_envvar” >&2 { (exit 1); exit 1; }; } eval $ac_envvar=\$ac_optarg export $ac_envvar ;;

) # FIXME: should be removed in autoconf 3.0. echo “$as_me: WARNING: you should use –build, –host, –target” >&2 expr “x$ac_option” : “.[^-._$as_cr_alnum]” >/dev/null && echo “$as_me: WARNING: invalid host type: $ac_option” >&2 : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} ;;

esac done

if test -n “$ac_prev”; then ac_option=–echo $ac_prev | sed 's/_/-/g' { echo “$as_me: error: missing argument to $ac_option” >&2 { (exit 1); exit 1; }; } fi

Be sure to have absolute directory names.

for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var case $ac_val in [\/$] | ?:[\/] ) continue;; NONE | ‘’ ) case $ac_var in *prefix ) continue;; esac;; esac { echo “$as_me: error: expected an absolute directory name for –$ac_var: $ac_val” >&2 { (exit 1); exit 1; }; } done

There might be people who depend on the old broken behavior: `$host'

used to hold the argument of –host etc.

FIXME: To remove some day.

build=$build_alias host=$host_alias target=$target_alias

FIXME: To remove some day.

if test “x$host_alias” != x; then if test “x$build_alias” = x; then cross_compiling=maybe echo “$as_me: WARNING: If you wanted to set the –build type, don’t use –host. If a cross compiler is detected then cross compile mode will be used.” >&2 elif test “x$build_alias” != “x$host_alias”; then cross_compiling=yes fi fi

ac_tool_prefix= test -n “$host_alias” && ac_tool_prefix=$host_alias-

test “$silent” = yes && exec 6>/dev/null

ac_pwd=pwd && test -n “$ac_pwd” && ac_ls_di=ls -di . && ac_pwd_ls_di=cd "$ac_pwd" && ls -di . || { echo “$as_me: error: Working directory cannot be determined” >&2 { (exit 1); exit 1; }; } test “X$ac_ls_di” = “X$ac_pwd_ls_di” || { echo “$as_me: error: pwd does not report name of working directory” >&2 { (exit 1); exit 1; }; }

Find the source files, if location was not specified.

if test -z “$srcdir”; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=$as_dirname -- "$0" || $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$0" : 'X\(//\)[^/]' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || echo X"$0" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' srcdir=$ac_confdir if test ! -r “$srcdir/$ac_unique_file”; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r “$srcdir/$ac_unique_file”; then test “$ac_srcdir_defaulted” = yes && srcdir=“$ac_confdir or ..” { echo “$as_me: error: cannot find sources ($ac_unique_file) in $srcdir” >&2 { (exit 1); exit 1; }; } fi ac_msg=“sources are in $srcdir, but `cd $srcdir' does not work” ac_abs_confdir=( cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2 { (exit 1); exit 1; }; } pwd)

When building in place, set srcdir=.

if test “$ac_abs_confdir” = “$ac_pwd”; then srcdir=. fi

Remove unnecessary trailing slashes from srcdir.

Double slashes in file names in object file debugging info

mess up M-x gdb in Emacs.

case $srcdir in */) srcdir=expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)';; esac for ac_var in $ac_precious_vars; do eval ac_env${ac_var}set=\${${ac_var}+set} eval ac_env${ac_var}value=\$${ac_var} eval ac_cv_env${ac_var}set=\${${ac_var}+set} eval ac_cv_env${ac_var}value=\$${ac_var} done

#

Report the –help message.

# if test “$ac_init_help” = “long”; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF `configure' configures sitecopy 0.16.6 to adapt to many kinds of systems.

Usage: $0 [OPTION]… [VAR=VALUE]…

To assign environment variables (e.g., CC, CFLAGS…), specify them as VAR=VALUE. See below for descriptions of some of the useful variables.

Defaults for the options are specified in brackets.

Configuration: -h, –help display this help and exit –help=short display options specific to this package –help=recursive display the short help of all the included packages -V, –version display version information and exit -q, –quiet, –silent do not print `checking…‘ messages –cache-file=FILE cache test results in FILE [disabled] -C, –config-cache alias for `–cache-file=config.cache’ -n, –no-create do not create output files –srcdir=DIR find the sources in DIR [configure dir or `..‘]

Installation directories: –prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] –exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX]

By default, `make install' will install all the files in `$ac_default_prefix/bin', `$ac_default_prefix/lib' etc. You can specify an installation prefix other than `$ac_default_prefix' using `–prefix', for instance `–prefix=\$HOME'.

For better control, use the options below.

Fine tuning of the installation directories: –bindir=DIR user executables [EPREFIX/bin] –sbindir=DIR system admin executables [EPREFIX/sbin] –libexecdir=DIR program executables [EPREFIX/libexec] –sysconfdir=DIR read-only single-machine data [PREFIX/etc] –sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] –localstatedir=DIR modifiable single-machine data [PREFIX/var] –libdir=DIR object code libraries [EPREFIX/lib] –includedir=DIR C header files [PREFIX/include] –oldincludedir=DIR C header files for non-gcc [/usr/include] –datarootdir=DIR read-only arch.-independent data root [PREFIX/share] –datadir=DIR read-only architecture-independent data [DATAROOTDIR] –infodir=DIR info documentation [DATAROOTDIR/info] –localedir=DIR locale-dependent data [DATAROOTDIR/locale] –mandir=DIR man documentation [DATAROOTDIR/man] –docdir=DIR documentation root [DATAROOTDIR/doc/sitecopy] –htmldir=DIR html documentation [DOCDIR] –dvidir=DIR dvi documentation [DOCDIR] –pdfdir=DIR pdf documentation [DOCDIR] –psdir=DIR ps documentation [DOCDIR] _ACEOF

cat <<_ACEOF

System types: –build=BUILD configure for building on BUILD [guessed] –host=HOST cross-compile to build programs to run on HOST [BUILD] _ACEOF fi

if test -n “$ac_init_help”; then case $ac_init_help in short | recursive ) echo “Configuration of sitecopy 0.16.6:”;; esac cat <<_ACEOF

Optional Features: –disable-FEATURE do not include FEATURE (same as –enable-FEATURE=no) –enable-FEATURE[=ARG] include FEATURE [ARG=yes] –disable-ftp disable FTP support –disable-webdav disable WebDAV support –disable-rsh disable rsh/rcp support –enable-gnomefe enable GNOME front end –disable-sftp disable sftp/ssh support –disable-debug disable runtime debugging messages –enable-threadsafe-ssl=posix enable SSL library thread-safety using POSIX threads: suitable CC/CFLAGS/LIBS must be used to make the POSIX library interfaces available –disable-nls do not use Native Language Support –enable-threads={posix|solaris|pth|win32} specify multithreading API –disable-threads build without multithread safety –disable-rpath do not hardcode runtime library paths –enable-warnings enable compiler warnings

Optional Packages: –with-PACKAGE[=ARG] use PACKAGE [ARG=yes] –without-PACKAGE do not use PACKAGE (same as –with-PACKAGE=no) –with-libs=DIR[:DIR2…] look for support libraries in DIR/{bin,lib,include} –with-included-neon force use of included neon library –with-neon[=DIR] specify location of neon library –with-ssl=openssl|gnutls enable SSL support (default OpenSSL) –with-egd[=PATH] enable EGD support [using EGD socket at PATH] –without-pakchois disable support for PKCS#11 using pakchois –with-ca-bundle specify filename of an SSL CA root bundle –with-socks use SOCKSv5 library –without-gssapi disable GSSAPI support –with-libxml2 force use of libxml 2.x –with-expat force use of expat –with-included-expat use bundled expat sources –with-libglade-config=LIBGLADE_CONFIG Location of libglade-config –with-gnu-ld assume the C compiler uses GNU ld default=no –with-libpth-prefix[=DIR] search for libpth in DIR/include and DIR/lib –without-libpth-prefix don’t search for libpth in includedir and libdir –with-libiconv-prefix[=DIR] search for libiconv in DIR/include and DIR/lib –without-libiconv-prefix don’t search for libiconv in includedir and libdir –with-included-gettext use the GNU gettext library included here –with-libintl-prefix[=DIR] search for libintl in DIR/include and DIR/lib –without-libintl-prefix don’t search for libintl in includedir and libdir

Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor

Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations.

Report bugs to sitecopy@lyra.org. _ACEOF ac_status=$? fi

if test “$ac_init_help” = “recursive”; then # If there are subdirs, report their specific –help. for ac_dir in : $ac_subdirs_all; do test “x$ac_dir” = x: && continue test -d “$ac_dir” || continue ac_builddir=.

case “$ac_dir” in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; ) ac_dir_suffix=/echo "$ac_dir" | sed 's,^\.[\\/],,' # A “..” for each directory in $ac_dir_suffix. ac_top_builddir_sub=echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,' case $ac_top_builddir_sub in “”) ac_top_builddir_sub=. ac_top_build_prefix= ;; ) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix

for backward compatibility:

ac_top_builddir=$ac_top_build_prefix

case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\/] | ?:[\/] ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

cd "$ac_dir" || { ac_status=$?; continue; }
# Check for guested configure.
if test -f "$ac_srcdir/configure.gnu"; then
  echo &&
  $SHELL "$ac_srcdir/configure.gnu" --help=recursive
elif test -f "$ac_srcdir/configure"; then
  echo &&
  $SHELL "$ac_srcdir/configure" --help=recursive
else
  echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
fi || ac_status=$?
cd "$ac_pwd" || { ac_status=$?; break; }

done fi

test -n “$ac_init_help” && exit $ac_status if $ac_init_version; then cat <<_ACEOF sitecopy configure 0.16.6 generated by GNU Autoconf 2.61

Copyright © 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. ACEOF exit fi cat >config.log <<ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake.

It was created by sitecopy $as_me 0.16.6, which was generated by GNU Autoconf 2.61. Invocation command line was

$ $0 $@

ACEOF exec 5>>config.log { cat <<ASUNAME

———

Platform.

———

hostname = (hostname || uname -n) 2>/dev/null | sed 1q uname -m = (uname -m) 2>/dev/null || echo unknown uname -r = (uname -r) 2>/dev/null || echo unknown uname -s = (uname -s) 2>/dev/null || echo unknown uname -v = (uname -v) 2>/dev/null || echo unknown

/usr/bin/uname -p = (/usr/bin/uname -p) 2>/dev/null || echo unknown /bin/uname -X = (/bin/uname -X) 2>/dev/null || echo unknown

/bin/arch = (/bin/arch) 2>/dev/null || echo unknown /usr/bin/arch -k = (/usr/bin/arch -k) 2>/dev/null || echo unknown /usr/convex/getsysinfo = (/usr/convex/getsysinfo) 2>/dev/null || echo unknown /usr/bin/hostinfo = (/usr/bin/hostinfo) 2>/dev/null || echo unknown /bin/machine = (/bin/machine) 2>/dev/null || echo unknown /usr/bin/oslevel = (/usr/bin/oslevel) 2>/dev/null || echo unknown /bin/universe = (/bin/universe) 2>/dev/null || echo unknown

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. echo “PATH: $as_dir” done IFS=$as_save_IFS

} >&5

cat >&5 <<_ACEOF

———–

Core tests.

———–

_ACEOF

Keep a trace of the command line.

Strip out –no-create and –no-recursion so they do not pile up.

Strip out –silent because we don’t want to record it for future runs.

Also quote any args containing shell meta-characters.

Make two passes to allow for proper duplicate-argument suppression.

ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | –no-c | -n | -no-recursion | –no-r) continue ;; -q | -quiet | –quiet | –quie | –qui | –qu | –q \ | -silent | –silent | –silen | –sile | –sil) continue ;; \‘) ac_arg=echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g" ;; esac case $ac_pass in 1) ac_configure_args0=“$ac_configure_args0 ’$ac_arg'” ;; 2) ac_configure_args1=“$ac_configure_args1 ‘$ac_arg’” if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in = | –config-cache | -C | -disable- | –disable- \ | -enable- | –enable- | -gas | –g | -nfp | –nf \ | -q | -quiet | –q | -silent | –sil | -v | -verb \ | -with- | –with- | -without- | –without- | –x) case “$ac_configure_args0 ” in “$ac_configure_args1”“ ‘$ac_arg’ ” ) continue ;; esac ;; - ) ac_must_keep_next=true ;; esac fi ac_configure_args=“$ac_configure_args ‘$ac_arg’” ;; esac done done $as_unset ac_configure_args0 || test “${ac_configure_args0+set}” != set || { ac_configure_args0=; export ac_configure_args0; } $as_unset ac_configure_args1 || test “${ac_configure_args1+set}” != set || { ac_configure_args1=; export ac_configure_args1; }

When interrupted or exit’d, cleanup temporary files, and complete

config.log. We remove comments because anyway the quotes in there

would cause problems or look ugly.

WARNING: Use ‘\’‘ to represent an apostrophe within the trap.

WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.

trap ‘exit_status=$? # Save into config.log some information that might help in debugging. { echo

cat <<\_ASBOX

—————-

Cache variables.

—————-

ASBOX echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in (set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''; do eval ac_val=\$$ac_var case $ac_val in #( ${as_nl}) case $ac_var in #( *cv) { echo “$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline.” >&5 echo “$as_me: WARNING: Cache variable $ac_var contains a newline.” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( ) $as_unset $ac_var ;; esac ;; esac done (set) 2>&1 | case $as_nl(ac_space='\'' '\''; set) 2>&1 in #( ${as_nl}ac_space=\ ) sed -n \ “s/‘\’‘/’\‘’\\‘\’‘’\‘’/g; s/^\([$as_cr_alnum]cv[_$as_cr_alnum]\)=\(.\)/\1=‘\’‘\2’\‘’/p” ;; #( ) sed -n “/^[$as_cr_alnum]*cv[$as_cr_alnum]*=/p” ;; esac | sort ) echo

cat <<\_ASBOX

—————–

Output variables.

—————–

_ASBOX echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in \‘\’‘) ac_val=echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g";; esac echo “$ac_var=’\‘’$ac_val'\‘’” done | sort echo

if test -n "$ac_subst_files"; then
  cat <<\_ASBOX

——————-

File substitutions.

——————-

_ASBOX echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in \‘\’‘) ac_val=echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g";; esac echo “$ac_var=’\‘’$ac_val'\‘’” done | sort echo fi

if test -s confdefs.h; then
  cat <<\_ASBOX

———–

confdefs.h.

———–

_ASBOX echo cat confdefs.h echo fi test “$ac_signal” != 0 && echo “$as_me: caught signal $ac_signal” echo “$as_me: exit $exit_status” } >&5 rm -f core .core core.conftest. && rm -f -r conftest confdefs conf$$* $ac_clean_files && exit $exit_status ‘ 0 for ac_signal in 1 2 13 15; do trap 'ac_signal=’$ac_signal'; { (exit 1); exit 1; }‘ $ac_signal done ac_signal=0

confdefs.h avoids OS command line length limits that DEFS can exceed.

rm -f -r conftest* confdefs.h

Predefined preprocessor variables.

cat >>confdefs.h <<_ACEOF

define PACKAGE_NAME “$PACKAGE_NAME”

_ACEOF

cat >>confdefs.h <<_ACEOF

define PACKAGE_TARNAME “$PACKAGE_TARNAME”

_ACEOF

cat >>confdefs.h <<_ACEOF

define PACKAGE_VERSION “$PACKAGE_VERSION”

_ACEOF

cat >>confdefs.h <<_ACEOF

define PACKAGE_STRING “$PACKAGE_STRING”

_ACEOF

cat >>confdefs.h <<_ACEOF

define PACKAGE_BUGREPORT “$PACKAGE_BUGREPORT”

_ACEOF

Let the site file select an alternate cache file if it wants to.

Prefer explicitly selected file to automatically selected ones.

if test -n “$CONFIG_SITE”; then set x “$CONFIG_SITE” elif test “x$prefix” != xNONE; then set x “$prefix/share/config.site” “$prefix/etc/config.site” else set x “$ac_default_prefix/share/config.site” \ “$ac_default_prefix/etc/config.site” fi shift for ac_site_file do if test -r “$ac_site_file”; then { echo “$as_me:$LINENO: loading site script $ac_site_file” >&5 echo “$as_me: loading site script $ac_site_file” >&6;} sed ’s/^/| /‘ “$ac_site_file” >&5 . “$ac_site_file” fi done

if test -r “$cache_file”; then # Some versions of bash will fail to source /dev/null (special # files actually), so we avoid doing that. if test -f “$cache_file”; then { echo “$as_me:$LINENO: loading cache $cache_file” >&5 echo “$as_me: loading cache $cache_file” >&6;} case $cache_file in [\/] | ?:[\/] ) . “$cache_file”;; *) . “./$cache_file”;; esac fi else { echo “$as_me:$LINENO: creating cache $cache_file” >&5 echo “$as_me: creating cache $cache_file” >&6;}

$cache_file fi

gt_needs=“$gt_needs ”

Check that the precious variables saved in the cache have kept the same

value.

ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env${ac_var}set eval ac_new_set=\$ac_env${ac_var}set eval ac_old_val=\$ac_cv_env${ac_var}value eval ac_new_val=\$ac_env${ac_var}value case $ac_old_set,$ac_new_set in set,) { echo “$as_me:$LINENO: error: `$ac_var' was set to `$ac_old_val' in the previous run” >&5 echo “$as_me: error: `$ac_var' was set to `$ac_old_val' in the previous run” >&2;} ac_cache_corrupted=: ;; ,set) { echo “$as_me:$LINENO: error: `$ac_var' was not set in the previous run” >&5 echo “$as_me: error: `$ac_var' was not set in the previous run” >&2;} ac_cache_corrupted=: ;; ,);; ) if test “x$ac_old_val” != “x$ac_new_val”; then { echo “$as_me:$LINENO: error: `$ac_var' has changed since the previous run:” >&5 echo “$as_me: error: `$ac_var' has changed since the previous run:” >&2;} { echo “$as_me:$LINENO: former value: $ac_old_val” >&5 echo “$as_me: former value: $ac_old_val” >&2;} { echo “$as_me:$LINENO: current value: $ac_new_val” >&5 echo “$as_me: current value: $ac_new_val” >&2;} ac_cache_corrupted=: fi;; esac # Pass precious variables to config.status. if test “$ac_new_set” = set; then case $ac_new_val in \‘) ac_arg=$ac_var=echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g" ;; ) ac_arg=$ac_var=$ac_new_val ;; esac case “ $ac_configure_args ” in “ ’$ac_arg' ”) ;; # Avoid dups. Use of quotes ensures accuracy. *) ac_configure_args=“$ac_configure_args ‘$ac_arg’” ;; esac fi done if $ac_cache_corrupted; then { echo “$as_me:$LINENO: error: changes in the environment can compromise the build” >&5 echo “$as_me: error: changes in the environment can compromise the build” >&2;} { { echo “$as_me:$LINENO: error: run `make distclean' and/or `rm $cache_file' and start over” >&5 echo “$as_me: error: run `make distclean' and/or `rm $cache_file' and start over” >&2;} { (exit 1); exit 1; }; } fi

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu

ac_config_headers=“$ac_config_headers config.h”

EXTRAOBJS=“” proto_msg=“” top_builddir=pwd

cat >>confdefs.h <<_ACEOF

define _GNU_SOURCE 1

_ACEOF

Check whether –with-libs was given.

if test “${with_libs+set}” = set; then withval=$with_libs; case $with_libs in yes|no) { { echo “$as_me:$LINENO: error: –with-libs must be passed a directory argument” >&5 echo “$as_me: error: –with-libs must be passed a directory argument” >&2;} { (exit 1); exit 1; }; } ;; *) ne_save_IFS=$IFS; IFS=: for dir in $with_libs; do ne_add_CPPFLAGS=“$ne_add_CPPFLAGS -I${dir}/include” ne_add_LDFLAGS=“$ne_add_LDFLAGS -L${dir}/lib” ne_add_PATH=“${ne_add_PATH}${dir}/bin:” PKG_CONFIG_PATH=${PKG_CONFIG_PATH}${PKG_CONFIG_PATH+:}${dir}/lib/pkgconfig done IFS=$ne_save_IFS CPPFLAGS=“${ne_add_CPPFLAGS} $CPPFLAGS” LDFLAGS=“${ne_add_LDFLAGS} $LDFLAGS” PATH=${ne_add_PATH}$PATH export PKG_CONFIG_PATH ;; esac fi

Check whether –enable-ftp was given.

if test “${enable_ftp+set}” = set; then enableval=$enable_ftp; else enable_ftp=yes fi

Check whether –enable-webdav was given.

if test “${enable_webdav+set}” = set; then enableval=$enable_webdav; else enable_webdav=yes fi

Check whether –enable-rsh was given.

if test “${enable_rsh+set}” = set; then enableval=$enable_rsh; else enable_rsh=yes fi

Check whether –enable-gnomefe was given.

if test “${enable_gnomefe+set}” = set; then enableval=$enable_gnomefe; fi

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}gcc”, so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$CC”; then ac_cv_prog_CC=“$CC” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_CC=“${ac_tool_prefix}gcc” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi CC=$ac_cv_prog_CC if test -n “$CC”; then { echo “$as_me:$LINENO: result: $CC” >&5 echo “${ECHO_T}$CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$ac_cv_prog_CC”; then ac_ct_CC=$CC # Extract the first word of “gcc”, so it can be a program name with args. set dummy gcc; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_ac_ct_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_CC”; then ac_cv_prog_ac_ct_CC=“$ac_ct_CC” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_ac_ct_CC=“gcc” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n “$ac_ct_CC”; then { echo “$as_me:$LINENO: result: $ac_ct_CC” >&5 echo “${ECHO_T}$ac_ct_CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_ct_CC” = x; then CC=“” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC=“$ac_cv_prog_CC” fi

if test -z “$CC”; then if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}cc”, so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$CC”; then ac_cv_prog_CC=“$CC” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_CC=“${ac_tool_prefix}cc” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi CC=$ac_cv_prog_CC if test -n “$CC”; then { echo “$as_me:$LINENO: result: $CC” >&5 echo “${ECHO_T}$CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi fi if test -z “$CC”; then # Extract the first word of “cc”, so it can be a program name with args. set dummy cc; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$CC”; then ac_cv_prog_CC=“$CC” # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then if test “$as_dir/$ac_word$ac_exec_ext” = “/usr/ucb/cc”; then ac_prog_rejected=yes continue fi ac_cv_prog_CC=“cc” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC=“$as_dir/$ac_word${1+‘ ’}$@” fi fi fi fi CC=$ac_cv_prog_CC if test -n “$CC”; then { echo “$as_me:$LINENO: result: $CC” >&5 echo “${ECHO_T}$CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$CC”; then if test -n “$ac_tool_prefix”; then for ac_prog in cl.exe do # Extract the first word of “$ac_tool_prefix$ac_prog”, so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$CC”; then ac_cv_prog_CC=“$CC” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_CC=“$ac_tool_prefix$ac_prog” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi CC=$ac_cv_prog_CC if test -n “$CC”; then { echo “$as_me:$LINENO: result: $CC” >&5 echo “${ECHO_T}$CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

test -n "$CC" && break

done fi if test -z “$CC”; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_ac_ct_CC+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_CC”; then ac_cv_prog_ac_ct_CC=“$ac_ct_CC” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_ac_ct_CC=“$ac_prog” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n “$ac_ct_CC”; then { echo “$as_me:$LINENO: result: $ac_ct_CC” >&5 echo “${ECHO_T}$ac_ct_CC” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

test -n “$ac_ct_CC” && break done

if test “x$ac_ct_CC” = x; then CC=“” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi

fi

test -z “$CC” && { { echo “$as_me:$LINENO: error: no acceptable C compiler found in \$PATH See `config.log' for more details.” >&5 echo “$as_me: error: no acceptable C compiler found in \$PATH See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; }

Provide some information about the compiler.

echo “$as_me:$LINENO: checking for C compiler version” >&5 ac_compiler=set X $ac_compile; echo $2 { (ac_try=“$ac_compiler –version >&5” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compiler –version >&5”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } { (ac_try=“$ac_compiler -v >&5” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compiler -v >&5”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } { (ac_try=“$ac_compiler -V >&5” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compiler -V >&5”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () {

; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files=“$ac_clean_files a.out a.exe b.out”

Try to create an executable without -o first, disregard a.out.

It will help us diagnose broken compilers, and finding out an intuition

of exeext.

{ echo “$as_me:$LINENO: checking for C compiler default output file name” >&5 echo $ECHO_N “checking for C compiler default output file name… $ECHO_C” >&6; } ac_link_default=echo "$ac_link" | sed 's/ -o *conftest[^ ]*//' #

List of possible output files, starting from the most likely.

The algorithm is not robust to junk in `.‘, hence go to wildcards (a.*)

only as a last resort. b.out is created by i960 compilers.

ac_files=‘a_out.exe a.exe conftest.exe a.out conftest a. conftest. b.out’ #

The IRIX 6 linker writes into existing files which may not be

executable, retaining their permissions. Remove them first so a

subsequent execution test works.

ac_rmfiles= for ac_file in $ac_files do case $ac_file in .$ac_ext | .xcoff | .tds | .d | .pdb | .xSYM | .bb | .bbg | .map | .inf | .o | .obj ) ;; * ) ac_rmfiles=“$ac_rmfiles $ac_file”;; esac done rm -f $ac_rmfiles

if { (ac_try=“$ac_link_default” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link_default”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.

So ignore a value of no', otherwise this would lead toEXEEXT = no'

in a Makefile. We should not override ac_cv_exeext if it was cached,

so that the user can short-circuit this test for compilers unknown to

Autoconf.

for ac_file in $ac_files ‘’ do test -f “$ac_file” || continue case $ac_file in .$ac_ext | .xcoff | .tds | .d | .pdb | .xSYM | .bb | .bbg | .map | .inf | .o | .obj ) ;; [ab].out ) # We found the default executable, but exeext=‘’ is most # certainly right. break;; . ) if test “${ac_cv_exeext+set}” = set && test “$ac_cv_exeext” != no; then :; else ac_cv_exeext=expr "$ac_file" : '[^.]*\(\..*\)' fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test “$ac_cv_exeext” = no && ac_cv_exeext=

else ac_file=‘’ fi

{ echo “$as_me:$LINENO: result: $ac_file” >&5 echo “${ECHO_T}$ac_file” >&6; } if test -z “$ac_file”; then echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

{ { echo “$as_me:$LINENO: error: C compiler cannot create executables See `config.log' for more details.” >&5 echo “$as_me: error: C compiler cannot create executables See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } fi

ac_exeext=$ac_cv_exeext

Check that the compiler produces executables we can run. If not, either

the compiler is broken, or we cross compile.

{ echo “$as_me:$LINENO: checking whether the C compiler works” >&5 echo $ECHO_N “checking whether the C compiler works… $ECHO_C” >&6; }

FIXME: These cross compiler hacks should be removed for Autoconf 3.0

If not cross compiling, check that we can run a simple program.

if test “$cross_compiling” != yes; then if { ac_try=‘./$ac_file’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then cross_compiling=no else if test “$cross_compiling” = maybe; then cross_compiling=yes else { { echo “$as_me:$LINENO: error: cannot run C compiled programs. If you meant to cross compile, use `–host'. See `config.log' for more details.” >&5 echo “$as_me: error: cannot run C compiled programs. If you meant to cross compile, use `–host'. See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; } fi fi fi { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; }

rm -f a.out a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save

Check that the compiler produces executables we can run. If not, either

the compiler is broken, or we cross compile.

{ echo “$as_me:$LINENO: checking whether we are cross compiling” >&5 echo $ECHO_N “checking whether we are cross compiling… $ECHO_C” >&6; } { echo “$as_me:$LINENO: result: $cross_compiling” >&5 echo “${ECHO_T}$cross_compiling” >&6; }

{ echo “$as_me:$LINENO: checking for suffix of executables” >&5 echo $ECHO_N “checking for suffix of executables… $ECHO_C” >&6; } if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then # If both conftest.exe' andconftest' are `present' (well, observable)

catch conftest.exe'. For instance with Cygwin,ls conftest' will

work properly (i.e., refer to `conftest.exe'), while it won’t with

`rm'.

for ac_file in conftest.exe conftest conftest.; do test -f “$ac_file” || continue case $ac_file in .$ac_ext | .xcoff | .tds | .d | .pdb | .xSYM | .bb | .bbg | .map | .inf | .o | .obj ) ;; .* ) ac_cv_exeext=expr "$ac_file" : '[^.]*\(\..*\)' break;; * ) break;; esac done else { { echo “$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute suffix of executables: cannot compile and link See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; } fi

rm -f conftest$ac_cv_exeext { echo “$as_me:$LINENO: result: $ac_cv_exeext” >&5 echo “${ECHO_T}$ac_cv_exeext” >&6; }

rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT { echo “$as_me:$LINENO: checking for suffix of object files” >&5 echo $ECHO_N “checking for suffix of object files… $ECHO_C” >&6; } if test “${ac_cv_objext+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () {

; return 0; } _ACEOF rm -f conftest.o conftest.obj if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then for ac_file in conftest.o conftest.obj conftest.; do test -f “$ac_file” || continue; case $ac_file in .$ac_ext | .xcoff | .tds | .d | .pdb | .xSYM | .bb | .bbg | .map | .inf ) ;; *) ac_cv_objext=expr "$ac_file" : '.*\.\(.*\)' break;; esac done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

{ { echo “$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute suffix of object files: cannot compile See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; } fi

rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_objext” >&5 echo “${ECHO_T}$ac_cv_objext” >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { echo “$as_me:$LINENO: checking whether we are using the GNU C compiler” >&5 echo $ECHO_N “checking whether we are using the GNU C compiler… $ECHO_C” >&6; } if test “${ac_cv_c_compiler_gnu+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () {

ifndef GNUC

   choke me

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_compiler_gnu=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_compiler_gnu=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi { echo “$as_me:$LINENO: result: $ac_cv_c_compiler_gnu” >&5 echo “${ECHO_T}$ac_cv_c_compiler_gnu” >&6; } GCC=test $ac_compiler_gnu = yes && echo yes ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { echo “$as_me:$LINENO: checking whether $CC accepts -g” >&5 echo $ECHO_N “checking whether $CC accepts -g… $ECHO_C” >&6; } if test “${ac_cv_prog_cc_g+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS=“-g” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_prog_cc_g=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

CFLAGS=""
  cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then : else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_c_werror_flag=$ac_save_c_werror_flag
 CFLAGS="-g"
 cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_prog_cc_g=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { echo “$as_me:$LINENO: result: $ac_cv_prog_cc_g” >&5 echo “${ECHO_T}$ac_cv_prog_cc_g” >&6; } if test “$ac_test_CFLAGS” = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test “$GCC” = yes; then CFLAGS=“-g -O2” else CFLAGS=“-g” fi else if test “$GCC” = yes; then CFLAGS=“-O2” else CFLAGS= fi fi { echo “$as_me:$LINENO: checking for $CC option to accept ISO C89” >&5 echo $ECHO_N “checking for $CC option to accept ISO C89… $ECHO_C” >&6; } if test “${ac_cv_prog_cc_c89+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdarg.h>

include <stdio.h>

include <sys/types.h>

include <sys/stat.h>

/ Most of the following tests are stolen from RCS 5.7’s src/conf.sh. / struct buf { int x; }; FILE * (rcsopen) (struct buf , struct stat , int); static char e (p, i) char p; int i; { return p[i]; } static char f (char * (g) (char , int), char *p, …) { char s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; }

/ OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not ‘\xHH’ hex character constants. These don’t provoke an error unfortunately, instead are silently treated as ‘x’. The following induces an error, until -std is added to get proper ANSI mode. Curiously ‘\x00’!=‘x’ always comes out true, for an array size at least. It’s necessary to write ‘\x00’==0 to get something that’s true only with -std. / int osf4_cc_array [‘\x00’ == 0 ? 1 : -1];

/ IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. /

define FOO(x) ‘x’

int xlc6_cc_array[FOO(a) == ‘x’ ? 1 : -1];

int test (int i, double x); struct s1 {int (f) (int a);}; struct s2 {int (f) (double a);}; int pairnames (int, char , FILE ()(struct buf , struct stat , int), int, int); int argc; char argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in ‘’ -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae “-Aa -D_HPUX_SOURCE” “-Xc -DEXTENSIONS” do CC=“$ac_save_CC $ac_arg” rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_prog_cc_c89=$ac_arg else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext test “x$ac_cv_prog_cc_c89” != “xno” && break done rm -f conftest.$ac_ext CC=$ac_save_CC

fi

AC_CACHE_VAL

case “x$ac_cv_prog_cc_c89” in x) { echo “$as_me:$LINENO: result: none needed” >&5 echo “${ECHO_T}none needed” >&6; } ;; xno) { echo “$as_me:$LINENO: result: unsupported” >&5 echo “${ECHO_T}unsupported” >&6; } ;; *) CC=“$CC $ac_cv_prog_cc_c89” { echo “$as_me:$LINENO: result: $ac_cv_prog_cc_c89” >&5 echo “${ECHO_T}$ac_cv_prog_cc_c89” >&6; } ;; esac

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu

{ echo “$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)” >&5 echo $ECHO_N “checking whether ${MAKE-make} sets \$(MAKE)… $ECHO_C” >&6; } set x ${MAKE-make}; ac_make=echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g' if { as_var=ac_cv_prog_make${ac_make}set; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.make <<_ACEOF SHELL = /bin/sh all: @echo ‘@@@%%%=$(MAKE)=@@@%%%’ _ACEOF

GNU make sometimes prints “make[1]: Entering…”, which would confuse us.

case ${MAKE-make} -f conftest.make 2>/dev/null in @@@%%%=?=@@@%%%) eval ac_cv_prog_make${ac_make}set=yes;; ) eval ac_cv_prog_make${ac_make}set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make${ac_make}set = yes; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } SET_MAKE= else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } SET_MAKE=“MAKE=${MAKE-make}” fi

{ echo “$as_me:$LINENO: checking for library containing strerror” >&5 echo $ECHO_N “checking for library containing strerror… $ECHO_C” >&6; } if test “${ac_cv_search_strerror+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_func_search_save_LIBS=$LIBS cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char strerror (); int main () { return strerror (); ; return 0; } _ACEOF for ac_lib in ‘’ cposix; do if test -z “$ac_lib”; then ac_res=“none required” else ac_res=-l$ac_lib LIBS=“-l$ac_lib $ac_func_search_save_LIBS” fi rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_search_strerror=$ac_res else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext if test “${ac_cv_search_strerror+set}” = set; then break fi done if test “${ac_cv_search_strerror+set}” = set; then : else ac_cv_search_strerror=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_search_strerror” >&5 echo “${ECHO_T}$ac_cv_search_strerror” >&6; } ac_res=$ac_cv_search_strerror if test “$ac_res” != no; then test “$ac_res” = “none required” || LIBS=“$ac_res $LIBS”

fi

ac_aux_dir= for ac_dir in “$srcdir” “$srcdir/..” “$srcdir/../..”; do if test -f “$ac_dir/install-sh”; then ac_aux_dir=$ac_dir ac_install_sh=“$ac_aux_dir/install-sh -c” break elif test -f “$ac_dir/install.sh”; then ac_aux_dir=$ac_dir ac_install_sh=“$ac_aux_dir/install.sh -c” break elif test -f “$ac_dir/shtool”; then ac_aux_dir=$ac_dir ac_install_sh=“$ac_aux_dir/shtool install -c” break fi done if test -z “$ac_aux_dir”; then { { echo “$as_me:$LINENO: error: cannot find install-sh or install.sh in \”$srcdir\“ \”$srcdir/..\“ \”$srcdir/../..\“” >&5 echo “$as_me: error: cannot find install-sh or install.sh in \”$srcdir\“ \”$srcdir/..\“ \”$srcdir/../..\“” >&2;} { (exit 1); exit 1; }; } fi

These three variables are undocumented and unsupported,

and are intended to be withdrawn in a future Autoconf release.

They can cause serious problems if a builder’s source tree is in a directory

whose full name contains unusual characters.

ac_config_guess=“$SHELL $ac_aux_dir/config.guess” # Please don’t use this var. ac_config_sub=“$SHELL $ac_aux_dir/config.sub” # Please don’t use this var. ac_configure=“$SHELL $ac_aux_dir/configure” # Please don’t use this var.

Find a good install program. We prefer a C program (faster),

so one script is as good as another. But avoid the broken or

incompatible versions:

SysV /etc/install, /usr/sbin/install

SunOS /usr/etc/install

IRIX /sbin/install

AIX /bin/install

AmigaOS /C/install, which installs bootblocks on floppy discs

AIX 4 /usr/bin/installbsd, which doesn’t work without a -g flag

AFS /usr/afsws/bin/install, which mishandles nonexistent args

SVR4 /usr/ucb/install, which tries to use the nonexistent group “staff”

OS/2’s system install, which has a completely different semantic

./install, which can be erroneously created by make from ./install.sh.

{ echo “$as_me:$LINENO: checking for a BSD-compatible install” >&5 echo $ECHO_N “checking for a BSD-compatible install… $ECHO_C” >&6; } if test -z “$INSTALL”; then if test “${ac_cv_path_install+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. # Account for people who put trailing slashes in PATH elements. case $as_dir/ in ./ | .// | /cC/ | \ /etc/ | /usr/sbin/ | /usr/etc/ | /sbin/ | /usr/afsws/bin/ | \ ?:\/os2\/install\/ | ?:\/OS2\/INSTALL\/ | \ /usr/ucb/ ) ;; ) # OSF1 and SCO ODT 3.0 have their own names for install. # Don’t use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_prog$ac_exec_ext” && $as_test_x “$as_dir/$ac_prog$ac_exec_ext”; }; then if test $ac_prog = install && grep dspmsg “$as_dir/$ac_prog$ac_exec_ext” >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus “$as_dir/$ac_prog$ac_exec_ext” >/dev/null 2>&1; then # program-specific install script used by HP pwplus–don’t use. : else ac_cv_path_install=“$as_dir/$ac_prog$ac_exec_ext -c” break 3 fi fi done done ;; esac done IFS=$as_save_IFS

fi if test “${ac_cv_path_install+set}” = set; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. Don’t cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi { echo “$as_me:$LINENO: result: $INSTALL” >&5 echo “${ECHO_T}$INSTALL” >&6; }

Use test -z because SunOS4 sh mishandles braces in ${var-val}.

It thinks the first close brace ends the variable substitution.

test -z “$INSTALL_PROGRAM” && INSTALL_PROGRAM=‘${INSTALL}’

test -z “$INSTALL_SCRIPT” && INSTALL_SCRIPT=‘${INSTALL}’

test -z “$INSTALL_DATA” && INSTALL_DATA=‘${INSTALL} -m 644’

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu

{ echo “$as_me:$LINENO: checking for inline” >&5 echo $ECHO_N “checking for inline… $ECHO_C” >&6; } if test “${ac_cv_c_inline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_c_inline=no for ac_kw in inline inline inline; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifndef __cplusplus

typedef int foo_t; static $ac_kw foo_t static_foo () {return 0; } $ac_kw foo_t foo () {return 0; }

endif

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_c_inline=$ac_kw else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test “$ac_cv_c_inline” != no && break done

fi { echo “$as_me:$LINENO: result: $ac_cv_c_inline” >&5 echo “${ECHO_T}$ac_cv_c_inline” >&6; }

case $ac_cv_c_inline in inline | yes) ;; ) case $ac_cv_c_inline in no) ac_val=;; ) ac_val=$ac_cv_c_inline;; esac cat >>confdefs.h <<_ACEOF

ifndef __cplusplus

define inline $ac_val

endif

_ACEOF ;; esac

{ echo “$as_me:$LINENO: checking for an ANSI C-conforming const” >&5 echo $ECHO_N “checking for an ANSI C-conforming const… $ECHO_C” >&6; } if test “${ac_cv_c_const+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { / FIXME: Include the comments suggested by Paul. /

ifndef __cplusplus

/ Ultrix mips cc rejects this. / typedef int charset[2]; const charset cs; / SunOS 4.1.1 cc rejects this. / char const const pcpcc; char ppc; / NEC SVR4.0.2 mips cc rejects this. / struct point {int x, y;}; static struct point const zero = {0,0}; / AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X pointer from another in an arm of an if-expression whose if-part is not a constant expression / const char g = “string”; pcpcc = &g + (g ? g-g : 0); / HPUX 7.0 cc rejects these. / ++pcpcc; ppc = (char) pcpcc; pcpcc = (char const const ) ppc; { / SCO 3.2v4 cc rejects this. / char t; char const s = 0 ? (char ) 0 : (char const ) 0;

*t++ = 0;
if (s) return 0;

} { / Someone thinks the Sun supposedly-ANSI compiler will reject this. / int x[] = {25, 17}; const int foo = &x[0]; ++foo; } { / Sun SC1.0 ANSI compiler rejects this – but not the above. / typedef const int iptr; iptr p = 0; ++p; } { / AIX XL C 1.02.0.0 rejects this saying “k.c”, line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. / struct s { int j; const int ap[3]; }; struct s b; b->j = 5; } { / ULTRIX-32 V3.1 (Rev 9) vcc rejects this / const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_c_const=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_c_const=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_c_const” >&5 echo “${ECHO_T}$ac_cv_c_const” >&6; } if test $ac_cv_c_const = no; then

cat >>confdefs.h <<_ACEOF

define const

_ACEOF

fi

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu { echo “$as_me:$LINENO: checking how to run the C preprocessor” >&5 echo $ECHO_N “checking how to run the C preprocessor… $ECHO_C” >&6; }

On Suns, sometimes $CPP names a directory.

if test -n “$CPP” && test -d “$CPP”; then CPP= fi if test -z “$CPP”; then if test “${ac_cv_prog_CPP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else # Double quotes because CPP needs to be expanded for CPP in “$CC -E” “$CC -E -traditional-cpp” “/lib/cpp” do ac_preproc_ok=false for ac_c_preproc_warn_flag in ‘’ yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer <limits.h> to <assert.h> if STDC is defined, since # <limits.h> exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler’s parser, # not just through cpp. “Syntax error” is here to catch this case. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

         Syntax error

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then : else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

# Broken: fails on valid input. continue fi

rm -f conftest.err conftest.$ac_ext

# OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <ac_nonexistent.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then # Broken: success on invalid input. continue else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

# Passes both tests. ac_preproc_ok=: break fi

rm -f conftest.err conftest.$ac_ext

done

Because of `break', _AC_PREPROC_IFELSE’s cleaning code was skipped.

rm -f conftest.err conftest.$ac_ext if $ac_preproc_ok; then break fi

done
ac_cv_prog_CPP=$CPP

fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { echo “$as_me:$LINENO: result: $CPP” >&5 echo “${ECHO_T}$CPP” >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in ‘’ yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer <limits.h> to <assert.h> if STDC is defined, since # <limits.h> exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler’s parser, # not just through cpp. “Syntax error” is here to catch this case. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

         Syntax error

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then : else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

# Broken: fails on valid input. continue fi

rm -f conftest.err conftest.$ac_ext

# OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <ac_nonexistent.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then # Broken: success on invalid input. continue else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

# Passes both tests. ac_preproc_ok=: break fi

rm -f conftest.err conftest.$ac_ext

done

Because of `break', _AC_PREPROC_IFELSE’s cleaning code was skipped.

rm -f conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { echo “$as_me:$LINENO: error: C preprocessor \”$CPP\“ fails sanity check See `config.log' for more details.” >&5 echo “$as_me: error: C preprocessor \”$CPP\“ fails sanity check See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; } fi

ac_ext=c ac_cpp=‘$CPP $CPPFLAGS’ ac_compile=‘$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5’ ac_link=‘$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5’ ac_compiler_gnu=$ac_cv_c_compiler_gnu

{ echo “$as_me:$LINENO: checking for grep that handles long lines and -e” >&5 echo $ECHO_N “checking for grep that handles long lines and -e… $ECHO_C” >&6; } if test “${ac_cv_path_GREP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else # Extract the first word of “grep ggrep” to use in msg output if test -z “$GREP”; then set dummy grep ggrep; ac_prog_name=$2 if test “${ac_cv_path_GREP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_path_GREP_found=false

Loop through the user’s path and test for each of PROGNAME-LIST

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in ‘’ $ac_executable_extensions; do ac_path_GREP=“$as_dir/$ac_prog$ac_exec_ext” { test -f “$ac_path_GREP” && $as_test_x “$ac_path_GREP”; } || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case "$ac_path_GREP" --version 2>&1 in GNU) ac_cv_path_GREP=“$ac_path_GREP” ac_path_GREP_found=:;; ) ac_count=0 echo $ECHO_N “0123456789$ECHO_C” >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” echo ‘GREP’ >> “conftest.nl” “$ac_path_GREP” -e ‘GREP$’ -e ‘-(cannot match)-’ < “conftest.nl” >“conftest.out” 2>/dev/null || break diff “conftest.out” “conftest.nl” >/dev/null 2>&1 || break ac_count=expr $ac_count + 1 if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP=“$ac_path_GREP” ac_path_GREP_max=$ac_count fi # 10(210) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac

$ac_path_GREP_found && break 3

done done

done IFS=$as_save_IFS

fi

GREP=“$ac_cv_path_GREP” if test -z “$GREP”; then { { echo “$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” >&5 echo “$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” >&2;} { (exit 1); exit 1; }; } fi

else ac_cv_path_GREP=$GREP fi

fi { echo “$as_me:$LINENO: result: $ac_cv_path_GREP” >&5 echo “${ECHO_T}$ac_cv_path_GREP” >&6; } GREP=“$ac_cv_path_GREP”

{ echo “$as_me:$LINENO: checking for egrep” >&5 echo $ECHO_N “checking for egrep… $ECHO_C” >&6; } if test “${ac_cv_path_EGREP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if echo a | $GREP -E ‘(a|b)’ >/dev/null 2>&1 then ac_cv_path_EGREP=“$GREP -E” else # Extract the first word of “egrep” to use in msg output if test -z “$EGREP”; then set dummy egrep; ac_prog_name=$2 if test “${ac_cv_path_EGREP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_path_EGREP_found=false

Loop through the user’s path and test for each of PROGNAME-LIST

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_prog in egrep; do for ac_exec_ext in ‘’ $ac_executable_extensions; do ac_path_EGREP=“$as_dir/$ac_prog$ac_exec_ext” { test -f “$ac_path_EGREP” && $as_test_x “$ac_path_EGREP”; } || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case "$ac_path_EGREP" --version 2>&1 in GNU) ac_cv_path_EGREP=“$ac_path_EGREP” ac_path_EGREP_found=:;; ) ac_count=0 echo $ECHO_N “0123456789$ECHO_C” >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” echo ‘EGREP’ >> “conftest.nl” “$ac_path_EGREP” ‘EGREP$’ < “conftest.nl” >“conftest.out” 2>/dev/null || break diff “conftest.out” “conftest.nl” >/dev/null 2>&1 || break ac_count=expr $ac_count + 1 if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP=“$ac_path_EGREP” ac_path_EGREP_max=$ac_count fi # 10(210) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac

$ac_path_EGREP_found && break 3

done done

done IFS=$as_save_IFS

fi

EGREP=“$ac_cv_path_EGREP” if test -z “$EGREP”; then { { echo “$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” >&5 echo “$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” >&2;} { (exit 1); exit 1; }; } fi

else ac_cv_path_EGREP=$EGREP fi

fi fi { echo “$as_me:$LINENO: result: $ac_cv_path_EGREP” >&5 echo “${ECHO_T}$ac_cv_path_EGREP” >&6; } EGREP=“$ac_cv_path_EGREP”

{ echo “$as_me:$LINENO: checking for ANSI C header files” >&5 echo $ECHO_N “checking for ANSI C header files… $ECHO_C” >&6; } if test “${ac_cv_header_stdc+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdlib.h>

include <stdarg.h>

include <string.h>

include <float.h>

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_header_stdc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_header_stdc=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem, contrary to ANSI. cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <string.h>

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “memchr” >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdlib.h>

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “free” >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test “$cross_compiling” = yes; then : else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <ctype.h>

include <stdlib.h>

if ((‘ ’ & 0x0FF) == 0x020)

define ISLOWER© (‘a’ <= © && © <= ‘z’)

define TOUPPER© (ISLOWER© ? ‘A’ + (© - ‘a’) : ©)

else

define ISLOWER© \

       (('a' <= (c) && (c) <= 'i') \
         || ('j' <= (c) && (c) <= 'r') \
         || ('s' <= (c) && (c) <= 'z'))

define TOUPPER© (ISLOWER© ? (© | 0x40) : ©)

endif

define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then : else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ac_cv_header_stdc=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi fi { echo “$as_me:$LINENO: result: $ac_cv_header_stdc” >&5 echo “${ECHO_T}$ac_cv_header_stdc” >&6; } if test $ac_cv_header_stdc = yes; then

cat >>confdefs.h <<_ACEOF

define STDC_HEADERS 1

_ACEOF

fi

if test “$enable_ftp” = “yes”; then EXTRAOBJS=“$EXTRAOBJS src/ftp.o src/ftpdriver.o” proto_msg=“FTP”

cat >>confdefs.h <<_ACEOF

define USE_FTP 1

_ACEOF

fi

if test “$enable_webdav” = “yes”; then # Add the required DAV objects to NEONOBJS proto_msg=“WebDAV ${proto_msg}” EXTRAOBJS=“$EXTRAOBJS src/davdriver.o”

cat >>confdefs.h <<_ACEOF

define USE_DAV 1

_ACEOF

fi

XML parser support is always required

NEON_NEED_XML_PARSER=yes

if test “$enable_rsh” = “yes”; then EXTRAOBJS=“$EXTRAOBJS src/rshdriver.o” proto_msg=“rsh/rcp ${proto_msg}”

cat >>confdefs.h <<_ACEOF

define USE_RSH 1

_ACEOF

fi

Check whether –enable-sftp was given.

if test “${enable_sftp+set}” = set; then enableval=$enable_sftp; else enable_sftp=no

for ac_func in socketpair pipe do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF enable_sftp=yes; break fi done

fi

if test “$enable_sftp” = “yes”; then EXTRAOBJS=“$EXTRAOBJS src/sftpdriver.o” proto_msg=“sftp/ssh ${proto_msg}”

cat >>confdefs.h <<_ACEOF

define USE_SFTP 1

_ACEOF

fi

Check whether –enable-debug was given.

if test “${enable_debug+set}” = set; then enableval=$enable_debug; fi

default is to enable debugging

case $enable_debug in no) { echo “$as_me:$LINENO: debugging is disabled” >&5 echo “$as_me: debugging is disabled” >&6;} LDFLAGS=“-s $LDFLAGS” ;; *) { echo “$as_me:$LINENO: debugging is enabled” >&5 echo “$as_me: debugging is enabled” >&6;}

cat >>confdefs.h <<_ACEOF

define NE_DEBUGGING 1

_ACEOF

;; esac

{ echo “$as_me:$LINENO: checking for GNU fnmatch” >&5 echo $ECHO_N “checking for GNU fnmatch… $ECHO_C” >&6; } if test “${sc_cv_gnu_fnmatch+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <fnmatch.h>

int main () { int flags = FNM_LEADING_DIR; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then sc_cv_gnu_fnmatch=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

sc_cv_gnu_fnmatch=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $sc_cv_gnu_fnmatch” >&5 echo “${ECHO_T}$sc_cv_gnu_fnmatch” >&6; }

if test “$sc_cv_gnu_fnmatch” = “no”; then case “ $LIBOBJS ” in “ lib/fnmatch.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/fnmatch.$ac_objext” ;; esac

fi

Support neon 0.24 through 0.28

Turn off ACL support

neon_no_acl=yes

On IRIX 5.3, sys/types and inttypes.h are conflicting.

for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then eval “$as_ac_Header=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_Header=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo “$as_me:$LINENO: checking for size_t” >&5 echo $ECHO_N “checking for size_t… $ECHO_C” >&6; } if test “${ac_cv_type_size_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef size_t ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_size_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_size_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_size_t” >&5 echo “${ECHO_T}$ac_cv_type_size_t” >&6; } if test $ac_cv_type_size_t = yes; then : else

cat >>confdefs.h <<_ACEOF

define size_t unsigned int

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for off_t” >&5 echo $ECHO_N “checking for off_t… $ECHO_C” >&6; } if test “${ac_cv_type_off_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef off_t ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off_t” >&5 echo “${ECHO_T}$ac_cv_type_off_t” >&6; } if test $ac_cv_type_off_t = yes; then : else

cat >>confdefs.h <<_ACEOF

define off_t long int

_ACEOF

fi

Check for Darwin, which needs extra cpp and linker flags.

{ echo “$as_me:$LINENO: checking for uname” >&5 echo $ECHO_N “checking for uname… $ECHO_C” >&6; } if test “${ne_cv_os_uname+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_os_uname=uname -s 2>/dev/null

fi { echo “$as_me:$LINENO: result: $ne_cv_os_uname” >&5 echo “${ECHO_T}$ne_cv_os_uname” >&6; }

if test “$ne_cv_os_uname” = “Darwin”; then CPPFLAGS=“$CPPFLAGS -no-cpp-precomp” LDFLAGS=“$LDFLAGS -flat_namespace” # poll has various issues in various Darwin releases if test x${ac_cv_func_poll+set} != xset; then ac_cv_func_poll=no fi fi

{ echo “$as_me:$LINENO: checking for int” >&5 echo $ECHO_N “checking for int… $ECHO_C” >&6; } if test “${ac_cv_type_int+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_int=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_int=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_int” >&5 echo “${ECHO_T}$ac_cv_type_int” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of int” >&5 echo $ECHO_N “checking size of int… $ECHO_C” >&6; } if test “${ac_cv_sizeof_int+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef int ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_int=$ac_lo;; ‘’) if test “$ac_cv_type_int” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (int) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (int) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_int=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default typedef int actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_int=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_int” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (int) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (int) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_int=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_int” >&5 echo “${ECHO_T}$ac_cv_sizeof_int” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_INT $ac_cv_sizeof_int

_ACEOF

{ echo “$as_me:$LINENO: checking for long” >&5 echo $ECHO_N “checking for long… $ECHO_C” >&6; } if test “${ac_cv_type_long+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_long=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_long=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_long” >&5 echo “${ECHO_T}$ac_cv_type_long” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of long” >&5 echo $ECHO_N “checking size of long… $ECHO_C” >&6; } if test “${ac_cv_sizeof_long+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_long=$ac_lo;; ‘’) if test “$ac_cv_type_long” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (long) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (long) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_long=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default typedef long actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_long=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_long” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (long) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (long) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_long=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_long” >&5 echo “${ECHO_T}$ac_cv_sizeof_long” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_LONG $ac_cv_sizeof_long

_ACEOF

{ echo “$as_me:$LINENO: checking for long long” >&5 echo $ECHO_N “checking for long long… $ECHO_C” >&6; } if test “${ac_cv_type_long_long+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_long_long=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_long_long=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_long_long” >&5 echo “${ECHO_T}$ac_cv_type_long_long” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of long long” >&5 echo $ECHO_N “checking size of long long… $ECHO_C” >&6; } if test “${ac_cv_sizeof_long_long+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef long long ac__type_sizeof; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (ac_type_sizeof))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_long_long=$ac_lo;; ‘’) if test “$ac_cv_type_long_long” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (long long) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (long long) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_long_long=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default typedef long long actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_long_long=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_long_long” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (long long) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (long long) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_long_long=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_long_long” >&5 echo “${ECHO_T}$ac_cv_sizeof_long_long” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long

_ACEOF

if test “$GCC” = “yes”; then { echo “$as_me:$LINENO: checking for gcc -Wformat -Werror sanity” >&5 echo $ECHO_N “checking for gcc -Wformat -Werror sanity… $ECHO_C” >&6; } if test “${ne_cv_cc_werror+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

# See whether a simple test program will compile without errors. ne_save_CPPFLAGS=$CPPFLAGS CPPFLAGS=“$CPPFLAGS -Wformat -Werror” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { int i = 42; printf(“%d”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_cc_werror=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_cv_cc_werror=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$ne_save_CPPFLAGS fi { echo “$as_me:$LINENO: result: $ne_cv_cc_werror” >&5 echo “${ECHO_T}$ne_cv_cc_werror” >&6; } ne_fmt_trycompile=$ne_cv_cc_werror else ne_fmt_trycompile=no fi

These checks are done whether or not the bundled neon build

is used.

for ac_header in errno.h stdarg.h string.h stdlib.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo “$as_me:$LINENO: checking for size_t” >&5 echo $ECHO_N “checking for size_t… $ECHO_C” >&6; } if test “${ac_cv_type_size_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_size_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_size_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_size_t” >&5 echo “${ECHO_T}$ac_cv_type_size_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of size_t” >&5 echo $ECHO_N “checking size of size_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_size_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef size_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_size_t=$ac_lo;; ‘’) if test “$ac_cv_type_size_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (size_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (size_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_size_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef size_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_size_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_size_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (size_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (size_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_size_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_size_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_size_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_SIZE_T $ac_cv_sizeof_size_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print size_t” >&5 echo $ECHO_N “checking how to print size_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_size_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_size_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in u lu llu; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { size_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_size_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_size_t in $ac_cv_sizeof_int) ne_cv_fmt_size_t=“u” ;; $ac_cv_sizeof_long) ne_cv_fmt_size_t=“lu” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_size_t=“llu” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_size_t” >&5 echo “${ECHO_T}$ne_cv_fmt_size_t” >&6; }

if test “x$ne_cv_fmt_size_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for size_t not found” >&5 echo “$as_me: error: format string for size_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_SIZE_T “$ne_cv_fmt_size_t”

_ACEOF

{ echo “$as_me:$LINENO: checking for off_t” >&5 echo $ECHO_N “checking for off_t… $ECHO_C” >&6; } if test “${ac_cv_type_off_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off_t” >&5 echo “${ECHO_T}$ac_cv_type_off_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of off_t” >&5 echo $ECHO_N “checking size of off_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_off_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_off_t=$ac_lo;; ‘’) if test “$ac_cv_type_off_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef off_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_off_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_off_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_off_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_off_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_OFF_T $ac_cv_sizeof_off_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print off_t” >&5 echo $ECHO_N “checking how to print off_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_off_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_off_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { off_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_off_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_off_t in $ac_cv_sizeof_int) ne_cv_fmt_off_t=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_off_t=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_off_t=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_off_t” >&5 echo “${ECHO_T}$ne_cv_fmt_off_t” >&6; }

if test “x$ne_cv_fmt_off_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for off_t not found” >&5 echo “$as_me: error: format string for off_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_OFF_T “$ne_cv_fmt_off_t”

_ACEOF

{ echo “$as_me:$LINENO: checking for ssize_t” >&5 echo $ECHO_N “checking for ssize_t… $ECHO_C” >&6; } if test “${ac_cv_type_ssize_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_ssize_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_ssize_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_ssize_t” >&5 echo “${ECHO_T}$ac_cv_type_ssize_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of ssize_t” >&5 echo $ECHO_N “checking size of ssize_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_ssize_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef ssize_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_ssize_t=$ac_lo;; ‘’) if test “$ac_cv_type_ssize_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (ssize_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (ssize_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_ssize_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef ssize_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_ssize_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_ssize_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (ssize_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (ssize_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_ssize_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_ssize_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_ssize_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_SSIZE_T $ac_cv_sizeof_ssize_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print ssize_t” >&5 echo $ECHO_N “checking how to print ssize_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_ssize_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_ssize_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { ssize_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_ssize_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_ssize_t in $ac_cv_sizeof_int) ne_cv_fmt_ssize_t=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_ssize_t=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_ssize_t=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_ssize_t” >&5 echo “${ECHO_T}$ne_cv_fmt_ssize_t” >&6; }

if test “x$ne_cv_fmt_ssize_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for ssize_t not found” >&5 echo “$as_me: error: format string for ssize_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_SSIZE_T “$ne_cv_fmt_ssize_t”

_ACEOF

{ echo “$as_me:$LINENO: checking whether byte ordering is bigendian” >&5 echo $ECHO_N “checking whether byte ordering is bigendian… $ECHO_C” >&6; } if test “${ac_cv_c_bigendian+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else # See if sys/param.h defines the BYTE_ORDER macro. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <sys/param.h>

int main () {

if ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \

&& BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)

bogus endian macros

endif

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then # It does; now see whether it defined to BIG_ENDIAN or not. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <sys/types.h>

include <sys/param.h>

int main () {

if BYTE_ORDER != BIG_ENDIAN

not big endian

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_c_bigendian=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_c_bigendian=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

# It does not; compile a test program.

if test “$cross_compiling” = yes; then # try to guess the endianness by grepping values into an object file ac_cv_c_bigendian=unknown cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; void ascii () { char s = (char ) ascii_mm; s = (char ) ascii_ii; } short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; void _ebcdic () { char s = (char ) ebcdic_mm; s = (char ) ebcdic_ii; } int main () { ascii (); ebcdic (); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then if test “$ac_cv_c_bigendian” = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default int main () {

/ Are we little or big endian? From Harbison&Steele. / union { long int l; char c[sizeof (long int)]; } u; u.l = 1; return u.c[sizeof (long int) - 1] == 1;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_c_bigendian=no else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ac_cv_c_bigendian=yes fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_c_bigendian” >&5 echo “${ECHO_T}$ac_cv_c_bigendian” >&6; } case $ac_cv_c_bigendian in yes)

cat >>confdefs.h <<_ACEOF

define WORDS_BIGENDIAN 1

_ACEOF ;; no) ;; *) { { echo “$as_me:$LINENO: error: unknown endianness presetting ac_cv_c_bigendian=no (or yes) will help” >&5 echo “$as_me: error: unknown endianness presetting ac_cv_c_bigendian=no (or yes) will help” >&2;} { (exit 1); exit 1; }; } ;; esac

{ echo “$as_me:$LINENO: checking whether strerror_r is declared” >&5 echo $ECHO_N “checking whether strerror_r is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_strerror_r+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default int main () {

ifndef strerror_r

(void) strerror_r;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_strerror_r=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_strerror_r=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_strerror_r” >&5 echo “${ECHO_T}$ac_cv_have_decl_strerror_r” >&6; } if test $ac_cv_have_decl_strerror_r = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_STRERROR_R 1

_ACEOF

else cat >>confdefs.h <<_ACEOF

define HAVE_DECL_STRERROR_R 0

_ACEOF

fi

for ac_func in strerror_r do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

{ echo “$as_me:$LINENO: checking whether strerror_r returns char ” >&5 echo $ECHO_N “checking whether strerror_r returns char … $ECHO_C” >&6; } if test “${ac_cv_func_strerror_r_char_p+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ac_cv_func_strerror_r_char_p=no
if test $ac_cv_have_decl_strerror_r = yes; then
  cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default int main () {

  char buf[100];
  char x = *strerror_r (0, buf, sizeof buf);
  char *p = strerror_r (0, buf, sizeof buf);
  return !p || x;

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_func_strerror_r_char_p=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else # strerror_r is not declared. Choose between # systems that have relatively inaccessible declarations for the # function. BeOS and DEC UNIX 4.0 fall in this category, but the # former has a strerror_r that returns char, while the latter # has a strerror_r that returns int'. # This test should segfault on the DEC system. if test "$cross_compiling" = yes; then : else cat >conftest.$ac_ext <<_ACEOF /* confdefs.h. */ _ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF /* end confdefs.h. */ $ac_includes_default extern char *strerror_r (); int main () { char buf[100]; char x = *strerror_r (0, buf, sizeof buf); return ! isalpha (x); ; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try="$ac_link" case "(($ac_try" in *\"* | *\ | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval “echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_func_strerror_r_char_p=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi

fi { echo “$as_me:$LINENO: result: $ac_cv_func_strerror_r_char_p” >&5 echo “${ECHO_T}$ac_cv_func_strerror_r_char_p” >&6; } if test $ac_cv_func_strerror_r_char_p = yes; then

cat >>confdefs.h <<_ACEOF

define STRERROR_R_CHAR_P 1

_ACEOF

fi

for ac_func in snprintf vsnprintf do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else

ne_save_LIBS=$LIBS LIBS=“$LIBS -lm” # Always need -lm { echo “$as_me:$LINENO: checking for trio_vsnprintf in -ltrio” >&5 echo $ECHO_N “checking for trio_vsnprintf in -ltrio… $ECHO_C” >&6; } if test “${ac_cv_lib_trio_trio_vsnprintf+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ltrio $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char trio_vsnprintf (); int main () { return trio_vsnprintf (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_trio_trio_vsnprintf=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_trio_trio_vsnprintf=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_trio_trio_vsnprintf” >&5 echo “${ECHO_T}$ac_cv_lib_trio_trio_vsnprintf” >&6; } if test $ac_cv_lib_trio_trio_vsnprintf = yes; then

for ac_header in trio.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

else { { echo “$as_me:$LINENO: error: trio installation problem? libtrio found but not trio.h” >&5 echo “$as_me: error: trio installation problem? libtrio found but not trio.h” >&2;} { (exit 1); exit 1; }; } fi

done

{ echo "$as_me:$LINENO: using trio printf replacement library" >&5

echo “$as_me: using trio printf replacement library” >&6;} NEON_LIBS=“$NEON_LIBS -ltrio -lm”

cat >>confdefs.h <<_ACEOF

define HAVE_TRIO 1

_ACEOF

else { echo “$as_me:$LINENO: no vsnprintf/snprintf detected in C library” >&5 echo “$as_me: no vsnprintf/snprintf detected in C library” >&6;} { { echo “$as_me:$LINENO: error: Install the trio library from http://daniel.haxx.se/projects/trio/” >&5 echo “$as_me: error: Install the trio library from http://daniel.haxx.se/projects/trio/” >&2;} { (exit 1); exit 1; }; } fi

LIBS=$ne_save_LIBS break

fi done

Search in /usr/ccs/bin for Solaris

ne_PATH=$PATH:/usr/ccs/bin if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}ar”, so it can be a program name with args. set dummy ${ac_tool_prefix}ar; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_AR+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $AR in [\/] | ?:[\/]) ac_cv_path_AR=“$AR” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $ne_PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_AR=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi AR=$ac_cv_path_AR if test -n “$AR”; then { echo “$as_me:$LINENO: result: $AR” >&5 echo “${ECHO_T}$AR” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$ac_cv_path_AR”; then ac_pt_AR=$AR # Extract the first word of “ar”, so it can be a program name with args. set dummy ar; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_ac_pt_AR+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $ac_pt_AR in [\/] | ?:[\/]) ac_cv_path_ac_pt_AR=“$ac_pt_AR” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $ne_PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_ac_pt_AR=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi ac_pt_AR=$ac_cv_path_ac_pt_AR if test -n “$ac_pt_AR”; then { echo “$as_me:$LINENO: result: $ac_pt_AR” >&5 echo “${ECHO_T}$ac_pt_AR” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_pt_AR” = x; then AR=“notfound” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac AR=$ac_pt_AR fi else AR=“$ac_cv_path_AR” fi

if test “x$AR” = “xnotfound”; then { { echo “$as_me:$LINENO: error: could not find ar tool” >&5 echo “$as_me: error: could not find ar tool” >&2;} { (exit 1); exit 1; }; } fi if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}ranlib”, so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_RANLIB+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $RANLIB in [\/] | ?:[\/]) ac_cv_path_RANLIB=“$RANLIB” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $ne_PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_RANLIB=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi RANLIB=$ac_cv_path_RANLIB if test -n “$RANLIB”; then { echo “$as_me:$LINENO: result: $RANLIB” >&5 echo “${ECHO_T}$RANLIB” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$ac_cv_path_RANLIB”; then ac_pt_RANLIB=$RANLIB # Extract the first word of “ranlib”, so it can be a program name with args. set dummy ranlib; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_ac_pt_RANLIB+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $ac_pt_RANLIB in [\/] | ?:[\/]) ac_cv_path_ac_pt_RANLIB=“$ac_pt_RANLIB” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $ne_PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_ac_pt_RANLIB=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi ac_pt_RANLIB=$ac_cv_path_ac_pt_RANLIB if test -n “$ac_pt_RANLIB”; then { echo “$as_me:$LINENO: result: $ac_pt_RANLIB” >&5 echo “${ECHO_T}$ac_pt_RANLIB” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_pt_RANLIB” = x; then RANLIB=“:” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_pt_RANLIB fi else RANLIB=“$ac_cv_path_RANLIB” fi

neon_bundled_srcdir=“\$(top_srcdir)/lib/neon” neon_bundled_builddir=“\$(top_builddir)/lib/neon”

Check whether –with-included-neon was given.

if test “${with_included_neon+set}” = set; then withval=$with_included_neon; neon_force_included=“$withval” else neon_force_included=“no” fi

Check whether –with-neon was given.

if test “${with_neon+set}” = set; then withval=$with_neon; case $withval in yes|no) neon_force_external=$withval; neon_ext_path= ;; *) neon_force_external=yes; neon_ext_path=$withval ;; esac; else

neon_force_external=no neon_ext_path=

fi

if test “$neon_force_included” = “no”; then # There is no included neon source directory, or –with-included-neon # wasn’t given (so we’re not forced to use it).

# Default to no external neon.
neon_got_library=no
if test "x$neon_ext_path" = "x"; then
# Extract the first word of "neon-config", so it can be a program name with args.

set dummy neon-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_NEON_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $NEON_CONFIG in [\/] | ?:[\/]) ac_cv_path_NEON_CONFIG=“$NEON_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_NEON_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_NEON_CONFIG” && ac_cv_path_NEON_CONFIG=“none” ;; esac fi NEON_CONFIG=$ac_cv_path_NEON_CONFIG if test -n “$NEON_CONFIG”; then { echo “$as_me:$LINENO: result: $NEON_CONFIG” >&5 echo “${ECHO_T}$NEON_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test "x${NEON_CONFIG}" = "xnone"; then
    { echo "$as_me:$LINENO: no external neon library found" >&5

echo “$as_me: no external neon library found” >&6;} elif test -x “${NEON_CONFIG}”; then

Configure to use an external neon, given a neon-config script

found at $NEON_CONFIG.

neon_prefix=$NEON_CONFIG --prefix

# Check whether the library is of required version
ne_save_LIBS="$LIBS"
ne_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`"
LIBS="$LIBS `$NEON_CONFIG --libs`"
ne_libver=`$NEON_CONFIG --version | sed -e "s/neon //g"`
# Check whether it's possible to link against neon
{ echo "$as_me:$LINENO: checking linking against neon" >&5

echo $ECHO_N “checking linking against neon… $ECHO_C” >&6; } if test “${ne_cv_lib_neon+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <ne_utils.h>

int main () { ne_version_match(0, 0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_lib_neon=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_cv_lib_neon=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_lib_neon” >&5 echo “${ECHO_T}$ne_cv_lib_neon” >&6; } if test “$ne_cv_lib_neon” = “yes”; then ne_cv_lib_neonver=no for v in 24 25 26 27 28; do case $ne_libver in 0.$v.*) ne_cv_lib_neonver=yes ;; esac done fi ne_goodver=$ne_cv_lib_neonver LIBS=$ne_save_LIBS CFLAGS=$ne_save_CFLAGS

if test “$ne_goodver” = “yes”; then { echo “$as_me:$LINENO: using neon library $ne_libver” >&5 echo “$as_me: using neon library $ne_libver” >&6;}

# Pick up CFLAGS and LIBS needed
CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`"
NEON_LIBS="$NEON_LIBS `$NEON_CONFIG --libs`"
# Pick up library version
set dummy `$NEON_CONFIG --version | sed 's/\./ /g'`
NE_VERSION_MAJOR=$3; NE_VERSION_MINOR=$4; NE_VERSION_PATCH=$5

NEON_VERSION=“${NE_VERSION_MAJOR}.${NE_VERSION_MINOR}.${NE_VERSION_PATCH}${NE_VERSION_TAG}”

cat >>confdefs.h <<_ACEOF

define NEON_VERSION “${NEON_VERSION}”

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MAJOR (${NE_VERSION_MAJOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MINOR (${NE_VERSION_MINOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_PATCH (${NE_VERSION_PATCH})

_ACEOF

neon_library_message="library in ${neon_prefix} (${NEON_VERSION})"
neon_xml_parser_message="using whatever neon uses"

if $NEON_CONFIG –support ssl >/dev/null; then

NE_FLAG_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SSL 1

_ACEOF

ne_SSL_message=“SSL is supported by neon” { echo “$as_me:$LINENO: SSL is supported by neon” >&5 echo “$as_me: SSL is supported by neon” >&6;}

else

NE_FLAG_SSL=no

ne_SSL_message=“SSL is not supported by neon” { echo “$as_me:$LINENO: SSL is not supported by neon” >&5 echo “$as_me: SSL is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support zlib >/dev/null; then

NE_FLAG_ZLIB=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_ZLIB 1

_ACEOF

ne_ZLIB_message=“zlib is supported by neon” { echo “$as_me:$LINENO: zlib is supported by neon” >&5 echo “$as_me: zlib is supported by neon” >&6;}

else

NE_FLAG_ZLIB=no

ne_ZLIB_message=“zlib is not supported by neon” { echo “$as_me:$LINENO: zlib is not supported by neon” >&5 echo “$as_me: zlib is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support ipv6 >/dev/null; then

NE_FLAG_IPV6=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_IPV6 1

_ACEOF

ne_IPV6_message=“IPv6 is supported by neon” { echo “$as_me:$LINENO: IPv6 is supported by neon” >&5 echo “$as_me: IPv6 is supported by neon” >&6;}

else

NE_FLAG_IPV6=no

ne_IPV6_message=“IPv6 is not supported by neon” { echo “$as_me:$LINENO: IPv6 is not supported by neon” >&5 echo “$as_me: IPv6 is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support lfs >/dev/null; then

NE_FLAG_LFS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_LFS 1

_ACEOF

ne_LFS_message=“LFS is supported by neon” { echo “$as_me:$LINENO: LFS is supported by neon” >&5 echo “$as_me: LFS is supported by neon” >&6;}

else

NE_FLAG_LFS=no

ne_LFS_message=“LFS is not supported by neon” { echo “$as_me:$LINENO: LFS is not supported by neon” >&5 echo “$as_me: LFS is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support socks >/dev/null; then

NE_FLAG_SOCKS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SOCKS 1

_ACEOF

ne_SOCKS_message=“SOCKSv5 is supported by neon” { echo “$as_me:$LINENO: SOCKSv5 is supported by neon” >&5 echo “$as_me: SOCKSv5 is supported by neon” >&6;}

else

NE_FLAG_SOCKS=no

ne_SOCKS_message=“SOCKSv5 is not supported by neon” { echo “$as_me:$LINENO: SOCKSv5 is not supported by neon” >&5 echo “$as_me: SOCKSv5 is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support ts_ssl >/dev/null; then

NE_FLAG_TS_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_TS_SSL 1

_ACEOF

ne_TS_SSL_message=“thread-safe SSL is supported by neon” { echo “$as_me:$LINENO: thread-safe SSL is supported by neon” >&5 echo “$as_me: thread-safe SSL is supported by neon” >&6;}

else

NE_FLAG_TS_SSL=no

ne_TS_SSL_message=“thread-safe SSL is not supported by neon” { echo “$as_me:$LINENO: thread-safe SSL is not supported by neon” >&5 echo “$as_me: thread-safe SSL is not supported by neon” >&6;}

fi

neon_got_library=yes
if test $NE_FLAG_LFS = yes; then

{ echo “$as_me:$LINENO: checking for off64_t” >&5 echo $ECHO_N “checking for off64_t… $ECHO_C” >&6; } if test “${ac_cv_type_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off64_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off64_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off64_t” >&5 echo “${ECHO_T}$ac_cv_type_off64_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of off64_t” >&5 echo $ECHO_N “checking size of off64_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_off64_t=$ac_lo;; ‘’) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef off64_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_off64_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_off64_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_off64_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_OFF64_T $ac_cv_sizeof_off64_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print off64_t” >&5 echo $ECHO_N “checking how to print off64_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_off64_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { off64_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_off64_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_off64_t in $ac_cv_sizeof_int) ne_cv_fmt_off64_t=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_off64_t=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_off64_t=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_off64_t” >&5 echo “${ECHO_T}$ne_cv_fmt_off64_t” >&6; }

if test “x$ne_cv_fmt_off64_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for off64_t not found” >&5 echo “$as_me: error: format string for off64_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_OFF64_T “$ne_cv_fmt_off64_t”

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF64_T

_ACEOF

else
   cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF_T

_ACEOF

fi

else { echo “$as_me:$LINENO: incompatible neon library version $ne_libver: wanted 0.24 25 26 27 28” >&5 echo “$as_me: incompatible neon library version $ne_libver: wanted 0.24 25 26 27 28” >&6;} neon_got_library=no fi

else
    { echo "$as_me:$LINENO: ignoring non-executable ${NEON_CONFIG}" >&5

echo “$as_me: ignoring non-executable ${NEON_CONFIG}” >&6;} fi else { echo “$as_me:$LINENO: checking for neon library in $neon_ext_path” >&5 echo $ECHO_N “checking for neon library in $neon_ext_path… $ECHO_C” >&6; } NEON_CONFIG=“$neon_ext_path/bin/neon-config” if test -x ${NEON_CONFIG}; then { echo “$as_me:$LINENO: result: found” >&5 echo “${ECHO_T}found” >&6; }

Configure to use an external neon, given a neon-config script

found at $NEON_CONFIG.

neon_prefix=$NEON_CONFIG --prefix

# Check whether the library is of required version
ne_save_LIBS="$LIBS"
ne_save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`"
LIBS="$LIBS `$NEON_CONFIG --libs`"
ne_libver=`$NEON_CONFIG --version | sed -e "s/neon //g"`
# Check whether it's possible to link against neon
{ echo "$as_me:$LINENO: checking linking against neon" >&5

echo $ECHO_N “checking linking against neon… $ECHO_C” >&6; } if test “${ne_cv_lib_neon+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <ne_utils.h>

int main () { ne_version_match(0, 0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_lib_neon=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_cv_lib_neon=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_lib_neon” >&5 echo “${ECHO_T}$ne_cv_lib_neon” >&6; } if test “$ne_cv_lib_neon” = “yes”; then ne_cv_lib_neonver=no for v in 24 25 26 27 28; do case $ne_libver in 0.$v.*) ne_cv_lib_neonver=yes ;; esac done fi ne_goodver=$ne_cv_lib_neonver LIBS=$ne_save_LIBS CFLAGS=$ne_save_CFLAGS

if test “$ne_goodver” = “yes”; then { echo “$as_me:$LINENO: using neon library $ne_libver” >&5 echo “$as_me: using neon library $ne_libver” >&6;}

# Pick up CFLAGS and LIBS needed
CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`"
NEON_LIBS="$NEON_LIBS `$NEON_CONFIG --libs`"
# Pick up library version
set dummy `$NEON_CONFIG --version | sed 's/\./ /g'`
NE_VERSION_MAJOR=$3; NE_VERSION_MINOR=$4; NE_VERSION_PATCH=$5

NEON_VERSION=“${NE_VERSION_MAJOR}.${NE_VERSION_MINOR}.${NE_VERSION_PATCH}${NE_VERSION_TAG}”

cat >>confdefs.h <<_ACEOF

define NEON_VERSION “${NEON_VERSION}”

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MAJOR (${NE_VERSION_MAJOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MINOR (${NE_VERSION_MINOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_PATCH (${NE_VERSION_PATCH})

_ACEOF

neon_library_message="library in ${neon_prefix} (${NEON_VERSION})"
neon_xml_parser_message="using whatever neon uses"

if $NEON_CONFIG –support ssl >/dev/null; then

NE_FLAG_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SSL 1

_ACEOF

ne_SSL_message=“SSL is supported by neon” { echo “$as_me:$LINENO: SSL is supported by neon” >&5 echo “$as_me: SSL is supported by neon” >&6;}

else

NE_FLAG_SSL=no

ne_SSL_message=“SSL is not supported by neon” { echo “$as_me:$LINENO: SSL is not supported by neon” >&5 echo “$as_me: SSL is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support zlib >/dev/null; then

NE_FLAG_ZLIB=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_ZLIB 1

_ACEOF

ne_ZLIB_message=“zlib is supported by neon” { echo “$as_me:$LINENO: zlib is supported by neon” >&5 echo “$as_me: zlib is supported by neon” >&6;}

else

NE_FLAG_ZLIB=no

ne_ZLIB_message=“zlib is not supported by neon” { echo “$as_me:$LINENO: zlib is not supported by neon” >&5 echo “$as_me: zlib is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support ipv6 >/dev/null; then

NE_FLAG_IPV6=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_IPV6 1

_ACEOF

ne_IPV6_message=“IPv6 is supported by neon” { echo “$as_me:$LINENO: IPv6 is supported by neon” >&5 echo “$as_me: IPv6 is supported by neon” >&6;}

else

NE_FLAG_IPV6=no

ne_IPV6_message=“IPv6 is not supported by neon” { echo “$as_me:$LINENO: IPv6 is not supported by neon” >&5 echo “$as_me: IPv6 is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support lfs >/dev/null; then

NE_FLAG_LFS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_LFS 1

_ACEOF

ne_LFS_message=“LFS is supported by neon” { echo “$as_me:$LINENO: LFS is supported by neon” >&5 echo “$as_me: LFS is supported by neon” >&6;}

else

NE_FLAG_LFS=no

ne_LFS_message=“LFS is not supported by neon” { echo “$as_me:$LINENO: LFS is not supported by neon” >&5 echo “$as_me: LFS is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support socks >/dev/null; then

NE_FLAG_SOCKS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SOCKS 1

_ACEOF

ne_SOCKS_message=“SOCKSv5 is supported by neon” { echo “$as_me:$LINENO: SOCKSv5 is supported by neon” >&5 echo “$as_me: SOCKSv5 is supported by neon” >&6;}

else

NE_FLAG_SOCKS=no

ne_SOCKS_message=“SOCKSv5 is not supported by neon” { echo “$as_me:$LINENO: SOCKSv5 is not supported by neon” >&5 echo “$as_me: SOCKSv5 is not supported by neon” >&6;}

fi

if $NEON_CONFIG –support ts_ssl >/dev/null; then

NE_FLAG_TS_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_TS_SSL 1

_ACEOF

ne_TS_SSL_message=“thread-safe SSL is supported by neon” { echo “$as_me:$LINENO: thread-safe SSL is supported by neon” >&5 echo “$as_me: thread-safe SSL is supported by neon” >&6;}

else

NE_FLAG_TS_SSL=no

ne_TS_SSL_message=“thread-safe SSL is not supported by neon” { echo “$as_me:$LINENO: thread-safe SSL is not supported by neon” >&5 echo “$as_me: thread-safe SSL is not supported by neon” >&6;}

fi

neon_got_library=yes
if test $NE_FLAG_LFS = yes; then

{ echo “$as_me:$LINENO: checking for off64_t” >&5 echo $ECHO_N “checking for off64_t… $ECHO_C” >&6; } if test “${ac_cv_type_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off64_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off64_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off64_t” >&5 echo “${ECHO_T}$ac_cv_type_off64_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of off64_t” >&5 echo $ECHO_N “checking size of off64_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_off64_t=$ac_lo;; ‘’) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef off64_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_off64_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_off64_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_off64_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_OFF64_T $ac_cv_sizeof_off64_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print off64_t” >&5 echo $ECHO_N “checking how to print off64_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_off64_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { off64_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_off64_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_off64_t in $ac_cv_sizeof_int) ne_cv_fmt_off64_t=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_off64_t=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_off64_t=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_off64_t” >&5 echo “${ECHO_T}$ne_cv_fmt_off64_t” >&6; }

if test “x$ne_cv_fmt_off64_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for off64_t not found” >&5 echo “$as_me: error: format string for off64_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_OFF64_T “$ne_cv_fmt_off64_t”

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF64_T

_ACEOF

else
   cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF_T

_ACEOF

fi

else { echo “$as_me:$LINENO: incompatible neon library version $ne_libver: wanted 0.24 25 26 27 28” >&5 echo “$as_me: incompatible neon library version $ne_libver: wanted 0.24 25 26 27 28” >&6;} neon_got_library=no fi

else
    { echo "$as_me:$LINENO: result: not found" >&5

echo “${ECHO_T}not found” >&6; } # …will fail since force_external=yes fi fi

if test "$neon_got_library" = "no"; then
if test $neon_force_external = yes; then
    { { echo "$as_me:$LINENO: error: could not use external neon library" >&5

echo “$as_me: error: could not use external neon library” >&2;} { (exit 1); exit 1; }; } elif test -n “$neon_bundled_srcdir”; then # Couldn’t find external neon, forced to use bundled sources neon_force_included=“yes” else # Couldn’t find neon, and don’t have bundled sources { { echo “$as_me:$LINENO: error: could not find neon” >&5 echo “$as_me: error: could not find neon” >&2;} { (exit 1); exit 1; }; } fi fi fi

if test “$neon_force_included” = “yes”; then

Define the current versions.

NE_VERSION_MAJOR=0 NE_VERSION_MINOR=28 NE_VERSION_PATCH=2 NE_VERSION_TAG=

0.28.x is backwards-compatible with 0.27.x, so AGE=1

NE_LIBTOOL_VERSINFO=“28:${NE_VERSION_PATCH}:1”

NEON_VERSION=“${NE_VERSION_MAJOR}.${NE_VERSION_MINOR}.${NE_VERSION_PATCH}${NE_VERSION_TAG}”

cat >>confdefs.h <<_ACEOF

define NEON_VERSION “${NEON_VERSION}”

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MAJOR (${NE_VERSION_MAJOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_MINOR (${NE_VERSION_MINOR})

_ACEOF

cat >>confdefs.h <<_ACEOF

define NE_VERSION_PATCH (${NE_VERSION_PATCH})

_ACEOF

{ echo "$as_me:$LINENO: using bundled neon ($NEON_VERSION)" >&5

echo “$as_me: using bundled neon ($NEON_VERSION)” >&6;} NEON_BUILD_BUNDLED=“yes”

for ac_header in sys/time.h limits.h sys/select.h arpa/inet.h libintl.h \ signal.h sys/socket.h netinet/in.h netinet/tcp.h netdb.h sys/poll.h \ sys/limits.h fcntl.h iconv.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default / netinet/tcp.h requires netinet/in.h on some platforms. /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then eval “$as_ac_Header=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_Header=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo “$as_me:$LINENO: checking for timezone global” >&5 echo $ECHO_N “checking for timezone global… $ECHO_C” >&6; } if test “${ne_cv_cc_timezone+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <time.h>

int main () { time_t t = 0 - timezone; timezone = 1; ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_cc_timezone=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_cv_cc_timezone=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_cc_timezone” >&5 echo “${ECHO_T}$ne_cv_cc_timezone” >&6; }

if test “$ne_cv_cc_timezone” = “yes”; then

cat >>confdefs.h <<_ACEOF

define HAVE_TIMEZONE 1

_ACEOF

fi

if test -z “$ac_cv_sizeof_off_t”; then

NE_FLAG_LFS=no

ne_LFS_message=“LFS support omitted: off_t size unknown!” { echo “$as_me:$LINENO: LFS support omitted: off_t size unknown!” >&5 echo “$as_me: LFS support omitted: off_t size unknown!” >&6;}

elif test $ac_cv_sizeof_off_t != 4; then

NE_FLAG_LFS=no

ne_LFS_message=“LFS support unnecessary, off_t is not 32-bit” { echo “$as_me:$LINENO: LFS support unnecessary, off_t is not 32-bit” >&5 echo “$as_me: LFS support unnecessary, off_t is not 32-bit” >&6;}

for ac_func in strtoll strtoq do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF break fi done

elif test -z “$ac_cv_sizeof_long_long”; then

NE_FLAG_LFS=no

ne_LFS_message=“LFS support omitted: long long size unknown” { echo “$as_me:$LINENO: LFS support omitted: long long size unknown” >&5 echo “$as_me: LFS support omitted: long long size unknown” >&6;}

elif test $ac_cv_sizeof_long_long != 8; then

NE_FLAG_LFS=no

ne_LFS_message=“LFS support omitted: long long not 64-bit” { echo “$as_me:$LINENO: LFS support omitted: long long not 64-bit” >&5 echo “$as_me: LFS support omitted: long long not 64-bit” >&6;}

else ne_save_CPPFLAGS=$CPPFLAGS CPPFLAGS=“$CPPFLAGS -D_LARGEFILE64_SOURCE” { echo “$as_me:$LINENO: checking for off64_t” >&5 echo $ECHO_N “checking for off64_t… $ECHO_C” >&6; } if test “${ac_cv_type_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef off64_t ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off64_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off64_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off64_t” >&5 echo “${ECHO_T}$ac_cv_type_off64_t” >&6; } if test $ac_cv_type_off64_t = yes; then

{ echo “$as_me:$LINENO: checking for off64_t” >&5 echo $ECHO_N “checking for off64_t… $ECHO_C” >&6; } if test “${ac_cv_type_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_off64_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_off64_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_off64_t” >&5 echo “${ECHO_T}$ac_cv_type_off64_t” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of off64_t” >&5 echo $ECHO_N “checking size of off64_t… $ECHO_C” >&6; } if test “${ac_cv_sizeof_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

typedef off64_t actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_off64_t=$ac_lo;; ‘’) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

typedef off64_t actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_off64_t=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_off64_t” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (off64_t) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_off64_t=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_off64_t” >&5 echo “${ECHO_T}$ac_cv_sizeof_off64_t” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_OFF64_T $ac_cv_sizeof_off64_t

_ACEOF

{ echo “$as_me:$LINENO: checking how to print off64_t” >&5 echo $ECHO_N “checking how to print off64_t… $ECHO_C” >&6; } if test “${ne_cv_fmt_off64_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_off64_t=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdio.h>

int main () { off64_t i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_off64_t=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_off64_t in $ac_cv_sizeof_int) ne_cv_fmt_off64_t=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_off64_t=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_off64_t=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_off64_t” >&5 echo “${ECHO_T}$ne_cv_fmt_off64_t” >&6; }

if test “x$ne_cv_fmt_off64_t” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for off64_t not found” >&5 echo “$as_me: error: format string for off64_t not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_OFF64_T “$ne_cv_fmt_off64_t”

_ACEOF

 ne_lfsok=no

for ac_func in strtoll strtoq do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF ne_lfsok=yes; break fi done

for ac_func in lseek64 fstat64 do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else ne_lfsok=no; break fi done

 if test x$ne_lfsok = xyes; then

NE_FLAG_LFS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_LFS 1

_ACEOF

ne_LFS_message=“LFS (large file) support enabled” { echo “$as_me:$LINENO: LFS (large file) support enabled” >&5 echo “$as_me: LFS (large file) support enabled” >&6;}

   NEON_CFLAGS="$NEON_CFLAGS -D_LARGEFILE64_SOURCE -DNE_LFS"
   ne_save_CPPFLAGS="$CPPFLAGS -DNE_LFS"
 else

NE_FLAG_LFS=no

ne_LFS_message=“LFS support omitted: 64-bit support functions not found” { echo “$as_me:$LINENO: LFS support omitted: 64-bit support functions not found” >&5 echo “$as_me: LFS support omitted: 64-bit support functions not found” >&6;}

 fi

else

NE_FLAG_LFS=no

ne_LFS_message=“LFS support omitted: off64_t type not found” { echo “$as_me:$LINENO: LFS support omitted: off64_t type not found” >&5 echo “$as_me: LFS support omitted: off64_t type not found” >&6;}

fi

CPPFLAGS=$ne_save_CPPFLAGS fi if test “$NE_FLAG_LFS” = “yes”; then

cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF64_T

_ACEOF

: Disabled for 0.28 to retain 0.27 ABI

else cat >>confdefs.h <<_ACEOF

define NE_FMT_NE_OFF_T NE_FMT_OFF_T

_ACEOF

fi

for ac_func in strcasecmp do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else case “ $LIBOBJS ” in “ $ac_func.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS $ac_func.$ac_objext” ;; esac

fi done

for ac_func in signal setvbuf setsockopt stpcpy poll fcntl getsockopt do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

if test “x${ac_cv_func_poll}${ac_cv_header_sys_poll_h}y” = “xyesyesy”; then

cat >>confdefs.h <<_ACEOF

define NE_USE_POLL 1

_ACEOF

fi

if test “$ac_cv_func_stpcpy” = “yes”; then { echo “$as_me:$LINENO: checking whether stpcpy is declared” >&5 echo $ECHO_N “checking whether stpcpy is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_stpcpy+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default int main () {

ifndef stpcpy

(void) stpcpy;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_stpcpy=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_stpcpy=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy” >&5 echo “${ECHO_T}$ac_cv_have_decl_stpcpy” >&6; } if test $ac_cv_have_decl_stpcpy = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_STPCPY 1

_ACEOF

else cat >>confdefs.h <<_ACEOF

define HAVE_DECL_STPCPY 0

_ACEOF

fi

fi

Modern AIXes with the “Linux-like” libc have an undeclared stpcpy

Unixware 7 can only link gethostbyname with -lnsl -lsocket

Pick up -lsocket first, then the gethostbyname check will work.

{ echo “$as_me:$LINENO: checking for library containing socket” >&5 echo $ECHO_N “checking for library containing socket… $ECHO_C” >&6; } if test “${ne_cv_libsfor_socket+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { socket(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_socket=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_socket=“not found” for lib in socket inet ws2_32; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall socket();” ;; ) ne__code=“socket();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_socket=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_socket” >&5 echo “${ECHO_T}$ne_cv_libsfor_socket” >&6; }

if test “$ne_cv_libsfor_socket” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing socket” >&5 echo “$as_me: error: could not find library containing socket” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_socket” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_socket $NEON_LIBS”

fi

Enable getaddrinfo support if it, gai_strerror and inet_ntop are

all available.

{ echo “$as_me:$LINENO: checking for library containing getaddrinfo” >&5 echo $ECHO_N “checking for library containing getaddrinfo… $ECHO_C” >&6; } if test “${ne_cv_libsfor_getaddrinfo+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { getaddrinfo(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_getaddrinfo=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_getaddrinfo=“not found” for lib in nsl; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall getaddrinfo();” ;; ) ne__code=“getaddrinfo();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_getaddrinfo=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_getaddrinfo” >&5 echo “${ECHO_T}$ne_cv_libsfor_getaddrinfo” >&6; }

if test “$ne_cv_libsfor_getaddrinfo” = “not found”; then ne_enable_gai=no elif test “$ne_cv_libsfor_getaddrinfo” = “none needed”; then # HP-UX boxes commonly get into a state where getaddrinfo is present # but borked: http://marc.theaimsgroup.com/?l=apr-dev&m=107730955207120&w=2 case xuname -sr 2>/dev/nully in xHP-UX11.[01]y) { echo “$as_me:$LINENO: getaddrinfo support disabled on HP-UX 11.0x/11.1x” >&5 echo “$as_me: getaddrinfo support disabled on HP-UX 11.0x/11.1x” >&6;} ;; *) ne_enable_gai=yes

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in gai_strerror getnameinfo inet_ntop do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else ne_enable_gai=no; break fi done

LIBS=$ne_cf_save_LIBS ;; esac

else NEON_LIBS=“$ne_cv_libsfor_getaddrinfo $NEON_LIBS” # HP-UX boxes commonly get into a state where getaddrinfo is present # but borked: http://marc.theaimsgroup.com/?l=apr-dev&m=107730955207120&w=2 case xuname -sr 2>/dev/nully in xHP-UX11.[01]y) { echo “$as_me:$LINENO: getaddrinfo support disabled on HP-UX 11.0x/11.1x” >&5 echo “$as_me: getaddrinfo support disabled on HP-UX 11.0x/11.1x” >&6;} ;; *) ne_enable_gai=yes

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in gai_strerror getnameinfo inet_ntop do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else ne_enable_gai=no; break fi done

LIBS=$ne_cf_save_LIBS ;; esac

fi

if test $ne_enable_gai = yes; then

NE_FLAG_IPV6=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_IPV6 1

_ACEOF

ne_IPV6_message=“IPv6 support is enabled” { echo “$as_me:$LINENO: IPv6 support is enabled” >&5 echo “$as_me: IPv6 support is enabled” >&6;}

cat >>confdefs.h <<_ACEOF

define USE_GETADDRINFO 1

_ACEOF

{ echo “$as_me:$LINENO: checking for working AI_ADDRCONFIG” >&5 echo $ECHO_N “checking for working AI_ADDRCONFIG… $ECHO_C” >&6; } if test “${ne_cv_gai_addrconfig+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

if test “$cross_compiling” = yes; then ne_cv_gai_addrconfig=no else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <netdb.h>

int main () { struct addrinfo hints = {0}, result; hints.ai_flags = AI_ADDRCONFIG; if (getaddrinfo(“localhost”, NULL, &hints, &result) != 0) return 1; ; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ne_cv_gai_addrconfig=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ne_cv_gai_addrconfig=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi { echo “$as_me:$LINENO: result: $ne_cv_gai_addrconfig” >&5 echo “${ECHO_T}$ne_cv_gai_addrconfig” >&6; } if test $ne_cv_gai_addrconfig = yes; then

cat >>confdefs.h <<_ACEOF

define USE_GAI_ADDRCONFIG 1

_ACEOF

fi else # Checks for non-getaddrinfo() based resolver interfaces. # QNX has gethostbyname in -lsocket. BeOS only has it in -lbind. # CygWin/Winsock2 has it in -lws2_32, allegedly.

{ echo “$as_me:$LINENO: checking for library containing gethostbyname” >&5 echo $ECHO_N “checking for library containing gethostbyname… $ECHO_C” >&6; } if test “${ne_cv_libsfor_gethostbyname+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { gethostbyname(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_gethostbyname=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_gethostbyname=“not found” for lib in socket nsl bind ws2_32; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall gethostbyname();” ;; ) ne__code=“gethostbyname();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_gethostbyname=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_gethostbyname” >&5 echo “${ECHO_T}$ne_cv_libsfor_gethostbyname” >&6; }

if test “$ne_cv_libsfor_gethostbyname” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing gethostbyname” >&5 echo “$as_me: error: could not find library containing gethostbyname” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_gethostbyname” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_gethostbyname $NEON_LIBS”

fi

{ echo “$as_me:$LINENO: checking for library containing hstrerror” >&5 echo $ECHO_N “checking for library containing hstrerror… $ECHO_C” >&6; } if test “${ne_cv_libsfor_hstrerror+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { hstrerror(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_hstrerror=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_hstrerror=“not found” for lib in resolv; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall hstrerror();” ;; ) ne__code=“hstrerror();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_hstrerror=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_hstrerror” >&5 echo “${ECHO_T}$ne_cv_libsfor_hstrerror” >&6; }

if test “$ne_cv_libsfor_hstrerror” = “not found”; then : elif test “$ne_cv_libsfor_hstrerror” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_hstrerror $NEON_LIBS”

fi

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in hstrerror do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

LIBS=$ne_cf_save_LIBS # Older Unixes don’t declare h_errno. { echo “$as_me:$LINENO: checking whether h_errno is declared” >&5 echo $ECHO_N “checking whether h_errno is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_h_errno+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <netdb.h>

int main () {

ifndef h_errno

(void) h_errno;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_h_errno=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_h_errno=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_h_errno” >&5 echo “${ECHO_T}$ac_cv_have_decl_h_errno” >&6; } if test $ac_cv_have_decl_h_errno = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_H_ERRNO 1

_ACEOF

else cat >>confdefs.h <<_ACEOF

define HAVE_DECL_H_ERRNO 0

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for in_addr_t” >&5 echo $ECHO_N “checking for in_addr_t… $ECHO_C” >&6; } if test “${ac_cv_type_in_addr_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif

typedef in_addr_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_in_addr_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_in_addr_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_in_addr_t” >&5 echo “${ECHO_T}$ac_cv_type_in_addr_t” >&6; } if test $ac_cv_type_in_addr_t = yes; then : else

cat >>confdefs.h <<_ACEOF

define in_addr_t unsigned int

_ACEOF

fi

fi

{ echo “$as_me:$LINENO: checking for socklen_t” >&5 echo $ECHO_N “checking for socklen_t… $ECHO_C” >&6; } if test “${ac_cv_type_socklen_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif

ifdef HAVE_SYS_SOCKET_H

include <sys/socket.h>

endif

typedef socklen_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_socklen_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_socklen_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_socklen_t” >&5 echo “${ECHO_T}$ac_cv_type_socklen_t” >&6; } if test $ac_cv_type_socklen_t = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_SOCKLEN_T 1

_ACEOF

else # Linux accept(2) says this should be size_t for SunOS 5… gah.

cat >>confdefs.h <<_ACEOF

define socklen_t int

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for struct tm.tm_gmtoff” >&5 echo $ECHO_N “checking for struct tm.tm_gmtoff… $ECHO_C” >&6; } if test “${ac_cv_member_struct_tm_tm_gmtoff+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <time.h>

int main () { static struct tm ac_aggr; if (ac_aggr.tm_gmtoff) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_member_struct_tm_tm_gmtoff=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <time.h>

int main () { static struct tm ac_aggr; if (sizeof ac_aggr.tm_gmtoff) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_member_struct_tm_tm_gmtoff=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_member_struct_tm_tm_gmtoff=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_member_struct_tm_tm_gmtoff” >&5 echo “${ECHO_T}$ac_cv_member_struct_tm_tm_gmtoff” >&6; } if test $ac_cv_member_struct_tm_tm_gmtoff = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_STRUCT_TM_TM_GMTOFF 1

_ACEOF

fi { echo “$as_me:$LINENO: checking for struct tm.tm_gmtoff” >&5 echo $ECHO_N “checking for struct tm.tm_gmtoff… $ECHO_C” >&6; } if test “${ac_cv_member_struct_tmtm_gmtoff+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <time.h>

int main () { static struct tm ac_aggr; if (ac_aggr.tm_gmtoff) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_member_struct_tmtm_gmtoff=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <time.h>

int main () { static struct tm ac_aggr; if (sizeof ac_aggr.tm_gmtoff) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_member_struct_tmtm_gmtoff=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_member_struct_tm___tm_gmtoff=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_member_struct_tmtm_gmtoff” >&5 echo “${ECHO_T}$ac_cv_member_struct_tmtm_gmtoff” >&6; } if test $ac_cv_member_struct_tm___tm_gmtoff = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_STRUCT_TM___TM_GMTOFF 1

_ACEOF

fi

if test ${ac_cv_member_struct_tm_tm_gmtoff}${ac_cv_member_struct_tm___tm_gmtoff}${ne_cv_cc_timezone} = nonono; then { echo “$as_me:$LINENO: WARNING: no timezone handling in date parsing on this platform” >&5 echo “$as_me: WARNING: no timezone handling in date parsing on this platform” >&2;} fi

NE_FLAG_ZLIB=no

ne_ZLIB_message=“zlib not supported” { echo “$as_me:$LINENO: zlib not supported” >&5 echo “$as_me: zlib not supported” >&6;}

Conditionally enable ACL support

{ echo “$as_me:$LINENO: checking whether to enable ACL support in neon” >&5 echo $ECHO_N “checking whether to enable ACL support in neon… $ECHO_C” >&6; } if test “x$neon_no_acl” = “xyes”; then { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } else { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } NEON_EXTRAOBJS=“$NEON_EXTRAOBJS ne_acl” fi

Check whether –with-ssl was given.

if test “${with_ssl+set}” = set; then withval=$with_ssl; fi

Check whether –with-egd was given.

if test “${with_egd+set}” = set; then withval=$with_egd; fi

Check whether –with-pakchois was given.

if test “${with_pakchois+set}” = set; then withval=$with_pakchois; fi

case $with_ssl in /*) { echo “$as_me:$LINENO: to use SSL libraries in non-standard locations, try –with-ssl –with-libs=$with_ssl” >&5 echo “$as_me: to use SSL libraries in non-standard locations, try –with-ssl –with-libs=$with_ssl” >&6;} { { echo “$as_me:$LINENO: error: –with-ssl does not take a path argument” >&5 echo “$as_me: error: –with-ssl does not take a path argument” >&2;} { (exit 1); exit 1; }; } ;; yes|openssl)

Extract the first word of “pkg-config”, so it can be a program name with args.

set dummy pkg-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_PKG_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $PKG_CONFIG in [\/] | ?:[\/]) ac_cv_path_PKG_CONFIG=“$PKG_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_PKG_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_PKG_CONFIG” && ac_cv_path_PKG_CONFIG=“no” ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n “$PKG_CONFIG”; then { echo “$as_me:$LINENO: result: $PKG_CONFIG” >&5 echo “${ECHO_T}$PKG_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “$PKG_CONFIG” = “no”; then : Not using pkg-config # Either OpenSSL library may require -ldl if built with dynamic engine support

{ echo “$as_me:$LINENO: checking for library containing RSA_new” >&5 echo $ECHO_N “checking for library containing RSA_new… $ECHO_C” >&6; } if test “${ne_cv_libsfor_RSA_new+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { RSA_new(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_RSA_new=“not found” for lib in crypto; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall RSA_new();” ;; ) ne__code=“RSA_new();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$ne_sl_save_LIBS -l$lib -ldl $NEON_LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“-l$lib -ldl”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_RSA_new” >&5 echo “${ECHO_T}$ne_cv_libsfor_RSA_new” >&6; }

if test “$ne_cv_libsfor_RSA_new” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing RSA_new” >&5 echo “$as_me: error: could not find library containing RSA_new” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_RSA_new” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_RSA_new $NEON_LIBS”

fi

{ echo “$as_me:$LINENO: checking for library containing SSL_library_init” >&5 echo $ECHO_N “checking for library containing SSL_library_init… $ECHO_C” >&6; } if test “${ne_cv_libsfor_SSL_library_init+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { SSL_library_init(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_SSL_library_init=“not found” for lib in ssl; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall SSL_library_init();” ;; ) ne__code=“SSL_library_init();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$ne_sl_save_LIBS -l$lib -ldl $NEON_LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“-l$lib -ldl”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_SSL_library_init” >&5 echo “${ECHO_T}$ne_cv_libsfor_SSL_library_init” >&6; }

if test “$ne_cv_libsfor_SSL_library_init” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing SSL_library_init” >&5 echo “$as_me: error: could not find library containing SSL_library_init” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_SSL_library_init” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_SSL_library_init $NEON_LIBS”

fi else { echo “$as_me:$LINENO: checking for openssl pkg-config data” >&5 echo $ECHO_N “checking for openssl pkg-config data… $ECHO_C” >&6; } if test “${ne_cv_pkg_openssl+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if $PKG_CONFIG openssl; then ne_cv_pkg_openssl=yes else ne_cv_pkg_openssl=no fi fi { echo “$as_me:$LINENO: result: $ne_cv_pkg_openssl” >&5 echo “${ECHO_T}$ne_cv_pkg_openssl” >&6; }

if test “$ne_cv_pkg_openssl” = “yes”; then NE_SSL_CFLAGS=$PKG_CONFIG --cflags openssl NE_SSL_LIBS=$PKG_CONFIG --libs openssl : Using provided pkg-config data { echo “$as_me:$LINENO: using SSL library configuration from pkg-config” >&5 echo “$as_me: using SSL library configuration from pkg-config” >&6;} CPPFLAGS=“$CPPFLAGS ${NE_SSL_CFLAGS}” NEON_LIBS=“$NEON_LIBS ${NE_SSL_LIBS}” else : No pkg-config for openssl provided # Either OpenSSL library may require -ldl if built with dynamic engine support

{ echo “$as_me:$LINENO: checking for library containing RSA_new” >&5 echo $ECHO_N “checking for library containing RSA_new… $ECHO_C” >&6; } if test “${ne_cv_libsfor_RSA_new+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { RSA_new(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_RSA_new=“not found” for lib in crypto; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall RSA_new();” ;; ) ne__code=“RSA_new();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$ne_sl_save_LIBS -l$lib -ldl $NEON_LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_RSA_new=“-l$lib -ldl”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_RSA_new” >&5 echo “${ECHO_T}$ne_cv_libsfor_RSA_new” >&6; }

if test “$ne_cv_libsfor_RSA_new” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing RSA_new” >&5 echo “$as_me: error: could not find library containing RSA_new” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_RSA_new” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_RSA_new $NEON_LIBS”

fi

{ echo “$as_me:$LINENO: checking for library containing SSL_library_init” >&5 echo $ECHO_N “checking for library containing SSL_library_init… $ECHO_C” >&6; } if test “${ne_cv_libsfor_SSL_library_init+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { SSL_library_init(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“none needed” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ne_sl_save_LIBS=$LIBS ne_cv_libsfor_SSL_library_init=“not found” for lib in ssl; do # The w32api libraries link using the stdcall calling convention. case ${lib}-${ne_cv_os_uname} in ws2_32-MINGW) necode=“stdcall SSL_library_init();” ;; ) ne__code=“SSL_library_init();” ;; esac

LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS"
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“-l$lib”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$ne_sl_save_LIBS -l$lib -ldl $NEON_LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

int main () { $ne_code ; return 0; } ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ne_cv_libsfor_SSL_library_init=“-l$lib -ldl”; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext done LIBS=$ne_sl_save_LIBS fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ne_cv_libsfor_SSL_library_init” >&5 echo “${ECHO_T}$ne_cv_libsfor_SSL_library_init” >&6; }

if test “$ne_cv_libsfor_SSL_library_init” = “not found”; then { { echo “$as_me:$LINENO: error: could not find library containing SSL_library_init” >&5 echo “$as_me: error: could not find library containing SSL_library_init” >&2;} { (exit 1); exit 1; }; } elif test “$ne_cv_libsfor_SSL_library_init” = “none needed”; then : else NEON_LIBS=“$ne_cv_libsfor_SSL_library_init $NEON_LIBS”

fi fi fi

for ac_header in openssl/ssl.h openssl/opensslv.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

else { { echo “$as_me:$LINENO: error: OpenSSL headers not found, cannot enable SSL support” >&5 echo “$as_me: error: OpenSSL headers not found, cannot enable SSL support” >&2;} { (exit 1); exit 1; }; } fi

done

# Enable EGD support if using 0.9.7 or newer

{ echo “$as_me:$LINENO: checking OpenSSL version is >= 0.9.7” >&5 echo $ECHO_N “checking OpenSSL version is >= 0.9.7… $ECHO_C” >&6; } if test “${ne_cv_lib_ssl097+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <openssl/opensslv.h>

if OPENSSL_VERSION_NUMBER >= 0x00907000L

good

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “good” >/dev/null 2>&1; then ne_cv_lib_ssl097=yes else ne_cv_lib_ssl097=no fi rm -f conftest*

fi { echo “$as_me:$LINENO: result: $ne_cv_lib_ssl097” >&5 echo “${ECHO_T}$ne_cv_lib_ssl097” >&6; } if test “$ne_cv_lib_ssl097” = “yes”; then { echo “$as_me:$LINENO: OpenSSL >= 0.9.7; EGD support not needed in neon” >&5 echo “$as_me: OpenSSL >= 0.9.7; EGD support not needed in neon” >&6;}

NE_FLAG_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SSL 1

_ACEOF

ne_SSL_message=“SSL support enabled, using OpenSSL (0.9.7 or later)” { echo “$as_me:$LINENO: SSL support enabled, using OpenSSL (0.9.7 or later)” >&5 echo “$as_me: SSL support enabled, using OpenSSL (0.9.7 or later)” >&6;}

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in CRYPTO_set_idptr_callback do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

LIBS=$ne_cf_save_LIBS else # Fail if OpenSSL is older than 0.9.6

{ echo “$as_me:$LINENO: checking OpenSSL version is >= 0.9.6” >&5 echo $ECHO_N “checking OpenSSL version is >= 0.9.6… $ECHO_C” >&6; } if test “${ne_cv_lib_ssl096+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <openssl/opensslv.h>

if OPENSSL_VERSION_NUMBER >= 0x00906000L

good

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “good” >/dev/null 2>&1; then ne_cv_lib_ssl096=yes else ne_cv_lib_ssl096=no fi rm -f conftest*

fi { echo “$as_me:$LINENO: result: $ne_cv_lib_ssl096” >&5 echo “${ECHO_T}$ne_cv_lib_ssl096” >&6; } if test “$ne_cv_lib_ssl096” != “yes”; then { { echo “$as_me:$LINENO: error: OpenSSL 0.9.6 or later is required” >&5 echo “$as_me: error: OpenSSL 0.9.6 or later is required” >&2;} { (exit 1); exit 1; }; } fi

NE_FLAG_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SSL 1

_ACEOF

ne_SSL_message=“SSL support enabled, using OpenSSL (0.9.6 or later)” { echo “$as_me:$LINENO: SSL support enabled, using OpenSSL (0.9.6 or later)” >&5 echo “$as_me: SSL support enabled, using OpenSSL (0.9.6 or later)” >&6;}

  case "$with_egd" in
  yes|no) ne_cv_lib_sslegd=$with_egd ;;
  /*) ne_cv_lib_sslegd=yes

cat >>confdefs.h <<_ACEOF

define EGD_PATH “$with_egd”

_ACEOF ;; *) # Guess whether EGD support is needed { echo “$as_me:$LINENO: checking whether to enable EGD support” >&5 echo $ECHO_N “checking whether to enable EGD support… $ECHO_C” >&6; } if test “${ne_cv_lib_sslegd+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -r /dev/random || test -r /dev/urandom; then ne_cv_lib_sslegd=no else ne_cv_lib_sslegd=yes fi fi { echo “$as_me:$LINENO: result: $ne_cv_lib_sslegd” >&5 echo “${ECHO_T}$ne_cv_lib_sslegd” >&6; } ;; esac if test “$ne_cv_lib_sslegd” = “yes”; then { echo “$as_me:$LINENO: EGD support enabled for seeding OpenSSL PRNG” >&5 echo “$as_me: EGD support enabled for seeding OpenSSL PRNG” >&6;}

cat >>confdefs.h <<_ACEOF

define ENABLE_EGD 1

_ACEOF

  fi

fi

cat >>confdefs.h <<_ACEOF

define HAVE_OPENSSL 1

_ACEOF

NEON_EXTRAOBJS=“$NEON_EXTRAOBJS ne_openssl” ;; gnutls) # Extract the first word of “libgnutls-config”, so it can be a program name with args. set dummy libgnutls-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_GNUTLS_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $GNUTLS_CONFIG in [\/] | ?:[\/]) ac_cv_path_GNUTLS_CONFIG=“$GNUTLS_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_GNUTLS_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_GNUTLS_CONFIG” && ac_cv_path_GNUTLS_CONFIG=“no” ;; esac fi GNUTLS_CONFIG=$ac_cv_path_GNUTLS_CONFIG if test -n “$GNUTLS_CONFIG”; then { echo “$as_me:$LINENO: result: $GNUTLS_CONFIG” >&5 echo “${ECHO_T}$GNUTLS_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “$GNUTLS_CONFIG” = “no”; then { { echo “$as_me:$LINENO: error: could not find libgnutls-config in \$PATH” >&5 echo “$as_me: error: could not find libgnutls-config in \$PATH” >&2;} { (exit 1); exit 1; }; } fi

ne_gnutls_ver=$GNUTLS_CONFIG --version case $ne_gnutls_ver in 1.0.?|1.0.1?|1.0.20|1.0.21) { { echo “$as_me:$LINENO: error: GNU TLS version $ne_gnutls_ver is too old – 1.0.22 or later required” >&5 echo “$as_me: error: GNU TLS version $ne_gnutls_ver is too old – 1.0.22 or later required” >&2;} { (exit 1); exit 1; }; } ;; esac

CPPFLAGS=“$CPPFLAGS $GNUTLS_CONFIG --cflags

if test “${ac_cv_header_gnutls_gnutls_h+set}” = set; then { echo “$as_me:$LINENO: checking for gnutls/gnutls.h” >&5 echo $ECHO_N “checking for gnutls/gnutls.h… $ECHO_C” >&6; } if test “${ac_cv_header_gnutls_gnutls_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi { echo “$as_me:$LINENO: result: $ac_cv_header_gnutls_gnutls_h” >&5 echo “${ECHO_T}$ac_cv_header_gnutls_gnutls_h” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking gnutls/gnutls.h usability” >&5 echo $ECHO_N “checking gnutls/gnutls.h usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <gnutls/gnutls.h>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking gnutls/gnutls.h presence” >&5 echo $ECHO_N “checking gnutls/gnutls.h presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <gnutls/gnutls.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: present but cannot be compiled” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: see the Autoconf documentation” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: gnutls/gnutls.h: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: gnutls/gnutls.h: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: gnutls/gnutls.h: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: gnutls/gnutls.h: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: gnutls/gnutls.h: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for gnutls/gnutls.h” >&5 echo $ECHO_N “checking for gnutls/gnutls.h… $ECHO_C” >&6; } if test “${ac_cv_header_gnutls_gnutls_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_header_gnutls_gnutls_h=$ac_header_preproc fi { echo “$as_me:$LINENO: result: $ac_cv_header_gnutls_gnutls_h” >&5 echo “${ECHO_T}$ac_cv_header_gnutls_gnutls_h” >&6; }

fi if test $ac_cv_header_gnutls_gnutls_h = yes; then : else { { echo “$as_me:$LINENO: error: could not find gnutls/gnutls.h in include path” >&5 echo “$as_me: error: could not find gnutls/gnutls.h in include path” >&2;} { (exit 1); exit 1; }; } fi

NE_FLAG_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SSL 1

_ACEOF

ne_SSL_message=“SSL support enabled, using GnuTLS $ne_gnutls_ver” { echo “$as_me:$LINENO: SSL support enabled, using GnuTLS $ne_gnutls_ver” >&5 echo “$as_me: SSL support enabled, using GnuTLS $ne_gnutls_ver” >&6;}

NEON_EXTRAOBJS=“$NEON_EXTRAOBJS ne_gnutls” NEON_LIBS=“$NEON_LIBS $GNUTLS_CONFIG --libs

cat >>confdefs.h <<_ACEOF

define HAVE_GNUTLS 1

_ACEOF

# Check for functions in later releases

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in gnutls_session_get_data2 gnutls_x509_dn_get_rdn_ava \ gnutls_sign_callback_set do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

LIBS=$ne_cf_save_LIBS

# Check for iconv support if using the new RDN access functions: if test ${ac_cv_func_gnutls_x509_dn_get_rdn_ava}X${ac_cv_header_iconv_h} = yesXyes; then

for ac_func in iconv do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

fi

if test x${ac_cv_func_gnutls_sign_callback_set} = xyes; then if test “$with_pakchois” != “no”; then # PKCS#11… ho!

Extract the first word of “pkg-config”, so it can be a program name with args.

set dummy pkg-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_PKG_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $PKG_CONFIG in [\/] | ?:[\/]) ac_cv_path_PKG_CONFIG=“$PKG_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_PKG_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_PKG_CONFIG” && ac_cv_path_PKG_CONFIG=“no” ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG if test -n “$PKG_CONFIG”; then { echo “$as_me:$LINENO: result: $PKG_CONFIG” >&5 echo “${ECHO_T}$PKG_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “$PKG_CONFIG” = “no”; then : Not using pkg-config { echo “$as_me:$LINENO: pakchois library not found; no PKCS11 support” >&5 echo “$as_me: pakchois library not found; no PKCS11 support” >&6;} else { echo “$as_me:$LINENO: checking for pakchois pkg-config data” >&5 echo $ECHO_N “checking for pakchois pkg-config data… $ECHO_C” >&6; } if test “${ne_cv_pkg_pakchois+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if $PKG_CONFIG pakchois; then ne_cv_pkg_pakchois=yes else ne_cv_pkg_pakchois=no fi fi { echo “$as_me:$LINENO: result: $ne_cv_pkg_pakchois” >&5 echo “${ECHO_T}$ne_cv_pkg_pakchois” >&6; }

if test “$ne_cv_pkg_pakchois” = “yes”; then NE_PK11_CFLAGS=$PKG_CONFIG --cflags pakchois NE_PK11_LIBS=$PKG_CONFIG --libs pakchois : Using provided pkg-config data { echo “$as_me:$LINENO: using pakchois for PKCS11 support” >&5 echo “$as_me: using pakchois for PKCS11 support” >&6;}

cat >>confdefs.h <<_ACEOF

define HAVE_PAKCHOIS 1

_ACEOF

        CPPFLAGS="$CPPFLAGS ${NE_PK11_CFLAGS}"
        NEON_LIBS="${NEON_LIBS} ${NE_PK11_LIBS}"

else : No pkg-config for pakchois provided { echo “$as_me:$LINENO: pakchois library not found; no PKCS11 support” >&5 echo “$as_me: pakchois library not found; no PKCS11 support” >&6;} fi fi fi fi

;; *) # Default to off; only create crypto-enabled binaries if requested.

NE_FLAG_SSL=no

ne_SSL_message=“SSL support is not enabled” { echo “$as_me:$LINENO: SSL support is not enabled” >&5 echo “$as_me: SSL support is not enabled” >&6;}

NE_FLAG_TS_SSL=no

ne_TS_SSL_message=“Thread-safe SSL support is not enabled” { echo “$as_me:$LINENO: Thread-safe SSL support is not enabled” >&5 echo “$as_me: Thread-safe SSL support is not enabled” >&6;}

NEON_EXTRAOBJS=“$NEON_EXTRAOBJS ne_stubssl” ;; esac

Check whether –with-ca-bundle was given.

if test “${with_ca_bundle+set}” = set; then withval=$with_ca_bundle; else with_ca_bundle=no fi

case ${NE_FLAG_SSL}-${with_ca_bundle} in -no) ;; yes-)

cat >>confdefs.h <<_ACEOF

define NE_SSL_CA_BUNDLE “${with_ca_bundle}”

_ACEOF

{ echo “$as_me:$LINENO: Using ${with_ca_bundle} as default SSL CA bundle” >&5 echo “$as_me: Using ${with_ca_bundle} as default SSL CA bundle” >&6;} ;; esac

Check whether –enable-threadsafe-ssl was given.

if test “${enable_threadsafe_ssl+set}” = set; then enableval=$enable_threadsafe_ssl; else enable_threadsafe_ssl=no fi

case $enable_threadsafe_ssl in posix|yes) ne_pthr_ok=yes

for ac_func in pthread_mutex_init pthread_mutex_lock do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

else ne_pthr_ok=no fi done

if test “${ne_pthr_ok}” = “no”; then { { echo “$as_me:$LINENO: error: could not find POSIX mutex interfaces; (try CC=\”${CC} -pthread\“?)” >&5 echo “$as_me: error: could not find POSIX mutex interfaces; (try CC=\”${CC} -pthread\“?)” >&2;} { (exit 1); exit 1; }; } fi

NE_FLAG_TS_SSL=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_TS_SSL 1

_ACEOF

ne_TS_SSL_message=“Thread-safe SSL supported using POSIX threads” { echo “$as_me:$LINENO: Thread-safe SSL supported using POSIX threads” >&5 echo “$as_me: Thread-safe SSL supported using POSIX threads” >&6;}

;; *)

NE_FLAG_TS_SSL=no

ne_TS_SSL_message=“Thread-safe SSL not supported” { echo “$as_me:$LINENO: Thread-safe SSL not supported” >&5 echo “$as_me: Thread-safe SSL not supported” >&6;}

;; esac

Check whether –with-socks was given.

if test “${with_socks+set}” = set; then withval=$with_socks; fi

if test “$with_socks” = “yes”; then ne_save_LIBS=$LIBS

for ac_header in socks.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

ACEOF { echo “$as_me:$LINENO: checking for connect in -lsocks5” >&5 echo $ECHO_N “checking for connect in -lsocks5… $ECHO_C” >&6; } if test “${ac_cv_lib_socks5_connect+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lsocks5 $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char connect (); int main () { return connect (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_socks5_connect=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_socks5_connect=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_socks5_connect” >&5 echo “${ECHO_T}$ac_cv_lib_socks5_connect” >&6; } if test $ac_cv_lib_socks5_connect = yes; then : else { { echo “$as_me:$LINENO: error: could not find libsocks5 for SOCKS support” >&5 echo “$as_me: error: could not find libsocks5 for SOCKS support” >&2;} { (exit 1); exit 1; }; } fi

else { { echo “$as_me:$LINENO: error: could not find socks.h for SOCKS support” >&5 echo “$as_me: error: could not find socks.h for SOCKS support” >&2;} { (exit 1); exit 1; }; } fi

done

NE_FLAG_SOCKS=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_SOCKS 1

_ACEOF

ne_SOCKS_message=“SOCKSv5 support is enabled” { echo “$as_me:$LINENO: SOCKSv5 support is enabled” >&5 echo “$as_me: SOCKSv5 support is enabled” >&6;}

NEON_LIBS=“$NEON_LIBS -lsocks5” LIBS=$ne_save_LIBS else

NE_FLAG_SOCKS=no

ne_SOCKS_message=“SOCKSv5 support is not enabled” { echo “$as_me:$LINENO: SOCKSv5 support is not enabled” >&5 echo “$as_me: SOCKSv5 support is not enabled” >&6;}

fi

Check whether –with-gssapi was given.

if test “${with_gssapi+set}” = set; then withval=$with_gssapi; fi

if test “$with_gssapi” != “no”; then # Extract the first word of “krb5-config”, so it can be a program name with args. set dummy krb5-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_KRB5_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $KRB5_CONFIG in [\/] | ?:[\/]) ac_cv_path_KRB5_CONFIG=“$KRB5_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_dummy=“$PATH:/usr/kerberos/bin” for as_dir in $as_dummy do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_KRB5_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_KRB5_CONFIG” && ac_cv_path_KRB5_CONFIG=“none” ;; esac fi KRB5_CONFIG=$ac_cv_path_KRB5_CONFIG if test -n “$KRB5_CONFIG”; then { echo “$as_me:$LINENO: result: $KRB5_CONFIG” >&5 echo “${ECHO_T}$KRB5_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

else KRB5_CONFIG=none fi if test “x$KRB5_CONFIG” != “xnone”; then ne_save_CPPFLAGS=$CPPFLAGS ne_save_LIBS=$NEON_LIBS NEON_LIBS=“$NEON_LIBS ${KRB5_CONFIG} --libs gssapi” CPPFLAGS=“$CPPFLAGS ${KRB5_CONFIG} --cflags gssapi” # MIT and Heimdal put gssapi.h in different places

for ac_header in gssapi/gssapi.h gssapi.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

ne_cf_save_LIBS=$LIBS LIBS=“$LIBS $NEON_LIBS”

for ac_func in gss_init_sec_context do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

  ne_save_CPPFLAGS=$CPPFLAGS
  ne_save_LIBS=$NEON_LIBS
  { echo "$as_me:$LINENO: GSSAPI authentication support enabled" >&5

echo “$as_me: GSSAPI authentication support enabled” >&6;}

cat >>confdefs.h <<_ACEOF

define HAVE_GSSAPI 1

_ACEOF

for ac_header in gssapi/gssapi_generic.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

  # Older versions of MIT Kerberos lack GSS_C_NT_HOSTBASED_SERVICE
  { echo "$as_me:$LINENO: checking whether GSS_C_NT_HOSTBASED_SERVICE is declared" >&5

echo $ECHO_N “checking whether GSS_C_NT_HOSTBASED_SERVICE is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef HAVE_GSSAPI_GSSAPI_H

include <gssapi/gssapi.h>

else

include <gssapi.h>

endif

int main () {

ifndef GSS_C_NT_HOSTBASED_SERVICE

(void) GSS_C_NT_HOSTBASED_SERVICE;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE” >&5 echo “${ECHO_T}$ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE” >&6; } if test $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE = yes; then : else

cat >>confdefs.h <<_ACEOF

define GSS_C_NT_HOSTBASED_SERVICE gss_nt_service_name

_ACEOF

fi

fi done

LIBS=$ne_cf_save_LIBS break

fi

done

CPPFLAGS=$ne_save_CPPFLAGS NEON_LIBS=$ne_save_LIBS fi

CFLAGS="$CFLAGS -I$neon_bundled_srcdir"
NEON_LIBS="-L$neon_bundled_builddir -lneon $NEON_LIBS"
NEON_NEED_XML_PARSER=yes
neon_library_message="included libneon (${NEON_VERSION})"

else # Don’t need to configure an XML parser NEON_NEED_XML_PARSER=no NEON_BUILD_BUNDLED=no fi

The colons are here so there is something to evaluate

in case the argument was not passed.

if test “$neon_force_included” = “yes”; then :

Check whether –with-libxml2 was given.

if test “${with_libxml2+set}” = set; then withval=$with_libxml2; fi

Check whether –with-expat was given.

if test “${with_expat+set}” = set; then withval=$with_expat; fi

Check whether –with-included-expat was given.

if test “${with_included_expat+set}” = set; then withval=$with_included_expat; else with_included_expat=no fi

if test “$NEON_NEED_XML_PARSER” = “yes”; then # Find an XML parser neon_xml_parser=none

# Forced choice of expat: case $with_expat in yes) if test “${ac_cv_header_expat_h+set}” = set; then { echo “$as_me:$LINENO: checking for expat.h” >&5 echo $ECHO_N “checking for expat.h… $ECHO_C” >&6; } if test “${ac_cv_header_expat_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi { echo “$as_me:$LINENO: result: $ac_cv_header_expat_h” >&5 echo “${ECHO_T}$ac_cv_header_expat_h” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking expat.h usability” >&5 echo $ECHO_N “checking expat.h usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking expat.h presence” >&5 echo $ECHO_N “checking expat.h presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <expat.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: expat.h: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: expat.h: present but cannot be compiled” >&5 echo “$as_me: WARNING: expat.h: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: expat.h: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: see the Autoconf documentation” >&5 echo “$as_me: WARNING: expat.h: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: expat.h: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: expat.h: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: expat.h: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: expat.h: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for expat.h” >&5 echo $ECHO_N “checking for expat.h… $ECHO_C” >&6; } if test “${ac_cv_header_expat_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_header_expat_h=$ac_header_preproc fi { echo “$as_me:$LINENO: result: $ac_cv_header_expat_h” >&5 echo “${ECHO_T}$ac_cv_header_expat_h” >&6; }

fi if test $ac_cv_header_expat_h = yes; then { echo “$as_me:$LINENO: checking for XML_SetXmlDeclHandler in -lexpat” >&5 echo $ECHO_N “checking for XML_SetXmlDeclHandler in -lexpat… $ECHO_C” >&6; } if test “${ac_cv_lib_expat_XML_SetXmlDeclHandler+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lexpat $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char XML_SetXmlDeclHandler (); int main () { return XML_SetXmlDeclHandler (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_expat_XML_SetXmlDeclHandler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_expat_XML_SetXmlDeclHandler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_expat_XML_SetXmlDeclHandler” >&5 echo “${ECHO_T}$ac_cv_lib_expat_XML_SetXmlDeclHandler” >&6; } if test $ac_cv_lib_expat_XML_SetXmlDeclHandler = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_EXPAT 1

_ACEOF

neon_xml_parser_message="expat"
NEON_LIBS="$NEON_LIBS -lexpat"
neon_xml_parser=expat
{ echo "$as_me:$LINENO: checking for XML_Size" >&5

echo $ECHO_N “checking for XML_Size… $ECHO_C” >&6; } if test “${ac_cv_type_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <expat.h>

typedef XML_Size actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_XML_Size=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_XML_Size=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_XML_Size” >&5 echo “${ECHO_T}$ac_cv_type_XML_Size” >&6; } if test $ac_cv_type_XML_Size = yes; then

{ echo “$as_me:$LINENO: checking for XML_Size” >&5 echo $ECHO_N “checking for XML_Size… $ECHO_C” >&6; } if test “${ac_cv_type_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_XML_Size=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_XML_Size=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_XML_Size” >&5 echo “${ECHO_T}$ac_cv_type_XML_Size” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of XML_Size” >&5 echo $ECHO_N “checking size of XML_Size… $ECHO_C” >&6; } if test “${ac_cv_sizeof_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_XML_Size=$ac_lo;; ‘’) if test “$ac_cv_type_XML_Size” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_XML_Size=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_XML_Size=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_XML_Size” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_XML_Size=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_XML_Size” >&5 echo “${ECHO_T}$ac_cv_sizeof_XML_Size” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_XML_SIZE $ac_cv_sizeof_XML_Size

_ACEOF

{ echo “$as_me:$LINENO: checking how to print XML_Size” >&5 echo $ECHO_N “checking how to print XML_Size… $ECHO_C” >&6; } if test “${ne_cv_fmt_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_XML_Size=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <expat.h>

include <stdio.h>

int main () { XML_Size i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_XML_Size=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_XML_Size in $ac_cv_sizeof_int) ne_cv_fmt_XML_Size=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_XML_Size=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_XML_Size=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_XML_Size” >&5 echo “${ECHO_T}$ne_cv_fmt_XML_Size” >&6; }

if test “x$ne_cv_fmt_XML_Size” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for XML_Size not found” >&5 echo “$as_me: error: format string for XML_Size not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “$ne_cv_fmt_XML_Size”

_ACEOF

else cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “d”

_ACEOF

fi

else { { echo “$as_me:$LINENO: error: expat library not found, cannot proceed” >&5 echo “$as_me: error: expat library not found, cannot proceed” >&2;} { (exit 1); exit 1; }; } fi

else { { echo “$as_me:$LINENO: error: expat library not found, cannot proceed” >&5 echo “$as_me: error: expat library not found, cannot proceed” >&2;} { (exit 1); exit 1; }; } fi

;; no) ;; */libexpat.la) # Special case for Subversion ne_expdir=echo $with_expat | sed 's:/libexpat.la$::' cat >>confdefs.h <<_ACEOF

define HAVE_EXPAT 1

_ACEOF

   cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “d”

_ACEOF

   CPPFLAGS="$CPPFLAGS -I$ne_expdir"
   if test "x${NEON_TARGET}" = "xlibneon.la"; then
     NEON_LTLIBS=$with_expat
   else
     # no dependency on libexpat => crippled libneon, so do partial install
     ALLOW_INSTALL=lib
   fi
   neon_xml_parser=expat
   neon_xml_parser_message="expat in $ne_expdir"
   ;;

/*) { { echo “$as_me:$LINENO: error: –with-expat does not take a directory argument” >&5 echo “$as_me: error: –with-expat does not take a directory argument” >&2;} { (exit 1); exit 1; }; } ;; esac

# If expat wasn’t specifically enabled and libxml was: if test “${neon_xml_parser}-${with_libxml2}-${with_included_expat}” = “none-yes-no”; then

Extract the first word of “xml2-config”, so it can be a program name with args.

set dummy xml2-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_XML2_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$XML2_CONFIG”; then ac_cv_prog_XML2_CONFIG=“$XML2_CONFIG” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_XML2_CONFIG=“xml2-config” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi XML2_CONFIG=$ac_cv_prog_XML2_CONFIG if test -n “$XML2_CONFIG”; then { echo “$as_me:$LINENO: result: $XML2_CONFIG” >&5 echo “${ECHO_T}$XML2_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test -n “$XML2_CONFIG”; then neon_xml_parser_message=“libxml $XML2_CONFIG --version

cat >>confdefs.h <<_ACEOF

define HAVE_LIBXML 1

_ACEOF

# xml2-config in some versions erroneously includes -I/include
# in the --cflags output.
CPPFLAGS="$CPPFLAGS `$XML2_CONFIG --cflags | sed 's| -I/include||g'`"
NEON_LIBS="$NEON_LIBS `$XML2_CONFIG --libs | sed 's|-L/usr/lib ||g'`"

for ac_header in libxml/xmlversion.h libxml/parser.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

else

  { { echo "$as_me:$LINENO: error: could not find parser.h, libxml installation problem?" >&5

echo “$as_me: error: could not find parser.h, libxml installation problem?” >&2;} { (exit 1); exit 1; }; } fi

done

neon_xml_parser=libxml2

else { { echo “$as_me:$LINENO: error: libxml2.x library not found, cannot proceed” >&5 echo “$as_me: error: libxml2.x library not found, cannot proceed” >&2;} { (exit 1); exit 1; }; } fi

fi

# Otherwise, by default search for expat then libxml2: if test “${neon_xml_parser}-${with_included_expat}” = “none-no”; then

if test “${ac_cv_header_expat_h+set}” = set; then { echo “$as_me:$LINENO: checking for expat.h” >&5 echo $ECHO_N “checking for expat.h… $ECHO_C” >&6; } if test “${ac_cv_header_expat_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi { echo “$as_me:$LINENO: result: $ac_cv_header_expat_h” >&5 echo “${ECHO_T}$ac_cv_header_expat_h” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking expat.h usability” >&5 echo $ECHO_N “checking expat.h usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking expat.h presence” >&5 echo $ECHO_N “checking expat.h presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <expat.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: expat.h: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: expat.h: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: expat.h: present but cannot be compiled” >&5 echo “$as_me: WARNING: expat.h: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: expat.h: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: see the Autoconf documentation” >&5 echo “$as_me: WARNING: expat.h: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: expat.h: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: expat.h: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: expat.h: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: expat.h: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: expat.h: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for expat.h” >&5 echo $ECHO_N “checking for expat.h… $ECHO_C” >&6; } if test “${ac_cv_header_expat_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_header_expat_h=$ac_header_preproc fi { echo “$as_me:$LINENO: result: $ac_cv_header_expat_h” >&5 echo “${ECHO_T}$ac_cv_header_expat_h” >&6; }

fi if test $ac_cv_header_expat_h = yes; then { echo “$as_me:$LINENO: checking for XML_SetXmlDeclHandler in -lexpat” >&5 echo $ECHO_N “checking for XML_SetXmlDeclHandler in -lexpat… $ECHO_C” >&6; } if test “${ac_cv_lib_expat_XML_SetXmlDeclHandler+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lexpat $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char XML_SetXmlDeclHandler (); int main () { return XML_SetXmlDeclHandler (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_expat_XML_SetXmlDeclHandler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_expat_XML_SetXmlDeclHandler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_expat_XML_SetXmlDeclHandler” >&5 echo “${ECHO_T}$ac_cv_lib_expat_XML_SetXmlDeclHandler” >&6; } if test $ac_cv_lib_expat_XML_SetXmlDeclHandler = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_EXPAT 1

_ACEOF

neon_xml_parser_message="expat"
NEON_LIBS="$NEON_LIBS -lexpat"
neon_xml_parser=expat
{ echo "$as_me:$LINENO: checking for XML_Size" >&5

echo $ECHO_N “checking for XML_Size… $ECHO_C” >&6; } if test “${ac_cv_type_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <expat.h>

typedef XML_Size actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_XML_Size=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_XML_Size=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_XML_Size” >&5 echo “${ECHO_T}$ac_cv_type_XML_Size” >&6; } if test $ac_cv_type_XML_Size = yes; then

{ echo “$as_me:$LINENO: checking for XML_Size” >&5 echo $ECHO_N “checking for XML_Size… $ECHO_C” >&6; } if test “${ac_cv_type_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_XML_Size=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_XML_Size=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_XML_Size” >&5 echo “${ECHO_T}$ac_cv_type_XML_Size” >&6; }

The cast to long int works around a bug in the HP C Compiler

version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

declarations like `int a3[[(sizeof (unsigned char)) >= 0]];‘.

This bug is HP SR number 8606223364.

{ echo “$as_me:$LINENO: checking size of XML_Size” >&5 echo $ECHO_N “checking size of XML_Size… $ECHO_C” >&6; } if test “${ac_cv_sizeof_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; int main () { static int test_array [1 - 2 * !(((long int) (sizeof (actype_sizeof_))) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) ac_cv_sizeof_XML_Size=$ac_lo;; ‘’) if test “$ac_cv_type_XML_Size” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_XML_Size=0 fi ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */ $ac_includes_default

include <expat.h>

typedef XML_Size actype_sizeof_; static long int longval () { return (long int) (sizeof (actype_sizeof)); } static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof)); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if (((long int) (sizeof (actype_sizeof_))) < 0) { long int i = longval (); if (i != ((long int) (sizeof (actype_sizeof)))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != ((long int) (sizeof (ac__type_sizeof)))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_sizeof_XML_Size=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) if test “$ac_cv_type_XML_Size” = yes; then { { echo “$as_me:$LINENO: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&5 echo “$as_me: error: cannot compute sizeof (XML_Size) See `config.log' for more details.” >&2;} { (exit 77); exit 77; }; } else ac_cv_sizeof_XML_Size=0 fi fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val fi { echo “$as_me:$LINENO: result: $ac_cv_sizeof_XML_Size” >&5 echo “${ECHO_T}$ac_cv_sizeof_XML_Size” >&6; }

cat >>confdefs.h <<_ACEOF

define SIZEOF_XML_SIZE $ac_cv_sizeof_XML_Size

_ACEOF

{ echo “$as_me:$LINENO: checking how to print XML_Size” >&5 echo $ECHO_N “checking how to print XML_Size… $ECHO_C” >&6; } if test “${ne_cv_fmt_XML_Size+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

ne_cv_fmt_XML_Size=none if test $ne_fmt_trycompile = yes; then oflags=“$CPPFLAGS” # Consider format string mismatches as errors CPPFLAGS=“$CPPFLAGS -Wformat -Werror” for str in d ld lld; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <expat.h>

include <stdio.h>

int main () { XML_Size i = 1; printf(“%$str”, i); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ne_cv_fmt_XML_Size=$str; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done CPPFLAGS=$oflags else # Best guess. Don’t have to be too precise since we probably won’t # get a warning message anyway. case $ac_cv_sizeof_XML_Size in $ac_cv_sizeof_int) ne_cv_fmt_XML_Size=“d” ;; $ac_cv_sizeof_long) ne_cv_fmt_XML_Size=“ld” ;; $ac_cv_sizeof_long_long) ne_cv_fmt_XML_Size=“lld” ;; esac fi

fi { echo “$as_me:$LINENO: result: $ne_cv_fmt_XML_Size” >&5 echo “${ECHO_T}$ne_cv_fmt_XML_Size” >&6; }

if test “x$ne_cv_fmt_XML_Size” = “xnone”; then { { echo “$as_me:$LINENO: error: format string for XML_Size not found” >&5 echo “$as_me: error: format string for XML_Size not found” >&2;} { (exit 1); exit 1; }; } fi

cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “$ne_cv_fmt_XML_Size”

_ACEOF

else cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “d”

_ACEOF

fi

else

Extract the first word of “xml2-config”, so it can be a program name with args.

set dummy xml2-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_XML2_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$XML2_CONFIG”; then ac_cv_prog_XML2_CONFIG=“$XML2_CONFIG” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_XML2_CONFIG=“xml2-config” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi XML2_CONFIG=$ac_cv_prog_XML2_CONFIG if test -n “$XML2_CONFIG”; then { echo “$as_me:$LINENO: result: $XML2_CONFIG” >&5 echo “${ECHO_T}$XML2_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test -n “$XML2_CONFIG”; then neon_xml_parser_message=“libxml $XML2_CONFIG --version

cat >>confdefs.h <<_ACEOF

define HAVE_LIBXML 1

_ACEOF

# xml2-config in some versions erroneously includes -I/include
# in the --cflags output.
CPPFLAGS="$CPPFLAGS `$XML2_CONFIG --cflags | sed 's| -I/include||g'`"
NEON_LIBS="$NEON_LIBS `$XML2_CONFIG --libs | sed 's|-L/usr/lib ||g'`"

for ac_header in libxml/xmlversion.h libxml/parser.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

else

  { { echo "$as_me:$LINENO: error: could not find parser.h, libxml installation problem?" >&5

echo “$as_me: error: could not find parser.h, libxml installation problem?” >&2;} { (exit 1); exit 1; }; } fi

done

neon_xml_parser=libxml2

else : fi

fi

else

Extract the first word of “xml2-config”, so it can be a program name with args.

set dummy xml2-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_XML2_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$XML2_CONFIG”; then ac_cv_prog_XML2_CONFIG=“$XML2_CONFIG” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_XML2_CONFIG=“xml2-config” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi XML2_CONFIG=$ac_cv_prog_XML2_CONFIG if test -n “$XML2_CONFIG”; then { echo “$as_me:$LINENO: result: $XML2_CONFIG” >&5 echo “${ECHO_T}$XML2_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test -n “$XML2_CONFIG”; then neon_xml_parser_message=“libxml $XML2_CONFIG --version

cat >>confdefs.h <<_ACEOF

define HAVE_LIBXML 1

_ACEOF

# xml2-config in some versions erroneously includes -I/include
# in the --cflags output.
CPPFLAGS="$CPPFLAGS `$XML2_CONFIG --cflags | sed 's| -I/include||g'`"
NEON_LIBS="$NEON_LIBS `$XML2_CONFIG --libs | sed 's|-L/usr/lib ||g'`"

for ac_header in libxml/xmlversion.h libxml/parser.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

else

  { { echo "$as_me:$LINENO: error: could not find parser.h, libxml installation problem?" >&5

echo “$as_me: error: could not find parser.h, libxml installation problem?” >&2;} { (exit 1); exit 1; }; } fi

done

neon_xml_parser=libxml2

else : fi

fi

fi

# If an XML parser still has not been found, fail or use the bundled expat if test “$neon_xml_parser” = “none”; then # Configure the bundled copy of expat

Define XML_BYTE_ORDER for expat sources.

if test $ac_cv_c_bigendian = “yes”; then ne_xml_border=21 else ne_xml_border=12 fi

mini-expat doesn’t pick up config.h

CPPFLAGS=“$CPPFLAGS -DXML_BYTE_ORDER=$ne_xml_border -DXML_DTD -I\$(top_srcdir)/lib/expat/xmlparse -I\$(top_srcdir)/lib/expat/xmltok”

cat >>confdefs.h <<_ACEOF

define NE_FMT_XML_SIZE “d”

_ACEOF

Use the bundled expat sources

case “ $LIBOBJS ” in “ \$(top_builddir)/lib/expat/xmltok/xmltok.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS \$(top_builddir)/lib/expat/xmltok/xmltok.$ac_objext” ;; esac

case “ $LIBOBJS ” in “ \$(top_builddir)/lib/expat/xmltok/xmlrole.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS \$(top_builddir)/lib/expat/xmltok/xmlrole.$ac_objext” ;; esac

case “ $LIBOBJS ” in “ \$(top_builddir)/lib/expat/xmlparse/xmlparse.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS \$(top_builddir)/lib/expat/xmlparse/xmlparse.$ac_objext” ;; esac

case “ $LIBOBJS ” in “ \$(top_builddir)/lib/expat/xmlparse/hashtable.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS \$(top_builddir)/lib/expat/xmlparse/hashtable.$ac_objext” ;; esac

cat >>confdefs.h <<_ACEOF

define HAVE_EXPAT 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define HAVE_XMLPARSE_H 1

_ACEOF

neon_xml_parser_message="bundled expat in \$(top_srcdir)/lib/expat"

fi

{ echo “$as_me:$LINENO: XML parser used: $neon_xml_parser_message” >&5 echo “$as_me: XML parser used: $neon_xml_parser_message” >&6;} fi

NEON_TARGET=libneon.a NEON_OBJEXT=o

Using the default set of object files to build.

Add the extension to EXTRAOBJS

ne=“$NEON_EXTRAOBJS” NEON_EXTRAOBJS= for o in $ne; do NEON_EXTRAOBJS=“$NEON_EXTRAOBJS $o.$NEON_OBJEXT” done

Was DAV support explicitly turned off?

if test “x$neon_no_webdav” = “xyes”; then # No WebDAV support NEONOBJS=“$NEONOBJS \$(NEON_BASEOBJS)”

NE_FLAG_DAV=no

ne_DAV_message=“WebDAV support is not enabled” { echo “$as_me:$LINENO: WebDAV support is not enabled” >&5 echo “$as_me: WebDAV support is not enabled” >&6;}

: Disabled for 0.28 to retain 0.27 ABI

else # WebDAV support NEONOBJS=“$NEONOBJS \$(NEON_DAVOBJS)”

NE_FLAG_DAV=yes

cat >>confdefs.h <<_ACEOF

define NE_HAVE_DAV 1

_ACEOF

ne_DAV_message=“WebDAV support is enabled” { echo “$as_me:$LINENO: WebDAV support is enabled” >&5 echo “$as_me: WebDAV support is enabled” >&6;}

fi

else :

fi

{ echo “$as_me:$LINENO: checking for getopt_long” >&5 echo $ECHO_N “checking for getopt_long… $ECHO_C” >&6; } if test “${ac_cv_func_getopt_long+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define getopt_long to an innocuous variant, in case <limits.h> declares getopt_long. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define getopt_long innocuous_getopt_long

/ System header to define stub macros and hopefully few prototypes, which can conflict with char getopt_long (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef getopt_long

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char getopt_long (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_getopt_long || defined stub___getopt_long

choke me

endif

int main () { return getopt_long (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_func_getopt_long=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_func_getopt_long=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_func_getopt_long” >&5 echo “${ECHO_T}$ac_cv_func_getopt_long” >&6; } if test $ac_cv_func_getopt_long = yes; then : else case “ $LIBOBJS ” in “ lib/getopt.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/getopt.$ac_objext” ;; esac

case “ $LIBOBJS ” in “ lib/getopt1.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/getopt1.$ac_objext” ;; esac

fi

{ echo “$as_me:$LINENO: checking for strcasecmp” >&5 echo $ECHO_N “checking for strcasecmp… $ECHO_C” >&6; } if test “${ac_cv_func_strcasecmp+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define strcasecmp to an innocuous variant, in case <limits.h> declares strcasecmp. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define strcasecmp innocuous_strcasecmp

/ System header to define stub macros and hopefully few prototypes, which can conflict with char strcasecmp (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef strcasecmp

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char strcasecmp (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_strcasecmp || defined stub___strcasecmp

choke me

endif

int main () { return strcasecmp (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_func_strcasecmp=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_func_strcasecmp=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_func_strcasecmp” >&5 echo “${ECHO_T}$ac_cv_func_strcasecmp” >&6; } if test $ac_cv_func_strcasecmp = yes; then : else case “ $LIBOBJS ” in “ lib/strcasecmp.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/strcasecmp.$ac_objext” ;; esac

fi

for ac_func in strdup strsignal strerror memcpy setlocale nl_langinfo do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

{ echo “$as_me:$LINENO: checking return type of signal handlers” >&5 echo $ECHO_N “checking return type of signal handlers… $ECHO_C” >&6; } if test “${ac_cv_type_signal+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <signal.h>

int main () { return (signal (0, 0)) (0) == 1; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ *+’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_signal=int else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_signal=void

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_signal” >&5 echo “${ECHO_T}$ac_cv_type_signal” >&6; }

cat >>confdefs.h <<_ACEOF

define RETSIGTYPE $ac_cv_type_signal

_ACEOF

for ac_header in stdarg.h string.h strings.h sys/time.h regex.h \ locale.h langinfo.h stdlib.h unistd.h limits.h sys/select.h fcntl.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo “$as_me:$LINENO: checking for the third argument of getsockname” >&5 echo $ECHO_N “checking for the third argument of getsockname… $ECHO_C” >&6; } if test “${ac_cv_ksize_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <sys/socket.h>

int main () {

socklen_t a=0; getsockname(0,(struct sockaddr*)0, &a);

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_ksize_t=socklen_t else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_ksize_t=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test -z “$ac_cv_ksize_t”; then ac_safe_cflags=“$CFLAGS” if test “$GCC” = “yes”; then CFLAGS=“-Werror $CFLAGS” fi cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <sys/socket.h>

int main () {

int a=0; getsockname(0,(struct sockaddr*)0, &a);

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_ksize_t=int else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_ksize_t=size_t

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS=“$ac_safe_cflags” fi

fi

if test -z “$ac_cv_ksize_t”; then ac_cv_ksize_t=int fi

{ echo “$as_me:$LINENO: result: $ac_cv_ksize_t” >&5 echo “${ECHO_T}$ac_cv_ksize_t” >&6; }

cat >>confdefs.h <<_ACEOF

define ksize_t $ac_cv_ksize_t

_ACEOF

if test “$enable_gnomefe” = “yes”; then { echo “$as_me:$LINENO: checking for pthread_create in -lpthread” >&5 echo $ECHO_N “checking for pthread_create in -lpthread… $ECHO_C” >&6; } if test “${ac_cv_lib_pthread_pthread_create+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lpthread $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char pthread_create (); int main () { return pthread_create (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_pthread_pthread_create=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_pthread_pthread_create=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_create” >&5 echo “${ECHO_T}$ac_cv_lib_pthread_pthread_create” >&6; } if test $ac_cv_lib_pthread_pthread_create = yes; then gnome_is_ok=yes else gnome_is_ok=no fi

Check whether –with-libglade-config was given.

if test “${with_libglade_config+set}” = set; then withval=$with_libglade_config; LIBGLADE_CONFIG=“$withval” fi

module_args= for module in . gnome; do case “$module” in gnome) module_args=“$module_args gnome” ;; bonobo) module_args=“$module_args bonobo” ;; gnomedb) module_args=“$module_args gnomedb” ;; esac done

Extract the first word of “libglade-config”, so it can be a program name with args.

set dummy libglade-config; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_LIBGLADE_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $LIBGLADE_CONFIG in [\/] | ?:[\/]) ac_cv_path_LIBGLADE_CONFIG=“$LIBGLADE_CONFIG” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_LIBGLADE_CONFIG=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_LIBGLADE_CONFIG” && ac_cv_path_LIBGLADE_CONFIG=“no” ;; esac fi LIBGLADE_CONFIG=$ac_cv_path_LIBGLADE_CONFIG if test -n “$LIBGLADE_CONFIG”; then { echo “$as_me:$LINENO: result: $LIBGLADE_CONFIG” >&5 echo “${ECHO_T}$LIBGLADE_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

{ echo “$as_me:$LINENO: checking for libglade” >&5 echo $ECHO_N “checking for libglade… $ECHO_C” >&6; } if test “$LIBGLADE_CONFIG” = “no”; then { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } : else if $LIBGLADE_CONFIG –check $module_args; then LIBGLADE_CFLAGS=$LIBGLADE_CONFIG --cflags $module_args LIBGLADE_LIBS=$LIBGLADE_CONFIG --libs $module_args { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } : else echo “*** libglade was not compiled with support for $module_args” 1>&2 { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } : fi fi

fi

ALL_LINGUAS=“ru fr cs ja de tr nn it” { echo “$as_me:$LINENO: checking for a thread-safe mkdir -p” >&5 echo $ECHO_N “checking for a thread-safe mkdir -p… $ECHO_C” >&6; } if test -z “$MKDIR_P”; then if test “${ac_cv_path_mkdir+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_prog in mkdir gmkdir; do for ac_exec_ext in ‘’ $ac_executable_extensions; do { test -f “$as_dir/$ac_prog$ac_exec_ext” && $as_test_x “$as_dir/$ac_prog$ac_exec_ext”; } || continue case "$as_dir/$ac_prog$ac_exec_ext" --version 2>&1 in #( ‘mkdir (GNU coreutils) ’ | \ ‘mkdir (coreutils) ’ | \ ‘mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS

fi

if test “${ac_cv_path_mkdir+set}” = set; then MKDIR_P=“$ac_cv_path_mkdir -p” else # As a last resort, use the slow shell script. Don’t cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. test -d ./–version && rmdir ./–version MKDIR_P=“$ac_install_sh -d” fi fi { echo “$as_me:$LINENO: result: $MKDIR_P” >&5 echo “${ECHO_T}$MKDIR_P” >&6; }

mkdir_p=“$MKDIR_P” case $mkdir_p in [\/$] | ?:[\/]) ;; /) mkdir_p=“\$(top_builddir)/$mkdir_p” ;; esac

{ echo “$as_me:$LINENO: checking whether NLS is requested” >&5 echo $ECHO_N “checking whether NLS is requested… $ECHO_C” >&6; } # Check whether –enable-nls was given. if test “${enable_nls+set}” = set; then enableval=$enable_nls; USE_NLS=$enableval else USE_NLS=yes fi

{ echo “$as_me:$LINENO: result: $USE_NLS” >&5 echo “${ECHO_T}$USE_NLS” >&6; }

  GETTEXT_MACRO_VERSION=0.17

Prepare PATH_SEPARATOR.

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi

Find out how to test for executable files. Don’t use a zero-byte file,

as systems may use methods other than mode bits to determine executability.

cat >conf$$.file <<_ASEOF

! /bin/sh

exit 0 _ASEOF chmod +x conf$$.file if test -x conf$$.file >/dev/null 2>&1; then ac_executable_p=“test -x” else ac_executable_p=“test -f” fi rm -f conf$$.file

Extract the first word of “msgfmt”, so it can be a program name with args.

set dummy msgfmt; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_MSGFMT+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case “$MSGFMT” in [\/] | ?:[\/]) ac_cv_path_MSGFMT=“$MSGFMT” # Let the user override the test with a path. ;; *) ac_save_IFS=“$IFS”; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS=“$ac_save_IFS” test -z “$ac_dir” && ac_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if $ac_executable_p “$ac_dir/$ac_word$ac_exec_ext”; then echo “$as_me: trying $ac_dir/$ac_word…” >&5 if $ac_dir/$ac_word –statistics /dev/null >&5 2>&1 && (if $ac_dir/$ac_word –statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then ac_cv_path_MSGFMT=“$ac_dir/$ac_word$ac_exec_ext” break 2 fi fi done done IFS=“$ac_save_IFS” test -z “$ac_cv_path_MSGFMT” && ac_cv_path_MSGFMT=“:” ;; esac fi MSGFMT=“$ac_cv_path_MSGFMT” if test “$MSGFMT” != “:”; then { echo “$as_me:$LINENO: result: $MSGFMT” >&5 echo “${ECHO_T}$MSGFMT” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

# Extract the first word of “gmsgfmt”, so it can be a program name with args. set dummy gmsgfmt; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_GMSGFMT+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $GMSGFMT in [\/] | ?:[\/]) ac_cv_path_GMSGFMT=“$GMSGFMT” # Let the user override the test with a path. ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_path_GMSGFMT=“$as_dir/$ac_word$ac_exec_ext” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

test -z “$ac_cv_path_GMSGFMT” && ac_cv_path_GMSGFMT=“$MSGFMT” ;; esac fi GMSGFMT=$ac_cv_path_GMSGFMT if test -n “$GMSGFMT”; then { echo “$as_me:$LINENO: result: $GMSGFMT” >&5 echo “${ECHO_T}$GMSGFMT” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

case `$MSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in
'' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) MSGFMT_015=: ;;
*) MSGFMT_015=$MSGFMT ;;

esac

case $GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,' in ‘’ | 0.[0-9] | 0.[0-9]. | 0.1[0-4] | 0.1[0-4].) GMSGFMT_015=: ;; *) GMSGFMT_015=$GMSGFMT ;; esac

Prepare PATH_SEPARATOR.

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi

Find out how to test for executable files. Don’t use a zero-byte file,

as systems may use methods other than mode bits to determine executability.

cat >conf$$.file <<_ASEOF

! /bin/sh

exit 0 _ASEOF chmod +x conf$$.file if test -x conf$$.file >/dev/null 2>&1; then ac_executable_p=“test -x” else ac_executable_p=“test -f” fi rm -f conf$$.file

Extract the first word of “xgettext”, so it can be a program name with args.

set dummy xgettext; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_XGETTEXT+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case “$XGETTEXT” in [\/] | ?:[\/]) ac_cv_path_XGETTEXT=“$XGETTEXT” # Let the user override the test with a path. ;; *) ac_save_IFS=“$IFS”; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS=“$ac_save_IFS” test -z “$ac_dir” && ac_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if $ac_executable_p “$ac_dir/$ac_word$ac_exec_ext”; then echo “$as_me: trying $ac_dir/$ac_word…” >&5 if $ac_dir/$ac_word –omit-header –copyright-holder= –msgid-bugs-address= /dev/null >&5 2>&1 && (if $ac_dir/$ac_word –omit-header –copyright-holder= –msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi); then ac_cv_path_XGETTEXT=“$ac_dir/$ac_word$ac_exec_ext” break 2 fi fi done done IFS=“$ac_save_IFS” test -z “$ac_cv_path_XGETTEXT” && ac_cv_path_XGETTEXT=“:” ;; esac fi XGETTEXT=“$ac_cv_path_XGETTEXT” if test “$XGETTEXT” != “:”; then { echo “$as_me:$LINENO: result: $XGETTEXT” >&5 echo “${ECHO_T}$XGETTEXT” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

rm -f messages.po

case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in
'' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;;
*) XGETTEXT_015=$XGETTEXT ;;

esac

Prepare PATH_SEPARATOR.

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi

Find out how to test for executable files. Don’t use a zero-byte file,

as systems may use methods other than mode bits to determine executability.

cat >conf$$.file <<_ASEOF

! /bin/sh

exit 0 _ASEOF chmod +x conf$$.file if test -x conf$$.file >/dev/null 2>&1; then ac_executable_p=“test -x” else ac_executable_p=“test -f” fi rm -f conf$$.file

Extract the first word of “msgmerge”, so it can be a program name with args.

set dummy msgmerge; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_path_MSGMERGE+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case “$MSGMERGE” in [\/] | ?:[\/]) ac_cv_path_MSGMERGE=“$MSGMERGE” # Let the user override the test with a path. ;; *) ac_save_IFS=“$IFS”; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS=“$ac_save_IFS” test -z “$ac_dir” && ac_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if $ac_executable_p “$ac_dir/$ac_word$ac_exec_ext”; then echo “$as_me: trying $ac_dir/$ac_word…” >&5 if $ac_dir/$ac_word –update -q /dev/null /dev/null >&5 2>&1; then ac_cv_path_MSGMERGE=“$ac_dir/$ac_word$ac_exec_ext” break 2 fi fi done done IFS=“$ac_save_IFS” test -z “$ac_cv_path_MSGMERGE” && ac_cv_path_MSGMERGE=“:” ;; esac fi MSGMERGE=“$ac_cv_path_MSGMERGE” if test “$MSGMERGE” != “:”; then { echo “$as_me:$LINENO: result: $MSGMERGE” >&5 echo “${ECHO_T}$MSGMERGE” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

    test -n "$localedir" || localedir='${datadir}/locale'


test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS=

ac_config_commands=“$ac_config_commands po-directories”

Make sure we can run config.sub.

$SHELL “$ac_aux_dir/config.sub” sun4 >/dev/null 2>&1 || { { echo “$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub” >&5 echo “$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub” >&2;} { (exit 1); exit 1; }; }

{ echo “$as_me:$LINENO: checking build system type” >&5 echo $ECHO_N “checking build system type… $ECHO_C” >&6; } if test “${ac_cv_build+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_build_alias=$build_alias test “x$ac_build_alias” = x && ac_build_alias=$SHELL "$ac_aux_dir/config.guess" test “x$ac_build_alias” = x && { { echo “$as_me:$LINENO: error: cannot guess build type; you must specify one” >&5 echo “$as_me: error: cannot guess build type; you must specify one” >&2;} { (exit 1); exit 1; }; } ac_cv_build=$SHELL "$ac_aux_dir/config.sub" $ac_build_alias || { { echo “$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed” >&5 echo “$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed” >&2;} { (exit 1); exit 1; }; }

fi { echo “$as_me:$LINENO: result: $ac_cv_build” >&5 echo “${ECHO_T}$ac_cv_build” >&6; } case $ac_cv_build in --) ;; ) { { echo “$as_me:$LINENO: error: invalid value of canonical build” >&5 echo “$as_me: error: invalid value of canonical build” >&2;} { (exit 1); exit 1; }; };; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS=‘-’ set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift

Remember, the first character of IFS is used to create $*,

except with old shells:

build_os=$ IFS=$ac_save_IFS case $build_os in \ *) build_os=echo "$build_os" | sed 's/ /-/g';; esac

{ echo “$as_me:$LINENO: checking host system type” >&5 echo $ECHO_N “checking host system type… $ECHO_C” >&6; } if test “${ac_cv_host+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “x$host_alias” = x; then ac_cv_host=$ac_cv_build else ac_cv_host=$SHELL "$ac_aux_dir/config.sub" $host_alias || { { echo “$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed” >&5 echo “$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed” >&2;} { (exit 1); exit 1; }; } fi

fi { echo “$as_me:$LINENO: result: $ac_cv_host” >&5 echo “${ECHO_T}$ac_cv_host” >&6; } case $ac_cv_host in --) ;; ) { { echo “$as_me:$LINENO: error: invalid value of canonical host” >&5 echo “$as_me: error: invalid value of canonical host” >&2;} { (exit 1); exit 1; }; };; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS=‘-’ set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift

Remember, the first character of IFS is used to create $*,

except with old shells:

host_os=$ IFS=$ac_save_IFS case $host_os in \ *) host_os=echo "$host_os" | sed 's/ /-/g';; esac

{ echo "$as_me:$LINENO: checking whether we are using the GNU C Library 2 or newer" >&5

echo $ECHO_N “checking whether we are using the GNU C Library 2 or newer… $ECHO_C” >&6; } if test “${ac_cv_gnu_library_2+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <features.h>

ifdef GNU_LIBRARY

#if (GLIBC >= 2) Lucky GNU user #endif

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “Lucky GNU user” >/dev/null 2>&1; then ac_cv_gnu_library_2=yes else ac_cv_gnu_library_2=no fi rm -f conftest*

fi { echo “$as_me:$LINENO: result: $ac_cv_gnu_library_2” >&5 echo “${ECHO_T}$ac_cv_gnu_library_2” >&6; }

GLIBC2="$ac_cv_gnu_library_2"

if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}ranlib”, so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_RANLIB+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$RANLIB”; then ac_cv_prog_RANLIB=“$RANLIB” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_RANLIB=“${ac_tool_prefix}ranlib” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi RANLIB=$ac_cv_prog_RANLIB if test -n “$RANLIB”; then { echo “$as_me:$LINENO: result: $RANLIB” >&5 echo “${ECHO_T}$RANLIB” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$ac_cv_prog_RANLIB”; then ac_ct_RANLIB=$RANLIB # Extract the first word of “ranlib”, so it can be a program name with args. set dummy ranlib; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_ac_ct_RANLIB+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_RANLIB”; then ac_cv_prog_ac_ct_RANLIB=“$ac_ct_RANLIB” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_ac_ct_RANLIB=“ranlib” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n “$ac_ct_RANLIB”; then { echo “$as_me:$LINENO: result: $ac_ct_RANLIB” >&5 echo “${ECHO_T}$ac_ct_RANLIB” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_ct_RANLIB” = x; then RANLIB=“:” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB fi else RANLIB=“$ac_cv_prog_RANLIB” fi

CFLAG_VISIBILITY= HAVE_VISIBILITY=0 if test -n “$GCC”; then { echo “$as_me:$LINENO: checking for simple visibility declarations” >&5 echo $ECHO_N “checking for simple visibility declarations… $ECHO_C” >&6; } if test “${gl_cv_cc_visibility+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

  gl_save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -fvisibility=hidden"
  cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / extern attribute((visibility(“hidden”))) int hiddenvar; extern attribute((visibility(“default”))) int exportedvar; extern attribute((visibility(“hidden”))) int hiddenfunc (void); extern attribute((visibility(“default”))) int exportedfunc (void); int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gl_cv_cc_visibility=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gl_cv_cc_visibility=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext CFLAGS=“$gl_save_CFLAGS” fi

{ echo "$as_me:$LINENO: result: $gl_cv_cc_visibility" >&5

echo “${ECHO_T}$gl_cv_cc_visibility” >&6; } if test $gl_cv_cc_visibility = yes; then CFLAG_VISIBILITY=“-fvisibility=hidden” HAVE_VISIBILITY=1 fi fi

cat >>confdefs.h <<_ACEOF

define HAVE_VISIBILITY $HAVE_VISIBILITY

_ACEOF

{ echo “$as_me:$LINENO: checking for stdint.h” >&5 echo $ECHO_N “checking for stdint.h… $ECHO_C” >&6; } if test “${gl_cv_header_stdint_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <stdint.h>

int main () { uintmax_t i = (uintmax_t) -1; return !i; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gl_cv_header_stdint_h=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gl_cv_header_stdint_h=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gl_cv_header_stdint_h” >&5 echo “${ECHO_T}$gl_cv_header_stdint_h” >&6; } if test $gl_cv_header_stdint_h = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_STDINT_H_WITH_UINTMAX 1

_ACEOF

fi

The Ultrix 4.2 mips builtin alloca declared by alloca.h only works

for constant arguments. Useless!

{ echo “$as_me:$LINENO: checking for working alloca.h” >&5 echo $ECHO_N “checking for working alloca.h… $ECHO_C” >&6; } if test “${ac_cv_working_alloca_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <alloca.h>

int main () { char p = (char ) alloca (2 * sizeof (int)); if (p) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_working_alloca_h=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_working_alloca_h=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_working_alloca_h” >&5 echo “${ECHO_T}$ac_cv_working_alloca_h” >&6; } if test $ac_cv_working_alloca_h = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_ALLOCA_H 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for alloca” >&5 echo $ECHO_N “checking for alloca… $ECHO_C” >&6; } if test “${ac_cv_func_alloca_works+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef GNUC

define alloca __builtin_alloca

else

ifdef _MSC_VER

include <malloc.h>

define alloca _alloca

else

ifdef HAVE_ALLOCA_H

include <alloca.h>

else

ifdef _AIX

#pragma alloca

else

ifndef alloca / predefined by HP cc +Olibcalls /

char *alloca ();

endif

endif

endif

endif

endif

int main () { char p = (char ) alloca (1); if (p) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_func_alloca_works=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_func_alloca_works=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_func_alloca_works” >&5 echo “${ECHO_T}$ac_cv_func_alloca_works” >&6; }

if test $ac_cv_func_alloca_works = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_ALLOCA 1

_ACEOF

else # The SVR3 libPW and SVR4 libucb both contain incompatible functions

that cause trouble. Some versions do not even contain alloca or

contain a buggy version. If you still want to use their alloca,

use ar to extract alloca.o from them instead of compiling alloca.c.

ALLOCA=\${LIBOBJDIR}alloca.$ac_objext

cat >>confdefs.h <<_ACEOF

define C_ALLOCA 1

_ACEOF

{ echo “$as_me:$LINENO: checking whether `alloca.c' needs Cray hooks” >&5 echo $ECHO_N “checking whether `alloca.c' needs Cray hooks… $ECHO_C” >&6; } if test “${ac_cv_os_cray+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

if defined CRAY && ! defined CRAY2

webecray

else

wenotbecray

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “webecray” >/dev/null 2>&1; then ac_cv_os_cray=yes else ac_cv_os_cray=no fi rm -f conftest*

fi { echo “$as_me:$LINENO: result: $ac_cv_os_cray” >&5 echo “${ECHO_T}$ac_cv_os_cray” >&6; } if test $ac_cv_os_cray = yes; then for ac_func in getb67 GETB67 getb67; do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then

cat >>confdefs.h <<_ACEOF

define CRAY_STACKSEG_END $ac_func

_ACEOF

break

fi

done fi

{ echo “$as_me:$LINENO: checking stack direction for C alloca” >&5 echo $ECHO_N “checking stack direction for C alloca… $ECHO_C” >&6; } if test “${ac_cv_c_stack_direction+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then ac_cv_c_stack_direction=0 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default int find_stack_direction () { static char *addr = 0; auto char dummy; if (addr == 0) { addr = &dummy; return find_stack_direction (); } else return (&dummy > addr) ? 1 : -1; }

int main () { return find_stack_direction () < 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_c_stack_direction=1 else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ac_cv_c_stack_direction=-1 fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi { echo “$as_me:$LINENO: result: $ac_cv_c_stack_direction” >&5 echo “${ECHO_T}$ac_cv_c_stack_direction” >&6; }

cat >>confdefs.h <<_ACEOF

define STACK_DIRECTION $ac_cv_c_stack_direction

_ACEOF

fi

for ac_header in stdlib.h unistd.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_func in getpagesize do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

{ echo “$as_me:$LINENO: checking for working mmap” >&5 echo $ECHO_N “checking for working mmap… $ECHO_C” >&6; } if test “${ac_cv_func_mmap_fixed_mapped+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test “$cross_compiling” = yes; then ac_cv_func_mmap_fixed_mapped=no else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default / malloc might have been renamed as rpl_malloc. /

undef malloc

/* Thanks to Mike Haertel and Jim Avera for this test. Here is a matrix of mmap possibilities: mmap private not fixed mmap private fixed at somewhere currently unmapped mmap private fixed at somewhere already mapped mmap shared not fixed mmap shared fixed at somewhere currently unmapped mmap shared fixed at somewhere already mapped For private mappings, we should verify that changes cannot be read() back from the file, nor mmap’s back from the file at a different address. (There have been systems where private was not correctly implemented like the infamous i386 svr4.0, and systems where the VM page cache was not coherent with the file system buffer cache like early versions of FreeBSD and possibly contemporary NetBSD.) For shared mappings, we should conversely verify that changes get propagated back to all the places they’re supposed to be.

Grep wants private fixed already mapped. The main things grep needs to know about mmap are: * does it exist and is it safe to write into the mmap’d area * how to use it (BSD variants) */

include <fcntl.h>

include <sys/mman.h>

if !defined STDC_HEADERS && !defined HAVE_STDLIB_H

char *malloc ();

endif

/ This mess was copied from the GNU getpagesize.h. /

ifndef HAVE_GETPAGESIZE

/ Assume that all systems that can run configure have sys/param.h. /

ifndef HAVE_SYS_PARAM_H

define HAVE_SYS_PARAM_H 1

endif

ifdef _SC_PAGESIZE

define getpagesize() sysconf(_SC_PAGESIZE)

else / no _SC_PAGESIZE /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

ifdef EXEC_PAGESIZE

define getpagesize() EXEC_PAGESIZE

else / no EXEC_PAGESIZE /

ifdef NBPG

define getpagesize() NBPG * CLSIZE

ifndef CLSIZE

define CLSIZE 1

endif / no CLSIZE /

else / no NBPG /

ifdef NBPC

define getpagesize() NBPC

else / no NBPC /

ifdef PAGESIZE

define getpagesize() PAGESIZE

endif / PAGESIZE /

endif / no NBPC /

endif / no NBPG /

endif / no EXEC_PAGESIZE /

else / no HAVE_SYS_PARAM_H /

define getpagesize() 8192 / punt totally /

endif / no HAVE_SYS_PARAM_H /

endif / no _SC_PAGESIZE /

endif / no HAVE_GETPAGESIZE /

int main () { char data, data2, *data3; int i, pagesize; int fd;

pagesize = getpagesize ();

/ First, make a file with some known garbage in it. / data = (char ) malloc (pagesize); if (!data) return 1; for (i = 0; i < pagesize; ++i) (data + i) = rand (); umask (0); fd = creat (“conftest.mmap”, 0600); if (fd < 0) return 1; if (write (fd, data, pagesize) != pagesize) return 1; close (fd);

/ Next, try to mmap the file at a fixed address which already has something else allocated at it. If we can, also make sure that we see the same garbage. / fd = open (“conftest.mmap”, O_RDWR); if (fd < 0) return 1; data2 = (char ) malloc (2 * pagesize); if (!data2) return 1; data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1); if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0L)) return 1; for (i = 0; i < pagesize; ++i) if ((data + i) != *(data2 + i)) return 1;

/ Finally, make sure that changes to the mapped area do not percolate back to the file as seen by read(). (This is a bug on some variants of i386 svr4.0.) / for (i = 0; i < pagesize; ++i) (data2 + i) = (data2 + i) + 1; data3 = (char ) malloc (pagesize); if (!data3) return 1; if (read (fd, data3, pagesize) != pagesize) return 1; for (i = 0; i < pagesize; ++i) if ((data + i) != (data3 + i)) return 1; close (fd); return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_func_mmap_fixed_mapped=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ac_cv_func_mmap_fixed_mapped=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi { echo “$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped” >&5 echo “${ECHO_T}$ac_cv_func_mmap_fixed_mapped” >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_MMAP 1

_ACEOF

fi rm -f conftest.mmap

{ echo “$as_me:$LINENO: checking whether integer division by zero raises SIGFPE” >&5 echo $ECHO_N “checking whether integer division by zero raises SIGFPE… $ECHO_C” >&6; } if test “${gt_cv_int_divbyzero_sigfpe+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

  gt_cv_int_divbyzero_sigfpe=
  case "$host_os" in
    macos* | darwin[6-9]* | darwin[1-9][0-9]*)
      # On MacOS X 10.2 or newer, just assume the same as when cross-
      # compiling. If we were to perform the real test, 1 Crash Report
      # dialog window would pop up.
      case "$host_cpu" in
        i[34567]86 | x86_64)
          gt_cv_int_divbyzero_sigfpe="guessing yes" ;;
      esac
      ;;
  esac
  if test -z "$gt_cv_int_divbyzero_sigfpe"; then
    if test "$cross_compiling" = yes; then

        # Guess based on the CPU.
        case "$host_cpu" in
          alpha* | i[34567]86 | x86_64 | m68k | s390*)
            gt_cv_int_divbyzero_sigfpe="guessing yes";;
          *)
            gt_cv_int_divbyzero_sigfpe="guessing no";;
        esac

else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdlib.h>

include <signal.h>

static void sigfpe_handler (int sig) { / Exit with code 0 if SIGFPE, with code 1 if any other signal. / exit (sig != SIGFPE); }

int x = 1; int y = 0; int z; int nan;

int main () { signal (SIGFPE, sigfpe_handler); / IRIX and AIX (when “xlc -qcheck” is used) yield signal SIGTRAP. /

if (defined (_sgi) || defined (AIX)) && defined (SIGTRAP)

signal (SIGTRAP, sigfpe_handler);

endif

/ Linux/SPARC yields signal SIGILL. /

if defined (sparc) && defined (linux)

signal (SIGILL, sigfpe_handler);

endif

z = x / y; nan = y / y; exit (1); }

_ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then gt_cv_int_divbyzero_sigfpe=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) gt_cv_int_divbyzero_sigfpe=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

  fi

fi { echo “$as_me:$LINENO: result: $gt_cv_int_divbyzero_sigfpe” >&5 echo “${ECHO_T}$gt_cv_int_divbyzero_sigfpe” >&6; } case “$gt_cv_int_divbyzero_sigfpe” in yes) value=1;; ) value=0;; esac

cat >>confdefs.h <<_ACEOF

define INTDIV0_RAISES_SIGFPE $value

_ACEOF

{ echo “$as_me:$LINENO: checking for inttypes.h” >&5 echo $ECHO_N “checking for inttypes.h… $ECHO_C” >&6; } if test “${gl_cv_header_inttypes_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <sys/types.h>

include <inttypes.h>

int main () { uintmax_t i = (uintmax_t) -1; return !i; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gl_cv_header_inttypes_h=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gl_cv_header_inttypes_h=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gl_cv_header_inttypes_h” >&5 echo “${ECHO_T}$gl_cv_header_inttypes_h” >&6; } if test $gl_cv_header_inttypes_h = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_INTTYPES_H_WITH_UINTMAX 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for unsigned long long int” >&5 echo $ECHO_N “checking for unsigned long long int… $ECHO_C” >&6; } if test “${ac_cv_type_unsigned_long_long_int+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / / Test preprocessor. / #if ! (-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) error in preprocessor; #endif #if ! (18446744073709551615ULL <= -1ull) error in preprocessor; #endif / Test literals. / long long int ll = 9223372036854775807ll; long long int nll = -9223372036854775807LL; unsigned long long int ull = 18446744073709551615ULL; / Test constant expressions. / typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) ? 1 : -1)]; typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 ? 1 : -1)]; int i = 63; int main () { / Test availability of runtime routines for shift and division. / long long int llmax = 9223372036854775807ll; unsigned long long int ullmax = 18446744073709551615ull; return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) | (llmax / ll) | (llmax % ll) | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) | (ullmax / ull) | (ullmax % ull)); ; return 0; }

_ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_type_unsigned_long_long_int=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_unsigned_long_long_int=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long_int” >&5 echo “${ECHO_T}$ac_cv_type_unsigned_long_long_int” >&6; } if test $ac_cv_type_unsigned_long_long_int = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_UNSIGNED_LONG_LONG_INT 1

_ACEOF

fi

if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then

test $ac_cv_type_unsigned_long_long_int = yes \
  && ac_type='unsigned long long' \
  || ac_type='unsigned long'

cat >>confdefs.h <<_ACEOF

define uintmax_t $ac_type

_ACEOF

else

cat >>confdefs.h <<_ACEOF

define HAVE_UINTMAX_T 1

_ACEOF

fi

for ac_header in inttypes.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

if test $ac_cv_header_inttypes_h = yes; then { echo “$as_me:$LINENO: checking whether the inttypes.h PRIxNN macros are broken” >&5 echo $ECHO_N “checking whether the inttypes.h PRIxNN macros are broken… $ECHO_C” >&6; } if test “${gt_cv_inttypes_pri_broken+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

    cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <inttypes.h>

ifdef PRId32

char *p = PRId32;

endif

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gt_cv_inttypes_pri_broken=no else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_inttypes_pri_broken=yes

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { echo “$as_me:$LINENO: result: $gt_cv_inttypes_pri_broken” >&5 echo “${ECHO_T}$gt_cv_inttypes_pri_broken” >&6; } fi if test “$gt_cv_inttypes_pri_broken” = yes; then

cat >>confdefs.h <<_ACEOF

define PRI_MACROS_BROKEN 1

_ACEOF

PRI_MACROS_BROKEN=1

else PRI_MACROS_BROKEN=0 fi

cat >>confdefs.h <<_ACEOF

define _GNU_SOURCE 1

_ACEOF

{ echo “$as_me:$LINENO: checking for AIX” >&5 echo $ECHO_N “checking for AIX… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

ifdef _AIX

yes

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “yes” >/dev/null 2>&1; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } cat >>confdefs.h <<_ACEOF

define _ALL_SOURCE 1

_ACEOF

else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi rm -f conftest*

if test “${ac_cv_header_minix_config_h+set}” = set; then { echo “$as_me:$LINENO: checking for minix/config.h” >&5 echo $ECHO_N “checking for minix/config.h… $ECHO_C” >&6; } if test “${ac_cv_header_minix_config_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi { echo “$as_me:$LINENO: result: $ac_cv_header_minix_config_h” >&5 echo “${ECHO_T}$ac_cv_header_minix_config_h” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking minix/config.h usability” >&5 echo $ECHO_N “checking minix/config.h usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <minix/config.h>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking minix/config.h presence” >&5 echo $ECHO_N “checking minix/config.h presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <minix/config.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: minix/config.h: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: minix/config.h: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: minix/config.h: present but cannot be compiled” >&5 echo “$as_me: WARNING: minix/config.h: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: minix/config.h: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: minix/config.h: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: minix/config.h: see the Autoconf documentation” >&5 echo “$as_me: WARNING: minix/config.h: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: minix/config.h: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: minix/config.h: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: minix/config.h: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: minix/config.h: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: minix/config.h: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: minix/config.h: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for minix/config.h” >&5 echo $ECHO_N “checking for minix/config.h… $ECHO_C” >&6; } if test “${ac_cv_header_minix_config_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_header_minix_config_h=$ac_header_preproc fi { echo “$as_me:$LINENO: result: $ac_cv_header_minix_config_h” >&5 echo “${ECHO_T}$ac_cv_header_minix_config_h” >&6; }

fi if test $ac_cv_header_minix_config_h = yes; then MINIX=yes else MINIX= fi

if test “$MINIX” = yes; then

cat >>confdefs.h <<_ACEOF

define _POSIX_SOURCE 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define _POSIX_1_SOURCE 2

_ACEOF

cat >>confdefs.h <<_ACEOF

define _MINIX 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking whether it is safe to define EXTENSIONS” >&5 echo $ECHO_N “checking whether it is safe to define EXTENSIONS… $ECHO_C” >&6; } if test “${ac_cv_safe_to_defineextensions+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

define EXTENSIONS 1

  $ac_includes_default

int main () {

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_safe_to_defineextensions=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_safe_to_define___extensions__=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_safe_to_defineextensions” >&5 echo “${ECHO_T}$ac_cv_safe_to_defineextensions” >&6; } test $ac_cv_safe_to_define_extensions = yes && cat >>confdefs.h <<_ACEOF

define EXTENSIONS 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define _POSIX_PTHREAD_SEMANTICS 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define _TANDEM_SOURCE 1

_ACEOF

# Check whether --enable-threads was given.

if test “${enable_threads+set}” = set; then enableval=$enable_threads; gl_use_threads=$enableval else case “$host_os” in osf) gl_use_threads=no ;; ) gl_use_threads=yes ;; esac

fi

if test “$gl_use_threads” = yes || test “$gl_use_threads” = posix; then # For using <pthread.h>: case “$host_os” in osf) # On OSF/1, the compiler needs the flag -D_REENTRANT so that it # groks <pthread.h>. cc also understands the flag -pthread, but # we don’t use it because 1. gcc-2.95 doesn’t understand -pthread, # 2. putting a flag into CPPFLAGS that has an effect on the linker # causes the AC_TRY_LINK test below to succeed unexpectedly, # leading to wrong values of LIBTHREAD and LTLIBTHREAD. CPPFLAGS=“$CPPFLAGS -D_REENTRANT” ;; esac # Some systems optimize for single-threaded programs by default, and # need special flags to disable these optimizations. For example, the # definition of ‘errno’ in <errno.h>. case “$host_os” in aix | freebsd) CPPFLAGS=“$CPPFLAGS -D_THREAD_SAFE” ;; solaris) CPPFLAGS=“$CPPFLAGS -D_REENTRANT” ;; esac fi

  if test "X$prefix" = "XNONE"; then
acl_final_prefix="$ac_default_prefix"

else acl_final_prefix=“$prefix” fi if test “X$exec_prefix” = “XNONE”; then acl_final_exec_prefix=‘${prefix}’ else acl_final_exec_prefix=“$exec_prefix” fi acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” eval acl_final_exec_prefix=\“$acl_final_exec_prefix\” prefix=“$acl_save_prefix”

Check whether –with-gnu-ld was given.

if test “${with_gnu_ld+set}” = set; then withval=$with_gnu_ld; test “$withval” = no || with_gnu_ld=yes else with_gnu_ld=no fi

Prepare PATH_SEPARATOR.

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi ac_prog=ld if test “$GCC” = yes; then # Check if gcc -print-prog-name=ld gives a path. { echo “$as_me:$LINENO: checking for ld used by GCC” >&5 echo $ECHO_N “checking for ld used by GCC… $ECHO_C” >&6; } case $host in --mingw) # gcc leaves a trailing carriage return which upsets mingw ac_prog=($CC -print-prog-name=ld) 2>&5 | tr -d '\015' ;; ) ac_prog=($CC -print-prog-name=ld) 2>&5 ;; esac case $ac_prog in # Accept absolute paths. [\/] | [A-Za-z]:[\/]) re_direlt=‘/[^/][^/]/../’ # Canonicalize the path of ld ac_prog=echo $ac_prog| sed 's%\\\\%/%g' while echo $ac_prog | grep “$re_direlt” > /dev/null 2>&1; do ac_prog=echo $ac_prog| sed "s%$re_direlt%/%" done test -z “$LD” && LD=“$ac_prog” ;; “”) # If it fails, then pretend we aren’t using GCC. ac_prog=ld ;; ) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test “$with_gnu_ld” = yes; then { echo “$as_me:$LINENO: checking for GNU ld” >&5 echo $ECHO_N “checking for GNU ld… $ECHO_C” >&6; } else { echo “$as_me:$LINENO: checking for non-GNU ld” >&5 echo $ECHO_N “checking for non-GNU ld… $ECHO_C” >&6; } fi if test “${acl_cv_path_LD+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -z “$LD”; then IFS=“${IFS= }”; ac_save_ifs=“$IFS”; IFS=“${IFS}${PATH_SEPARATOR-:}” for ac_dir in $PATH; do test -z “$ac_dir” && ac_dir=. if test -f “$ac_dir/$ac_prog” || test -f “$ac_dir/$ac_prog$ac_exeext”; then acl_cv_path_LD=“$ac_dir/$ac_prog” # Check to see if the program is GNU ld. I’d rather use –version, # but apparently some GNU ld’s only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case "$acl_cv_path_LD" -v 2>&1 < /dev/null in GNU | ‘with BFD’) test “$with_gnu_ld” != no && break ;; *) test “$with_gnu_ld” != yes && break ;; esac fi done IFS=“$ac_save_ifs” else acl_cv_path_LD=“$LD” # Let the user override the test with a path. fi fi

LD=“$acl_cv_path_LD” if test -n “$LD”; then { echo “$as_me:$LINENO: result: $LD” >&5 echo “${ECHO_T}$LD” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi test -z “$LD” && { { echo “$as_me:$LINENO: error: no acceptable ld found in \$PATH” >&5 echo “$as_me: error: no acceptable ld found in \$PATH” >&2;} { (exit 1); exit 1; }; } { echo “$as_me:$LINENO: checking if the linker ($LD) is GNU ld” >&5 echo $ECHO_N “checking if the linker ($LD) is GNU ld… $ECHO_C” >&6; } if test “${acl_cv_prog_gnu_ld+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else # I’d rather use –version here, but apparently some GNU ld’s only accept -v. case $LD -v 2>&1 </dev/null in GNU | ‘with BFD’) acl_cv_prog_gnu_ld=yes ;; *) acl_cv_prog_gnu_ld=no ;; esac fi { echo “$as_me:$LINENO: result: $acl_cv_prog_gnu_ld” >&5 echo “${ECHO_T}$acl_cv_prog_gnu_ld” >&6; } with_gnu_ld=$acl_cv_prog_gnu_ld

                                            { echo "$as_me:$LINENO: checking for shared library run path origin" >&5

echo $ECHO_N “checking for shared library run path origin… $ECHO_C” >&6; } if test “${acl_cv_rpath+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
. ./conftest.sh
rm -f ./conftest.sh
acl_cv_rpath=done

fi { echo “$as_me:$LINENO: result: $acl_cv_rpath” >&5 echo “${ECHO_T}$acl_cv_rpath” >&6; } wl=“$acl_cv_wl” acl_libext=“$acl_cv_libext” acl_shlibext=“$acl_cv_shlibext” acl_libname_spec=“$acl_cv_libname_spec” acl_library_names_spec=“$acl_cv_library_names_spec” acl_hardcode_libdir_flag_spec=“$acl_cv_hardcode_libdir_flag_spec” acl_hardcode_libdir_separator=“$acl_cv_hardcode_libdir_separator” acl_hardcode_direct=“$acl_cv_hardcode_direct” acl_hardcode_minus_L=“$acl_cv_hardcode_minus_L” # Check whether –enable-rpath was given. if test “${enable_rpath+set}” = set; then enableval=$enable_rpath; : else enable_rpath=yes fi

              acl_libdirstem=lib

searchpath=(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,' if test -n “$searchpath”; then acl_save_IFS=“${IFS= }”; IFS=“:” for searchdir in $searchpath; do if test -d “$searchdir”; then case “$searchdir” in /lib64/ | /lib64 ) acl_libdirstem=lib64 ;; ) searchdir=cd "$searchdir" && pwd case “$searchdir” in /lib64 ) acl_libdirstem=lib64 ;; esac ;; esac fi done IFS=“$acl_save_IFS” fi

gl_threads_api=none LIBTHREAD= LTLIBTHREAD= LIBMULTITHREAD= LTLIBMULTITHREAD= if test “$gl_use_threads” != no; then { echo “$as_me:$LINENO: checking whether imported symbols can be declared weak” >&5 echo $ECHO_N “checking whether imported symbols can be declared weak… $ECHO_C” >&6; } gl_have_weak=no cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / extern void xyzzy ();

pragma weak xyzzy

int main () { xyzzy(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gl_have_weak=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext { echo “$as_me:$LINENO: result: $gl_have_weak” >&5 echo “${ECHO_T}$gl_have_weak” >&6; } if test “$gl_use_threads” = yes || test “$gl_use_threads” = posix; then # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that # it groks <pthread.h>. It’s added above, in gl_LOCK_EARLY_BODY. if test “${ac_cv_header_pthread_h+set}” = set; then { echo “$as_me:$LINENO: checking for pthread.h” >&5 echo $ECHO_N “checking for pthread.h… $ECHO_C” >&6; } if test “${ac_cv_header_pthread_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi { echo “$as_me:$LINENO: result: $ac_cv_header_pthread_h” >&5 echo “${ECHO_T}$ac_cv_header_pthread_h” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking pthread.h usability” >&5 echo $ECHO_N “checking pthread.h usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <pthread.h>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking pthread.h presence” >&5 echo $ECHO_N “checking pthread.h presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <pthread.h>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: pthread.h: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: pthread.h: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: pthread.h: present but cannot be compiled” >&5 echo “$as_me: WARNING: pthread.h: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: pthread.h: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: pthread.h: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: pthread.h: see the Autoconf documentation” >&5 echo “$as_me: WARNING: pthread.h: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: pthread.h: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: pthread.h: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: pthread.h: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: pthread.h: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: pthread.h: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: pthread.h: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for pthread.h” >&5 echo $ECHO_N “checking for pthread.h… $ECHO_C” >&6; } if test “${ac_cv_header_pthread_h+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_header_pthread_h=$ac_header_preproc fi { echo “$as_me:$LINENO: result: $ac_cv_header_pthread_h” >&5 echo “${ECHO_T}$ac_cv_header_pthread_h” >&6; }

fi if test $ac_cv_header_pthread_h = yes; then gl_have_pthread_h=yes else gl_have_pthread_h=no fi

  if test "$gl_have_pthread_h" = yes; then
    # Other possible tests:
    #   -lpthreads (FSU threads, PCthreads)
    #   -lgthreads
    gl_have_pthread=
    # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
    # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
    # the second one only in libpthread, and lock.c needs it.
    cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <pthread.h>

int main () { pthread_mutex_lock((pthread_mutex_t)0); pthread_mutexattr_init((pthread_mutexattr_t)0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gl_have_pthread=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext # Test for libpthread by looking for pthread_kill. (Not pthread_self, # since it is defined as a macro on OSF/1.) if test -n “$gl_have_pthread”; then # The program links fine without libpthread. But it may actually # need to link with libpthread in order to create multiple threads. { echo “$as_me:$LINENO: checking for pthread_kill in -lpthread” >&5 echo $ECHO_N “checking for pthread_kill in -lpthread… $ECHO_C” >&6; } if test “${ac_cv_lib_pthread_pthread_kill+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lpthread $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char pthread_kill (); int main () { return pthread_kill (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_pthread_pthread_kill=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_pthread_pthread_kill=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_kill” >&5 echo “${ECHO_T}$ac_cv_lib_pthread_pthread_kill” >&6; } if test $ac_cv_lib_pthread_pthread_kill = yes; then LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread # On Solaris and HP-UX, most pthread functions exist also in libc. # Therefore pthread_in_use() needs to actually try to create a # thread: pthread_create from libc will fail, whereas # pthread_create will actually create a thread. case “$host_os” in solaris | hpux)

cat >>confdefs.h <<_ACEOF

define PTHREAD_IN_USE_DETECTION_HARD 1

_ACEOF

         esac

fi

    else
      # Some library is needed. Try libpthread and libc_r.
      { echo "$as_me:$LINENO: checking for pthread_kill in -lpthread" >&5

echo $ECHO_N “checking for pthread_kill in -lpthread… $ECHO_C” >&6; } if test “${ac_cv_lib_pthread_pthread_kill+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lpthread $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char pthread_kill (); int main () { return pthread_kill (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_pthread_pthread_kill=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_pthread_pthread_kill=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_kill” >&5 echo “${ECHO_T}$ac_cv_lib_pthread_pthread_kill” >&6; } if test $ac_cv_lib_pthread_pthread_kill = yes; then gl_have_pthread=yes LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread fi

      if test -z "$gl_have_pthread"; then
        # For FreeBSD 4.
        { echo "$as_me:$LINENO: checking for pthread_kill in -lc_r" >&5

echo $ECHO_N “checking for pthread_kill in -lc_r… $ECHO_C” >&6; } if test “${ac_cv_lib_c_r_pthread_kill+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lc_r $LIBS” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char pthread_kill (); int main () { return pthread_kill (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then ac_cv_lib_c_r_pthread_kill=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_c_r_pthread_kill=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_lib_c_r_pthread_kill” >&5 echo “${ECHO_T}$ac_cv_lib_c_r_pthread_kill” >&6; } if test $ac_cv_lib_c_r_pthread_kill = yes; then gl_have_pthread=yes LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r fi

      fi
    fi
    if test -n "$gl_have_pthread"; then
      gl_threads_api=posix

cat >>confdefs.h <<_ACEOF

define USE_POSIX_THREADS 1

_ACEOF

      if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
        if test $gl_have_weak = yes; then

cat >>confdefs.h <<_ACEOF

define USE_POSIX_THREADS_WEAK 1

_ACEOF

          LIBTHREAD=
          LTLIBTHREAD=
        fi
      fi
      # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the
      # pthread_rwlock_* functions.
      { echo "$as_me:$LINENO: checking for pthread_rwlock_t" >&5

echo $ECHO_N “checking for pthread_rwlock_t… $ECHO_C” >&6; } if test “${ac_cv_type_pthread_rwlock_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <pthread.h>

typedef pthread_rwlock_t actype_new_; int main () { if ((actype_new *) 0) return 0; if (sizeof (ac__type_new)) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_pthread_rwlock_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_pthread_rwlock_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_pthread_rwlock_t” >&5 echo “${ECHO_T}$ac_cv_type_pthread_rwlock_t” >&6; } if test $ac_cv_type_pthread_rwlock_t = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_PTHREAD_RWLOCK 1

_ACEOF

fi

      # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro.
      cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <pthread.h>

int main () {

if FreeBSD == 4

error “No, in FreeBSD 4.0 recursive mutexes actually don’t work.”

else

int x = (int)PTHREAD_MUTEX_RECURSIVE; return !x;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then

cat >>confdefs.h <<_ACEOF

define HAVE_PTHREAD_MUTEX_RECURSIVE 1

_ACEOF

else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi fi fi if test -z “$gl_have_pthread”; then if test “$gl_use_threads” = yes || test “$gl_use_threads” = solaris; then gl_have_solaristhread= gl_save_LIBS=“$LIBS” LIBS=“$LIBS -lthread” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <thread.h>

include <synch.h>

int main () { thr_self(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gl_have_solaristhread=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gl_save_LIBS” if test -n “$gl_have_solaristhread”; then gl_threads_api=solaris LIBTHREAD=-lthread LTLIBTHREAD=-lthread LIBMULTITHREAD=“$LIBTHREAD” LTLIBMULTITHREAD=“$LTLIBTHREAD”

cat >>confdefs.h <<_ACEOF

define USE_SOLARIS_THREADS 1

_ACEOF

      if test $gl_have_weak = yes; then

cat >>confdefs.h <<_ACEOF

define USE_SOLARIS_THREADS_WEAK 1

_ACEOF

        LIBTHREAD=
        LTLIBTHREAD=
      fi
    fi
  fi
fi
if test "$gl_use_threads" = pth; then
  gl_save_CPPFLAGS="$CPPFLAGS"

{ echo “$as_me:$LINENO: checking how to link with libpth” >&5 echo $ECHO_N “checking how to link with libpth… $ECHO_C” >&6; } if test “${ac_cv_libpth_libs+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

use_additional=yes

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

eval additional_includedir=\"$includedir\"
eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

Check whether –with-libpth-prefix was given.

if test “${with_libpth_prefix+set}” = set; then withval=$with_libpth_prefix; if test “X$withval” = “Xno”; then use_additional=no else if test “X$withval” = “X”; then

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

      eval additional_includedir=\"$includedir\"
      eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  else
    additional_includedir="$withval/include"
    additional_libdir="$withval/$acl_libdirstem"
  fi
fi

fi

  LIBPTH=

LTLIBPTH= INCPTH= LIBPTH_PREFIX= rpathdirs= ltrpathdirs= names_already_handled= names_next_round=‘pth ’ while test -n “$names_next_round”; do names_this_round=“$names_next_round” names_next_round= for name in $names_this_round; do already_handled= for n in $names_already_handled; do if test “$n” = “$name”; then already_handled=yes break fi done if test -z “$already_handled”; then names_already_handled=“$names_already_handled $name” uppername=echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|' eval value=\“\$HAVE_LIB$uppername\” if test -n “$value”; then if test “$value” = yes; then eval value=\“\$LIB$uppername\” test -z “$value” || LIBPTH=“${LIBPTH}${LIBPTH:+ }$value” eval value=\“\$LTLIB$uppername\” test -z “$value” || LTLIBPTH=“${LTLIBPTH}${LTLIBPTH:+ }$value” else : fi else found_dir= found_la= found_so= found_a= eval libname=\“$acl_libname_spec\” # typically: libname=lib$name if test -n “$acl_shlibext”; then shrext=“.$acl_shlibext” # typically: shrext=.so else shrext= fi if test $use_additional = yes; then dir=“$additional_libdir” if test -n “$acl_shlibext”; then if test -f “$dir/$libname$shrext”; then found_dir=“$dir” found_so=“$dir/$libname$shrext” else if test “$acl_library_names_spec” = ‘$libname$shrext$versuffix’; then ver=(cd "$dir" && \ for f in "$libname$shrext".*; do echo "$f"; done \ | sed -e "s,^$libname$shrext\\\\.,," \ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ | sed 1q ) 2>/dev/null if test -n “$ver” && test -f “$dir/$libname$shrext.$ver”; then found_dir=“$dir” found_so=“$dir/$libname$shrext.$ver” fi else eval library_names=\“$acl_library_names_spec\” for f in $library_names; do if test -f “$dir/$f”; then found_dir=“$dir” found_so=“$dir/$f” break fi done fi fi fi if test “X$found_dir” = “X”; then if test -f “$dir/$libname.$acl_libext”; then found_dir=“$dir” found_a=“$dir/$libname.$acl_libext” fi fi if test “X$found_dir” != “X”; then if test -f “$dir/$libname.la”; then found_la=“$dir/$libname.la” fi fi fi if test “X$found_dir” = “X”; then for x in $LDFLAGS $LTLIBPTH; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

          case "$x" in
            -L*)
              dir=`echo "X$x" | sed -e 's/^X-L//'`
                                if test -n "$acl_shlibext"; then
                if test -f "$dir/$libname$shrext"; then
                  found_dir="$dir"
                  found_so="$dir/$libname$shrext"
                else
                  if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
                    ver=`(cd "$dir" && \
                          for f in "$libname$shrext".*; do echo "$f"; done \
                          | sed -e "s,^$libname$shrext\\\\.,," \
                          | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                          | sed 1q ) 2>/dev/null`
                    if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
                      found_dir="$dir"
                      found_so="$dir/$libname$shrext.$ver"
                    fi
                  else
                    eval library_names=\"$acl_library_names_spec\"
                    for f in $library_names; do
                      if test -f "$dir/$f"; then
                        found_dir="$dir"
                        found_so="$dir/$f"
                        break
                      fi
                    done
                  fi
                fi
              fi
                                if test "X$found_dir" = "X"; then
                if test -f "$dir/$libname.$acl_libext"; then
                  found_dir="$dir"
                  found_a="$dir/$libname.$acl_libext"
                fi
              fi
              if test "X$found_dir" != "X"; then
                if test -f "$dir/$libname.la"; then
                  found_la="$dir/$libname.la"
                fi
              fi
              ;;
          esac
          if test "X$found_dir" != "X"; then
            break
          fi
        done
      fi
      if test "X$found_dir" != "X"; then
                    LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-L$found_dir -l$name"
        if test "X$found_so" != "X"; then
                                                    if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
                            LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so"
          else
                                                                            haveit=
            for x in $ltrpathdirs; do
              if test "X$x" = "X$found_dir"; then
                haveit=yes
                break
              fi
            done
            if test -z "$haveit"; then
              ltrpathdirs="$ltrpathdirs $found_dir"
            fi
                            if test "$acl_hardcode_direct" = yes; then
                                                  LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so"
            else
              if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
                                                        LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so"
                                                        haveit=
                for x in $rpathdirs; do
                  if test "X$x" = "X$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  rpathdirs="$rpathdirs $found_dir"
                fi
              else
                                                                            haveit=
                for x in $LDFLAGS $LIBPTH; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                  if test "X$x" = "X-L$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  LIBPTH="${LIBPTH}${LIBPTH:+ }-L$found_dir"
                fi
                if test "$acl_hardcode_minus_L" != no; then
                                                                                    LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so"
                else
                                                                                                                                                                            LIBPTH="${LIBPTH}${LIBPTH:+ }-l$name"
                fi
              fi
            fi
          fi
        else
          if test "X$found_a" != "X"; then
                            LIBPTH="${LIBPTH}${LIBPTH:+ }$found_a"
          else
                                            LIBPTH="${LIBPTH}${LIBPTH:+ }-L$found_dir -l$name"
          fi
        fi
                    additional_includedir=
        case "$found_dir" in
          */$acl_libdirstem | */$acl_libdirstem/)
            basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
            LIBPTH_PREFIX="$basedir"
            additional_includedir="$basedir/include"
            ;;
        esac
        if test "X$additional_includedir" != "X"; then
                                                                                                            if test "X$additional_includedir" != "X/usr/include"; then
            haveit=
            if test "X$additional_includedir" = "X/usr/local/include"; then
              if test -n "$GCC"; then
                case $host_os in
                  linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                esac
              fi
            fi
            if test -z "$haveit"; then
              for x in $CPPFLAGS $INCPTH; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                if test "X$x" = "X-I$additional_includedir"; then
                  haveit=yes
                  break
                fi
              done
              if test -z "$haveit"; then
                if test -d "$additional_includedir"; then
                                        INCPTH="${INCPTH}${INCPTH:+ }-I$additional_includedir"
                fi
              fi
            fi
          fi
        fi
                    if test -n "$found_la"; then
                                                    save_libdir="$libdir"
          case "$found_la" in
            */* | *\\*) . "$found_la" ;;
            *) . "./$found_la" ;;
          esac
          libdir="$save_libdir"
                        for dep in $dependency_libs; do
            case "$dep" in
              -L*)
                additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
                                                                                                                                                            if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
                  haveit=
                  if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
                    if test -n "$GCC"; then
                      case $host_os in
                        linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                      esac
                    fi
                  fi
                  if test -z "$haveit"; then
                    haveit=
                    for x in $LDFLAGS $LIBPTH; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LIBPTH="${LIBPTH}${LIBPTH:+ }-L$additional_libdir"
                      fi
                    fi
                    haveit=
                    for x in $LDFLAGS $LTLIBPTH; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-L$additional_libdir"
                      fi
                    fi
                  fi
                fi
                ;;
              -R*)
                dir=`echo "X$dep" | sed -e 's/^X-R//'`
                if test "$enable_rpath" != no; then
                                                              haveit=
                  for x in $rpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    rpathdirs="$rpathdirs $dir"
                  fi
                                                              haveit=
                  for x in $ltrpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    ltrpathdirs="$ltrpathdirs $dir"
                  fi
                fi
                ;;
              -l*)
                                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
                ;;
              *.la)
                                                                            names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                ;;
              *)
                                    LIBPTH="${LIBPTH}${LIBPTH:+ }$dep"
                LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }$dep"
                ;;
            esac
          done
        fi
      else
                                                        LIBPTH="${LIBPTH}${LIBPTH:+ }-l$name"
        LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-l$name"
      fi
    fi
  fi
done

done if test “X$rpathdirs” != “X”; then if test -n “$acl_hardcode_libdir_separator”; then alldirs= for found_dir in $rpathdirs; do alldirs=“${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir” done acl_save_libdir=“$libdir” libdir=“$alldirs” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBPTH=“${LIBPTH}${LIBPTH:+ }$flag” else for found_dir in $rpathdirs; do acl_save_libdir=“$libdir” libdir=“$found_dir” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBPTH=“${LIBPTH}${LIBPTH:+ }$flag” done fi fi if test “X$ltrpathdirs” != “X”; then for found_dir in $ltrpathdirs; do LTLIBPTH=“${LTLIBPTH}${LTLIBPTH:+ }-R$found_dir” done fi

ac_cv_libpth_libs="$LIBPTH"
ac_cv_libpth_ltlibs="$LTLIBPTH"
ac_cv_libpth_cppflags="$INCPTH"
ac_cv_libpth_prefix="$LIBPTH_PREFIX"

fi { echo “$as_me:$LINENO: result: $ac_cv_libpth_libs” >&5 echo “${ECHO_T}$ac_cv_libpth_libs” >&6; } LIBPTH=“$ac_cv_libpth_libs” LTLIBPTH=“$ac_cv_libpth_ltlibs” INCPTH=“$ac_cv_libpth_cppflags” LIBPTH_PREFIX=“$ac_cv_libpth_prefix”

for element in $INCPTH; do haveit= for x in $CPPFLAGS; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  if test "X$x" = "X$element"; then
    haveit=yes
    break
  fi
done
if test -z "$haveit"; then
  CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
fi

done

  HAVE_LIBPTH=yes



  gl_have_pth=
  gl_save_LIBS="$LIBS"
  LIBS="$LIBS -lpth"
  cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <pth.h>

int main () { pth_self(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gl_have_pth=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gl_save_LIBS” if test -n “$gl_have_pth”; then gl_threads_api=pth LIBTHREAD=“$LIBPTH” LTLIBTHREAD=“$LTLIBPTH” LIBMULTITHREAD=“$LIBTHREAD” LTLIBMULTITHREAD=“$LTLIBTHREAD”

cat >>confdefs.h <<_ACEOF

define USE_PTH_THREADS 1

_ACEOF

    if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
      if test $gl_have_weak = yes; then

cat >>confdefs.h <<_ACEOF

define USE_PTH_THREADS_WEAK 1

_ACEOF

        LIBTHREAD=
        LTLIBTHREAD=
      fi
    fi
  else
    CPPFLAGS="$gl_save_CPPFLAGS"
  fi
fi
if test -z "$gl_have_pthread"; then
  if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
    if { case "$host_os" in
           mingw*) true;;
           *) false;;
         esac
       }; then
      gl_threads_api=win32

cat >>confdefs.h <<_ACEOF

define USE_WIN32_THREADS 1

_ACEOF

    fi
  fi
fi

fi { echo “$as_me:$LINENO: checking for multithread API to use” >&5 echo $ECHO_N “checking for multithread API to use… $ECHO_C” >&6; } { echo “$as_me:$LINENO: result: $gl_threads_api” >&5 echo “${ECHO_T}$gl_threads_api” >&6; }

use_additional=yes

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

eval additional_includedir=\"$includedir\"
eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

Check whether –with-libiconv-prefix was given.

if test “${with_libiconv_prefix+set}” = set; then withval=$with_libiconv_prefix; if test “X$withval” = “Xno”; then use_additional=no else if test “X$withval” = “X”; then

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

      eval additional_includedir=\"$includedir\"
      eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  else
    additional_includedir="$withval/include"
    additional_libdir="$withval/$acl_libdirstem"
  fi
fi

fi

  LIBICONV=

LTLIBICONV= INCICONV= LIBICONV_PREFIX= rpathdirs= ltrpathdirs= names_already_handled= names_next_round=‘iconv ’ while test -n “$names_next_round”; do names_this_round=“$names_next_round” names_next_round= for name in $names_this_round; do already_handled= for n in $names_already_handled; do if test “$n” = “$name”; then already_handled=yes break fi done if test -z “$already_handled”; then names_already_handled=“$names_already_handled $name” uppername=echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|' eval value=\“\$HAVE_LIB$uppername\” if test -n “$value”; then if test “$value” = yes; then eval value=\“\$LIB$uppername\” test -z “$value” || LIBICONV=“${LIBICONV}${LIBICONV:+ }$value” eval value=\“\$LTLIB$uppername\” test -z “$value” || LTLIBICONV=“${LTLIBICONV}${LTLIBICONV:+ }$value” else : fi else found_dir= found_la= found_so= found_a= eval libname=\“$acl_libname_spec\” # typically: libname=lib$name if test -n “$acl_shlibext”; then shrext=“.$acl_shlibext” # typically: shrext=.so else shrext= fi if test $use_additional = yes; then dir=“$additional_libdir” if test -n “$acl_shlibext”; then if test -f “$dir/$libname$shrext”; then found_dir=“$dir” found_so=“$dir/$libname$shrext” else if test “$acl_library_names_spec” = ‘$libname$shrext$versuffix’; then ver=(cd "$dir" && \ for f in "$libname$shrext".*; do echo "$f"; done \ | sed -e "s,^$libname$shrext\\\\.,," \ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ | sed 1q ) 2>/dev/null if test -n “$ver” && test -f “$dir/$libname$shrext.$ver”; then found_dir=“$dir” found_so=“$dir/$libname$shrext.$ver” fi else eval library_names=\“$acl_library_names_spec\” for f in $library_names; do if test -f “$dir/$f”; then found_dir=“$dir” found_so=“$dir/$f” break fi done fi fi fi if test “X$found_dir” = “X”; then if test -f “$dir/$libname.$acl_libext”; then found_dir=“$dir” found_a=“$dir/$libname.$acl_libext” fi fi if test “X$found_dir” != “X”; then if test -f “$dir/$libname.la”; then found_la=“$dir/$libname.la” fi fi fi if test “X$found_dir” = “X”; then for x in $LDFLAGS $LTLIBICONV; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

          case "$x" in
            -L*)
              dir=`echo "X$x" | sed -e 's/^X-L//'`
                                if test -n "$acl_shlibext"; then
                if test -f "$dir/$libname$shrext"; then
                  found_dir="$dir"
                  found_so="$dir/$libname$shrext"
                else
                  if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
                    ver=`(cd "$dir" && \
                          for f in "$libname$shrext".*; do echo "$f"; done \
                          | sed -e "s,^$libname$shrext\\\\.,," \
                          | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                          | sed 1q ) 2>/dev/null`
                    if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
                      found_dir="$dir"
                      found_so="$dir/$libname$shrext.$ver"
                    fi
                  else
                    eval library_names=\"$acl_library_names_spec\"
                    for f in $library_names; do
                      if test -f "$dir/$f"; then
                        found_dir="$dir"
                        found_so="$dir/$f"
                        break
                      fi
                    done
                  fi
                fi
              fi
                                if test "X$found_dir" = "X"; then
                if test -f "$dir/$libname.$acl_libext"; then
                  found_dir="$dir"
                  found_a="$dir/$libname.$acl_libext"
                fi
              fi
              if test "X$found_dir" != "X"; then
                if test -f "$dir/$libname.la"; then
                  found_la="$dir/$libname.la"
                fi
              fi
              ;;
          esac
          if test "X$found_dir" != "X"; then
            break
          fi
        done
      fi
      if test "X$found_dir" != "X"; then
                    LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-L$found_dir -l$name"
        if test "X$found_so" != "X"; then
                                                    if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
                            LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"
          else
                                                                            haveit=
            for x in $ltrpathdirs; do
              if test "X$x" = "X$found_dir"; then
                haveit=yes
                break
              fi
            done
            if test -z "$haveit"; then
              ltrpathdirs="$ltrpathdirs $found_dir"
            fi
                            if test "$acl_hardcode_direct" = yes; then
                                                  LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"
            else
              if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
                                                        LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"
                                                        haveit=
                for x in $rpathdirs; do
                  if test "X$x" = "X$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  rpathdirs="$rpathdirs $found_dir"
                fi
              else
                                                                            haveit=
                for x in $LDFLAGS $LIBICONV; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                  if test "X$x" = "X-L$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  LIBICONV="${LIBICONV}${LIBICONV:+ }-L$found_dir"
                fi
                if test "$acl_hardcode_minus_L" != no; then
                                                                                    LIBICONV="${LIBICONV}${LIBICONV:+ }$found_so"
                else
                                                                                                                                                                            LIBICONV="${LIBICONV}${LIBICONV:+ }-l$name"
                fi
              fi
            fi
          fi
        else
          if test "X$found_a" != "X"; then
                            LIBICONV="${LIBICONV}${LIBICONV:+ }$found_a"
          else
                                            LIBICONV="${LIBICONV}${LIBICONV:+ }-L$found_dir -l$name"
          fi
        fi
                    additional_includedir=
        case "$found_dir" in
          */$acl_libdirstem | */$acl_libdirstem/)
            basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
            LIBICONV_PREFIX="$basedir"
            additional_includedir="$basedir/include"
            ;;
        esac
        if test "X$additional_includedir" != "X"; then
                                                                                                            if test "X$additional_includedir" != "X/usr/include"; then
            haveit=
            if test "X$additional_includedir" = "X/usr/local/include"; then
              if test -n "$GCC"; then
                case $host_os in
                  linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                esac
              fi
            fi
            if test -z "$haveit"; then
              for x in $CPPFLAGS $INCICONV; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                if test "X$x" = "X-I$additional_includedir"; then
                  haveit=yes
                  break
                fi
              done
              if test -z "$haveit"; then
                if test -d "$additional_includedir"; then
                                        INCICONV="${INCICONV}${INCICONV:+ }-I$additional_includedir"
                fi
              fi
            fi
          fi
        fi
                    if test -n "$found_la"; then
                                                    save_libdir="$libdir"
          case "$found_la" in
            */* | *\\*) . "$found_la" ;;
            *) . "./$found_la" ;;
          esac
          libdir="$save_libdir"
                        for dep in $dependency_libs; do
            case "$dep" in
              -L*)
                additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
                                                                                                                                                            if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
                  haveit=
                  if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
                    if test -n "$GCC"; then
                      case $host_os in
                        linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                      esac
                    fi
                  fi
                  if test -z "$haveit"; then
                    haveit=
                    for x in $LDFLAGS $LIBICONV; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LIBICONV="${LIBICONV}${LIBICONV:+ }-L$additional_libdir"
                      fi
                    fi
                    haveit=
                    for x in $LDFLAGS $LTLIBICONV; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-L$additional_libdir"
                      fi
                    fi
                  fi
                fi
                ;;
              -R*)
                dir=`echo "X$dep" | sed -e 's/^X-R//'`
                if test "$enable_rpath" != no; then
                                                              haveit=
                  for x in $rpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    rpathdirs="$rpathdirs $dir"
                  fi
                                                              haveit=
                  for x in $ltrpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    ltrpathdirs="$ltrpathdirs $dir"
                  fi
                fi
                ;;
              -l*)
                                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
                ;;
              *.la)
                                                                            names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                ;;
              *)
                                    LIBICONV="${LIBICONV}${LIBICONV:+ }$dep"
                LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }$dep"
                ;;
            esac
          done
        fi
      else
                                                        LIBICONV="${LIBICONV}${LIBICONV:+ }-l$name"
        LTLIBICONV="${LTLIBICONV}${LTLIBICONV:+ }-l$name"
      fi
    fi
  fi
done

done if test “X$rpathdirs” != “X”; then if test -n “$acl_hardcode_libdir_separator”; then alldirs= for found_dir in $rpathdirs; do alldirs=“${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir” done acl_save_libdir=“$libdir” libdir=“$alldirs” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBICONV=“${LIBICONV}${LIBICONV:+ }$flag” else for found_dir in $rpathdirs; do acl_save_libdir=“$libdir” libdir=“$found_dir” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBICONV=“${LIBICONV}${LIBICONV:+ }$flag” done fi fi if test “X$ltrpathdirs” != “X”; then for found_dir in $ltrpathdirs; do LTLIBICONV=“${LTLIBICONV}${LTLIBICONV:+ }-R$found_dir” done fi

cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / int foo (int a) { a = __builtin_expect (a, 10); return a == 10 ? 0 : 1; } int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then

cat >>confdefs.h <<_ACEOF

define HAVE_BUILTIN_EXPECT 1

_ACEOF

else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

for ac_header in argz.h inttypes.h limits.h unistd.h sys/param.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_func in getcwd getegid geteuid getgid getuid mempcpy munmap \ stpcpy strcasecmp strdup strtoul tsearch argz_count argz_stringify \ argz_next fsetlocking do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

{ echo “$as_me:$LINENO: checking whether feof_unlocked is declared” >&5 echo $ECHO_N “checking whether feof_unlocked is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_feof_unlocked+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

int main () {

ifndef feof_unlocked

char p = (char ) feof_unlocked;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_feof_unlocked=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_feof_unlocked=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_feof_unlocked” >&5 echo “${ECHO_T}$ac_cv_have_decl_feof_unlocked” >&6; } if test $ac_cv_have_decl_feof_unlocked = yes; then gt_value=1 else gt_value=0 fi

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_FEOF_UNLOCKED $gt_value

_ACEOF

{ echo “$as_me:$LINENO: checking whether fgets_unlocked is declared” >&5 echo $ECHO_N “checking whether fgets_unlocked is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_fgets_unlocked+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

int main () {

ifndef fgets_unlocked

char p = (char ) fgets_unlocked;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_fgets_unlocked=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_fgets_unlocked=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_fgets_unlocked” >&5 echo “${ECHO_T}$ac_cv_have_decl_fgets_unlocked” >&6; } if test $ac_cv_have_decl_fgets_unlocked = yes; then gt_value=1 else gt_value=0 fi

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_FGETS_UNLOCKED $gt_value

_ACEOF

      am_save_CPPFLAGS="$CPPFLAGS"

for element in $INCICONV; do haveit= for x in $CPPFLAGS; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  if test "X$x" = "X$element"; then
    haveit=yes
    break
  fi
done
if test -z "$haveit"; then
  CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
fi

done

{ echo “$as_me:$LINENO: checking for iconv” >&5 echo $ECHO_N “checking for iconv… $ECHO_C” >&6; } if test “${am_cv_func_iconv+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

am_cv_func_iconv="no, consider installing GNU libiconv"
am_cv_lib_iconv=no
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stdlib.h>

include <iconv.h>

int main () { iconv_t cd = iconv_open(“”,“”); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then am_cv_func_iconv=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext if test “$am_cv_func_iconv” != yes; then am_save_LIBS=“$LIBS” LIBS=“$LIBS $LIBICONV” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdlib.h>

include <iconv.h>

int main () { iconv_t cd = iconv_open(“”,“”); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then am_cv_lib_iconv=yes am_cv_func_iconv=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$am_save_LIBS” fi

fi { echo “$as_me:$LINENO: result: $am_cv_func_iconv” >&5 echo “${ECHO_T}$am_cv_func_iconv” >&6; } if test “$am_cv_func_iconv” = yes; then { echo “$as_me:$LINENO: checking for working iconv” >&5 echo $ECHO_N “checking for working iconv… $ECHO_C” >&6; } if test “${am_cv_func_iconv_works+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

        am_save_LIBS="$LIBS"
  if test $am_cv_lib_iconv = yes; then
    LIBS="$LIBS $LIBICONV"
  fi
  if test "$cross_compiling" = yes; then

case “$host_os” in aix | hpux) am_cv_func_iconv_works=“guessing no” ;; ) am_cv_func_iconv_works=“guessing yes” ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <iconv.h>

include <string.h>

int main () { / Test against AIX 5.1 bug: Failures are not distinguishable from successful returns. / { iconv_t cd_utf8_to_88591 = iconv_open (“ISO8859-1”, “UTF-8”); if (cd_utf8_to_88591 != (iconv_t)(-1)) { static const char input[] = “\342\202\254”; / EURO SIGN / char buf[10]; const char inptr = input; size_t inbytesleft = strlen (input); char outptr = buf; size_t outbytesleft = sizeof (buf); size_t res = iconv (cd_utf8_to_88591, (char **) &inptr, &inbytesleft, &outptr, &outbytesleft); if (res == 0) return 1; } }

if 0 / This bug could be worked around by the caller. /

/ Test against HP-UX 11.11 bug: Positive return value instead of 0. / { iconv_t cd_88591_to_utf8 = iconv_open (“utf8”, “iso88591”); if (cd_88591_to_utf8 != (iconv_t)(-1)) { static const char input[] = “\304rger mit b\366sen B\374bchen ohne Augenma\337”; char buf[50]; const char inptr = input; size_t inbytesleft = strlen (input); char outptr = buf; size_t outbytesleft = sizeof (buf); size_t res = iconv (cd_88591_to_utf8, (char **) &inptr, &inbytesleft, &outptr, &outbytesleft); if ((int)res > 0) return 1; } }

endif

/ Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is provided. / if (/ Try standardized names. / iconv_open (“UTF-8”, “EUC-JP”) == (iconv_t)(-1) / Try IRIX, OSF/1 names. / && iconv_open (“UTF-8”, “eucJP”) == (iconv_t)(-1) / Try AIX names. / && iconv_open (“UTF-8”, “IBM-eucJP”) == (iconv_t)(-1) / Try HP-UX names. / && iconv_open (“utf8”, “eucJP”) == (iconv_t)(-1)) return 1; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then am_cv_func_iconv_works=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) am_cv_func_iconv_works=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

  LIBS="$am_save_LIBS"

fi { echo “$as_me:$LINENO: result: $am_cv_func_iconv_works” >&5 echo “${ECHO_T}$am_cv_func_iconv_works” >&6; } case “$am_cv_func_iconv_works” in no) am_func_iconv=no am_cv_lib_iconv=no ;; ) am_func_iconv=yes ;; esac else am_func_iconv=no am_cv_lib_iconv=no fi if test “$am_func_iconv” = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_ICONV 1

_ACEOF

fi if test “$am_cv_lib_iconv” = yes; then { echo “$as_me:$LINENO: checking how to link with libiconv” >&5 echo $ECHO_N “checking how to link with libiconv… $ECHO_C” >&6; } { echo “$as_me:$LINENO: result: $LIBICONV” >&5 echo “${ECHO_T}$LIBICONV” >&6; } else CPPFLAGS=“$am_save_CPPFLAGS” LIBICONV= LTLIBICONV= fi

if test “$am_cv_func_iconv” = yes; then { echo “$as_me:$LINENO: checking for iconv declaration” >&5 echo $ECHO_N “checking for iconv declaration… $ECHO_C” >&6; } if test “${am_cv_proto_iconv+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

  cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stdlib.h>

include <iconv.h>

extern

ifdef __cplusplus

“C”

endif

if defined(STDC) || defined(__cplusplus)

size_t iconv (iconv_t cd, char * inbuf, size_t inbytesleft, char * outbuf, size_t outbytesleft);

else

size_t iconv();

endif

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then am_cv_proto_iconv_arg1=“” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

am_cv_proto_iconv_arg1="const"

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext am_cv_proto_iconv=“extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * inbuf, size_t inbytesleft, char * outbuf, size_t outbytesleft);” fi

am_cv_proto_iconv=`echo "$am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
{ echo "$as_me:$LINENO: result: ${ac_t:-
     }$am_cv_proto_iconv" >&5

echo “${ECHO_T}${ac_t:- }$am_cv_proto_iconv” >&6; }

cat >>confdefs.h <<_ACEOF

define ICONV_CONST $am_cv_proto_iconv_arg1

_ACEOF

fi

  { echo "$as_me:$LINENO: checking for NL_LOCALE_NAME macro" >&5

echo $ECHO_N “checking for NL_LOCALE_NAME macro… $ECHO_C” >&6; } if test “${gt_cv_nl_locale_name+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <langinfo.h>

include <locale.h>

int main () { char* cs = nl_langinfo(_NL_LOCALE_NAME(LC_MESSAGES)); return !cs;

; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_nl_locale_name=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_nl_locale_name=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

fi { echo “$as_me:$LINENO: result: $gt_cv_nl_locale_name” >&5 echo “${ECHO_T}$gt_cv_nl_locale_name” >&6; } if test $gt_cv_nl_locale_name = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_NL_LOCALE_NAME 1

_ACEOF

fi

                  for ac_prog in bison

do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_INTLBISON+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$INTLBISON”; then ac_cv_prog_INTLBISON=“$INTLBISON” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_INTLBISON=“$ac_prog” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi INTLBISON=$ac_cv_prog_INTLBISON if test -n “$INTLBISON”; then { echo “$as_me:$LINENO: result: $INTLBISON” >&5 echo “${ECHO_T}$INTLBISON” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

test -n “$INTLBISON” && break done

if test -z “$INTLBISON”; then ac_verc_fail=yes else { echo “$as_me:$LINENO: checking version of bison” >&5 echo $ECHO_N “checking version of bison… $ECHO_C” >&6; } ac_prog_version=$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p' case $ac_prog_version in ‘’) ac_prog_version=“v. ?.??, bad”; ac_verc_fail=yes;; 1.2[6-9] | 1.[3-9][0-9] | [2-9].) ac_prog_version=“$ac_prog_version, ok”; ac_verc_fail=no;; ) ac_prog_version=“$ac_prog_version, bad”; ac_verc_fail=yes;; esac { echo “$as_me:$LINENO: result: $ac_prog_version” >&5 echo “${ECHO_T}$ac_prog_version” >&6; } fi if test $ac_verc_fail = yes; then INTLBISON=: fi

{ echo “$as_me:$LINENO: checking for long long int” >&5 echo $ECHO_N “checking for long long int… $ECHO_C” >&6; } if test “${ac_cv_type_long_long_int+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / / Test preprocessor. / #if ! (-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) error in preprocessor; #endif #if ! (18446744073709551615ULL <= -1ull) error in preprocessor; #endif / Test literals. / long long int ll = 9223372036854775807ll; long long int nll = -9223372036854775807LL; unsigned long long int ull = 18446744073709551615ULL; / Test constant expressions. / typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) ? 1 : -1)]; typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 ? 1 : -1)]; int i = 63; int main () { / Test availability of runtime routines for shift and division. / long long int llmax = 9223372036854775807ll; unsigned long long int ullmax = 18446744073709551615ull; return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) | (llmax / ll) | (llmax % ll) | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) | (ullmax / ull) | (ullmax % ull)); ; return 0; }

ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then if test “$cross_compiling” = yes; then ac_cv_type_long_long_int=yes else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <limits.h>

       #ifndef LLONG_MAX
       # define HALF \
        (1LL << (sizeof (long long int) * CHAR_BIT - 2))
       # define LLONG_MAX (HALF - 1 + HALF)
       #endif

int main () { long long int n = 1; int i; for (i = 0; ; i++) { long long int m = n << i; if (m >> i != n) return 1; if (LLONG_MAX / 2 < m) break; } return 0; ; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then ac_cv_type_long_long_int=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) ac_cv_type_long_long_int=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_long_long_int=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_long_long_int” >&5 echo “${ECHO_T}$ac_cv_type_long_long_int” >&6; } if test $ac_cv_type_long_long_int = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_LONG_LONG_INT 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for wchar_t” >&5 echo $ECHO_N “checking for wchar_t… $ECHO_C” >&6; } if test “${gt_cv_c_wchar_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

   wchar_t foo = (wchar_t)'\0';

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gt_cv_c_wchar_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_c_wchar_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gt_cv_c_wchar_t” >&5 echo “${ECHO_T}$gt_cv_c_wchar_t” >&6; } if test $gt_cv_c_wchar_t = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_WCHAR_T 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for wint_t” >&5 echo $ECHO_N “checking for wint_t… $ECHO_C” >&6; } if test “${gt_cv_c_wint_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

/ Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before <wchar.h>. BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be included before <wchar.h>. /

include <stddef.h>

include <stdio.h>

include <time.h>

include <wchar.h>

   wint_t foo = (wchar_t)'\0';

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gt_cv_c_wint_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_c_wint_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gt_cv_c_wint_t” >&5 echo “${ECHO_T}$gt_cv_c_wint_t” >&6; } if test $gt_cv_c_wint_t = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_WINT_T 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for intmax_t” >&5 echo $ECHO_N “checking for intmax_t… $ECHO_C” >&6; } if test “${gt_cv_c_intmax_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

include <stdlib.h>

if HAVE_STDINT_H_WITH_UINTMAX

include <stdint.h>

endif

if HAVE_INTTYPES_H_WITH_UINTMAX

include <inttypes.h>

endif

int main () { intmax_t x = -1; return !x; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then gt_cv_c_intmax_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_c_intmax_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gt_cv_c_intmax_t” >&5 echo “${ECHO_T}$gt_cv_c_intmax_t” >&6; } if test $gt_cv_c_intmax_t = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_INTMAX_T 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking whether printf() supports POSIX/XSI format strings” >&5 echo $ECHO_N “checking whether printf() supports POSIX/XSI format strings… $ECHO_C” >&6; } if test “${gt_cv_func_printf_posix+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

  if test "$cross_compiling" = yes; then

    cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

if defined NetBSD || defined BEOS || defined _MSC_VER || defined MINGW32 || defined CYGWIN

notposix

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “notposix” >/dev/null 2>&1; then gt_cv_func_printf_posix=“guessing no” else gt_cv_func_printf_posix=“guessing yes” fi rm -f conftest*

else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

include <string.h>

/ The string “%2$d %1$d”, with dollar characters protected from the shell’s dollar expansion (possibly an autoconf bug). / static char format[] = { ‘%’, ‘2’, ‘$’, ’d', ‘ ’, ‘%’, ‘1’, ‘$’, ’d', ‘\0’ }; static char buf[100]; int main () { sprintf (buf, format, 33, 55); return (strcmp (buf, “55 33”) != 0); } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then gt_cv_func_printf_posix=yes else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) gt_cv_func_printf_posix=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

fi { echo “$as_me:$LINENO: result: $gt_cv_func_printf_posix” >&5 echo “${ECHO_T}$gt_cv_func_printf_posix” >&6; } case $gt_cv_func_printf_posix in *yes)

cat >>confdefs.h <<_ACEOF

define HAVE_POSIX_PRINTF 1

_ACEOF

  ;;

esac

{ echo "$as_me:$LINENO: checking whether we are using the GNU C Library 2.1 or newer" >&5

echo $ECHO_N “checking whether we are using the GNU C Library 2.1 or newer… $ECHO_C” >&6; } if test “${ac_cv_gnu_library_2_1+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <features.h>

ifdef GNU_LIBRARY

#if (GLIBC == 2 && GLIBC_MINOR >= 1) || (GLIBC > 2) Lucky GNU user #endif

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “Lucky GNU user” >/dev/null 2>&1; then ac_cv_gnu_library_2_1=yes else ac_cv_gnu_library_2_1=no fi rm -f conftest*

fi { echo “$as_me:$LINENO: result: $ac_cv_gnu_library_2_1” >&5 echo “${ECHO_T}$ac_cv_gnu_library_2_1” >&6; }

GLIBC21="$ac_cv_gnu_library_2_1"

for ac_header in stdint.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo "$as_me:$LINENO: checking for SIZE_MAX" >&5

echo $ECHO_N “checking for SIZE_MAX… $ECHO_C” >&6; } if test “${gl_cv_size_max+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else

gl_cv_size_max=
cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <limits.h>

if HAVE_STDINT_H

include <stdint.h>

endif

ifdef SIZE_MAX

Found it

endif

_ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “Found it” >/dev/null 2>&1; then gl_cv_size_max=yes fi rm -f conftest*

if test -z "$gl_cv_size_max"; then
                    if test "$cross_compiling" = yes; then

# Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

include <limits.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

include <limits.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

include <limits.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

include <limits.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

include <limits.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) size_t_bits_minus_1=$ac_lo;; ‘’) size_t_bits_minus_1= ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <stddef.h>

include <limits.h>

static long int longval () { return sizeof (size_t) * CHAR_BIT - 1; } static unsigned long int ulongval () { return sizeof (size_t) * CHAR_BIT - 1; }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if ((sizeof (size_t) * CHAR_BIT - 1) < 0) { long int i = longval (); if (i != (sizeof (size_t) * CHAR_BIT - 1)) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != (sizeof (size_t) * CHAR_BIT - 1)) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then size_t_bits_minus_1=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) size_t_bits_minus_1= fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val if test “$cross_compiling” = yes; then # Depending upon the size, compute the lo and hi bounds. cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) >= 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=0 ac_mid=0 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr $ac_mid + 1`
        if test $ac_lo -le $ac_mid; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >conftest.$ac_ext <<_ACEOF

/ confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) < 0)]; test_array [0] = 0

; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=-1 ac_mid=-1 while :; do cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. /

include <stddef.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) >= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_lo=$ac_mid; break else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_hi=`expr '(' $ac_mid ')' - 1`
        if test $ac_mid -le $ac_hi; then
          ac_lo= ac_hi=
          break
        fi
        ac_mid=`expr 2 '*' $ac_mid`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo= ac_hi=

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

Binary search between lo and hi bounds.

while test “x$ac_lo” != “x$ac_hi”; do ac_mid=expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

int main () { static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) <= $ac_mid)]; test_array [0] = 0

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_hi=$ac_mid else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_lo=`expr '(' $ac_mid ')' + 1`

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in ?) fits_in_uint=$ac_lo;; ‘’) fits_in_uint= ;; esac else cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <stddef.h>

static long int longval () { return sizeof (size_t) <= sizeof (unsigned int); } static unsigned long int ulongval () { return sizeof (size_t) <= sizeof (unsigned int); }

include <stdio.h>

include <stdlib.h>

int main () {

FILE *f = fopen (“conftest.val”, “w”); if (! f) return 1; if ((sizeof (size_t) <= sizeof (unsigned int)) < 0) { long int i = longval (); if (i != (sizeof (size_t) <= sizeof (unsigned int))) return 1; fprintf (f, “%ld\n”, i); } else { unsigned long int i = ulongval (); if (i != (sizeof (size_t) <= sizeof (unsigned int))) return 1; fprintf (f, “%lu\n”, i); } return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF rm -f conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { ac_try=‘./conftest$ac_exeext’ { (case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_try”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; }; then fits_in_uint=cat conftest.val else echo “$as_me: program exited with status $ac_status” >&5 echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

( exit $ac_status ) fits_in_uint= fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f conftest.val if test -n “$size_t_bits_minus_1” && test -n “$fits_in_uint”; then if test $fits_in_uint = 1; then cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stddef.h>

        extern size_t foo;
        extern unsigned long foo;

int main () {

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then fits_in_uint=0 else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi if test $fits_in_uint = 1; then gl_cv_size_max=“(((1U << $size_t_bits_minus_1) - 1) * 2 + 1)” else gl_cv_size_max=“(((1UL << $size_t_bits_minus_1) - 1) * 2 + 1)” fi else gl_cv_size_max=‘((size_t)~(size_t)0)’ fi fi

fi

{ echo “$as_me:$LINENO: result: $gl_cv_size_max” >&5 echo “${ECHO_T}$gl_cv_size_max” >&6; } if test “$gl_cv_size_max” != yes; then

cat >>confdefs.h <<_ACEOF

define SIZE_MAX $gl_cv_size_max

_ACEOF

fi

for ac_header in stdint.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

{ echo "$as_me:$LINENO: checking for CFPreferencesCopyAppValue" >&5

echo $ECHO_N “checking for CFPreferencesCopyAppValue… $ECHO_C” >&6; } if test “${gt_cv_func_CFPreferencesCopyAppValue+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else gt_save_LIBS=“$LIBS” LIBS=“$LIBS -Wl,-framework -Wl,CoreFoundation” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <CoreFoundation/CFPreferences.h>

int main () { CFPreferencesCopyAppValue(NULL, NULL) ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_func_CFPreferencesCopyAppValue=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_func_CFPreferencesCopyAppValue=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gt_save_LIBS” fi { echo “$as_me:$LINENO: result: $gt_cv_func_CFPreferencesCopyAppValue” >&5 echo “${ECHO_T}$gt_cv_func_CFPreferencesCopyAppValue” >&6; } if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_CFPREFERENCESCOPYAPPVALUE 1

_ACEOF

fi { echo “$as_me:$LINENO: checking for CFLocaleCopyCurrent” >&5 echo $ECHO_N “checking for CFLocaleCopyCurrent… $ECHO_C” >&6; } if test “${gt_cv_func_CFLocaleCopyCurrent+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else gt_save_LIBS=“$LIBS” LIBS=“$LIBS -Wl,-framework -Wl,CoreFoundation” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <CoreFoundation/CFLocale.h>

int main () { CFLocaleCopyCurrent(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_func_CFLocaleCopyCurrent=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_func_CFLocaleCopyCurrent=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gt_save_LIBS” fi { echo “$as_me:$LINENO: result: $gt_cv_func_CFLocaleCopyCurrent” >&5 echo “${ECHO_T}$gt_cv_func_CFLocaleCopyCurrent” >&6; } if test $gt_cv_func_CFLocaleCopyCurrent = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_CFLOCALECOPYCURRENT 1

_ACEOF

fi INTL_MACOSX_LIBS= if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then INTL_MACOSX_LIBS=“-Wl,-framework -Wl,CoreFoundation” fi

{ echo “$as_me:$LINENO: checking for ptrdiff_t” >&5 echo $ECHO_N “checking for ptrdiff_t… $ECHO_C” >&6; } if test “${ac_cv_type_ptrdiff_t+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. / $ac_includes_default typedef ptrdiff_t ac__type_new; int main () { if ((actype_new_ *) 0) return 0; if (sizeof (actype_new)) return 0; ; return 0; } ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_type_ptrdiff_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_ptrdiff_t=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_type_ptrdiff_t” >&5 echo “${ECHO_T}$ac_cv_type_ptrdiff_t” >&6; } if test $ac_cv_type_ptrdiff_t = yes; then : else

cat >>confdefs.h <<_ACEOF

define ptrdiff_t long

_ACEOF

fi

for ac_header in stddef.h stdlib.h string.h do as_ac_Header=echo "ac_cv_header_$ac_header" | $as_tr_sh if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } else # Is the header compilable? { echo “$as_me:$LINENO: checking $ac_header usability” >&5 echo $ECHO_N “checking $ac_header usability… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / $ac_includes_default

include <$ac_header>

_ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_header_compiler=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_compiler=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_compiler” >&5 echo “${ECHO_T}$ac_header_compiler” >&6; }

Is the header present?

{ echo “$as_me:$LINENO: checking $ac_header presence” >&5 echo $ECHO_N “checking $ac_header presence… $ECHO_C” >&6; } cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <$ac_header>

_ACEOF if { (ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } >/dev/null && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then ac_header_preproc=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_header_preproc=no fi

rm -f conftest.err conftest.$ac_ext { echo “$as_me:$LINENO: result: $ac_header_preproc” >&5 echo “${ECHO_T}$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in yes:no: ) { echo “$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&5 echo “$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler’s result” >&5 echo “$as_me: WARNING: $ac_header: proceeding with the compiler’s result” >&2;} ac_header_preproc=yes ;; no:yes:* ) { echo “$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled” >&5 echo “$as_me: WARNING: $ac_header: present but cannot be compiled” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?” >&5 echo “$as_me: WARNING: $ac_header: check for missing prerequisite headers?” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation” >&5 echo “$as_me: WARNING: $ac_header: see the Autoconf documentation” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\”“ >&5 echo ”$as_me: WARNING: $ac_header: section \“Present But Cannot Be Compiled\”“ >&2;} { echo ”$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor’s result" >&5 echo “$as_me: WARNING: $ac_header: proceeding with the preprocessor’s result” >&2;} { echo “$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence” >&5 echo “$as_me: WARNING: $ac_header: in the future, the compiler will take precedence” >&2;} ( cat <<_ASBOX

——————————–

Report this to sitecopy@lyra.org

——————————–

_ASBOX ) | sed “s/^/$as_me: WARNING: /” >&2 ;; esac { echo “$as_me:$LINENO: checking for $ac_header” >&5 echo $ECHO_N “checking for $ac_header… $ECHO_C” >&6; } if { as_var=$as_ac_Header; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else eval “$as_ac_Header=\$ac_header_preproc” fi ac_res=eval echo '${'$as_ac_Header'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

fi if test eval echo '${'$as_ac_Header'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_func in asprintf fwprintf putenv setenv setlocale snprintf wcslen do as_ac_var=echo "ac_cv_func_$ac_func" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_func” >&5 echo $ECHO_N “checking for $ac_func… $ECHO_C” >&6; } if { as_var=$as_ac_var; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. / / Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $ac_func innocuous_$ac_func

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. Prefer <limits.h> to <assert.h> if STDC__ is defined, since <limits.h> exists even on freestanding compilers. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

undef $ac_func

/ Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. /

ifdef __cplusplus

extern “C”

endif

char $ac_func (); / The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. /

if defined stub_$ac_func || defined stub___$ac_func

choke me

endif

int main () { return $ac_func (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$as_ac_var=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$as_ac_var=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$as_ac_var'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } if test eval echo '${'$as_ac_var'}' = yes; then cat >>confdefs.h <<_ACEOF

define echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

{ echo “$as_me:$LINENO: checking whether snprintf is declared” >&5 echo $ECHO_N “checking whether snprintf is declared… $ECHO_C” >&6; } if test “${ac_cv_have_declsnprintf+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

int main () {

ifndef _snprintf

char p = (char ) _snprintf;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl__snprintf=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl__snprintf=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_declsnprintf” >&5 echo “${ECHO_T}$ac_cv_have_declsnprintf” >&6; } if test $ac_cv_have_decl__snprintf = yes; then gt_value=1 else gt_value=0 fi

cat >>confdefs.h <<_ACEOF

define HAVE_DECL__SNPRINTF $gt_value

_ACEOF

{ echo “$as_me:$LINENO: checking whether snwprintf is declared” >&5 echo $ECHO_N “checking whether snwprintf is declared… $ECHO_C” >&6; } if test “${ac_cv_have_declsnwprintf+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

int main () {

ifndef _snwprintf

char p = (char ) _snwprintf;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl__snwprintf=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl__snwprintf=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_declsnwprintf” >&5 echo “${ECHO_T}$ac_cv_have_declsnwprintf” >&6; } if test $ac_cv_have_decl__snwprintf = yes; then gt_value=1 else gt_value=0 fi

cat >>confdefs.h <<_ACEOF

define HAVE_DECL__SNWPRINTF $gt_value

_ACEOF

{ echo “$as_me:$LINENO: checking whether getc_unlocked is declared” >&5 echo $ECHO_N “checking whether getc_unlocked is declared… $ECHO_C” >&6; } if test “${ac_cv_have_decl_getc_unlocked+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <stdio.h>

int main () {

ifndef getc_unlocked

char p = (char ) getc_unlocked;

endif

; return 0; } _ACEOF rm -f conftest.$ac_objext if { (ac_try=“$ac_compile” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_compile”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then ac_cv_have_decl_getc_unlocked=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_have_decl_getc_unlocked=no

fi

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $ac_cv_have_decl_getc_unlocked” >&5 echo “${ECHO_T}$ac_cv_have_decl_getc_unlocked” >&6; } if test $ac_cv_have_decl_getc_unlocked = yes; then gt_value=1 else gt_value=0 fi

cat >>confdefs.h <<_ACEOF

define HAVE_DECL_GETC_UNLOCKED $gt_value

_ACEOF

case $gt_cv_func_printf_posix in yes) HAVE_POSIX_PRINTF=1 ;; ) HAVE_POSIX_PRINTF=0 ;; esac

if test “$ac_cv_func_asprintf” = yes; then HAVE_ASPRINTF=1 else HAVE_ASPRINTF=0 fi

if test “$ac_cv_func_snprintf” = yes; then HAVE_SNPRINTF=1 else HAVE_SNPRINTF=0 fi

if test “$ac_cv_func_wprintf” = yes; then HAVE_WPRINTF=1 else HAVE_WPRINTF=0 fi

{ echo “$as_me:$LINENO: checking for nl_langinfo and CODESET” >&5 echo $ECHO_N “checking for nl_langinfo and CODESET… $ECHO_C” >&6; } if test “${am_cv_langinfo_codeset+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <langinfo.h>

int main () { char cs = nl_langinfo(CODESET); return !cs; ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ *+’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then am_cv_langinfo_codeset=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

am_cv_langinfo_codeset=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext

fi { echo “$as_me:$LINENO: result: $am_cv_langinfo_codeset” >&5 echo “${ECHO_T}$am_cv_langinfo_codeset” >&6; } if test $am_cv_langinfo_codeset = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_LANGINFO_CODESET 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for LC_MESSAGES” >&5 echo $ECHO_N “checking for LC_MESSAGES… $ECHO_C” >&6; } if test “${gt_cv_val_LC_MESSAGES+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <locale.h>

int main () { return LC_MESSAGES ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_val_LC_MESSAGES=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_val_LC_MESSAGES=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi { echo “$as_me:$LINENO: result: $gt_cv_val_LC_MESSAGES” >&5 echo “${ECHO_T}$gt_cv_val_LC_MESSAGES” >&6; } if test $gt_cv_val_LC_MESSAGES = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_LC_MESSAGES 1

_ACEOF

fi

            if test "$enable_shared" = yes; then
case "$host_os" in
  mingw* | cygwin*) is_woe32dll=yes ;;
  *) is_woe32dll=no ;;
esac

else is_woe32dll=no fi WOE32DLL=$is_woe32dll

  case "$host_os" in
mingw* | cygwin*) is_woe32=yes ;;
*) is_woe32=no ;;

esac WOE32=$is_woe32

if test $WOE32 = yes; then if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}windres”, so it can be a program name with args. set dummy ${ac_tool_prefix}windres; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_WINDRES+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$WINDRES”; then ac_cv_prog_WINDRES=“$WINDRES” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_WINDRES=“${ac_tool_prefix}windres” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi WINDRES=$ac_cv_prog_WINDRES if test -n “$WINDRES”; then { echo “$as_me:$LINENO: result: $WINDRES” >&5 echo “${ECHO_T}$WINDRES” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

fi if test -z “$ac_cv_prog_WINDRES”; then ac_ct_WINDRES=$WINDRES # Extract the first word of “windres”, so it can be a program name with args. set dummy windres; ac_word=$2 { echo “$as_me:$LINENO: checking for $ac_word” >&5 echo $ECHO_N “checking for $ac_word… $ECHO_C” >&6; } if test “${ac_cv_prog_ac_ct_WINDRES+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_WINDRES”; then ac_cv_prog_ac_ct_WINDRES=“$ac_ct_WINDRES” # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_exec_ext in ‘’ $ac_executable_extensions; do if { test -f “$as_dir/$ac_word$ac_exec_ext” && $as_test_x “$as_dir/$ac_word$ac_exec_ext”; }; then ac_cv_prog_ac_ct_WINDRES=“windres” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_WINDRES=$ac_cv_prog_ac_ct_WINDRES if test -n “$ac_ct_WINDRES”; then { echo “$as_me:$LINENO: result: $ac_ct_WINDRES” >&5 echo “${ECHO_T}$ac_ct_WINDRES” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_ct_WINDRES” = x; then WINDRES=“” else case $cross_compiling:$ac_tool_warned in yes:) { echo “$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&5 echo “$as_me: WARNING: In the future, Autoconf will not detect cross-tools whose name does not start with the host triplet. If you think this configuration is useful to you, please write to autoconf@gnu.org.” >&2;} ac_tool_warned=yes ;; esac WINDRES=$ac_ct_WINDRES fi else WINDRES=“$ac_cv_prog_WINDRES” fi

fi

          case "$host_os" in
hpux*) LTLIBC="" ;;
*)     LTLIBC="-lc" ;;

esac

{ echo "$as_me:$LINENO: checking for CFPreferencesCopyAppValue" >&5

echo $ECHO_N “checking for CFPreferencesCopyAppValue… $ECHO_C” >&6; } if test “${gt_cv_func_CFPreferencesCopyAppValue+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else gt_save_LIBS=“$LIBS” LIBS=“$LIBS -Wl,-framework -Wl,CoreFoundation” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <CoreFoundation/CFPreferences.h>

int main () { CFPreferencesCopyAppValue(NULL, NULL) ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_func_CFPreferencesCopyAppValue=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_func_CFPreferencesCopyAppValue=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gt_save_LIBS” fi { echo “$as_me:$LINENO: result: $gt_cv_func_CFPreferencesCopyAppValue” >&5 echo “${ECHO_T}$gt_cv_func_CFPreferencesCopyAppValue” >&6; } if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_CFPREFERENCESCOPYAPPVALUE 1

_ACEOF

fi { echo “$as_me:$LINENO: checking for CFLocaleCopyCurrent” >&5 echo $ECHO_N “checking for CFLocaleCopyCurrent… $ECHO_C” >&6; } if test “${gt_cv_func_CFLocaleCopyCurrent+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else gt_save_LIBS=“$LIBS” LIBS=“$LIBS -Wl,-framework -Wl,CoreFoundation” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <CoreFoundation/CFLocale.h>

int main () { CFLocaleCopyCurrent(); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then gt_cv_func_CFLocaleCopyCurrent=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

gt_cv_func_CFLocaleCopyCurrent=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext LIBS=“$gt_save_LIBS” fi { echo “$as_me:$LINENO: result: $gt_cv_func_CFLocaleCopyCurrent” >&5 echo “${ECHO_T}$gt_cv_func_CFLocaleCopyCurrent” >&6; } if test $gt_cv_func_CFLocaleCopyCurrent = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_CFLOCALECOPYCURRENT 1

_ACEOF

fi INTL_MACOSX_LIBS= if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then INTL_MACOSX_LIBS=“-Wl,-framework -Wl,CoreFoundation” fi

BUILD_INCLUDED_LIBINTL=no
USE_INCLUDED_LIBINTL=no

LIBINTL= LTLIBINTL= POSUB=

case " $gt_needs " in
*" need-formatstring-macros "*) gt_api_version=3 ;;
*" need-ngettext "*) gt_api_version=2 ;;
*) gt_api_version=1 ;;

esac gt_func_gnugettext_libc=“gt_cv_func_gnugettext${gt_api_version}libc” gt_func_gnugettext_libintl=“gt_cv_func_gnugettext${gt_api_version}libintl”

if test "$USE_NLS" = "yes"; then
gt_use_preinstalled_gnugettext=no

  { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5

echo $ECHO_N “checking whether included gettext is requested… $ECHO_C” >&6; }

Check whether –with-included-gettext was given.

if test “${with_included_gettext+set}” = set; then withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval else nls_cv_force_use_gnu_gettext=no fi

  { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5

echo “${ECHO_T}$nls_cv_force_use_gnu_gettext” >&6; }

  nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext"
  if test "$nls_cv_force_use_gnu_gettext" != "yes"; then


    if test $gt_api_version -ge 3; then
      gt_revision_test_code='

ifndef __GNU_GETTEXT_SUPPORTED_REVISION

define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1)

endif

typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; ‘ else gt_revision_test_code= fi if test $gt_api_version -ge 2; then gt_expression_test_code=’ + * ngettext (“”, “”, 0)‘ else gt_expression_test_code= fi

    { echo "$as_me:$LINENO: checking for GNU gettext in libc" >&5

echo $ECHO_N “checking for GNU gettext in libc… $ECHO_C” >&6; } if { as_var=$gt_func_gnugettext_libc; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <libintl.h>

$gt_revision_test_code extern int nl_msg_cat_cntr; extern int *nl_domain_bindings; int main () { bindtextdomain (“”, “”); return * gettext (“”)$gt_expression_test_code + nl_msg_cat_cntr + *nl_domain_bindings ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$gt_func_gnugettext_libc=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$gt_func_gnugettext_libc=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi ac_res=eval echo '${'$gt_func_gnugettext_libc'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; }

    if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then





use_additional=yes

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

eval additional_includedir=\"$includedir\"
eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

Check whether –with-libintl-prefix was given.

if test “${with_libintl_prefix+set}” = set; then withval=$with_libintl_prefix; if test “X$withval” = “Xno”; then use_additional=no else if test “X$withval” = “X”; then

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix”

      eval additional_includedir=\"$includedir\"
      eval additional_libdir=\"$libdir\"

exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  else
    additional_includedir="$withval/include"
    additional_libdir="$withval/$acl_libdirstem"
  fi
fi

fi

  LIBINTL=

LTLIBINTL= INCINTL= LIBINTL_PREFIX= rpathdirs= ltrpathdirs= names_already_handled= names_next_round=‘intl ’ while test -n “$names_next_round”; do names_this_round=“$names_next_round” names_next_round= for name in $names_this_round; do already_handled= for n in $names_already_handled; do if test “$n” = “$name”; then already_handled=yes break fi done if test -z “$already_handled”; then names_already_handled=“$names_already_handled $name” uppername=echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|' eval value=\“\$HAVE_LIB$uppername\” if test -n “$value”; then if test “$value” = yes; then eval value=\“\$LIB$uppername\” test -z “$value” || LIBINTL=“${LIBINTL}${LIBINTL:+ }$value” eval value=\“\$LTLIB$uppername\” test -z “$value” || LTLIBINTL=“${LTLIBINTL}${LTLIBINTL:+ }$value” else : fi else found_dir= found_la= found_so= found_a= eval libname=\“$acl_libname_spec\” # typically: libname=lib$name if test -n “$acl_shlibext”; then shrext=“.$acl_shlibext” # typically: shrext=.so else shrext= fi if test $use_additional = yes; then dir=“$additional_libdir” if test -n “$acl_shlibext”; then if test -f “$dir/$libname$shrext”; then found_dir=“$dir” found_so=“$dir/$libname$shrext” else if test “$acl_library_names_spec” = ‘$libname$shrext$versuffix’; then ver=(cd "$dir" && \ for f in "$libname$shrext".*; do echo "$f"; done \ | sed -e "s,^$libname$shrext\\\\.,," \ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ | sed 1q ) 2>/dev/null if test -n “$ver” && test -f “$dir/$libname$shrext.$ver”; then found_dir=“$dir” found_so=“$dir/$libname$shrext.$ver” fi else eval library_names=\“$acl_library_names_spec\” for f in $library_names; do if test -f “$dir/$f”; then found_dir=“$dir” found_so=“$dir/$f” break fi done fi fi fi if test “X$found_dir” = “X”; then if test -f “$dir/$libname.$acl_libext”; then found_dir=“$dir” found_a=“$dir/$libname.$acl_libext” fi fi if test “X$found_dir” != “X”; then if test -f “$dir/$libname.la”; then found_la=“$dir/$libname.la” fi fi fi if test “X$found_dir” = “X”; then for x in $LDFLAGS $LTLIBINTL; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

          case "$x" in
            -L*)
              dir=`echo "X$x" | sed -e 's/^X-L//'`
                                if test -n "$acl_shlibext"; then
                if test -f "$dir/$libname$shrext"; then
                  found_dir="$dir"
                  found_so="$dir/$libname$shrext"
                else
                  if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
                    ver=`(cd "$dir" && \
                          for f in "$libname$shrext".*; do echo "$f"; done \
                          | sed -e "s,^$libname$shrext\\\\.,," \
                          | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                          | sed 1q ) 2>/dev/null`
                    if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
                      found_dir="$dir"
                      found_so="$dir/$libname$shrext.$ver"
                    fi
                  else
                    eval library_names=\"$acl_library_names_spec\"
                    for f in $library_names; do
                      if test -f "$dir/$f"; then
                        found_dir="$dir"
                        found_so="$dir/$f"
                        break
                      fi
                    done
                  fi
                fi
              fi
                                if test "X$found_dir" = "X"; then
                if test -f "$dir/$libname.$acl_libext"; then
                  found_dir="$dir"
                  found_a="$dir/$libname.$acl_libext"
                fi
              fi
              if test "X$found_dir" != "X"; then
                if test -f "$dir/$libname.la"; then
                  found_la="$dir/$libname.la"
                fi
              fi
              ;;
          esac
          if test "X$found_dir" != "X"; then
            break
          fi
        done
      fi
      if test "X$found_dir" != "X"; then
                    LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-L$found_dir -l$name"
        if test "X$found_so" != "X"; then
                                                    if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
                            LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"
          else
                                                                            haveit=
            for x in $ltrpathdirs; do
              if test "X$x" = "X$found_dir"; then
                haveit=yes
                break
              fi
            done
            if test -z "$haveit"; then
              ltrpathdirs="$ltrpathdirs $found_dir"
            fi
                            if test "$acl_hardcode_direct" = yes; then
                                                  LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"
            else
              if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
                                                        LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"
                                                        haveit=
                for x in $rpathdirs; do
                  if test "X$x" = "X$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  rpathdirs="$rpathdirs $found_dir"
                fi
              else
                                                                            haveit=
                for x in $LDFLAGS $LIBINTL; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                  if test "X$x" = "X-L$found_dir"; then
                    haveit=yes
                    break
                  fi
                done
                if test -z "$haveit"; then
                  LIBINTL="${LIBINTL}${LIBINTL:+ }-L$found_dir"
                fi
                if test "$acl_hardcode_minus_L" != no; then
                                                                                    LIBINTL="${LIBINTL}${LIBINTL:+ }$found_so"
                else
                                                                                                                                                                            LIBINTL="${LIBINTL}${LIBINTL:+ }-l$name"
                fi
              fi
            fi
          fi
        else
          if test "X$found_a" != "X"; then
                            LIBINTL="${LIBINTL}${LIBINTL:+ }$found_a"
          else
                                            LIBINTL="${LIBINTL}${LIBINTL:+ }-L$found_dir -l$name"
          fi
        fi
                    additional_includedir=
        case "$found_dir" in
          */$acl_libdirstem | */$acl_libdirstem/)
            basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
            LIBINTL_PREFIX="$basedir"
            additional_includedir="$basedir/include"
            ;;
        esac
        if test "X$additional_includedir" != "X"; then
                                                                                                            if test "X$additional_includedir" != "X/usr/include"; then
            haveit=
            if test "X$additional_includedir" = "X/usr/local/include"; then
              if test -n "$GCC"; then
                case $host_os in
                  linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                esac
              fi
            fi
            if test -z "$haveit"; then
              for x in $CPPFLAGS $INCINTL; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                if test "X$x" = "X-I$additional_includedir"; then
                  haveit=yes
                  break
                fi
              done
              if test -z "$haveit"; then
                if test -d "$additional_includedir"; then
                                        INCINTL="${INCINTL}${INCINTL:+ }-I$additional_includedir"
                fi
              fi
            fi
          fi
        fi
                    if test -n "$found_la"; then
                                                    save_libdir="$libdir"
          case "$found_la" in
            */* | *\\*) . "$found_la" ;;
            *) . "./$found_la" ;;
          esac
          libdir="$save_libdir"
                        for dep in $dependency_libs; do
            case "$dep" in
              -L*)
                additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
                                                                                                                                                            if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
                  haveit=
                  if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
                    if test -n "$GCC"; then
                      case $host_os in
                        linux* | gnu* | k*bsd*-gnu) haveit=yes;;
                      esac
                    fi
                  fi
                  if test -z "$haveit"; then
                    haveit=
                    for x in $LDFLAGS $LIBINTL; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LIBINTL="${LIBINTL}${LIBINTL:+ }-L$additional_libdir"
                      fi
                    fi
                    haveit=
                    for x in $LDFLAGS $LTLIBINTL; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

                      if test "X$x" = "X-L$additional_libdir"; then
                        haveit=yes
                        break
                      fi
                    done
                    if test -z "$haveit"; then
                      if test -d "$additional_libdir"; then
                                                    LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-L$additional_libdir"
                      fi
                    fi
                  fi
                fi
                ;;
              -R*)
                dir=`echo "X$dep" | sed -e 's/^X-R//'`
                if test "$enable_rpath" != no; then
                                                              haveit=
                  for x in $rpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    rpathdirs="$rpathdirs $dir"
                  fi
                                                              haveit=
                  for x in $ltrpathdirs; do
                    if test "X$x" = "X$dir"; then
                      haveit=yes
                      break
                    fi
                  done
                  if test -z "$haveit"; then
                    ltrpathdirs="$ltrpathdirs $dir"
                  fi
                fi
                ;;
              -l*)
                                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
                ;;
              *.la)
                                                                            names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
                ;;
              *)
                                    LIBINTL="${LIBINTL}${LIBINTL:+ }$dep"
                LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }$dep"
                ;;
            esac
          done
        fi
      else
                                                        LIBINTL="${LIBINTL}${LIBINTL:+ }-l$name"
        LTLIBINTL="${LTLIBINTL}${LTLIBINTL:+ }-l$name"
      fi
    fi
  fi
done

done if test “X$rpathdirs” != “X”; then if test -n “$acl_hardcode_libdir_separator”; then alldirs= for found_dir in $rpathdirs; do alldirs=“${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir” done acl_save_libdir=“$libdir” libdir=“$alldirs” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBINTL=“${LIBINTL}${LIBINTL:+ }$flag” else for found_dir in $rpathdirs; do acl_save_libdir=“$libdir” libdir=“$found_dir” eval flag=\“$acl_hardcode_libdir_flag_spec\” libdir=“$acl_save_libdir” LIBINTL=“${LIBINTL}${LIBINTL:+ }$flag” done fi fi if test “X$ltrpathdirs” != “X”; then for found_dir in $ltrpathdirs; do LTLIBINTL=“${LTLIBINTL}${LTLIBINTL:+ }-R$found_dir” done fi

      { echo "$as_me:$LINENO: checking for GNU gettext in libintl" >&5

echo $ECHO_N “checking for GNU gettext in libintl… $ECHO_C” >&6; } if { as_var=$gt_func_gnugettext_libintl; eval “test \”\${$as_var+set}\“ = set”; }; then echo $ECHO_N “(cached) $ECHO_C” >&6 else gt_save_CPPFLAGS=“$CPPFLAGS” CPPFLAGS=“$CPPFLAGS $INCINTL” gt_save_LIBS=“$LIBS” LIBS=“$LIBS $LIBINTL” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <libintl.h>

$gt_revision_test_code extern int _nl_msg_cat_cntr; extern

ifdef __cplusplus

“C”

endif

const char _nl_expand_alias (const char ); int main () { bindtextdomain (“”, “”); return * gettext (“”)$gt_expression_test_code + nl_msg_cat_cntr + *nl_expand_alias (“”) ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then eval “$gt_func_gnugettext_libintl=yes” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

eval "$gt_func_gnugettext_libintl=no"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext if { eval “gt_val=\$$gt_func_gnugettext_libintl”; test “$gt_val” != yes; } && test -n “$LIBICONV”; then LIBS=“$LIBS $LIBICONV” cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <libintl.h>

$gt_revision_test_code extern int _nl_msg_cat_cntr; extern

ifdef __cplusplus

“C”

endif

const char _nl_expand_alias (const char ); int main () { bindtextdomain (“”, “”); return * gettext (“”)$gt_expression_test_code + nl_msg_cat_cntr + *nl_expand_alias (“”) ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval "echo \”\$as_me:$LINENO: $ac_try_echo\“”) >&5 (eval “$ac_link”) 2>conftest.er1 ac_status=$? grep -v ‘^ +’ conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && $as_test_x conftest$ac_exeext; then LIBINTL=“$LIBINTL $LIBICONV” LTLIBINTL=“$LTLIBINTL $LTLIBICONV” eval “$gt_func_gnugettext_libintl=yes”

else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext fi CPPFLAGS=“$gt_save_CPPFLAGS” LIBS=“$gt_save_LIBS” fi ac_res=eval echo '${'$gt_func_gnugettext_libintl'}' { echo “$as_me:$LINENO: result: $ac_res” >&5 echo “${ECHO_T}$ac_res” >&6; } fi

                                    if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \
       || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \
            && test "$PACKAGE" != gettext-runtime \
            && test "$PACKAGE" != gettext-tools; }; then
      gt_use_preinstalled_gnugettext=yes
    else
                LIBINTL=
      LTLIBINTL=
      INCINTL=
    fi


    if test "$gt_use_preinstalled_gnugettext" != "yes"; then
                          nls_cv_use_gnu_gettext=yes
    fi
  fi

  if test "$nls_cv_use_gnu_gettext" = "yes"; then
            BUILD_INCLUDED_LIBINTL=yes
    USE_INCLUDED_LIBINTL=yes
    LIBINTL="\${top_builddir}/intl/libintl.a $LIBICONV $LIBTHREAD"
    LTLIBINTL="\${top_builddir}/intl/libintl.a $LTLIBICONV $LTLIBTHREAD"
    LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'`
  fi

  CATOBJEXT=
  if test "$gt_use_preinstalled_gnugettext" = "yes" \
     || test "$nls_cv_use_gnu_gettext" = "yes"; then
            CATOBJEXT=.gmo
  fi


if test -n "$INTL_MACOSX_LIBS"; then
  if test "$gt_use_preinstalled_gnugettext" = "yes" \
     || test "$nls_cv_use_gnu_gettext" = "yes"; then
            LIBINTL="$LIBINTL $INTL_MACOSX_LIBS"
    LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS"
  fi
fi

if test "$gt_use_preinstalled_gnugettext" = "yes" \
   || test "$nls_cv_use_gnu_gettext" = "yes"; then

cat >>confdefs.h <<_ACEOF

define ENABLE_NLS 1

_ACEOF

else
  USE_NLS=no
fi

fi

{ echo “$as_me:$LINENO: checking whether to use NLS” >&5 echo $ECHO_N “checking whether to use NLS… $ECHO_C” >&6; } { echo “$as_me:$LINENO: result: $USE_NLS” >&5 echo “${ECHO_T}$USE_NLS” >&6; } if test “$USE_NLS” = “yes”; then { echo “$as_me:$LINENO: checking where the gettext function comes from” >&5 echo $ECHO_N “checking where the gettext function comes from… $ECHO_C” >&6; } if test “$gt_use_preinstalled_gnugettext” = “yes”; then if { eval “gt_val=\$$gt_func_gnugettext_libintl”; test “$gt_val” = “yes”; }; then gt_source=“external libintl” else gt_source=“libc” fi else gt_source=“included intl directory” fi { echo “$as_me:$LINENO: result: $gt_source” >&5 echo “${ECHO_T}$gt_source” >&6; } fi

if test “$USE_NLS” = “yes”; then

if test "$gt_use_preinstalled_gnugettext" = "yes"; then
  if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then
    { echo "$as_me:$LINENO: checking how to link with libintl" >&5

echo $ECHO_N “checking how to link with libintl… $ECHO_C” >&6; } { echo “$as_me:$LINENO: result: $LIBINTL” >&5 echo “${ECHO_T}$LIBINTL” >&6; }

for element in $INCINTL; do haveit= for x in $CPPFLAGS; do

acl_save_prefix=“$prefix” prefix=“$acl_final_prefix” acl_save_exec_prefix=“$exec_prefix” exec_prefix=“$acl_final_exec_prefix” eval x=\“$x\” exec_prefix=“$acl_save_exec_prefix” prefix=“$acl_save_prefix”

  if test "X$x" = "X$element"; then
    haveit=yes
    break
  fi
done
if test -z "$haveit"; then
  CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element"
fi

done

  fi

cat >>confdefs.h <<_ACEOF

define HAVE_GETTEXT 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define HAVE_DCGETTEXT 1

_ACEOF

fi

    POSUB=po

fi

        if test "$PACKAGE" = gettext-runtime || test "$PACKAGE" = gettext-tools; then
  BUILD_INCLUDED_LIBINTL=yes
fi





    nls_cv_header_intl=
nls_cv_header_libgt=

    DATADIRNAME=share


    INSTOBJEXT=.mo


    GENCAT=gencat


    INTLOBJS=
if test "$USE_INCLUDED_LIBINTL" = yes; then
  INTLOBJS="\$(GETTOBJS)"
fi


    INTL_LIBTOOL_SUFFIX_PREFIX=



INTLLIBS="$LIBINTL"

if test “$USE_NLS” = “yes”; then if test “$USE_INCLUDED_LIBINTL” = “yes”; then nls_msg=“Built using included libintl” CPPFLAGS=“$CPPFLAGS -I\$(top_builddir)/intl” else nls_msg=“Built using native support” fi else nls_msg=“Not built” fi

Check whether –enable-warnings was given.

if test “${enable_warnings+set}” = set; then enableval=$enable_warnings; fi

if test “$enable_warnings” = “yes”; then case $GCC:uname in yes:) CFLAGS=“$CFLAGS -Wall -Wmissing-declarations -Wshadow -Wreturn-type -Wsign-compare -Wundef -Wpointer-arith -Wbad-function-cast -Wformat-security” if test -z “$with_ssl” -o “$with_ssl” = “no”; then # OpenSSL headers fail strict prototypes checks CFLAGS=“$CFLAGS -Wstrict-prototypes” fi ;; no:OSF1) CFLAGS=“$CFLAGS -check -msg_disable returnchecks -msg_disable alignment -msg_disable overflow” ;; no:IRIX) CFLAGS=“$CFLAGS -fullwarn” ;; no:UnixWare) CFLAGS=“$CFLAGS -v” ;; ) { echo “$as_me:$LINENO: WARNING: warning flags unknown for compiler on this platform” >&5 echo “$as_me: WARNING: warning flags unknown for compiler on this platform” >&2;} ;; esac fi

if test “$enable_gnomefe” = “yes”; then if test “$gnome_is_ok” = “yes”; then EXTRAOBJS=“$EXTRAOBJS \$(GNOMEOBJS)” LIBS=“$LIBS $GNOME_LIBS $GTK_LIBS $GNOME_LIBDIR $GNOMEUI_LIBS $LIBGLADE_LIBS” CPPFLAGS=“$CPPFLAGS $GNOME_INCLUDEDIR $LIBGLADE_CFLAGS” GNOME_SC_HELPDIR=“gnome-config --datadir/gnome/help/xsitecopy” SHORTCUT_LOCATION=“gnome-config --datadir/gnome/apps/Internet” TARGET=“xsitecopy” fe_msg=“GNOME” else { { echo “$as_me:$LINENO: error: could not find the required GNOME libraries” >&5 echo “$as_me: error: could not find the required GNOME libraries” >&2;} { (exit 1); exit 1; }; } fi else # Console front end EXTRAOBJS=“$EXTRAOBJS src/console_fe.o” case “ $LIBOBJS ” in “ lib/rpmatch.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/rpmatch.$ac_objext” ;; esac

case " $LIBOBJS " in

“ lib/yesno.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS lib/yesno.$ac_objext” ;; esac

fe_msg="Console"
TARGET="sitecopy"

fi

This goes in CPPFLAGS so libneon/Makefile can pick up config.h

CPPFLAGS=“$CPPFLAGS -I\$(top_builddir)”

ac_config_files=“$ac_config_files Makefile lib/neon/Makefile po/Makefile.in intl/Makefile”

cat >confcache <<_ACEOF

This file is a shell script that caches the results of configure

tests run on this system so they can be shared between configure

scripts and configure runs, see configure’s option –config-cache.

It is not useful on other systems. If it contains results you don’t

want to keep, you may remove or edit it.

#

config.status only pays attention to the cache file if you give it

the –recheck option to rerun configure.

#

`ac_cv_env_foo' variables (set or unset) will be overridden when

loading this file, other unset `ac_cv_foo' will be assigned the

following values.

_ACEOF

The following way of writing the cache mishandles newlines in values,

but we know of no workaround that is simple, portable, and efficient.

So, we kill variables containing newlines.

Ultrix sh set writes to stderr and can’t be redirected directly,

and sets the high bit in the cache file unless we assign to the vars.

( for ac_var in (set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'; do eval ac_val=\$$ac_var case $ac_val in #( ${as_nl}) case $ac_var in #( cv) { echo “$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline.” >&5 echo “$as_me: WARNING: Cache variable $ac_var contains a newline.” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( *) $as_unset $ac_var ;; esac ;; esac done

(set) 2>&1 | case $as_nl(ac_space=' '; set) 2>&1 in #( ${as_nl}ac_space=\ ) # set' does not quote correctly, so add quotes (double-quote # substitution turns \\\\ into \\, and sed turns \\ into \). sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) #set' quotes correctly as required by POSIX, so do not add quotes. sed -n “/^[$as_cr_alnum]*cv[$as_cr_alnum]=/p” ;; esac | sort ) | sed ‘ /^ac_cv_env_/b end t clear :clear s/^([^=])=(.[{}].)$/test “${\1+set}” = set || &/ t end s/^([^=])=(.)$/\1=${\1=\2}/ :end’ >>confcache if diff “$cache_file” confcache >/dev/null 2>&1; then :; else if test -w “$cache_file”; then test “x$cache_file” != “x/dev/null” && { echo “$as_me:$LINENO: updating cache $cache_file” >&5 echo “$as_me: updating cache $cache_file” >&6;} cat confcache >$cache_file else { echo “$as_me:$LINENO: not updating unwritable cache $cache_file” >&5 echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache

test “x$prefix” = xNONE && prefix=$ac_default_prefix

Let make expand exec_prefix.

test “x$exec_prefix” = xNONE && exec_prefix=‘${prefix}’

DEFS=-DHAVE_CONFIG_H

ac_libobjs= ac_ltlibobjs= for ac_i in : $LIBOBJS; do test “x$ac_i” = x: && continue # 1. Remove the extension, and $U if already installed. ac_script=’s/\$U././;s/.o$//;s/.obj$//‘ ac_i=echo "$ac_i" | sed "$ac_script" # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. ac_libobjs=“$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext” ac_ltlibobjs=“$ac_ltlibobjs \${LIBOBJDIR}$ac_i”’$U.lo' done LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs

: ${CONFIG_STATUS=./config.status} ac_clean_files_save=$ac_clean_files ac_clean_files=“$ac_clean_files $CONFIG_STATUS” { echo “$as_me:$LINENO: creating $CONFIG_STATUS” >&5 echo “$as_me: creating $CONFIG_STATUS” >&6;} cat >$CONFIG_STATUS <<_ACEOF

! $SHELL

Generated by $as_me.

Run this file to recreate the current configuration.

Compiler output produced by configure, useful for debugging

configure, is in config.log if it exists.

debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} _ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

———————

M4sh Initialization.

———————

Be more Bourne compatible

DUALCASE=1; export DUALCASE # for MKS sh if test -n “${ZSH_VERSION+set}” && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: # Zsh 3.x and 4.x performs word splitting on ${1+“$@”}, which # is contrary to our usage. Disable this feature. alias -g ‘${1+“$@”}’=‘“$@”’ setopt NO_GLOB_SUBST else case (set -o) 2>/dev/null in posix) set -o posix ;; esac

fi

PATH needs CR

Avoid depending upon Character Ranges.

as_cr_letters=‘abcdefghijklmnopqrstuvwxyz’ as_cr_LETTERS=‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’ as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits=‘0123456789’ as_cr_alnum=$as_cr_Letters$as_cr_digits

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then echo “#! /bin/sh” >conf$$.sh echo “exit 0” >>conf$$.sh chmod +x conf$$.sh if (PATH=“/nonexistent;.”; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=‘;’ else PATH_SEPARATOR=: fi rm -f conf$$.sh fi

Support unset when possible.

if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then as_unset=unset else as_unset=false fi

IFS

We need space, tab and new line, in precisely that order. Quoting is

there to prevent editors from complaining about space-tab.

(If _AS_PATH_WALK were called with IFS unset, it would disable word

splitting by setting IFS to empty value.)

as_nl=‘ ’ IFS=“ ”“ $as_nl”

Find who we are. Look in the path if we contain no directory separator.

case $0 in [\/] ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. test -r “$as_dir/$0” && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS

 ;;

esac

We did not find ourselves, most probably we were run as `sh COMMAND'

in which case we are not to be found in the path.

if test “x$as_myself” = x; then as_myself=$0 fi if test ! -f “$as_myself”; then echo “$as_myself: error: cannot find myself; rerun with an absolute file name” >&2 { (exit 1); exit 1; } fi

Work around bugs in pre-3.0 UWIN ksh.

for as_var in ENV MAIL MAILPATH do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var done PS1=‘$ ’ PS2=‘> ’ PS4=‘+ ’

NLS nuisances.

for as_var in \ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ LC_TELEPHONE LC_TIME do if (set +x; test -z “(eval $as_var=C; export $as_var) 2>&1”); then eval $as_var=C; export $as_var else ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var fi done

Required to use basename.

if expr a : ‘(a)’ >/dev/null 2>&1 && test “Xexpr 00001 : '.*\(...\)'” = X001; then as_expr=expr else as_expr=false fi

if (basename – /) >/dev/null 2>&1 && test “Xbasename -- / 2>&1” = “X/”; then as_basename=basename else as_basename=false fi

Name of the executable.

as_me=$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'

CDPATH.

$as_unset CDPATH

as_lineno_1=$LINENO as_lineno_2=$LINENO test “x$as_lineno_1” != “x$as_lineno_2” && test “xexpr $as_lineno_1 + 1” = “x$as_lineno_2” || {

# Create $as_me.lineno as a copy of $as_myself, but with $LINENO # uniformly replaced by the line number. The first ‘sed’ inserts a # line-number line after each line using $LINENO; the second ‘sed’ # does the real work. The second script uses ‘N’ to pair each # line-number line with the line containing $LINENO, and appends # trailing ‘-’ during substitution so that $LINENO is not a special # case at line end. # (Raja R Harinath suggested sed ‘=’, and Paul Eggert wrote the # scripts with optimization help from Paolo Bonzini. Blame Lee # E. McMahon (1931-1989) for sed’s syntax. :-) sed -n ‘ p /[$]LINENO/= ’ <$as_myself | sed ‘ s/[$]LINENO./&-/ t lineno b :lineno N :loop s/[$]LINENO([^’$as_cr_alnum'_].\n)(.)/\2\1\2/ t loop s/-\n.// ‘ >$as_me.lineno && chmod +x “$as_me.lineno” || { echo “$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell” >&2 { (exit 1); exit 1; }; }

# Don’t try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . “./$as_me.lineno” # Exit status is that of the last command. exit }

if (as_dir=dirname -- / && test “X$as_dir” = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi

ECHO_C= ECHO_N= ECHO_T= case echo -n x in -n) case echo 'x\c' in c) ECHO_T=‘ ’;; # ECHO_T is single tab character. ) ECHO_C=‘\c’;; esac;; *) ECHO_N=‘-n’;; esac

if expr a : ‘(a)’ >/dev/null 2>&1 && test “Xexpr 00001 : '.*\(...\)'” = X001; then as_expr=expr else as_expr=false fi

rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir fi echo >conf$$.file if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s=‘ln -s’ # … but there are two gotchas: # 1) On MSYS, both ln -s file dir' andln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; ln -s' creates a wrapper executable. # In both cases, we have to default tocp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s=‘cp -p’ elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s=‘cp -p’ fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then as_mkdir_p=: else test -d ./-p && rmdir ./-p as_mkdir_p=false fi

if test -x / >/dev/null 2>&1; then as_test_x=‘test -x’ else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=‘ eval sh -c ’\‘’ if test -d “$1”; then test -d “$1/.”; else case $1 in -)set “./$1”;; esac; case ls -ld'$as_ls_L_option' "$1" 2>/dev/null in ???[sx]):;;*)false;;esac;fi ‘\’‘ sh ’ fi as_executable_p=$as_test_x

Sed expression to map a string onto a valid CPP name.

as_tr_cpp=“eval sed ‘y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^$as_cr_alnum]%%g’”

Sed expression to map a string onto a valid variable name.

as_tr_sh=“eval sed ‘y%*+%pp%;s%[^$as_cr_alnum]%%g’”

exec 6>&1

Save the log message, to keep $[0] and so on meaningful, and to

report actual input values of CONFIG_FILES etc. instead of their

values after options handling.

ac_log=“ This file was extended by sitecopy $as_me 0.16.6, which was generated by GNU Autoconf 2.61. Invocation command line was

CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@

on (hostname || uname -n) 2>/dev/null | sed 1q "

_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

Files that config.status was made for.

config_files=“$ac_config_files” config_headers=“$ac_config_headers” config_commands=“$ac_config_commands”

_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF ac_cs_usage=“\ `$as_me' instantiates files from templates according to the current configuration.

Usage: $0 [OPTIONS] [FILE]…

-h, –help print this help, then exit -V, –version print version number and configuration settings, then exit -q, –quiet do not print progress messages -d, –debug don’t remove temporary files –recheck update $as_me by reconfiguring in the same conditions –file=FILE[:TEMPLATE] instantiate the configuration file FILE –header=FILE[:TEMPLATE] instantiate the configuration header FILE

Configuration files: $config_files

Configuration headers: $config_headers

Configuration commands: $config_commands

Report bugs to bug-autoconf@gnu.org."

ACEOF cat >>$CONFIG_STATUS <<ACEOF ac_cs_version=“\ sitecopy config.status 0.16.6 configured by $0, generated by GNU Autoconf 2.61, with options \”echo "$ac_configure_args" | sed 's/^ //; s/[\\""\\$]/\\&/g'`\"

Copyright © 2006 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it."

ac_pwd=‘$ac_pwd’ srcdir=‘$srcdir’ INSTALL=‘$INSTALL’ MKDIR_P=‘$MKDIR_P’ _ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

If no file are specified by the user, then we need to provide default

value. By we need to know if files were specified by the user.

ac_need_defaults=: while test $# != 0 do case $1 in –=) ac_option=expr "X$1" : 'X\([^=]*\)=' ac_optarg=expr "X$1" : 'X[^=]*=\(.*\)' ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac

case $ac_option in # Handling of the options. -recheck | –recheck | –rechec | –reche | –rech | –rec | –re | –r) ac_cs_recheck=: ;; –version | –versio | –versi | –vers | –ver | –ve | –v | -V ) echo “$ac_cs_version”; exit ;; –debug | –debu | –deb | –de | –d | -d ) debug=: ;; –file | –fil | –fi | –f ) $ac_shift CONFIG_FILES=“$CONFIG_FILES $ac_optarg” ac_need_defaults=false;; –header | –heade | –head | –hea ) $ac_shift CONFIG_HEADERS=“$CONFIG_HEADERS $ac_optarg” ac_need_defaults=false;; –he | –h) # Conflict between –help and –header { echo “$as_me: error: ambiguous option: $1 Try `$0 –help' for more information.” >&2 { (exit 1); exit 1; }; };; –help | –hel | -h ) echo “$ac_cs_usage”; exit ;; -q | -quiet | –quiet | –quie | –qui | –qu | –q \ | -silent | –silent | –silen | –sile | –sil | –si | –s) ac_cs_silent=: ;;

# This is an error. -*) { echo “$as_me: error: unrecognized option: $1 Try `$0 –help' for more information.” >&2 { (exit 1); exit 1; }; } ;;

*) ac_config_targets=“$ac_config_targets $1” ac_need_defaults=false ;;

esac shift done

ac_configure_extra_args=

if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args=“$ac_configure_extra_args –silent” fi

ACEOF cat >>$CONFIG_STATUS <<ACEOF if \$ac_cs_recheck; then echo “running CONFIG_SHELL=$SHELL $SHELL $0 ”$ac_configure_args \$ac_configure_extra_args “ –no-create –no-recursion” >&6 CONFIG_SHELL=$SHELL export CONFIG_SHELL exec $SHELL “$0”$ac_configure_args \$ac_configure_extra_args –no-create –no-recursion fi

ACEOF cat >>$CONFIG_STATUS <<_ACEOF exec 5>>config.log { echo sed ‘h;s/./-/g;s/^…/## /;s/…$/ ##/;p;x;p;x’ <<ASBOX

Running $as_me.

_ASBOX echo “$ac_log” } >&5

ACEOF cat >>$CONFIG_STATUS <<ACEOF #

INIT-COMMANDS

#

Capture the value of obsolete ALL_LINGUAS because we need it to compute

# POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES, CATALOGS. But hide it
# from automake < 1.5.
eval 'OBSOLETE_ALL_LINGUAS''="$ALL_LINGUAS"'
# Capture the value of LINGUAS because we need it to compute CATALOGS.
LINGUAS="${LINGUAS-%UNSET%}"

_ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

Handling of arguments.

for ac_config_target in $ac_config_targets do case $ac_config_target in “config.h”) CONFIG_HEADERS=“$CONFIG_HEADERS config.h” ;; “po-directories”) CONFIG_COMMANDS=“$CONFIG_COMMANDS po-directories” ;; “Makefile”) CONFIG_FILES=“$CONFIG_FILES Makefile” ;; “lib/neon/Makefile”) CONFIG_FILES=“$CONFIG_FILES lib/neon/Makefile” ;; “po/Makefile.in”) CONFIG_FILES=“$CONFIG_FILES po/Makefile.in” ;; “intl/Makefile”) CONFIG_FILES=“$CONFIG_FILES intl/Makefile” ;;

*) { { echo “$as_me:$LINENO: error: invalid argument: $ac_config_target” >&5 echo “$as_me: error: invalid argument: $ac_config_target” >&2;} { (exit 1); exit 1; }; };; esac done

If the user did not use the arguments to specify the items to instantiate,

then the envvar interface is used. Set only those that are not.

We use the long form for the default assignment because of an extremely

bizarre bug on SunOS 4.1.3.

if $ac_need_defaults; then test “${CONFIG_FILES+set}” = set || CONFIG_FILES=$config_files test “${CONFIG_HEADERS+set}” = set || CONFIG_HEADERS=$config_headers test “${CONFIG_COMMANDS+set}” = set || CONFIG_COMMANDS=$config_commands fi

Have a temporary directory for convenience. Make it in the build tree

simply because there is no reason against having it here, and in addition,

creating and moving files from /tmp can sometimes cause problems.

Hook for its removal unless debugging.

Note that there is a small window in which the directory will not be cleaned:

after its creation but before its name has been assigned to `$tmp'.

$debug || { tmp= trap ‘exit_status=$? { test -z “$tmp” || test ! -d “$tmp” || rm -fr “$tmp”; } && exit $exit_status ’ 0 trap ‘{ (exit 1); exit 1; }’ 1 2 13 15 }

Create a (secure) tmp directory for tmp files.

{ tmp=(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null && test -n “$tmp” && test -d “$tmp” } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir “$tmp”) } || { echo “$me: cannot create a temporary directory in .” >&2 { (exit 1); exit 1; } }

#

Set up the sed scripts for CONFIG_FILES section.

#

No need to generate the scripts if there are no CONFIG_FILES.

This happens for instance when ./config.status config.h

if test -n “$CONFIG_FILES”; then

_ACEOF

ac_delim=‘%!!# ’ for ac_last_try in false false false false false :; do cat >conf$$subs.sed <<ACEOF SHELL!$SHELL$ac_delim PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim PACKAGE_NAME!$PACKAGE_NAME$ac_delim PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim PACKAGE_STRING!$PACKAGE_STRING$ac_delim PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim exec_prefix!$exec_prefix$ac_delim prefix!$prefix$ac_delim program_transform_name!$program_transform_name$ac_delim bindir!$bindir$ac_delim sbindir!$sbindir$ac_delim libexecdir!$libexecdir$ac_delim datarootdir!$datarootdir$ac_delim datadir!$datadir$ac_delim sysconfdir!$sysconfdir$ac_delim sharedstatedir!$sharedstatedir$ac_delim localstatedir!$localstatedir$ac_delim includedir!$includedir$ac_delim oldincludedir!$oldincludedir$ac_delim docdir!$docdir$ac_delim infodir!$infodir$ac_delim htmldir!$htmldir$ac_delim dvidir!$dvidir$ac_delim pdfdir!$pdfdir$ac_delim psdir!$psdir$ac_delim libdir!$libdir$ac_delim localedir!$localedir$ac_delim mandir!$mandir$ac_delim DEFS!$DEFS$ac_delim ECHO_C!$ECHO_C$ac_delim ECHO_N!$ECHO_N$ac_delim ECHO_T!$ECHO_T$ac_delim LIBS!$LIBS$ac_delim build_alias!$build_alias$ac_delim host_alias!$host_alias$ac_delim target_alias!$target_alias$ac_delim CC!$CC$ac_delim CFLAGS!$CFLAGS$ac_delim LDFLAGS!$LDFLAGS$ac_delim CPPFLAGS!$CPPFLAGS$ac_delim ac_ct_CC!$ac_ct_CC$ac_delim EXEEXT!$EXEEXT$ac_delim OBJEXT!$OBJEXT$ac_delim SET_MAKE!$SET_MAKE$ac_delim INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim INSTALL_DATA!$INSTALL_DATA$ac_delim CPP!$CPP$ac_delim GREP!$GREP$ac_delim EGREP!$EGREP$ac_delim LIBOBJS!$LIBOBJS$ac_delim NEON_CONFIG!$NEON_CONFIG$ac_delim NE_FLAG_SSL!$NE_FLAG_SSL$ac_delim NE_FLAG_ZLIB!$NE_FLAG_ZLIB$ac_delim NE_FLAG_IPV6!$NE_FLAG_IPV6$ac_delim NE_FLAG_LFS!$NE_FLAG_LFS$ac_delim NE_FLAG_SOCKS!$NE_FLAG_SOCKS$ac_delim NE_FLAG_TS_SSL!$NE_FLAG_TS_SSL$ac_delim PKG_CONFIG!$PKG_CONFIG$ac_delim GNUTLS_CONFIG!$GNUTLS_CONFIG$ac_delim NEON_SUPPORTS_SSL!$NEON_SUPPORTS_SSL$ac_delim KRB5_CONFIG!$KRB5_CONFIG$ac_delim NEON_CFLAGS!$NEON_CFLAGS$ac_delim NEON_LIBS!$NEON_LIBS$ac_delim NEON_LTLIBS!$NEON_LTLIBS$ac_delim NEON_BUILD_BUNDLED!$NEON_BUILD_BUNDLED$ac_delim XML2_CONFIG!$XML2_CONFIG$ac_delim AR!$AR$ac_delim RANLIB!$RANLIB$ac_delim NE_FLAG_DAV!$NE_FLAG_DAV$ac_delim NEON_TARGET!$NEON_TARGET$ac_delim NEON_OBJEXT!$NEON_OBJEXT$ac_delim NEONOBJS!$NEONOBJS$ac_delim NEON_EXTRAOBJS!$NEON_EXTRAOBJS$ac_delim NEON_LINK_FLAGS!$NEON_LINK_FLAGS$ac_delim LIBGLADE_CONFIG!$LIBGLADE_CONFIG$ac_delim LIBGLADE_CFLAGS!$LIBGLADE_CFLAGS$ac_delim LIBGLADE_LIBS!$LIBGLADE_LIBS$ac_delim mkdir_p!$mkdir_p$ac_delim USE_NLS!$USE_NLS$ac_delim GETTEXT_MACRO_VERSION!$GETTEXT_MACRO_VERSION$ac_delim MSGFMT!$MSGFMT$ac_delim GMSGFMT!$GMSGFMT$ac_delim MSGFMT_015!$MSGFMT_015$ac_delim GMSGFMT_015!$GMSGFMT_015$ac_delim XGETTEXT!$XGETTEXT$ac_delim XGETTEXT_015!$XGETTEXT_015$ac_delim MSGMERGE!$MSGMERGE$ac_delim XGETTEXT_EXTRA_OPTIONS!$XGETTEXT_EXTRA_OPTIONS$ac_delim build!$build$ac_delim build_cpu!$build_cpu$ac_delim build_vendor!$build_vendor$ac_delim build_os!$build_os$ac_delim host!$host$ac_delim host_cpu!$host_cpu$ac_delim host_vendor!$host_vendor$ac_delim _ACEOF

if test sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X = 97; then break elif $ac_last_try; then { { echo “$as_me:$LINENO: error: could not make $CONFIG_STATUS” >&5 echo “$as_me: error: could not make $CONFIG_STATUS” >&2;} { (exit 1); exit 1; }; } else ac_delim=“$ac_delim!$ac_delim _$ac_delim!! ” fi done

ac_eof=sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed if test -n “$ac_eof”; then ac_eof=echo "$ac_eof" | sort -nru | sed 1q ac_eof=expr $ac_eof + 1 fi

cat >>$CONFIG_STATUS <<ACEOF cat >“\$tmp/subs-1.sed” <<\CEOF$ac_eof /@[a-zA-Z][a-zA-Z_0-9]@/!b ACEOF sed ‘ s/[,\&]/\&/g; s/@/@|#!!#|/g s/^/s,@/; s/!/@,|#!!_#|/ :n t n s/’“$ac_delim”‘$/,g/; t s/$/\/; p N; s/^.\n//; s/[,\&]/\&/g; s/@/@|#!!#|/g; b n ’ >>$CONFIG_STATUS <conf$$subs.sed rm -f conf$$subs.sed cat >>$CONFIG_STATUS <<ACEOF CEOF$ac_eof ACEOF

ac_delim=‘%!!# ’ for ac_last_try in false false false false false :; do cat >conf$$subs.sed <<ACEOF host_os!$host_os$ac_delim GLIBC2!$GLIBC2$ac_delim CFLAG_VISIBILITY!$CFLAG_VISIBILITY$ac_delim HAVE_VISIBILITY!$HAVE_VISIBILITY$ac_delim ALLOCA!$ALLOCA$ac_delim PRI_MACROS_BROKEN!$PRI_MACROS_BROKEN$ac_delim LIBPTH!$LIBPTH$ac_delim LTLIBPTH!$LTLIBPTH$ac_delim LIBPTH_PREFIX!$LIBPTH_PREFIX$ac_delim LIBTHREAD!$LIBTHREAD$ac_delim LTLIBTHREAD!$LTLIBTHREAD$ac_delim LIBMULTITHREAD!$LIBMULTITHREAD$ac_delim LTLIBMULTITHREAD!$LTLIBMULTITHREAD$ac_delim LIBICONV!$LIBICONV$ac_delim LTLIBICONV!$LTLIBICONV$ac_delim INTLBISON!$INTLBISON$ac_delim GLIBC21!$GLIBC21$ac_delim INTL_MACOSX_LIBS!$INTL_MACOSX_LIBS$ac_delim HAVE_POSIX_PRINTF!$HAVE_POSIX_PRINTF$ac_delim HAVE_ASPRINTF!$HAVE_ASPRINTF$ac_delim HAVE_SNPRINTF!$HAVE_SNPRINTF$ac_delim HAVE_WPRINTF!$HAVE_WPRINTF$ac_delim WOE32DLL!$WOE32DLL$ac_delim WOE32!$WOE32$ac_delim WINDRES!$WINDRES$ac_delim LTLIBC!$LTLIBC$ac_delim BUILD_INCLUDED_LIBINTL!$BUILD_INCLUDED_LIBINTL$ac_delim USE_INCLUDED_LIBINTL!$USE_INCLUDED_LIBINTL$ac_delim CATOBJEXT!$CATOBJEXT$ac_delim DATADIRNAME!$DATADIRNAME$ac_delim INSTOBJEXT!$INSTOBJEXT$ac_delim GENCAT!$GENCAT$ac_delim INTLOBJS!$INTLOBJS$ac_delim INTL_LIBTOOL_SUFFIX_PREFIX!$INTL_LIBTOOL_SUFFIX_PREFIX$ac_delim INTLLIBS!$INTLLIBS$ac_delim LIBINTL!$LIBINTL$ac_delim LTLIBINTL!$LTLIBINTL$ac_delim POSUB!$POSUB$ac_delim GNOME_SC_HELPDIR!$GNOME_SC_HELPDIR$ac_delim XSC_HELP!$XSC_HELP$ac_delim SHORTCUT_LOCATION!$SHORTCUT_LOCATION$ac_delim EXTRAOBJS!$EXTRAOBJS$ac_delim TARGET!$TARGET$ac_delim LTLIBOBJS!$LTLIBOBJS$ac_delim _ACEOF

if test sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X = 44; then break elif $ac_last_try; then { { echo “$as_me:$LINENO: error: could not make $CONFIG_STATUS” >&5 echo “$as_me: error: could not make $CONFIG_STATUS” >&2;} { (exit 1); exit 1; }; } else ac_delim=“$ac_delim!$ac_delim _$ac_delim!! ” fi done

ac_eof=sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed if test -n “$ac_eof”; then ac_eof=echo "$ac_eof" | sort -nru | sed 1q ac_eof=expr $ac_eof + 1 fi

cat >>$CONFIG_STATUS <<ACEOF cat >“\$tmp/subs-2.sed” <<\CEOF$ac_eof /@[a-zA-Z][a-zA-Z_0-9]@/!b end ACEOF sed ‘ s/[,\&]/\&/g; s/@/@|#!!#|/g s/^/s,@/; s/!/@,|#!!_#|/ :n t n s/’“$ac_delim”‘$/,g/; t s/$/\/; p N; s/^.\n//; s/[,\&]/\&/g; s/@/@|#!!#|/g; b n ’ >>$CONFIG_STATUS <conf$$subs.sed rm -f conf$$subs.sed cat >>$CONFIG_STATUS <<ACEOF :end s/|#!!#|//g CEOF$ac_eof ACEOF

VPATH may cause trouble with some makes, so we remove $(srcdir),

${srcdir} and @srcdir@ from VPATH if srcdir is “.”, strip leading and

trailing colons and then remove the whole line if VPATH becomes empty

(actually we leave an empty line to preserve line numbers).

if test “x$srcdir” = x.; then ac_vpsub=‘/^[ ]VPATH[ ]=/{ s/:\$(srcdir):/:/ s/:\${srcdir}:/:/ s/:@srcdir@:/:/ s/^([^=]=[ ]):/\1/ s/:$// s/^[^=]=[ ]$// }’ fi

cat >>$CONFIG_STATUS <<_ACEOF fi # test -n “$CONFIG_FILES”

for ac_tag in :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]:);; :L | :C:) { { echo “$as_me:$LINENO: error: Invalid tag $ac_tag.” >&5 echo “$as_me: error: Invalid tag $ac_tag.” >&2;} { (exit 1); exit 1; }; };; :[FH]-) ac_tag=-:-;; :[FH]) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift

case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f=“$tmp/stdin”;; ) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:‘. test -f “$ac_f” || case $ac_f in [\/$]) false;; *) test -f “$srcdir/$ac_f” && ac_f=“$srcdir/$ac_f”;; esac || { { echo “$as_me:$LINENO: error: cannot find input file: $ac_f” >&5 echo “$as_me: error: cannot find input file: $ac_f” >&2;} { (exit 1); exit 1; }; };; esac ac_file_inputs=“$ac_file_inputs $ac_f” done

# Let's still pretend it is `configure' which instantiates (i.e., don't
# use $as_me), people would be surprised to read:
#    /* config.h.  Generated by config.status.  */
configure_input="Generated from "`IFS=:
  echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
if test x"$ac_file" != x-; then
  configure_input="$ac_file.  $configure_input"
  { echo "$as_me:$LINENO: creating $ac_file" >&5

echo “$as_me: creating $ac_file” >&6;} fi

case $ac_tag in
*:-:* | *:-) cat >"$tmp/stdin";;
esac
;;

esac

ac_dir=$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' { as_dir=“$ac_dir” case $as_dir in #( -) as_dir=./$as_dir;; esac test -d “$as_dir” || { $as_mkdir_p && mkdir -p “$as_dir”; } || { as_dirs= while :; do case $as_dir in #( \‘) as_qdir=echo "$as_dir" | sed "s/'/'\\\\\\\\''/g";; #( ) as_qdir=$as_dir;; esac as_dirs=“’$as_qdir' $as_dirs” as_dir=$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' test -d “$as_dir” && break done test -z “$as_dirs” || eval “mkdir $as_dirs” } || test -d “$as_dir” || { { echo “$as_me:$LINENO: error: cannot create directory $as_dir” >&5 echo “$as_me: error: cannot create directory $as_dir” >&2;} { (exit 1); exit 1; }; }; } ac_builddir=.

case “$ac_dir” in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; ) ac_dir_suffix=/echo "$ac_dir" | sed 's,^\.[\\/],,' # A “..” for each directory in $ac_dir_suffix. ac_top_builddir_sub=echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,' case $ac_top_builddir_sub in “”) ac_top_builddir_sub=. ac_top_build_prefix= ;; ) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix

for backward compatibility:

ac_top_builddir=$ac_top_build_prefix

case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\/] | ?:[\/] ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

case $ac_mode in :F) # # CONFIG_FILE #

case $INSTALL in [\/$] | ?:[\/] ) ac_INSTALL=$INSTALL ;; ) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\/$] | ?:[\/] ) ;; /*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac _ACEOF

cat >>$CONFIG_STATUS <<_ACEOF

If the template does not know about datarootdir, expand it.

FIXME: This hack should be removed a few years after 2.60.

ac_datarootdir_hack=; ac_datarootdir_seen=

case sed -n '/datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p ' $ac_file_inputs in datarootdir) ac_datarootdir_seen=yes;; @datadir@|@docdir@|@infodir@|@localedir@|@mandir@) { echo “$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the –datarootdir setting” >&5 echo “$as_me: WARNING: $ac_file_inputs seems to ignore the –datarootdir setting” >&2;} ACEOF cat >>$CONFIG_STATUS <<ACEOF ac_datarootdir_hack=‘ s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\${datarootdir}&$datarootdir&g’ ;; esac _ACEOF

Neutralize VPATH when $srcdir' =.‘.

Shell code in configure.ac might set extrasub.

FIXME: do we really want to maintain this feature?

cat >>$CONFIG_STATUS <<ACEOF sed “$ac_vpsub $extrasub ACEOF cat >>$CONFIG_STATUS <<_ACEOF :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s&@configure_input@&$configure_input&;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack ” $ac_file_inputs | sed -f “$tmp/subs-1.sed” | sed -f “$tmp/subs-2.sed” >$tmp/out

test -z “$ac_datarootdir_hack$ac_datarootdir_seen” && { ac_out=sed -n '/\${datarootdir}/p' "$tmp/out"; test -n “$ac_out”; } && { ac_out=sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"; test -z “$ac_out”; } && { echo “$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable `datarootdir' which seems to be undefined. Please make sure it is defined.” >&5 echo “$as_me: WARNING: $ac_file contains a reference to the variable `datarootdir' which seems to be undefined. Please make sure it is defined.” >&2;}

rm -f “$tmp/stdin” case $ac_file in -) cat “$tmp/out”; rm -f “$tmp/out”;; *) rm -f “$ac_file”; mv “$tmp/out” $ac_file;; esac ;; :H) # # CONFIG_HEADER # _ACEOF

Transform confdefs.h into a sed script `conftest.defines', that

substitutes the proper values into config.h.in to produce config.h.

rm -f conftest.defines conftest.tail

First, append a space to every undef/define line, to ease matching.

echo ’s/$/ /‘ >conftest.defines

Then, protect against being on the right side of a sed subst, or in

an unquoted here document, in config.status. If some macros were

called several times there might be several #defines for the same

symbol, which is useless. But do not sort them, since the last

AC_DEFINE must be honored.

ac_word_re=[$as_cr_Letters][$as_cr_alnum]*

These sed commands are passed to sed as “A NAME B PARAMS C VALUE D”, where

NAME is the cpp macro being defined, VALUE is the value it is being given.

PARAMS is the parameter list in the macro definition–in most cases, it’s

just an empty string.

ac_dA=’s,^\([ #]\)[^ ]\([ ]‘ ac_dB=’\)[ (].,\1define\2' ac_dC=‘ ’ ac_dD=‘ ,’

uniq confdefs.h | sed -n ‘ t rset :rset s/^[ ]#[ ]define[ ][ ]// t ok d :ok s/[\&,]/\&/g s/^(’“$ac_word_re”‘)(([^()]))[ ](.)/ ’“$ac_dA”‘\1’“$ac_dB”‘\2’“${ac_dC}”‘\3’“$ac_dD”‘/p s/^(’“$ac_word_re”‘)[ ](.)/’“$ac_dA”‘\1’“$ac_dB$ac_dC”‘\2’“$ac_dD”‘/p ’ >>conftest.defines

Remove the space that was appended to ease matching.

Then replace #undef with comments. This is necessary, for

example, in the case of _POSIX_SOURCE, which is predefined and required

on some systems where configure will not decide to define it.

(The regexp can be short, since the line contains either #define or #undef.)

echo ’s/ $// s,^[ #]u.,/ & /,‘ >>conftest.defines

Break up conftest.defines:

ac_max_sed_lines=50

First sed command is: sed -f defines.sed $ac_file_inputs >“$tmp/out1”

Second one is: sed -f defines.sed “$tmp/out1” >“$tmp/out2”

Third one will be: sed -f defines.sed “$tmp/out2” >“$tmp/out1”

et cetera.

ac_in=‘$ac_file_inputs’ ac_out=‘“$tmp/out1”’ ac_nxt=‘“$tmp/out2”’

while : do # Write a here document: cat >>$CONFIG_STATUS <<ACEOF # First, check the format of the line: cat >“\$tmp/defines.sed” <<\CEOF /^[ ]#[ ]undef[ ][ ]$ac_word_re[ ]\$/b def /^[ ]#[ ]define[ ][ ]*$ac_word_re[( ]/b def b :def ACEOF sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS echo ‘CEOF sed -f “$tmp/defines.sed”’ “$ac_in >$ac_out” >>$CONFIG_STATUS ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail grep . conftest.tail >/dev/null || break rm -f conftest.defines mv conftest.tail conftest.defines done rm -f conftest.defines conftest.tail

echo “ac_result=$ac_in” >>$CONFIG_STATUS cat >>$CONFIG_STATUS <<_ACEOF if test x"$ac_file" != x-; then echo “/ $configure_input /” >“$tmp/config.h” cat “$ac_result” >>“$tmp/config.h” if diff $ac_file “$tmp/config.h” >/dev/null 2>&1; then { echo “$as_me:$LINENO: $ac_file is unchanged” >&5 echo “$as_me: $ac_file is unchanged” >&6;} else rm -f $ac_file mv “$tmp/config.h” $ac_file fi else echo “/ $configure_input /” cat “$ac_result” fi rm -f “$tmp/out12” ;;

:C) { echo “$as_me:$LINENO: executing $ac_file commands” >&5 echo “$as_me: executing $ac_file commands” >&6;} ;; esac

case $ac_file$ac_mode in “po-directories”:C) for ac_file in $CONFIG_FILES; do # Support “outfile[:infile[:infile…]]” case “$ac_file” in :) ac_file=echo "$ac_file"|sed 's%:.*%%' ;; esac # PO directories have a Makefile.in generated from Makefile.in.in. case “$ac_file” in /Makefile.in) # Adjust a relative srcdir. ac_dir=echo "$ac_file"|sed 's%/[^/][^/]*$%%' ac_dir_suffix=“/echo "$ac_dir"|sed 's%^\./%%'” ac_dots=echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g' # In autoconf-2.13 it is called $ac_given_srcdir. # In autoconf-2.50 it is called $srcdir. test -n “$ac_given_srcdir” || ac_given_srcdir=“$srcdir” case “$ac_given_srcdir” in .) top_srcdir=echo $ac_dots|sed 's%/$%%' ;; /) top_srcdir=“$ac_given_srcdir” ;; ) top_srcdir=“$ac_dots$ac_given_srcdir” ;; esac # Treat a directory as a PO directory if and only if it has a # POTFILES.in file. This allows packages to have multiple PO # directories under different names or in different locations. if test -f “$ac_given_srcdir/$ac_dir/POTFILES.in”; then rm -f “$ac_dir/POTFILES” test -n “$as_me” && echo “$as_me: creating $ac_dir/POTFILES” || echo “creating $ac_dir/POTFILES” cat “$ac_given_srcdir/$ac_dir/POTFILES.in” | sed -e “/^#/d” -e “/^[ ]\$/d” -e “s,., $top_srcdir/& \\,” | sed -e “\$s/(.) \\/\1/” > “$ac_dir/POTFILES” POMAKEFILEDEPS=“POTFILES.in” # ALL_LINGUAS, POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES depend # on $ac_dir but don’t depend on user-specified configuration # parameters. if test -f “$ac_given_srcdir/$ac_dir/LINGUAS”; then # The LINGUAS file contains the set of available languages. if test -n “$OBSOLETE_ALL_LINGUAS”; then test -n “$as_me” && echo “$as_me: setting ALL_LINGUAS in configure.in is obsolete” || echo “setting ALL_LINGUAS in configure.in is obsolete” fi ALL_LINGUAS=sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS" # Hide the ALL_LINGUAS assigment from automake < 1.5. eval ‘ALL_LINGUAS’‘=$ALL_LINGUAS’ POMAKEFILEDEPS=“$POMAKEFILEDEPS LINGUAS” else # The set of available languages was given in configure.in. # Hide the ALL_LINGUAS assigment from automake < 1.5. eval ‘ALL_LINGUAS’‘=$OBSOLETE_ALL_LINGUAS’ fi # Compute POFILES # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po) # Compute UPDATEPOFILES # as $(foreach lang, $(ALL_LINGUAS), $(lang).po-update) # Compute DUMMYPOFILES # as $(foreach lang, $(ALL_LINGUAS), $(lang).nop) # Compute GMOFILES # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo) case “$ac_given_srcdir” in .) srcdirpre= ;; ) srcdirpre=‘$(srcdir)/’ ;; esac POFILES= UPDATEPOFILES= DUMMYPOFILES= GMOFILES= for lang in $ALL_LINGUAS; do POFILES=“$POFILES $srcdirpre$lang.po” UPDATEPOFILES=“$UPDATEPOFILES $lang.po-update” DUMMYPOFILES=“$DUMMYPOFILES $lang.nop” GMOFILES=“$GMOFILES $srcdirpre$lang.gmo” done # CATALOGS depends on both $ac_dir and the user’s LINGUAS # environment variable. INST_LINGUAS= if test -n “$ALL_LINGUAS”; then for presentlang in $ALL_LINGUAS; do useit=no if test “%UNSET%” != “$LINGUAS”; then desiredlanguages=“$LINGUAS” else desiredlanguages=“$ALL_LINGUAS” fi for desiredlang in $desiredlanguages; do # Use the presentlang catalog if desiredlang is # a. equal to presentlang, or # b. a variant of presentlang (because in this case, # presentlang can be used as a fallback for messages # which are not translated in the desiredlang catalog). case “$desiredlang” in “$presentlang”) useit=yes;; esac done if test $useit = yes; then INST_LINGUAS=“$INST_LINGUAS $presentlang” fi done fi CATALOGS= if test -n “$INST_LINGUAS”; then for lang in $INST_LINGUAS; do CATALOGS=“$CATALOGS $lang.gmo” done fi test -n “$as_me” && echo “$as_me: creating $ac_dir/Makefile” || echo “creating $ac_dir/Makefile” sed -e “/^POTFILES =/r $ac_dir/POTFILES” -e “/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars” -e “s|@POFILES@|$POFILES|g” -e “s|@UPDATEPOFILES@|$UPDATEPOFILES|g” -e “s|@DUMMYPOFILES@|$DUMMYPOFILES|g” -e “s|@GMOFILES@|$GMOFILES|g” -e “s|@CATALOGS@|$CATALOGS|g” -e “s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g” “$ac_dir/Makefile.in” > “$ac_dir/Makefile” for f in “$ac_given_srcdir/$ac_dir”/Rules-; do if test -f “$f”; then case “$f” in .orig | .bak | ~) ;; *) cat “$f” >> “$ac_dir/Makefile” ;; esac fi done fi ;; esac done ;;

esac done # for ac_tag

{ (exit 0); exit 0; } _ACEOF chmod +x $CONFIG_STATUS ac_clean_files=$ac_clean_files_save

configure is writing to config.log, and then calls config.status.

config.status does its own redirection, appending to config.log.

Unfortunately, on DOS this fails, as config.log is still kept open

by configure, so config.status won’t be able to write to it; its

output is simply discarded. So we exec the FD to /dev/null,

effectively closing config.log, so it can be properly (re)opened and

appended to by config.status. When coming back to configure, we

need to make the FD available again.

if test “$no_create” != yes; then ac_cs_success=: ac_config_status_args= test “$silent” = yes && ac_config_status_args=“$ac_config_status_args –quiet” exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || { (exit 1); exit 1; } fi

{ echo “$as_me:$LINENO: Configured sitecopy $PACKAGE_VERSION:

Install prefix: ${prefix} Compiler: ${CC} Frontend: ${fe_msg} (executable named ‘${TARGET}’) Supported protocols: ${proto_msg} neon library: ${neon_library_message} XML Parser: ${neon_xml_parser_message} SSL library: ${ne_SSL_message} Internationalization: ${nls_msg} “ >&5 echo ”$as_me: Configured sitecopy $PACKAGE_VERSION:

Install prefix: ${prefix} Compiler: ${CC} Frontend: ${fe_msg} (executable named ‘${TARGET}’) Supported protocols: ${proto_msg} neon library: ${neon_library_message} XML Parser: ${neon_xml_parser_message} SSL library: ${ne_SSL_message} Internationalization: ${nls_msg} “ >&6;}

if test “$enable_gnomefe” = “yes”; then { echo “$as_me:$LINENO: The GNOME frontend is currently unmaintained.” >&5 echo “$as_me: The GNOME frontend is currently unmaintained.” >&6;} fi

Create all the necessary directories for VPATH builds.

for i in gnome src intl lib/expat lib/expat/xmltok lib/expat/gennmtab \ lib/expat/xmlparse; do test -d $i || mkdir $i done