dnl Process this file with autoconf to produce a configure script.

#Copyright (C) 1995,1996,1997,1998,2000 Free Software Foundation, Inc.

#This file is part of Gforth.

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

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

#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.

AC_INIT(engine/engine.c)

dnl We use some automake macros here,
dnl but don't use automake for creating Makefile.in
AM_INIT_AUTOMAKE(gforth,0.5.9-20020901)
#snapshots have numbers major.minor.release-YYYYMMDD
#note that lexicographic ordering bust be heeded.
#I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1!
UPDATED="1 September 2002"
AC_SUBST(UPDATED)
AM_CONFIG_HEADER(engine/config.h)
#AM_CYGWIN32

AC_ARG_ENABLE(force-reg,
[  --enable-force-reg	  Use explicit register declarations if they appear in
			  the machine.h file. This can cause a good speedup,
			  but also incorrect code with some gcc versions on
			  some processors (default disabled).],
AC_DEFINE(FORCE_REG))

AC_ARG_WITH(debug,
[  --with-debug     specifies option -g to compile with debug info (default)
  --without-debug  omits the -g switch and creates smaller images on
                   machines where "strip" has problems with gcc style
                   debugging informations.],
if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)

PEEPHOLE="yes"
AC_ARG_WITH(peephole,
[  --with-peephole	Enable peephole optimization (default)
  --without-peephole	disables peephole optimization. Creates smaller,
			but slower images.],
PEEPHOLE="$withval")

#currently we force direct threading this way.  Eventually we should
#setup in the arch and engine files right

CFLAGS=$CFLAGS

AC_PROG_CC

if test "$GCC" = "yes"
then
   echo "Fine, gcc is available"
else
   cat <<'EOF'
Gforth requires GCC-2.0 or higher (it uses GNU C extensions).
It does not work with other C compilers. Please install the GNU C compiler,
and try again (or search for a binary distribution for your platform).
EOF
   exit 1
fi

AC_SUBST(CC)
AC_SUBST(DEBUGFLAG)

dnl the following macro produces a warning with autoconf-2.1
AC_CHECK_SIZEOF(char *)
case "$ac_cv_sizeof_char_p" in
  2)
    wordsize=16
    ;;
  4)
    wordsize=32
    ;;
  8)
    wordsize=64
    ;;
esac

AC_CHECK_SIZEOF(char)
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)

ac_cv_int_type_cell=none
case "$ac_cv_sizeof_char_p" in
  $ac_cv_sizeof_int)
    ac_cv_int_type_cell=int
    ;;
  $ac_cv_sizeof_short)
    ac_cv_int_type_cell=short
    ;;
  $ac_cv_sizeof_char)
    ac_cv_int_type_cell=char
    ;;
  $ac_cv_sizeof_long)
    ac_cv_int_type_cell=long
    ;;
  $ac_cv_sizeof_long_long)
    ac_cv_int_type_cell="long long"
    ;;
esac
if test "$ac_cv_int_type_cell" != int; then
	echo "So, sizeof(pointer)!=sizeof(int); looks like a DOS C compiler to me."
	echo "Since you don't have a proper C on this machine, that's one more reason"
	echo "to use Forth;-)"
fi
AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell)

ac_cv_int_type_double_cell=none
case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
  $ac_cv_sizeof_short)
    ac_cv_int_type_double_cell=short
    ;;
  $ac_cv_sizeof_int)
    ac_cv_int_type_double_cell=int
    ;;
  $ac_cv_sizeof_long)
    ac_cv_int_type_double_cell=long
    ;;
  $ac_cv_sizeof_long_long)
    ac_cv_int_type_double_cell="long long"
    ;;
esac
if test "$ac_cv_int_type_double_cell" = none; then
	echo "Emulating double-cell arithmetic. This may be slow."
	echo "If you find this unacceptable, ask the GCC maintainers to provide proper"
	echo 'long longs for your machine (the GCC manual states that they \"are twice as'
	echo "long as \`long int\'\")."
	AC_LIBOBJ(dblsub)
	AC_DEFINE(BUGGY_LONG_LONG)
