"Fossies" - the Fresh Open Source Software Archive

Member "gftp-2.0.19/configure" (30 Nov 2008, 584166 Bytes) of archive /linux/misc/gftp-2.0.19.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.

#

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= PACKAGE_TARNAME= PACKAGE_VERSION= PACKAGE_STRING= PACKAGE_BUGREPORT=

ac_unique_file=“lib/gftp.h”

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"

ac_header_list= 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 INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE amleading_dot AMTAR amtar amuntar CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR aminclude amquote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE amfastdepCC_TRUE am__fastdepCC_FALSE CPP GREP EGREP PREFIX build build_cpu build_vendor build_os host host_cpu host_vendor host_os RANLIB GETCONF U ANSI2KNR MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT LN_S ALLOCA PKG_CONFIG GLIB_CFLAGS GLIB_LIBS GLIB_CONFIG EXTRA_LIBS READLINE_LIBS GFTP_TEXT GTK_CFLAGS GTK_LIBS GTK_CONFIG PTHREAD_CFLAGS PTHREAD_LIBS GTHREAD_LIBS GFTP_GTK SSL_LIBS USE_NLS GETTEXT_MACRO_VERSION MSGFMT GMSGFMT MSGFMT_015 GMSGFMT_015 XGETTEXT XGETTEXT_015 MSGMERGE XGETTEXT_EXTRA_OPTIONS GLIBC2 CFLAG_VISIBILITY HAVE_VISIBILITY 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 DB2HTML HAVE_DOCBOOK_TRUE HAVE_DOCBOOK_FALSE LIBOBJS LTLIBOBJS’ ac_subst_files=‘’ ac_precious_vars=‘build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP PKG_CONFIG GLIB_CFLAGS GLIB_LIBS GTK_CFLAGS GTK_LIBS’

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}’ 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 this package 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/PACKAGE] –htmldir=DIR html documentation [DOCDIR] –dvidir=DIR dvi documentation [DOCDIR] –pdfdir=DIR pdf documentation [DOCDIR] –psdir=DIR ps documentation [DOCDIR] _ACEOF

cat <<_ACEOF

Program names: –program-prefix=PREFIX prepend PREFIX to installed program names –program-suffix=SUFFIX append SUFFIX to installed program names –program-transform-name=PROGRAM run sed PROGRAM on installed program names

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

cat <<_ACEOF

Optional Features: –disable-FEATURE do not include FEATURE (same as –enable-FEATURE=no) –enable-FEATURE[=ARG] include FEATURE [ARG=yes] –disable-dependency-tracking speeds up one-time build –enable-dependency-tracking do not reject slow dependency extractors –disable-gtk20 Don’t look for GTK+ 2.0 libraries –disable-gtkport Disable compiling the GTK+ port –disable-textport Disable compiling the text port –disable-ssl Disable SSL support –disable-largefile omit support for large files –enable-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer –disable-glibtest Do not try to compile and run a test GLIB program –disable-gtktest Do not try to compile and run a test GTK program –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

Optional Packages: –with-PACKAGE[=ARG] use PACKAGE [ARG=yes] –without-PACKAGE do not use PACKAGE (same as –with-PACKAGE=no) –with-glib-prefix=PFX Prefix where GLIB is installed (optional) –with-glib-exec-prefix=PFX Exec prefix where GLIB is installed (optional) –with-readline turn on readline default=yes, default tries -lncurses, -lcurses, -ltermcap –with-dmalloc use dmalloc, as in http://www.dmalloc.com/dmalloc.tar.gz –with-gtk-prefix=PFX Prefix where GTK is installed (optional) –with-gtk-exec-prefix=PFX Exec prefix where GTK is installed (optional) –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 PKG_CONFIG path to pkg-config utility GLIB_CFLAGS C compiler flags for GLIB, overriding pkg-config GLIB_LIBS linker flags for GLIB, overriding pkg-config GTK_CFLAGS C compiler flags for GTK, overriding pkg-config GTK_LIBS linker flags for GTK, overriding pkg-config

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

_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 configure 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 $as_me, 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

ac_header_list=“$ac_header_list utime.h” 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”

am__api_version=“1.9” 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’

{ echo “$as_me:$LINENO: checking whether build environment is sane” >&5 echo $ECHO_N “checking whether build environment is sane… $ECHO_C” >&6; }

Just in case

sleep 1 echo timestamp > conftest.file

Do `set' in a subshell so we don’t clobber the current shell’s

arguments. Must try -L first in case configure is actually a

symlink; some systems play weird games with the mod time of symlinks

(eg FreeBSD returns the mod time of the symlink’s containing

directory).

if ( set X ls -Lt $srcdir/configure conftest.file 2> /dev/null if test “$” = “X”; then # -L didn’t work. set X ls -t $srcdir/configure conftest.file fi rm -f conftest.file if test “$” != “X $srcdir/configure conftest.file” \ && test “$*” != “X conftest.file $srcdir/configure”; then

  # If neither matched, then we have a broken ls.  This can happen
  # if, for instance, CONFIG_SHELL is bash and it inherits a
  # broken ls alias from the environment.  This has actually
  # happened.  Such a system could not be considered "sane".
  { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken

alias in your environment" >&5 echo “$as_me: error: ls -t appears to fail. Make sure there is not a broken alias in your environment” >&2;} { (exit 1); exit 1; }; } fi

test “$2” = conftest.file ) then # Ok. : else { { echo “$as_me:$LINENO: error: newly created file is older than distributed files! Check your system clock” >&5 echo “$as_me: error: newly created file is older than distributed files! Check your system clock” >&2;} { (exit 1); exit 1; }; } fi { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } test “$program_prefix” != NONE && program_transform_name=“s&^&$program_prefix&;$program_transform_name”

Use a double $ so make ignores it.

test “$program_suffix” != NONE && program_transform_name=“s&\$&$program_suffix&;$program_transform_name”

Double any \ or $. echo might interpret backslashes.

By default was `s,x,x', remove it if useless.

cat <<_ACEOF >conftest.sed s/[\$]/&&/g;s/;s,x,x,$// _ACEOF program_transform_name=echo $program_transform_name | sed -f conftest.sed rm -f conftest.sed

expand $ac_aux_dir to an absolute path

am_aux_dir=cd $ac_aux_dir && pwd

test x"${MISSING+set}“ = xset || MISSING=”\${SHELL} $am_aux_dir/missing"

Use eval to expand $SHELL

if eval “$MISSING –run true”; then am_missing_run=“$MISSING –run ” else am_missing_run= { echo “$as_me:$LINENO: WARNING: `missing' script is too old or missing” >&5 echo “$as_me: WARNING: `missing' script is too old or missing” >&2;} fi

if mkdir -p –version . >/dev/null 2>&1 && test ! -d ./–version; then # We used to keeping the .' as first argument, in order to # allow $(mkdir_p) to be used without argument. As in # $(mkdir_p) $(somedir) # where $(somedir) is conditionally defined. However this is wrong # for two reasons: # 1. if the package is installed by a user who cannot write.‘ # make install will fail, # 2. the above comment should most certainly read # $(mkdir_p) $(DESTDIR)$(somedir) # so it does not work when $(somedir) is undefined and # $(DESTDIR) is not. # To support the latter case, we have to write # test -z “$(somedir)” || $(mkdir_p) $(DESTDIR)$(somedir), # so the .' trick is pointless. mkdir_p='mkdir -p --' else # On NextStep and OpenStep, themkdir’ command does not # recognize any option. It will interpret all options as # directories to create, and then abort because `.‘ already # exists. for d in ./-p ./–version; do test -d $d && rmdir $d done # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists. if test -f “$ac_aux_dir/mkinstalldirs”; then mkdir_p=’$(mkinstalldirs)‘ else mkdir_p=’$(install_sh) -d' fi fi

for ac_prog in gawk mawk nawk awk 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_AWK+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$AWK”; then ac_cv_prog_AWK=“$AWK” # 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_AWK=“$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 AWK=$ac_cv_prog_AWK if test -n “$AWK”; then { echo “$as_me:$LINENO: result: $AWK” >&5 echo “${ECHO_T}$AWK” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

test -n “$AWK” && break done

{ 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

rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then amleading_dot=. else amleading_dot=_ fi rmdir .tst 2>/dev/null

test to see if srcdir already configured

if test “cd $srcdir && pwd” != “pwd” && test -f $srcdir/config.status; then { { echo “$as_me:$LINENO: error: source directory already configured; run \"make distclean\” there first" >&5 echo “$as_me: error: source directory already configured; run \"make distclean\” there first" >&2;} { (exit 1); exit 1; }; } fi

test whether we have cygpath

if test -z “$CYGPATH_W”; then if (cygpath –version) >/dev/null 2>/dev/null; then CYGPATH_W=‘cygpath -w’ else CYGPATH_W=echo fi fi

Define the identity of the package.

PACKAGE=gftp VERSION=2.0.19

cat >>confdefs.h <<_ACEOF

define PACKAGE “$PACKAGE”

_ACEOF

cat >>confdefs.h <<_ACEOF

define VERSION “$VERSION”

_ACEOF

Some tools Automake needs.

ACLOCAL=${ACLOCAL-“${am_missing_run}aclocal-${am__api_version}”}

AUTOCONF=${AUTOCONF-“${am_missing_run}autoconf”}

AUTOMAKE=${AUTOMAKE-“${am_missing_run}automake-${am__api_version}”}

AUTOHEADER=${AUTOHEADER-“${am_missing_run}autoheader”}

MAKEINFO=${MAKEINFO-“${am_missing_run}makeinfo”}

install_sh=${install_sh-“$am_aux_dir/install-sh”}

Installed binaries are usually stripped using `strip' when the user

run make install-strip'. Howeverstrip' might not be the right

tool to use in cross-compilation environments, therefore Automake

will honor the `STRIP' environment variable to overrule this program.

if test “$cross_compiling” != no; then if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}strip”, so it can be a program name with args. set dummy ${ac_tool_prefix}strip; 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_STRIP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$STRIP”; then ac_cv_prog_STRIP=“$STRIP” # 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_STRIP=“${ac_tool_prefix}strip” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

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

fi if test -z “$ac_cv_prog_STRIP”; then ac_ct_STRIP=$STRIP # Extract the first word of “strip”, so it can be a program name with args. set dummy strip; 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_STRIP+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_STRIP”; then ac_cv_prog_ac_ct_STRIP=“$ac_ct_STRIP” # 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_STRIP=“strip” 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_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n “$ac_ct_STRIP”; then { echo “$as_me:$LINENO: result: $ac_ct_STRIP” >&5 echo “${ECHO_T}$ac_ct_STRIP” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_ct_STRIP” = x; then STRIP=“:” 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 STRIP=$ac_ct_STRIP fi else STRIP=“$ac_cv_prog_STRIP” fi

fi INSTALL_STRIP_PROGRAM=“\${SHELL} \$(install_sh) -c -s”

We need awk for the “check” target. The system “awk” is bad on

some platforms.

Always define AMTAR for backward compatibility.

AMTAR=${AMTAR-“${am_missing_run}tar”}

amtar=‘${AMTAR} chof - “$$tardir”’; amuntar=‘${AMTAR} xf -’

cat >>confdefs.h <<_ACEOF

define _GNU_SOURCE 1

_ACEOF

DEPDIR=“${am__leading_dot}deps”

ac_config_commands=“$ac_config_commands depfiles”

am_make=${MAKE-make} cat > confinc << ‘END’ amdoit: @echo done .PHONY: amdoit END

If we don’t find an include directive, just comment out the code.

{ echo “$as_me:$LINENO: checking for style of include used by $am_make” >&5 echo $ECHO_N “checking for style of include used by $am_make… $ECHO_C” >&6; } aminclude=“#” amquote= _am_result=none

First try GNU make style include.

echo “include confinc” > confmf

We grep out Entering directory' andLeaving directory'

messages which can occur if `w' ends up in MAKEFLAGS.

In particular we don’t look at `^make:‘ because GNU make might

be invoked under some other name (usually “gmake”), in which

case it prints its new name instead of `make'.

if test “$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'” = “done”; then aminclude=include amquote= _am_result=GNU fi

Now try BSD make style include.

if test “$aminclude” = “#”; then echo ‘.include “confinc”’ > confmf if test “$am_make -s -f confmf 2> /dev/null” = “done”; then aminclude=.include am_quote=“\”“ am_result=BSD fi fi

{ echo “$as_me:$LINENO: result: $am_result” >&5 echo “${ECHO_T}$am_result” >&6; } rm -f confinc confmf

Check whether –enable-dependency-tracking was given.

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

if test “x$enable_dependency_tracking” != xno; then am_depcomp=“$ac_aux_dir/depcomp” AMDEPBACKSLASH=‘\’ fi

if test “x$enable_dependency_tracking” != xno; then AMDEP_TRUE= AMDEP_FALSE=‘#’ else AMDEP_TRUE=‘#’ AMDEP_FALSE= 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

depcc=“$CC” am_compiler_list=

{ echo “$as_me:$LINENO: checking dependency style of $depcc” >&5 echo $ECHO_N “checking dependency style of $depcc… $ECHO_C” >&6; } if test “${am_cv_CC_dependencies_compiler_type+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -z “$AMDEP_TRUE” && test -f “$am_depcomp”; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don’t know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named D' -- because-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won’t find it if we’re # using a relative directory. cp “$am_depcomp” conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64’s cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub

am_cv_CC_dependencies_compiler_type=none if test “$am_compiler_list” = “”; then am_compiler_list=sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp fi for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with ), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo ‘#include “conftst’$i'.h”‘ >> sub/conftest.c # Using `: > sub/conftst$i.h’ creates only sub/conftst1.h with # Solaris 8’s {/usr,}/bin/sh. touch sub/conftst$i.h done echo “${aminclude} ${amquote}sub/conftest.Po${am__quote}” > confmf

case $depmode in
nosideeffect)
  # after this tag, mechanisms are not by side-effect, so they'll
  # only be used when explicitly requested
  if test "x$enable_dependency_tracking" = xyes; then
