--- gforth/configure.in	1997/06/15 19:43:27	1.32
+++ gforth/configure.in	2008/08/19 20:18:58	1.244
@@ -1,12 +1,12 @@
 dnl Process this file with autoconf to produce a configure script.
 
-#Copyright (C) 1995,1996 Free Software Foundation, Inc.
+#Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006,2007,2008 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
+#as published by the Free Software Foundation, either version 3
 #of the License, or (at your option) any later version.
 
 #This program is distributed in the hope that it will be useful,
@@ -15,57 +15,345 @@ dnl Process this file with autoconf to p
 #GNU General Public License for more details.
 
 #You should have received a copy of the GNU General Public License
-#along with this program; if not, write to the Free Software
-#Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#along with this program. If not, see http://www.gnu.org/licenses/.
 
-AC_INIT(engine/engine.c)
-AC_CONFIG_HEADER(engine/config.h)
 
-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))
-dnl this is not quite according to the autoconf manual, it causes a replacement
-AC_ARG_ENABLE(direct-threaded,
-[  --enable-direct-threaded	Force direct threading. This may not work on
-				some machines and may cause slowdown on others.
-				(default processor-dependent)],
-AC_DEFINE(DIRECT_THREADED))
-AC_ARG_ENABLE(indirect-threaded,
-[  --enable-indirect-threaded	Force indirect threading. This can cause a
-				slowdown on some machines.
-				(default processor-dependent)],
-AC_DEFINE(INDIRECT_THREADED))
+dnl We use some automake macros here,
+dnl but don't use automake for creating Makefile.in
+AC_INIT([gforth],[0.6.9-20080716],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])
+AC_PREREQ(2.54)
+#snapshots have numbers major.minor.release-YYYYMMDD
+#note that lexicographic ordering must be heeded.
+#I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1!
+UPDATED="July 16, 2008"
+AC_SUBST(UPDATED)
+AC_CONFIG_HEADERS(engine/config.h)
+
+#remnants from having ltdl as convenience library
+LTDLDEPS=""
+LTDLINCL=""
+LIBLTDL=""
+LTDL_LDLIBS=""
+AC_SUBST(LTDLDEPS)
+AC_SUBST(LTDLINCL)
+AC_SUBST(LIBLTDL)
+AC_SUBST(LTDL_LDLIBS)
+
+#suppress the "-g -O2" default
+test "$CFLAGS" || CFLAGS=-O2
+
+AC_ARG_ENABLE(force-cdiv,
+	AC_HELP_STRING([--enable-force-cdiv],
+		       [  Use the native C division - symmetric - instead of
+		          floored division (default disabled).]),
+	,enable_force_cdiv=no)
+test "$enable_force_cdiv" = "no"||
+  AC_DEFINE(FORCE_CDIV,,[Define if you want to use explicit symmetric division for better performance])
+
+AC_SUBST(PROFEXES)
+AC_SUBST(PROFOBJS)
+AC_ARG_ENABLE(prof,
+	AC_HELP_STRING([--enable-prof],
+			[ Build gforth-prof, which outputs frequently occuring
+                          sequences of primitives.]),
+	,enable_prof=no)
+if test "$enable_prof" != "no"; then
+  PROFEXES='gforth-prof$(OPT)$(EXE)'; PROFOBJS='engine-prof$(OPT).o main-prof$(OPT).o profile$(OPT).o'
+fi
 
 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.],
+[  --with-debug		  specifies option -g to compile with debug info
+  --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)
 
