mercury/configure.in

#-----------------------------------------------------------------------------#
# Copyright (C) 1995-1999 The University of Melbourne. 
# This file may only be copied under the terms of the GNU General
# Public Licence - see the file COPYING in the Mercury distribution.
#-----------------------------------------------------------------------------#
#
# configure.in: autoconf source code for `configure' script.
#
# This file is automatically processed by `autoconf' to produce the
# `configure' script.
#
# IMPORTANT NOTE: any changes here will usually also require changes in
# bindist/bindist.configure.in or bindist/bindist.build_vars.in.
#
#-----------------------------------------------------------------------------#
#
# Define a macro MERCURY_MSG, similar to AC_MSG_RESULT, for displaying output.
#
dnl MERCURY_MSG(MESSAGE)
define(MERCURY_MSG,
[echo $1 1>&AC_FD_MSG])
#-----------------------------------------------------------------------------#
AC_INIT(runtime/mercury_wrapper.c)
#-----------------------------------------------------------------------------#
#
# Ensure that all messages are saved to a file `configure.log' by
# invoking ourself recursively without output piped into `tee configure.log'.
# The environment variable `SUPPRESS_LOG_FILE_RECURSION' is used to prevent
# infinite recursion.
#
if test "$SUPPRESS_LOG_FILE_RECURSION" != "yes"; then
	SUPPRESS_LOG_FILE_RECURSION=yes
	export SUPPRESS_LOG_FILE_RECURSION
	trap 0 1 2 3 13 15
	case $# in
		0) exec ${CONFIG_SHELL-/bin/sh} "$0"      ;;
		*) exec ${CONFIG_SHELL-/bin/sh} "$0" "$@" ;;
	esac | exec tee configure.log
	exit
fi
#-----------------------------------------------------------------------------#
AC_CONFIG_HEADER(runtime/mercury_conf.h)
AC_PREFIX_DEFAULT(/usr/local/mercury-`. ./VERSION; echo $VERSION`)
AC_CANONICAL_HOST
FULLARCH="$host"
AC_SUBST(FULLARCH)
AC_DEFINE_UNQUOTED(MR_FULLARCH, "$FULLARCH")
. ./VERSION
AC_DEFINE_UNQUOTED(MR_VERSION, "$VERSION")
if test "$prefix" = "NONE"; then
	PREFIX="$ac_default_prefix"
else
	PREFIX="$prefix"
fi
LIBDIR="$PREFIX/lib/mercury"
NONSHARED_LIB_DIR=${MERCURY_NONSHARED_LIB_DIR=$PREFIX/lib/nonshared}
AC_SUBST(PREFIX)
AC_SUBST(NONSHARED_LIB_DIR)
AC_SUBST(LIBDIR)
DEFAULT_MERCURY_DEBUGGER_INIT_DIR=$LIBDIR/mdb
AC_SUBST(DEFAULT_MERCURY_DEBUGGER_INIT_DIR)
#-----------------------------------------------------------------------------#
case "$host" in
	mips-sgi-irix5.*)
		AC_MSG_WARN(*** Read README.IRIX-5 before proceeding!)
		;;
	*-*-bsdi*)
		AC_MSG_WARN(*** Read README.BSDI before proceeding!)
		;;
esac
#-----------------------------------------------------------------------------#
MERCURY_MSG("looking for an already installed Mercury compiler to bootstrap with...")
AC_PATH_PROG(BOOTSTRAP_MC,mmc)
if test "$BOOTSTRAP_MC" != ""; then
	AC_MSG_CHECKING(whether $BOOTSTRAP_MC works and is sufficiently recent)
	cat > conftest.m << EOF
		% this module contains features which didn't work in
		% previous versions of the Mercury compiler
		:- module conftest.
		:- interface.
		:- import_module io.
		:- pred main(io__state::di, io__state::uo) is det.
		:- implementation.
		:- import_module int.
		main --> 
			% check that we have unchecked_left_shift
			{ _X = unchecked_left_shift(2,2) },
			print("Hello, world\n").
EOF
	if
	 	 echo $BOOTSTRAP_MC conftest >&AC_FD_CC 2>&1 &&
	 	 $BOOTSTRAP_MC conftest </dev/null >&AC_FD_CC 2>&1 &&
		 test "`./conftest 2>&1`" = "Hello, world"
	then
		AC_MSG_RESULT(yes)
	else
		BOOTSTRAP_MC=
		AC_MSG_RESULT(no)
	fi
	rm -f conftest*
fi
#-----------------------------------------------------------------------------#
MERCURY_MSG("looking for GNU Make...")
AC_PROGRAMS_CHECK(GNU_MAKE,gmake make)
if test "$GNU_MAKE" != ""; then
	case "`$GNU_MAKE -v bogus </dev/null 2>&1`" in
		"GNU Make"*)
			;;
		*)
			GNU_MAKE=
	esac
fi
if test "$GNU_MAKE" = ""; then
	AC_MSG_ERROR(cannot find GNU Make)
	exit 1
else
	MERCURY_MSG("found GNU Make: $GNU_MAKE")
fi
AC_SUBST(GNU_MAKE)
#-----------------------------------------------------------------------------#
MERCURY_MSG("looking for a way to create named pipes...")

save_PATH="$PATH"
PATH="$PATH:/etc:/usr/etc:/sbin"

AC_PATH_PROG(MKFIFO,mkfifo)
if test "$MKFIFO" != ""; then
	# check that it really works
	tmp=/tmp/fifo$$
	trap "rm -f $tmp" 1 2 3 13 15
	if $MKFIFO $tmp && test -p $tmp; then
		true
	else
		MKFIFO=""
	fi
	rm -f $tmp
fi
if test "$MKFIFO" = ""; then
	AC_PATH_PROG(MKNOD,mknod)
	if test "$MKNOD" != ""; then
		# check that it really works
		tmp=/tmp/fifo$$
		trap "rm -f $tmp" 1 2 3 13 15
		if $MKNOD $tmp p && test -p $tmp; then
			MKFIFO=mkfifo_using_mknod
		else
			MKNOD=
		fi
	fi
fi
if test "$MKFIFO" = ""; then
	AC_MSG_WARN(cannot find a working \`mkfifo' or \`mknod')
	MKFIFO=none
fi
AC_SUBST(MKFIFO)
test "$MKNOD" = "" && MKNOD=mknod
AC_SUBST(MKNOD)

PATH="$save_PATH"
#-----------------------------------------------------------------------------#
MERCURY_MSG("looking for a way to create temporary files...")

AC_PATH_PROG(MKTEMP,mktemp)
if test "$MKTEMP" != ""; then
	# check that it really works
	TMPFILE="`mktemp /tmp/configure.XXXXXX < /dev/null`"
	case "$TMPFILE" in 
		/tmp/configure.*) rm -f $TMPFILE ;;
		*) MKTEMP="" ;;
	esac
fi
if test "$MKTEMP" = ""; then
	AC_MSG_WARN(cannot find a working \`mktemp', using \`mkdir || exit'')
	MKTEMP=""
fi
AC_SUBST(MKTEMP)
#-----------------------------------------------------------------------------#
AC_PATH_PROG(INSTALL_INFO,install-info)
AC_SUBST(INSTALL_INFO)
#-----------------------------------------------------------------------------#
AC_PROG_CC
AC_SUBST(CC)

# We need to ensure that CFLAGS does not contain `-g', because
# on some (broken) distributions of Linux (specifically Debian 0.93R6),
# the `-lc' and `-lg' libraries have different contents; specifically,
# only the latter contains memalign().  We need to make sure that the
# test for memalign() doesn't use `-g', since `ml' doesn't use `-g'.
CFLAGS="-O"

# we also need to add the appropriate `-I' options so that the test programs
# can #include various Mercury runtime headers.
CFLAGS="-I runtime -I runtime/machdeps $CFLAGS"

# Make sure we search /usr/local/include and /usr/local/lib for
# header files and libraries.  GNU C normally searches /usr/local/include
# by default, but (inconsistently) it does _not_ search /usr/local/lib;
# and in any case the user might be using a different C compiler that
# doesn't search either of those by default.
CFLAGS="-I /usr/local/include $CFLAGS"
LIBS="-L/usr/local/lib $LIBS"

AC_PROG_CPP
AC_C_CROSS
AC_PROG_RANLIB
AC_RETSIGTYPE
# Don't try to use mprotect() on gnu-win32, since it is broken
# (at least for version b18, anyway) and trying it can crash Win95.
case "$host" in
	*-cygwin*)
		ac_cv_func_mprotect=no ;;
esac
AC_HAVE_FUNCS(sysconf getpagesize memalign mprotect sigaction setitimer strerror memmove)
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(sys/wait.h, HAVE_SYS_WAIT_H=1)
if test "$HAVE_SYS_WAIT_H" = 1; then
	AC_DEFINE(HAVE_SYS_WAIT)
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(sys/siginfo.h, HAVE_SYS_SIGINFO_H=1)
if test "$HAVE_SYS_SIGINFO_H" = 1; then
	AC_DEFINE(HAVE_SYS_SIGINFO)
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(ucontext.h, HAVE_UCONTEXT_H=1)
if test "$HAVE_UCONTEXT_H" = 1; then
	AC_DEFINE(HAVE_UCONTEXT)
	CFLAGS="$CFLAGS -DHAVE_UCONTEXT"
else
	AC_CHECK_HEADER(sys/ucontext.h, HAVE_SYS_UCONTEXT_H=1)
	if test "$HAVE_SYS_UCONTEXT_H" = 1; then
		AC_DEFINE(HAVE_SYS_UCONTEXT)
	fi
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(asm/sigcontext.h, HAVE_ASM_SIGCONTEXT_H=1)
if test "$HAVE_ASM_SIGCONTEXT_H" = 1; then
	AC_DEFINE(HAVE_ASM_SIGCONTEXT)
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(sys/param.h, HAVE_SYS_PARAM_H=1)
if test "$HAVE_SYS_PARAM_H" = 1; then
	AC_DEFINE(HAVE_SYS_PARAM)
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(sys/time.h, HAVE_SYS_TIME_H=1)
if test "$HAVE_SYS_TIME_H" = 1; then
	AC_DEFINE(HAVE_SYS_TIME)
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(dlfcn.h, HAVE_DLFCN_H=1)
if test "$HAVE_DLFCN_H" = 1; then
	AC_DEFINE(HAVE_DLFCN_H)
fi
AC_CHECK_LIB(dl, dlopen, DL_LIBRARY="-ldl", DL_LIBRARY="")
AC_SUBST(DL_LIBRARY)