continue
  else
break
  fi
  ;;
none) break ;;
esac
# We check with `-c' and `-o' for the sake of the "dashmstdout"
# mode.  It turns out that the SunPro C++ compiler does not properly
# handle `-M -o', and we need to detect this.
if depmode=$depmode \
   source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
   depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
   $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
     >/dev/null 2>conftest.err &&
   grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
   grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
   ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
  # icc doesn't choke on unknown options, it will just issue warnings
  # or remarks (even with -Werror).  So we grep stderr for any message
  # that says an option was ignored or not supported.
  # When given -MP, icc 7.0 and 7.1 complain thusly:
  #   icc: Command line warning: ignoring option '-M'; no argument required
  # The diagnosis changed in icc 8.0:
  #   icc: Command line remark: option '-MP' not supported
  if (grep 'ignoring option' conftest.err ||
      grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
    am_cv_CC_dependencies_compiler_type=$depmode
    break
  fi
fi

done

cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi

fi { echo “$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type” >&5 echo “${ECHO_T}$am_cv_CC_dependencies_compiler_type” >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

if test “x$enable_dependency_tracking” != xno \ && test “$am_cv_CC_dependencies_compiler_type” = gcc3; then amfastdepCC_TRUE= amfastdepCC_FALSE=‘#’ else amfastdepCC_TRUE=‘#’ amfastdepCC_FALSE= 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 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*

{ 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

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

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;}

;;

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-gtk20 was given.

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

Check whether –enable-gtkport was given.

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

Check whether –enable-textport was given.

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

Check whether –enable-ssl was given.

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

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

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); }

{ 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

depcc=“$CC” am_compiler_list=

{ echo “$as_me:$LINENO: checking dependency style of $depcc” >&5 echo $ECHO_N “checking dependency style of $depcc… $ECHO_C” >&6; } if test “${am_cv_CC_dependencies_compiler_type+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -z “$AMDEP_TRUE” && test -f “$am_depcomp”; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don’t know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named D' -- because-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won’t find it if we’re # using a relative directory. cp “$am_depcomp” conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64’s cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub

am_cv_CC_dependencies_compiler_type=none if test “$am_compiler_list” = “”; then am_compiler_list=sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp fi for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with ), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo ‘#include “conftst’$i'.h”‘ >> sub/conftest.c # Using `: > sub/conftst$i.h’ creates only sub/conftst1.h with # Solaris 8’s {/usr,}/bin/sh. touch sub/conftst$i.h done echo “${aminclude} ${amquote}sub/conftest.Po${am__quote}” > confmf

case $depmode in
nosideeffect)
  # after this tag, mechanisms are not by side-effect, so they'll
  # only be used when explicitly requested
  if test "x$enable_dependency_tracking" = xyes; then
continue
  else
break
  fi
  ;;
none) break ;;
esac
# We check with `-c' and `-o' for the sake of the "dashmstdout"
# mode.  It turns out that the SunPro C++ compiler does not properly
# handle `-M -o', and we need to detect this.
if depmode=$depmode \
   source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
   depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
   $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
     >/dev/null 2>conftest.err &&
   grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
   grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
   ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
  # icc doesn't choke on unknown options, it will just issue warnings
  # or remarks (even with -Werror).  So we grep stderr for any message
  # that says an option was ignored or not supported.
  # When given -MP, icc 7.0 and 7.1 complain thusly:
  #   icc: Command line warning: ignoring option '-M'; no argument required
  # The diagnosis changed in icc 8.0:
  #   icc: Command line remark: option '-MP' not supported
  if (grep 'ignoring option' conftest.err ||
      grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
    am_cv_CC_dependencies_compiler_type=$depmode
    break
  fi
fi

done

cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi

fi { echo “$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type” >&5 echo “${ECHO_T}$am_cv_CC_dependencies_compiler_type” >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

if test “x$enable_dependency_tracking” != xno \ && test “$am_cv_CC_dependencies_compiler_type” = gcc3; then amfastdepCC_TRUE= amfastdepCC_FALSE=‘#’ else amfastdepCC_TRUE=‘#’ amfastdepCC_FALSE= 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_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

# Check whether –enable-largefile was given. if test “${enable_largefile+set}” = set; then enableval=$enable_largefile; fi

if test “$enable_largefile” != no; then if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}getconf”, so it can be a program name with args. set dummy ${ac_tool_prefix}getconf; 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_GETCONF+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$GETCONF”; then ac_cv_prog_GETCONF=“$GETCONF” # 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_GETCONF=“${ac_tool_prefix}getconf” echo “$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

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

fi if test -z “$ac_cv_prog_GETCONF”; then ac_ct_GETCONF=$GETCONF # Extract the first word of “getconf”, so it can be a program name with args. set dummy getconf; 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_GETCONF+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$ac_ct_GETCONF”; then ac_cv_prog_ac_ct_GETCONF=“$ac_ct_GETCONF” # 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_GETCONF=“getconf” 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_GETCONF=$ac_cv_prog_ac_ct_GETCONF if test -n “$ac_ct_GETCONF”; then { echo “$as_me:$LINENO: result: $ac_ct_GETCONF” >&5 echo “${ECHO_T}$ac_ct_GETCONF” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if test “x$ac_ct_GETCONF” = x; then GETCONF=“” 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 GETCONF=$ac_ct_GETCONF fi else GETCONF=“$ac_cv_prog_GETCONF” fi

 { echo "$as_me:$LINENO: checking for CFLAGS value to request large file support" >&5

echo $ECHO_N “checking for CFLAGS value to request large file support… $ECHO_C” >&6; } if test “${ac_cv_sys_largefile_CFLAGS+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_largefile_CFLAGS=($GETCONF LFS_CFLAGS) 2>/dev/null || { ac_cv_sys_largefile_CFLAGS=no case “$host_os” in # IRIX 6.2 and later require cc -n32. irix6.[2-9] | irix6.1[0-9] | irix[7-9]. | irix[1-9][0-9]) if test “$GCC” != yes; then ac_cv_sys_largefile_CFLAGS=-n32 fi ac_save_CC=“$CC” CC=“$CC $ac_cv_sys_largefile_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 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 : else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_sys_largefile_CFLAGS=no

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext CC=“$ac_save_CC” esac } fi { echo “$as_me:$LINENO: result: $ac_cv_sys_largefile_CFLAGS” >&5 echo “${ECHO_T}$ac_cv_sys_largefile_CFLAGS” >&6; } { echo “$as_me:$LINENO: checking for LDFLAGS value to request large file support” >&5 echo $ECHO_N “checking for LDFLAGS value to request large file support… $ECHO_C” >&6; } if test “${ac_cv_sys_largefile_LDFLAGS+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_largefile_LDFLAGS=($GETCONF LFS_LDFLAGS) 2>/dev/null || { ac_cv_sys_largefile_LDFLAGS=no

  }

fi { echo “$as_me:$LINENO: result: $ac_cv_sys_largefile_LDFLAGS” >&5 echo “${ECHO_T}$ac_cv_sys_largefile_LDFLAGS” >&6; } { echo “$as_me:$LINENO: checking for LIBS value to request large file support” >&5 echo $ECHO_N “checking for LIBS value to request large file support… $ECHO_C” >&6; } if test “${ac_cv_sys_largefile_LIBS+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_largefile_LIBS=($GETCONF LFS_LIBS) 2>/dev/null || { ac_cv_sys_largefile_LIBS=no

  }

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

 for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do
   case "$ac_flag" in
   no) ;;
   -D_FILE_OFFSET_BITS=*) ;;
   -D_LARGEFILE_SOURCE | -D_LARGEFILE_SOURCE=*) ;;
   -D_LARGE_FILES | -D_LARGE_FILES=*) ;;
   -D?* | -I?*)
 case "$ac_flag" in

