Fresh Fish 4/FreshFish_May-June1994.bin/bbs/gnu/make-3.70-src.lha/src/amiga/make-3.70/configure

Text File | 1994-02-21 | 59.3 KB | 2,360 lines

#!/bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 1.7.1
# Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.

# This configure script is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This script is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

# Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp]
#        [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]]
# Ignores all args except --srcdir, --prefix, --exec-prefix, and
# --with-PACKAGE[=VALUE] unless this script has special code to handle it.

for arg
do
  # Handle --exec-prefix with a space before the argument.
  if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix=
  # Handle --host with a space before the argument.
  elif test x$next_host = xyes; then next_host=
  # Handle --prefix with a space before the argument.
  elif test x$next_prefix = xyes; then prefix=$arg; next_prefix=
  # Handle --srcdir with a space before the argument.
  elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir=
  else
    case $arg in
     # For backward compatibility, recognize -exec-prefix and --exec_prefix.
     -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*)
    exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e)
    next_exec_prefix=yes ;;

     -gas | --gas | --ga | --g) ;;

     -host=* | --host=* | --hos=* | --ho=* | --h=*) ;;
     -host | --host | --hos | --ho | --h)
    next_host=yes ;;

     -nfp | --nfp | --nf) ;;

     -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    next_prefix=yes ;;

     -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*)
    srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;;
     -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s)
    next_srcdir=yes ;;

     -with-* | --with-*)
       package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'`
       # Reject names that aren't valid shell variable names.
       if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then
         echo "configure: $package: invalid package name" >&2; exit 1
       fi
       package=`echo $package| sed 's/-/_/g'`
       case "$arg" in
         *=*) val="`echo $arg|sed 's/[^=]*=//'`" ;;
         *) val=1 ;;
       esac
       eval "with_$package='$val'" ;;

     -v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v)
       verbose=yes ;;

     *) ;;
    esac
  fi
done

trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 3 15
trap 'rm -f confdefs* $ac_clean_files' 0

# NLS nuisances.
# These must not be set unconditionally because not all systems understand
# e.g. LANG=C (notably SCO).
if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi
if test "${LANG+set}"   = 'set' ; then LANG=C;   export LANG;   fi

rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h
compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1'

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
unique_file=vpath.c

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  srcdirdefaulted=yes
  # Try the directory containing this script, then `..'.
  prog=$0
  confdir=`echo $prog| sed 's|/$||' | sed 's|//|/|' | sed 's|/[^/]*$||'`
  test "X$confdir" = "X$prog" && confdir=.
  srcdir=$confdir
  if test ! -r $srcdir/$unique_file; then
    srcdir=..
  fi
fi
if test ! -r $srcdir/$unique_file; then
  if test x$srcdirdefaulted = xyes; then
    echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2
  else
    echo "configure: Can not find sources in \`${srcdir}'." 1>&2
  fi
  exit 1