-CFLAGS=$CFLAGS
+GCC_LD="\$(GCC)"
+EC_MODE="false"
+EC=""
+engine2='engine2$(OPT).o'
+engine_fast2='engine-fast2$(OPT).o'
+no_dynamic=""
+image_i=""
+signals_o="io.o signals.o"
+
+AC_ARG_WITH(ec,
+	AC_HELP_STRING([--with-ec=<arch>],
+			[  Build gforth for systems without OS.]),
+[if test "$withval" = "no"; then
+  echo "defining hosted system"
+else
+  echo "defining standalone system (${withval})"
+  AC_DEFINE(STANDALONE,,[Define if you want a Gforth without OS])
+  EC_MODE="true"
+  EC="-ec"
+  engine2=""
+  engine_fast2=""
+  no_dynamic="-DNO_DYNAMIC"
+  image_i="image.i"
+  if test "$withval" != "yes"; then
+    signals_o="io-${withval}.o"
+  else
+    signals_o="io.o"
+  fi
+  GCC_PATH=$(which $CC)
+  LIB_PATH=${GCC_PATH%/*/*}
+  GCC_LD="\$(LD)"
+  platform=${withval}
+fi])
+
+#variables mentioned in INSTALL
+AC_ARG_VAR(CC, [The C compiler (must support GNU C 2.x).])
+AC_ARG_VAR(FORTHSIZES, [Gforth command line options for the default stack and dictionary sizes (see INSTALL).])
+AC_ARG_VAR(STACK_CACHE_REGS, [number of registers in the maximum stack cache state for gforth-fast and gforth-native (default platform-dependent).])
+AC_ARG_VAR(STACK_CACHE_DEFAULT_FAST, [number of registers in the default stack cache state for gforth-fast and gforth-native (default 1).])
+AC_ARG_VAR(GCC_PR15242_WORKAROUND, [Force the enabling (1) or disabling (0) of a workaround for a gcc-3.x performance bug (default unset: use workaround for gcc-3.x)])
+AC_ARG_VAR(LIBCC_BUILD_SRC, [(Additional) libcc interface source files that should be processed on building and installation (default none)])
+
+AC_ARG_VAR(ac_cv_sizeof_char_p, [sizeof(char *)])
+AC_ARG_VAR(ac_cv_sizeof_void_p, [sizeof(void *)])
+AC_ARG_VAR(ac_cv_sizeof_char, [sizeof(char)])
+AC_ARG_VAR(ac_cv_sizeof_short, [sizeof(short)])
+AC_ARG_VAR(ac_cv_sizeof_int, [sizeof(int)])
+AC_ARG_VAR(ac_cv_sizeof_long, [sizeof(long)])
+AC_ARG_VAR(ac_cv_sizeof_long_long, [sizeof(long long)])
+AC_ARG_VAR(ac_cv_sizeof_intptr_t, [sizeof(intptr_t)])
+AC_ARG_VAR(ac_cv_c_bigendian, [Is the target big-endian ("yes" or "no")?])
+AC_ARG_VAR(no_dynamic_default, [run gforth with --dynamic (0) or --no-dynamic (1) by default])
+AC_ARG_VAR(condbranch_opt, [enable (1) or disable (0) using two dispatches for conditional branches])
+AC_ARG_VAR(skipcode, [assembly code for skipping 16 bytes of code])
+AC_ARG_VAR(asmcomment, [assembler comment start string])
+AC_ARG_VAR(arm_cacheflush, [file containing ARM cacheflush function (without .c)])
+
+#set up feature test macros, so the tests get them right:
+# turn on all POSIX, SUSv3, and GNU features if available
+AC_GNU_SOURCE
+dnl AC_DEFINE_UNQUOTED([_GNU_SOURCE],1,[feature test macro])
+
+dnl Don't define _POSIX_SOURCE etc. because some OSs (in particular
+dnl MacOSX) disable some features then (MacOSX checks for _POSIX_SOURCE,
+dnl but not for _XOPEN_SOURCE)
+dnl AC_DEFINE_UNQUOTED([_POSIX_SOURCE],1,[feature test macro])
+dnl AC_DEFINE_UNQUOTED([_POSIX_C_SOURCE],199506L,[feature test macro])
+dnl AC_DEFINE_UNQUOTED([_XOPEN_SOURCE],600,[feature test macro])
+# turn on large file support with 64-bit off_t where available
+AC_SYS_LARGEFILE
+dnl AC_DEFINE_UNQUOTED([_LARGEFILE_SOURCE],1,[feature test macro])
+dnl AC_DEFINE_UNQUOTED([_FILE_OFFSET_BITS],64,[feature test macro])
+
+#currently we force direct threading this way.  Eventually we should
+#setup in the arch and engine files right
 
 AC_PROG_CC
 
-if test "$GCC" = "yes"
-then
-   echo "Fine, gcc is available"
+test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher)
+
+AC_MSG_CHECKING([whether to use two dispatches per conditional branch])
+test x$condbranch_opt = x && 
+if ($CC -v 2>&1 |grep 'gcc version 3' >/dev/null); then
+   condbranch_opt=0
 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
+   condbranch_opt=1
 fi
+AC_MSG_RESULT($condbranch_opt)
+AC_SUBST(condbranch_opt)
 
 AC_SUBST(CC)
-AC_SUBST(GCCLDFLAGS)
+AC_SUBST(GCC_LD)
 AC_SUBST(DEBUGFLAG)
+AC_SUBST(EC)
+AC_SUBST(EC_MODE)
+AC_SUBST(engine2)
+AC_SUBST(engine_fast2)
+AC_SUBST(no_dynamic)
+AC_SUBST(image_i)
+AC_SUBST(signals_o)
+
+#this is used to disable some (not generally essential) part of the
+#Makefile that some makes don't grok.  It would be better to test for
+#this specific Makefile feature than the make version.
+AC_MSG_CHECKING(make type)
+make_type=`make -n -v 2>&1|grep 'ake'|sed 's/ake .*/ake/'`
+GNUMAKE='#'
+test "$make_type" = "GNU Make" && GNUMAKE=''
+AC_MSG_RESULT($make_type)
+AC_SUBST(GNUMAKE)
+
+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
+	arm*)
+		machine=arm
+		CFLAGS="$CFLAGS -fomit-frame-pointer"
+		if test x$platform = xnxt; then
+		   CFLAGS="$CFLAGS -mthumb -mthumb-interwork"
+		fi
+		if test -z $arm_cacheflush; then
+		   case "$host_os" in
+		     *linux*)
+			arm_cacheflush=arch/arm/cacheflush-linux 
+			;;
+		     *)   
+			no_dynamic_default=1
+			arm_cacheflush=arch/arm/cacheflush0
+			AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])
+			;;
+                   esac
+		fi
+                AC_LIBSOURCES([../arch/arm/cacheflush0, dnl
+			       ../arch/arm/cacheflush-linux])
+                AC_LIBOBJ(../$arm_cacheflush)
+                #longer skipcodes lead to problems on ARM, and it uses
+                #only 4-byte alignment anyway
+		test "$skipcode" || skipcode="nop"
+		;;
+	hppa*)
+		machine=hppa
+		$srcdir/mkinstalldirs arch/hppa
+		AC_LIBOBJ(../arch/hppa/cache)
+		#-N needed for --dynamic <M4U3b.3790$9d.317@news.cpqcorp.net>
+		LDFLAGS="$LDFLAGS -Xlinker -N"
+		LIBS="$LIBS -L/lib/pa1.1/"
+		;;
+	sparc*)
+		machine=sparc
+		;;
+	i386)
+		machine=386
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
+		;;
+	i486)
+		machine=386
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -m486"
+		;;
+	i*86)
+		machine=386
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
+		CFLAGS_1="$CFLAGS"
+		CFLAGS="$CFLAGS -march=pentium"
+		AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
+		;;
+	x86_64)
+		case $CC
+		in
+		    *-m32*)
+		    	machine=386
+			CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
+			CFLAGS_1="$CFLAGS"
+			CFLAGS="$CFLAGS -march=athlon64"
+			;;
+		    *)
+		    	machine=amd64
+			;;
+		esac
+		;;
+	ia64*)
+		machine=ia64
+		AC_LIBOBJ(../arch/ia64/flush_icache_block)
+		test "$skipcode" || skipcode="nop.i 0"
+		#".skip 16" passes the test below,
+		# but gives an assembler error in engine
+		;;
+        m68k)
+		machine=m68k
+		CFLAGS="$CFLAGS -fomit-frame-pointer"
+		if test "$host_os" = "nextstep3"
+		then
+			AC_LIBOBJ(termios)
+		fi
+		;;
+	mips*)
+		machine=mips
+		#dynamic native code has the following problems on MIPS:
+		#
+		#1) J/JAL seems relocatable, but is are only
+		#relocatable within a 256MB-segment.  While we try to
+		#get the linker to arrange this, there is no guarantee
+		#that this will succeed (and if the user uses a lot of
+		#memory, it is likely to fail).
+		#
+		#2) The way we generate dynamic native code may
+		#violate MIPS architectural restrictions (in
+		#particular, the delay slots of LW, MFLO, etc.)
+		#
+		#Therefore we disable dynamic native code by default:
+		if test -z $no_dynamic_default; then
+		    no_dynamic_default=1
+		    AC_MSG_WARN([Disabling default dynamic native code generation (relocation and delay slot issues)])
+		fi
+		;;
+	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)])
+		#long long is broken on (at least) gcc-2.95.* for PPC
+		test x$ac_cv_sizeof_long_long = x && 
+		($CC -v 2>&1 |grep 'gcc version 2.95' >/dev/null) &&
+		ac_cv_sizeof_long_long=0
+                #The only architecture with enough callee-saved registers
+                test x$STACK_CACHE_REGS = x && STACK_CACHE_REGS=3
+                #or use 2, hardly slower at run-time and starts up faster
+		;;
+	*)
+		AC_MSG_WARN([Using a generic machine description])
+		AC_MSG_WARN([Assuming C floats and doubles are IEEE floats and doubles (for SF@ DF@ SF! DF!)])
+		AC_MSG_WARN([FLUSH-ICACHE will do nothing, so END-CODE may not work properly!])
+		machine=generic
+		#I-cache flushing would be needed for dynamic code generation
+		if test -z $no_dynamic_default; then
+		    no_dynamic_default=1
+		    AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])
+		fi
+esac
+AC_SUBST(host)
+
+MAKEINC=""
+
+echo "Check for arch/$machine/$platform/gforth.ld ($EC_MODE)"
+if test x$EC_MODE = xtrue
+then
+	echo "Check for arch/$machine/$platform/gforth.ld"
+	if test -f arch/$machine/$platform/gforth.ld
+	then
+		LDFLAGS="-T ../arch/$machine/$platform/gforth.ld -Map \$@.map -cref --gc-sections $LDFLAGS"
+		if test x$platform = xnxt; then
+			LIBS="$LIB_PATH/lib/gcc/arm-elf/$($CC --version | grep GCC | cut -d' ' -f3)/interwork/libgcc.a $LIB_PATH/arm-elf/lib/interwork/libc.a $LIBS"
+		fi
+	fi
+	if test -f arch/$machine/$platform/make.inc
+	then
+		MAKEINC="include ../arch/$machine/$platform/make.inc"
+	fi
+fi
+AC_SUBST(MAKEINC)
+
+AC_ARG_VAR(STACK_CACHE_REGS, [number of registers in the maximum stack cache state for gforth-fast and gforth-native (default platform-dependent).])
+
+test x$STACK_CACHE_REGS = x && STACK_CACHE_REGS=1
+AC_DEFINE_UNQUOTED(STACK_CACHE_REGS, $STACK_CACHE_REGS,
+		   [number of registers in the maximum stack cache state for gforth-fast and gforth-native])
+test x$STACK_CACHE_DEFAULT_FAST = x && STACK_CACHE_DEFAULT_FAST=1
+AC_DEFINE_UNQUOTED(STACK_CACHE_DEFAULT_FAST, $STACK_CACHE_DEFAULT_FAST,
+		   [number of registers in the default stack cache state for gforth-fast and gforth-native])
+
+test x$GCC_PR15242_WORKAROUND = x ||
+AC_DEFINE_UNQUOTED(GCC_PR15242_WORKAROUND, $GCC_PR15242_WORKAROUND,
+                   [force (1) or forbid (0) use of a workaround for a gcc performance bug])
 
 dnl the following macro produces a warning with autoconf-2.1
 AC_CHECK_SIZEOF(char *)