# temporarily add $DL_LIBRARY to LIBS while we check for dlopen etc.
save_LIBS="$LIBS"
LIBS="$LIBS $DL_LIBRARY"

AC_HAVE_FUNCS(dlopen dlclose dlsym dlerror)

# restore old value of LIBS
LIBS="$save_LIBS"
#-----------------------------------------------------------------------------#
#
# check the basics of sigaction
#
if test "$ac_cv_func_sigaction" = yes; then
	AC_MSG_CHECKING(for \`sigaction' field name)
	AC_CACHE_VAL(mercury_cv_sigaction_field,
	AC_TRY_RUN([

	#include <signal.h>
	#include <stdlib.h>

	#define FAULT_ADDRESS ((int *)112)

	extern void handler(int signum, siginfo_t *info, void *context);

	int main() {
		struct sigaction act;
		act.sa_flags = SA_SIGINFO;
		act.sa_sigaction = handler;
		if (sigemptyset(&act.sa_mask) != 0)
			exit(1);
		if (sigaction(SIGSEGV, &act, NULL) != 0)
			exit(1);
		/* provoke a SIGSEGV */
		(*FAULT_ADDRESS)++;
		exit(1);
	}

	void handler(int signum, siginfo_t *info, void *context) {
		if (signum == SIGSEGV &&
		    info->si_signo == SIGSEGV &&
		    info->si_code > 0 &&
		    (int *)info->si_addr == FAULT_ADDRESS)
		{
			exit(0);
		} else {
			exit(1);
		}
	}],
	[mercury_cv_sigaction_field=sa_sigaction],
	[mercury_cv_sigaction_field=sa_handler],
	[mercury_cv_sigaction_field=sa_handler]))
	AC_MSG_RESULT($mercury_cv_sigaction_field)
	AC_DEFINE_UNQUOTED(SIGACTION_FIELD,$mercury_cv_sigaction_field)
	if test $mercury_cv_sigaction_field = sa_sigaction; then
		AC_DEFINE(HAVE_SIGINFO)
	fi
fi
#
# check the basics of sigcontext_struct
#
AC_MSG_CHECKING(for working \`sigcontext_struct' in second arg)
AC_CACHE_VAL(mercury_cv_sigcontext_struct_2arg,
mercury_cv_sigcontext_struct_2arg=no
AC_TRY_RUN([
/* see runtime/memory.c for documentation of this code */

#define sigcontext_struct sigcontext

#define __KERNEL__
#include <signal.h>
#undef __KERNEL__

#ifdef HAVE_ASM_SIGCONTEXT
#include <asm/sigcontext.h>
#endif

#include "mercury_faultaddr.h"

#include <stdio.h>

extern void handler(int signum, struct sigcontext_struct info);

#define FAULT_ADDRESS ((int *)112)

int main() {
	signal(SIGSEGV, (void (*)(int))handler);

	/* provoke a SIGSEGV */
	(*FAULT_ADDRESS)++;

	exit(1);
}

void handler(int signum, struct sigcontext_struct context) {
	int *addr;
	addr = (int *) MR_GET_FAULT_ADDR(context);
	if (signum == SIGSEGV && addr == FAULT_ADDRESS) {
		exit(0);
	} else {
		exit(1);
	}
}], [mercury_cv_sigcontext_struct_2arg=yes], [true], [true]))
AC_MSG_RESULT($mercury_cv_sigcontext_struct_2arg)

if test $mercury_cv_sigcontext_struct_2arg = no; then
	#
	# check for a sigcontext_struct in the third argument of
	# the signal handler (Linux-68k has this).
	#
	AC_MSG_CHECKING(for working \`sigcontext_struct' in third arg)
	AC_CACHE_VAL(mercury_cv_sigcontext_struct_3arg,
	mercury_cv_sigcontext_struct_3arg=no

	AC_TRY_RUN([
	/* see runtime/mercury_memory.c for documentation of this code */

	#define sigcontext_struct sigcontext

	#define __KERNEL__
	#include <signal.h>
	#undef __KERNEL__

	#ifdef HAVE_ASM_SIGCONTEXT
	#include <asm/sigcontext.h>
	#endif

	#include "mercury_faultaddr.h"

	#include <stdio.h>

	extern void handler(int signum, int code, struct
		sigcontext_struct info);

	#define FAULT_ADDRESS ((int *)112)

	int main() {
		signal(SIGSEGV, (void (*)(int))handler);

		/* provoke a SIGSEGV */
		(*FAULT_ADDRESS)++;

		exit(1);
	}

	void handler(int signum, int code, struct sigcontext_struct context) {
		int *addr;
		addr = (int *) MR_GET_FAULT_ADDR(context);
		if (signum == SIGSEGV && addr == FAULT_ADDRESS) {
			exit(0);
		} else {
			exit(1);
		}
	}], [mercury_cv_sigcontext_struct_3arg=yes], [true], [true]))
	AC_MSG_RESULT($mercury_cv_sigcontext_struct_3arg)
else
	mercury_cv_sigcontext_struct_3arg=no
fi

mercury_cv_sigcontext_struct=no

if test $mercury_cv_sigcontext_struct_2arg = yes; then
	mercury_cv_sigcontext_struct=yes
	AC_DEFINE(HAVE_SIGCONTEXT_STRUCT_2ARG)
fi

if test $mercury_cv_sigcontext_struct_3arg = yes; then
	mercury_cv_sigcontext_struct=yes
	AC_DEFINE(HAVE_SIGCONTEXT_STRUCT_3ARG)
fi

if test $mercury_cv_sigcontext_struct = yes; then
	AC_DEFINE(HAVE_SIGCONTEXT_STRUCT)
	AC_DEFINE(HAVE_SIGINFO)

	#
	# check for sigcontext_struct.eip
	#
	AC_MSG_CHECKING(for \`sigcontext_struct' pc access at signals)
	AC_CACHE_VAL(mercury_cv_pc_access,
	mercury_cv_pc_access=no
	AC_TRY_RUN([
	/* see runtime/memory.c for documentation of this code */

	#define sigcontext_struct sigcontext

	#define __KERNEL__
	#include <signal.h>
	#undef __KERNEL__

	#ifdef HAVE_ASM_SIGCONTEXT
	#include <asm/sigcontext.h>
	#endif

	#include "mercury_faultaddr.h"

	#include <stdio.h>

	#if HAVE_SIGCONTEXT_STRUCT_3ARG
	extern void handler(int signum, int code, 
			struct sigcontext_struct context);
	#else
	extern void handler(int signum, struct sigcontext_struct context);
	#endif

	#define FAULT_ADDRESS ((int *)112)

	int main() {
		signal(SIGSEGV, (void (*)(int))handler);

		/* provoke a SIGSEGV */
		(*FAULT_ADDRESS)++;

		exit(1);
	}

	#if HAVE_SIGCONTEXT_STRUCT_3ARG
	void handler(int signum, int code, struct sigcontext_struct context) {
	#else
	void handler(int signum, struct sigcontext_struct context) {
	#endif
		int *addr;
		long pc;
		addr = (int *) MR_GET_FAULT_ADDR(context);
		pc = (long) context.eip;
		if (signum == SIGSEGV && addr == FAULT_ADDRESS && pc != 0) {
			exit(0);
		} else {
			exit(1);
		}
	}], [mercury_cv_pc_access=eip], [true], [true]))
	AC_MSG_RESULT($mercury_cv_pc_access)
	if test $mercury_cv_pc_access != no; then
		AC_DEFINE_UNQUOTED(PC_ACCESS,$mercury_cv_pc_access)
	fi
else
	AC_MSG_CHECKING(for \`siginfo_t')
	AC_CACHE_VAL(mercury_cv_siginfo_t,
	mercury_cv_siginfo_t=no
	AC_TRY_RUN([
	#include <stdio.h>
	#include <signal.h>
	#ifdef HAVE_SYS_SIGINFO
	#include <sys/siginfo.h>
	#endif
	#ifdef HAVE_UCONTEXT
	#include <ucontext.h>
	#endif
	#ifdef HAVE_SYS_UCONTEXT
	#include <sys/ucontext.h>
	#endif
	int save_signum = 0;
	int save_cause;
	int save_pc;
	extern void handler(int signum, siginfo_t *info, void *context);
	int main() {
		struct sigaction act;
		act.sa_flags = SA_SIGINFO;
		act.$mercury_cv_sigaction_field = handler;
		if (sigemptyset(&act.sa_mask) != 0)
			exit(1);
		if (sigaction(SIGSEGV, &act, NULL) != 0)
			exit(1);
		if (kill(getpid(), SIGSEGV) != 0)
			exit(1);
		if (save_signum == 0)
			exit(1);
		exit(0);
	}
	void handler(int signum, siginfo_t *info, void *context) {
		save_signum = signum;
		switch (info->si_code) {
		case SEGV_MAPERR:	save_cause = info->si_code;
					break;
		case SEGV_ACCERR:	save_cause = info->si_code;
					break;
		}
		switch (info->si_code) {
		case BUS_ADRALN:	save_cause = info->si_code;
					break;
		case BUS_ADRERR:	save_cause = info->si_code;
					break;
		case BUS_OBJERR:	save_cause = info->si_code;
					break;
		}
		save_cause = info->si_code;
	}], [mercury_cv_siginfo_t=yes], [true], [true]))
	AC_MSG_RESULT($mercury_cv_siginfo_t)
	if test $mercury_cv_siginfo_t = yes; then
		AC_DEFINE(HAVE_SIGINFO_T)
		AC_DEFINE(HAVE_SIGINFO)

		AC_MSG_CHECKING(for \`siginfo' pc access at signals)
		AC_CACHE_VAL(mercury_cv_pc_access,
		mercury_cv_pc_access=no
		AC_TRY_RUN([
		#include <stdio.h>
		#include <signal.h>
		#include <sys/siginfo.h>
		#ifdef HAVE_UCONTEXT
		#include <ucontext.h>
		#else
		#include <sys/ucontext.h>
		#endif
		int save_signum = 0;
		int save_cause;
		int save_pc;
		extern void handler(int signum, siginfo_t *info, void *context);
		int main() {
			struct sigaction act;
			act.sa_flags = SA_SIGINFO;
			act.$mercury_cv_sigaction_field = handler;
			if (sigemptyset(&act.sa_mask) != 0)
				exit(1);
			if (sigaction(SIGSEGV, &act, NULL) != 0)
				exit(1);
			if (kill(getpid(), SIGSEGV) != 0)
				exit(1);
			if (save_signum == 0)
				exit(1);
			exit(0);
		}
		void handler(int signum, siginfo_t *info, void *context) {
			save_signum = signum;
			save_cause = info->si_code;
			/* Don't use array indexing - the square brackets
			   are autoconf quote characters */
			save_pc = *(((ucontext_t *) context)->uc_mcontext.gregs
					+ REG_PC);
		}], [mercury_cv_pc_access=REG_PC;mercury_cv_pc_access_greg=yes],
			[true], [true])
		AC_TRY_RUN([
		#include <stdio.h>
		#include <signal.h>
		#include <sys/siginfo.h>
		#ifdef HAVE_UCONTEXT
		#include <ucontext.h>
		#else
		#include <sys/ucontext.h>
		#endif
		int save_signum = 0;
		int save_cause;
		int save_pc;
		extern void handler(int signum, siginfo_t *info, void *context);
		int main() {
			struct sigaction act;
			act.sa_flags = SA_SIGINFO;
			act.$mercury_cv_sigaction_field = handler;
			if (sigemptyset(&act.sa_mask) != 0)
				exit(1);
			if (sigaction(SIGSEGV, &act, NULL) != 0)
				exit(1);
			if (kill(getpid(), SIGSEGV) != 0)
				exit(1);
			if (save_signum == 0)
				exit(1);
			exit(0);
		}
		void handler(int signum, siginfo_t *info, void *context) {
			save_signum = signum;
			save_cause = info->si_code;
			save_pc = *(((ucontext_t *) context)->uc_mcontext.gregs
					+ CTX_EPC);
		}], [mercury_cv_pc_access=CTX_EPC;mercury_cv_pc_access_greg=yes],
			[true], [true])
		AC_TRY_RUN([
		#include <stdio.h>
		#include <signal.h>
		#include <sys/siginfo.h>
		#ifdef HAVE_UCONTEXT
		#include <ucontext.h>
		#else
		#include <sys/ucontext.h>
		#endif
		int save_signum = 0;
		int save_cause;
		int save_pc;
		extern void handler(int signum, siginfo_t *info, void *context);
		int main() {
			struct sigaction act;
			act.sa_flags = SA_SIGINFO;
			act.$mercury_cv_sigaction_field = handler;
			if (sigemptyset(&act.sa_mask) != 0)
				exit(1);
			if (sigaction(SIGSEGV, &act, NULL) != 0)
				exit(1);
			if (kill(getpid(), SIGSEGV) != 0)
				exit(1);
			if (save_signum == 0)
				exit(1);
			exit(0);
		}
		void handler(int signum, siginfo_t *info, void *context) {
			save_signum = signum;
			save_cause = info->si_code;
			save_pc = ((ucontext_t *) context)->uc_mcontext.sc_pc;
		}], [mercury_cv_pc_access=sc_pc;mercury_cv_pc_access_greg=no],
			[true], [true])
		)
		AC_MSG_RESULT($mercury_cv_pc_access)
		if test $mercury_cv_pc_access != no; then
			AC_DEFINE_UNQUOTED(PC_ACCESS,$mercury_cv_pc_access)
			if test $mercury_cv_pc_access_greg != no; then
				AC_DEFINE(PC_ACCESS_GREG)
			fi
		fi
	fi
fi
#-----------------------------------------------------------------------------#
AC_CHECK_HEADER(sys/types.h, HAVE_SYS_TYPES_H=1)
AC_CHECK_HEADER(inttypes.h, HAVE_INTTYPES_H=1)
AC_CHECK_HEADER(stdint.h, HAVE_STDINT_H=1)

# On some systems, e.g. SGI IRIX 5.2, you can include
# <inttypes.h>, or <sys/types.h>, but not both!

if test "$HAVE_INTTYPES_H" = 1 && test "$HAVE_SYS_TYPES_H" = 1; then
	AC_CACHE_VAL(mercury_cv_inttypes_compat,
	AC_MSG_CHECKING(whether inttypes.h is compatible with sys/types.h)
	AC_TRY_COMPILE([
		#include <inttypes.h>
		#include <sys/types.h>
	],
	[],
	[mercury_cv_inttypes_compat=yes], [mercury_cv_inttypes_compat=no]))
	AC_MSG_RESULT($mercury_cv_inttypes_compat)

	# If <inttypes.h> is not compatible with <sys/types.h>, then
	# don't use it.
	if test "$mercury_cv_inttypes_compat" = no; then
		HAVE_INTTYPES_H=0
	fi
fi

if test "$HAVE_SYS_TYPES_H" = 1; then
	AC_DEFINE(HAVE_SYS_TYPES)
fi
if test "$HAVE_INTTYPES_H" = 1; then
	AC_DEFINE(HAVE_INTTYPES)
fi
if test "$HAVE_STDINT_H" = 1; then
	AC_DEFINE(HAVE_STDINT)
fi

#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(for intptr_t)
AC_CACHE_VAL(mercury_cv_have_intptr_t,
	AC_TRY_COMPILE([
		#ifdef HAVE_STDINT
		  #include <stdint.h>
		#endif
		#ifdef HAVE_INTTYPES
		  #include <inttypes.h>
		#endif
		#ifdef HAVE_SYS_TYPES
		  #include <sys/types.h>
		#endif
	], [
		changequote(<<,>>) 

		/* test the existence of the types */
		intptr_t foo;
		uintptr_t bar;

		/* check that they have the right size */
		#define ASSERTION \
			(sizeof(intptr_t) == sizeof(void *) && \
			 sizeof(uintptr_t) == sizeof(void *))

		/* this forces a compile error if ASSERTION is false */
		int array[ASSERTION ? 1 : -1];

		changequote([,]) 
	],
	[mercury_cv_have_intptr_t=yes],
	[mercury_cv_have_intptr_t=no])
)
AC_MSG_RESULT($mercury_cv_have_intptr_t)
if test "$mercury_cv_have_intptr_t" = yes; then
	AC_DEFINE(MR_HAVE_INTPTR_T)
fi
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(for int_leastN_t)
AC_CACHE_VAL(mercury_cv_have_int_leastN_t,
	AC_TRY_COMPILE([
		#ifdef HAVE_STDINT
		  #include <stdint.h>
		#endif
		#ifdef HAVE_INTTYPES
		  #include <inttypes.h>
		#endif
		#ifdef HAVE_SYS_TYPES
		  #include <sys/types.h>
		#endif
		#include <limits.h> /* for CHAR_BIT */
	], [
		changequote(<<,>>) 

		/* test the existence of the types */
		int_least8_t foo8;
		uint_least8_t bar8;
		int_least16_t foo16;
		uint_least16_t bar16;
		int_least32_t foo32;
		uint_least32_t bar32;

		/* check that they have the right size */
		#define ASSERTION \
			(sizeof(int_least8_t) * CHAR_BIT >= 8 && \
			 sizeof(uint_least8_t) * CHAR_BIT >= 8 && \
			 sizeof(int_least16_t) * CHAR_BIT >= 16 && \
			 sizeof(uint_least16_t) * CHAR_BIT >= 16 && \
			 sizeof(int_least32_t) * CHAR_BIT >= 32 && \
			 sizeof(uint_least32_t) * CHAR_BIT >= 32)

		/* this forces a compile error if ASSERTION is false */
		int array[ASSERTION ? 1 : -1];

		changequote([,]) 
	],
	[mercury_cv_have_int_leastN_t=yes],
	[mercury_cv_have_int_leastN_t=no])
)
AC_MSG_RESULT($mercury_cv_have_int_leastN_t)
if test "$mercury_cv_have_int_leastN_t" = yes; then
	AC_DEFINE(MR_HAVE_INT_LEASTN_T)
fi
#-----------------------------------------------------------------------------#
if test "$mercury_cv_have_intptr_t" = yes; then
	true
else
	AC_MSG_CHECKING(for an integer type with the same size as a pointer)
	AC_CACHE_VAL(mercury_cv_word_type,
		AC_TRY_RUN([
		#include <stdio.h>
		int main() {
			FILE *fp;

			fp = fopen("conftest.tags", "w");
			if (fp == NULL)
				exit(1);

			if (sizeof(int) == sizeof(void *))
			{
				fprintf(fp, "int\n");
				exit(0);
			}

			if (sizeof(long) == sizeof(void *))
			{
				fprintf(fp, "long\n");
				exit(0);
			}

			fprintf(fp, "unknown\n");
			exit(1);
		}],
		[mercury_cv_word_type=`cat conftest.tags`],
		[mercury_cv_word_type=unknown],
		[mercury_cv_word_type=unknown])
	)
	if test "$mercury_cv_word_type" = unknown; then
		AC_TRY_RUN([
		#include <stdio.h>
		int main() {
			FILE *fp;

			fp = fopen("conftest.tags", "w");
			if (fp == NULL)
				exit(1);

			if (sizeof(long long) == sizeof(void *))
			{
				fprintf(fp, "long long\n");
				exit(0);
			}

			fprintf(fp, "unknown\n");
			exit(1);
		}],
		[mercury_cv_word_type=`cat conftest.tags`],
		[mercury_cv_word_type=unknown],
		[mercury_cv_word_type=unknown])
	fi
	AC_MSG_RESULT($mercury_cv_word_type)
	AC_DEFINE_UNQUOTED(MR_WORD_TYPE, $mercury_cv_word_type)
	MR_WORD_TYPE=$mercury_cv_word_type
	AC_SUBST(MR_WORD_TYPE)
fi # ! have_int_ptr_t
#-----------------------------------------------------------------------------#
if test "$mercury_cv_have_int_leastN_t" = yes; then
	true
else
	AC_MSG_CHECKING(for an integer type of at least 32 bits)
	AC_CACHE_VAL(mercury_cv_int_least32_type,
		AC_TRY_RUN([
		#include <stdio.h>
		#include <limits.h>
		int main() {
			FILE *fp;

			fp = fopen("conftest.tags", "w");
			if (fp == NULL)
				exit(1);

			if (sizeof(int) * CHAR_BIT >= 32)
			{
				fprintf(fp, "int\n");
				exit(0);
			}

			if (sizeof(long) * CHAR_BIT >= 32)
			{
				fprintf(fp, "long\n");
				exit(0);
			}

			fprintf(fp, "unknown\n");
			exit(1);
		}],
		[mercury_cv_int_least32_type=`cat conftest.tags`],
		[mercury_cv_int_least32_type=unknown],
		[mercury_cv_int_least32_type=unknown])
	)
	AC_MSG_RESULT($mercury_cv_int_least32_type)
	AC_DEFINE_UNQUOTED(MR_INT_LEAST32_TYPE, $mercury_cv_int_least32_type)
	MR_INT_LEAST32_TYPE=$mercury_cv_int_least32_type
	AC_SUBST(MR_INT_LEAST32_TYPE)
#-----------------------------------------------------------------------------#
	AC_MSG_CHECKING(for an integer type of at least 16 bits)
	AC_CACHE_VAL(mercury_cv_int_least16_type,
		AC_TRY_RUN([
		#include <stdio.h>
		#include <limits.h>
		int main() {
			FILE *fp;

			fp = fopen("conftest.tags", "w");
			if (fp == NULL)
				exit(1);

			if (sizeof(short) * CHAR_BIT >= 16)
			{
				fprintf(fp, "short\n");
				exit(0);
			}

			if (sizeof(int) * CHAR_BIT >= 16)
			{
				fprintf(fp, "int\n");
				exit(0);
			}

			fprintf(fp, "unknown\n");
			exit(1);
		}],
		[mercury_cv_int_least16_type=`cat conftest.tags`],
		[mercury_cv_int_least16_type=unknown],
		[mercury_cv_int_least16_type=unknown])
	)
	AC_MSG_RESULT($mercury_cv_int_least16_type)
	AC_DEFINE_UNQUOTED(MR_INT_LEAST16_TYPE, $mercury_cv_int_least16_type)
	MR_INT_LEAST16_TYPE=$mercury_cv_int_least16_type
	AC_SUBST(MR_INT_LEAST16_TYPE)
fi # ! have_int_leastN_t
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(the number of low tag bits available)
AC_CACHE_VAL(mercury_cv_low_tag_bits,
	AC_TRY_RUN([
	#include <stdio.h>
	#include <stdlib.h>
	int main() {
		FILE *fp;

		fp = fopen("conftest.tags", "w");
		if (fp == NULL)
			exit(1);

		if (sizeof(void *) == 4)
		{
			fprintf(fp, "2\n");
			exit(0);
		}
		if (sizeof(void *) == 8)
		{
			fprintf(fp, "3\n");
			exit(0);
		}
		if (sizeof(void *) == 16)
		{
			fprintf(fp, "4\n");
			exit(0);
		}
		fprintf(fp, "0\n");
		exit(1);
	}],
	[mercury_cv_low_tag_bits=`cat conftest.tags`],
	[mercury_cv_low_tag_bits=0],
	[mercury_cv_low_tag_bits=0])
)
AC_MSG_RESULT($mercury_cv_low_tag_bits)
if test "$mercury_cv_low_tag_bits" -lt 2; then
	if test "$BOOTSTRAP_MC" = ""; then
		AC_MSG_ERROR("cannot bootstrap: low tag bits less than 2")
		exit 1
	fi
fi
if test "$mercury_cv_low_tag_bits" -gt 2; then
	if test "$BOOTSTRAP_MC" = ""; then
		AC_MSG_WARN("bootstrapping using only 2 low tag bits")
		mercury_cv_low_tag_bits=2
	fi
fi
AC_DEFINE_UNQUOTED(LOW_TAG_BITS, $mercury_cv_low_tag_bits)
LOW_TAG_BITS=$mercury_cv_low_tag_bits
AC_SUBST(LOW_TAG_BITS)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(the number of bytes per word)
AC_CACHE_VAL(mercury_cv_bytes_per_word,
	AC_TRY_RUN([
	#include <stdio.h>
	#include <stdlib.h>
	int main() {
		FILE *fp;

		fp = fopen("conftest.wordbytes", "w");
		if (fp == NULL)
			exit(1);
		fprintf(fp, "%d\n", sizeof(void *));

		exit(0);
	}],
	[mercury_cv_bytes_per_word=`cat conftest.wordbytes`],
	[mercury_cv_bytes_per_word=0],
	[mercury_cv_bytes_per_word=0])
)
AC_MSG_RESULT($mercury_cv_bytes_per_word)
AC_DEFINE_UNQUOTED(BYTES_PER_WORD, $mercury_cv_bytes_per_word)
BYTES_PER_WORD=$mercury_cv_bytes_per_word
AC_SUBST(BYTES_PER_WORD)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(the number of words in a synchronization term)
AC_CACHE_VAL(mercury_cv_sync_term_size,
	AC_TRY_RUN([
	#include <stdio.h>
	#include <stdlib.h>
	#include <pthread.h>
	int main() {
		struct {
			pthread_mutex_t lock;
			int		count;
			void		*parent;
		} x;
		FILE *fp;

		fp = fopen("conftest.syncsize", "w");
		if (fp == NULL)
			exit(1);
		fprintf(fp, "%d\n", (sizeof(void *) - 1 + sizeof(x))/
				sizeof(void *));

		exit(0);
	}],
	[mercury_cv_sync_term_size=`cat conftest.syncsize`],
	[mercury_cv_sync_term_size=0],
	[mercury_cv_sync_term_size=0])
)
AC_MSG_RESULT($mercury_cv_sync_term_size)
AC_DEFINE_UNQUOTED(SYNC_TERM_SIZE, $mercury_cv_sync_term_size)
SYNC_TERM_SIZE=$mercury_cv_sync_term_size
AC_SUBST(SYNC_TERM_SIZE)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(the number of bits per word)
AC_CACHE_VAL(mercury_cv_bits_per_word,
	AC_TRY_RUN([
	#include <stdio.h>
	#include <stdlib.h>
	#include <limits.h>
	int main() {
		FILE *fp;

		fp = fopen("conftest.wordbits", "w");
		if (fp == NULL)
			exit(1);
		fprintf(fp, "%d\n", CHAR_BIT * sizeof(void *));

		exit(0);
	}],
	[mercury_cv_bits_per_word=`cat conftest.wordbits`],
	[mercury_cv_bits_per_word=0],
	[mercury_cv_bits_per_word=0])
)
AC_MSG_RESULT($mercury_cv_bits_per_word)
AC_DEFINE_UNQUOTED(BITS_PER_WORD, $mercury_cv_bits_per_word)
BITS_PER_WORD=$mercury_cv_bits_per_word
AC_SUBST(BITS_PER_WORD)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether we can use unboxed floats)
AC_CACHE_VAL(mercury_cv_unboxed_floats,
	AC_TRY_RUN([
	int main() {
		if (sizeof(double) == sizeof(void *))
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_unboxed_floats=yes],
	[mercury_cv_unboxed_floats=no],
	[mercury_cv_unboxed_floats=no])
)
AC_MSG_RESULT($mercury_cv_unboxed_floats)
if test "$mercury_cv_unboxed_floats" = yes; then
	if test "$BOOTSTRAP_MC" = ""; then
		AC_MSG_WARN(Mercury compiler not yet installed -" \
				"cannot use unboxed floats)
		AC_MSG_WARN(bootstrapping using boxed floats)
		AC_MSG_WARN(*** after installation is complete you" \
				"may want to reinstall from scratch)
		AC_MSG_WARN(*** so you can use unboxed floats," \
				"which are more efficient.)
		mercury_cv_unboxed_floats=no
	fi
fi
if test "$mercury_cv_unboxed_floats" = yes; then
	HAVE_BOXED_FLOATS="--unboxed-float"
else
	AC_DEFINE(BOXED_FLOAT)
	HAVE_BOXED_FLOATS="--no-unboxed-float"
fi
AC_SUBST(HAVE_BOXED_FLOATS)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether float is 64-bit)
AC_CACHE_VAL(mercury_cv_float_is_64_bit,
	AC_TRY_RUN([
	#include <limits.h>
	int main() {
		if (sizeof(float) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_float_is_64_bit=yes],
	[mercury_cv_float_is_64_bit=no],
	[mercury_cv_float_is_64_bit=no])
)
AC_MSG_RESULT($mercury_cv_float_is_64_bit)
if test "$mercury_cv_float_is_64_bit" = yes; then
	AC_DEFINE(MR_FLOAT_IS_64_BIT)
fi
AC_SUBST(MR_FLOAT_IS_64_BIT)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether double is 64-bit)
AC_CACHE_VAL(mercury_cv_double_is_64_bit,
	AC_TRY_RUN([
	#include <limits.h>
	int main() {
		if (sizeof(double) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_double_is_64_bit=yes],
	[mercury_cv_double_is_64_bit=no],
	[mercury_cv_double_is_64_bit=no])
)
AC_MSG_RESULT($mercury_cv_double_is_64_bit)
if test "$mercury_cv_double_is_64_bit" = yes; then
	AC_DEFINE(MR_DOUBLE_IS_64_BIT)
fi
AC_SUBST(MR_DOUBLE_IS_64_BIT)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether long double is 64-bit)
AC_CACHE_VAL(mercury_cv_long_double_is_64_bit,
	AC_TRY_RUN([
	#include <limits.h>
	int main() {
		if (sizeof(long double) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_long_double_is_64_bit=yes],
	[mercury_cv_long_double_is_64_bit=no],
	[mercury_cv_long_double_is_64_bit=no])
)
AC_MSG_RESULT($mercury_cv_long_double_is_64_bit)
if test "$mercury_cv_long_double_is_64_bit" = yes; then
	AC_DEFINE(MR_LONG_DOUBLE_IS_64_BIT)
fi
AC_SUBST(MR_LONG_DOUBLE_IS_64_BIT)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether architecture is big-endian)
AC_CACHE_VAL(mercury_cv_is_bigender,
	AC_TRY_RUN([
	int main() {
		int		x = 1;
		unsigned char	*x_p;

		x_p = (unsigned char*) &x;

		if (*x_p == 0)
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_is_bigender=yes],
	[mercury_cv_is_bigender=no],
	[mercury_cv_is_bigender=no])
)
AC_MSG_RESULT($mercury_cv_is_bigender)
if test "$mercury_cv_is_bigender" = yes; then
	AC_DEFINE(MR_BIG_ENDIAN)
fi
AC_SUBST(MR_BIG_ENDIAN)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether architecture is little-endian)
AC_CACHE_VAL(mercury_cv_is_littleender,
	AC_TRY_RUN([
	int main() {
		int		x = 1;
		unsigned char	*x_p;

		x_p = (unsigned char*) &x;

		if (*x_p == 1)
			exit(0);
		else
			exit(1);
	}],
	[mercury_cv_is_littleender=yes],
	[mercury_cv_is_littleender=no],
	[mercury_cv_is_littleender=no])
)
AC_MSG_RESULT($mercury_cv_is_littleender)
if test "$mercury_cv_is_littleender" = yes; then
	AC_DEFINE(MR_LITTLE_ENDIAN)
fi
AC_SUBST(MR_LITTLE_ENDIAN)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(return values of system)
AC_CACHE_VAL(mercury_cv_normal_system_retval,
	AC_TRY_RUN([
	#include <stdlib.h>
	#ifdef HAVE_SYS_WAIT
	#include <sys/wait.h>
	#endif
	int main() {
		#if defined (WIFEXITED) && defined (WEXITSTATUS) && \
			defined (WIFSIGNALED) && defined (WTERMSIG)
		/* 
		** All the necessary macros for handling the return values of
		** system() are defined, so we do not need to test the return
		** value of system()
		*/
		exit(0);
	
		#else
		/*
		** Normal return values from system() are considered to be
		** when high 8 bits of the return value give the exit
		** status, and the low 8 bits give the signal number which
		** killed the process.
		*/
			if( system("exit 0") == 0 &&
					system("exit 42") == 42 << 8 ) {
					/* && system("kill -9 $$") == 9 */
				exit(0);
			} else {
				exit(1);
			}
		#endif
	}],
	[mercury_cv_normal_system_retval=yes],
	[mercury_cv_normal_system_retval=no],
	AC_TRY_COMPILE([#include <sys/wait.h>], [
	#if defined (WIFEXITED) && defined (WEXITSTATUS) && \
		defined (WIFSIGNALED) && defined (WTERMSIG)

	#else
	/* 
	** As these macros are not defined the compilation must fail.
	** Unmatched brackets should do that for us.
	*/
		}
	#endif
	], 
	[mercury_cv_normal_system_retval=yes],
	[mercury_cv_normal_system_retval=no]))
)
AC_MSG_RESULT($mercury_cv_normal_system_retval)
if test "$mercury_cv_normal_system_retval" = no; then
	AC_MSG_ERROR(Unable to interpret return values from system)
	exit 1
fi
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(for tempnam)
AC_CACHE_VAL(mercury_cv_has_tempnam,
	AC_TRY_RUN([
	#include <stdio.h>
	int main() {
		char	*name;

		name = tempnam("/tmp", "foobie");

		exit(name == NULL);
	}],
	[mercury_cv_has_tempnam=yes],
	[mercury_cv_has_tempnam=no],
	[mercury_cv_has_tempnam=no])
)
AC_MSG_RESULT($mercury_cv_has_tempnam)
if test "$mercury_cv_has_tempnam" = yes; then
	AC_DEFINE(IO_HAVE_TEMPNAM)
fi
AC_SUBST(IO_HAVE_TEMPNAM)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(to see if we can handle contexts blocking on IO)
AC_CACHE_VAL(mercury_cv_can_do_pending_io,
	AC_TRY_RUN([
	#include <sys/types.h>
	#include <sys/time.h>
	int main() {
		fd_set f;
		struct timeval zero;
		int err;

		FD_ZERO(&f);
		zero.tv_sec = 0;
		zero.tv_usec = 0;
		err = select(1, &f, &f, &f, &zero);
		exit(err != 0);
	}],
	[mercury_cv_can_do_pending_io=yes],
	[mercury_cv_can_do_pending_io=no],
	[mercury_cv_can_do_pending_io=no])
)
AC_MSG_RESULT($mercury_cv_can_do_pending_io)
if test "$mercury_cv_can_do_pending_io" = yes; then
	AC_DEFINE(MR_CAN_DO_PENDING_IO)
fi
AC_SUBST(MR_CAN_DO_PENDING_IO)
#-----------------------------------------------------------------------------#
#
# On sparc, x86, and probably on other architectures,
# for egcs 1.1, if we're using non-local gotos, then we need
# `-fno-gcse -fno-function-cse'.
# (Actually I don't know if _both_ of these are needed.
# Maybe you can get away with just one of them.)
# Earlier versions of gcc will just ignore those arguments,
# so we don't need to conditionalize that on the gcc version.
#
# For Irix 5, gcc labels don't work with shared libraries,
# so if we're using gcc labels, we need to use non-shared libraries,
# which means passing -non_shared and -mno-abicalls and also setting
# LIBRARY_PATH.
#
# For x86, gcc global registers only work with -fno-builtin
# and -fno-omit-frame-pointer.
#
# NB. Any changes here may also require changes to scripts/mgnuc.in.
#
save_CC="$CC"
save_LIBRARY_PATH="$LIBRARY_PATH"
CFLAGS_FOR_REGS=
case $ac_cv_prog_gcc in yes)
    case "`$CC --version < /dev/null`" in
	2.8*) CFLAGS_FOR_GOTOS="-fno-defer-pop -fno-function-cse" ;;
	*)    CFLAGS_FOR_GOTOS="-fno-defer-pop -fno-function-cse -fno-gcse" ;;
    esac ;;
