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

# This program 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 program 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] [--no-create]
#        [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE] [TARGET]
# Ignores all args except --srcdir, --prefix, --exec-prefix, --no-create, and
# --with-PACKAGE 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, also recognize exact --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) ;;

     -no-create | --no-create | --no-creat | --no-crea | --no-cre | --no-cr | --no-c | --no- | --no)
        no_create=1 ;;

     -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 's/-*with-//'`
       # Delete all the valid chars; see if any are left.
       if test -n "`echo $package|sed 's/[-a-zA-Z0-9_]*//g'`"; then
         echo "configure: $package: invalid package name" >&2; exit 1
       fi
       eval "with_`echo $package|sed s/-/_/g`=1" ;;

     *) ;;
    esac
  fi
done

trap 'rm -f conftest* core; exit 1' 1 3 15

rm -f conftest*
compile='${CC-cc} $DEFS 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=groff/groff.cc

# 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%/[^/][^/]*$%%'`
  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

if test -z "$prefix"
then
  echo checking for grops to derive installation directory prefix
  saveifs="$IFS"; IFS="$IFS:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test $dir != . && test -f $dir/grops; then
      # Not all systems have dirname.
      prefix=`echo $dir|sed 's%/[^/][^/]*$%%'`
      break
    fi
  done
  IFS="$saveifs"
fi
if test -z "$prefix"
then
  echo checking for gcc to derive installation directory prefix
  saveifs="$IFS"; IFS="$IFS:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test $dir != . && test -f $dir/gcc; then
      # Not all systems have dirname.
      prefix=`echo $dir|sed 's%/[^/][^/]*$%%'`
      break
    fi
  done
  IFS="$saveifs"
fi

if test -z "$CC"; then
  echo checking for gcc
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/gcc; then
      CC="gcc"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CC" && CC="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*

cc_compile='$CCC conftest.cc -o conftest $CCLIBS $LIBS >/dev/null 2>&1'

if test -z "$CCC"; then
# See whether the C compiler is also a C++ compiler.
echo checking if C compiler is also a C++ compiler
cat <<EOF > conftest.cc
#ifdef __cplusplus
  yes
#endif
EOF
$CC -E conftest.cc >conftest.out 2>&1
if egrep yes conftest.out >/dev/null 2>&1; then
  CCC="$CC"
fi
fi
if test -z "$CCC"; then
  echo checking for g++
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/g++; then
      CCC="g++"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CCC" && CCC=""

if test -z "$CCC"; then
  echo checking for CC
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/CC; then
      CCC="CC"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CCC" && CCC=""

if test -z "$CCC"; then
  echo checking for cc++
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/cc++; then
      CCC="cc++"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$CCC" && CCC=""

if test -z "$CCC"; then
cat <<EOM
This package requires a C++ compiler, but I couldn't find one.
Set the environment variable CCC to the name of your C++ compiler.
EOM
rm -f conftest* core; exit 1
fi
echo checking that C++ compiler can compile very simple C++ program
cat <<EOF > conftest.cc

extern "C" { void exit(int); }
int main() { exit(0); }

EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
  :
else
  cat <<EOM
$CCC was unable successfully to compile a very simple C++ program
(the C++ program was in a file with a suffix of .cc)
EOM
rm -f conftest* core; exit 1

fi
rm -f conftest*
echo checking that C++ static constructors and destructors are called
cat <<EOF > conftest.cc

extern "C" {
  void exit(int);
  void _exit(int);
}
int i;
struct A {
  char dummy;
  A() { i = 1; }
  ~A() { if (i == 1) _exit(0); }
};
A a;
main() { exit(1); }

EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
  :
else
  cat <<EOM
$CCC is not installed correctly: static constructors and destructors do not work
EOM
rm -f conftest* core; exit 1

fi
rm -f conftest*
echo checking for C++ header files
cat <<EOF >conftest.cc
#include <stdio.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { fopen(0, 0); }
EOF
if eval $cc_compile; then
  :
