--- gforth/configure.in	2003/09/08 10:14:19	1.134
+++ gforth/configure.in	2007/06/02 14:25:26	1.187
@@ -1,6 +1,6 @@
 dnl Process this file with autoconf to produce a configure script.
 
-#Copyright (C) 1995,1996,1997,1998,2000,2003 Free Software Foundation, Inc.
+#Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006 Free Software Foundation, Inc.
 
 #This file is part of Gforth.
 
@@ -21,27 +21,56 @@ dnl Process this file with autoconf to p
 
 dnl We use some automake macros here,
 dnl but don't use automake for creating Makefile.in
-AC_INIT([gforth],[0.6.2],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])
+AC_INIT([gforth],[0.6.9-20070602],[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="August 25, 2003"
+UPDATED="June 02, 2007"
 AC_SUBST(UPDATED)
 AC_CONFIG_HEADERS(engine/config.h)
 
 #suppress the "-g -O2" default
 test "$CFLAGS" || CFLAGS=-O2
 
-#default setting that may be changed later:
-test "$no_dynamic_default" || no_dynamic_default=0
-
 AC_ARG_ENABLE(force-reg,
-[  --enable-force-reg	  Use explicit register declarations if they appear in
+	AC_HELP_STRING([--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).]),
+	,enable_force_reg=no)
+test "$enable_force_reg" = "no"||
+  AC_DEFINE(FORCE_REG,,[Define if you want to use explicit register declarations for better performance or for more convenient CODE words (does not work with all GCC versions on all machines)])
+
+AC_ARG_ENABLE(force-ll,
+	AC_HELP_STRING([--enable-force-ll],
+		       [  Use explicit long long 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,,[Define if you want to use explicit register declarations for better performance or for more convenient CODE words (does not work with all GCC versions on all machines)]))
+			  some processors (default disabled).]),
+	,enable_force_ll=no)
+test "$enable_force_ll" = "no"||
+  AC_DEFINE(FORCE_LL,,[Define if you want to use explicit long long declarations for better performance (does not work with all GCC versions on all machines)])
+
+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\$(EXE)"; PROFOBJS="engine-prof.o main-prof.o profile.o"
+fi
 
 AC_ARG_WITH(debug,
 [  --with-debug		  specifies option -g to compile with debug info
@@ -57,10 +86,48 @@ dnl   --without-peephole	disables peepho
 dnl 			but slower images.],
 dnl PEEPHOLE="$withval")
 
+GCC_LD="\$(GCC)"
+EC_MODE="false"
+EC=""
+engine2="engine2.o"
+engine_fast2="engine-fast2.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); gcc-2.95 recommended.])
 AC_ARG_VAR(FORTHSIZES, [Gforth command line options for the default stack and dictionary sizes (see INSTALL).])
