AC_REVISION("$Id: configure.in,v 1.833 2004/09/12 22:50:56 marcus Exp $")
AC_INIT(interpret.c)
AC_CONFIG_HEADER(machine.h)

rm -f config.warnings 2>/dev/null

if_autoconf(2,50,[
  if test "x$cache_file" = "x/dev/null"; then
    cache_file=./config.cache
    if test -r "$cache_file"; then
      echo "loading cache $cache_file"
      . $cache_file
    else
      echo "creating cache $cache_file"
      > $cache_file
    fi
  fi
], [
  PIKE_MSG_WARN([configure script has been generated with autoconf 2.13 or earlier.])
])

# We want an absolute path to the source-dir.
case "$srcdir" in
    /*)
    ;;
    *)
	oldsrcdir="$srcdir"
	srcdir="`cd \"$srcdir\";pwd`"
	AC_MSG_WARN([Converted $oldsrcdir to $srcdir,
If this does not work, please use an absolute path to the configure script.])
    ;;
esac

# Check that we can write to the source directory.
sleep 1
if touch "$srcdir/configure~"; then
  # Check that the system time is reasonably correct.
  if test `cd "$srcdir" && ls -1t configure configure~ | head -n 1` = "configure"; then
    echo "Current system time is `date`."
    AC_MSG_ERROR([
$srcdir/configure has modification time in the future.
Check and set your system time.
])
  fi
else
  ls -ld "$srcdir"
  AC_MSG_ERROR([
Failed to write in source directory.
Fix your permissions.
])
fi

# Attempt to use bash instead of /bin/sh to run configure
# since bash is usually several orders of magnitude faster
# on machines that have a real /bin/sh.
# Some OS's also have a seriously broken /bin/sh (eg NetBSD).
if test "x$CONFIG_SHELL" = "x"; then 
  AC_PATH_PROG(bash_prog, bash, no)
  if test "x$ac_cv_path_bash_prog" = "xno"; then :; else
    AC_MSG_CHECKING([if $ac_cv_path_bash_prog works])
    if "$ac_cv_path_bash_prog" -norc -c : 2>&AC_FD_CC; then
      AC_MSG_RESULT(yes)
    else
      AC_MSG_RESULT(no)
      ac_cv_path_bash_prog=no
    fi
  fi
  if test "x$ac_cv_path_bash_prog" = "xno"; then :; else
    AC_MSG_WARN([Found bash as $ac_cv_path_bash_prog.
Will attempt to restart configure with bash for performance.
If this fails, please set CONFIG_SHELL to /bin/sh before starting configure.])
    CONFIG_SHELL="$ac_cv_path_bash_prog -norc"
    export CONFIG_SHELL
    echo $CONFIG_SHELL "$srcdir/configure" $ac_configure_args
    eval exec $CONFIG_SHELL "$srcdir/configure" $ac_configure_args
    exit 17
  fi
else :; fi

AC_PROG_MAKE_SET


rm "conftest_VPATH.in" 2>/dev/null
touch "$srcdir/conftest_VPATH.in"
if test -f conftest_VPATH.in; then :; else
  # Not building in source tree.
  AC_MSG_CHECKING([whether ${MAKE-make} supports VPATH])
  AC_CACHE_VAL(pike_cv_make_supports_VPATH, [
    cat > conftestmake <<EOF
VPATH=.:$srcdir
.SUFFIXES: .in .out
.in.out:
	cat "\$<" >"\$@"
EOF
    pike_cv_make_supports_VPATH=no
    if ${MAKE-make} -f conftestmake conftest_VPATH.out >/dev/null 2>&AC_FD_CC; then
      if test -f conftest_VPATH.out; then
        pike_cv_make_supports_VPATH=yes
      else :; fi
    else :; fi
    rm -f conftestmake conftest_VPATH.out
  ])
  AC_MSG_RESULT($pike_cv_make_supports_VPATH)
  if test "x$pike_cv_make_supports_VPATH" = "xno"; then
    AC_ERROR([
Building in a separate directory is not supported without VPATH.

Build in the source directory, or try another make (eg gnumake).
])
    exit 1
  else :; fi
fi
rm "$srcdir/conftest_VPATH.in" 2>/dev/null

if test -d "$srcdir/../bundles"; then
  # Some of the bundled libraries (eg nettle) set SHELL.
  AC_MSG_CHECKING([whether ${MAKE-make} supports spaces in SHELL])
  AC_CACHE_VAL(pike_cv_make_supports_spaces_in_SHELL, [
    cat > conftestmake <<EOF
SHELL=/bin/sh -n
false:
	/bin/false
true:
	:
complex_false:
	test "foo" = "foo" && /bin/false
complex_true:
	test "foo" = "bar" || :
EOF
    if ${MAKE-make} -f conftestmake false >&AC_FD_CC 2>&AC_FD_CC; then
      # /bin/sh was found, and /bin/false was not executed.
      pike_cv_make_supports_spaces_in_SHELL=yes
    elif ${MAKE-make} -f conftestmake complex_false >&AC_FD_CC 2>&AC_FD_CC; then
      # SHELL is ignored for simple targets, but not for more
      # complex expressions.
      # When SHELL is used, spaces are supported.
      pike_cv_make_supports_spaces_in_SHELL="complex only"
    elif ${MAKE-make} -f conftestmake complex_true >&AC_FD_CC 2>&AC_FD_CC; then
      # SHELL is ignored for all targets.
      pike_cv_make_supports_spaces_in_SHELL=ignored
    elif ${MAKE-make} -f conftestmake true >&AC_FD_CC 2>&AC_FD_CC; then
      # SHELL is ignored for simple targets, but not for more
      # complex expressions.
      # When SHELL is used, spaces are not supported.
      pike_cv_make_supports_spaces_in_SHELL=no
    else
      # Spaces are not supported in SHELL.
      pike_cv_make_supports_spaces_in_SHELL=no
    fi
    rm -f conftestmake
  ])
  AC_MSG_RESULT($pike_cv_make_supports_spaces_in_SHELL)
else :; fi

AC_ARG_ENABLE(make_conf, MY_DESCR([--disable-make.conf],
   [do not use settings from /etc/make.conf]),
             [], [enable_make_conf=yes])

initial_cflags="${CFLAGS}"
initial_cppflags="${CPPFLAGS}"
initial_ldflags="${LDFLAGS}"

if test "x${CFLAGS-}" = x ; then
  cflags_is_set=no
else
  cflags_is_set=yes
fi

if test "x${CPPFLAGS-}" = x ; then
  cppflags_is_set=no
else
  cppflags_is_set=yes
fi

if test "x${LDFLAGS-}" = x ; then
  ldflags_is_set=no
else
  ldflags_is_set=yes
fi

# if test "x$enable_make_conf" = x"yes" -a -f /etc/make.conf; then
#   set >conftest.tmp
#   echo Using settings from /etc/make.conf...
#   . /etc/make.conf
#   set | diff -u conftest.tmp -  | grep '^+C'
#   PIKE_MSG_WARN([Using settings from /etc/make.conf.])
# fi

AC_ARG_WITH(cflags, MY_DESCR([--with-cflags=cflags],
			     [specify extra c compiler flags]),
	    [ CFLAGS="$with_cflags $CFLAGS" ])
AC_ARG_WITH(cppflags, MY_DESCR([--with-cppflags=cppflags],
			       [specify extra c preprocessor flags]),
	    [ CPPFLAGS="$with_cppflags $CPPFLAGS" ])
AC_ARG_WITH(ldflags, MY_DESCR([--with-ldflags=ldflags],
			      [specify extra linker flags]),
	    [ LDFLAGS="$with_ldflags $LDFLAGS" ])

# Force use of thread libs LIBS
AC_ARG_WITH(thread-library,
	    MY_DESCR([--with-thread-library=lib],
		     [Use a specific thread library]),
	    [
	      case "x$withval" in
	        x-*)
		  with_thread_library="$withval"
		;;
		*)
		  with_thread_library="-l$withval"
		;;
	      esac
	    ], [ with_thread_library=no ])

for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    PIKE_MSG_WARN([You are using a site file to initialize configure, please
note that this can lead to problems if anything in
$ac_site_file is not correct. If Pike does not compile, or
does not run, please try this to compile Pike again:
rm ./config.cache ; CONFIG_SITE=x ./configure ; make])
  fi
done

AC_ARG_ENABLE(binary, MY_DESCR([--disable-binary],
   [do not configure for binary build, only do tests for precompilation stuff]),
	      [], [enable_binary=yes])

if test "x$enable_binary" = "xno"; then
  PIKE_MSG_WARN([Short-circuiting configure tests for binary building. Only some
targets in the Makefile can be used, typically those that only
operates on the source directory, e.g. depend.])
  AC_DEFINE(DISABLE_BINARY)
else

  if test ! -z "$pike_cv_prog_CC_save" -a ! -z "$CC" -a "$CC" != "$pike_cv_prog_CC_save"
  then
    PIKE_MSG_WARN([CC is different than last time Pike was compiled,
It is probably best to delete ./config.cache before proceeding.])
  fi

  pike_cv_prog_CC_save="$CC"

fi

AC_ARG_ENABLE(noopt-retry, MY_DESCR([--disable-noopty-retry],
    [do not retry compilation without optimizations if it fails]),
	      [], [noopt_retry=yes])

# Do the below even when --disable-binary is used, since we need a
# real $CPP, and AC_PROG_CPP wants AC_PROG_CC to be called earlier.
# $CC will be overridden with a dummy later on.

# MY_AC_PROG_CC
# The above has problems if the smartlink binary is removed. /grubba
AC_PROG_CC
AC_PROG_CPP

#############################################################################

if test "x$enable_binary" != "xno"; then
  AC_ISC_POSIX
  AC_AIX
  AC_MINIX
fi
 
#############################################################################

# option, cache_name, variable, do_if_failed, do_if_ok, paranoia_test
AC_DEFUN(AC_SYS_COMPILER_FLAG,
[
  AC_MSG_CHECKING($1)
  AC_CACHE_VAL(pike_cv_option_$2,
  [
    OLD_CPPFLAGS="[$]CPPFLAGS"
    CPPFLAGS="[$]OLD_CPPFLAGS $1"
    old_ac_link="[$]ac_link"
    ac_link="[$]old_ac_link 2>conftezt.out.2"
    AC_TRY_RUN([
      int foo;
      int main(int argc, char **argv)
      {
        /* The following code triggs gcc:s generation of aline opcodes,
	 * which some versions of as does not support.
	 */
	if (argc > 0) argc = 0;
	return argc;
      }
    ],pike_cv_option_$2=yes,
      pike_cv_option_$2=no, [
      AC_TRY_LINK([], [], pike_cv_option_$2=yes, pike_cv_option_$2=no)
    ])
    if grep -i 'unrecognized option' <conftezt.out.2 >/dev/null; then
      pike_cv_option_$2=no
    elif grep -i 'unknown option' <conftezt.out.2 >/dev/null; then
      # cc/HPUX says the following regarding -q64:
      #
      # cc: warning 422: Unknown option "6" ignored.
      # cc: warning 422: Unknown option "4" ignored.
      pike_cv_option_$2=no
    elif grep -i 'optimizer bugs' <conftezt.out.2 >/dev/null; then
      # gcc/FreeBSD-4.6/alpha says the following regarding -O2:
      #
      # cc1: warning: 
      # ***
      # ***     The -O2 flag TRIGGERS KNOWN OPTIMIZER BUGS ON THIS PLATFORM
      # ***
      pike_cv_option_$2=no
    elif grep -i 'not found' <conftezt.out.2 >/dev/null; then
      # cc/AIX says the following regarding +O3:
      #
      # cc: 1501-228 input file +O3 not found
      pike_cv_option_$2=no
    elif grep -i 'ignored' <conftezt.out.2 >/dev/null; then
      # gcc/AIX says the following regarding -fpic:
      #
      # cc1: warning: -fpic ignored (all code is position independent)
      pike_cv_option_$2=no
    else :; fi
    ifelse([$6], , ,[
    if test "$pike_cv_option_$2" = yes; then
      :
      $6
    else :; fi
    ]) dnl
    CPPFLAGS="[$]OLD_CPPFLAGS"
    ac_link="[$]old_ac_link"
    rm conftezt.out.2
  ])
  
  if test x"[$]pike_cv_option_$2" = "xyes" ; then
    $3="[$]$3 $1"
    case "$3" in
      OPTIMIZE)
        CFLAGS="[$]CFLAGS $1"
      ;;
    esac
    AC_MSG_RESULT(yes)
    $5
  else
    AC_MSG_RESULT(no)
    $4
  fi
])

# arch, option, cache_name, variable
AC_DEFUN(AC_SYS_CPU_COMPILER_FLAG,
[
 if test "`uname -m 2>/dev/null`" = "$1" ; then
    AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6)
    $7
 fi
])

# os, option, cache_name, variable
AC_DEFUN(AC_SYS_OS_COMPILER_FLAG,
[
 if test "x$pike_cv_sys_os" = "x$1" ; then
    AC_SYS_COMPILER_FLAG($2,$3,$4,$5,$6)
    $7
 fi
])

define([DO_IF_OS],
[
 if test "x$pike_cv_sys_os" = "x$1" ; then
$2
fi
])

define([DO_IF_CPU],
[
if test "`uname -m 2>/dev/null`" = "$1" ; then
$2
fi
])

#############################################################################

if test "x$GCC" = "x"; then
  GCC=no
else
  :;
fi

if test "x$GCC" = "xno" -a "x$TCC" = "xno"; then
  #
  # We want 64bit mode if possible.
  #

  AC_SYS_COMPILER_FLAG(-q64, q64, CFLAGS)

  if test "x$ac_cv_prog_cc_cross" = "xyes"; then
    # The AIX 5L/cc beta can not generate working binaries without a
    # data-segment...
    AC_MSG_CHECKING([if we are really using a cross-compiler])

    AC_CACHE_VAL(pike_cv_datasegment_required, [
      ac_cv_prog_cc_cross=no;
      AC_TRY_RUN([int foo;main(){return(0);}], [
        pike_cv_datasegment_required=yes
      ], [
        pike_cv_datasegment_required=no
	ac_cv_prog_cc_cross=yes
      ], [
        pike_cv_datasegment_required=no
	ac_cv_prog_cc_cross=yes
      ])
    ])
    if test "x$pike_cv_datasegment_required" = "xyes"; then
      AC_MSG_RESULT([no -- Applying data-segment kludge])
      ac_cv_prog_cc_cross=no
      cat >conftest.c <<EOF
static int foo;
EOF
      pike_cv_datasegemnt_file=no
      if AC_TRY_EVAL(ac_compile); then
        if test -f "conftest.$ac_objext"; then
	  rm -f "data-segment.$ac_objext"
	  if mv "conftest.$ac_objext" "data-segment.$ac_objext"; then
	    if test -f "`pwd`/data-segment.$ac_objext"; then
	      pike_cv_datasegemnt_file="`pwd`/data-segment.$ac_objext"
	    else
	      PIKE_MSG_WARN(Lost track of data-segment kludge-file.)
	    fi
	  else
	    PIKE_MSG_WARN(Failed to rename data-segment kludge-file.)
	  fi
	else
	  PIKE_MSG_WARN(Can not find data-segment kludgefile.)
	fi
      else
        PIKE_MSG_WARN(Failed to compile data-segment kludge.)
      fi
      if test "x$pike_cv_datasegment_file" = "xno"; then
	PIKE_MSG_WARN(Some tests may yield false results.)
      else
        LIBS="$pike_cv_datasegment_file $LIBS"
	export LIBS
        PIKE_MSG_WARN(Data-segment kludge applied.)
      fi
    else
      AC_MSG_RESULT(yes)
    fi
  fi
else
  if test "x$TCC" = "xyes"; then
    AC_MSG_CHECKING(if we can use pragma TenDRA longlong)
    AC_CACHE_VAL(pike_cv_pragma_tendra_longlong, [
      AC_TRY_COMPILE([
#pragma TenDRA longlong type allow
      ], [], [ pike_cv_pragma_tendra_longlong=yes
      ], [ pike_cv_pragma_tendra_longlong=no ])
    ])
    if test "x$pike_cv_pragma_tendra_longlong" = "xyes"; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_PRAGMA_TENDRA_LONGLONG)
    else
      AC_MSG_RESULT(no)
    fi

    AC_MSG_CHECKING(if we can use pragma TenDRA set longlong type)
    AC_CACHE_VAL(pike_cv_pragma_tendra_set_longlong_type, [
      AC_TRY_COMPILE([
#ifdef HAVE_TENDRA_LONGLONG
#pragma TenDRA longlong type allow
#endif /* HAVE_TENDRA_LONGLONG */
#pragma TenDRA set longlong type : long long

long long foo;
      ], [], [ pike_cv_pragma_tendra_set_longlong_type=yes
      ], [ pike_cv_pragma_tendra_set_longlong_type=no ])
    ])
    if test "x$pike_cv_pragma_tendra_set_longlong_type" = "xyes"; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_PRAGMA_TENDRA_SET_LONGLONG_TYPE)
    else
      AC_MSG_RESULT(no)
    fi
  else :; fi
fi

#############################################################################

if test "x$enable_binary" != "xno"; then

#
# The purpose of this test is to check that there is no filesystem
# caching preventing pike from compiling correctly.
#
AC_MSG_CHECKING([filesystem synchronization])

AC_CACHE_VAL(pike_cv_filesystem_syncronization,
[
  pike_cv_filesystem_syncronization=working

  AC_EGREP_CPP(true, [ true ], , pike_cv_filesystem_syncronization=broken)
  AC_EGREP_CPP(false, [ false ], , pike_cv_filesystem_syncronization=broken)
  AC_EGREP_CPP(oui, [ oui ], , pike_cv_filesystem_syncronization=broken)
  AC_EGREP_CPP(no, [ no ], , pike_cv_filesystem_syncronization=broken)
  AC_EGREP_CPP(near, [ far ], pike_cv_filesystem_syncronization=broken, )
  AC_EGREP_CPP(up, [ up ], , pike_cv_filesystem_syncronization=broken)
  AC_EGREP_CPP(down, [ down], , pike_cv_filesystem_syncronization=broken)
])

AC_MSG_RESULT($pike_cv_filesystem_syncronization)
if test "x$pike_cv_filesystem_syncronization" = xbroken ; then
  AC_MSG_ERROR([Filesystem caching is too aggressive. If you are using
Samba, make sure to have the following line in your smb.conf:
oplocks = False
])
  exit 1
fi

fi

#############################################################################

LIBDIR=`(cd $srcdir/../lib ; pwd)`
BINDIR=`(cd $srcdir/../bin ; pwd)`
MANDIR=`(cd $srcdir/../man ; pwd)`
DOCDIR=`(cd $srcdir/../refdoc ; pwd)`
BASEDIR=`(cd $srcdir/.. ; pwd)`
BUILDDIR=`pwd`
AC_SUBST(LIBDIR)
AC_SUBST(BINDIR)
AC_SUBST(MANDIR)
AC_SUBST(DOCDIR)
AC_SUBST(BASEDIR)
AC_SUBST(BUILDDIR)

#############################################################################

#
# Some cross-compilation support and --disable-binary stuff
#

if test "x$enable_binary" = "xno"; then
  CROSS=yes
else
  CROSS="$ac_cv_prog_cc_cross"
fi
AC_SUBST(CROSS)

if test "x$enable_binary" = "xno"; then
  CC="$BINDIR/nobinary_dummy cc"
  RUNPIKE="USE_PIKE"
else
  if test "x$cross_compiling" = "xyes"; then
    RUNPIKE="USE_PIKE"
  else
    RUNPIKE="DEFAULT_RUNPIKE"
  fi
fi
AC_SUBST(RUNPIKE)

#############################################################################
if test "x$enable_binary" != "xno"; then
# The following tests are only relevant if we intend to build binaries.
#############################################################################

AC_CHECK_HEADERS(fnord/fnord/fnord.h)

AC_MSG_CHECKING([if CHECK_HEADERS works])
if test "x$ac_cv_header_fnord_fnord_fnord_h" = xyes ; then
  AC_MSG_RESULT(no)
  exit 1
fi
AC_MSG_RESULT(yes)

#############################################################################

AC_MSG_CHECKING(if we can allocate large auto variables)
AC_CACHE_VAL(pike_cv_C_supports_large_auto, [
  AC_TRY_LINK([
#include <stdio.h>
    int eat_stack(int foo)
    {
      char large_array[131072] = "";
      int i, sum = 0;

      for (i = 0; i < foo; i++) {
        /* Make sure the compiler does not optimize away the array. */
	large_array[i] = sum;
	sum += foo;
      }
      for (i = 0; i < foo; i++) {
        sum += large_array[i] - large_array[foo-1-i];
      }
      return sum;
    }
  ], [
    return !eat_stack(4711);
  ], [
    pike_cv_C_supports_large_auto=yes
  ], [
    pike_cv_C_supports_large_auto=no
  ])
])
if test "$pike_cv_C_supports_large_auto" = "yes"; then
  AC_MSG_RESULT([yes - good])
else
  AC_MSG_RESULT([no])
  AC_MSG_CHECKING([if we can make a workaround by defining _chkstk to call __chkstk])
  AC_CACHE_VAL([pike_cv_kludge__chkstk],
  [
    AC_TRY_LINK([
#include <stdio.h>
      int eat_stack(int foo)
      {
  	char large_array[131072] = "";
  	int i, sum = 0;
  
  	for (i = 0; i < foo; i++) {
  	  /* Make sure the compiler does not optimize away the array. */
  	  large_array[i] = sum;
  	  sum += foo;
  	}
  	for (i = 0; i < foo; i++) {
  	  sum += large_array[i] - large_array[foo-1-i];
  	}
  	return sum;
      }
  
      extern size_t __chkstk();
      size_t _chkstk() { return __chkstk(); }
  
    ], [
      return !eat_stack(4711);
    ], [
      pike_cv_kludge__chkstk=yes
    ], [
      pike_cv_kludge__chkstk=no
    ])
  ])
  if test "$pike_cv_kludge__chkstk" = "yes"; then
    AC_MSG_RESULT([yes - applying workaround])
    AC_DEFINE(HAVE_BROKEN_CHKSTK)
  else
    AC_MSG_RESULT([no])
    AC_ERROR([Your C compiler does not link code that uses large auto variables.

Please check config.log, and fix the problem.])
    exit 1
  fi  
fi

#############################################################################

## Build smartlink

AC_CHECK_HEADERS(stdlib.h string.h unistd.h sys/stat.h sys/types.h sys/errno.h)

if test -x /usr/bin/uname 2>/dev/null; then
  UNAME=`/usr/bin/uname -sr`
elif test -x /bin/uname 2>/dev/null; then
  UNAME=`/bin/uname -sr`
else
  UNAME=unknown
fi

# We need some special hacks when running slowaris
AC_PATH_PROG(uname_prog,uname,no)
AC_MSG_CHECKING(operating system)
AC_CACHE_VAL(pike_cv_sys_os,
[
if test "$cross_compiling" = "yes"; then
  case "$host_alias" in
    *amigaos*)	pike_cv_sys_os="AmigaOS";;
    *linux*)	pike_cv_sys_os="Linux";;
    *solaris*)	pike_cv_sys_os="Solaris";;
    *sunos*)	pike_cv_sys_os="SunOS";;
    *windows*)	pike_cv_sys_os="Windows_NT";;
    *)		pike_cv_sys_os="Unknown";;
  esac
else
if test "$uname_prog" != "no"; then
  # uname on UNICOS doesn't work like other people's uname...
  if getconf CRAY_RELEASE >/dev/null 2>&1; then
    pike_cv_sys_os="UNICOS"
  else
    pike_cv_sys_os="`uname`"
  fi

  case "$pike_cv_sys_os" in
    SunOS)
      case "`uname -r`" in
        5.*) pike_cv_sys_os="Solaris" ;;
      esac
    ;;
    Monterey64)
      # According to the release notes, the string "Monterey64"
      # will be changed to "AIX" in the final release.
      # (Monterey 64 is also known as AIX 5L).
      pike_cv_sys_os="AIX"
    ;;
    *Windows*|*windows*)
      pike_cv_sys_os="Windows_NT"
    ;;
  esac
else
  pike_cv_sys_os="Not Solaris"
fi
fi
])
AC_MSG_RESULT($pike_cv_sys_os)

if test "$GCC" = "yes"; then :; else
#
# Special hack for HP-UX stupid cc
#
  if test "$pike_cv_sys_os" = "HP-UX"; then
    AC_TRY_COMPILE([int foo(int bar);],[],[],
    [
      OLD_CC="${CC-cc}"
      OLD_CFLAGS="$CFLAGS"
      case "/$CC" in
        */smartlink\ cc)
           if test -x /usr/bin/cc; then
             CC="`echo $CC|sed -e 's/ cc/ \/usr\/bin\/cc/`"
           else
             : ;
           fi
        ;;
      esac
      CFLAGS="-Ae +Olibcalls $CFLAGS"
      AC_TRY_COMPILE([int foo(int bar);],[],[],[
        CC="$OLD_CC"
	CFLAGS="$OLD_CFLAGS"
      ])
      pike_cv_prog_CC="${CC}"
    ])
  fi
fi

if test "$pike_cv_sys_os" = "Solaris" ; then
  AC_DEFINE(SOLARIS)
else
  :
fi

# Workaround for compiling Pike on some OS that have some clues
case "$pike_cv_sys_os" in
   CYGWIN*)
      # Cygwin have both Windows includes and Unix ones.
      # Hiding them make it a somewhat Unix compliant OS.
      echo 'Cygwin host detected. Enabling workarounds...'
      # winsock.h, winbase.h, winsock2.h, windows.h, wingdi.h, windef.h
      # are part of VC api but given as headers in cygwin. We
      # should detect them when using cygwin
      ac_cv_header_wingdi_h="no"
      ac_cv_header_windef_h="no"
      ac_cv_header_winsock_h="no"
      ac_cv_header_winsock2_h="no"
      ac_cv_header_winbase_h="no"
      ac_cv_header_windows_h="no"
      with_machine_code="no"
   ;;
  FreeBSD*)
      # FreeBSD have other naming convention for gtk-config and sdl-config
      if test "x${GTK_CONFIG}" = "x"; then
         GTK_CONFIG=`which ${ac_tool_prefix}gtk12-config`
         export GTK_CONFIG
      fi
      if test "x${SDL_CONFIG}" = "x"; then
         SDL_CONFIG=`which ${ac_tool_prefix}sdl11-config`
	 export SDL_CONFIG
      fi
   ;;
esac

# Strip smartlink from $CC
REALCC="`echo $CC|sed -e 's/.*smartlink //'`"


# FIXME: Add proper tests
AC_MSG_CHECKING([for ld.so run path method])
AC_CACHE_VAL(pike_cv_ld_so_run_path_method, [
  case "$UNAME" in
    OSF1\ V4.*|OSF1\ V5.*|OSF1\ V6.*)
      pike_cv_run_path_method=rpath
    ;;
    HPUX\ 11.*)
      pike_cv_run_path_method=plus_b
    ;;
    IRIX\ 6.*)
      pike_cv_run_path_method=rpath
    ;;
    IRIX\ 5.*)
      pike_cv_run_path_method=rpath
    ;;
    SunOS\ 5.*)
      if test "$TCC" = "yes"; then
  	# tcc doesn't know about -R
        pike_cv_run_path_method=wl_r
      else
        pike_cv_run_path_method=r
      fi
    ;;
    Linux\ 2.*)
      if $REALCC -V 2>&1 | head -1 | grep "Intel(R) C" >/dev/null; then
        # icc or ecc.
        pike_cv_run_path_method=qoption
      else
        pike_cv_run_path_method=wl
      fi
    ;;
    UnixWare\ 7.*|OpenUNIX\ 8.*)
      if test "$ac_cv_prog_gcc" = "yes"; then
        pike_cv_run_path_method=xlinker_yp_
      else
        pike_cv_run_path_method=yp_
      fi
    ;;
    *)
      pike_cv_run_path_method=ld_library_path
    ;;
  esac
])
case "$pike_cv_run_path_method" in
  rpath)
    AC_DEFINE(USE_RPATH)
    AC_MSG_RESULT([use -rpath])
  ;;
  plus_b)
    AC_DEFINE(USE_PLUS_b)
    AC_MSG_RESULT([use +b])
  ;;
  yp_)
    AC_DEFINE(USE_YP_)
    AC_MSG_RESULT([use -Yp,])
  ;;
  xlinker_yp_)
    AC_DEFINE(USE_XLINKER_YP_)
    AC_MSG_RESULT([use -Xlinker -Yp, -Xlinker])
  ;;
  wl_r)
    AC_DEFINE(USE_Wl_R)
    AC_MSG_RESULT([use -Wl,-R])
  ;;
  r)
    AC_DEFINE(USE_R)
    AC_MSG_RESULT([use -R])
  ;;
  wl)
    AC_DEFINE(USE_Wl)
    AC_MSG_RESULT([use -Wl,-rpath])
  ;;
  qoption)
    AC_DEFINE(USE_Qoption)
    AC_MSG_RESULT([use -Qoption,ld,-rpath])
  ;;
  ld_library_path|*)
    AC_DEFINE(USE_LD_LIBRARY_PATH)
    AC_MSG_RESULT([use LD_LIBRARY_PATH/LD_RUN_PATH])
  ;;
esac


# Fix a smartlink
SMARTLINK="$BUILDDIR/smartlink"