else
  cat <<\EOF
Your header files do not appear to support C++.
I was unable to compile and link a simple C++ program that used a function
declared in <stdio.h>.
If you're using gcc/g++, you should install libg++.
EOF
rm -f conftest* core; exit 1
fi
rm -f conftest*
if test -z "$PSPRINT"
then
	for p in lpr
do
if test -z "$LPR"; then
  echo checking for $p
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$p; then
      LPR="$p"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$LPR" && LPR=""

test -n "$LPR" && break
done

	for p in lp
do
if test -z "$LP"; then
  echo checking for $p
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$p; then
      LP="$p"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$LP" && LP=""

test -n "$LP" && break
done

	if test -n "$LPR" && test -n "$LP"
	then
		# HP-UX provides an lpr command that emulates lpr using lp,
		# but it doesn't have lpq; in this case we want to use lp
		# rather than lpr.
		for p in lpq
do
if test -z "$LPQ"; then
  echo checking for $p
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/$p; then
      LPQ="$p"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$LPQ" && LPQ=""

test -n "$LPQ" && break
done

		test -n "$LPQ" || LPR=
	fi
	if test -n "$LPR"
	then
		PSPRINT="$LPR"
	elif test -n "$LP"
	then
		PSPRINT="$LP"
	fi
fi

# Figure out DVIPRINT from PSPRINT.
if test -n "$PSPRINT" && test -z "$DVIPRINT"
then
	if test "X$PSPRINT" = "Xlpr"
	then
		DVIPRINT="lpr -d"
	else
		DVIPRINT="$PSPRINT"
	fi
fi

echo checking for perl
PERLPATH=
saveifs="$IFS"; IFS="${IFS}:"
for dir in $PATH; do
  test -z "$dir" && dir=.
  if test -f $dir/perl; then
     PERLPATH="$dir/perl"
     break
  fi
done
IFS="$saveifs"

if test -z "$YACC"; then
  echo checking for byacc
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/byacc; then
      YACC="byacc"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$YACC" && YACC=""

if test -z "$YACC"; then
  echo checking for bison
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/bison; then
      YACC="bison -y"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$YACC" && YACC="yacc"


if test -z "$RANLIB"; then
  echo checking for ranlib
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    if test -f $dir/ranlib; then
      RANLIB="ranlib"
      break
    fi
  done
  IFS="$saveifs"
fi
test -z "$RANLIB" && RANLIB="@:"

# 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.  (Sigh.)
if test -z "$INSTALL"; then
  echo checking for install
  saveifs="$IFS"; IFS="${IFS}:"
  for dir in $PATH; do
    test -z "$dir" && dir=.
    case $dir in
    /etc|/usr/sbin|/usr/etc|/usr/afsws/bin) ;;
    *)
      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
INSTALL=${INSTALL-cp}
INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'}
INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'}

echo checking for ln -s
rm -f conftestdata
if ln -s X conftestdata 2>/dev/null
then
  rm -f conftestdata
  LN_S="ln -s"
else
  LN_S=ln
fi


echo checking for etags C++ option
for flag in p C
do
	test -z "$ETAGSCCFLAG" || break
	>conftest.c
	(etags -$flag -o /dev/null conftest.c >/dev/null 2>&1) 2>/dev/null &&
		ETAGSCCFLAG="-$flag"
	rm -f conftest.c
done

echo 'checking for csh # hack'
cat <<EOF >conftest.sh
#!/bin/sh
true || exit 0
export PATH || exit 0
exit 1
EOF
chmod +x conftest.sh
if echo ./conftest.sh | (csh >/dev/null 2>&1) >/dev/null 2>&1
then
	:; SH_SCRIPT_SED_CMD='1s/.*/:/'
else
	:; SH_SCRIPT_SED_CMD=''
fi
rm -f conftest.sh