@@ -81,18 +369,39 @@ case "$ac_cv_sizeof_char_p" in
     ;;
 esac
 
+AC_CHECK_SIZEOF(void *)
+case "$ac_cv_sizeof_void_p" in
+  2)
+    vwordsize=16
+    ;;
+  4)
+    vwordsize=32
+    ;;
+  8)
+    vwordsize=64
+    ;;
+esac
+
+AC_CHECK_SIZEOF(char)
 AC_CHECK_SIZEOF(short)
 AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)
 AC_CHECK_SIZEOF(long long)
+AC_CHECK_SIZEOF(intptr_t)
+AC_CHECK_SIZEOF(int128_t)
+AC_CHECK_SIZEOF(uint128_t)
 
+AC_MSG_CHECKING([for a C type for cells])
 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_int)
-    ac_cv_int_type_cell=int
+  $ac_cv_sizeof_char)
+    ac_cv_int_type_cell=char
     ;;
   $ac_cv_sizeof_long)
     ac_cv_int_type_cell=long
@@ -100,14 +409,64 @@ case "$ac_cv_sizeof_char_p" in
   $ac_cv_sizeof_long_long)
     ac_cv_int_type_cell="long long"
     ;;
+  $ac_cv_sizeof_intptr_t)
+    ac_cv_int_type_cell="intptr_t"
+    ;;
 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_MSG_RESULT($ac_cv_int_type_cell)
+AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer])
 
+AC_MSG_CHECKING([for a C type for wydes])
+ac_cv_wyde_type_cell=none
+case 2 in
+  $ac_cv_sizeof_int)
+    ac_cv_wyde_type_cell=int
+    ;;
+  $ac_cv_sizeof_short)
+    ac_cv_wyde_type_cell=short
+    ;;
+  $ac_cv_sizeof_char)
+    ac_cv_wyde_type_cell=char
+    ;;
+  $ac_cv_sizeof_long)
+    ac_cv_wyde_type_cell=long
+    ;;
+  $ac_cv_sizeof_long_long)
+    ac_cv_wyde_type_cell="long long"
+    ;;
+  $ac_cv_sizeof_intptr_t)
+    ac_cv_wyde_type_cell="intptr_t"
+    ;;
+esac
+AC_MSG_RESULT($ac_cv_wyde_type_cell)
+AC_DEFINE_UNQUOTED(WYDE_TYPE,$ac_cv_wyde_type_cell,[an integer type that is 2 bytes long])
+
+AC_MSG_CHECKING([for a C type for tetrabytes])
+ac_cv_tetrabyte_type_cell=none
+case 4 in
+  $ac_cv_sizeof_int)
+    ac_cv_tetrabyte_type_cell=int
+    ;;
+  $ac_cv_sizeof_short)
+    ac_cv_tetrabyte_type_cell=short
+    ;;
+  $ac_cv_sizeof_char)
+    ac_cv_tetrabyte_type_cell=char
+    ;;
+  $ac_cv_sizeof_long)
+    ac_cv_tetrabyte_type_cell=long
+    ;;
+  $ac_cv_sizeof_long_long)
+    ac_cv_tetrabyte_type_cell="long long"
+    ;;
+  $ac_cv_sizeof_intptr_t)
+    ac_cv_tetrabyte_type_cell="intptr_t"
+    ;;
+esac
+AC_MSG_RESULT($ac_cv_tetrabyte_type_cell)
+AC_DEFINE_UNQUOTED(TETRABYTE_TYPE,$ac_cv_tetrabyte_type_cell,[an integer type that is 4 bytes long])
+
+AC_MSG_CHECKING([for a C type for double-cells])
 ac_cv_int_type_double_cell=none
 case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
   $ac_cv_sizeof_short)
@@ -122,107 +481,233 @@ case `expr 2 '*' "$ac_cv_sizeof_char_p"`
   $ac_cv_sizeof_long_long)
     ac_cv_int_type_double_cell="long long"
     ;;