AC_MSG_CHECKING(if $SMARTLINK exists is up to date and works)
if ls -1tr "$SMARTLINK${ac_exeext}" "$srcdir/smartlink.$ac_ext" 2>/dev/null | head -n 1 | grep "smartlink.$ac_ext" >/dev/null 2>&AC_FD_CC && "$SMARTLINK" -v >/dev/null 2>&AC_FD_CC; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  SMARTBUILDCC="${REALCC-cc}"

  if echo foo "$CC" | egrep 'rntc.|rnt.cl' >/dev/null; then
    PIKE_MSG_WARN([rntcc/rntcl/rnticl/rntecl detected.])
    AC_PATH_PROGS(SMARTBUILDCC,gcc cc egcs,gcc, $PATH:$EXTRA_PATH)
    echo Using $SMARTBUILDCC to compile smartlink.
  else
    if test "x$ac_cv_prog_cc_cross" = "xyes"; then
      PIKE_MSG_WARN([Crosscompiler detected.])
      AC_PATH_PROGS(SMARTBUILDCC, gcc cc egcs, gcc, /usr/bin:/bin/:/usr/ccs/bin:/usr/local/bin:$PATH:$EXTRA_PATH)
      echo Using $SMARTBUILDCC to compile smartlink.
    fi
  fi

  rm -f "$SMARTLINK"

  AC_MSG_CHECKING(whether smartlink compiles)

  link_cmd='${SMARTBUILDCC-cc} -o smartlink${ac_exeext} $CFLAGS -I. $CPPFLAGS $LDFLAGS $srcdir/smartlink.$ac_ext $LIBS 2>&AC_FD_CC'
  if { (eval echo Compiling smartlink: \"$link_cmd\") 1>&AC_FD_CC; (eval $link_cmd) 2>&AC_FD_CC; } && "$BUILDDIR/smartlink" -v >/dev/null 2>&AC_FD_CC; then
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no - use the sh script)
    SMARTLINK="$BINDIR/smartlink"
  fi
fi

CC="$SMARTLINK $REALCC"
pike_cv_prog_CC="$CC"

AC_SUBST(SMARTLINK)
AC_SUBST(REALCC)
export REALCC SMARTLINK

AC_MSG_CHECKING([for a fallback compiler])
# Strip smartlink from $FALLBACK_CC
FALLBACK_CC="`echo $FALLBACK_CC|sed -e 's/.*smartlink //'`"
if test "x$FALLBACK_CC" = "x"; then
  AC_MSG_RESULT(no)
else
  FALLBACK_CC="$SMARTLINK $FALLBACK_CC"
  AC_MSG_RESULT($FALLBACK_CC)
fi
AC_SUBST(FALLBACK_CC)
export FALLBACK_CC

#############################################################################
fi #if test "x$enable_binary" != "xno"
#############################################################################

# Restore the -O2 that the default AC_PROG_CC adds.

AC_SYS_COMPILER_FLAG(+O3,plus_O3,OPTIMIZE, [
  AC_SYS_COMPILER_FLAG(-O2,O2,OPTIMIZE, [
    AC_SYS_COMPILER_FLAG(-O,O,OPTIMIZE)
  ])
])

if test "$GCC" = "yes"; then
  if test "$cflags_is_set" = "no"; then
    AC_SYS_COMPILER_FLAG(-pipe, pipe, OPTIMIZE)

    #### For exec-shield in newer linux kernels.
    #### We should really fix the machine code generator to use mprotect instead.
    #### That should work.
    AC_SYS_COMPILER_FLAG([[-Wa,--execstack]],executableheap,CFLAGS)
  fi
fi

LD='$(CC) $(CFLAGS)'
LC_REQ="-lc"

case "$pike_cv_sys_os" in
  Darwin*)
      LC_REQ="-lc -lcc_dynamic"
      ;;
  SCO*)
     case "$CFLAGS" in
        *-belf*) 
          AC_SYS_COMPILER_FLAG(-belf,sco_belf_option,CFLAGS,[],[
            case "$LDFLAGS" in
              *-belf*) ;;
              *)
                echo "Adding -belf option to ldflags."
                LDFLAGS="$LDFLAGS -belf"
              ;;
            esac
          ])
       ;;
       *)
	 AC_SYS_COMPILER_FLAG(-belf,belf,CFLAGS)
       ;;
     esac
     case "$LDFLAGS" in
       *-belf*) ;;
       *)
	  AC_SYS_COMPILER_FLAG(-belf,belf,LDFLAGS)
       ;;
     esac
  ;;
  SunOS*)
    # gcc on SunOS 4 forgets to define this:
    echo "SunOS. Adding -D__USE_FIXED_PROTOTYPES__"
    CFLAGS="$CFLAGS -D__USE_FIXED_PROTOTYPES__"
  ;;
  BSD/OS*)
    case "`uname -r`" in
      [4-9].*) ;;
      *) LD="$BINDIR/smartlink shlicc";;
    esac
  ;;
  UnixWare*|OpenUNIX*)
    case "$CFLAGS" in
      *-Kalloca*) ;;
      *)
	if test "$GCC" != "yes"; then
	  # We are using built-in inline function
	  CFLAGS="$CFLAGS -Kalloca"
	  CXX="$CXX -DNO_CPLUSPLUS_ALLOCA"
	  LC_REQ=""
	fi
      ;;
    esac
  ;;
  Linux*)
    if $REALCC -V 2>&1 | head -1 | grep "Intel(R) C" >/dev/null; then
      # icc or ecc.
      LC_REQ=""
    fi
  ;;
esac

AC_SUBST(LD)
AC_SUBST(LC_REQ)

#############################################################################

AC_ARG_WITH(patch_gcc, MY_DESCR([--with-patch-gcc],
				[attempt to patch the UA32 relocation bug.]),
	    [], [with_patch_gcc=no])

AC_ARG_WITH(force_ua32, MY_DESCR([--with-force-ua32],
				 [ignore the UA32 relocation bug.]),
	    [], [with_force_ua32=no])

# Some sanity checks.

if test "$GCC" = "yes" -a "$pike_cv_sys_os" = "Solaris" && test "`uname -p`" = "sparc"; then
  # Solaris/sparc:
  #   Check that gnu ld isn't used.
  #   It's usually hidden in $prefix/sparc-sun-solaris2.?/bin/.
  # NOTE: M4 uses [] as quotes.
  gcc_ld_path="`$CC -v 2>&1 | sed -e '1,1s/[[^\/]]*\(\/.*\/\)[[^\/]]*$/\1/p;d' | sed -e '/lib\/gcc-lib\//s/lib\/gcc-lib\///;s/\/[[0-9]]*\.[[0-9]]*\.[[0-9]]*\/$/\/bin/'`"
  if test "x$gcc_ld_path" = "x"; then :; else
    if test -d "$gcc_ld_path/."; then
      if "$gcc_ld_path/ld" -v 2>&1 | grep -i GNU >/dev/null; then
        PIKE_MSG_WARN([GNU ld found on Solaris sparc system ($gcc_ld_path/ld).
This may cause the dynamic module support to fail.])
      else :; fi
    else :; fi
  fi
  unset gcc_ld_path


  # Watch out for gcc-2.8.1 on Solaris 7 sparc machines. It generates
  # assembler code which contains .uaword directives, which in turn
  # generates code with R_SPARC_UA32 relocations, which /usr/bin/ld.so
  # has buggy support for (it doesn't relocate the MSB).

  #  Check that gcc doesn't generate uaword opcodes
  AC_MSG_CHECKING(if your gcc generates uaword opcodes)
  AC_CACHE_VAL(pike_cv_gcc_uaword, [
    cat > conftest.c <<EOF    
char *foo[[]] = { "bar" };
EOF
    pike_compile='${CC-cc} -S $CPPFLAGS conftest.c 1>&AC_FD_CC'
    pike_cv_gcc_uaword=no
    if { (eval echo configure: \"$pike_compile\") >&AC_FD_CC; (eval $pike_compile) 2>&AC_FD_CC; }; then
      if grep ".uaword" conftest.s 2>&AC_FD_CC >/dev/null; then
        echo "configure: result contains .uaword:" >&AC_FD_CC
	cat conftest.s >&AC_FD_CC
        pike_cv_gcc_uaword=yes
      else :; fi
    else
      echo "configure: failed program was:" >&AC_FD_CC
      cat conftest.c >&AC_FD_CC
    fi
    rm -rf conftest.*
  ])
  AC_MSG_RESULT($pike_cv_gcc_uaword)

  # Check if as generates R_SPARC_UA32 relocations from .uaword.
  if test "$pike_cv_gcc_uaword" = "yes"; then
    AC_MSG_CHECKING([if your as generates R_SPARC_UA32 relocations])
    AC_CACHE_VAL(pike_cv_as_r_sparc_ua32, [
      AC_TRY_ASSEMBLE([
.section	".rodata"
	.align 8
.STRING:
	.asciz	"String"
.section	".data"
	.align 4
	.type	string,#object
	.size	string,4
string:
	.uaword	.STRING
      ],[
        if /usr/ccs/bin/elfdump -r conftest.o | grep -i R_SPARC_UA32 >/dev/null 2>&AC_FD_CC; then
	  pike_cv_ac_r_sparc_ua32=yes
	else
	  pike_cv_ac_r_sparc_ua32=no
	fi
      ],[
        pike_cv_ac_r_sparc_ua32=no
      ])
    ])
    AC_MSG_RESULT($pike_cv_ac_r_sparc_ua32)
    if test "$pike_cv_ac_r_sparc_ua32" = "yes"; then
      PIKE_MSG_WARN([Your gcc/as combo may generate R_SPARC_UA32 relocations.
R_SPARC_UA32 relocations are unsupported in Solaris >= 2.3,
and have broken support in Solaris 7.])

      if test "x$with_patch_gcc$with_force_ua32" = "xnono"; then
  	if test -d "/var/sadm/patch/107058-01/."; then
  	  PIKE_MSG_WARN([Back out patch 107058-01, or
recompile gcc with a modified config/sparc/sol2.h.])
  	else
  	  PIKE_MSG_WARN([Recompile gcc with a modified config/sparc/sol2.h.])
  	fi

	PIKE_MSG_WARN([You may want to try binary patching gcc.
In that case rerun configure with --with-patch-gcc.
NOTE: Binary patching is highly experimental and risky,
      and may break your existing gcc even more.

R_SPARC_UA32 relocations are supported on some versions
of Solaris. If you want to try a binary with R_SPARC_UA32
relocations, rerun configure with --with-force-ua32.])
        exit 1
      fi

      if test "x$with_patch_gcc" = "xno"; then :; else
        AC_MSG_WARN([Will attempt to patch gcc.])

        AC_MSG_CHECKING([for cc1])
        if test "x$with_patch_gcc" = "xyes"; then
          cc1="`$CC -v 2>&1|sed -e '/\//s!^[[^/]]*\(/.*\)/specs$!\1/cc1!p' -ed`"
        else
	  cc1="$with_patch_gcc";
        fi
        if test -f "$cc1"; then
	  AC_MSG_RESULT($cc1)
        else
	  AC_MSG_RESULT(not found. Tried $cc1)
	  exit 1
        fi
       
        AC_MSG_CHECKING(if $cc1 looks unpatched)
        if /usr/bin/strings "$cc1" | grep uaword >/dev/null 2>&1; then
          AC_MSG_RESULT(yes)
        else
          AC_MSG_RESULT(no -- strange)
          exit 1
        fi
      
        AC_MSG_CHECKING(if patch_cc1 compiles)
        link_cmd='${CC-cc} -o patch_cc1${ac_exeext} $CFLAGS -I. $CPPFLAGS $LDFLAGS $srcdir/patch_cc1.$ac_ext $LIBS 2>&AC_FD_CC'
        if { (eval echo Compiling patch_cc1: \"$link_cmd\") 1>&AC_FD_CC; (eval $link_cmd) 2>&AC_FD_CC; } && "$BUILDDIR/patch_cc1" -v >/dev/null 2>&AC_FD_CC; then
          AC_MSG_RESULT(yes)
      
          if test -f "$cc1.patched"; then
            AC_MSG_ERROR([$cc1.patched already exists.
Please move it out of the way.])
            exit 1;
          fi

          if test -f "$cc1.orig"; then
            AC_MSG_ERROR([$cc1.orig already exists.
Please move it out of the way.])
            exit 1;
          fi

	  AC_MSG_CHECKING(if patch_cc1 works)
	  if ./patch_cc1 "$cc1" 2>&AC_FD_CC >"$cc1.patched"; then
	    if test -f "$cc1.patched"; then :; else
	      AC_MSG_RESULT(no - failed to create $cc1.patched)
	      exit 1
	    fi
	    if chmod 755 "$cc1.patched"; then :; else
	      AC_MSG_RESULT(no - failed to set permission to 755 on $cc1.patched)
	      exit 1
	    fi

	    if test "`/bin/ls -l \"$cc1\"|awk '{print $5}'`" = "`/bin/ls -l \"$cc1.patched\"|awk '{print $5}'`"; then
              if /usr/bin/strings "$cc1.patched" | grep uaword >/dev/null 2>&1; then
	        rm -f "$cc1.patched"
                AC_MSG_RESULT(no -- patching failed)
                exit 1
	      fi

	      if "$cc1.patched" --help >/dev/null 2>&1; then :; else
	        AC_MSG_RESULT(no -- the patched binary does not seem to work)
	        exit 1
	      fi

              AC_MSG_RESULT(yes)

	      AC_MSG_WARN([Activating the patched cc1.
NOTE: Entering critical section.
If configure fails at this point a broken gcc my result.])
	      if /usr/bin/mv -f "$cc1" "$cc1.orig"; then

	        AC_MSG_WARN([Moved $cc1 to $cc1.orig.])

	        if /usr/bin/mv -f "$cc1.patched" "$cc1"; then
	          AC_MSG_WARN([Patching seems to have succeeded.
Please rerun configure.])
		  exit 1
	        fi

	        AC_MSG_WARN([Moving the patched cc1 into place failed.
Will try to restore the old cc1.])

	        if /usr/bin/mv -f "$cc1.orig" "$cc1"; then
	          AC_MSG_WARN([The old cc1 has been restored.])
	          exit 1
	        fi

	        AC_MSG_ERROR([Restoring the old cc1 failed.
Your installation of gcc is most likely broken now.
Sorry, you will have to restore it yourself.
Please move $cc1.orig to $cc1.])
	        exit 1
	      else
	        AC_MSG_ERROR([Failed to move the old cc1 to safety.
Please replace $cc1 with $cc1.patched by hand.])
	        exit 1
	      fi
	    else
	      rm -f "$cc1.patched"
	      AC_MSG_ERROR([The size has changed.
You need to patch cc1 by hand.])
	      exit 1
	    fi
	  else
	    AC_MSG_RESULT(no -- you need to patch cc1 by hand)
	    exit 1
	  fi
        else
          AC_MSG_RESULT(no -- you need to patch cc1 by hand)
          exit 1
        fi
      fi
    else :; fi
  else :; fi
else :; fi

#############################################################################


AC_ARG_WITH(root, MY_DESCR([--with-root=path],
			   [specify a cross-compilation root-directory]),[
  case "$with_root" in
    /)
      with_root=""
    ;;
    /*)
    ;;
    no)
      with_root=""
    ;;
    *)
      PIKE_MSG_WARN([Root path $with_root is not absolute. Ignored.])
      with_root=""
    ;;
  esac
],[with_root=""])
MY_AC_ARG_WITH(relocatable_dumped_modules,
	       MY_DESCR([--with-relocatable-dumped-modules],
			[make dumped modules relocatable]),
	       [with_relocatable_dumped_modules=yes])
AC_ARG_WITH(dynamic_modules, MY_DESCR([--without-dynamic-modules],
				      [link modules statically]))
MY_AC_ARG_WITH(static_linking, MY_DESCR([--with-static-linking],
					[link statically, if possible]),
	       [with_static_linking=yes])
AC_ARG_WITH(bundles,
	    MY_DESCR([--without-bundles],
		     [do not enable bundled libraries]),
	    [], [with_bundles=yes])
pike_bundle_dir=""
if test "$with_bundles" = "no"; then :; else
  if test -d "$with_bundles/."; then
    # The user has specified a bundle directory. Use it.
    pike_bundle_dir="$with_bundles"
  elif test -d "$srcdir/../bundles/."; then
    # We have a bundle directory; enable them if needed.
    pike_bundle_dir=`cd "$srcdir/../bundles" && pwd`
  fi
  test -d bundles/. || mkdir bundles;
fi
if test -d bundles/.; then
  touch bundles/no_testsuites
  pike_bundle_prefix="`pwd`/bundles"
  LDFLAGS="$LDFLAGS -L$pike_bundle_prefix/lib"
  CPPFLAGS="$CPPFLAGS -I$pike_bundle_prefix/include"
fi
export pike_bundle_dir
AC_ARG_WITH(site-prefixes,
	    MY_DESCR([--with-site-prefixes],
		     [list of prefixes to search for include, lib and bin dirs.]))
AC_ARG_WITH(include-path,
	    MY_DESCR([--with-include-path],
		     [a list of paths to search for include files.]))
AC_ARG_WITH(lib-path,
	    MY_DESCR([--with-lib-path],
		     [a list of paths to search for libraries.]))

AC_ARG_WITH(long-double-precision, MY_DESCR([--with-long-double-precision],
					    [use long double precision floats]))
AC_ARG_WITH(double-precision, MY_DESCR([--with-double-precision],
				       [use double precision floats]))

AC_ARG_WITH(long-long-int, MY_DESCR([--with-long-long-int],
				    [use long long native type int]))
AC_ARG_WITH(long-int, MY_DESCR([--with-long-int],
			       [use long native type int]))
AC_ARG_WITH(int-int, MY_DESCR([--with-int-int],
			      [use int native type int]))
dnl AC_ARG_WITH(short-int, MY_DESCR([--with-short-int],
dnl 				    [use short native type int (EXPERIMENTAL)]))
dnl AC_ARG_WITH(unsigned-long-int, MY_DESCR([--with-unsigned-long-int],
dnl 				    [use short native type int (EXPERIMENTAL)]))
dnl AC_ARG_WITH(unsigned-long-long-int, MY_DESCR([--with-unsigned-long-longint],
dnl 				    [use short native type int (EXPERIMENTAL)]))

MY_AC_ARG_WITH(cleanup-on-exit,
	       MY_DESCR([--with-cleanup-on-exit],
			[Do full cleanup at exit to detect leaks better.]),
	       [AC_DEFINE(DO_PIKE_CLEANUP)])
MY_AC_ARG_WITH(dmalloc, MY_DESCR([--with-dmalloc],[Enable memory leak checks.]),
	       [AC_DEFINE(DEBUG_MALLOC,10)])
MY_AC_ARG_WITH(dmalloc-malloc, MY_DESCR([--with-dmalloc-malloc],
					[Enable overloading of malloc(3)]),
	       [ AC_DEFINE(ENCAPSULATE_MALLOC,1) ])
MY_AC_ARG_WITH(dmalloc-malloc-leaks,
	       MY_DESCR([--with-dmalloc-malloc-leaks],
			[Report memory allocated by malloc(3) as leaks.]),
	       [ AC_DEFINE(REPORT_ENCAPSULATED_MALLOC,1) ])
MY_AC_ARG_WITH(dmalloc-trace, MY_DESCR([--with-dmalloc-trace],
				       [enable tracepoints]),
	       [with_dmalloc_trace="yes" AC_DEFINE(DMALLOC_TRACE,10)])
AC_ARG_WITH(debug, MY_DESCR([--with-debug],[same as --with-cdebug --with-rtldebug]),
	    [],[with_debug=])
AC_ARG_WITH(debug, MY_DESCR([--without-debug],[same as --without-cdebug --without-rtldebug]),
	    [],[with_debug=])
AC_ARG_WITH(rtldebug, MY_DESCR([--with-rtldebug],[enable run time self tests]),
	    [],[with_rtldebug=])
AC_ARG_WITH(cdebug, MY_DESCR([--without-cdebug],[disable -g]),[],[
  case "$pike_cv_sys_os:$GCC" in
    Solaris:no)
      # Solaris/cc has problems with combining optimizations and debuginfo.
      PIKE_MSG_WARN([Defaulting to --without-cdebug since the OS is Solaris,
and gcc is not being used.])
      with_cdebug=no
    ;;
    HP-UX:no|HPUX:no)
      # HP-UX/cc has problems with combining optimizations and debuginfo.
      #
      # cc: internal panic 7815: Malloc: underflow detected in free(). (7815)
      PIKE_MSG_WARN([Defaulting to --without-cdebug since the OS is HP-UX,
and gcc is not being used.])
      with_cdebug=no
    ;;
    *)
      with_cdebug=
    ;;
  esac
])
AC_ARG_WITH(copt, MY_DESCR([--without-copt], [disable -O2]), [], [with_copt=])
AC_ARG_WITH(threads, MY_DESCR([--without-threads], [disable threads support]),
	    [],[
   case "x$pike_cv_sys_os" in
     xFreeBSD*)
        if test "`uname -r|sed -e 's/\([[0-9]]*\).*/\1/'`" -lt 4; then
           PIKE_MSG_WARN([FreeBSD <= 3.x detected, disabling threads.
Use --with-threads to force threads support.])
           with_threads=no
        fi
     ;;
     xOpenBSD*)
        if test "`uname -r|sed -e 's/\([[0-9]]*\).*/\1/'`" -lt 4 \
             -a "x`uname -m`" = "xalpha"; then
           PIKE_MSG_WARN([OpenBSD/alpha <= 3.x detected, disabling threads.
Use --with-threads to force threads support.])
           with_threads=no
        fi
     ;;
   esac

   if test "x${with_threads-}" = x; then
     with_threads=yes
   fi
])

AC_ARG_WITH(malloc_overhead,
	    MY_DESCR([--with-malloc-overhead=n],
	             [tune the malloc block overhead (default is 2 * sizeof(void *))]),
	    [AC_DEFINE(PIKE_MALLOC_OVERHEAD,($withval))],
	    [AC_DEFINE(PIKE_MALLOC_OVERHEAD,(2 * sizeof(void *)))])
AC_ARG_WITH(malloc_page_size,
	    MY_DESCR([--with-malloc-page-size=n],
		     [tune to the memory page size (default is 4 kb)]),
	    [AC_DEFINE(PIKE_MALLOC_PAGE_SIZE,($withval))],
	    [AC_DEFINE(PIKE_MALLOC_PAGE_SIZE,(4 * 1024))])
AC_ARG_WITH(thread_c_stack,
	    MY_DESCR([--with-thread-c-stack=n],
	             [tune the thread c-stack (default is 256 * 1024)]),
	    [AC_DEFINE_UNQUOTED(PIKE_THREAD_C_STACK_SIZE,($withval))],
	    [AC_DEFINE(PIKE_THREAD_C_STACK_SIZE,(256 * 1024))])

AC_ARG_WITH(devpoll, MY_DESCR([--without-devpoll],
			      [disable support for /dev/poll]),
	    [],[with_devpoll=yes])
AC_ARG_WITH(gdbm, MY_DESCR([--without-gdbm],[no GNU database manager support]))
AC_ARG_WITH(gmp, MY_DESCR([--without-gmp],[no support for Gmp bignums]))
AC_ARG_WITH(zlib, MY_DESCR([--without-zlib],[disable gz compression support]),
	    [],[with_zlib=yes])
AC_ARG_WITH(ssleay,
	    MY_DESCR([--with-ssleay],
		     [support for the secure socket protocol (OBSOLETE)]),
	    [],[with_ssleay=no])
AC_ARG_WITH(mysql, MY_DESCR([--without-mysql],
			    [disable support for the Mysql database]),
	    [],[with_mysql=yes])
AC_ARG_WITH(valgrind, MY_DESCR([--with-valgrind=path],
	    [Support for running with valgrind]), [
  if test "x$with_valgrind" = "xyes"; then
    AC_PATH_PROG(with_valgrind, valgrind, no)
    if test "x$with_valgrind" = "xno"; then
      PIKE_MSG_WARN(valgrind not found, disabled.)
    else :; fi
  else :; fi
], [with_valgrind=no])
AC_ARG_WITH(checker, MY_DESCR([--with-checker],
			      [add extra memory checking overhead (Purify)]))
AC_ARG_WITH(gcov, MY_DESCR([--with-gcov],
			   [compile with support for gcov (gcc-only)]))
MY_AC_ARG_WITH(profiling, MY_DESCR([--with-profiling],
				   [add code used to profile pike code]),
	       [AC_DEFINE(PROFILING)])
MY_AC_ARG_WITH(internal-profiling, MY_DESCR([--with-internal-profiling],
				   [add profiling code for various internal things]),
	       [AC_DEFINE(INTERNAL_PROFILING)])
MY_AC_ARG_WITH(pg, MY_DESCR([--with-pg],[use the gcc -pg option]),
	       [PROFIL=-pg])
AC_ARG_WITH(poll, MY_DESCR([--with-poll], [use poll instead of select]), [], [
  # Neither --with-poll nor --without-poll was specified
  case "$pike_cv_sys_os" in
    Solaris|HP-UX|OSF1|IRIX|Linux|UnixWare|OpenUNIX)
#    PIKE_MSG_WARN([Defaulting to --with-poll since the OS is $pike_cv_sys_os.])
# Nothing to warn about, really...
      with_poll=yes
    ;;
    AIX)
      # poll(2) is broken on AIX 4.1 and earlier.
      if test "`uname -r`" -ge 2 -a "`uname -v`" -ge 4 ; then
        with_poll=yes
      else if test "`uname -v`" -gt 4 ; then
          with_poll=yes
        else :; fi
      fi
    ;;
  esac
])
AC_ARG_WITH(max-fd,
	    MY_DESCR([--with-max-fd=X],
		     [set how many filedescriptors can be used at once]),
	    [pike_cv_max_open_fd=$withval])
MY_AC_ARG_WITH(oob, MY_DESCR([--without-oob],
			     [disable out-of-band data handling (INVALID)]),
[],[
  AC_MSG_ERROR([Support for out of band data is mandatory in Pike 7.5 and later.])
])
MY_AC_ARG_WITH(compiler-trace, MY_DESCR([--with-compiler-trace],
					[enable tracing of the compiler]),
	       [AC_DEFINE(YYDEBUG)])
AC_ARG_WITH(security, MY_DESCR([--with-security],
			       [enable internal pike security system]),
	    [AC_DEFINE(PIKE_SECURITY)])
AC_ARG_WITH(bignums, MY_DESCR([--without-bignums],
			      [disable internal conversion to bignums (not recommended)]),
	    [],[with_bignums=yes])
dnl Shared nodes has been disabled in an ugly way. To enable it you
dnl need to remove the line that sets the OPT_NOT_SHARED flag at the
dnl top of freeze_node in src/las.c. /mast
dnl AC_ARG_WITH(shared-nodes,
dnl 		MY_DESCR([--without-shared-nodes],
dnl 			 [disable the SHARED_NODES mode of the optimizer]),
dnl 		[],[with_shared_nodes=yes])
AC_ARG_WITH(computed-goto,
	    MY_DESCR([--with-computed-goto],
		     [enable use of gcc-style computed goto (EXPERIMENTAL).]),
	    [], [with_computed_goto=no])
AC_ARG_WITH(machine-code,
	MY_DESCR([--without-machine-code],
		 [do not try to use of machine code on supported architectures.]),
	[], [
	  case "x$pike_cv_sys_os" in
	    xOpenBSD*)
	      PIKE_MSG_WARN([OpenBSD detected, disabling machine code.
Use --with-machine-code to force usage of machine code support.])
	      with_machine_code="no"
	    ;;
	  esac
	
	  if test "x${with_machine_code-}" = x; then
	    with_machine_code="yes"
	  fi
	])

MY_AC_ARG_WITH(keypair-loop,
	MY_DESCR([--with-keypair-loop],
		 [enable use of keypair mapping loop method (EXPERIMENTAL).]),
	       [AC_DEFINE(PIKE_MAPPING_KEYPAIR_LOOP)])

MY_AC_ARG_WITH(portable-bytecode,
	MY_DESCR([--with-portable-bytecode],
		 [enable portable bytecode support (EXPERIMENTAL).]),
	       [AC_DEFINE(PIKE_PORTABLE_BYTECODE)])

MY_AC_ARG_WITH(lock,
	       MY_DESCR([--without-lock],
	  [enable experimental code for multicpu machines (EXPERIMENTAL).]),
		[],[AC_DEFINE(PIKE_RUN_UNLOCKED)])

AC_ARG_WITH(pike-type, MY_DESCR([--without-pike-type],
				[disable struct pike_type (IGNORED).]))

if test "x$with_pike_type" = "xno"; then
  PIKE_MSG_WARN([Disabling of USE_PIKE_TYPE is no longer supported.])
fi

if test "x$with_bignums" = xyes; then
  AC_DEFINE(AUTO_BIGNUM)
  if test "x$with_gmp" = xno; then
    AC_MSG_ERROR([Cannot compile --with-bignums without the GMP library
It is highly recommended that you install a working GMP
library on your system as that will add features to Pike
required by many applications (such as Roxen).  However,
if you know that you do not need GMP, you may re-run configure
with the option --without-bignums instead.])
  else :; fi
else
  PIKE_MSG_WARN([****** Compiling without bignum support. This is discouraged. Many
****** Pike applications might not work correctly.])
 sleep 10
fi

dnl Pike currently breaks miserably if SHARED_NODES is not defined.
dnl Shared nodes are still disabled bluntly. (See note above.)
dnl if test "x$with_shared_nodes" != xno; then
dnl  echo 'Enabling the SHARED_NODES mode of the optimizer.'
  AC_DEFINE(SHARED_NODES)
dnl else :; fi

if test "x$with_poll" = "xyes"; then
  AC_DEFINE(HAVE_AND_USE_POLL)
else :; fi

if test "x$with_valgrind" = "xno"; then
  VALGRIND=""
  VALGRINDARGS=""
else
  VALGRIND="$with_valgrind"
  # Make valgrind a bit silent by default.
  VALGRINDARGS="-q --tool=memcheck"
  AC_DEFINE(USE_VALGRIND)

  if test "x$with_copt" != "xno"; then
    PIKE_MSG_WARN([--without-copt is advisable when using valgrind!])
  fi
fi
export VALGRIND VALGRINDARGS
AC_SUBST(VALGRIND)
AC_SUBST(VALGRINDARGS)

if test "x$with_checker" = "xyes"; then
  AC_DEFINE(__CHECKER__)
else :; fi

if test "x$with_relocatable_dumped_modules" = xyes; then
  PIKE_MODULE_RELOC=1
else
  PIKE_MODULE_RELOC=""
fi
AC_SUBST(PIKE_MODULE_RELOC)


#
# Allow --with(out)-debug to toggle both cdebug and rtldebug, but
# let --with(out)-{c,rtl}debug take precedence.
#
if test "x$with_cdebug" = x ; then
  with_cdebug="$with_debug"
fi

if test "x$with_rtldebug" = x ; then
  with_rtldebug="$with_debug"
fi


#
# --with-dmalloc requires --with-rtldebug
#
if test "x$with_dmalloc" = "x"; then :; else
  if test "x$with_rtldebug" = "xyes"; then :; else
    PIKE_MSG_WARN([Debug malloc requires rtldebug. Enabling rtldebug.])
    with_rtldebug=yes
  fi
fi


#
# Defaults for cdebug and rtldebug here:
#

if test "x$with_cdebug" = x ; then
  with_cdebug=yes
fi

if test "x$with_rtldebug" = x ; then
  with_rtldebug=no
#  with_rtldebug=yes
fi

if test "x$with_rtldebug" = xyes ; then
  AC_DEFINE(PIKE_DEBUG)
fi

#############################################################################


WARN=""
OPTIMIZE="${OPTFLAGS-}"

AC_ARG_ENABLE(pedantic, MY_DESCR([--enable-pedantic],
   [enable -pedantic compilation]))

if test "$cflags_is_set" = "no"; then
  if test "x$with_cdebug" = "xno" ; then
    CFLAGS=`echo " $CFLAGS " | sed -e 's@ -g @ @g'`
  else
    :
  fi

  if test "x$enable_pedantic" = "xyes"; then
    AC_SYS_COMPILER_FLAG(-pedantic,pedantic,WARN)
  fi


  if test "x${GCC-}" = xyes ; then
  # Do not use -Wall, since that produces a lot of warnings that are not
  # really interresting (such as the warning for if( ... ) ... if(
  # ... ) .... else
    AC_SYS_COMPILER_FLAG(-W,W,WARN)
    AC_SYS_COMPILER_FLAG(-Wall,Wall,WARN)
    AC_SYS_COMPILER_FLAG(-Wno-unused,Wno_unused,WARN)
    AC_SYS_COMPILER_FLAG(-Wcomment,Wcomment,WARN)
    AC_SYS_COMPILER_FLAG(-Wformat,Wformat,WARN)
    AC_SYS_COMPILER_FLAG(-Wimplicit-function-declaration,Wimplicit_function_declaration,WARN)
    AC_SYS_COMPILER_FLAG(-Wmultichar,Wmultichar,WARN)
    AC_SYS_COMPILER_FLAG(-Wswitch,Wswitch,WARN)

    if test "x$with_copt" != xno; then
      # gcc complains that it doesn't support this when compiling
      # without optimizations.
      AC_SYS_COMPILER_FLAG(-Wuninitialized,Wuninitialized,WARN)
    fi
    AC_SYS_COMPILER_FLAG(-Wpointer-arith,Wpointer_arith,WARN)
    AC_SYS_COMPILER_FLAG(-Wchar-subscripts,Wchar_subscripts,WARN)
    AC_SYS_COMPILER_FLAG(-Wno-long-long,Wno_long_long,WARN)

    if test "x${with_static_linking-}" = "xyes" ; then
      AC_SYS_COMPILER_FLAG(-static,link_static,CFLAGS)
    else
      :
    fi

    if test "x$with_gcov" = "xyes"; then
      # Support for gcov
      AC_SYS_COMPILER_FLAG(-fprofile-arcs, fprofile_arcs, CFLAGS)
      AC_SYS_COMPILER_FLAG(-ftest-coverage, ftest_coverage, CFLAGS)
    else :; fi

    ##
    ## -fomit-frame-pointer does not work with egcs 1.1.1
    ## /Hubbe 1998-12-20
    ##
    #if test "x$with_cdebug" = "xno" ; then
    #  AC_SYS_COMPILER_FLAG(-fomit-frame-pointer,fomit_frame_pointer,OPTIMIZE)
    #else
    #  :
    #fi  