echo checking for unistd.h
echo checking how to run the C preprocessor
if test -z "$CPP"; then
  CPP='${CC-cc} -E'
  cat > conftest.c <<EOF
#include <stdio.h>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
  :
else
  CPP=/lib/cpp
fi
rm -f conftest*
fi

cat > conftest.c <<EOF
#include <unistd.h>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
  DEFS="$DEFS -DHAVE_UNISTD_H=1"
fi
rm -f conftest*

for hdr in dirent.h limits.h sys/dir.h stdlib.h
do
trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'`
echo checking for ${hdr}
cat > conftest.c <<EOF
#include <${hdr}>
EOF
err=`eval "$CPP $DEFS conftest.c 2>&1 >/dev/null"`
if test -z "$err"; then
  DEFS="$DEFS -D${trhdr}=1"
fi
rm -f conftest*
done

echo checking for 'C++ <limits.h>'
cat <<EOF >conftest.cc
#include <limits.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { int x = INT_MIN; int y = INT_MAX; int z = UCHAR_MAX; }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DHAVE_CC_LIMITS_H=1"
fi
rm -f conftest*
echo checking for 'C++ <unistd.h>'
cat <<EOF >conftest.cc
#include <unistd.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { read(0, 0, 0); }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DHAVE_CC_UNISTD_H=1"
fi
rm -f conftest*
echo checking for declaration of getopt in stdlib.h
cat <<EOF >conftest.cc
#include <stdlib.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { int opt = getopt(0, 0, 0); optarg = "foo"; optind = 1; }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DSTDLIB_H_DECLARES_GETOPT=1"
fi
rm -f conftest*
echo checking for declaration of getopt in unistd.h
cat <<EOF >conftest.cc
#include <sys/types.h>
#include <unistd.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { int opt = getopt(0, 0, 0); }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DUNISTD_H_DECLARES_GETOPT=1"
fi
rm -f conftest*

echo checking for declaration of putenv
cat <<EOF >conftest.cc
#include <stdlib.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { putenv((char *)0); }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DSTDLIB_H_DECLARES_PUTENV=1"
fi
rm -f conftest*
echo checking for time_t
cat <<EOF >conftest.cc
#include <time.h>
extern "C" { void exit(int); }
int main() { exit(0); } void t() { time_t t = time(0); struct tm *p = localtime(&t); }
EOF
if eval $cc_compile; then
  :
else
  DEFS="$DEFS -DLONG_FOR_TIME_T=1"
fi
rm -f conftest*
echo checking for return type of signal handlers
cat > conftest.c <<EOF
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
extern void (*signal ()) ();
main() { exit(0); } 
t() { int i; }
EOF
if eval $compile; then
  DEFS="$DEFS -DRETSIGTYPE=void"
else
  DEFS="$DEFS -DRETSIGTYPE=int"
fi
rm -f conftest*


echo checking for struct exception
cat > conftest.c <<EOF
#include <math.h>
main() { exit(0); } 
t() { struct exception e; }
EOF
if eval $compile; then
  DEFS="$DEFS -DHAVE_STRUCT_EXCEPTION=1"
fi
rm -f conftest*

echo checking for mmap
cat > conftest.c <<EOF
#include <sys/types.h>
#include <sys/mman.h>
main() { exit(0); } 
t() { char *p = mmap(0, 0, PROT_READ, MAP_PRIVATE, 0, 0); munmap(p, 0); }
EOF
if eval $compile; then
  DEFS="$DEFS -DHAVE_MMAP=1"
fi
rm -f conftest*

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

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

echo checking for working vfork
cat > conftest.c <<EOF
/* Thanks to Paul Eggert for this test.  */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_VFORK_H
#include <vfork.h>
#endif
main() {
  pid_t parent = getpid();
  pid_t 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. 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 file descriptor bug occur?  */
	 || fstat(fileno(stdout), &st) != 0
	 );
  }
}
EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  :
else
  DEFS="$DEFS -Dvfork=fork"