+  $ac_cv_sizeof_intptr_t)
+    ac_cv_int_type_double_cell="intptr_t"
+    ;;
+  $ac_cv_sizeof_int128_t)
+    ac_cv_int_type_double_cell="int128_t"
+    ;;
+esac
+AC_MSG_RESULT($ac_cv_int_type_double_cell)
+
+AC_MSG_CHECKING([for a C type for unsigned double-cells])
+ac_cv_int_type_double_ucell=none
+case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
+  $ac_cv_sizeof_short)
+    ac_cv_int_type_double_ucell="unsigned short"
+    ;;
+  $ac_cv_sizeof_int)
+    ac_cv_int_type_double_ucell="unsigned int"
+    ;;
+  $ac_cv_sizeof_long)
+    ac_cv_int_type_double_ucell="unsigned long"
+    ;;
+  $ac_cv_sizeof_long_long)
+    ac_cv_int_type_double_ucell="unsigned long long"
+    ;;
+  $ac_cv_sizeof_intptr_t)
+    ac_cv_int_type_double_ucell="unsigned intptr_t"
+    ;;
+  $ac_cv_sizeof_uint128_t)
+    ac_cv_int_type_double_ucell="uint128_t"
+    ;;
 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\'\")."
-	LIBOBJS="$LIBOBJS dblsub.o"
-	AC_DEFINE(BUGGY_LONG_LONG)
+AC_MSG_RESULT($ac_cv_int_type_double_ucell)
+
+if test "$ac_cv_int_type_double_cell" != none && \
+   test "$ac_cv_int_type_double_ucell" != none
+then
+	AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell,[an integer type that is twice as long as a pointer])
+	AC_DEFINE_UNQUOTED(DOUBLE_UCELL_TYPE,$ac_cv_int_type_double_ucell,[an unsigned integer type that is twice as long as a pointer])
+        OPTS=-ll
 else
-  AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell)
+        if test "$ac_cv_sizeof_char_p" = 8; then
+           OPTS="-ll -noll"
+        else
+           OPTS=-noll
+        fi
 fi
 