### Optimize for different SUN machines. If there is no working 'uname'
### no extra optimization will be done, but nothing should break either.
  case "`uname -m 2>/dev/null`" in
   sun4c)
    # The -msparclite option seems to generate assembler that /bin/as doesn't
    # understand.	/grubba 1998-07-17
    # AC_SYS_COMPILER_FLAG(-msparclite,sparclite,CFLAGS) 
   ;;
   sun4m)
    AC_SYS_COMPILER_FLAG(-mv8,microsparc,CFLAGS)
   ;;
   sun4d)
    AC_SYS_COMPILER_FLAG(-msupersparc,supersparc,CFLAGS)
   ;;
   sun4u)
    AC_SYS_COMPILER_FLAG(-mcpu=ultrasparc,mcpu_ultrasparc,CFLAGS,[
      AC_SYS_COMPILER_FLAG(-msupersparc,supersparc,CFLAGS)
    ],[],[
      # Some versions of gcc define __sparcv9 but aren't LP64.
      # Definition of __sparcv9 causes <sys/isa_defs.h> to define _LP64,
      # which is not a good thing for ILP32 systems...
      # Some versions of gcc define __sparc_v9__, which causes the
      # fix-included <limits.h> to think the same...
      AC_TRY_CPP([#include <limits.h>
#include <sys/types.h>
#if defined(_LP64) || (LONG_MAX != 2147483647L)
#error "We might have a problem."
#endif
      ],[],[
        # We might have a problem...
        # Check that we indeed have a LP64 system.
        AC_MSG_RESULT([yes, but LP64])
        AC_CHECK_SIZEOF(long, 4)
	# Note: the result for the following message is provided
	# by SYS_COMPILER_FLAG
	AC_MSG_CHECKING([are we really an LP64 system])
	if test "x$ac_cv_sizeof_long" = "x8"; then
	  :; #OK, we have an LP64 system!
	else
	  pike_cv_option_mcpu_ultrasparc=no
	fi
      ])
    ])
   ;;
   i586)
    AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[
	AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS)
    ])
   ;;
   i686)
    AC_SYS_COMPILER_FLAG(-mcpu=i686,mcpu_i686,CFLAGS,[
        AC_SYS_COMPILER_FLAG(-mpentiumpro,pentiumpro,CFLAGS,[
	    AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[
		AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS)
	    ])
        ])
    ])
#    AC_SYS_COMPILER_FLAG(-march=i686,march_i686,CFLAGS)
   ;;
   i86pc)
     case "`isalist 2>/dev/null`" in 
        *pentium_pro*)
	 AC_SYS_COMPILER_FLAG(-mcpu=i686,mcpu_i686,CFLAGS,[
	 	AC_SYS_COMPILER_FLAG(-mpentiumpro,pentiumpro,CFLAGS,[
		    AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[
			AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS)
		    ])
	 	])
	 ])
#         AC_SYS_COMPILER_FLAG(-march=i686,march_i686,CFLAGS)
	;;
        *pentium*)
	 AC_SYS_COMPILER_FLAG(-mcpu=pentium,mcpu_pentium,CFLAGS,[
	   AC_SYS_COMPILER_FLAG(-mpentium,pentium,CFLAGS,[
             AC_SYS_COMPILER_FLAG(-m486,486,CFLAGS)
	   ])
         ])
	;;
     esac
    ;;
  esac

  # AIX
  DO_IF_OS(AIX,
  [
    # Tell the linker to generate a large toc if needed
    #
    # This option is not needed on AIX 5L/ia64.
    if test "x`uname -p`" = "xia64"; then :; else
      AC_SYS_COMPILER_FLAG(-bbigtoc,bbigtoc,LDFLAGS)
      AC_SYS_COMPILER_FLAG([-Wl,-bbigtoc],Wlbbigtoc,LDFLAGS)
    fi
  ])

  DO_IF_OS(Darwin,
  [
    # aka MacOS X.
    # Foundation framework needed by JavaVM.framework. The OS X 10.1 linker
    # no longer includes indirect dependencies so we need to add them here.
    AC_SYS_COMPILER_FLAG(-framework Foundation, framework_Foundation, LDFLAGS)
    AC_SYS_COMPILER_FLAG(-framework System, framework_System, LDFLAGS)

    # -flat_namespace only needed for linking with libMallocDebug
    # AC_SYS_COMPILER_FLAG(-flat_namespace, flat_namespace, LDFLAGS)

    # OS X only runs on G3 or newer. Tuning for recent G4s should help them
    # while being ok for older machines as well.
    AC_SYS_COMPILER_FLAG(-mcpu=750,cpu750,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-mtune=7450,tune7450,OPTIMIZE)
  ])

  DO_IF_OS(Linux,
  [
    if test "x$with_machine_code" = "xno"; then :; else
      # WORKAROUND: mprotect(PROT_EXEC) doesn't work on Linux/x86.
      # Try to set the stackexec flag on the binary.
      # First try -z execstack (ld).
      AC_SYS_COMPILER_FLAG([-z execstack], z_execstack, LDFLAGS, [
        # No, try passing it directly to the linker.
        AC_SYS_COMPILER_FLAG([-Wl,-z,execstack], Wl_z_execstack, LDFLAGS, [
	  # No, try --execstack (gas).
	  AC_SYS_COMPILER_FLAG([--execstack], execstack, CFLAGS, [
	    # No, try passing it directly to the assembler.
	    AC_SYS_COMPILER_FLAG([-Wa,--execstack], Wa_execstack, CFLAGS, [
	      # No.
	      # FIXME: Add support for use of chstk(1).
	      PIKE_MSG_WARN([Could not find any way to enable executable stack.])
	    ])
	  ])
	])
      ])
    fi
  ])

 else if test "x${TCC-}" = xyes ; then

  # Yikes! We're using the TenDRA compiler!

  # Make sure we can use the system headerfiles...
  # Already done by the CC test in aclocal.m4.
  # AC_SYS_COMPILER_FLAG(-Ysystem, ysystem, CPPFLAGS)

  # Use lenient ANSI compliance...
  #AC_SYS_COMPILER_FLAG(-Xa, xa, CFLAGS)

  # Find out where libtdf.a is hidden.
  AC_MSG_CHECKING(for machine dependant library directory)
  AC_CACHE_VAL(pike_cv_tcc_lib_path,
  [
    pike_cv_tcc_lib_path="`${CC-cc} -dry conftest.c -i 2>&1 | sed -e '/tdfc/s/bin\/tdfc.*/lib\/sys/p' -ed| head -n 1`"
    if test -d "$pike_cv_tcc_lib_path/." ; then :; else
      # Failed.
      pike_cv_tcc_lib_path="no"
    fi
  ])
  AC_MSG_RESULT($pike_cv_tcc_lib_path)

  if test "$pike_cv_tcc_lib_path" = "no" ; then :; else
    LDFLAGS="$LDFLAGS -L$pike_cv_tcc_lib_path"

    # This library is needed for 64bit support on 32bit machines/OS's.
    AC_CHECK_LIB(tdf, __TDFUnot)
  fi

 else

  # Assume system compiler "cc".

  if test "x${with_static_linking-}" = "xyes" ; then
    DO_IF_OS(AIX,
    [
      AC_SYS_COMPILER_FLAG([-Wl,-bstatic],wl_link_static,CFLAGS)
      LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -bstatic"
    ])

    DO_IF_OS(OSF1,
    [
      AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS)
      LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -non_shared"
    ])

    DO_IF_OS(IRIX,
    [
      AC_SYS_COMPILER_FLAG(-non_shared,non_shared,CFLAGS)
      LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS} -B static"
    ])

    # how do you link statically on HP-UX ?
  else
    :
  fi

### Non-gcc thingies. This should probably be enhanced...

  # Linux with Intel C++
  DO_IF_OS(Linux,
  [
    if $REALCC -V 2>&1 | head -1 | grep "Intel(R) C" >/dev/null; then
      # icc or ecc.
      AC_SYS_COMPILER_FLAG(-Ob2,Ob2,OPTIMIZE)
      AC_SYS_COMPILER_FLAG(-ipo,ipo,OPTIMIZE)
      AC_SYS_COMPILER_FLAG(-ipo,ipo,EXTRALDFLAGS)
      AC_SYS_COMPILER_FLAG(-ipo_obj,ipo_obj,OPTIMIZE)
      AC_SYS_COMPILER_FLAG(-parallel, parallel,OPTIMIZE)
      AC_SYS_COMPILER_FLAG(-parallel, parallel,LDFLAGS)
      # arch dependent optimizations while maintaining
      # i386 compatibility
      AC_SYS_COMPILER_FLAG(-axKW,axKW,OPTIMIZE)
    fi
  ])


  # Solaris
  DO_IF_OS(Solaris,
  [
    AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-xdepend,xdepend,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-xs,xs,CFLAGS)
    # Causes __STDC__ to be 1 which causes several headerfiles to behave
    # differently.
    # AC_SYS_OS_COMPILER_FLAG(-Xc,Xc,WARN)
  ])

  # AIX
  DO_IF_OS(AIX,
  [
    # This one is needed to get the compiler to fail on errors,
    # which is needed for several configure-tests.
    AC_SYS_COMPILER_FLAG(-qhalt=e,qhalt_e,CFLAGS)
    AC_SYS_COMPILER_FLAG(-qro,qro,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-qfold,qfold,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-qwarn64,qwarn64,WARN)
    AC_SYS_COMPILER_FLAG(-qflag=w:w,qflag_w_w,WARN)
    AC_DEFUN(AC_SYS_COMPILER_FLAG_QINFO, [
      AC_SYS_COMPILER_FLAG(-qinfo=$1,qinfo_$1,WARN)
    ])
    AC_SYS_COMPILER_FLAG_QINFO(cmp)
    AC_SYS_COMPILER_FLAG_QINFO(cnd)
    AC_SYS_COMPILER_FLAG_QINFO(cns)
    AC_SYS_COMPILER_FLAG_QINFO(cnv)
    AC_SYS_COMPILER_FLAG_QINFO(dcl)
    AC_SYS_COMPILER_FLAG_QINFO(eff)
    AC_SYS_COMPILER_FLAG_QINFO(enu)
    AC_SYS_COMPILER_FLAG_QINFO(ext)
    AC_SYS_COMPILER_FLAG_QINFO(gen)
    AC_SYS_COMPILER_FLAG_QINFO(gnr)
    AC_SYS_COMPILER_FLAG_QINFO(got)
    AC_SYS_COMPILER_FLAG_QINFO(ini)
    AC_SYS_COMPILER_FLAG_QINFO(inl)
    AC_SYS_COMPILER_FLAG_QINFO(lan)
    AC_SYS_COMPILER_FLAG_QINFO(obs)
    AC_SYS_COMPILER_FLAG_QINFO(ord)
    AC_SYS_COMPILER_FLAG_QINFO(par)
    AC_SYS_COMPILER_FLAG_QINFO(por)
    # ppc disabled since it complains about the system header files.
    # AC_SYS_COMPILER_FLAG_QINFO(ppc)
    # ppt disabled since tracing the preprocessor isn't interresting.
    # AC_SYS_COMPILER_FLAG_QINFO(ppt)
    AC_SYS_COMPILER_FLAG_QINFO(pro)
    AC_SYS_COMPILER_FLAG_QINFO(rea)
    AC_SYS_COMPILER_FLAG_QINFO(ret)
    # trd disabled, since it adds extra errors (in particular 1506-419).
    # AC_SYS_COMPILER_FLAG_QINFO(trd)
    AC_SYS_COMPILER_FLAG_QINFO(tru)
    AC_SYS_COMPILER_FLAG_QINFO(uni)
    AC_SYS_COMPILER_FLAG_QINFO(use)
    # AC_SYS_COMPILER_FLAG(-qalias=addr,qalias_addr,OPTIMIZE)    
    # AC_SYS_COMPILER_FLAG(-qlibansi,qlibansi,OPTIMIZE)
    # Tell the linker to generate a large toc if needed
    # Tell the linker to generate a large toc if needed
    #
    # This option is not needed on AIX 5L/ia64.
    if test "x`uname -p`" = "xia64"; then :; else
      AC_SYS_COMPILER_FLAG(-bbigtoc,bbigtoc,LDFLAGS)
    fi
  ])

  # HP-UX
  DO_IF_OS(HP-UX,
  [
    AC_SYS_COMPILER_FLAG(-D__STDC_EXT__,stdc_ext,CFLAGS)
    AC_SYS_COMPILER_FLAG([-Wp,-H50000],cpp_buffer_size,CFLAGS)
    AC_SYS_COMPILER_FLAG(+ESlit,plus_ESlit,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(+Odataprefetch,plus_Odataprefetch,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(+Ofailsafe,plus_Ofailsafe,OPTIMIZE)
    # Ignore the following warnings if you enable +w1
    #   414 Optimization reduced to +O2 for compatibility with Debug.
    #   530 Casting from loose to strict alignment
    #   558 Empty declaration.
    # AC_SYS_COMPILER_FLAG(+w1,plus_w1,WARN)
  ])

  # OSF/1
  DO_IF_OS(OSF1,
  [
    AC_SYS_COMPILER_FLAG(-fast,fast,OPTIMIZE)
    # The need for -ieee is not detected properly by the FPE tests below.
    # AC_SYS_COMPILER_FLAG(-ieee,ieee,CFLAGS)
    AC_SYS_COMPILER_FLAG(-readonly_strings,readonly_strings,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-assume trusted_short_alignment,
      assume_trusted_short_alignment,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-assume aligned_objects,
      assume_aligned_objects,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-no_misalign,no_misalign,OPTIMIZE)
  
    if test "x$with_cdebug" = "xyes" ; then
      # FIXME:
      # Maybe should remove the -g flag if this succeeds.
      AC_SYS_COMPILER_FLAG(-g3,g3,CFLAGS)
      AC_SYS_COMPILER_FLAG(-trapuv,trapuv,WARN)
    fi
    AC_SYS_COMPILER_FLAG(-host,host,OPTIMIZE)

    # Flags that cause errors or change compiler behaviour
    # must go in CFLAGS, they can not go in WARN
    # /Hubbe
    AC_SYS_COMPILER_FLAG(-std1,std1,CFLAGS)
    AC_SYS_COMPILER_FLAG(-warnprotos,warnprotos,WARN)
  ])

  # IRIX
  DO_IF_OS(IRIX,
  [
    # sopt disabled since it takes too long time on interpret.c (>45min on an OČ)
    # AC_SYS_COMPILER_FLAG(-sopt,sopt,OPTIMIZE)

    # -n32 moved to smartlink so it will affect cc as well as linker
    # this way the user can override it by setting LDFLAGS and/or CFLAGS
    # AC_SYS_COMPILER_FLAG(-n32,n32,CFLAGS)
    AC_SYS_COMPILER_FLAG(-fullwarn,fullwarn,WARN)
    AC_SYS_COMPILER_FLAG(-woff 1209,woff_1209,WARN)
    AC_SYS_COMPILER_FLAG(-OPT:Olimit_opt=on,OPT_Olimit_opt_on,OPTIMIZE)
    if test x$with_cdebug = xyes ; then
      AC_SYS_COMPILER_FLAG(-g3,g3,CFLAGS)
    fi
    if test x$with_rtldebug = xyes ; then
      AC_SYS_COMPILER_FLAG(-trapuw,trapuw,WARN)
    fi
  ])

  # Windows NT
  DO_IF_OS(Windows_NT,
  [
    # FIXME: The test below probably doesn't work.
    if echo "x$CC" | grep "rntecl" >/dev/null 2>&1; then
      # Some options used by ecl (Intel's IA64 compiler).

      # We want threads, and link libc statically.
      AC_SYS_COMPILER_FLAG(-MT,MT,LDFLAGS)

      # Interprocedural optimizations.
      # For some reason this seems to cause the error:
      # dynamic_buffer.obj : error LNK2001: unresolved external symbol "[Entry] ?1memcpy" (.?1memcpy)
      # AC_SYS_COMPILER_FLAG(-Qip,Qip,OPTIMIZE)

      # More warnings.
      AC_SYS_COMPILER_FLAG(-W3,W3,WARN)

      if test x$with_rtldebug = xyes ; then
        # Initialize auto variables to 0xcc.
	# (Only if optimizations are turned off with -Od).
        AC_SYS_COMPILER_FLAG(-GZ,GZ,WARN)
      fi
    else :; fi

    if test x$with_dynamic_modules = xno ; then :; else
      PIKE_MSG_WARN([Enabling dynamic modules for Win32.])
#      EXTRA_MODULE_REQUIREMENTS="${EXTRA_MODULE_REQUIREMENTS} import_functions.h"
      EXTRA_OBJS="${EXTRA_OBJS} dlopen.o"
      pike_cv_sys_dynamic_loading=yes
      with_dynamic_modules=yes
      AC_DEFINE(USE_MY_WIN32_DLOPEN)
    fi
  ])

dnl
dnl This does not work with Digital UNIX cc/ld (cc thinks it is ok, ld does not)
dnl  
dnl AC_SYS_COMPILER_FLAG(-native,native,OPTIMIZE)
dnl

dnl ### Ok. This is for apcc...
case "$CC" in
  *apcc)
    AC_SYS_COMPILER_FLAG(-XO=5,apcc_opt,OPTIMIZE)
    AC_SYS_COMPILER_FLAG(-Xcallmod=2,apcc_opt_2,OPTIMIZE)
  ;;
esac

# Old cc for solaris.
#  AC_SYS_CPU_COMPILER_FLAG(sun4m,-Xpipe=micro,microsparc,OPTIMIZE)
#  AC_SYS_CPU_COMPILER_FLAG(sun4d,-Xpipe=super,supersparc,OPTIMIZE)
#  AC_SYS_CPU_COMPILER_FLAG(sun4u,-Xpipe=super,ultrasparc,OPTIMIZE)

  case "${CFLAGS-} $OPTIMIZE" in
    *-O*) ;;
    *+O*) ;;
    *-fast*) ;;
    *)
      case "$pike_cv_sys_os:$GCC" in
        UnixWare*:no|OpenUNIX*:no)
	;;
	*)
	;;
      esac
    ;;
  esac
 fi
 fi
else
  # CFLAGS has already been set by the user.
  # Avoid adding anything that isn't essential.
  DO_IF_OS(AIX,
  [
    # This one is needed to get the compiler to fail on errors,
    # which is needed for several configure-tests.
    AC_SYS_COMPILER_FLAG(-qhalt=e,qhalt_e,CFLAGS)
  ])
fi

#############################################################################

if test ! -d modules/. ; then
  mkdir modules
fi

#############################################################################

## Search for some popular places where libraries may be hidden.

#############################################################################

if test x$"pike_cv_sys_os" != xWindows_NT ; then

echo Searching for include-file directories...

#Don't add include dirs if they give us warnings...
OLD_ac_c_preproc_warn_flag="$ac_c_preproc_warn_flag"
ac_c_preproc_warn_flag=yes

if test $cppflags_is_set = no -a x${C_INCLUDE_PATH-} = x ; then
  real_include_dirs=''
  for d in `echo ${with_include_path} | sed 's/:/ /g'` \
    `echo "${with_site_prefixes}/include"|sed -e 's/:/\/include /g'` \
    `echo $prefix | sed "s@^NONE@$with_root$ac_default_prefix@g"`/include \
    $with_root/usr/local/include $with_root/sw/local/include \
    $with_root/usr/gnu/include $with_root/opt/gnu/include \
    $with_root/sw/gnu/include $with_root/sw/include \
    $with_root/usr/freeware/include $with_root/usr/pkg/include \
    $with_root/opt/sfw/include \
    `echo $with_root/opt/gnome*/include | sort -r` \
    `echo $with_root/usr/X11*/include | sort -r`
  do
    AC_MSG_CHECKING($d)
    case x$d in
      x/usr/include | x/usr//include)
      ;;
      *)
        if test -d "$d/." ; then
          REALDIR="`cd $d/. ; /bin/pwd`"
          if test "x$REALDIR" = x ; then
            REALDIR=UNKNOWN
          else
            :
          fi

          case " $CPPFLAGS $real_include_dirs " in
            *\ -I$d\ * | *\ -I$REALDIR\ *)
               AC_MSG_RESULT(already added)
            ;;
            *)
	      OLD_CPPFLAGS="${CPPFLAGS}"
              CPPFLAGS="${CPPFLAGS} -I$d"
	      AC_TRY_CPP([#include <stdio.h>], [
                AC_MSG_RESULT(added)
                if test "x$REALDIR" != xUNKNOWN; then
                  real_include_dirs="${real_include_dirs} -I$REALDIR"
                else
                  :
                fi
	      ], [
	        AC_MSG_RESULT(fails)
		CPPFLAGS="${OLD_CPPFLAGS}"
	      ])
            ;;
          esac
        else
          AC_MSG_RESULT(no)
        fi
      ;;
    esac
  done
else
  :
fi

#Restore preprocessor warning sensitivity
ac_c_preproc_warn_flag="$OLD_ac_c_preproc_warn_flag"

echo Searching for library directories...
if test $ldflags_is_set = no ; then
  for dd in `echo ${with_lib_path} | sed 's/:/ /g'` \
    `echo "${with_site_prefixes}/lib"|sed -e 's/:/\/lib /g'` \
    `echo $exec_prefix | sed "s@^NONE@$prefix/lib@g" | sed "s@^NONE@$with_root$ac_default_prefix@g"` \
    $with_root/usr/local/lib $with_root/sw/local/lib $with_root/sw/lib \
    $with_root/usr/gnu/lib $with_root/opt/gnu/lib $with_root/sw/gnu/lib \
    $with_root/usr/freeware/lib $with_root/usr/pkg/lib \
    $with_root/opt/sfw/lib $with_root/opt/gnome-1.4/lib \
    `echo $with_root/usr/X11*/lib | sort -r`
  do
    if test "$dd" = "/lib"; then continue; fi
    if test "$dd" = "/usr/lib"; then continue; fi
    for suff in '' 32 64 '/64'; do
      d="$dd$suff"
      AC_MSG_CHECKING($d)
      if test -d "$d/." ; then
  	case " $LDFLAGS " in
  	  *\ -L$d\ -R$d\ * | *\ -R$d\ -L$d\ *)
  	    AC_MSG_RESULT(already added)
  	  ;;
  	  *)
  	    OLD_LDFLAGS="${LDFLAGS}"
  	    LDFLAGS="${LDFLAGS} -R$d -L$d -lm"
  	    AC_TRY_RUN([
#include <stdio.h>
#include <math.h>
int main(int argc, char **argv)
{
  double (*foo)(double) = ceil;
  exit(0);
}
  	    ],[ LDFLAGS="$OLD_LDFLAGS -R$d -L$d"
  		AC_MSG_RESULT(yes)
  	    ],[ LDFLAGS="$OLD_LDFLAGS"
  		AC_MSG_RESULT(no)
  	    ],[AC_TRY_LINK([
#include <stdio.h>
#include <math.h>
  	       ],[
  		 double (*foo)(double) = ceil;
  		 exit(0);
  	       ],[ LDFLAGS="$OLD_LDFLAGS -R$d -L$d"
  		   AC_MSG_RESULT(probably)
  	       ],[ LDFLAGS="$OLD_LDFLAGS"
  		   AC_MSG_RESULT(no)])])
  	  ;;
  	esac
      else
  	AC_MSG_RESULT(no)
      fi
    done
  done
else
  :
fi

echo Searching for binary directories...
for d in `echo $exec_prefix | sed "s@^NONE@$prefix@g" | sed "s@^NONE@$with_root$ac_default_prefix@g"` \
    `echo "${with_site_prefixes}"|sed -e 's/:/ /g'` \
    "$with_root" $with_root/usr $with_root/usr/ccs $with_root/usr/vac \
    $with_root/usr/local $with_root/sw/local $with_root/usr/gnu \
    $with_root/opt/gnu $with_root/sw/gnu $with_root/sw \
    $with_root/opt/sfw $with_root/opt/gnome-1.4 \
    $with_root/usr/freeware $with_root/usr/pkg
do
  AC_MSG_CHECKING($d/bin)
  if test -d "$d/bin/." ; then
    AC_MSG_RESULT(added)
    EXTRA_PATH="${EXTRA_PATH}:$d/bin"
  else
    AC_MSG_RESULT(no)
  fi
done
export EXTRA_PATH

else
  # We are running NT
  :
fi

# During the configure tests we need some extra includes that
# shouldn't be there in the final version.
CONF_CPPFLAGS_EXTRA="-I$srcdir -I`pwd`"
CPPFLAGS="${CPPFLAGS} ${CONF_CPPFLAGS_EXTRA}"  

#############################################################################

## At this point we have at last initialized the compiler!

#############################################################################

if test ! -f confdefs.h ; then
  PIKE_MSG_WARN([Warning, lost confdefs.h, testing will be flawed!!
You might need to use bash instead of /bin/sh to get correct results.
To do this, please type the following at an sh prompt:
	\$ rm ./config.cache
	\$ CONFIG_SHELL=/path/to/bash
	\$ export CONFIG_SHELL
	\$ $CONFIG_SHELL ./configure])
fi

#############################################################################

AC_DEFINE(POSIX_SOURCE)

AC_MSG_CHECKING(ansi prototype capability)
AC_CACHE_VAL(pike_cv_sys_ansi_prototypes,
[
  AC_TRY_COMPILE([int foo(int bar);],[],
  [pike_cv_sys_ansi_prototypes=yes],
  [pike_cv_sys_ansi_prototypes=no])
])

if test "$pike_cv_sys_ansi_prototypes" = "yes"; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT([no, giving up...])
  exit 1
fi

#############################################################################

# The AC_PROG_INSTALL test is broken if $INSTALL is specified by hand.
# The FreeBSD ports system does this...
# Workaround:

if test "x$INSTALL" = "x"; then :; else
  # $INSTALL overrides ac_cv_path_install anyway...
  ac_cv_path_install="$INSTALL"
fi

AC_PROG_INSTALL
AC_PROG_CPP
AC_PROG_RANLIB

if test "x${AR-}" = x ; then
  AC_PATH_PROG(AR, ar, ar, $PATH:$EXTRA_PATH)
  export AR
fi

AC_SUBST(AR)

#############################################################################

# installbsd seems to be broken on some versions of AIX
#
# /grubba 1997-08-16

case "$ac_cv_path_install" in
  *installbsd*)
    AC_MSG_CHECKING(if $ac_cv_path_install works)
    AC_CACHE_VAL(pike_cv_install_works,
[
    if $ac_cv_path_install "$srcdir/configure.in" ./conftest >/dev/null 2>&1
    then
      if cmp "$srcdir/configure.in" ./conftest >/dev/null 2>&1; then
        pike_cv_install_works=yes;
      else
        pike_cv_install_works=no;
      fi
    else
      pike_cv_install_works=no;
    fi
    if test -f ./conftest; then
      rm -f ./conftest
    fi
])
    AC_MSG_RESULT($pike_cv_install_works)
    if test "$pike_cv_install_works" = "no"; then
      echo "Warning: Falling back to $ac_install_sh"
      INSTALL="$ac_install_sh"
    fi
  ;;
esac

#############################################################################

AC_MSG_CHECKING(for yacc clone that handles %pure_parser)
AC_CACHE_VAL(pike_cv_prog_working_yacc,
[
for YACC in pyacc byacc "bison -y" yacc "None"; do
  set dummy $YACC; ac_word=$2
  has_it=no
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      has_it="yes"
      break
    fi
  done
  IFS="$ac_save_ifs"
  
  if test "$has_it" = "yes"; then
cat >conftest.y<<\EOF
%pure_parser
%{
void parse();
void yyerror(char *);
%}
%%
all: foo bar
foo: 'f' 'o' 'o' { parse(); } ;
bar: 'b' 'a' 'r' ;
%%
int context;

int yylex(YYSTYPE *yylval)
{
  switch(context++)
  {
    case 0: return 'f';
    case 1: return 'o';
    case 2: return 'o';
    case 3: return 'b';
    case 4: return 'a';
    case 5: return 'r';
    default: return 0;
  }
}

int depth=0;
void parse()
{
  int tmp;
  if(depth++>5) return;
  tmp=context;
  context=0;
  yyparse();
  context=tmp;
}
int errors=0;
void yyerror(char *fel) { errors++; }
int main()
{
  parse();
  exit(errors);
}
EOF
    if $YACC -d conftest.y 1>&AC_FD_CC 2>&AC_FD_CC; then
      if test "x$enable_binary" = "xno"; then
	break
      else
	AC_TRY_RUN([
#include "y.tab.c"
],pure_parser_works=yes,pure_parser_works=no,pure_parser_works=no)
	if test "$pure_parser_works" = "yes"; then
	  break
	fi
      fi
    fi
  fi
done
pike_cv_prog_working_yacc="$YACC"
])

YACC="$pike_cv_prog_working_yacc"

if test "x$YACC" = "xNone" ; then
  AC_MSG_RESULT([Get bison if you want to do "make export"])
  YACC="bison -y"
else
  AC_MSG_RESULT($YACC)
fi

#############################################################################

AC_MSG_CHECKING(for the type of __yy_memcpy)
AC_CACHE_VAL(pike_cv___yy_memcpy_count_type, [
  pike_cv___yy_memcpy_from_const=
  pike_cv___yy_memcpy_count_type=unknown
  for count_type in "unsigned int" "size_t" "unsigned long" "int"; do
    for from_const in "const" ""; do
      cat >conftest.y <<EOF
%pure_parser
%{
#include <stdio.h>

#ifndef __GNUC__
#ifndef __cplusplus
static void __yy_memcpy(char *to, $from_const char *from, $count_type count);
#endif /* !__cplusplus */
#endif /* !__GNUC__ */

void yyerror(char *);
int yylex(void *);
%}
%%
all: foo bar
foo: 'f' 'o' 'o' { fprintf(stderr, "foo\\n"); } ;
bar: 'b' 'a' 'r' ;
%%
int yylex(void *yylval) { return 'f'; }
void yyerror(char *err) { fprintf(stderr, "ERR: %s\\n", err); }
EOF
      echo conftest.y: 1>&AC_FD_CC
      cat conftest.y 1>&AC_FD_CC
      if $YACC -d conftest.y 1>&AC_FD_CC 2>&AC_FD_CC; then
        AC_TRY_LINK([
#include "y.tab.c"
        ], [
  yyparse();
  exit(0);
        ], [
          pike_cv___yy_memcpy_count_type=$count_type
	  pike_cv___yy_memcpy_from_const="$from_const"
          break
        ])
      fi
    done
    if test "x$pike_cv___yy_memcpy_count_type" = "xunknown"; then :; else
      break
    fi
  done
])
if test "x$pike_cv___yy_memcpy_count_type" = "xunknown"; then
  AC_MSG_RESULT($pike_cv___yy_memcpy_count_type)
  AC_MSG_WARN([Defaulting to unsigned int.])
  YY_COUNT_TYPE="unsigned int"
  YY_FROM_CONST=""