fi
rm -f conftest*

saved_libs="$LIBS"
LIBS="$LIBS -lm"
for func in fmod strtol getcwd strerror putenv
do
echo checking for ${func}
cat > conftest.c <<EOF

main() { exit(0); } 
t() { 
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}(); }
EOF
if eval $compile; then
  :
else
  LIBOBJS="$LIBOBJS ${func}.o"
fi
rm -f conftest*

done

LIBS="$saved_libs"
for func in rename mkstemp
do
trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'`
echo checking for ${func}
cat > conftest.c <<EOF
#include <stdio.h>
main() { exit(0); } 
t() { 
#ifdef __stub_${func}
choke me
#else
/* Override any gcc2 internal prototype to avoid an error.  */
extern char ${func}(); ${func}();
#endif
 }
EOF
if eval $compile; then
  DEFS="$DEFS -D${trfunc}=1"
fi
rm -f conftest*
#endif
done

echo checking for sys_siglist
cat > conftest.c <<EOF

main() { exit(0); } 
t() { extern char *sys_siglist[]; sys_siglist[0] = 0; }
EOF
if eval $compile; then
  DEFS="$DEFS -DHAVE_SYS_SIGLIST=1"
fi
rm -f conftest*

echo checking for gcc/g++ delete bug
cat <<EOF > conftest.cc

#include <stdlib.h>
#include <stddef.h>

int testit = 0;

int main()
{
  testit = 1;
  int *p = new int;
  delete p;
  testit = 0;
  exit(1);
}

static unsigned dummy[3];

void *operator new(size_t n)
{
  if (testit) {
    dummy[1] = -(unsigned)(dummy + 2);
    return dummy + 2;
  }
  else
    return (void *)malloc(n);
}

void operator delete(void *p)
{
  if (testit) {
    if (p == dummy)
      exit(0);
  }
  else
    free(p);
}

EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
  DEFS="$DEFS -DCOOKIE_BUG=1"
fi
rm -f conftest*
echo checking for cfront ANSI C INT_MIN bug
cat <<EOF > conftest.cc
#include <stdlib.h>
#ifdef HAVE_CC_LIMITS_H
#include <limits.h>
#else
#define INT_MAX 2147483647
#endif

#undef INT_MIN
#define INT_MIN (-INT_MAX-1)

int main()
{
  int z = 0;
  exit(INT_MIN < z);
}

EOF
rm -f conftest
eval $cc_compile
if test -s conftest && (./conftest) 2>/dev/null; then
  DEFS="$DEFS -DCFRONT_ANSI_BUG=1"
fi
rm -f conftest*
echo checking for new array delete syntax
cat <<EOF >conftest.cc

extern "C" { void exit(int); }
int main() { exit(0); } void t() { char *p = new char[5]; delete [] p; }
EOF
if eval $cc_compile; then
  :
else
  DEFS="$DEFS -DARRAY_DELETE_NEEDS_SIZE=1"
fi
rm -f conftest*
echo checking for traditional preprocessor
cat <<EOF >conftest.cc
#define name2(a,b) a/**/b
extern "C" { void exit(int); }
int main() { exit(0); } void t() { int name2(foo,bar); }
EOF
if eval $cc_compile; then
  DEFS="$DEFS -DTRADITIONAL_CPP=1"
fi
rm -f conftest*
echo checking for w_coredump
cat > conftest.c <<EOF

#include <sys/types.h>
#include <sys/wait.h>
main()
{
#ifdef WCOREFLAG
  exit(1);
#else
  int i = 0;
  ((union wait *)&i)->w_coredump = 1;
  exit(i != 0200);
#endif
}

EOF
eval $compile
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  DEFS="$DEFS -DWCOREFLAG=0200"
fi
rm -f conftest*
test -n "${BROKEN_SPOOLER_FLAGS}" || BROKEN_SPOOLER_FLAGS=7
echo using default value of ${BROKEN_SPOOLER_FLAGS} for grops -b option


