#! /bin/sh

# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 2.9 
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.

# Defaults:
ac_help=
ac_default_prefix=/usr/local
# Any additions from configure.in:
ac_default_prefix=/usr/local/mercury-`. ./VERSION; echo $VERSION`
ac_help="$ac_help
  --with-cc=<program>     Specify which C compiler to use."
ac_help="$ac_help
  --enable-gcc-back-end   enable the Mercury compiler's GCC back-end interface"
ac_help="$ac_help
  --disable-aditi-back-end
                          disable the Mercury compiler's Aditi back-end"
ac_help="$ac_help
  --enable-inefficient-grades
                          install inefficient versions of the library"
ac_help="$ac_help
  --disable-most-grades   install only the essential versions of the library"
ac_help="$ac_help
  --disable-nogc-grades   do not install no-gc versions of the library"
ac_help="$ac_help
  --disable-prof-grades   do not install profiling versions of the library"
ac_help="$ac_help
  --disable-trail-grades  do not install trailing versions of the library"
ac_help="$ac_help
  --disable-par-grades    do not install thread-safe versions of the library"
ac_help="$ac_help
  --enable-hlc-prof-grades
                          install profiling versions of the high level C grade"
ac_help="$ac_help
  --enable-libgrades=...  install exactly the given versions of the library"
ac_help="$ac_help
  --disable-decl-debug    disable the declarative debugger"
ac_help="$ac_help
  --disable-extern-debug  disable the external (separate process) debugger"
ac_help="$ac_help
  --disable-dynamic-link  disable the use of dynamic linking"
ac_help="$ac_help
  --enable-new-mercuryfile-struct
                          enable new MercuryFile struct."
ac_help="$ac_help
  --without-readline      Don't use the GPL'd GNU readline library"

# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
cache_file=./config.cache
exec_prefix=NONE
host=NONE
no_create=
nonopt=NONE
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
target=NONE
verbose=
x_includes=NONE
x_libraries=NONE
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datadir='${prefix}/share'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
libdir='${exec_prefix}/lib'
includedir='${prefix}/include'
oldincludedir='/usr/include'
infodir='${prefix}/info'
mandir='${prefix}/man'

# Initialize some other variables.
subdirs=
MFLAGS= MAKEFLAGS=

ac_prev=
for ac_option
do

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

  case "$ac_option" in
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  *) ac_optarg= ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case "$ac_option" in

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir="$ac_optarg" ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build="$ac_optarg" ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file="$ac_optarg" ;;

  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
  | --da=*)
    datadir="$ac_optarg" ;;

  -disable-* | --disable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    eval "enable_${ac_feature}=no" ;;

  -enable-* | --enable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "enable_${ac_feature}='$ac_optarg'" ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix="$ac_optarg" ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he)
    # Omit some internal or obsolete options to make the list less imposing.
    # This message is too long to be a string in the A/UX 3.1 sh.
    cat << EOF
Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
Configuration:
  --cache-file=FILE       cache test results in FILE
  --help                  print this message
  --no-create             do not create output files
  --quiet, --silent       do not print \`checking...' messages
  --version               print the version of autoconf that created configure
Directory and file names:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [same as prefix]
  --bindir=DIR            user executables in DIR [EPREFIX/bin]
  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
  --datadir=DIR           read-only architecture-independent data in DIR
                          [PREFIX/share]
  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
                          [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
  --includedir=DIR        C header files in DIR [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
  --infodir=DIR           info documentation in DIR [PREFIX/info]
  --mandir=DIR            man documentation in DIR [PREFIX/man]
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
  --program-prefix=PREFIX prepend PREFIX to installed program names
  --program-suffix=SUFFIX append SUFFIX to installed program names
  --program-transform-name=PROGRAM
                          run sed PROGRAM on installed program names
EOF
    cat << EOF
Host type:
  --build=BUILD           configure for building on BUILD [BUILD=HOST]
  --host=HOST             configure for HOST [guessed]
  --target=TARGET         configure for TARGET [TARGET=HOST]
Features and packages:
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --x-includes=DIR        X include files are in DIR
  --x-libraries=DIR       X library files are in DIR
EOF
    if test -n "$ac_help"; then
      echo "--enable and --with options recognized:$ac_help"
    fi
    exit 0 ;;

  -host | --host | --hos | --ho)
    ac_prev=host ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host="$ac_optarg" ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir="$ac_optarg" ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir="$ac_optarg" ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir="$ac_optarg" ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir="$ac_optarg" ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst \
  | --locals | --local | --loca | --loc | --lo)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
    localstatedir="$ac_optarg" ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir="$ac_optarg" ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

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

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir="$ac_optarg" ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix="$ac_optarg" ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix="$ac_optarg" ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix="$ac_optarg" ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name="$ac_optarg" ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir="$ac_optarg" ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir="$ac_optarg" ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site="$ac_optarg" ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir="$ac_optarg" ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir="$ac_optarg" ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target="$ac_optarg" ;;

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

  -version | --version | --versio | --versi | --vers)
    echo "configure generated by autoconf version 2.9"
    exit 0 ;;

  -with-* | --with-*)
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "with_${ac_package}='$ac_optarg'" ;;

  -without-* | --without-*)
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    eval "with_${ac_package}=no" ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes="$ac_optarg" ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries="$ac_optarg" ;;

  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
    ;;

  *)
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
      echo "configure: warning: $ac_option: invalid host type" 1>&2
    fi
    if test "x$nonopt" != xNONE; then
      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
    fi
    nonopt="$ac_option"
    ;;

  esac
done

if test -n "$ac_prev"; then
  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
fi

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

# File descriptor usage:
# 0 standard input
# 1 file creation
# 2 errors and warnings
# 3 some systems may open it to /dev/tty
# 4 used on the Kubota Titan
# 6 checking for... messages and results
# 5 compiler messages saved in config.log
if test "$silent" = yes; then
  exec 6>/dev/null
else
  exec 6>&1
fi
exec 5>./config.log

echo "\
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
" 1>&5

# Strip out --no-create and --no-recursion so they do not pile up.
# Also quote any args containing shell metacharacters.
ac_configure_args=
for ac_arg
do
  case "$ac_arg" in
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c) ;;
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
  esac
done

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

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h

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

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then its parent.
  ac_prog=$0
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
  srcdir=$ac_confdir
  if test ! -r $srcdir/$ac_unique_file; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r $srcdir/$ac_unique_file; then
  if test "$ac_srcdir_defaulted" = yes; then
    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
  else
    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
  fi
fi
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`

# Prefer explicitly selected file to automatically selected ones.
if test -z "$CONFIG_SITE"; then
  if test "x$prefix" != xNONE; then
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
  else
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
  fi
fi
for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    echo "loading site script $ac_site_file"
    . "$ac_site_file"
  fi
done

if test -r "$cache_file"; then
  echo "loading cache $cache_file"
  . $cache_file
else
  echo "creating cache $cache_file"
  > $cache_file
fi

ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'

if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='	'
  else
    ac_n=-n ac_c= ac_t=
  fi
else
  ac_n= ac_c='\c' ac_t=
fi


TMPDIR=${TMPDIR=/tmp}
#-----------------------------------------------------------------------------#
#
# 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_aux_dir=
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
  if test -f $ac_dir/install-sh; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install-sh -c"
    break
  elif test -f $ac_dir/install.sh; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install.sh -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; }
fi
ac_config_guess=$ac_aux_dir/config.guess
ac_config_sub=$ac_aux_dir/config.sub
ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.


# Make sure we can run config.sub.
if $ac_config_sub sun4 >/dev/null 2>&1; then :
else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
fi

echo $ac_n "checking host system type""... $ac_c" 1>&6

host_alias=$host
case "$host_alias" in
NONE)
  case $nonopt in
  NONE)
    if host_alias=`$ac_config_guess`; then :
    else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
    fi ;;
  *) host_alias=$nonopt ;;
  esac ;;
esac

host=`$ac_config_sub $host_alias`
host_cpu=`echo $host | sed 's/^\(.*\)-\(.*\)-\(.*\)$/\1/'`
host_vendor=`echo $host | sed 's/^\(.*\)-\(.*\)-\(.*\)$/\2/'`
host_os=`echo $host | sed 's/^\(.*\)-\(.*\)-\(.*\)$/\3/'`
echo "$ac_t""$host" 1>&6

FULLARCH="$host"

cat >> confdefs.h <<EOF
#define MR_FULLARCH "$FULLARCH"
EOF

. ./VERSION
cat >> confdefs.h <<EOF
#define MR_VERSION "$VERSION"
EOF

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}



DEFAULT_MERCURY_DEBUGGER_INIT_DIR=$LIBDIR/mdb

#-----------------------------------------------------------------------------#
case "$host" in
	mips-sgi-irix5.*)
		echo "configure: warning: *** Read README.IRIX-5 before proceeding!" 1>&2
		;;
	*-*-bsdi*)
		echo "configure: warning: *** Read README.BSDI before proceeding!" 1>&2
		;;
