--- gforth/configure.in	2005/12/04 13:46:11	1.153
+++ gforth/configure.in	2008/01/08 19:55:55	1.207
@@ -1,12 +1,12 @@
 dnl Process this file with autoconf to produce a configure script.
 
-#Copyright (C) 1995,1996,1997,1998,2000,2003,2004 Free Software Foundation, Inc.
+#Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006,2007 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,55 +15,23 @@ 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., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
+#along with this program. If not, see http://www.gnu.org/licenses/.
 
 
 dnl We use some automake macros here,
 dnl but don't use automake for creating Makefile.in
-AC_INIT([gforth],[0.6.2-20030910],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])
+AC_INIT([gforth],[0.6.9-20070604],[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="September 10, 2003"
+UPDATED="June 02, 2007"
 AC_SUBST(UPDATED)
 AC_CONFIG_HEADERS(engine/config.h)
 
 #suppress the "-g -O2" default
 test "$CFLAGS" || CFLAGS=-O2
 
-AC_ARG_ENABLE(force-reg,
-	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).]),
-	,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(gcc-pr15242-workaround,
-              AC_HELP_STRING([--disable-gcc-pr15242-workaround],[Disables
-                             dynamic code generation on some versions of gcc
-                             (slowdown~2 on Athlon) and causes slower building
-                             of gforth (but gforth speedups) on others.
-                             (default enabled)]),
-		,enable_gcc_pr15242_workaround=yes)
-test "$enable_gcc_pr15242_workaround" = "no"||
-AC_DEFINE(GCC_PR15242_WORKAROUND,,[Define if you want to get dynamic code
-generation on gccs affected by PR15242])
-
 AC_ARG_ENABLE(force-cdiv,
 	AC_HELP_STRING([--enable-force-cdiv],
 		       [  Use the native C division - symmetric - instead of
@@ -79,8 +47,8 @@ AC_ARG_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"
+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,
@@ -90,29 +58,61 @@ AC_ARG_WITH(debug,
 			  debugging informations.],
 if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)
 
-dnl PEEPHOLE="yes"
-dnl AC_ARG_WITH(peephole,
-dnl [  --with-peephole	Enable peephole optimization (default)
-dnl   --without-peephole	disables peephole optimization. Creates smaller,
-dnl 			but slower images.],
-dnl PEEPHOLE="$withval")
+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); gcc-2.95 recommended.])
+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(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_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(skip_code, [assembly code for skipping 16 bytes of code])
+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
@@ -137,17 +137,35 @@ AC_PROG_CC
 
 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 -q 'gcc version 3'); then
+   condbranch_opt=0
+else
+   condbranch_opt=1
+fi
+AC_MSG_RESULT($condbranch_opt)
+AC_SUBST(condbranch_opt)
+
 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)
 
 AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
@@ -166,10 +184,19 @@ case "$host_cpu" in
 	arm*)
 		machine=arm
 		CFLAGS="$CFLAGS -fomit-frame-pointer"
-		if test -z $no_dynamic_default; then
+		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
@@ -184,21 +211,32 @@ case "$host_cpu" in
 		;;
 	i386)
 		machine=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
 		;;
 	i486)
 		machine=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -m486"
 		;;
 	i*86)
 		machine=386
-		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
+		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
 		CFLAGS_1="$CFLAGS"
 		CFLAGS="$CFLAGS -march=pentium"
 		AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
 		;;
 	x86_64)
-		machine=amd64
+		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
@@ -245,7 +283,12 @@ case "$host_cpu" in
 		$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 && 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
+                #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])
@@ -260,14 +303,38 @@ case "$host_cpu" in
 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])
 
-if test "${enable_force_ll+set}" = set; then
-   ac_includes_default="$ac_includes_default
-#include \"arch/generic/128bit.h\""
-fi
+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 *)
@@ -283,6 +350,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)
@@ -313,9 +393,6 @@ case "$ac_cv_sizeof_char_p" in
   $ac_cv_sizeof_intptr_t)
     ac_cv_int_type_cell="intptr_t"
     ;;
-  $ac_cv_sizeof_int128_t)
-    ac_cv_int_type_cell="int128_t"
-    ;;
 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])
@@ -341,9 +418,6 @@ case 2 in
   $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])
@@ -369,9 +443,6 @@ case 4 in
   $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])
@@ -424,16 +495,24 @@ case `expr 2 '*' "$ac_cv_sizeof_char_p"`
 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
+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])
+        OPTS=-ll
+else
+        if test "$ac_cv_sizeof_char_p" == 8; then
+           OPTS="-ll -no-ll"
+        else
+           OPTS=-noll
+        fi
+fi
+
+if grep -q FORCE_REG arch/$machine/machine.h; then
+   OPTS=`for i in $OPTS; do echo -n "$i-reg "; done`$OPTS
 fi
+AC_SUBST(OPTS)
 
 AC_TYPE_OFF_T
 AC_CHECK_SIZEOF(off_t)
@@ -477,22 +556,70 @@ AC_TRY_COMPILE(,,ac_noreorder_blocks=yes
 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)
 
-AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
+#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_DEFINE_UNQUOTED(M4,"$M4",[How to invoke m4])
+AC_MSG_RESULT($M4)
+
+# Find installed Gforth
+AC_MSG_CHECKING([for gforth])
+GFORTH="`which gforth 2>/dev/null`"
+if test ! -z "$GFORTH"; then  GFORTH="$GFORTH -m4M" ; fi
+AC_SUBST(GFORTH)
+AC_DEFINE_UNQUOTED(GFORTH,"$GFORTH",[How to invoke gforth])
+AC_MSG_RESULT($GFORTH)
+
+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)
 
-AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)
+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|cygwin)
+	*win32*)
+		# !!!FIXME!!! problems with cygwin and ';' as path separator
 		DIRSEP="\\\\"
 		PATHSEP=";"
 		#we want the builtins of command.com/cmd.exe and its
@@ -523,6 +650,10 @@ AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a
 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=""
@@ -569,8 +700,8 @@ else
 fi
 
 #check how to do asm(".skip 16")
-echo "CFLAGS=$CFLAGS"
-echo "ac_link=$ac_link"
+#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
@@ -615,17 +746,40 @@ 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_LIB(ltdl,lt_dlinit)
 AC_CHECK_LIB(dl,dlopen)
 dnl check for libffi 2.x
 AC_CHECK_LIB(ffi,ffi_call)
@@ -657,7 +811,7 @@ 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)])
@@ -671,8 +825,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
@@ -686,11 +842,17 @@ Makedist
 gforthmi
 vmgen
 machpc.fs
+envos.fs
 engine/Makefile
-doc/version.texi ])
+engine/libcc.h
+doc/version.texi
+build-ec ])
 AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h
 chmod +x gforthmi
 chmod +x vmgen
-test -d kernel||mkdir kernel]],[[]])
+chmod +x build-ec
+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