fi
# Preserve a srcdir of `.' to avoid automounter screwups with pwd.
# But we can't avoid them for `..', to make subdirectories work.
case $srcdir in
  .|/*|~*) ;;
  *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute.
esac


# Save the original args to write them into config.status later.
configure_args="$*"


# We want these before the checks, so the checks can modify their values.
test -z "$CFLAGS" && CFLAGS=-O2
test -z "$LDFLAGS" && LDFLAGS=

if test -z "$CC"; then
  # Extract the first word of `gcc', so it can be a program name with args.
  set dummy gcc; word=$2
  echo checking for $word
  IFS="${IFS=     }"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      CC="gcc"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CC" && CC="cc"
test -n "$CC" && test -n "$verbose" && echo "    setting CC to $CC"

# Find out if we are using GNU C, under whatever name.
cat > conftest.c <<EOF
#ifdef __GNUC__
  yes
#endif
EOF
${CC-cc} -E conftest.c > conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
  GCC=1 # For later tests.
fi
rm -f conftest*

# Make sure to not get the incompatible SysV /etc/install and
# /usr/sbin/install, which might be in PATH before a BSD-like install,
# or the SunOS /usr/etc/install directory, or the AIX /bin/install,
# or the AFS install, which mishandles nonexistent args, or
# /usr/ucb/install on SVR4, which tries to use the nonexistent group
# `staff'.  On most BSDish systems install is in /usr/bin, not /usr/ucb
# anyway.  Sigh.
if test "z${INSTALL}" = "z" ; then
  echo checking for install
  IFS="${IFS=     }"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    #test -z "$dir" && dir=.
    case "$dir" in
    ''|.|/etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;;
    *)
      if test -f $dir/installbsd; then
    INSTALL="$dir/installbsd -c" # OSF1
    INSTALL_PROGRAM='$(INSTALL)'
    INSTALL_DATA='$(INSTALL) -m 644'
    break
      fi
      if test -f $dir/install; then
    if grep dspmsg $dir/install >/dev/null 2>&1; then
      : # AIX
    else
      INSTALL="$dir/install -c"
      INSTALL_PROGRAM='$(INSTALL)'
      INSTALL_DATA='$(INSTALL) -m 644'
      break
    fi
      fi
      ;;
    esac
  done
  IFS="$saveifs"
fi
if test -z "$INSTALL"; then
  if test -f ${srcdir}/install.sh; then
    # As a last resort, use the slow shell script.
    # We want the top-level source directory, not the subdir's srcdir,
    # so expand srcdir now rather than in the Makefile.
    INSTALL="${srcdir}/install.sh -c"
  else
    echo "warning: ${srcdir}/install.sh not found; using cp"
    INSTALL=cp
  fi
fi
test -n "$verbose" && echo "    setting INSTALL to $INSTALL"
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
test -n "$verbose" && echo "    setting INSTALL_PROGRAM to $INSTALL_PROGRAM"
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}
test -n "$verbose" && echo "    setting INSTALL_DATA to $INSTALL_DATA"

if test -z "$RANLIB"; then
  # Extract the first word of `ranlib', so it can be a program name with args.
  set dummy ranlib; word=$2
  echo checking for $word
  IFS="${IFS=     }"; saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$word; then
      RANLIB="ranlib"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$RANLIB" && RANLIB=":"
test -n "$RANLIB" && test -n "$verbose" && echo "    setting RANLIB to $RANLIB"

echo checking how to run the C preprocessor
if test -z "$CPP"; then
  # This must be in double quotes, not single quotes, because CPP may get
  # substituted into the Makefile and ``${CC-cc}'' will simply confuse
  # make.  It must be expanded now.
  CPP="${CC-cc} -E"
  cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  :
else
  rm -rf conftest*
  CPP="${CC-cc} -E -traditional-cpp"
  cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdio.h>
Syntax Error
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  :
else
  rm -rf conftest*
  CPP=/lib/cpp
fi
rm -f conftest*
fi
rm -f conftest*
fi
test ".${verbose}" != "." && echo "    setting CPP to $CPP"
            echo checking for AIX
cat > conftest.c <<EOF
#include "confdefs.h"
#ifdef _AIX
  yes
#endif

EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining _ALL_SOURCE"
echo "#define _ALL_SOURCE 1" >> confdefs.h
DEFS="$DEFS -D_ALL_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_ALL_SOURCE\${SEDdB}_ALL_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_ALL_SOURCE\${SEDuB}_ALL_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_ALL_SOURCE\${SEDeB}_ALL_SOURCE\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


echo checking for POSIXized ISC
if test -d /etc/conf/kconfig.d &&
  grep _POSIX_VERSION /gnu/include/sys/unistd.h >/dev/null 2>&1
then
  ISC=1 # If later tests want to check for ISC.

{
test -n "$verbose" && \
echo "    defining _POSIX_SOURCE"
echo "#define _POSIX_SOURCE 1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
"
}

  if test -n "$GCC"; then
    CC="$CC -posix"
  else
    CC="$CC -Xp"
  fi
fi

echo checking for minix/config.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <minix/config.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  MINIX=1

fi
rm -f conftest*

# The Minix shell can't assign to the same variable on the same line!
if test -n "$MINIX"; then

{
test -n "$verbose" && \
echo "    defining _POSIX_SOURCE"
echo "#define _POSIX_SOURCE 1" >> confdefs.h
DEFS="$DEFS -D_POSIX_SOURCE=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD}
\${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD}
\${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD}
"
}


{
test -n "$verbose" && \
echo "    defining _POSIX_1_SOURCE to be 2"
echo "#define _POSIX_1_SOURCE 2" >> confdefs.h
DEFS="$DEFS -D_POSIX_1_SOURCE=2"
SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_1_SOURCE\${SEDdB}_POSIX_1_SOURCE\${SEDdC}2\${SEDdD}
\${SEDuA}_POSIX_1_SOURCE\${SEDuB}_POSIX_1_SOURCE\${SEDuC}2\${SEDuD}
\${SEDeA}_POSIX_1_SOURCE\${SEDeB}_POSIX_1_SOURCE\${SEDeC}2\${SEDeD}
"
}


{
test -n "$verbose" && \
echo "    defining _MINIX"
echo "#define _MINIX 1" >> confdefs.h
DEFS="$DEFS -D_MINIX=1"
SEDDEFS="${SEDDEFS}\${SEDdA}_MINIX\${SEDdB}_MINIX\${SEDdC}1\${SEDdD}
\${SEDuA}_MINIX\${SEDuB}_MINIX\${SEDuC}1\${SEDuD}
\${SEDeA}_MINIX\${SEDeB}_MINIX\${SEDeC}1\${SEDeD}
"
}

fi

echo checking for ANSI C header files
cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <float.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
echo '#include "confdefs.h"
#include <string.h>' > conftest.c
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "memchr" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  # SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#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)) exit(2);
exit (0); }

EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
echo '#include "confdefs.h"
#include <stdlib.h>' > conftest.c
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "free" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining STDC_HEADERS"
echo "#define STDC_HEADERS 1" >> confdefs.h
DEFS="$DEFS -DSTDC_HEADERS=1"
SEDDEFS="${SEDDEFS}\${SEDdA}STDC_HEADERS\${SEDdB}STDC_HEADERS\${SEDdC}1\${SEDdD}
\${SEDuA}STDC_HEADERS\${SEDuB}STDC_HEADERS\${SEDuC}1\${SEDuD}
\${SEDeA}STDC_HEADERS\${SEDeB}STDC_HEADERS\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


fi
rm -fr conftest*

fi
rm -f conftest*


fi
rm -f conftest*

echo checking for directory library header
dirheader=
if test -z "$dirheader"; then
  echo checking for dirent.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <dirent.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining DIRENT"
echo "#define DIRENT 1" >> confdefs.h
DEFS="$DEFS -DDIRENT=1"
SEDDEFS="${SEDDEFS}\${SEDdA}DIRENT\${SEDdB}DIRENT\${SEDdC}1\${SEDdD}
\${SEDuA}DIRENT\${SEDuB}DIRENT\${SEDuC}1\${SEDuD}
\${SEDeA}DIRENT\${SEDeB}DIRENT\${SEDeC}1\${SEDeD}
"
}
 dirheader=dirent.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for sys/ndir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining SYSNDIR"
echo "#define SYSNDIR 1" >> confdefs.h
DEFS="$DEFS -DSYSNDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SYSNDIR\${SEDdB}SYSNDIR\${SEDdC}1\${SEDdD}
\${SEDuA}SYSNDIR\${SEDuB}SYSNDIR\${SEDuC}1\${SEDuD}
\${SEDeA}SYSNDIR\${SEDeB}SYSNDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=sys/ndir.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for sys/dir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/dir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining SYSDIR"
echo "#define SYSDIR 1" >> confdefs.h
DEFS="$DEFS -DSYSDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SYSDIR\${SEDdB}SYSDIR\${SEDdC}1\${SEDdD}
\${SEDuA}SYSDIR\${SEDuB}SYSDIR\${SEDuC}1\${SEDuD}
\${SEDeA}SYSDIR\${SEDeB}SYSDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=sys/dir.h

fi
rm -f conftest*
fi
if test -z "$dirheader"; then
  echo checking for ndir.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <ndir.h>
int main() { exit(0); }
int t() { DIR *dirp = 0; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining NDIR"
echo "#define NDIR 1" >> confdefs.h
DEFS="$DEFS -DNDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NDIR\${SEDdB}NDIR\${SEDdC}1\${SEDdD}
\${SEDuA}NDIR\${SEDuB}NDIR\${SEDuC}1\${SEDuD}
\${SEDeA}NDIR\${SEDeB}NDIR\${SEDeC}1\${SEDeD}
"
}
 dirheader=ndir.h

fi
rm -f conftest*
fi

echo checking for closedir return value
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <$dirheader>
int closedir(); main() { exit(closedir(opendir(".")) != 0); }
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else

{
test -n "$verbose" && \
echo "    defining VOID_CLOSEDIR"
echo "#define VOID_CLOSEDIR 1" >> confdefs.h
DEFS="$DEFS -DVOID_CLOSEDIR=1"
SEDDEFS="${SEDDEFS}\${SEDdA}VOID_CLOSEDIR\${SEDdB}VOID_CLOSEDIR\${SEDdC}1\${SEDdD}
\${SEDuA}VOID_CLOSEDIR\${SEDuB}VOID_CLOSEDIR\${SEDuC}1\${SEDuD}
\${SEDeA}VOID_CLOSEDIR\${SEDeB}VOID_CLOSEDIR\${SEDeC}1\${SEDeD}
"
}

fi
rm -fr conftest*

echo checking for uid_t in sys/types.h
echo '#include "confdefs.h"
#include <sys/types.h>' > conftest.c
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "uid_t" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining uid_t to be int"
echo "#define uid_t int" >> confdefs.h
DEFS="$DEFS -Duid_t=int"
SEDDEFS="${SEDDEFS}\${SEDdA}uid_t\${SEDdB}uid_t\${SEDdC}int\${SEDdD}
\${SEDuA}uid_t\${SEDuB}uid_t\${SEDuC}int\${SEDuD}
\${SEDeA}uid_t\${SEDeB}uid_t\${SEDeC}int\${SEDeD}
"
}

{
test -n "$verbose" && \
echo "    defining gid_t to be int"
echo "#define gid_t int" >> confdefs.h
DEFS="$DEFS -Dgid_t=int"
SEDDEFS="${SEDDEFS}\${SEDdA}gid_t\${SEDdB}gid_t\${SEDdC}int\${SEDdD}
\${SEDuA}gid_t\${SEDuB}gid_t\${SEDuC}int\${SEDuD}
\${SEDeA}gid_t\${SEDeB}gid_t\${SEDeC}int\${SEDeD}
"
}

fi
rm -f conftest*
            echo checking for type of array argument to getgroups
prog='/* Thanks to Mike Rendell for this test.  */
#include <sys/types.h>
#define NGID 256
#undef MAX
#define MAX(x,y) ((x) > (y) ? (x) : (y))
main()
{
  gid_t gidset[NGID];
  int i, n;
  union { gid_t gval; long 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 but getgroups modifies an array of ints.  */
  exit ((n > 0 && gidset[n] != val.gval) ? 1 : 0);
}'
cat > conftest.c <<EOF
#include "confdefs.h"
$prog
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining GETGROUPS_T to be gid_t"
echo "#define GETGROUPS_T gid_t" >> confdefs.h
DEFS="$DEFS -DGETGROUPS_T=gid_t"
SEDDEFS="${SEDDEFS}\${SEDdA}GETGROUPS_T\${SEDdB}GETGROUPS_T\${SEDdC}gid_t\${SEDdD}
\${SEDuA}GETGROUPS_T\${SEDuB}GETGROUPS_T\${SEDuC}gid_t\${SEDuD}
\${SEDeA}GETGROUPS_T\${SEDeB}GETGROUPS_T\${SEDeC}gid_t\${SEDeD}
"
}


