"Fossies" - the Fresh Open Source Software Archive

Member "am-utils-6.2/configure" (30 Oct 2014, 1533125 Bytes) of archive /linux/misc/am-utils-6.2.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

From configure.ac Revision: 1.134 .

Guess values for system-dependent variables and create Makefiles.

Generated by GNU Autoconf 2.69 for am-utils 6.2.

#

Report bugs to <https://bugzilla.am-utils.org/ or am-utils@am-utils.org>.

# #

Copyright © 1992-1996, 1998-2012 Free Software Foundation, Inc.

# #

This configure script is free software; the Free Software Foundation

gives unlimited permission to copy, distribute and modify it.

#

Copyright © 1997-2011 Erez Zadok

——————–

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=: # Pre-4.2 versions of Zsh do 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_nl=‘ ’ export as_nl

Printing a long string crashes Solaris 7 /usr/bin/printf.

as_echo=‘\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\’ as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo

Prefer a ksh shell builtin over an external printf program on Solaris,

but without wasting forks for bash or zsh.

if test -z “$BASH_VERSION$ZSH_VERSION” \ && (test “Xprint -r -- $as_echo” = “X$as_echo”) 2>/dev/null; then as_echo=‘print -r –’ as_echo_n=‘print -rn –’ elif (test “Xprintf %s $as_echo” = “X$as_echo”) 2>/dev/null; then as_echo=‘printf %s\n’ as_echo_n=‘printf %s’ else if test “X(/usr/ucb/echo -n -n $as_echo) 2>/dev/null” = “X-n $as_echo”; then as_echo_body=‘eval /usr/ucb/echo -n “$1$as_nl”’ as_echo_n=‘/usr/ucb/echo -n’ else as_echo_body=‘eval expr “X$1” : “X\(.\)”’ as_echo_n_body=‘eval arg=$1; case $arg in #( “$as_nl”) expr “X$arg” : “X\(.\)$as_nl”; arg=expr "X$arg" : ".*$as_nl\\(.*\\)";; esac; expr “X$arg” : “X\(.*\)” | tr -d “$as_nl” ’ export as_echo_n_body as_echo_n=‘sh -c $as_echo_n_body as_echo’ fi export as_echo_body as_echo=‘sh -c $as_echo_body as_echo’ fi

The user is always right.

if test “${PATH_SEPARATOR+set}” != set; then PATH_SEPARATOR=: (PATH=‘/bin;/bin’; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH=‘/bin:/bin’; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=‘;’ } 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.)

IFS=“ ”“ $as_nl”

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

as_myself= 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 $as_echo “$as_myself: error: cannot find myself; rerun with an absolute file name” >&2 exit 1 fi

Unset variables that we do not need and which cause bugs (e.g. in

pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the “|| exit 1”

suppresses any “Segmentation fault” message there. ‘((’ could

trigger a bug in pdksh 5.2.14.

for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1=‘$ ’ PS2=‘> ’ PS4=‘+ ’

NLS nuisances.

LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE

CDPATH.

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

Use a proper internal environment variable to ensure we don’t fall

# into an infinite loop, continuously re-executing ourselves. if test x"${as_can_reexec}“ != xno && test "x$CONFIG_SHELL” != x; then as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a

neutralization value for shells without unset; and this also

works around shells that cannot unset nonexistent variables.

Preserve -v and -x to the replacement shell.

BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( vx | xv ) as_opts=-vx ;; v ) as_opts=-v ;; x ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts “$as_myself” ${1+“$@”}

Admittedly, this is quite paranoid, since all the known shells bail

out after a failed `exec'.

$as_echo “$0: could not re-execute with $CONFIG_SHELL” >&2 as_fn_exit 255 fi # We don’t want this to propagate to other subprocesses. { as_can_reexec=; unset as_can_reexec;} if test “x$CONFIG_SHELL” = x; then as_bourne_compatible=“if test -n \”\${ZSH_VERSION+set}\“ && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do 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_required=“as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; }

exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \“\$1\” ); then :

else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=“ as_lineno_1=”;as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=“;as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested” as_lineno_2a=\$LINENO eval ‘test \“x\$as_lineno_1’\$as_run'\” != \“x\$as_lineno_2'\$as_run'\” && test \“x`expr \$as_lineno_1'\$as_run' + 1`\” = \“x\$as_lineno_2'\$as_run'\”‘ || exit 1 test \$(( 1 + 1 )) = 2 || exit 1

test -n \“\${ZSH_VERSION+set}\${BASH_VERSION+set}\” || ( ECHO=‘\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\’ ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO PATH=/empty FPATH=/empty; export PATH FPATH test \“X`printf %s \$ECHO`\” = \“X\$ECHO\” \ || test \“X`print -r – \$ECHO`\” = \“X\$ECHO\” ) || exit 1" if (eval “$as_required”) 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval “$as_suggested”) 2>/dev/null; then :

else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f “$as_shell” || test -f “$as_shell.exe”; } && { $as_echo “$as_bourne_compatible”“$as_required” | as_run=a “$as_shell”; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo “$as_bourne_compatible”“$as_suggested” | as_run=a “$as_shell”; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f “$SHELL” || test -f “$SHELL.exe”; } && { $as_echo “$as_bourne_compatible”“$as_required” | as_run=a “$SHELL”; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS

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

export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a

neutralization value for shells without unset; and this also

works around shells that cannot unset nonexistent variables.

Preserve -v and -x to the replacement shell.

BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( vx | xv ) as_opts=-vx ;; v ) as_opts=-v ;; x ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts “$as_myself” ${1+“$@”}

Admittedly, this is quite paranoid, since all the known shells bail

out after a failed `exec'.

$as_echo “$0: could not re-execute with $CONFIG_SHELL” >&2 exit 255 fi

if test x$as_have_required = xno; then :

$as_echo “$0: This script requires a shell more modern than all” $as_echo “$0: the shells that I found on your system.” if test x${ZSH_VERSION+set} = xset ; then $as_echo “$0: In particular, zsh $ZSH_VERSION has bugs and should” $as_echo “$0: be upgraded to zsh 4.3.4 or later.” else $as_echo “$0: Please tell bug-autoconf@gnu.org and $0: https://bugzilla.am-utils.org/ or am-utils@am-utils.org $0: about your system, including any error possibly output $0: before this message. Then install a modern shell, or $0: manually run the script under such a shell if you do $0: have one.” fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL

Unset more variables known to interfere with behavior of common tools.

CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS

———————

M4sh Shell Functions.

———————

as_fn_unset VAR

—————

Portably unset VAR.

as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset

as_fn_set_status STATUS

———————–

Set $? to STATUS, without forking.

as_fn_set_status () { return $1 } # as_fn_set_status

as_fn_exit STATUS

—————–

Exit the shell with STATUS, even in a “trap 0” or “set -e” context.

as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit

as_fn_mkdir_p

————-

Create “$as_dir” as a directory, including parents if necessary.

as_fn_mkdir_p () {

case $as_dir in #( -) as_dir=./$as_dir;; esac test -d “$as_dir” || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( \‘) as_qdir=$as_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 || $as_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” || as_fn_error $? “cannot create directory $as_dir”

} # as_fn_mkdir_p

as_fn_executable_p FILE

———————–

Test if FILE is an executable regular file.

as_fn_executable_p () { test -f “$1” && test -x “$1” } # as_fn_executable_p

as_fn_append VAR VALUE

———————-

Append the text in VALUE to the end of the definition contained in VAR. Take

advantage of any shell optimizations that allow amortized linear growth over

repeated appends, instead of the typical quadratic growth present in naive

implementations.

if (eval “as_var=1; as_var+=2; test x\$as_var = x12”) 2>/dev/null; then : eval ‘as_fn_append () { eval $1+=\$2 }’ else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append

as_fn_arith ARG…

——————

Perform arithmetic evaluation on the ARGs, and store the result in the

global $as_val. Take advantage of shells that can avoid forks. The arguments

must be portable across $(()) and expr.

if (eval “test \$(( 1 + 1 )) = 2”) 2>/dev/null; then : eval ‘as_fn_arith () { as_val=$(( $* )) }’ else as_fn_arith () { as_val=expr "$@" || test $? -eq 1 } fi # as_fn_arith

as_fn_error STATUS ERROR [LINENO LOG_FD]

—————————————-

Output “basename $0: error: ERROR” to stderr. If LINENO and LOG_FD are

provided, also output the error to LOG_FD, referencing LINENO. Then exit the

script with STATUS, using 1 if that was 0.

as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test “$4”; then as_lineno=${as_lineno-“$3”} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo “$as_me:${as_lineno-$LINENO}: error: $2” >&$4 fi $as_echo “$as_me: error: $2” >&2 as_fn_exit $as_status } # as_fn_error

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

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

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

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

as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval ‘test “x$as_lineno_1’$as_run'” != “x$as_lineno_2'$as_run'” && test “xexpr $as_lineno_1'$as_run' + 1” = “x$as_lineno_2'$as_run'”‘ || { # 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” || { $as_echo “$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell” >&2; as_fn_exit 1; }

# If we had to re-execute with $CONFIG_SHELL, we’re ensured to have # already done that, so ensure we don’t try to do so again and fall # in an infinite loop. This has already happened in practice. as_can_reexec=no; export as_can_reexec # 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 }

ECHO_C= ECHO_N= ECHO_T= case echo -n x in #((((( -n) case echo 'xy\c' in c) ECHO_T=‘ ’;; # ECHO_T is single tab character. xy) ECHO_C=‘\c’;; ) echo echo ksh88 bug on AIX 6.1 > /dev/null ECHO_T=‘ ’;; esac;; *) ECHO_N=‘-n’;; esac

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 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then 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 -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s=‘cp -pR’ elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s=‘cp -pR’ fi else as_ln_s=‘cp -pR’ 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=‘mkdir -p “$as_dir”’ else test -d ./-p && rmdir ./-p as_mkdir_p=false fi

as_test_x=‘test -x’ as_executable_p=as_fn_executable_p

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

SHELL=${CONFIG_SHELL-/bin/sh}

test -n “$DJDIR” || exec 7<&0 &1

Name of the host.

hostname on some systems (SVR3.2, old GNU/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=

Identity of this package.

PACKAGE_NAME=‘am-utils’ PACKAGE_TARNAME=‘am-utils’ PACKAGE_VERSION=‘6.2’ PACKAGE_STRING=‘am-utils 6.2’ PACKAGE_BUGREPORT=‘https://bugzilla.am-utils.org/ or am-utils@am-utils.org’ PACKAGE_URL=‘’

ac_unique_file=“amd/amd.c”

Factoring default headers for most tests.

ac_includes_default=“\

include <stdio.h>

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif

ifdef HAVE_SYS_STAT_H

include <sys/stat.h>

endif

ifdef STDC_HEADERS

include <stdlib.h>

include <stddef.h>

else

ifdef HAVE_STDLIB_H

include <stdlib.h>

endif

endif

ifdef HAVE_STRING_H

if !defined STDC_HEADERS && defined HAVE_MEMORY_H

include <memory.h>

endif

include <string.h>

endif

ifdef HAVE_STRINGS_H

include <strings.h>

endif

ifdef HAVE_INTTYPES_H

include <inttypes.h>

endif

ifdef HAVE_STDINT_H

include <stdint.h>

endif

ifdef HAVE_UNISTD_H

include <unistd.h>

endif"

ac_subst_vars=‘amEXEEXT_FALSE amEXEEXT_TRUE LIBTOOL_DEPS AMU_LIB_OBJS LTLIBOBJS WRAPLIB am_utils_unmount_args am_utils_unmount_call AMU_AUTOFS_PROT_HEADER AMD_INFO_OBJS AMD_FS_OBJS AMU_NFS_PROT_HEADER LIBOBJS UNMOUNT_PROGRAM PERL LEX_OUTPUT_ROOT LEXLIB LEX YACC OTOOL64 OTOOL LIPO NMEDIT DSYMUTIL MANIFEST_TOOL RANLIB ac_ct_AR AR DLLTOOL OBJDUMP LN_S NM ac_ct_DUMPBIN DUMPBIN LD FGREP SED LIBTOOL MAINT MAINTAINER_MODE_FALSE MAINTAINER_MODE_TRUE AMU_CFLAGS EGREP GREP CPP amfastdepCC_FALSE amfastdepCC_TRUE CCDEPMODE amnodep AMDEPBACKSLASH AMDEP_FALSE AMDEP_TRUE amquote aminclude DEPDIR OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC LIBTOOL_LDFLAGS AM_BACKSLASH AM_DEFAULT_VERBOSITY AM_DEFAULT_V AM_V amuntar amtar AMTAR amleading_dot SET_MAKE AWK mkdir_p MKDIR_P INSTALL_STRIP_PROGRAM STRIP install_sh MAKEINFO AUTOHEADER AUTOMAKE AUTOCONF ACLOCAL VERSION PACKAGE CYGPATH_W am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL’ ac_subst_files=‘am_utils_mount_trap am_utils_nfs_sa_dref am_utils_nfs_hn_dref am_utils_nfs_fh_dref’ ac_user_opts=‘ enable_option_checking enable_silent_rules enable_dependency_tracking with_ldap with_hesiod with_ndbm enable_debug enable_cppflags enable_libs enable_ldflags enable_am_cflags enable_maintainer_mode enable_shared enable_static with_pic enable_fast_install with_gnu_ld with_sysroot enable_libtool_lock enable_largefile ’ ac_precious_vars=‘build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP’

Initialize some variables set by options.

ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep=

The variables have the same names as the options, with

dashes changed to underlines.

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

Installation directory options.

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

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

by default will actually change.

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

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

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

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

case $ac_option in =?) ac_optarg=expr "X$ac_option" : '[^=]*=\(.*\)' ;; =) ac_optarg= ;; ) 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_useropt=expr "x$ac_option" : 'x-*disable-\(.*\)' # Reject names that are not valid shell variable names. expr “x$ac_useropt” : “.[^-+._$as_cr_alnum]” >/dev/null && as_fn_error $? “invalid feature name: $ac_useropt” ac_useropt_orig=$ac_useropt ac_useropt=$as_echo "$ac_useropt" | sed 's/[-+.]/_/g' case $ac_user_opts in “ "enable$ac_useropt” “) ;; ) ac_unrecognized_opts=”$ac_unrecognized_opts$ac_unrecognized_sep–disable-$ac_useropt_orig" ac_unrecognized_sep=‘, ’;; esac eval enable$ac_useropt=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_useropt=expr "x$ac_option" : 'x-*enable-\([^=]*\)' # Reject names that are not valid shell variable names. expr “x$ac_useropt” : “.[^-+._$as_cr_alnum]” >/dev/null && as_fn_error $? “invalid feature name: $ac_useropt” ac_useropt_orig=$ac_useropt ac_useropt=$as_echo "$ac_useropt" | sed 's/[-+.]/_/g' case $ac_user_opts in “ "enable$ac_useropt” “) ;; ) ac_unrecognized_opts=”$ac_unrecognized_opts$ac_unrecognized_sep–enable-$ac_useropt_orig" ac_unrecognized_sep=‘, ’;; esac eval enable$ac_useropt=\$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_useropt=expr "x$ac_option" : 'x-*with-\([^=]*\)' # Reject names that are not valid shell variable names. expr “x$ac_useropt” : “.[^-+._$as_cr_alnum]” >/dev/null && as_fn_error $? “invalid package name: $ac_useropt” ac_useropt_orig=$ac_useropt ac_useropt=$as_echo "$ac_useropt" | sed 's/[-+.]/_/g' case $ac_user_opts in “ "with$ac_useropt” “) ;; ) ac_unrecognized_opts=”$ac_unrecognized_opts$ac_unrecognized_sep–with-$ac_useropt_orig" ac_unrecognized_sep=‘, ’;; esac eval with$ac_useropt=\$ac_optarg ;;

-without- | –without-) ac_useropt=expr "x$ac_option" : 'x-*without-\(.*\)' # Reject names that are not valid shell variable names. expr “x$ac_useropt” : “.[^-+._$as_cr_alnum]” >/dev/null && as_fn_error $? “invalid package name: $ac_useropt” ac_useropt_orig=$ac_useropt ac_useropt=$as_echo "$ac_useropt" | sed 's/[-+.]/_/g' case $ac_user_opts in “ "with$ac_useropt” “) ;; ) ac_unrecognized_opts=”$ac_unrecognized_opts$ac_unrecognized_sep–without-$ac_useropt_orig" ac_unrecognized_sep=‘, ’;; esac eval with$ac_useropt=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 ;;

-*) as_fn_error $? “unrecognized option: `$ac_option' Try `$0 –help' for more information” ;;

=) ac_envvar=expr "x$ac_option" : 'x\([^=]*\)=' # Reject names that are not valid shell variable names. case $ac_envvar in #( ‘’ | [0-9] | [!_$as_cr_alnum]* ) as_fn_error $? “invalid variable name: `$ac_envvar'” ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;;

) # FIXME: should be removed in autoconf 3.0. $as_echo “$as_me: WARNING: you should use –build, –host, –target” >&2 expr “x$ac_option” : “.[^-._$as_cr_alnum]” >/dev/null && $as_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' as_fn_error $? “missing argument to $ac_option” fi

if test -n “$ac_unrecognized_opts”; then case $enable_option_checking in no) ;; fatal) as_fn_error $? “unrecognized options: $ac_unrecognized_opts” ;; *) $as_echo “$as_me: WARNING: unrecognized options: $ac_unrecognized_opts” >&2 ;; esac fi

Check all directory arguments for consistency.

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 # Remove trailing slashes. case $ac_val in / ) ac_val=expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)' eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\/$] | ?:[\/] ) continue;; NONE | ‘’ ) case $ac_var in prefix ) continue;; esac;; esac as_fn_error $? “expected an absolute directory name for –$ac_var: $ac_val” 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 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 . || as_fn_error $? “working directory cannot be determined” test “X$ac_ls_di” = “X$ac_pwd_ls_di” || as_fn_error $? “pwd does not report name of working directory”

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 -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | 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 ..” as_fn_error $? “cannot find sources ($ac_unique_file) in $srcdir” fi ac_msg=“sources are in $srcdir, but `cd $srcdir' does not work” ac_abs_confdir=( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" 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 am-utils 6.2 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/am-utils] –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 case $ac_init_help in short | recursive ) echo “Configuration of am-utils 6.2:”;; esac cat <<_ACEOF

Optional Features: –disable-option-checking ignore unrecognized –enable/–with options –disable-FEATURE do not include FEATURE (same as –enable-FEATURE=no) –enable-FEATURE[=ARG] include FEATURE [ARG=yes] –enable-silent-rules less verbose build output (undo: “make V=1”) –disable-silent-rules verbose build output (undo: “make V=0”) –enable-dependency-tracking do not reject slow dependency extractors –disable-dependency-tracking speeds up one-time build –enable-debug=ARG enable debugging (yes/mem/no) –enable-cppflags=ARG configure/compile with ARG (-I) preprocessor flags –enable-libs=ARG configure/compile with ARG (-l) library flags –enable-ldflags=ARG configure/compile with ARG (-L) library flags –enable-am-cflags=ARG compile package with ARG additional C flags –enable-maintainer-mode enable make rules and dependencies not useful (and sometimes confusing) to the casual installer –enable-shared[=PKGS] build shared libraries [default=no] –enable-static[=PKGS] build static libraries [default=yes] –enable-fast-install[=PKGS] optimize for fast installation [default=yes] –disable-libtool-lock avoid locking (might break parallel builds) –disable-largefile omit support for large files

Optional Packages: –with-PACKAGE[=ARG] use PACKAGE [ARG=yes] –without-PACKAGE do not use PACKAGE (same as –with-PACKAGE=no) –with-ldap enable LDAP support (default=yes if found) –with-hesiod enable HESIOD support (default=yes if found) –with-ndbm enable NDBM support (default=yes if found) –with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use both] –with-gnu-ld assume the C compiler uses GNU ld [default=no] –with-sysroot=DIR Search for dependent libraries within DIR (or the compiler’s sysroot if not specified).

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 (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor

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

Report bugs to <https://bugzilla.am-utils.org/ or am-utils@am-utils.org>. _ACEOF ac_status=$? fi

if test “$ac_init_help” = “recursive”; then # If there are subdirs, report their specific –help. for ac_dir in : $ac_subdirs_all; do test “x$ac_dir” = x: && continue test -d “$ac_dir” || { cd “$srcdir” && ac_pwd=pwd && srcdir=. && 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=/$as_echo "$ac_dir" | sed 's|^\.[\\/]||' # A “..” for each directory in $ac_dir_suffix. ac_top_builddir_sub=$as_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
  $as_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 am-utils configure 6.2 generated by GNU Autoconf 2.69

Copyright © 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it.

Copyright © 1997-2011 Erez Zadok _ACEOF exit fi

————————

Autoconf initialization.

————————

ac_fn_c_try_compile LINENO

————————–

Try to compile conftest.$ac_ext, and return whether this succeeded.

ac_fn_c_try_compile () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack 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 ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_compile”) 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v ‘^ +’ conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_retval=1

fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval

} # ac_fn_c_try_compile

ac_fn_c_try_cpp LINENO

———————-

Try to preprocess conftest.$ac_ext, and return whether this succeeded.

ac_fn_c_try_cpp () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try=“$ac_cpp conftest.$ac_ext” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_cpp conftest.$ac_ext”) 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v ‘^ +’ conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } > conftest.i && { test -z “$ac_c_preproc_warn_flag$ac_c_werror_flag” || test ! -s conftest.err }; then : ac_retval=0 else $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_retval=1

fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval

} # ac_fn_c_try_cpp

ac_fn_c_try_link LINENO

———————–

Try to link conftest.$ac_ext, and return whether this succeeded.

ac_fn_c_try_link () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack 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 ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_link”) 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v ‘^ +’ conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && { test -z “$ac_c_werror_flag” || test ! -s conftest.err } && test -s conftest$ac_exeext && { test “$cross_compiling” = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

ac_retval=1

fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple’s compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval

} # ac_fn_c_try_link

ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES

——————————————————-

Tests whether HEADER exists, giving a warning if it cannot be compiled using

the include files in INCLUDES and setting the cache variable VAR

accordingly.

ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $2” >&5 $as_echo_n “checking for $2… ” >&6; } if eval \${$3+:} false; then : $as_echo_n “(cached) ” >&6 fi eval ac_res=\$$3 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } else # Is the header compilable? { $as_echo “$as_me:${as_lineno-$LINENO}: checking $2 usability” >&5 $as_echo_n “checking $2 usability… ” >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / $4

include <$2>

_ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler” >&5 $as_echo “$ac_header_compiler” >&6; }

Is the header present?

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking $2 presence” >&5 $as_echo_n “checking $2 presence… ” >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <$2>

_ACEOF if ac_fn_c_try_cpp “$LINENO”; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc” >&5 $as_echo “$ac_header_preproc” >&6; }

So? What about this header?

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!” >&5 $as_echo “$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler’s result” >&5 $as_echo “$as_me: WARNING: $2: proceeding with the compiler’s result” >&2;} ;; no:yes:* ) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled” >&5 $as_echo “$as_me: WARNING: $2: present but cannot be compiled” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?” >&5 $as_echo “$as_me: WARNING: $2: check for missing prerequisite headers?” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation” >&5 $as_echo “$as_me: WARNING: $2: see the Autoconf documentation” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\”“ >&5 $as_echo ”$as_me: WARNING: $2: section \“Present But Cannot Be Compiled\”“ >&2;} { $as_echo ”$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler’s result" >&5 $as_echo “$as_me: WARNING: $2: proceeding with the compiler’s result” >&2;} ( $as_echo “## ———————————————————————- ##

Report this to https://bugzilla.am-utils.org/ or am-utils@am-utils.org

———————————————————————- ##"

 ) | sed "s/^/$as_me: WARNING:     /" >&2
;;

esac { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $2” >&5 $as_echo_n “checking for $2… ” >&6; } if eval \${$3+:} false; then : $as_echo_n “(cached) ” >&6 else eval “$3=\$ac_header_compiler” fi eval ac_res=\$$3 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_mongrel

ac_fn_c_try_run LINENO

———————-

Try to link conftest.$ac_ext, and return whether this succeeded. Assumes

that executables can be run.

ac_fn_c_try_run () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_link”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && { ac_try=‘./conftest$ac_exeext’ { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo “$as_me: program exited with status $ac_status” >&5 $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

   ac_retval=$ac_status

fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval

} # ac_fn_c_try_run

ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES

——————————————————-

Tests whether HEADER exists and can be compiled using the include files in

INCLUDES, setting the cache variable VAR accordingly.

ac_fn_c_check_header_compile () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $2” >&5 $as_echo_n “checking for $2… ” >&6; } if eval \${$3+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / $4

include <$2>

_ACEOF if ac_fn_c_try_compile “$LINENO”; then : eval “$3=yes” else eval “$3=no” fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_compile

ac_fn_c_check_func LINENO FUNC VAR

———————————-

Tests whether FUNC exists, setting the cache variable VAR accordingly

ac_fn_c_check_func () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $2” >&5 $as_echo_n “checking for $2… ” >&6; } if eval \${$3+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Define $2 to an innocuous variant, in case <limits.h> declares $2. For example, HP-UX 11i <limits.h> declares gettimeofday. /

define $2 innocuous_$2

/ System header to define stub macros and hopefully few prototypes, which can conflict with char $2 (); 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 $2

/ 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 $2 (); / 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_$2 || defined stub___$2

choke me

endif

int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : eval “$3=yes” else eval “$3=no” fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_func

ac_fn_c_check_type LINENO TYPE VAR INCLUDES

——————————————-

Tests whether TYPE exists after having included INCLUDES, setting cache

variable VAR accordingly.

ac_fn_c_check_type () { as_lineno=${as_lineno-“$1”} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $2” >&5 $as_echo_n “checking for $2… ” >&6; } if eval \${$3+:} false; then : $as_echo_n “(cached) ” >&6 else eval “$3=no” cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / $4 int main () { if (sizeof ($2)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / $4 int main () { if (sizeof (($2))) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then :

else eval “$3=yes” 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 eval ac_res=\$$3 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_type 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 am-utils $as_me 6.2, which was generated by GNU Autoconf 2.69. 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=. $as_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=$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g" ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 “ ’$ac_arg'” ;; 2) as_fn_append 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 as_fn_append ac_configure_args “ ‘$ac_arg’” ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset 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

$as_echo "## ---------------- ##

Cache variables.

—————- ##"

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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( ) { eval $ac_var=; 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

$as_echo "## ----------------- ##

Output variables.

—————– ##"

echo
for ac_var in $ac_subst_vars
do
  eval ac_val=\$$ac_var
  case $ac_val in
  *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
  esac
  $as_echo "$ac_var='\''$ac_val'\''"
done | sort
echo

if test -n "$ac_subst_files"; then
  $as_echo "## ------------------- ##

File substitutions.

——————- ##"

  echo
  for ac_var in $ac_subst_files
  do
eval ac_val=\$$ac_var
case $ac_val in
*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
esac
$as_echo "$ac_var='\''$ac_val'\''"
  done | sort
  echo
fi

if test -s confdefs.h; then
  $as_echo "## ----------- ##

confdefs.h.

———– ##"

  echo
  cat confdefs.h
  echo
fi
test "$ac_signal" != 0 &&
  $as_echo "$as_me: caught signal $ac_signal"
$as_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'; as_fn_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

$as_echo “/ confdefs.h /” > 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

cat >>confdefs.h <<_ACEOF

define PACKAGE_URL “$PACKAGE_URL”

_ACEOF

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

Prefer an explicitly selected file to automatically selected ones.

ac_site_file1=NONE ac_site_file2=NONE if test -n “$CONFIG_SITE”; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -) ac_site_file1=./$CONFIG_SITE;; /) ac_site_file1=$CONFIG_SITE;; ) ac_site_file1=./$CONFIG_SITE;; esac elif test “x$prefix” != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in “$ac_site_file1” “$ac_site_file2” do test “x$ac_site_file” = xNONE && continue if test /dev/null != “$ac_site_file” && test -r “$ac_site_file”; then { $as_echo “$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file” >&5 $as_echo “$as_me: loading site script $ac_site_file” >&6;} sed ’s/^/| /‘ “$ac_site_file” >&5 . “$ac_site_file” \ || { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd’:” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “failed to load site script $ac_site_file See `config.log' for more details” “$LINENO” 5; } 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. DJGPP emulates it as a regular file. if test /dev/null != “$cache_file” && test -f “$cache_file”; then { $as_echo “$as_me:${as_lineno-$LINENO}: loading cache $cache_file” >&5 $as_echo “$as_me: loading cache $cache_file” >&6;} case $cache_file in [\/] | ?:[\/] ) . “$cache_file”;; *) . “./$cache_file”;; esac fi else { $as_echo “$as_me:${as_lineno-$LINENO}: creating cache $cache_file” >&5 $as_echo “$as_me: creating cache $cache_file” >&6;}

$cache_file fi

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,) { $as_echo “$as_me:${as_lineno-$LINENO}: error: `$ac_var' was set to `$ac_old_val' in the previous run” >&5 $as_echo “$as_me: error: `$ac_var' was set to `$ac_old_val' in the previous run” >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo “$as_me:${as_lineno-$LINENO}: error: `$ac_var' was not set in the previous run” >&5 $as_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 # differences in whitespace do not lead to failure. ac_old_val_w=echo x $ac_old_val ac_new_val_w=echo x $ac_new_val if test “$ac_old_val_w” != “$ac_new_val_w”; then { $as_echo “$as_me:${as_lineno-$LINENO}: error: `$ac_var' has changed since the previous run:” >&5 $as_echo “$as_me: error: `$ac_var' has changed since the previous run:” >&2;} ac_cache_corrupted=: else { $as_echo “$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in `$ac_var' since the previous run:” >&5 $as_echo “$as_me: warning: ignoring whitespace changes in `$ac_var' since the previous run:” >&2;} eval $ac_var=\$ac_old_val fi { $as_echo “$as_me:${as_lineno-$LINENO}: former value: `$ac_old_val'” >&5 $as_echo “$as_me: former value: `$ac_old_val'” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: current value: `$ac_new_val'” >&5 $as_echo “$as_me: current value: `$ac_new_val'” >&2;} fi;; esac # Pass precious variables to config.status. if test “$ac_new_set” = set; then case $ac_new_val in \‘) ac_arg=$ac_var=$as_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. *) as_fn_append ac_configure_args “ ‘$ac_arg’” ;; esac fi done if $ac_cache_corrupted; then { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} { $as_echo “$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build” >&5 $as_echo “$as_me: error: changes in the environment can compromise the build” >&2;} as_fn_error $? “run `make distclean' and/or `rm $cache_file' and start over” “$LINENO” 5 fi

——————–

Main body of script.

——————–

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

{ $as_echo “$as_me:${as_lineno-$LINENO}: INITIALIZATION ” >&5 $as_echo “$as_me: INITIALIZATION ” >&6;}

ac_config_headers=“$ac_config_headers config.h”

{ $as_echo “$as_me:${as_lineno-$LINENO}: SYSTEM TYPES ” >&5 $as_echo “$as_me: SYSTEM TYPES ” >&6;} 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 as_fn_error $? “cannot find install-sh, install.sh, or shtool in \”$srcdir\“ \”$srcdir/..\“ \”$srcdir/../..\“” “$LINENO” 5 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.

Make sure we can run config.sub.

$SHELL “$ac_aux_dir/config.sub” sun4 >/dev/null 2>&1 || as_fn_error $? “cannot run $SHELL $ac_aux_dir/config.sub” “$LINENO” 5

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking build system type” >&5 $as_echo_n “checking build system type… ” >&6; } if ${ac_cv_build+:} false; then : $as_echo_n “(cached) ” >&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 && as_fn_error $? “cannot guess build type; you must specify one” “$LINENO” 5 ac_cv_build=$SHELL "$ac_aux_dir/config.sub" $ac_build_alias || as_fn_error $? “$SHELL $ac_aux_dir/config.sub $ac_build_alias failed” “$LINENO” 5

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_build” >&5 $as_echo “$ac_cv_build” >&6; } case $ac_cv_build in --) ;; ) as_fn_error $? “invalid value of canonical build” “$LINENO” 5;; 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

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host system type” >&5 $as_echo_n “checking host system type… ” >&6; } if ${ac_cv_host+:} false; then : $as_echo_n “(cached) ” >&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 || as_fn_error $? “$SHELL $ac_aux_dir/config.sub $host_alias failed” “$LINENO” 5 fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_host” >&5 $as_echo “$ac_cv_host” >&6; } case $ac_cv_host in --) ;; ) as_fn_error $? “invalid value of canonical host” “$LINENO” 5;; 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

these are defined already by the macro ‘CANONICAL_HOST’

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host cpu” >&5 $as_echo_n “checking host cpu… ” >&6; } cat >>confdefs.h <<_ACEOF

define HOST_CPU “$host_cpu”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_cpu” >&5 $as_echo “$host_cpu” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking vendor” >&5 $as_echo_n “checking vendor… ” >&6; } cat >>confdefs.h <<_ACEOF

define HOST_VENDOR “$host_vendor”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_vendor” >&5 $as_echo “$host_vendor” >&6; }

if vendor is apple, then check values in /usr/bin/sw_vers

if test “${host_vendor}” = “apple” then pn=sw_vers -productName 2>/dev/null pv=sw_vers -productVersion 2>/dev/null if test -n “${pn}” && test -n “${pv}” then host_os_name=echo ${pn} | tr -d ' ' | tr 'A-Z' 'a-z' host_os_version=“${pv}” host_os=“${host_os_name}-${host_os_version}” fi fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host full OS name and version” >&5 $as_echo_n “checking host full OS name and version… ” >&6; } # normalize some host OS names case ${host_os} in # linux is linux is linux, regardless of RMS. linux-gnu | lignux ) host_os=linux ;; # NetBSD systems today are elf, so no need to distinguish netbsdelf* ) host_os=echo ${host_os} | sed 's/^netbsdelf/netbsd/';; esac cat >>confdefs.h <<_ACEOF

define HOST_OS “$host_os”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_os” >&5 $as_echo “$host_os” >&6; }

break host_os into host_os_name and host_os_version

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host OS name” >&5 $as_echo_n “checking host OS name… ” >&6; } host_os_name=echo $host_os | sed 's/\..*//g' # normalize some OS names case ${host_os_name} in # linux is linux is linux, regardless of RMS. linux-gnu | lignux ) host_os_name=linux ;; # all NetBSD systems today should just show up as “netbsd” netbsd* ) host_os_name=netbsd;; esac cat >>confdefs.h <<_ACEOF

define HOST_OS_NAME “$host_os_name”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_os_name” >&5 $as_echo “$host_os_name” >&6; }

parse out the OS version of the host

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host OS version” >&5 $as_echo_n “checking host OS version… ” >&6; } host_os_version=echo $host_os | sed 's/^[^0-9]*//g' if test -z “$host_os_version” then host_os_version=(uname -r) 2>/dev/null || host_os_version=unknown fi case ${host_os_version} in # fixes for some OS versions (solaris used to be here) * ) # do nothing for now ;; esac cat >>confdefs.h <<_ACEOF

define HOST_OS_VERSION “$host_os_version”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_os_version” >&5 $as_echo “$host_os_version” >&6; }

figure out host architecture (different than CPU)

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host OS architecture” >&5 $as_echo_n “checking host OS architecture… ” >&6; } host_arch=(uname -m) 2>/dev/null || host_arch=unknown # normalize some names case ${host_arch} in sun4 ) host_arch=sun4 ;; sun3x ) host_arch=sun3 ;; sun ) host_arch=(arch) 2>/dev/null || host_arch=unknown ;; i?86 ) host_arch=i386 ;; # all x86 should show up as i386 PowerMacintosh ) host_arch=powerpc ;; esac cat >>confdefs.h <<_ACEOF

define HOST_ARCH “$host_arch”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_arch” >&5 $as_echo “$host_arch” >&6; }

figure out (linux) distribution, if any

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking OS system distribution” >&5 $as_echo_n “checking OS system distribution… ” >&6; } ac_config_distro=$SHELL $ac_aux_dir/config.guess.long | cut -d'-' -f4- if test -z “$ac_config_distro” then ac_config_distro=“none” fi cat >>confdefs.h <<_ACEOF

define DISTRO_NAME “$ac_config_distro”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_config_distro” >&5 $as_echo “$ac_config_distro” >&6; }

figure out host name

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking host name” >&5 $as_echo_n “checking host name… ” >&6; } host_name=(hostname || uname -n) 2>/dev/null || host_name=unknown cat >>confdefs.h <<_ACEOF

define HOST_NAME “$host_name”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_name” >&5 $as_echo “$host_name” >&6; }

figure out user name

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking user name” >&5 $as_echo_n “checking user name… ” >&6; } if test -n “$USER” then user_name=“$USER” else if test -n “$LOGNAME” then user_name=“$LOGNAME” else user_name=(whoami) 2>/dev/null || user_name=unknown fi fi cat >>confdefs.h <<_ACEOF

define USER_NAME “$user_name”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $user_name” >&5 $as_echo “$user_name” >&6; }

figure out configuration date

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking configuration date” >&5 $as_echo_n “checking configuration date… ” >&6; } config_date=(date) 2>/dev/null || config_date=unknown_date cat >>confdefs.h <<_ACEOF

define CONFIG_DATE “$config_date”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $config_date” >&5 $as_echo “$config_date” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: PACKAGE NAME AND VERSION ” >&5 $as_echo “$as_me: PACKAGE NAME AND VERSION ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking package name” >&5 $as_echo_n “checking package name… ” >&6; } cat >>confdefs.h <<_ACEOF

define PACKAGE_NAME “$PACKAGE_NAME”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: \”$PACKAGE_NAME\“” >&5 $as_echo “\”$PACKAGE_NAME\“” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking version of package” >&5 $as_echo_n “checking version of package… ” >&6; } cat >>confdefs.h <<_ACEOF

define PACKAGE_VERSION “$PACKAGE_VERSION”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: \”$PACKAGE_VERSION\“” >&5 $as_echo “\”$PACKAGE_VERSION\“” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking bug-reporting address” >&5 $as_echo_n “checking bug-reporting address… ” >&6; } cat >>confdefs.h <<_ACEOF

define PACKAGE_BUGREPORT “$PACKAGE_BUGREPORT”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: \”$PACKAGE_BUGREPORT\“” >&5 $as_echo “\”$PACKAGE_BUGREPORT\“” >&6; }

am__api_version=‘1.14’

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.

Reject install programs that cannot install multiple files.

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install” >&5 $as_echo_n “checking for a BSD-compatible install… ” >&6; } if test -z “$INSTALL”; then if ${ac_cv_path_install+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$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 rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if “$as_dir/$ac_prog$ac_exec_ext” -c conftest.one conftest.two “pwd/conftest.dir” && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install=“$as_dir/$ac_prog$ac_exec_ext -c” break 3 fi fi fi done done ;; esac

done IFS=$as_save_IFS

rm -rf conftest.one conftest.two conftest.dir

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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $INSTALL” >&5 $as_echo “$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’

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether build environment is sane” >&5 $as_echo_n “checking whether build environment is sane… ” >&6; }

Reject unsafe characters in $srcdir or the absolute working directory

name. Accept space and tab only in the latter.

am_lf=‘ ’ case pwd in [\\“#\$&\‘`$am_lf]) as_fn_error $? "unsafe absolute working directory name” “$LINENO” 5;; esac case $srcdir in [\\“#\$&\’`$am_lf\ \ ]) as_fn_error $? "unsafe srcdir value: ‘$srcdir’” “$LINENO” 5;; esac

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 ( am_has_slept=no for am_try in 1 2; do echo “timestamp, slept: $am_has_slept” > conftest.file 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 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".
as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken

alias in your environment" “$LINENO” 5 fi if test “$2” = conftest.file || test $am_try -eq 2; then break fi # Just in case. sleep 1 am_has_slept=yes done test “$2” = conftest.file ) then # Ok. : else as_fn_error $? “newly created file is older than distributed files! Check your system clock” “$LINENO” 5 fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; }

If we didn’t sleep, we still need to ensure time stamps of config.status and

generated files are strictly newer.

am_sleep_pid= if grep ‘slept: no’ conftest.file >/dev/null 2>&1; then ( sleep 1 ) & am_sleep_pid=$! fi

rm -f conftest.file

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

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

ac_script=’s/[\$]/&&/g;s/;s,x,x,$//‘ program_transform_name=$as_echo "$program_transform_name" | sed "$ac_script"

expand $ac_aux_dir to an absolute path

am_aux_dir=cd $ac_aux_dir && pwd

if test x"${MISSING+set}“ != xset; then case $am_aux_dir in \ * | \ ) MISSING=”\${SHELL} \“$am_aux_dir/missing\”“ ;; ) MISSING=”\${SHELL} $am_aux_dir/missing" ;; esac fi

Use eval to expand $SHELL

if eval “$MISSING –is-lightweight”; then am_missing_run=“$MISSING ” else am_missing_run= { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: ‘missing’ script is too old or missing” >&5 $as_echo “$as_me: WARNING: ‘missing’ script is too old or missing” >&2;} fi

if test x"${install_sh}“ != xset; then case $am_aux_dir in \ * | \ ) install_sh=”\${SHELL} ‘$am_aux_dir/install-sh’“ ;; ) install_sh=”\${SHELL} $am_aux_dir/install-sh" esac fi

Installed binaries are usually stripped using ‘strip’ when the user

run “make install-strip”. However ‘strip’ 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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_STRIP+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_STRIP=“${ac_tool_prefix}strip” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $STRIP” >&5 $as_echo “$STRIP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_STRIP+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_STRIP=“strip” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP” >&5 $as_echo “$ac_ct_STRIP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_STRIP” = x; then STRIP=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP=“$ac_cv_prog_STRIP” fi

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

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p” >&5 $as_echo_n “checking for a thread-safe mkdir -p… ” >&6; } if test -z “$MKDIR_P”; then if ${ac_cv_path_mkdir+:} false; then : $as_echo_n “(cached) ” >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_prog in mkdir gmkdir; do for ac_exec_ext in ‘’ $ac_executable_extensions; do as_fn_executable_p “$as_dir/$ac_prog$ac_exec_ext” || continue case "$as_dir/$ac_prog$ac_exec_ext" --version 2>&1 in #( ‘mkdir (GNU coreutils) ’ | \ ‘mkdir (coreutils) ’ | \ ‘mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS

fi

test -d ./–version && rmdir ./–version if test “${ac_cv_path_mkdir+set}” = set; then MKDIR_P=“$ac_cv_path_mkdir -p” else # As a last resort, use the slow shell script. Don’t cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. MKDIR_P=“$ac_install_sh -d” fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $MKDIR_P” >&5 $as_echo “$MKDIR_P” >&6; }

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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_AWK+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_AWK=“$ac_prog” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $AWK” >&5 $as_echo “$AWK” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$AWK” && break done

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)” >&5 $as_echo_n “checking whether ${MAKE-make} sets \$(MAKE)… ” >&6; } set x ${MAKE-make} ac_make=$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g' if eval \${ac_cv_prog_make${ac_make}set+:} false; then : $as_echo_n “(cached) ” >&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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } SET_MAKE= else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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

Check whether –enable-silent-rules was given.

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

case $enable_silent_rules in # ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; *) AM_DEFAULT_VERBOSITY=1;; esac am_make=${MAKE-make} { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables” >&5 $as_echo_n “checking whether $am_make supports nested variables… ” >&6; } if ${am_cv_make_support_nested_variables+:} false; then : $as_echo_n “(cached) ” >&6 else if $as_echo ‘TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 amdoit: @$(TRUE) .PHONY: amdoit’ | $am_make -f - >/dev/null 2>&1; then am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables” >&5 $as_echo “$am_cv_make_support_nested_variables” >&6; } if test $am_cv_make_support_nested_variables = yes; then AM_V=‘$(V)’ AM_DEFAULT_V=‘$(AM_DEFAULT_VERBOSITY)’ else AM_V=$AM_DEFAULT_VERBOSITY AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY fi AM_BACKSLASH=‘\’

if test “cd $srcdir && pwd” != “pwd”; then # Use -I$(srcdir) only when $(srcdir) != ., so that make’s output # is not polluted with repeated “-I.” am__isrc=‘ -I$(srcdir)’ # test to see if srcdir already configured if test -f $srcdir/config.status; then as_fn_error $? “source directory already configured; run \"make distclean\” there first" “$LINENO” 5 fi 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=‘am-utils’ VERSION=‘6.2’

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

For better backward compatibility. To be removed once Automake 1.9.x

dies out for good. For more background, see:

http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html

http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html

mkdir_p=‘$(MKDIR_P)’

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

some platforms.

Always define AMTAR for backward compatibility. Yes, it’s still used

in the wild :-( We should find a proper way to deprecate it …

AMTAR=‘$${TAR-tar}’

We’ll loop over all known methods to create a tar archive until one works.

_am_tools=‘gnutar pax cpio none’

amtar=‘$${TAR-tar} chof - “$$tardir”’ amuntar=‘$${TAR-tar} xf -’

POSIX will say in a future version that running “rm -f” with no argument

is OK; and we want to be able to make that assumption in our Makefile

recipes. So use an aggressive probe to check that the usage we want is

actually supported “in the wild” to an acceptable degree.

See automake bug#10828.

To make any issue more visible, cause the running configure to be aborted

by default if the ‘rm’ program in use doesn’t match our expectations; the

user can still override this though.

if rm -f && rm -fr && rm -rf; then : OK; else cat >&2 <<‘END’ Oops!

Your ‘rm’ program seems unable to run without file operands specified on the command line, even when the ‘-f’ option is present. This is contrary to the behaviour of most rm programs out there, and not conforming with the upcoming POSIX standard: http://austingroupbugs.net/view.php?id=542

Please tell bug-automake@gnu.org about your system, including the value of your $PATH and any error possibly output before this message. This can help us improve future automake versions.

END if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then echo ‘Configuration will proceed anyway, since you have set the’ >&2 echo ‘ACCEPT_INFERIOR_RM_PROGRAM variable to “yes”’ >&2 echo >&2 else cat >&2 <<‘END’ Aborting the configuration process, to ensure you take notice of the issue.

You can download and install GNU coreutils to get an ‘rm’ implementation that behaves properly: http://www.gnu.org/software/coreutils/.

If you want to complete the configuration process using your problematic ‘rm’ anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM to “yes”, and re-run configure.

END as_fn_error $? “Your ‘rm’ program is bad, sorry.” “$LINENO” 5 fi fi LIBTOOL_LDFLAGS=“-version-info 4:0:0”

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR PROGRAMS (part 1) ” >&5 $as_echo “$as_me: PARTICULAR PROGRAMS (part 1) ” >&6;} 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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_CC=“${ac_tool_prefix}gcc” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $CC” >&5 $as_echo “$CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_CC=“gcc” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC” >&5 $as_echo “$ac_ct_CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_CC” = x; then CC=“” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_CC=“${ac_tool_prefix}cc” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $CC” >&5 $as_echo “$CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$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” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $CC” >&5 $as_echo “$CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_CC=“$ac_tool_prefix$ac_prog” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $CC” >&5 $as_echo “$CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_CC=“$ac_prog” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC” >&5 $as_echo “$ac_ct_CC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi

fi

test -z “$CC” && { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “no acceptable C compiler found in \$PATH See `config.log' for more details” “$LINENO” 5; }

Provide some information about the compiler.

$as_echo “$as_me:${as_lineno-$LINENO}: checking for C compiler version” >&5 set X $ac_compile ac_compiler=$2 for ac_option in –version -v -V -qversion; do { { ac_try=“$ac_compiler $ac_option >&5” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_compiler $ac_option >&5”) 2>conftest.err ac_status=$? if test -s conftest.err; then sed ‘10a\ … rest of stderr output deleted … 10q’ conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } done

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

int main () {

; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files=“$ac_clean_files a.out a.out.dSYM 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.

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether the C compiler works” >&5 $as_echo_n “checking whether the C compiler works… ” >&6; } ac_link_default=$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'

The possible output files:

ac_files=“a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*”

ac_rmfiles= for ac_file in $ac_files do case $ac_file in .$ac_ext | .xcoff | .tds | .d | .pdb | .xSYM | .bb | .bbg | .map | .inf | .dSYM | .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 ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_link_default”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; 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 | .dSYM | .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 if test -z “$ac_file”; then : { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

{ { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error 77 “C compiler cannot create executables See `config.log' for more details” “$LINENO” 5; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } fi { $as_echo “$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name” >&5 $as_echo_n “checking for C compiler default output file name… ” >&6; } { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_file” >&5 $as_echo “$ac_file” >&6; } ac_exeext=$ac_cv_exeext

rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo “$as_me:${as_lineno-$LINENO}: checking for suffix of executables” >&5 $as_echo_n “checking for suffix of executables… ” >&6; } if { { ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_link”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; 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 | .dSYM | .o | .obj ) ;; . ) ac_cv_exeext=expr "$ac_file" : '[^.]*\(\..*\)' break;; * ) break;; esac done else { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot compute suffix of executables: cannot compile and link See `config.log' for more details” “$LINENO” 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext” >&5 $as_echo “$ac_cv_exeext” >&6; }

rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <stdio.h>

int main () { FILE *f = fopen (“conftest.out”, “w”); return ferror (f) || fclose (f) != 0;

; return 0; } _ACEOF ac_clean_files=“$ac_clean_files conftest.out”

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

the compiler is broken, or we cross compile.

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling” >&5 $as_echo_n “checking whether we are cross compiling… ” >&6; } if test “$cross_compiling” != yes; then { { ac_try=“$ac_link” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_link”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } if { ac_try=‘./conftest$ac_cv_exeext’ { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test “$cross_compiling” = maybe; then cross_compiling=yes else { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run C compiled programs. If you meant to cross compile, use `–host'. See `config.log' for more details” “$LINENO” 5; } fi fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $cross_compiling” >&5 $as_echo “$cross_compiling” >&6; }

rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo “$as_me:${as_lineno-$LINENO}: checking for suffix of object files” >&5 $as_echo_n “checking for suffix of object files… ” >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_compile”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; 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 | .dSYM ) ;; ) ac_cv_objext=expr "$ac_file" : '.*\.\(.*\)' break;; esac done else $as_echo “$as_me: failed program was:” >&5 sed ’s/^/| /‘ conftest.$ac_ext >&5

{ { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot compute suffix of object files: cannot compile See `config.log' for more details” “$LINENO” 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext” >&5 $as_echo “$ac_cv_objext” >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler” >&5 $as_echo_n “checking whether we are using the GNU C compiler… ” >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

ifndef GNUC

   choke me

endif

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_compiler_gnu=yes else 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu” >&5 $as_echo “$ac_cv_c_compiler_gnu” >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g” >&5 $as_echo_n “checking whether $CC accepts -g… ” >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n “(cached) ” >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_prog_cc_g=yes else CFLAGS=“” cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then :

else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS=“-g” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_prog_cc_g=yes 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g” >&5 $as_echo “$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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89” >&5 $as_echo_n “checking for $CC option to accept ISO C89… ” >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n “(cached) ” >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include <stdarg.h>

include <stdio.h>

struct stat; / 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” if ac_fn_c_try_compile “$LINENO”; then : ac_cv_prog_cc_c89=$ac_arg 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) { $as_echo “$as_me:${as_lineno-$LINENO}: result: none needed” >&5 $as_echo “none needed” >&6; } ;; xno) { $as_echo “$as_me:${as_lineno-$LINENO}: result: unsupported” >&5 $as_echo “unsupported” >&6; } ;; *) CC=“$CC $ac_cv_prog_cc_c89” { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89” >&5 $as_echo “$ac_cv_prog_cc_c89” >&6; } ;; esac if test “x$ac_cv_prog_cc_c89” != xno; then :

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_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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together” >&5 $as_echo_n “checking whether $CC understands -c and -o together… ” >&6; } if ${am_cv_prog_cc_c_o+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF # Make sure it works both with $CC and with simple cc. # Following AC_PROG_CC_C_O, we do the test twice because some # compilers refuse to overwrite an existing .o file with -o, # though they will create one. am_cv_prog_cc_c_o=yes for am_i in 1 2; do if { echo “$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext” >&5 ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5 ac_status=$? echo “$as_me:$LINENO: \$? = $ac_status” >&5 (exit $ac_status); } \ && test -f conftest2.$ac_objext; then : OK else am_cv_prog_cc_c_o=no break fi done rm -f core conftest* unset am_i fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o” >&5 $as_echo “$am_cv_prog_cc_c_o” >&6; } if test “$am_cv_prog_cc_c_o” != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. # But if we don’t then we get into trouble of one sort or another. # A longer-term fix would be to have automake use amCC in this case, # and then we could set amCC=“\$(top_srcdir)/compile \$(CC)” CC=“$am_aux_dir/compile $CC” 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

DEPDIR=“${am__leading_dot}deps”

ac_config_commands=“$ac_config_commands depfiles”

am_make=${MAKE-make} cat > confinc << ‘END’ amdoit: @echo this is the amdoit target .PHONY: am__doit END

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

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

First try GNU make style include.

echo “include confinc” > confmf

Ignore all kinds of additional output from ‘make’.

case $am_make -s -f confmf 2> /dev/null in #( the\ am__doit\ target) aminclude=include amquote= _am_result=GNU ;; esac

Now try BSD make style include.

if test “$aminclude” = “#”; then echo ‘.include “confinc”’ > confmf case $am_make -s -f confmf 2> /dev/null in #( *the\ amdoit\ target*) aminclude=.include amquote=“\”“ _am_result=BSD ;; esac fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $am_result” >&5 $as_echo “$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=‘\’ am_nodep=‘no’ fi if test “x$enable_dependency_tracking” != xno; then AMDEP_TRUE= AMDEP_FALSE=‘#’ else AMDEP_TRUE=‘#’ AMDEP_FALSE= fi

depcc=“$CC” am_compiler_list=

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc” >&5 $as_echo_n “checking dependency style of $depcc… ” >&6; } if ${am_cv_CC_dependencies_compiler_type+:} false; then : $as_echo_n “(cached) ” >&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”. rm -rf conftest.dir 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 amuniversal=false case “ $depcc ” in #( \ -arch\ \ -arch\ *) amuniversal=true ;; esac

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 10 /bin/sh. echo ’/ dummy /‘ > sub/conftst$i.h done echo “${aminclude} ${amquote}sub/conftest.Po${am__quote}” > confmf

# 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.  Also, some Intel
# versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
gcc)
  # This depmode causes a compiler race in universal mode.
  test "$am__universal" = false || continue
  ;;
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
  ;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
  # This compiler won't grok '-c -o', but also, the minuso test has
  # not run yet.  These depmodes are late enough in the game, and
  # so weak that their functioning should not be impacted.
  am__obj=conftest.${OBJEXT-o}
  am__minus_obj=
  ;;
none) break ;;
esac
if depmode=$depmode \
   source=sub/conftest.c object=$am__obj \
   depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
   $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
     >/dev/null 2>conftest.err &&
   grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
   grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
   grep $am__obj 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type” >&5 $as_echo “$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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor” >&5 $as_echo_n “checking how to run the C preprocessor… ” >&6; }

On Suns, sometimes $CPP names a directory.

if test -n “$CPP” && test -d “$CPP”; then CPP= fi if test -z “$CPP”; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n “(cached) ” >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

         Syntax error

_ACEOF if ac_fn_c_try_cpp “$LINENO”; then :

else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext

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

include <ac_nonexistent.h>

_ACEOF if ac_fn_c_try_cpp “$LINENO”; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext

done

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

rm -f conftest.i 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $CPP” >&5 $as_echo “$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 confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

ifdef STDC

include <limits.h>

else

include <assert.h>

endif

         Syntax error

_ACEOF if ac_fn_c_try_cpp “$LINENO”; then :

else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext

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

include <ac_nonexistent.h>

_ACEOF if ac_fn_c_try_cpp “$LINENO”; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext

done

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

rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then :

else { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “C preprocessor \”$CPP\“ fails sanity check See `config.log' for more details” “$LINENO” 5; } 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 “x$CC” != xcc; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together” >&5 $as_echo_n “checking whether $CC and cc understand -c and -o together… ” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together” >&5 $as_echo_n “checking whether cc understands -c and -o together… ” >&6; } fi set dummy $CC; ac_cc=$as_echo "$2" | sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/' if eval \${ac_cv_prog_cc${ac_cc}c_o+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF

Make sure it works both with $CC and with simple cc.

We do the test twice because some compilers refuse to overwrite an

existing .o file with -o, though they will create one.

ac_try=‘$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5’ rm -f conftest2. if { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -f conftest2.$ac_objext && { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then eval ac_cv_prog_cc${ac_cc}c_o=yes if test “x$CC” != xcc; then # Test first that cc exists at all. if { ac_try=‘cc -c conftest.$ac_ext >&5’ { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; }; then ac_try=‘cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5’ rm -f conftest2. if { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -f conftest2.$ac_objext && { { case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; ) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$ac_try”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then # cc works too. : else # cc exists but doesn’t like -o. eval ac_cv_prog_cc${ac_cc}c_o=no fi fi fi else eval ac_cv_prog_cc${ac_cc}c_o=no fi rm -f core conftest

fi if eval test \$ac_cv_prog_cc${ac_cc}c_o = yes; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; }

$as_echo “#define NO_MINUS_C_MINUS_O 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e” >&5 $as_echo_n “checking for grep that handles long lines and -e… ” >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n “(cached) ” >&6 else if test -z “$GREP”; then 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” as_fn_executable_p “$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 $as_echo_n 0123456789 >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” $as_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 as_fn_arith $ac_count + 1 && ac_count=$as_val 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 if test -z “$ac_cv_path_GREP”; then as_fn_error $? “no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” “$LINENO” 5 fi else ac_cv_path_GREP=$GREP fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP” >&5 $as_echo “$ac_cv_path_GREP” >&6; } GREP=“$ac_cv_path_GREP”

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for egrep” >&5 $as_echo_n “checking for egrep… ” >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n “(cached) ” >&6 else if echo a | $GREP -E ‘(a|b)’ >/dev/null 2>&1 then ac_cv_path_EGREP=“$GREP -E” else if test -z “$EGREP”; then 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” as_fn_executable_p “$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 $as_echo_n 0123456789 >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” $as_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 as_fn_arith $ac_count + 1 && ac_count=$as_val 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 if test -z “$ac_cv_path_EGREP”; then as_fn_error $? “no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” “$LINENO” 5 fi else ac_cv_path_EGREP=$EGREP fi

fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP” >&5 $as_echo “$ac_cv_path_EGREP” >&6; } EGREP=“$ac_cv_path_EGREP”

if test $ac_cv_c_compiler_gnu = yes; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether $CC needs -traditional” >&5 $as_echo_n “checking whether $CC needs -traditional… ” >&6; } if ${ac_cv_prog_gcc_traditional+:} false; then : $as_echo_n “(cached) ” >&6 else ac_pattern=“Autoconf.‘x’” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_gcc_traditional” >&5 $as_echo “$ac_cv_prog_gcc_traditional” >&6; } if test $ac_cv_prog_gcc_traditional = yes; then CC=“$CC -traditional” fi fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)” >&5 $as_echo_n “checking whether ${MAKE-make} sets \$(MAKE)… ” >&6; } set x ${MAKE-make} ac_make=$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g' if eval \${ac_cv_prog_make${ac_make}set+:} false; then : $as_echo_n “(cached) ” >&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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } SET_MAKE= else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } SET_MAKE=“MAKE=${MAKE-make}” fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for library containing strerror” >&5 $as_echo_n “checking for library containing strerror… ” >&6; } if ${ac_cv_search_strerror+:} false; then : $as_echo_n “(cached) ” >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

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

ifdef __cplusplus

extern “C”

endif

char strerror (); int main () { return strerror (); ; return 0; } _ACEOF for ac_lib in ‘’ cposix; do if test -z “$ac_lib”; then ac_res=“none required” else ac_res=-l$ac_lib LIBS=“-l$ac_lib $ac_func_search_save_LIBS” fi if ac_fn_c_try_link “$LINENO”; then : ac_cv_search_strerror=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_strerror+:} false; then : break fi done if ${ac_cv_search_strerror+:} false; then :

else ac_cv_search_strerror=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_strerror” >&5 $as_echo “$ac_cv_search_strerror” >&6; } ac_res=$ac_cv_search_strerror if test “$ac_res” != no; then : test “$ac_res” = “none required” || LIBS=“$ac_res $LIBS”

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ANSI C header files” >&5 $as_echo_n “checking for ANSI C header files… ” >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <stdlib.h>

include <stdarg.h>

include <string.h>

include <float.h>

int main () {

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_header_stdc=yes else 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_run “$LINENO”; then :

else ac_cv_header_stdc=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

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

$as_echo “#define STDC_HEADERS 1” >>confdefs.h

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=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_compile “$LINENO” “$ac_header” “$as_ac_Header” “$ac_includes_default ” if eval test \“x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

ac_fn_c_check_header_mongrel “$LINENO” “minix/config.h” “ac_cv_header_minix_config_h” “$ac_includes_default” if test “x$ac_cv_header_minix_config_h” = xyes; then : MINIX=yes else MINIX= fi

if test “$MINIX” = yes; then

$as_echo “#define _POSIX_SOURCE 1” >>confdefs.h

$as_echo “#define _POSIX_1_SOURCE 2” >>confdefs.h

$as_echo “#define _MINIX 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether it is safe to define EXTENSIONS” >&5 $as_echo_n “checking whether it is safe to define EXTENSIONS… ” >&6; } if ${ac_cv_safe_to_defineextensions+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

define EXTENSIONS 1

      $ac_includes_default

int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_safe_to_defineextensions=yes else ac_cv_safe_to_defineextensions=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_defineextensions” >&5 $as_echo “$ac_cv_safe_to_defineextensions” >&6; } test $ac_cv_safe_to_defineextensions = yes && $as_echo “#define EXTENSIONS 1” >>confdefs.h

$as_echo “#define _ALL_SOURCE 1” >>confdefs.h

$as_echo “#define _GNU_SOURCE 1” >>confdefs.h

$as_echo “#define _POSIX_PTHREAD_SEMANTICS 1” >>confdefs.h

$as_echo “#define _TANDEM_SOURCE 1” >>confdefs.h

{ $as_echo “$as_me:${as_lineno-$LINENO}: OPTION PROCESSING ” >&5 $as_echo “$as_me: OPTION PROCESSING ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking if ldap is wanted” >&5 $as_echo_n “checking if ldap is wanted… ” >&6; } ac_upcase=echo ldap|tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

Check whether –with-ldap was given.

if test “${with_ldap+set}” = set; then : withval=$with_ldap; if test “$withval” = “yes”; then with_ldap=yes elif test “$withval” = “no”; then with_ldap=no else as_fn_error $? “please use \"yes\” or \“no\” with –with-ldap" “$LINENO” 5 fi

else

with_ldap=yes

fi

if test “$with_ldap” = “yes” then { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes, will enable if all libraries are found” >&5 $as_echo “yes, will enable if all libraries are found” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if hesiod is wanted” >&5 $as_echo_n “checking if hesiod is wanted… ” >&6; } ac_upcase=echo hesiod|tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

Check whether –with-hesiod was given.

if test “${with_hesiod+set}” = set; then : withval=$with_hesiod; if test “$withval” = “yes”; then with_hesiod=yes elif test “$withval” = “no”; then with_hesiod=no else as_fn_error $? “please use \"yes\” or \“no\” with –with-hesiod" “$LINENO” 5 fi

else

with_hesiod=yes

fi

if test “$with_hesiod” = “yes” then { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes, will enable if all libraries are found” >&5 $as_echo “yes, will enable if all libraries are found” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if ndbm is wanted” >&5 $as_echo_n “checking if ndbm is wanted… ” >&6; } ac_upcase=echo ndbm|tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

Check whether –with-ndbm was given.

if test “${with_ndbm+set}” = set; then : withval=$with_ndbm; if test “$withval” = “yes”; then with_ndbm=yes elif test “$withval” = “no”; then with_ndbm=no else as_fn_error $? “please use \"yes\” or \“no\” with –with-ndbm" “$LINENO” 5 fi

else

with_ndbm=yes

fi

if test “$with_ndbm” = “yes” then { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes, will enable if all libraries are found” >&5 $as_echo “yes, will enable if all libraries are found” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for debugging options” >&5 $as_echo_n “checking for debugging options… ” >&6; }

Check whether –enable-debug was given.

if test “${enable_debug+set}” = set; then : enableval=$enable_debug; if test “$enableval” = yes; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } $as_echo “#define DEBUG 1” >>confdefs.h

ac_cv_opt_debug=yes elif test “$enableval” = mem; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: mem” >&5 $as_echo “mem” >&6; } $as_echo “#define DEBUG 1” >>confdefs.h

$as_echo “#define DEBUG_MEM 1” >>confdefs.h

ac_fn_c_check_func “$LINENO” “malloc_verify” “ac_cv_func_malloc_verify” if test “x$ac_cv_func_malloc_verify” = xyes; then :

else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for malloc_verify in -lmapmalloc” >&5 $as_echo_n “checking for malloc_verify in -lmapmalloc… ” >&6; } if ${ac_cv_lib_mapmalloc_malloc_verify+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lmapmalloc $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 malloc_verify (); int main () { return malloc_verify (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_mapmalloc_malloc_verify=yes else ac_cv_lib_mapmalloc_malloc_verify=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mapmalloc_malloc_verify” >&5 $as_echo “$ac_cv_lib_mapmalloc_malloc_verify” >&6; } if test “x$ac_cv_lib_mapmalloc_malloc_verify” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBMAPMALLOC 1

_ACEOF

LIBS=“-lmapmalloc $LIBS”

fi

fi

ac_fn_c_check_func “$LINENO” “mallinfo” “ac_cv_func_mallinfo” if test “x$ac_cv_func_mallinfo” = xyes; then :

else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for mallinfo in -lmalloc” >&5 $as_echo_n “checking for mallinfo in -lmalloc… ” >&6; } if ${ac_cv_lib_malloc_mallinfo+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lmalloc $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 mallinfo (); int main () { return mallinfo (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_malloc_mallinfo=yes else ac_cv_lib_malloc_mallinfo=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_malloc_mallinfo” >&5 $as_echo “$ac_cv_lib_malloc_mallinfo” >&6; } if test “x$ac_cv_lib_malloc_mallinfo” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBMALLOC 1

_ACEOF

LIBS=“-lmalloc $LIBS”

fi

fi

ac_cv_opt_debug=mem else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } ac_cv_opt_debug=no fi

else

# default is no debugging { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; }

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for configuration/compilation (-I) preprocessor flags” >&5 $as_echo_n “checking for configuration/compilation (-I) preprocessor flags… ” >&6; }

Check whether –enable-cppflags was given.

if test “${enable_cppflags+set}” = set; then : enableval=$enable_cppflags; if test “$enableval” = “” || test “$enableval” = “yes” || test “$enableval” = “no”; then as_fn_error $? “cppflags must be supplied if option is used” “$LINENO” 5 fi

use supplied options

CPPFLAGS=“$CPPFLAGS $enableval” export CPPFLAGS { $as_echo “$as_me:${as_lineno-$LINENO}: result: $enableval” >&5 $as_echo “$enableval” >&6; }

else

# default is to have no additional flags { $as_echo “$as_me:${as_lineno-$LINENO}: result: none” >&5 $as_echo “none” >&6; }

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for configuration/compilation (-l) library flags” >&5 $as_echo_n “checking for configuration/compilation (-l) library flags… ” >&6; }

Check whether –enable-libs was given.

if test “${enable_libs+set}” = set; then : enableval=$enable_libs; if test “$enableval” = “” || test “$enableval” = “yes” || test “$enableval” = “no”; then as_fn_error $? “libs must be supplied if option is used” “$LINENO” 5 fi

use supplied options

LIBS=“$LIBS $enableval” export LIBS { $as_echo “$as_me:${as_lineno-$LINENO}: result: $enableval” >&5 $as_echo “$enableval” >&6; }

else

# default is to have no additional flags { $as_echo “$as_me:${as_lineno-$LINENO}: result: none” >&5 $as_echo “none” >&6; }

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for configuration/compilation (-L) library flags” >&5 $as_echo_n “checking for configuration/compilation (-L) library flags… ” >&6; }

Check whether –enable-ldflags was given.

if test “${enable_ldflags+set}” = set; then : enableval=$enable_ldflags; if test “$enableval” = “” || test “$enableval” = “yes” || test “$enableval” = “no”; then as_fn_error $? “ldflags must be supplied if option is used” “$LINENO” 5 fi

use supplied options

LDFLAGS=“$LDFLAGS $enableval” export LDFLAGS { $as_echo “$as_me:${as_lineno-$LINENO}: result: $enableval” >&5 $as_echo “$enableval” >&6; }

else

# default is to have no additional flags { $as_echo “$as_me:${as_lineno-$LINENO}: result: none” >&5 $as_echo “none” >&6; }

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for additional C option compilation flags” >&5 $as_echo_n “checking for additional C option compilation flags… ” >&6; }

Check whether –enable-am-cflags was given.

if test “${enable_am_cflags+set}” = set; then : enableval=$enable_am_cflags; if test “$enableval” = “” || test “$enableval” = “yes” || test “$enableval” = “no”; then as_fn_error $? “am-cflags must be supplied if option is used” “$LINENO” 5 fi

user supplied a cflags option to configure

AMU_CFLAGS=“$enableval”

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $enableval” >&5 $as_echo “$enableval” >&6; }

else

# default is to have no additional C flags AMU_CFLAGS=“”

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: none” >&5 $as_echo “none” >&6; }

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking a local configuration file” >&5 $as_echo_n “checking a local configuration file… ” >&6; } if test -f localconfig.h then $as_echo “#define HAVE_LOCALCONFIG_H 1” >>confdefs.h

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles” >&5 $as_echo_n “checking whether to enable maintainer-specific portions of Makefiles… ” >&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

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE” >&5 $as_echo “$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

{ $as_echo “$as_me:${as_lineno-$LINENO}: LIBTOOL ” >&5 $as_echo “$as_me: LIBTOOL ” >&6;}

Check whether –enable-shared was given.

if test “${enable_shared+set}” = set; then : enableval=$enable_shared; p=${PACKAGE-default} case $enableval in yes) enable_shared=yes ;; no) enable_shared=no ;; *) enable_shared=no # Look at the argument we got. We use all the common list separators. lt_save_ifs=“$IFS”; IFS=“${IFS}$PATH_SEPARATOR,” for pkg in $enableval; do IFS=“$lt_save_ifs” if test “X$pkg” = “X$p”; then enable_shared=yes fi done IFS=“$lt_save_ifs” ;; esac else enable_shared=no fi

case ${host_os} in # Temporarily undo renaming of “linux-gnu” to “linux”, because # libtool only looks for “linux-gnu”. Sigh. linux ) host_os=linux-gnu ;; esac case pwd in \ * | \ *) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in `pwd`” >&5 $as_echo “$as_me: WARNING: Libtool does not cope well with whitespace in `pwd`” >&2;} ;; esac

macro_version=‘2.4.2’ macro_revision=‘1.3337’

ltmain=“$ac_aux_dir/ltmain.sh”

Backslashify metacharacters that are still active within

double-quoted strings.

sed_quote_subst=’s/([“`$\])/\\1/g'

Same as above, but do not quote variable references.

double_quote_subst=’s/([“`\])/\\1/g'

Sed substitution to delay expansion of an escaped shell variable in a

double_quote_subst'ed string.

delay_variable_subst=’s/\\\\\\$/\\\$/g'

Sed substitution to delay expansion of an escaped single quote.

delay_single_quote_subst=’s/‘\’‘/’\‘\\\\’\‘’/g'

Sed substitution to avoid accidental globbing in evaled expressions

no_glob_subst=’s/*/\*/g'

ECHO=‘\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\’ ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to print strings” >&5 $as_echo_n “checking how to print strings… ” >&6; }

Test print first, because it will be a builtin if present.

if test “X( print -r -- -n ) 2>/dev/null” = X-n && \ test “Xprint -r -- $ECHO 2>/dev/null” = “X$ECHO”; then ECHO=‘print -r –’ elif test “Xprintf %s $ECHO 2>/dev/null” = “X$ECHO”; then ECHO=‘printf %s\n’ else # Use this function as a fallback that always works. func_fallback_echo () { eval ‘cat <<LTECHO_EOF $1 LTECHO_EOF’ } ECHO=‘func_fallback_echo’ fi

func_echo_all arg…

Invoke $ECHO with all args, space-separated.

func_echo_all () { $ECHO “” }

case “$ECHO” in printf) { $as_echo “$as_me:${as_lineno-$LINENO}: result: printf” >&5 $as_echo “printf” >&6; } ;; print) { $as_echo “$as_me:${as_lineno-$LINENO}: result: print -r” >&5 $as_echo “print -r” >&6; } ;; *) { $as_echo “$as_me:${as_lineno-$LINENO}: result: cat” >&5 $as_echo “cat” >&6; } ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output” >&5 $as_echo_n “checking for a sed that does not truncate output… ” >&6; } if ${ac_cv_path_SED+:} false; then : $as_echo_n “(cached) ” >&6 else ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for ac_i in 1 2 3 4 5 6 7; do ac_script=“$ac_script$as_nl$ac_script” done echo “$ac_script” 2>/dev/null | sed 99q >conftest.sed { ac_script=; unset ac_script;} if test -z “$SED”; then ac_path_SED_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 do IFS=$as_save_IFS test -z “$as_dir” && as_dir=. for ac_prog in sed gsed; do for ac_exec_ext in ‘’ $ac_executable_extensions; do ac_path_SED=“$as_dir/$ac_prog$ac_exec_ext” as_fn_executable_p “$ac_path_SED” || continue

Check for GNU ac_path_SED and select it if it is found.

# Check for GNU $ac_path_SED case "$ac_path_SED" --version 2>&1 in GNU) ac_cv_path_SED=“$ac_path_SED” ac_path_SED_found=:;; ) ac_count=0 $as_echo_n 0123456789 >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” $as_echo ‘’ >> “conftest.nl” “$ac_path_SED” -f conftest.sed < “conftest.nl” >“conftest.out” 2>/dev/null || break diff “conftest.out” “conftest.nl” >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_SED_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_SED=“$ac_path_SED” ac_path_SED_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_SED_found && break 3
done

done done IFS=$as_save_IFS if test -z “$ac_cv_path_SED”; then as_fn_error $? “no acceptable sed could be found in \$PATH” “$LINENO” 5 fi else ac_cv_path_SED=$SED fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED” >&5 $as_echo “$ac_cv_path_SED” >&6; } SED=“$ac_cv_path_SED” rm -f conftest.sed

test -z “$SED” && SED=sed Xsed=“$SED -e 1s/^X//”

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for fgrep” >&5 $as_echo_n “checking for fgrep… ” >&6; } if ${ac_cv_path_FGREP+:} false; then : $as_echo_n “(cached) ” >&6 else if echo ‘abc’ | $GREP -F ‘abc’ >/dev/null 2>&1 then ac_cv_path_FGREP=“$GREP -F” else if test -z “$FGREP”; then ac_path_FGREP_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 fgrep; do for ac_exec_ext in ‘’ $ac_executable_extensions; do ac_path_FGREP=“$as_dir/$ac_prog$ac_exec_ext” as_fn_executable_p “$ac_path_FGREP” || continue

Check for GNU ac_path_FGREP and select it if it is found.

# Check for GNU $ac_path_FGREP case "$ac_path_FGREP" --version 2>&1 in GNU) ac_cv_path_FGREP=“$ac_path_FGREP” ac_path_FGREP_found=:;; ) ac_count=0 $as_echo_n 0123456789 >“conftest.in” while : do cat “conftest.in” “conftest.in” >“conftest.tmp” mv “conftest.tmp” “conftest.in” cp “conftest.in” “conftest.nl” $as_echo ‘FGREP’ >> “conftest.nl” “$ac_path_FGREP” FGREP < “conftest.nl” >“conftest.out” 2>/dev/null || break diff “conftest.out” “conftest.nl” >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_FGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_FGREP=“$ac_path_FGREP” ac_path_FGREP_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_FGREP_found && break 3
done

done done IFS=$as_save_IFS if test -z “$ac_cv_path_FGREP”; then as_fn_error $? “no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin” “$LINENO” 5 fi else ac_cv_path_FGREP=$FGREP fi

fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP” >&5 $as_echo “$ac_cv_path_FGREP” >&6; } FGREP=“$ac_cv_path_FGREP”

test -z “$GREP” && GREP=grep

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

ac_prog=ld if test “$GCC” = yes; then # Check if gcc -print-prog-name=ld gives a path. { $as_echo “$as_me:${as_lineno-$LINENO}: checking for ld used by $CC” >&5 $as_echo_n “checking for ld used by $CC… ” >&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. [\/] | ?:[\/]) re_direlt=‘/[^/][^/]/../’ # Canonicalize the pathname 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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for GNU ld” >&5 $as_echo_n “checking for GNU ld… ” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for non-GNU ld” >&5 $as_echo_n “checking for non-GNU ld… ” >&6; } fi if ${lt_cv_path_LD+:} false; then : $as_echo_n “(cached) ” >&6 else if test -z “$LD”; then lt_save_ifs=“$IFS”; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS=“$lt_save_ifs” test -z “$ac_dir” && ac_dir=. if test -f “$ac_dir/$ac_prog” || test -f “$ac_dir/$ac_prog$ac_exeext”; then lt_cv_path_LD=“$ac_dir/$ac_prog” # Check to see if the program is GNU ld. I’d rather use –version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case "$lt_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=“$lt_save_ifs” else lt_cv_path_LD=“$LD” # Let the user override the test with a path. fi fi

LD=“$lt_cv_path_LD” if test -n “$LD”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $LD” >&5 $as_echo “$LD” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi test -z “$LD” && as_fn_error $? “no acceptable ld found in \$PATH” “$LINENO” 5 { $as_echo “$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld” >&5 $as_echo_n “checking if the linker ($LD) is GNU ld… ” >&6; } if ${lt_cv_prog_gnu_ld+:} false; then : $as_echo_n “(cached) ” >&6 else # I’d rather use –version here, but apparently some GNU lds only accept -v. case $LD -v 2>&1 </dev/null in GNU | ‘with BFD’) lt_cv_prog_gnu_ld=yes ;; *) lt_cv_prog_gnu_ld=no ;; esac fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld” >&5 $as_echo “$lt_cv_prog_gnu_ld” >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)” >&5 $as_echo_n “checking for BSD- or MS-compatible name lister (nm)… ” >&6; } if ${lt_cv_path_NM+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$NM”; then # Let the user override the test. lt_cv_path_NM=“$NM” else lt_nm_to_check=“${ac_tool_prefix}nm” if test -n “$ac_tool_prefix” && test “$build” = “$host”; then lt_nm_to_check=“$lt_nm_to_check nm” fi for lt_tmp_nm in $lt_nm_to_check; do lt_save_ifs=“$IFS”; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do IFS=“$lt_save_ifs” test -z “$ac_dir” && ac_dir=. tmp_nm=“$ac_dir/$lt_tmp_nm” if test -f “$tmp_nm” || test -f “$tmp_nm$ac_exeext” ; then # Check to see if the nm accepts a BSD-compat flag. # Adding the sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file case“$tmp_nm” -B /dev/null 2>&1 | sed ‘1q’in */dev/null* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break ;; *) case“$tmp_nm” -p /dev/null 2>&1 | sed ‘1q’` in /dev/null) lt_cv_path_NM=“$tmp_nm -p” break ;; *) lt_cv_path_NM=${lt_cv_path_NM=“$tmp_nm”} # keep the first match, but continue # so that we can try to find one that supports BSD flags ;; esac ;; esac fi done IFS=“$lt_save_ifs” done : ${lt_cv_path_NM=no} fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM” >&5 $as_echo “$lt_cv_path_NM” >&6; } if test “$lt_cv_path_NM” != “no”; then NM=“$lt_cv_path_NM” else # Didn’t find any BSD compatible name lister, look for dumpbin. if test -n “$DUMPBIN”; then : # Let the user override the test. else if test -n “$ac_tool_prefix”; then for ac_prog in dumpbin “link -dump” 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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_DUMPBIN+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$DUMPBIN”; then ac_cv_prog_DUMPBIN=“$DUMPBIN” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_DUMPBIN=“$ac_tool_prefix$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi DUMPBIN=$ac_cv_prog_DUMPBIN if test -n “$DUMPBIN”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $DUMPBIN” >&5 $as_echo “$DUMPBIN” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n "$DUMPBIN" && break

done fi if test -z “$DUMPBIN”; then ac_ct_DUMPBIN=$DUMPBIN for ac_prog in dumpbin “link -dump” do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_DUMPBIN”; then ac_cv_prog_ac_ct_DUMPBIN=“$ac_ct_DUMPBIN” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_DUMPBIN=“$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN if test -n “$ac_ct_DUMPBIN”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN” >&5 $as_echo “$ac_ct_DUMPBIN” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$ac_ct_DUMPBIN” && break done

if test “x$ac_ct_DUMPBIN” = x; then DUMPBIN=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac DUMPBIN=$ac_ct_DUMPBIN fi fi

case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
*COFF*)
  DUMPBIN="$DUMPBIN -symbols"
  ;;
*)
  DUMPBIN=:
  ;;
esac

fi

if test “$DUMPBIN” != “:”; then NM=“$DUMPBIN” fi fi test -z “$NM” && NM=nm

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface” >&5 $as_echo_n “checking the name lister ($NM) interface… ” >&6; } if ${lt_cv_nm_interface+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_nm_interface=“BSD nm” echo “int some_variable = 0;” > conftest.$ac_ext (eval echo “\”\$as_me:$LINENO: $ac_compile\“” >&5) (eval “$ac_compile” 2>conftest.err) cat conftest.err >&5 (eval echo “\”\$as_me:$LINENO: $NM \\“conftest.$ac_objext\\”\“” >&5) (eval “$NM \"conftest.$ac_objext\”“ 2>conftest.err > conftest.out) cat conftest.err >&5 (eval echo ”\“\$as_me:$LINENO: output\”“ >&5) cat conftest.out >&5 if $GREP ‘External.some_variable’ conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin” fi rm -rf conftest fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface” >&5 $as_echo “$lt_cv_nm_interface” >&6; }

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

find the maximum length of command line arguments

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments” >&5 $as_echo_n “checking the maximum length of command line arguments… ” >&6; } if ${lt_cv_sys_max_cmd_len+:} false; then : $as_echo_n “(cached) ” >&6 else i=0 teststring=“ABCD”

case $build_os in msdosdjgpp*) # On DJGPP, this test can blow up pretty badly due to problems in libc # (any single argument exceeding 2000 bytes causes a buffer overrun # during glob expansion). Even if it were fixed, the result of this # check would be larger than it should be. lt_cv_sys_max_cmd_len=12288; # 12K is about right ;;

gnu*) # Under GNU Hurd, this test is not required because there is # no limit to the length of command line arguments. # Libtool will interpret -1 as no limit whatsoever lt_cv_sys_max_cmd_len=-1; ;;

cygwin | mingw | cegcc*) # On Win9x/ME, this test blows up – it succeeds, but takes # about 5 minutes as the teststring grows exponentially. # Worse, since 9x/ME are not pre-emptively multitasking, # you end up with a “frozen” computer, even though with patience # the test eventually succeeds (with a max line length of 256k). # Instead, let’s just punt: use the minimum linelength reported by # all of the supported platforms: 8192 (on NT/2K/XP). lt_cv_sys_max_cmd_len=8192; ;;

mint*) # On MiNT this can take a long time and run out of memory. lt_cv_sys_max_cmd_len=8192; ;;

amigaos*) # On AmigaOS with pdksh, this test takes hours, literally. # So we just punt and use a minimum line length of 8192. lt_cv_sys_max_cmd_len=8192; ;;

netbsd | freebsd | openbsd | darwin | dragonfly*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=/sbin/sysctl -n kern.argmax elif test -x /usr/sbin/sysctl; then lt_cv_sys_max_cmd_len=/usr/sbin/sysctl -n kern.argmax else lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs fi # And add a safety zone lt_cv_sys_max_cmd_len=expr $lt_cv_sys_max_cmd_len \/ 4 lt_cv_sys_max_cmd_len=expr $lt_cv_sys_max_cmd_len \* 3 ;;

interix*) # We know the value 262144 and hardcode it with a safety zone (like BSD) lt_cv_sys_max_cmd_len=196608 ;;

os2*) # The test takes a long time on OS/2. lt_cv_sys_max_cmd_len=8192 ;;

osf) # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not # nice to cause kernel panics so lets avoid the loop below. # First set a reasonable default. lt_cv_sys_max_cmd_len=16384 # if test -x /sbin/sysconfig; then case /sbin/sysconfig -q proc exec_disable_arg_limit in 1) lt_cv_sys_max_cmd_len=-1 ;; esac fi ;; sco3.2v5) lt_cv_sys_max_cmd_len=102400 ;; sysv5 | sco5v6 | sysv4.2uw2) kargmax=grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null if test -n “$kargmax”; then lt_cv_sys_max_cmd_len=echo $kargmax | sed 's/.*[ ]//' else lt_cv_sys_max_cmd_len=32768 fi ;; ) lt_cv_sys_max_cmd_len=(getconf ARG_MAX) 2> /dev/null if test -n “$lt_cv_sys_max_cmd_len”; then lt_cv_sys_max_cmd_len=expr $lt_cv_sys_max_cmd_len \/ 4 lt_cv_sys_max_cmd_len=expr $lt_cv_sys_max_cmd_len \* 3 else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. for i in 1 2 3 4 5 6 7 8 ; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we’ll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can’t tell. while { test “X”env echo "$teststring$teststring" 2>/dev/null \ = “X$teststring$teststring”; } >/dev/null 2>&1 && test $i != 17 # ½ MB should be enough do i=expr $i + 1 teststring=$teststring$teststring done # Only check the string length outside the loop. lt_cv_sys_max_cmd_len=expr "X$teststring" : ".*" 2>&1 teststring= # Add a significant safety factor because C++ compilers can tack on # massive amounts of additional arguments before passing them to the # linker. It appears as though ½ is a usable value. lt_cv_sys_max_cmd_len=expr $lt_cv_sys_max_cmd_len \/ 2 fi ;; esac

fi

if test -n $lt_cv_sys_max_cmd_len ; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len” >&5 $as_echo “$lt_cv_sys_max_cmd_len” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: none” >&5 $as_echo “none” >&6; } fi max_cmd_len=$lt_cv_sys_max_cmd_len

: ${CP=“cp -f”} : ${MV=“mv -f”} : ${RM=“rm -f”}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs” >&5 $as_echo_n “checking whether the shell understands some XSI constructs… ” >&6; }

Try some XSI features

xsi_shell=no ( lt_dummy=“a/b/c” test “${lt_dummy##/},${_lt_dummy%/},${lt_dummy#??}”${lt_dummy%“$lt_dummy”}, \ = c,a/b,b/c, \ && eval ‘test $(( 1 + 1 )) -eq 2 \ && test “${#lt_dummy}” -eq 5’ ) >/dev/null 2>&1 \ && xsi_shell=yes { $as_echo “$as_me:${as_lineno-$LINENO}: result: $xsi_shell” >&5 $as_echo “$xsi_shell” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether the shell understands \”+=\“” >&5 $as_echo_n “checking whether the shell understands \”+=\“… ” >&6; } lt_shell_append=no ( foo=bar; set foo baz; eval “$1+=\$2” && test “$foo” = barbaz ) \ >/dev/null 2>&1 \ && lt_shell_append=yes { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_shell_append” >&5 $as_echo “$lt_shell_append” >&6; }

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

test EBCDIC or ASCII

case echo X|tr X '\101' in A) # ASCII based system # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr lt_SP2NL=‘tr \040 \012’ lt_NL2SP=‘tr \015\012 \040\040’ ;; *) # EBCDIC based system lt_SP2NL=‘tr \100 \n’ lt_NL2SP=‘tr \r\n \100\100’ ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format” >&5 $as_echo_n “checking how to convert $build file names to $host format… ” >&6; } if ${lt_cv_to_host_file_cmd+:} false; then : $as_echo_n “(cached) ” >&6 else case $host in --mingw ) case $build in --mingw ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 ;; --cygwin ) lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 ;; * ) # otherwise, assume nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 ;; esac ;; --cygwin ) case $build in --mingw ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin ;; --cygwin ) lt_cv_to_host_file_cmd=func_convert_file_noop ;; * ) # otherwise, assume nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin ;; esac ;; * ) # unhandled hosts (and “normal” native builds) lt_cv_to_host_file_cmd=func_convert_file_noop ;; esac

fi

to_host_file_cmd=$lt_cv_to_host_file_cmd { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd” >&5 $as_echo “$lt_cv_to_host_file_cmd” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format” >&5 $as_echo_n “checking how to convert $build file names to toolchain format… ” >&6; } if ${lt_cv_to_tool_file_cmd+:} false; then : $as_echo_n “(cached) ” >&6 else #assume ordinary cross tools, or native build. lt_cv_to_tool_file_cmd=func_convert_file_noop case $host in --mingw ) case $build in --mingw ) # actually msys lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 ;; esac ;; esac

fi

to_tool_file_cmd=$lt_cv_to_tool_file_cmd { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd” >&5 $as_echo “$lt_cv_to_tool_file_cmd” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files” >&5 $as_echo_n “checking for $LD option to reload object files… ” >&6; } if ${lt_cv_ld_reload_flag+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_ld_reload_flag=‘-r’ fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag” >&5 $as_echo “$lt_cv_ld_reload_flag” >&6; } reload_flag=$lt_cv_ld_reload_flag case $reload_flag in “” | “ ”) ;; ) reload_flag=“ $reload_flag” ;; esac reload_cmds=‘$LD$reload_flag -o $output$reload_objs’ case $host_os in cygwin | mingw | pw32 | cegcc) if test “$GCC” != yes; then reload_cmds=false fi ;; darwin*) if test “$GCC” = yes; then reload_cmds=‘$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs’ else reload_cmds=‘$LD$reload_flag -o $output$reload_objs’ fi ;; esac

if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}objdump”, so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_OBJDUMP+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$OBJDUMP”; then ac_cv_prog_OBJDUMP=“$OBJDUMP” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_OBJDUMP=“${ac_tool_prefix}objdump” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n “$OBJDUMP”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $OBJDUMP” >&5 $as_echo “$OBJDUMP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_OBJDUMP”; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of “objdump”, so it can be a program name with args. set dummy objdump; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_OBJDUMP”; then ac_cv_prog_ac_ct_OBJDUMP=“$ac_ct_OBJDUMP” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_OBJDUMP=“objdump” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n “$ac_ct_OBJDUMP”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP” >&5 $as_echo “$ac_ct_OBJDUMP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_OBJDUMP” = x; then OBJDUMP=“false” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP fi else OBJDUMP=“$ac_cv_prog_OBJDUMP” fi

test -z “$OBJDUMP” && OBJDUMP=objdump

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries” >&5 $as_echo_n “checking how to recognize dependent libraries… ” >&6; } if ${lt_cv_deplibs_check_method+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_file_magic_cmd=‘$MAGIC_CMD’ lt_cv_file_magic_test_file= lt_cv_deplibs_check_method=‘unknown’

Need to set the preceding variable on all platforms that support

interlibrary dependencies.

‘none’ – dependencies not supported.

`unknown' – same as none, but documents that we really don’t know.

‘pass_all’ – all dependencies passed with no checks.

‘test_compile’ – check by making test program.

‘file_magic [[regex]]’ – check by looking for files in library path

which responds to the $file_magic_cmd with a given extended regex.

If you have `file' or equivalent on your system and you’re not sure

whether `pass_all' will always work, you probably want this one.

case $host_os in aix[4-9]*) lt_cv_deplibs_check_method=pass_all ;;

beos*) lt_cv_deplibs_check_method=pass_all ;;

bsdi[45]) lt_cv_deplibs_check_method=‘file_magic ELF [0-9][0-9]-bit [ML]SB (shared object|dynamic lib)’ lt_cv_file_magic_cmd=‘/usr/bin/file -L’ lt_cv_file_magic_test_file=/shlib/libc.so ;;

cygwin*) # func_win32_libid is a shell function defined in ltmain.sh lt_cv_deplibs_check_method=‘file_magic ^x86 archive import|^x86 DLL’ lt_cv_file_magic_cmd=‘func_win32_libid’ ;;

mingw | pw32) # Base MSYS/MinGW do not provide the ‘file’ command needed by # func_win32_libid shell function, so use a weaker test based on ‘objdump’, # unless we find ‘file’, for example because we are cross-compiling. # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. if ( test “$lt_cv_nm_interface” = “BSD nm” && file / ) >/dev/null 2>&1; then lt_cv_deplibs_check_method=‘file_magic ^x86 archive import|^x86 DLL’ lt_cv_file_magic_cmd=‘func_win32_libid’ else # Keep this pattern in sync with the one in func_win32_libid. lt_cv_deplibs_check_method=‘file_magic file format (pei-i386(.architecture: i386)?|pe-arm-wince|pe-x86-64)’ lt_cv_file_magic_cmd=‘$OBJDUMP -f’ fi ;;

cegcc) # use the weaker test based on ‘objdump’. See mingw. lt_cv_deplibs_check_method=‘file_magic file format pe-arm-.little(.architecture: arm)?’ lt_cv_file_magic_cmd=‘$OBJDUMP -f’ ;;

darwin | rhapsody) lt_cv_deplibs_check_method=pass_all ;;

freebsd | dragonfly) if echo ELF | $CC -E - | $GREP ELF > /dev/null; then case $host_cpu in i*86 ) # Not sure whether the presence of OpenBSD here was a mistake. # Let’s accept both of them until this is cleared up. lt_cv_deplibs_check_method=‘file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library’ lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=echo /usr/lib/libc.so.* ;; esac else lt_cv_deplibs_check_method=pass_all fi ;;

gnu*) lt_cv_deplibs_check_method=pass_all ;;

haiku*) lt_cv_deplibs_check_method=pass_all ;;

hpux10.20 | hpux11) lt_cv_file_magic_cmd=/usr/bin/file case $host_cpu in ia64) lt_cv_deplibs_check_method=‘file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64’ lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so ;; hppa64) lt_cv_deplibs_check_method=‘file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -] PA-RISC [0-9].[0-9]’ lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl ;; *) lt_cv_deplibs_check_method=‘file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library’ lt_cv_file_magic_test_file=/usr/lib/libc.sl ;; esac ;;

interix[3-9]*) # PIC code is broken on Interix 3.x, that’s why |.a not |_pic.a here lt_cv_deplibs_check_method=‘match_pattern /lib[^/]+(.so|.a)$’ ;;

irix5 | irix6 | nonstopux) case $LD in -32|“-32 ”) libmagic=32-bit;; -n32|“-n32 ”) libmagic=N32;; -64|“-64 ”) libmagic=64-bit;; ) libmagic=never-match;; esac lt_cv_deplibs_check_method=pass_all ;;

This must be glibc/ELF.

linux | kbsd-gnu | kopensolaris-gnu) lt_cv_deplibs_check_method=pass_all ;;

netbsd*) if echo ELF | $CC -E - | $GREP ELF > /dev/null; then lt_cv_deplibs_check_method=‘match_pattern /lib[^/]+(.so.[0-9]+.[0-9]+|pic.a)$’ else lt_cv_deplibs_check_method=‘match_pattern /lib[^/]+(.so|pic.a)$’ fi ;;

newos6) lt_cv_deplibs_check_method=‘file_magic ELF [0-9][0-9]-bit [ML]SB (executable|dynamic lib)’ lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=/usr/lib/libnls.so ;;

nto | qnx) lt_cv_deplibs_check_method=pass_all ;;

openbsd*) if test -z “echo __ELF__ | $CC -E - | $GREP __ELF__” || test “$host_os-$host_cpu” = “openbsd2.8-powerpc”; then lt_cv_deplibs_check_method=‘match_pattern /lib[^/]+(.so.[0-9]+.[0-9]+|.so|pic.a)$’ else lt_cv_deplibs_check_method=‘match_pattern /lib[^/]+(.so.[0-9]+.[0-9]+|pic.a)$’ fi ;;

osf3 | osf4 | osf5*) lt_cv_deplibs_check_method=pass_all ;;

rdos*) lt_cv_deplibs_check_method=pass_all ;;

solaris*) lt_cv_deplibs_check_method=pass_all ;;

sysv5 | sco3.2v5 | sco5v6 | unixware | OpenUNIX | sysv4uw2*) lt_cv_deplibs_check_method=pass_all ;;

sysv4 | sysv4.3) case $host_vendor in motorola) lt_cv_deplibs_check_method=‘file_magic ELF [0-9][0-9]-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9] Version [0-9]’ lt_cv_file_magic_test_file=echo /usr/lib/libc.so* ;; ncr) lt_cv_deplibs_check_method=pass_all ;; sequent) lt_cv_file_magic_cmd=‘/bin/file’ lt_cv_deplibs_check_method=‘file_magic ELF [0-9][0-9]-bit [LM]SB (shared object|dynamic lib )’ ;; sni) lt_cv_file_magic_cmd=‘/bin/file’ lt_cv_deplibs_check_method=“file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib” lt_cv_file_magic_test_file=/lib/libc.so ;; siemens) lt_cv_deplibs_check_method=pass_all ;; pc) lt_cv_deplibs_check_method=pass_all ;; esac ;;

tpf*) lt_cv_deplibs_check_method=pass_all ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method” >&5 $as_echo “$lt_cv_deplibs_check_method” >&6; }

file_magic_glob= want_nocaseglob=no if test “$build” = “$host”; then case $host_os in mingw | pw32) if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then want_nocaseglob=yes else file_magic_glob=echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g" fi ;; esac fi

file_magic_cmd=$lt_cv_file_magic_cmd deplibs_check_method=$lt_cv_deplibs_check_method test -z “$deplibs_check_method” && deplibs_check_method=unknown

if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}dlltool”, so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_DLLTOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$DLLTOOL”; then ac_cv_prog_DLLTOOL=“$DLLTOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_DLLTOOL=“${ac_tool_prefix}dlltool” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n “$DLLTOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $DLLTOOL” >&5 $as_echo “$DLLTOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_DLLTOOL”; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of “dlltool”, so it can be a program name with args. set dummy dlltool; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_DLLTOOL”; then ac_cv_prog_ac_ct_DLLTOOL=“$ac_ct_DLLTOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_DLLTOOL=“dlltool” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n “$ac_ct_DLLTOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL” >&5 $as_echo “$ac_ct_DLLTOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_DLLTOOL” = x; then DLLTOOL=“false” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL fi else DLLTOOL=“$ac_cv_prog_DLLTOOL” fi

test -z “$DLLTOOL” && DLLTOOL=dlltool

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries” >&5 $as_echo_n “checking how to associate runtime and link libraries… ” >&6; } if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_sharedlib_from_linklib_cmd=‘unknown’

case $host_os in cygwin | mingw | pw32 | cegcc) # two different shell functions defined in ltmain.sh # decide which to use based on capabilities of $DLLTOOL case $DLLTOOL --help 2>&1 in –identify-strict) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib ;; ) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback ;; esac ;; ) # fallback: assume linklib IS sharedlib lt_cv_sharedlib_from_linklib_cmd=“$ECHO” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd” >&5 $as_echo “$lt_cv_sharedlib_from_linklib_cmd” >&6; } sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z “$sharedlib_from_linklib_cmd” && sharedlib_from_linklib_cmd=$ECHO

if test -n “$ac_tool_prefix”; then for ac_prog in ar 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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_AR+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$AR”; then ac_cv_prog_AR=“$AR” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_AR=“$ac_tool_prefix$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi AR=$ac_cv_prog_AR if test -n “$AR”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $AR” >&5 $as_echo “$AR” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n "$AR" && break

done fi if test -z “$AR”; then ac_ct_AR=$AR for ac_prog in ar do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_AR+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_AR”; then ac_cv_prog_ac_ct_AR=“$ac_ct_AR” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_AR=“$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n “$ac_ct_AR”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR” >&5 $as_echo “$ac_ct_AR” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$ac_ct_AR” && break done

if test “x$ac_ct_AR” = x; then AR=“false” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR fi fi

: ${AR=ar} : ${AR_FLAGS=cru}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support” >&5 $as_echo_n “checking for archiver @FILE support… ” >&6; } if ${lt_cv_ar_at_file+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_ar_at_file=no cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : echo conftest.$ac_objext > conftest.lst lt_ar_try=‘$AR $AR_FLAGS libconftest.a @conftest.lst >&5’ { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$lt_ar_try\“”; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } if test “$ac_status” -eq 0; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$lt_ar_try\“”; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } if test “$ac_status” -ne 0; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a

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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file” >&5 $as_echo “$lt_cv_ar_at_file” >&6; }

if test “x$lt_cv_ar_at_file” = xno; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file fi

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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_STRIP+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_STRIP=“${ac_tool_prefix}strip” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $STRIP” >&5 $as_echo “$STRIP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_STRIP+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_STRIP=“strip” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP” >&5 $as_echo “$ac_ct_STRIP” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_STRIP” = x; then STRIP=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP=“$ac_cv_prog_STRIP” fi

test -z “$STRIP” && STRIP=:

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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_RANLIB+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_RANLIB=“${ac_tool_prefix}ranlib” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $RANLIB” >&5 $as_echo “$RANLIB” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : $as_echo_n “(cached) ” >&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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_RANLIB=“ranlib” $as_echo “$as_me:${as_lineno-$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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB” >&5 $as_echo “$ac_ct_RANLIB” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_RANLIB” = x; then RANLIB=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB fi else RANLIB=“$ac_cv_prog_RANLIB” fi

test -z “$RANLIB” && RANLIB=:

Determine commands to create old-style static archives.

old_archive_cmds=‘$AR $AR_FLAGS $oldlib$oldobjs’ old_postinstall_cmds=‘chmod 644 $oldlib’ old_postuninstall_cmds=

if test -n “$RANLIB”; then case $host_os in openbsd) old_postinstall_cmds=“$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib” ;; ) old_postinstall_cmds=“$old_postinstall_cmds~\$RANLIB \$tool_oldlib” ;; esac old_archive_cmds=“$old_archive_cmds~\$RANLIB \$tool_oldlib” fi

case $host_os in darwin) lock_old_archive_extraction=yes ;; ) lock_old_archive_extraction=no ;; esac

If no C compiler was specified, use CC.

LTCC=${LTCC-“$CC”}

If no C compiler flags were specified, use CFLAGS.

LTCFLAGS=${LTCFLAGS-“$CFLAGS”}

Allow CC to be a program name with arguments.

compiler=$CC

Check for command to grab the raw symbol name followed by C symbol from nm.

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object” >&5 $as_echo_n “checking command to parse $NM output from $compiler object… ” >&6; } if ${lt_cv_sys_global_symbol_pipe+:} false; then : $as_echo_n “(cached) ” >&6 else

These are sane defaults that work on at least a few old systems.

[They come from Ultrix. What could be older than Ultrix?!! ;)]

Character class describing NM global symbol codes.

symcode=‘[BCDEGRST]’

Regexp to match symbols that can be accessed directly from C.

sympat=‘([A-Za-z][A-Za-z0-9]*)’

Define system-specific variables.

case $host_os in aix) symcode=‘[BCDT]’ ;; cygwin | mingw | pw32 | cegcc) symcode=‘[ABCDGISTW]’ ;; hpux) if test “$host_cpu” = ia64; then symcode=‘[ABCDEGRST]’ fi ;; irix | nonstopux) symcode=‘[BCDEGRST]’ ;; osf) symcode=‘[BCDEGQRST]’ ;; solaris) symcode=‘[BDRT]’ ;; sco3.2v5) symcode=‘[DT]’ ;; sysv4.2uw2) symcode=‘[DT]’ ;; sysv5 | sco5v6 | unixware | OpenUNIX) symcode=‘[ABDT]’ ;; sysv4) symcode=‘[DFNSTU]’ ;; esac

If we’re using GNU nm, then use its standard symbol codes.

case $NM -V 2>&1 in GNU | ‘with BFD’) symcode=‘[ABCDGIRSTW]’ ;; esac

Transform an extracted symbol line into a proper C declaration.

Some systems (esp. on ia64) link data and code symbols differently,

so use this general approach.

lt_cv_sys_global_symbol_to_cdecl=“sed -n -e ’s/^T . (.)$/extern int \1();/p' -e ’s/^$symcode . (.*)$/extern char \1;/p'”

Transform an extracted symbol line into symbol name and symbol address

lt_cv_sys_global_symbol_to_c_name_address=“sed -n -e ’s/^: ([^ ])[ ]$/ {\\”\1\\“, (void ) 0},/p' -e ’s/^$symcode ([^ ]) ([^ ])$/ {\”\2\“, (void ) &\2},/p'” lt_cv_sys_global_symbol_to_c_name_address_lib_prefix=“sed -n -e ’s/^: ([^ ])[ ]$/ {\\”\1\\“, (void ) 0},/p' -e ’s/^$symcode ([^ ]) (lib[^ ])$/ {\”\2\“, (void ) &\2},/p' -e ’s/^$symcode ([^ ]) ([^ ])$/ {\"lib\2\”, (void ) &\2},/p'"

Handle CRLF in mingw tool chain

opt_cr= case $build_os in mingw*) opt_cr=$ECHO 'x\{0,1\}' | tr x '\015' # option cr in regexp ;; esac

Try without a prefix underscore, then with it.

for ac_symprfx in “” “_”; do

# Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. symxfrm=“\1 $ac_symprfx\2 \2”

# Write the raw and C identifiers. if test “$lt_cv_nm_interface” = “MS dumpbin”; then # Fake it for dumpbin and say T for any non-static function # and D for any global variable. # Also find C++ and fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe=“$AWK ‘”\ “ {last_section=section; section=\$ 3};”\ “ /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};”\ “ /Section length .#relocs.(pick any)/{hide[last_section]=1};”\ “ \$ 0!~/External |/{next};”\ “ / 0+ UNDEF /{next}; / UNDEF ([^|])()/{next};”\ “ {if(hide[section]) next};”\ “ {f=0}; \$ 0~/().|/{f=1}; {printf f ? \"T \” : \“D \”};“\ ” {split(\$ 0, a, /||\r/); split(a[2], s)};“\ ” s[1]~/^[@?]/{print s[1], s[1]; next};“\ ” s[1]~prfx {split(s[1],t,\“@\”); print t[1], substr(t[1],length(prfx))}“\ ” ’ prfx=^$ac_symprfx" else lt_cv_sys_global_symbol_pipe=“sed -n -e ’s/^.[ ]($symcode$symcode)[ ][ ]$ac_symprfx$sympat$opt_cr$/$symxfrm/p'” fi lt_cv_sys_global_symbol_pipe=“$lt_cv_sys_global_symbol_pipe | sed ‘/ gnu_lto/d’”

# Check to see that the pipe works correctly. pipe_works=no

rm -rf conftest* cat > conftest.$ac_ext <<_LT_EOF

ifdef __cplusplus

extern “C” {

endif

char nm_test_var; void nm_test_func(void); void nm_test_func(void){}

ifdef __cplusplus

}

endif

int main(){nm_test_var=‘a’;nm_test_func();return(0);} _LT_EOF

if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_compile\“”; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then # Now try to grab the symbols. nlist=conftest.nm if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$NM conftest.$ac_objext | “$lt_cv_sys_global_symbol_pipe” > $nlist\“”; } >&5 (eval $NM conftest.$ac_objext | “$lt_cv_sys_global_symbol_pipe” > $nlist) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -s “$nlist”; then # Try sorting and uniquifying the output. if sort “$nlist” | uniq > “$nlist"T; then mv -f ”$nlist"T “$nlist” else rm -f “$nlist"T fi

  # Make sure that we snagged all the symbols we need.
  if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
  cat <<_LT_EOF > conftest.$ac_ext

/ Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. /

if defined(WIN32) || defined(CYGWIN) || defined(WIN32_WCE)

/ DATA imports from DLLs on WIN32 con’t be const, because runtime relocations are performed – see ld’s documentation on pseudo-relocs. /

define LT_DLSYM_CONST

elif defined(osf)

/ This system does not cope well with relocations in const data. /

define LT_DLSYM_CONST

else

define LT_DLSYM_CONST const

endif

ifdef __cplusplus

extern “C” {

endif

_LT_EOF # Now generate the symbol file. eval “$lt_cv_sys_global_symbol_to_cdecl”‘ < “$nlist” | $GREP -v main >> conftest.$ac_ext’

  cat <<_LT_EOF >> conftest.$ac_ext

/ The mapping between symbol names and symbols. / LT_DLSYM_CONST struct { const char name; void address; } ltPROGRAMLTX_preloaded_symbols[] = { { “@PROGRAM@”, (void ) 0 }, _LT_EOF $SED “s/^$symcode$symcode (.) (.)$/ {\”\2\“, (void ) &\2},/” < “$nlist” | $GREP -v main >> conftest.$ac_ext cat <<_LT_EOF >> conftest.$ac_ext {0, (void ) 0} };

/ This works around a problem in FreeBSD linker /

ifdef FREEBSD_WORKAROUND

static const void *lt_preloaded_setup() { return ltPROGRAMLTX_preloaded_symbols; }

endif

ifdef __cplusplus

}

endif

_LT_EOF # Now try linking the two files. mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS LIBS=“conftstm.$ac_objext” CFLAGS=“$CFLAGS$lt_prog_compiler_no_builtin_flag” if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_link\“”; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -s conftest${ac_exeext}; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS CFLAGS=$lt_globsym_save_CFLAGS else echo “cannot find nm_test_func in $nlist” >&5 fi else echo “cannot find nm_test_var in $nlist” >&5 fi else echo “cannot run $lt_cv_sys_global_symbol_pipe” >&5 fi else echo “$progname: failed program was:” >&5 cat conftest.$ac_ext >&5 fi rm -rf conftest conftst

# Do not use the global_symbol_pipe unless it works. if test “$pipe_works” = yes; then break else lt_cv_sys_global_symbol_pipe= fi done

fi

if test -z “$lt_cv_sys_global_symbol_pipe”; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z “$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: failed” >&5 $as_echo “failed” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: ok” >&5 $as_echo “ok” >&6; } fi

Response file support.

if test “$lt_cv_nm_interface” = “MS dumpbin”; then nm_file_list_spec=‘@’ elif $NM –help 2>/dev/null | grep ‘[@]FILE’ >/dev/null; then nm_file_list_spec=‘@’ fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for sysroot” >&5 $as_echo_n “checking for sysroot… ” >&6; }

Check whether –with-sysroot was given.

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

lt_sysroot= case ${with_sysroot} in #( yes) if test “$GCC” = yes; then lt_sysroot=$CC --print-sysroot 2>/dev/null fi ;; #( /) lt_sysroot=echo "$with_sysroot" | sed -e "$sed_quote_subst" ;; #( no|‘’) ;; #( ) { $as_echo “$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}” >&5 $as_echo “${with_sysroot}” >&6; } as_fn_error $? “The sysroot must be an absolute path.” “$LINENO” 5 ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}” >&5 $as_echo “${lt_sysroot:-no}” >&6; }

Check whether –enable-libtool-lock was given.

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

test “x$enable_libtool_lock” != xno && enable_libtool_lock=yes

Some flags need to be propagated to the compiler or linker for good

libtool support.

case $host in ia64--hpux) # Find out which ABI we are using. echo ‘int i;’ > conftest.$ac_ext if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_compile\“”; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then case /usr/bin/file conftest.$ac_objext in ELF-32) HPUX_IA64_MODE=“32” ;; ELF-64) HPUX_IA64_MODE=“64” ;; esac fi rm -rf conftest ;; --irix6) # Find out which ABI we are using. echo ‘#line ’$LINENO' “configure”‘ > conftest.$ac_ext if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_compile\“”; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then if test “$lt_cv_prog_gnu_ld” = yes; then case /usr/bin/file conftest.$ac_objext in 32-bit) LD=“${LD-ld} -melf32bsmip” ;; N32) LD=“${LD-ld} -melf32bmipn32” ;; 64-bit) LD=“${LD-ld} -melf64bmip” ;; esac else case /usr/bin/file conftest.$ac_objext in 32-bit) LD=“${LD-ld} -32” ;; N32) LD=“${LD-ld} -n32” ;; 64-bit) LD=“${LD-ld} -64” ;; esac fi fi rm -rf conftest* ;;

x86_64-kfreebsd-gnu|x86_64-linux|ppc-linux|powerpc-linux| \ s390-linux|s390-tpf|sparc-linux) # Find out which ABI we are using. echo ‘int i;’ > conftest.$ac_ext if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_compile\“”; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then case /usr/bin/file conftest.o in 32-bit) case $host in x86_64-kfreebsd-gnu) LD=“${LD-ld} -m elf_i386_fbsd” ;; x86_64-linux) LD=“${LD-ld} -m elf_i386” ;; ppc64-linux|powerpc64-linux) LD=“${LD-ld} -m elf32ppclinux” ;; s390x-linux) LD=“${LD-ld} -m elf_s390” ;; sparc64-linux) LD=“${LD-ld} -m elf32_sparc” ;; esac ;; 64-bit) case $host in x86_64-kfreebsd-gnu) LD=“${LD-ld} -m elf_x86_64_fbsd” ;; x86_64-linux) LD=“${LD-ld} -m elf_x86_64” ;; ppc-linux|powerpc-linux) LD=“${LD-ld} -m elf64ppc” ;; s390-linux|s390-tpf) LD=“${LD-ld} -m elf64_s390” ;; sparc-linux) LD=“${LD-ld} -m elf64_sparc” ;; esac ;; esac fi rm -rf conftest* ;;

--sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS=“$CFLAGS” CFLAGS=“$CFLAGS -belf” { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf” >&5 $as_echo_n “checking whether the C compiler needs -belf… ” >&6; } if ${lt_cv_cc_needs_belf+:} false; then : $as_echo_n “(cached) ” >&6 else 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

 cat confdefs.h - <<_ACEOF >conftest.$ac_ext

/ end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : lt_cv_cc_needs_belf=yes else lt_cv_cc_needs_belf=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext 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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf” >&5 $as_echo “$lt_cv_cc_needs_belf” >&6; } if test x"$lt_cv_cc_needs_belf" != x"yes"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=“$SAVE_CFLAGS” fi ;; -solaris) # Find out which ABI we are using. echo ‘int i;’ > conftest.$ac_ext if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_compile\“”; } >&5 (eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; }; then case /usr/bin/file conftest.o in 64-bit) case $lt_cv_prog_gnu_ld in yes) case $host in i?86--solaris) LD=“${LD-ld} -m elf_x86_64” ;; sparc--solaris) LD=“${LD-ld} -m elf64_sparc” ;; esac # GNU ld 2.21 introduced sol2 emulations. Use them if available. if ${LD-ld} -V | grep sol2 >/dev/null 2>&1; then LD=“${LD-ld}_sol2” fi ;; ) if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then LD=“${LD-ld} -64” fi ;; esac ;; esac fi rm -rf conftest* ;; esac

need_locks=“$enable_libtool_lock”

if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}mt”, so it can be a program name with args. set dummy ${ac_tool_prefix}mt; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_MANIFEST_TOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$MANIFEST_TOOL”; then ac_cv_prog_MANIFEST_TOOL=“$MANIFEST_TOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_MANIFEST_TOOL=“${ac_tool_prefix}mt” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL if test -n “$MANIFEST_TOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL” >&5 $as_echo “$MANIFEST_TOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_MANIFEST_TOOL”; then ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL # Extract the first word of “mt”, so it can be a program name with args. set dummy mt; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_MANIFEST_TOOL”; then ac_cv_prog_ac_ct_MANIFEST_TOOL=“$ac_ct_MANIFEST_TOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_MANIFEST_TOOL=“mt” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL if test -n “$ac_ct_MANIFEST_TOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL” >&5 $as_echo “$ac_ct_MANIFEST_TOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_MANIFEST_TOOL” = x; then MANIFEST_TOOL=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL fi else MANIFEST_TOOL=“$ac_cv_prog_MANIFEST_TOOL” fi

test -z “$MANIFEST_TOOL” && MANIFEST_TOOL=mt { $as_echo “$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool” >&5 $as_echo_n “checking if $MANIFEST_TOOL is a manifest tool… ” >&6; } if ${lt_cv_path_mainfest_tool+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_path_mainfest_tool=no echo “$as_me:$LINENO: $MANIFEST_TOOL ‘-?’” >&5 $MANIFEST_TOOL ‘-?’ 2>conftest.err > conftest.out cat conftest.err >&5 if $GREP ‘Manifest Tool’ conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi rm -rf conftest* fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool” >&5 $as_echo “$lt_cv_path_mainfest_tool” >&6; } if test “x$lt_cv_path_mainfest_tool” != xyes; then MANIFEST_TOOL=: fi

case $host_os in rhapsody | darwin) if test -n “$ac_tool_prefix”; then # Extract the first word of “${ac_tool_prefix}dsymutil”, so it can be a program name with args. set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_DSYMUTIL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$DSYMUTIL”; then ac_cv_prog_DSYMUTIL=“$DSYMUTIL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_DSYMUTIL=“${ac_tool_prefix}dsymutil” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi DSYMUTIL=$ac_cv_prog_DSYMUTIL if test -n “$DSYMUTIL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL” >&5 $as_echo “$DSYMUTIL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_DSYMUTIL”; then ac_ct_DSYMUTIL=$DSYMUTIL # Extract the first word of “dsymutil”, so it can be a program name with args. set dummy dsymutil; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_DSYMUTIL”; then ac_cv_prog_ac_ct_DSYMUTIL=“$ac_ct_DSYMUTIL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_DSYMUTIL=“dsymutil” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL if test -n “$ac_ct_DSYMUTIL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL” >&5 $as_echo “$ac_ct_DSYMUTIL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_DSYMUTIL” = x; then DSYMUTIL=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac DSYMUTIL=$ac_ct_DSYMUTIL fi else DSYMUTIL=“$ac_cv_prog_DSYMUTIL” fi

if test -n "$ac_tool_prefix"; then

# Extract the first word of “${ac_tool_prefix}nmedit”, so it can be a program name with args. set dummy ${ac_tool_prefix}nmedit; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_NMEDIT+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$NMEDIT”; then ac_cv_prog_NMEDIT=“$NMEDIT” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_NMEDIT=“${ac_tool_prefix}nmedit” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi NMEDIT=$ac_cv_prog_NMEDIT if test -n “$NMEDIT”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $NMEDIT” >&5 $as_echo “$NMEDIT” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_NMEDIT”; then ac_ct_NMEDIT=$NMEDIT # Extract the first word of “nmedit”, so it can be a program name with args. set dummy nmedit; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_NMEDIT”; then ac_cv_prog_ac_ct_NMEDIT=“$ac_ct_NMEDIT” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_NMEDIT=“nmedit” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT if test -n “$ac_ct_NMEDIT”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT” >&5 $as_echo “$ac_ct_NMEDIT” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_NMEDIT” = x; then NMEDIT=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac NMEDIT=$ac_ct_NMEDIT fi else NMEDIT=“$ac_cv_prog_NMEDIT” fi

if test -n "$ac_tool_prefix"; then

# Extract the first word of “${ac_tool_prefix}lipo”, so it can be a program name with args. set dummy ${ac_tool_prefix}lipo; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_LIPO+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$LIPO”; then ac_cv_prog_LIPO=“$LIPO” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_LIPO=“${ac_tool_prefix}lipo” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi LIPO=$ac_cv_prog_LIPO if test -n “$LIPO”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $LIPO” >&5 $as_echo “$LIPO” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_LIPO”; then ac_ct_LIPO=$LIPO # Extract the first word of “lipo”, so it can be a program name with args. set dummy lipo; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_LIPO+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_LIPO”; then ac_cv_prog_ac_ct_LIPO=“$ac_ct_LIPO” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_LIPO=“lipo” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO if test -n “$ac_ct_LIPO”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO” >&5 $as_echo “$ac_ct_LIPO” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_LIPO” = x; then LIPO=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac LIPO=$ac_ct_LIPO fi else LIPO=“$ac_cv_prog_LIPO” fi

if test -n "$ac_tool_prefix"; then

# Extract the first word of “${ac_tool_prefix}otool”, so it can be a program name with args. set dummy ${ac_tool_prefix}otool; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_OTOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$OTOOL”; then ac_cv_prog_OTOOL=“$OTOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_OTOOL=“${ac_tool_prefix}otool” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi OTOOL=$ac_cv_prog_OTOOL if test -n “$OTOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $OTOOL” >&5 $as_echo “$OTOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_OTOOL”; then ac_ct_OTOOL=$OTOOL # Extract the first word of “otool”, so it can be a program name with args. set dummy otool; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_OTOOL+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_OTOOL”; then ac_cv_prog_ac_ct_OTOOL=“$ac_ct_OTOOL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_OTOOL=“otool” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL if test -n “$ac_ct_OTOOL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL” >&5 $as_echo “$ac_ct_OTOOL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_OTOOL” = x; then OTOOL=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac OTOOL=$ac_ct_OTOOL fi else OTOOL=“$ac_cv_prog_OTOOL” fi

if test -n "$ac_tool_prefix"; then

# Extract the first word of “${ac_tool_prefix}otool64”, so it can be a program name with args. set dummy ${ac_tool_prefix}otool64; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_OTOOL64+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$OTOOL64”; then ac_cv_prog_OTOOL64=“$OTOOL64” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_OTOOL64=“${ac_tool_prefix}otool64” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi OTOOL64=$ac_cv_prog_OTOOL64 if test -n “$OTOOL64”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $OTOOL64” >&5 $as_echo “$OTOOL64” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test -z “$ac_cv_prog_OTOOL64”; then ac_ct_OTOOL64=$OTOOL64 # Extract the first word of “otool64”, so it can be a program name with args. set dummy otool64; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$ac_ct_OTOOL64”; then ac_cv_prog_ac_ct_OTOOL64=“$ac_ct_OTOOL64” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_ac_ct_OTOOL64=“otool64” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 if test -n “$ac_ct_OTOOL64”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64” >&5 $as_echo “$ac_ct_OTOOL64” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test “x$ac_ct_OTOOL64” = x; then OTOOL64=“:” else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet” >&5 $as_echo “$as_me: WARNING: using cross tools not prefixed with host triplet” >&2;} ac_tool_warned=yes ;; esac OTOOL64=$ac_ct_OTOOL64 fi else OTOOL64=“$ac_cv_prog_OTOOL64” fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5

$as_echo_n “checking for -single_module linker flag… ” >&6; } if ${lt_cv_apple_cc_single_mod+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_apple_cc_single_mod=no if test -z “${LT_MULTI_MODULE}”; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the # link flags. rm -rf libconftest.dylib echo “int foo(void){return 1;}” > conftest.c echo “$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c” >&5 $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err lt_result=$? # If there is a non-empty error log, and “single_module” # appears in it, assume the flag caused a linker warning if test -s conftest.err && $GREP single_module conftest.err; then cat conftest.err >&5 # Otherwise, if the output was created with a 0 exit code from # the compiler, it worked. elif test -f libconftest.dylib && test $lt_result -eq 0; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&5 fi rm -rf libconftest.dylib rm -f conftest.* fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod” >&5 $as_echo “$lt_cv_apple_cc_single_mod” >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5

$as_echo_n “checking for -exported_symbols_list linker flag… ” >&6; } if ${lt_cv_ld_exported_symbols_list+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo “main” > conftest.sym LDFLAGS=“$LDFLAGS -Wl,-exported_symbols_list,conftest.sym” cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : lt_cv_ld_exported_symbols_list=yes else lt_cv_ld_exported_symbols_list=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=“$save_LDFLAGS”

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list” >&5 $as_echo “$lt_cv_ld_exported_symbols_list” >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5

$as_echo_n “checking for -force_load linker flag… ” >&6; } if ${lt_cv_ld_force_load+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_ld_force_load=no cat > conftest.c << LT_EOF int forced_loaded() { return 2;} LT_EOF echo “$LTCC $LTCFLAGS -c -o conftest.o conftest.c” >&5 $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5 echo “$AR cru libconftest.a conftest.o” >&5 $AR cru libconftest.a conftest.o 2>&5 echo “$RANLIB libconftest.a” >&5 $RANLIB libconftest.a 2>&5 cat > conftest.c << LT_EOF int main() { return 0;} LT_EOF echo “$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a” >&5 $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err lt_result=$? if test -s conftest.err && $GREP force_load conftest.err; then cat conftest.err >&5 elif test -f conftest && test $lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then lt_cv_ld_force_load=yes else cat conftest.err >&5 fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load” >&5 $as_echo “$lt_cv_ld_force_load” >&6; } case $host_os in rhapsody | darwin1.[012]) _lt_dar_allow_undefined=‘${wl}-undefined ${wl}suppress’ ;; darwin1.) lt_dar_allow_undefined=‘${wl}-flat_namespace ${wl}-undefined ${wl}suppress’ ;; darwin) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don’t you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,86-darwin8|10.0,-darwin[91]) lt_dar_allow_undefined=‘${wl}-undefined ${wl}dynamic_lookup’ ;; 10.[012]) _lt_dar_allow_undefined=‘${wl}-flat_namespace ${wl}-undefined ${wl}suppress’ ;; 10.) lt_dar_allow_undefined=‘${wl}-undefined ${wl}dynamic_lookup’ ;; esac ;; esac if test “$lt_cv_apple_cc_single_mod” = “yes”; then lt_dar_single_mod=‘$single_module’ fi if test “$lt_cv_ld_exported_symbols_list” = “yes”; then lt_dar_export_syms=‘ ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym’ else lt_dar_export_syms=‘~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}’ fi if test “$DSYMUTIL” != “:” && test “$lt_cv_ld_force_load” = “no”; then lt_dsymutil=‘~$DSYMUTIL $lib || :’ else lt_dsymutil= fi ;; esac

for ac_header in dlfcn.h do : ac_fn_c_check_header_compile “$LINENO” “dlfcn.h” “ac_cv_header_dlfcn_h” “$ac_includes_default ” if test “x$ac_cv_header_dlfcn_h” = xyes; then : cat >>confdefs.h <<_ACEOF

define HAVE_DLFCN_H 1

_ACEOF

fi

done

Set options

    enable_dlopen=no

enable_win32_dll=no

# Check whether –enable-static was given. if test “${enable_static+set}” = set; then : enableval=$enable_static; p=${PACKAGE-default} case $enableval in yes) enable_static=yes ;; no) enable_static=no ;; *) enable_static=no # Look at the argument we got. We use all the common list separators. lt_save_ifs=“$IFS”; IFS=“${IFS}$PATH_SEPARATOR,” for pkg in $enableval; do IFS=“$lt_save_ifs” if test “X$pkg” = “X$p”; then enable_static=yes fi done IFS=“$lt_save_ifs” ;; esac else enable_static=yes fi

Check whether –with-pic was given.

if test “${with_pic+set}” = set; then : withval=$with_pic; lt_p=${PACKAGE-default} case $withval in yes|no) pic_mode=$withval ;; *) pic_mode=default # Look at the argument we got. We use all the common list separators. lt_save_ifs=“$IFS”; IFS=“${IFS}$PATH_SEPARATOR,” for lt_pkg in $withval; do IFS=“$lt_save_ifs” if test “X$lt_pkg” = “X$lt_p”; then pic_mode=yes fi done IFS=“$lt_save_ifs” ;; esac else pic_mode=default fi

test -z “$pic_mode” && pic_mode=default

# Check whether –enable-fast-install was given. if test “${enable_fast_install+set}” = set; then : enableval=$enable_fast_install; p=${PACKAGE-default} case $enableval in yes) enable_fast_install=yes ;; no) enable_fast_install=no ;; *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. lt_save_ifs=“$IFS”; IFS=“${IFS}$PATH_SEPARATOR,” for pkg in $enableval; do IFS=“$lt_save_ifs” if test “X$pkg” = “X$p”; then enable_fast_install=yes fi done IFS=“$lt_save_ifs” ;; esac else enable_fast_install=yes fi

This can be used to rebuild libtool when needed

LIBTOOL_DEPS=“$ltmain”

Always use our own libtool.

LIBTOOL=‘$(SHELL) $(top_builddir)/libtool’

test -z “$LN_S” && LN_S=“ln -s”

if test -n “${ZSH_VERSION+set}” ; then setopt NO_GLOB_SUBST fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for objdir” >&5 $as_echo_n “checking for objdir… ” >&6; } if ${lt_cv_objdir+:} false; then : $as_echo_n “(cached) ” >&6 else rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then lt_cv_objdir=.libs else # MS-DOS does not allow filenames that begin with a dot. lt_cv_objdir=_libs fi rmdir .libs 2>/dev/null fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir” >&5 $as_echo “$lt_cv_objdir” >&6; } objdir=$lt_cv_objdir

cat >>confdefs.h <<_ACEOF

define LT_OBJDIR “$lt_cv_objdir/”

_ACEOF

case $host_os in aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test “X${COLLECT_NAMES+set}” != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi ;; esac

Global variables:

ofile=libtool can_build_shared=yes

All known linkers require a `.a' archive for static linking (except MSVC,

which needs ‘.lib’).

libext=a

with_gnu_ld=“$lt_cv_prog_gnu_ld”

old_CC=“$CC” old_CFLAGS=“$CFLAGS”

Set sane defaults for various variables

test -z “$CC” && CC=cc test -z “$LTCC” && LTCC=$CC test -z “$LTCFLAGS” && LTCFLAGS=$CFLAGS test -z “$LD” && LD=ld test -z “$ac_objext” && ac_objext=o

for cc_temp in $compiler"“; do case $cc_temp in compile | [\/]compile | ccache | [\/]ccache ) ;; distcc | [\/]distcc | purify | [\/]purify ) ;; -) ;; ) break;; esac done cc_basename=$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"

Only perform the check for file, if the check method requires it

test -z “$MAGIC_CMD” && MAGIC_CMD=file case $deplibs_check_method in file_magic) if test “$file_magic_cmd” = ‘$MAGIC_CMD’; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file” >&5 $as_echo_n “checking for ${ac_tool_prefix}file… ” >&6; } if ${lt_cv_path_MAGIC_CMD+:} false; then : $as_echo_n “(cached) ” >&6 else case $MAGIC_CMD in [\/] | ?:[\/]) lt_cv_path_MAGIC_CMD=“$MAGIC_CMD” # Let the user override the test with a path. ;; ) lt_save_MAGIC_CMD=“$MAGIC_CMD” lt_save_ifs=“$IFS”; IFS=$PATH_SEPARATOR ac_dummy=“/usr/bin$PATH_SEPARATOR$PATH” for ac_dir in $ac_dummy; do IFS=“$lt_save_ifs” test -z “$ac_dir” && ac_dir=. if test -f $ac_dir/${ac_tool_prefix}file; then lt_cv_path_MAGIC_CMD=“$ac_dir/${ac_tool_prefix}file” if test -n “$file_magic_test_file”; then case $deplibs_check_method in “file_magic ”*) file_magic_regex=expr "$deplibs_check_method" : "file_magic \(.*\)" MAGIC_CMD=“$lt_cv_path_MAGIC_CMD” if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP “$file_magic_regex” > /dev/null; then : else cat <<_LT_EOF 1>&2

Warning: the command libtool uses to detect shared libraries, $file_magic_cmd, produces output that libtool cannot recognize. The result is that libtool may fail to recognize shared libraries as such. This will affect the creation of libtool libraries that depend on shared libraries, but programs linked with such libtool libraries will work regardless of this problem. Nevertheless, you may want to report the problem to your system manager and/or to bug-libtool@gnu.org

_LT_EOF fi ;; esac fi break fi done IFS=“$lt_save_ifs” MAGIC_CMD=“$lt_save_MAGIC_CMD” ;; esac fi

MAGIC_CMD=“$lt_cv_path_MAGIC_CMD” if test -n “$MAGIC_CMD”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD” >&5 $as_echo “$MAGIC_CMD” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

if test -z “$lt_cv_path_MAGIC_CMD”; then if test -n “$ac_tool_prefix”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for file” >&5 $as_echo_n “checking for file… ” >&6; } if ${lt_cv_path_MAGIC_CMD+:} false; then : $as_echo_n “(cached) ” >&6 else case $MAGIC_CMD in [\/] | ?:[\/]) lt_cv_path_MAGIC_CMD=“$MAGIC_CMD” # Let the user override the test with a path. ;; ) lt_save_MAGIC_CMD=“$MAGIC_CMD” lt_save_ifs=“$IFS”; IFS=$PATH_SEPARATOR ac_dummy=“/usr/bin$PATH_SEPARATOR$PATH” for ac_dir in $ac_dummy; do IFS=“$lt_save_ifs” test -z “$ac_dir” && ac_dir=. if test -f $ac_dir/file; then lt_cv_path_MAGIC_CMD=“$ac_dir/file” if test -n “$file_magic_test_file”; then case $deplibs_check_method in “file_magic ”) file_magic_regex=expr "$deplibs_check_method" : "file_magic \(.*\)" MAGIC_CMD=“$lt_cv_path_MAGIC_CMD” if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP “$file_magic_regex” > /dev/null; then : else cat <<_LT_EOF 1>&2

Warning: the command libtool uses to detect shared libraries, $file_magic_cmd, produces output that libtool cannot recognize. The result is that libtool may fail to recognize shared libraries as such. This will affect the creation of libtool libraries that depend on shared libraries, but programs linked with such libtool libraries will work regardless of this problem. Nevertheless, you may want to report the problem to your system manager and/or to bug-libtool@gnu.org

_LT_EOF fi ;; esac fi break fi done IFS=“$lt_save_ifs” MAGIC_CMD=“$lt_save_MAGIC_CMD” ;; esac fi

MAGIC_CMD=“$lt_cv_path_MAGIC_CMD” if test -n “$MAGIC_CMD”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD” >&5 $as_echo “$MAGIC_CMD” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

else MAGIC_CMD=: fi fi

fi ;; esac

Use C for the default configuration in the libtool script

lt_save_CC=“$CC” 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

Source file extension for C test sources.

ac_ext=c

Object file extension for compiled C test sources.

objext=o objext=$objext

Code to be used in simple compile tests

lt_simple_compile_test_code=“int some_variable = 0;”

Code to be used in simple link tests

lt_simple_link_test_code=‘int main(){return(0);}’

If no C compiler was specified, use CC.

LTCC=${LTCC-“$CC”}

If no C compiler flags were specified, use CFLAGS.

LTCFLAGS=${LTCFLAGS-“$CFLAGS”}

Allow CC to be a program name with arguments.

compiler=$CC

Save the default compiler, since it gets overwritten when the other

tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.

compiler_DEFAULT=$CC

save warnings/boilerplate of simple test code

ac_outfile=conftest.$ac_objext echo “$lt_simple_compile_test_code” >conftest.$ac_ext eval “$ac_compile” 2>&1 >/dev/null | $SED ‘/^$/d; /^ +/d’ >conftest.err _lt_compiler_boilerplate=cat conftest.err $RM -r conftest

ac_outfile=conftest.$ac_objext echo “$lt_simple_link_test_code” >conftest.$ac_ext eval “$ac_link” 2>&1 >/dev/null | $SED ‘/^$/d; /^ +/d’ >conftest.err _lt_linker_boilerplate=cat conftest.err $RM -r conftest

CAVEAT EMPTOR:

There is no encapsulation within the following macros, do not change

the running order or otherwise move them around unless you know exactly

what you are doing…

if test -n “$compiler”; then

lt_prog_compiler_no_builtin_flag=

if test “$GCC” = yes; then case $cc_basename in nvcc) lt_prog_compiler_no_builtin_flag=‘ -Xcompiler -fno-builtin’ ;; ) lt_prog_compiler_no_builtin_flag=‘ -fno-builtin’ ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions” >&5 $as_echo_n “checking if $compiler supports -fno-rtti -fno-exceptions… ” >&6; } if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_rtti_exceptions=no ac_outfile=conftest.$ac_objext echo “$lt_simple_compile_test_code” > conftest.$ac_ext lt_compiler_flag=“-fno-rtti -fno-exceptions” # Insert the option either (1) after the last FLAGS variable, or # (2) before a word containing “conftest.”, or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:' (eval echo “\”\$as_me:$LINENO: $lt_compile\“” >&5) (eval “$lt_compile” 2>conftest.err) ac_status=$? cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 if (exit $ac_status) && test -s “$ac_outfile”; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO “$_lt_compiler_boilerplate” | $SED ‘/^$/d’ >conftest.exp $SED ‘/^$/d; /^ +/d’ conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_rtti_exceptions=yes fi fi $RM -r conftest*

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions” >&5 $as_echo “$lt_cv_prog_compiler_rtti_exceptions” >&6; }

if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then lt_prog_compiler_no_builtin_flag=“$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions” else : fi

fi

lt_prog_compiler_wl= lt_prog_compiler_pic= lt_prog_compiler_static=

if test “$GCC” = yes; then lt_prog_compiler_wl=‘-Wl,’ lt_prog_compiler_static=‘-static’

case $host_os in
  aix*)
  # All AIX code is PIC.
  if test "$host_cpu" = ia64; then
# AIX 5 now supports IA64 processor
lt_prog_compiler_static='-Bstatic'
  fi
  ;;

amigaos*)
  case $host_cpu in
  powerpc)
        # see comment about AmigaOS4 .so support
        lt_prog_compiler_pic='-fPIC'
    ;;
  m68k)
        # FIXME: we need at least 68020 code to build shared libraries, but
        # adding the `-m68020' flag to GCC prevents building anything better,
        # like `-m68040'.
        lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
    ;;
  esac
  ;;

beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
  # PIC is the default for these OSes.
  ;;

mingw* | cygwin* | pw32* | os2* | cegcc*)
  # This hack is so that the source file can tell whether it is being
  # built for inclusion in a dll (and should export symbols for example).
  # Although the cygwin gcc ignores -fPIC, still need this for old-style
  # (--disable-auto-import) libraries
  lt_prog_compiler_pic='-DDLL_EXPORT'
  ;;

darwin* | rhapsody*)
  # PIC is the default on this platform
  # Common symbols not allowed in MH_DYLIB files
  lt_prog_compiler_pic='-fno-common'
  ;;

haiku*)
  # PIC is the default for Haiku.
  # The "-static" flag exists, but is broken.
  lt_prog_compiler_static=
  ;;

hpux*)
  # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
  # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
  # sets the default TLS model and affects inlining.
  case $host_cpu in
  hppa*64*)
# +Z the default
;;
  *)
lt_prog_compiler_pic='-fPIC'
;;
  esac
  ;;

interix[3-9]*)
  # Interix 3.x gcc -fpic/-fPIC options generate broken code.
  # Instead, we relocate shared libraries at runtime.
  ;;

msdosdjgpp*)
  # Just because we use GCC doesn't mean we suddenly get shared libraries
  # on systems that don't support them.
  lt_prog_compiler_can_build_shared=no
  enable_shared=no
  ;;

*nto* | *qnx*)
  # QNX uses GNU C++, but need to define -shared option too, otherwise
  # it will coredump.
  lt_prog_compiler_pic='-fPIC -shared'
  ;;

sysv4*MP*)
  if test -d /usr/nec; then
lt_prog_compiler_pic=-Kconform_pic
  fi
  ;;

*)
  lt_prog_compiler_pic='-fPIC'
  ;;
esac

case $cc_basename in
nvcc*) # Cuda Compiler Driver 2.2
  lt_prog_compiler_wl='-Xlinker '
  if test -n "$lt_prog_compiler_pic"; then
    lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
  fi
  ;;
esac

else # PORTME Check for flag to pass linker flags through the system compiler. case $host_os in aix*) lt_prog_compiler_wl=‘-Wl,’ if test “$host_cpu” = ia64; then # AIX 5 now supports IA64 processor lt_prog_compiler_static=‘-Bstatic’ else lt_prog_compiler_static=‘-bnso -bI:/lib/syscalls.exp’ fi ;;

mingw* | cygwin* | pw32* | os2* | cegcc*)
  # This hack is so that the source file can tell whether it is being
  # built for inclusion in a dll (and should export symbols for example).
  lt_prog_compiler_pic='-DDLL_EXPORT'
  ;;

hpux9* | hpux10* | hpux11*)
  lt_prog_compiler_wl='-Wl,'
  # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
  # not for PA HP-UX.
  case $host_cpu in
  hppa*64*|ia64*)
# +Z the default
;;
  *)
lt_prog_compiler_pic='+Z'
;;
  esac
  # Is there a better lt_prog_compiler_static that works with the bundled CC?
  lt_prog_compiler_static='${wl}-a ${wl}archive'
  ;;

irix5* | irix6* | nonstopux*)
  lt_prog_compiler_wl='-Wl,'
  # PIC (with -KPIC) is the default.
  lt_prog_compiler_static='-non_shared'
  ;;

linux* | k*bsd*-gnu | kopensolaris*-gnu)
  case $cc_basename in
  # old Intel for x86_64 which still supported -KPIC.
  ecc*)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-KPIC'
lt_prog_compiler_static='-static'
    ;;
  # icc used to be incompatible with GCC.
  # ICC 10 doesn't accept -KPIC any more.
  icc* | ifort*)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fPIC'
lt_prog_compiler_static='-static'
    ;;
  # Lahey Fortran 8.1.
  lf95*)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='--shared'
lt_prog_compiler_static='--static'
;;
  nagfor*)
# NAG Fortran compiler
lt_prog_compiler_wl='-Wl,-Wl,,'
lt_prog_compiler_pic='-PIC'
lt_prog_compiler_static='-Bstatic'
;;
  pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
    # Portland Group compilers (*not* the Pentium gcc compiler,
# which looks to be a dead project)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fpic'
lt_prog_compiler_static='-Bstatic'
    ;;
  ccc*)
    lt_prog_compiler_wl='-Wl,'
    # All Alpha code is PIC.
    lt_prog_compiler_static='-non_shared'
    ;;
  xl* | bgxl* | bgf* | mpixl*)
# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-qpic'
lt_prog_compiler_static='-qstaticlink'
;;
  *)
case `$CC -V 2>&1 | sed 5q` in
*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
  # Sun Fortran 8.3 passes all unrecognized flags to the linker
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  lt_prog_compiler_wl=''
  ;;
*Sun\ F* | *Sun*Fortran*)
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  lt_prog_compiler_wl='-Qoption ld '
  ;;
*Sun\ C*)
  # Sun C 5.9
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  lt_prog_compiler_wl='-Wl,'
  ;;
    *Intel*\ [CF]*Compiler*)
  lt_prog_compiler_wl='-Wl,'
  lt_prog_compiler_pic='-fPIC'
  lt_prog_compiler_static='-static'
  ;;
*Portland\ Group*)
  lt_prog_compiler_wl='-Wl,'
  lt_prog_compiler_pic='-fpic'
  lt_prog_compiler_static='-Bstatic'
  ;;
esac
;;
  esac
  ;;

newsos6)
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  ;;

*nto* | *qnx*)
  # QNX uses GNU C++, but need to define -shared option too, otherwise
  # it will coredump.
  lt_prog_compiler_pic='-fPIC -shared'
  ;;

osf3* | osf4* | osf5*)
  lt_prog_compiler_wl='-Wl,'
  # All OSF/1 code is PIC.
  lt_prog_compiler_static='-non_shared'
  ;;

rdos*)
  lt_prog_compiler_static='-non_shared'
  ;;

solaris*)
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  case $cc_basename in
  f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
lt_prog_compiler_wl='-Qoption ld ';;
  *)
lt_prog_compiler_wl='-Wl,';;
  esac
  ;;

sunos4*)
  lt_prog_compiler_wl='-Qoption ld '
  lt_prog_compiler_pic='-PIC'
  lt_prog_compiler_static='-Bstatic'
  ;;

sysv4 | sysv4.2uw2* | sysv4.3*)
  lt_prog_compiler_wl='-Wl,'
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  ;;

sysv4*MP*)
  if test -d /usr/nec ;then
lt_prog_compiler_pic='-Kconform_pic'
lt_prog_compiler_static='-Bstatic'
  fi
  ;;

sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
  lt_prog_compiler_wl='-Wl,'
  lt_prog_compiler_pic='-KPIC'
  lt_prog_compiler_static='-Bstatic'
  ;;

unicos*)
  lt_prog_compiler_wl='-Wl,'
  lt_prog_compiler_can_build_shared=no
  ;;

uts4*)
  lt_prog_compiler_pic='-pic'
  lt_prog_compiler_static='-Bstatic'
  ;;

*)
  lt_prog_compiler_can_build_shared=no
  ;;
esac

fi

case $host_os in # For platforms which do not support PIC, -DPIC is meaningless: djgpp) lt_prog_compiler_pic= ;; *) lt_prog_compiler_pic=“$lt_prog_compiler_pic -DPIC” ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC” >&5 $as_echo_n “checking for $compiler option to produce PIC… ” >&6; } if ${lt_cv_prog_compiler_pic+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_pic=$lt_prog_compiler_pic fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic” >&5 $as_echo “$lt_cv_prog_compiler_pic” >&6; } lt_prog_compiler_pic=$lt_cv_prog_compiler_pic

#

Check to make sure the PIC flag actually works.

# if test -n “$lt_prog_compiler_pic”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works” >&5 $as_echo_n “checking if $compiler PIC flag $lt_prog_compiler_pic works… ” >&6; } if ${lt_cv_prog_compiler_pic_works+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_pic_works=no ac_outfile=conftest.$ac_objext echo “$lt_simple_compile_test_code” > conftest.$ac_ext lt_compiler_flag=“$lt_prog_compiler_pic -DPIC” # Insert the option either (1) after the last FLAGS variable, or # (2) before a word containing “conftest.”, or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:' (eval echo “\”\$as_me:$LINENO: $lt_compile\“” >&5) (eval “$lt_compile” 2>conftest.err) ac_status=$? cat conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 if (exit $ac_status) && test -s “$ac_outfile”; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO “$_lt_compiler_boilerplate” | $SED ‘/^$/d’ >conftest.exp $SED ‘/^$/d; /^ +/d’ conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_pic_works=yes fi fi $RM -r conftest*

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works” >&5 $as_echo “$lt_cv_prog_compiler_pic_works” >&6; }

if test x"$lt_cv_prog_compiler_pic_works" = xyes; then case $lt_prog_compiler_pic in “” | “ ”) ;; ) lt_prog_compiler_pic=“ $lt_prog_compiler_pic” ;; esac else lt_prog_compiler_pic= lt_prog_compiler_can_build_shared=no fi

fi

#

Check to make sure the static flag actually works.

# wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\“$lt_prog_compiler_static\” { $as_echo “$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works” >&5 $as_echo_n “checking if $compiler static flag $lt_tmp_static_flag works… ” >&6; } if ${lt_cv_prog_compiler_static_works+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_static_works=no save_LDFLAGS=“$LDFLAGS” LDFLAGS=“$LDFLAGS $lt_tmp_static_flag” echo “$lt_simple_link_test_code” > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&5 $ECHO “$_lt_linker_boilerplate” | $SED ‘/^$/d’ > conftest.exp $SED ‘/^$/d; /^ +/d’ conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compiler_static_works=yes fi else lt_cv_prog_compiler_static_works=yes fi fi $RM -r conftest LDFLAGS=“$save_LDFLAGS”

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works” >&5 $as_echo “$lt_cv_prog_compiler_static_works” >&6; }

if test x"$lt_cv_prog_compiler_static_works" = xyes; then : else lt_prog_compiler_static= fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext” >&5 $as_echo_n “checking if $compiler supports -c -o file.$ac_objext… ” >&6; } if ${lt_cv_prog_compiler_c_o+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo “$lt_simple_compile_test_code” > conftest.$ac_ext

lt_compiler_flag=“-o out/conftest2.$ac_objext” # Insert the option either (1) after the last FLAGS variable, or # (2) before a word containing “conftest.”, or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:' (eval echo “\”\$as_me:$LINENO: $lt_compile\“” >&5) (eval “$lt_compile” 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO “$_lt_compiler_boilerplate” | $SED ‘/^$/d’ > out/conftest.exp $SED ‘/^$/d; /^ +/d’ out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o=yes fi fi chmod u+w . 2>&5 $RM -r conftest # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/ && rmdir out/ii_files $RM out/ && rmdir out cd .. $RM -r conftest $RM -r conftest

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o” >&5 $as_echo “$lt_cv_prog_compiler_c_o” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext” >&5 $as_echo_n “checking if $compiler supports -c -o file.$ac_objext… ” >&6; } if ${lt_cv_prog_compiler_c_o+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo “$lt_simple_compile_test_code” > conftest.$ac_ext

lt_compiler_flag=“-o out/conftest2.$ac_objext” # Insert the option either (1) after the last FLAGS variable, or # (2) before a word containing “conftest.”, or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:' (eval echo “\”\$as_me:$LINENO: $lt_compile\“” >&5) (eval “$lt_compile” 2>out/conftest.err) ac_status=$? cat out/conftest.err >&5 echo “$as_me:$LINENO: \$? = $ac_status” >&5 if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO “$_lt_compiler_boilerplate” | $SED ‘/^$/d’ > out/conftest.exp $SED ‘/^$/d; /^ +/d’ out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then lt_cv_prog_compiler_c_o=yes fi fi chmod u+w . 2>&5 $RM -r conftest # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/ && rmdir out/ii_files $RM out/ && rmdir out cd .. $RM -r conftest $RM -r conftest

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o” >&5 $as_echo “$lt_cv_prog_compiler_c_o” >&6; }

hard_links=“nottested” if test “$lt_cv_prog_compiler_c_o” = no && test “$need_locks” != no; then # do not overwrite the value of need_locks provided by the user { $as_echo “$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links” >&5 $as_echo_n “checking if we can lock with hard links… ” >&6; } hard_links=yes $RM -r conftest* ln conftest.a conftest.b 2>/dev/null && hard_links=no touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no { $as_echo “$as_me:${as_lineno-$LINENO}: result: $hard_links” >&5 $as_echo “$hard_links” >&6; } if test “$hard_links” = no; then { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: `$CC' does not support `-c -o', so `make -j' may be unsafe” >&5 $as_echo “$as_me: WARNING: `$CC' does not support `-c -o', so `make -j' may be unsafe” >&2;} need_locks=warn fi else need_locks=no fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries” >&5 $as_echo_n “checking whether the $compiler linker ($LD) supports shared libraries… ” >&6; }

runpath_var= allow_undefined_flag= always_export_symbols=no archive_cmds= archive_expsym_cmds= compiler_needs_object=no enable_shared_with_static_runtimes=no export_dynamic_flag_spec= export_symbols_cmds=‘$NM $libobjs $convenience | $global_symbol_pipe | $SED ’\‘’s/. //’\‘’ | sort | uniq > $export_symbols' hardcode_automatic=no hardcode_direct=no hardcode_direct_absolute=no hardcode_libdir_flag_spec= hardcode_libdir_separator= hardcode_minus_L=no hardcode_shlibpath_var=unsupported inherit_rpath=no link_all_deplibs=unknown module_cmds= module_expsym_cmds= old_archive_from_new_cmds= old_archive_from_expsyms_cmds= thread_safe_flag_spec= whole_archive_flag_spec= # include_expsyms should be a list of space-separated symbols to be always # included in the symbol list include_expsyms= # exclude_expsyms can be an extended regexp of symbols to exclude # it will be wrapped by (' and)$‘, so one must not match beginning or # end of line. Example: a|bc|.*d.*' will exclude the symbolsa’ and bc', # as well as any symbol that containsd'. exclude_expsyms=‘GLOBAL_OFFSET_TABLE|GLOBAL__F[ID].’ # Although GLOBAL_OFFSET_TABLE is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if # the symbol is explicitly referenced. Since portable code cannot # rely on this symbol name, it’s probably fine to never include it in # preloaded symbol tables. # Exclude shared library initialization/finalization symbols. extract_expsyms_cmds=

case $host_os in cygwin | mingw | pw32 | cegcc) # FIXME: the MSVC++ port hasn’t been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. if test “$GCC” != yes; then with_gnu_ld=no fi ;; interix) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd) with_gnu_ld=no ;; esac

ld_shlibs=yes

# On some targets, GNU ld is compatible enough with the native linker # that we’re better off using the native interface for both. lt_use_gnu_ld_interface=no if test “$with_gnu_ld” = yes; then case $host_os in aix) # The AIX port of GNU ld has always aspired to compatibility # with the native linker. However, as the warning in the GNU ld # block says, versions before 2.19.5 couldn’t really create working # shared libraries, regardless of the interface used. case $LD -v 2>&1 in \ (GNU\ Binutils)\ 2.19.5) ;; \ (GNU\ Binutils)\ 2.[2-9]) ;; \ (GNU\ Binutils)\ [3-9]) ;; ) lt_use_gnu_ld_interface=yes ;; esac ;; ) lt_use_gnu_ld_interface=yes ;; esac fi

if test “$lt_use_gnu_ld_interface” = yes; then # If archive_cmds runs LD, not CC, wlarc should be empty wlarc=‘${wl}’

# Set some defaults for GNU ld with shared library support. These
# are reset later if shared libraries are not supported. Putting them
# here allows them to be overridden if necessary.
runpath_var=LD_RUN_PATH
hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
export_dynamic_flag_spec='${wl}--export-dynamic'
# ancient GNU ld didn't support --whole-archive et. al.
if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
  whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
else
  whole_archive_flag_spec=
fi
supports_anon_versioning=no
case `$LD -v 2>&1` in
  *GNU\ gold*) supports_anon_versioning=yes ;;
  *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
  *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
  *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
  *\ 2.11.*) ;; # other 2.11 versions
  *) supports_anon_versioning=yes ;;
esac

# See if GNU ld supports shared libraries.
case $host_os in
aix[3-9]*)
  # On AIX/PPC, the GNU linker is very broken
  if test "$host_cpu" != ia64; then
ld_shlibs=no
cat <<_LT_EOF 1>&2

Warning: the GNU linker, at least up to release 2.19, is reported to be unable to reliably create shared libraries on AIX. Therefore, libtool is disabling shared libraries support. If you really care for shared libraries, you may want to install binutils 2.20 or above, or modify your PATH so that a non-GNU linker is found. You will then need to restart the configuration process.

_LT_EOF fi ;;

amigaos*)
  case $host_cpu in
  powerpc)
        # see comment about AmigaOS4 .so support
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
        archive_expsym_cmds=''
    ;;
  m68k)
        archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
        hardcode_libdir_flag_spec='-L$libdir'
        hardcode_minus_L=yes
    ;;
  esac
  ;;

beos*)
  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
allow_undefined_flag=unsupported
# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
# support --undefined.  This deserves some investigation.  FIXME
archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
  else
ld_shlibs=no
  fi
  ;;

cygwin* | mingw* | pw32* | cegcc*)
  # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
  # as there is no search path for DLLs.
  hardcode_libdir_flag_spec='-L$libdir'
  export_dynamic_flag_spec='${wl}--export-all-symbols'
  allow_undefined_flag=unsupported
  always_export_symbols=no
  enable_shared_with_static_runtimes=yes
  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
  exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'

  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
# If the export-symbols file already is a .def file (1st line
# is EXPORTS), use it as is; otherwise, prepend...
archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
  cp $export_symbols $output_objdir/$soname.def;
else
  echo EXPORTS > $output_objdir/$soname.def;
  cat $export_symbols >> $output_objdir/$soname.def;
fi~
$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
  else
ld_shlibs=no
  fi
  ;;

haiku*)
  archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
  link_all_deplibs=yes
  ;;

interix[3-9]*)
  hardcode_direct=no
  hardcode_shlibpath_var=no
  hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
  export_dynamic_flag_spec='${wl}-E'
  # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
  # Instead, shared libraries are loaded at an image base (0x10000000 by
  # default) and relocated if they conflict, which is a slow very memory
  # consuming and fragmenting process.  To avoid this, we pick a random,
  # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
  # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
  archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
  archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
  ;;

gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
  tmp_diet=no
  if test "$host_os" = linux-dietlibc; then
case $cc_basename in
  diet\ *) tmp_diet=yes;;   # linux-dietlibc with static linking (!diet-dyn)
esac
  fi
  if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
 && test "$tmp_diet" = no
  then
tmp_addflag=' $pic_flag'
tmp_sharedflag='-shared'
case $cc_basename,$host_cpu in
    pgcc*)              # Portland Group C compiler
  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
  tmp_addflag=' $pic_flag'
  ;;
pgf77* | pgf90* | pgf95* | pgfortran*)
                # Portland Group f77 and f90 compilers
  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
  tmp_addflag=' $pic_flag -Mnomain' ;;
ecc*,ia64* | icc*,ia64*)    # Intel C compiler on ia64
  tmp_addflag=' -i_dynamic' ;;
efc*,ia64* | ifort*,ia64*)  # Intel Fortran compiler on ia64
  tmp_addflag=' -i_dynamic -nofor_main' ;;
ifc* | ifort*)          # Intel Fortran compiler
  tmp_addflag=' -nofor_main' ;;
lf95*)              # Lahey Fortran 8.1
  whole_archive_flag_spec=
  tmp_sharedflag='--shared' ;;
xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
  tmp_sharedflag='-qmkshrobj'
  tmp_addflag= ;;
nvcc*)  # Cuda Compiler Driver 2.2
  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
  compiler_needs_object=yes
  ;;
esac
case `$CC -V 2>&1 | sed 5q` in
*Sun\ C*)           # Sun C 5.9
  whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
  compiler_needs_object=yes
  tmp_sharedflag='-G' ;;
*Sun\ F*)           # Sun Fortran 8.3
  tmp_sharedflag='-G' ;;
esac
archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

    if test "x$supports_anon_versioning" = xyes; then
      archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
    echo "local: *; };" >> $output_objdir/$libname.ver~
    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
    fi

case $cc_basename in
xlf* | bgf* | bgxlf* | mpixlf*)
  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
  if test "x$supports_anon_versioning" = xyes; then
    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
      echo "local: *; };" >> $output_objdir/$libname.ver~
      $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
  fi
  ;;
esac
  else
    ld_shlibs=no
  fi
  ;;

netbsd*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
wlarc=
  else
archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
  fi
  ;;

solaris*)
  if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
ld_shlibs=no
cat <<_LT_EOF 1>&2

Warning: The releases 2.8. of the GNU linker cannot reliably create shared libraries on Solaris systems. Therefore, libtool is disabling shared libraries support. We urge you to upgrade GNU binutils to release 2.9.1 or newer. Another option is to modify your PATH or compiler configuration so that the native linker is * used, and then restart.

_LT_EOF elif $LD –help 2>&1 | $GREP ‘: supported targets:.* elf’ > /dev/null; then archive_cmds=‘$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib’ archive_expsym_cmds=‘$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib’ else ld_shlibs=no fi ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
  case `$LD -v 2>&1` in
    *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
ld_shlibs=no
cat <<_LT_EOF 1>&2

Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not reliably create shared libraries on SCO systems. Therefore, libtool is disabling shared libraries support. We urge you to upgrade GNU binutils to release 2.16.91.0.3 or newer. Another option is to modify your PATH or compiler configuration so that the native linker is used, and then restart.

_LT_EOF ;; ) # For security reasons, it is highly recommended that you always # use absolute paths for naming shared libraries, and exclude the # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD –help 2>&1 | $GREP ‘: supported targets:. elf’ > /dev/null; then hardcode_libdir_flag_spec=‘${wl}-rpath ${wl}$libdir’ archive_cmds=‘$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib’ archive_expsym_cmds=‘$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib’ else ld_shlibs=no fi ;; esac ;;

sunos4*)
  archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
  wlarc=
  hardcode_direct=yes
  hardcode_shlibpath_var=no
  ;;

*)
  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
  else
ld_shlibs=no
  fi
  ;;
esac

if test "$ld_shlibs" = no; then
  runpath_var=
  hardcode_libdir_flag_spec=
  export_dynamic_flag_spec=
  whole_archive_flag_spec=
fi

else # PORTME fill in a description of your system’s linker (not GNU ld) case $host_os in aix3*) allow_undefined_flag=unsupported always_export_symbols=yes archive_expsym_cmds=‘$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname’ # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. hardcode_minus_L=yes if test “$GCC” = yes && test -z “$lt_prog_compiler_static”; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. hardcode_direct=unsupported fi ;;

aix[4-9]*)
  if test "$host_cpu" = ia64; then
# On IA64, the linker does run time linking by default, so we don't
# have to do anything special.
aix_use_runtimelinking=no
exp_sym_flag='-Bexport'
no_entry_flag=""
  else
# If we're using GNU nm, then we don't want the "-C" option.
# -C means demangle to AIX nm, but means don't demangle with GNU nm
# Also, AIX nm treats weak defined symbols like other global
# defined symbols, whereas GNU nm marks them as "W".
if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
else
  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
fi
aix_use_runtimelinking=no

# Test if we are trying to use run time linking or normal
# AIX style linking. If -brtl is somewhere in LDFLAGS, we
# need to do runtime linking.
case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
  for ld_flag in $LDFLAGS; do
  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
    aix_use_runtimelinking=yes
    break
  fi
  done
  ;;
esac

exp_sym_flag='-bexport'
no_entry_flag='-bnoentry'
  fi

  # When large executables or shared objects are built, AIX ld can
  # have problems creating the table of contents.  If linking a library
  # or program results in "error TOC overflow" add -mminimal-toc to
  # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
  # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

  archive_cmds=''
  hardcode_direct=yes
  hardcode_direct_absolute=yes
  hardcode_libdir_separator=':'
  link_all_deplibs=yes
  file_list_spec='${wl}-f,'

  if test "$GCC" = yes; then
case $host_os in aix4.[012]|aix4.[012].*)
# We only want to do this on AIX 4.2 and lower, the check
# below for broken collect2 doesn't work under 4.3+
  collect2name=`${CC} -print-prog-name=collect2`
  if test -f "$collect2name" &&
   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
  then
  # We have reworked collect2
  :
  else
  # We have old collect2
  hardcode_direct=unsupported
  # It fails to find uninstalled libraries when the uninstalled
  # path is not listed in the libpath.  Setting hardcode_minus_L
  # to unsupported forces relinking
  hardcode_minus_L=yes
  hardcode_libdir_flag_spec='-L$libdir'
  hardcode_libdir_separator=
  fi
  ;;
esac
shared_flag='-shared'
if test "$aix_use_runtimelinking" = yes; then
  shared_flag="$shared_flag "'${wl}-G'
fi
  else
# not using gcc
if test "$host_cpu" = ia64; then
# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
# chokes on -Wl,-G. The following line is correct:
  shared_flag='-G'
else
  if test "$aix_use_runtimelinking" = yes; then
    shared_flag='${wl}-G'
  else
    shared_flag='${wl}-bM:SRE'
  fi
fi
  fi

  export_dynamic_flag_spec='${wl}-bexpall'
  # It seems that -bexpall does not export symbols beginning with
  # underscore (_), so it is better to generate a list of symbols to export.
  always_export_symbols=yes
  if test "$aix_use_runtimelinking" = yes; then
# Warning - without using the other runtime loading flags (-brtl),
# -berok will link without error, but may produce a broken library.
allow_undefined_flag='-berok'
    # Determine the default libpath from the value encoded in an
    # empty executable.
    if test "${lt_cv_aix_libpath+set}" = set; then

aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then :

lt_aix_libpath_sed=‘ /Import File Strings/,/^$/ { /^0/ { s/^0 ([^ ]) *$/\1/ p } }’ lt_cv_aix_libpath=dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed" # Check for a 64-bit object if we didn’t find anything. if test -z “$lt_cv_aix_libpath”; then lt_cv_aix_libpath=dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed" fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z “$lt_cv_aix_libpath”; then lt_cv_aix_libpath_=“/usr/lib:/lib” fi

fi

aix_libpath=$lt_cv_aix_libpath_ fi

    hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
    archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
  else
if test "$host_cpu" = ia64; then
  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
  allow_undefined_flag="-z nodefs"
  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
else
 # Determine the default libpath from the value encoded in an
 # empty executable.
 if test "${lt_cv_aix_libpath+set}" = set; then

aix_libpath=$lt_cv_aix_libpath else if ${lt_cv_aix_libpath+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then :

lt_aix_libpath_sed=‘ /Import File Strings/,/^$/ { /^0/ { s/^0 ([^ ]) *$/\1/ p } }’ lt_cv_aix_libpath=dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed" # Check for a 64-bit object if we didn’t find anything. if test -z “$lt_cv_aix_libpath”; then lt_cv_aix_libpath=dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed" fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext if test -z “$lt_cv_aix_libpath”; then lt_cv_aix_libpath_=“/usr/lib:/lib” fi

fi

aix_libpath=$lt_cv_aix_libpath_ fi

 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
  # Warning - without using the other run time loading flags,
  # -berok will link without error, but may produce a broken library.
  no_undefined_flag=' ${wl}-bernotok'
  allow_undefined_flag=' ${wl}-berok'
  if test "$with_gnu_ld" = yes; then
    # We only use this code for GNU lds that support --whole-archive.
    whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
  else
    # Exported symbols can be pulled into shared objects from archives
    whole_archive_flag_spec='$convenience'
  fi
  archive_cmds_need_lc=yes
  # This is similar to how AIX traditionally builds its shared libraries.
  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
fi
  fi
  ;;

amigaos*)
  case $host_cpu in
  powerpc)
        # see comment about AmigaOS4 .so support
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
        archive_expsym_cmds=''
    ;;
  m68k)
        archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
        hardcode_libdir_flag_spec='-L$libdir'
        hardcode_minus_L=yes
    ;;
  esac
  ;;

bsdi[45]*)
  export_dynamic_flag_spec=-rdynamic
  ;;

cygwin* | mingw* | pw32* | cegcc*)
  # When not using gcc, we currently assume that we are using
  # Microsoft Visual C++.
  # hardcode_libdir_flag_spec is actually meaningless, as there is
  # no search path for DLLs.
  case $cc_basename in
  cl*)
# Native MSVC
hardcode_libdir_flag_spec=' '
allow_undefined_flag=unsupported
always_export_symbols=yes
file_list_spec='@'
# Tell ltmain to make .lib files, not .a files.
libext=lib
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=".dll"
# FIXME: Setting linknames here is a bad hack.
archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
    sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
  else
    sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
  fi~
  $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
  linknames='
# The linker will not automatically build a static lib if we build a DLL.
# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
enable_shared_with_static_runtimes=yes
exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
# Don't use ranlib
old_postinstall_cmds='chmod 644 $oldlib'
postlink_cmds='lt_outputfile="@OUTPUT@"~
  lt_tool_outputfile="@TOOL_OUTPUT@"~
  case $lt_outputfile in
    *.exe|*.EXE) ;;
    *)
      lt_outputfile="$lt_outputfile.exe"
      lt_tool_outputfile="$lt_tool_outputfile.exe"
      ;;
  esac~
  if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
    $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
    $RM "$lt_outputfile.manifest";
  fi'
;;
  *)
# Assume MSVC wrapper
hardcode_libdir_flag_spec=' '
allow_undefined_flag=unsupported
# Tell ltmain to make .lib files, not .a files.
libext=lib
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=".dll"
# FIXME: Setting linknames here is a bad hack.
archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
# The linker will automatically build a .lib file if we build a DLL.
old_archive_from_new_cmds='true'
# FIXME: Should let the user specify the lib program.
old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
enable_shared_with_static_runtimes=yes
;;
  esac
  ;;

darwin* | rhapsody*)

archive_cmds_need_lc=no hardcode_direct=no hardcode_automatic=yes hardcode_shlibpath_var=unsupported if test “$lt_cv_ld_force_load” = “yes”; then whole_archive_flag_spec=‘for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"

else whole_archive_flag_spec=‘’ fi link_all_deplibs=yes allow_undefined_flag=“$lt_dar_allow_undefined” case $cc_basename in ifort*) lt_dar_can_shared=yes ;; *) lt_dar_can_shared=$GCC ;; esac if test “$lt_dar_can_shared” = “yes”; then output_verbose_link_cmd=func_echo_all archive_cmds=“\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $lt_dar_single_mod${lt_dsymutil}” module_cmds=“\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${lt_dsymutil}” archive_expsym_cmds=“sed ’s,^,,‘ < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${lt_dar_single_mod}${lt_dar_export_syms}${lt_dsymutil}” module_expsym_cmds=“sed -e ’s,^,,’ < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${lt_dar_export_syms}${lt_dsymutil}”

else ld_shlibs=no fi

  ;;

dgux*)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_libdir_flag_spec='-L$libdir'
  hardcode_shlibpath_var=no
  ;;

# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
# support.  Future versions do this automatically, but an explicit c++rt0.o
# does not break anything, and helps significantly (at the cost of a little
# extra space).
freebsd2.2*)
  archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
  hardcode_libdir_flag_spec='-R$libdir'
  hardcode_direct=yes
  hardcode_shlibpath_var=no
  ;;

# Unfortunately, older versions of FreeBSD 2 do not have this feature.
freebsd2.*)
  archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
  hardcode_direct=yes
  hardcode_minus_L=yes
  hardcode_shlibpath_var=no
  ;;

# FreeBSD 3 and greater uses gcc -shared to do shared libraries.
freebsd* | dragonfly*)
  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
  hardcode_libdir_flag_spec='-R$libdir'
  hardcode_direct=yes
  hardcode_shlibpath_var=no
  ;;

hpux9*)
  if test "$GCC" = yes; then
archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
  else
archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
  fi
  hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
  hardcode_libdir_separator=:
  hardcode_direct=yes

  # hardcode_minus_L: Not really in the search PATH,
  # but as the default location of the library.
  hardcode_minus_L=yes
  export_dynamic_flag_spec='${wl}-E'
  ;;

hpux10*)
  if test "$GCC" = yes && test "$with_gnu_ld" = no; then
archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
  else
archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
  fi
  if test "$with_gnu_ld" = no; then
hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
hardcode_libdir_separator=:
hardcode_direct=yes
hardcode_direct_absolute=yes
export_dynamic_flag_spec='${wl}-E'
# hardcode_minus_L: Not really in the search PATH,
# but as the default location of the library.
hardcode_minus_L=yes
  fi
  ;;

hpux11*)
  if test "$GCC" = yes && test "$with_gnu_ld" = no; then
case $host_cpu in
hppa*64*)
  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
  ;;
ia64*)
  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
  ;;
*)
  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
  ;;
esac
  else
case $host_cpu in
hppa*64*)
  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
  ;;
ia64*)
  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
  ;;
*)

  # Older versions of the 11.00 compiler do not understand -b yet
  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5

$as_echo_n “checking if $CC understands -b… ” >&6; } if ${lt_cv_prog_compilerb+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_prog_compilerb=no save_LDFLAGS=“$LDFLAGS” LDFLAGS=“$LDFLAGS -b” echo “$lt_simple_link_test_code” > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&5 $ECHO “$_lt_linker_boilerplate” | $SED ‘/^$/d’ > conftest.exp $SED ‘/^$/d; /^ +/d’ conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then lt_cv_prog_compilerb=yes fi else lt_cv_prog_compilerb=yes fi fi $RM -r conftest LDFLAGS=“$save_LDFLAGS”

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compilerb” >&5 $as_echo “$lt_cv_prog_compilerb” >&6; }

if test x"$lt_cv_prog_compiler__b" = xyes; then archive_cmds=‘$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags’ else archive_cmds=‘$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags’ fi

  ;;
esac
  fi
  if test "$with_gnu_ld" = no; then
hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
hardcode_libdir_separator=:

case $host_cpu in
hppa*64*|ia64*)
  hardcode_direct=no
  hardcode_shlibpath_var=no
  ;;
*)
  hardcode_direct=yes
  hardcode_direct_absolute=yes
  export_dynamic_flag_spec='${wl}-E'

  # hardcode_minus_L: Not really in the search PATH,
  # but as the default location of the library.
  hardcode_minus_L=yes
  ;;
esac
  fi
  ;;

irix5* | irix6* | nonstopux*)
  if test "$GCC" = yes; then
archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
# Try to use the -exported_symbol ld option, if it does not
# work, assume that -exports_file does not work either and
# implicitly export all symbols.
# This should be the same for all languages, so no per-tag cache variable.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5

$as_echo_n “checking whether the $host_os linker accepts -exported_symbol… ” >&6; } if ${lt_cv_irix_exported_symbol+:} false; then : $as_echo_n “(cached) ” >&6 else save_LDFLAGS=“$LDFLAGS” LDFLAGS=“$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null” cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / int foo (void) { return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : lt_cv_irix_exported_symbol=yes else lt_cv_irix_exported_symbol=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=“$save_LDFLAGS” fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol” >&5 $as_echo “$lt_cv_irix_exported_symbol” >&6; } if test “$lt_cv_irix_exported_symbol” = yes; then archive_expsym_cmds=‘$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring" ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib’ fi else archive_cmds=‘$CC -shared $libobjs $deplibs $compiler_flags -soname $soname test -n "$verstring" && func_echo_all "-set_version $verstring" -update_registry ${output_objdir}/so_locations -o $lib’ archive_expsym_cmds=‘$CC -shared $libobjs $deplibs $compiler_flags -soname $soname test -n "$verstring" && func_echo_all "-set_version $verstring" -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib’ fi archive_cmds_need_lc=‘no’ hardcode_libdir_flag_spec=‘${wl}-rpath ${wl}$libdir’ hardcode_libdir_separator=: inherit_rpath=yes link_all_deplibs=yes ;;

netbsd*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
  else
archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
  fi
  hardcode_libdir_flag_spec='-R$libdir'
  hardcode_direct=yes
  hardcode_shlibpath_var=no
  ;;

newsos6)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_direct=yes
  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
  hardcode_libdir_separator=:
  hardcode_shlibpath_var=no
  ;;

*nto* | *qnx*)
  ;;

openbsd*)
  if test -f /usr/libexec/ld.so; then
hardcode_direct=yes
hardcode_shlibpath_var=no
hardcode_direct_absolute=yes
if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
  hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
  export_dynamic_flag_spec='${wl}-E'
else
  case $host_os in
   openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
     archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
     hardcode_libdir_flag_spec='-R$libdir'
     ;;
   *)
     archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
     hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
     ;;
  esac
fi
  else
ld_shlibs=no
  fi
  ;;

os2*)
  hardcode_libdir_flag_spec='-L$libdir'
  hardcode_minus_L=yes
  allow_undefined_flag=unsupported
  archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
  old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
  ;;

osf3*)
  if test "$GCC" = yes; then
allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
  else
allow_undefined_flag=' -expect_unresolved \*'
archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
  fi
  archive_cmds_need_lc='no'
  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
  hardcode_libdir_separator=:
  ;;

osf4* | osf5*)  # as osf3* with the addition of -msym flag
  if test "$GCC" = yes; then
allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
  else
allow_undefined_flag=' -expect_unresolved \*'
archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'

# Both c and cxx compiler support -rpath directly
hardcode_libdir_flag_spec='-rpath $libdir'
  fi
  archive_cmds_need_lc='no'
  hardcode_libdir_separator=:
  ;;

solaris*)
  no_undefined_flag=' -z defs'
  if test "$GCC" = yes; then
wlarc='${wl}'
archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
  $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
  else
case `$CC -V 2>&1` in
*"Compilers 5.0"*)
  wlarc=''
  archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
  ;;
*)
  wlarc='${wl}'
  archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
  ;;
esac
  fi
  hardcode_libdir_flag_spec='-R$libdir'
  hardcode_shlibpath_var=no
  case $host_os in
  solaris2.[0-5] | solaris2.[0-5].*) ;;
  *)
# The compiler driver will combine and reorder linker options,
# but understands `-z linker_flag'.  GCC discards it without `$wl',
# but is careful enough not to reorder.
# Supported since Solaris 2.6 (maybe 2.5.1?)
if test "$GCC" = yes; then
  whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
else
  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
fi
;;
  esac
  link_all_deplibs=yes
  ;;

sunos4*)
  if test "x$host_vendor" = xsequent; then
# Use $CC to link under sequent, because it throws in some extra .o
# files that make .init and .fini sections work.
archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
  else
archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
  fi
  hardcode_libdir_flag_spec='-L$libdir'
  hardcode_direct=yes
  hardcode_minus_L=yes
  hardcode_shlibpath_var=no
  ;;

sysv4)
  case $host_vendor in
sni)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_direct=yes # is this really true???
;;
siemens)
  ## LD is ld it makes a PLAMLIB
  ## CC just makes a GrossModule.
  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
  reload_cmds='$CC -r -o $output$reload_objs'
  hardcode_direct=no
    ;;
motorola)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
;;
  esac
  runpath_var='LD_RUN_PATH'
  hardcode_shlibpath_var=no
  ;;

sysv4.3*)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_shlibpath_var=no
  export_dynamic_flag_spec='-Bexport'
  ;;

sysv4*MP*)
  if test -d /usr/nec; then
archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
hardcode_shlibpath_var=no
runpath_var=LD_RUN_PATH
hardcode_runpath_var=yes
ld_shlibs=yes
  fi
  ;;

sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
  no_undefined_flag='${wl}-z,text'
  archive_cmds_need_lc=no
  hardcode_shlibpath_var=no
  runpath_var='LD_RUN_PATH'

  if test "$GCC" = yes; then
archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
  else
archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
  fi
  ;;

sysv5* | sco3.2v5* | sco5v6*)
  # Note: We can NOT use -z defs as we might desire, because we do not
  # link with -lc, and that would cause any symbols used from libc to
  # always be unresolved, which means just about no library would
  # ever link correctly.  If we're not using GNU ld we use -z text
  # though, which does catch some bad symbols but isn't as heavy-handed
  # as -z defs.
  no_undefined_flag='${wl}-z,text'
  allow_undefined_flag='${wl}-z,nodefs'
  archive_cmds_need_lc=no
  hardcode_shlibpath_var=no
  hardcode_libdir_flag_spec='${wl}-R,$libdir'
  hardcode_libdir_separator=':'
  link_all_deplibs=yes
  export_dynamic_flag_spec='${wl}-Bexport'
  runpath_var='LD_RUN_PATH'

  if test "$GCC" = yes; then
archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
  else
archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
  fi
  ;;

uts4*)
  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
  hardcode_libdir_flag_spec='-L$libdir'
  hardcode_shlibpath_var=no
  ;;

*)
  ld_shlibs=no
  ;;
esac

if test x$host_vendor = xsni; then
  case $host in
  sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
export_dynamic_flag_spec='${wl}-Blargedynsym'
;;
  esac
fi

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $ld_shlibs” >&5 $as_echo “$ld_shlibs” >&6; } test “$ld_shlibs” = no && can_build_shared=no

with_gnu_ld=$with_gnu_ld

#

Do we need to explicitly link libc?

# case “x$archive_cmds_need_lc” in x|xyes) # Assume -lc should be added archive_cmds_need_lc=yes

if test “$enable_shared” = yes && test “$GCC” = yes; then case $archive_cmds in ‘~’) # FIXME: we may have to deal with multi-command sequences. ;; ‘$CC ’) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don’t add -lc before -lgcc. { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in” >&5 $as_echo_n “checking whether -lc should be explicitly linked in… ” >&6; } if ${lt_cv_archive_cmds_need_lc+:} false; then : $as_echo_n “(cached) ” >&6 else $RM -r conftest echo “$lt_simple_compile_test_code” > conftest.$ac_ext

if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5

(eval $ac_compile) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$lt_prog_compiler_wl pic_flag=$lt_prog_compiler_pic compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$allow_undefined_flag allow_undefined_flag= if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$archive_cmds 2>&1 | $GREP \“ -lc \” >/dev/null 2>&1\“”; } >&5 (eval $archive_cmds 2>&1 | $GREP \“ -lc \” >/dev/null 2>&1) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc=no else lt_cv_archive_cmds_need_lc=yes fi allow_undefined_flag=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM -r conftest*

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc” >&5 $as_echo “$lt_cv_archive_cmds_need_lc” >&6; } archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc ;; esac fi ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics” >&5 $as_echo_n “checking dynamic linker characteristics… ” >&6; }

if test “$GCC” = yes; then case $host_os in darwin) lt_awk_arg=“/^libraries:/,/LR/” ;; ) lt_awk_arg=“/^libraries:/” ;; esac case $host_os in mingw | cegcc) lt_sed_strip_eq=“s,=([A-Za-z]:),\1,g” ;; ) lt_sed_strip_eq=“s,=/,/,g” ;; esac lt_search_path_spec=$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq case $lt_search_path_spec in \;) # if the path contains “;” then we assume it to be the separator # otherwise default to the standard path separator (i.e. “:”) - it is # assumed that no part of a normal pathname contains “;” but that should # okay in the real world where “;” in dirpaths is itself problematic. lt_search_path_spec=$ECHO "$lt_search_path_spec" | $SED 's/;/ /g' ;; ) lt_search_path_spec=$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g" ;; esac # Ok, now we have the path, separated by spaces, we can step through it # and add multilib dir if necessary. lt_tmp_lt_search_path_spec= lt_multi_os_dir=$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null for lt_sys_path in $lt_search_path_spec; do if test -d “$lt_sys_path/$lt_multi_os_dir”; then lt_tmp_lt_search_path_spec=“$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir” else test -d “$lt_sys_path” && \ lt_tmp_lt_search_path_spec=“$lt_tmp_lt_search_path_spec $lt_sys_path” fi done lt_search_path_spec=$ECHO "$lt_tmp_lt_search_path_spec" | awk ' BEGIN {RS=" "; FS="/|\n";} { lt_foo=""; lt_count=0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { lt_foo="/" $lt_i lt_foo; } else { lt_count--; } } } } if (lt_foo != "") { lt_freq[lt_foo]++; } if (lt_freq[lt_foo] == 1) { print lt_foo; } }' # AWK program above erroneously prepends ‘/’ to C:/dos/paths # for these hosts. case $host_os in mingw | cegcc) lt_search_path_spec=$ECHO "$lt_search_path_spec" |\ $SED 's,/\([A-Za-z]:\),\1,g' ;; esac sys_lib_search_path_spec=$ECHO "$lt_search_path_spec" | $lt_NL2SP else sys_lib_search_path_spec=“/lib /usr/lib /usr/local/lib” fi library_names_spec= libname_spec=‘lib$name’ soname_spec= shrext_cmds=“.so” postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= shlibpath_overrides_runpath=unknown version_type=none dynamic_linker=“$host_os ld.so” sys_lib_dlsearch_path_spec=“/lib /usr/lib” need_lib_prefix=unknown hardcode_into_libs=no

when you set need_version to no, make sure it does not cause -set_version

flags to be left without arguments

need_version=unknown

case $host_os in aix3*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec=‘${libname}${release}${shared_ext}$versuffix $libname.a’ shlibpath_var=LIBPATH

# AIX 3 has no versioning support, so we append a major version to the name. soname_spec=‘${libname}${release}${shared_ext}$major’ ;;

aix[4-9]) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no hardcode_into_libs=yes if test “$host_cpu” = ia64; then # AIX 5 supports IA64 library_names_spec=‘${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}’ shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with # the line #! .'. This would cause the generated library to # depend on.‘, always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[01] | aix4.[01].) if { echo ’#if GNUC > 2 || (GNUC == 2 && GNUC_MINOR >= 97)‘ echo ’ yes ‘ echo ’#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac # AIX (on Power*) has no versioning support, so currently we can not hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. if test “$aix_use_runtimelinking” = yes; then # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ else # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. library_names_spec=‘${libname}${release}.a $libname.a’ soname_spec=‘${libname}${release}${shared_ext}$major’ fi shlibpath_var=LIBPATH fi ;;

amigaos*) case $host_cpu in powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ ;; m68k) library_names_spec=‘$libname.ixlibrary $libname.a’ # Create ${libname}ixlibrary.a entries in /sys/libs. finish_eval=‘for lib in ls $libdir/*.ixlibrary 2>/dev/null; do libname=func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''; test $RM /sys/libs/${libname}ixlibrary.a; $show “cd /sys/libs && $LN_S $lib ${libname}ixlibrary.a”; cd /sys/libs && $LN_S $lib ${libname}ixlibrary.a || exit 1; done’ ;; esac ;;

beos*) library_names_spec=‘${libname}${shared_ext}’ dynamic_linker=“$host_os ld.so” shlibpath_var=LIBRARY_PATH ;;

bsdi[45]*) version_type=linux # correct to gnu/linux during the next big refactor need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ finish_cmds=‘PATH=“\$PATH:/sbin” ldconfig $libdir’ shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec=“/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib” sys_lib_dlsearch_path_spec=“/shlib /usr/lib /usr/local/lib” # the default ld.so.conf also contains /usr/contrib/lib and # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow # libtool to hard-code these into programs ;;

cygwin | mingw | pw32 | cegcc) version_type=windows shrext_cmds=“.dll” need_version=no need_lib_prefix=no

case $GCC,$cc_basename in yes,*) # gcc library_names_spec=‘$libname.dll.a’ # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds=‘base_file=basename \${file}~ dlpath=$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''~ dldir=$destdir/dirname \$dlpath~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ chmod a+x \$dldir/$dlname~ if test -n ’\‘’$stripme'\‘’ && test -n ‘\’‘$striplib’\‘’; then eval ‘\’‘$striplib \$dldir/$dlname’\‘’ || exit \$?; fi' postuninstall_cmds=‘dldll=$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''~ dlpath=$dir/\$dldll~ $RM \$dlpath’ shlibpath_overrides_runpath=yes

case $host_os in
cygwin*)
  # Cygwin DLLs use 'cyg' prefix rather than 'lib'
  soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
  ;;
mingw* | cegcc*)
  # MinGW DLLs use traditional 'lib' prefix
  soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
  ;;
pw32*)
  # pw32 DLLs use 'pw' prefix rather than 'lib'
  library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
  ;;
esac
dynamic_linker='Win32 ld.exe'
;;

,cl) # Native MSVC libname_spec=‘$name’ soname_spec=‘${libname}echo ${release} | $SED -e 's/[.]/-/g'${versuffix}${shared_ext}’ library_names_spec=‘${libname}.dll.lib’

case $build_os in
mingw*)
  sys_lib_search_path_spec=
  lt_save_ifs=$IFS
  IFS=';'
  for lt_path in $LIB
  do
    IFS=$lt_save_ifs
    # Let DOS variable expansion print the short 8.3 style file name.
    lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
    sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
  done
  IFS=$lt_save_ifs
  # Convert to MSYS style.
  sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
  ;;
cygwin*)
  # Convert to unix form, then to dos form, then back to unix form
  # but this time dos style (no spaces!) so that the unix form looks
  # like /cygdrive/c/PROGRA~1:/cygdr...
  sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
  sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
  sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
  ;;
*)
  sys_lib_search_path_spec="$LIB"
  if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
    # It is most probably a Windows format PATH.
    sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
  else
    sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
  fi
  # FIXME: find the short name or the path components, as spaces are
  # common. (e.g. "Program Files" -> "PROGRA~1")
  ;;
esac

# DLL is installed to $(libdir)/../bin by postinstall_cmds
postinstall_cmds='base_file=`basename \${file}`~
  dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
  dldir=$destdir/`dirname \$dlpath`~
  test -d \$dldir || mkdir -p \$dldir~
  $install_prog $dir/$dlname \$dldir/$dlname'
postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
  dlpath=$dir/\$dldll~
   $RM \$dlpath'
shlibpath_overrides_runpath=yes
dynamic_linker='Win32 link.exe'
;;

*) # Assume MSVC wrapper library_names_spec=‘${libname}echo ${release} | $SED -e 's/[.]/-/g'${versuffix}${shared_ext} $libname.lib’ dynamic_linker=‘Win32 ld.exe’ ;; esac # FIXME: first we should search . and the directory the executable is in shlibpath_var=PATH ;;

darwin | rhapsody) dynamic_linker=“$host_os dyld” version_type=darwin need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${major}$shared_ext ${libname}$shared_ext’ soname_spec=‘${libname}${release}${major}$shared_ext’ shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds=‘test .$module = .yes && echo .so || echo .dylib

sys_lib_search_path_spec=“$sys_lib_search_path_spec /usr/local/lib” sys_lib_dlsearch_path_spec=‘/usr/local/lib /lib /usr/lib’ ;;

dgux*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH ;;

freebsd | dragonfly) # DragonFly does not have aout. When/if they implement a new # versioning mechanism, adjust this. if test -x /usr/bin/objformat; then objformat=/usr/bin/objformat else case $host_os in freebsd[23].) objformat=aout ;; ) objformat=elf ;; esac fi version_type=freebsd-$objformat case $version_type in freebsd-elf) library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}’ need_version=no need_lib_prefix=no ;; freebsd-) library_names_spec=‘${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix’ need_version=yes ;; esac shlibpath_var=LD_LIBRARY_PATH case $host_os in freebsd2.) shlibpath_overrides_runpath=yes ;; freebsd3.[01] | freebsdelf3.[01]) shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; freebsd3.[2-9] | freebsdelf3.[2-9] | \ freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; ) # from 4.6 on, and DragonFly shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; esac ;;

gnu*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;;

haiku*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no dynamic_linker=“$host_os runtime_loader” library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LIBRARY_PATH shlibpath_overrides_runpath=yes sys_lib_dlsearch_path_spec=‘/boot/home/config/lib /boot/common/lib /boot/system/lib’ hardcode_into_libs=yes ;;

hpux9 | hpux10 | hpux11) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. version_type=sunos need_lib_prefix=no need_version=no case $host_cpu in ia64) shrext_cmds=‘.so’ hardcode_into_libs=yes dynamic_linker=“$host_os dld.so” shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ if test “X$HPUX_IA64_MODE” = X32; then sys_lib_search_path_spec=“/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib” else sys_lib_search_path_spec=“/usr/lib/hpux64 /usr/local/lib/hpux64” fi sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa64) shrext_cmds=‘.sl’ hardcode_into_libs=yes dynamic_linker=“$host_os dld.sl” shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ sys_lib_search_path_spec=“/usr/lib/pa20_64 /usr/ccs/lib/pa20_64” sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; ) shrext_cmds=‘.sl’ dynamic_linker=“$host_os dld.sl” shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ ;; esac # HP-UX runs really* slowly unless shared libraries are mode 555, … postinstall_cmds=‘chmod 555 $lib’ # or fails outright, so override atomically: install_override_mode=555 ;;

interix[3-9]*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ dynamic_linker=‘Interix 3.x ld.so.1 (PE, like ELF)’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;;

irix5 | irix6 | nonstopux) case $host_os in nonstopux) version_type=nonstopux ;; ) if test “$lt_cv_prog_gnu_ld” = yes; then version_type=linux # correct to gnu/linux during the next big refactor else version_type=irix fi ;; esac need_lib_prefix=no need_version=no soname_spec=‘${libname}${release}${shared_ext}$major’ library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}’ case $host_os in irix5 | nonstopux) libsuff= shlibsuff= ;; ) case $LD in # libtool.m4 will add one of these switches to LD -32|“-32 ”|-melf32bsmip|“-melf32bsmip ”) libsuff= shlibsuff= libmagic=32-bit;; -n32|“-n32 ”|-melf32bmipn32|“-melf32bmipn32 ”) libsuff=32 shlibsuff=N32 libmagic=N32;; -64|“-64 ”|-melf64bmip|“-melf64bmip ”) libsuff=64 shlibsuff=64 libmagic=64-bit;; *) libsuff= shlibsuff= libmagic=never-match;; esac ;; esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no sys_lib_search_path_spec=“/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}” sys_lib_dlsearch_path_spec=“/usr/lib${libsuff} /lib${libsuff}” hardcode_into_libs=yes ;;

No shared lib support for Linux oldld, aout, or coff.

linuxoldld | linuxaout | linuxcoff) dynamic_linker=no ;;

This must be glibc/ELF.

linux | kbsd-gnu | kopensolaris-gnu) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ finish_cmds=‘PATH=“\$PATH:/sbin” ldconfig -n $libdir’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no

# Some binutils ld are patched to set DT_RUNPATH if ${lt_cv_shlibpath_overrides_runpath+:} false; then : $as_echo_n “(cached) ” >&6 else lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval “libdir=/foo; wl=\”$lt_prog_compiler_wl\“; \ LDFLAGS=\”\$LDFLAGS $hardcode_libdir_flag_spec\“” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep “RUNPATH.*$libdir” >/dev/null; then : lt_cv_shlibpath_overrides_runpath=yes fi fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$save_LDFLAGS libdir=$save_libdir

fi

shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath

# This implies no fast_install, which is unacceptable. # Some rework will be needed to allow for fast_install # before this can be enabled. hardcode_into_libs=yes

# Append ld.so.conf contents to the search path if test -f /etc/ld.so.conf; then lt_ld_extra=awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' ' sys_lib_dlsearch_path_spec=“/lib /usr/lib $lt_ld_extra” fi

# We used to test for /lib/ld.so.1 and disable shared libraries on # powerpc, because MkLinux only supported shared libraries with the # GNU dynamic linker. Since this was broken with cross compilers, # most powerpc-linux boxes support dynamic linking these days and # people can always –disable-shared, the test was removed, and we # assume the GNU/Linux dynamic linker is in use. dynamic_linker=‘GNU/Linux ld.so’ ;;

netbsd*) version_type=sunos need_lib_prefix=no need_version=no if echo ELF | $CC -E - | $GREP ELF >/dev/null; then library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix’ finish_cmds=‘PATH=“\$PATH:/sbin” ldconfig -m $libdir’ dynamic_linker=‘NetBSD (a.out) ld.so’ else library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ dynamic_linker=‘NetBSD ld.elf_so’ fi shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;;

newsos6) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;;

nto | qnx) version_type=qnx need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker=‘ldqnx.so’ ;;

openbsd) version_type=sunos sys_lib_dlsearch_path_spec=“/usr/lib” need_lib_prefix=no # Some older versions of OpenBSD (3.3 at least) do need versioned libs. case $host_os in openbsd3.3 | openbsd3.3.) need_version=yes ;; ) need_version=no ;; esac library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix’ finish_cmds=‘PATH=“\$PATH:/sbin” ldconfig -m $libdir’ shlibpath_var=LD_LIBRARY_PATH if test -z “echo __ELF__ | $CC -E - | $GREP __ELF__” || test “$host_os-$host_cpu” = “openbsd2.8-powerpc”; then case $host_os in openbsd2.[89] | openbsd2.[89].) shlibpath_overrides_runpath=no ;; *) shlibpath_overrides_runpath=yes ;; esac else shlibpath_overrides_runpath=yes fi ;;

os2*) libname_spec=‘$name’ shrext_cmds=“.dll” need_lib_prefix=no library_names_spec=‘$libname${shared_ext} $libname.a’ dynamic_linker=‘OS/2 ld.exe’ shlibpath_var=LIBPATH ;;

osf3 | osf4 | osf5*) version_type=osf need_lib_prefix=no need_version=no soname_spec=‘${libname}${release}${shared_ext}$major’ library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec=“/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib” sys_lib_dlsearch_path_spec=“$sys_lib_search_path_spec” ;;

rdos*) dynamic_linker=no ;;

solaris*) version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes # ldd complains unless libraries are executable postinstall_cmds=‘chmod +x $lib’ ;;

sunos4*) version_type=sunos library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix’ finish_cmds=‘PATH=“\$PATH:/usr/etc” ldconfig $libdir’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes if test “$with_gnu_ld” = yes; then need_lib_prefix=no fi need_version=yes ;;

sysv4 | sysv4.3*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) shlibpath_overrides_runpath=no need_lib_prefix=no runpath_var=LD_RUN_PATH ;; siemens) need_lib_prefix=no ;; motorola) need_lib_prefix=no need_version=no shlibpath_overrides_runpath=no sys_lib_search_path_spec=‘/lib /usr/lib /usr/ccs/lib’ ;; esac ;;

sysv4MP) if test -d /usr/nec ;then version_type=linux # correct to gnu/linux during the next big refactor library_names_spec=‘$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}’ soname_spec=‘$libname${shared_ext}.$major’ shlibpath_var=LD_LIBRARY_PATH fi ;;

sysv5 | sco3.2v5 | sco5v6 | unixware | OpenUNIX | sysv4uw2) version_type=freebsd-elf need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes if test “$with_gnu_ld” = yes; then sys_lib_search_path_spec=‘/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib’ else sys_lib_search_path_spec=‘/usr/ccs/lib /usr/lib’ case $host_os in sco3.2v5) sys_lib_search_path_spec=“$sys_lib_search_path_spec /lib” ;; esac fi sys_lib_dlsearch_path_spec=‘/usr/lib’ ;;

tpf*) # TPF is a cross-target only. Preferred cross-host = GNU/Linux. version_type=linux # correct to gnu/linux during the next big refactor need_lib_prefix=no need_version=no library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;;

uts4*) version_type=linux # correct to gnu/linux during the next big refactor library_names_spec=‘${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}’ soname_spec=‘${libname}${release}${shared_ext}$major’ shlibpath_var=LD_LIBRARY_PATH ;;

*) dynamic_linker=no ;; esac { $as_echo “$as_me:${as_lineno-$LINENO}: result: $dynamic_linker” >&5 $as_echo “$dynamic_linker” >&6; } test “$dynamic_linker” = no && can_build_shared=no

variables_saved_for_relink=“PATH $shlibpath_var $runpath_var” if test “$GCC” = yes; then variables_saved_for_relink=“$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH” fi

if test “${lt_cv_sys_lib_search_path_spec+set}” = set; then sys_lib_search_path_spec=“$lt_cv_sys_lib_search_path_spec” fi if test “${lt_cv_sys_lib_dlsearch_path_spec+set}” = set; then sys_lib_dlsearch_path_spec=“$lt_cv_sys_lib_dlsearch_path_spec” fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs” >&5 $as_echo_n “checking how to hardcode library paths into programs… ” >&6; } hardcode_action= if test -n “$hardcode_libdir_flag_spec” || test -n “$runpath_var” || test “X$hardcode_automatic” = “Xyes” ; then

# We can hardcode non-existent directories. if test “$hardcode_direct” != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one ## test “$_LT_TAGVAR(hardcode_shlibpath_var, )” != no && test “$hardcode_minus_L” != no; then # Linking always hardcodes the temporary library directory. hardcode_action=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. hardcode_action=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. hardcode_action=unsupported fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $hardcode_action” >&5 $as_echo “$hardcode_action” >&6; }

if test “$hardcode_action” = relink || test “$inherit_rpath” = yes; then # Fast installation is not supported enable_fast_install=no elif test “$shlibpath_overrides_runpath” = yes || test “$enable_shared” = no; then # Fast installation is not necessary enable_fast_install=needless fi

if test “x$enable_dlopen” != xyes; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown else lt_cv_dlopen=no lt_cv_dlopen_libs=

case $host_os in beos*) lt_cv_dlopen=“load_add_on” lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;;

mingw | pw32 | cegcc*) lt_cv_dlopen=“LoadLibrary” lt_cv_dlopen_libs= ;;

cygwin*) lt_cv_dlopen=“dlopen” lt_cv_dlopen_libs= ;;

darwin) # if libdl is installed we need to link against it { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl” >&5 $as_echo_n “checking for dlopen in -ldl… ” >&6; } if ${ac_cv_lib_dl_dlopen+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ldl $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_dl_dlopen=yes else ac_cv_lib_dl_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen” >&5 $as_echo “$ac_cv_lib_dl_dlopen” >&6; } if test “x$ac_cv_lib_dl_dlopen” = xyes; then : lt_cv_dlopen=“dlopen” lt_cv_dlopen_libs=“-ldl” else

lt_cv_dlopen="dyld"
lt_cv_dlopen_libs=
lt_cv_dlopen_self=yes

fi

;;

) ac_fn_c_check_func “$LINENO” “shl_load” “ac_cv_func_shl_load” if test “x$ac_cv_func_shl_load” = xyes; then : lt_cv_dlopen=“shl_load” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld” >&5 $as_echo_n “checking for shl_load in -ldld… ” >&6; } if ${ac_cv_lib_dld_shl_load+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ldld $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 shl_load (); int main () { return shl_load (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_dld_shl_load=yes else ac_cv_lib_dld_shl_load=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load” >&5 $as_echo “$ac_cv_lib_dld_shl_load” >&6; } if test “x$ac_cv_lib_dld_shl_load” = xyes; then : lt_cv_dlopen=“shl_load” lt_cv_dlopen_libs=“-ldld” else ac_fn_c_check_func “$LINENO” “dlopen” “ac_cv_func_dlopen” if test “x$ac_cv_func_dlopen” = xyes; then : lt_cv_dlopen=“dlopen” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl” >&5 $as_echo_n “checking for dlopen in -ldl… ” >&6; } if ${ac_cv_lib_dl_dlopen+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ldl $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dlopen (); int main () { return dlopen (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_dl_dlopen=yes else ac_cv_lib_dl_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen” >&5 $as_echo “$ac_cv_lib_dl_dlopen” >&6; } if test “x$ac_cv_lib_dl_dlopen” = xyes; then : lt_cv_dlopen=“dlopen” lt_cv_dlopen_libs=“-ldl” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld” >&5 $as_echo_n “checking for dlopen in -lsvld… ” >&6; } if ${ac_cv_lib_svld_dlopen+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lsvld $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dlopen (); int main () { return dlopen (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_svld_dlopen=yes else ac_cv_lib_svld_dlopen=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen” >&5 $as_echo “$ac_cv_lib_svld_dlopen” >&6; } if test “x$ac_cv_lib_svld_dlopen” = xyes; then : lt_cv_dlopen=“dlopen” lt_cv_dlopen_libs=“-lsvld” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld” >&5 $as_echo_n “checking for dld_link in -ldld… ” >&6; } if ${ac_cv_lib_dld_dld_link+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ldld $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dld_link (); int main () { return dld_link (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_dld_dld_link=yes else ac_cv_lib_dld_dld_link=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link” >&5 $as_echo “$ac_cv_lib_dld_dld_link” >&6; } if test “x$ac_cv_lib_dld_dld_link” = xyes; then : lt_cv_dlopen=“dld_link” lt_cv_dlopen_libs=“-ldld” fi

fi

fi

fi

fi

fi

;;

esac

if test “x$lt_cv_dlopen” != xno; then enable_dlopen=yes else enable_dlopen=no fi

case $lt_cv_dlopen in dlopen) save_CPPFLAGS=“$CPPFLAGS” test “x$ac_cv_header_dlfcn_h” = xyes && CPPFLAGS=“$CPPFLAGS -DHAVE_DLFCN_H”

save_LDFLAGS="$LDFLAGS"
wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

save_LIBS="$LIBS"
LIBS="$lt_cv_dlopen_libs $LIBS"

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5

$as_echo_n “checking whether a program can dlopen itself… ” >&6; } if ${lt_cv_dlopen_self+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : lt_cv_dlopen_self=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF

line $LINENO “configure”

include “confdefs.h”

if HAVE_DLFCN_H

include <dlfcn.h>

endif

include <stdio.h>

ifdef RTLD_GLOBAL

define LT_DLGLOBAL RTLD_GLOBAL

else

ifdef DL_GLOBAL

define LT_DLGLOBAL DL_GLOBAL

else

define LT_DLGLOBAL 0

endif

endif

/ We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. /

ifndef LT_DLLAZY_OR_NOW

ifdef RTLD_LAZY

define LT_DLLAZY_OR_NOW RTLD_LAZY

else

ifdef DL_LAZY

define LT_DLLAZY_OR_NOW DL_LAZY

else

ifdef RTLD_NOW

define LT_DLLAZY_OR_NOW RTLD_NOW

else

ifdef DL_NOW

define LT_DLLAZY_OR_NOW DL_NOW

else

define LT_DLLAZY_OR_NOW 0

endif

endif

endif

endif

endif

/ When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. /

if defined(GNUC) && (((GNUC == 3) && (GNUC_MINOR >= 3)) || (GNUC > 3))

int fnord () attribute((visibility(“default”)));

endif

int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown;

if (self) { if (dlsym (self,“fnord”)) status = $lt_dlno_uscore; else { if (dlsym( self,“_fnord”)) status = $lt_dlneed_uscore; else puts (dlerror ()); } / dlclose (self); / } else puts (dlerror ());

return status; } _LT_EOF if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_link\“”; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; x$lt_dlunknown|x) lt_cv_dlopen_self=no ;; esac else : # compilation failed lt_cv_dlopen_self=no fi fi rm -fr conftest

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self” >&5 $as_echo “$lt_cv_dlopen_self” >&6; }

if test "x$lt_cv_dlopen_self" = xyes; then
  wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5

$as_echo_n “checking whether a statically linked program can dlopen itself… ” >&6; } if ${lt_cv_dlopen_self_static+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : lt_cv_dlopen_self_static=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF

line $LINENO “configure”

include “confdefs.h”

if HAVE_DLFCN_H

include <dlfcn.h>

endif

include <stdio.h>

ifdef RTLD_GLOBAL

define LT_DLGLOBAL RTLD_GLOBAL

else

ifdef DL_GLOBAL

define LT_DLGLOBAL DL_GLOBAL

else

define LT_DLGLOBAL 0

endif

endif

/ We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. /

ifndef LT_DLLAZY_OR_NOW

ifdef RTLD_LAZY

define LT_DLLAZY_OR_NOW RTLD_LAZY

else

ifdef DL_LAZY

define LT_DLLAZY_OR_NOW DL_LAZY

else

ifdef RTLD_NOW

define LT_DLLAZY_OR_NOW RTLD_NOW

else

ifdef DL_NOW

define LT_DLLAZY_OR_NOW DL_NOW

else

define LT_DLLAZY_OR_NOW 0

endif

endif

endif

endif

endif

/ When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. /

if defined(GNUC) && (((GNUC == 3) && (GNUC_MINOR >= 3)) || (GNUC > 3))

int fnord () attribute((visibility(“default”)));

endif

int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown;

if (self) { if (dlsym (self,“fnord”)) status = $lt_dlno_uscore; else { if (dlsym( self,“_fnord”)) status = $lt_dlneed_uscore; else puts (dlerror ()); } / dlclose (self); / } else puts (dlerror ());

return status; } _LT_EOF if { { eval echo “\”\$as_me\“:${as_lineno-$LINENO}: \”$ac_link\“”; } >&5 (eval $ac_link) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; x$lt_dlunknown|x) lt_cv_dlopen_self_static=no ;; esac else : # compilation failed lt_cv_dlopen_self_static=no fi fi rm -fr conftest

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static” >&5 $as_echo “$lt_cv_dlopen_self_static” >&6; } fi

CPPFLAGS="$save_CPPFLAGS"
LDFLAGS="$save_LDFLAGS"
LIBS="$save_LIBS"
;;

esac

case $lt_cv_dlopen_self in yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; *) enable_dlopen_self=unknown ;; esac

case $lt_cv_dlopen_self_static in yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; *) enable_dlopen_self_static=unknown ;; esac fi

striplib= old_striplib= { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible” >&5 $as_echo_n “checking whether stripping libraries is possible… ” >&6; } if test -n “$STRIP” && $STRIP -V 2>&1 | $GREP “GNU strip” >/dev/null; then test -z “$old_striplib” && old_striplib=“$STRIP –strip-debug” test -z “$striplib” && striplib=“$STRIP –strip-unneeded” { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } else

FIXME - insert some real tests, host_os isn’t really good enough

case $host_os in darwin) if test -n “$STRIP” ; then striplib=“$STRIP -x” old_striplib=“$STRIP -S” { $as_echo “$as_me:${as_lineno-$LINENO}: result: yes” >&5 $as_echo “yes” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi ;; ) { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } ;; esac fi

# Report which library types will actually be built { $as_echo “$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries” >&5 $as_echo_n “checking if libtool supports shared libraries… ” >&6; } { $as_echo “$as_me:${as_lineno-$LINENO}: result: $can_build_shared” >&5 $as_echo “$can_build_shared” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries” >&5 $as_echo_n “checking whether to build shared libraries… ” >&6; } test “$can_build_shared” = “no” && enable_shared=no

# On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test “$enable_shared” = yes && enable_static=no if test -n “$RANLIB”; then archive_cmds=“$archive_cmds~\$RANLIB \$lib” postinstall_cmds=‘$RANLIB $lib’ fi ;;

aix[4-9]*) if test “$host_cpu” != ia64 && test “$aix_use_runtimelinking” = no ; then test “$enable_shared” = yes && enable_static=no fi ;; esac { $as_echo “$as_me:${as_lineno-$LINENO}: result: $enable_shared” >&5 $as_echo “$enable_shared” >&6; }

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether to build static libraries” >&5 $as_echo_n “checking whether to build static libraries… ” >&6; } # Make sure either enable_shared or enable_static is yes. test “$enable_shared” = yes || enable_static=yes { $as_echo “$as_me:${as_lineno-$LINENO}: result: $enable_static” >&5 $as_echo “$enable_static” >&6; }

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

CC=“$lt_save_CC”

    ac_config_commands="$ac_config_commands libtool"

Only expand once:

case ${host_os} in # end temporary renaming of “linux-gnu” to “linux” linux-gnu ) host_os=linux ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: EXTRA OPTION PROCESSING ” >&5 $as_echo “$as_me: EXTRA OPTION PROCESSING ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking additional preprocessor flags” >&5 $as_echo_n “checking additional preprocessor flags… ” >&6; } if ${ac_cv_os_cppflags+:} false; then : $as_echo_n “(cached) ” >&6 else

case “${host_os}” in

off for now, posix may be a broken thing for nextstep3…

nextstep* )

ac_cv_os_cppflags=“-D_POSIX_SOURCE”

;;

* ) ac_cv_os_cppflags="" ;;

esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_cppflags” >&5 $as_echo “$ac_cv_os_cppflags” >&6; } CPPFLAGS=“$CPPFLAGS $ac_cv_os_cppflags”

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking additional compiler flags” >&5 $as_echo_n “checking additional compiler flags… ” >&6; } if ${ac_cv_os_cflags+:} false; then : $as_echo_n “(cached) ” >&6 else

case “${host_os}” in irix6 ) case “${CC}” in cc ) # do not use 64-bit compiler ac_cv_os_cflags=“-n32 -mips3 -Wl,-woff,84” ;; esac ;; osf[1-3] ) # get the right version of struct sockaddr case “${CC}” in cc ) ac_cv_os_cflags=“-std -D_SOCKADDR_LEN -D_NO_PROTO” ;; * ) ac_cv_os_cflags=“-D_SOCKADDR_LEN -D_NO_PROTO” ;; esac ;; osf ) # get the right version of struct sockaddr case “${CC}” in cc ) ac_cv_os_cflags=“-std -D_SOCKADDR_LEN” ;; * ) ac_cv_os_cflags=“-D_SOCKADDR_LEN” ;; esac ;; aix[1-3] ) ac_cv_os_cflags=“” ;; aix4.[0-2] ) # turn on additional headers ac_cv_os_cflags=“-D_XOPEN_EXTENDED_SOURCE” ;; aix5.3 ) # avoid circular dependencies in yp headers, and more ac_cv_os_cflags=“-DHAVE_BAD_HEADERS -D_XOPEN_EXTENDED_SOURCE -D_USE_IRS -D_MSGQSUPPORT” ;; aix ) # avoid circular dependencies in yp headers ac_cv_os_cflags=“-DHAVE_BAD_HEADERS -D_XOPEN_EXTENDED_SOURCE -D_USE_IRS” ;; OFF-sunos4 ) # make sure passing whole structures is handled in gcc case “${CC}” in gcc ) ac_cv_os_cflags=“-fpcc-struct-return” ;; esac ;; sunos[34] | solaris1 | solaris2.[0-5] | sunos5.[0-5] | solaris2.5. | sunos5.5. ) ac_cv_os_cflags=“” ;; solaris2 | sunos5 ) # turn on 64-bit file offset interface case “${CC}” in * ) ac_cv_os_cflags=“-D_LARGEFILE64_SOURCE” ;; esac ;; hpux ) # use Ansi compiler on HPUX case “${CC}” in cc ) ac_cv_os_cflags=“-Ae” ;; esac ;; darwin | macosx | rhapsody ) ac_cv_os_cflags=“-D_P1003_1B_VISIBLE” ;; * ) ac_cv_os_cflags=“” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_cflags” >&5 $as_echo “$ac_cv_os_cflags” >&6; } AMU_CFLAGS=“$AMU_CFLAGS $ac_cv_os_cflags”

use same flags for configuring, so it matches what we do at compile time

CFLAGS=“$CFLAGS $ac_cv_os_cflags” export CFLAGS

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking additional linker flags” >&5 $as_echo_n “checking additional linker flags… ” >&6; } if ${ac_cv_os_ldflags+:} false; then : $as_echo_n “(cached) ” >&6 else

case “${host_os}” in solaris2.7 | sunos5.7 ) # find LDAP: off until Sun includes ldap headers. case “${CC}” in * ) #ac_cv_os_ldflags=“-L/usr/lib/fn” ;; esac ;; * ) ac_cv_os_ldflags=“” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_ldflags” >&5 $as_echo “$ac_cv_os_ldflags” >&6; } LDFLAGS=“$LDFLAGS $ac_cv_os_ldflags”

{ $as_echo “$as_me:${as_lineno-$LINENO}: UNIX VARIANTS ” >&5 $as_echo “$as_me: UNIX VARIANTS ” >&6;}

test sanity of running kernel vs. kernel headers

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking \"host headers version\”“ >&5 $as_echo_n "checking \"host headers version\”… “ >&6; } case ${host_os} in linux ) host_header_version="bad”

value=“notfound” if test “$cross_compiling” = yes; then : value=“notfound” else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <stdio.h>

include <linux/version.h>

main(argc) int argc; {

if (argc > 1)

ifdef UTS_RELEASE

printf(“%s”, UTS_RELEASE);

else

define AMU_MA(a) ((a) >> 16)

define AMU_MI(a) (((a) & 0xffff) >> 8)

define AMU_PL(a) ((a) & 0xff)

printf(“%d.%d.%d”, AMU_MA(LINUX_VERSION_CODE), AMU_MI(LINUX_VERSION_CODE), AMU_PL(LINUX_VERSION_CODE));

endif

exit(0); } _ACEOF if ac_fn_c_try_run “$LINENO”; then :

value=./conftest dummy 2>>config.log test -z “$value” && value=“notfound”

else value=“notfound” fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

if test “$value” = notfound then : echo as_fn_error $? “cannot find UTS_RELEASE in <linux/version.h>. This Linux system may be misconfigured or unconfigured!” “$LINENO” 5

else : host_header_version=$value fi

;;
* ) host_header_version=$host_os_version ;;

esac cat >>confdefs.h <<_ACEOF

define HOST_HEADER_VERSION “$host_header_version”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: result: $host_header_version” >&5 $as_echo “$host_header_version” >&6; }

case ${host_os} in linux ) if test “$host_os_version” != $host_header_version then { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: Linux kernel $host_os_version mismatch with $host_header_version headers!” >&5 $as_echo “$as_me: WARNING: Linux kernel $host_os_version mismatch with $host_header_version headers!” >&2;} fi ;; esac ac_cv_os_version=$host_os_version ac_cv_header_version=$host_header_version

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR PROGRAMS (part 2) ” >&5 $as_echo “$as_me: PARTICULAR PROGRAMS (part 2) ” >&6;}

for ac_prog in ‘bison -y’ byacc yacc do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_YACC+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$YACC”; then ac_cv_prog_YACC=“$YACC” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_YACC=“$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi YACC=$ac_cv_prog_YACC if test -n “$YACC”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $YACC” >&5 $as_echo “$YACC” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$YACC” && break done test -n “$YACC” || YACC=“:”

if test “x$YACC” = “x:”; then as_fn_error $? “cannot find bison/yacc/byacc – needed for am-utils” “$LINENO” 5 fi for ac_prog in flex lex do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_LEX+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$LEX”; then ac_cv_prog_LEX=“$LEX” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_LEX=“$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi LEX=$ac_cv_prog_LEX if test -n “$LEX”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $LEX” >&5 $as_echo “$LEX” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$LEX” && break done test -n “$LEX” || LEX=“:”

if test -z “$LEXLIB” then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for yywrap in -lfl” >&5 $as_echo_n “checking for yywrap in -lfl… ” >&6; } if ${ac_cv_lib_fl_yywrap+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lfl $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 yywrap (); int main () { return yywrap (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_fl_yywrap=yes else ac_cv_lib_fl_yywrap=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fl_yywrap” >&5 $as_echo “$ac_cv_lib_fl_yywrap” >&6; } if test “x$ac_cv_lib_fl_yywrap” = xyes; then : LEXLIB=“-lfl” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for yywrap in -ll” >&5 $as_echo_n “checking for yywrap in -ll… ” >&6; } if ${ac_cv_lib_l_yywrap+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ll $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 yywrap (); int main () { return yywrap (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_l_yywrap=yes else ac_cv_lib_l_yywrap=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_l_yywrap” >&5 $as_echo “$ac_cv_lib_l_yywrap” >&6; } if test “x$ac_cv_lib_l_yywrap” = xyes; then : LEXLIB=“-ll” fi

fi

fi

if test “x$LEX” != “x:”; then cat >conftest.l <<_ACEOF %% a { ECHO; } b { REJECT; } c { yymore (); } d { yyless (1); } e { / IRIX 6.5 flex 2.5.4 underquotes its yyless argument. / yyless ((input () != 0)); } f { unput (yytext[0]); } . { BEGIN INITIAL; } %%

ifdef YYTEXT_POINTER

extern char *yytext;

endif

int main (void) { return ! yylex () + ! yywrap (); } _ACEOF { { ac_try=“$LEX conftest.l” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$LEX conftest.l”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } { $as_echo “$as_me:${as_lineno-$LINENO}: checking lex output file root” >&5 $as_echo_n “checking lex output file root… ” >&6; } if ${ac_cv_prog_lex_root+:} false; then : $as_echo_n “(cached) ” >&6 else

if test -f lex.yy.c; then ac_cv_prog_lex_root=lex.yy elif test -f lexyy.c; then ac_cv_prog_lex_root=lexyy else as_fn_error $? “cannot find output from $LEX; giving up” “$LINENO” 5 fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root” >&5 $as_echo “$ac_cv_prog_lex_root” >&6; } LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root

if test -z “${LEXLIB+set}”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking lex library” >&5 $as_echo_n “checking lex library… ” >&6; } if ${ac_cv_lib_lex+:} false; then : $as_echo_n “(cached) ” >&6 else

ac_save_LIBS=$LIBS
ac_cv_lib_lex='none needed'
for ac_lib in '' -lfl -ll; do
  LIBS="$ac_lib $ac_save_LIBS"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext

/ end confdefs.h. / cat $LEX_OUTPUT_ROOT.c _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_lex=$ac_lib fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext test “$ac_cv_lib_lex” != ‘none needed’ && break done LIBS=$ac_save_LIBS

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex” >&5 $as_echo “$ac_cv_lib_lex” >&6; } test “$ac_cv_lib_lex” != ‘none needed’ && LEXLIB=$ac_cv_lib_lex fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer” >&5 $as_echo_n “checking whether yytext is a pointer… ” >&6; } if ${ac_cv_prog_lex_yytext_pointer+:} false; then : $as_echo_n “(cached) ” >&6 else # POSIX says lex can declare yytext either as a pointer or an array; the

default is implementation-dependent. Figure out which it is, since

not all implementations provide the %pointer and %array declarations.

ac_cv_prog_lex_yytext_pointer=no ac_save_LIBS=$LIBS LIBS=“$LEXLIB $ac_save_LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

#define YYTEXT_POINTER 1 cat $LEX_OUTPUT_ROOT.c _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_prog_lex_yytext_pointer=yes fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_save_LIBS

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer” >&5 $as_echo “$ac_cv_prog_lex_yytext_pointer” >&6; } if test $ac_cv_prog_lex_yytext_pointer = yes; then

$as_echo “#define YYTEXT_POINTER 1” >>confdefs.h

fi rm -f conftest.l $LEX_OUTPUT_ROOT.c

else as_fn_error $? “cannot find flex/lex – needed for am-utils” “$LINENO” 5 fi if test 0 != 0 ; then for ac_prog in flex lex do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_prog_LEX+:} false; then : $as_echo_n “(cached) ” >&6 else if test -n “$LEX”; then ac_cv_prog_LEX=“$LEX” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_prog_LEX=“$ac_prog” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

fi fi LEX=$ac_cv_prog_LEX if test -n “$LEX”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $LEX” >&5 $as_echo “$LEX” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$LEX” && break done test -n “$LEX” || LEX=“:”

if test “x$LEX” != “x:”; then cat >conftest.l <<_ACEOF %% a { ECHO; } b { REJECT; } c { yymore (); } d { yyless (1); } e { / IRIX 6.5 flex 2.5.4 underquotes its yyless argument. / yyless ((input () != 0)); } f { unput (yytext[0]); } . { BEGIN INITIAL; } %%

ifdef YYTEXT_POINTER

extern char *yytext;

endif

int main (void) { return ! yylex () + ! yywrap (); } _ACEOF { { ac_try=“$LEX conftest.l” case “(($ac_try” in \“ | ` | \) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo=”\“\$as_me:${as_lineno-$LINENO}: $ac_try_echo\”“ $as_echo ”$ac_try_echo"; } >&5 (eval “$LEX conftest.l”) 2>&5 ac_status=$? $as_echo “$as_me:${as_lineno-$LINENO}: \$? = $ac_status” >&5 test $ac_status = 0; } { $as_echo “$as_me:${as_lineno-$LINENO}: checking lex output file root” >&5 $as_echo_n “checking lex output file root… ” >&6; } if ${ac_cv_prog_lex_root+:} false; then : $as_echo_n “(cached) ” >&6 else

if test -f lex.yy.c; then ac_cv_prog_lex_root=lex.yy elif test -f lexyy.c; then ac_cv_prog_lex_root=lexyy else as_fn_error $? “cannot find output from $LEX; giving up” “$LINENO” 5 fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_root” >&5 $as_echo “$ac_cv_prog_lex_root” >&6; } LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root

if test -z “${LEXLIB+set}”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking lex library” >&5 $as_echo_n “checking lex library… ” >&6; } if ${ac_cv_lib_lex+:} false; then : $as_echo_n “(cached) ” >&6 else

ac_save_LIBS=$LIBS
ac_cv_lib_lex='none needed'
for ac_lib in '' -lfl -ll; do
  LIBS="$ac_lib $ac_save_LIBS"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext

/ end confdefs.h. / cat $LEX_OUTPUT_ROOT.c _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_lex=$ac_lib fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext test “$ac_cv_lib_lex” != ‘none needed’ && break done LIBS=$ac_save_LIBS

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lex” >&5 $as_echo “$ac_cv_lib_lex” >&6; } test “$ac_cv_lib_lex” != ‘none needed’ && LEXLIB=$ac_cv_lib_lex fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether yytext is a pointer” >&5 $as_echo_n “checking whether yytext is a pointer… ” >&6; } if ${ac_cv_prog_lex_yytext_pointer+:} false; then : $as_echo_n “(cached) ” >&6 else # POSIX says lex can declare yytext either as a pointer or an array; the

default is implementation-dependent. Figure out which it is, since

not all implementations provide the %pointer and %array declarations.

ac_cv_prog_lex_yytext_pointer=no ac_save_LIBS=$LIBS LIBS=“$LEXLIB $ac_save_LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

#define YYTEXT_POINTER 1 cat $LEX_OUTPUT_ROOT.c _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_prog_lex_yytext_pointer=yes fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_save_LIBS

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_lex_yytext_pointer” >&5 $as_echo “$ac_cv_prog_lex_yytext_pointer” >&6; } if test $ac_cv_prog_lex_yytext_pointer = yes; then

$as_echo “#define YYTEXT_POINTER 1” >>confdefs.h

fi rm -f conftest.l $LEX_OUTPUT_ROOT.c

fi if test “$LEX” = :; then LEX=${am_missing_run}flex fi fi

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

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

test -n “$AR” && break done test -n “$AR” || AR=“:”

for ac_prog in perl5 perl4 perl do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_path_PERL+:} false; then : $as_echo_n “(cached) ” >&6 else case $PERL in [\/] | ?:[\/]) ac_cv_path_PERL=“$PERL” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_path_PERL=“$as_dir/$ac_word$ac_exec_ext” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi PERL=$ac_cv_path_PERL if test -n “$PERL”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $PERL” >&5 $as_echo “$PERL” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$PERL” && break done test -n “$PERL” || PERL=“/usr/bin/perl”

for ac_prog in umount unmount do # Extract the first word of “$ac_prog”, so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_word” >&5 $as_echo_n “checking for $ac_word… ” >&6; } if ${ac_cv_path_UNMOUNT_PROGRAM+:} false; then : $as_echo_n “(cached) ” >&6 else case $UNMOUNT_PROGRAM in [\/] | ?:[\/]) ac_cv_path_UNMOUNT_PROGRAM=“$UNMOUNT_PROGRAM” # 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 as_fn_executable_p “$as_dir/$ac_word$ac_exec_ext”; then ac_cv_path_UNMOUNT_PROGRAM=“$as_dir/$ac_word$ac_exec_ext” $as_echo “$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext” >&5 break 2 fi done done IFS=$as_save_IFS

;; esac fi UNMOUNT_PROGRAM=$ac_cv_path_UNMOUNT_PROGRAM if test -n “$UNMOUNT_PROGRAM”; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: $UNMOUNT_PROGRAM” >&5 $as_echo “$UNMOUNT_PROGRAM” >&6; } else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

test -n “$UNMOUNT_PROGRAM” && break done test -n “$UNMOUNT_PROGRAM” || UNMOUNT_PROGRAM=“/bin/umount”

{ $as_echo “$as_me:${as_lineno-$LINENO}: LIBRARY FILES ” >&5 $as_echo “$as_me: LIBRARY FILES ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for additional OS libraries” >&5 $as_echo_n “checking for additional OS libraries… ” >&6; } if ${ac_cv_os_libs+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct set of libraries to link with

case “${host_os_name}” in svr4 | sysv4 | solaris2 | sunos5 | aoi* ) ac_cv_os_libs=“-lsocket -lnsl” ;; * ) ac_cv_os_libs=none ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_os_libs” >&5 $as_echo “$ac_cv_os_libs” >&6; }

set list of libraries to link with

if test “$ac_cv_os_libs” != none then LIBS=“$ac_cv_os_libs $LIBS” fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for clnt_sperrno in -lrpc” >&5 $as_echo_n “checking for clnt_sperrno in -lrpc… ” >&6; } if ${ac_cv_lib_rpc_clnt_sperrno+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lrpc $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 clnt_sperrno (); int main () { return clnt_sperrno (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_rpc_clnt_sperrno=yes else ac_cv_lib_rpc_clnt_sperrno=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rpc_clnt_sperrno” >&5 $as_echo “$ac_cv_lib_rpc_clnt_sperrno” >&6; } if test “x$ac_cv_lib_rpc_clnt_sperrno” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBRPC 1

_ACEOF

LIBS=“-lrpc $LIBS”

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for xdr_fhandle in -lrpcsvc” >&5 $as_echo_n “checking for xdr_fhandle in -lrpcsvc… ” >&6; } if ${ac_cv_lib_rpcsvc_xdr_fhandle+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lrpcsvc $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 xdr_fhandle (); int main () { return xdr_fhandle (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_rpcsvc_xdr_fhandle=yes else ac_cv_lib_rpcsvc_xdr_fhandle=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rpcsvc_xdr_fhandle” >&5 $as_echo “$ac_cv_lib_rpcsvc_xdr_fhandle” >&6; } if test “x$ac_cv_lib_rpcsvc_xdr_fhandle” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBRPCSVC 1

_ACEOF

LIBS=“-lrpcsvc $LIBS”

fi

ac_fn_c_check_func “$LINENO” “hstrerror” “ac_cv_func_hstrerror” if test “x$ac_cv_func_hstrerror” = xyes; then :

else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for hstrerror in -lresolv” >&5 $as_echo_n “checking for hstrerror in -lresolv… ” >&6; } if ${ac_cv_lib_resolv_hstrerror+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lresolv $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 hstrerror (); int main () { return hstrerror (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_resolv_hstrerror=yes else ac_cv_lib_resolv_hstrerror=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_resolv_hstrerror” >&5 $as_echo “$ac_cv_lib_resolv_hstrerror” >&6; } if test “x$ac_cv_lib_resolv_hstrerror” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBRESOLV 1

_ACEOF

LIBS=“-lresolv $LIBS”

fi

fi

ac_fn_c_check_func “$LINENO” “yp_all” “ac_cv_func_yp_all” if test “x$ac_cv_func_yp_all” = xyes; then :

else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for yp_all in -lnsl” >&5 $as_echo_n “checking for yp_all in -lnsl… ” >&6; } if ${ac_cv_lib_nsl_yp_all+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lnsl $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 yp_all (); int main () { return yp_all (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_nsl_yp_all=yes else ac_cv_lib_nsl_yp_all=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_yp_all” >&5 $as_echo “$ac_cv_lib_nsl_yp_all” >&6; } if test “x$ac_cv_lib_nsl_yp_all” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBNSL 1

_ACEOF

LIBS=“-lnsl $LIBS”

fi

fi

if test “$with_hesiod” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for hes_init in -lhesiod” >&5 $as_echo_n “checking for hes_init in -lhesiod… ” >&6; } ac_lib_var=echo hesiod'_'hes_init | sed 'y%./+-%__p_%' if eval \${ac_cv_lib_$ac_lib_var+:} false; then : $as_echo_n “(cached) ” >&6 else ac_save_LIBS=“$LIBS”

first try with base library, without auxiliary library

LIBS=“-lhesiod $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Override any gcc2 internal prototype to avoid an error. /

/ We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. / char hes_init();

int main () { hes_init() ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : eval “ac_cv_lib$ac_lib_var=\"hesiod\”“ else eval "ac_cv_lib_$ac_lib_var=no” fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext

if OK, set to no auxiliary library, else try auxiliary library

if eval “test \”echo '$ac_cv_lib_'$ac_lib_var\“ = no”; then LIBS=“-lhesiod -lresolv $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Override any gcc2 internal prototype to avoid an error. /

/ We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. / char hes_init();

int main () { hes_init() ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : eval “ac_cv_lib$ac_lib_var=\"hesiod -lresolv\”“ else eval "ac_cv_lib_$ac_lib_var=no” fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi

LIBS=“$ac_save_LIBS”

fi ac_tmp=“eval echo '$''{ac_cv_lib_'$ac_lib_var'}'” if test “${ac_tmp}” != no; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: -l$ac_tmp” >&5 $as_echo “-l$ac_tmp” >&6; }

ac_tr_lib=HAVE_LIBecho hesiod | sed -e 's/[^a-zA-Z0-9_]/_/g' \ -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'

cat >>confdefs.h <<_ACEOF

define $ac_tr_lib 1

_ACEOF

LIBS=“-l$ac_tmp $LIBS”

else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

fi if test “$with_ldap” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for ldap_open in -lldap” >&5 $as_echo_n “checking for ldap_open in -lldap… ” >&6; } ac_lib_var=echo ldap'_'ldap_open | sed 'y%./+-%__p_%' if eval \${ac_cv_lib_$ac_lib_var+:} false; then : $as_echo_n “(cached) ” >&6 else ac_save_LIBS=“$LIBS”

first try with base library, without auxiliary library

LIBS=“-lldap $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Override any gcc2 internal prototype to avoid an error. /

/ We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. / char ldap_open();

int main () { ldap_open() ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : eval “ac_cv_lib$ac_lib_var=\"ldap\”“ else eval "ac_cv_lib_$ac_lib_var=no” fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext

if OK, set to no auxiliary library, else try auxiliary library

if eval “test \”echo '$ac_cv_lib_'$ac_lib_var\“ = no”; then LIBS=“-lldap -llber $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Override any gcc2 internal prototype to avoid an error. /

/ We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. / char ldap_open();

int main () { ldap_open() ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : eval “ac_cv_lib$ac_lib_var=\"ldap -llber\”“ else eval "ac_cv_lib_$ac_lib_var=no” fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi

LIBS=“$ac_save_LIBS”

fi ac_tmp=“eval echo '$''{ac_cv_lib_'$ac_lib_var'}'” if test “${ac_tmp}” != no; then { $as_echo “$as_me:${as_lineno-$LINENO}: result: -l$ac_tmp” >&5 $as_echo “-l$ac_tmp” >&6; }

ac_tr_lib=HAVE_LIBecho ldap | sed -e 's/[^a-zA-Z0-9_]/_/g' \ -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'

cat >>confdefs.h <<_ACEOF

define $ac_tr_lib 1

_ACEOF

LIBS=“-l$ac_tmp $LIBS”

else { $as_echo “$as_me:${as_lineno-$LINENO}: result: no” >&5 $as_echo “no” >&6; } fi

for ac_func in ldap_enable_cache do : ac_fn_c_check_func “$LINENO” “ldap_enable_cache” “ac_cv_func_ldap_enable_cache” if test “x$ac_cv_func_ldap_enable_cache” = xyes; then : cat >>confdefs.h <<_ACEOF

define HAVE_LDAP_ENABLE_CACHE 1

_ACEOF

fi done

fi

case “$ac_cv_opt_debug” in yes | mem ) { $as_echo “$as_me:${as_lineno-$LINENO}: checking for clock_gettime in -lrt” >&5 $as_echo_n “checking for clock_gettime in -lrt… ” >&6; } if ${ac_cv_lib_rt_clock_gettime+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lrt $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 clock_gettime (); int main () { return clock_gettime (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_rt_clock_gettime=yes else ac_cv_lib_rt_clock_gettime=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_clock_gettime” >&5 $as_echo “$ac_cv_lib_rt_clock_gettime” >&6; } if test “x$ac_cv_lib_rt_clock_gettime” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBRT 1

_ACEOF

LIBS=“-lrt $LIBS”

else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for clock_gettime in -lposix4” >&5 $as_echo_n “checking for clock_gettime in -lposix4… ” >&6; } if ${ac_cv_lib_posix4_clock_gettime+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lposix4 $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 clock_gettime (); int main () { return clock_gettime (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_posix4_clock_gettime=yes else ac_cv_lib_posix4_clock_gettime=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_clock_gettime” >&5 $as_echo “$ac_cv_lib_posix4_clock_gettime” >&6; } if test “x$ac_cv_lib_posix4_clock_gettime” = xyes; then : cat >>confdefs.h <<ACEOF

define HAVE_LIBPOSIX4 1

_ACEOF

LIBS=“-lposix4 $LIBS”

fi

fi

 ;;

esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR LIBRARY FUNCTIONS ” >&5 $as_echo “$as_me: PARTICULAR LIBRARY FUNCTIONS ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for working memcmp” >&5 $as_echo_n “checking for working memcmp… ” >&6; } if ${ac_cv_func_memcmp_working+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : ac_cv_func_memcmp_working=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default int main () {

/ Some versions of memcmp are not 8-bit clean. / char c0 = ‘\100’, c1 = ‘\200’, c2 = ‘\201’; if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0) return 1;

/ The Next x86 OpenStep bug shows up only when comparing 16 bytes or more and with at least one buffer not starting on a 4-byte boundary. William Lewis provided this test program. / { char foo[21]; char bar[21]; int i; for (i = 0; i < 4; i++) { char a = foo + i; char b = bar + i; strcpy (a, “——–01111111”); strcpy (b, “——–10000000”); if (memcmp (a, b, 16) >= 0) return 1; } return 0; }

; return 0; } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_memcmp_working=yes else ac_cv_func_memcmp_working=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_memcmp_working” >&5 $as_echo “$ac_cv_func_memcmp_working” >&6; } test $ac_cv_func_memcmp_working = no && case “ $LIBOBJS ” in “ memcmp.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS memcmp.$ac_objext” ;; esac

if test “$ac_cv_func_memcmp_working” = no then $as_echo “#define HAVE_BAD_MEMCMP 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for a file-descriptor leakage clean yp_all” >&5 $as_echo_n “checking for a file-descriptor leakage clean yp_all… ” >&6; } if ${ac_cv_func_yp_all_clean+:} false; then : $as_echo_n “(cached) ” >&6 else

clean by default

ac_cv_func_yp_all_clean=yes

select the correct type

case “${host_os_name}” in irix ) ac_cv_func_yp_all_clean=no ;; linux ) # RedHat 5.1 systems with glibc glibc-2.0.7-19 or below # leak a UDP socket from yp_all() case “cat /etc/redhat-release /dev/null 2>/dev/null” in 5.1 ) ac_cv_func_yp_all_clean=no ;; esac esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_yp_all_clean” >&5 $as_echo “$ac_cv_func_yp_all_clean” >&6; } if test $ac_cv_func_yp_all_clean = no then $as_echo “#define HAVE_BAD_YP_ALL 1” >>confdefs.h

fi

ac_fn_c_check_type “$LINENO” “pid_t” “ac_cv_type_pid_t” “$ac_includes_default” if test “x$ac_cv_type_pid_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define pid_t int

_ACEOF

fi

for ac_header in vfork.h do : ac_fn_c_check_header_mongrel “$LINENO” “vfork.h” “ac_cv_header_vfork_h” “$ac_includes_default” if test “x$ac_cv_header_vfork_h” = xyes; then : cat >>confdefs.h <<_ACEOF

define HAVE_VFORK_H 1

_ACEOF

fi

done

for ac_func in fork vfork do : as_ac_var=$as_echo "ac_cv_func_$ac_func" | $as_tr_sh ac_fn_c_check_func “$LINENO” “$ac_func” “$as_ac_var” if eval test \“x\$”$as_ac_var"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

if test “x$ac_cv_func_fork” = xyes; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for working fork” >&5 $as_echo_n “checking for working fork… ” >&6; } if ${ac_cv_func_fork_works+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : ac_cv_func_fork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default int main () {

  /* By Ruediger Kuhlmann. */
  return fork () < 0;

; return 0; } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_fork_works=yes else ac_cv_func_fork_works=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works” >&5 $as_echo “$ac_cv_func_fork_works” >&6; }

else ac_cv_func_fork_works=$ac_cv_func_fork fi if test “x$ac_cv_func_fork_works” = xcross; then case $host in --amigaos | --msdosdjgpp) # Override, as these systems have only a dummy fork() stub ac_cv_func_fork_works=no ;; ) ac_cv_func_fork_works=yes ;; esac { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation” >&5 $as_echo “$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation” >&2;} fi ac_cv_func_vfork_works=$ac_cv_func_vfork if test “x$ac_cv_func_vfork” = xyes; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for working vfork” >&5 $as_echo_n “checking for working vfork… ” >&6; } if ${ac_cv_func_vfork_works+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : ac_cv_func_vfork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Thanks to Paul Eggert for this test. */ $ac_includes_default

include <sys/wait.h>

ifdef HAVE_VFORK_H

include <vfork.h>

endif

/ On some sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include <vfork.h>, but some compilers (e.g. gcc -O) don’t grok <vfork.h>. Test for this by using a static variable whose address is put into a register that is clobbered by the vfork. / static void

ifdef __cplusplus

sparc_address_test (int arg)

else

sparc_address_test (arg) int arg;

endif

{ static pid_t child; if (!child) { child = vfork (); if (child < 0) { perror (“vfork”); exit(2); } if (!child) { arg = getpid(); write(-1, “”, 0); exit (arg); } } }

int main () { pid_t parent = getpid (); pid_t child;

sparc_address_test (0);

child = vfork ();

if (child == 0) { / Here is another test for sparc vfork register problems. This test uses lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can’t possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. / pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); / Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. / if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1);

/* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent
   from child file descriptors.  If the child closes a descriptor
   before it execs or exits, this munges the parent's descriptor
   as well.  Test for this by closing stdout in the child.  */
_exit(close(fileno(stdout)) != 0);

} else { int status; struct stat st;

while (wait(&status) != child)
  ;
return (
 /* Was there some problem with vforking?  */
 child < 0

 /* Did the child fail?  (This shouldn't happen.)  */
 || status

 /* Did the vfork/compiler bug occur?  */
 || parent != getpid()

 /* Did the file descriptor bug occur?  */
 || fstat(fileno(stdout), &st) != 0
 );

} } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_vfork_works=yes else ac_cv_func_vfork_works=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works” >&5 $as_echo “$ac_cv_func_vfork_works” >&6; }

fi; if test “x$ac_cv_func_fork_works” = xcross; then ac_cv_func_vfork_works=$ac_cv_func_vfork { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation” >&5 $as_echo “$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation” >&2;} fi

if test “x$ac_cv_func_vfork_works” = xyes; then

$as_echo “#define HAVE_WORKING_VFORK 1” >>confdefs.h

else

$as_echo “#define vfork fork” >>confdefs.h

fi if test “x$ac_cv_func_fork_works” = xyes; then

$as_echo “#define HAVE_WORKING_FORK 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for wait3 that fills in rusage” >&5 $as_echo_n “checking for wait3 that fills in rusage… ” >&6; } if ${ac_cv_func_wait3_rusage+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : ac_cv_func_wait3_rusage=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default

include <sys/time.h>

include <sys/resource.h>

include <sys/wait.h>

/ HP-UX has wait3 but does not fill in rusage at all. / int main () { struct rusage r; int i; / Use a field that we can force nonzero – voluntary context switches. For systems like NeXT and OSF/1 that don’t set it, also use the system CPU time. And page faults (I/O) for Linux. / r.ru_nvcsw = 0; r.ru_stime.tv_sec = 0; r.ru_stime.tv_usec = 0; r.ru_majflt = r.ru_minflt = 0; switch (fork ()) { case 0: / Child. / sleep(1); / Give up the CPU. / exit(0); break; case -1: / What can we do? / exit(0); break; default: / Parent. / wait3(&i, 0, &r); / Avoid “text file busy” from rm on fast HP-UX machines. / sleep(2); return (r.ru_nvcsw == 0 && r.ru_majflt == 0 && r.ru_minflt == 0 && r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0); } } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_wait3_rusage=yes else ac_cv_func_wait3_rusage=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_wait3_rusage” >&5 $as_echo “$ac_cv_func_wait3_rusage” >&6; } if test $ac_cv_func_wait3_rusage = yes; then

$as_echo “#define HAVE_WAIT3 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether getpgrp requires zero arguments” >&5 $as_echo_n “checking whether getpgrp requires zero arguments… ” >&6; } if ${ac_cv_func_getpgrp_void+:} false; then : $as_echo_n “(cached) ” >&6 else # Use it with a single arg. cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default int main () { getpgrp (0); ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_func_getpgrp_void=no else ac_cv_func_getpgrp_void=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_getpgrp_void” >&5 $as_echo “$ac_cv_func_getpgrp_void” >&6; } if test $ac_cv_func_getpgrp_void = yes; then

$as_echo “#define GETPGRP_VOID 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether setpgrp takes no argument” >&5 $as_echo_n “checking whether setpgrp takes no argument… ” >&6; } if ${ac_cv_func_setpgrp_void+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : as_fn_error $? “cannot check setpgrp when cross compiling” “$LINENO” 5 else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default int main () { / If this system has a BSD-style setpgrp which takes arguments, setpgrp(1, 1) will fail with ESRCH and return -1, in that case exit successfully. / return setpgrp (1,1) != -1; ; return 0; } ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_setpgrp_void=no else ac_cv_func_setpgrp_void=yes fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_setpgrp_void” >&5 $as_echo “$ac_cv_func_setpgrp_void” >&6; } if test $ac_cv_func_setpgrp_void = yes; then

$as_echo “#define SETPGRP_VOID 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: GENERIC LIBRARY FUNCTIONS ” >&5 $as_echo “$as_me: GENERIC LIBRARY FUNCTIONS ” >&6;} for ac_func in \ rpc_get_local_uid \ seterr_reply \ _seterr_reply \ bcmp \ bcopy \ bzero \ clnt_create \ clnt_create_vers \ clnt_create_vers_timed \ clnt_spcreateerror \ clock_gettime \ cnodeid \ dg_mount \ flock \ fsmount \ get_myaddress \ getccent \ getcwd \ getdomainname \ getdtablesize \ gethostname \ getifaddrs \ getmntinfo \ getmountent \ getpagesize \ gettimeofday \ hasmntopt \ hstrerror \ madvise \ memcmp \ memcpy \ memmove \ memset \ mkdir \ mkstemp \ mntctl \ mlockall \ mount \ mountsyscall \ plock \ regcomp \ regexec \ rmdir \ select \ seteuid \ setitimer \ setresuid \ setsid \ sigaction \ signal \ sigsuspend \ socket \ statfs \ statvfs \ strcasecmp \ strchr \ strcspn \ strdup \ strerror \ strlcat \ strlcpy \ strspn \ strstr \ svc_getreq \ svc_getreqset \ sysfs \ syslog \ uname \ umount \ umount2 \ unmount \ uvmount \ vfork \ vfsmount \ vmount \ vsnprintf \ wait3 \ waitpid \

do : as_ac_var=$as_echo "ac_cv_func_$ac_func" | $as_tr_sh ac_fn_c_check_func “$LINENO” “$ac_func” “$as_ac_var” if eval test \“x\$”$as_ac_var"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

if test “$with_hesiod” = “yes”; then for ac_func in \ hes_init \ hesiod_init \ hesiod_reload \ hesiod_to_bind \

do : as_ac_var=$as_echo "ac_cv_func_$ac_func" | $as_tr_sh ac_fn_c_check_func “$LINENO” “$ac_func” “$as_ac_var” if eval test \“x\$”$as_ac_var"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

fi ac_fn_c_check_func “$LINENO” “clnt_sperrno” “ac_cv_func_clnt_sperrno” if test “x$ac_cv_func_clnt_sperrno” = xyes; then : $as_echo “#define HAVE_CLNT_SPERRNO 1” >>confdefs.h

else case “ $LIBOBJS ” in “ clnt_sperrno.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS clnt_sperrno.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “hasmntopt” “ac_cv_func_hasmntopt” if test “x$ac_cv_func_hasmntopt” = xyes; then : $as_echo “#define HAVE_HASMNTOPT 1” >>confdefs.h

else case “ $LIBOBJS ” in “ hasmntopt.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS hasmntopt.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strcasecmp” “ac_cv_func_strcasecmp” if test “x$ac_cv_func_strcasecmp” = xyes; then : $as_echo “#define HAVE_STRCASECMP 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strcasecmp.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strcasecmp.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strdup” “ac_cv_func_strdup” if test “x$ac_cv_func_strdup” = xyes; then : $as_echo “#define HAVE_STRDUP 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strdup.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strdup.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strerror” “ac_cv_func_strerror” if test “x$ac_cv_func_strerror” = xyes; then : $as_echo “#define HAVE_STRERROR 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strerror.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strerror.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strlcat” “ac_cv_func_strlcat” if test “x$ac_cv_func_strlcat” = xyes; then : $as_echo “#define HAVE_STRLCAT 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strlcat.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strlcat.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strlcpy” “ac_cv_func_strlcpy” if test “x$ac_cv_func_strlcpy” = xyes; then : $as_echo “#define HAVE_STRLCPY 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strlcpy.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strlcpy.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “strstr” “ac_cv_func_strstr” if test “x$ac_cv_func_strstr” = xyes; then : $as_echo “#define HAVE_STRSTR 1” >>confdefs.h

else case “ $LIBOBJS ” in “ strstr.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS strstr.$ac_objext” ;; esac

fi

ac_fn_c_check_func “$LINENO” “ualarm” “ac_cv_func_ualarm” if test “x$ac_cv_func_ualarm” = xyes; then : $as_echo “#define HAVE_UALARM 1” >>confdefs.h

else case “ $LIBOBJS ” in “ ualarm.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS ualarm.$ac_objext” ;; esac

fi

for ac_func in \ xdr_attrstat \ xdr_createargs \ xdr_dirlist \ xdr_diropargs \ xdr_diropokres \ xdr_diropres \ xdr_dirpath \ xdr_entry \ xdr_exportnode \ xdr_exports \ xdr_fattr \ xdr_fhandle \ xdr_fhstatus \ xdr_filename \ xdr_ftype \ xdr_groupnode \ xdr_groups \ xdr_linkargs \ xdr_mountbody \ xdr_mountlist \ xdr_name \ xdr_nfs_fh \ xdr_nfscookie \ xdr_nfspath \ xdr_nfsstat \ xdr_nfstime \ xdr_pointer \ xdr_u_int64_t \ xdr_readargs \ xdr_readdirargs \ xdr_readdirres \ xdr_readlinkres \ xdr_readokres \ xdr_readres \ xdr_renameargs \ xdr_sattr \ xdr_sattrargs \ xdr_statfsokres \ xdr_statfsres \ xdr_symlinkargs \ xdr_writeargs \

do : as_ac_var=$as_echo "ac_cv_func_$ac_func" | $as_tr_sh ac_fn_c_check_func “$LINENO” “$ac_func” “$as_ac_var” if eval test \“x\$”$as_ac_var"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_func" | $as_tr_cpp 1

_ACEOF

fi done

if test -f confdefs.h then cp confdefs.h dbgcf.h fi 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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; 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 if test “x$cache_file” != “x/dev/null”; then { $as_echo “$as_me:${as_lineno-$LINENO}: updating cache $cache_file” >&5 $as_echo “$as_me: updating cache $cache_file” >&6;} if test ! -f “$cache_file” || test -h “$cache_file”; then cat confcache >“$cache_file” else case $cache_file in #( / | ?:) mv -f confcache “$cache_file”$$ && mv -f “$cache_file”$$ “$cache_file” ;; #( ) mv -f confcache “$cache_file” ;; esac fi fi else { $as_echo “$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file” >&5 $as_echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache { $as_echo “$as_me:${as_lineno-$LINENO}: SAVING CONFIGURE STATE ” >&5 $as_echo “$as_me: SAVING CONFIGURE STATE ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR HEADER FILES ” >&5 $as_echo “$as_me: PARTICULAR HEADER FILES ” >&6;} ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do as_ac_Header=$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR” >&5 $as_echo_n “checking for $ac_hdr that defines DIR… ” >&6; } if eval \${$as_ac_Header+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

include <$ac_hdr>

int main () { if ((DIR *) 0) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : eval “$as_ac_Header=yes” else eval “$as_ac_Header=no” fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$as_ac_Header { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_res” >&5 $as_echo “$ac_res” >&6; } if eval test \“x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<ACEOF

define $as_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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for library containing opendir” >&5 $as_echo_n “checking for library containing opendir… ” >&6; } if ${ac_cv_search_opendir+:} false; then : $as_echo_n “(cached) ” >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_link “$LINENO”; then : ac_cv_search_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then :

else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir” >&5 $as_echo “$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 { $as_echo “$as_me:${as_lineno-$LINENO}: checking for library containing opendir” >&5 $as_echo_n “checking for library containing opendir… ” >&6; } if ${ac_cv_search_opendir+:} false; then : $as_echo_n “(cached) ” >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_link “$LINENO”; then : ac_cv_search_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then :

else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir” >&5 $as_echo “$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

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ANSI C header files” >&5 $as_echo_n “checking for ANSI C header files… ” >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <stdlib.h>

include <stdarg.h>

include <string.h>

include <float.h>

int main () {

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_header_stdc=yes else 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_run “$LINENO”; then :

else ac_cv_header_stdc=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

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

$as_echo “#define STDC_HEADERS 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible” >&5 $as_echo_n “checking for sys/wait.h that is POSIX.1 compatible… ” >&6; } if ${ac_cv_header_sys_wait_h+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_compile “$LINENO”; then : ac_cv_header_sys_wait_h=yes else ac_cv_header_sys_wait_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h” >&5 $as_echo “$ac_cv_header_sys_wait_h” >&6; } if test $ac_cv_header_sys_wait_h = yes; then

$as_echo “#define HAVE_SYS_WAIT_H 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: GENERIC HEADER FILES ” >&5 $as_echo “$as_me: GENERIC HEADER FILES ” >&6;} for ac_header in \ arpa/nameser.h \ arpa/inet.h \ bsd/rpc/rpc.h \ cdfs/cdfsmount.h \ cdfs/cdfs_mount.h \ fs/udf/udf_mount.h \ db1/ndbm.h \ fs/efs/efs_mount.h \ fs/msdosfs/msdosfsmount.h \ fs/tmpfs/tmpfs_args.h \ gdbm/ndbm.h \ hsfs/hsfs.h \ linux/fs.h \ linux/kdev_t.h \ linux/list.h \ linux/nfs.h \ linux/nfs2.h \ linux/nfs4.h \ linux/posix_types.h \ linux/socket.h \ machine/endian.h \ net/errno.h \ net/if_var.h \ netinet/in.h \ nfs/export.h \ nfs/mount.h \ nfs/nfs_gfs.h \ nfs/nfs_mount.h \ nfs/nfsmount.h \ nfs/nfsproto.h \ nfs/nfsv2.h \ nfs/pathconf.h \ nfs/rpcv2.h \ nfsclient/nfsargs.h \ rpc/rpc.h \ rpc/types.h \ rpcsvc/autofs_prot.h \ rpcsvc/mount.h \ rpcsvc/mountv3.h \ rpcsvc/nfs_prot.h \ rpcsvc/nis.h \ rpcsvc/ypclnt.h \ sys/config.h \ sys/dg_mount.h \ sys/dir.h \ sys/errno.h \ sys/file.h \ sys/fs/autofs.h \ sys/fs/autofs_prot.h \ sys/fs/cachefs_fs.h \ sys/fs/efs_clnt.h \ sys/fs/nfs.h \ sys/fs/nfs/mount.h \ sys/fs/nfs/nfs_clnt.h \ sys/fs/nfs_clnt.h \ sys/fs/pc_fs.h \ sys/fs/tmp.h \ sys/fs/ufs_mount.h \ sys/fs/xfs_clnt.h \ sys/fs_types.h \ sys/fsid.h \ sys/fstyp.h \ sys/ioctl.h \ sys/immu.h \ sys/lock.h \ sys/machine.h \ sys/mman.h \ sys/mntctl.h \ sys/mntent.h \ sys/mnttab.h \ sys/mount.h \ sys/ndir.h \ sys/netconfig.h \ sys/param.h \ sys/pathconf.h \ sys/resource.h \ sys/sema.h \ sys/signal.h \ sys/socket.h \ sys/sockio.h \ sys/stat.h \ sys/statfs.h \ sys/statvfs.h \ sys/syscall.h \ sys/syslimits.h \ sys/syslog.h \ sys/time.h \ sys/tiuser.h \ sys/types.h \ sys/ucred.h \ sys/uio.h \ sys/utsname.h \ sys/vfs.h \ sys/vmount.h \ sys/vnode.h \ ufs/ufs/extattr.h \ ufs/ufs/ufsmount.h \ ufs/ufs_mount.h \ \ assert.h \ cluster.h \ ctype.h \ errno.h \ fcntl.h \ ifaddrs.h \ irs.h \ grp.h \ libgen.h \ limits.h \ malloc.h \ memory.h \ mntent.h \ mnttab.h \ mount.h \ ndbm.h \ ndir.h \ netconfig.h \ netdb.h \ netdir.h \ nsswitch.h \ pwd.h \ regex.h \ setjmp.h \ signal.h \ socketbits.h \ statbuf.h \ stdarg.h \ stdlib.h \ stdio.h \ string.h \ strings.h \ syslog.h \ tcpd.h \ time.h \ tiuser.h \ varargs.h \ unistd.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_mongrel “$LINENO” “$ac_header” “$as_ac_Header” “$ac_includes_default” if eval test \“x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_header in \ net/if.h \ net/route.h \ nfs/nfs_clnt.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_compile “$LINENO” “$ac_header” “$as_ac_Header” "

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_SOCKET_H

include <sys/socket.h>

endif / HAVE_SYS_SOCKET_H /

“ if eval test \"x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

if test “$with_ldap” = “yes”; then for ac_header in \ lber.h \ ldap.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_mongrel “$LINENO” “$ac_header” “$as_ac_Header” “$ac_includes_default” if eval test \“x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

fi if test “$with_hesiod” = “yes”; then for ac_header in \ hesiod.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_mongrel “$LINENO” “$ac_header” “$as_ac_Header” “$ac_includes_default” if eval test \“x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

fi for ac_header in \ isofs/cd9660/cd9660_mount.h \ msdosfs/msdosfsmount.h \ netinet/if_ether.h \ nfs/nfs.h \ rpc/auth.h \ rpc/auth_des.h \ rpc/pmap_clnt.h \ rpc/pmap_prot.h \ rpcsvc/yp_prot.h \ sys/mbuf.h \ sys/proc.h \ resolv.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_compile “$LINENO” “$ac_header” “$as_ac_Header” "

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_SOCKET_H

include <sys/socket.h>

endif / HAVE_SYS_SOCKET_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

ifdef HAVE_SYS_QUEUE_H

include <sys/queue.h>

endif / HAVE_SYS_QUEUE_H /

ifdef HAVE_NET_IF_H

include <net/if.h>

endif / HAVE_NET_IF_H /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_MOUNT_H

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_NFS_NFSMOUNT_H

include <nfs/nfsmount.h>

endif / HAVE_NFS_NFSMOUNT_H /

ifdef HAVE_RPC_TYPES_H

include <rpc/types.h>

endif / HAVE_RPC_TYPES_H /

ifdef HAVE_RPC_RPC_H

include <rpc/rpc.h>

endif / HAVE_RPC_RPC_H /

ifdef HAVE_NFS_RPCV2_H

include <nfs/rpcv2.h>

endif / HAVE_NFS_RPCV2_H /

“ if eval test \"x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_header in \ linux/auto_fs.h \ linux/auto_fs4.h \ linux/loop.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_compile “$LINENO” “$ac_header” “$as_ac_Header” "

ifdef HAVE_SYS_SOCKET_H

include <sys/socket.h>

endif / HAVE_SYS_SOCKET_H /

ifdef HAVE_LIMITS_H

include <limits.h>

endif / HAVE_LIMITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

/ next dev_t lines needed due to changes in kernel code /

undef dev_t

define dev_t unsigned short / compatible with Red Hat and SuSE /

“ if eval test \"x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

for ac_header in \ linux/nfs_mount.h \

do : as_ac_Header=$as_echo "ac_cv_header_$ac_header" | $as_tr_sh ac_fn_c_check_header_compile “$LINENO” “$ac_header” “$as_ac_Header” “ / * Needed to find nfs2_fh and nfs_fh on older systems (yellowdog2.3, gentoo, * etc.) * Needs to be defined before <asm/types.h> so u32 is available for * <linux/sunrpc/msg_prot.h>. /

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

/ * It used to be the case that linux/socket.h would define sa_family_t, * but as of FC15, this is not the case anymore (although the comments * in some headers say that is true! So we include <sys/socket.h> too. /

ifdef HAVE_LINUX_SOCKET_H

include <linux/socket.h>

endif / HAVE_LINUX_SOCKET_H /

ifdef HAVE_SYS_SOCKET_H

include <sys/socket.h>

endif / HAVE_SYS_SOCKET_H /

ifdef HAVE_LIMITS_H

include <limits.h>

endif / HAVE_LIMITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifdef HAVE_LINUX_NFS2_H

if !defined(FHSIZE) && defined(NFS2_FHSIZE)

define FHSIZE NFS2_FHSIZE

endif

ifdef HAVE_LINUX_NFS_H

include <linux/nfs.h>

if !defined(FHSIZE) && defined(NFS_FHSIZE)

define FHSIZE NFS_FHSIZE

endif

endif

struct nfs2_fh { char data[FHSIZE]; };

define _LINUX_NFS2_H

endif / HAVE_LINUX_NFS2_H /

/ next dev_t lines needed due to changes in kernel code /

undef dev_t

define dev_t unsigned short / compatible with Red Hat and SuSE /

“ if eval test \"x\$”$as_ac_Header"\“ = x"yes”; then : cat >>confdefs.h <<_ACEOF

define $as_echo "HAVE_$ac_header" | $as_tr_cpp 1

_ACEOF

fi

done

if test “$with_ndbm” = “yes” then if test “$ac_cv_lib_new_dbm” = “” -a “$ac_cv_header_ndbm_h” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -lndbm” >&5 $as_echo_n “checking for dbm_open in -lndbm… ” >&6; } if ${ac_cv_lib_ndbm_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lndbm $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_ndbm_dbm_open=yes else ac_cv_lib_ndbm_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ndbm_dbm_open” >&5 $as_echo “$ac_cv_lib_ndbm_dbm_open” >&6; } if test “x$ac_cv_lib_ndbm_dbm_open” = xyes; then : { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_pagfno in -lndbm” >&5 $as_echo_n “checking for dbm_pagfno in -lndbm… ” >&6; } if ${ac_cv_lib_ndbm_dbm_pagfno+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lndbm $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dbm_pagfno (); int main () { return dbm_pagfno (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_ndbm_dbm_pagfno=yes else ac_cv_lib_ndbm_dbm_pagfno=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ndbm_dbm_pagfno” >&5 $as_echo “$ac_cv_lib_ndbm_dbm_pagfno” >&6; } if test “x$ac_cv_lib_ndbm_dbm_pagfno” = xyes; then : ac_cv_header_new_dbm=“ndbm.h”; ac_cv_lib_new_dbm=“ndbm” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_pagfno in -lgdbm” >&5 $as_echo_n “checking for dbm_pagfno in -lgdbm… ” >&6; } if ${ac_cv_lib_gdbm_dbm_pagfno+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lgdbm $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dbm_pagfno (); int main () { return dbm_pagfno (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_gdbm_dbm_pagfno=yes else ac_cv_lib_gdbm_dbm_pagfno=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gdbm_dbm_pagfno” >&5 $as_echo “$ac_cv_lib_gdbm_dbm_pagfno” >&6; } if test “x$ac_cv_lib_gdbm_dbm_pagfno” = xyes; then : ac_cv_header_new_dbm=“ndbm.h”; ac_cv_lib_new_dbm=“ndbm -lgdbm” fi

fi

fi

fi if test “$ac_cv_lib_new_dbm” = “” -a “$ac_cv_header_ndbm_h” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -lc” >&5 $as_echo_n “checking for dbm_open in -lc… ” >&6; } if ${ac_cv_lib_c_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lc $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_c_dbm_open=yes else ac_cv_lib_c_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dbm_open” >&5 $as_echo “$ac_cv_lib_c_dbm_open” >&6; } if test “x$ac_cv_lib_c_dbm_open” = xyes; then : ac_cv_header_new_dbm=“ndbm.h”; ac_cv_lib_new_dbm=“c” fi

fi if test “$ac_cv_lib_new_dbm” = “” -a “$ac_cv_header_db1_ndbm_h” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -ldb1” >&5 $as_echo_n “checking for dbm_open in -ldb1… ” >&6; } if ${ac_cv_lib_db1_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-ldb1 $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_db1_dbm_open=yes else ac_cv_lib_db1_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_db1_dbm_open” >&5 $as_echo “$ac_cv_lib_db1_dbm_open” >&6; } if test “x$ac_cv_lib_db1_dbm_open” = xyes; then : ac_cv_header_new_dbm=“db1/ndbm.h”; ac_cv_lib_new_dbm=“db1” fi

fi if test “$ac_cv_lib_new_dbm” = “” -a “$ac_cv_header_gdbm_ndbm_h” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -lgdbm” >&5 $as_echo_n “checking for dbm_open in -lgdbm… ” >&6; } if ${ac_cv_lib_gdbm_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lgdbm $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_gdbm_dbm_open=yes else ac_cv_lib_gdbm_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gdbm_dbm_open” >&5 $as_echo “$ac_cv_lib_gdbm_dbm_open” >&6; } if test “x$ac_cv_lib_gdbm_dbm_open” = xyes; then : ac_cv_header_new_dbm=“gdbm/ndbm.h”; ac_cv_lib_new_dbm=“gdbm” fi

else # reset any previous knowledge and retest for different header name # check also gdbm_compat library (Debian 3.1) unset ac_cv_header_gdbm_ndbm_h for ac_header in gdbm-ndbm.h do : ac_fn_c_check_header_mongrel “$LINENO” “gdbm-ndbm.h” “ac_cv_header_gdbm_ndbm_h” “$ac_includes_default” if test “x$ac_cv_header_gdbm_ndbm_h” = xyes; then : cat >>confdefs.h <<_ACEOF

define HAVE_GDBM_NDBM_H 1

_ACEOF

fi

done

if test “$ac_cv_lib_new_dbm” = “” -a “$ac_cv_header_gdbm_ndbm_h” = “yes”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -lgdbm” >&5 $as_echo_n “checking for dbm_open in -lgdbm… ” >&6; } if ${ac_cv_lib_gdbm_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lgdbm $LIBS” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_gdbm_dbm_open=yes else ac_cv_lib_gdbm_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gdbm_dbm_open” >&5 $as_echo “$ac_cv_lib_gdbm_dbm_open” >&6; } if test “x$ac_cv_lib_gdbm_dbm_open” = xyes; then : ac_cv_header_new_dbm=“gdbm-ndbm.h”; ac_cv_lib_new_dbm=“gdbm” else { $as_echo “$as_me:${as_lineno-$LINENO}: checking for dbm_open in -lgdbm_compat” >&5 $as_echo_n “checking for dbm_open in -lgdbm_compat… ” >&6; } if ${ac_cv_lib_gdbm_compat_dbm_open+:} false; then : $as_echo_n “(cached) ” >&6 else ac_check_lib_save_LIBS=$LIBS LIBS=“-lgdbm_compat $LIBS” cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 dbm_open (); int main () { return dbm_open (); ; return 0; } _ACEOF if ac_fn_c_try_link “$LINENO”; then : ac_cv_lib_gdbm_compat_dbm_open=yes else ac_cv_lib_gdbm_compat_dbm_open=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gdbm_compat_dbm_open” >&5 $as_echo “$ac_cv_lib_gdbm_compat_dbm_open” >&6; } if test “x$ac_cv_lib_gdbm_compat_dbm_open” = xyes; then : ac_cv_header_new_dbm=“gdbm-ndbm.h”; ac_cv_lib_new_dbm=“gdbm -lgdbm_compat” fi

fi

fi fi if test “$ac_cv_header_new_dbm” != “” -a “$ac_cv_lib_new_dbm” != “”; then cat >>confdefs.h <<_ACEOF

define NEW_DBM_H “$ac_cv_header_new_dbm”

_ACEOF

if test “$ac_cv_lib_new_dbm” != “c” ; then LIBS=“-l$ac_cv_lib_new_dbm $LIBS” fi fi fi

if test -f confdefs.h then cp confdefs.h dbgcf.h fi 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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; 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 if test “x$cache_file” != “x/dev/null”; then { $as_echo “$as_me:${as_lineno-$LINENO}: updating cache $cache_file” >&5 $as_echo “$as_me: updating cache $cache_file” >&6;} if test ! -f “$cache_file” || test -h “$cache_file”; then cat confcache >“$cache_file” else case $cache_file in #( / | ?:) mv -f confcache “$cache_file”$$ && mv -f “$cache_file”$$ “$cache_file” ;; #( ) mv -f confcache “$cache_file” ;; esac fi fi else { $as_echo “$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file” >&5 $as_echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache { $as_echo “$as_me:${as_lineno-$LINENO}: SAVING CONFIGURE STATE ” >&5 $as_echo “$as_me: SAVING CONFIGURE STATE ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR STRUCTURES ” >&5 $as_echo “$as_me: PARTICULAR STRUCTURES ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken” >&5 $as_echo_n “checking whether stat file-mode macros are broken… ” >&6; } if ${ac_cv_header_stat_broken+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

include <sys/stat.h>

if defined S_ISBLK && defined S_IFDIR

extern char c1[S_ISBLK (S_IFDIR) ? -1 : 1];

endif

if defined S_ISBLK && defined S_IFCHR

extern char c2[S_ISBLK (S_IFCHR) ? -1 : 1];

endif

if defined S_ISLNK && defined S_IFREG

extern char c3[S_ISLNK (S_IFREG) ? -1 : 1];

endif

if defined S_ISSOCK && defined S_IFREG

extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1];

endif

_ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_header_stat_broken=no else ac_cv_header_stat_broken=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken” >&5 $as_echo “$ac_cv_header_stat_broken” >&6; } if test $ac_cv_header_stat_broken = yes; then

$as_echo “#define STAT_MACROS_BROKEN 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included” >&5 $as_echo_n “checking whether time.h and sys/time.h may both be included… ” >&6; } if ${ac_cv_header_time+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_compile “$LINENO”; then : ac_cv_header_time=yes else ac_cv_header_time=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time” >&5 $as_echo “$ac_cv_header_time” >&6; } if test $ac_cv_header_time = yes; then

$as_echo “#define TIME_WITH_SYS_TIME 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h” >&5 $as_echo_n “checking whether struct tm is in sys/time.h or time.h… ” >&6; } if ${ac_cv_struct_tm+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_tm=time.h else ac_cv_struct_tm=sys/time.h fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm” >&5 $as_echo “$ac_cv_struct_tm” >&6; } if test $ac_cv_struct_tm = sys/time.h; then

$as_echo “#define TM_IN_SYS_TIME 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: GENERIC STRUCTURES ” >&5 $as_echo “$as_me: GENERIC STRUCTURES ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking location of NFS protocol header files” >&5 $as_echo_n “checking location of NFS protocol header files… ” >&6; } if ${ac_cv_nfs_prot_headers+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct style for mounting filesystems

case “${host_os}” in irix5 ) ac_cv_nfs_prot_headers=irix5 ;; irix ) ac_cv_nfs_prot_headers=irix6 ;; sunos3 ) ac_cv_nfs_prot_headers=sunos3 ;; sunos4 | solaris1 ) ac_cv_nfs_prot_headers=sunos4 ;; sunos5.[0-3] | solaris2.[0-3] ) ac_cv_nfs_prot_headers=sunos5_3 ;; sunos5.4 | solaris2.4 ) ac_cv_nfs_prot_headers=sunos5_4 ;; sunos5.5 | solaris2.5 ) ac_cv_nfs_prot_headers=sunos5_5 ;; sunos5.6 | solaris2.6 ) ac_cv_nfs_prot_headers=sunos5_6 ;; sunos5.7 | solaris2.7 ) ac_cv_nfs_prot_headers=sunos5_7 ;; sunos5 | solaris2 ) ac_cv_nfs_prot_headers=sunos5_8 ;; bsdi2) ac_cv_nfs_prot_headers=bsdi2 ;; bsdi ) ac_cv_nfs_prot_headers=bsdi3 ;; freebsd2 ) ac_cv_nfs_prot_headers=freebsd2 ;; freebsd | freebsdelf ) ac_cv_nfs_prot_headers=freebsd3 ;; netbsd1.[0-2] ) ac_cv_nfs_prot_headers=netbsd ;; netbsd1.3 ) ac_cv_nfs_prot_headers=netbsd1_3 ;; netbsd | netbsdelf ) ac_cv_nfs_prot_headers=netbsd1_4 ;; openbsd ) ac_cv_nfs_prot_headers=openbsd ;; hpux[6-9] | hpux10 ) ac_cv_nfs_prot_headers=hpux ;; hpux ) ac_cv_nfs_prot_headers=hpux11 ;; aix[1-3] ) ac_cv_nfs_prot_headers=aix3 ;; aix4.[01] ) ac_cv_nfs_prot_headers=aix4 ;; aix4.2 ) ac_cv_nfs_prot_headers=aix4_2 ;; aix4.3 ) ac_cv_nfs_prot_headers=aix4_3 ;; aix5.1 ) ac_cv_nfs_prot_headers=aix5_1 ;; aix ) ac_cv_nfs_prot_headers=aix5_2 ;; osf[1-3] ) ac_cv_nfs_prot_headers=osf2 ;; osf4 ) ac_cv_nfs_prot_headers=osf4 ;; osf ) ac_cv_nfs_prot_headers=osf5 ;; svr4 ) ac_cv_nfs_prot_headers=svr4 ;; sysv4 ) # this is for NCR2 machines ac_cv_nfs_prot_headers=ncr2 ;; linux ) ac_cv_nfs_prot_headers=linux ;; nextstep ) ac_cv_nfs_prot_headers=nextstep ;; ultrix ) ac_cv_nfs_prot_headers=ultrix ;; darwin | macosx | rhapsody* ) ac_cv_nfs_prot_headers=darwin ;; * ) ac_cv_nfs_prot_headers=default ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_nfs_prot_headers” >&5 $as_echo “$ac_cv_nfs_prot_headers” >&6; }

make sure correct header is linked in top build directory

am_utils_nfs_prot_file=“amu_nfs_prot.h” am_utils_link_files=${am_utils_link_files}${am_utils_nfs_prot_file}:conf/nfs_prot/nfs_prot_${ac_cv_nfs_prot_headers}.h" "

define the name of the header to be included for other M4 macros

cat >>confdefs.h <<_ACEOF

define AMU_NFS_PROTOCOL_HEADER “${srcdir}/conf/nfs_prot/nfs_prot_${ac_cv_nfs_prot_headers}.h”

_ACEOF

set headers in a macro for Makefile.am files to use (for dependencies)

AMU_NFS_PROT_HEADER=‘${top_builddir}/’$am_utils_nfs_prot_file

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for struct mntent” >&5 $as_echo_n “checking for struct mntent… ” >&6; } if ${ac_cv_have_struct_mntent+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () {

struct mntent mt;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_mntent=yes else ac_cv_have_struct_mntent=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_have_struct_mntent” >&5 $as_echo “$ac_cv_have_struct_mntent” >&6; } if test “$ac_cv_have_struct_mntent” = yes then $as_echo “#define HAVE_STRUCT_MNTENT 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for struct mnttab” >&5 $as_echo_n “checking for struct mnttab… ” >&6; } if ${ac_cv_have_struct_mnttab+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () {

struct mnttab mt;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_mnttab=yes else ac_cv_have_struct_mnttab=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_have_struct_mnttab” >&5 $as_echo “$ac_cv_have_struct_mnttab” >&6; } if test “$ac_cv_have_struct_mnttab” = yes then $as_echo “#define HAVE_STRUCT_MNTTAB 1” >>confdefs.h

fi

if test $ac_cv_func_hasmntopt = yes then

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for working hasmntopt” >&5 $as_echo_n “checking for working hasmntopt… ” >&6; } if ${ac_cv_func_hasmntopt_working+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run test program while cross compiling See `config.log' for more details” “$LINENO” 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef HAVE_MNTENT_H

/ some systems need <stdio.h> before <mntent.h> is included /

ifdef HAVE_STDIO_H

include <stdio.h>

endif / HAVE_STDIO_H /

include <mntent.h>

endif / HAVE_MNTENT_H /

ifdef HAVE_SYS_MNTENT_H

include <sys/mntent.h>

endif / HAVE_SYS_MNTENT_H /

ifdef HAVE_SYS_MNTTAB_H

include <sys/mnttab.h>

endif / HAVE_SYS_MNTTAB_H /

if defined(HAVE_MNTTAB_H) && !defined(MNTTAB)

include <mnttab.h>

endif / defined(HAVE_MNTTAB_H) && !defined(MNTTAB) /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t; / map struct mnttab field names to struct mntent field names /

define mnt_opts mnt_mntopts

endif / not HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

int main() { mntent_t mnt; char *tmp = NULL;

/ * Test if hasmntopt will incorrectly find the string “soft”, which * is part of the large “softlookup” function. / mnt.mnt_opts = “hard,softlookup,ro”;

if ((tmp = hasmntopt(&mnt, “soft”))) exit(1); exit(0); }

_ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_func_hasmntopt_working=yes else ac_cv_func_hasmntopt_working=no

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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_hasmntopt_working” >&5 $as_echo “$ac_cv_func_hasmntopt_working” >&6; } if test $ac_cv_func_hasmntopt_working = no then case “ $LIBOBJS ” in “ hasmntopt.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS hasmntopt.$ac_objext” ;; esac

$as_echo "#define HAVE_BAD_HASMNTOPT 1" >>confdefs.h

fi

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for struct nfs_args” >&5 $as_echo_n “checking for struct nfs_args… ” >&6; } if ${ac_cv_have_struct_nfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the structure

assume not found

ac_cv_have_struct_nfs_args=notfound

look for “struct irix5_nfs_args” (specially set in conf/nfs_prot/)

if test “$ac_cv_have_struct_nfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct irix5_nfs_args na;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_nfs_args=“struct irix5_nfs_args” else ac_cv_have_struct_nfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct aix5_nfs_args” (specially set in conf/nfs_prot/)

if test “$ac_cv_have_struct_nfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct aix5_nfs_args na;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_nfs_args=“struct aix5_nfs_args” else ac_cv_have_struct_nfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct aix4_nfs_args” (specially set in conf/nfs_prot/)

if test “$ac_cv_have_struct_nfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct aix4_nfs_args na;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_nfs_args=“struct aix4_nfs_args” else ac_cv_have_struct_nfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct nfs_args”

if test “$ac_cv_have_struct_nfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct nfs_args na;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_nfs_args=“struct nfs_args” else ac_cv_have_struct_nfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_have_struct_nfs_args” >&5 $as_echo “$ac_cv_have_struct_nfs_args” >&6; }

if test “$ac_cv_have_struct_nfs_args” != notfound then $as_echo “#define HAVE_STRUCT_NFS_ARGS 1” >>confdefs.h

cat >>confdefs.h <<_ACEOF

define nfs_args_t $ac_cv_have_struct_nfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for struct nfs_gfs_mount” >&5 $as_echo_n “checking for struct nfs_gfs_mount… ” >&6; } if ${ac_cv_have_struct_nfs_gfs_mount+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the structure

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct nfs_gfs_mount ngm;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_struct_nfs_gfs_mount=yes else ac_cv_have_struct_nfs_gfs_mount=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_have_struct_nfs_gfs_mount” >&5 $as_echo “$ac_cv_have_struct_nfs_gfs_mount” >&6; } if test “$ac_cv_have_struct_nfs_gfs_mount” = yes then $as_echo “#define HAVE_STRUCT_NFS_GFS_MOUNT 1” >>confdefs.h

$as_echo “#define nfs_args_t struct nfs_gfs_mount” >>confdefs.h

fi

if test “$ac_cv_have_struct_nfs_args” = notfound && test “$ac_cv_have_struct_nfs_gfs_mount” = no then as_fn_error $? “Cannot find any definition for struct nfs_args! This can be due to several reasons: a misconfigured system, a system that is missing some vital NFS-related headers or libraries, one for which am-utils was not ported to yet, or even a bug in the am-utils sources. Check the BUGS file in this distribution and see if there is any mention relevant to your system. If that does not help, check the config.log and config.cache files in this build for details and report them to https://bugzilla.am-utils.org/ or am-utils@am-utils.org please. ” “$LINENO” 5 fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for the name of the nfs filehandle field in nfs_args_t” >&5 $as_echo_n “checking for the name of the nfs filehandle field in nfs_args_t… ” >&6; } if ${ac_cv_struct_field_nfs_fh+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_struct_field_nfs_fh=notfound

look for name “fh” (most systems)

if test “$ac_cv_struct_field_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { nfs_args_t nat; char cp = (char ) &(nat.fh);

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_field_nfs_fh=fh else ac_cv_struct_field_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for name “root” (for example Linux)

if test “$ac_cv_struct_field_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { nfs_args_t nat; char cp = (char ) &(nat.root);

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_field_nfs_fh=root else ac_cv_struct_field_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_field_nfs_fh” >&5 $as_echo “$ac_cv_struct_field_nfs_fh” >&6; } if test “$ac_cv_struct_field_nfs_fh” != notfound then cat >>confdefs.h <<_ACEOF

define NFS_FH_FIELD $ac_cv_struct_field_nfs_fh

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for type/structure of NFS V2 filehandle” >&5 $as_echo_n “checking for type/structure of NFS V2 filehandle… ” >&6; } if ${ac_cv_struct_nfs_fh+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the type

set to a default value

ac_cv_struct_nfs_fh=notfound

look for “nfs_fh”

if test “$ac_cv_struct_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { nfs_fh nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh=“nfs_fh” else ac_cv_struct_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct nfs_fh”

if test “$ac_cv_struct_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct nfs_fh nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh=“struct nfs_fh” else ac_cv_struct_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct nfssvcfh”

if test “$ac_cv_struct_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct nfssvcfh nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh=“struct nfssvcfh” else ac_cv_struct_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “nfsv2fh_t”

if test “$ac_cv_struct_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { nfsv2fh_t nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh=“nfsv2fh_t” else ac_cv_struct_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “fhandle_t”

if test “$ac_cv_struct_nfs_fh” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { fhandle_t nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh=“fhandle_t” else ac_cv_struct_nfs_fh=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_nfs_fh” >&5 $as_echo “$ac_cv_struct_nfs_fh” >&6; }

if test “$ac_cv_struct_nfs_fh” != notfound then cat >>confdefs.h <<_ACEOF

define am_nfs_fh $ac_cv_struct_nfs_fh

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for type/structure of NFS V3 filehandle” >&5 $as_echo_n “checking for type/structure of NFS V3 filehandle… ” >&6; } if ${ac_cv_struct_nfs_fh3+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the type

set to a default value

ac_cv_struct_nfs_fh3=notfound

look for “nfs_fh3”

if test “$ac_cv_struct_nfs_fh3” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { nfs_fh3 nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh3=“nfs_fh3_netbsd20” else ac_cv_struct_nfs_fh3=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct nfs_fh3”

if test “$ac_cv_struct_nfs_fh3” = notfound then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { struct nfs_fh3 nh;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_struct_nfs_fh3=“struct nfs_fh3” else ac_cv_struct_nfs_fh3=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_nfs_fh3” >&5 $as_echo “$ac_cv_struct_nfs_fh3” >&6; }

if test “$ac_cv_struct_nfs_fh3” != notfound then cat >>confdefs.h <<_ACEOF

define am_nfs_fh3 $ac_cv_struct_nfs_fh3

_ACEOF

fi

find what name to give to the fs

if test -n “” then ac_fs_name= ac_fs_as_name=“ (from: nfs3)” else ac_fs_name=nfs3 ac_fs_as_name=“” fi

store variable name of filesystem

ac_upcase_fs_name=echo $ac_fs_name | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ac_safe=HAVE_FS_$ac_upcase_fs_name

check for cache and set it if needed

ac_tmp=echo ac_cv_fs_$ac_fs_name if eval “test \”echo '$''{'$ac_tmp'+set}'\“ = set”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } echo $ECHO_N “(cached) $ECHO_C” 1>&6 else

assume not found

eval “ac_cv_fs_$ac_fs_name=no” for ac_fs_tmp in nfs3 do ac_upcase_fs_symbol=echo $ac_fs_tmp | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# first look for MNTTYPE* cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNTTYPE_$ac_upcase_fs_symbol

yes

endif / MNTTYPE_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MOUNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MOUNT_$ac_upcase_fs_symbol

yes

endif / MOUNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNT_$ac_upcase_fs_symbol

yes

endif / MNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for GT macro (ultrix) cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef GT_$ac_upcase_fs_symbol

yes

endif / GT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# look for a loadable filesystem module (linux) if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux 2.4+) if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux redhat-5.1) if test -f /lib/modules/preferred/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/preferred/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# in addition look for statically compiled filesystem (linux) if egrep “[^a-zA-Z0-9]$ac_fs_tmp$” /proc/filesystems >/dev/null 2>&1 then eval “ac_cv_fs$ac_fs_name=yes” break fi

if test “$ac_fs_tmp” = “nfs3” -a “$ac_cv_header_linux_nfs_mount_h” = “yes” then # hack hack hack # in 6.1, which has fallback to v2/udp, we might want # to always use version 4. # in 6.0 we do not have much choice # let nfs_mount_version=“grep NFS_MOUNT_VERSION /usr/include/linux/nfs_mount.h | awk '{print $''3;}'” if test $nfs_mount_version -ge 4 then eval “ac_cv_fs_$ac_fs_name=yes” break fi fi

# run a test program for bsdi3 if test “$cross_compiling” = yes; then : { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run test program while cross compiling See `config.log' for more details” “$LINENO” 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/param.h>

include <sys/mount.h>

main() { int i; struct vfsconf vf; i = getvfsbyname(“$ac_fs_tmp”, &vf); if (i < 0) exit(1); else exit(0); }

ACEOF if ac_fn_c_try_run “$LINENO”; then : eval “ac_cv_fs$ac_fs_name=yes” break

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

done

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } fi ac_tmp_val=eval eval "echo '$''{'$ac_tmp'}'" { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_tmp_val” >&5 $as_echo “$ac_tmp_val” >&6; }

check if need to define variable

if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” = yes then cat >>confdefs.h <<_ACEOF

define $ac_safe 1

_ACEOF

append ops_.o object to AMD_FS_OBJS for automatic compilation

if first time we add something to this list, then also tell autoconf

to replace instances of it in Makefiles.

if test -z “$AMD_FS_OBJS” then AMD_FS_OBJS=“ops_${ac_fs_name}.o”

else # since this object file could have already been added before # we need to ensure we do not add it twice. case “${AMD_FS_OBJS}” in ops_${ac_fs_name}.o ) ;; * ) AMD_FS_OBJS=“$AMD_FS_OBJS ops_${ac_fs_name}.o” ;; esac fi fi

find what name to give to the fs

if test -n “” then ac_fs_name= ac_fs_as_name=“ (from: nfs4)” else ac_fs_name=nfs4 ac_fs_as_name=“” fi

store variable name of filesystem

ac_upcase_fs_name=echo $ac_fs_name | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ac_safe=HAVE_FS_$ac_upcase_fs_name

check for cache and set it if needed

ac_tmp=echo ac_cv_fs_$ac_fs_name if eval “test \”echo '$''{'$ac_tmp'+set}'\“ = set”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } echo $ECHO_N “(cached) $ECHO_C” 1>&6 else

assume not found

eval “ac_cv_fs_$ac_fs_name=no” for ac_fs_tmp in nfs4 do ac_upcase_fs_symbol=echo $ac_fs_tmp | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# first look for MNTTYPE* cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNTTYPE_$ac_upcase_fs_symbol

yes

endif / MNTTYPE_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MOUNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MOUNT_$ac_upcase_fs_symbol

yes

endif / MOUNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNT_$ac_upcase_fs_symbol

yes

endif / MNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for GT macro (ultrix) cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef GT_$ac_upcase_fs_symbol

yes

endif / GT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# look for a loadable filesystem module (linux) if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux 2.4+) if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux redhat-5.1) if test -f /lib/modules/preferred/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/preferred/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# in addition look for statically compiled filesystem (linux) if egrep “[^a-zA-Z0-9]$ac_fs_tmp$” /proc/filesystems >/dev/null 2>&1 then eval “ac_cv_fs$ac_fs_name=yes” break fi

if test “$ac_fs_tmp” = “nfs3” -a “$ac_cv_header_linux_nfs_mount_h” = “yes” then # hack hack hack # in 6.1, which has fallback to v2/udp, we might want # to always use version 4. # in 6.0 we do not have much choice # let nfs_mount_version=“grep NFS_MOUNT_VERSION /usr/include/linux/nfs_mount.h | awk '{print $''3;}'” if test $nfs_mount_version -ge 4 then eval “ac_cv_fs_$ac_fs_name=yes” break fi fi

# run a test program for bsdi3 if test “$cross_compiling” = yes; then : { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run test program while cross compiling See `config.log' for more details” “$LINENO” 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/param.h>

include <sys/mount.h>

main() { int i; struct vfsconf vf; i = getvfsbyname(“$ac_fs_tmp”, &vf); if (i < 0) exit(1); else exit(0); }

ACEOF if ac_fn_c_try_run “$LINENO”; then : eval “ac_cv_fs$ac_fs_name=yes” break

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

done

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } fi ac_tmp_val=eval eval "echo '$''{'$ac_tmp'}'" { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_tmp_val” >&5 $as_echo “$ac_tmp_val” >&6; }

check if need to define variable

if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” = yes then cat >>confdefs.h <<_ACEOF

define $ac_safe 1

_ACEOF

append ops_.o object to AMD_FS_OBJS for automatic compilation

if first time we add something to this list, then also tell autoconf

to replace instances of it in Makefiles.

if test -z “$AMD_FS_OBJS” then AMD_FS_OBJS=“ops_${ac_fs_name}.o”

else # since this object file could have already been added before # we need to ensure we do not add it twice. case “${AMD_FS_OBJS}” in ops_${ac_fs_name}.o ) ;; * ) AMD_FS_OBJS=“$AMD_FS_OBJS ops_${ac_fs_name}.o” ;; esac fi fi

find what name to give to the fs

if test -n “” then ac_fs_name= ac_fs_as_name=“ (from: lustre)” else ac_fs_name=lustre ac_fs_as_name=“” fi

store variable name of filesystem

ac_upcase_fs_name=echo $ac_fs_name | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ac_safe=HAVE_FS_$ac_upcase_fs_name

check for cache and set it if needed

ac_tmp=echo ac_cv_fs_$ac_fs_name if eval “test \”echo '$''{'$ac_tmp'+set}'\“ = set”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } echo $ECHO_N “(cached) $ECHO_C” 1>&6 else

assume not found

eval “ac_cv_fs_$ac_fs_name=no” for ac_fs_tmp in lustre do ac_upcase_fs_symbol=echo $ac_fs_tmp | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# first look for MNTTYPE* cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNTTYPE_$ac_upcase_fs_symbol

yes

endif / MNTTYPE_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MOUNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MOUNT_$ac_upcase_fs_symbol

yes

endif / MOUNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for MNT macro cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef MNT_$ac_upcase_fs_symbol

yes

endif / MNT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# now try to look for GT macro (ultrix) cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

ifdef GT_$ac_upcase_fs_symbol

yes

endif / GT_$ac_upcase_fs_symbol /

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

# check if need to terminate “for” loop if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” != no then break fi

# look for a loadable filesystem module (linux) if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux 2.4+) if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/$host_os_version/kernel/fs/$ac_fs_tmp/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# look for a loadable filesystem module (linux redhat-5.1) if test -f /lib/modules/preferred/fs/$ac_fs_tmp.ko then eval “ac_cv_fs$ac_fs_name=yes” break fi if test -f /lib/modules/preferred/fs/$ac_fs_tmp.o then eval “ac_cv_fs$ac_fs_name=yes” break fi

# in addition look for statically compiled filesystem (linux) if egrep “[^a-zA-Z0-9]$ac_fs_tmp$” /proc/filesystems >/dev/null 2>&1 then eval “ac_cv_fs$ac_fs_name=yes” break fi

if test “$ac_fs_tmp” = “nfs3” -a “$ac_cv_header_linux_nfs_mount_h” = “yes” then # hack hack hack # in 6.1, which has fallback to v2/udp, we might want # to always use version 4. # in 6.0 we do not have much choice # let nfs_mount_version=“grep NFS_MOUNT_VERSION /usr/include/linux/nfs_mount.h | awk '{print $''3;}'” if test $nfs_mount_version -ge 4 then eval “ac_cv_fs_$ac_fs_name=yes” break fi fi

# run a test program for bsdi3 if test “$cross_compiling” = yes; then : { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run test program while cross compiling See `config.log' for more details” “$LINENO” 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/param.h>

include <sys/mount.h>

main() { int i; struct vfsconf vf; i = getvfsbyname(“$ac_fs_tmp”, &vf); if (i < 0) exit(1); else exit(0); }

ACEOF if ac_fn_c_try_run “$LINENO”; then : eval “ac_cv_fs$ac_fs_name=yes” break

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

done

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for $ac_fs_name$ac_fs_as_name mntent definition” >&5 $as_echo_n “checking for $ac_fs_name$ac_fs_as_name mntent definition… ” >&6; } fi ac_tmp_val=eval eval "echo '$''{'$ac_tmp'}'" { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_tmp_val” >&5 $as_echo “$ac_tmp_val” >&6; }

check if need to define variable

if test “eval echo '$''{ac_cv_fs_'$ac_fs_name'}'” = yes then cat >>confdefs.h <<_ACEOF

define $ac_safe 1

_ACEOF

append ops_.o object to AMD_FS_OBJS for automatic compilation

if first time we add something to this list, then also tell autoconf

to replace instances of it in Makefiles.

if test -z “$AMD_FS_OBJS” then AMD_FS_OBJS=“ops_${ac_fs_name}.o”

else # since this object file could have already been added before # we need to ensure we do not add it twice. case “${AMD_FS_OBJS}” in ops_${ac_fs_name}.o ) ;; * ) AMD_FS_OBJS=“$AMD_FS_OBJS ops_${ac_fs_name}.o” ;; esac fi fi

if test -f confdefs.h then cp confdefs.h dbgcf.h fi 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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; 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 if test “x$cache_file” != “x/dev/null”; then { $as_echo “$as_me:${as_lineno-$LINENO}: updating cache $cache_file” >&5 $as_echo “$as_me: updating cache $cache_file” >&6;} if test ! -f “$cache_file” || test -h “$cache_file”; then cat confcache >“$cache_file” else case $cache_file in #( / | ?:) mv -f confcache “$cache_file”$$ && mv -f “$cache_file”$$ “$cache_file” ;; #( ) mv -f confcache “$cache_file” ;; esac fi fi else { $as_echo “$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file” >&5 $as_echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache { $as_echo “$as_me:${as_lineno-$LINENO}: SAVING CONFIGURE STATE ” >&5 $as_echo “$as_me: SAVING CONFIGURE STATE ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR TYPEDEFS ” >&5 $as_echo “$as_me: PARTICULAR TYPEDEFS ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h” >&5 $as_echo_n “checking for uid_t in sys/types.h… ” >&6; } if ${ac_cv_type_uid_t+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t” >&5 $as_echo “$ac_cv_type_uid_t” >&6; } if test $ac_cv_type_uid_t = no; then

$as_echo “#define uid_t int” >>confdefs.h

$as_echo “#define gid_t int” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking type of array argument to getgroups” >&5 $as_echo_n “checking type of array argument to getgroups… ” >&6; } if ${ac_cv_type_getgroups+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : ac_cv_type_getgroups=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Thanks to Mike Rendell for this test. / $ac_includes_default

define NGID 256

undef MAX

define MAX(x, y) ((x) > (y) ? (x) : (y))

int main () { gid_t gidset[NGID]; int i, n; union { gid_t gval; long int lval; } val;

val.lval = -1; for (i = 0; i < NGID; i++) gidset[i] = val.gval; n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1, gidset); / Exit non-zero if getgroups seems to require an array of ints. This happens when gid_t is short int but getgroups modifies an array of ints. / return n > 0 && gidset[n] != val.gval; } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_type_getgroups=gid_t else ac_cv_type_getgroups=int fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

if test $ac_cv_type_getgroups = cross; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <unistd.h>

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

fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_getgroups” >&5 $as_echo “$ac_cv_type_getgroups” >&6; }

cat >>confdefs.h <<_ACEOF

define GETGROUPS_T $ac_cv_type_getgroups

_ACEOF

ac_fn_c_check_type “$LINENO” “mode_t” “ac_cv_type_mode_t” “$ac_includes_default” if test “x$ac_cv_type_mode_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define mode_t int

_ACEOF

fi

ac_fn_c_check_type “$LINENO” “pid_t” “ac_cv_type_pid_t” “$ac_includes_default” if test “x$ac_cv_type_pid_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define pid_t int

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking return type of signal handlers” >&5 $as_echo_n “checking return type of signal handlers… ” >&6; } if ${ac_cv_type_signal+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

include <signal.h>

int main () { return *(signal (0, 0)) (0) == 1; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_signal=int else ac_cv_type_signal=void fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_signal” >&5 $as_echo “$ac_cv_type_signal” >&6; }

cat >>confdefs.h <<_ACEOF

define RETSIGTYPE $ac_cv_type_signal

_ACEOF

ac_fn_c_check_type “$LINENO” “size_t” “ac_cv_type_size_t” “$ac_includes_default” if test “x$ac_cv_type_size_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define size_t unsigned int

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h” >&5 $as_echo_n “checking for uid_t in sys/types.h… ” >&6; } if ${ac_cv_type_uid_t+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t” >&5 $as_echo “$ac_cv_type_uid_t” >&6; } if test $ac_cv_type_uid_t = no; then

$as_echo “#define uid_t int” >>confdefs.h

$as_echo “#define gid_t int” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: GENERIC TYPEDEFS ” >&5 $as_echo “$as_me: GENERIC TYPEDEFS ” >&6;} ac_fn_c_check_type “$LINENO” “time_t” “ac_cv_type_time_t” “$ac_includes_default” if test “x$ac_cv_type_time_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define time_t long

_ACEOF

fi

ac_fn_c_check_type “$LINENO” “rpcvers_t” “ac_cv_type_rpcvers_t” "

ifdef HAVE_RPC_TYPES_H

include <rpc/types.h>

endif / HAVE_RPC_TYPES_H /

“ if test "x$ac_cv_type_rpcvers_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define rpcvers_t unsigned long

_ACEOF

fi

case “${host_os}” in irix6* ) ac_fn_c_check_type “$LINENO” “pte_t” “ac_cv_type_pte_t” "

ifdef HAVE_SYS_IMMU_H

include <sys/immu.h>

endif / HAVE_SYS_IMMU_H /

“ if test "x$ac_cv_type_pte_t” = xyes; then :

else

cat >>confdefs.h <<_ACEOF

define pte_t unsigned int

_ACEOF

fi

;;

esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if plain fhandle type exists” >&5 $as_echo_n “checking if plain fhandle type exists… ” >&6; } if ${ac_cv_have_fhandle+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the type

set to a default value

ac_cv_have_fhandle=no

look for “struct nfs_fh”

if test “$ac_cv_have_fhandle” = no then

try to compile a program which may have a definition for a structure

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

int main () { fhandle a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_have_fhandle=yes else ac_cv_have_fhandle=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_have_fhandle” >&5 $as_echo “$ac_cv_have_fhandle” >&6; } if test “$ac_cv_have_fhandle” != no then $as_echo “#define HAVE_FHANDLE 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking type of mount type field in mount() call” >&5 $as_echo_n “checking type of mount type field in mount() call… ” >&6; } if ${ac_cv_mtype_type+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct type

case “${host_os_name}” in osf | freebsd2 | bsdi2 | aix | ultrix ) ac_cv_mtype_type=int ;; * ) ac_cv_mtype_type=“char ” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_mtype_type” >&5 $as_echo “$ac_cv_mtype_type” >&6; } cat >>confdefs.h <<_ACEOF

define MTYPE_TYPE $ac_cv_mtype_type

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking printf string to print type field of mount() call” >&5 $as_echo_n “checking printf string to print type field of mount() call… ” >&6; } if ${ac_cv_mtype_printf_type+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct printf type

case “${host_os_name}” in osf | freebsd2 | bsdi2 | aix | ultrix* ) ac_cv_mtype_printf_type=“%d” ;; irix3 | isc3 ) ac_cv_mtype_printf_type=“0x%x” ;; * ) ac_cv_mtype_printf_type=“%s” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_mtype_printf_type” >&5 $as_echo “$ac_cv_mtype_printf_type” >&6; } cat >>confdefs.h <<_ACEOF

define MTYPE_PRINTF_TYPE “$ac_cv_mtype_printf_type”

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking pointer type of 3rd argument to yp_order()” >&5 $as_echo_n “checking pointer type of 3rd argument to yp_order()… ” >&6; } if ${ac_cv_yp_order_outorder+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct type

case “${host_os}” in aix[1-3] | aix4.[0-2] | sunos[34] | solaris1 ) ac_cv_yp_order_outorder=int ;; solaris | svr4 | sysv4 | sunos | hpux | aix ) ac_cv_yp_order_outorder=“unsigned long” ;; linux | osf ) # DU4 man page is wrong, headers are right ac_cv_yp_order_outorder=“unsigned int” ;; * ) ac_cv_yp_order_outorder=int ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_yp_order_outorder” >&5 $as_echo “$ac_cv_yp_order_outorder” >&6; } cat >>confdefs.h <<_ACEOF

define YP_ORDER_OUTORDER_TYPE $ac_cv_yp_order_outorder

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking non-pointer type of 6th (fromlen) argument to recvfrom()” >&5 $as_echo_n “checking non-pointer type of 6th (fromlen) argument to recvfrom()… ” >&6; } if ${ac_cv_recvfrom_fromlen+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct type

case “${host_os}” in linux ) ac_cv_recvfrom_fromlen=“unsigned int” ;; aix[1-3] ) ac_cv_recvfrom_fromlen=“int” ;; aix ) ac_cv_recvfrom_fromlen=“size_t” ;; # old macosx used “int” but all newer ones use socklen_t macosx-10.[0-3] ) ac_cv_recvfrom_fromlen=“int” ;; macosx ) ac_cv_recvfrom_fromlen=“socklen_t” ;; bsd* ) ac_cv_recvfrom_fromlen=“socklen_t” ;; * ) ac_cv_recvfrom_fromlen=“int” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_recvfrom_fromlen” >&5 $as_echo “$ac_cv_recvfrom_fromlen” >&6; } cat >>confdefs.h <<_ACEOF

define RECVFROM_FROMLEN_TYPE $ac_cv_recvfrom_fromlen

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking argument type of 5rd argument to authunix_create()” >&5 $as_echo_n “checking argument type of 5rd argument to authunix_create()… ” >&6; } if ${ac_cv_auth_create_gidlist+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct type

case “${host_os_name}” in sunos[34] | bsdi2 | sysv4 | hpux10.10 | ultrix | aix4 ) ac_cv_auth_create_gidlist=“int” ;; # old macosx used “gid_t” but all newer ones use int macosx-10.[0-3] ) ac_cv_auth_create_gidlist=“gid_t” ;; macosx ) ac_cv_auth_create_gidlist=“int” ;; bsd* ) ac_cv_auth_create_gidlist=“int” ;; * ) ac_cv_auth_create_gidlist=“gid_t” ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_auth_create_gidlist” >&5 $as_echo “$ac_cv_auth_create_gidlist” >&6; } cat >>confdefs.h <<_ACEOF

define AUTH_CREATE_GIDLIST_TYPE $ac_cv_auth_create_gidlist

_ACEOF

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for type of 3rd arg (‘in’) arg to svc_sendreply()” >&5 $as_echo_n “checking for type of 3rd arg (‘in’) arg to svc_sendreply()… ” >&6; } if ${ac_cv_type_svc_in_arg+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the type

set to a default value

ac_cv_type_svc_in_arg=notfound

look for “caddr_t”

if test “$ac_cv_type_svc_in_arg” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_RPC_RPC_H

include <rpc/rpc.h>

endif / HAVE_RPC_RPC_H /

/ Prevent multiple inclusion on Ultrix 4 /

if defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER)

include <rpc/xdr.h>

endif / defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER) /

int main () { SVCXPRT *SX; xdrproc_t xp; caddr_t p; svc_sendreply(SX, xp, p);

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_svc_in_arg=“caddr_t” else ac_cv_type_svc_in_arg=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “char *”

if test “$ac_cv_type_svc_in_arg” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_RPC_RPC_H

include <rpc/rpc.h>

endif / HAVE_RPC_RPC_H /

/ Prevent multiple inclusion on Ultrix 4 /

if defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER)

include <rpc/xdr.h>

endif / defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER) /

int main () { SVCXPRT SX; xdrproc_t xp; char p; svc_sendreply(SX, xp, p);

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_svc_in_arg=“char *” else ac_cv_type_svc_in_arg=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_svc_in_arg” >&5 $as_echo “$ac_cv_type_svc_in_arg” >&6; } if test “$ac_cv_type_svc_in_arg” != notfound then cat >>confdefs.h <<_ACEOF

define SVC_IN_ARG_TYPE $ac_cv_type_svc_in_arg

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of autofs mount(2) arguments” >&5 $as_echo_n “checking for structure type of autofs mount(2) arguments… ” >&6; } if ${ac_cv_type_autofs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_autofs_args=notfound

look for “struct auto_args”

if test “$ac_cv_type_autofs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct auto_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_autofs_args=“struct auto_args” else ac_cv_type_autofs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct autofs_args”

if test “$ac_cv_type_autofs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct autofs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_autofs_args=“struct autofs_args” else ac_cv_type_autofs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_autofs_args” >&5 $as_echo “$ac_cv_type_autofs_args” >&6; } if test “$ac_cv_type_autofs_args” != notfound then cat >>confdefs.h <<_ACEOF

define autofs_args_t $ac_cv_type_autofs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of cachefs mount(2) arguments” >&5 $as_echo_n “checking for structure type of cachefs mount(2) arguments… ” >&6; } if ${ac_cv_type_cachefs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_cachefs_args=notfound

look for “struct cachefs_mountargs”

if test “$ac_cv_type_cachefs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct cachefs_mountargs a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cachefs_args=“struct cachefs_mountargs” else ac_cv_type_cachefs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_cachefs_args” >&5 $as_echo “$ac_cv_type_cachefs_args” >&6; } if test “$ac_cv_type_cachefs_args” != notfound then cat >>confdefs.h <<_ACEOF

define cachefs_args_t $ac_cv_type_cachefs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of cdfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of cdfs mount(2) arguments… ” >&6; } if ${ac_cv_type_cdfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_cdfs_args=notfound

look for “struct iso_args”

if test “$ac_cv_type_cdfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct iso_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cdfs_args=“struct iso_args” else ac_cv_type_cdfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct iso9660_args”

if test “$ac_cv_type_cdfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct iso9660_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cdfs_args=“struct iso9660_args” else ac_cv_type_cdfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct cdfs_args”

if test “$ac_cv_type_cdfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct cdfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cdfs_args=“struct cdfs_args” else ac_cv_type_cdfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct hsfs_args”

if test “$ac_cv_type_cdfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct hsfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cdfs_args=“struct hsfs_args” else ac_cv_type_cdfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct iso_specific” (ultrix)

if test “$ac_cv_type_cdfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct iso_specific a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_cdfs_args=“struct iso_specific” else ac_cv_type_cdfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_cdfs_args” >&5 $as_echo “$ac_cv_type_cdfs_args” >&6; } if test “$ac_cv_type_cdfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define cdfs_args_t $ac_cv_type_cdfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of udf mount(2) arguments” >&5 $as_echo_n “checking for structure type of udf mount(2) arguments… ” >&6; } if ${ac_cv_type_udf_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_udf_args=notfound

look for “struct udf_args”

if test “$ac_cv_type_udf_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct udf_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_udf_args=“struct udf_args” else ac_cv_type_udf_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_udf_args” >&5 $as_echo “$ac_cv_type_udf_args” >&6; } if test “$ac_cv_type_udf_args” != notfound then cat >>confdefs.h <<_ACEOF

define udf_args_t $ac_cv_type_udf_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of lofs mount(2) arguments” >&5 $as_echo_n “checking for structure type of lofs mount(2) arguments… ” >&6; } if ${ac_cv_type_lofs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_lofs_args=notfound

look for “struct lofs_args”

if test “$ac_cv_type_lofs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct lofs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_lofs_args=“struct lofs_args” else ac_cv_type_lofs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct lo_args”

if test “$ac_cv_type_lofs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct lo_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_lofs_args=“struct lo_args” else ac_cv_type_lofs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_lofs_args” >&5 $as_echo “$ac_cv_type_lofs_args” >&6; } if test “$ac_cv_type_lofs_args” != notfound then cat >>confdefs.h <<_ACEOF

define lofs_args_t $ac_cv_type_lofs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of mfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of mfs mount(2) arguments… ” >&6; } if ${ac_cv_type_mfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_mfs_args=notfound

look for “struct mfs_args”

if test “$ac_cv_type_mfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct mfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_mfs_args=“struct mfs_args” else ac_cv_type_mfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_mfs_args” >&5 $as_echo “$ac_cv_type_mfs_args” >&6; } if test “$ac_cv_type_mfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define mfs_args_t $ac_cv_type_mfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of pcfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of pcfs mount(2) arguments… ” >&6; } if ${ac_cv_type_pcfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_pcfs_args=notfound

look for “struct msdos_args”

if test “$ac_cv_type_pcfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct msdos_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_pcfs_args=“struct msdos_args” else ac_cv_type_pcfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct pc_args”

if test “$ac_cv_type_pcfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct pc_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_pcfs_args=“struct pc_args” else ac_cv_type_pcfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct pcfs_args”

if test “$ac_cv_type_pcfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct pcfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_pcfs_args=“struct pcfs_args” else ac_cv_type_pcfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct msdosfs_args”

if test “$ac_cv_type_pcfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct msdosfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_pcfs_args=“struct msdosfs_args” else ac_cv_type_pcfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_pcfs_args” >&5 $as_echo “$ac_cv_type_pcfs_args” >&6; }

if test “$ac_cv_type_pcfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define pcfs_args_t $ac_cv_type_pcfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of rfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of rfs mount(2) arguments… ” >&6; } if ${ac_cv_type_rfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_rfs_args=notfound

look for “struct rfs_args”

if test “$ac_cv_type_rfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct rfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_rfs_args=“struct rfs_args” else ac_cv_type_rfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_rfs_args” >&5 $as_echo “$ac_cv_type_rfs_args” >&6; } if test “$ac_cv_type_rfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define rfs_args_t $ac_cv_type_rfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of tmpfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of tmpfs mount(2) arguments… ” >&6; } if ${ac_cv_type_tmpfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_tmpfs_args=notfound

look for “struct tmpfs_args”

if test “$ac_cv_type_tmpfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct tmpfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_tmpfs_args=“struct tmpfs_args” else ac_cv_type_tmpfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_tmpfs_args” >&5 $as_echo “$ac_cv_type_tmpfs_args” >&6; } if test “$ac_cv_type_tmpfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define tmpfs_args_t $ac_cv_type_tmpfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of ufs mount(2) arguments” >&5 $as_echo_n “checking for structure type of ufs mount(2) arguments… ” >&6; } if ${ac_cv_type_ufs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_ufs_args=notfound

look for “struct ufs_args”

if test “$ac_cv_type_ufs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct ufs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_ufs_args=“struct ufs_args” else ac_cv_type_ufs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct efs_args” (irix)

if test “$ac_cv_type_ufs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct efs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_ufs_args=“struct efs_args” else ac_cv_type_ufs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

look for “struct ufs_specific” (ultrix)

if test “$ac_cv_type_ufs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct ufs_specific a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_ufs_args=“struct ufs_specific” else ac_cv_type_ufs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_ufs_args” >&5 $as_echo “$ac_cv_type_ufs_args” >&6; } if test “$ac_cv_type_ufs_args” != notfound then cat >>confdefs.h <<_ACEOF

define ufs_args_t $ac_cv_type_ufs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of xfs mount(2) arguments” >&5 $as_echo_n “checking for structure type of xfs mount(2) arguments… ” >&6; } if ${ac_cv_type_xfs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_xfs_args=notfound

look for “struct xfs_args”

if test “$ac_cv_type_xfs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct xfs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_xfs_args=“struct xfs_args” else ac_cv_type_xfs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_xfs_args” >&5 $as_echo “$ac_cv_type_xfs_args” >&6; } if test “$ac_cv_type_xfs_args” != notfound then cat >>confdefs.h <<_ACEOF

define xfs_args_t $ac_cv_type_xfs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for structure type of efs mount(2) arguments” >&5 $as_echo_n “checking for structure type of efs mount(2) arguments… ” >&6; } if ${ac_cv_type_efs_args+:} false; then : $as_echo_n “(cached) ” >&6 else

set to a default value

ac_cv_type_efs_args=notfound

look for “struct efs_args”

if test “$ac_cv_type_efs_args” = notfound then

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_SYS_PARAM_H

include <sys/param.h>

endif / HAVE_SYS_PARAM_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_NETINET_IN_H

include <netinet/in.h>

endif / HAVE_NETINET_IN_H /

ifdef HAVE_SYS_TIUSER_H

include <sys/tiuser.h>

endif / HAVE_SYS_TIUSER_H /

ifdef HAVE_SYS_MOUNT_H

ifndef NFSCLIENT

define NFSCLIENT

endif / not NFSCLIENT /

ifndef PCFS

define PCFS

endif / not PCFS /

ifndef LOFS

define LOFS

endif / not LOFS /

ifndef RFS

define RFS

endif / not RFS /

ifndef MSDOSFS

define MSDOSFS

endif / not MSDOSFS /

ifndef MFS

define MFS 1

endif / not MFS /

ifndef CD9660

define CD9660

endif / not CD9660 /

ifndef NFS

define NFS

endif / not NFS /

include <sys/mount.h>

endif / HAVE_SYS_MOUNT_H /

ifdef HAVE_SYS_VMOUNT_H

include <sys/vmount.h>

endif / HAVE_SYS_VMOUNT_H /

/ * There is no point in including this on a glibc2 system * we’re only asking for trouble /

if defined HAVE_LINUX_FS_H && (!defined GLIBC || GLIBC < 2)

/ * There’s a conflict of definitions on redhat alpha linux between * <netinet/in.h> and <linux/fs.h>. * Also a conflict in definitions of ntohl/htonl in RH-5.1 sparc64 * between <netinet/in.h> and <linux/byteorder/generic.h> (2.1 kernels). /

ifdef HAVE_SOCKETBITS_H

define _LINUX_SOCKET_H

undef BLKFLSBUF

undef BLKGETSIZE

undef BLKRAGET

undef BLKRASET

undef BLKROGET

undef BLKROSET

undef BLKRRPART

undef MS_MGC_VAL

undef MS_RMT_MASK

endif / HAVE_SOCKETBITS_H /

ifdef HAVE_LINUX_POSIX_TYPES_H

include <linux/posix_types.h>

endif / HAVE_LINUX_POSIX_TYPES_H /

ifndef _LINUX_BYTEORDER_GENERIC_H

define _LINUX_BYTEORDER_GENERIC_H

endif / _LINUX_BYTEORDER_GENERIC_H /

ifndef LINUX_STRING_H

define LINUX_STRING_H

endif / not LINUX_STRING_H /

ifdef HAVE_LINUX_KDEV_T_H

define KERNEL

include <linux/kdev_t.h>

undef KERNEL

endif / HAVE_LINUX_KDEV_T_H /

ifdef HAVE_LINUX_LIST_H

define KERNEL

include <linux/list.h>

undef KERNEL

endif / HAVE_LINUX_LIST_H /

include <linux/fs.h>

endif / HAVE_LINUX_FS_H && (!GLIBC || GLIBC < 2) /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_SYS_FS_CACHEFS_FS_H

include <sys/fs/cachefs_fs.h>

endif / HAVE_SYS_FS_CACHEFS_FS_H /

ifdef HAVE_SYS_FS_PC_FS_H

include <sys/fs/pc_fs.h>

endif / HAVE_SYS_FS_PC_FS_H /

ifdef HAVE_MSDOSFS_MSDOSFSMOUNT_H

include <msdosfs/msdosfsmount.h>

endif / HAVE_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H

include <fs/msdosfs/msdosfsmount.h>

endif / HAVE_FS_MSDOSFS_MSDOSFSMOUNT_H /

ifdef HAVE_SYS_FS_TMP_H

include <sys/fs/tmp.h>

endif / HAVE_SYS_FS_TMP_H /

ifdef HAVE_FS_TMPFS_TMPFS_ARGS_H

include <fs/tmpfs/tmpfs_args.h>

endif / HAVE_FS_TMPFS_TMPFS_ARGS_H /

ifdef HAVE_UFS_UFS_MOUNT_H

include <ufs/ufs_mount.h>

endif / HAVE_UFS_UFS_MOUNT_H /

ifdef HAVE_UFS_UFS_UFSMOUNT_H

ifndef MAXQUOTAS

define MAXQUOTAS 2

endif / not MAXQUOTAS /

struct netexport { int this_is_SO_wrong; }; / for bsdi-2.1 / / netbsd-1.4 does’t protect <ufs/ufs/ufsmount.h> /

ifndef _UFS_UFS_UFSMOUNT_H

include <ufs/ufs/ufsmount.h>

define _UFS_UFS_UFSMOUNT_H

endif / not _UFS_UFS_UFSMOUNT_H /

endif / HAVE_UFS_UFS_UFSMOUNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_FS_EFS_EFS_MOUNT_H

include <fs/efs/efs_mount.h>

endif / HAVE_FS_EFS_EFS_MOUNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_CDFS_CDFS_MOUNT_H

include <cdfs/cdfs_mount.h>

endif / HAVE_CDFS_CDFS_MOUNT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_CDFS_CDFSMOUNT_H

include <cdfs/cdfsmount.h>

endif / HAVE_CDFS_CDFSMOUNT_H /

ifdef HAVE_ISOFS_CD9660_CD9660_MOUNT_H

include <isofs/cd9660/cd9660_mount.h>

endif / HAVE_ISOFS_CD9660_CD9660_MOUNT_H /

ifdef HAVE_FS_UDF_UDF_MOUNT_H

include <fs/udf/udf_mount.h>

endif / HAVE_FS_UDF_UDF_MOUNT_H /

int main () { struct efs_args a;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_efs_args=“struct efs_args” else ac_cv_type_efs_args=notfound fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_efs_args” >&5 $as_echo “$ac_cv_type_efs_args” >&6; } if test “$ac_cv_type_efs_args” != notfound then cat >>confdefs.h <<_ACEOF

define efs_args_t $ac_cv_type_efs_args

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for xdrproc_t” >&5 $as_echo_n “checking for xdrproc_t… ” >&6; } if ${ac_cv_type_xdrproc_t+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which may have a definition for the type

look for “xdrproc_t”

try to compile a program which may have a definition for a structure

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

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_RPC_RPC_H

include <rpc/rpc.h>

endif / HAVE_RPC_RPC_H /

/ Prevent multiple inclusion on Ultrix 4 /

if defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER)

include <rpc/xdr.h>

endif / defined(HAVE_RPC_XDR_H) && !defined(XDR_HEADER) /

int main () { xdrproc_t xdr_int;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_type_xdrproc_t=yes else ac_cv_type_xdrproc_t=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_xdrproc_t” >&5 $as_echo “$ac_cv_type_xdrproc_t” >&6; } if test “$ac_cv_type_xdrproc_t” = yes then cat >>confdefs.h <<_ACEOF

define XDRPROC_T_TYPE xdrproc_t

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: PARTICULAR COMPILER CHARACTERISTICS ” >&5 $as_echo “$as_me: PARTICULAR COMPILER CHARACTERISTICS ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian” >&5 $as_echo_n “checking whether byte ordering is bigendian… ” >&6; } if ${ac_cv_c_bigendian+:} false; then : $as_echo_n “(cached) ” >&6 else ac_cv_c_bigendian=unknown # See if we’re dealing with a universal compiler. cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

ifndef APPLE_CC

       not a universal capable compiler
     #endif
     typedef int dummy;

_ACEOF if ac_fn_c_try_compile “$LINENO”; then :

# Check for potential -arch flags.  It is not universal unless
# there are at least two -arch flags with different values.
ac_arch=
ac_prev=
for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
 if test -n "$ac_prev"; then
   case $ac_word in
     i?86 | x86_64 | ppc | ppc64)
       if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
     ac_arch=$ac_word
       else
     ac_cv_c_bigendian=universal
     break
       fi
       ;;
   esac
   ac_prev=
 elif test "x$ac_word" = "x-arch"; then
   ac_prev=arch
 fi
   done

fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_c_bigendian = unknown; then # See if sys/param.h defines the BYTE_ORDER macro. cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

     #include <sys/param.h>

int main () {

if ! (defined BYTE_ORDER && defined BIG_ENDIAN \

         && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
         && LITTLE_ENDIAN)
      bogus endian macros
     #endif

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

    #include <sys/param.h>

int main () {

if BYTE_ORDER != BIG_ENDIAN

     not big endian
    #endif

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # See if <limits.h> defines LITTLE_ENDIAN or BIG_ENDIAN (e.g., Solaris). cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include <limits.h>

int main () {

if ! (defined LITTLE_ENDIAN || defined BIG_ENDIAN)

      bogus endian macros
     #endif

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <limits.h>

int main () {

ifndef _BIG_ENDIAN

     not big endian
    #endif

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # Compile a test program. if test “$cross_compiling” = yes; then : # Try to guess by grepping values from an object file. cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; int use_ascii (int i) { return ascii_mm[i] + ascii_ii[i]; } short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; int use_ebcdic (int i) { return ebcdic_mm[i] + ebcdic_ii[i]; } extern int foo;

int main () { return use_ascii (foo) == use_ebcdic (foo); ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then if test “$ac_cv_c_bigendian” = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. / $ac_includes_default int main () {

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

; return 0; } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_c_bigendian=no else ac_cv_c_bigendian=yes fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian” >&5 $as_echo “$ac_cv_c_bigendian” >&6; } case $ac_cv_c_bigendian in #( yes) $as_echo “#define WORDS_BIGENDIAN 1” >>confdefs.h ;; #( no) ;; #( universal)

$as_echo “#define AC_APPLE_UNIVERSAL_BUILD 1” >>confdefs.h

 ;; #(

*) as_fn_error $? “unknown endianness presetting ac_cv_c_bigendian=no (or yes) will help” “$LINENO” 5 ;; esac

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const” >&5 $as_echo_n “checking for an ANSI C-conforming const… ” >&6; } if ${ac_cv_c_const+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

ifndef __cplusplus

/ Ultrix mips cc rejects this sort of thing. / typedef int charset[2]; const charset cs = { 0, 0 }; / 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 sort of thing. / char tx; char t = &tx; 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 sort of thing, saying “k.c”, line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. / struct s { int j; const int ap[3]; } bx; struct s b = &bx; 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 if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_const=yes else ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const” >&5 $as_echo “$ac_cv_c_const” >&6; } if test $ac_cv_c_const = no; then

$as_echo “#define const /**/” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for inline” >&5 $as_echo_n “checking for inline… ” >&6; } if ${ac_cv_c_inline+:} false; then : $as_echo_n “(cached) ” >&6 else ac_cv_c_inline=no for ac_kw in inline inline _inline; do cat confdefs.h - <<ACEOF >conftest.$ac_ext / 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 if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_inline=$ac_kw fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test “$ac_cv_c_inline” != no && break done

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline” >&5 $as_echo “$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

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for working volatile” >&5 $as_echo_n “checking for working volatile… ” >&6; } if ${ac_cv_c_volatile+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

int main () {

volatile int x; int * volatile y = (int *) 0; return !x && !y; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_volatile=yes else ac_cv_c_volatile=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_volatile” >&5 $as_echo “$ac_cv_c_volatile” >&6; } if test $ac_cv_c_volatile = no; then

$as_echo “#define volatile /**/” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: GENERIC COMPILER CHARACTERISTICS ” >&5 $as_echo “$as_me: GENERIC COMPILER CHARACTERISTICS ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if compiler can handle void ” >&5 $as_echo_n “checking if compiler can handle void … ” >&6; } if ${ac_cv_c_void_p+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program which uses void *

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

int main () {

void *vp;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_c_void_p=yes else ac_cv_c_void_p=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_void_p” >&5 $as_echo “$ac_cv_c_void_p” >&6; } if test “$ac_cv_c_void_p” = yes then $as_echo “#define voidp void *” >>confdefs.h

else $as_echo “#define voidp char *” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if compiler can handle variable-length macros” >&5 $as_echo_n “checking if compiler can handle variable-length macros… ” >&6; } if ${ac_cv_varargs_macros+:} false; then : $as_echo_n “(cached) ” >&6 else

try C99 style

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

define foo(str,size,fmt,…) bar(FILE,LINE,(str),(size),(fmt),VA_ARGS)

int main () {

char a[80]; foo(a, sizeof(a), “%d,%d”, 1, 2);

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_varargs_macros=c99 else # else try gcc style cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

define foo(str,size,args…) bar(FILE,LINE,(str),(size),(fmt),args)

int main () {

char a80; foo(a, sizeof(a), “%d,%d”, 1, 2);

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_varargs_macros=gcc else ac_cv_varargs_macros=none 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 { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_varargs_macros” >&5 $as_echo “$ac_cv_varargs_macros” >&6; } if test “$ac_cv_varargs_macros” = c99 then

$as_echo “#define HAVE_C99_VARARGS_MACROS 1” >>confdefs.h

else if test “$ac_cv_varargs_macros” = gcc then

$as_echo “#define HAVE_GCC_VARARGS_MACROS 1” >>confdefs.h

fi fi

if test -f confdefs.h then cp confdefs.h dbgcf.h fi 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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; 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 if test “x$cache_file” != “x/dev/null”; then { $as_echo “$as_me:${as_lineno-$LINENO}: updating cache $cache_file” >&5 $as_echo “$as_me: updating cache $cache_file” >&6;} if test ! -f “$cache_file” || test -h “$cache_file”; then cat confcache >“$cache_file” else case $cache_file in #( / | ?:) mv -f confcache “$cache_file”$$ && mv -f “$cache_file”$$ “$cache_file” ;; #( ) mv -f confcache “$cache_file” ;; esac fi fi else { $as_echo “$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file” >&5 $as_echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache { $as_echo “$as_me:${as_lineno-$LINENO}: SAVING CONFIGURE STATE ” >&5 $as_echo “$as_me: SAVING CONFIGURE STATE ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: EXTERNAL DEFINITIONS ” >&5 $as_echo “$as_me: EXTERNAL DEFINITIONS ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if external definition for sys_errlist exists” >&5 $as_echo_n “checking if external definition for sys_errlist exists… ” >&6; } if ${ac_cv_extern_sys_errlist+:} false; then : $as_echo_n “(cached) ” >&6 else

try to locate pattern in header files

pattern=“(extern)?.char.sys_errlist.*[]”

pattern=“(extern)?.char.sys_errlist.” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. */

ifdef HAVE_STDIO_H

include <stdio.h>

endif / HAVE_STDIO_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_ERRNO_H

include <errno.h>

endif / HAVE_ERRNO_H /

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

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_extern_sys_errlist” >&5 $as_echo “$ac_cv_extern_sys_errlist” >&6; }

check if need to define variable

if test “$ac_cv_extern_sys_errlist” = yes then $as_echo “#define HAVE_EXTERN_SYS_ERRLIST 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if external definition for optarg exists” >&5 $as_echo_n “checking if external definition for optarg exists… ” >&6; } if ${ac_cv_extern_optarg+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile program that uses the variable

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

ifdef HAVE_STDIO_H

include <stdio.h>

endif / HAVE_STDIO_H /

ifdef HAVE_UNISTD_H

include <unistd.h>

endif / HAVE_UNISTD_H /

ifdef HAVE_STDLIB_H

include <stdlib.h>

endif / HAVE_STDLIB_H /

ifdef HAVE_SYS_ERRNO_H

include <sys/errno.h>

endif / HAVE_SYS_ERRNO_H /

ifdef HAVE_ERRNO_H

include <errno.h>

endif / HAVE_ERRNO_H /

int main () {

char *cp = optarg;

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_extern_optarg=yes else ac_cv_extern_optarg=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_extern_optarg” >&5 $as_echo “$ac_cv_extern_optarg” >&6; } if test “$ac_cv_extern_optarg” = yes then $as_echo “#define HAVE_EXTERN_OPTARG 1” >>confdefs.h

fi

for ac_tmp_arg in clnt_spcreateerror \ clnt_sperrno \ free \ get_myaddress \ getccent \ getdomainname \ getdtablesize \ gethostname \ getlogin \ getpagesize \ getwd \ hosts_ctl \ innetgr \ mkstemp \ mntctl \ sbrk \ seteuid \ setitimer \ sleep \ strcasecmp \ strdup \ strlcat \ strlcpy \ strstr \ ualarm \ usleep \ wait3 \ vsnprintf \ xdr_callmsg \ xdr_opaque_auth \

do

store variable name for external definition

ac_upcase_extern_name=echo $ac_tmp_arg | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ac_safe=HAVE_EXTERN_$ac_upcase_extern_name

check for cached value and set it if needed

ac_tmp=echo ac_cv_extern_$ac_tmp_arg if eval “test \”echo '$''{'$ac_tmp'+set}'\“ = set”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking external function definition for $ac_tmp_arg” >&5 $as_echo_n “checking external function definition for $ac_tmp_arg… ” >&6; } echo $ECHO_N “(cached) $ECHO_C” 1>&6 else

the old pattern assumed that the complete external definition is on one

line but on some systems it is split over several lines, so only match

beginning of the extern definition including the opening parenthesis.

pattern=“(extern)?.[^a-zA-Z0-9]$ac_tmp_arg[^a-zA-Z0-9]?.(.).;”

pattern=“(extern)?.[^a-zA-Z0-9]$ac_tmp_arg[^a-zA-Z0-9]?.(” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_WAIT_H

include <sys/wait.h>

endif / HAVE_SYS_WAIT_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

if defined(_AIX) && defined(HAVE_SYS_VMOUNT_H)

include <sys/vmount.h>

endif / defined(_AIX) && defined(HAVE_SYS_VMOUNT_H) /

ifdef HAVE_STDIO_H

include <stdio.h>

endif / HAVE_STDIO_H /

ifdef HAVE_STDLIB_H

include <stdlib.h>

endif / HAVE_STDLIB_H /

if HAVE_UNISTD_H

include <unistd.h>

endif / HAVE_UNISTD_H /

if HAVE_STRING_H

include <string.h>

endif / HAVE_STRING_H /

ifdef HAVE_STRINGS_H

include <strings.h>

endif / HAVE_STRINGS_H /

ifdef HAVE_NETDB_H

include <netdb.h>

endif / HAVE_NETDB_H /

ifdef HAVE_CLUSTER_H

include <cluster.h>

endif / HAVE_CLUSTER_H /

ifdef HAVE_RPC_RPC_H

/ * Turn on PORTMAP, so that additional header files would get included * and the important definition for UDPMSGSIZE is included too. /

ifndef PORTMAP

define PORTMAP

endif / not PORTMAP /

include <rpc/rpc.h>

ifndef XDRPROC_T_TYPE

typedef bool_t (xdrproc_t) __P ((XDR , __ptr_t, …));

endif / not XDRPROC_T_TYPE /

endif / HAVE_RPC_RPC_H /

if defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP)

include <tcpd.h>

endif / defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP) /

ACEOF if (eval “$ac_cpp conftest.$ac_ext”) 2>&5 | $EGREP “${pattern}” >/dev/null 2>&1; then : eval “ac_cv_extern$ac_tmp_arg=yes” else eval “ac_cv_extern_$ac_tmp_arg=no” fi rm -f conftest*

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking external function definition for $ac_tmp_arg” >&5 $as_echo_n “checking external function definition for $ac_tmp_arg… ” >&6; } fi ac_tmp_val=eval eval "echo '$''{'$ac_tmp'}'" { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_tmp_val” >&5 $as_echo “$ac_tmp_val” >&6; }

check if need to define variable

if test “eval echo '$''{ac_cv_extern_'$ac_tmp_arg'}'” = yes then cat >>confdefs.h <<_ACEOF

define $ac_safe 1

_ACEOF

fi

done

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

store variable name for external definition

ac_upcase_extern_name=echo ldap_enable_cache | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ac_safe=HAVE_EXTERN_$ac_upcase_extern_name

check for cached value and set it if needed

ac_tmp=echo ac_cv_extern_ldap_enable_cache if eval “test \”echo '$''{'$ac_tmp'+set}'\“ = set”; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking external function definition for ldap_enable_cache” >&5 $as_echo_n “checking external function definition for ldap_enable_cache… ” >&6; } echo $ECHO_N “(cached) $ECHO_C” 1>&6 else

the old pattern assumed that the complete external definition is on one

line but on some systems it is split over several lines, so only match

beginning of the extern definition including the opening parenthesis.

pattern=“(extern)?.[^a-zA-Z0-9]ldap_enable_cache[^a-zA-Z0-9]?.(.).;”

pattern=“(extern)?.([^a-zA-Z0-9])?ldap_enable_cache[^a-zA-Z0-9]?.(” cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

ifdef HAVE_SYS_TYPES_H

include <sys/types.h>

endif / HAVE_SYS_TYPES_H /

ifdef HAVE_SYS_WAIT_H

include <sys/wait.h>

endif / HAVE_SYS_WAIT_H /

if TIME_WITH_SYS_TIME

include <sys/time.h>

include <time.h>

else / not TIME_WITH_SYS_TIME /

if HAVE_SYS_TIME_H

include <sys/time.h>

else / not HAVE_SYS_TIME_H /

include <time.h>

endif / not HAVE_SYS_TIME_H /

endif / not TIME_WITH_SYS_TIME /

ifdef HAVE_STDIO_H

include <stdio.h>

endif / HAVE_STDIO_H /

ifdef HAVE_STDLIB_H

include <stdlib.h>

endif / HAVE_STDLIB_H /

if HAVE_UNISTD_H

include <unistd.h>

endif / HAVE_UNISTD_H /

if HAVE_STRING_H

include <string.h>

endif / HAVE_STRING_H /

ifdef HAVE_STRINGS_H

include <strings.h>

endif / HAVE_STRINGS_H /

ifdef HAVE_NETDB_H

include <netdb.h>

endif / HAVE_NETDB_H /

ifdef HAVE_CLUSTER_H

include <cluster.h>

endif / HAVE_CLUSTER_H /

ifdef HAVE_RPC_RPC_H

/ * Turn on PORTMAP, so that additional header files would get included * and the important definition for UDPMSGSIZE is included too. /

ifndef PORTMAP

define PORTMAP

endif / not PORTMAP /

include <rpc/rpc.h>

ifndef XDRPROC_T_TYPE

typedef bool_t (xdrproc_t) __P ((XDR , __ptr_t, …));

endif / not XDRPROC_T_TYPE /

endif / HAVE_RPC_RPC_H /

if defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP)

include <tcpd.h>

endif / defined(HAVE_TCPD_H) && defined(HAVE_LIBWRAP) /

ifdef HAVE_LDAP_H

include <ldap.h>

endif / HAVE_LDAP_H /

ifdef HAVE_LBER_H

include <lber.h>

endif / HAVE_LBER_H /

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

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking external function definition for ldap_enable_cache” >&5 $as_echo_n “checking external function definition for ldap_enable_cache… ” >&6; } fi ac_tmp_val=eval eval "echo '$''{'$ac_tmp'}'" { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_tmp_val” >&5 $as_echo “$ac_tmp_val” >&6; }

check if need to define variable

if test “eval echo '$''{ac_cv_extern_'ldap_enable_cache'}'” = yes then cat >>confdefs.h <<_ACEOF

define $ac_safe 1

_ACEOF

fi

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: C PREPROCESSOR MACROS ” >&5 $as_echo “$as_me: C PREPROCESSOR MACROS ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: SYSTEM SERVICES ” >&5 $as_echo “$as_me: SYSTEM SERVICES ” >&6;} { $as_echo “$as_me:${as_lineno-$LINENO}: checking for long file names” >&5 $as_echo_n “checking for long file names… ” >&6; } if ${ac_cv_sys_long_file_names+:} false; then : $as_echo_n “(cached) ” >&6 else ac_cv_sys_long_file_names=yes

Test for long file names in all the places we know might matter:

. the current directory, where building will happen

$prefix/lib where we will be installing things

$exec_prefix/lib likewise

$TMPDIR if set, where it might want to write temporary files

/tmp where it might want to write temporary files

/var/tmp likewise

/usr/tmp likewise

for ac_dir in . “$TMPDIR” /tmp /var/tmp /usr/tmp “$prefix/lib” “$exec_prefix/lib”; do # Skip $TMPDIR if it is empty or bogus, and skip $exec_prefix/lib # in the usual case where exec_prefix is ‘${prefix}’. case $ac_dir in #( . | / | ?:[\/]) ;; #( *) continue;; esac test -w “$ac_dir/.” || continue # It is less confusing to not echo anything here. ac_xdir=$ac_dir/cf$$ (umask 077 && mkdir “$ac_xdir” 2>/dev/null) || continue ac_tf1=$ac_xdir/conftest9012345 ac_tf2=$ac_xdir/conftest9012346 touch “$ac_tf1” 2>/dev/null && test -f “$ac_tf1” && test ! -f “$ac_tf2” || ac_cv_sys_long_file_names=no rm -f -r “$ac_xdir” 2>/dev/null test $ac_cv_sys_long_file_names = no && break done fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_long_file_names” >&5 $as_echo “$ac_cv_sys_long_file_names” >&6; } if test $ac_cv_sys_long_file_names = yes; then

$as_echo “#define HAVE_LONG_FILE_NAMES 1” >>confdefs.h

fi

Check whether –enable-largefile was given.

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

if test “$enable_largefile” != no; then

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files” >&5 $as_echo_n “checking for special C compiler options needed for large files… ” >&6; } if ${ac_cv_sys_largefile_CC+:} false; then : $as_echo_n “(cached) ” >&6 else ac_cv_sys_largefile_CC=no if test “$GCC” != yes; then ac_save_CC=$CC while :; do # IRIX 6.2 and later do not support large files by default, # so use the C compiler’s -n32 option if that helps. cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

/ Check that off_t can represent 2**63 - 1 correctly. We can’t simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. /

define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))

int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main () {

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : break fi rm -f core conftest.err conftest.$ac_objext CC=“$CC -n32” if ac_fn_c_try_compile “$LINENO”; then : ac_cv_sys_largefile_CC=‘ -n32’; break fi rm -f core conftest.err conftest.$ac_objext break done CC=$ac_save_CC rm -f conftest.$ac_ext fi fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC” >&5 $as_echo “$ac_cv_sys_largefile_CC” >&6; } if test “$ac_cv_sys_largefile_CC” != no; then CC=$CC$ac_cv_sys_largefile_CC fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for FILE_OFFSET_BITS value needed for large files” >&5 $as_echo_n “checking for FILE_OFFSET_BITS value needed for large files… ” >&6; } if ${ac_cv_sys_file_offset_bits+:} false; then : $as_echo_n “(cached) ” >&6 else while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

/ Check that off_t can represent 2**63 - 1 correctly. We can’t simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. /

define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))

int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_sys_file_offset_bits=no; break fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

define _FILE_OFFSET_BITS 64

include <sys/types.h>

/ Check that off_t can represent 2**63 - 1 correctly. We can’t simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. /

define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))

int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_sys_file_offset_bits=64; break fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_sys_file_offset_bits=unknown break done fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits” >&5 $as_echo “$ac_cv_sys_file_offset_bits” >&6; } case $ac_cv_sys_file_offset_bits in #( no | unknown) ;; *) cat >>confdefs.h <<ACEOF

define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits

ACEOF ;; esac rm -rf conftest* if test $ac_cv_sys_file_offset_bits = unknown; then { $as_echo “$as_me:${as_lineno-$LINENO}: checking for LARGE_FILES value needed for large files” >&5 $as_echo_n “checking for LARGE_FILES value needed for large files… ” >&6; } if ${ac_cv_sys_large_files+:} false; then : $as_echo_n “(cached) ” >&6 else while :; do cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include <sys/types.h>

/ Check that off_t can represent 2**63 - 1 correctly. We can’t simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. /

define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))

int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_sys_large_files=no; break fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

define _LARGE_FILES 1

include <sys/types.h>

/ Check that off_t can represent 2**63 - 1 correctly. We can’t simply define LARGE_OFF_T to be 9223372036854775807, since some C++ compilers masquerading as C compilers incorrectly reject 9223372036854775807. /

define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))

int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1]; int main () {

; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_sys_large_files=1; break fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_sys_large_files=unknown break done fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files” >&5 $as_echo “$ac_cv_sys_large_files” >&6; } case $ac_cv_sys_large_files in #( no | unknown) ;; *) cat >>confdefs.h <<ACEOF

define _LARGE_FILES $ac_cv_sys_large_files

_ACEOF ;; esac rm -rf conftest* fi

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for restartable system calls” >&5 $as_echo_n “checking for restartable system calls… ” >&6; } if ${ac_cv_sys_restartable_syscalls+:} false; then : $as_echo_n “(cached) ” >&6 else if test “$cross_compiling” = yes; then : { { $as_echo “$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':” >&5 $as_echo “$as_me: error: in `$ac_pwd':” >&2;} as_fn_error $? “cannot run test program while cross compiling See `config.log' for more details” “$LINENO” 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. / / Exit 0 (true) if wait returns something other than -1, i.e. the pid of the child, which means that wait was restarted after getting the signal. /

$ac_includes_default

include <signal.h>

ifdef HAVE_SYS_WAIT_H

include <sys/wait.h>

endif

/ Some platforms explicitly require an extern “C” signal handler when using C++. /

ifdef __cplusplus

extern “C” void ucatch (int dummy) { }

else

void ucatch (dummy) int dummy; { }

endif

int main () { int i = fork (), status;

if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); return 0; }

signal (SIGINT, ucatch);

status = wait (&i); if (status == -1) wait (&i);

return status == -1; } _ACEOF if ac_fn_c_try_run “$LINENO”; then : ac_cv_sys_restartable_syscalls=yes else ac_cv_sys_restartable_syscalls=no fi rm -f core .core core.conftest. gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_restartable_syscalls” >&5 $as_echo “$ac_cv_sys_restartable_syscalls” >&6; } if test $ac_cv_sys_restartable_syscalls = yes; then

$as_echo “#define HAVE_RESTARTABLE_SYSCALLS 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking network transport type” >&5 $as_echo_n “checking network transport type… ” >&6; } if ${ac_cv_transport_type+:} false; then : $as_echo_n “(cached) ” >&6 else

select the correct type

case “${host_os_name}” in solaris1 | sunos[34] | hpux[6-9] | hpux10 ) ac_cv_transport_type=sockets ;; solaris | sunos | hpux* ) ac_cv_transport_type=tli ;; * ) ac_cv_transport_type=sockets ;; esac

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_transport_type” >&5 $as_echo “$ac_cv_transport_type” >&6; } am_utils_link_files=${am_utils_link_files}libamu/transputil.c:conf/transp/transp_${ac_cv_transport_type}.c" "

append transport utilities object to LIBOBJS for automatic compilation

case “ $LIBOBJS ” in “ transputil.$ac_objext ” ) ;; *) LIBOBJS=“$LIBOBJS transputil.$ac_objext” ;; esac

if test $ac_cv_transport_type = tli then $as_echo “#define HAVE_TRANSPORT_TYPE_TLI 1” >>confdefs.h

fi

if test -f confdefs.h then cp confdefs.h dbgcf.h fi 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) { $as_echo “$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline” >&5 $as_echo “$as_me: WARNING: cache variable $ac_var contains a newline” >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; 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 if test “x$cache_file” != “x/dev/null”; then { $as_echo “$as_me:${as_lineno-$LINENO}: updating cache $cache_file” >&5 $as_echo “$as_me: updating cache $cache_file” >&6;} if test ! -f “$cache_file” || test -h “$cache_file”; then cat confcache >“$cache_file” else case $cache_file in #( / | ?:) mv -f confcache “$cache_file”$$ && mv -f “$cache_file”$$ “$cache_file” ;; #( ) mv -f confcache “$cache_file” ;; esac fi fi else { $as_echo “$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file” >&5 $as_echo “$as_me: not updating unwritable cache $cache_file” >&6;} fi fi rm -f confcache { $as_echo “$as_me:${as_lineno-$LINENO}: SAVING CONFIGURE STATE ” >&5 $as_echo “$as_me: SAVING CONFIGURE STATE ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: FIELDS WITHIN STRUCTURES ” >&5 $as_echo “$as_me: FIELDS WITHIN STRUCTURES ” >&6;}

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for fd_set.fds_bits” >&5 $as_echo_n “checking for fd_set.fds_bits… ” >&6; } if ${ac_cv_member_fd_set_fds_bits+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static fd_set ac_aggr; if (&(ac_aggr.fds_bits)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_fd_set_fds_bits=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static fd_set ac_aggr; if (sizeof ac_aggr.fds_bits) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_fd_set_fds_bits=yes else ac_cv_member_fd_set_fds_bits=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_fd_set_fds_bits” >&5 $as_echo “$ac_cv_member_fd_set_fds_bits” >&6; } if test $ac_cv_member_fd_set_fds_bits = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_FD_SET_FDS_BITS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for mntent_t.mnt_cnode” >&5 $as_echo_n “checking for mntent_t.mnt_cnode… ” >&6; } if ${ac_cv_member_mntent_t_mnt_cnode+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (&(ac_aggr.mnt_cnode)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_cnode=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (sizeof ac_aggr.mnt_cnode) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_cnode=yes else ac_cv_member_mntent_t_mnt_cnode=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_mntent_t_mnt_cnode” >&5 $as_echo “$ac_cv_member_mntent_t_mnt_cnode” >&6; } if test $ac_cv_member_mntent_t_mnt_cnode = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_MNTENT_T_MNT_CNODE 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for mntent_t.mnt_ro” >&5 $as_echo_n “checking for mntent_t.mnt_ro… ” >&6; } if ${ac_cv_member_mntent_t_mnt_ro+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (&(ac_aggr.mnt_ro)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_ro=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (sizeof ac_aggr.mnt_ro) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_ro=yes else ac_cv_member_mntent_t_mnt_ro=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_mntent_t_mnt_ro” >&5 $as_echo “$ac_cv_member_mntent_t_mnt_ro” >&6; } if test $ac_cv_member_mntent_t_mnt_ro = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_MNTENT_T_MNT_RO 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for mntent_t.mnt_time” >&5 $as_echo_n “checking for mntent_t.mnt_time… ” >&6; } if ${ac_cv_member_mntent_t_mnt_time+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (&(ac_aggr.mnt_time)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_time=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static mntent_t ac_aggr; if (sizeof ac_aggr.mnt_time) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_mntent_t_mnt_time=yes else ac_cv_member_mntent_t_mnt_time=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_mntent_t_mnt_time” >&5 $as_echo “$ac_cv_member_mntent_t_mnt_time” >&6; } if test $ac_cv_member_mntent_t_mnt_time = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_MNTENT_T_MNT_TIME 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking if mntent_t field mnt_time exist as type string” >&5 $as_echo_n “checking if mntent_t field mnt_time exist as type string… ” >&6; } if ${ac_cv_field_mntent_t_mnt_time_string+:} false; then : $as_echo_n “(cached) ” >&6 else

try to compile a program

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

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

else / not HAVE_STRUCT_MNTTAB /

error XXX: could not find definition for struct mntent or struct mnttab!

endif / not HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

int main () {

mntent_t mtt; char *cp = “test”; int i; mtt.mnt_time = cp; i = mtt.mnt_time[0];

; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_field_mntent_t_mnt_time_string=yes else ac_cv_field_mntent_t_mnt_time_string=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_field_mntent_t_mnt_time_string” >&5 $as_echo “$ac_cv_field_mntent_t_mnt_time_string” >&6; } if test “$ac_cv_field_mntent_t_mnt_time_string” = yes then $as_echo “#define HAVE_MNTENT_T_MNT_TIME_STRING 1” >>confdefs.h

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.flags” >&5 $as_echo_n “checking for cdfs_args_t.flags… ” >&6; } if ${ac_cv_member_cdfs_args_t_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_flags=yes else ac_cv_member_cdfs_args_t_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_flags” >&5 $as_echo “$ac_cv_member_cdfs_args_t_flags” >&6; } if test $ac_cv_member_cdfs_args_t_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.fspec” >&5 $as_echo_n “checking for cdfs_args_t.fspec… ” >&6; } if ${ac_cv_member_cdfs_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_fspec=yes else ac_cv_member_cdfs_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_fspec” >&5 $as_echo “$ac_cv_member_cdfs_args_t_fspec” >&6; } if test $ac_cv_member_cdfs_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.iso_flags” >&5 $as_echo_n “checking for cdfs_args_t.iso_flags… ” >&6; } if ${ac_cv_member_cdfs_args_t_iso_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.iso_flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_iso_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.iso_flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_iso_flags=yes else ac_cv_member_cdfs_args_t_iso_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_iso_flags” >&5 $as_echo “$ac_cv_member_cdfs_args_t_iso_flags” >&6; } if test $ac_cv_member_cdfs_args_t_iso_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_ISO_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.iso_pgthresh” >&5 $as_echo_n “checking for cdfs_args_t.iso_pgthresh… ” >&6; } if ${ac_cv_member_cdfs_args_t_iso_pgthresh+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.iso_pgthresh)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_iso_pgthresh=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.iso_pgthresh) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_iso_pgthresh=yes else ac_cv_member_cdfs_args_t_iso_pgthresh=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_iso_pgthresh” >&5 $as_echo “$ac_cv_member_cdfs_args_t_iso_pgthresh” >&6; } if test $ac_cv_member_cdfs_args_t_iso_pgthresh = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_ISO_PGTHRESH 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.norrip” >&5 $as_echo_n “checking for cdfs_args_t.norrip… ” >&6; } if ${ac_cv_member_cdfs_args_t_norrip+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.norrip)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_norrip=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.norrip) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_norrip=yes else ac_cv_member_cdfs_args_t_norrip=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_norrip” >&5 $as_echo “$ac_cv_member_cdfs_args_t_norrip” >&6; } if test $ac_cv_member_cdfs_args_t_norrip = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_NORRIP 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for cdfs_args_t.ssector” >&5 $as_echo_n “checking for cdfs_args_t.ssector… ” >&6; } if ${ac_cv_member_cdfs_args_t_ssector+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (&(ac_aggr.ssector)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_ssector=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static cdfs_args_t ac_aggr; if (sizeof ac_aggr.ssector) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_cdfs_args_t_ssector=yes else ac_cv_member_cdfs_args_t_ssector=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_cdfs_args_t_ssector” >&5 $as_echo “$ac_cv_member_cdfs_args_t_ssector” >&6; } if test $ac_cv_member_cdfs_args_t_ssector = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_CDFS_ARGS_T_SSECTOR 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.version” >&5 $as_echo_n “checking for udf_args_t.version… ” >&6; } if ${ac_cv_member_udf_args_t_version+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.version)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_version=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.version) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_version=yes else ac_cv_member_udf_args_t_version=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_version” >&5 $as_echo “$ac_cv_member_udf_args_t_version” >&6; } if test $ac_cv_member_udf_args_t_version = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_VERSION 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.fspec” >&5 $as_echo_n “checking for udf_args_t.fspec… ” >&6; } if ${ac_cv_member_udf_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_fspec=yes else ac_cv_member_udf_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_fspec” >&5 $as_echo “$ac_cv_member_udf_args_t_fspec” >&6; } if test $ac_cv_member_udf_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.sessionnr” >&5 $as_echo_n “checking for udf_args_t.sessionnr… ” >&6; } if ${ac_cv_member_udf_args_t_sessionnr+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.sessionnr)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_sessionnr=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.sessionnr) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_sessionnr=yes else ac_cv_member_udf_args_t_sessionnr=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_sessionnr” >&5 $as_echo “$ac_cv_member_udf_args_t_sessionnr” >&6; } if test $ac_cv_member_udf_args_t_sessionnr = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_SESSIONNR 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.udfmflags” >&5 $as_echo_n “checking for udf_args_t.udfmflags… ” >&6; } if ${ac_cv_member_udf_args_t_udfmflags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.udfmflags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_udfmflags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.udfmflags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_udfmflags=yes else ac_cv_member_udf_args_t_udfmflags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_udfmflags” >&5 $as_echo “$ac_cv_member_udf_args_t_udfmflags” >&6; } if test $ac_cv_member_udf_args_t_udfmflags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_UDFMFLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.gmtoff” >&5 $as_echo_n “checking for udf_args_t.gmtoff… ” >&6; } if ${ac_cv_member_udf_args_t_gmtoff+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.gmtoff)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_gmtoff=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.gmtoff) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_gmtoff=yes else ac_cv_member_udf_args_t_gmtoff=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_gmtoff” >&5 $as_echo “$ac_cv_member_udf_args_t_gmtoff” >&6; } if test $ac_cv_member_udf_args_t_gmtoff = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_GMTOFF 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.anon_uid” >&5 $as_echo_n “checking for udf_args_t.anon_uid… ” >&6; } if ${ac_cv_member_udf_args_t_anon_uid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.anon_uid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_anon_uid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.anon_uid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_anon_uid=yes else ac_cv_member_udf_args_t_anon_uid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_anon_uid” >&5 $as_echo “$ac_cv_member_udf_args_t_anon_uid” >&6; } if test $ac_cv_member_udf_args_t_anon_uid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_ANON_UID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.anon_gid” >&5 $as_echo_n “checking for udf_args_t.anon_gid… ” >&6; } if ${ac_cv_member_udf_args_t_anon_gid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.anon_gid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_anon_gid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.anon_gid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_anon_gid=yes else ac_cv_member_udf_args_t_anon_gid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_anon_gid” >&5 $as_echo “$ac_cv_member_udf_args_t_anon_gid” >&6; } if test $ac_cv_member_udf_args_t_anon_gid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_ANON_GID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.nobody_uid” >&5 $as_echo_n “checking for udf_args_t.nobody_uid… ” >&6; } if ${ac_cv_member_udf_args_t_nobody_uid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.nobody_uid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_nobody_uid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.nobody_uid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_nobody_uid=yes else ac_cv_member_udf_args_t_nobody_uid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_nobody_uid” >&5 $as_echo “$ac_cv_member_udf_args_t_nobody_uid” >&6; } if test $ac_cv_member_udf_args_t_nobody_uid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_NOBODY_UID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.nobody_gid” >&5 $as_echo_n “checking for udf_args_t.nobody_gid… ” >&6; } if ${ac_cv_member_udf_args_t_nobody_gid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.nobody_gid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_nobody_gid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.nobody_gid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_nobody_gid=yes else ac_cv_member_udf_args_t_nobody_gid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_nobody_gid” >&5 $as_echo “$ac_cv_member_udf_args_t_nobody_gid” >&6; } if test $ac_cv_member_udf_args_t_nobody_gid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_NOBODY_GID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for udf_args_t.sector_size” >&5 $as_echo_n “checking for udf_args_t.sector_size… ” >&6; } if ${ac_cv_member_udf_args_t_sector_size+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (&(ac_aggr.sector_size)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_sector_size=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static udf_args_t ac_aggr; if (sizeof ac_aggr.sector_size) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_udf_args_t_sector_size=yes else ac_cv_member_udf_args_t_sector_size=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_udf_args_t_sector_size” >&5 $as_echo “$ac_cv_member_udf_args_t_sector_size” >&6; } if test $ac_cv_member_udf_args_t_sector_size = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UDF_ARGS_T_SECTOR_SIZE 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.dirmask” >&5 $as_echo_n “checking for pcfs_args_t.dirmask… ” >&6; } if ${ac_cv_member_pcfs_args_t_dirmask+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.dirmask)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_dirmask=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.dirmask) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_dirmask=yes else ac_cv_member_pcfs_args_t_dirmask=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_dirmask” >&5 $as_echo “$ac_cv_member_pcfs_args_t_dirmask” >&6; } if test $ac_cv_member_pcfs_args_t_dirmask = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_DIRMASK 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.dsttime” >&5 $as_echo_n “checking for pcfs_args_t.dsttime… ” >&6; } if ${ac_cv_member_pcfs_args_t_dsttime+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.dsttime)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_dsttime=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.dsttime) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_dsttime=yes else ac_cv_member_pcfs_args_t_dsttime=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_dsttime” >&5 $as_echo “$ac_cv_member_pcfs_args_t_dsttime” >&6; } if test $ac_cv_member_pcfs_args_t_dsttime = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_DSTTIME 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.fspec” >&5 $as_echo_n “checking for pcfs_args_t.fspec… ” >&6; } if ${ac_cv_member_pcfs_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_fspec=yes else ac_cv_member_pcfs_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_fspec” >&5 $as_echo “$ac_cv_member_pcfs_args_t_fspec” >&6; } if test $ac_cv_member_pcfs_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.gid” >&5 $as_echo_n “checking for pcfs_args_t.gid… ” >&6; } if ${ac_cv_member_pcfs_args_t_gid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.gid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_gid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.gid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_gid=yes else ac_cv_member_pcfs_args_t_gid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_gid” >&5 $as_echo “$ac_cv_member_pcfs_args_t_gid” >&6; } if test $ac_cv_member_pcfs_args_t_gid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_GID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.mask” >&5 $as_echo_n “checking for pcfs_args_t.mask… ” >&6; } if ${ac_cv_member_pcfs_args_t_mask+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.mask)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_mask=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.mask) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_mask=yes else ac_cv_member_pcfs_args_t_mask=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_mask” >&5 $as_echo “$ac_cv_member_pcfs_args_t_mask” >&6; } if test $ac_cv_member_pcfs_args_t_mask = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_MASK 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.secondswest” >&5 $as_echo_n “checking for pcfs_args_t.secondswest… ” >&6; } if ${ac_cv_member_pcfs_args_t_secondswest+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.secondswest)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_secondswest=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.secondswest) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_secondswest=yes else ac_cv_member_pcfs_args_t_secondswest=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_secondswest” >&5 $as_echo “$ac_cv_member_pcfs_args_t_secondswest” >&6; } if test $ac_cv_member_pcfs_args_t_secondswest = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_SECONDSWEST 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for pcfs_args_t.uid” >&5 $as_echo_n “checking for pcfs_args_t.uid… ” >&6; } if ${ac_cv_member_pcfs_args_t_uid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (&(ac_aggr.uid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_uid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static pcfs_args_t ac_aggr; if (sizeof ac_aggr.uid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_pcfs_args_t_uid=yes else ac_cv_member_pcfs_args_t_uid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_pcfs_args_t_uid” >&5 $as_echo “$ac_cv_member_pcfs_args_t_uid” >&6; } if test $ac_cv_member_pcfs_args_t_uid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_PCFS_ARGS_T_UID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ufs_args_t.flags” >&5 $as_echo_n “checking for ufs_args_t.flags… ” >&6; } if ${ac_cv_member_ufs_args_t_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (&(ac_aggr.flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (sizeof ac_aggr.flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_flags=yes else ac_cv_member_ufs_args_t_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_ufs_args_t_flags” >&5 $as_echo “$ac_cv_member_ufs_args_t_flags” >&6; } if test $ac_cv_member_ufs_args_t_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UFS_ARGS_T_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ufs_args_t.fspec” >&5 $as_echo_n “checking for ufs_args_t.fspec… ” >&6; } if ${ac_cv_member_ufs_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_fspec=yes else ac_cv_member_ufs_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_ufs_args_t_fspec” >&5 $as_echo “$ac_cv_member_ufs_args_t_fspec” >&6; } if test $ac_cv_member_ufs_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UFS_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ufs_args_t.ufs_flags” >&5 $as_echo_n “checking for ufs_args_t.ufs_flags… ” >&6; } if ${ac_cv_member_ufs_args_t_ufs_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (&(ac_aggr.ufs_flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_ufs_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (sizeof ac_aggr.ufs_flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_ufs_flags=yes else ac_cv_member_ufs_args_t_ufs_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_ufs_args_t_ufs_flags” >&5 $as_echo “$ac_cv_member_ufs_args_t_ufs_flags” >&6; } if test $ac_cv_member_ufs_args_t_ufs_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UFS_ARGS_T_UFS_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for ufs_args_t.ufs_pgthresh” >&5 $as_echo_n “checking for ufs_args_t.ufs_pgthresh… ” >&6; } if ${ac_cv_member_ufs_args_t_ufs_pgthresh+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (&(ac_aggr.ufs_pgthresh)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_ufs_pgthresh=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static ufs_args_t ac_aggr; if (sizeof ac_aggr.ufs_pgthresh) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_ufs_args_t_ufs_pgthresh=yes else ac_cv_member_ufs_args_t_ufs_pgthresh=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_ufs_args_t_ufs_pgthresh” >&5 $as_echo “$ac_cv_member_ufs_args_t_ufs_pgthresh” >&6; } if test $ac_cv_member_ufs_args_t_ufs_pgthresh = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_UFS_ARGS_T_UFS_PGTHRESH 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for efs_args_t.flags” >&5 $as_echo_n “checking for efs_args_t.flags… ” >&6; } if ${ac_cv_member_efs_args_t_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (&(ac_aggr.flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (sizeof ac_aggr.flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_flags=yes else ac_cv_member_efs_args_t_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_efs_args_t_flags” >&5 $as_echo “$ac_cv_member_efs_args_t_flags” >&6; } if test $ac_cv_member_efs_args_t_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_EFS_ARGS_T_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for efs_args_t.fspec” >&5 $as_echo_n “checking for efs_args_t.fspec… ” >&6; } if ${ac_cv_member_efs_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_fspec=yes else ac_cv_member_efs_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_efs_args_t_fspec” >&5 $as_echo “$ac_cv_member_efs_args_t_fspec” >&6; } if test $ac_cv_member_efs_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_EFS_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for efs_args_t.version” >&5 $as_echo_n “checking for efs_args_t.version… ” >&6; } if ${ac_cv_member_efs_args_t_version+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (&(ac_aggr.version)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_version=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static efs_args_t ac_aggr; if (sizeof ac_aggr.version) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_efs_args_t_version=yes else ac_cv_member_efs_args_t_version=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_efs_args_t_version” >&5 $as_echo “$ac_cv_member_efs_args_t_version” >&6; } if test $ac_cv_member_efs_args_t_version = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_EFS_ARGS_T_VERSION 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for xfs_args_t.flags” >&5 $as_echo_n “checking for xfs_args_t.flags… ” >&6; } if ${ac_cv_member_xfs_args_t_flags+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static xfs_args_t ac_aggr; if (&(ac_aggr.flags)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_xfs_args_t_flags=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static xfs_args_t ac_aggr; if (sizeof ac_aggr.flags) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_xfs_args_t_flags=yes else ac_cv_member_xfs_args_t_flags=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_xfs_args_t_flags” >&5 $as_echo “$ac_cv_member_xfs_args_t_flags” >&6; } if test $ac_cv_member_xfs_args_t_flags = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_XFS_ARGS_T_FLAGS 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for xfs_args_t.fspec” >&5 $as_echo_n “checking for xfs_args_t.fspec… ” >&6; } if ${ac_cv_member_xfs_args_t_fspec+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static xfs_args_t ac_aggr; if (&(ac_aggr.fspec)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_xfs_args_t_fspec=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static xfs_args_t ac_aggr; if (sizeof ac_aggr.fspec) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_xfs_args_t_fspec=yes else ac_cv_member_xfs_args_t_fspec=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_xfs_args_t_fspec” >&5 $as_echo “$ac_cv_member_xfs_args_t_fspec” >&6; } if test $ac_cv_member_xfs_args_t_fspec = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_XFS_ARGS_T_FSPEC 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_version” >&5 $as_echo_n “checking for tmpfs_args_t.ta_version… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_version+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_version)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_version=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_version) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_version=yes else ac_cv_member_tmpfs_args_t_ta_version=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_version” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_version” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_version = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_VERSION 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_nodes_max” >&5 $as_echo_n “checking for tmpfs_args_t.ta_nodes_max… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_nodes_max+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_nodes_max)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_nodes_max=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_nodes_max) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_nodes_max=yes else ac_cv_member_tmpfs_args_t_ta_nodes_max=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_nodes_max” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_nodes_max” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_nodes_max = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_NODES_MAX 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_size_max” >&5 $as_echo_n “checking for tmpfs_args_t.ta_size_max… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_size_max+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_size_max)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_size_max=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_size_max) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_size_max=yes else ac_cv_member_tmpfs_args_t_ta_size_max=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_size_max” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_size_max” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_size_max = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_SIZE_MAX 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_root_uid” >&5 $as_echo_n “checking for tmpfs_args_t.ta_root_uid… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_root_uid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_root_uid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_uid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_root_uid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_uid=yes else ac_cv_member_tmpfs_args_t_ta_root_uid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_root_uid” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_root_uid” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_root_uid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_ROOT_UID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_root_gid” >&5 $as_echo_n “checking for tmpfs_args_t.ta_root_gid… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_root_gid+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_root_gid)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_gid=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_root_gid) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_gid=yes else ac_cv_member_tmpfs_args_t_ta_root_gid=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_root_gid” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_root_gid” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_root_gid = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_ROOT_GID 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for tmpfs_args_t.ta_root_mode” >&5 $as_echo_n “checking for tmpfs_args_t.ta_root_mode… ” >&6; } if ${ac_cv_member_tmpfs_args_t_ta_root_mode+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (&(ac_aggr.ta_root_mode)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_mode=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static tmpfs_args_t ac_aggr; if (sizeof ac_aggr.ta_root_mode) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_tmpfs_args_t_ta_root_mode=yes else ac_cv_member_tmpfs_args_t_ta_root_mode=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_tmpfs_args_t_ta_root_mode” >&5 $as_echo “$ac_cv_member_tmpfs_args_t_ta_root_mode” >&6; } if test $ac_cv_member_tmpfs_args_t_ta_root_mode = yes; then :

cat >>confdefs.h <<_ACEOF

define HAVE_TMPFS_ARGS_T_TA_ROOT_MODE 1

_ACEOF

fi

{ $as_echo “$as_me:${as_lineno-$LINENO}: checking for struct fhstatus.fhs_fh” >&5 $as_echo_n “checking for struct fhstatus.fhs_fh… ” >&6; } if ${ac_cv_member_struct_fhstatus_fhs_fh+:} false; then : $as_echo_n “(cached) ” >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static struct fhstatus ac_aggr; if (&(ac_aggr.fhs_fh)) return 0; ; return 0; } ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_struct_fhstatus_fhs_fh=yes else cat confdefs.h - <<ACEOF >conftest.$ac_ext / end confdefs.h. /

include “${srcdir}/include/mount_headers1.h”

include AMU_NFS_PROTOCOL_HEADER

include “${srcdir}/include/mount_headers2.h”

/ now set the typedef /

ifdef HAVE_STRUCT_MNTENT

typedef struct mntent mntent_t;

else / not HAVE_STRUCT_MNTENT /

ifdef HAVE_STRUCT_MNTTAB

typedef struct mnttab mntent_t;

endif / HAVE_STRUCT_MNTTAB /

endif / not HAVE_STRUCT_MNTENT /

/ * for various filesystem specific mount arguments /

ifdef HAVE_SYS_FS_EFS_CLNT_H

include <sys/fs/efs_clnt.h>

endif / HAVE_SYS_FS_EFS_CLNT_H /

ifdef HAVE_SYS_FS_XFS_CLNT_H

include <sys/fs/xfs_clnt.h>

endif / HAVE_SYS_FS_XFS_CLNT_H /

ifdef HAVE_SYS_FS_UFS_MOUNT_H

include <sys/fs/ufs_mount.h>

endif / HAVE_SYS_FS_UFS_MOUNT_H /

ifdef HAVE_SYS_FS_AUTOFS_H

include <sys/fs/autofs.h>

endif / HAVE_SYS_FS_AUTOFS_H /

ifdef HAVE_RPCSVC_AUTOFS_PROT_H

include <rpcsvc/autofs_prot.h>

else / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_SYS_FS_AUTOFS_PROT_H

include <sys/fs/autofs_prot.h>

endif / HAVE_SYS_FS_AUTOFS_PROT_H /

endif / not HAVE_RPCSVC_AUTOFS_PROT_H /

ifdef HAVE_HSFS_HSFS_H

include <hsfs/hsfs.h>

endif / HAVE_HSFS_HSFS_H /

ifdef HAVE_IFADDRS_H

include <ifaddrs.h>

endif / HAVE_IFADDRS_H /

int main () { static struct fhstatus ac_aggr; if (sizeof ac_aggr.fhs_fh) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile “$LINENO”; then : ac_cv_member_struct_fhstatus_fhs_fh=yes else ac_cv_member_struct_fhstatus_fhs_fh=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo “$as_me:${as_lineno-$LINENO}: result: $ac_cv_member_struct_fhstatus_fhs_fh” >&5 $as_echo “