esac
case "$host" in
	mips-sgi-irix5.*)
		CC="$CC -non_shared -mno-abicalls"
		CFLAGS_FOR_GOTOS="$CFLAGS_FOR_GOTOS -non_shared -mno-abicalls"
LIBRARY_PATH="$NONSHARED_LIB_DIR:/usr/lib/nonshared:$LIBRARY_PATH"
		export LIBRARY_PATH
		;;
	i?86-*)
		CC="$CC -fno-builtin -fno-omit-frame-pointer"
		CFLAGS_FOR_REGS="-fno-builtin -fno-omit-frame-pointer"
		;;
	# We need a special-case hack here, because the auto-config 
	# gets it wrong on the Alpha: the little example program
	# works fine in fast.gc mode, but big programs don't,
	# due to problems with the `gp' register.  Ideally we
	# ought to write a big enough example program to trigger
	# the problem, but that would be too much work.
	alpha-dec-*)
		MERCURY_MSG("asm labels work on the Alpha")
		MERCURY_MSG("but plain gcc labels do not")
		mercury_cv_asm_labels=yes
		mercury_cv_gcc_labels=no
		CFLAGS_FOR_GOTOS="$CFLAGS_FOR_GOTOS -fomit-frame-pointer"
		;;
	# Similarly for rs6000
	rs6000-*)
		MERCURY_MSG("gcc labels do not work on the RS/6000")
		mercury_cv_asm_labels=no
		mercury_cv_gcc_labels=no
		;;
	sparc*)
		case $ac_cv_prog_gcc in yes)
		    case "`$CC --version < /dev/null`" in 2.8*)
			AC_MSG_WARN(*** Mercury might not work with " \
				"gcc 2.8 on sparc!)
			AC_MSG_WARN(We advise using gcc 2.7.x or egcs.)
			;;
		    esac
		    ;;
		esac
		;;