else
  AC_MSG_RESULT(void __yy_memcpy(char *, $pike_cv___yy_memcpy_from_const char *, $pike_cv___yy_memcpy_count_type))
  YY_COUNT_TYPE="$pike_cv___yy_memcpy_count_type"
  YY_FROM_CONST="$pike_cv___yy_memcpy_from_const"
fi
AC_SUBST(YY_COUNT_TYPE)
AC_SUBST(YY_FROM_CONST)

#############################################################################

## At this point we have found all binaries we are going to use.

#############################################################################

AC_C_CONST

# The above doesn't find IBM C's buggy const.

if test "$ac_cv_c_const" = "yes"; then
  AC_MSG_CHECKING(if const really does work)
  AC_CACHE_VAL(pike_cv_c_really_const,[
    AC_TRY_COMPILE([
const int foo(int bar) { return bar; }
    ], [
      return bar(0);
    ], [
       pike_cv_c_really_const=yes
    ], [
       pike_cv_c_really_const=no
    ])
  ])

  AC_MSG_RESULT($pike_cv_c_really_const)
  if test "x$pike_cv_c_really_const" = xno ; then
    AC_DEFINE(const, [])
  else
    :
  fi
fi

AC_MSG_CHECKING([if restrict keyword is available (C99)])
AC_CACHE_VAL(pike_cv_keyword_restrict, [
  AC_TRY_COMPILE([
extern int foo(void *bar[restrict], void *restrict baz);
  ], [], [ pike_cv_keyword_restrict="yes" ], [ pike_cv_keyword_restrict="no" ])
])
AC_MSG_RESULT($pike_cv_keyword_restrict)
if test "x$pike_cv_keyword_restrict" = "xno"; then
  AC_DEFINE(restrict, [ /* Not supported */ ])
fi

AC_C_CHAR_UNSIGNED

AC_MSG_CHECKING(if we can cast void * to a function pointer)
AC_CACHE_VAL(pike_cv_function_cast, [
  AC_TRY_COMPILE([
    void *foo = 0;
  ],[
    void (*bar)(void) = (void (*)(void)) foo;
  ],[ pike_cv_function_cast="yes" ], [ pike_cv_function_cast="no" ])
])
if test "$pike_cv_function_cast" = "yes"; then
  AC_MSG_RESULT(yes)
else
  AC_MSG_RESULT(no)
  AC_DEFINE(NO_CAST_TO_FUN)
fi

#############################################################################

AC_HEADER_TIME
AC_HEADER_STDC
AC_CHECK_HEADERS(sys/rusage.h time.h sys/time.h sys/types.h unistd.h stdlib.h \
		 memory.h values.h string.h strings.h fcntl.h sys/filio.h \
		 sys/sockio.h crypt.h locale.h sys/select.h net/socket.h \
		 sys/mman.h setjmp.h sys/user.h limits.h pthread.h \
		 crt/signal.h sys/id.h mach-o/dyld.h sys/ptrace.h \
		 thread.h dlfcn.h dld.h dl.h sys/times.h sched.h \
		 sys/procfs.h sys/param.h winsock.h sys/ioct.h sys/socket.h \
		 malloc.h netinet/in.h sys/wait.h winbase.h grp.h pwd.h \
		 passwd.h group.h winsock2.h signal.h sys/file.h poll.h \
		 sys/poll.h socket.h ieeefp.h fp_class.h floatingpoint.h \
		 float.h sys/priocntl.h sys/sched.h windows.h errno.h \
		 stddef.h mmx.h asm/mmx.h sys/termio.h sys/termios.h \
		 ws2tcpip.h valgrind/memcheck.h memcheck.h valgrind.h \
		 sys/prctl.h sys/ioctl.h mach/task_info.h mach/task.h \
		 mach/mach_init.h syscall.h sys/syscall.h)

# Make it possible to disable use of /dev/poll.
if test "x$with_devpoll" = "xno"; then :; else
  AC_CHECK_HEADERS(sys/devpoll.h sys/event.h sys/epoll.h)

  AC_CHECK_FUNCS(kqueue)

  AC_MSG_CHECKING(for poll device)
  AC_CACHE_VAL(pike_cv_device_devpoll, [
    pike_cv_poll_device="no"
    for device in /dev/poll /dev/epoll; do
      if test -w "$device"; then
        pike_cv_poll_device="$device"
	break
      fi
    done
  ])
  AC_MSG_RESULT($pike_cv_poll_device)
  if test "x$pike_cv_poll_device" = "xno"; then :; else
    AC_DEFINE_UNQUOTED(PIKE_POLL_DEVICE, "$pike_cv_poll_device")
  fi
fi

# some Linux systems have a broken resource.h that compiles anyway /Mirar
AC_MSG_CHECKING([for sys/resource.h])
AC_CACHE_VAL(pike_cv_sys_resource_h, [
  AC_TRY_COMPILE([
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_TIME_H
#include <time.h>
#endif /* HAVE_TIME_H */
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif /* HAVE_SYS_TIME_H */

#include <sys/resource.h>

  ],[],
  [pike_cv_sys_resource_h=yes], [pike_cv_sys_resource_h=no])
])
if test "x$pike_cv_sys_resource_h" = "xyes"; then
  AC_MSG_RESULT(yes)
  AC_DEFINE(HAVE_SYS_RESOURCE_H)
else
  AC_MSG_RESULT(no)
fi

AC_CHECK_SIZEOF(char *,4)
AC_CHECK_SIZEOF(int, 4)
AC_CHECK_SIZEOF(short, 2)
AC_CHECK_SIZEOF(float, 4)
AC_CHECK_SIZEOF(double, 8)
AC_CHECK_SIZEOF(long double, 0)
AC_CHECK_SIZEOF(long, 4)
AC_CHECK_SIZEOF(long long, 0)
AC_CHECK_SIZEOF(__int64, 0)

AC_MY_CHECK_TYPE(size_t,unsigned long)
AC_MY_CHECK_TYPE(ptrdiff_t,long)
AC_MY_CHECK_TYPE(off_t,long)
AC_MY_CHECK_TYPE(pid_t,int)
AC_MY_CHECK_TYPE(uid_t,int)
AC_MY_CHECK_TYPE(gid_t,int)
AC_MY_CHECK_TYPE(time_t,INT32)
AC_MY_CHECK_TYPE(pri_t, short)

AC_CHECK_SIZEOF(off_t, 4)

AC_MSG_CHECKING(for sizeof anything)
if test "$ac_cv_sizeof_long_double" != 0 -a \
	"x$with_long_double_precision" = xyes ; then
  sizeof_float_type="$ac_cv_sizeof_long_double"
elif test "x$with_double_precision" = xyes ; then
  sizeof_float_type="$ac_cv_sizeof_double"
else
  sizeof_float_type="$ac_cv_sizeof_float"
fi

if test "$ac_cv_sizeof_long_long" != 0 -a \
	"x$with_long_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof_long_long"
elif test "$ac_cv_sizeof___int64" != 0 -a \
	"x$with_long_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof___int64"
elif test "x$with_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof_long"
elif test "x$with_short_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof_short"
elif test "x$with_unsigned_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof_long"
elif test "$ac_cv_sizeof_long_long" != 0 -a \
	  "x$with_unsigned_long_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof_long_long"
elif test "$ac_cv_sizeof___int64" != 0 -a \
	   "x$with_unsigned_long_long_int" = xyes ; then
  sizeof_int_type="$ac_cv_sizeof___int64"
else
  sizeof_int_type="$ac_cv_sizeof_int"
fi
sizeof_anything="$ac_cv_sizeof_char_p"
if test "$sizeof_float_type" -gt "$sizeof_anything"; then
  sizeof_anything="$sizeof_float_type"
fi
if test "$sizeof_int_type" -gt "$sizeof_anything"; then
  sizeof_anything="$sizeof_int_type"
fi
AC_MSG_RESULT($sizeof_anything)

AC_MSG_CHECKING(for FLOAT_TYPE)

if test "x$with_long_double_precision" = x -a \
	"x$with_double_precision" = x ; then
  # Choose the longest available float that fits in a pointer.
  if test "$ac_cv_sizeof_long_double" != 0 -a \
	  "$ac_cv_sizeof_long_double" -le "$sizeof_anything" ; then
    with_long_double_precision=yes
  elif test "$ac_cv_sizeof_double" -le "$sizeof_anything" ; then
    with_double_precision=yes
  fi
fi

if test "$ac_cv_sizeof_long_double" != 0 -a \
	"x$with_long_double_precision" = xyes ; then
  AC_MSG_RESULT(long double)
  AC_DEFINE(WITH_LONG_DOUBLE_PRECISION_SVALUE)
  AC_DEFINE(FLOAT_TYPE, long double)
  AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_LONG_DOUBLE)
  float_type="long double"
  sizeof_float_type="$ac_cv_sizeof_long_double"
elif test "x$with_double_precision" = xyes ; then
  AC_MSG_RESULT(double)
  AC_DEFINE(WITH_DOUBLE_PRECISION_SVALUE)
  AC_DEFINE(FLOAT_TYPE, double)
  AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_DOUBLE)
  float_type="double"
  sizeof_float_type="$ac_cv_sizeof_double"
else
  AC_MSG_RESULT(float)
  AC_DEFINE(FLOAT_TYPE, float)
  AC_DEFINE(SIZEOF_FLOAT_TYPE, SIZEOF_FLOAT)
  float_type="float"
  sizeof_float_type="$ac_cv_sizeof_float"
fi

AC_MSG_CHECKING(for INT_TYPE)

if test "x$with_long_long_int" = x -a \
	"x$with_long_int" = x -a \
	"x$with_int_int" = x -a \
	"x$with_short_int" = x ; then
  # Choose the longest available integer that fits in a pointer.
#  if test $ac_cv_sizeof_long_long != 0 -a \
#	   $ac_cv_sizeof_long_long -le $ac_cv_sizeof_char_p ; then
#    # This isn't a good idea on architectures where
#    # sizeof(long int) < sizeof(LONGEST).
#    # This is due to the gmp mpz api's using long int instead of
#    # mp_limb_{signed_}t.
#    #with_long_long_int=yes
#    :
#  fi
  if test "$ac_cv_sizeof_long" -le "$sizeof_anything" ; then
    with_long_int=yes
  else
    with_int_int=yes
  fi
  :
fi

if test "$ac_cv_sizeof_long_long" != 0 -a \
	"x$with_long_long_int" = xyes ; then
  AC_MSG_RESULT(long long)
  AC_DEFINE(WITH_LONG_LONG_INT)
  AC_DEFINE(INT_TYPE, long long)
  AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG_LONG)
  int_type="long long"
  sizeof_int_type="$ac_cv_sizeof_long_long"
elif test "$ac_cv_sizeof___int64" != 0 -a \
	  "x$with_long_long_int" = xyes ; then
  AC_MSG_RESULT(__int64)
  AC_DEFINE(WITH_LONG_LONG_INT)
  AC_DEFINE(INT_TYPE, __int64)
  AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF___INT64)
  int_type="__int64"
  sizeof_int_type="$ac_cv_sizeof___int64"
elif test "x$with_long_int" = xyes ; then
  AC_MSG_RESULT(long)
  AC_DEFINE(WITH_LONG_INT)
  AC_DEFINE(INT_TYPE, long)
  AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG)
  int_type="long"
  sizeof_int_type="$ac_cv_sizeof_long"
dnl elif test "x$with_short_int" = xyes ; then
dnl   AC_MSG_RESULT(short)
dnl   AC_DEFINE(WITH_SHORT_INT)
dnl   AC_DEFINE(INT_TYPE, short)
dnl   AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_SHORT)
dnl elif test "x$with_unsigned_long_int" = xyes ; then
dnl   AC_MSG_RESULT(unsigned long)
dnl   AC_DEFINE(WITH_UNSIGNED_LONG_INT)
dnl   AC_DEFINE(INT_TYPE, unsigned long)
dnl   AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG)
dnl elif test "$ac_cv_sizeof_long_long" != 0 -a \
dnl 	      "x$with_unsigned_long_long_int" = xyes ; then
dnl   AC_MSG_RESULT(unsigned long long)
dnl   AC_DEFINE(WITH_UNSIGNED_LONG_LONG_INT)
dnl   AC_DEFINE(INT_TYPE, unsigned long long)
dnl   AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_LONG_LONG)
dnl elif test "$ac_cv_sizeof___int64" != 0 -a \
dnl 	      "x$with_unsigned_long_long_int" = xyes ; then
dnl   AC_MSG_RESULT(unsigned __int64)
dnl   AC_DEFINE(WITH_UNSIGNED_LONG_LONG_INT)
dnl   AC_DEFINE(INT_TYPE, unsigned __int64)
dnl   AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF___INT64)
else
  AC_MSG_RESULT(int)
  AC_DEFINE(WITH_INT_INT)
  AC_DEFINE(INT_TYPE, int)
  AC_DEFINE(SIZEOF_INT_TYPE, SIZEOF_INT)
  int_type="int"
  sizeof_int_type="$ac_cv_sizeof_int"
fi

AC_TYPE_SIGNAL

dnl AC_CHECK_LIB(PW, alloca)

dnl Checking if poll() call is in libpoll (in general in Darwin or BSD/OS)
AC_CHECK_LIB(poll, poll)

AC_CHECK_LIB(m, floor)

AC_CHECK_LIB(socket, socket)

if test x"$pike_cv_sys_os" = xWindows_NT ; then
  AC_MSG_CHECKING(if we should use the 64 bit API)
  AC_CACHE_VAL(pike_cv_sys_win64, [
    AC_EGREP_CPP(oui, [
#if defined(_WIN64) || defined(__WIN64__)
  oui
#else
  no
#endif
    ], [ pike_cv_sys_win64=yes ], [ pike_cv_sys_win64=no ])
  ])
  if test "x$pike_cv_sys_win64" = "xyes"; then
    AC_MSG_RESULT(yes)
    # Apparently the libraries are stilled named *32...
    # LIBS="-lkernel64 -lws2_64 -ladvapi64 $LIBS"
    LIBS="-lshell32 -lkernel32 -lws2_32 -ladvapi32 $LIBS"
  else
    AC_MSG_RESULT(no)
    LIBS="-lshell32 -lkernel32 -lws2_32 -ladvapi32 $LIBS"
  fi
fi

AC_CHECK_LIB(nsl, gethostbyname)
AC_CHECK_LIB(rt, nanosleep)

AC_CHECK_LIB(dl, dlopen)
AC_CHECK_LIB(dld, shl_load)
AC_CHECK_LIB(dld, dld_link)


if test "${pike_cv_sys_os}" = "Linux"; then
  if test "${ac_cv_lib_m_floor}" = "no"; then
    AC_MSG_WARN(I will compensate for this by adding -lc -lm.)
    LIBS="${LIBS} -lc -lm"
  fi

  if test "$ac_cv_header_sched_h" = "yes"; then
    AC_MSG_CHECKING(if sched.h has a typo)
    AC_CACHE_VAL(pike_cv_broken_sched_h, [
      AC_TRY_COMPILE([
#include <sched.h>
      ],[ ],[ pike_cv_broken_shed_h=no ], [
        OLDCPPFLAGS="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS -D_P=__P"
	AC_TRY_COMPILE([
#include <sched.h>
        ],[ ],[ pike_cv_broken_sched_h=yes ],[
          pike_cv_broken_sched_h="very broken"
        ])
	CPPFLAGS="$OLDCPPFLAGS"
      ])
    ])
    AC_MSG_RESULT($pike_cv_broken_sched_h)
    if test "$pike_cv_broken_sched_h" = "yes"; then
      PIKE_MSG_WARN(Applying workaround for sched.h typo.)
      CPPFLAGS="$CPPFLAGS -D_P=__P"
    fi
  fi
fi

########################################################################

using_threads="no (forced)"

if test x$with_threads = xyes ; then
  using_threads="no (no known threads found)"
  OLDLIBS="$LIBS"
  OLDCFLAGS="$CFLAGS"

if test "x$pike_cv_sys_os" = "xWindows_NT" ; then
  # NT has threads...

  AC_DEFINE(_REENTRANT)
  AC_DEFINE(_THREAD_SAFE)
  AC_DEFINE(_UNIX_THREADS)
  AC_DEFINE(NT_THREADS)
  AC_DEFINE(PIKE_THREADS)
  using_threads="yes (nt)"

  pike_cv_thread_t_type=integer

else

  # Test for POSIX threads

  if test "x$with_thread_library" != "xno"; then
    AC_MSG_CHECKING([for thread library])
    AC_MSG_RESULT([$with_thread_library (--with-thread-library)])
    LIBS="${OLDLIBS} $with_thread_library"
  else
  case "x$pike_cv_sys_os" in
    xOSF1*)
#      LIBS="${OLDLIBS} -lpthread -lmach -lexc -lc"
      LIBS="${OLDLIBS} -lpthread -lmach -lexc"
    ;;
 
    xBSD/OS*)
      LIBS="${OLDLIBS}"
    ;;

    xUnixWare*|xOpenUNIX*)
      if test "$GCC" = yes ; then
        CFLAGS="${CFLAGS} -pthread"
      else
        CFLAGS="${CFLAGS} -Kthread"
      fi
    ;;

    xOpenBSD*)
      CFLAGS="${CFLAGS} -pthread"
      LDFLAGS="${LDFLAGS} -pthread"
    ;;

    xFreeBSD*)      
      # Threads on FreeBSD earlier than 1998-06-07 are broken.
      LIBS="${OLDLIBS}"
      AC_MSG_CHECKING(if this version of FreeBSD may have working threads)
      AC_CACHE_VAL(pike_cv_freebsd_threads, [
        AC_TRY_RUN([
#include <osreldate.h>

int main(int argc, char **argv)
{
  /* FreeBSD before 228000 and 300000 - 300005 have broken threads.
   */
  if (__FreeBSD_version < 228000)
    return(1);
  if (__FreeBSD_version < 300000)
    return(0);
  if (__FreeBSD_version < 300006)
    return(1);
  return(0);
}
        ], pike_cv_freebsd_threads=yes, pike_cv_freebsd_threads=no,
        pike_cv_freebsd_threads=yes)
      ])
      if test "x$pike_cv_freebsd_threads" = "xno"; then
        AC_MSG_RESULT(no)
      else
        AC_MSG_RESULT(yes)

        AC_PATH_PROG(PTHREAD_CONFIG,${ac_tool_prefix}pthread-config,no)
        if test "x$PTHREAD_CONFIG" = xno ; then
	  # FIXME: Might want to look at OS version:
	  #   500000 <= version < 500016: -pthread
	  #   500016 <= version < 502102: -lc_r
	  #   502102 <= version         : -lpthread
          AC_SYS_COMPILER_FLAG(-pthread, pthread, CFLAGS, LIBS="$LIBS -lc_r")
          LD_FALLBACK_FLAGS="${LD_FALLBACK_FLAGS-} -lc_r"
        else
          CFLAGS="$CFLAGS `${PTHREAD_CONFIG} --cflags`"
          LIBS="${OLDLIBS} `${PTHREAD_CONFIG} --libs`"
          LDFLAGS="$CFLAGS `${PTHREAD_CONFIG} --ldflags`"
        fi
      fi
    ;;

    xAIX*)
      if test "`uname -v`" -gt 4 ; then
        LIBS="${OLDLIBS} -lpthread"
      else
        LIBS="${OLDLIBS} -lpthreads -lc_r"
      fi
    ;;

    xSolaris*)
      # Some versions of Solaris 2.5.1 require linking with -lthread too.
      LIBS="${OLDLIBS} -lpthread -lthread"
    ;;

    xDarwin*)
      LIBS="${OLDLIBS}"
    ;;

    *)
      LIBS="${OLDLIBS} -lpthread"
    ;;
  esac
  fi

  AC_CHECK_FUNCS(pthread_init pthread_mutexattr_init pthread_kill)

  AC_MSG_CHECKING(posix threads)

  AC_CACHE_VAL(pike_cv_posix_threads, [
    AC_TRY_RUN([
#define _REENTRANT
#define _THREAD_SAFE
#define _MIT_POSIX_THREADS 1

#include <pthread.h>

void *foo(void *bar) { pthread_exit(0); return 0; }
pthread_mutexattr_t attr;
pthread_mutex_t tmp;
pthread_t gazonk;

int main()
{
  void *sune;
#ifdef HAVE_PTHREAD_INIT
  pthread_init();
#endif /* HAVE_PTHREAD_INIT */
#ifdef HAVE_PTHREAD_MUTEXATTR_INIT
  pthread_mutexattr_init(&attr);
#else
  memset(&attr, 0, sizeof(attr));
#endif /* HAVE_PTHREAD_MUTEXATTR_INIT */
  pthread_mutex_init(&tmp, &attr);
  pthread_mutex_lock(&tmp);
  pthread_create(&gazonk,0,foo,0);
  pthread_join(gazonk,&sune);
  exit(0);
}
    ], [ pike_cv_posix_threads=yes ], [ pike_cv_posix_threads=no ], [
      AC_TRY_LINK([
#define _REENTRANT
#define _THREAD_SAFE
#define _MIT_POSIX_THREADS 1

#include <pthread.h>

void *foo(void *bar) { pthread_exit(0); return 0; }
pthread_mutexattr_t attr;
pthread_mutex_t tmp;
pthread_t gazonk;

      ], [
{
  void *sune;
#ifdef HAVE_PTHREAD_INIT
  pthread_init();
#endif /* HAVE_PTHREAD_INIT */
#ifdef HAVE_PTHREAD_MUTEXATTR_INIT
  pthread_mutexattr_init(&attr);
#else
  memset(&attr, 0, sizeof(attr));
#endif /* HAVE_PTHREAD_MUTEXATTR_INIT */
  pthread_mutex_init(&tmp, &attr);
  pthread_mutex_lock(&tmp);
  pthread_create(&gazonk,0,foo,0);
  pthread_join(gazonk,&sune);
  exit(0);
}
      ], [ pike_cv_posix_threads=yes ], [ pike_cv_posix_threads=no ])
    ])
  ])

  if test $pike_cv_posix_threads = yes ; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(_REENTRANT)
    AC_DEFINE(_THREAD_SAFE)
    AC_DEFINE(_MIT_POSIX_THREADS,1)
    AC_DEFINE(PIKE_THREADS)
    using_threads="yes (posix)"

##########################################################################

    AC_MSG_CHECKING(for pthread_attr_setstacksize)
    AC_CACHE_VAL(pike_cv_have_pthread_attr_setstacksize,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(pthread_attr_t*x) { pthread_attr_setstacksize(x, 1024*1024); }
      ],[],[
        pike_cv_have_pthread_attr_setstacksize=yes
      ],[
        pike_cv_have_pthread_attr_setstacksize=no
      ])
    ])
    AC_MSG_RESULT($pike_cv_have_pthread_attr_setstacksize)
    if test x$pike_cv_have_pthread_attr_setstacksize = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE)
    else
      :
    fi

##########################################################################

    AC_MSG_CHECKING(for pthread_atfork)
    AC_CACHE_VAL(pike_cv_have_pthread_atfork,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(void) { pthread_atfork(0,0,0); }
      ],[],[
        pike_cv_have_pthread_atfork=yes
      ],[
        pike_cv_have_pthread_atfork=no
      ])
    ])
    if test x$pike_cv_have_pthread_atfork = xyes ; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(HAVE_PTHREAD_ATFORK)
    else
      AC_MSG_RESULT([no - FreeBSD?])
    fi

##########################################################################

    AC_MSG_CHECKING(for pthread_yield)
    AC_CACHE_VAL(pike_cv_have_pthread_yield,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(void) { pthread_yield(); }
      ],[],[
        pike_cv_have_pthread_yield=yes
      ],[
        pike_cv_have_pthread_yield=no
      ])
    ])
    AC_MSG_RESULT($pike_cv_have_pthread_yield)
    if test x$pike_cv_have_pthread_yield = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_YIELD)
    else
      :
    fi

##########################################################################

    AC_MSG_CHECKING(for pthread_yield_np)
    AC_CACHE_VAL(pike_cv_have_pthread_yield_np,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(void) { pthread_yield_np(); }
      ],[],[
        pike_cv_have_pthread_yield_np=yes
      ],[
        pike_cv_have_pthread_yield_np=no
      ])
    ])
    AC_MSG_RESULT($pike_cv_have_pthread_yield_np)
    if test x$pike_cv_have_pthread_yield_np = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_YIELD_NP)
    else
      :
    fi

##########################################################################

    AC_MSG_CHECKING(for pthread_cond_init)
    AC_CACHE_VAL(pike_cv_have_pthread_cond_init,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(pthread_cond_t*x, pthread_condattr_t*y) { pthread_cond_init(x,y); }
      ],[],[
        pike_cv_have_pthread_cond_init=yes
      ],[
        pike_cv_have_pthread_cond_init=no
      ])
    ])
    AC_MSG_RESULT($pike_cv_have_pthread_cond_init)
    if test x$pike_cv_have_pthread_cond_init = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_COND_INIT)
    else
      :
    fi

##########################################################################

    AC_MSG_CHECKING(if pthread_condattr_default is defined)
    AC_CACHE_VAL(pike_cv_have_pthread_condattr_default,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(pthread_cond_t *bar) { pthread_cond_init(bar, pthread_condattr_default); }
      ],[],[
        pike_cv_have_pthread_condattr_default=yes
      ],[
        pike_cv_have_pthread_condattr_default=no
      ])
    ])

    AC_MSG_RESULT($pike_cv_have_pthread_condattr_default)

    if test x$pike_cv_have_pthread_condattr_default = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT)
    else
      :
    fi


    #
    # FreeBSD doesn't like the &, while AIX requires it...
    #

    AC_MSG_CHECKING(if pthread_condattr_default is needs an & (AIX))
    AC_CACHE_VAL(pike_cv_have_pthread_condattr_default_aix,[
      AC_TRY_LINK([#include <pthread.h>
        void foo(pthread_cond_t *bar) { pthread_cond_init(bar, &pthread_condattr_default); }
      ],[],[
        pike_cv_have_pthread_condattr_default_aix=yes
      ],[
        pike_cv_have_pthread_condattr_default_aix=no
      ])
    ])

    AC_MSG_RESULT($pike_cv_have_pthread_condattr_default_aix)

    if test x$pike_cv_have_pthread_condattr_default_aix = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_CONDATTR_DEFAULT_AIX)
    else
      :
    fi

##########################################################################

    AC_MSG_CHECKING(for __pthread_initial_thread_bos)
    AC_CACHE_VAL(pike_cv_have_pthread_initial_thread_bos,[
      AC_TRY_LINK([#include <pthread.h>
        char *foo(void) { extern char *__pthread_initial_thread_bos; 
           return __pthread_initial_thread_bos; }
      ],[],[
        pike_cv_have_pthread_initial_thread_bos=yes
      ],[
        pike_cv_have_pthread_initial_thread_bos=no
      ])
    ])

    AC_MSG_RESULT($pike_cv_have_pthread_initial_thread_bos)

    if test x$pike_cv_have_pthread_initial_thread_bos = xyes ; then
      AC_DEFINE(HAVE_PTHREAD_INITIAL_THREAD_BOS)
    else
      :
    fi

##########################################################################

    # On Linux the threads don't inherit euid & egid from the main thread.
    # FIXME: Add a real test here!
    if test "x$pike_cv_sys_os" = "xLinux"; then
      AC_DEFINE(HAVE_BROKEN_LINUX_THREAD_EUID)
    else :; fi

    AC_MSG_CHECKING([behaviour of the pthread_t type])
    AC_CACHE_VAL(pike_cv_thread_t_type, [
      AC_TRY_COMPILE([
#include <sys/types.h>
#ifdef STDC_HEADERS
#include <stdlib.h>
#include <stddef.h>
#endif
#include <pthread.h>
extern pthread_t bar;
      ], [
	void *foo = (void *)(ptrdiff_t)bar;
	return 0;
      ], [ pike_cv_thread_t_type=integer ], [ pike_cv_thread_t_type=pointer ])
    ])
    AC_MSG_RESULT($pike_cv_thread_t_type)

  else
    AC_MSG_RESULT(no)
    LIBS="$OLDLIBS"
    CFLAGS="$OLDCFLAGS"

    # No POSIX threads.

    # Try UNIX threads instead

    AC_MSG_CHECKING(unix threads)
    case "x$pike_cv_sys_os" in
      xUnixWare*|xOpenUNIX*)
  	if test "$GCC" = yes ; then
  	  CFLAGS="${CFLAGS} -pthread"
  	else
  	  CFLAGS="${CFLAGS} -Kthread"
  	fi
  	CFLAGS="${CFLAGS} -D_UNIXWARE_THREADS_"
      ;;
      *)
  	LIBS="${LIBS} -lthread"
      ;;
    esac
  
    AC_CACHE_VAL(pike_cv_unix_threads, [
      AC_TRY_RUN([
#define _REENTRANT
#define _THREAD_SAFE
#define _MIT_POSIX_THREADS 1
#include <thread.h>
#ifdef _UNIXWARE_THREADS_
#include <synch.h>
#endif

void *foo(void *bar) { thr_exit(0); return 0; }
mutex_t tmp;
thread_t gazonk;

int main()
{
  void *sune;
  mutex_lock(& tmp);
  thr_create(0,0,foo,0,0,&gazonk);
  thr_join(gazonk,0,&sune);
  exit(0);
}
      ],pike_cv_unix_threads=yes,pike_cv_unix_threads=no,pike_cv_unix_threads=no)
    ])

    if test x$pike_cv_unix_threads = xyes ; then
      AC_MSG_RESULT(yes)
      AC_DEFINE(_REENTRANT)
      AC_DEFINE(_THREAD_SAFE)
      AC_DEFINE(_UNIX_THREADS)
      AC_DEFINE(PIKE_THREADS)
      using_threads="yes (unix)"
    else
      AC_MSG_RESULT(no)
      LIBS="$OLDLIBS"
      CFLAGS="$OLDCFLAGS"

      # Now we've sunk really low -- test for proprietary threads

      # SGI old-style shared group processes
      # AC_CHECK_FUNCS(sproc oserror)
      # 
      # AC_MSG_CHECKING(Fallback to sproc)
      # 
      # if test x$ac_cv_func_sproc$ac_cv_func_oserror = xyesyes; then
      #   AC_MSG_RESULT(yes)
      #   AC_DEFINE(_REENTRANT)
      #   AC_DEFINE(_THREAD_SAFE)
      #   AC_DEFINE(_SGI_SPROC_THREADS)
      #   AC_DEFINE(_SGI_MP_SOURCE)
      #   using_threads="yes (sgi)"
      # else
      #   AC_MSG_RESULT(no)
      #   :
      # fi
    fi # UNIX threads

    pike_cv_thread_t_type=integer
  fi # POSIX threads