if test -z "$PAGE" && test -r $prefix/lib/groff/font/devps/DESC
then
	if grep "^paperlength 841890" \
		$prefix/lib/groff/font/devps/DESC >/dev/null 2>&1
	then
		PAGE=A4
	else
		PAGE=letter
	fi
fi
if test -z "$PAGE"
then
	dom=`awk '($1 == "dom" || $1 == "search") { print $2; exit}' \
	    /etc/resolv.conf 2>/dev/null`

	if test -z "$dom"
	then
		dom=`(domainname) 2>/dev/null | tr -d '+'`
		if test -z "$dom"
		then
			dom=`(hostname) 2>/dev/null | grep '\.'`
		fi
	fi

	# If the top-level domain is two letters and it's not `us' or `ca'
	# then they probably use A4 paper.
	case "$dom" in
	*.[Uu][Ss]|*.[Cc][Aa]) ;;
	*.[A-Za-z][A-Za-z]) PAGE=A4 ;;
	esac
fi
test -n "$PAGE" || PAGE=letter
echo guessing $PAGE size paper

if test -n "$prefix"; then
  test -z "$exec_prefix" && 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

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`:
#
# $0 $*

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

trap 'rm -f Makefile; exit 1' 1 3 15
CC='$CC'
CCLIBS='$CCLIBS'
CCC='$CCC'
LPR='$LPR'
LP='$LP'
LPQ='$LPQ'
PSPRINT='$PSPRINT'
DVIPRINT='$DVIPRINT'
PERLPATH='$PERLPATH'
YACC='$YACC'
RANLIB='$RANLIB'
INSTALL='$INSTALL'
INSTALL_PROGRAM='$INSTALL_PROGRAM'
INSTALL_DATA='$INSTALL_DATA'
LN_S='$LN_S'
ETAGSCCFLAG='$ETAGSCCFLAG'
SH_SCRIPT_SED_CMD='$SH_SCRIPT_SED_CMD'
CPP='$CPP'
LIBOBJS='$LIBOBJS'
BROKEN_SPOOLER_FLAGS='$BROKEN_SPOOLER_FLAGS'
PAGE='$PAGE'
LIBS='$LIBS'
srcdir='$srcdir'
DEFS='$DEFS'
prefix='$prefix'
exec_prefix='$exec_prefix'
prsub='$prsub'
EOF
cat >> config.status <<\EOF

top_srcdir=$srcdir
for file in .. Makefile; do if [ "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
  echo "# Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." > $file
  sed -e "
$prsub
s%@CC@%$CC%g
s%@CCLIBS@%$CCLIBS%g
s%@CCC@%$CCC%g
s%@LPR@%$LPR%g
s%@LP@%$LP%g
s%@LPQ@%$LPQ%g
s%@PSPRINT@%$PSPRINT%g
s%@DVIPRINT@%$DVIPRINT%g
s%@PERLPATH@%$PERLPATH%g
s%@YACC@%$YACC%g
s%@RANLIB@%$RANLIB%g
s%@INSTALL@%$INSTALL%g
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
s%@INSTALL_DATA@%$INSTALL_DATA%g
s%@LN_S@%$LN_S%g
s%@ETAGSCCFLAG@%$ETAGSCCFLAG%g
s%@SH_SCRIPT_SED_CMD@%$SH_SCRIPT_SED_CMD%g
s%@CPP@%$CPP%g
s%@LIBOBJS@%$LIBOBJS%g
s%@BROKEN_SPOOLER_FLAGS@%$BROKEN_SPOOLER_FLAGS%g
s%@PAGE@%$PAGE%g
s%@LIBS@%$LIBS%g
s%@srcdir@%$srcdir%g
s%@DEFS@%$DEFS%
" $top_srcdir/${file}.in >> $file
fi; done

EOF
chmod +x config.status
test -n "$no_create" || ./config.status