+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(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)])
@@ -68,8 +135,12 @@ AC_ARG_VAR(ac_cv_sizeof_long, [sizeof(lo
 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_sizeof_int128_t, [sizeof(int128_t)])
+AC_ARG_VAR(ac_cv_sizeof_uint128_t, [sizeof(uint128_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(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
@@ -95,28 +166,26 @@ AC_PROG_CC
 test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher)
 
 AC_SUBST(CC)
+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 -v 2>&1|grep 'ake version'|sed 's/ version .*//'`
-
+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)
 
-dnl gcc-3.2 seems to work fine now
-dnl AC_MSG_CHECKING(gcc version)
-dnl gcc_version=`$CC -v 2>&1|grep 'gcc version'|sed 's/.*gcc version //'`
-dnl AC_MSG_RESULT($gcc_version)
-dnl if expr "$gcc_version" \> 3.0.4 >/dev/null && expr "$gcc_version" \< 3.2.1 >/dev/null
-dnl then
-dnl    no_dynamic_default=1
-dnl    AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))
-dnl fi
-
 AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
 OLDLDFLAGS=$LDFLAGS
 LDFLAGS="$LDFLAGS -export-dynamic"
@@ -130,6 +199,23 @@ AC_MSG_RESULT($ac_export_dynamic)
 #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
+		    no_dynamic_default=1
+                    arm_cacheflush=arch/arm/cacheflush0
+		    AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])
+		fi
+                AC_LIBSOURCES([../arch/arm/cacheflush0, ../arch/arm/cacheflush1, ../arch/arm/cacheflush2])
+                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
@@ -159,10 +245,13 @@ case "$host_cpu" in
 	x86_64)
 		machine=amd64
 		;;
-#generic should work for IA64
-#	ia64*)
-#		machine=ia64
-#		;;
+	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"
@@ -186,8 +275,10 @@ case "$host_cpu" in
 		#particular, the delay slots of LW, MFLO, etc.)
 		#
 		#Therefore we disable dynamic native code by default:
-		no_dynamic_default=1
-		AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))
+		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
@@ -197,9 +288,11 @@ case "$host_cpu" in
 	power*|rs6000)
 		machine=power
 		$srcdir/mkinstalldirs arch/power
-		AC_CHECK_FUNC(_sync_cache_range,true,AC_LIBOBJ(../arch/power/_sync_cache_range))
+		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 && ac_cv_sizeof_long_long=0
+		test x$ac_cv_sizeof_long_long = x && 
+		($CC -v 2>&1 |grep -q 'gcc version 2.95') &&
+		ac_cv_sizeof_long_long=0
 		;;
 	*)
 		AC_MSG_WARN([Using a generic machine description])
@@ -207,11 +300,50 @@ case "$host_cpu" in
 		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
-		no_dynamic_default=1
-		AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))
+		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)
+
+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 AC_DEFINE(GCC_PR15242_WORKAROUND,,[Define if you want to get dynamic code
+dnl generation on gccs affected by PR15242])
+
+
+if test "${enable_force_ll+set}" = set; then
+   ac_includes_default="$ac_includes_default
+#include \"arch/generic/128bit.h\""
+fi
+
 dnl the following macro produces a warning with autoconf-2.1
 AC_CHECK_SIZEOF(char *)
 case "$ac_cv_sizeof_char_p" in
@@ -226,6 +358,19 @@ 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)
@@ -233,6 +378,7 @@ 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
@@ -262,6 +408,62 @@ esac
 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"
+    ;;
+  $ac_cv_sizeof_int128_t)
+    ac_cv_wyde_type_cell="int128_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"
+    ;;
+  $ac_cv_sizeof_int128_t)
+    ac_cv_tetrabyte_type_cell="int128_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
@@ -285,12 +487,40 @@ case `expr 2 '*' "$ac_cv_sizeof_char_p"`
     ;;
 esac
 AC_MSG_RESULT($ac_cv_int_type_double_cell)
-if test "$ac_cv_int_type_double_cell" = none; then
+
+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
+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_MSG_WARN([Emulating double-cell arithmetic. This may be slow.])
 	AC_LIBOBJ(dblsub)
 	AC_DEFINE(BUGGY_LONG_LONG,,[define this if there is no working DOUBLE_CELL_TYPE on your machine])
 else
 	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])
 fi
 
 AC_TYPE_OFF_T
@@ -327,6 +557,14 @@ AC_TRY_COMPILE(,,ac_nocrossjumping=yes;E
 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 __attribute__((unused))
 AC_MSG_CHECKING([how to suppress 'unused variable' warnings])
 AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',)
@@ -342,9 +580,16 @@ 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|cygwin)
+	*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 "
 		;;
 	*darwin*)
 		#Darwin uses some funny preprocessor by default; eliminate it:
@@ -352,17 +597,24 @@ case "$host_os" in
 		CFLAGS="$CFLAGS -no-cpp-precomp"
 		DIRSEP="/"
 		PATHSEP=":"
+		DEFAULTSYSTEMPREFIX=""
 		;;
 	*)
 		DIRSEP="/"
 		PATHSEP=":"
+		DEFAULTSYSTEMPREFIX=""
 		;;
 esac
 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)
@@ -410,59 +662,105 @@ else
 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])
-skipcode=no
-for i in ".skip 16" ".block 16" ".org .+16" ".=.+16" ".space 16"
-do
+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 foo(int,int,int);
 main()
 {
-  exit(foo(0)!=16);
+  exit(foo(0,0,0)!=16);
 }
-int foo(int x)
+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");
-  label2:
+    asm("$i"); /* or ".space 16" or somesuch */
+  label2: ;
   }
-  return (&&label2)-(&&label1);
-}
+  {
+  if (y) goto *labels[z]; /* workaround for gcc PR12108 */
+  return labels[1]-labels[0];
+  }
+}]
 	,skipcode=$i; break
 	,,)
-done	
+    done
+    CFLAGS=$CFLAGS_1
+fi
 AC_MSG_RESULT($skipcode)
 if test "$skipcode" = no
 then 
-    no_dynamic_default=1
+    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)
-    AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))
 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 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)
+dnl check for libffi 2.x
+AC_CHECK_LIB(ffi,ffi_call)
+if test $ac_cv_lib_ffi_ffi_call = yes
+then
+LIBFFIFLAG="true"
+FFCALLFLAG="false"
+OLDCALLFLAG="false"
+AC_DEFINE(HAS_LIBFFI,,[define this if you want to use the ffcall interface with libffi 2.0])
+else
 dnl check for ffcall libraries
 dnl unfortunately, these four calls are separated out into a library each.
 AC_CHECK_LIB(avcall,__builtin_avcall)
 AC_CHECK_LIB(callback,__vacall_r)
 AC_CHECK_LIB(vacall,vacall)
 AC_CHECK_LIB(trampoline,alloc_trampoline)
+LIBFFIFLAG="false"
 FFCALLFLAG="false"
 OLDCALLFLAG="true"
 test $ac_cv_lib_avcall___builtin_avcall = yes && FFCALLFLAG="true" && OLDCALLFLAG="false" && AC_DEFINE(HAS_FFCALL,,[define this if you want to use the ffcall libraries])
 test $ac_cv_lib_avcall___builtin_avcall = no && AC_DEFINE(HAS_OLDCALL,,[define this if you want to use the old call libraries])
+fi
+AC_SUBST(LIBFFIFLAG)
 AC_SUBST(FFCALLFLAG)
 AC_SUBST(OLDCALLFLAG)
 if test "$host_os" != "nextstep3"
@@ -471,10 +769,10 @@ then
 fi
 AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh)
 AC_FUNC_FSEEKO
-AC_CHECK_FUNCS(ftello dlopen sys_siglist getrusage)
+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,true,AC_LIBOBJ(getopt); AC_LIBOBJ(getopt1))
+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
@@ -485,8 +783,10 @@ test $ac_cv_func_fnmatch_works = yes ||
 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
@@ -500,11 +800,14 @@ Makedist
 gforthmi
 vmgen
 machpc.fs
+envos.fs
 engine/Makefile
-doc/version.texi ])
+doc/version.texi
+build-ec ])
 AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h
 chmod +x gforthmi
 chmod +x vmgen
+chmod +x build-ec
 test -d kernel||mkdir kernel]],[[]])
 AC_OUTPUT