fi  # NT
else
  # Without threads
  pike_cv_thread_t_type=integer
  :
fi

if test "x$pike_cv_thread_t_type" = "xpointer"; then
  AC_DEFINE(PIKE_THREAD_T_IS_POINTER)
fi

if test "x$pike_cv_sys_os" = "xWindows_NT" ; then :; else
  AC_MSG_CHECKING(Initial stack limit)
  AC_CACHE_VAL(pike_cv_initial_stack_size,[
    AC_TRY_RUN([
#include <stdio.h>

      static int depth=0;
      FILE *f;

      void save_depth(void);

      void use_stack(void *page)
      {
        void *X[8190];
        X[0]=page;
        save_depth();
        use_stack(&X);
      }

      void save_depth(void)
      {
        depth+=sizeof(void *)*8192;
        fprintf(f,"%d\n",depth);
        fflush(f);
        if(depth>0x80000000) exit(0);
      }

      int main(int argc)
      {
        f=fopen("confdefs.out.2", "w");
	/* weird filename to circumvent configure weirdness */
        save_depth();
        use_stack(0);
      }
    ], [pike_cv_initial_stack_size=''], [
      while read x; do
        pike_cv_initial_stack_size=$x ;
      done <confdefs.out.2
    ])
    rm confdefs.out.2 >/dev/null 2>/dev/null || :
  ])
  if test x$pike_cv_initial_stack_size = x ; then
    AC_MSG_RESULT(unlimited)
  else
    AC_MSG_RESULT($pike_cv_initial_stack_size)
    AC_DEFINE_UNQUOTED(Pike_INITIAL_STACK_SIZE,$pike_cv_initial_stack_size)
  fi
fi

########################################################################

PIKE_CHECK_CONSTANTS(mutex error check flag,
                     PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_ERRORCHECK_NP, [
#ifdef HAVE_PTHREAD_H
#include <pthread.h>
#elif defined (HAVE_THREAD_H)
#include <thread.h>
#endif
                     ], PIKE_MUTEX_ERRORCHECK)

########################################################################

PIKE_CHECK_CONSTANTS(recursive mutex flag,
                     PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP, [
#ifdef HAVE_PTHREAD_H
#include <pthread.h>
#elif defined (HAVE_THREAD_H)
#include <thread.h>
#endif
                     ], PIKE_MUTEX_RECURSIVE)

########################################################################

# NOTE: The following test is hardcoded to fail when crosscompiling
# It also clobbers $LIBOBJS.

ifdef([m4_pattern_allow], [
  # Handle the latest autoconf incompatibility...
  m4_pattern_allow(LIBOBJS)
])
OLD_LIBOBJS="${LIBOBJS}"

AC_FUNC_MEMCMP

if test "x$ac_cv_func_memcmp_clean" = "xyes"; then
  AC_DEFINE(HAVE_MEMCMP)
fi

LIBOBJS="${OLD_LIBOBJS}"

########################################################################

AC_FUNC_MMAP

AC_CHECK_FUNCS( \
 _alldiv \
 _aullshr \
 _crypt \
 poll \
 bcopy \
 bzero \
 clock \
 crypt \
 fchmod \
 gethrtime \
 gethrvtime \
 getenv \
 getrlimit \
 getrusage \
 gettimeofday \
 index \
 localtime \
 gmtime \
 memchr \
 mktime \
 perror \
 ptrace \
 rindex \
 setbuf \
 setlocale \
 setrlimit \
 setresuid \
 setvbuf \
 sigaction \
 sigblock \
 sigprocmask \
 sigvec \
 strcasecmp \
 strnlen \
 strncmp \
 strchr \
 strcspn \
 strerror \
 strrchr \
 strtod \
 strtok \
 strtol \
 time \
 times \
 tzset \
 vfprintf \
 vsprintf \
 snprintf \
 vsnprintf \
 wait3 \
 wait4 \
 waitpid \
 munmap \
 shl_load \
 dld_link \
 dld_get_func \
 pipe \
 strdup \
 strstr \
 kill \
 alarm \
 fork1 \
 flock \
 lockf \
 setuid getuid seteuid geteuid \
 setgid getgid setegid getegid \
 getpwent getpwnam getpwuid \
 getgrent getgrnam \
 setsid setpgrp getpgrp setpgid getpgid \
 initgroups setgroups \
 socketpair \
 fpclass \
 fp_class_d \
 isinf \
 isnan \
 iszero \
 finite \
 signbit \
 nan \
 nice \
 __priocntl \
 sched_setscheduler \
 setpriority \
 usleep \
 nanosleep \
 thr_yield \
 prctl \
)

# SunOS 4 realloc() returns NULL when reallocing NULL.
AC_MSG_CHECKING([if realloc(NULL, SZ) works])
AC_CACHE_VAL(pike_cv_realloc_null_works, [
  AC_TRY_RUN([
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
  void *foo = realloc(NULL, 16);

  return !foo;
}
  ], [ pike_cv_realloc_null_works=yes
  ], [ pike_cv_realloc_null_works=no
  ], [ pike_cv_realloc_null_works=no
  ])
])
if test "x$pike_cv_realloc_null_works" = "xyes"; then
  AC_MSG_RESULT(yes)
  AC_DEFINE(HAVE_WORKING_REALLOC_NULL)
else
  AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(for the type of the last argument to accept)
AC_CACHE_VAL(pike_cv_accept_size_t, [
  for t in socklen_t size_t int; do
    AC_TRY_COMPILE([
#ifndef _LARGEFILE_SOURCE
#  define _FILE_OFFSET_BITS 64
#  define _LARGEFILE_SOURCE
#  define _LARGEFILE64_SOURCE 1
#endif
/* HPUX needs these too... */
#ifndef __STDC_EXT__
#  define __STDC_EXT__
#endif /* !__STDC_EXT__ */

#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

/* NT */
#ifdef HAVE_WINSOCK2_H
#include <WinSock2.h>
#ifdef HAVE_WS2TCPIP_H
/* Needed for IPv6 support. */
#include <WS2tcpip.h>
#endif
#elif defined(HAVE_WINSOCK_H)
#include <winsock.h>
#endif

/* Here is the actual test: */
int accept(int, struct sockaddr *, $t *);
    ], [
      /* EMPTY */
    ], [
      pike_cv_accept_size_t=$t
      break
    ], [
      AC_TRY_COMPILE([
#ifndef _LARGEFILE_SOURCE
#  define _FILE_OFFSET_BITS 64
#  define _LARGEFILE_SOURCE
#  define _LARGEFILE64_SOURCE 1
#endif
/* HPUX needs these too... */
#ifndef __STDC_EXT__
#  define __STDC_EXT__
#endif /* !__STDC_EXT__ */

#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

/* NT */
#ifdef HAVE_WINSOCK2_H
#include <WinSock2.h>
#ifdef HAVE_WS2TCPIP_H
/* Needed for IPv6 support. */
#include <WS2tcpip.h>
#endif
#elif defined(HAVE_WINSOCK_H)
#include <winsock.h>
#endif

/* Here is the actual test: */
SOCKET accept(SOCKET, struct sockaddr *, $t *);
      ], [
        /* EMPTY */
      ], [
	pike_cv_accept_size_t=$t
	break
      ], [])
    ])
  done
  if test "x$pike_cv_accept_size_t" = "x"; then
    # Check if it could be a Psocklen_t
    # Psocklen_t is a stupid typedef of socklen_t *.
    AC_TRY_COMPILE([
#ifndef _LARGEFILE_SOURCE
#  define _FILE_OFFSET_BITS 64
#  define _LARGEFILE_SOURCE
#  define _LARGEFILE64_SOURCE 1
#endif
/* HPUX needs these too... */
#ifndef __STDC_EXT__
#  define __STDC_EXT__
#endif /* !__STDC_EXT__ */

#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

/* NT */
#ifdef HAVE_WINSOCK2_H
#include <WinSock2.h>
#ifdef HAVE_WS2TCPIP_H
/* Needed for IPv6 support. */
#include <WS2tcpip.h>
#endif
#elif defined(HAVE_WINSOCK_H)
#include <winsock.h>
#endif

/* Here is the actual test: */
int accept(int, struct sockaddr *, Psocklen_t);
    ], [
      /* EMPTY */
    ], [
      pike_cv_accept_size_t=socklen_t
    ], [
      # FIXME: Should probably have a warning here.
      # FIXME: Should we check if socklen_t exists, and use that?
      pike_cv_accept_size_t=int
    ])
  fi
])
AC_MSG_RESULT($pike_cv_accept_size_t *)
AC_DEFINE_UNQUOTED(ACCEPT_SIZE_T, $pike_cv_accept_size_t)

if test x"$pike_cv_sys_os" = xWindows_NT ; then
 AC_DEFINE(HAVE_LOADLIBRARY)
 AC_DEFINE(HAVE_FREELIBRARY)
 AC_DEFINE(HAVE_GETPROCADDRESS)
 AC_DEFINE(DL_EXPORT, _dlspec(export))
else
 AC_DEFINE(DL_EXPORT, [])
fi

if test $ac_cv_func_crypt$ac_cv_func__crypt = nono ; then
  AC_CHECK_LIB(crypt,crypt,[LIBS="${LIBS} -lcrypt" ; AC_DEFINE(HAVE_CRYPT)],
[
  if test -f "$srcdir/crypt.c"; then
    AC_MSG_RESULT(Using crypt.c for BSD style crypt())
    EXTRA_OBJS="${EXTRA_OBJS} crypt.o"
    AC_DEFINE(HAVE_CRYPT)
    AC_DEFINE(USE_CRYPT_C)
  else
    :
  fi
])

fi


#############################################################################
MY_CHECK_FUNCTION(infnan,
[
#include <errno.h>
#include <math.h>
], [
  double pinf = infnan(ERANGE);
  double ninf = infnan(-ERANGE);
  double nan = infnan(EDOM);
  exit(!(isinf(pinf)>0 && isinf(ninf)<0 && isnan(nan)));
])
#############################################################################
MY_CHECK_FUNCTION(_isnan,
[
#include <float.h>
], [
  exit(_isnan(0.0));
])
#############################################################################

# FreeBSD 3.0 has broken F_SETFD when running with threads.

AC_MSG_CHECKING(whether F_SETFD exists and works)

AC_CACHE_VAL(pike_cv_broken_f_setfd, [
  AC_TRY_RUN([
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#include <sys/stat.h>
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif /* HAVE_FCNTL_H */
#include <stdio.h>
#ifndef FD_CLOEXEC
#define FD_CLOEXEC 1
#endif /* FD_CLOEXEC */
int main(int argc, char **argv)
{
  int fd = 0;
  if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) {
    exit(1);
  }
  if (fcntl(fd, F_GETFD) != FD_CLOEXEC) {
    exit(1);
  }
  exit(0);
}
], pike_cv_broken_f_setfd=no, pike_cv_broken_f_setfd=yes,
   pike_cv_broken_f_setfd=yes)
])

if test "x$pike_cv_broken_f_setfd" = "xyes"; then
  AC_MSG_RESULT(no)
  AC_DEFINE(HAVE_BROKEN_F_SETFD)
else
  AC_MSG_RESULT(yes)
fi

#############################################################################

AC_STRUCT_TM

#############################################################################

AC_MSG_CHECKING(extern int timezone)

AC_CACHE_VAL(pike_cv_has_external_timezone,[
AC_TRY_LINK([
#include <time.h>
],[
  int _tz;
  _tz=timezone;
  timezone=_tz;
],pike_cv_has_external_timezone=yes,pike_cv_has_external_timezone=no)
])

if test "$pike_cv_has_external_timezone" = "yes"; then
  AC_DEFINE(HAVE_EXTERNAL_TIMEZONE)
fi

AC_MSG_RESULT($pike_cv_has_external_timezone)

#############################################################################

# No test for this yet...
AC_DEFINE(HAVE_STRUCT_TIMEVAL)

#############################################################################

AC_MSG_CHECKING(struct sockaddr_in6)

AC_CACHE_VAL(pike_cv_has_struct_sockaddr_in6,[
AC_TRY_LINK([
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif /* HAVE_SYS_SOCKET_H */
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif /* HAVE_NETINET_IN_H */
#ifdef HAVE_WINSOCK2_H
#include <WinSock2.h>
#ifdef HAVE_WS2TCPIP_H
#include <WS2tcpip.h>
#endif
#elif defined(HAVE_WINSOCK_H)
#include <winsock.h>
#endif
],[
  struct sockaddr_in6 foo;
],pike_cv_has_struct_sockaddr_in6=yes,pike_cv_has_struct_sockaddr_in6=no)
])

if test "$pike_cv_has_struct_sockaddr_in6" = "yes"; then
  AC_DEFINE(HAVE_STRUCT_SOCKADDR_IN6)
fi

AC_MSG_RESULT($pike_cv_has_struct_sockaddr_in6)

#############################################################################

if test "x$ac_cv_func_strtol" = "xyes"; then
  AC_MSG_CHECKING(if strtol works for large hexadecimal constants)
  AC_CACHE_VAL(pike_cv_func_strtol_works, [
    AC_TRY_RUN([
#include <stdlib.h>
int main(int argc, char **argv)
{
  /* On some OS:s strtol() rounds this to 0x7fffffff. */
  return(strtol("0xffffffff", NULL, 0) != 0xffffffff);
}
    ], pike_cv_func_strtol_works=yes,
       pike_cv_func_strtol_works=no,
       pike_cv_func_strtol_works=no)
  ])
  AC_MSG_RESULT($pike_cv_func_strtol_works)
  if test "x$pike_cv_func_strtol_works" = "xyes"; then
    AC_DEFINE(HAVE_WORKING_STRTOL)
  else :; fi
else :; fi

#############################################################################

AC_MSG_CHECKING(if gettimeofday takes two arguments)
AC_CACHE_VAL(pike_cv_func_gettimeofday_has_two_args,
[
  AC_TRY_RUN([
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  if HAVE_TIME_H
#   include <time.h>
#  endif
# endif
#endif

#ifndef HAVE_STRUCT_TIMEVAL
struct timeval
{
  long tv_sec;
  long tv_usec;
};
#endif

int main() {
  struct timeval tv;
  gettimeofday(&tv,(void *)0);
  exit(0);
}
  ], [ pike_cv_func_gettimeofday_has_two_args=yes
  ], [ pike_cv_func_gettimeofday_has_two_args=no
  ], [
    AC_TRY_LINK([
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  if HAVE_TIME_H
#   include <time.h>
#  endif
# endif
#endif

#ifndef HAVE_STRUCT_TIMEVAL
struct timeval
{
  long tv_sec;
  long tv_usec;
};
#endif
    ], [
{
  struct timeval tv;
  gettimeofday(&tv,(void *)0);
  exit(0);
}
    ], [ pike_cv_func_gettimeofday_has_two_args=yes ], [pike_cv_func_gettimeofday_has_two_args=no])
  ])
])

if test $pike_cv_func_gettimeofday_has_two_args = yes; then
  AC_DEFINE(GETTIMEOFDAY_TAKES_TWO_ARGS)
fi

AC_MSG_RESULT($pike_cv_func_gettimeofday_has_two_args)

if test "x$ac_cv_func_gethrvtime" = xyes; then
  AC_MSG_CHECKING(if gethrvtime really works)
  AC_CACHE_VAL(pike_cv_func_gethrvtime_works, [
    AC_TRY_RUN([
#define CONFIGURE_TEST

#include "port.c"

int main()
{
  time_t start = TIME (0), now;
  hrtime_t vt = gethrvtime(), next_vt;
  if (start == (time_t) -1) return 1; /* Normal time doesn't work. */
  do { /* Take some cpu time. */
    now = TIME (0);
    next_vt = gethrvtime();
    if (next_vt < vt) return 2; /* Shouldn't go backward. */
    vt = next_vt;
  } while (now != (time_t) -1 && now <= start + 1);
  if (now == (time_t) -1) return 3; /* Normal time does not work. */
  if (vt <= 0) return 4; /* Should have accounted for some cpu time. */
  return 0;
}
    ], pike_cv_func_gethrvtime_works=yes,
       pike_cv_func_gethrvtime_works=no,
       pike_cv_func_gethrvtime_works=no)
  ])
  AC_MSG_RESULT($pike_cv_func_gethrvtime_works)
  if test "x$pike_cv_func_gethrvtime_works" = xyes; then
    AC_DEFINE(HAVE_WORKING_GETHRVTIME)
  fi
fi

#   if test "x$ac_cv_func_gethrtime" != "xyes"; then
#     AC_MSG_CHECKING(if we can make gethrtime by the RDTSC instruction)
#     AC_CACHE_VAL(pike_cv_own_gethrtime_rdtsc, [
#   	 AC_TRY_RUN([
#   #include <unistd.h>
#   #include <stdio.h>
#   #include <sys/time.h>
#   
#   static long long hrtime_rtsc_zero;
#   static long long hrtime_rtsc_last;
#   static long long hrtime_max;
#   static struct timeval hrtime_timeval_zero;
#   static long double hrtime_conv=0.0;
#   
#   #define GETTIMEOFDAY(PTR) gettimeofday(PTR,NULL)
#   
#   #define RTSC(x)   							\
#      __asm__ __volatile__ (  "rdtsc"                			\
#   			       :"=a" (((unsigned long*)&x)[0]), 		\
#   			       "=d" (((unsigned long*)&x)[1]))
#   
#   void own_gethrtime_init()
#   {
#      GETTIMEOFDAY(&hrtime_timeval_zero);
#      RTSC(hrtime_rtsc_zero);
#      hrtime_rtsc_last=hrtime_rtsc_zero;
#      hrtime_max=0;
#   }
#   
#   int own_gethrtime_update(struct timeval *ptr)
#   {
#      long long td,t,now;
#      GETTIMEOFDAY(ptr);
#      RTSC(now);
#      td=((long long)ptr->tv_sec-hrtime_timeval_zero.tv_sec)*1000000000+
#   	  ((long long)ptr->tv_usec-hrtime_timeval_zero.tv_usec)*1000;
#   
#      hrtime_rtsc_last=now;
#      t=now-hrtime_rtsc_zero;
#      if (t) hrtime_conv=((long double)td)/t;
#   
#      return 1;
#   }
#   
#   /* this is very sensitive to the compiler; keep all crap */
#   
#   long long gethrtime()
#   {
#      long long now;
#      struct timeval tv;
#   
#      if (hrtime_conv==0.0) 
#      {
#   	  if (!own_gethrtime_update(&tv))  /* not calibrated yet */
#   	  {
#   	     return
#   		hrtime_max=
#   		((long long)tv.tv_sec-hrtime_timeval_zero.tv_sec)*1000000000+
#   		((long long)tv.tv_usec-hrtime_timeval_zero.tv_usec)*1000;
#   	  }
#      }
#   
#      RTSC(now);
#   
#      if (now-hrtime_rtsc_last > 2000000000) 
#      {
#   	  own_gethrtime_update(&tv);
#   	  return gethrtime();
#      }
#   
#      now = (long long) ( (long double)(now-hrtime_rtsc_zero) * hrtime_conv );
#   
#      if (now<hrtime_max) now=hrtime_max;
#      return hrtime_max=now;
#   }
#   
#   #include <stdio.h>
#   
#   int main()
#   {
#      struct timeval tv1,tv2;
#      long long td,t1,t2;
#      own_gethrtime_init();
#   
#      usleep(10);
#      own_gethrtime_update(&tv2);
#   
#      t1=gethrtime();
#      
#      gettimeofday(&tv1,NULL);
#      for (;;) /* busy loop */
#      {
#   	  GETTIMEOFDAY(&tv2);
#   	  td=((long long)tv2.tv_sec-tv1.tv_sec)*1000000000+
#   	     ((long long)tv2.tv_usec-tv1.tv_usec)*1000;
#   	  if (td>1000000) break;
#      }
#      t2=gethrtime();
#   
#   /*   printf("t2-t1=%lld\n",t2-t1);  */
#   
#      if (t2==hrtime_rtsc_zero ||
#   	   t2-t1>1100000 ||
#   	   t2-t1<900000) return 1;
#   
#      return 0;
#   }], pike_cv_own_gethrtime_rdtsc=yes,
#   	    pike_cv_own_gethrtime_rdtsc=no, pike_cv_own_gethrtime_rdtsc=no)
#   	    ])
#     if test "x$pike_cv_own_gethrtime_rdtsc" = "xyes"; then
#   	AC_MSG_RESULT(yes)
#   	AC_DEFINE(OWN_GETHRTIME)
#   	AC_DEFINE(OWN_GETHRTIME_RDTSC)
#   	AC_DEFINE(HAVE_GETHRTIME)
#     else 
#   	AC_MSG_RESULT([no])
#     fi
#   fi
#   
AC_MSG_CHECKING(if struct tm has tm_gmtoff)

AC_CACHE_VAL(pike_cv_struct_tm_has_gmtoff,[
AC_TRY_COMPILE([
#ifdef TM_IN_SYS_TIME
#include <sys/time.h>
#else
#include <time.h>
#endif
],[
  int _tz;
  struct tm foo;
  _tz=foo.tm_gmtoff;
],pike_cv_struct_tm_has_gmtoff=yes,pike_cv_struct_tm_has_gmtoff=no)
])

if test "$pike_cv_struct_tm_has_gmtoff" = "yes"; then
  AC_DEFINE(STRUCT_TM_HAS_GMTOFF)
fi

AC_MSG_RESULT($pike_cv_struct_tm_has_gmtoff)

AC_MSG_CHECKING(if struct tm has __tm_gmtoff)

AC_CACHE_VAL(pike_cv_struct_tm_has___tm_gmtoff,[
AC_TRY_COMPILE([
#ifdef TM_IN_SYS_TIME
#include <sys/time.h>
#else
#include <time.h>
#endif
],[
  int _tz;
  struct tm foo;
  _tz=foo.__tm_gmtoff;
],pike_cv_struct_tm_has___tm_gmtoff=yes,pike_cv_struct_tm_has___tm_gmtoff=no)
])

if test "$pike_cv_struct_tm_has___tm_gmtoff" = "yes"; then
  AC_DEFINE(STRUCT_TM_HAS___TM_GMTOFF)
fi

AC_MSG_RESULT($pike_cv_struct_tm_has___tm_gmtoff)

AC_MSG_CHECKING(for USHRT_MAX definition)

AC_CACHE_VAL(pike_cv_ushrt_max_is_defined,[
AC_EGREP_CPP(oui,[
#include <limits.h>
#ifdef USHRT_MAX
oui
#endif
],pike_cv_ushrt_max_is_defined=yes,pike_cv_ushrt_max_is_defined=no)
])

if test "$pike_cv_ushrt_max_is_defined" = "no" ; then
  AC_DEFINE(USHRT_MAX,65535)
fi

AC_MSG_RESULT($pike_cv_ushrt_max_is_defined)

define(MY_CHECK_HEADERS,
[
 AC_MSG_CHECKING(for $1 declaration)
 AC_CACHE_VAL(pike_cv_decl_$1,
 [
   OLD_CPPFLAGS="$CPPFLAGS"
   pike_cv_decl_$1=nonexistent
   for a in $2
   do
     AC_EGREP_HEADER($1,$a,[ pike_cv_decl_$1=existent; break ])
     
     # Kludge for MacOS X. Retry with the traditional cpp...
     CPPFLAGS="$CPPFLAGS -traditional-cpp"
     AC_EGREP_HEADER($1,$a,[ pike_cv_decl_$1=existent; break ])
     CPPFLAGS="$OLD_CPPFLAGS"
   done
   CPPFLAGS="$OLD_CPPFLAGS"
 ])
 AC_MSG_RESULT($pike_cv_decl_$1)
 if test "$pike_cv_decl_$1" = nonexistent -o "$pike_cv_decl_$1" = nonexistant; then
   AC_DEFINE(translit($1,[a-z],[A-Z])[]_DECL_MISSING)
 fi
])

MY_CHECK_HEADERS(strchr,string.h unistd.h stdlib.h)
MY_CHECK_HEADERS(malloc,memory.h unistd.h stdlib.h)
MY_CHECK_HEADERS(getpeername,sys/socket.h sys/socketvar.h sys/socketio.h winsock.h winsock2.h ws2tcpip.h)
MY_CHECK_HEADERS(popen,stdio.h unistd.h)
MY_CHECK_HEADERS(getenv,unistd.h stdlib.h)
MY_CHECK_HEADERS(gethostname,unistd.h netdb.h winsock.h winsock2.h ws2tcpip.h)

AC_ALLOCA

AC_C_CONST
AC_C_INLINE

AC_CHECK_FUNCS(ualarm setitimer)

if test "x$ac_cv_func_ualarm" = "xyes"; then
  AC_MSG_CHECKING(no of arguments to ualarm)
  AC_CACHE_VAL(pike_cv_ualarm_takes_two_args,
  [
    AC_TRY_COMPILE([
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
    ],[
      ualarm(0,0);
    ],pike_cv_ualarm_takes_two_args=yes,pike_cv_ualarm_takes_two_args=no)
  ])
  if test "$pike_cv_ualarm_takes_two_args" = yes; then
    AC_MSG_RESULT(2)
    AC_DEFINE(UALARM_TAKES_TWO_ARGS)
  else
    AC_MSG_RESULT(1)
  fi
fi

if test "x$ac_cv_func_ptrace" = "xyes"; then
  AC_MSG_CHECKING(no of arguments to ptrace)
  AC_CACHE_VAL(pike_cv_ptrace_takes_four_args,
  [
    AC_TRY_COMPILE([
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_SYS_PTRACE_H
#include <sys/ptrace.h>
#endif /* HAVE_SYS_PTRACE_H */
    ],[
      ptrace(0,0,0,0);
    ],pike_cv_ptrace_takes_four_args=yes,pike_cv_ptrace_takes_four_args=no)
  ])
  if test "$pike_cv_ptrace_takes_four_args" = yes; then
    AC_MSG_RESULT(4)
    AC_DEFINE(PTRACE_TAKES_FOUR_ARGS)
  else
    AC_MSG_RESULT(5)
  fi
  AC_MSG_CHECKING([type of argument 3 (addr) to ptrace])
  AC_CACHE_VAL(pike_cv_ptrace_addr_type, [
    AC_TRY_COMPILE([
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_SYS_PTRACE_H
#include <sys/ptrace.h>
#endif /* HAVE_SYS_PTRACE_H */
    ],[
#ifdef PTRACE_TAKES_FOUR_ARGS
      ptrace(0,0,(void *)0,0);
#else
      ptrace(0,0,(void *)0,0,0);
#endif
    ],pike_cv_ptrace_addr_type=pointer,pike_cv_ptrace_addr_type=integer)
  ])
  if test "$pike_cv_ptrace_addr_type" = pointer; then
    AC_MSG_RESULT(pointer)
    AC_DEFINE(PTRACE_ADDR_TYPE_IS_POINTER)
  else
    AC_MSG_RESULT([integer (SVID)])
  fi
fi



########################################################################
AC_MSG_CHECKING(stack direction)
AC_CACHE_VAL(pike_cv_hardware_stack_direction,
[
  AC_TRY_RUN([
#include <stdio.h>
static int find_stack_direction(void *foo)
{
  if (((void *)&foo) > foo) {
    return 1;
  } else {
    return -1;
  }
}

int main() { void *bar; exit( find_stack_direction(&bar) > 0); }
  ], [ pike_cv_hardware_stack_direction=down
  ], [ pike_cv_hardware_stack_direction=up
  ], [
    AC_MSG_WARN([Defaulting to down.])
    pike_cv_hardware_stack_direction=down
  ])
])

AC_MSG_RESULT($pike_cv_hardware_stack_direction)

if grep STACK_DIRECTION confdefs.h >/dev/null 2>&1; then
  :
else
  if test "x$pike_cv_hardware_stack_direction" = "xup" ; then
    AC_DEFINE(STACK_DIRECTION, 1)
  else
    AC_DEFINE(STACK_DIRECTION, -1)
  fi
fi

########################################################################

AC_MSG_CHECKING(byteorder)
AC_CACHE_VAL(pike_cv_hardware_byteorder,
[
if test "x$enable_binary" = "xno"; then
  pike_cv_hardware_byteorder=0
else
AC_TRY_RUN([
#include <stdio.h>

int main()
{
#if SIZEOF_INT == 4
#define T int
#else
#define T long
#endif
  FILE *f;
  T a;
  int e;
  for(e=0;e<sizeof(T);e++)
    ((char *)&a)[e]=(e+1) % 10;

  f=fopen("conftest.out.2","w");
  for(e=0;e<sizeof(T);e++)
  {
    fprintf(f,"%d",(int)(a & 255));
    a>>=8;
  }
  fprintf(f,"\n");
  fclose(f);
  
  return 0;
}],
pike_cv_hardware_byteorder=`cat conftest.out.2`
,
pike_cv_hardware_byteorder=0
,
pike_cv_hardware_byteorder=0
)
fi
])

AC_MSG_RESULT($pike_cv_hardware_byteorder)
AC_DEFINE_UNQUOTED(PIKE_BYTEORDER,$pike_cv_hardware_byteorder)

########################################################################

AC_MSG_CHECKING(pointer alignment)
AC_CACHE_VAL(pike_cv_hardware_alignment,
[
if test "x$enable_binary" = "xno"; then
  pike_cv_hardware_alignment=4
else
AC_TRY_RUN([
#include <stdio.h>

struct x { char a; void *b; };

struct y { void *a; char b; };

int main(int argc, char *argv[])
{
  FILE *f;
  int align = (int)&(((struct x *)0)->b);
  if (align > sizeof(struct y)-sizeof(void *))
    align = sizeof(struct y) - sizeof(void *);

  if(!(f=fopen("conftest.out.2","w")))
    return 1;

  fprintf(f, "%d\n", align);
  fclose(f);
  return 0;
}],
pike_cv_hardware_alignment=`cat conftest.out.2`,
pike_cv_hardware_alignment=4,
pike_cv_hardware_alignment=4
)
fi
])

AC_MSG_RESULT($pike_cv_hardware_alignment)
AC_DEFINE_UNQUOTED(PIKE_POINTER_ALIGNMENT,$pike_cv_hardware_alignment)

#############################################################################

## Check if we should default to --with-machine-code

#############################################################################

if test "$with_machine_code" = "no"; then :; else

  AC_MSG_CHECKING(machine code architecture)
  AC_CACHE_VAL(pike_cv_machine_code_arch, [
    pike_cv_machine_code_arch=unknown
    AC_TRY_COMPILE([
#if defined(__GNUC__)
#if !defined(__i386__) && !defined(__i386)
#error Not ia32 architecture
#endif
#elif defined(_MSC_VER)
#if !defined(_M_IX86)
#error Not ia32 architecture
#endif
#else
#error Unsupported compiler
#endif
    ], [], [pike_cv_machine_code_arch=ia32], [])
    AC_TRY_COMPILE([
#if defined(__GNUC__)
#if !defined(sparc) && !defined(__sparc__) && !defined(__sparc)
#error Not sparc architecture
#endif
#else
#error Unsupported compiler
#endif
    ], [], [pike_cv_machine_code_arch=sparc], [])
    AC_TRY_COMPILE([
#if defined(__GNUC__)
#if !defined(__ppc__) && !defined(__powerpc__) && !defined(_POWER)
#error Not ppc32 architecture
#endif
#else
#error Unsupported compiler
#endif
    ], [], [pike_cv_machine_code_arch=ppc32], [])
  ])
  AC_MSG_RESULT($pike_cv_machine_code_arch)
  if test "x$pike_cv_machine_code_arch" = xunknown ; then
    with_machine_code="no"
  else
    with_machine_code="yes"
    AC_DEFINE(PIKE_USE_MACHINE_CODE)
  fi