esac
AC_SUBST(CFLAGS_FOR_REGS)
AC_SUBST(CFLAGS_FOR_GOTOS)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether we can use gcc labels)
AC_CACHE_VAL(mercury_cv_gcc_labels,
	AC_TRY_RUN([
	void *entry_foo_1;
	void *entry_bar_1;
	void *succip;
	int global;
	foo() {
		entry_foo_1 = && foo_1;
		return;
	foo_1:
		if (global != 42) exit(1);
		goto *entry_bar_1;
	}
	bar() {
		entry_bar_1 = && bar_1;
		return;
	bar_1:
		if (global != 42) exit(1);
		goto *succip;
	}
	main() {
		global = 42;
		foo();
		bar();
		succip = &&last;
		goto *entry_foo_1;
		exit(1);
	last:
		if (global != 42) exit(1);
		exit(0);
	}], [mercury_cv_gcc_labels=yes], [mercury_cv_gcc_labels=no],
		[mercury_cv_gcc_labels=no])
)
AC_MSG_RESULT($mercury_cv_gcc_labels)
if test "$mercury_cv_gcc_labels" = yes; then
	AC_DEFINE(HAVE_GCC_LABELS)
fi
#-----------------------------------------------------------------------------#
if test $mercury_cv_gcc_labels = yes; then
	AC_MSG_CHECKING(whether we can use asm labels)
	AC_CACHE_VAL(mercury_cv_asm_labels,
	AC_TRY_RUN([
	void *volatile volatile_global_pointer;
	extern void mercury__label1 (void) __asm__("entry_" "mercury__label1" );
	main() {
		void *addr;

		volatile_global_pointer = &&mercury__label1;
		addr = &mercury__label1;
		goto *addr;
		exit(1);

	mercury__label1:
		__asm__(".globl entry_" "mercury__label1" "\n" "entry_"
			"mercury__label1" ":");
		exit(0);
	}], [mercury_cv_asm_labels=yes], [mercury_cv_asm_labels=no],
		[mercury_cv_asm_labels=no])
	)
	AC_MSG_RESULT($mercury_cv_asm_labels)