esac
#-----------------------------------------------------------------------------#
echo "looking for an already installed Mercury compiler to bootstrap with..." 1>&6
# Extract the first word of "mmc", so it can be a program name with args.
set dummy mmc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_BOOTSTRAP_MC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$BOOTSTRAP_MC" in
  /*)
  ac_cv_path_BOOTSTRAP_MC="$BOOTSTRAP_MC" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_BOOTSTRAP_MC="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
BOOTSTRAP_MC="$ac_cv_path_BOOTSTRAP_MC"
if test -n "$BOOTSTRAP_MC"; then
  echo "$ac_t""$BOOTSTRAP_MC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test "$BOOTSTRAP_MC" != ""; then
	echo $ac_n "checking whether $BOOTSTRAP_MC works and is sufficiently recent""... $ac_c" 1>&6
	cat > conftest.m << EOF
		% this module contains features which didn't work in
		% previous versions of the Mercury compiler
		% We may also test to see if the installed compiler is
		% recent enough by checking what flags mmc takes.
		% Use [ ] for lists.
		:- module conftest.
		:- interface.
		:- import_module io.
		:- pred main(io__state::di, io__state::uo) is det.

		:- implementation.
	
		% Check that we can declare foreign_proc for C and MC++.
		:- pred foo(int::out) is det.
		:- pragma foreign_proc("C",    foo(X::out),
			[will_not_call_mercury, thread_safe],
			" X = 42; ").
		:- pragma foreign_proc("MC++", foo(X::out),
			[will_not_call_mercury, thread_safe],
			" X = 42; ").

		% Currently we test that mmc accepts the
		% --fixed-user-guided-type-specialization flag.
		main --> 
			( { foo(42) } ->
				print("Hello, world\n")
			;
				print("Nope.\n")
			).
EOF
	if
	 	 echo $BOOTSTRAP_MC conftest >&5 2>&1 &&
	 	 $BOOTSTRAP_MC --fixed-user-guided-type-specialization \
			 --halt-at-warn --link-flags "--static" conftest \
		 	</dev/null >&5 2>&1 &&
		 test "`./conftest 2>&1 | tr -d '\015'`" = "Hello, world"
	then
		rm -f conftest*
		cat > conftest.m << EOF
			% This module generates an assignment of the address of
			% the MR_do_fail label to a redoip slot.
			:- module conftest.

			:- interface.

			:- pred p(int::out) is multi.

			:- implementation.

			p(1).
			p(2).
EOF
		if 
			$BOOTSTRAP_MC --compile-to-c --grade asm_fast.gc -O0 \
				conftest </dev/null >&5 2>&1 &&
			grep "MR_ENTRY(MR_do_fail);" conftest.c >/dev/null 2>&1
		then
		echo "$ac_t""yes" 1>&6
		else
			BOOTSTRAP_MC=
			echo "$ac_t""no" 1>&6
		fi
	else
		BOOTSTRAP_MC=
		echo "$ac_t""no" 1>&6
	fi
	rm -f conftest*
fi
#-----------------------------------------------------------------------------#
# Let the user specify which C compiler to use.
# Check whether --with-cc or --without-cc was given.
if test "${with_cc+set}" = set; then
  withval="$with_cc"
  mercury_cv_with_cc="$withval"
else
  mercury_cv_with_cc=""
fi

case "$mercury_cv_with_cc" in
	yes)	{ echo "configure: error: missing argument to --with-cc=... option" 1>&2; exit 1; }
		exit 1
		;;
	no)	{ echo "configure: error: invalid option --without-cc" 1>&2; exit 1; }
		exit 1
		;;
	"")
		;;
	*)
		CC="$mercury_cv_with_cc"
		;;
esac
#-----------------------------------------------------------------------------#
#
# Find the GCC source code
# and determine whether or not to enable the GCC back-end interface.
#
# Check whether --enable-gcc-back-end or --disable-gcc-back-end was given.
if test "${enable_gcc_back_end+set}" = set; then
  enableval="$enable_gcc_back_end"
  enable_gcc_back_end="$enableval"
else
  enable_gcc_back_end=default
fi

echo $ac_n "checking for GCC source directory""... $ac_c" 1>&6
gcc_src_dir=not_found
case $enable_gcc_back_end in
	yes|no|default)
		# Search for the gcc source code;
		# first try in a subdirectory of this directory,
		# then one parallel to this directory,
		# and finally try one level up.
		for dir in gcc ../gcc ..; do
			if test -f $dir/gcc/tree.c; then
				gcc_src_dir="$dir"
				break
			fi
		done
		;;
	*)
		# The user has specifies the gcc source directory via
		# `--enable-gcc-back-end=<directory>'.  Check that
		# they specified it correctly.
		gcc_src_dir="$enable_gcc_back_end"
		if test -f "$gcc_src_dir"/gcc/tree.c; then
			enable_gcc_back_end=yes
		else
			{ echo "configure: error: --enable-gcc-back-end=$gcc_src_dir specified" 1>&2; exit 1; }
			{ echo "configure: error: but GCC source code not found in $gcc_src_dir" 1>&2; exit 1; }
			exit 1
		fi		
		;;
esac
echo "$ac_t""$gcc_src_dir" 1>&6
echo $ac_n "checking whether to enable the GCC back-end interface""... $ac_c" 1>&6
case $enable_gcc_back_end in
	yes|default)
		if test "$gcc_src_dir" = not_found; then
			case $enable_gcc_back_end in
				yes)
					{ echo "configure: error: --enable-gcc-back-end specified" 1>&2; exit 1; }
					{ echo "configure: error: but gcc source code not found" 1>&2; exit 1; }
					exit 1
					;;
				default)
					enable_gcc_back_end=no
					;;
			esac
		else
			enable_gcc_back_end=yes
		fi
		;;
	no)
		;;
esac
echo "$ac_t""$enable_gcc_back_end" 1>&6
ENABLE_GCC_BACK_END=$enable_gcc_back_end
GCC_SRC_DIR=$gcc_src_dir


#-----------------------------------------------------------------------------#
#
# Determine whether or not to enable the Aditi back-end.
#
# Check whether --enable-aditi-back-end or --disable-aditi-back-end was given.
if test "${enable_aditi_back_end+set}" = set; then
  enableval="$enable_aditi_back_end"
  enable_aditi_back_end="$enableval"
else
  enable_aditi_back_end=yes
fi

echo $ac_n "checking whether to enable the Aditi back-end""... $ac_c" 1>&6
echo "$ac_t""$enable_aditi_back_end" 1>&6
ENABLE_ADITI_BACK_END=$enable_aditi_back_end

#-----------------------------------------------------------------------------#
echo "looking for GNU Make..." 1>&6
for ac_prog in gmake make
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_GNU_MAKE'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$GNU_MAKE"; then
  ac_cv_prog_GNU_MAKE="$GNU_MAKE" # Let the user override the test.
else
  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
      ac_cv_prog_GNU_MAKE="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
GNU_MAKE="$ac_cv_prog_GNU_MAKE"
if test -n "$GNU_MAKE"; then
  echo "$ac_t""$GNU_MAKE" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$GNU_MAKE" && break
done

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
	{ echo "configure: error: cannot find GNU Make" 1>&2; exit 1; }
	exit 1
else
	echo "found GNU Make: $GNU_MAKE" 1>&6
fi

#-----------------------------------------------------------------------------#
echo "looking for a way to create named pipes..." 1>&6

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

# Extract the first word of "mkfifo", so it can be a program name with args.
set dummy mkfifo; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_MKFIFO'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$MKFIFO" in
  /*)
  ac_cv_path_MKFIFO="$MKFIFO" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_MKFIFO="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
MKFIFO="$ac_cv_path_MKFIFO"
if test -n "$MKFIFO"; then
  echo "$ac_t""$MKFIFO" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test "$MKFIFO" != ""; then
	# check that it really works
	tmp=$TMPDIR/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
	# Extract the first word of "mknod", so it can be a program name with args.
set dummy mknod; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_MKNOD'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$MKNOD" in
  /*)
  ac_cv_path_MKNOD="$MKNOD" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_MKNOD="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
MKNOD="$ac_cv_path_MKNOD"
if test -n "$MKNOD"; then
  echo "$ac_t""$MKNOD" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

	if test "$MKNOD" != ""; then
		# check that it really works
		tmp=$TMPDIR/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
	echo "configure: warning: cannot find a working \`mkfifo' or \`mknod'" 1>&2
	MKFIFO=none
fi

test "$MKNOD" = "" && MKNOD=mknod


PATH="$save_PATH"
#-----------------------------------------------------------------------------#
echo "looking for a way to create temporary files..." 1>&6

# Extract the first word of "mktemp", so it can be a program name with args.
set dummy mktemp; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_MKTEMP'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$MKTEMP" in
  /*)
  ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_MKTEMP="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
MKTEMP="$ac_cv_path_MKTEMP"
if test -n "$MKTEMP"; then
  echo "$ac_t""$MKTEMP" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test "$MKTEMP" != ""; then
	# check that it really works
	TMPFILE="`mktemp $TMPDIR/configure.XXXXXX < /dev/null`"
	case "$TMPFILE" in 
		$TMPDIR/configure.*) rm -f $TMPFILE ;;
		*) MKTEMP="" ;;
	esac
fi
if test "$MKTEMP" = ""; then
	echo "configure: warning: cannot find a working \`mktemp'" 1>&2
	MKTEMP=""
fi

#-----------------------------------------------------------------------------#
# Extract the first word of "install-info", so it can be a program name with args.
set dummy install-info; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_INSTALL_INFO'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$INSTALL_INFO" in
  /*)
  ac_cv_path_INSTALL_INFO="$INSTALL_INFO" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_INSTALL_INFO="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
INSTALL_INFO="$ac_cv_path_INSTALL_INFO"
if test -n "$INSTALL_INFO"; then
  echo "$ac_t""$INSTALL_INFO" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "texi2dvi", so it can be a program name with args.
set dummy texi2dvi; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_TEXI2DVI'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$TEXI2DVI" in
  /*)
  ac_cv_path_TEXI2DVI="$TEXI2DVI" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_TEXI2DVI="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
TEXI2DVI="$ac_cv_path_TEXI2DVI"
if test -n "$TEXI2DVI"; then
  echo "$ac_t""$TEXI2DVI" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "dvips", so it can be a program name with args.
set dummy dvips; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_DVIPS'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$DVIPS" in
  /*)
  ac_cv_path_DVIPS="$DVIPS" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_DVIPS="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
DVIPS="$ac_cv_path_DVIPS"
if test -n "$DVIPS"; then
  echo "$ac_t""$DVIPS" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "makeinfo", so it can be a program name with args.
set dummy makeinfo; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_MAKEINFO'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$MAKEINFO" in
  /*)
  ac_cv_path_MAKEINFO="$MAKEINFO" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_MAKEINFO="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
MAKEINFO="$ac_cv_path_MAKEINFO"
if test -n "$MAKEINFO"; then
  echo "$ac_t""$MAKEINFO" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "info", so it can be a program name with args.
set dummy info; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_INFO'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$INFO" in
  /*)
  ac_cv_path_INFO="$INFO" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_INFO="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
INFO="$ac_cv_path_INFO"
if test -n "$INFO"; then
  echo "$ac_t""$INFO" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "perl", so it can be a program name with args.
set dummy perl; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_PERL'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$PERL" in
  /*)
  ac_cv_path_PERL="$PERL" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_PERL="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
PERL="$ac_cv_path_PERL"
if test -n "$PERL"; then
  echo "$ac_t""$PERL" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


#-----------------------------------------------------------------------------#
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  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
      ac_cv_prog_CC="gcc"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:"
  ac_prog_rejected=no
  for ac_dir in $PATH; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
        ac_prog_rejected=yes
	continue
      fi
      ac_cv_prog_CC="cc"
      break
    fi
  done
  IFS="$ac_save_ifs"
if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# -gt 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    set dummy "$ac_dir/$ac_word" "$@"
    shift
    ac_cv_prog_CC="$@"
  fi
fi
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
fi

echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.c <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1334: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gcc=yes
else
  ac_cv_prog_gcc=no
fi
fi

echo "$ac_t""$ac_cv_prog_gcc" 1>&6
if test $ac_cv_prog_gcc = yes; then
  GCC=yes
  if test "${CFLAGS+set}" != set; then
    echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_gcc_g'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  echo 'void f(){}' > conftest.c
if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
  ac_cv_prog_gcc_g=yes
else
  ac_cv_prog_gcc_g=no
fi
rm -f conftest*

fi

echo "$ac_t""$ac_cv_prog_gcc_g" 1>&6
    if test $ac_cv_prog_gcc_g = yes; then
      CFLAGS="-g -O"
    else
      CFLAGS="-O"
    fi
  fi
else
  GCC=
  test "${CFLAGS+set}" = set || CFLAGS="-g"
fi



# 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.
CPPFLAGS="-Iruntime -Iruntime/machdeps $CPPFLAGS"

# 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.
CPPFLAGS="-I/usr/local/include $CPPFLAGS"
LIBS="-L/usr/local/lib $LIBS"

echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
    # This must be in double quotes, not single quotes, because CPP may get
  # substituted into the Makefile and "${CC-cc}" will confuse make.
  CPP="${CC-cc} -E"
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp.
  cat > conftest.$ac_ext <<EOF
#line 1407 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1413: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  :
else
  echo "$ac_err" >&5
  rm -rf conftest*
  CPP="${CC-cc} -E -traditional-cpp"
  cat > conftest.$ac_ext <<EOF
#line 1422 "configure"
#include "confdefs.h"
#include <assert.h>
Syntax Error
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1428: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  :
else
  echo "$ac_err" >&5
  rm -rf conftest*
  CPP=/lib/cpp
fi
rm -f conftest*
fi
rm -f conftest*
  ac_cv_prog_CPP="$CPP"
fi
  CPP="$ac_cv_prog_CPP"
else
  ac_cv_prog_CPP="$CPP"
fi
echo "$ac_t""$CPP" 1>&6

echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1453 "configure"
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
#ifdef signal
#undef signal
#endif
#ifdef __cplusplus
extern "C" void (*signal (int, void (*)(int)))(int);
#else
void (*signal ()) ();
#endif

int main() { return 0; }
int t() {
int i;
; return 0; }
EOF
if { (eval echo configure:1471: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  ac_cv_type_signal=void
else
  rm -rf conftest*
  ac_cv_type_signal=int
fi
rm -f conftest*

fi

echo "$ac_t""$ac_cv_type_signal" 1>&6
cat >> confdefs.h <<EOF
#define RETSIGTYPE $ac_cv_type_signal
EOF


#-----------------------------------------------------------------------------#
# Check for `-lm': some systems, e.g. MacOS X (Darwin), don't have it.
echo $ac_n "checking for -lm""... $ac_c" 1>&6
ac_lib_var=`echo m_sin | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lm  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 1498 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char sin();

int main() { return 0; }
int t() {
sin()
; return 0; }
EOF
if { (eval echo configure:1508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  MATH_LIB=-lm
else
  echo "$ac_t""no" 1>&6
MATH_LIB=
fi


#-----------------------------------------------------------------------------#
echo $ac_n "checking for use of a Microsoft compiler""... $ac_c" 1>&6
cat > conftest.$ac_ext <<EOF
#line 1531 "configure"
#include "confdefs.h"

#ifdef _MSC_VER
	yes
#endif

EOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  egrep "yes" >/dev/null 2>&1; then
  rm -rf conftest*
  ac_microsoft=yes
 echo "$ac_t""yes" 1>&6
else
  rm -rf conftest*
  ac_microsoft=no
 echo "$ac_t""no" 1>&6
fi
rm -f conftest*


if test "$ac_microsoft" = "yes" ; then
	EXE_SUFFIX=".exe"
	OBJ_SUFFIX="obj"
	LIB_SUFFIX="lib"
	LIB_PREFIX="lib"
	LIB_LIBPATH="/LIBPATH:"
	LINK_LIB=""
	LINK_OPT_SEP="/link"

	OBJFILE_OPT="/Fo"
	AR="lib"
	ARFLAGS=""
	AR_LIBFILE_OPT="/OUT:"
	BOEHMGC_MAKEFILE="-f NT_MAKEFILE"

	CYGPATH="cygpath -w"

		# MS doesn't use a ranlib.
	RANLIB="echo"
	
else
	EXE_SUFFIX=""
	OBJ_SUFFIX="o"
	LIB_SUFFIX="a"
	LIB_PREFIX=""
	LIB_LIBPATH="-L"
	LINK_LIB="-l"
	LINK_OPT_SEP=""

	OBJFILE_OPT="-o "
	AR="ar"
	ARFLAGS="cr"
	AR_LIBFILE_OPT=""
	BOEHMGC_MAKEFILE=""

	CYGPATH=echo

	# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
  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
      ac_cv_prog_RANLIB="ranlib"
      break
    fi
  done
  IFS="$ac_save_ifs"
  test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
fi
fi
RANLIB="$ac_cv_prog_RANLIB"
if test -n "$RANLIB"; then
  echo "$ac_t""$RANLIB" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

fi















#-----------------------------------------------------------------------------#
# Microsoft.NET configuration
# 

# Extract the first word of "ilasm", so it can be a program name with args.
set dummy ilasm; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_ILASM'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$ILASM" in
  /*)
  ac_cv_path_ILASM="$ILASM" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_ILASM="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
ILASM="$ac_cv_path_ILASM"
if test -n "$ILASM"; then
  echo "$ac_t""$ILASM" 1>&6
else
  echo "$ac_t""no" 1>&6
fi


echo $ac_n "checking for Microsoft.NET Framework SDK""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_microsoft_dotnet'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  
if test "$ILASM" != ""; then
	 
	MS_DOTNET_SDK_DIR=`expr "$ILASM" : '\(.*\)[/\\]*[bB]in[/\\]*ilasm'`
	 
	mercury_cv_microsoft_dotnet="yes"
else
	MS_DOTNET_SDK_DIR=""
	mercury_cv_microsoft_dotnet="no"
fi

fi

echo "$ac_t""$mercury_cv_microsoft_dotnet" 1>&6
ILASM=`basename "$ILASM"`





#-----------------------------------------------------------------------------#
# 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
for ac_func in sysconf getpagesize memalign mprotect sigaction setitimer
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1706 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $ac_func(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
char $ac_func();

int main() { return 0; }
int t() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
$ac_func();
#endif

; return 0; }
EOF
if { (eval echo configure:1728: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=yes"
else
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=no"
fi
rm -f conftest*

fi
if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
  cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
 
else
  echo "$ac_t""no" 1>&6
fi
done

for ac_func in strerror memmove dup fileno fdopen fstat
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1757 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $ac_func(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
char $ac_func();

int main() { return 0; }
int t() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
$ac_func();
#endif

; return 0; }
EOF
if { (eval echo configure:1779: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=yes"
else
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=no"
fi
rm -f conftest*

fi
if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
  cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
 
else
  echo "$ac_t""no" 1>&6
fi
done

for ac_func in vsnprintf _vsnprintf
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1808 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $ac_func(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
char $ac_func();

int main() { return 0; }
int t() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
$ac_func();
#endif

; return 0; }
EOF
if { (eval echo configure:1830: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=yes"
else
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=no"
fi
rm -f conftest*

fi
if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
  cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
 
else
  echo "$ac_t""no" 1>&6
fi
done

#-----------------------------------------------------------------------------#
ac_safe=`echo "unistd.h" | tr './\055' '___'`
echo $ac_n "checking for unistd.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1859 "configure"
#include "confdefs.h"
#include <unistd.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1864: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_UNISTD_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_UNISTD_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_UNISTD_H 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/wait.h" | tr './\055' '___'`
echo $ac_n "checking for sys/wait.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1896 "configure"
#include "confdefs.h"
#include <sys/wait.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1901: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_WAIT_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_WAIT_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_WAIT 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/siginfo.h" | tr './\055' '___'`
echo $ac_n "checking for sys/siginfo.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1933 "configure"
#include "confdefs.h"
#include <sys/siginfo.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1938: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_SIGINFO_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_SIGINFO_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_SIGINFO 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/signal.h" | tr './\055' '___'`
echo $ac_n "checking for sys/signal.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 1970 "configure"
#include "confdefs.h"
#include <sys/signal.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:1975: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_SIGNAL_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_SIGNAL_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_SIGNAL 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "ucontext.h" | tr './\055' '___'`
echo $ac_n "checking for ucontext.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2007 "configure"
#include "confdefs.h"
#include <ucontext.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2012: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_UCONTEXT_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_UCONTEXT_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_UCONTEXT 1
EOF

else
	ac_safe=`echo "sys/ucontext.h" | tr './\055' '___'`
echo $ac_n "checking for sys/ucontext.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2043 "configure"
#include "confdefs.h"
#include <sys/ucontext.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2048: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_UCONTEXT_H=1
else
  echo "$ac_t""no" 1>&6
fi

	if test "$HAVE_SYS_UCONTEXT_H" = 1; then
		cat >> confdefs.h <<\EOF
#define HAVE_SYS_UCONTEXT 1
EOF

	fi
fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "asm/sigcontext.h" | tr './\055' '___'`
echo $ac_n "checking for asm/sigcontext.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2081 "configure"
#include "confdefs.h"
#include <asm/sigcontext.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2086: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_ASM_SIGCONTEXT_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_ASM_SIGCONTEXT_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_ASM_SIGCONTEXT 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/param.h" | tr './\055' '___'`
echo $ac_n "checking for sys/param.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2118 "configure"
#include "confdefs.h"
#include <sys/param.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2123: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_PARAM_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_PARAM_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_PARAM 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/time.h" | tr './\055' '___'`
echo $ac_n "checking for sys/time.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2155 "configure"
#include "confdefs.h"
#include <sys/time.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2160: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_TIME_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_TIME_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_TIME 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/times.h" | tr './\055' '___'`
echo $ac_n "checking for sys/times.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2192 "configure"
#include "confdefs.h"
#include <sys/times.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2197: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_TIMES_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_TIMES_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_TIMES_H 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/types.h" | tr './\055' '___'`
echo $ac_n "checking for sys/types.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2229 "configure"
#include "confdefs.h"
#include <sys/types.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2234: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_TYPES_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_TYPES_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_TYPES_H 1
EOF

fi
#-----------------------------------------------------------------------------#
ac_safe=`echo "sys/stat.h" | tr './\055' '___'`
echo $ac_n "checking for sys/stat.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 2266 "configure"
#include "confdefs.h"
#include <sys/stat.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:2271: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_SYS_STAT_H=1
else
  echo "$ac_t""no" 1>&6
fi

if test "$HAVE_SYS_STAT_H" = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_SYS_STAT_H 1
EOF

fi
#-----------------------------------------------------------------------------#
#
# check the basics of sigaction
#
if test "$ac_cv_func_sigaction" = yes; then
	echo $ac_n "checking for \`sigaction' field name""... $ac_c" 1>&6
	if eval "test \"`echo '$''{'mercury_cv_sigaction_field'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  # If we cannot run a trivial program, we must be cross compiling.
echo $ac_n "checking whether cross-compiling""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_c_cross'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  ac_cv_c_cross=yes
else
cat > conftest.$ac_ext <<EOF
#line 2314 "configure"
#include "confdefs.h"
main(){return(0);}
EOF
{ (eval echo configure:2318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  ac_cv_c_cross=no
else
  ac_cv_c_cross=yes
fi
fi
rm -fr conftest*
fi

echo "$ac_t""$ac_cv_c_cross" 1>&6
cross_compiling=$ac_cv_c_cross

if test "$cross_compiling" = yes; then
  mercury_cv_sigaction_field=sa_handler
else
cat > conftest.$ac_ext <<EOF
#line 2335 "configure"
#include "confdefs.h"


	#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);
		}
	}
EOF
{ (eval echo configure:2371: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_sigaction_field=sa_sigaction
else
  mercury_cv_sigaction_field=sa_handler
fi
fi
rm -fr conftest*
fi

	echo "$ac_t""$mercury_cv_sigaction_field" 1>&6
	cat >> confdefs.h <<EOF
#define SIGACTION_FIELD $mercury_cv_sigaction_field
EOF

	if test $mercury_cv_sigaction_field = sa_sigaction; then
		cat >> confdefs.h <<\EOF
#define HAVE_SIGINFO 1
EOF

	fi
fi
#
# check the basics of sigcontext_struct
#
echo $ac_n "checking for working \`sigcontext_struct' in second arg""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_sigcontext_struct_2arg'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  mercury_cv_sigcontext_struct_2arg=no
if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2405 "configure"
#include "confdefs.h"

/* 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);
	}
}
EOF
{ (eval echo configure:2447: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_sigcontext_struct_2arg=yes
else
  true
fi
fi
rm -fr conftest*
fi

echo "$ac_t""$mercury_cv_sigcontext_struct_2arg" 1>&6

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).
	#
	echo $ac_n "checking for working \`sigcontext_struct' in third arg""... $ac_c" 1>&6
	if eval "test \"`echo '$''{'mercury_cv_sigcontext_struct_3arg'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  mercury_cv_sigcontext_struct_3arg=no

	if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2474 "configure"
#include "confdefs.h"

	/* 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);
		}
	}
EOF
{ (eval echo configure:2517: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_sigcontext_struct_3arg=yes
else
  true
fi
fi
rm -fr conftest*
fi

	echo "$ac_t""$mercury_cv_sigcontext_struct_3arg" 1>&6
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
	cat >> confdefs.h <<\EOF
#define HAVE_SIGCONTEXT_STRUCT_2ARG 1
EOF

fi

if test $mercury_cv_sigcontext_struct_3arg = yes; then
	mercury_cv_sigcontext_struct=yes
	cat >> confdefs.h <<\EOF
#define HAVE_SIGCONTEXT_STRUCT_3ARG 1
EOF

fi

if test $mercury_cv_sigcontext_struct = yes; then
	cat >> confdefs.h <<\EOF
#define HAVE_SIGCONTEXT_STRUCT 1
EOF

	cat >> confdefs.h <<\EOF
#define HAVE_SIGINFO 1
EOF


	#
	# check for sigcontext_struct.eip
	#
	echo $ac_n "checking for \`sigcontext_struct' pc access at signals""... $ac_c" 1>&6
	if eval "test \"`echo '$''{'mercury_cv_pc_access'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  mercury_cv_pc_access=no
	if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2572 "configure"
#include "confdefs.h"

	/* 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);
		}
	}
EOF
{ (eval echo configure:2625: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_pc_access=eip
else
  true
fi
fi
rm -fr conftest*
fi

	echo "$ac_t""$mercury_cv_pc_access" 1>&6
	if test $mercury_cv_pc_access != no; then
		cat >> confdefs.h <<EOF
#define PC_ACCESS $mercury_cv_pc_access
EOF

	fi
else
	echo $ac_n "checking for \`siginfo_t'""... $ac_c" 1>&6
	if eval "test \"`echo '$''{'mercury_cv_siginfo_t'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  mercury_cv_siginfo_t=no
	if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2652 "configure"
#include "confdefs.h"

	#include <stdio.h>
	#include <signal.h>
	#ifdef HAVE_SYS_SIGINFO
	#include <sys/siginfo.h>
	#endif
	#ifdef HAVE_SYS_SIGNAL
	#include <sys/signal.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;
		save_cause = info->si_code;
	}
EOF
{ (eval echo configure:2692: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_siginfo_t=yes
else
  true
fi
fi
rm -fr conftest*
fi

	echo "$ac_t""$mercury_cv_siginfo_t" 1>&6
	if test $mercury_cv_siginfo_t = yes; then
		cat >> confdefs.h <<\EOF
#define HAVE_SIGINFO_T 1
EOF

		cat >> confdefs.h <<\EOF
#define HAVE_SIGINFO 1
EOF


		echo $ac_n "checking for \`siginfo' pc access at signals""... $ac_c" 1>&6
		if eval "test \"`echo '$''{'mercury_cv_pc_access'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  mercury_cv_pc_access=no
		if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2722 "configure"
#include "confdefs.h"

		#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);
		}
EOF
{ (eval echo configure:2760: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_pc_access=REG_PC;mercury_cv_pc_access_greg=yes
else
  true
fi
fi
rm -fr conftest*
		if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2772 "configure"
#include "confdefs.h"

		#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);
		}
EOF
{ (eval echo configure:2808: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_pc_access=CTX_EPC;mercury_cv_pc_access_greg=yes
else
  true
fi
fi
rm -fr conftest*
		if test "$cross_compiling" = yes; then
  true
else
cat > conftest.$ac_ext <<EOF
#line 2820 "configure"
#include "confdefs.h"

		#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;
		}
EOF
{ (eval echo configure:2855: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_pc_access=sc_pc;mercury_cv_pc_access_greg=no
else
  true
fi
fi
rm -fr conftest*
		
fi

		echo "$ac_t""$mercury_cv_pc_access" 1>&6
		if test $mercury_cv_pc_access != no; then
			cat >> confdefs.h <<EOF
#define PC_ACCESS $mercury_cv_pc_access
EOF

			if test $mercury_cv_pc_access_greg != no; then
				cat >> confdefs.h <<\EOF
#define PC_ACCESS_GREG 1
EOF

			fi
		fi
	fi
fi
#-----------------------------------------------------------------------------#
echo $ac_n "checking for an integer type with the same size as a pointer""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_word_type'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_word_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 2890 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:2917: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_word_type=`cat conftest.tags`
else
  mercury_cv_word_type=unknown
fi
fi
rm -fr conftest*

fi

if test "$mercury_cv_word_type" = unknown; then
	if test "$cross_compiling" = yes; then
  mercury_cv_word_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 2933 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:2954: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_word_type=`cat conftest.tags`
else
  mercury_cv_word_type=unknown
fi
fi
rm -fr conftest*
fi
echo "$ac_t""$mercury_cv_word_type" 1>&6
cat >> confdefs.h <<EOF
#define MR_WORD_TYPE $mercury_cv_word_type
EOF

MR_WORD_TYPE=$mercury_cv_word_type


if test "$mercury_cv_word_type" = int; then
	cat >> confdefs.h <<EOF
#define MR_INTEGER_LENGTH_MODIFIER ""
EOF

elif test "$mercury_cv_word_type" = long; then
	cat >> confdefs.h <<EOF
#define MR_INTEGER_LENGTH_MODIFIER "l"
EOF

elif test "$mercury_cv_word_type" = "long long"; then
	cat >> confdefs.h <<EOF
#define MR_INTEGER_LENGTH_MODIFIER "ll"
EOF

else
	{ echo "configure: error: "Cannot determine the length modifier for the MR_Integer type."" 1>&2; exit 1; }
fi


#-----------------------------------------------------------------------------#
echo $ac_n "checking for an integer type of at least 64 bits""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_int_least64_type'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_int_least64_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 3000 "configure"
#include "confdefs.h"

	#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 >= 64)
		{
			fprintf(fp, "int\n");
			exit(0);
		}

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

		fprintf(fp, "unknown\n");
		exit(1);
	}
EOF
{ (eval echo configure:3028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_int_least64_type=`cat conftest.tags`
else
  mercury_cv_int_least64_type=unknown
fi
fi
rm -fr conftest*

fi

if test "$mercury_cv_int_least64_type" = unknown; then
	if test "$cross_compiling" = yes; then
  mercury_cv_int_least64_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 3044 "configure"
#include "confdefs.h"

	#include <stdio.h>
	#include <limits.h>
	int main() {
		FILE *fp;

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

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

		fprintf(fp, "unknown\n");
		exit(1);
	}
EOF
{ (eval echo configure:3066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_int_least64_type=`cat conftest.tags`
else
  mercury_cv_int_least64_type=unknown
fi
fi
rm -fr conftest*
fi
echo "$ac_t""$mercury_cv_int_least64_type" 1>&6
if test "$mercury_cv_int_least64_type" != unknown; then
	cat >> confdefs.h <<EOF
#define MR_INT_LEAST64_TYPE $mercury_cv_int_least64_type
EOF

	MR_INT_LEAST64_TYPE=$mercury_cv_int_least64_type
	
fi
#-----------------------------------------------------------------------------#
echo $ac_n "checking for an integer type of at least 32 bits""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_int_least32_type'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_int_least32_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 3093 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_int_least32_type=`cat conftest.tags`
else
  mercury_cv_int_least32_type=unknown
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_int_least32_type" 1>&6
cat >> confdefs.h <<EOF
#define MR_INT_LEAST32_TYPE $mercury_cv_int_least32_type
EOF

MR_INT_LEAST32_TYPE=$mercury_cv_int_least32_type

#-----------------------------------------------------------------------------#
echo $ac_n "checking for an integer type of at least 16 bits""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_int_least16_type'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_int_least16_type=unknown
else
cat > conftest.$ac_ext <<EOF
#line 3148 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3176: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_int_least16_type=`cat conftest.tags`
else
  mercury_cv_int_least16_type=unknown
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_int_least16_type" 1>&6
cat >> confdefs.h <<EOF
#define MR_INT_LEAST16_TYPE $mercury_cv_int_least16_type
EOF

MR_INT_LEAST16_TYPE=$mercury_cv_int_least16_type

#-----------------------------------------------------------------------------#
echo $ac_n "checking the number of low tag bits available""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_low_tag_bits'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_low_tag_bits=0
else
cat > conftest.$ac_ext <<EOF
#line 3203 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3234: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_low_tag_bits=`cat conftest.tags`
else
  mercury_cv_low_tag_bits=0
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_low_tag_bits" 1>&6
if test "$mercury_cv_low_tag_bits" -lt 2; then
	if test "$BOOTSTRAP_MC" = ""; then
		{ echo "configure: error: "cannot bootstrap: low tag bits less than 2"" 1>&2; exit 1; }
		exit 1
	fi
fi
if test "$mercury_cv_low_tag_bits" -gt 2; then
	if test "$BOOTSTRAP_MC" = ""; then
		echo "configure: warning: "bootstrapping using only 2 low tag bits"" 1>&2
		mercury_cv_low_tag_bits=2
	fi
fi
cat >> confdefs.h <<EOF
#define LOW_TAG_BITS $mercury_cv_low_tag_bits
EOF

LOW_TAG_BITS=$mercury_cv_low_tag_bits

#-----------------------------------------------------------------------------#
echo $ac_n "checking the number of bytes per word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_bytes_per_word'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_bytes_per_word=0
else
cat > conftest.$ac_ext <<EOF
#line 3273 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3289: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_bytes_per_word=`cat conftest.wordbytes`
else
  mercury_cv_bytes_per_word=0
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_bytes_per_word" 1>&6
cat >> confdefs.h <<EOF
#define BYTES_PER_WORD $mercury_cv_bytes_per_word
EOF

BYTES_PER_WORD=$mercury_cv_bytes_per_word

#-----------------------------------------------------------------------------#
echo $ac_n "checking the number of words in a synchronization term""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_sync_term_size'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_sync_term_size=0
else
cat > conftest.$ac_ext <<EOF
#line 3316 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3339: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_sync_term_size=`cat conftest.syncsize`
else
  mercury_cv_sync_term_size=0
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_sync_term_size" 1>&6
cat >> confdefs.h <<EOF
#define SYNC_TERM_SIZE $mercury_cv_sync_term_size
EOF

SYNC_TERM_SIZE=$mercury_cv_sync_term_size

#-----------------------------------------------------------------------------#
echo $ac_n "checking the number of bits per word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_bits_per_word'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_bits_per_word=0
else
cat > conftest.$ac_ext <<EOF
#line 3366 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3383: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_bits_per_word=`cat conftest.wordbits`
else
  mercury_cv_bits_per_word=0
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_bits_per_word" 1>&6
cat >> confdefs.h <<EOF
#define BITS_PER_WORD $mercury_cv_bits_per_word
EOF

BITS_PER_WORD=$mercury_cv_bits_per_word

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether we can use unboxed floats""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_unboxed_floats'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_unboxed_floats=no
else
cat > conftest.$ac_ext <<EOF
#line 3410 "configure"
#include "confdefs.h"

	int main() {
		if (sizeof(double) == sizeof(void *))
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3420: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_unboxed_floats=yes
else
  mercury_cv_unboxed_floats=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_unboxed_floats" 1>&6
if test "$mercury_cv_unboxed_floats" = yes; then
	if test "$BOOTSTRAP_MC" = ""; then
		echo "configure: warning: Mercury compiler not yet installed -" \
				"cannot use unboxed floats" 1>&2
		echo "configure: warning: bootstrapping using boxed floats" 1>&2
		echo "configure: warning: *** after installation is complete you" \
				"may want to reinstall from scratch" 1>&2
		echo "configure: warning: *** so you can use unboxed floats" 1>&2
		mercury_cv_unboxed_floats=no
	fi
fi
if test "$mercury_cv_unboxed_floats" = yes; then
	HAVE_BOXED_FLOATS="--unboxed-float"
else
	cat >> confdefs.h <<\EOF
#define BOXED_FLOAT 1
EOF

	HAVE_BOXED_FLOATS="--no-unboxed-float"
fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether float is 64-bit""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_float_is_64_bit'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_float_is_64_bit=no
else
cat > conftest.$ac_ext <<EOF
#line 3462 "configure"
#include "confdefs.h"

	#include <limits.h>
	int main() {
		if (sizeof(float) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3473: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_float_is_64_bit=yes
else
  mercury_cv_float_is_64_bit=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_float_is_64_bit" 1>&6
if test "$mercury_cv_float_is_64_bit" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_FLOAT_IS_64_BIT 1
EOF

fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether double is 64-bit""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_double_is_64_bit'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_double_is_64_bit=no
else
cat > conftest.$ac_ext <<EOF
#line 3501 "configure"
#include "confdefs.h"

	#include <limits.h>
	int main() {
		if (sizeof(double) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3512: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_double_is_64_bit=yes
else
  mercury_cv_double_is_64_bit=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_double_is_64_bit" 1>&6
if test "$mercury_cv_double_is_64_bit" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_DOUBLE_IS_64_BIT 1
EOF

fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether long double is 64-bit""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_long_double_is_64_bit'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_long_double_is_64_bit=no
else
cat > conftest.$ac_ext <<EOF
#line 3540 "configure"
#include "confdefs.h"

	#include <limits.h>
	int main() {
		if (sizeof(long double) * CHAR_BIT == 64)
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3551: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_long_double_is_64_bit=yes
else
  mercury_cv_long_double_is_64_bit=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_long_double_is_64_bit" 1>&6
if test "$mercury_cv_long_double_is_64_bit" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_LONG_DOUBLE_IS_64_BIT 1
EOF

fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether architecture is big-endian""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_is_bigender'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_is_bigender=no
else
cat > conftest.$ac_ext <<EOF
#line 3579 "configure"
#include "confdefs.h"

	int main() {
		int		x = 1;
		unsigned char	*x_p;

		x_p = (unsigned char*) &x;

		if (*x_p == 0)
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3594: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_is_bigender=yes
else
  mercury_cv_is_bigender=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_is_bigender" 1>&6
if test "$mercury_cv_is_bigender" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_BIG_ENDIAN 1
EOF

fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether architecture is little-endian""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_is_littleender'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_is_littleender=no
else
cat > conftest.$ac_ext <<EOF
#line 3622 "configure"
#include "confdefs.h"

	int main() {
		int		x = 1;
		unsigned char	*x_p;

		x_p = (unsigned char*) &x;

		if (*x_p == 1)
			exit(0);
		else
			exit(1);
	}
EOF
{ (eval echo configure:3637: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_is_littleender=yes
else
  mercury_cv_is_littleender=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_is_littleender" 1>&6
if test "$mercury_cv_is_littleender" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_LITTLE_ENDIAN 1
EOF

fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking return values of system""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_normal_system_retval'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  cat > conftest.$ac_ext <<EOF
#line 3663 "configure"
#include "confdefs.h"
#include <sys/wait.h>
int main() { return 0; }
int t() {

	#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
	
; return 0; }
EOF
if { (eval echo configure:3682: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
  rm -rf conftest*
  mercury_cv_normal_system_retval=yes
else
  rm -rf conftest*
  mercury_cv_normal_system_retval=no
fi
rm -f conftest*

else
cat > conftest.$ac_ext <<EOF
#line 3693 "configure"
#include "confdefs.h"

	#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
	}
EOF
{ (eval echo configure:3727: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_normal_system_retval=yes
else
  mercury_cv_normal_system_retval=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_normal_system_retval" 1>&6
if test "$mercury_cv_normal_system_retval" = no; then
		# Warn since VC++6 compiler fails this test
	echo "configure: warning: Unable to interpret return values from system" 1>&2
fi
#-----------------------------------------------------------------------------#
echo $ac_n "checking to see if we can handle contexts blocking on IO""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_can_do_pending_io'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_can_do_pending_io=no
else
cat > conftest.$ac_ext <<EOF
#line 3752 "configure"
#include "confdefs.h"

	#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);
	}
EOF
{ (eval echo configure:3769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_can_do_pending_io=yes
else
  mercury_cv_can_do_pending_io=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_can_do_pending_io" 1>&6
if test "$mercury_cv_can_do_pending_io" = yes; then
	cat >> confdefs.h <<\EOF
#define MR_CAN_DO_PENDING_IO 1
EOF

fi

#-----------------------------------------------------------------------------#
#
# On sparc, x86, and probably on other architectures,
# if we're using non-local gotos, then for egcs 1.1, we need
# `-fno-gcse -fno-function-cse', and for gcc 2.8 we need `-fno-function-cse'.
# Otherwise gcc generates code which initializes registers in the function
# prologue and expects them to be valid later on, which doesn't work with
# non-local gotos, since we jump directly into the middle of a function.
# (Actually I don't know if `-fno-functions-cse' is really needed.
# Maybe you can get away without it.  But better to err on the safe side...)
#
# For alpha and for mips, and probably on other architectures, when using
# non-local gotos we need -fomit-frame-pointer, otherwise when compiling
# with --no-c-optimize we run into a problem similar to the one above:
# Gcc generates code which initializes the frame pointer in the
# function prologue, and then expects it to be valid later on, which
# doesn't work with non-local gotos, since we jump directly into the
# middle of a function.
#
# 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.
#
CFLAGS_FOR_REGS=
CFLAGS_FOR_GOTOS=
LIBRARY_PATH_FOR_GOTOS=
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
    case "$host" in
	mips-sgi-irix5.*)
		CFLAGS_FOR_GOTOS="$CFLAGS_FOR_GOTOS -non_shared -mno-abicalls"
		LIBRARY_PATH_FOR_GOTOS="$NONSHARED_LIB_DIR:/usr/lib/nonshared"
		;;
    esac
    case "$host" in
	mips-*)
		CFLAGS_FOR_GOTOS="$CFLAGS_FOR_GOTOS -fomit-frame-pointer"
		;;
	i?86-*)
		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-*)
		echo "asm labels work on the Alpha" 1>&6
		echo "but plain gcc labels do not" 1>&6
		mercury_cv_asm_labels=yes
		mercury_cv_gcc_labels=no
		CFLAGS_FOR_GOTOS="$CFLAGS_FOR_GOTOS -fomit-frame-pointer"
		;;
	# Similarly for rs6000
	rs6000-*)
		echo "gcc labels do not work on the RS/6000" 1>&6
		mercury_cv_asm_labels=no
		mercury_cv_gcc_labels=no
		;;
	sparc*)
		case "`$CC --version < /dev/null`" in 2.8*)
			echo "configure: warning: *** Mercury might not work with " \
				"gcc 2.8 on sparc!" 1>&2
			echo "configure: warning: We advise using gcc 2.7.x or egcs." 1>&2
			;;
		esac
		;;
    esac
    ;;
esac


#-----------------------------------------------------------------------------#
echo $ac_n "checking whether we can use gcc labels""... $ac_c" 1>&6

# Set env vars for compiling with gcc non-local gotos
save_CC="$CC"
save_LIBRARY_PATH="$LIBRARY_PATH"
CC="$CC $CFLAGS_FOR_GOTOS"
if test "$LIBRARY_PATH_FOR_GOTOS" != ""; then
	LIBRARY_PATH="$LIBRARY_PATH_FOR_GOTOS:$LIBRARY_PATH"
	export LIBRARY_PATH
fi

if eval "test \"`echo '$''{'mercury_cv_gcc_labels'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_gcc_labels=no
else
cat > conftest.$ac_ext <<EOF
#line 3889 "configure"
#include "confdefs.h"

	void *entry_foo_1;
	void *entry_bar_1;
	void *succip;
	int global;
	void *dummy_identity_function(void *);
	foo() {
		entry_foo_1 = && foo_1;
		goto *dummy_identity_function(&&return_label);
	return_label:
		return;
	foo_1:
		if (global != 42) exit(1);
		goto *entry_bar_1;
	}
	bar() {
		entry_bar_1 = && bar_1;
		goto *dummy_identity_function(&&return_label);
	return_label:
		return;
	bar_1:
		if (global != 42) exit(1);
		goto *succip;
	}
	main() {
		global = 42;
		foo();
		bar();
		succip = &&last;
		goto *dummy_identity_function(&&return_label);
	return_label:
		goto *entry_foo_1;
		exit(1);
	last:
		if (global != 42) exit(1);
		exit(0);
	}
	void *dummy_identity_function(void *p) {
		return p;
	}
	
EOF
{ (eval echo configure:3933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_gcc_labels=yes
else
  mercury_cv_gcc_labels=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_gcc_labels" 1>&6
if test "$mercury_cv_gcc_labels" = yes; then
	cat >> confdefs.h <<\EOF
#define HAVE_GCC_LABELS 1
EOF

fi

if test $mercury_cv_gcc_labels = yes; then
	echo $ac_n "checking whether we can use asm labels""... $ac_c" 1>&6

	if eval "test \"`echo '$''{'mercury_cv_asm_labels'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_asm_labels=no
else
cat > conftest.$ac_ext <<EOF
#line 3962 "configure"
#include "confdefs.h"

	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);
	}
EOF
{ (eval echo configure:3981: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_asm_labels=yes
else
  mercury_cv_asm_labels=no
fi
fi
rm -fr conftest*
	
fi

	echo "$ac_t""$mercury_cv_asm_labels" 1>&6
else
	mercury_cv_asm_labels=${mercury_cv_asm_labels-no}
fi
HAVE_ASM_LABELS=$mercury_cv_asm_labels

if test $HAVE_ASM_LABELS = 1; then
	cat >> confdefs.h <<\EOF
#define HAVE_ASM_LABELS 1
EOF

fi

# Restore env vars modified above
CC="$save_CC"
LIBRARY_PATH="$save_LIBRARY_PATH"

#-----------------------------------------------------------------------------#
# 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
	echo $ac_n "checking whether we can use gcc labels and global registers""... $ac_c" 1>&6

	# Set env vars for compiling with gcc non-local gotos and registers
	save_CC="$CC"
	save_LIBRARY_PATH="$LIBRARY_PATH"
	CC="$CC $CFLAGS_FOR_GOTOS $CFLAGS_FOR_REGS"
	if test "$LIBRARY_PATH_FOR_GOTOS" != ""; then
		LIBRARY_PATH="$LIBRARY_PATH_FOR_GOTOS:$LIBRARY_PATH"
		export LIBRARY_PATH
	fi

	if eval "test \"`echo '$''{'mercury_cv_gcc_model_fast'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_gcc_model_fast=no
else
cat > conftest.$ac_ext <<EOF
#line 4037 "configure"
#include "confdefs.h"

	#define USE_GCC_NONLOCAL_GOTOS
	#define USE_GCC_GLOBAL_REGISTERS
	#include "mercury_engine.h"
	 
	MercuryEngine MR_engine_base;
	 
	main() {
		MR_mr0 = 20;
		MR_mr7 = 22;
		if (MR_mr0 + MR_mr7 != 42)
			exit(1);
		exit(0);
	}
EOF
{ (eval echo configure:4054: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_gcc_model_fast=yes
else
  mercury_cv_gcc_model_fast=no
fi
fi
rm -fr conftest*
	
fi

	echo "$ac_t""$mercury_cv_gcc_model_fast" 1>&6

	# Restore env vars modified above
	CC="$save_CC"
	LIBRARY_PATH="$save_LIBRARY_PATH"
else
	mercury_cv_gcc_model_fast=no
fi
#-----------------------------------------------------------------------------#

echo $ac_n "checking whether we can use global registers without gcc labels""... $ac_c" 1>&6

# Set env vars for compiling with gcc registers
save_CC="$CC"
CC="$CC $CFLAGS_FOR_REGS"

if eval "test \"`echo '$''{'mercury_cv_gcc_model_reg'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_gcc_model_reg=no
else
cat > conftest.$ac_ext <<EOF
#line 4088 "configure"
#include "confdefs.h"

#define USE_GCC_GLOBAL_REGISTERS
#include "mercury_engine.h"
 
MercuryEngine MR_engine_base;
 
main() {
	MR_mr0 = 20;
	MR_mr7 = 22;
	if (MR_mr0 + MR_mr7 != 42)
		exit(1);
	exit(0);
}
EOF
{ (eval echo configure:4104: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_gcc_model_reg=yes
else
  mercury_cv_gcc_model_reg=no
fi
fi
rm -fr conftest*

fi

echo "$ac_t""$mercury_cv_gcc_model_reg" 1>&6

# Restore env vars modified above
CC="$save_CC"

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

echo $ac_n "checking whether we can support profiling on this system""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_profiling'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 4127 "configure"
#include "confdefs.h"

/* 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

EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:4157: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  mercury_cv_profiling=yes
else
  echo "$ac_err" >&5
  rm -rf conftest*
  mercury_cv_profiling=no
fi
rm -f conftest*
fi

echo "$ac_t""$mercury_cv_profiling" 1>&6

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

# 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
	cat >> confdefs.h <<\EOF
#define MR_DIGITAL_UNIX_PTHREADS 1
EOF

fi

# Figure out what options we need to pass to the C compiler
# for multithreading.   We may need to pass different
# options to tell (a) the Mercury runtime & library
# (b) the boehm collector and (c) the C library
# that they need to be thread-safe.
case "$host" in
	*solaris*)
		CFLAGS_FOR_THREADS="-DMR_THREAD_SAFE -DSOLARIS_THREADS \
			-D_SOLARIS_PTHREADS -D_REENTRANT"
		;;

	*linux*)
		CFLAGS_FOR_THREADS="-DMR_THREAD_SAFE -DLINUX_THREADS \
			-D_THREAD_SAFE -D_REENTRANT"
		# Note that for old versions of Linux / glibc,
		# you may also need to make sure that you don't
		# pass -ansi to gcc.
		;;

	*cygwin*)
		case "$CC" in
			*cl* | *CL*)	# cl is the Microsoft C compiler
				CFLAGS_FOR_THREADS="-DMR_THREAD_SAFE -DWIN32_THREADS /MD" ;;
			*)
				CFLAGS_FOR_THREADS="" ;;
		esac
		;;

###	# The threads stuff on Digital Unix (OSF) is not yet enabled because
###	# the Boehm garbage collector doesn't support threads on that platform
###	# XXX probably we should enable it but report an error if you try to
###	#     use an *.par.gc* grade
###	*-osf*)
###		CFLAGS_FOR_THREADS="-DMR_THREAD_SAFE"
###		;;

###	# The threads stuff on IRIX is not yet enabled because
###	# we don't have an IRIX box to test it on.
###	# (XXX perhaps we should enable it anyway, so it is easier to test?)
###	*irix*)
###		CFLAGS_FOR_THREADS="-DMR_THREAD_SAFE -DIRIX_THREADS"
###		;;

	*)	
		# Multithreading not (yet) supported on other architectures.
		# For multithreading, we need (1) Posix threads and
		# (2) a port of the Boehm gc for that architecture
		# that works with threads.
		CFLAGS_FOR_THREADS=""
		;;
esac


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

#
# 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
		echo "configure: warning: Mercury compiler not yet installed -" \
				"cannot use grade \`$DESIRED_GRADE'" 1>&2
		echo "configure: warning: using \`GRADE=$GRADE' to compile the compiler" 1>&2
		echo "configure: warning: *** after installation is complete you" \
				"should reinstall from scratch" 1>&2
		echo "configure: warning: *** so you can use the more efficient" \
				"grade \`$DESIRED_GRADE'" 1>&2
	else
		echo "using \`GRADE=$GRADE' to compile the compiler" 1>&6
		echo "compiler and library will be rebuilt with new grade" 1>&6
		echo "installation may take a long time" 1>&6
		rm -f library/*.c compiler/*.c browser/*.c profiler/*.c
	fi
else
	# If we are using the MS compiler we want to install all the
	# none.* and hlc.* grades.  The easiest way to do this is to
	# pretend we want to use the none.gc grade and then override it
	# later.
	if test $ac_microsoft = no; then
		echo "using \`GRADE=$GRADE' to compile the compiler" 1>&6
	fi
fi

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.*)
		case $ac_cv_prog_gcc in yes)
			DEFAULT_GRADE=reg.gc
			;;
		esac
		;;
	esac
fi

#
# Figure out which grades to use if --enable-inefficient-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

# Check whether --enable-inefficient-grades or --disable-inefficient-grades was given.
if test "${enable_inefficient_grades+set}" = set; then
  enableval="$enable_inefficient_grades"
  enable_inefficient_grades="$enableval"
else
  enable_inefficient_grades=no
fi


# Check whether --enable-most-grades or --disable-most-grades was given.
if test "${enable_most_grades+set}" = set; then
  enableval="$enable_most_grades"
  enable_most_grades="$enableval"
else
  enable_most_grades=yes
fi


# Check whether --enable-nogc-grades or --disable-nogc-grades was given.
if test "${enable_nogc_grades+set}" = set; then
  enableval="$enable_nogc_grades"
  enable_nogc_grades="$enableval"
else
  enable_nogc_grades=yes
fi


# Check whether --enable-prof-grades or --disable-prof-grades was given.
if test "${enable_prof_grades+set}" = set; then
  enableval="$enable_prof_grades"
  enable_prof_grades="$enableval"
else
  enable_prof_grades=yes
fi


# Check whether --enable-trail-grades or --disable-trail-grades was given.
if test "${enable_trail_grades+set}" = set; then
  enableval="$enable_trail_grades"
  enable_trail_grades="$enableval"
else
  enable_trail_grades=yes
fi


# Check whether --enable-par-grades or --disable-par-grades was given.
if test "${enable_par_grades+set}" = set; then
  enableval="$enable_par_grades"
  enable_par_grades="$enableval"
else
  enable_par_grades=yes
fi


# Check whether --enable-hlc-prof-grades or --disable-hlc-prof-grades was given.
if test "${enable_hlc_prof_grades+set}" = set; then
  enableval="$enable_hlc_prof_grades"
  enable_hlc_prof_grades=yes
else
  enable_hlc_prof_grades=no
fi


# Check whether --enable-libgrades or --disable-libgrades was given.
if test "${enable_libgrades+set}" = set; then
  enableval="$enable_libgrades"
  enable_libgrades_given=yes;enable_libgrades="$enableval"
else
  enable_libgrades_given=no
fi


if test "$enable_most_grades" = no; then
	enable_inefficient_grades=no
	enable_nogc_grades=no
	enable_prof_grades=no
	enable_trail_grades=no
	enable_hlc_prof_grades=no
	enable_par_grades=no
fi

if test "$enable_inefficient_grades" = yes; then
	BASE_LIBGRADES="$ALL_LIBGRADES"
else
	BASE_LIBGRADES="$BEST_GRADE"
fi

# find all `.gc' (--conservative-gc) grades
GC_LIBGRADES=""
for grade in $BASE_LIBGRADES; do
	GC_LIBGRADES="$GC_LIBGRADES $grade.gc"
done

if test "$enable_nogc_grades" = yes; then
	LIBGRADES="$BASE_LIBGRADES $GC_LIBGRADES"
else
	LIBGRADES="$GC_LIBGRADES"
fi

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

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

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

# add `hlc' (--high-level-code, i.e. MLDS back-end) grades
LIBGRADES="$LIBGRADES hlc.gc"

if test $enable_hlc_prof_grades = "yes" -o $ac_microsoft = "yes"; then
	# add `.prof' (--profiling) grades, if time profiling is supported,
	# and a `.memprof' (--memory-profiling) grade.
	if test $mercury_cv_profiling = yes -a "$enable_prof_grades" = yes; then
		LIBGRADES="$LIBGRADES hlc.gc.prof"
	fi
	LIBGRADES="$LIBGRADES hlc.gc.memprof"
fi

if test "$enable_par_grades" = yes; then
	# Add the .par grade
	LIBGRADES="$LIBGRADES hlc.par.gc"
fi

if test "$enable_libgrades_given" = yes; then
	if test "$enable_libgrades" = no; then
		echo "--enable-libgrades requires a comma-separated list of grades as argument" 1>&6
		echo "aborting configure" 1>&6
		exit 1
	elif test "$enable_libgrades" = yes; then
		echo "--enable-libgrades requires a comma-separated list of grades as argument" 1>&6
		echo "aborting configure" 1>&6
		exit 1
	else
		# Generate only the grades specified by the user.
		raw_grades=`echo $enable_libgrades | sed 's/,/ /g'`
		canonical_grades=""
		grade_error=false
		for raw_grade in $raw_grades
		do
			if scripts/canonical_grade --grade $raw_grade > .confgrade
			then
				canonical_grades="$canonical_grades `cat .confgrade`"
			else
				echo "--enable-libgrades: $raw_grade is not a grade" 1>&6
				grade_error=true
			fi
		done

		rm -f .confgrade > /dev/null 2>&1

		if $grade_error
		then
			comma=","
			echo "invalid grade(s) specified for --enable-libgrades$comma aborting configure" 1>&6
			exit 1
		fi

		LIBGRADES=$canonical_grades
	fi
fi

# If we are using the Microsoft compiler then use hlc.gc as the default
# grade.
if test $ac_microsoft = yes; then
	GRADE=hlc.gc
	DEFAULT_GRADE=hlc.gc
	echo "\`GRADE=$GRADE' to compile the compiler" 1>&6
fi


# Output default grade
echo "using \`DEFAULT_GRADE=$DEFAULT_GRADE' as the default grade for applications" 1>&6


# remove GRADE from LIBGRADES
LIBGRADES=` echo " $LIBGRADES " | sed "s/ $GRADE / /" `
echo "using \`LIBGRADES=$LIBGRADES' as the set of library grades to install" 1>&6



#-----------------------------------------------------------------------------#
#
# Add an option that disables declarative debugging support in the internal
# debugger.  It is enabled by default.
#
# Check whether --enable-decl-debug or --disable-decl-debug was given.
if test "${enable_decl_debug+set}" = set; then
  enableval="$enable_decl_debug"
  mercury_cv_enable_decl_debug="$enableval"
else
  mercury_cv_enable_decl_debug=yes
fi

if test "$mercury_cv_enable_decl_debug" = "no"; then
	cat >> confdefs.h <<\EOF
#define MR_DISABLE_DECLARATIVE_DEBUGGER 1
EOF

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=7
		# but succip, sp, and hp are real regs, so subtract 3
		NUM_REAL_R_REGS=4
		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




#-----------------------------------------------------------------------------#
echo $ac_n "checking whether the assembler does not handle .type""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_cannot_grok_asm_type_directive'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  
	case "$host" in
		*-sunos4.*)
			mercury_cv_cannot_grok_asm_type_directive=yes
			;;
		*)
			mercury_cv_cannot_grok_asm_type_directive=no
			;;
	esac

fi

echo "$ac_t""$mercury_cv_cannot_grok_asm_type_directive" 1>&6
if test $mercury_cv_cannot_grok_asm_type_directive = "yes"; then
	cat >> confdefs.h <<\EOF
#define MR_CANNOT_GROK_ASM_TYPE_DIRECTIVE 1
EOF

fi
#-----------------------------------------------------------------------------#
# Extract the first word of "as", so it can be a program name with args.
set dummy as; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_path_AS'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  case "$AS" in
  /*)
  ac_cv_path_AS="$AS" # Let the user override the test with a path.
  ;;
  *)
  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
      ac_cv_path_AS="$ac_dir/$ac_word"
      break
    fi
  done
  IFS="$ac_save_ifs"
  ;;
esac
fi
AS="$ac_cv_path_AS"
if test -n "$AS"; then
  echo "$ac_t""$AS" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

echo $ac_n "checking whether the assembler does full preprocessing""... $ac_c" 1>&6

if eval "test \"`echo '$''{'mercury_cv_asm_does_full_preprocessing'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  
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 >&5 2>&1 &&
		$AS conftest.s </dev/null >&5 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"
	fi
	rm -f conftest*
else
	mercury_cv_asm_does_full_preprocessing="no"
fi

fi

echo "$ac_t""$mercury_cv_asm_does_full_preprocessing" 1>&6	
if test $mercury_cv_asm_does_full_preprocessing = "no"; then
	AS="gcc -c -x assembler-with-cpp"
fi

#-----------------------------------------------------------------------------#
echo $ac_n "checking whether structure assignment conflicts with global registers""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_cannot_use_structure_assignment'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test "$cross_compiling" = yes; then
  mercury_cv_cannot_use_structure_assignment=yes
else
cat > conftest.$ac_ext <<EOF
#line 4735 "configure"
#include "confdefs.h"

 

/* 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);
 
}
EOF
{ (eval echo configure:4756: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }
if test -s conftest && (./conftest; exit) 2>/dev/null; then
  mercury_cv_cannot_use_structure_assignment=no
else
  mercury_cv_cannot_use_structure_assignment=yes
fi
fi
rm -fr conftest*
fi

echo "$ac_t""$mercury_cv_cannot_use_structure_assignment" 1>&6
if test $mercury_cv_cannot_use_structure_assignment = "yes"; then
	cat >> confdefs.h <<\EOF
#define MR_CANNOT_USE_STRUCTURE_ASSIGNMENT 1
EOF

fi
#-----------------------------------------------------------------------------#
echo $ac_n "checking whether Mercury supports shared libraries on this system""... $ac_c" 1>&6
# 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"
LINK_SHARED_OBJ_SH="$CC -shared"
SHARED_LIBS='`gcc -print-libgcc-file-name` $(MATH_LIB) -lc'
SHARED_LIBS_SH='`gcc -print-libgcc-file-name` $MATH_LIB -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=$LIB_SUFFIX
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)
		case $ac_cv_prog_gcc in
		yes)
			echo "$ac_t""yes" 1>&6
			EXT_FOR_SHARED_LIB=so
			echo $ac_n "checking if linker supports --no-undefined""... $ac_c" 1>&6
			rm -f conftest*
			echo "int main(void) { return 0; }" > conftest.c
			$CC -Wl,--no-undefined -o conftest conftest.c
			if test -f conftest; then
				echo "$ac_t""yes" 1>&6
				ERROR_UNDEFINED="-Wl,--no-undefined"

				echo $ac_n "checking for ld-linux.so""... $ac_c" 1>&6
				rm -f conftest*
				echo "int main(void) { return 0; }" > conftest.c
				$CC -o conftest conftest.c
				ld_linux=`ldd ./conftest | \
					awk '/ld-linux/{print $1;}'`
				case $ld_linux in /lib/ld-linux.so*)
					echo "$ac_t""$ld_linux" 1>&6
					SHARED_LIBS="$SHARED_LIBS $ld_linux"
					SHARED_LIBS_SH="$SHARED_LIBS_SH $ld_linux"
					;;
				*)
					echo "$ac_t""no" 1>&6
					;;
				esac
			else
				echo "$ac_t""no" 1>&6
			fi
			rm -f conftest*
			;;
		*)
			echo "$ac_t""no" 1>&6
			;;
		esac
		;;
	m68*-linux|m68*-linux-gnu)
		echo "$ac_t""yes" 1>&6
		EXT_FOR_SHARED_LIB=so
		;;
	i?86-*-freebsd*)
		# From Cornelis van der Laan <nils@ims.uni-stuttgart.de>
		echo "$ac_t""yes" 1>&6
		LINK_SHARED_OBJ="ld -Bshareable"
		LINK_SHARED_OBJ_SH="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.*)
		echo "$ac_t""yes" 1>&6
		SHARED_LIBS="$(MATH_LIB) -lc"	# don't link in libgcc.a
		SHARED_LIBS_SH="$MATH_LIB -lc"	# don't link in libgcc.a
		LINK_SHARED_OBJ="$CC -shared -mimpure-text"
		LINK_SHARED_OBJ_SH="$CC -shared -mimpure-text"
		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*)
		echo "$ac_t""yes" 1>&6
		LINK_SHARED_OBJ="gcc -shared \
		-Wl,-O3,-update_registry,\$(SO_LOCATIONS_DIR)so_locations"
		LINK_SHARED_OBJ_SH="gcc -shared \
		-Wl,-O3,-update_registry,\${SO_LOCATIONS_DIR}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_DIR)so_locations \
			-quickstart_info -rdata_shared"
		LINK_SHARED_OBJ_SH="ld -shared \
			-update_registry \${SO_LOCATIONS_DIR}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
			echo "$ac_t""yes" 1>&6
			EXT_FOR_SHARED_LIB=so
		else
			EXT_FOR_SHARED_LIB=a
			echo "$ac_t""no" 1>&6
			echo "$ac_t""Read README.IRIX-5" 1>&6
		fi
		;;
	*-cygwin*)
		# disabled for now, since it hasn't been tested
		# xxx_MSG_RESULT(yes)
		# EXT_FOR_SHARED_LIB=dll
		# USE_DLLS=yes
		echo "$ac_t""disabled for now because it is untested" 1>&6

		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=
		echo "$ac_t""no" 1>&6
		;;
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

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

case "$host" in
	*-cygwin*)
		EXT_FOR_EXE=".exe"
		;;
	*)
		EXT_FOR_EXE=
		;;
esac

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


















if test $USE_DLLS = "yes"; then
	cat >> confdefs.h <<\EOF
#define USE_DLLS 1
EOF

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"

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

# 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
CANONICAL_GRADE=$top/scripts/canonical_grade.sh-subr





#-----------------------------------------------------------------------------#
#
# Check for the POSIX struct tms and times() function.
# This is used for the time__times procedure in library/times.m.
#
echo $ac_n "checking for struct tms and times function""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_have_posix_times'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5049 "configure"
#include "confdefs.h"

	#include <sys/types.h>
	#include <sys/times.h>

int main() { return 0; }
int t() {

	struct tms t;
	long Ut, St, CUt, CSt;
	long Ret;

	Ret = (long) times(&t);

	Ut = (long) t.tms_utime;
	St = (long) t.tms_stime;
	CUt = (long) t.tms_cutime;
	CSt = (long) t.tms_cstime;

; return 0; }
EOF
if { (eval echo configure:5071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  mercury_cv_have_posix_times=yes
else
  rm -rf conftest*
  mercury_cv_have_posix_times=no
fi
rm -f conftest*

fi


#
# figure out whether the test succeeded
#
if test "$mercury_cv_have_posix_times" = yes; then
	echo "$ac_t""yes" 1>&6
	cat >> confdefs.h <<\EOF
#define MR_HAVE_POSIX_TIMES 1
EOF

else
	echo "$ac_t""no" 1>&6
fi

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

#
# check whether we need -lsocket
#
echo $ac_n "checking for -lsocket""... $ac_c" 1>&6
ac_lib_var=`echo socket_socket | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lsocket  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5112 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char socket();

int main() { return 0; }
int t() {
socket()
; return 0; }
EOF
if { (eval echo configure:5122: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  SOCKET_LIBRARY=-lsocket
else
  echo "$ac_t""no" 1>&6
SOCKET_LIBRARY=""
fi


#
# check whether we need -lnsl
#
echo $ac_n "checking for -lnsl""... $ac_c" 1>&6
ac_lib_var=`echo nsl_inet_addr | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lnsl  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5153 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char inet_addr();

int main() { return 0; }
int t() {
inet_addr()
; return 0; }
EOF
if { (eval echo configure:5163: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  NSL_LIBRARY=-lnsl
else
  echo "$ac_t""no" 1>&6
NSL_LIBRARY=""
fi


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

#
# use TRY_LINK to see whether we can use sockets
#
echo $ac_n "checking whether we can use sockets (for Morphine)""... $ac_c" 1>&6
if eval "test \"`echo '$''{'mercury_cv_sockets_work'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5197 "configure"
#include "confdefs.h"

	 
	/*
	** 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);
	}

int main() { return 0; }
int t() {

	/* this is the body of the test function */
	{
		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_addr(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");
		}
	}
	 