fi

########################################################################

if test yes = "$with_machine_code"; then
AC_MSG_CHECKING(register name convention)
AC_CACHE_VAL(pike_cv_cpu_reg_prefix,
[
  for pike_cv_cpu_reg_prefix in "default" "" "r" "%%" "%%r" "unknown"; do
    AC_TRY_COMPILE([
#define REGPREFIX "$pike_cv_cpu_reg_prefix"
], [
#if defined(__ppc__) || defined(__powerpc__) || defined(_POWER)
	__asm__ __volatile__(" li "REGPREFIX"11,1");
#else
	; /* Do not need to find out */
#endif
    ],[break])
  done
])
case "$pike_cv_cpu_reg_prefix" in
  default|unknown) AC_MSG_RESULT($pike_cv_cpu_reg_prefix);;
  *) AC_MSG_RESULT(${pike_cv_cpu_reg_prefix}0)
     AC_DEFINE_UNQUOTED(PIKE_CPU_REG_PREFIX,"$pike_cv_cpu_reg_prefix");;
esac
else :; fi

########################################################################
MY_CHECK_FUNCTION(fork,
[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
], [
  exit(fork()==-1);
])

########################################################################
MY_CHECK_FUNCTION(fpsetmask,
[
#include <math.h>
#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif
], [
  fpsetmask(0);
  exit(0);
])
########################################################################
MY_CHECK_FUNCTION(fpsetround,
[
#include <math.h>
#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

#ifndef FP_RN
#define FP_RN 0
#endif /* FP_RN */
], [
  fpsetround(FP_RN);
  exit(0);
])
########################################################################
MY_CHECK_FUNCTION(isless,
[
#include <math.h>
#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

], [
  int t = isless(0.0, 0.0);
  exit(0);
])
########################################################################
MY_CHECK_FUNCTION(isunordered,
[
#include <math.h>
#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

], [
  int t = isunordered(0.0, 0.0);
  exit(0);
])
########################################################################

MY_CHECK_FUNCTION(dlopen,
[
#include <dlfcn.h>
], [
  dlopen(0, 0);
  exit(0);
])
########################################################################

MY_CHECK_FUNCTION(ldexp,
[
#include <math.h>
], [
  double x;
  int p;

  for(x=0.0;x<2.0;x+=1.0/64.0)
    for(p=-6;p<7;p++)
      if(ldexp(x,p) != x*pow(2.0, (double)p))
	exit(1);
    exit(0);
])

########################################################################
MY_CHECK_FUNCTION(rint,
[
#include <math.h>
#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif /* HAVE_IEEEFP_H */
], [
#ifdef HAVE_FPSETROUND
  /* Round to nearest */
#ifndef FP_RN
#define FP_RN 0
#endif /* FP_RN */
  fpsetround(FP_RN);
#endif /* HAVE_FPSETROUND */
  if(rint(0.1) != 0.0 ||
     rint(0.6) != 1.0) exit(1);
  exit(0);
])

########################################################################

MY_CHECK_FUNCTION(frexp,
[
#include <math.h>
], [
  double x,y;
  int p,e;

  x=frexp(1.0, &e);
  if(x * pow(2.0,(double)e) != 1.0) exit(3);

  p=-7;
  for(x=3.0/4.0*pow(2.0,(double)p);x<50000.0;x*=2.0,p++)
  {
    if(frexp(x, &e)!=3.0/4.0) exit(1);
    if(e!=p) exit(2);
  }
  exit(0);
])

#############################################################################
MY_CHECK_FUNCTION(GetSystemTimeAsFileTime,
[
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#ifdef HAVE_WINBASE_H
#include <winbase.h>
#endif
], [
  FILETIME f;
  GetSystemTimeAsFileTime(&f);
  exit(0);
])
#############################################################################
MY_CHECK_FUNCTION(gethostname,
[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_WINSOCK2_H
#include <winsock2.h>
#elif defined(HAVE_WINSOCK_H)
#include <winsock.h>
#endif
], [
  char buffer[10000];
  char *x=gethostname(buffer,sizeof(buffer));
  exit(0);
])
#############################################################################
MY_CHECK_FUNCTION(strcoll,
[
#include <string.h>
#include <locale.h>
], [
  setlocale(LC_CTYPE, "ISO-8859-1");
  exit(strcoll("abc", "def") >= 0 ||
       strcoll("ABC", "DEF") >= 0 ||
       strcoll("ABC", "ABCD") >= 0 ||
       strcoll("ABCD", "ABC") <= 0 ||
       strcoll("*^#", "*^#") != 0 ||
       strcoll("123", "456") >= 0);
])

########################################################################

MY_CHECK_FUNCTION(memmem,
[
#include <string.h>
char *a="foo bar gazonk";
char *b="foo";
char *c="bar";
char *d="gazonk";
], [
  if(((char *)memmem(b,strlen(b),a,strlen(a)))!=a ||
     ((char *)memmem(c,strlen(c),a,strlen(a)))!=(a+4) ||
     ((char *)memmem(d,strlen(d),a,strlen(a)))!=(a+8) ||
     ((char *)memmem(d,0,a,strlen(a)))!=a ||
     memmem(d,strlen(d)+1,a,strlen(a))!=0)
    exit(1);
  exit(0);
])

########################################################################

MY_CHECK_FUNCTION(memcpy,
[
#include <string.h>
char *a="foo bar gazonk";
char foo[23];
], [
  memcpy(foo, a, strlen(a)+1);
  memcpy(foo, a+4, 3);
  if(strcmp(foo,"bar bar gazonk")) exit(1);
  exit(0);
])

########################################################################

MY_CHECK_FUNCTION(memset,
[
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif /* HAVE_STDDEF_H */
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif /* HAVE_STDLIB_H */
#include <stdio.h>
#include <string.h>
char foo[23];

struct pike_string {
  int refs;
  int size_shift;
  ptrdiff_t len;
  size_t hval;
  struct pike_string *next;
  char str[1];
};

struct pike_string *begin_shared_string(int len)
{
  return (struct pike_string *)malloc(sizeof(struct pike_string) + len);
}

], [
  int i;
  struct pike_string *str;
  ptrdiff_t len;

  memset(foo, 0, 11);
  memset(foo, 'a', 10);
  memset(foo, 'b', 5);
  fprintf(stderr, "1\n");
  if(strcmp(foo,"bbbbbaaaaa")) {
    exit(1);
  }
  memset(foo, 0, 6);
  fprintf(stderr, "2\n");
  for (i=6; i--;) {
    if (foo[i]) {
      exit(1);
    }
  }
  memset(foo+1, 1, 6);
  fprintf(stderr, "3\n");
  for (i=6; i--;) {
    if (foo[i+1] != 1) {
      exit(1);
    }
  }
  memset(foo+2, 0, 6);
  fprintf(stderr, "4\n");
  for (i=6; i--;) {
    if (foo[i+2]) {
      exit(1);
    }
  }
  memset(foo+3, 1, 6);
  fprintf(stderr, "5\n");
  for (i=6; i--;) {
    if (foo[i+3] != 1) {
      exit(1);
    }
  }
  memset(foo+4, 0, 6);
  fprintf(stderr, "6\n");
  for (i=6; i--;) {
    if (foo[i+4]) {
      exit(1);
    }
  }
  memset(foo+5, 1, 6);
  fprintf(stderr, "7\n");
  for (i=6; i--;) {
    if (foo[i+5] != 1) {
      exit(1);
    }
  }
  memset(foo+6, 0, 6);
  fprintf(stderr, "8\n");
  for (i=6; i--;) {
    if (foo[i+6]) {
      exit(1);
    }
  }
  memset(foo+7, 1, 6);
  fprintf(stderr, "9\n");
  for (i=6; i--;) {
    if (foo[i+7] != 1) {
      exit(1);
    }
  }

  len = 6;
  str = begin_shared_string(len);

  fprintf(stderr, "string start\n");
  if (!str) exit(1);

  for (i=len; i--;) {
    str->str[i] = ~0;
  }
  memset(str->str, 0, len);
  fprintf(stderr, "string end\n");
  for (i = len; i--;) {
    if (str->str[i]) {
      exit(1);
    }
  }
  free(str);
  exit(0);
])

########################################################################

MY_CHECK_FUNCTION(memmove,
[
#include <string.h>
char buf[100];
], [
  strcpy(buf,"foo bar gazonk elefantsnabel.");
  if(strcmp(buf,"foo bar gazonk elefantsnabel.")) exit(1);
  memmove(buf,buf+1,7);
  if(strcmp(buf,"oo bar  gazonk elefantsnabel.")) exit(1);
  memmove(buf+1,buf+1,9);
  if(strcmp(buf,"oo bar  gazonk elefantsnabel.")) exit(1);
  memmove(buf+1,buf,11);
  if(strcmp(buf,"ooo bar  gaznk elefantsnabel.")) exit(1);
  exit(0);
])

########################################################################

MY_CHECK_FUNCTION(isspace,
[
#include <ctype.h>
], [
  if(isspace(' ')) exit(0);
  exit(1);
])

#############################################################################

AC_MSG_CHECKING(if we can declare environ)
AC_CACHE_VAL(pike_cv_declare_environ,[
AC_TRY_COMPILE([
#include <stdlib.h>
],[
  extern char **environ;
  exit(0);
],pike_cv_declare_environ=yes,pike_cv_declare_environ=no,pike_cv_declare_environ=yes)
])

AC_MSG_RESULT($pike_cv_declare_environ)
if test "x$pike_cv_declare_environ" = xyes ; then
  AC_DEFINE(DECLARE_ENVIRON)
fi

#############################################################################

AC_MSG_CHECKING([for union wait (old BSD convention)])
AC_CACHE_VAL(pike_cv_union_wait, [ AC_TRY_COMPILE([
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif /* HAVE_SYS_WAIT_H */
], [
  union wait status;
  exit(0);
], pike_cv_union_wait=yes, pike_cv_union_wait=no)
])

AC_MSG_RESULT($pike_cv_union_wait)
if test "x$pike_cv_union_wait" = "xyes" ; then
  AC_MSG_CHECKING([whether union wait is really needed])
  AC_CACHE_VAL(pike_cv_union_wait_needed, [ AC_TRY_COMPILE([
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif /* HAVE_SYS_WAIT_H */
], [
  int status;
  return WIFEXITED(status) || 0;
], pike_cv_union_wait_needed=no, pike_cv_union_wait_needed=yes)
])
  AC_MSG_RESULT($pike_cv_union_wait_needed)
  if test "x$pike_cv_union_wait_needed" = "xyes" ; then
    AC_DEFINE(HAVE_UNION_WAIT)
  else :; fi
else :; fi

#############################################################################

AC_MSG_CHECKING(how to extract an unsigned char)
AC_CACHE_VAL(pike_cv_method_extract_uchar,
[
AC_TRY_RUN([
int main()
{
  char i,*p;
  i=-10;
  p=&i;
  if(*(unsigned char *)(p)!= 0x100 - 10) exit(1);
  exit(0);
}
],pike_cv_method_extract_uchar=by_cast,
pike_cv_method_extract_uchar=not_by_cast,
pike_cv_method_extract_uchar=not_by_cast)])

if test "$pike_cv_method_extract_uchar" = by_cast; then
  AC_MSG_RESULT(by cast)
  AC_DEFINE(EXTRACT_UCHAR_BY_CAST)
else
  AC_MSG_RESULT(not by cast)
fi

########################################################################

AC_MSG_CHECKING(how to extract a signed char)
AC_CACHE_VAL(pike_cv_method_extract_char,
[
AC_TRY_RUN([
int main()
{
  char i,*p;
  i=-10;
  p=&i;
  if(*(signed char *)(p)!= -10) exit(1);
  exit(0);
}
],pike_cv_method_extract_char=by_cast,
pike_cv_method_extract_char=not_by_cast,
pike_cv_method_extract_char=not_by_cast)])

if test "$pike_cv_method_extract_char" = by_cast; then
  AC_MSG_RESULT(by cast)
  AC_DEFINE(EXTRACT_CHAR_BY_CAST)
else
  AC_MSG_RESULT(not by cast)
fi

#############################################################################
AC_ARG_WITH(copt, MY_DESCR([--without-mmx], [disable MMX usage]), [], [with_mmx=])

mmx_reason=' (no mmx.h found)'
if test "x$with_mmx" = xno; then
   mmx_reason=' (--without-mmx)'
   unset pike_cv_sys_has_working_mmx
else
if test "x$ac_cv_header_mmx_h" = xyes -o "x$ac_cv_header_asm_mmx_h" = xyes; then
  AC_MSG_CHECKING(for working MMX)
  mmx_reason=' (mmx.h found, but mmx operations failed)'

  AC_CACHE_VAL(pike_cv_sys_has_working_mmx,
  [
    AC_TRY_LINK([
#ifdef HAVE_MMX_H
#include <mmx.h>
#endif
#ifdef HAVE_ASM_MMX_H
#include <asm/mmx.h>
#endif
    ],[
    {
      int try_use_mmx;
      char a[8];
      movq_m2r( *a, mm0 );
      paddb_r2r( mm0, mm0 );
      movq_r2m( mm0, *a );
      try_use_mmx=mmx_ok();
    }
    ],pike_cv_sys_has_working_mmx=yes,pike_cv_sys_has_working_mmx=no)
  ])

  AC_MSG_RESULT($pike_cv_sys_has_working_mmx)

  if test "x$pike_cv_sys_has_working_mmx" = xyes ; then
    AC_DEFINE(TRY_USE_MMX)
    mmx_reason=''
  else :; fi

  if test "x$with_copt" = "xno"; then
    PIKE_MSG_WARN([--without-mmx is advisable when using --without-copt.])
  fi
else :; fi
fi

#############################################################################

AC_MSG_CHECKING(if float conversion can cause SIGFPE)
AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe,
[
 AC_TRY_RUN([
#include <math.h>

#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

float foo_float = 0.0;

int main(int argc, char **argv)
{
  float x=2.0, y=-128.0;
#ifdef HAVE_FPSETMASK
  fpsetmask(0);
#endif
  x = pow(2.0, -128.0);
  foo_float = x;
  if (x == 2.0) exit(1);
  x = pow(2.0, 1024.0);
  foo_float = x;
  if(x == 2.0) exit(1);
  exit(0);
}
],pike_cv_sys_idiot_sigfpe=no,pike_cv_sys_idiot_sigfpe=yes,
  pike_cv_sys_idiot_sigfpe=yes)
])

if test $pike_cv_sys_idiot_sigfpe = yes ; then
  AC_MSG_RESULT(yes)

  IEEE_FLAG=no
  if test "x${GCC-}" = xyes ; then
    AC_SYS_COMPILER_FLAG(-mieee, mieee, CFLAGS,[],IEEE_FLAG=yes)
  else
    AC_SYS_COMPILER_FLAG(-ieee, ieee, CFLAGS,[],IEEE_FLAG=yes)
  fi
  TEST_IGNORE_SIGFPE=yes

  if test $IEEE_FLAG = yes; then
    AC_MSG_CHECKING(if float conversion is still broken)
    AC_CACHE_VAL(pike_cv_sys_idiot_sigfpe_with_ieee,
[
 OLD_CFLAGS="$CFLAGS"
 CFLAGS="$CFLAGS $OPTIMIZE"
 AC_TRY_RUN([
#include <math.h>

#ifdef HAVE_FLOATINGPOINT_H
#include <floatingpoint.h>
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif

float foo_float = 0.0;

int main(int argc, char **argv)
{
  float x=2.0, y=-128.0;
#ifdef HAVE_FPSETMASK
  fpsetmask(0);
#endif
  x = pow(2.0, -128.0);
  foo_float = x;
  if (x == 2.0) exit(1);
  x = pow(2.0, 1024.0);
  foo_float = x;
  if(x == 2.0) exit(1);
  exit(0);
}
],pike_cv_sys_idiot_sigfpe_with_ieee=no,pike_cv_sys_idiot_sigfpe_with_ieee=yes,
  pike_cv_sys_idiot_sigfpe_with_ieee=yes)
  CFLAGS="$OLD_CFLAGS"
])
   
  if test $pike_cv_sys_idiot_sigfpe_with_ieee = yes ; then
    AC_MSG_RESULT(yes)
  else
    AC_MSG_RESULT(no)
    TEST_IGNORE_SIGFPE=no
  fi
fi # IEEE_FLAG

if test $TEST_IGNORE_SIGFPE = yes; then
  AC_MSG_CHECKING(if ignoring SIGFPE helps)
  AC_CACHE_VAL(pike_cv_sys_ignore_sigfpe,
[
 OLD_CFLAGS="$CFLAGS"
 CFLAGS="$CFLAGS $OPTIMIZE"
AC_TRY_RUN([
#include <signal.h>
#include <math.h>
int counter=0;
RETSIGTYPE func(void)
{
 if(counter++>10) exit(7);
 signal(SIGFPE,func);
}

float foo_float = 0.0;

int main(int argc, char **argv)
{
  float x=2.0, y=-128.0;
  signal(SIGFPE,func);
  x = pow(2.0, -128.0);
  foo_float = x;
  if (x == 2.0) exit(1);
  x = pow(2.0, 1024.0);
  foo_float = x;
  if(x == 2.0) exit(1);
  exit(0);
}
],pike_cv_sys_ignore_sigfpe=yes,pike_cv_sys_ignore_sigfpe=no,
  pike_cv_sys_ignore_sigfpe=yes)
  CFLAGS="$OLD_CFLAGS"
])

if test "$pike_cv_sys_ignore_sigfpe" = yes; then
 AC_MSG_RESULT(yes)
 AC_DEFINE(IGNORE_SIGFPE)
else
 AC_MSG_RESULT(no)
fi
fi # TEST_IGNORE_SIGFPE

else
 AC_MSG_RESULT(no)
fi # pike_cv_sys_idiot_sigfpe

#############################################################################

define(float_check, [[
#include <math.h>
#define TY $1
#define TEST_$1
#define TEST_$2
#define EXPECTED_SIZE_float 4
#define EXPECTED_SIZE_double 8
void check(TY n, char *pf, char *pd)
{
  int i;
  char *p, *p2 = (char*)&n;
#ifdef TEST_float
    p = pf;
#else
    p = pd;
#endif
  for(i=0; i<sizeof(TY); i++)
#ifdef TEST_BIG
    if(p[i] != p2[i])
      exit(1);
#else
    if(p[i] != p2[sizeof(TY)-i-1])
      exit(1);
#endif
}
int main()
{
  if(sizeof(TY)!=EXPECTED_SIZE_$1)
    exit(1);
  check((TY)0.0, "\000\000\000\000", "\000\000\000\000\000\000\000\000");
  check((TY)1.0, "\077\200\000\000", "\077\360\000\000\000\000\000\000");
  check((TY)-1.0, "\277\200\000\000", "\277\360\000\000\000\000\000\000");
  check((TY)2.0, "\100\000\000\000", "\100\000\000\000\000\000\000\000");
  check((TY)1.5, "\077\300\000\000", "\077\370\000\000\000\000\000\000");
  check((TY)0.032999999821186065673828125, "\075\007\053\002", "\077\240\345\140\100\000\000\000");
  exit(0);
}
]])