else
	mercury_cv_asm_labels=${mercury_cv_asm_labels-no}
fi
HAVE_ASM_LABELS=$mercury_cv_asm_labels
AC_SUBST(HAVE_ASM_LABELS)
if test $HAVE_ASM_LABELS = 1; then
	AC_DEFINE(HAVE_ASM_LABELS)
fi
#-----------------------------------------------------------------------------#
# We need to ensure that runtime/mercury_conf.h exists, since some of the
# programs we attempt to compile below indirectly include it.
test -f runtime/mercury_conf.h || {
	cat > runtime/mercury_conf.h <<EOF
#define MR_WORD_TYPE $MR_WORD_TYPE
EOF
}
#-----------------------------------------------------------------------------#
if test $mercury_cv_gcc_labels = yes || test $mercury_cv_asm_labels = yes; then
	AC_MSG_CHECKING(whether we can use gcc labels and global registers)
	AC_CACHE_VAL(mercury_cv_gcc_model_fast,
	AC_TRY_RUN([
	#define USE_GCC_NONLOCAL_GOTOS
	#define USE_GCC_GLOBAL_REGISTERS
	#include "mercury_engine.h"
	changequote(<<,>>) 
	MercuryEngine MR_engine_base;
	changequote([,]) 
	main() {
		mr0 = 20;
		mr7 = 22;
		if (mr0 + mr7 != 42)
			exit(1);
		exit(0);
	}], [mercury_cv_gcc_model_fast=yes], [mercury_cv_gcc_model_fast=no],
		[mercury_cv_gcc_model_fast=no])
	)
	AC_MSG_RESULT($mercury_cv_gcc_model_fast)
else
	mercury_cv_gcc_model_fast=no