else

{
test -n "$verbose" && \
echo "    defining GETGROUPS_T to be int"
echo "#define GETGROUPS_T int" >> confdefs.h
DEFS="$DEFS -DGETGROUPS_T=int"
SEDDEFS="${SEDDEFS}\${SEDdA}GETGROUPS_T\${SEDdB}GETGROUPS_T\${SEDdC}int\${SEDdD}
\${SEDuA}GETGROUPS_T\${SEDuB}GETGROUPS_T\${SEDuC}int\${SEDuD}
\${SEDeA}GETGROUPS_T\${SEDeB}GETGROUPS_T\${SEDeC}int\${SEDeD}
"
}

fi
rm -fr conftest*

echo checking for pid_t in sys/types.h
echo '#include "confdefs.h"
#include <sys/types.h>' > conftest.c
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "pid_t" conftest.out >/dev/null 2>&1; then
  :
else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining pid_t to be int"
echo "#define pid_t int" >> confdefs.h
DEFS="$DEFS -Dpid_t=int"
SEDDEFS="${SEDDEFS}\${SEDdA}pid_t\${SEDdB}pid_t\${SEDdC}int\${SEDdD}
\${SEDuA}pid_t\${SEDuB}pid_t\${SEDuC}int\${SEDuD}
\${SEDeA}pid_t\${SEDeB}pid_t\${SEDeC}int\${SEDeD}
"
}

fi
rm -f conftest*

echo checking for return type of signal handlers
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
int main() { exit(0); }
int t() { int i; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining RETSIGTYPE to be void"
echo "#define RETSIGTYPE void" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=void"
SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD}
\${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD}
\${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD}
"
}


else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining RETSIGTYPE to be int"
echo "#define RETSIGTYPE int" >> confdefs.h
DEFS="$DEFS -DRETSIGTYPE=int"
SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD}
\${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD}
\${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD}
"
}

fi
rm -f conftest*


for hdr in unistd.h limits.h sys/param.h fcntl.h string.h memory.h \
            sys/timeb.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining ${trhdr}"