-#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*)
-		mach_h=hppa
-		LIBOBJS="cache.o"
-		LDFLAGS="-Xlinker -N"
-		LIBS="-L/lib/pa1.1/"
-		if test "${enable_direct_threaded+set}" = ""
-		then
-			AC_DEFINE(DIRECT_THREADED)
-		fi
-		;;
-	sparc*)
-		mach_h=sparc
-		;;
-	i386)
-		mach_h=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
-		if test "${enable_direct_threaded+set}" = "" \
-			-a "${enable_indirect_threaded+set}" = ""
-		then
-			echo "Using direct threaded on 386er"
-			AC_DEFINE(DIRECT_THREADED)
-		fi
-		;;
-	i486)
-		mach_h=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"
-		if test "${enable_direct_threaded+set}" = "" \
-			-a "${enable_indirect_threaded+set}" = ""
-		then
-			echo "Using direct threaded on 486er"
-			AC_DEFINE(DIRECT_THREADED)
-		fi
-		;;
-	i586|i686)
-		mach_h=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"
-		if test "${enable_direct_threaded+set}" = "" \
-			-a "${enable_indirect_threaded+set}" = ""
-		then
-			echo "Using indirect threaded on Pentium and up"
-			AC_DEFINE(INDIRECT_THREADED)
-		fi
-		;;
-        m68k)
-		mach_h=m68k
-		CFLAGS="$CFLAGS -fomit-frame-pointer"
-		if test "$host_os" = "nextstep3"
-		then
-			LIBOBJS="$LIBOBJS termios.o"
-		fi
-		;;
-	mips*)
-		mach_h=mips
-		#link text and data segment into the same 256M region!
-		GCCLDFLAGS="-Xlinker -T -Xlinker 10000000 -Xlinker -D -Xlinker 10400000"
-		;;
-	alpha*)
-		mach_h=alpha
+if grep FORCE_REG arch/$machine/machine.h >/dev/null; then
+   OPTS2=''
+   for i in $OPTS; do OPTS2="$OPTS2 $i-reg"; done
+   OPTS="$OPTS2 $OPTS"
+else
+  AC_DEFINE_UNQUOTED(FORCE_REG_UNNECESSARY,,[defined if the platform does not need FORCE_REG])
+fi
+AC_SUBST(OPTS)
+
+AC_TYPE_OFF_T
+AC_CHECK_SIZEOF(off_t)
+test $ac_cv_sizeof_off_t -gt $ac_cv_sizeof_char_p
+ac_small_off_t=$?
+AC_DEFINE_UNQUOTED(SMALL_OFF_T,$ac_small_off_t,[1 if off_t fits in a Cell])
+
+ENGINE_FLAGS=
+AC_SUBST(ENGINE_FLAGS)
+
+# Try if GCC understands -fno-gcse
+
+AC_MSG_CHECKING([if $CC understands -fno-gcse])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -fno-gcse"
+AC_TRY_COMPILE(,,ac_nogcse=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-gcse",ac_nogcse=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_nogcse)
+
+# Try if GCC understands -fno-strict-aliasing
+AC_MSG_CHECKING([if $CC understands -fno-strict-aliasing])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -fno-strict-aliasing"
+AC_TRY_COMPILE(,,ac_nostrictaliasing=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-strict-aliasing",ac_nostrictaliasing=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_nostrictaliasing)
+
+# Try if GCC understands -fno-crossjumping
+AC_MSG_CHECKING([if $CC understands -fno-crossjumping])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -fno-crossjumping"
+AC_TRY_COMPILE(,,ac_nocrossjumping=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-crossjumping",ac_nocrossjumping=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_nocrossjumping)
+
+# Try if GCC understands -fno-reorder-blocks
+AC_MSG_CHECKING([if $CC understands -fno-reorder-blocks])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -fno-reorder-blocks"
+AC_TRY_COMPILE(,,ac_noreorder_blocks=yes;ENGINE_FLAGS="$ENGINE_FLAGS -fno-reorder-blocks",ac_noreorder_blocks=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_noreorder_blocks)
+
+# Try if GCC understands -falign-labels=1
+AC_MSG_CHECKING([if $CC understands -falign-labels=1])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -falign-labels=1"
+AC_TRY_COMPILE(,,ac_align_labels=yes;ENGINE_FLAGS="$ENGINE_FLAGS -falign-labels=1",ac_align_labels=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_align_labels)
+
+# Try if GCC understands -falign-loops=1
+AC_MSG_CHECKING([if $CC understands -falign-loops=1])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -falign-loops=1"
+AC_TRY_COMPILE(,,ac_align_loops=yes;ENGINE_FLAGS="$ENGINE_FLAGS -falign-loops=1",ac_align_loops=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_align_loops)
+
+# Try if GCC understands -falign-jumps=1
+AC_MSG_CHECKING([if $CC understands -falign-jumps=1])
+CFLAGS_1="$CFLAGS"
+CFLAGS="$CFLAGS -falign-jumps=1"
+AC_TRY_COMPILE(,,ac_align_jumps=yes;ENGINE_FLAGS="$ENGINE_FLAGS -falign-jumps=1",ac_align_jumps=no)
+CFLAGS="$CFLAGS_1"
+AC_MSG_RESULT($ac_align_jumps)
+
+# Try if GCC understands __attribute__((unused))
+AC_MSG_CHECKING([how to suppress 'unused variable' warnings])
+AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',)
+AC_DEFINE_UNQUOTED(MAYBE_UNUSED,$MAYBE_UNUSED,[attribute for possibly unused variables])
+AC_MSG_RESULT($MAYBE_UNUSED)
+
+#try if m4 understands -s
+AC_MSG_CHECKING([how to invoke m4])
+if m4 -s /dev/null >/dev/null 2>&1; then
+ M4="m4 -s"
+else
+ M4=m4
+fi
+AC_SUBST(M4)
+AC_MSG_RESULT($M4)
+
+# Find installed Gforth
+AC_MSG_CHECKING([for gforth])
+GFORTH="`cd / && which gforth 2>/dev/null`"
+(cd / && $GFORTH -e bye >/dev/null 2>/dev/null) || GFORTH=""
+if test -z "$GFORTH"; then
+  PREFORTH='echo "You need to configure with a gforth in \$PATH to build this part" && false'
+  kernel_anti_dependence=''
+else
+  PREFORTH="$GFORTH -i `cd / && $GFORTH --debug -e bye 2>&1 |grep "Opened image file: "|sed 's/Opened image file: //'`" ;
+  kernel_anti_dependence='$(kernel_fi)'
+fi
+AC_SUBST(PREFORTH)
+AC_SUBST(kernel_anti_dependence)
+AC_MSG_RESULT($PREFORTH)
+
+#echo "machine='$machine'"
+
+dnl AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
+AC_CHECK_FILE($srcdir/arch/$machine/asm.fs,[asm_fs=arch/$machine/asm.fs],)
+AC_SUBST(asm_fs)
+
+dnl AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)
+AC_CHECK_FILE($srcdir/arch/$machine/disasm.fs,[disasm_fs=arch/$machine/disasm.fs],)
+AC_SUBST(disasm_fs)
+
+AC_PATH_PROG(INSTALL_INFO,install-info,[echo '>>>>Please make info dir entry:'],$PATH:/sbin:/usr/sbin:/usr/local/sbin)
+
+case "$host_os" in
+	*win32*)
+		# !!!FIXME!!! problems with cygwin and ';' as path separator
+		DIRSEP="\\\\"
+		PATHSEP=";"
+		#we want the builtins of command.com/cmd.exe and its
+		# handling of .com files.
+		#$COMSPEC contains the name of the Windows shell;
+		# the ./ is there, because the bash does not recognize
+		# absolute DOS filenames
+		DEFAULTSYSTEMPREFIX="./$COMSPEC /c "
 		;;
-	power*)
-		mach_h=power
+	*darwin*)
+		#Darwin uses some funny preprocessor by default; eliminate it:
+		AC_MSG_NOTICE([using -no-cpp-precomp on Darwin])
+		CFLAGS="$CFLAGS -no-cpp-precomp"
+		DIRSEP="/"
+		PATHSEP=":"
+		DEFAULTSYSTEMPREFIX=""
+                #the following magic value was suggested by
+                #http://mail.python.org/pipermail/pythonmac-sig/2005-October/015190.html
+                AC_DEFINE_UNQUOTED(MACOSX_DEPLOYMENT_TARGET,"10.3",[an environment variable value needed by libtool on some MacOS X versions])
 		;;
 	*)