fi
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether we can support profiling on this system)
AC_CACHE_VAL(mercury_cv_profiling,
AC_TRY_CPP([
/* The following code comes from runtime/prof.c */
#include	<unistd.h>
#include	<errno.h>
#include	<string.h>
#include	<signal.h>

#ifdef HAVE_SYS_PARAM
#include	<sys/param.h>
#endif

#ifdef HAVE_SYS_TIME
#include	<sys/time.h>
#endif

/* 
** if HZ is not defined, we may be able to use sysconf(_SC_CLK_TCK) instead
*/
#if !defined(HZ) && defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
#define HZ ((int)sysconf(_SC_CLK_TCK))
#endif

#if !defined(HZ) || !defined(SIGPROF) || !defined(HAVE_SETITIMER)
#error "Time profiling not supported on this system"
#endif
], [mercury_cv_profiling=yes], [mercury_cv_profiling=no]))
AC_MSG_RESULT($mercury_cv_profiling)

#-----------------------------------------------------------------------------#
#
# Restore env vars modified by Irix 5 hack above
#
CC="$save_CC"
LIBRARY_PATH="$save_LIBRARY_PATH"
#-----------------------------------------------------------------------------#

AC_MSG_CHECKING(whether we can use global registers without gcc labels)
AC_CACHE_VAL(mercury_cv_gcc_model_reg,
AC_TRY_RUN([
#define USE_GCC_GLOBAL_REGISTERS
#include "mercury_engine.h"
changequote(<<,>>) 
MercuryEngine MR_engine_base;
changequote([,]) 
main() {
	mr0 = 20;
	mr7 = 22;
	if (mr0 + mr7 != 42)
		exit(1);
	exit(0);
}], [mercury_cv_gcc_model_reg=yes], [mercury_cv_gcc_model_reg=no],
	[mercury_cv_gcc_model_reg=no])
)
AC_MSG_RESULT($mercury_cv_gcc_model_reg)
#-----------------------------------------------------------------------------#

# Figure out which flavour of pthreads to use, since none of the
# implementations seem to be exactly the same
case $host in
	alpha-dec-osf*)
		mercury_cv_use_digital_unix_threads=yes ;;

	*)
		mercury_cv_use_digital_unix_threads=no ;;
esac

if test $mercury_cv_use_digital_unix_threads = yes; then
	AC_DEFINE(MR_DIGITAL_UNIX_PTHREADS)
fi

#-----------------------------------------------------------------------------#

#
# figure out the most efficient base grade to use.
#
if test $mercury_cv_asm_labels = yes; then
	if test $mercury_cv_gcc_model_fast = yes; then
		BEST_GRADE=asm_fast
	else
		BEST_GRADE=asm_jump
	fi
elif test $mercury_cv_gcc_labels = yes; then
	if test $mercury_cv_gcc_model_fast = yes; then
		BEST_GRADE=fast
	else
		BEST_GRADE=jump
	fi
else
	if test $mercury_cv_gcc_model_reg = yes; then
		BEST_GRADE=reg
	else
		BEST_GRADE=none
	fi
fi

# We can't use grade jump.gc or fast.gc unless we have a working Mercury
# compiler to bootstrap with, since the C code generated for the other
# grades won't work in grade jump.gc or fast.gc.

DESIRED_GRADE=$BEST_GRADE.gc
GRADE=$DESIRED_GRADE
if test "$GRADE" = jump.gc || test "$GRADE" = fast.gc; then
	if test "$BOOTSTRAP_MC" = ""; then
		if test "$DESIRED_GRADE" = jump.gc; then
			GRADE=none.gc
		else
			GRADE=reg.gc
		fi
		AC_MSG_WARN(Mercury compiler not yet installed -" \
				"cannot use grade \`$DESIRED_GRADE')
		AC_MSG_WARN(using \`GRADE=$GRADE' to compile the compiler)
		AC_MSG_WARN(*** after installation is complete you" \
				"should reinstall from scratch)
		AC_MSG_WARN(*** so you can use the more efficient" \
				"grade \`$DESIRED_GRADE')
	else
		MERCURY_MSG("using \`GRADE=$GRADE' to compile the compiler")
		MERCURY_MSG("compiler and library will be rebuilt with new grade")
		MERCURY_MSG("installation may take a long time")
		rm -f library/*.c compiler/*.c browser/*.c profiler/*.c
	fi
else
	MERCURY_MSG("using \`GRADE=$GRADE' to compile the compiler")
fi

AC_SUBST(GRADE)

if test "$DEFAULT_GRADE" = ""; then
	DEFAULT_GRADE=$GRADE
	# For Irix 5.x, shared libraries are incompatible
	# with gcc non-local gotos.
	# We prefer to use shared libraries by default
	case "$host" in
		mips-sgi-irix5.*)
			DEFAULT_GRADE=reg.gc
			;;
	esac
fi
MERCURY_MSG("using \`DEFAULT_GRADE=$DEFAULT_GRADE' as the default grade for applications")
AC_SUBST(DEFAULT_GRADE)

#
# Figure out which grades to use if --enable-all-grades is specified.
#
ALL_LIBGRADES="none"
if test $mercury_cv_gcc_model_reg = yes; then
	ALL_LIBGRADES="$ALL_LIBGRADES reg"
fi
if test $mercury_cv_gcc_labels = yes; then
	ALL_LIBGRADES="$ALL_LIBGRADES jump"
	if test $mercury_cv_gcc_model_fast = yes; then
		ALL_LIBGRADES="$ALL_LIBGRADES fast"
	fi
fi
if test $mercury_cv_asm_labels = yes; then
	if test $mercury_cv_gcc_labels = yes; then
		ALL_LIBGRADES="$ALL_LIBGRADES asm_jump"
	fi
	if test $mercury_cv_gcc_model_fast = yes; then
		ALL_LIBGRADES="$ALL_LIBGRADES asm_fast"
	fi
fi

AC_ARG_ENABLE(all-grades,
[  --enable-all-grades     install all the different versions of the library],
enable_all_grades="$enableval",enable_all_grades=no)

if test "$enable_all_grades" = yes; then
	LIBGRADES="$ALL_LIBGRADES"
else
	LIBGRADES="$BEST_GRADE"
fi

# add `.gc' (--conservative-gc) grades
for grade in $LIBGRADES; do
	LIBGRADES="$LIBGRADES $grade.gc"
done

# add `.prof' (--profiling) grades, if time profiling is supported,
# and a `.memprof' (--memory-profiling) grade.
if test $mercury_cv_profiling = yes; then
	DEFAULT_GRADE_NOGC="`echo $DEFAULT_GRADE | sed 's/\.gc$//'`"
	LIBGRADES="$LIBGRADES $DEFAULT_GRADE.prof $DEFAULT_GRADE_NOGC.prof"
	if test $GRADE != $DEFAULT_GRADE; then
		GRADE_NOGC="`echo $GRADE | sed 's/\.gc$//'`"
		LIBGRADES="$LIBGRADES $GRADE.prof $GRADE_NOGC.prof"
	fi
fi
LIBGRADES="$LIBGRADES $DEFAULT_GRADE.memprof"

# add `.tr' (--trailing) grades
LIBGRADES="$LIBGRADES $DEFAULT_GRADE.tr"
if test "$enable_all_grades" = yes; then
	DEFAULT_GRADE_NOGC="`echo $DEFAULT_GRADE | sed 's/\.gc$//'`"
	LIBGRADES="$LIBGRADES $DEFAULT_GRADE_NOGC.tr"
	if test $mercury_cv_profiling = yes; then
		LIBGRADES="$LIBGRADES $DEFAULT_GRADE.prof.tr"
	fi
fi

# add `.debug' (--debug) grades
LIBGRADES="$LIBGRADES $DEFAULT_GRADE.tr.debug"

# remove GRADE from LIBGRADES
LIBGRADES=` echo " $LIBGRADES " | sed "s/ $GRADE / /" `
MERCURY_MSG("using \`LIBGRADES=$LIBGRADES' as the set of library grades to install")
AC_SUBST(LIBGRADES)
#-----------------------------------------------------------------------------#
#
# Add an option that disables declarative debugging support in the internal
# debugger.  It is enabled by default.
#
AC_ARG_ENABLE(decl-debug,
[  --disable-decl-debug    disable the declarative debugger],
mercury_cv_enable_decl_debug="$enableval",mercury_cv_enable_decl_debug=yes)
if test "$mercury_cv_enable_decl_debug" = "yes"; then
	AC_DEFINE(MR_USE_DECLARATIVE_DEBUGGER)
fi
#-----------------------------------------------------------------------------#

# Determine how many of the r registers (r1, r2, ...) are real registers.
# Determine how many temporaries may be allocated real registers.
# Find out whether branch instructions have a delay slot.

case "$host" in
	i?86-*)
		# NUM_REAL_REGS=3
		# but succip and sp are real regs, so subtract 2
		NUM_REAL_R_REGS=1
		NUM_REAL_R_TEMPS=0
		HAVE_DELAY_SLOT=
		;;
	alpha-*)
		# NUM_REAL_REGS=6
		# but succip, sp, and hp are real regs, so subtract 3
		NUM_REAL_R_REGS=3
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=
		;;
	mips-*)
		# NUM_REAL_REGS=8
		# but succip, sp, and hp are real regs, so subtract 3
		NUM_REAL_R_REGS=5
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=--have-delay-slot
		;;
	rs6000-*)
		# NUM_REAL_REGS=10
		# but succip, sp, hp, maxfr, and curfr are real regs,
		# so subtract 5
		NUM_REAL_R_REGS=5
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=
		;;
	sparc-*)
		# NUM_REAL_REGS=10
		# but succip, sp, hp, maxfr, and curfr are real regs,
		# so subtract 5
		NUM_REAL_R_REGS=5
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=--have-delay-slot
		;;
	hppa-*)
		# NUM_REAL_REGS=8
		# but succip, sp, and hp are real regs, so subtract 3
		NUM_REAL_R_REGS=5
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=
		;;
	*)
		NUM_REAL_R_REGS=0
		NUM_REAL_R_TEMPS=6
		HAVE_DELAY_SLOT=
		;;
esac
AC_SUBST(NUM_REAL_R_REGS)
AC_SUBST(NUM_REAL_R_TEMPS)
AC_SUBST(HAVE_DELAY_SLOT)

#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether the assembler does not handle .type)
AC_CACHE_VAL(mercury_cv_cannot_grok_asm_type_directive, [
	case "$host" in
		*-sunos4.*)
			mercury_cv_cannot_grok_asm_type_directive=yes
			;;
		*)
			mercury_cv_cannot_grok_asm_type_directive=no
			;;
	esac
])
AC_MSG_RESULT($mercury_cv_cannot_grok_asm_type_directive)
if test $mercury_cv_cannot_grok_asm_type_directive = "yes"; then
	AC_DEFINE(MR_CANNOT_GROK_ASM_TYPE_DIRECTIVE)
fi
#-----------------------------------------------------------------------------#
AC_PATH_PROG(AS,as)
AC_MSG_CHECKING(whether the assembler does full preprocessing)