AC_MSG_CHECKING(for type of float)
AC_CACHE_VAL(pike_cv_float_type, [
  AC_TRY_RUN(float_check(float,BIG), pike_cv_float_type=ieee_big, [
    AC_TRY_RUN(float_check(float,LITTLE), pike_cv_float_type=ieee_little,
      pike_cv_float_type=not_ieee, pike_cv_float_type=not_ieee)
  ], [
    echo $ac_n "crosscompiling... $ac_c" 1>&6
    # Use some magical constants...
    cat > conftest.$ac_ext <<EOF
dnl This sometimes fails to find confdefs.h, for some reason.
dnl [#]line __oline__ "[$]0"
[#]line __oline__ "configure"
#include "confdefs.h"
#include <stdio.h>
float float_info[[]] = {
  0.0,
  14914788644012054221422592.0, 16305677175569252352.0,
  0.0
};
EOF
    if AC_TRY_EVAL(ac_compile); then
      if test -f "conftest.$ac_objext"; then
        if strings "conftest.$ac_objext" | grep "iEeE_bIg" >/dev/null; then
	  pike_cv_float_type=ieee_big
        else
	  if strings "conftest.$ac_objext" | grep "EeEigIb_" >/dev/null; then
	    pike_cv_float_type=ieee_little
	  else
	    pike_cv_float_type=not_ieee
	  fi
	fi
      else
        AC_MSG_WARN([Object file not found - using default.])
	pike_cv_float_type=not_ieee
      fi
    else
      pike_cv_float_type=not_ieee
    fi
    rm -rf conftest*
  ])
])
if test "$pike_cv_float_type" = ieee_big; then
  AC_MSG_RESULT(IEEE big endian)
  AC_DEFINE(FLOAT_IS_IEEE_BIG)
else
  if test "$pike_cv_float_type" = ieee_little; then
    AC_MSG_RESULT(IEEE little endian)
    AC_DEFINE(FLOAT_IS_IEEE_LITTLE)
  else
    AC_MSG_RESULT(not IEEE)
  fi
fi

AC_MSG_CHECKING(for type of double)
AC_CACHE_VAL(pike_cv_double_type, [
  AC_TRY_RUN(float_check(double,BIG), pike_cv_double_type=ieee_big, [
    AC_TRY_RUN(float_check(double,LITTLE), pike_cv_double_type=ieee_little,
      pike_cv_double_type=not_ieee, pike_cv_double_type=not_ieee)
  ], [
    echo $ac_n "crosscompiling... $ac_c" 1>&6
    # Use some magical constants...
    cat > conftest.$ac_ext <<EOF
dnl This sometimes fails to find confdefs.h, for some reason.
dnl [#]line __oline__ "[$]0"
[#]line __oline__ "configure"
#include "confdefs.h"
#include <stdio.h>
double double_info[[]] = {
  0.0,
  12794738495187527498222028847205909954314554441725728393516969126669975252147490126864122090122288822751876426313291683594796075946303753742007913302630260537160845833197547903208108732031187791380480.0,
  0.0
};
EOF
    if AC_TRY_EVAL(ac_compile); then
      if test -f "conftest.$ac_objext"; then
        if strings "conftest.$ac_objext" | grep "iEeE_bIg" >/dev/null; then
	  pike_cv_double_type=ieee_big
        else
	  if strings "conftest.$ac_objext" | grep "gIb_EeEi" >/dev/null; then
	    pike_cv_double_type=ieee_little
	  else
	    pike_cv_double_type=not_ieee
	  fi
	fi
      else
        AC_MSG_WARN([Object file not found - using default.])
	pike_cv_float_type=not_ieee
      fi
    else
      pike_cv_float_type=not_ieee
    fi
    rm -rf conftest*
  ])
])
if test "$pike_cv_double_type" = ieee_big; then
  AC_MSG_RESULT(IEEE big endian)
  AC_DEFINE(DOUBLE_IS_IEEE_BIG)
else
  if test "$pike_cv_double_type" = ieee_little; then
    AC_MSG_RESULT(IEEE little endian)
    AC_DEFINE(DOUBLE_IS_IEEE_LITTLE)
  else
    AC_MSG_RESULT(not IEEE)
  fi
fi

#############################################################################

AC_MSG_CHECKING(for volatile)
AC_CACHE_VAL(pike_cv_volatile,
[
 AC_TRY_COMPILE([],[ volatile int foo=1;], pike_cv_volatile=yes,pike_cv_volatile=no)
])

if test "$pike_cv_volatile" = yes; then
 AC_MSG_RESULT(yes)
 AC_DEFINE(VOLATILE,volatile)
else
 AC_MSG_RESULT(no)
 AC_DEFINE(VOLATILE,)
fi

########################################################################

AC_MSG_CHECKING(for sig_atomic_t)
AC_CACHE_VAL(ac_cv_type_sig_atomic_t,
[
  AC_EGREP_CPP(sig_atomic_t, [
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#ifdef HAVE_CRT_SIGNAL_H
#include <crt/signal.h>
#endif
#include <sys/types.h>
#if STDC_HEADERS
#include <stdlib.h>
#include <stddef.h>
#endif], ac_cv_type_sig_atomic_t=yes, ac_cv_type_sig_atomic_t=no)])
AC_MSG_RESULT($ac_cv_type_sig_atomic_t)
if test x"$ac_cv_type_sig_atomic_t" = xno; then
  AC_DEFINE(sig_atomic_t, int)
else
  :
fi

AC_MSG_CHECKING(if signal handlers reset automatically)
AC_CACHE_VAL(pike_cv_sys_signal_oneshot,
[
AC_TRY_RUN([
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#include <sys/types.h>
#if STDC_HEADERS
#include <stdlib.h>
#include <stddef.h>
#endif
VOLATILE sig_atomic_t sigrun[2]= { 0, 0 };
RETSIGTYPE func(int sig)
{
  write(2, "func called\n", sizeof("func called\n") - sizeof(""));
  sigrun[0] = -1;
}

int main()
{
#define sig SIGSEGV

#ifdef HAVE_SIGACTION
  {
    static struct sigaction action;
    action.sa_handler= func;
    sigfillset(&action.sa_mask);
#ifdef SA_INTERRUPT
    action.sa_flags=SA_INTERRUPT;
#endif
    sigaction(sig,&action,0);
  }
#else
#ifdef HAVE_SIGVEC
  {
    static struct sigvec action;
    action.sv_handler= func;
    action.sv_mask=-1;
#ifdef SV_INTERRUPT
    action.sv_flags=SV_INTERRUPT;
#endif
    sigvec(sig,&action,0);
  }
#else
  signal(sig, func);
#endif
#endif

  kill(getpid(), sig);
#ifdef HAVE_POLL
  struct pollfd sentinel;
  while(!strlen((char *)sigrun)) poll(&sentinel,0,100);
#else
  while(!strlen((char *)sigrun)) sleep(1);
#endif
  sigrun[0]=0;
  kill(getpid(), sig);
#ifdef HAVE_POLL
  while(!strlen((char *)sigrun)) poll(&sentinel,0,100);
#else
  while(!strlen((char *)sigrun)) sleep(1);
#endif
  sigrun[0]=0;
  exit(0);
}
],pike_cv_sys_signal_oneshot=no,pike_cv_sys_signal_oneshot=yes,pike_cv_sys_signal_oneshot=yes)])

if test "$pike_cv_sys_signal_oneshot" = yes; then
  AC_MSG_RESULT(yes)
  AC_DEFINE(SIGNAL_ONESHOT)
else
  AC_MSG_RESULT(no)
fi

########################################################################

AC_MSG_CHECKING(available file descriptors)
AC_CACHE_VAL(pike_cv_max_open_fd,
[
if test "x$enable_binary" = "xno"; then
  pike_cv_max_open_fd=256
else
AC_TRY_RUN([
#include <stdio.h>
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif

#ifndef MAX_FD
#define MAX_FD 65536
#endif

int main()
{
  FILE *f;
  long limit;

#if !defined(RLIMIT_NOFILE) && defined(RLIMIT_OFILE)
#define RLIMIT_NOFILE RLIMIT_OFILE
#endif

#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
  struct rlimit lim;

  if(getrlimit(RLIMIT_NOFILE,&lim))
  {
    limit = MAX_FD;
  }else{
    if(lim.rlim_max == RLIM_INFINITY)
    {
      limit = 1024 * 1024 * 2; /* Noone needs more :-) */
    }else{
      limit=lim.rlim_max;
      if(limit > 1024 * 1024 * 2) limit= 1024 * 1024 * 2;
    }
  }
#else
  limit = MAX_FD;
#endif

  f=fopen("conftest.out.2","w");
  fprintf(f,"%ld\n",(long)limit);
  fclose(f);

  return 0;
}
],
pike_cv_max_open_fd=`cat conftest.out.2`
,
pike_cv_max_open_fd=256
,
pike_cv_max_open_fd=256
)
fi
])
AC_MSG_RESULT($pike_cv_max_open_fd)
AC_DEFINE_UNQUOTED(MAX_OPEN_FILEDESCRIPTORS,$pike_cv_max_open_fd)

AC_MSG_CHECKING(full availability of struct rusage members)
AC_CACHE_VAL(pike_cv_func_getrusage_full,
[
AC_TRY_LINK([
#include <sys/time.h>
#ifdef HAVE_SYS_RUSAGE_H
#include <sys/rusage.h>
#endif
#include <sys/resource.h>
#ifndef RUSAGE_SELF
#define RUSAGE_SELF     0
#endif
],[
    struct rusage rus;
    long *v = (long *)main;
    getrusage(RUSAGE_SELF, &rus);
    *v++ = rus.ru_maxrss;
    *v++ = rus.ru_ixrss;
    *v++ = rus.ru_idrss;
    *v++ = rus.ru_isrss;
    *v++ = rus.ru_minflt;
    *v++ = rus.ru_majflt;
    *v++ = rus.ru_nswap;
    *v++ = rus.ru_inblock;
    *v++ = rus.ru_oublock;
    *v++ = rus.ru_msgsnd;
    *v++ = rus.ru_msgrcv;
    *v++ = rus.ru_nsignals;
    *v++ = rus.ru_nvcsw;
    *v++ = rus.ru_nivcsw;
],
  pike_cv_func_getrusage_full=yes
,
  pike_cv_func_getrusage_full=no
)])

if test "$pike_cv_func_getrusage_full" = yes; then
  AC_MSG_RESULT(all there)
else
  AC_MSG_RESULT(getrusage is restricted)
  AC_DEFINE(GETRUSAGE_RESTRICTED)
fi

########################################################################
# 
# IRIX also has procfs support, but it it different, a separate test
# should be made. /Hubbe
#

if test "$ac_cv_header_sys_procfs_h" = "yes"; then
  AC_MSG_CHECKING(getrusage() through procfs)
  AC_CACHE_VAL(pike_cv_getrusage_procfs, [
    AC_TRY_COMPILE([
#ifndef _LARGEFILE_SOURCE
#  define _FILE_OFFSET_BITS 64
#  define _LARGEFILE_SOURCE
#  define _LARGEFILE64_SOURCE 1
#endif
#include <sys/procfs.h>
#include <sys/fcntl.h>
int proc_fd;
long tmp;
char proc_name[20];
prusage_t  pru;
    ],[
      sprintf(proc_name, "/proc/%05d", getpid());
      proc_fd = open(proc_name, O_RDONLY);
      ioctl(proc_fd, PIOCUSAGE, &pru);
      tmp=pru.pr_utime.tv_sec;
    ],
      pike_cv_getrusage_procfs=yes
    ,
      pike_cv_getrusage_procfs=no
    )
  ])

  if test "$pike_cv_getrusage_procfs" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(GETRUSAGE_THROUGH_PROCFS)
  else
    AC_MSG_RESULT(no)
  fi
fi

#############################################################################

if test "$ac_cv_getrusage_procfs" = "yes"; then
  AC_MSG_CHECKING(prstatus_t contains pr_brksize and pr_stksize)
  AC_CACHE_VAL(pike_cv_getrusage_procfs_prs, [
    AC_TRY_COMPILE([
#ifndef _LARGEFILE_SOURCE
#  define _FILE_OFFSET_BITS 64
#  define _LARGEFILE_SOURCE
#  define _LARGEFILE64_SOURCE 1
#endif
#include <sys/procfs.h>
#include <sys/fcntl.h>
int proc_fd;
long tmp;
char proc_name[20];
prstatus_t prs;
    ],[
      sprintf(proc_name, "/proc/%05d", getpid());
      proc_fd = open(proc_name, O_RDONLY);
      ioctl(proc_fd, PIOCSTATUS, &prs);
      tmp=prs.pr_brksize + prs.pr_stksize;
    ],
      pike_cv_getrusage_procfs_prs=yes
    ,
      pike_cv_getrusage_procfs_prs=no
    )
  ])

  if test "$pike_cv_getrusage_procfs_prs" = yes; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(GETRUSAGE_THROUGH_PROCFS_PRS)
  else
    AC_MSG_RESULT(no)
  fi
fi

#############################################################################

AC_MSG_CHECKING(for isgraph)
AC_CACHE_VAL(pike_cv_func_isgraph, [ AC_TRY_LINK([
#include <ctype.h>
], [
return(!isgraph('A'));
], pike_cv_func_isgraph=yes, pike_cv_func_isgraph=no)
])
AC_MSG_RESULT($pike_cv_func_isgraph)
if test "x$pike_cv_func_isgraph" = "xyes" ; then
  AC_DEFINE(HAVE_ISGRAPH)
else :; fi

#############################################################################
#
# __func__ is new in ISO C 9x
#
# It should expand to the name of the current function, and is
# useful for debug.

AC_MSG_CHECKING(if __func__ exists and works)
AC_CACHE_VAL(pike_cv_have_working___func__,
[
  AC_TRY_RUN([
#ifdef HAVE_STRING_H
#include <string.h>
#else /* !HAVE_STRING_H */
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif /* HAVE_STRIGNS_H */
#endif /* HAVE_STRING_H */
int main()
{
  exit(strcmp("main", __func__));
}
  ], pike_cv_have_working___func__=yes, pike_cv_have_working___func__=no,
     pike_cv_have_working___func__=no)
])
AC_MSG_RESULT($pike_cv_have_working___func__)
if test "$pike_cv_have_working___func__" = yes; then
  AC_DEFINE(HAVE_WORKING___FUNC__)
else :; fi

# gcc has __FUNCTION__ instead.

AC_MSG_CHECKING(if __FUNCTION__ exists and works)
AC_CACHE_VAL(pike_cv_have_working___FUNCTION__,
[
  AC_TRY_RUN([
#ifdef HAVE_STRING_H
#include <string.h>
#else /* !HAVE_STRING_H */
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif /* HAVE_STRIGNS_H */
#endif /* HAVE_STRING_H */
int main()
{
  exit(strcmp("main", __FUNCTION__));
}
  ], pike_cv_have_working___FUNCTION__=yes,
     pike_cv_have_working___FUNCTION__=no,
     pike_cv_have_working___FUNCTION__=no)
])
AC_MSG_RESULT($pike_cv_have_working___FUNCTION__)
if test "$pike_cv_have_working___FUNCTION__" = yes; then
  AC_DEFINE(HAVE_WORKING___FUNCTION__)
else :; fi

#############################################################################

if test "x$with_computed_goto" = "xyes"; then
  AC_MSG_CHECKING(for gcc-style computed goto)
  AC_CACHE_VAL(pike_cv_gcc_computed_goto, [
    AC_TRY_COMPILE([], [
      void *skip = &&label;

      goto *skip;

      return 1;

    label:
      return 0;
    ], [ pike_cv_gcc_computed_goto=yes ], [ pike_cv_gcc_computed_goto=no ])
  ])
  AC_MSG_RESULT($pike_cv_gcc_computed_goto)
  if test "x$pike_cv_gcc_computed_goto" = "xyes"; then
    PIKE_MSG_WARN([Enabling computed goto (EXPERIMENTAL).])
    AC_DEFINE(HAVE_COMPUTED_GOTO)
  else :; fi
else :; fi

#############################################################################

if test "$with_machine_code" = "yes" ; then
  AC_DEFINE_UNQUOTED(PIKE_BYTECODE_METHOD, [[PIKE_BYTECODE_`echo $pike_cv_machine_code_arch | tr '[a-z]' '[A-Z]'`]])
  byte_code_format=$pike_cv_machine_code_arch
elif test "x$pike_cv_gcc_computed_goto" = "xyes"; then
  AC_DEFINE(PIKE_BYTECODE_METHOD, PIKE_BYTECODE_GOTO)
  byte_code_format="computed goto"
else
  AC_DEFINE(PIKE_BYTECODE_METHOD, PIKE_BYTECODE_DEFAULT)
  byte_code_format="virtual machine"
fi

#############################################################################

AC_MSG_CHECKING(for lc __declspec)
AC_CACHE_VAL(pike_cv_lc___declspec,
[
  AC_TRY_RUN([
#include <stdarg.h>
__declspec(noreturn) void fatal(char *foo,...);

__declspec(noreturn) void fatal(char *foo,...)
{
  va_list args;
  va_start(foo,args);
  printf(foo,args);
  va_end(args);
  exit(2);
}

int main() {  exit(0); }

  ], pike_cv_lc___declspec=yes, pike_cv_lc___declspec=no, [
    echo $ac_n "crosscompiling... $ac_c" 1>&6
    AC_TRY_LINK([
#include <stdarg.h>
__declspec(noreturn) void fatal(char *foo,...);

__declspec(noreturn) void fatal(char *foo,...)
{
  va_list args;
  va_start(foo,args);
  printf(foo,args);
  va_end(args);
  exit(2);
}
    ], [
  exit(0);
    ], pike_cv_lc___declspec=yes, pike_cv_lc___declspec=no)
  ])
])

AC_MSG_RESULT($pike_cv_lc___declspec)
if test "$pike_cv_lc___declspec" = yes; then
 AC_DEFINE(HAVE_DECLSPEC)
else

  # NOTE: Avoid using __attribute__ if __declspec is available.
  #       This is a kludge to descrease the number of warnings
  #       on ecc.

  AC_MSG_CHECKING(for gcc function attributes)
  AC_CACHE_VAL(pike_cv_gcc_attributes,
  [
    AC_TRY_RUN([
#include <stdarg.h>
void fatal(char *foo,...) __attribute__ ((noreturn,format (printf,1,2)));
int sqr(int x) __attribute__ ((const));

int sqr(int x) { return x*x; }

void fatal(char *foo,...)
{
  va_list args;
  va_start(foo,args);
  printf(foo,args);
  va_end(args);
  exit(2);
}

int main() {  exit(0); }

    ], pike_cv_gcc_attributes=yes, pike_cv_gcc_attributes=no, [
      echo $ac_n "crosscompiling... $ac_c" 1>&6
      AC_TRY_LINK([
#include <stdarg.h>
void fatal(char *foo,...) __attribute__ ((noreturn,format (printf,1,2)));
int sqr(int x) __attribute__ ((const));

int sqr(int x) { return x*x; }

void fatal(char *foo,...)
{
  va_list args;
  va_start(foo,args);
  printf(foo,args);
  va_end(args);
  exit(2);
}
      ], [
  exit(0);
      ], pike_cv_gcc_attributes=yes, pike_cv_gcc_attributes=no)
    ])
  ])

  AC_MSG_RESULT($pike_cv_gcc_attributes)
  if test "$pike_cv_gcc_attributes" = yes; then
    AC_DEFINE(HAVE_FUNCTION_ATTRIBUTES)
  fi
fi

#############################################################################

AC_MSG_CHECKING(how to concatenate two symbols)
AC_CACHE_VAL(pike_cv_cpp_symbol_concat, [
  AC_TRY_COMPILE([
int AABB=0;
#define CONCAT(X,Y)	X##Y
  ], [
    return CONCAT(AA,BB);
  ], pike_cv_cpp_symbol_concat=ANSI, [
    AC_TRY_COMPILE([
int AABB=0;
#define CONCAT(X,Y)	X/**/Y
    ], [
      return CONCAT(AA,BB);
    ], pike_cv_cpp_symbol_concat=KR, [
      pike_cv_cpp_symbol_concat=Unknown
    ])
  ])
])
AC_MSG_RESULT($pike_cv_cpp_symbol_concat)
case "$pike_cv_cpp_symbol_concat" in
  "ANSI")
    AC_DEFINE(HAVE_ANSI_CONCAT)
  ;;
  "KR")
    AC_DEFINE(HAVE_KR_CONCAT)
  ;;
esac

#############################################################################

AC_MSG_CHECKING(how to set things nonblocking)
AC_CACHE_VAL(pike_cv_sys_nonblock,
[
  # Kludge needed for AmigaOS
  if test "$pike_cv_sys_os" = "AmigaOS" ; then
    pike_cv_sys_nonblock=USE_FCNTL_O_NONBLOCK
  else
    OCPPFLAGS="$CPPFLAGS"
    pike_cv_sys_bad_signal_handling=""
    pike_cv_sys_nonblock=UNKNOWN
    # USE_FCNTL_O_NONBLOCK seems to be the most common, so let's start
    # with it.
    for method in USE_FCNTL_O_NONBLOCK USE_FCNTL_FNDELAY USE_FCNTL_O_NDELAY \
		  USE_IOCTL_FIONBIO USE_IOCTLSOCKET_FIONBIO; do
      # Make sure we can run configure in a separate directory,
      # and set the method to try.
      CPPFLAGS="$OCPPFLAGS -D$method"
      AC_TRY_RUN([
#define TESTING
#include "fd_control.c"
      ], [
        pike_cv_sys_nonblock=$method
	break;
      ], [], [
        AC_TRY_LINK([
#define TESTING
#include "fd_control.c"
#define main dummy_main
        ], [], [
	  pike_cv_sys_nonblock=$method
	  break;
	])
      ])
    done
    if test "$pike_cv_sys_nonblock" = "UNKNOWN"; then
      # Some OS's don't like signals in combination with threads.
      # Try compiling half the test...

      # USE_FCNTL_O_NONBLOCK seems to be the most common, so let's start
      # with it.
      for method in USE_FCNTL_O_NONBLOCK USE_FCNTL_FNDELAY USE_FCNTL_O_NDELAY \
		    USE_IOCTL_FIONBIO USE_IOCTLSOCKET_FIONBIO; do
	# Make sure we can run configure in a separate directory,
	# and set the method to try.
	CPPFLAGS="$OCPPFLAGS -D$method -DSHORT_TEST"
	AC_TRY_RUN([
#define TESTING
#include "fd_control.c"
        ], [
	  pike_cv_sys_bad_signal_handling=" (signal handling failed)"
          pike_cv_sys_nonblock=$method
          break;
        ], [], [
	  :; # Not meaningful.
  	])
      done
    else :; fi
    # Restore CPPFLAGS
    CPPFLAGS="$OCPPFLAGS"
  fi
])

if test "${pike_cv_sys_nonblock}" = "UNKNOWN"; then
  AC_MSG_RESULT(none found)
  if test "${pike_cv_sys_os}" = "Windows_NT"; then :; else
    config_fail="No way to set nonblocking I/O"
  fi
else
 AC_MSG_RESULT($pike_cv_sys_nonblock$pike_cv_sys_bad_signal_handling)
 AC_DEFINE_UNQUOTED($pike_cv_sys_nonblock)
fi

rm -f core

##########################################################################
AC_MSG_CHECKING(how well OOB handling works)
AC_CACHE_VAL(pike_cv_system_oob_working,[
if test "x$enable_binary" = "xno"; then
  pike_cv_system_oob_working=WORKING
else
  AC_TRY_RUN([
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/stat.h>
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_SYS_POLL_H
#include <sys/poll.h>
#endif
#include <fcntl.h>
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif

#define SP_DEBUG(X)	fprintf X

#ifndef POLLRDNORM
#define POLLRDNORM      POLLIN
#endif

#ifndef POLLRDBAND
#define POLLRDBAND      POLLPRI
#endif

#ifndef POLLWRBAND
#define POLLWRBAND      POLLOUT
#endif

int set_nonblocking(int fd,int which)
{
  int ret;
  do 
  {
#if defined(USE_IOCTL_FIONBIO) || defined(__NT__)
    ret=ioctl(fd, FIONBIO, &which);
#else

#ifdef USE_FCNTL_O_NDELAY
    ret=fcntl(fd, F_SETFL, which?O_NDELAY:0);
#else

#ifdef USE_FCNTL_O_NONBLOCK
    ret=fcntl(fd, F_SETFL, which?O_NONBLOCK:0);
#else

#ifdef USE_FCNTL_FNDELAY
    ret=fcntl(fd, F_SETFL, which?FNDELAY:0);
#else

#error Do not know how to set your filedescriptors nonblocking.

#endif
#endif
#endif
#endif
  } while(ret <0 && errno==EINTR);
  return ret;
}


static int socketpair_fd = -1;
int my_socketpair(int family, int type, int protocol, int sv[2])
{
  static struct sockaddr_in my_addr;
  struct sockaddr_in addr,addr2;
  int retries=0;
  ACCEPT_SIZE_T len;

  memset((char *)&addr,0,sizeof(struct sockaddr_in));

  if(socketpair_fd==-1)
  {
    if((socketpair_fd=socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      SP_DEBUG((stderr, "my_socketpair:socket() failed, errno:%d\n",
		errno));
      return -1;
    }

    memset((char *)&my_addr,0,sizeof(struct sockaddr_in));
    my_addr.sin_family=AF_INET;
    my_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    my_addr.sin_port=htons(0);


    if(bind(socketpair_fd, (struct sockaddr *)&my_addr, sizeof(addr)) < 0)
    {
      SP_DEBUG((stderr, "my_socketpair:bind() failed, errno:%d\n",
		errno));
      close(socketpair_fd);
      socketpair_fd=-1;
      return -1;
    }

    len = sizeof(my_addr);
    if(getsockname(socketpair_fd,(struct sockaddr *)&my_addr,&len) < 0)
    {
      SP_DEBUG((stderr, "my_socketpair:getsockname() failed, errno:%d\n",
		errno));
      close(socketpair_fd);
      socketpair_fd=-1;
      return -1;
    }

    if(listen(socketpair_fd, 5) < 0)
    {
      SP_DEBUG((stderr, "my_socketpair:listen() failed, errno:%d\n",
		errno));
      close(socketpair_fd);
      socketpair_fd=-1;
      return -1;
    }

    set_nonblocking(socketpair_fd, 1);

    my_addr.sin_addr.s_addr=inet_addr("127.0.0.1");
  }


  if((sv[1]=socket(AF_INET, SOCK_STREAM, 0)) <0) {
    SP_DEBUG((stderr, "my_socketpair:socket() failed, errno:%d (2)\n",
	      errno));
    return -1;
  }


retry_connect:
  retries++;
  if(connect(sv[1], (struct sockaddr *)&my_addr, sizeof(addr)) < 0)
  {
    SP_DEBUG((stderr, "my_socketpair:connect() failed, errno:%d (%d)\n",
	      errno, EWOULDBLOCK));
    if(errno != EWOULDBLOCK)
    {
      int tmp2;
      for(tmp2=0;tmp2<20;tmp2++)
      {
	int tmp;
	ACCEPT_SIZE_T len2;

	len2=sizeof(addr);
	tmp=accept(socketpair_fd,(struct sockaddr *)&addr,&len2);

	if(tmp!=-1) {
	  SP_DEBUG((stderr, "my_socketpair:accept() failed, errno:%d\n",
		    errno));
	  close(tmp);
	}
	else
	  break;
      }
      if(retries > 20) return -1;
      goto retry_connect;
    }
  }


  do
  {
    ACCEPT_SIZE_T len3;

    len3=sizeof(addr);
  retry_accept:
    sv[0]=accept(socketpair_fd,(struct sockaddr *)&addr,&len3);

    if(sv[0] < 0) {
      SP_DEBUG((stderr, "my_socketpair:accept() failed, errno:%d (2)\n",
		errno));
      if(errno==EINTR) goto retry_accept;
      close(sv[1]);
      return -1;
    }

    set_nonblocking(sv[0],0);

    len=sizeof(addr);
    if(getpeername(sv[0], (struct sockaddr *)&addr,&len)) {
      SP_DEBUG((stderr, "my_socketpair:getpeername() failed, errno:%d\n",
		errno));
      return -1;
    }
    len=sizeof(addr);
    if(getsockname(sv[1],(struct sockaddr *)&addr2,&len) < 0) {
      SP_DEBUG((stderr, "my_socketpair:getsockname() failed, errno:%d\n",
		errno));
      return -1;
    }
  }while(len < (int)sizeof(addr) ||
	 addr2.sin_addr.s_addr != addr.sin_addr.s_addr ||
	 addr2.sin_port != addr.sin_port);

  SP_DEBUG((stderr, "my_socketpair: succeeded\n",
	    errno));

  return 0;
}

int socketpair_ultra(int family, int type, int protocol, int sv[2])
{
  int retries=0;

  while(1)
  {
    int ret=my_socketpair(family, type, protocol, sv);
    if(ret>=0) return ret;

    switch(errno)
    {
      case EAGAIN: break;

      case EADDRINUSE:
	if(retries++ > 10) return ret;
	break;

      default:
	return ret;
    }
  }
}


FILE *output;
struct pollfd pollset[2];
int fds[2];
static int sent=0;
int xcalls=0;

int ping(int fd)
{
  int r;
  sent++;
  if(sent > 10000)
  {
    fprintf(output,xcalls ? "SEMIWORKING" : "WORKING");
    exit(0);
  }
  do {
    r=send(fds[fd],"x",1,MSG_OOB);
  }while(r < 0 && errno==EINTR);
  if(r!=1)
  {
    fprintf(output,"XBYTES\n");
    exit(0);
  }

  pollset[fd].events &=~ POLLWRBAND;
  pollset[!fd].events |= POLLRDBAND;
}

int pong(int fd)
{
  char foo[2];
  int r;
   do {
    r=recv(fds[fd], &foo, 2, MSG_OOB);
  }while(r < 0 && errno==EINTR);
  if(r!=1)
  {
    fprintf(output,"XBYTES\n");
    exit(0);
  }

  pollset[fd].events &=~ POLLRDBAND;
  pollset[fd].events |=  POLLWRBAND;
}

void pang(int fd)
{
  char foo[2];
  int r;
  xcalls++;
   do {
    r=recv(fds[fd], &foo, 2, 0);
  }while(r < 0 && errno==EINTR);
  if(r<0 && errno==EAGAIN) return;

  fprintf(output,"INLINED\n");
  exit(0);
}

int main(int argc, char **argv)
{
  int e;
  output=fopen("conftest.out.2","w");
  socketpair_ultra(AF_UNIX, SOCK_STREAM, 0, fds);

#define INIT(X) do {\
  set_nonblocking(fds[X],1); \
  pollset[X].fd=fds[X]; \
  pollset[X].events=POLLIN; \
}while(0);

  INIT(0);
  INIT(1);

  ping(0);

  while(1)
  {
    if(!poll(pollset, 2, 10000))
    {
      fprintf(output,sent>1 ? "WORKS_A_LITTLE\n" : "TIMEOUT\n");
      exit(0);
    }

    for(e=0;e<2;e++)
    {
      if(pollset[e].revents & POLLRDBAND) pong(e);
      if(pollset[e].revents & POLLWRBAND) ping(e);
      if(pollset[e].revents & POLLIN) pang(e);
    }
  }
}  ],
pike_cv_system_oob_working="`cat conftest.out.2`",
pike_cv_system_oob_working=UNKNOWN,
pike_cv_system_oob_working=UNKNOWN)
  
  rm conftest.out.2 >/dev/null 2>/dev/null || :
fi
])
AC_MSG_RESULT($pike_cv_system_oob_working)

case "x$pike_cv_system_oob_working" in
  xWORKING)        AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,3)  ;;
  xSEMIWORKING)    AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,2)  ;;
  xINLINED)        AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,1)  ;;
  xWORKS_A_LITTLE) AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,1)  ;;
  xXBYTES)         AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,0)  ;;
  xTIMEOUT)        AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,0)  ;;
  *)               AC_DEFINE_UNQUOTED(PIKE_OOB_WORKS,-1) ;; #unknown
esac

#######################################################################

MY_AC_CHECK_PRINTF_INT_TYPE(size_t,
			    "z" "" "l" "ll" "L", "",
			    PRINTSIZET,
			    [%${res}u, %${res}x])
MY_AC_CHECK_PRINTF_INT_TYPE(ptrdiff_t,
			    "t" "" "l" "ll" "L", "",
			    PRINTPTRDIFFT,
			    [%${res}d, %${res}x])
MY_AC_CHECK_PRINTF_INT_TYPE(INT64,
			    "" "l" "ll" "I64" "L", "l",
			    PRINTINT64,
			    [%${res}d, %${res}x])

#######################################################################

AC_MSG_CHECKING(if union initialization works)
AC_CACHE_VAL(pike_cv_have_union_init, [
  AC_TRY_RUN([
    struct foo {int a;};
    struct bar {char b[2];};
    union anything
    {
      struct foo foo;
      struct bar bar;
    };
    struct svalue
    {
      unsigned type;
      unsigned subtype;
      union anything u;
    };
    struct svalue my_svalue = {0, 0, {{4711}}};
    int main() {
      return !(my_svalue.u.foo.a == 4711);
    }
  ],
  pike_cv_have_union_init=yes,
  pike_cv_have_union_init=no,
  pike_cv_have_union_init=no)])
AC_MSG_RESULT($pike_cv_have_union_init)
if test "$pike_cv_have_union_init" = yes; then
  AC_DEFINE(HAVE_UNION_INIT)
fi

#######################################################################

AC_MSG_CHECKING(if cpu time is thread local)
AC_CACHE_VAL(pike_cv_thread_local_cpu_time, [
  rm -f confdefs.out.2 2>/dev/null
  AC_TRY_RUN([
#include <stdio.h>

/* libc_r:fputs on AIX 4.2 is broken. */
#define FPUTS(S, F)	fwrite(S, sizeof(S)-sizeof(""), 1, F)

#ifdef PIKE_THREADS

#ifndef TOSTR
#define TOSTR(X)	#X
#endif
#ifndef DEFINETOSTR
#define DEFINETOSTR(X)	TOSTR(X)
#endif

#define CONFIGURE_TEST

#include "port.c"
#include "rusage.c"
#include "threads.c"

PIKE_MUTEX_T m;
COND_T c;

cpu_time_t work_time, wait_time;

TH_RETURN_TYPE work_thread (void *dummy)
{
  struct timeval rt_start, rt;
  cpu_time_t start;
  FPUTS("work_thread waiting.\n", stderr);
  mt_lock (&m);
  FPUTS("work_thread start.\n", stderr);
  GETTIMEOFDAY (&rt_start);
  start = get_cpu_time();
  do {
    cpu_time_t t = get_cpu_time();
    GETTIMEOFDAY (&rt);
    if (t == (cpu_time_t) -1) {
      work_time = t;
      break;
    }
    work_time = t - start;
  } while (work_time < (CPU_TIME_TICKS / 10) && rt.tv_sec <= rt_start.tv_sec + 1);
  FPUTS("work_thread releasing main.\n", stderr);
  co_signal (&c);
  mt_unlock (&m);
  FPUTS("work_thread done.\n", stderr);
  return 0;
}

int main()
{
  cpu_time_t start;
  THREAD_T worker;
  FILE *res = fopen ("confdefs.out.2", "w"); /* weird name to circumvent configure cleanups */
  if (!res) return 2;

  really_low_th_init();

  mt_init (&m);
  co_init (&c);

  mt_lock (&m);
  FPUTS("Creating work_thread.\n", stderr);
  if (th_create (&worker, work_thread, NULL)) {
    FPUTS("unknown (failed to create thread)", res);
    fclose (res);
    return 3;
  }

  start = get_cpu_time();
  co_wait (&c, &m);
  wait_time = get_cpu_time() - start;
  if (start == (cpu_time_t) -1 || work_time == (cpu_time_t) -1) {
    FPUTS("unknown (get_cpu_time doesn't work)", res);
    fclose (res);
    return 4;
  }
  if (work_time < (CPU_TIME_TICKS / 10)) {
    fprintf (res, "unknown (get_cpu_time doesn't work - loop took only %ld ms)",
	     (long) (work_time / (CPU_TIME_TICKS / 1000)));
    fclose (res);
    return 5;
  }

  if (work_time > wait_time)
    return 0; /* It is thread local. */
  else {
    FPUTS("no", res);
    fclose (res);
    return 1; /* It is not thread local. */
  }
}

#else
int main()
{
  FILE *res = fopen ("confdefs.out.2", "w"); /* weird name to circumvent configure cleanups */
  if (!res) return 6;
  FPUTS("no", res);
  fclose (res);
  return 1;
}
#endif
    ], [
      pike_cv_thread_local_cpu_time=yes
    ], [
      if test -f confdefs.out.2; then
        pike_cv_thread_local_cpu_time=`cat confdefs.out.2`
      else
        AC_MSG_WARN([Test failed to compile.
Problems in port.c, rusage.c or threads.c with CONFIGURE_TEST is defined?])
        # Don't set pike_cv_thread_local_cpu_time here so that the
        # failure doesn't get cached.
        result="unknown (compilation failed)"
      fi
    ], [
      pike_cv_thread_local_cpu_time="unknown (cross compilation)"
    ])
  rm -f confdefs.out.2 2>/dev/null
])
test x"$pike_cv_thread_local_cpu_time" != x && result="$pike_cv_thread_local_cpu_time"
AC_MSG_RESULT($result)
if test "$pike_cv_thread_local_cpu_time" = yes; then
  AC_DEFINE(CPU_TIME_IS_THREAD_LOCAL, PIKE_YES)
elif test "$pike_cv_thread_local_cpu_time" = no; then
  AC_DEFINE(CPU_TIME_IS_THREAD_LOCAL, PIKE_NO)
else
  AC_DEFINE(CPU_TIME_IS_THREAD_LOCAL, PIKE_UNKNOWN)
fi

#######################################################################

# Set info about shared libraries.
AC_SUBST(SO)
AC_SUBST(LDSHARED)
AC_SUBST(CCSHARED)
AC_SUBST(LINKFORSHARED)

# SO is the extension of shared libraries
# -- usually so, sl on HP-UX
AC_MSG_CHECKING(SO)
if test -z "$SO"
then
	case "$pike_cv_sys_os" in
	hp*|HP*)   SO=sl;;
	*)	   SO=so;;
	esac
fi
AC_MSG_RESULT($SO)
# LDSHARED is the ld *command* used to create shared library
# -- "ld" on SunOS 4.x.x, "ld -G" on SunOS 5.x, "ld -shared" on IRIX 5
AC_MSG_CHECKING(LDSHARED)
if test -z "$LDSHARED" ; then
  case "$pike_cv_sys_os" in
    AIX*)
      if test "$GCC" = yes ; then
        if test "`uname -r`" -ge 2 -a "`uname -v`" -eq 4 ; then
          LDSHARED="ld -G -bexpall"
	else if test "`uname -v`" -gt 4 ; then
	    # AIX 5L+
	    LDSHARED="ld -G"
	  else
	    # AIX 4.1 and earlier don't have/have unreliable
	    # handling of dlopen et al.
	    #
	    # Even AIX 4.2.1 has buggy dlopen -- NEVER attempt
	    # to dlopen a file that hasn't been linked with -G.
	    pike_cv_sys_dynamic_loading=no
	    LDSHARED="ld"
	  fi
        fi
      else
        if test "`uname -r`" -ge 3 -a "`uname -v`" -eq 4 ; then
          LDSHARED="ld -G -bexpall"
	else if test "`uname -v`" -gt 4 ; then
	    # AIX 5L+
	    LDSHARED="ld -G"
	  else
	    # AIX 4.1 and earlier don't have/have unreliable
	    # handling of dlopen et al.
	    #
	    # Even AIX 4.2.1 has buggy dlopen -- NEVER attempt
	    # to dlopen a file that hasn't been linked with -G.
	    pike_cv_sys_dynamic_loading=no
	    LDSHARED="ld"
	  fi
        fi
      fi
    ;;
    Darwin*)
      LDSHARED="ld -bundle -bind_at_load -flat_namespace -undefined suppress -lbundle1.o"
    ;;
    IRIX*)
      if test "$GCC" = yes ; then
        # egcs defaults to building -n32 objects
        LDSHARED="ld -shared -n32"
      else
        LDSHARED="ld -shared"
      fi
      # -woff isn't understood by ld on Irix 5.
      if test "`uname -r`" -ge 6 ; then
        LDSHARED="$LDSHARED -woff 84,85,134"
      else :; fi
    ;;
    SunOS*) LDSHARED="ld";;
    Solaris) LDSHARED="/usr/ccs/bin/ld -G";;
    hp*|HP*) LDSHARED="ld -b";;
    OSF*) LDSHARED="ld -expect_unresolved '*' -shared -msym -O3";;
    DYNIX/ptx*) LDSHARED="ld -G";;
    next*) LDSHARED="$REALCC $CFLAGS -nostdlib -r";;
    Linux*) LDSHARED="$REALCC -shared";;
    GNU*) LDSHARED="ld -Bshareable";;
    FreeBSD*) LDSHARED="$REALCC -Wl,-Bshareable";;
    NetBSD*) LDSHARED="ld -Bshareable";;
    OpenBSD*) LDSHARED="ld -Bshareable";;
    BSD/OS*)
      case "`uname -r`" in
       [4-9].*) LDSHARED="$REALCC -shared";;
        *) LDSHARED="shlicc -r";;
      esac
    ;;
    SCO_SV*) LDSHARED="$REALCC -G -KPIC -Wl,-Bexport";;
    UNIX_SV*) LDSHARED="ld -G";;
    UnixWare*|OpenUNIX*)
      if test "$GCC" = yes ; then
        LDSHARED="$REALCC -G -fPIC"
      else
        LDSHARED="$REALCC -G -KPIC -Wl,-Bexport"
      fi
    ;;
    Windows_NT*|NT*)
       LDSHARED="pntld"
    ;;
    *) LDSHARED="ld";;
  esac
fi
AC_MSG_RESULT($LDSHARED)

# CCSHARED are the C *flags* used to create objects to go into a shared
# library -- this is only needed for a few systems
AC_MSG_CHECKING(CCSHARED)
AC_CACHE_VAL(pike_cv_sys_ccshared,[
  if test -z "$CCSHARED" ; then
    if test "$GCC" = yes ; then
      case "$pike_cv_sys_os" in
	BSD/OS*)
         case "`uname -r`" in
           4.*) CCSHARED="-fPIC";;
           *) CCSHARED="";;
         esac
	;;
	Darwin*)
	  CCSHARED="-fPIC"
	;;
	Solaris*)
	  # The Image module runs out of symbol reference space unless we
	  # use the large PIC model:
	  # ld: fatal: too many symbols require `small' PIC references:
	  # 	have 2205, maximum 2048 -- recompile some modules -K PIC.
	  CCSHARED="-fPIC"
	;;
	*)
	  AC_SYS_COMPILER_FLAG(-fPIC, fPIC, CCSHARED, [
	    AC_SYS_COMPILER_FLAG(-fpic, fpic, CCSHARED)
	  ])
	;;
      esac
    else
      case "$pike_cv_sys_os" in
	Darwin*)
	  CCSHARED="-fPIC"
	;;
        IRIX*)
          AC_SYS_COMPILER_FLAG(-share,cc_shared,CCSHARED)
        ;;
	hp*|HP*) CCSHARED="+z"; ;;
	FreeBSD*) CCSHARED="-fpic";;
	SCO_SV*) CCSHARED="-KPIC -dy -Bdynamic";;
        UnixWare*|OpenUNIX*) CCSHARED="-KPIC -dy -Bdynamic";;
	Solaris*) CCSHARED="-KPIC -Bdynamic";;
	Windows_NT*) CCSHARED="-shared" ;;
      esac
    fi
  fi
  OLD_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS $CCSHARED"
  AC_TRY_COMPILE([], [exit(0);],
    pike_cv_sys_ccshared="$CCSHARED", pike_cv_sys_ccshared='')
  CFLAGS="$OLD_CFLAGS"
])
CCSHARED="$pike_cv_sys_ccshared"
AC_MSG_RESULT($CCSHARED)