-		echo "No direct threading support for $host_cpu, using indirect threading."
-		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!"
-		mach_h=32bit
+		DIRSEP="/"
+		PATHSEP=":"
+		DEFAULTSYSTEMPREFIX=""
+		;;
 esac
-AC_SUBST(host)
-AC_SUBST(ENGINE_FLAGS)
+AC_SUBST(DIRSEP)
+AC_DEFINE_UNQUOTED(DIRSEP,'$DIRSEP',[a directory separator character])
+AC_SUBST(PATHSEP)
+AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character])
+AC_SUBST(DEFAULTSYSTEMPREFIX)
+AC_DEFINE_UNQUOTED(DEFAULTSYSTEMPREFIX,"$DEFAULTSYSTEMPREFIX",[default for environment variable GFORTHSYSTEMPREFIX])
+
+#work around SELinux brain damage (from Andrew Haley <12t8f3jakb74g2c@news.supernews.com>)
+#This magic incantation  seems to be completely undocumented.
+AC_CHECK_PROG([MASSAGE_EXE],[chcon],[chcon -t unconfined_execmem_exec_t],[true])
 
 dnl Now a little support for DOS/DJGCC
 AC_SUBST(GFORTH_EXE)
-GFORTH_EXE=""
+GFORTH_EXE="true"
+AC_SUBST(GFORTHFAST_EXE)
+GFORTHFAST_EXE="true"
+AC_SUBST(GFORTHITC_EXE)
+GFORTHITC_EXE="true"
 AC_SUBST(GFORTHDITC_EXE)
-GFORTHDITC_EXE=""
-
-PATHSEP=":"
-AC_SUBST(PATHSEP)
-AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP')
+GFORTHDITC_EXE="true"
 
 AC_SUBST(FORTHSIZES)
 
+dnl if test "$PEEPHOLE" = "yes"
+dnl then
+dnl    PEEPHOLEFLAG="true"
+dnl    AC_DEFINE(HAS_PEEPHOLE,,[Define if you want to use peephole optimization])
+dnl else
+dnl    PEEPHOLEFLAG="false"
+dnl fi
+PEEPHOLEFLAG="true"
+AC_SUBST(PEEPHOLEFLAG)
+
 dnl copy commands for systems that don't have links
 AC_SUBST(LINK_KERNL)
 LINK_KERNL=""
@@ -246,38 +731,169 @@ else
   KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi"
 fi
 
+#check how to do asm(".skip 16")
+#echo "CFLAGS=$CFLAGS"
+#echo "ac_link=$ac_link"
+AC_MSG_CHECKING([if and how we can waste code space])
+if test -z "$skipcode"; then
+    skipcode=no
+    CFLAGS_1="$CFLAGS"
+    CFLAGS="$CFLAGS $ENGINE_FLAGS"
+    for i in ".skip 16" ".block 16" ".org .+16" ".=.+16" ".space 16"
+    do
+	AC_TRY_RUN(
+[int foo(int,int,int);
+main()
+{
+  exit(foo(0,0,0)!=16);
+}
+int foo(int x, int y, int z)
+{
+  static void *labels[]={&&label1, &&label2};
+  if (x) {
+    y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */
+  label1:
+    asm("$i"); /* or ".space 16" or somesuch */
+  label2: ;
+  }
+  {
+  if (y) goto *labels[z]; /* workaround for gcc PR12108 */
+  return labels[1]-labels[0];
+  }
+}]
+	,skipcode=$i; break
+	,,)
+    done
+    CFLAGS=$CFLAGS_1
+fi
+AC_MSG_RESULT($skipcode)
+if test "$skipcode" = no
+then 
+    if test -z $no_dynamic_default; then
+	no_dynamic_default=1
+	AC_MSG_WARN(Disabling default dynamic native code generation)
+    fi
+    AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes)
+else
+    AC_DEFINE_UNQUOTED(SKIP16,asm("$skipcode"),statement for skipping 16 bytes)
+fi
+
+AC_MSG_CHECKING([if and how we can do comments in asm statements])
+#the point here is to get asm statements that look different to
+#gcc's "optimizer"
+if test -z "$asmcomment"; then
+    asmcomment=no
+    CFLAGS_1="$CFLAGS"
+    CFLAGS="$CFLAGS $ENGINE_FLAGS"
+    for i in '"# "' '"! "' '"; "'; do
+	AC_TRY_COMPILE(,[asm($i"fluffystunk");],asmcomment=$i; break,)
+    done
+    CFLAGS=$CFLAGS_1
+fi
+AC_MSG_RESULT($asmcomment)
+if test "$asmcomment" != no
+then 
+    AC_DEFINE_UNQUOTED(ASMCOMMENT,$asmcomment,[assembler comment start string])
+fi
+
+test "$no_dynamic_default" || no_dynamic_default=0
+AC_DEFINE_UNQUOTED(NO_DYNAMIC_DEFAULT,$no_dynamic_default,default value for no_dynamic)
+
 dnl Checks for programs.
 AC_PROG_LN_S
 AC_PROG_INSTALL