AC_CACHE_VAL(mercury_cv_asm_does_full_preprocessing, [
if test "$AS" != ""; then
	# check that it really works
	cat > conftest.s << EOF

# define foo(x) \
	/* foo */

	foo(x)
EOF
	if 
		echo $AS conftest.s >&AC_FD_CC 2>&1 &&
		$AS conftest.s </dev/null >&AC_FD_CC 2>&1 
	then
		mercury_cv_asm_does_full_preprocessing="yes"
	else
		AS="gcc -c -x assembler-with-cpp"
		mercury_cv_asm_does_full_preprocessing="no"
		AC_MSG_RESULT(no)	
	fi
	rm -f conftest*
else
	AS="gcc -c -x assembler-with-cpp"
fi
])
AC_MSG_RESULT($mercury_cv_asm_does_full_preprocessing)	
AC_DEFINE(AS)
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether structure assignment conflicts with global registers)
AC_CACHE_VAL(mercury_cv_cannot_use_structure_assignment,
AC_TRY_RUN([
changequote(<<,>>) 

/* USE_GCC_GLOBAL_REGISTERS are essential to the purpose of the test. */
/* We define USE_GCC_NONLOCAL_GOTOS because some platforms (e.g. SPARCs) */
/* cannot have USE_GCC_GLOBAL_REGISTERS without it. */
#define	USE_GCC_GLOBAL_REGISTERS
#define USE_GCC_NONLOCAL_GOTOS
#include "mercury_imp.h"
#include "trace/mercury_trace_spy.h"

MR_Spy_Point	spied_procs[2];

int main() {
	spied_procs[1] = spied_procs[0];
	exit(0);
changequote([,]) 
}],
[mercury_cv_cannot_use_structure_assignment=no],
[mercury_cv_cannot_use_structure_assignment=yes],
[mercury_cv_cannot_use_structure_assignment=yes]))
AC_MSG_RESULT($mercury_cv_cannot_use_structure_assignment)
if test $mercury_cv_cannot_use_structure_assignment = "yes"; then
	AC_DEFINE(MR_CANNOT_USE_STRUCTURE_ASSIGNMENT)
fi
#-----------------------------------------------------------------------------#
AC_MSG_CHECKING(whether Mercury supports shared libraries on this system)
# We ought to use $target here rather than $host - but we don't
# support cross-compilation at the moment anyhow.

# set up some default values that should work on most systems
# see Mmake.common.in for documentation on the meaning of these variables
LINK_SHARED_OBJ="$CC -shared"
SHARED_LIBS='`gcc -print-libgcc-file-name` -lm -lc'
EXE_RPATH_OPT="-Wl,-rpath,"
EXE_RPATH_SEP=" -Wl,-rpath,"
SHLIB_RPATH_OPT="-Wl,-rpath,"
SHLIB_RPATH_SEP=" -Wl,-rpath,"
CFLAGS_FOR_PIC="-fpic -DPIC"
EXT_FOR_PIC_OBJECTS=pic_o
EXT_FOR_SHARED_LIB=a
USE_DLLS=no
# The following variables specify options to $LINK_SHARED_OBJ to
# allow/disallow unresolved symbols when building shared libraries.
ALLOW_UNDEFINED=""
ERROR_UNDEFINED=""

case "$host" in
	i?86-*-linux|i?86-*-linux-gnu)
		AC_MSG_RESULT(yes)
		EXT_FOR_SHARED_LIB=so
		;;
	m68*-linux|m68*-linux-gnu)
		AC_MSG_RESULT(yes)
		EXT_FOR_SHARED_LIB=so
		;;
	i?86-*-freebsd*)
		# From Cornelis van der Laan <nils@ims.uni-stuttgart.de>
		AC_MSG_RESULT(yes)
		LINK_SHARED_OBJ="ld -Bshareable"
		EXT_FOR_SHARED_LIB=so
		# From Kevet Duncombe <dunc@acm.org> tested on FreeBSD 2.2.5
		EXE_RPATH_OPT="-R"
		EXE_RPATH_SEP=" -R"
		SHLIB_RPATH_OPT="-R"
		SHLIB_RPATH_SEP=" -R"
		;;
	sparc-sun-solaris2.*)
		AC_MSG_RESULT(yes)
		SHARED_LIBS="-lm -lc"	# don't link in libgcc.a
		LINK_SHARED_OBJ="$CC -G"
		ERROR_UNDEFINED="-Wl,-z,defs"
		EXE_RPATH_OPT="-R"
		EXE_RPATH_SEP=" -R"
		SHLIB_RPATH_OPT="-R"
		SHLIB_RPATH_SEP=" -R"
		CFLAGS_FOR_PIC="-fpic -DPIC"	# used only for libgc.{a,so}
		EXT_FOR_PIC_OBJECTS=o
		#
		# Note that despite the above definition of CFLAGS_FOR_PIC,
		# we don't use `-fpic' for shared libraries on Solaris
		# (the definition of EXT_FOR_PIC_OBJECTS=o means that
		# CFLAGS_FOR_PIC will be used only for building libgc.a
		# and libgc.so.)
		#
		# The reason for this is that shared libraries work without
		# it (well, at least they are shared on disk -- although the
		# code is not shared at runtime), and using `-fpic' would
		# reduce efficiency.
		#
		# It works because the Solaris dynamic linker will
		# actually do the fixups at runtime for non-PIC code.
		# (The code is mapped copy-on-write, and when the linker
		# does the fixups, it gets copied.  Hence the lack of
		# runtime sharing.)  We need to link with `gcc -G'
		# rather than `gcc -shared', because `gcc -shared'
		# passes `-z text' to the linker, which causes it to
		# report an error if any runtime fixups would be needed.
		#
		# If you *do* use `-fpic', you must also use `-DPIC'.
		#
		# See runtime/mercury_goto.h for the code that handles PIC
		# on SPARCs.
		# Note that mixing PIC and non-PIC code is fine on SPARCs
		# (though it doesn't work on x86s, due to the use of `ebx'
		# in runtime/machdeps/i386_regs.h).

		EXT_FOR_SHARED_LIB=so
		;;
	alpha-dec-osf*)
		AC_MSG_RESULT(yes)
		LINK_SHARED_OBJ="gcc -shared \
			-Wl,-O3,-update_registry,../so_locations"
		ERROR_UNDEFINED="-Wl,-error_unresolved"
		EXE_RPATH_OPT="-Wl,-rpath,"
		EXE_RPATH_SEP=":"
		SHLIB_RPATH_OPT="-Wl,-rpath,"
		SHLIB_RPATH_SEP=":"
		EXT_FOR_SHARED_LIB=so
		# -fpic not needed on Alpha/OSF, since it is the default
		CFLAGS_FOR_PIC=
		EXT_FOR_PIC_OBJECTS=o
		;;
	mips-sgi-irix5.*)
		LINK_SHARED_OBJ="ld -shared -update_registry ../so_locations\
			-quickstart_info -rdata_shared"
		ERROR_UNDEFINED="-no_unresolved"
		EXE_RPATH_OPT="-Wl,-rpath,"
		EXE_RPATH_SEP=":"
		SHLIB_RPATH_OPT="-rpath "
		SHLIB_RPATH_SEP=":"
		# -fpic not needed on IRIX, since it is the default
		CFLAGS_FOR_PIC=
		EXT_FOR_PIC_OBJECTS=o
		# shared libraries only work for reg.gc or none.gc
		if test "$GRADE" = reg.gc || test "$GRADE" = none.gc; then
			AC_MSG_RESULT(yes)
			EXT_FOR_SHARED_LIB=so
		else
			EXT_FOR_SHARED_LIB=a
			AC_MSG_RESULT(no)
			AC_MSG_RESULT(Read README.IRIX-5)
		fi
		;;
	*-cygwin*)
		# disabled for now, since it hasn't been tested
		# xxx_MSG_RESULT(yes)
		# EXT_FOR_SHARED_LIB=dll
		# USE_DLLS=yes
		AC_MSG_RESULT(disabled for now because it is untested)

		CFLAGS_FOR_PIC=
		;;
	*)
		# CFLAGS_FOR_PIC is used by boehm_gc/Makefile when creating
		# libgc.a.  If the system doesn't support shared libraries,
		# then we should set it to empty, not `-fpic'.
		CFLAGS_FOR_PIC=
		AC_MSG_RESULT(no)
		;;
esac

#
# This sets the default value of RM_C, which should be either `rm' to
# remove the intermediate C files, or `:' to keep them.
#
# If RM_C is set to `rm', then unfortunately Mmake needs to invoke
# make recursively, and this causes several problems:
#	(1) it causes performance problems, particularly on MS-Windows
#	(2) it can break parallel makes, because there are race
#           conditions involved when you invoke make recursively
#	    in a parallel make
#
# Therefore by default we currently keep the intermediate C files.
#
DEFAULT_RM_C=:

case $EXT_FOR_PIC_OBJECTS in
	o)
		LIBRARY_RM_C=$DEFAULT_RM_C
		;;
	*)
		# If we're going to be building both `.pic_o' files
		# and `.o' files, then we should not remove the generated `.c'
		# files in the library directory after building the `.o' files.
		LIBRARY_RM_C=:
		;;
esac

#-----------------------------------------------------------------------------#

AC_SUBST(LINK_SHARED_OBJ)
AC_SUBST(ERROR_UNDEFINED)
AC_SUBST(ALLOW_UNDEFINED)
AC_SUBST(EXE_RPATH_OPT)
AC_SUBST(EXE_RPATH_SEP)
AC_SUBST(SHLIB_RPATH_OPT)
AC_SUBST(SHLIB_RPATH_SEP)
AC_SUBST(CFLAGS_FOR_PIC)
AC_SUBST(EXT_FOR_PIC_OBJECTS)
AC_SUBST(EXT_FOR_SHARED_LIB)
AC_SUBST(USE_DLLS)
AC_SUBST(SHARED_LIBS)
AC_SUBST(DEFAULT_RM_C)
AC_SUBST(LIBRARY_RM_C)
if test $USE_DLLS = "yes"; then
	AC_DEFINE(USE_DLLS)
fi
#-----------------------------------------------------------------------------#
if test "$BOOTSTRAP_MC" = ""; then
	BOOTSTRAP_MC=mmc
fi
BOOTSTRAP_MC="$BOOTSTRAP_MC $HAVE_BOXED_FLOATS --conf-low-tag-bits $LOW_TAG_BITS --bits-per-word $BITS_PER_WORD --bytes-per-word $BYTES_PER_WORD"
AC_SUBST(BOOTSTRAP_MC)
#-----------------------------------------------------------------------------#