AC_MSG_CHECKING(LINKFORSHARED)

AC_CACHE_VAL(pike_cv_sys_linkforshared,[
# LINKFORSHARED are the flags passed to the $(CC) command that links
# the pike executable -- this is only needed for a few systems
if test -z "$LINKFORSHARED"
then
  LINKFORSHARED=""
  if test "$GCC" = yes ; then
    case "$pike_cv_sys_os" in
      AIX*)
        if test "`uname -v`" -gt 4 ; then
	  # This is probably wrong, but I don't have a man page for ld yet.
	  LINKFORSHARED=""
	else
	  LINKFORSHARED="-Wl,-bexpall -Wl,-brtl"
	fi
      ;;
      Darwin*) LINKFORSHARED="-dynamic";;
      hp*|HP*) LINKFORSHARED="-Wl,-E";;
      Linux*) LINKFORSHARED="-rdynamic";;
      BSD/OS*)
        case "`uname -r`" in
         4.*) LINKFORSHARED="-rdynamic";;
       esac
      ;;
      BSD/OS*)
        case "`uname -r`" in
         4.*) LINKFORSHARED="-rdynamic";;
       esac
      ;;
      GNU*) LINKFORSHARED="-rdynamic";;
      NetBSD*) LINKFORSHARED="-Wl,-E";;
      next*) LINKFORSHARED="-u libsys_s";;
      SCO_SV*) LINKFORSHARED="-fpic -Wl,-Bexport";;
      # What about UNIX_SV?
      UnixWare*|OpenUNIX*) LINKFORSHARED="-fpic -Wl,-Bexport";;

      FreeBSD*)
        AC_TRY_RUN([int main(){exit(
#ifdef __ELF__
    0
#else
    1
#endif
);}
        ],LINKFORSHARED=-rdynamic)
      ;;
    esac
  else
    case "$pike_cv_sys_os" in
      AIX*)
        if test "`uname -v`" -gt 4 ; then
	  LINKFORSHARED="-Bexport"
	else
	  LINKFORSHARED="-Wl,-bexpall -Wl,-brtl"
	fi
      ;;
      Darwin*) LINKFORSHARED="-dynamic";;
      hp*|HP*) LINKFORSHARED="-Wl,-E";;
      Linux*) LINKFORSHARED="-rdynamic";;
      GNU*) LINKFORSHARED="-rdynamic";;
      next*) LINKFORSHARED="-u libsys_s";;
      SCO_SV*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";;
      # What about UNIX_SV?
      UnixWare*|OpenUNIX*) LINKFORSHARED="-Bdynamic -dy -Wl,-Bexport";;
      Windows_NT*|NT*) LINKFORSHARED="-rdynamic";;

      FreeBSD*)
        AC_TRY_RUN([int main(){exit(
#ifdef __ELF__
    0
#else
    1
#endif
);}
        ],LINKFORSHARED=-rdynamic)
      ;;
    esac
  fi
fi


   OLD_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS $LINKFORSHARED"
   AC_TRY_RUN([int main() { exit(0); }],
 pike_cv_sys_linkforshared="$LINKFORSHARED", pike_cv_sys_linkforshared='', pike_cv_sys_linkforshared='')
   CFLAGS="$OLD_CFLAGS"
])

LINKFORSHARED="$pike_cv_sys_linkforshared"

AC_MSG_RESULT($LINKFORSHARED)

#############################################################################

if test $ac_cv_prog_gcc = yes; then
  AC_MSG_CHECKING(for libgcc file name)
  if test -f "$pike_cv_libgcc_filename"; then :; else
    # libgcc has gone away probably due to gcc having been upgraded.
    # Invalidate the entry.
    unset pike_cv_libgcc_filename
  fi
  AC_CACHE_VAL(pike_cv_libgcc_filename,
  [
    pike_cv_libgcc_filename="`${CC-cc} $CCSHARED -print-libgcc-file-name`"
    if test -z "$pike_cv_libgcc_filename"; then
      pike_cv_libgcc_filename=no
    else
       if test -f "$pike_cv_libgcc_filename"; then
         pic_name=`echo "$pike_cv_libgcc_filename"|sed -e 's/\.a$/_pic.a/'`
	 if test -f "$pic_name"; then
	   pike_cv_libgcc_filename="$pic_name"
	 fi
       else
         pike_cv_libgcc_filename=no
       fi
    fi
  ])
  AC_MSG_RESULT($pike_cv_libgcc_filename)
  if test x"$pike_cv_libgcc_filename" = xno; then
    LIBGCC=""
  else
    LIBGCC="$pike_cv_libgcc_filename"
  fi
else
  LIBGCC=""
fi
AC_SUBST(LIBGCC)

# In case we're going to use gcc for linking shared objects,
# we should use the -static-libgcc flag if it exists.
# Shared libgcc is nothing but trouble.
STATIC_LIBGCC=""
if test yes = "$GCC" ; then
  AC_SYS_COMPILER_FLAG(-static-libgcc,static_libgcc,STATIC_LIBGCC)
else :; fi

#############################################################################

cat >conftest.c <<EOF
#include <stdio.h>
#include <stdlib.h>
void testfunc(void) {
  fprintf(stderr,"Calling testfunc2\n");
  testfunc2();
  fprintf(stderr,"testfunc2 returned!\n");
  exit(1);
}
EOF

AC_MSG_CHECKING(if dynamic loading works)
AC_CACHE_VAL(pike_cv_sys_dynamic_loading,
[
  echo $CC -c $CFLAGS $CCSHARED conftest.c -o conftest.o 1>&AC_FD_CC
  $CC -c $CFLAGS $CCSHARED conftest.c -o conftest.o 1>&AC_FD_CC 2>&AC_FD_CC

  echo $BINDIR/smartlink $LDSHARED $LDFLAGS conftest.o -o conftest.$SO 1>&AC_FD_CC
  $BINDIR/smartlink $LDSHARED $LDFLAGS conftest.o -o conftest.$SO 1>&AC_FD_CC 2>&AC_FD_CC

  if test -f conftest.$SO ; then
    mv conftest.$SO myconftest.so

    OLD_CFLAGS="$CFLAGS"
    
    CFLAGS="$CFLAGS $LINKFORSHARED"
    OLD_CC="$CC"
    case "$LD" in
      *shlicc)
        CC="$BINDIR/smartlink shlicc"
      ;;
    esac
    AC_TRY_RUN([
#define TESTING
#include "dynamic_load.c"
void testfunc2(void) { exit(0); }
], pike_cv_sys_dynamic_loading=yes, pike_cv_sys_dynamic_loading=no, pike_cv_sys_dynamic_loading=no)
    CFLAGS="$OLD_CFLAGS"
    CC="$OLD_CC"
  else    
    pike_cv_sys_dynamic_loading=no
  fi
  rm -f myconftest.so >/dev/null 2>/dev/null
])
AC_MSG_RESULT($pike_cv_sys_dynamic_loading)


if test "x$with_dynamic_modules" != "xno" ; then
  if test x$pike_cv_sys_dynamic_loading = xno ; then
    with_dynamic_modules=no
  else
    with_dynamic_modules=yes
  fi
fi

#######################################################################
# Since configure doesn't always know if we will be linking with ld or cc,
# We use this little code snippet to add flags to ld that would otherwise
# be given automatically by $(CC) $(CFLAGS)
# /Hubbe
#
if test "$ldflags_is_set" = no ; then
case "x$LD $LDFLAGS" in
  *\$\(CFLAGS\)*)
    # Options in CFLAGS, no stuff needs to be added
  ;;
  x$CC*|x\$\(CC\)*)
    LD="$LD \$(CFLAGS)"
  ;;
  *)
    LD="$LD ${LD_FALLBACK_FLAGS-}"
  ;;
esac

case "x$LDSHARED $LDFLAGS" in
  *\$\(CFLAGS\)*)
    # Options in CFLAGS, no stuff needs to be added
  ;;
  x$CC*|x\$\(CC\)*)
    LDSHARED="$LDSHARED $STATIC_LIBGCC \$(CFLAGS)"
  ;;
  *)
    LDSHARED="$LDSHARED ${LD_FALLBACK_FLAGS-}"
  ;;
esac
fi

##########################################################################

case "x$pike_cv_sys_os" in
  xWindows_NT)
    signal_handler="custom NT"
  ;;

  xAmigaOS)
    signal_handler="custom AmigaOS"
  ;;

  xLinux)
    # Linux's stupid thread implementation doesn't survive USE_WAIT_THREAD.
    signal_handler="SIGCHILD"
    AC_DEFINE(USE_SIGCHILD)
  ;;

  *)
    # This is valid for at least Solaris, AIX and Darwin.
    if grep _REENTRANT confdefs.h >/dev/null 2>&1; then
      signal_handler="wait thread"
      AC_DEFINE(USE_WAIT_THREAD)
    else
      signal_handler="SIGCHILD"
      AC_DEFINE(USE_SIGCHILD)
    fi
  ;;
esac

#######################################################################
# Since all $OPTIMIZE flags have to be automatically included in $CFLAGS
# (because otherwise the tests will not be accurate) we have to remove all
# OPTIMIZE flags from the regular CFLAGS...
# (also some other misc work on the flags)

INTERPRET_DEOPTIMIZE=

OPT_GOT_OFLAG=no
OPT_GOT_MCPU=no
OPT_GOT_MARCH=no
NEW_CFLAGS=
NEW_OPTIMIZE=
OPT_NOT_USED=
for opt in ${CFLAGS-}
do
   case " $OPTIMIZE " in
     *\ $opt\ *) ;;
     *)
       case "$opt" in
	  +O*|-O*)
	    if test "x$OPT_GOT_OFLAG" = "xno"; then
              # only use the first -O flag (from make.conf etc)
	      OPT_GOT_OFLAG=yes 
	      if test "x$with_copt" != xno; then 
		OPTIMIZE="${OPTIMIZE-} $opt" 
	      else
	        OPT_NOT_USED="${OPT_NOT_USED-} $opt"
              fi
	    fi
	    ;;
	  -f*) 
	    if test "x$opt" = "x-fomit-frame-pointer" -a \
	            "x$with_machine_code" = xyes; then
	       INTERPRET_DEOPTIMIZE=-fno-omit-frame-pointer
	       PIKE_MSG_WARN([-fno-omit-frame-pointer used for interpret.c,
since the use of machine code is broken by -fomit-frame-pointer.])
	    fi

	    if test "x$with_copt" != xno; then 
	      OPTIMIZE="${OPTIMIZE-} $opt" 
	    else
	      OPT_NOT_USED="${OPT_NOT_USED-} $opt"
	    fi
	    ;;
	  -parallel|-ip*)
	    # Flags used by icc and ecc.
	    # They need to be propagated to the linker.
	    OPTIMIZE="${OPTIMIZE-} $opt"
	    EXTRALDFLAGS="${EXTRALDFLAGS} $opt"
	    ;;
          -pipe) 
	    OPTIMIZE="${OPTIMIZE-} $opt" 
	    ;;
	  -mcpu*)
            if test "x$OPT_GOT_MCPU" = xno; then 
 	      NEW_CFLAGS="$NEW_CFLAGS $opt"  
	      OPT_GOT_MCPU=yes
	    fi
            ;;
	  -march*)
            if test "x$OPT_GOT_MARCH" = xno; then 
 	      NEW_CFLAGS="$NEW_CFLAGS $opt"  
	      OPT_GOT_MARCH=yes
	    fi
            ;;
          *)  
	    NEW_CFLAGS="$NEW_CFLAGS $opt" 
	    ;;
       esac
     ;;
   esac
done
CFLAGS="$NEW_CFLAGS"

unset NEW_CFLAGS
unset OPT_GOT_OFLAG
unset OPT_GOT_MCPU
unset OPT_GOT_ARCH

AC_SUBST(INTERPRET_DEOPTIMIZE)

#############################################################################
dnl handled above in the CFLAGS/OPTIMIZE split
dnl if test "x$with_copt" = xno ; then
dnl   OPTIMIZE=

dnl The unused code below can be used to implement a good/bad-list
dnl to determine when to zap the -O2 for buggy gccs...
dnl
dnl  else
dnl
dnl  if test "x$GCC" = xyes; then
dnl    BAD=unknown
dnl    case `gcc -v 2>&1` in
dnl      */i?86-*/2.95.3/*19991030*) BAD=no ;;
dnl    esac
dnl  fi

dnl fi

#############################################################################
# Remove the extra args temporarily added to CPPFLAGS.

for extra_arg in $CONF_CPPFLAGS_EXTRA; do
  NEW_CPPFLAGS=""
  for arg in $CPPFLAGS; do
    test "$arg" = "$extra_arg" || NEW_CPPFLAGS="$NEW_CPPFLAGS $arg"
  done
  CPPFLAGS="$NEW_CPPFLAGS"
done

#############################################################################

if test x$with_dynamic_modules = xyes ; then
  dmmsrc="modules/dynamic_module_makefile.in"
  CCSHARED="${CCSHARED} -DDYNAMIC_MODULE"
else
  dmmsrc="modules/static_module_makefile.in"
fi

#############################################################################

PMOD_TARGETS=
for f in $srcdir/*.cmod; do
  PMOD_TARGETS="$PMOD_TARGETS $f"
done
PMOD_TARGETS=`echo $srcdir/*.cmod | sed -e "s/\.cmod/\.c/g" | sed -e "s|$srcdir/|\\$(SRCDIR)/|g"`
AC_SUBST(PMOD_TARGETS)

#############################################################################

echo
echo "Compiler summary:"
echo
echo "C Compiler:    $CC"
echo "Preprocessor:  $CPP"
echo "Linker:        $LD"
echo "Shared linker: $LDSHARED"
echo
echo "Shared object extension: $SO"
echo "Dynamic modules: $with_dynamic_modules"
echo
echo "CPPFLAGS:      $CPPFLAGS"
echo "CFLAGS:        $CFLAGS"
echo "CCSHARED:      $CCSHARED"
echo "LINKFORSHARED: $LINKFORSHARED"
echo "LIBGCC:        $LIBGCC"
echo "WARN:          $WARN"
echo "PROFIL:        $PROFIL"
echo "OPTIMIZE:      $OPTIMIZE"
echo "LDFLAGS:       $LDFLAGS"
echo "LIBS:          $LIBS"
echo "prefix:        $prefix"
echo

#############################################################################

export LDFLAGS CFLAGS CPPFLAGS LIBS
export prefix exec_prefix OTHERFLAGS
export TMP_BINDIR DEFINES INSTALL
export noopt_retry

PIKE_SRC_DIR=$srcdir
export PIKE_SRC_DIR
BUILD_BASE=`pwd`
export BUILD_BASE

default_master=$prefix/pike/%d.%d.%d/lib/master.pike
AC_DEFINE_UNQUOTED(DEFAULT_MASTER,"$default_master")

AC_SUBST(WARN)
AC_SUBST(PROFIL)
AC_SUBST(OPTIMIZE)
AC_SUBST(EXTRA_OBJS)
AC_SUBST(RANLIB)
AC_SUBST(DEBUGDEF)
AC_SUBST(EXTRA_MODULE_REQUIREMENTS)
AC_SUBST(noopt_retry)

pike_cv_prog_CC="${CC}"

#############################################################################

AC_CONFIG_SUBDIRS(modules post_modules)

AC_SUBST_FILE(dependencies)
dependencies=$srcdir/dependencies

AC_SUBST(YACC)
AC_SUBST(INSTALL)
AC_SUBST(ac_configure_args)

AC_SUBST(dmmsrc)

common_module_makefile=modules/common_module_makefile
AC_SUBST_FILE(common_module_makefile)

AC_OUTPUT(Makefile \
          modules/common_module_makefile \
          modules/static_module_makefile \
          post_modules/static_module_makefile:modules/static_module_makefile.in \
          modules/dynamic_module_makefile:$dmmsrc \
          post_modules/dynamic_module_makefile:$dmmsrc \
          precompile.sh specs, [
            echo foo >stamp-h
            chmod +x precompile.sh
          ])

# Check if we have to enable some bundles
if test "$pike_bundle_dir" = ""; then :; else
  bundle_info="`find . -type f -name '*.bundle'`"
  if test "$bundle_info" = ""; then :; else
    # We have some bundles to enable.

    cat <<EOF


###################################################
# Extracting bundles...
#   Requested from:
`echo "$bundle_info"|sed -e 's/^/#     /'`
EOF
    bundles=`echo "$bundle_info" | sed -e 's/.*\///g' -e 's/\.bundle$//' | sort | uniq`
    # FIXME: Intra-bundle dependencies?
    for bundle in $bundles; do
      AC_MSG_CHECKING(for bundle $bundle)
      for dist_file in `cd "$pike_bundle_dir" && echo ${bundle}*.tar.gz` no; do
        if test -f "$pike_bundle_dir/$dist_file"; then
	  dist_file="$pike_bundle_dir/$dist_file"
	  break
	fi
      done
      AC_MSG_RESULT($dist_file)
      if test "$dist_file" = "no"; then
        AC_MSG_WARN([Bundle $bundle not found.
Requested from:
$bundle_info])
        bundle_info=`echo "$bundle_info" | grep -v "$bundle.bundle"`
      else
        # First extract the bundle.

        # Bundle source is expected to be extracted into a directory
	# of the same name as the bundle.
        bundle_source_dir=`echo "$dist_file"|sed -e 's/.tar.gz$//'`

        if test -f "$bundle_source_dir/configure"; then
	  # Bundle source already extracted.
	  :
	else
	  echo "Extracting bundle $dist_file..."
	  ( cd "$pike_bundle_dir" && \
	    gzip -cd "$dist_file" | tar xf -
	  )
	fi
	# Use ptar.gz instead of tar.gz to avoid problems with globbing.
	if test -f "${bundle_source_dir}.ptar.gz"; then
	  # There's a patch file.
	  if test -f "${bundle_source_dir}/pike-patch.stamp"; then :; else
	    echo "Patching bundle $dist_file..."
	    ( cd "$pike_bundle_dir" && \
	      gzip -cd "${bundle_source_dir}.ptar.gz" | tar xf -
	      touch "${bundle_source_dir}/pike-patch.stamp"
	    )
	  fi
	fi
	if test -d "bundles/$bundle.build" || \
	   mkdir "bundles/$bundle.build"; then :; else
	  echo "Failed to create bundle build directory bundles/$bundle.build"
	  exit 1
	fi
	( cd "bundles/$bundle.build" || exit 1

	  # Make sure stuff in /usr/ccs/bin and the like can be found.
	  # We also want to hide some possibly broken binaries (notably
	  # makeinfo) with ${pike_bundle_prefix}/bin.
	  OLD_PATH="$PATH"
	  PATH="${pike_bundle_prefix}/bin:$PATH:$EXTRA_PATH"
	  export PATH

	  if test -f "Makefile"; then :; else
            # Configure bundle.
	    # Note
	    #  * Configure for installation in $pike_bundle_prefix.
	    #  * Make sure that only static libraries are built.
	    #  * Make sure it uses a cache file, and that it doesn't
	    #    conflict with ours.

	    if test -f "$bundle_source_dir/configure"; then :; else
	      echo "Bundle configure script $bundle_source_dir/configure not found."
	      exit 1
	    fi

	    echo "Configuring bundle $bundle_source_dir in `pwd`..."

	    # INSTALL seems to be thrashed here, since we're in a
	    # subshell unsetting it shouldn't be a problem.
	    unset INSTALL

	    # Any libraries must be compiled with -pic, since we want
	    # to be able use them in dynamic modules.
	    OLD_CFLAGS="$CFLAGS"
	    CFLAGS="$CCSHARED $CFLAGS"
	    export CFLAGS

	    extra_configure_args=""
	    # Some libraries insist in using config.guess;
	    # they tend to have problems with rntcl...
	    # Let's help them along.
	    if echo foo "$CC" | egrep 'rntc.|rnt.cl' >/dev/null; then
	      cpu="`uname -m`"
	      if test "$cpu" = "x86"; then
	        # Normalize the cpu.
	        cpu="i386"
	      fi
	      extra_configure_args="--build=${cpu}-unknown-winnt`uname -r`"
	    fi

	    echo "${CONFIG_SHELL-/bin/sh} \"$bundle_source_dir/configure\"" \
	      "--prefix=\"$pike_bundle_prefix\"" ${extra_configure_args} \
	      "--disable-shared --cache-file=config.cache"
	    ${CONFIG_SHELL-/bin/sh} "$bundle_source_dir/configure" \
	      --prefix="$pike_bundle_prefix" ${extra_configure_args} \
	      --disable-shared --cache-file=config.cache || exit 1

	    # Restore CFLAGS
	    CFLAGS="$OLD_CFLAGS"

	    if test -f "Makefile"; then :; else
	      echo "Makefile not found in `pwd`."
	      exit 1
	    fi
	  fi

	  # Do we need to patch the Makefiles with respect to SHELL?
	  if test "$pike_cv_make_supports_spaces_in_SHELL" = "no"; then
	    echo "Patching Makefiles..."
	    echo "Patching Makefiles..." >&AC_FD_CC
	    for f in `find . -type f \( -name Makefile -o -name makefile \) -print`; do
	      echo "  Patching $f..."
	      echo "  Patching $f..." >&AC_FD_CC
	      sed -e '/^SHELL[ 	]*=/s/^SHELL/PIKE_SHELL/' \
		  -e 's/\$(SHELL)/\$(PIKE_SHELL)/g' <"$f" >"$f.pike.patch" \
		2>&AC_FD_CC || exit 1
	      if cmp "$f" "$f.pike.patch" >&AC_FD_CC 2>&AC_FD_CC; then
	        echo "  No change."
	        echo "  No change." >&AC_FD_CC
	        rm -f "$f.pike.patch"
	      else
	        echo "  Changed."
	        echo "  Diff:" >&AC_FD_CC
	        diff "$f" "$f.pike.patch" >&AC_FD_CC 2>&AC_FD_CC
	        mv -f "$f.pike.patch" "$f" || exit 1
	      fi
	    done
	  fi

	  # Compile bundle.
	  echo "Compiling bundle $bundle in `pwd`..."
	  ${MAKE-make} || exit 1

	  # Install bundle.
	  echo "Installing bundle $bundle in ${pike_bundle_prefix}..."
	  ${MAKE-make} install || exit 1

	  # Restore PATH
	  PATH="$OLD_PATH"

	  # Done.
	  echo "Bundle $bundle installed successfully."
	) || exit 1
      fi
    done
    # Kludge for rntcl in case *.lib hasn't been copied on install.
    if echo foo "$CC" | egrep 'rntc.|rnt.cl' >/dev/null; then
      echo "Fixing libraries..."
      for f in `(cd bundles/lib && echo lib*.a)` no; do
        if test "$f" = "no"; then
	  break
	fi
        lib_name="`echo $f|sed -e 's/^lib\(.*\)\.a$/\1.lib/'`"
	if cmp "bundles/lib/$f" "bundles/lib/$lib_name" 2>/dev/null; then
	  :
	else
	  echo "  $f ==> $lib_name"
	  rm -f "bundles/lib/$lib_name" 2>/dev/null
	  cp "bundles/lib/$f" "bundles/lib/$lib_name"
	fi
      done
    fi
    # Clear the caches.
    echo Clearing cached variables related to the bundles.
    for varname in `cat $bundle_info|sed -e 's/^[[ 	]]*//'|sort|uniq` no; do
      if test "$varname" = "no"; then :; else
	unset $varname
      fi
    done
    if test -r "$cache_file"; then
      for varname in `cat $bundle_info|sed -e 's/^[[ 	]]*//'|sort|uniq` no; do
        if test "$varname" = "no"; then :; else
          sed -e '/^'"$varname"'=/d' <"$cache_file" >"$cache_file.new" && \
            mv -f "$cache_file.new" "$cache_file" || exit 1
        fi
      done
    fi
    # Rerun configure
    cat <<EOF


Rerunning configure with the bundles `echo $bundles` enabled.


EOF
    # Restore CFLAGS, CPPFLAGS and LDFLAGS to what they were
    # when configure was started.
    if test "$cflags_is_set" = "no"; then
      unset CFLAGS
    else
      CFLAGS="${initial_cflags}"
      export CFLAGS
    fi
    if test "$cppflags_is_set" = "no"; then
      unset CPPFLAGS
    else
      CPPFLAGS="${initial_cppflags}"
      export CPPFLAGS
    fi
    if test "$ldflags_is_set" = "no"; then
      unset LDFLAGS
    else
      LDFLAGS="${initial_ldflags}"
      export LDFLAGS
    fi
    echo ${CONFIG_SHELL-/bin/sh} "$srcdir/configure" $ac_configure_args --without-bundles
    eval exec ${CONFIG_SHELL-/bin/sh} "$srcdir/configure" $ac_configure_args --without-bundles
    exit 17
  fi
fi

# NOTE: M4 uses [] as quotes.

PIKE_VERSION="`sed -n -e 's/^.*PIKE_MAJOR_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h`.`sed -n -e 's/^.*PIKE_MINOR_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h`.`sed -n -e 's/^.*PIKE_BUILD_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h`"
PIKE_VERSION_LONG="Pike v`sed -n -e 's/^.*PIKE_MAJOR_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h`.`sed -n -e 's/^.*PIKE_MINOR_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h` release `sed -n -e 's/^.*PIKE_BUILD_VERSION[[ \t]]*\([[^ \t]]*\)/\1/p' <$srcdir/version.h`"


if test "x$with_cdebug" = x; then
  with_cdebug=no
fi
if test "x$with_rtldebug" = x; then
  with_rtldebug=no
fi
if test "x$with_dmalloc" = x; then
  with_dmalloc=no
fi
with_mmx=$pike_cv_sys_has_working_mmx
if test "x$with_mmx" = x; then
  with_mmx=no
fi

if test "x$with_copt" = xno ; then 
  opt_reasons="  ($OPT_NOT_USED turned off with --without-copt)"
else
  opt_reasons=
fi

rm config.info 2>/dev/null

float_is_ieee=""
if test "x$float_type" = "xfloat" -a "x$pike_cv_float_type" = "xieee_big"; then
  float_is_ieee=" (ieee big endian)"
else if test "x$float_type" = "xfloat" -a "x$pike_cv_float_type" = "xieee_little"; then
  float_is_ieee=" (ieee little endian)"
else if test "x$float_type" = "xdouble" -a "x$pike_cv_double_type" = "xieee_big"; then
  float_is_ieee=" (ieee big endian)"
else if test "x$float_type" = "xdouble" -a "x$pike_cv_double_type" = "xieee_little"; then
  float_is_ieee=" (ieee little endian)"
fi; fi; fi; fi

cat >>config.info <<EOF
=========================================================
$PIKE_VERSION_LONG configuration summary

install information:
prefix........ $prefix
pike binary... $prefix/bin/pike
pike library.. $prefix/pike/${PIKE_VERSION}/lib

system information:
system.... $UNAME`echo $pike_cv_libgcc_filename | sed -n -e 's+^.*gcc-lib/\([[^/]]*\)/.*$+ (\1)+p'`
EOF

uname -a >/dev/null 2>/dev/null && echo "uname..... `uname -a`" >>config.info
hostname >/dev/null 2>/dev/null && echo "hostname.. `hostname`" >>config.info
whoami >/dev/null 2>/dev/null   && echo "user...... `whoami`" >>config.info

# too many dots makes too long lines, keep them as short as possible
# inside each section

cat >>config.info <<EOF

build information:
source path..... $srcdir
build path...... $BUILDDIR
cpp............. $CPP
cc.............. $CC
ld.............. $LD
cc shared....... $CCSHARED
ld shared....... $LINKFORSHARED
pike............ $PIKE
install......... $INSTALL
shared object... .$SO
libs............ $LIBS
cross-compiled.. $cross_compiling
CPPFLAGS........$CPPFLAGS
CFLAGS (opt)....$OPTIMIZE$opt_reasons
CFLAGS (warn)...$WARN
CFLAGS (misc)...$CFLAGS $OSFLAGS $PROFIL
LDFLAGS.........$LDFLAGS $LINKFORSHARED $EXTRALDFLAGS
EOF

# insert information about debugging tools here, if they are turned on
if test "x$with_valgrind" != xno ; then 
  cat >>config.info <<EOF
valgrind........ yes, using $VALGRIND $VALGRINDARGS
EOF
fi

cat >>config.info <<EOF

features:
PAD_FEATURE([dynamic loading])$pike_cv_sys_dynamic_loading
PAD_FEATURE([threads])$using_threads
PAD_FEATURE([signal handler])$signal_handler
PAD_FEATURE([cdebug])$with_cdebug
PAD_FEATURE([rtldebug])$with_rtldebug
PAD_FEATURE([dmalloc])$with_dmalloc
PAD_FEATURE([mmx])$with_mmx$mmx_reason
PAD_FEATURE([byte code format])$byte_code_format
PAD_FEATURE([module reloc])${with_relocatable_dumped_modules:-no}
PAD_FEATURE([use machine code])$with_machine_code
PAD_FEATURE([int type])$int_type ($sizeof_int_type bytes)
PAD_FEATURE([float type])$float_type ($sizeof_float_type bytes)$float_is_ieee
PAD_FEATURE([pointer size])$ac_cv_sizeof_char_p bytes
EOF

touch confdefs.h 2>/dev/null

OLD_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="-I. -I$srcdir $CPPFLAGS"
AC_TRY_RUN([
#include "global.h"
#include "svalue.h"

int main()
{
   FILE *fp, *out;
   char float_type[80] = "?";
   char int_type[80] = "?";
   char *s;
   struct svalue sval;

   out=fopen("config.info", "a");
   if (!out) return 1;

   fprintf(out,"]PAD_FEATURE([svalue size])[%d bytes (%d+%d+%d)\n",
           sizeof(sval),
           sizeof(sval.type),
           sizeof(sval.subtype),
           sizeof(sval.u));

   fclose(out);

   return 0;
}
],[],[],[:])
rm conftypes.txt 2>/dev/null
CPPFLAGS="$OLD_CPPFLAGS"

echo >>config.info

ls -1 pike_*.feature 2>/dev/null | xargs cat | sort >>config.info 
ls -1 post_modules/*/pike_*.feature modules/*/pike_*.feature 2>/dev/null |  xargs cat | sort >>config.info

if test -f config.warnings; then
  echo >>config.info
  echo 'Warnings and notes summary:' >>config.info
  echo >>config.info
  cat config.warnings >>config.info
fi

echo

echo "=========================================================" >>config.info

cat config.info

if test "x$config_fail" = "x"; then :; else
  echo 1>&2
  echo 1>&2
  echo "Configuration error: $config_fail" 1>&2
  echo 1>&2
  exit 1
fi