+AC_CHECK_PROGS(TEXI2DVI,texi2dvi4a2ps texi2dvi)
+
+dnl MacOS X has a libtool that does something else
+AC_CHECK_PROGS(GNU_LIBTOOL,glibtool libtool)
 
 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_FUNCS(dlopen)
-AC_CHECK_LIB(dl,dlopen)
-AC_CHECK_LIB(kernel32,GetModuleHandle)
+AC_CHECK_LIB(ltdl,lt_dlinit)
+#check for libffi 2.x
+AC_CHECK_HEADER(ffi.h,FFI_H_NAME=ffi.h,)
+if test -z "$FFI_H_NAME"; then
+  AC_CHECK_HEADER(ffi/ffi.h,FFI_H_NAME=ffi/ffi.h,)
+fi
+AC_SUBST(FFI_H_NAME)
+AC_CHECK_LIB(ffi,ffi_call)
+if test -n "$FFI_H_NAME" -a $ac_cv_lib_ffi_ffi_call = yes
+then
+  LIBFFIFLAG="true"
+  LIBCC_BUILD_SRC="$LIBCC_BUILD_SRC libffi.fs"
+else
+  LIBFFIFLAG="false"
+fi
+#check for ffcall libraries
+#unfortunately, these four calls are separated out into a library each.
+AC_CHECK_LIB(avcall,__builtin_avcall)
+dnl AC_CHECK_LIB(callback,__vacall_r)
+dnl AC_CHECK_LIB(vacall,vacall)
+dnl AC_CHECK_LIB(trampoline,alloc_trampoline)
+if test $ac_cv_lib_avcall___builtin_avcall = yes; then
+  FFCALLFLAG="true"
+  LIBCC_BUILD_SRC="$LIBCC_BUILD_SRC fflib.fs"
+else
+  FFCALLFLAG="false"
+fi
+if test $LIBFFIFLAG = false -a $FFCALLFLAG = false; then
+  AC_MSG_WARN([The (old) lib.fs foreign function interface needs either libffi or the ffcall libraries])
+fi
+AC_SUBST(LIBFFIFLAG)
+AC_SUBST(FFCALLFLAG)
+AC_SUBST(LIBCC_BUILD_SRC)
 if test "$host_os" != "nextstep3"
 then
 	AC_FUNC_MEMCMP
 fi
 AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh)
-AC_CHECK_FUNCS(sys_siglist)
+AC_FUNC_FSEEKO
+AC_CHECK_FUNCS(ftello dlopen sys_siglist getrusage nanosleep)
+AC_CHECK_TYPES(stack_t,,,[#include <signal.h>])
 AC_DECL_SYS_SIGLIST
-AC_CHECK_FUNC(getopt_long,getopt_long="",getopt_long="getopt.o getopt1.o")
-AC_SUBST(getopt_long)
-AC_CHECK_FUNCS(rint expm1 log1p)
-AC_REPLACE_FUNCS(ecvt)
+AC_CHECK_FUNC(getopt_long,[true],[AC_LIBOBJ(getopt) AC_LIBOBJ(getopt1)])
+AC_CHECK_FUNCS(expm1 log1p)
+AC_REPLACE_FUNCS(rint ecvt)
 dnl No check for select, because our replacement is no good under
 dnl anything but DOS
-AC_CHECK_HEADERS(sys/mman.h)
+AC_CHECK_HEADERS(sys/mman.h fnmatch.h alloca.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
+kernel_fi=kernl${vwordsize}${bytesex}.fi
+include_fi=kernl${wordsize}${bytesex}${EC}.fi
 AC_SUBST(kernel_fi)
+AC_SUBST(include_fi)
+
+#this breaks bindists
+#dnl replace srource directory by absolute value
+#if test $srcdir = "."; then srcdir=`pwd` 
+#fi
 
-AC_LINK_FILES(arch/${mach_h} $kernel_fi,machine kernel.fi)
-AC_OUTPUT([
+AC_SUBST(machine)
+AC_CONFIG_FILES([
 Makefile
-engine/Makefile ],echo timestamp > stamp-h)
+Makedist
+gforthmi
+vmgen
+machpc.fs
+envos.fs
+preforth
+engine/Makefile
+engine/libcc.h
+doc/version.texi
+build-ec ])
+AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h
+chmod +x gforthmi
+chmod +x vmgen
+chmod +x build-ec
+chmod +x preforth
+test -d kernel||mkdir kernel
+$srcdir/mkinstalldirs include/gforth/$PACKAGE_VERSION
+ln -sf ../../../engine/config.h ../../../engine/libcc.h include/gforth/$PACKAGE_VERSION]],[[PACKAGE_VERSION=$PACKAGE_VERSION]])
+AC_OUTPUT