# The following allows us to share some subroutines between the
# `ml' and `mgnuc' scripts.

top=`pwd`
INIT_GRADE_OPTIONS=$top/scripts/init_grade_options.sh-subr
PARSE_GRADE_OPTIONS=$top/scripts/parse_grade_options.sh-subr
FINAL_GRADE_OPTIONS=$top/scripts/final_grade_options.sh-subr
AC_SUBST_FILE(INIT_GRADE_OPTIONS)
AC_SUBST_FILE(PARSE_GRADE_OPTIONS)
AC_SUBST_FILE(FINAL_GRADE_OPTIONS)

#-----------------------------------------------------------------------------#
#
# Check whether sockets work (we need them for the external debugger)
#

#
# check whether we need -lsocket
#
AC_CHECK_LIB(socket, socket, SOCKET_LIBRARY=-lsocket, SOCKET_LIBRARY="")
AC_SUBST(SOCKET_LIBRARY)

#
# temporarily add -lsocket to LIBS, for use by TRY_LINK
#
save_LIBS="$LIBS"
LIBS="$LIBS $SOCKET_LIBRARY"

#
# use TRY_LINK to see whether we can use sockets
#
AC_MSG_CHECKING(whether we can use sockets (for Opium-M))
AC_CACHE_VAL(mercury_cv_sockets_work,
AC_TRY_LINK([
	changequote(<<,>>) 
	/*
	** The following code was copied from
	** runtime/mercury_trace_external.c
	*/

	#include <stdio.h>
	#include <string.h>
	#include <errno.h>
	#include <stdarg.h>
	#include <stdlib.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <netdb.h>
],[
	static int MR_debug_socket = 1;

	void
	fatal_error(const char *s)
	{
		fprintf(stderr, "", s);
		exit(1);
	}

	void
	MR_trace_init_external(void)
	{
		int fd;
		int len;
		FILE *file_in;
		FILE *file_out;
		int addr_family;
		char *unix_socket;
		char *inet_socket;
		struct sockaddr_un unix_address;
		struct sockaddr_in inet_address;
		struct sockaddr* addr;

		/*
		** We presume that the user's program has been invoked from
		** within the debugger (e.g. Opium).
		** The debugger (or the user) should set the
		** MERCURY_DEBUGGER_UNIX_SOCKET or MERCURY_DEBUGGER_INET_SOCKET
		** environment variable to tell the user's program which socket
		** it needs to connect to.
		*/
		unix_socket = getenv("MERCURY_DEBUGGER_UNIX_SOCKET");
		inet_socket = getenv("MERCURY_DEBUGGER_INET_SOCKET");
		if (unix_socket == NULL && inet_socket == NULL) {
			fatal_error("you must set either the "
				"MERCURY_DEBUGGER_UNIX_SOCKET\n"
				"or MERCURY_DEBUGGER_INET_SOCKET "
				"environment variable");
		}
		if (unix_socket != NULL && inet_socket != NULL) {
			fatal_error("you must set only one of the "
				"MERCURY_DEBUGGER_UNIX_SOCKET "
				"and MERCURY_DEBUGGER_INET_SOCKET\n"
				"environment variables");
		}
		if (unix_socket) {
		
			addr_family = AF_UNIX;
			memset(&unix_address, 0, sizeof(unix_address));
			unix_address.sun_family = AF_UNIX;
			strcpy(unix_address.sun_path, unix_socket);
			addr = (struct sockaddr *) &unix_address;
			len = strlen(unix_address.sun_path) + 
				sizeof(unix_address.sun_family);
		} else {
			char hostname[255];
			char port_string[255];
			unsigned short port;
			int host_addr;

			/*
			** Parse the MERCURY_DEBUGGER_INET_SOCKET environment variable.
			** It should be in the format "<hostname> <port>",
			** where <hostname> is numeric (e.g. "123.456.78.90").
			*/

			if (sscanf(inet_socket, "%254s %254s", hostname, port_string) 
				!= 2)
			{
				fatal_error("MERCURY_DEBUGGER_INET_SOCKET invalid");
			}
			host_addr = inet_network(hostname);
			if (host_addr == -1) {
				fatal_error("MERCURY_DEBUGGER_INET_SOCKET: "
					"invalid address");
			}
			if (sscanf(port_string, "%hu", &port) != 1) {
				fatal_error("MERCURY_DEBUGGER_INET_SOCKET: "
					"invalid port");
			}

			fprintf(stderr, "Mercury runtime: host = %s, port = %d\n",
					hostname, port);
		
			inet_address.sin_family = AF_INET;
			inet_address.sin_addr.s_addr = host_addr;
			inet_address.sin_port = htons(port);
			addr_family = AF_INET;
			addr = (struct sockaddr *) &inet_address;
			len = sizeof(inet_address);
		}

		/*
		** Open the socket.
		*/

		fd = socket(addr_family, SOCK_STREAM, 0);
		if (fd < 0) {
			fprintf(stderr, "Mercury runtime: socket() failed: %s\n",
				strerror(errno));
			fatal_error("cannot open socket for debugger");
		} else if (MR_debug_socket) {
			fprintf(stderr,"Mercury runtime: creation of socket ok\n");
		}

		/*
		** Connect to the socket
		*/
		if (connect(fd, addr, len) < 0) {
			fprintf(stderr, "Mercury runtime: connect() failed: %s\n",
				strerror(errno));
			fatal_error("can't connect to debugger socket");
		} else if (MR_debug_socket) {
			fprintf(stderr, "Mercury runtime: connection to socket: ok\n");
		}

		/*
		** Convert the socket fd to a Mercury stream
		*/
		file_in = fdopen(fd, "r");
		file_out = fdopen(fd, "w");
		if ((file_in == NULL)||(file_out == NULL)) {
			fprintf(stderr, "Mercury runtime: fdopen() failed: %s\n",
				strerror(errno));
			fatal_error("cannot open debugger socket");
		} else if (MR_debug_socket) {
			fprintf(stderr, "Mercury runtime: fdopen(): ok\n");
		}
	}
	changequote([,]) 
],[mercury_cv_sockets_work=yes],[mercury_cv_sockets_work=no]))

#
# figure out whether the test succeeded
#
if test "$mercury_cv_sockets_work" = yes; then
	AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi

#
# restore the previous value of LIBS
#
LIBS="$save_LIBS"

#-----------------------------------------------------------------------------#
#
# Add an option that enables the external debugger support.
# By default, external debugger support is enabled if and only if
# sockets work.  But it is also possible to explicitly disable this
# by passing the `--disable-extern-debug' option.  This is needed on
# some platforms because the test for sockets working sometimes gets
# some false positives (e.g. if they work with dynamic linking but
# not static linking, then the test will pass, but it will cause
# problems later on when we try to link things statically).
#
AC_ARG_ENABLE(extern-debug,
[  --disable-extern-debug  disable the external (separate process) debugger],
mercury_cv_enable_extern_debug="$enableval",
mercury_cv_enable_extern_debug="$mercury_cv_sockets_work")

AC_MSG_CHECKING(whether to enable the external debugger)
if test "$mercury_cv_enable_extern_debug" = "yes"; then
	if test "$mercury_cv_sockets_work" = yes; then
		AC_MSG_RESULT(yes)
		AC_DEFINE(MR_USE_EXTERNAL_DEBUGGER)
	else
		AC_MSG_RESULT(no)
		AC_MSG_ERROR(Cannot enable external debugger)
		AC_MSG_ERROR(because sockets do not work)
	fi		
else
	AC_MSG_RESULT(no)
fi
#-----------------------------------------------------------------------------#
MERCURY_CHECK_READLINE
#-----------------------------------------------------------------------------#
to_keep=""
to_delete=""
if test "$BOOTSTRAP_MC" != "" ; then
    MERCURY_MSG("checking whether any C files need to be rebuilt...")
    for c_file in library/*.c compiler/*.c browser/*.c profiler/*.c
    do
        case $c_file in
        */'*.c')
            ;;
        *)
            sed -e '/END_OF_C_GRADE_INFO/,$d' < $c_file > confscratch
            if grep "TAG_BITS=$mercury_cv_low_tag_bits" \
	    	confscratch > /dev/null 2>&1
            then
                if grep "UNBOXED_FLOAT=$mercury_cv_unboxed_floats" \
			confscratch > /dev/null 2>&1
                then
                    to_keep="$to_keep $c_file"
                else
                    to_delete="$to_delete $c_file"
                fi
            else
                to_delete="$to_delete $c_file"
            fi
            ;;
        esac
    done
    if test "$to_delete" = "" ; then
        if test "$to_keep" != "" ; then
            MERCURY_MSG("no - they are compatible with autoconfigured settings")
        else
            MERCURY_MSG("there are no existing Mercury-generated C files")
        fi
    else
        if test "$to_keep" != "" ; then
            MERCURY_MSG("the following C files must be rebuilt in a grade")
            MERCURY_MSG("that is consistent with autoconfigured settings")
            MERCURY_MSG("$to_delete")
        else
            MERCURY_MSG("all Mercury generated C files must be rebuilt")
            MERCURY_MSG("in a grade that is consistent with the")
            MERCURY_MSG("autoconfigured settings")
        fi
        MERCURY_MSG("installation may take longer than usual")
    fi
    rm -f confscratch $to_delete
fi
#-----------------------------------------------------------------------------#
AC_OUTPUT(Mmake.common scripts/Mmake.vars scripts/mmc scripts/mprof
scripts/mercury_update_interface scripts/mgnuc scripts/ml
scripts/mmake scripts/c2init scripts/mdb scripts/mdbrc 
scripts/sicstus_conv scripts/mkfifo_using_mknod bindist/bindist.build_vars
,
for header in $CONFIG_HEADERS ; do
	if test "$header" = "runtime/mercury_conf.h"; then
		touch runtime/mercury_conf.h.date
	fi
done
# conftest.junk is used to avoid a warning if there
# are no files in the list passed to chmod
touch conftest.junk
chmod +x `echo $CONFIG_FILES | sed -e 's/[^ ]*Mmake.common//' ` conftest.junk
rm -f conftest.junk

# The --prefix is hard-coded in the scripts, which are regenerated every
# time you run configure, and also (unfortunately) in the .so files.
# The following rm command is here to ensure that things will work correctly
# if you rerun configure with a new --prefix and then don't do a `make clean'
# before running `make'.
rm -f runtime/libmer.so library/libmercury.so bytecode/libmbi.so
)

#-----------------------------------------------------------------------------#