else
  AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell)
fi

AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
OLDLDFLAGS=$LDFLAGS
LDFLAGS="$LDFLAGS -export-dynamic"
dnl AC_TRY_LINK gives false positive on rs6000-ibm-aix4.2.1.0
dnl AC_TRY_LINK(,,ac_export_dynamic=yes,ac_export_dynamic=no)
AC_TRY_RUN(main(){exit(0);},ac_export_dynamic=yes,ac_export_dynamic=no,ac_export_dynamic=no)
test $ac_export_dynamic = yes|| LDFLAGS=$OLDLDFLAGS
AC_MSG_RESULT($ac_export_dynamic)

#terminology is a bit unusual here: The host is the system on which
#gforth will run; the system on which configure will run is the `build'
AC_CANONICAL_HOST
case "$host_cpu" in
	hppa*)
		machine=hppa
		$srcdir/mkinstalldirs arch/hppa
		AC_LIBOBJ(../arch/hppa/cache)
		LDFLAGS="$LDFLAGS -Xlinker -N"
		LIBS="$LIBS -L/lib/pa1.1/"
		;;
	sparc*)
		machine=sparc
		;;
	i386)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
		;;
	i486)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"
		;;
	i*86)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
		CFLAGS_1="$CFLAGS"
		CFLAGS="$CFLAGS -march=pentium"
		AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
		;;
	ia64*)
		machine=ia64
		;;
        m68k)
		machine=m68k
		CFLAGS="$CFLAGS -fomit-frame-pointer"
		if test "$host_os" = "nextstep3"
		then
			AC_LIBOBJ(termios)
		fi
		;;
	mips*)
		machine=mips
		#link text and data segment into the same 256M region!
		AC_MSG_CHECKING([whether the linker accepts -T])
		OLDLDFLAGS=$LDFLAGS
		LDFLAGS="$LDFLAGS -Xlinker -T -Xlinker 10000000"
		AC_TRY_LINK(,,ac_link_mips_t=yes,ac_link_mips_t=no)
		test $ac_link_mips_t = yes||LDFLAGS=$OLDLDFLAGS
		AC_MSG_RESULT($ac_link_mips_t)
		fixme #dynamically generated code should be in the same 256MB
		# region as the text segment; no indirect threading necessary
		test $ac_link_mips_t = yes||(echo cannot link text and data into same 256M region, using indirect threading; AC_DEFINE(INDIRECT_THREADED))
		AC_MSG_CHECKING([whether the linker accepts -D])
		OLDLDFLAGS=$LDFLAGS
		LDFLAGS="$LDFLAGS -Xlinker -D -Xlinker 10400000"
		AC_TRY_LINK(,,ac_link_mips_d=yes,ac_link_mips_d=no)
		test $ac_link_mips_d = yes||LDFLAGS=$OLDLDFLAGS
		AC_MSG_RESULT($ac_link_mips_d)
		;;
	alpha*)
		machine=alpha
		#full IEEE FP support for more uniformity across platforms:
		CFLAGS="$CFLAGS -mieee"
		;;
	power*|rs6000)
		machine=power
		$srcdir/mkinstalldirs arch/power
		AC_CHECK_FUNC(_sync_cache_range,true,AC_LIBOBJ(../arch/power/_sync_cache_range))
		;;
	*)
		echo "Using a generic machine description."
		echo "I'll assume that C floats and doubles are represented by IEEE single and"
		echo "double numbers. If this is not so, SF@ etc. will not work correctly."
		echo "FLUSH-ICACHE will do nothing, so END-CODE may not work properly!"
		machine=generic
esac
AC_SUBST(host)
AC_SUBST(ENGINE_FLAGS)

# Try if GCC understands -fno-cross-jump

CFLAGS_1="$CFLAGS"
CFLAGS="$CFLAGS -fno-cross-jump"
AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1")

AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
AC_SUBST(asm_fs)

AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)
AC_SUBST(disasm_fs)

case "$host_os" in
	*win32)
		EXE=".exe"
		DIRSEP="\\"
		;;
	*)
		EXE=""
		DIRSEP="/"
		;;
esac
AC_SUBST(EXE)
AC_SUBST(DIRSEP)
AC_DEFINE_UNQUOTED(DIRSEP,'$DIRSEP')

dnl Now a little support for DOS/DJGCC
AC_SUBST(GFORTH_EXE)
GFORTH_EXE=""
AC_SUBST(GFORTHFAST_EXE)
GFORTHFAST_EXE=""
AC_SUBST(GFORTHITC_EXE)
GFORTHITC_EXE=""
AC_SUBST(GFORTHDITC_EXE)
GFORTHDITC_EXE=""

PATHSEP=":"
AC_SUBST(PATHSEP)
AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP')

AC_SUBST(FORTHSIZES)

if test "$PEEPHOLE" = "yes"
then
   PEEPHOLEFLAG="true"
   AC_DEFINE(HAS_PEEPHOLE)
else
   PEEPHOLEFLAG="false"
fi
AC_SUBST(PEEPHOLEFLAG)

dnl copy commands for systems that don't have links
AC_SUBST(LINK_KERNL)
LINK_KERNL=""

#if test $host_os=dos
#then
#  echo Configuring for DOS!!!
#  MAKE_EXE="coff2exe gforth"
#  LINK_KERNL='$(CP) kernl32l.fi kernel.fi'
#fi

dnl the following macro produces a warning with autoconf-2.1
AC_C_BIGENDIAN
AC_SUBST(KERNEL)
dnl ac_cv_c_bigendian is an undocumented variable of autoconf-2.1
if test $ac_cv_c_bigendian = yes; then
  bytesex=b
  KERNEL="kernl16b.fi kernl16l.fi kernl32b.fi kernl32l.fi kernl64b.fi kernl64l.fi"
else
  bytesex=l
  KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi"
fi

dnl Checks for programs.
AC_PROG_LN_S
dnl AM_PROG_INSTALL #performed by AM_INIT_AUTOMAKE

dnl Checks for library functions
dnl This check is just for making later checks link with libm.
dnl using sin here is no good idea since it is built-into gcc and typechecked
AC_CHECK_LIB(m,asin)
AC_CHECK_LIB(dl,dlopen)
if test "$host_os" != "nextstep3"
then
	AC_FUNC_MEMCMP
fi
AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh)
AC_CHECK_FUNCS(dlopen sys_siglist getrusage)
AC_DECL_SYS_SIGLIST
AC_CHECK_FUNC(getopt_long,true,AC_LIBOBJ(getopt.$ac_objext getopt1))
AC_CHECK_FUNCS(rint expm1 log1p)
AC_REPLACE_FUNCS(ecvt)
dnl No check for select, because our replacement is no good under
dnl anything but DOS
AC_CHECK_HEADERS(sys/mman.h fnmatch.h)
AC_FUNC_FNMATCH
test $ac_cv_func_fnmatch_works = yes || AC_LIBOBJ(fnmatch)
AC_CHECK_FUNCS(mmap sysconf getpagesize)
AM_PATH_LISPDIR

kernel_fi=kernl${wordsize}${bytesex}.fi
AC_SUBST(kernel_fi)

#this breaks bindists
#dnl replace srource directory by absolute value
#if test $srcdir = "."; then srcdir=`pwd` 
#fi

AC_SUBST(machine)
dnl AC_LINK_FILES(arch/$machine,arch/machine) #no longer needed
AC_OUTPUT([
Makefile
Makedist
gforthmi
vmgen
machpc.fs
engine/Makefile
doc/version.texi ],
echo timestamp > stamp-h
chmod +x gforthmi
chmod +x vmgen
test -d kernel||mkdir kernel)