no) ;; ?) case “$CPPFLAGS” in ‘’) CPPFLAGS=“$ac_flag” ;; ) CPPFLAGS=$CPPFLAGS' ‘“$ac_flag” ;; esac ;; esac ;; ) case “$ac_flag” in no) ;; ?) case “$CFLAGS” in ’‘) CFLAGS=“$ac_flag” ;; ) CFLAGS=$CFLAGS’ ‘“$ac_flag” ;; esac ;; esac ;; esac done case “$ac_cv_sys_largefile_LDFLAGS” in no) ;; ?) case “$LDFLAGS” in ’‘) LDFLAGS=“$ac_cv_sys_largefile_LDFLAGS” ;; ) LDFLAGS=$LDFLAGS’ ‘“$ac_cv_sys_largefile_LDFLAGS” ;; esac ;; esac case “$ac_cv_sys_largefile_LIBS” in no) ;; ?) case “$LIBS” in ’‘) LIBS=“$ac_cv_sys_largefile_LIBS” ;; *) LIBS=$LIBS’ ‘“$ac_cv_sys_largefile_LIBS” ;; esac ;; esac { echo “$as_me:$LINENO: checking for FILE_OFFSET_BITS” >&5 echo $ECHO_N “checking for FILE_OFFSET_BITS… $ECHO_C” >&6; } if test “${ac_cv_sys_file_offset_bits+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_file_offset_bits=no

  for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do
case "$ac_flag" in
-D_FILE_OFFSET_BITS)
  ac_cv_sys_file_offset_bits=1 ;;
-D_FILE_OFFSET_BITS=*)
  ac_cv_sys_file_offset_bits=`expr " $ac_flag" : '[^=]*=\(.*\)'` ;;
esac
  done

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

cat >>confdefs.h <<_ACEOF

define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits

_ACEOF

fi { echo “$as_me:$LINENO: checking for LARGEFILE_SOURCE” >&5 echo $ECHO_N “checking for LARGEFILE_SOURCE… $ECHO_C” >&6; } if test “${ac_cv_sys_largefile_source+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_largefile_source=no case “$host_os” in # HP-UX 10.20 and later hpux10.[2-9][0-9] | hpux1[1-9] | hpux[2-9][0-9]) ac_cv_sys_largefile_source=1 ;; esac for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do case “$ac_flag” in -D_LARGEFILE_SOURCE) ac_cv_sys_largefile_source=1 ;; -D_LARGEFILE_SOURCE=) ac_cv_sys_largefile_source=expr " $ac_flag" : '[^=]*=\(.*\)' ;; esac done

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

cat >>confdefs.h <<_ACEOF

define _LARGEFILE_SOURCE $ac_cv_sys_largefile_source

_ACEOF

fi { echo “$as_me:$LINENO: checking for LARGE_FILES” >&5 echo $ECHO_N “checking for LARGE_FILES… $ECHO_C” >&6; } if test “${ac_cv_sys_large_files+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_cv_sys_large_files=no case “$host_os” in # AIX 4.2 and later aix4.[2-9] | aix4.1[0-9] | aix[5-9]. | aix[1-9][0-9]) ac_cv_sys_large_files=1 ;; esac for ac_flag in $ac_cv_sys_largefile_CFLAGS no; do case “$ac_flag” in -D_LARGE_FILES) ac_cv_sys_large_files=1 ;; -D_LARGE_FILES=*) ac_cv_sys_large_files=expr " $ac_flag" : '[^=]*=\(.*\)' ;; esac done

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

cat >>confdefs.h <<_ACEOF

define _LARGE_FILES $ac_cv_sys_large_files

_ACEOF

fi fi

{ echo “$as_me:$LINENO: checking for function prototypes” >&5 echo $ECHO_N “checking for function prototypes… $ECHO_C” >&6; } if test “$ac_cv_prog_cc_c89” != no; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; }

cat >>confdefs.h <<_ACEOF

define PROTOTYPES 1

_ACEOF

cat >>confdefs.h <<_ACEOF

define __PROTOTYPES 1

_ACEOF

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

if test “$ac_cv_prog_cc_stdc” != no; then U= ANSI2KNR= else U=_ ANSI2KNR=./ansi2knr fi

Ensure some checks needed by ansi2knr itself.

for ac_header in 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;}

;;

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 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

{ 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 whether the printf family of functions supports %‘ld” >&5 echo $ECHO_N “checking whether the printf family of functions supports %'ld… $ECHO_C” >&6; } if test “$cross_compiling” = yes; then { { echo “$as_me:$LINENO: error: cannot run test program while cross compiling See `config.log’ for more details.” >&5 echo “$as_me: error: cannot run test program while cross compiling See `config.log' for more details.” >&2;} { (exit 1); exit 1; }; } 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>

           int main(void) {
             char buf[20];

if defined (_LARGEFILE_SOURCE)

             sprintf (buf, "%'lld", (long) 1);

else

             sprintf (buf, "%'ld", (long) 1);

endif

             if (strchr (buf, '1') == NULL)
               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

cat >>confdefs.h <<_ACEOF

define HAVE_INTL_PRINTF 1

_ACEOF

 { echo "$as_me:$LINENO: result: yes" >&5

echo “${ECHO_T}yes” >&6; } 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 ) { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

{ echo “$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles” >&5 echo $ECHO_N “checking whether to enable maintainer-specific portions of Makefiles… $ECHO_C” >&6; } # Check whether –enable-maintainer-mode was given. if test “${enable_maintainer_mode+set}” = set; then enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval else USE_MAINTAINER_MODE=no fi

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

if test $USE_MAINTAINER_MODE = yes; then MAINTAINER_MODE_TRUE= MAINTAINER_MODE_FALSE=‘#’ else MAINTAINER_MODE_TRUE=‘#’ MAINTAINER_MODE_FALSE= fi

MAINT=$MAINTAINER_MODE_TRUE

for ac_prog in gawk mawk nawk awk 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_AWK+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$AWK”; then ac_cv_prog_AWK=“$AWK” # 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_AWK=“$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 AWK=$ac_cv_prog_AWK if test -n “$AWK”; then { echo “$as_me:$LINENO: result: $AWK” >&5 echo “${ECHO_T}$AWK” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

test -n “$AWK” && break done

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’

{ echo “$as_me:$LINENO: checking whether ln -s works” >&5 echo $ECHO_N “checking whether ln -s works… $ECHO_C” >&6; } LN_S=$as_ln_s if test “$LN_S” = “ln -s”; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } else { echo “$as_me:$LINENO: result: no, using $LN_S” >&5 echo “${ECHO_T}no, using $LN_S” >&6; } fi