echo "#define ${trhdr} 1" >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
\${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
\${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done

echo checking whether $CC and cc understand -c and -o together
echo 'foo(){}' > conftest.c
# 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.
if ${CC-cc} -c conftest.c -o conftest.o >/dev/null 2>&1 \
 && test -f conftest.o && ${CC-cc} -c conftest.c -o conftest.o >/dev/null 2>&1
then
  # Test first that cc exists at all.
  if cc -c conftest.c >/dev/null 2>&1
  then
    if cc -c conftest.c -o conftest2.o >/dev/null 2>&1 && \
       test -f conftest2.o && cc -c conftest.c -o conftest2.o >/dev/null 2>&1
    then
      :
    else

{
test -n "$verbose" && \
echo "    defining NO_MINUS_C_MINUS_O"
echo "#define NO_MINUS_C_MINUS_O 1" >> confdefs.h
DEFS="$DEFS -DNO_MINUS_C_MINUS_O=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NO_MINUS_C_MINUS_O\${SEDdB}NO_MINUS_C_MINUS_O\${SEDdC}1\${SEDdD}
\${SEDuA}NO_MINUS_C_MINUS_O\${SEDuB}NO_MINUS_C_MINUS_O\${SEDuC}1\${SEDuD}
\${SEDeA}NO_MINUS_C_MINUS_O\${SEDeB}NO_MINUS_C_MINUS_O\${SEDeC}1\${SEDeD}
"
}

    fi
  fi
else

{
test -n "$verbose" && \
echo "    defining NO_MINUS_C_MINUS_O"
echo "#define NO_MINUS_C_MINUS_O 1" >> confdefs.h
DEFS="$DEFS -DNO_MINUS_C_MINUS_O=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NO_MINUS_C_MINUS_O\${SEDdB}NO_MINUS_C_MINUS_O\${SEDdC}1\${SEDdD}
\${SEDuA}NO_MINUS_C_MINUS_O\${SEDuB}NO_MINUS_C_MINUS_O\${SEDuC}1\${SEDuD}
\${SEDeA}NO_MINUS_C_MINUS_O\${SEDeB}NO_MINUS_C_MINUS_O\${SEDeC}1\${SEDeD}
"
}

fi
rm -f conftest*

prog='/* Ultrix mips cc rejects this.  */
typedef int charset[2]; const charset x;
/* SunOS 4.1.1 cc rejects this.  */
char const *const *ccp;
char **p;
/* 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";
ccp = &g + (g ? g-g : 0);
/* HPUX 7.0 cc rejects these. */
++ccp;
p = (char**) ccp;
ccp = (char const *const *) p;
{ /* SCO 3.2v4 cc rejects this.  */
  char *t;
  char const *s = 0 ? (char *) 0 : (char const *) 0;

  *t++ = 0;
}
{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
  int x[] = {25,17};
  const int *foo = &x[0];
  ++foo;
}
{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
  typedef const int *iptr;
  iptr p = 0;
  ++p;
}
{ /* AIX XL C 1.02.0.0 rejects this saying
     "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
  struct s { int j; const int *ap[3]; };
  struct s *b; b->j = 5;
}
{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
  const int foo = 10;
}'
echo checking for lack of working const
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { $prog }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining const to be empty"
echo "#define const " >> confdefs.h
DEFS="$DEFS -Dconst="
SEDDEFS="${SEDDEFS}\${SEDdA}const\${SEDdB}const\${SEDdC}\${SEDdD}
\${SEDuA}const\${SEDuB}const\${SEDuC}\${SEDuD}
\${SEDeA}const\${SEDeB}const\${SEDeC}\${SEDeD}
"
}

fi
rm -f conftest*
            echo checking for broken stat file mode macros
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/stat.h>
#ifdef S_ISBLK
#if S_ISBLK (S_IFDIR)
You lose.
#endif
#ifdef S_IFCHR
#if S_ISBLK (S_IFCHR)
You lose.
#endif
#endif /* S_IFCHR */
#endif /* S_ISBLK */
#ifdef S_ISLNK
#if S_ISLNK (S_IFREG)
You lose.
#endif
#endif /* S_ISLNK */
#ifdef S_ISSOCK
#if S_ISSOCK (S_IFREG)
You lose.
#endif
#endif /* S_ISSOCK */

EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "You lose" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining STAT_MACROS_BROKEN"
echo "#define STAT_MACROS_BROKEN 1" >> confdefs.h
DEFS="$DEFS -DSTAT_MACROS_BROKEN=1"
SEDDEFS="${SEDDEFS}\${SEDdA}STAT_MACROS_BROKEN\${SEDdB}STAT_MACROS_BROKEN\${SEDdC}1\${SEDdD}
\${SEDuA}STAT_MACROS_BROKEN\${SEDuB}STAT_MACROS_BROKEN\${SEDuC}1\${SEDuD}
\${SEDeA}STAT_MACROS_BROKEN\${SEDeB}STAT_MACROS_BROKEN\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*




for func in getdtablesize sys_siglist _sys_siglist psignal \
          dup2 getcwd sigsetmask getgroups setlinebuf \
          setreuid setregid strerror
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining ${trfunc}"
echo "#define ${trfunc} 1" >> confdefs.h
DEFS="$DEFS -D${trfunc}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
\${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
\${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done

# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments.  Useless!
echo checking for working alloca.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <alloca.h>
int main() { exit(0); }
int t() { char *p = alloca(2 * sizeof(int)); }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_ALLOCA_H"
echo "#define HAVE_ALLOCA_H 1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALLOCA_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA_H\${SEDdB}HAVE_ALLOCA_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_ALLOCA_H\${SEDuB}HAVE_ALLOCA_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_ALLOCA_H\${SEDeB}HAVE_ALLOCA_H\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*

decl="#ifdef __GNUC__
#define alloca __builtin_alloca
#else
#if HAVE_ALLOCA_H
#include <alloca.h>
#else
#ifdef _AIX
 #pragma alloca
#else
char *alloca ();
#endif
#endif
#endif
"
echo checking for alloca
cat > conftest.c <<EOF
#include "confdefs.h"
$decl
int main() { exit(0); }
int t() { char *p = (char *) alloca(1); }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_ALLOCA"
echo "#define HAVE_ALLOCA 1" >> confdefs.h
DEFS="$DEFS -DHAVE_ALLOCA=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA\${SEDdB}HAVE_ALLOCA\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_ALLOCA\${SEDuB}HAVE_ALLOCA\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_ALLOCA\${SEDeB}HAVE_ALLOCA\${SEDeC}1\${SEDeD}
"
}


else
  rm -rf conftest*
  alloca_missing=1
cat > conftest.c <<EOF
#include "confdefs.h"

#if defined(CRAY) && ! defined(CRAY2)
winnitude
#else
lossage
#endif

EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "winnitude" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  echo checking for _getb67
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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__getb67) || defined (__stub____getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char _getb67(); _getb67();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining CRAY_STACKSEG_END to be _getb67"
echo "#define CRAY_STACKSEG_END _getb67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}_getb67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}_getb67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}_getb67\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for GETB67
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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_GETB67) || defined (__stub___GETB67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char GETB67(); GETB67();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining CRAY_STACKSEG_END to be GETB67"
echo "#define CRAY_STACKSEG_END GETB67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}GETB67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}GETB67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}GETB67\${SEDeD}
"
}


else
  rm -rf conftest*
  echo checking for getb67
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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_getb67) || defined (__stub___getb67)
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char getb67(); getb67();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining CRAY_STACKSEG_END to be getb67"
echo "#define CRAY_STACKSEG_END getb67" >> confdefs.h
DEFS="$DEFS -DCRAY_STACKSEG_END=getb67"
SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}getb67\${SEDdD}
\${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}getb67\${SEDuD}
\${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}getb67\${SEDeD}
"
}


fi
rm -f conftest*

fi
rm -f conftest*

fi
rm -f conftest*


fi
rm -f conftest*


fi
rm -f conftest*

if test -n "$alloca_missing"; then
  # The SVR3 libPW and SVR4 libucb both contain incompatible functions
  # that cause trouble.  Some versions do not even contain alloca or
  # contain a buggy version.  If you still want to use their alloca,
  # use ar to extract alloca.o from them instead of compiling alloca.c.
  ALLOCA=alloca.o

{
test -n "$verbose" && \
echo "    defining C_ALLOCA"
echo "#define C_ALLOCA 1" >> confdefs.h
DEFS="$DEFS -DC_ALLOCA=1"
SEDDEFS="${SEDDEFS}\${SEDdA}C_ALLOCA\${SEDdB}C_ALLOCA\${SEDdC}1\${SEDdD}
\${SEDuA}C_ALLOCA\${SEDuB}C_ALLOCA\${SEDuC}1\${SEDuD}
\${SEDeA}C_ALLOCA\${SEDeB}C_ALLOCA\${SEDeC}1\${SEDeD}
"
}


  echo 'checking stack direction for C alloca'
  echo checking whether cross-compiling
# If we cannot run a trivial program, we must be cross compiling.
cat > conftest.c <<EOF
#include "confdefs.h"
main(){exit(0);}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  cross_compiling=1
fi
rm -fr conftest*

if test -n "$cross_compiling"
then

{
test -n "$verbose" && \
echo "    defining STACK_DIRECTION to be 0"
echo "#define STACK_DIRECTION 0" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=0"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}0\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}0\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}0\${SEDeD}
"
}

else
cat > conftest.c <<EOF
#include "confdefs.h"
find_stack_direction ()
{
  static char *addr = 0;
  auto char dummy;
  if (addr == 0)
    {
      addr = &dummy;
      return find_stack_direction ();
    }
  else
    return (&dummy > addr) ? 1 : -1;
}
main ()
{
  exit (find_stack_direction() < 0);
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining STACK_DIRECTION to be 1"
echo "#define STACK_DIRECTION 1" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=1"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}1\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}1\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}1\${SEDeD}
"
}


else