; return 0; }
EOF
if { (eval echo configure:5354: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  mercury_cv_sockets_work=yes
else
  rm -rf conftest*
  mercury_cv_sockets_work=no
fi
rm -f conftest*

fi


#
# figure out whether the test succeeded
#
if test "$mercury_cv_sockets_work" = yes; then
	echo "$ac_t""yes" 1>&6
else
	echo "$ac_t""no" 1>&6
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).
#
# Check whether --enable-extern-debug or --disable-extern-debug was given.
if test "${enable_extern_debug+set}" = set; then
  enableval="$enable_extern_debug"
  mercury_cv_enable_extern_debug="$enableval"
else
  mercury_cv_enable_extern_debug="$mercury_cv_sockets_work"
fi


echo $ac_n "checking whether to enable the external debugger""... $ac_c" 1>&6
if test "$mercury_cv_enable_extern_debug" = "yes"; then
	if test "$mercury_cv_sockets_work" = yes; then
		echo "$ac_t""yes" 1>&6
		cat >> confdefs.h <<\EOF
#define MR_USE_EXTERNAL_DEBUGGER 1
EOF

	else
		echo "$ac_t""no" 1>&6
		{ echo "configure: error: Cannot enable external debugger" 1>&2; exit 1; }
		{ echo "configure: error: because sockets do not work" 1>&2; exit 1; }
	fi		
else
	echo "$ac_t""no" 1>&6

	# don't link with the socket library if we're not going to use it
	SOCKET_LIBRARY=
	NSL_LIBRARY=
fi



#-----------------------------------------------------------------------------#
#
# Check for dynamic linking, unless the --disable-dynamic-link option
# was specified.
#
# Check whether --enable-dynamic-link or --disable-dynamic-link was given.
if test "${enable_dynamic_link+set}" = set; then
  enableval="$enable_dynamic_link"
  mercury_cv_enable_dynamic_link="$enableval"
else
  mercury_cv_enable_dynamic_link=yes
fi

if test "$mercury_cv_enable_dynamic_link" = "yes"; then
	ac_safe=`echo "dlfcn.h" | tr './\055' '___'`
echo $ac_n "checking for dlfcn.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5443 "configure"
#include "confdefs.h"
#include <dlfcn.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:5448: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_DLFCN_H=1
else
  echo "$ac_t""no" 1>&6
fi

	if test "$HAVE_DLFCN_H" = 1; then
		cat >> confdefs.h <<\EOF
#define HAVE_DLFCN_H 1
EOF

	fi
	echo $ac_n "checking for -ldl""... $ac_c" 1>&6
ac_lib_var=`echo dl_dlopen | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ldl  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5481 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char dlopen();

int main() { return 0; }
int t() {
dlopen()
; return 0; }
EOF
if { (eval echo configure:5491: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  DL_LIBRARY="-ldl"
else
  echo "$ac_t""no" 1>&6
DL_LIBRARY=""
fi

	

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

	for ac_func in dlopen dlclose dlsym dlerror
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5523 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $ac_func(); below.  */
#include <assert.h>
/* Override any gcc2 internal prototype to avoid an error.  */
char $ac_func();

int main() { return 0; }
int t() {

/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
choke me
#else
$ac_func();
#endif

; return 0; }
EOF
if { (eval echo configure:5545: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=yes"
else
  rm -rf conftest*
  eval "ac_cv_func_$ac_func=no"
fi
rm -f conftest*

fi
if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
  echo "$ac_t""yes" 1>&6
    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
  cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
 
else
  echo "$ac_t""no" 1>&6
fi
done


	# restore old value of LIBS
	LIBS="$save_LIBS"
fi
#-----------------------------------------------------------------------------#

echo $ac_n "checking whether to enable the new MercuryFile struct""... $ac_c" 1>&6
# Check whether --enable-new-mercuryfile-struct or --disable-new-mercuryfile-struct was given.
if test "${enable_new_mercuryfile_struct+set}" = set; then
  enableval="$enable_new_mercuryfile_struct"
  ac_new_mercuryfile_struct=yes
else
  ac_new_mercuryfile_struct=no
fi


if test "$ac_new_mercuryfile_struct" = "yes"; then
	echo "$ac_t""yes" 1>&6
	cat >> confdefs.h <<\EOF
#define MR_NEW_MERCURYFILE_STRUCT 1
EOF

else
	echo "$ac_t""no" 1>&6
fi

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

# Check whether --with-readline or --without-readline was given.
if test "${with_readline+set}" = set; then
  withval="$with_readline"
  mercury_cv_with_readline="$withval"
else
  mercury_cv_with_readline=yes
fi


if test "$mercury_cv_with_readline" = yes; then

	# check for the readline header files
	ac_safe=`echo "readline/readline.h" | tr './\055' '___'`
echo $ac_n "checking for readline/readline.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5613 "configure"
#include "confdefs.h"
#include <readline/readline.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:5618: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_READLINE_READLINE_H=1
else
  echo "$ac_t""no" 1>&6
fi

	if test "$HAVE_READLINE_READLINE_H" = 1; then
		cat >> confdefs.h <<\EOF
#define HAVE_READLINE_READLINE 1
EOF

	fi
	ac_safe=`echo "readline/history.h" | tr './\055' '___'`
echo $ac_n "checking for readline/history.h""... $ac_c" 1>&6
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.$ac_ext <<EOF
#line 5649 "configure"
#include "confdefs.h"
#include <readline/history.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:5654: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out`
if test -z "$ac_err"; then
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=yes"
else
  echo "$ac_err" >&5
  rm -rf conftest*
  eval "ac_cv_header_$ac_safe=no"
fi
rm -f conftest*
fi
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  HAVE_READLINE_HISTORY_H=1
else
  echo "$ac_t""no" 1>&6
fi

	if test "$HAVE_READLINE_HISTORY_H" = 1; then
		cat >> confdefs.h <<\EOF
#define HAVE_READLINE_HISTORY 1
EOF

	fi

	# check for the libraries that readline depends on
	echo 'looking for termcap or curses (needed by readline)...' 1>&6
	echo $ac_n "checking for -ltermcap""... $ac_c" 1>&6
ac_lib_var=`echo termcap_tgetent | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-ltermcap  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5690 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char tgetent();

int main() { return 0; }
int t() {
tgetent()
; return 0; }
EOF
if { (eval echo configure:5700: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  mercury_cv_termcap_lib=-ltermcap
else
  echo "$ac_t""no" 1>&6
echo $ac_n "checking for -lcurses""... $ac_c" 1>&6
ac_lib_var=`echo curses_tgetent | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lcurses  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5724 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char tgetent();

int main() { return 0; }
int t() {
tgetent()
; return 0; }
EOF
if { (eval echo configure:5734: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  mercury_cv_termcap_lib=-lcurses
else
  echo "$ac_t""no" 1>&6
echo $ac_n "checking for -lncurses""... $ac_c" 1>&6
ac_lib_var=`echo ncurses_tgetent | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lncurses  $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5758 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char tgetent();

int main() { return 0; }
int t() {
tgetent()
; return 0; }
EOF
if { (eval echo configure:5768: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  mercury_cv_termcap_lib=-lncurses
else
  echo "$ac_t""no" 1>&6
mercury_cv_termcap_lib=''
fi

fi

fi


	# check for the readline library
	echo $ac_n "checking for -lreadline""... $ac_c" 1>&6
ac_lib_var=`echo readline_readline | tr '.-/+' '___p'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  ac_save_LIBS="$LIBS"
LIBS="-lreadline $mercury_cv_termcap_lib $LIBS"
cat > conftest.$ac_ext <<EOF
#line 5801 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error.  */
char readline();

int main() { return 0; }
int t() {
readline()
; return 0; }
EOF
if { (eval echo configure:5811: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=yes"
else
  rm -rf conftest*
  eval "ac_cv_lib_$ac_lib_var=no"
fi
rm -f conftest*
LIBS="$ac_save_LIBS"

fi
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
  echo "$ac_t""yes" 1>&6
  mercury_cv_have_readline=yes
else
  echo "$ac_t""no" 1>&6
mercury_cv_have_readline=no
fi

else
	mercury_cv_have_readline=no
fi

# Now figure out whether we can use readline, and define variables according.
# Note that on most systems, we don't actually need the header files in
# order to use readline. (Ain't C grand? ;-).

if test $mercury_cv_have_readline = no; then
	TERMCAP_LIBRARY=""
	READLINE_LIBRARIES=""
	cat >> confdefs.h <<\EOF
#define MR_NO_USE_READLINE 1
EOF

else
	TERMCAP_LIBRARY="$mercury_cv_termcap_lib"
	READLINE_LIBRARIES="-lreadline $TERMCAP_LIBRARY"
fi




#-----------------------------------------------------------------------------#
to_keep=""
to_delete=""
if test "$BOOTSTRAP_MC" != "" ; then
    echo "checking whether any C files need to be rebuilt..." 1>&6
    for c_file in library/*.c compiler/*.c browser/*.c profiler/*.c \
    		library/Mercury/cs/*.c compiler/Mercury/cs/*.c \
		browser/Mercury/cs/*.c profiler/Mercury/cs/*.c 
    do
        case $c_file in
        */'*.c')
            ;;
        */*_init.c)
            to_keep="$to_keep $c_file"
            ;;
        *)
            sed -e '/END_OF_C_GRADE_INFO/q' < $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
            echo "no - they are compatible with autoconfigured settings" 1>&6
        else
            echo "there are no existing Mercury-generated C files" 1>&6
        fi
    else
        if test "$to_keep" != "" ; then
            echo "the following C files must be rebuilt in a grade" 1>&6
            echo "that is consistent with autoconfigured settings" 1>&6
            echo "$to_delete" 1>&6
        else
            echo "all Mercury generated C files must be rebuilt" 1>&6
            echo "in a grade that is consistent with the" 1>&6
            echo "autoconfigured settings" 1>&6
        fi
        echo "installation may take longer than usual" 1>&6
    fi
    rm -f confscratch $to_delete
fi
#-----------------------------------------------------------------------------#
trap '' 1 2 15
cat > confcache <<\EOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
# scripts and configure runs.  It is not useful on other systems.
# If it contains results you don't want to keep, you may remove or edit it.
#
# By default, configure uses ./config.cache as the cache file,
# creating it if it does not exist already.  You can give configure
# the --cache-file=FILE option to use a different cache file; that is
# what configure does when it calls configure scripts in
# subdirectories, so they share the cache.
# Giving --cache-file=/dev/null disables caching, for debugging configure.
# config.status only pays attention to the cache file if you give it the
# --recheck option to rerun configure.
#
EOF
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(set) 2>&1 |
  sed -n "s/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=\${\1='\2'}/p" \
  >> confcache
if cmp -s $cache_file confcache; then
  :
else
  if test -w $cache_file; then
    echo "updating cache $cache_file"
    cat confcache > $cache_file
  else
    echo "not updating unwritable cache $cache_file"
  fi
fi
rm -f confcache

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

# Any assignment to VPATH causes Sun make to only execute
# the first set of double-colon rules, so remove it if not needed.
# If there is a colon in the path, we need to keep it.
if test "x$srcdir" = x.; then
  ac_vpsub='/^[ 	]*VPATH[ 	]*=[^:]*$/d'
fi

trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15

DEFS=-DHAVE_CONFIG_H

# Without the "./", some shells look in PATH for config.status.
: ${CONFIG_STATUS=./config.status}

echo creating $CONFIG_STATUS
rm -f $CONFIG_STATUS
cat > $CONFIG_STATUS <<EOF
#! /bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $ac_configure_args
#
# Compiler output produced by configure, useful for debugging
# configure, is in ./config.log if it exists.

ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
for ac_option
do
  case "\$ac_option" in
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
    exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
    echo "$CONFIG_STATUS generated by autoconf version 2.9"
    exit 0 ;;
  -help | --help | --hel | --he | --h)
    echo "\$ac_cs_usage"; exit 0 ;;
  *) echo "\$ac_cs_usage"; exit 1 ;;
  esac
done

ac_given_srcdir=$srcdir

trap 'rm -fr `echo "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
 runtime/mercury_conf.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
EOF
cat >> $CONFIG_STATUS <<EOF

# Protect against being on the right side of a sed subst in config.status.
sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
 s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
$ac_vpsub
$extrasub
s%@CFLAGS@%$CFLAGS%g
s%@CPPFLAGS@%$CPPFLAGS%g
s%@CXXFLAGS@%$CXXFLAGS%g
s%@DEFS@%$DEFS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@LIBS@%$LIBS%g
s%@exec_prefix@%$exec_prefix%g
s%@prefix@%$prefix%g
s%@program_transform_name@%$program_transform_name%g
s%@bindir@%$bindir%g
s%@sbindir@%$sbindir%g
s%@libexecdir@%$libexecdir%g
s%@datadir@%$datadir%g
s%@sysconfdir@%$sysconfdir%g
s%@sharedstatedir@%$sharedstatedir%g
s%@localstatedir@%$localstatedir%g
s%@libdir@%$libdir%g
s%@includedir@%$includedir%g
s%@oldincludedir@%$oldincludedir%g
s%@infodir@%$infodir%g
s%@mandir@%$mandir%g
s%@host@%$host%g
s%@host_alias@%$host_alias%g
s%@host_cpu@%$host_cpu%g
s%@host_vendor@%$host_vendor%g
s%@host_os@%$host_os%g
s%@FULLARCH@%$FULLARCH%g
s%@PREFIX@%$PREFIX%g
s%@NONSHARED_LIB_DIR@%$NONSHARED_LIB_DIR%g
s%@LIBDIR@%$LIBDIR%g
s%@DEFAULT_MERCURY_DEBUGGER_INIT_DIR@%$DEFAULT_MERCURY_DEBUGGER_INIT_DIR%g
s%@BOOTSTRAP_MC@%$BOOTSTRAP_MC%g
s%@ENABLE_GCC_BACK_END@%$ENABLE_GCC_BACK_END%g
s%@GCC_SRC_DIR@%$GCC_SRC_DIR%g
s%@ENABLE_ADITI_BACK_END@%$ENABLE_ADITI_BACK_END%g
s%@GNU_MAKE@%$GNU_MAKE%g
s%@MKFIFO@%$MKFIFO%g
s%@MKNOD@%$MKNOD%g
s%@MKTEMP@%$MKTEMP%g
s%@INSTALL_INFO@%$INSTALL_INFO%g
s%@TEXI2DVI@%$TEXI2DVI%g
s%@DVIPS@%$DVIPS%g
s%@MAKEINFO@%$MAKEINFO%g
s%@INFO@%$INFO%g
s%@PERL@%$PERL%g
s%@CC@%$CC%g
s%@CPP@%$CPP%g
s%@MATH_LIB@%$MATH_LIB%g
s%@RANLIB@%$RANLIB%g
s%@OBJFILE_OPT@%$OBJFILE_OPT%g
s%@AR@%$AR%g
s%@ARFLAGS@%$ARFLAGS%g
s%@AR_LIBFILE_OPT@%$AR_LIBFILE_OPT%g
s%@BOEHMGC_MAKEFILE@%$BOEHMGC_MAKEFILE%g
s%@EXE_SUFFIX@%$EXE_SUFFIX%g
s%@OBJ_SUFFIX@%$OBJ_SUFFIX%g
s%@LIB_SUFFIX@%$LIB_SUFFIX%g
s%@LIB_PREFIX@%$LIB_PREFIX%g
s%@LIB_LIBPATH@%$LIB_LIBPATH%g
s%@LINK_LIB@%$LINK_LIB%g
s%@LINK_OPT_SEP@%$LINK_OPT_SEP%g
s%@CYGPATH@%$CYGPATH%g
s%@ILASM@%$ILASM%g
s%@MS_DOTNET_SDK_DIR@%$MS_DOTNET_SDK_DIR%g
s%@MR_WORD_TYPE@%$MR_WORD_TYPE%g
s%@MR_INTEGER_LENGTH_MODIFIER@%$MR_INTEGER_LENGTH_MODIFIER%g
s%@MR_INT_LEAST64_TYPE@%$MR_INT_LEAST64_TYPE%g
s%@MR_INT_LEAST32_TYPE@%$MR_INT_LEAST32_TYPE%g
s%@MR_INT_LEAST16_TYPE@%$MR_INT_LEAST16_TYPE%g
s%@LOW_TAG_BITS@%$LOW_TAG_BITS%g
s%@BYTES_PER_WORD@%$BYTES_PER_WORD%g
s%@SYNC_TERM_SIZE@%$SYNC_TERM_SIZE%g
s%@BITS_PER_WORD@%$BITS_PER_WORD%g
s%@HAVE_BOXED_FLOATS@%$HAVE_BOXED_FLOATS%g
s%@MR_FLOAT_IS_64_BIT@%$MR_FLOAT_IS_64_BIT%g
s%@MR_DOUBLE_IS_64_BIT@%$MR_DOUBLE_IS_64_BIT%g
s%@MR_LONG_DOUBLE_IS_64_BIT@%$MR_LONG_DOUBLE_IS_64_BIT%g
s%@MR_BIG_ENDIAN@%$MR_BIG_ENDIAN%g
s%@MR_LITTLE_ENDIAN@%$MR_LITTLE_ENDIAN%g
s%@MR_CAN_DO_PENDING_IO@%$MR_CAN_DO_PENDING_IO%g
s%@CFLAGS_FOR_REGS@%$CFLAGS_FOR_REGS%g
s%@CFLAGS_FOR_GOTOS@%$CFLAGS_FOR_GOTOS%g
s%@HAVE_ASM_LABELS@%$HAVE_ASM_LABELS%g
s%@CFLAGS_FOR_THREADS@%$CFLAGS_FOR_THREADS%g
s%@GRADE@%$GRADE%g
s%@DEFAULT_GRADE@%$DEFAULT_GRADE%g
s%@LIBGRADES@%$LIBGRADES%g
s%@NUM_REAL_R_REGS@%$NUM_REAL_R_REGS%g
s%@NUM_REAL_R_TEMPS@%$NUM_REAL_R_TEMPS%g
s%@HAVE_DELAY_SLOT@%$HAVE_DELAY_SLOT%g
s%@AS@%$AS%g
s%@LINK_SHARED_OBJ@%$LINK_SHARED_OBJ%g
s%@LINK_SHARED_OBJ_SH@%$LINK_SHARED_OBJ_SH%g
s%@ERROR_UNDEFINED@%$ERROR_UNDEFINED%g
s%@ALLOW_UNDEFINED@%$ALLOW_UNDEFINED%g
s%@EXE_RPATH_OPT@%$EXE_RPATH_OPT%g
s%@EXE_RPATH_SEP@%$EXE_RPATH_SEP%g
s%@SHLIB_RPATH_OPT@%$SHLIB_RPATH_OPT%g
s%@SHLIB_RPATH_SEP@%$SHLIB_RPATH_SEP%g
s%@CFLAGS_FOR_PIC@%$CFLAGS_FOR_PIC%g
s%@EXT_FOR_PIC_OBJECTS@%$EXT_FOR_PIC_OBJECTS%g
s%@EXT_FOR_SHARED_LIB@%$EXT_FOR_SHARED_LIB%g
s%@EXT_FOR_EXE@%$EXT_FOR_EXE%g
s%@USE_DLLS@%$USE_DLLS%g
s%@SHARED_LIBS@%$SHARED_LIBS%g
s%@SHARED_LIBS_SH@%$SHARED_LIBS_SH%g
s%@DEFAULT_RM_C@%$DEFAULT_RM_C%g
s%@LIBRARY_RM_C@%$LIBRARY_RM_C%g
/@INIT_GRADE_OPTIONS@/r $INIT_GRADE_OPTIONS
s%@INIT_GRADE_OPTIONS@%%g
/@PARSE_GRADE_OPTIONS@/r $PARSE_GRADE_OPTIONS
s%@PARSE_GRADE_OPTIONS@%%g
/@FINAL_GRADE_OPTIONS@/r $FINAL_GRADE_OPTIONS
s%@FINAL_GRADE_OPTIONS@%%g
/@CANONICAL_GRADE@/r $CANONICAL_GRADE
s%@CANONICAL_GRADE@%%g
s%@SOCKET_LIBRARY@%$SOCKET_LIBRARY%g
s%@NSL_LIBRARY@%$NSL_LIBRARY%g
s%@DL_LIBRARY@%$DL_LIBRARY%g
s%@TERMCAP_LIBRARY@%$TERMCAP_LIBRARY%g
s%@READLINE_LIBRARIES@%$READLINE_LIBRARIES%g

CEOF
EOF
cat >> $CONFIG_STATUS <<EOF

CONFIG_FILES=\${CONFIG_FILES-"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
"}
EOF
cat >> $CONFIG_STATUS <<\EOF
for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
  # Support "outfile[:infile]", defaulting infile="outfile.in".
  case "$ac_file" in
  *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'`
       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
  *) ac_file_in="${ac_file}.in" ;;
  esac

  # Adjust relative srcdir, etc. for subdirectories.

  # Remove last slash and all that follows it.  Not all systems have dirname.
  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
    # The file is in a subdirectory.
    test ! -d "$ac_dir" && mkdir "$ac_dir"
    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
    # A "../" for each directory in $ac_dir_suffix.
    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
  else
    ac_dir_suffix= ac_dots=
  fi

  case "$ac_given_srcdir" in
  .)  srcdir=.
      if test -z "$ac_dots"; then top_srcdir=.
      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
  *) # Relative path.
    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
    top_srcdir="$ac_dots$ac_given_srcdir" ;;
  esac

  echo creating "$ac_file"
  rm -f "$ac_file"
  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
  case "$ac_file" in
  *Makefile*) ac_comsub="1i\\
# $configure_input" ;;
  *) ac_comsub= ;;
  esac
  sed -e "$ac_comsub
s%@configure_input@%$configure_input%g
s%@srcdir@%$srcdir%g
s%@top_srcdir@%$top_srcdir%g
" -f conftest.subs $ac_given_srcdir/$ac_file_in > $ac_file
fi; done
rm -f conftest.subs

# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
# NAME is the cpp macro being defined and VALUE is the value it is being given.
#
# ac_d sets the value in "#define NAME VALUE" lines.
ac_dA='s%^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'
ac_dB='\([ 	][ 	]*\)[^ 	]*%\1#\2'
ac_dC='\3'
ac_dD='%g'
# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
ac_uA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
ac_uB='\([ 	]\)%\1#\2define\3'
ac_uC=' '
ac_uD='\4%g'
# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
ac_eA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
ac_eB='$%\1#\2define\3'
ac_eC=' '
ac_eD='%g'

CONFIG_HEADERS=${CONFIG_HEADERS-"runtime/mercury_conf.h"}
for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
  # Support "outfile[:infile]", defaulting infile="outfile.in".
  case "$ac_file" in
  *:*) ac_file_in=`echo "$ac_file"|sed 's%.*:%%'`
       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
  *) ac_file_in="${ac_file}.in" ;;
  esac

  echo creating $ac_file

  rm -f conftest.frag conftest.in conftest.out
  cp $ac_given_srcdir/$ac_file_in conftest.in

EOF

# Transform confdefs.h into a sed script conftest.vals that substitutes
# the proper values into config.h.in to produce config.h.  And first:
# Protect against being on the right side of a sed subst in config.status.
# Protect against being in an unquoted here document in config.status.
rm -f conftest.vals
cat > conftest.hdr <<\EOF
s/[\\&%]/\\&/g
s%[\\$`]%\\&%g
s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
s%ac_d%ac_u%gp
s%ac_u%ac_e%gp
EOF
sed -n -f conftest.hdr confdefs.h > conftest.vals
rm -f conftest.hdr

# This sed command replaces #undef with comments.  This is necessary, for
# example, in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it.
cat >> conftest.vals <<\EOF
s%^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
EOF

# Break up conftest.vals because some shells have a limit on
# the size of here documents, and old seds have small limits too.
# Maximum number of lines to put in a single here document.
ac_max_here_lines=12

rm -f conftest.tail
while :
do
  ac_lines=`grep -c . conftest.vals`
  # grep -c gives empty output for an empty file on some AIX systems.
  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
  # Write a limited-size here document to conftest.frag.
  echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
  sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
  echo 'CEOF
  sed -f conftest.frag conftest.in > conftest.out
  rm -f conftest.in
  mv conftest.out conftest.in
' >> $CONFIG_STATUS
  sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
  rm -f conftest.vals
  mv conftest.tail conftest.vals
done
rm -f conftest.vals

cat >> $CONFIG_STATUS <<\EOF
  rm -f conftest.frag conftest.h
  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
  cat conftest.in >> conftest.h
  rm -f conftest.in
  if cmp -s $ac_file conftest.h 2>/dev/null; then
    echo "$ac_file is unchanged"
    rm -f conftest.h
  else
    rm -f $ac_file
    mv conftest.h $ac_file
  fi
fi; done


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

exit 0
EOF
chmod +x $CONFIG_STATUS
rm -fr confdefs* $ac_clean_files
test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1


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