{ 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

ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do as_ac_Header=echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh { echo “$as_me:$LINENO: checking for $ac_hdr that defines DIR” >&5 echo $ECHO_N “checking for $ac_hdr that defines DIR… $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. /

include <sys/types.h>

include <$ac_hdr>

int main () { if ((DIR ) 0) 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 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_hdr" | $as_tr_cpp 1

_ACEOF

ac_header_dirent=$ac_hdr; break fi

done

Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.

if test $ac_header_dirent = dirent.h; then { echo “$as_me:$LINENO: checking for library containing opendir” >&5 echo $ECHO_N “checking for library containing opendir… $ECHO_C” >&6; } if test “${ac_cv_search_opendir+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 opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in ‘’ dir; 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_opendir=$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_opendir+set}” = set; then break fi done if test “${ac_cv_search_opendir+set}” = set; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_search_opendir” >&5 echo “${ECHO_T}$ac_cv_search_opendir” >&6; } ac_res=$ac_cv_search_opendir if test “$ac_res” != no; then test “$ac_res” = “none required” || LIBS=“$ac_res $LIBS”

fi

else { echo “$as_me:$LINENO: checking for library containing opendir” >&5 echo $ECHO_N “checking for library containing opendir… $ECHO_C” >&6; } if test “${ac_cv_search_opendir+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 opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in ‘’ x; 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_opendir=$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_opendir+set}” = set; then break fi done if test “${ac_cv_search_opendir+set}” = set; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { echo “$as_me:$LINENO: result: $ac_cv_search_opendir” >&5 echo “${ECHO_T}$ac_cv_search_opendir” >&6; } ac_res=$ac_cv_search_opendir if test “$ac_res” != no; then test “$ac_res” = “none required” || LIBS=“$ac_res $LIBS”

fi

fi

{ 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

{ echo “$as_me:$LINENO: checking for sys/wait.h that is POSIX.1 compatible” >&5 echo $ECHO_N “checking for sys/wait.h that is POSIX.1 compatible… $ECHO_C” >&6; } if test “${ac_cv_header_sys_wait_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 <sys/wait.h>

ifndef WEXITSTATUS

define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)

endif

ifndef WIFEXITED

define WIFEXITED(stat_val) (((stat_val) & 255) == 0)

endif

int main () { int s; wait (&s); s = WIFEXITED (s) ? WEXITSTATUS (s) : 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_header_sys_wait_h=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_header_sys_wait_h=no

fi

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

cat >>confdefs.h <<_ACEOF

define HAVE_SYS_WAIT_H 1

_ACEOF

fi

for ac_header in fcntl.h libutil.h limits.h malloc.h pty.h strings.h sys/ioctl.h sys/time.h unistd.h stdint.h sys/mkdev.h 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;}

;;

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 socklen_t in sys/socket.h” >&5 echo $ECHO_N “checking for socklen_t in sys/socket.h… $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. /

define _POSIX_PII_SOCKET

#include <sys/types.h> #include <sys/socket.h> int main () { socklen_t x = 5; ; 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 { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >>confdefs.h <<_ACEOF

define socklen_t int

_ACEOF

  { echo "$as_me:$LINENO: result: no" >&5

echo “${ECHO_T}no” >&6; } fi

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

{ echo “$as_me:$LINENO: checking for mode_t” >&5 echo $ECHO_N “checking for mode_t… $ECHO_C” >&6; } if test “${ac_cv_type_mode_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 mode_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_mode_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_mode_t=no

fi

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

cat >>confdefs.h <<_ACEOF

define mode_t int

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for intptr_t in stdint.h” >&5 echo $ECHO_N “checking for intptr_t in stdint.h… $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 <stdint.h>

int main () { intptr_t i = 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 { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

cat >>confdefs.h <<_ACEOF

define intptr_t long

_ACEOF

  { echo "$as_me:$LINENO: result: no" >&5

echo “${ECHO_T}no” >&6; } fi

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

{ echo “$as_me:$LINENO: checking for pid_t” >&5 echo $ECHO_N “checking for pid_t… $ECHO_C” >&6; } if test “${ac_cv_type_pid_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 pid_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_pid_t=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_pid_t=no

fi

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

cat >>confdefs.h <<_ACEOF

define pid_t int

_ACEOF

fi

{ 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 whether time.h and sys/time.h may both be included” >&5 echo $ECHO_N “checking whether time.h and sys/time.h may both be included… $ECHO_C” >&6; } if test “${ac_cv_header_time+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/time.h>

include <time.h>

int main () { if ((struct tm ) 0) 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_header_time=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_header_time=no

fi

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

cat >>confdefs.h <<_ACEOF

define TIME_WITH_SYS_TIME 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking whether struct tm is in sys/time.h or time.h” >&5 echo $ECHO_N “checking whether struct tm is in sys/time.h or time.h… $ECHO_C” >&6; } if test “${ac_cv_struct_tm+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 () { struct tm tm; int p = &tm.tm_sec; return !p; ; 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_struct_tm=time.h else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_struct_tm=sys/time.h

fi

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

cat >>confdefs.h <<_ACEOF

define TM_IN_SYS_TIME 1

_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; }

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 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 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 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_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

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

if test $ac_cv_c_compiler_gnu = yes; then { echo “$as_me:$LINENO: checking whether $CC needs -traditional” >&5 echo $ECHO_N “checking whether $CC needs -traditional… $ECHO_C” >&6; } if test “${ac_cv_prog_gcc_traditional+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_pattern=“Autoconf.‘x’” cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <sgtty.h>

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

if test $ac_cv_prog_gcc_traditional = no; then cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <termio.h>

Autoconf TCGETA _ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “$ac_pattern” >/dev/null 2>&1; then ac_cv_prog_gcc_traditional=yes fi rm -f conftest*

fi fi { echo “$as_me:$LINENO: result: $ac_cv_prog_gcc_traditional” >&5 echo “${ECHO_T}$ac_cv_prog_gcc_traditional” >&6; } if test $ac_cv_prog_gcc_traditional = yes; then CC=“$CC -traditional” fi 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;}

;;

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 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_func in strftime 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 # strftime is in -lintl on SCO UNIX. { echo “$as_me:$LINENO: checking for strftime in -lintl” >&5 echo $ECHO_N “checking for strftime in -lintl… $ECHO_C” >&6; } if test “${ac_cv_lib_intl_strftime+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lintl $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 strftime (); int main () { return strftime (); ; 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_intl_strftime=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_intl_strftime=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_intl_strftime” >&5 echo “${ECHO_T}$ac_cv_lib_intl_strftime” >&6; } if test $ac_cv_lib_intl_strftime = yes; then cat >>confdefs.h <<_ACEOF

define HAVE_STRFTIME 1

_ACEOF

LIBS=“-lintl $LIBS” fi

fi done

for ac_header in $ac_header_list 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;}

;;

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 whether utime accepts a null argument” >&5 echo $ECHO_N “checking whether utime accepts a null argument… $ECHO_C” >&6; } if test “${ac_cv_func_utime_null+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else rm -f conftest.data; >conftest.data

Sequent interprets utime(file, 0) to mean use start of epoch. Wrong.

if test “$cross_compiling” = yes; then ac_cv_func_utime_null=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 #ifdef HAVE_UTIME_H # include <utime.h> #endif int main () { struct stat s, t; return ! (stat (“conftest.data”, &s) == 0 && utime (“conftest.data”, 0) == 0 && stat (“conftest.data”, &t) == 0 && t.st_mtime >= s.st_mtime && t.st_mtime - s.st_mtime < 120); ; 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_utime_null=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_utime_null=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_utime_null” >&5 echo “${ECHO_T}$ac_cv_func_utime_null” >&6; } if test $ac_cv_func_utime_null = yes; then

cat >>confdefs.h <<_ACEOF

define HAVE_UTIME_NULL 1

_ACEOF

fi rm -f conftest.data

for ac_func in gai_strerror getaddrinfo getcwd gettimeofday getwd mkdir mktime putenv rmdir select socket strdup strstr strtod strtol uname grantpt openpty getdtablesize 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

This is needed by fsplib. This check is from configure.ac in that distribution.

{ echo “$as_me:$LINENO: checking for union semun” >&5 echo $ECHO_N “checking for union semun… $ECHO_C” >&6; } if test “${ac_cv_type_union_semun+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/ipc.h>

include <sys/sem.h>

typedef union semun 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_union_semun=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_type_union_semun=no

fi

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

cat >>confdefs.h <<_ACEOF

define _SEM_SEMUN_UNDEFINED 1

_ACEOF

fi

if test “x$enable_gtk20” = “xyes” ; then

if test “x$ac_cv_env_PKG_CONFIG_set” != “xset”; then if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}pkg-config”, so it can be a program name with args. set dummy ${ac_tool_prefix}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

;; 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

fi if test -z “$ac_cv_path_PKG_CONFIG”; then ac_pt_PKG_CONFIG=$PKG_CONFIG # 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_ac_pt_PKG_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $ac_pt_PKG_CONFIG in [\/] | ?:[\/]) ac_cv_path_ac_pt_PKG_CONFIG=“$ac_pt_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_ac_pt_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

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

if test “x$ac_pt_PKG_CONFIG” = x; then PKG_CONFIG=“” 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 PKG_CONFIG=$ac_pt_PKG_CONFIG fi else PKG_CONFIG=“$ac_cv_path_PKG_CONFIG” fi

fi if test -n “$PKG_CONFIG”; then pkg_min_version=0.9.0 { echo “$as_me:$LINENO: checking pkg-config is at least version $pkg_min_version” >&5 echo $ECHO_N “checking pkg-config is at least version $pkg_min_version… $ECHO_C” >&6; } if $PKG_CONFIG –atleast-pkgconfig-version $pkg_min_version; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } PKG_CONFIG=“” fi

fi

pkg_failed=no { echo “$as_me:$LINENO: checking for GLIB” >&5 echo $ECHO_N “checking for GLIB… $ECHO_C” >&6; }

if test -n “$PKG_CONFIG”; then if test -n “$GLIB_CFLAGS”; then pkg_cv_GLIB_CFLAGS=“$GLIB_CFLAGS” else if test -n “$PKG_CONFIG” && \ { (echo “$as_me:$LINENO: \$PKG_CONFIG –exists –print-errors \"glib-2.0 >= 2.0.0\”“) >&5 ($PKG_CONFIG –exists –print-errors "glib-2.0 >= 2.0.0”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then pkg_cv_GLIB_CFLAGS=$PKG_CONFIG --cflags "glib-2.0 >= 2.0.0" 2>/dev/null else pkg_failed=yes fi fi else pkg_failed=untried fi if test -n “$PKG_CONFIG”; then if test -n “$GLIB_LIBS”; then pkg_cv_GLIB_LIBS=“$GLIB_LIBS” else if test -n “$PKG_CONFIG” && \ { (echo “$as_me:$LINENO: \$PKG_CONFIG –exists –print-errors \"glib-2.0 >= 2.0.0\”“) >&5 ($PKG_CONFIG –exists –print-errors "glib-2.0 >= 2.0.0”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then pkg_cv_GLIB_LIBS=$PKG_CONFIG --libs "glib-2.0 >= 2.0.0" 2>/dev/null else pkg_failed=yes fi fi else pkg_failed=untried fi

if test $pkg_failed = yes; then

if $PKG_CONFIG –atleast-pkgconfig-version 0.20; then pkg_short_errors_supported=yes else pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then GLIB_PKG_ERRORS=$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "glib-2.0 >= 2.0.0" else GLIB_PKG_ERRORS=$PKG_CONFIG --errors-to-stdout --print-errors "glib-2.0 >= 2.0.0" fi # Put the nasty error message in config.log where it belongs echo “$GLIB_PKG_ERRORS” >&5

{ echo "$as_me:$LINENO: result: no" >&5

echo “${ECHO_T}no” >&6; } found_glib20=0 elif test $pkg_failed = untried; then found_glib20=0 else GLIB_CFLAGS=$pkg_cv_GLIB_CFLAGS GLIB_LIBS=$pkg_cv_GLIB_LIBS { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } found_glib20=1 fi else found_glib20=0; fi

if test “x$GFTP_TEXT” = “x” -a $found_glib20 = 0 ; then

Check whether –with-glib-prefix was given.

if test “${with_glib_prefix+set}” = set; then withval=$with_glib_prefix; glib_config_prefix=“$withval” else glib_config_prefix=“” fi

Check whether –with-glib-exec-prefix was given.

if test “${with_glib_exec_prefix+set}” = set; then withval=$with_glib_exec_prefix; glib_config_exec_prefix=“$withval” else glib_config_exec_prefix=“” fi

Check whether –enable-glibtest was given.

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

if test x$glib_config_exec_prefix != x ; then glib_config_args=“$glib_config_args –exec-prefix=$glib_config_exec_prefix” if test x${GLIB_CONFIG+set} != xset ; then GLIB_CONFIG=$glib_config_exec_prefix/bin/glib-config fi fi if test x$glib_config_prefix != x ; then glib_config_args=“$glib_config_args –prefix=$glib_config_prefix” if test x${GLIB_CONFIG+set} != xset ; then GLIB_CONFIG=$glib_config_prefix/bin/glib-config fi fi

for module in . do case “$module” in gmodule) glib_config_args=“$glib_config_args gmodule” ;; gthread) glib_config_args=“$glib_config_args gthread” ;; esac done

# Extract the first word of “glib-config”, so it can be a program name with args. set dummy glib-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_GLIB_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $GLIB_CONFIG in [\/] | ?:[\/]) ac_cv_path_GLIB_CONFIG=“$GLIB_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_GLIB_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_GLIB_CONFIG” && ac_cv_path_GLIB_CONFIG=“no” ;; esac fi GLIB_CONFIG=$ac_cv_path_GLIB_CONFIG if test -n “$GLIB_CONFIG”; then { echo “$as_me:$LINENO: result: $GLIB_CONFIG” >&5 echo “${ECHO_T}$GLIB_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

min_glib_version=1.2.3 { echo “$as_me:$LINENO: checking for GLIB - version >= $min_glib_version” >&5 echo $ECHO_N “checking for GLIB - version >= $min_glib_version… $ECHO_C” >&6; } no_glib=“” if test “$GLIB_CONFIG” = “no” ; then no_glib=yes else GLIB_CFLAGS=$GLIB_CONFIG $glib_config_args --cflags GLIB_LIBS=$GLIB_CONFIG $glib_config_args --libs glib_config_major_version=$GLIB_CONFIG $glib_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\1/' glib_config_minor_version=$GLIB_CONFIG $glib_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\2/' glib_config_micro_version=$GLIB_CONFIG $glib_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/' if test “x$enable_glibtest” = “xyes” ; then ac_save_CFLAGS=“$CFLAGS” ac_save_LIBS=“$LIBS” CFLAGS=“$CFLAGS $GLIB_CFLAGS” LIBS=“$GLIB_LIBS $LIBS” rm -f conf.glibtest if test “$cross_compiling” = yes; then echo $ac_n “cross compiling; assumed OK… $ac_c” else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <glib.h>

include <stdio.h>

include <stdlib.h>

int main () { int major, minor, micro; char *tmp_version;

system (“touch conf.glibtest”);

/ HP/UX 9 (%@#!) writes to sscanf strings / tmp_version = g_strdup(“$min_glib_version”); if (sscanf(tmp_version, “%d.%d.%d”, &major, &minor, &micro) != 3) { printf(“%s, bad version string\n”, “$min_glib_version”); exit(1); }

if ((glib_major_version != $glib_config_major_version) || (glib_minor_version != $glib_config_minor_version) || (glib_micro_version != $glib_config_micro_version)) { printf(“\n ‘glib-config –version’ returned %d.%d.%d, but GLIB (%d.%d.%d)\n”, $glib_config_major_version, $glib_config_minor_version, $glib_config_micro_version, glib_major_version, glib_minor_version, glib_micro_version); printf (“ was found! If glib-config was correct, then it is best\n”); printf (“ to remove the old version of GLIB. You may also be able to fix the error\n”); printf(“ by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n”); printf(“ /etc/ld.so.conf. Make sure you have run ldconfig if that is\n”); printf(“ required on your system.\n”); printf(“ If glib-config was wrong, set the environment variable GLIB_CONFIG\n”); printf(“ to point to the correct copy of glib-config, and remove the file config.cache\n”); printf(“ before re-running configure\n”); } else if ((glib_major_version != GLIB_MAJOR_VERSION) || (glib_minor_version != GLIB_MINOR_VERSION) || (glib_micro_version != GLIB_MICRO_VERSION)) { printf(“ GLIB header files (version %d.%d.%d) do not match\n”, GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION); printf(“ library (version %d.%d.%d)\n”, glib_major_version, glib_minor_version, glib_micro_version); } else { if ((glib_major_version > major) || ((glib_major_version == major) && (glib_minor_version > minor)) || ((glib_major_version == major) && (glib_minor_version == minor) && (glib_micro_version >= micro))) { return 0; } else { printf(“\n An old version of GLIB (%d.%d.%d) was found.\n”, glib_major_version, glib_minor_version, glib_micro_version); printf(“ You need a version of GLIB newer than %d.%d.%d. The latest version of\n”, major, minor, micro); printf(“ GLIB is always available from ftp://ftp.gtk.org.\n”); printf(“\n”); printf(“ If you have already installed a sufficiently new version, this error\n”); printf(“ probably means that the wrong copy of the glib-config shell script is\n”); printf(“ being found. The easiest way to fix this is to remove the old version\n”); printf(“ of GLIB, but you can also set the GLIB_CONFIG environment to point to the\n”); printf(“ correct copy of glib-config. (In this case, you will have to\n”); printf(“ modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n”); printf(“ so that the correct libraries are found at run-time))\n”); } } return 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 : 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 ) no_glib=yes fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

   CFLAGS="$ac_save_CFLAGS"
   LIBS="$ac_save_LIBS"
 fi

fi if test “x$no_glib” = x ; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } : else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } if test “$GLIB_CONFIG” = “no” ; then echo “ The glib-config script installed by GLIB could not be found” echo “ If GLIB was installed in PREFIX, make sure PREFIX/bin is in” echo “ your path, or set the GLIB_CONFIG environment variable to the” echo “ full path to glib-config.” else if test -f conf.glibtest ; then : else echo “ Could not run GLIB test program, checking why…” CFLAGS=“$CFLAGS $GLIB_CFLAGS” LIBS=“$LIBS $GLIB_LIBS” cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <glib.h>

include <stdio.h>

int main () { return ((glib_major_version) || (glib_minor_version) || (glib_micro_version)); ; 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 echo “ The test program compiled, but did not run. This usually means” echo “ that the run-time linker is not finding GLIB or finding the wrong” echo “ version of GLIB. If it is not finding GLIB, you’ll need to set your” echo “ LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point” echo “ to the installed location Also, make sure you have run ldconfig if that” echo “ is required on your system” echo “” echo “ If you have an old version installed, it is best to remove it, although” echo “ you may also be able to get things to work by modifying LD_LIBRARY_PATH” echo “” echo “ If you have a RedHat 5.0 system, you should remove the GTK package that” echo “ came with the system with the command” echo “” echo “ rpm –erase –nodeps gtk gtk-devel” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

 echo "*** The test program failed to compile or link. See the file config.log for the"
      echo "*** exact error that occured. This usually means GLIB was incorrectly installed"
      echo "*** or that you have moved GLIB since it was installed. In the latter case, you"
      echo "*** may want to edit the glib-config script: $GLIB_CONFIG"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext CFLAGS=“$ac_save_CFLAGS” LIBS=“$ac_save_LIBS” fi fi GLIB_CFLAGS=“” GLIB_LIBS=“” { { echo “$as_me:$LINENO: error: gFTP needs GLIB 1.2.3 or higher” >&5 echo “$as_me: error: gFTP needs GLIB 1.2.3 or higher” >&2;} { (exit 1); exit 1; }; } fi

rm -f conf.glibtest

fi

EXTRA_LIBS=“”

FreeBSD needs this

{ echo “$as_me:$LINENO: checking for openpty in -lutil” >&5 echo $ECHO_N “checking for openpty in -lutil… $ECHO_C” >&6; } if test “${ac_cv_lib_util_openpty+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lutil $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 openpty (); int main () { return openpty (); ; 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_util_openpty=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_util_openpty=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_util_openpty” >&5 echo “${ECHO_T}$ac_cv_lib_util_openpty” >&6; } if test $ac_cv_lib_util_openpty = yes; then EXTRA_LIBS=“-lutil”

cat >>confdefs.h <<_ACEOF

define HAVE_OPENPTY 1

_ACEOF

fi

{ echo “$as_me:$LINENO: checking for socket in -lsocket” >&5 echo $ECHO_N “checking for socket in -lsocket… $ECHO_C” >&6; } if test “${ac_cv_lib_socket_socket+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lsocket $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 socket (); int main () { return 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 ac_cv_lib_socket_socket=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_socket_socket=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_socket_socket” >&5 echo “${ECHO_T}$ac_cv_lib_socket_socket” >&6; } if test $ac_cv_lib_socket_socket = yes; then EXTRA_LIBS=“-lsocket” fi

{ echo “$as_me:$LINENO: checking for gethostbyname in -lnsl” >&5 echo $ECHO_N “checking for gethostbyname in -lnsl… $ECHO_C” >&6; } if test “${ac_cv_lib_nsl_gethostbyname+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lnsl $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 gethostbyname (); int main () { return 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 ac_cv_lib_nsl_gethostbyname=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_nsl_gethostbyname=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_nsl_gethostbyname” >&5 echo “${ECHO_T}$ac_cv_lib_nsl_gethostbyname” >&6; } if test $ac_cv_lib_nsl_gethostbyname = yes; then EXTRA_LIBS=“$EXTRA_LIBS -lnsl” fi

GFTP_TEXT=“” USE_READLINE=“yes” READLINE_LIBS=“” if test “x$enable_textport” = “xyes” ; then GFTP_TEXT=“gftp-text”

{ echo “$as_me:$LINENO: checking whether to use readline” >&5 echo $ECHO_N “checking whether to use readline… $ECHO_C” >&6; }

Check whether –with-readline was given.

if test “${with_readline+set}” = set; then withval=$with_readline; case “${withval}” in yes) USE_READLINE=“yes” ; { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } ;; no) USE_READLINE=“no” ; { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } ;; only) USE_READLINE=“yes” EXTRA_LIBREADLINE_DEPS=“ ” { echo “$as_me:$LINENO: result: yes (using only readline)” >&5 echo “${ECHO_T}yes (using only readline)” >&6; } ;; *) USE_READLINE=“yes” EXTRA_LIBREADLINE_DEPS=“${withval}” { echo “$as_me:$LINENO: result: yes (using extra libraries ${withval})” >&5 echo “${ECHO_T}yes (using extra libraries ${withval})” >&6; } ;; esac else { echo “$as_me:$LINENO: result: ${USE_READLINE}” >&5 echo “${ECHO_T}${USE_READLINE}” >&6; } fi

      if test "$USE_READLINE" = yes ; then
if test "$EXTRA_LIBREADLINE_DEPS" = "" ; then
  unset ac_cv_lib_readline_readline
  { echo "$as_me:$LINENO: checking for readline in -lreadline" >&5

echo $ECHO_N “checking for readline in -lreadline… $ECHO_C” >&6; } if test “${ac_cv_lib_readline_readline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lreadline -lncurses $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 readline (); int main () { return readline (); ; 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_readline_readline=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_readline_readline=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_readline_readline” >&5 echo “${ECHO_T}$ac_cv_lib_readline_readline” >&6; } if test $ac_cv_lib_readline_readline = yes; then HAVE_LIBREADLINE=true else HAVE_LIBREADLINE=false fi

  if test x${HAVE_LIBREADLINE} = xtrue ; then
    echo "  Using -lreadline -lncurses"
    EXTRA_LIBREADLINE_DEPS=-lncurses

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 1

_ACEOF

  else
    unset ac_cv_lib_readline_readline
    { echo "$as_me:$LINENO: checking for readline in -lreadline" >&5

echo $ECHO_N “checking for readline in -lreadline… $ECHO_C” >&6; } if test “${ac_cv_lib_readline_readline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lreadline -lcurses $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 readline (); int main () { return readline (); ; 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_readline_readline=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_readline_readline=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_readline_readline” >&5 echo “${ECHO_T}$ac_cv_lib_readline_readline” >&6; } if test $ac_cv_lib_readline_readline = yes; then HAVE_LIBREADLINE=true else HAVE_LIBREADLINE=false fi

    if test x${HAVE_LIBREADLINE} = xtrue ; then
      echo "  Using -lreadline -lcurses"
      EXTRA_LIBREADLINE_DEPS=-lcurses

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 1

_ACEOF

    else
      unset ac_cv_lib_readline_readline
      { echo "$as_me:$LINENO: checking for readline in -lreadline" >&5

echo $ECHO_N “checking for readline in -lreadline… $ECHO_C” >&6; } if test “${ac_cv_lib_readline_readline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lreadline -ltermcap $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 readline (); int main () { return readline (); ; 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_readline_readline=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_readline_readline=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_readline_readline” >&5 echo “${ECHO_T}$ac_cv_lib_readline_readline” >&6; } if test $ac_cv_lib_readline_readline = yes; then HAVE_LIBREADLINE=true else HAVE_LIBREADLINE=false fi

      if test x${HAVE_LIBREADLINE} = xtrue ; then
        echo "  Using -lreadline -ltermcap"
        EXTRA_LIBREADLINE_DEPS=-ltermcap

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 1

_ACEOF

      else
        unset ac_cv_lib_readline_readline
        { echo "$as_me:$LINENO: checking for readline in -lreadline" >&5

echo $ECHO_N “checking for readline in -lreadline… $ECHO_C” >&6; } if test “${ac_cv_lib_readline_readline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lreadline $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 readline (); int main () { return readline (); ; 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_readline_readline=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_readline_readline=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_readline_readline” >&5 echo “${ECHO_T}$ac_cv_lib_readline_readline” >&6; } if test $ac_cv_lib_readline_readline = yes; then HAVE_LIBREADLINE=true else HAVE_LIBREADLINE=false fi

        if test x${HAVE_LIBREADLINE} = xtrue ; then

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 1

_ACEOF

        else

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 0

_ACEOF

        fi
      fi
    fi
  fi
else
  unset ac_cv_lib_readline_readline
  { echo "$as_me:$LINENO: checking for readline in -lreadline" >&5

echo $ECHO_N “checking for readline in -lreadline… $ECHO_C” >&6; } if test “${ac_cv_lib_readline_readline+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lreadline ${EXTRA_LIBREADLINE_DEPS} $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 readline (); int main () { return readline (); ; 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_readline_readline=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_readline_readline=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_readline_readline” >&5 echo “${ECHO_T}$ac_cv_lib_readline_readline” >&6; } if test $ac_cv_lib_readline_readline = yes; then HAVE_LIBREADLINE=true else HAVE_LIBREADLINE=false fi

  if test x${HAVE_LIBREADLINE} = xtrue ; then
    echo "  Using -lreadline ${EXTRA_LIBREADLINE_DEPS}"

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 1

_ACEOF

  else

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 0

_ACEOF

  fi
fi

else HAVE_LIBREADLINE=false

cat >>confdefs.h <<_ACEOF

define HAVE_LIBREADLINE 0

_ACEOF

fi if test x${HAVE_LIBREADLINE} = xtrue; then READLINE_LIBS=“-lreadline ${EXTRA_LIBREADLINE_DEPS}” fi fi

{ echo “$as_me:$LINENO: checking for log10 in -lm” >&5 echo $ECHO_N “checking for log10 in -lm… $ECHO_C” >&6; } if test “${ac_cv_lib_m_log10+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lm $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 log10 (); int main () { return log10 (); ; 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_m_log10=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_m_log10=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_m_log10” >&5 echo “${ECHO_T}$ac_cv_lib_m_log10” >&6; } if test $ac_cv_lib_m_log10 = yes; then EXTRA_LIBS=“$EXTRA_LIBS -lm” fi

{ echo “$as_me:$LINENO: checking if malloc debugging is wanted” >&5 echo $ECHO_N “checking if malloc debugging is wanted… $ECHO_C” >&6; }

Check whether –with-dmalloc was given.

if test “${with_dmalloc+set}” = set; then withval=$with_dmalloc; if test “$withval” = yes; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; }

cat >>confdefs.h <<_ACEOF

define WITH_DMALLOC 1

_ACEOF

LIBS=“$LIBS -ldmalloc” LDFLAGS=“$LDFLAGS -g” else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

GFTP_GTK=“” PTHREAD_CFLAGS=“” PTHREAD_LIBS=“”

I don’t have PKG_CHECK_MODULES or AM_PATH_GLIB check for gthread because

the text port doesn’t need to be compiled against the thread libraries

GTHREAD_LIBS=“”

if test “x$enable_gtkport” = “xyes” ; then if test $found_glib20 = 1 -a “x$enable_gtk20” = “xyes” ; then

pkg_failed=no { echo “$as_me:$LINENO: checking for GTK” >&5 echo $ECHO_N “checking for GTK… $ECHO_C” >&6; }

if test -n “$PKG_CONFIG”; then if test -n “$GTK_CFLAGS”; then pkg_cv_GTK_CFLAGS=“$GTK_CFLAGS” else if test -n “$PKG_CONFIG” && \ { (echo “$as_me:$LINENO: \$PKG_CONFIG –exists –print-errors \"gtk+-2.0 >= 2.0.0\”“) >&5 ($PKG_CONFIG –exists –print-errors "gtk+-2.0 >= 2.0.0”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then pkg_cv_GTK_CFLAGS=$PKG_CONFIG --cflags "gtk+-2.0 >= 2.0.0" 2>/dev/null else pkg_failed=yes fi fi else pkg_failed=untried fi if test -n “$PKG_CONFIG”; then if test -n “$GTK_LIBS”; then pkg_cv_GTK_LIBS=“$GTK_LIBS” else if test -n “$PKG_CONFIG” && \ { (echo “$as_me:$LINENO: \$PKG_CONFIG –exists –print-errors \"gtk+-2.0 >= 2.0.0\”“) >&5 ($PKG_CONFIG –exists –print-errors "gtk+-2.0 >= 2.0.0”) 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); }; then pkg_cv_GTK_LIBS=$PKG_CONFIG --libs "gtk+-2.0 >= 2.0.0" 2>/dev/null else pkg_failed=yes fi fi else pkg_failed=untried fi

if test $pkg_failed = yes; then

if $PKG_CONFIG –atleast-pkgconfig-version 0.20; then pkg_short_errors_supported=yes else pkg_short_errors_supported=no fi if test $_pkg_short_errors_supported = yes; then GTK_PKG_ERRORS=$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "gtk+-2.0 >= 2.0.0" else GTK_PKG_ERRORS=$PKG_CONFIG --errors-to-stdout --print-errors "gtk+-2.0 >= 2.0.0" fi # Put the nasty error message in config.log where it belongs echo “$GTK_PKG_ERRORS” >&5

{ echo "$as_me:$LINENO: result: no" >&5

echo “${ECHO_T}no” >&6; } { { echo “$as_me:$LINENO: error: You have GLIB 2.0 installed but I cannot find GTK+ 2.0. Run configure with –disable-gtk20 or install GTK+ 2.0” >&5 echo “$as_me: error: You have GLIB 2.0 installed but I cannot find GTK+ 2.0. Run configure with –disable-gtk20 or install GTK+ 2.0” >&2;} { (exit 1); exit 1; }; } elif test $pkg_failed = untried; then { { echo “$as_me:$LINENO: error: You have GLIB 2.0 installed but I cannot find GTK+ 2.0. Run configure with –disable-gtk20 or install GTK+ 2.0” >&5 echo “$as_me: error: You have GLIB 2.0 installed but I cannot find GTK+ 2.0. Run configure with –disable-gtk20 or install GTK+ 2.0” >&2;} { (exit 1); exit 1; }; } else GTK_CFLAGS=$pkg_cv_GTK_CFLAGS GTK_LIBS=$pkg_cv_GTK_LIBS { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } GFTP_GTK=gftp-gtk fi fi

if test “x$GFTP_GTK” = “x” ; then

Check whether –with-gtk-prefix was given.

if test “${with_gtk_prefix+set}” = set; then withval=$with_gtk_prefix; gtk_config_prefix=“$withval” else gtk_config_prefix=“” fi

Check whether –with-gtk-exec-prefix was given.

if test “${with_gtk_exec_prefix+set}” = set; then withval=$with_gtk_exec_prefix; gtk_config_exec_prefix=“$withval” else gtk_config_exec_prefix=“” fi

Check whether –enable-gtktest was given.

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

for module in . do case “$module” in gthread) gtk_config_args=“$gtk_config_args gthread” ;; esac done

if test x$gtk_config_exec_prefix != x ; then gtk_config_args=“$gtk_config_args –exec-prefix=$gtk_config_exec_prefix” if test x${GTK_CONFIG+set} != xset ; then GTK_CONFIG=$gtk_config_exec_prefix/bin/gtk-config fi fi if test x$gtk_config_prefix != x ; then gtk_config_args=“$gtk_config_args –prefix=$gtk_config_prefix” if test x${GTK_CONFIG+set} != xset ; then GTK_CONFIG=$gtk_config_prefix/bin/gtk-config fi fi

# Extract the first word of “gtk-config”, so it can be a program name with args. set dummy gtk-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_GTK_CONFIG+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else case $GTK_CONFIG in [\/] | ?:[\/]) ac_cv_path_GTK_CONFIG=“$GTK_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_GTK_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_GTK_CONFIG” && ac_cv_path_GTK_CONFIG=“no” ;; esac fi GTK_CONFIG=$ac_cv_path_GTK_CONFIG if test -n “$GTK_CONFIG”; then { echo “$as_me:$LINENO: result: $GTK_CONFIG” >&5 echo “${ECHO_T}$GTK_CONFIG” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

min_gtk_version=1.2.3 { echo “$as_me:$LINENO: checking for GTK - version >= $min_gtk_version” >&5 echo $ECHO_N “checking for GTK - version >= $min_gtk_version… $ECHO_C” >&6; } no_gtk=“” if test “$GTK_CONFIG” = “no” ; then no_gtk=yes else GTK_CFLAGS=$GTK_CONFIG $gtk_config_args --cflags GTK_LIBS=$GTK_CONFIG $gtk_config_args --libs gtk_config_major_version=$GTK_CONFIG $gtk_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\1/' gtk_config_minor_version=$GTK_CONFIG $gtk_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\2/' gtk_config_micro_version=$GTK_CONFIG $gtk_config_args --version | \ sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/' if test “x$enable_gtktest” = “xyes” ; then ac_save_CFLAGS=“$CFLAGS” ac_save_LIBS=“$LIBS” CFLAGS=“$CFLAGS $GTK_CFLAGS” LIBS=“$GTK_LIBS $LIBS” rm -f conf.gtktest if test “$cross_compiling” = yes; then echo $ac_n “cross compiling; assumed OK… $ac_c” else cat >conftest.$ac_ext <<ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<_ACEOF / end confdefs.h. /

include <gtk/gtk.h>

include <stdio.h>

include <stdlib.h>

int main () { int major, minor, micro; char *tmp_version;

system (“touch conf.gtktest”);

/ HP/UX 9 (%@#!) writes to sscanf strings / tmp_version = g_strdup(“$min_gtk_version”); if (sscanf(tmp_version, “%d.%d.%d”, &major, &minor, &micro) != 3) { printf(“%s, bad version string\n”, “$min_gtk_version”); exit(1); }

if ((gtk_major_version != $gtk_config_major_version) || (gtk_minor_version != $gtk_config_minor_version) || (gtk_micro_version != $gtk_config_micro_version)) { printf(“\n ‘gtk-config –version’ returned %d.%d.%d, but GTK+ (%d.%d.%d)\n”, $gtk_config_major_version, $gtk_config_minor_version, $gtk_config_micro_version, gtk_major_version, gtk_minor_version, gtk_micro_version); printf (“ was found! If gtk-config was correct, then it is best\n”); printf (“ to remove the old version of GTK+. You may also be able to fix the error\n”); printf(“ by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n”); printf(“ /etc/ld.so.conf. Make sure you have run ldconfig if that is\n”); printf(“ required on your system.\n”); printf(“ If gtk-config was wrong, set the environment variable GTK_CONFIG\n”); printf(“ to point to the correct copy of gtk-config, and remove the file config.cache\n”); printf(“*** before re-running configure\n”); }

if defined (GTK_MAJOR_VERSION) && defined (GTK_MINOR_VERSION) && defined (GTK_MICRO_VERSION)

else if ((gtk_major_version != GTK_MAJOR_VERSION) || (gtk_minor_version != GTK_MINOR_VERSION) || (gtk_micro_version != GTK_MICRO_VERSION)) { printf(“ GTK+ header files (version %d.%d.%d) do not match\n”, GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); printf(“ library (version %d.%d.%d)\n”, gtk_major_version, gtk_minor_version, gtk_micro_version); }

endif / defined (GTK_MAJOR_VERSION) … /

else { if ((gtk_major_version > major) || ((gtk_major_version == major) && (gtk_minor_version > minor)) || ((gtk_major_version == major) && (gtk_minor_version == minor) && (gtk_micro_version >= micro))) { return 0; } else { printf(“\n An old version of GTK+ (%d.%d.%d) was found.\n”, gtk_major_version, gtk_minor_version, gtk_micro_version); printf(“ You need a version of GTK+ newer than %d.%d.%d. The latest version of\n”, major, minor, micro); printf(“ GTK+ is always available from ftp://ftp.gtk.org.\n”); printf(“\n”); printf(“ If you have already installed a sufficiently new version, this error\n”); printf(“ probably means that the wrong copy of the gtk-config shell script is\n”); printf(“ being found. The easiest way to fix this is to remove the old version\n”); printf(“ of GTK+, but you can also set the GTK_CONFIG environment to point to the\n”); printf(“ correct copy of gtk-config. (In this case, you will have to\n”); printf(“ modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n”); printf(“*** so that the correct libraries are found at run-time))\n”); } } return 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 : 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 ) no_gtk=yes fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi

   CFLAGS="$ac_save_CFLAGS"
   LIBS="$ac_save_LIBS"
 fi

fi if test “x$no_gtk” = x ; then { echo “$as_me:$LINENO: result: yes” >&5 echo “${ECHO_T}yes” >&6; } GFTP_GTK=gftp-gtk else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } if test “$GTK_CONFIG” = “no” ; then echo “ The gtk-config script installed by GTK could not be found” echo “ If GTK was installed in PREFIX, make sure PREFIX/bin is in” echo “ your path, or set the GTK_CONFIG environment variable to the” echo “ full path to gtk-config.” else if test -f conf.gtktest ; then : else echo “ Could not run GTK test program, checking why…” CFLAGS=“$CFLAGS $GTK_CFLAGS” LIBS=“$LIBS $GTK_LIBS” cat >conftest.$ac_ext <<_ACEOF / confdefs.h. / ACEOF cat confdefs.h >>conftest.$ac_ext cat >>conftest.$ac_ext <<ACEOF / end confdefs.h. */

include <gtk/gtk.h>

include <stdio.h>

int main () { return ((gtk_major_version) || (gtk_minor_version) || (gtk_micro_version)); ; 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 echo “ The test program compiled, but did not run. This usually means” echo “ that the run-time linker is not finding GTK or finding the wrong” echo “ version of GTK. If it is not finding GTK, you’ll need to set your” echo “ LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point” echo “ to the installed location Also, make sure you have run ldconfig if that” echo “ is required on your system” echo “” echo “ If you have an old version installed, it is best to remove it, although” echo “ you may also be able to get things to work by modifying LD_LIBRARY_PATH” echo “” echo “ If you have a RedHat 5.0 system, you should remove the GTK package that” echo “ came with the system with the command” echo “” echo “ rpm –erase –nodeps gtk gtk-devel” else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

 echo "*** The test program failed to compile or link. See the file config.log for the"
      echo "*** exact error that occured. This usually means GTK was incorrectly installed"
      echo "*** or that you have moved GTK since it was installed. In the latter case, you"
      echo "*** may want to edit the gtk-config script: $GTK_CONFIG"

fi

rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ conftest$ac_exeext conftest.$ac_ext CFLAGS=“$ac_save_CFLAGS” LIBS=“$ac_save_LIBS” fi fi GTK_CFLAGS=“” GTK_LIBS=“” { echo “$as_me:$LINENO: WARNING: gFTP needs GTK+ 1.2.3 or higher for the graphical version. Only building the text version” >&5 echo “$as_me: WARNING: gFTP needs GTK+ 1.2.3 or higher for the graphical version. Only building the text version” >&2;} fi

rm -f conf.gtktest

GTHREAD_LIBS="-lgthread"

else GTHREAD_LIBS=“-lgthread-2.0” fi

if test “x$GFTP_GTK” = xgftp-gtk; then case $host in -hpux)

{ echo “$as_me:$LINENO: checking for sem_init in -lrt” >&5 echo $ECHO_N “checking for sem_init in -lrt… $ECHO_C” >&6; } if test “${ac_cv_lib_rt_sem_init+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lrt $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 sem_init (); int main () { return sem_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 ac_cv_lib_rt_sem_init=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_rt_sem_init=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_rt_sem_init” >&5 echo “${ECHO_T}$ac_cv_lib_rt_sem_init” >&6; } if test $ac_cv_lib_rt_sem_init = yes; then cat >>confdefs.h <<_ACEOF

define HAVE_LIBRT 1

_ACEOF

LIBS=“-lrt $LIBS”

fi

    # From H.Merijn Brand <h.m.brand@hccnet.nl>
    echo '#define pthread_attr_init(x) __pthread_attr_init_system(x)' >>confdefs.h
    echo '#define pthread_create(x) __pthread_create_system(x)' >>confdefs.h
    ;;
esac

{ 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 PTHREAD_LIBS=“-lpthread” fi

if test "x$PTHREAD_LIBS" = x ; then
  { echo "$as_me:$LINENO: checking for pthread_create in -lpthreads" >&5

echo $ECHO_N “checking for pthread_create in -lpthreads… $ECHO_C” >&6; } if test “${ac_cv_lib_pthreads_pthread_create+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lpthreads $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_pthreads_pthread_create=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_pthreads_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_pthreads_pthread_create” >&5 echo “${ECHO_T}$ac_cv_lib_pthreads_pthread_create” >&6; } if test $ac_cv_lib_pthreads_pthread_create = yes; then PTHREAD_LIBS=“-lpthreads” fi

fi

if test "x$PTHREAD_LIBS" = x ; then
  { echo "$as_me:$LINENO: checking for pthread_create in -lc_r" >&5

echo $ECHO_N “checking for pthread_create in -lc_r… $ECHO_C” >&6; } if test “${ac_cv_lib_c_r_pthread_create+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_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_c_r_pthread_create=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_c_r_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_c_r_pthread_create” >&5 echo “${ECHO_T}$ac_cv_lib_c_r_pthread_create” >&6; } if test $ac_cv_lib_c_r_pthread_create = yes; then PTHREAD_LIBS=“-lc_r” fi

fi

if test "x$PTHREAD_LIBS" = x ; then
  echo ;
  echo "Error: Cannot find the pthread libraries. If you don't have them installed," ;
  echo "your X libraries probably aren't thread safe either. You can download the" ;
  echo "pthread library and the thread safe X libraries from my webpage at" ;
  echo "http://www.gftp.org/. Note the pthread library and the thread safe" ;
  echo "X libraries on my webpage are for Linux libc5 machines ONLY" ;
  echo ;
  exit
fi

PTHREAD_CFLAGS="-D_REENTRANT"

# I took some of these from the glib 1.3.3 configure.in
case $host in
  *-aix*)
    PTHREAD_CFLAGS="$PTHREAD_CFLAGS -D_THREAD_SAFE"
    if test x"$GCC" = xyes; then
      PTHREAD_CFLAGS="$PTHREAD_CFLAGS -mthreads"
    fi
    ;;
  *-freebsd*)
    PTHREAD_CFLAGS="$PTHREAD_CFLAGS -D_THREAD_SAFE"

    # FreeBSD 2.2.x shiped with gcc 2.7.2.x, which doesn't support
    # -mthreads flag.
    ;;
  *-openbsd*)
    PTHREAD_CFLAGS="$PTHREAD_CFLAGS -D_THREAD_SAFE"
      if test "x$PTHREAD_LIBS" = "x-lc_r"; then
        PTHREAD_LIBS="-pthread"
      fi
    ;;
  *-sysv5uw7*)  # UnixWare 7
    if test "$GCC" != "yes"; then
      PTHREAD_CFLAGS="$PTHREAD_CFLAGS -Kthread"
    else
      PTHREAD_CFLAGS="$PTHREAD_CFLAGS -pthread"
    fi
    ;;
  *-dg-dgux*)  # DG/UX
    PTHREAD_CFLAGS="$PTHREAD_CFLAGS -D_POSIX4A_DRAFT10_SOURCE"
esac

fi fi

SSL_LIBS=“” if test “x$enable_ssl” = “xyes” ; then

for ac_header in openssl/ssl.h ssl.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;}

;;

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_openssl_ssl_h = yes -o $ac_cv_header_ssl_h = yes ; then
    { echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5

echo $ECHO_N “checking for SSL_library_init in -lssl… $ECHO_C” >&6; } if test “${ac_cv_lib_ssl_SSL_library_init+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lssl $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 SSL_library_init (); int main () { return 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 ac_cv_lib_ssl_SSL_library_init=yes else echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_cv_lib_ssl_SSL_library_init=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_ssl_SSL_library_init” >&5 echo “${ECHO_T}$ac_cv_lib_ssl_SSL_library_init” >&6; } if test $ac_cv_lib_ssl_SSL_library_init = yes; then SSL_LIBS=“-lcrypto -lssl” fi

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

cat >>confdefs.h <<_ACEOF

define USE_SSL 1

_ACEOF

    fi
fi

fi

{ 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”

{ 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"

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

{ 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;}

;;

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

# 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;}

;;

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;}

;;

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;}

;;

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;}

;;

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;}

;;

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"

Extract the first word of “db2html”, so it can be a program name with args.

set dummy db2html; 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_DB2HTML+set}” = set; then echo $ECHO_N “(cached) $ECHO_C” >&6 else if test -n “$DB2HTML”; then ac_cv_prog_DB2HTML=“$DB2HTML” # 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_DB2HTML=“true” 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_prog_DB2HTML” && ac_cv_prog_DB2HTML=“false” fi fi DB2HTML=$ac_cv_prog_DB2HTML if test -n “$DB2HTML”; then { echo “$as_me:$LINENO: result: $DB2HTML” >&5 echo “${ECHO_T}$DB2HTML” >&6; } else { echo “$as_me:$LINENO: result: no” >&5 echo “${ECHO_T}no” >&6; } fi

if $DB2HTML; then HAVE_DOCBOOK_TRUE= HAVE_DOCBOOK_FALSE=‘#’ else HAVE_DOCBOOK_TRUE=‘#’ HAVE_DOCBOOK_FALSE= fi

ac_config_files=“$ac_config_files po/Makefile.in intl/Makefile Makefile docs/Makefile docs/sample.gftp/Makefile lib/Makefile lib/fsplib/Makefile src/gftp src/Makefile src/uicommon/Makefile src/gtk/Makefile src/text/Makefile gftp.spec”

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

if test -z “${AMDEP_TRUE}” && test -z “${AMDEP_FALSE}”; then { { echo “$as_me:$LINENO: error: conditional \"AMDEP\” was never defined. Usually this means the macro was only invoked conditionally.“ >&5 echo ”$as_me: error: conditional \“AMDEP\” was never defined. Usually this means the macro was only invoked conditionally.“ >&2;} { (exit 1); exit 1; }; } fi if test -z ”${amfastdepCC_TRUE}“ && test -z ”${amfastdepCC_FALSE}“; then { { echo ”$as_me:$LINENO: error: conditional \“amfastdepCC\” was never defined. Usually this means the macro was only invoked conditionally.“ >&5 echo ”$as_me: error: conditional \“amfastdepCC\” was never defined. Usually this means the macro was only invoked conditionally.“ >&2;} { (exit 1); exit 1; }; } fi if test -z ”${amfastdepCC_TRUE}“ && test -z ”${amfastdepCC_FALSE}“; then { { echo ”$as_me:$LINENO: error: conditional \“amfastdepCC\” was never defined. Usually this means the macro was only invoked conditionally.“ >&5 echo ”$as_me: error: conditional \“amfastdepCC\” was never defined. Usually this means the macro was only invoked conditionally.“ >&2;} { (exit 1); exit 1; }; } fi if test -z ”${MAINTAINER_MODE_TRUE}“ && test -z ”${MAINTAINER_MODE_FALSE}“; then { { echo ”$as_me:$LINENO: error: conditional \“MAINTAINER_MODE\” was never defined. Usually this means the macro was only invoked conditionally.“ >&5 echo ”$as_me: error: conditional \“MAINTAINER_MODE\” was never defined. Usually this means the macro was only invoked conditionally.“ >&2;} { (exit 1); exit 1; }; } fi if test -z ”${HAVE_DOCBOOK_TRUE}“ && test -z ”${HAVE_DOCBOOK_FALSE}“; then { { echo ”$as_me:$LINENO: error: conditional \“HAVE_DOCBOOK\” was never defined. Usually this means the macro was only invoked conditionally.“ >&5 echo ”$as_me: error: conditional \“HAVE_DOCBOOK\” was never defined. Usually this means the macro was only invoked conditionally.“ >&2;} { (exit 1); exit 1; }; } fi

: ${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 $as_me, 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=“\ config.status 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’ _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

# AMDEP_TRUE=“$AMDEP_TRUE” ac_aux_dir=“$ac_aux_dir”

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” ;; “depfiles”) CONFIG_COMMANDS=“$CONFIG_COMMANDS depfiles” ;; “po-directories”) CONFIG_COMMANDS=“$CONFIG_COMMANDS po-directories” ;; “po/Makefile.in”) CONFIG_FILES=“$CONFIG_FILES po/Makefile.in” ;; “intl/Makefile”) CONFIG_FILES=“$CONFIG_FILES intl/Makefile” ;; “Makefile”) CONFIG_FILES=“$CONFIG_FILES Makefile” ;; “docs/Makefile”) CONFIG_FILES=“$CONFIG_FILES docs/Makefile” ;; “docs/sample.gftp/Makefile”) CONFIG_FILES=“$CONFIG_FILES docs/sample.gftp/Makefile” ;; “lib/Makefile”) CONFIG_FILES=“$CONFIG_FILES lib/Makefile” ;; “lib/fsplib/Makefile”) CONFIG_FILES=“$CONFIG_FILES lib/fsplib/Makefile” ;; “src/gftp”) CONFIG_FILES=“$CONFIG_FILES src/gftp” ;; “src/Makefile”) CONFIG_FILES=“$CONFIG_FILES src/Makefile” ;; “src/uicommon/Makefile”) CONFIG_FILES=“$CONFIG_FILES src/uicommon/Makefile” ;; “src/gtk/Makefile”) CONFIG_FILES=“$CONFIG_FILES src/gtk/Makefile” ;; “src/text/Makefile”) CONFIG_FILES=“$CONFIG_FILES src/text/Makefile” ;; “gftp.spec”) CONFIG_FILES=“$CONFIG_FILES gftp.spec” ;;

*) { { 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 INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim INSTALL_DATA!$INSTALL_DATA$ac_delim CYGPATH_W!$CYGPATH_W$ac_delim PACKAGE!$PACKAGE$ac_delim VERSION!$VERSION$ac_delim ACLOCAL!$ACLOCAL$ac_delim AUTOCONF!$AUTOCONF$ac_delim AUTOMAKE!$AUTOMAKE$ac_delim AUTOHEADER!$AUTOHEADER$ac_delim MAKEINFO!$MAKEINFO$ac_delim install_sh!$install_sh$ac_delim STRIP!$STRIP$ac_delim INSTALL_STRIP_PROGRAM!$INSTALL_STRIP_PROGRAM$ac_delim mkdir_p!$mkdir_p$ac_delim AWK!$AWK$ac_delim SET_MAKE!$SET_MAKE$ac_delim amleading_dot!$amleading_dot$ac_delim AMTAR!$AMTAR$ac_delim amtar!$amtar$ac_delim amuntar!$amuntar$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 DEPDIR!$DEPDIR$ac_delim aminclude!$aminclude$ac_delim amquote!$amquote$ac_delim AMDEP_TRUE!$AMDEP_TRUE$ac_delim AMDEP_FALSE!$AMDEP_FALSE$ac_delim AMDEPBACKSLASH!$AMDEPBACKSLASH$ac_delim CCDEPMODE!$CCDEPMODE$ac_delim amfastdepCC_TRUE!$amfastdepCC_TRUE$ac_delim amfastdepCC_FALSE!$amfastdepCC_FALSE$ac_delim CPP!$CPP$ac_delim GREP!$GREP$ac_delim EGREP!$EGREP$ac_delim PREFIX!$PREFIX$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 host_os!$host_os$ac_delim RANLIB!$RANLIB$ac_delim GETCONF!$GETCONF$ac_delim U!$U$ac_delim ANSI2KNR!$ANSI2KNR$ac_delim MAINTAINER_MODE_TRUE!$MAINTAINER_MODE_TRUE$ac_delim MAINTAINER_MODE_FALSE!$MAINTAINER_MODE_FALSE$ac_delim MAINT!$MAINT$ac_delim LN_S!$LN_S$ac_delim ALLOCA!$ALLOCA$ac_delim PKG_CONFIG!$PKG_CONFIG$ac_delim GLIB_CFLAGS!$GLIB_CFLAGS$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 GLIB_LIBS!$GLIB_LIBS$ac_delim GLIB_CONFIG!$GLIB_CONFIG$ac_delim EXTRA_LIBS!$EXTRA_LIBS$ac_delim READLINE_LIBS!$READLINE_LIBS$ac_delim GFTP_TEXT!$GFTP_TEXT$ac_delim GTK_CFLAGS!$GTK_CFLAGS$ac_delim GTK_LIBS!$GTK_LIBS$ac_delim GTK_CONFIG!$GTK_CONFIG$ac_delim PTHREAD_CFLAGS!$PTHREAD_CFLAGS$ac_delim PTHREAD_LIBS!$PTHREAD_LIBS$ac_delim GTHREAD_LIBS!$GTHREAD_LIBS$ac_delim GFTP_GTK!$GFTP_GTK$ac_delim SSL_LIBS!$SSL_LIBS$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 GLIBC2!$GLIBC2$ac_delim CFLAG_VISIBILITY!$CFLAG_VISIBILITY$ac_delim HAVE_VISIBILITY!$HAVE_VISIBILITY$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 DB2HTML!$DB2HTML$ac_delim HAVE_DOCBOOK_TRUE!$HAVE_DOCBOOK_TRUE$ac_delim HAVE_DOCBOOK_FALSE!$HAVE_DOCBOOK_FALSE$ac_delim LIBOBJS!$LIBOBJS$ac_delim LTLIBOBJS!$LTLIBOBJS$ac_delim _ACEOF

if test sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X = 64; 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 _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 $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”

Compute $ac_file’s index in $config_headers.

am_stamp_count=1 for am_header in $config_headers :; do case $am_header in $ac_file | $ac_file:* ) break ;; * ) am_stamp_count=expr $_am_stamp_count + 1 ;; esac done echo “timestamp for $ac_file” >$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'/stamp-h$_am_stamp_count ;;

: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 “depfiles”:C) test x"$AMDEP_TRUE" != x"“ || for mf in $CONFIG_FILES; do # Strip MF so we end up with the name of the file. mf=echo "$mf" | sed -e 's/:.*$//' # Check whether this is an Automake generated Makefile or not. # We used to match only the files named Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # So let's grep whole file. if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then dirpart=$as_dirname – ”$mf" || $as_expr X"$mf" : ‘X(.[^/])//[^/][^/]/$’ | \ X"$mf" : ‘X(//)[^/]’ | \ X"$mf" : ‘X(//)$’ | \ X"$mf" : ‘X(/)’ | . 2>/dev/null || echo X"$mf" | sed ‘/^X(.[^/])\/\/[^/][^/]\/$/{ s//\1/ q } /^X(\/\/)[^/]./{ s//\1/ q } /^X(\/\/)$/{ s//\1/ q } /^X(\/)./{ s//\1/ q } s/././; q’ else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without runningmake'. DEPDIR=sed -n 's/^DEPDIR = //p' < "$mf" test -z “$DEPDIR” && continue aminclude=sed -n 's/^am__include = //p' < "$mf" test -z “aminclude” && continue am__quote=sed -n 's/^am__quote = //p' < "$mf" # When using ansi2knr, U may be empty or an underscore; expand it U=sed -n 's/^U = //p' < "$mf" # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'; do # Make sure the directory exists. test -f “$dirpart/$file” && continue fdir=$as_dirname -- "$file" || $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$file" : 'X\(//\)[^/]' \| \ X"$file" : 'X\(//\)$' \| \ X"$file" : 'X\(/\)' \| . 2>/dev/null || echo X"$file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' { as_dir=$dirpart/$fdir 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; }; }; } # echo “creating $dirpart/$file” echo ‘# dummy’ > “$dirpart/$file” done done ;; “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