{
test -n "$verbose" && \
echo "    defining STACK_DIRECTION to be -1"
echo "#define STACK_DIRECTION -1" >> confdefs.h
DEFS="$DEFS -DSTACK_DIRECTION=-1"
SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}-1\${SEDdD}
\${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}-1\${SEDuD}
\${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}-1\${SEDeD}
"
}

fi
fi
rm -fr conftest*
fi

echo checking for vfork.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <vfork.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_VFORK_H"
echo "#define HAVE_VFORK_H 1" >> confdefs.h
DEFS="$DEFS -DHAVE_VFORK_H=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_VFORK_H\${SEDdB}HAVE_VFORK_H\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_VFORK_H\${SEDuB}HAVE_VFORK_H\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_VFORK_H\${SEDeB}HAVE_VFORK_H\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*

echo checking for working vfork

cat > conftest.c <<EOF
#include "confdefs.h"
/* Thanks to Paul Eggert for this test.  */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_VFORK_H
#include <vfork.h>
#endif
static int signalled;
static RETSIGTYPE catch (s) int s; { signalled = 1; }
main() {
  pid_t parent = getpid ();
  pid_t child;

  signal (SIGINT, catch);

  child = vfork ();

  if (child == 0) {
    /* On 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 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 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. SunOS 5.2), if the parent is catching
       a signal, the child ignores the signal before execing,
       and the parent later receives that signal, the parent dumps core.
       Test for this by ignoring SIGINT in the child.  */
    signal (SIGINT, SIG_IGN);

    /* 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)
      ;
    exit(
     /* 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 signal handling bug occur?  */
     || kill(parent, SIGINT) != 0
     || signalled != 1

     /* Did the file descriptor bug occur?  */
     || fstat(fileno(stdout), &st) != 0
     );
  }
}
EOF
eval $compile
if true; then
  :
else

{
test -n "$verbose" && \
echo "    defining vfork to be fork"
echo "#define vfork fork" >> confdefs.h
DEFS="$DEFS -Dvfork=fork"
SEDDEFS="${SEDDEFS}\${SEDdA}vfork\${SEDdB}vfork\${SEDdC}fork\${SEDdD}
\${SEDuA}vfork\${SEDuB}vfork\${SEDuC}fork\${SEDuD}
\${SEDeA}vfork\${SEDeB}vfork\${SEDeC}fork\${SEDeD}
"
}

fi
rm -fr conftest*

cat > conftest.c <<EOF
#include "confdefs.h"
#include <stdio.h>
/* If setvbuf has the reversed format, exit 0. */
main () {
  /* This call has the arguments reversed.
     A reversed system may check and see that the address of main
     is not _IOLBF, _IONBF, or _IOFBF, and return nonzero.  */
  if (setvbuf(stdout, _IOLBF, (char *) main, BUFSIZ) != 0)
    exit(1);
  putc('\r', stdout);
  exit(0);            /* Non-reversed systems segv here.  */
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining SETVBUF_REVERSED"
echo "#define SETVBUF_REVERSED 1" >> confdefs.h
DEFS="$DEFS -DSETVBUF_REVERSED=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SETVBUF_REVERSED\${SEDdB}SETVBUF_REVERSED\${SEDdC}1\${SEDdD}
\${SEDuA}SETVBUF_REVERSED\${SEDuB}SETVBUF_REVERSED\${SEDuC}1\${SEDuD}
\${SEDeA}SETVBUF_REVERSED\${SEDeB}SETVBUF_REVERSED\${SEDeC}1\${SEDeD}
"
}


fi
rm -fr conftest*
rm -f core

# Some definitions of getloadavg require that the program be installed setgid.
NEED_SETGID=false
need_func=true

# Check for the 4.4BSD definition of getloadavg.
LIBS_save="${LIBS}"
LIBS="${LIBS} -lutil"
have_lib=""
echo checking for -lutil
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS_save="${LIBS}"
LIBS="${LIBS} -lkvm"
have_lib=""
echo checking for -lkvm
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lutil -lkvm" need_func=false
else
   :;
fi

else
   :;
fi


if $need_func; then
# There is a commonly available library for RS/6000 AIX.
# Since it is not a standard part of AIX, it might be installed locally.
LIBS_old="$LIBS"
LIBS="-L/local/lib $LIBS"
LIBS_save="${LIBS}"
LIBS="${LIBS} -lgetloadavg"
have_lib=""
echo checking for -lgetloadavg
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lgetloadavg" need_func=false
else
   :; LIBS="$LIBS_old"
fi

fi

# Make sure it is really in the library, if we think we found it at all.
for func in getloadavg
do
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  :
else
  rm -rf conftest*
  LIBOBJS="$LIBOBJS ${func}.o"
test -n "$verbose" && echo "    using ${func}.o instead"
fi
rm -f conftest*

done


case "$LIBOBJS" in
*getloadavg*)
need_func=true
echo checking for sys/dg_sys_info.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/dg_sys_info.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining DGUX"
echo "#define DGUX 1" >> confdefs.h
DEFS="$DEFS -DDGUX=1"
SEDDEFS="${SEDDEFS}\${SEDdA}DGUX\${SEDdB}DGUX\${SEDdC}1\${SEDdD}
\${SEDuA}DGUX\${SEDuB}DGUX\${SEDuC}1\${SEDuD}
\${SEDeA}DGUX\${SEDeB}DGUX\${SEDeC}1\${SEDeD}
"
}
 need_func=false
# Some versions of DGUX need -ldgc for dg_sys_info.
LIBS_save="${LIBS}"
LIBS="${LIBS} -ldgc"
have_lib=""
echo checking for -ldgc
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then

{
test -n "$verbose" && \
echo "    defining HAVE_LIBDGC"
echo "#define HAVE_LIBDGC 1" >> confdefs.h
DEFS="$DEFS -DHAVE_LIBDGC=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LIBDGC\${SEDdB}HAVE_LIBDGC\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_LIBDGC\${SEDuB}HAVE_LIBDGC\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_LIBDGC\${SEDeB}HAVE_LIBDGC\${SEDeC}1\${SEDeD}
"
}

   LIBS="${LIBS} -ldgc"
fi


fi
rm -f conftest*

if $need_func; then
# We cannot check for <dwarf.h>, because Solaris 2 does not use dwarf (it
# uses stabs), but it's still SVR4.  We cannot check for <elf.h> because
# Irix 4.0.5F has the header but not the library.
LIBS_save="${LIBS}"
LIBS="${LIBS} -lelf"
have_lib=""
echo checking for -lelf
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :;
{
test -n "$verbose" && \
echo "    defining SVR4"
echo "#define SVR4 1" >> confdefs.h
DEFS="$DEFS -DSVR4=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SVR4\${SEDdB}SVR4\${SEDdC}1\${SEDdD}
\${SEDuA}SVR4\${SEDuB}SVR4\${SEDuC}1\${SEDuD}
\${SEDeA}SVR4\${SEDeB}SVR4\${SEDeC}1\${SEDeD}
"
}
 LIBS="$LIBS -lelf" need_func=false
  LIBS_save="${LIBS}"
LIBS="${LIBS} -lkvm"
have_lib=""
echo checking for -lkvm
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lkvm"
else
   :;
fi

else
   :;
fi

fi
if $need_func; then
echo checking for inq_stats/cpustats.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <inq_stats/cpustats.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining UMAX4_3"
echo "#define UMAX4_3 1" >> confdefs.h
DEFS="$DEFS -DUMAX4_3=1"
SEDDEFS="${SEDDEFS}\${SEDdA}UMAX4_3\${SEDdB}UMAX4_3\${SEDdC}1\${SEDdD}
\${SEDuA}UMAX4_3\${SEDuB}UMAX4_3\${SEDuC}1\${SEDuD}
\${SEDeA}UMAX4_3\${SEDeB}UMAX4_3\${SEDeC}1\${SEDeD}
"
}

{
test -n "$verbose" && \
echo "    defining UMAX"
echo "#define UMAX 1" >> confdefs.h
DEFS="$DEFS -DUMAX=1"
SEDDEFS="${SEDDEFS}\${SEDdA}UMAX\${SEDdB}UMAX\${SEDdC}1\${SEDdD}
\${SEDuA}UMAX\${SEDuB}UMAX\${SEDuC}1\${SEDuD}
\${SEDeA}UMAX\${SEDeB}UMAX\${SEDeC}1\${SEDeD}
"
}

  need_func=false

fi
rm -f conftest*

fi
if $need_func; then
echo checking for sys/cpustats.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/cpustats.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining UMAX"
echo "#define UMAX 1" >> confdefs.h
DEFS="$DEFS -DUMAX=1"
SEDDEFS="${SEDDEFS}\${SEDdA}UMAX\${SEDdB}UMAX\${SEDdC}1\${SEDdD}
\${SEDuA}UMAX\${SEDuB}UMAX\${SEDuC}1\${SEDuD}
\${SEDeA}UMAX\${SEDeB}UMAX\${SEDeC}1\${SEDeD}
"
}
 need_func=false

fi
rm -f conftest*

fi
if $need_func; then
for hdr in mach/mach.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining ${trhdr}"
echo "#define ${trhdr} 1" >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
\${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
\${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done

fi

echo checking for nlist.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <nlist.h>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining NLIST_STRUCT"
echo "#define NLIST_STRUCT 1" >> confdefs.h
DEFS="$DEFS -DNLIST_STRUCT=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NLIST_STRUCT\${SEDdB}NLIST_STRUCT\${SEDdC}1\${SEDdD}
\${SEDuA}NLIST_STRUCT\${SEDuB}NLIST_STRUCT\${SEDuC}1\${SEDuD}
\${SEDeA}NLIST_STRUCT\${SEDeB}NLIST_STRUCT\${SEDeC}1\${SEDeD}
"
}

echo checking for n_un in struct nlist
cat > conftest.c <<EOF
#include "confdefs.h"
#include <nlist.h>
int main() { exit(0); }
int t() { struct nlist n; n.n_un.n_name = 0; }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining NLIST_NAME_UNION"
echo "#define NLIST_NAME_UNION 1" >> confdefs.h
DEFS="$DEFS -DNLIST_NAME_UNION=1"
SEDDEFS="${SEDDEFS}\${SEDdA}NLIST_NAME_UNION\${SEDdB}NLIST_NAME_UNION\${SEDdC}1\${SEDdD}
\${SEDuA}NLIST_NAME_UNION\${SEDuB}NLIST_NAME_UNION\${SEDuC}1\${SEDuD}
\${SEDeA}NLIST_NAME_UNION\${SEDeB}NLIST_NAME_UNION\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


fi
rm -f conftest*

# Figure out whether we will need to install setgid.
cat > conftest.c <<EOF
#include "confdefs.h"
dnl
#include "${srcdir}/getloadavg.c"
#ifdef LDAV_PRIVILEGED
Yowza Am I SETGID yet
#endif
EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "Yowza Am I SETGID yet" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining GETLOADAVG_PRIVILEGED"
echo "#define GETLOADAVG_PRIVILEGED 1" >> confdefs.h
DEFS="$DEFS -DGETLOADAVG_PRIVILEGED=1"
SEDDEFS="${SEDDEFS}\${SEDdA}GETLOADAVG_PRIVILEGED\${SEDdB}GETLOADAVG_PRIVILEGED\${SEDdC}1\${SEDdD}
\${SEDuA}GETLOADAVG_PRIVILEGED\${SEDuB}GETLOADAVG_PRIVILEGED\${SEDuC}1\${SEDuD}
\${SEDeA}GETLOADAVG_PRIVILEGED\${SEDeB}GETLOADAVG_PRIVILEGED\${SEDeC}1\${SEDeD}
"
}
 NEED_SETGID=true

fi
rm -f conftest*
;;

*)
{
test -n "$verbose" && \
echo "    defining HAVE_GETLOADAVG"
echo "#define HAVE_GETLOADAVG 1" >> confdefs.h
DEFS="$DEFS -DHAVE_GETLOADAVG=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_GETLOADAVG\${SEDdB}HAVE_GETLOADAVG\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_GETLOADAVG\${SEDuB}HAVE_GETLOADAVG\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_GETLOADAVG\${SEDeB}HAVE_GETLOADAVG\${SEDeC}1\${SEDeD}
"
}
 ;;
esac

if $NEED_SETGID; then
  # Figure out what group owns /dev/kmem.
  # The installed program will need to be setgid and owned by that group.
  # On Solaris, /dev/kmem is a symlink.  Get info on the real file.
  ls_output=`ls -lgL /dev/kmem 2>/dev/null`
  # If we got an error (system does not support symlinks), try without -L.
  test -z "$ls_output" && ls_output=`ls -lg /dev/kmem`
  KMEM_GROUP=`echo $ls_output \
    | sed -ne 's/[     ][     ]*/ /g;
           s/^.[sSrwx-]* *[0-9]* *\([^0-9]*\)  *.*/\1/;
           / /s/.* //;p;'`
fi

echo checking for strcoll
cat > conftest.c <<EOF
#include "confdefs.h"
#include <string.h>
main ()
{
  exit (strcoll ("abc", "def") >= 0 ||
    strcoll ("ABC", "DEF") >= 0 ||
    strcoll ("123", "456") >= 0);
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then

{
test -n "$verbose" && \
echo "    defining HAVE_STRCOLL"
echo "#define HAVE_STRCOLL 1" >> confdefs.h
DEFS="$DEFS -DHAVE_STRCOLL=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_STRCOLL\${SEDdB}HAVE_STRCOLL\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_STRCOLL\${SEDuB}HAVE_STRCOLL\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_STRCOLL\${SEDeB}HAVE_STRCOLL\${SEDeC}1\${SEDeD}
"
}


fi
rm -fr conftest*

for hdr in sys/wait.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <${hdr}>
EOF
err=`eval "($CPP conftest.c >/dev/null) 2>&1"`
if test -z "$err"; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining ${trhdr}"
echo "#define ${trhdr} 1" >> confdefs.h
DEFS="$DEFS -D${trhdr}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD}
\${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD}
\${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done
 for func in waitpid wait3
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include "confdefs.h"
#include <ctype.h>
int main() { exit(0); }
int t() {
/* 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_${func}) || defined (__stub___${func})
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*
  {
test -n "$verbose" && \
echo "    defining ${trfunc}"
echo "#define ${trfunc} 1" >> confdefs.h
DEFS="$DEFS -D${trfunc}=1"
SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD}
\${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD}
\${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*
done

echo checking for union wait
cat > conftest.c <<EOF
#include "confdefs.h"
#include <sys/types.h>
#include <sys/wait.h>
int main() { exit(0); }
int t() { union wait status; int pid; pid = wait (&status);
#ifdef WEXITSTATUS
/* Some POSIXoid systems have both the new-style macros and the old
   union wait type, and they do not work together.  If union wait
   conflicts with WEXITSTATUS et al, we don't want to use it at all.  */
if (WEXITSTATUS (status) != 0) pid = -1;
#endif
#ifdef HAVE_WAITPID
/* Make sure union wait works with waitpid.  */
pid = waitpid (-1, &status, 0);
#endif
 }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining HAVE_UNION_WAIT"
echo "#define HAVE_UNION_WAIT 1" >> confdefs.h
DEFS="$DEFS -DHAVE_UNION_WAIT=1"
SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_UNION_WAIT\${SEDdB}HAVE_UNION_WAIT\${SEDdC}1\${SEDdD}
\${SEDuA}HAVE_UNION_WAIT\${SEDuB}HAVE_UNION_WAIT\${SEDuC}1\${SEDuD}
\${SEDeA}HAVE_UNION_WAIT\${SEDeB}HAVE_UNION_WAIT\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


echo checking for sys_siglist declaration in signal.h or unistd.h
cat > conftest.c <<EOF
#include "confdefs.h"
#include <signal.h>
/* NetBSD declares sys_siglist in <unistd.h>.  */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
int main() { exit(0); }
int t() { char *msg = *(sys_siglist + 1); }
EOF
if eval $compile; then
  rm -rf conftest*

{
test -n "$verbose" && \
echo "    defining SYS_SIGLIST_DECLARED"
echo "#define SYS_SIGLIST_DECLARED 1" >> confdefs.h
DEFS="$DEFS -DSYS_SIGLIST_DECLARED=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SYS_SIGLIST_DECLARED\${SEDdB}SYS_SIGLIST_DECLARED\${SEDdC}1\${SEDdD}
\${SEDuA}SYS_SIGLIST_DECLARED\${SEDuB}SYS_SIGLIST_DECLARED\${SEDuC}1\${SEDuD}
\${SEDeA}SYS_SIGLIST_DECLARED\${SEDeB}SYS_SIGLIST_DECLARED\${SEDeC}1\${SEDeD}
"
}


fi
rm -f conftest*


# The presence of the following is not meant to imply
# that make necessarily works on those systems.
LIBS_save="${LIBS}"
LIBS="${LIBS} -lseq"
have_lib=""
echo checking for -lseq
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lseq"
else
   :;
fi


echo checking for Xenix
cat > conftest.c <<EOF
#include "confdefs.h"
#if defined(M_XENIX) && !defined(M_UNIX)
  yes
#endif

EOF
eval "$CPP conftest.c > conftest.out 2>&1"
if egrep "yes" conftest.out >/dev/null 2>&1; then
  rm -rf conftest*
  XENIX=1

fi
rm -f conftest*

if test -n "$XENIX"; then
  LIBS="$LIBS -lx"
  case "$DEFS" in
  *SYSNDIR*) ;;
  *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx.
  esac
fi

LIBS_save="${LIBS}"
LIBS="${LIBS} -lsun"
have_lib=""
echo checking for -lsun
cat > conftest.c <<EOF
#include "confdefs.h"

int main() { exit(0); }
int t() { main(); }
EOF
if eval $compile; then
  rm -rf conftest*
  have_lib="1"

fi
rm -f conftest*
LIBS="${LIBS_save}"
if test -n "${have_lib}"; then
   :; LIBS="$LIBS -lsun"
else
   :;
fi



 REMOTE=stub
# check whether --with-customs was given
withval="$with_customs"
if test -n "$withval"; then
  REMOTE=cstms
LIBS="$LIBS libcustoms.a"
fi


echo checking for location of SCCS get command
if false; then
  SCCS_GET=/usr/sccs/get

{
test -n "$verbose" && \
echo "    defining SCCS_GET to be \"/usr/sccs/get\""
echo "#define SCCS_GET \"/usr/sccs/get\"" >> confdefs.h
DEFS="$DEFS -DSCCS_GET=\"/usr/sccs/get\""
SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET\${SEDdB}SCCS_GET\${SEDdC}\"/usr/sccs/get\"\${SEDdD}
\${SEDuA}SCCS_GET\${SEDuB}SCCS_GET\${SEDuC}\"/usr/sccs/get\"\${SEDuD}
\${SEDeA}SCCS_GET\${SEDeB}SCCS_GET\${SEDeC}\"/usr/sccs/get\"\${SEDeD}
"
}

else
  SCCS_GET=get

{
test -n "$verbose" && \
echo "    defining SCCS_GET to be \"get\""
echo "#define SCCS_GET \"get\"" >> confdefs.h
DEFS="$DEFS -DSCCS_GET=\"get\""
SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET\${SEDdB}SCCS_GET\${SEDdC}\"get\"\${SEDdD}
\${SEDuA}SCCS_GET\${SEDuB}SCCS_GET\${SEDuC}\"get\"\${SEDuD}
\${SEDeA}SCCS_GET\${SEDeB}SCCS_GET\${SEDeC}\"get\"\${SEDeD}
"
}

fi
ac_clean_files="$ac_clean_files s.conftest conftoast" # Remove these later.
if ( false || admin -n s.conftest ) >/dev/null 2>&1 &&
   test -f s.conftest; then
  # We successfully created an SCCS file.
  echo checking if SCCS get command understands -G
  if $SCCS_GET s.conftest -Gconftoast >/dev/null 2>&1 &&
     test -f conftoast; then

{
test -n "$verbose" && \
echo "    defining SCCS_GET_MINUS_G"
echo "#define SCCS_GET_MINUS_G 1" >> confdefs.h
DEFS="$DEFS -DSCCS_GET_MINUS_G=1"
SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET_MINUS_G\${SEDdB}SCCS_GET_MINUS_G\${SEDdC}1\${SEDdD}
\${SEDuA}SCCS_GET_MINUS_G\${SEDuB}SCCS_GET_MINUS_G\${SEDuC}1\${SEDuD}
\${SEDeA}SCCS_GET_MINUS_G\${SEDeB}SCCS_GET_MINUS_G\${SEDeC}1\${SEDeD}
"
}

  fi
fi
rm -f s.conftest conftoast

# Set default prefixes.
if test "z$prefix" != 'z' ; then
  test "z$exec_prefix" = 'z' && exec_prefix='${prefix}'
  prsub="s%^prefix\\([     ]*\\)=\\([     ]*\\).*$%prefix\\1=\\2$prefix%"
fi
if test -n "$exec_prefix"; then
  prsub="$prsub
s%^exec_prefix\\([     ]*\\)=\\([     ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%"
fi
# Quote sed substitution magic chars in DEFS.
cat >conftest.def <<EOF
$DEFS
EOF
escape_ampersand_and_backslash='s%[&\\]%\\&%g'
DEFS=`sed "$escape_ampersand_and_backslash" <conftest.def`
rm -f conftest.def
# Substitute for predefined variables.

trap 'rm -f config.status; exit 1' 1 3 15
echo creating config.status
rm -f config.status
cat > config.status <<EOF
#!/bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $configure_args

for arg
do
  case "\$arg" in
    -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args
    exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args ;;
    *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;;
  esac
done

trap 'rm -fr Makefile build.sh glob/Makefile config.h conftest*; exit 1' 1 3 15
CFLAGS='$CFLAGS'
LDFLAGS='$LDFLAGS'
CC='$CC'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
RANLIB='$RANLIB'
CPP='$CPP'
LIBOBJS='$LIBOBJS'
ALLOCA='$ALLOCA'
NEED_SETGID='$NEED_SETGID'
KMEM_GROUP='$KMEM_GROUP'
REMOTE='$REMOTE'
LIBS='$LIBS'
srcdir='$srcdir'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
extrasub='$extrasub'
EOF
cat >> config.status <<\EOF

top_srcdir=$srcdir

CONFIG_FILES=${CONFIG_FILES-"Makefile build.sh glob/Makefile"}
for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then
  srcdir=$top_srcdir
  # Remove last slash and all that follows it.  Not all systems have dirname.
  dir=`echo $file|sed 's%/[^/][^/]*$%%'`
  if test "$dir" != "$file"; then
    test "$top_srcdir" != . && srcdir=$top_srcdir/$dir
    test ! -d "$dir" && mkdir "$dir"
  fi
  echo creating "$file"
  rm -f "$file"
  comment_str="Generated automatically from `echo $file|sed 's|.*/||'`.in by configure."
  case "$file" in
    *.c | *.h | *.C | *.cc | *.m )  echo "/* $comment_str */" > "$file" ;;
    * )          echo "# $comment_str"     > "$file" ;;
  esac
  sed -e "
$prsub
$extrasub
s%@CFLAGS@%$CFLAGS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@CC@%$CC%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@RANLIB@%$RANLIB%g
s%@CPP@%$CPP%g
s%@LIBOBJS@%$LIBOBJS%g
s%@ALLOCA@%$ALLOCA%g
s%@NEED_SETGID@%$NEED_SETGID%g
s%@KMEM_GROUP@%$KMEM_GROUP%g
s%@REMOTE@%$REMOTE%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file
fi; done

CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"}
for file in .. ${CONFIG_HEADERS}; do if test "x$file" != x..; then
echo creating $file

# These sed commands are put into SEDDEFS when defining a macro.
# They are broken into pieces to make the sed script easier to manage.
# They are passed to sed as "A NAME B NAME C VALUE D", where NAME
# is the cpp macro being defined and VALUE is the value it is being given.
# Each defining turns into a single global substitution command.
# Hopefully no one uses "!" as a variable value.
# Other candidates for the sed separators, like , and @, do get used.
#
# SEDd sets the value in "#define NAME VALUE" lines.
SEDdA='s!^\([     ]*\)#\([     ]*define[     ][     ]*\)'
SEDdB='\([     ][     ]*\)[^     ]*!\1#\2'
SEDdC='\3'
SEDdD='!g'
# SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
SEDuA='s!^\([     ]*\)#\([     ]*\)undef\([     ][     ]*\)'
SEDuB='\([     ]\)!\1#\2define\3'
SEDuC=' '
SEDuD='\4!g'
# SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
SEDeA='s!^\([     ]*\)#\([     ]*\)undef\([     ][     ]*\)'
SEDeB='$!\1#\2define\3'
SEDeC=' '
SEDeD='!g'
rm -f conftest.sed
EOF
# Turn off quoting long enough to insert the sed commands.
rm -f conftest.sh
cat > conftest.sh <<EOF
$SEDDEFS
EOF

# Break up $SEDDEFS (now in conftest.sh) because some shells have a limit
# on the size of here documents.

# Maximum number of lines to put in a single here document.
maxshlines=9

while :
do
  # wc gives bogus results for an empty file on some systems.
  lines=`grep -c . conftest.sh`
  if test -z "$lines" || test "$lines" -eq 0; then break; fi
  rm -f conftest.s1 conftest.s2
  sed ${maxshlines}q conftest.sh > conftest.s1 # Like head -20.
  sed 1,${maxshlines}d conftest.sh > conftest.s2 # Like tail +21.
  # Write a limited-size here document to append to conftest.sed.
  echo 'cat >> conftest.sed <<CONFEOF' >> config.status
  cat conftest.s1 >> config.status
  echo 'CONFEOF' >> config.status
  rm -f conftest.s1 conftest.sh
  mv conftest.s2 conftest.sh
done
rm -f conftest.sh

# Now back to your regularly scheduled config.status.
cat >> config.status <<\EOF
# This sed command replaces #undef's with comments.  This is necessary, for
# example, in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it in
# config.h.
cat >> conftest.sed <<\CONFEOF
s,^[     ]*#[     ]*undef[     ][     ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
CONFEOF
rm -f conftest.h
# Break up the sed commands because old seds have small limits.
maxsedlines=20
cp $top_srcdir/$file.in conftest.h1
while :
do
  lines=`grep -c . conftest.sed`
  if test -z "$lines" || test "$lines" -eq 0; then break; fi
  rm -f conftest.s1 conftest.s2 conftest.h2
  sed ${maxsedlines}q conftest.sed > conftest.s1 # Like head -20.
  sed 1,${maxsedlines}d conftest.sed > conftest.s2 # Like tail +21.
  sed -f conftest.s1 < conftest.h1 > conftest.h2
  rm -f conftest.s1 conftest.h1 conftest.sed
  mv conftest.h2 conftest.h1
  mv conftest.s2 conftest.sed
done
rm -f conftest.sed conftest.h
echo "/* $file.  Generated automatically by configure.  */" > conftest.h
cat conftest.h1 >> conftest.h
rm -f conftest.h1
if cmp -s $file conftest.h 2>/dev/null; then
  # The file exists and we would not be changing it.
  echo "$file is unchanged"
  rm -f conftest.h
else
  rm -f $file
  mv conftest.h $file
fi
fi; done



# Makefile uses this timestamp file to know when to remake Makefile,
# build.sh, and glob/Makefile.
touch stamp-config
exit 0
EOF
chmod +x config.status
${CONFIG_SHELL-/bin/sh} config.status