Diff for /gforth/configure.in between versions 1.66 and 1.320

version 1.66, 2000/07/15 19:58:47 version 1.320, 2012/10/21 21:55:19
Line 1 Line 1
 dnl Process this file with autoconf to produce a configure script.  dnl Process this file with autoconf to produce a configure script.
   
 #Copyright (C) 1995,1996,1997,1998 Free Software Foundation, Inc.  #Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006,2007,2008,2009,2010,2011 Free Software Foundation, Inc.
   
 #This file is part of Gforth.  #This file is part of Gforth.
   
 #Gforth is free software; you can redistribute it and/or  #Gforth is free software; you can redistribute it and/or
 #modify it under the terms of the GNU General Public License  #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.  #of the License, or (at your option) any later version.
   
 #This program is distributed in the hope that it will be useful,  #This program is distributed in the hope that it will be useful,
Line 15  dnl Process this file with autoconf to p Line 15  dnl Process this file with autoconf to p
 #GNU General Public License for more details.  #GNU General Public License for more details.
   
 #You should have received a copy of the GNU General Public License  #You should have received a copy of the GNU General Public License
 #along with this program; if not, write to the Free Software  #along with this program. If not, see http://www.gnu.org/licenses/.
 #Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
   
 AC_INIT(engine/engine.c)  
   
 dnl We use some automake macros here,  dnl We use some automake macros here,
 dnl but don't use automake for creating Makefile.in  dnl but don't use automake for creating Makefile.in
 AM_INIT_AUTOMAKE(gforth,0.4.9-20000715)  AC_INIT([gforth],[0.7.9-20121007],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])
   AC_PREREQ(2.54)
 #snapshots have numbers major.minor.release-YYYYMMDD  #snapshots have numbers major.minor.release-YYYYMMDD
 #note that lexicographic ordering bust be heeded.  #note that lexicographic ordering must be heeded.
 #I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1!  #I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1!
 AM_CONFIG_HEADER(engine/config.h)  UPDATED="October 7, 2012"
 #AM_CYGWIN32  AC_SUBST(UPDATED)
   AC_CONFIG_HEADERS(engine/config.h)
 AC_ARG_ENABLE(force-reg,  
 [  --enable-force-reg     Use explicit register declarations if they appear in  #remnants from having ltdl as convenience library
                           the machine.h file. This can cause a good speedup,  LTDLDEPS=""
                           but also incorrect code with some gcc versions on  LTDLINCL=""
                           some processors (default disabled).],  LIBLTDL=""
   LTDL_LDLIBS=""
 AC_DEFINE(FORCE_REG))  AC_SUBST(LTDLDEPS)
 dnl this is not quite according to the autoconf manual, it causes a replacement  AC_SUBST(LTDLINCL)
 AC_ARG_ENABLE(direct-threaded,  AC_SUBST(LIBLTDL)
 [  --enable-direct-threaded     Force direct threading. This may not work on  AC_SUBST(LTDL_LDLIBS)
                                 some machines and may cause slowdown on others.  
                                 (default processor-dependent)],  #suppress the "-g -O2" default
 AC_DEFINE(DIRECT_THREADED))  test "$CFLAGS" || CFLAGS=-O2
 AC_ARG_ENABLE(indirect-threaded,  
 [  --enable-indirect-threaded   Force indirect threading. This can cause a  AC_ARG_ENABLE(force-cdiv,
                                 slowdown on some machines.          AC_HELP_STRING([--enable-force-cdiv],
                                 (default processor-dependent)],                         [  Use the native C division - symmetric - instead of
 AC_DEFINE(INDIRECT_THREADED))                            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,  AC_ARG_WITH(debug,
 [  --with-debug     specifies option -g to compile with debug info (default)  [  --with-debug           specifies option -g to compile with debug info
   --without-debug  omits the -g switch and creates smaller images on    --without-debug         omits the -g switch and creates smaller images on
                    machines where "strip" has problems with gcc style                            machines where "strip" has problems with gcc style
                    debugging informations.],                            debugging informations.],
 if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)  if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)
   
 CFLAGS=$CFLAGS  GCC_LD="\$(GCC)"
   EC_MODE="false"
   NO_EC=""
   NO_CROSS=""
   EC=""
   engine2='engine2$(OPT).o'
   engine_fast2='engine-fast2$(OPT).o'
   no_dynamic=""
   image_i=""
   signals_o="io.o signals.o"
   
   AC_CANONICAL_HOST
   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"
     NO_EC="#"
     NO_CROSS="#"
     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
     if test -f "arch/$host_cpu/${withval}/config.sh"; then
       source "arch/$host_cpu/${withval}/config.sh"
     fi
     GCC_PATH=$(which $CC)
     LIB_PATH=${GCC_PATH%/*/*}
     GCC_LD="\$(LD)"
     platform=${withval}
   fi])
   
   AC_ARG_ENABLE(lib,
           AC_HELP_STRING([--enable-lib],
                          [  Compile Gforth as shared library (default disabled).]),
           ,enable_lib=no)
   if test "$enable_lib" != "no"; then
      AC_DEFINE(HAS_LIB,,[Define if you want to build as shared library])
      libengines=libgforths
      libinstall=libinstall
      LIB_VERSION=0:8:0
   fi
   AC_SUBST(libengines)
   AC_SUBST(libinstall)
   AC_SUBST(LIB_VERSION)
   
   AC_ARG_WITH(cross,
           AC_HELP_STRING([--with-cross=<arch>],
                           [  Build gforth using a cross compiler.]),
   [if test "$withval" = "no"; then
     echo "defining hosted system"
   else
     echo "defining cross compiled system (${withval})"
     if test -f "arch/$host_cpu/${withval}/config.sh"; then
       source "arch/$host_cpu/${withval}/config.sh"
     fi
     GCC_PATH=$(which $CC)
     LIB_PATH=${GCC_PATH%/*/*}
     platform=${withval}
     NO_EC=""
     NO_CROSS="#"
   fi])
   
   AC_ARG_WITH(arch,
           AC_HELP_STRING([--with-arch=<arch>],
                           [  Build gforth binaries with <arch> postfix]),
   [if test "$withval" = "no"; then
     ARCH=""
   else
     ARCH=-${withval}
   fi])
   AC_SUBST(ARCH)
   
   #variables mentioned in INSTALL
   AC_ARG_VAR(SH, [The shell])
   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_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(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)])
   AC_ARG_VAR(LTDL_LIBRARY_PATH, [additional directories for libltdl (for some 64-bit platforms)])
   
   #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  AC_PROG_CC
   
 if test "$GCC" = "yes"  test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher)
 then  
    echo "Fine, gcc is available"  test "x$SH" = "x" && SH="/bin/sh"
   
   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  else
    cat <<'EOF'     condbranch_opt=1
 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  fi
   AC_MSG_RESULT($condbranch_opt)
   AC_SUBST(condbranch_opt)
   AC_SUBST(host_cpu)
   
   AC_SUBST(SH)
 AC_SUBST(CC)  AC_SUBST(CC)
   AC_SUBST(GCC_LD)
 AC_SUBST(DEBUGFLAG)  AC_SUBST(DEBUGFLAG)
   AC_SUBST(EC)
   AC_SUBST(NO_EC)
   AC_SUBST(NO_CROSS)
   AC_SUBST(EC_MODE)
   AC_SUBST(engine2)
   AC_SUBST(engine_fast2)
   AC_SUBST(no_dynamic)
   AC_SUBST(image_i)
   AC_SUBST(signals_o)
   AC_SUBST(mi_prefix)
   
   #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)
   
   if test "$ac_export_dynamic" != yes; then
     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)
   else
     LDFLAGS="$LDFLAGS -export-dynamic"
   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'
   case "$host_cpu" in
           arm*)
                   machine=arm
                   CFLAGS="$CFLAGS -fomit-frame-pointer"
                   if test x$platform = xnxt; then
                      CFLAGS="$CFLAGS -mthumb -mthumb-interwork"
                   fi
                   case "$host_os" in
                        *android*)
                           CFLAGS="$CFLAGS -march=armv7-a -mfloat-abi=softfp -mfpu=vfp"
                           ;;
                   esac
                   if test -z $arm_cacheflush; then
                      case "$host_os" in
                        *linux*)
                           AC_LIBOBJ(../arch/arm/cacheflush-linux) 
                           ;;
                        *)   
                           no_dynamic_default=1
                           AC_LIBOBJ(../arch/arm/cacheflush0)
                           AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])
                           ;;
                      esac
                   else
                      AC_LIBOBJ(../$arm_cacheflush)
                      test $srcdir = . || AC_MSG_WARN([setting arm_cacheflush requires building in the source directory])
                   fi
                   #longer skipcodes lead to problems on ARM, and it uses
                   #only 4-byte alignment anyway
                   test "$skipcode" || skipcode="nop"
                   ;;
           hppa*)
                   machine=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"
                   CFLAGS_1="$CFLAGS"
                   CFLAGS="$CFLAGS -march=i486"
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1")
                   ;;
           i*86)
                   machine=386
                   CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
                   CFLAGS_1="$CFLAGS"
                   CFLAGS="$CFLAGS -march=pentium -mtune=generic"
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -march=pentium")
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1")
                   ;;
           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
                   AC_LIBOBJ(../arch/mips/check_prim) 
                   #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
                   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
   
                   #the skipcode that is normally selected below does not
                   #work with gcc-3.[34]
                   test "$skipcode" || skipcode="nop\nnop\nnop\nnop"
                   ;;
           *)
                   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=""
   GFORTH_EXE="true"
   
   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"
                   GFORTH_EXE="\$(MAKE) -f arch/$machine/$platform/make.inc \$@.exe"
           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  dnl the following macro produces a warning with autoconf-2.1
 AC_CHECK_SIZEOF(char *)  AC_CHECK_SIZEOF(char *)
Line 88  case "$ac_cv_sizeof_char_p" in Line 448  case "$ac_cv_sizeof_char_p" in
     ;;      ;;
 esac  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(char)
 AC_CHECK_SIZEOF(short)  AC_CHECK_SIZEOF(short)
 AC_CHECK_SIZEOF(int)  AC_CHECK_SIZEOF(int)
 AC_CHECK_SIZEOF(long)  AC_CHECK_SIZEOF(long)
 AC_CHECK_SIZEOF(long 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  ac_cv_int_type_cell=none
 case "$ac_cv_sizeof_char_p" in  case "$ac_cv_sizeof_char_p" in
   $ac_cv_sizeof_int)    $ac_cv_sizeof_int)
Line 111  case "$ac_cv_sizeof_char_p" in Line 488  case "$ac_cv_sizeof_char_p" in
   $ac_cv_sizeof_long_long)    $ac_cv_sizeof_long_long)
     ac_cv_int_type_cell="long long"      ac_cv_int_type_cell="long long"
     ;;      ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_int_type_cell="intptr_t"
       ;;
 esac  esac
 if test "$ac_cv_int_type_cell" != int; then  AC_MSG_RESULT($ac_cv_int_type_cell)
         echo "So, sizeof(pointer)!=sizeof(int); looks like a DOS C compiler to me."  AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer])
         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_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 octabytes])
   ac_cv_octabyte_type_cell=none
   case 8 in
     $ac_cv_sizeof_int)
       ac_cv_octabyte_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_octabyte_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_octabyte_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_octabyte_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_octabyte_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_octabyte_type_cell="intptr_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_octabyte_type_cell)
   AC_DEFINE_UNQUOTED(OCTABYTE_TYPE,$ac_cv_octabyte_type_cell,[an integer type that is 8 bytes long])
   
   AC_MSG_CHECKING([for a C type for double-cells])
 ac_cv_int_type_double_cell=none  ac_cv_int_type_double_cell=none
 case `expr 2 '*' "$ac_cv_sizeof_char_p"` in  case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
   $ac_cv_sizeof_short)    $ac_cv_sizeof_short)
Line 133  case `expr 2 '*' "$ac_cv_sizeof_char_p"` Line 585  case `expr 2 '*' "$ac_cv_sizeof_char_p"`
   $ac_cv_sizeof_long_long)    $ac_cv_sizeof_long_long)
     ac_cv_int_type_double_cell="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  esac
 if test "$ac_cv_int_type_double_cell" = none; then  AC_MSG_RESULT($ac_cv_int_type_double_cell)
         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)  
 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"  
 AC_TRY_LINK(,,ac_export_dynamic=yes,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  AC_MSG_CHECKING([for a C type for unsigned double-cells])
 #gforth will run; the system on which configure will run is the `build'  ac_cv_int_type_double_ucell=none
 AC_CANONICAL_HOST  case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
 case "$host_cpu" in    $ac_cv_sizeof_short)
         hppa*)      ac_cv_int_type_double_ucell="unsigned short"
                 machine=hppa      ;;
                 $srcdir/mkinstalldirs arch/hppa    $ac_cv_sizeof_int)
                 LIBOBJS="$LIBOBJS ../arch/hppa/cache.o"      ac_cv_int_type_double_ucell="unsigned int"
                 LDFLAGS="$LDFLAGS -Xlinker -N"      ;;
                 LIBS="$LIBS -L/lib/pa1.1/"    $ac_cv_sizeof_long)
                 if test "${enable_direct_threaded+set}" = ""      ac_cv_int_type_double_ucell="unsigned long"
                 then      ;;
                         AC_DEFINE(DIRECT_THREADED)    $ac_cv_sizeof_long_long)
                 fi      ac_cv_int_type_double_ucell="unsigned long long"
                 ;;      ;;
         sparc*)    $ac_cv_sizeof_intptr_t)
                 machine=sparc      ac_cv_int_type_double_ucell="unsigned intptr_t"
                 ;;      ;;
         i386)    $ac_cv_sizeof_uint128_t)
                 machine=386      ac_cv_int_type_double_ucell="uint128_t"
                 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 code on 386"  
                         AC_DEFINE(DIRECT_THREADED)  
                 fi  
                 ;;  
         i486)  
                 machine=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 code on 486"  
                         AC_DEFINE(DIRECT_THREADED)  
                 fi  
                 ;;  
         i586)  
                 machine=386  
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"  
                 CFLAGS_1="$CFLAGS"  
                 CFLAGS="$CFLAGS -mpentium"  
                 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")  
                 if test "${enable_direct_threaded+set}" = "" \  
                         -a "${enable_indirect_threaded+set}" = ""  
                 then  
                         echo "Using indirect threaded code on Pentium/K5/K6"  
                         AC_DEFINE(INDIRECT_THREADED)  
                 fi  
                 ;;  
         i686)  
                 machine=386  
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"  
                 CFLAGS_1="$CFLAGS"  
                 CFLAGS="$CFLAGS -mpentiumpro"  
                 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")  
                 if test "${enable_direct_threaded+set}" = "" \  
                         -a "${enable_indirect_threaded+set}" = ""  
                 then  
                         echo "Using direct threaded code on Athlon/PPro/Pentium II/Pentium III"  
                         AC_DEFINE(DIRECT_THREADED)  
                 fi  
                 ;;  
         m68k)  
                 machine=m68k  
                 CFLAGS="$CFLAGS -fomit-frame-pointer"  
                 if test "$host_os" = "nextstep3"  
                 then  
                         LIBOBJS="$LIBOBJS termios.o"  
                 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)  
                 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*)  
                 machine=power  
                 $srcdir/mkinstalldirs arch/power  
                 AC_CHECK_FUNC(_sync_cache_range,true,LIBOBJS="$LIBOBJS ../arch/power/_sync_cache_range.o")  
                 #link text segment into first 32MB  
                 AC_MSG_CHECKING([whether the linker accepts --script=arch/power/elf32ppc.x])  
                 OLDLDFLAGS=$LDFLAGS  
                 #the -L../$srcdir helps when $srcdir is relative  
                 LDFLAGS="$LDFLAGS -L$srcdir -L../$srcdir -Xlinker --script=$srcdir/arch/power/elf32ppc.x"  
                 AC_TRY_LINK(,,ac_link_script=yes,ac_link_script=no)  
                 test $ac_link_script = yes||LDFLAGS=$OLDLDFLAGS  
                 AC_MSG_RESULT($ac_link_script)  
                 AC_MSG_CHECKING([whether the code is in the first 32MB])  
                 AC_TRY_RUN([main(){label: exit(((unsigned long)&&label)>32000000UL);}],ac_code_under_32=yes,ac_code_under_32=no,ac_code_under_32=no)  
                 AC_MSG_RESULT($ac_code_under_32)  
                 test $ac_code_under_32 = yes||(AC_MSG_WARN([Using indirect threading; please contact us (bug-gforth@gnu.org)]); AC_DEFINE(INDIRECT_THREADED))  
                 ;;  
         *)  
                 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!"  
                 machine=generic  
 esac  esac
 AC_SUBST(host)  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
           if test "$ac_cv_sizeof_char_p" = 8; then
              OPTS="-ll -noll"
           else
              OPTS=-noll
           fi
   fi
   
   if grep FORCE_REG $srcdir/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)  AC_SUBST(ENGINE_FLAGS)
   
 AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)  # 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)
   
   if test -z "$LIBTOOL_CC"
   then
     LIBTOOL_CC="$CC"
     # Try if GCC understands -Wimplicit-function-declaration
     AC_MSG_CHECKING([if $CC understands -Wimplicit-function-declaration])
     CFLAGS_1="$CFLAGS"
     CFLAGS="$CFLAGS -Wimplicit-function-declaration"
     AC_TRY_COMPILE(,,LIBTOOL_CC="$CC -Wimplicit-function-declaration",)
     CFLAGS="$CFLAGS_1"
     AC_MSG_RESULT($ac_align_jumps)
   fi
   AC_SUBST(LIBTOOL_CC)
   
   
   
   # 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 GCC understands __thread
   AC_CACHE_CHECK([whether gcc understands '__thread'], [ac_cv_thread],
        [AC_TRY_COMPILE(,[extern __thread int foo;],
                           [ac_cv_thread=yes],
                           [ac_cv_thread=no])])
   test x$ac_cv_thread = xyes && PER_THREAD='__thread'
   AC_DEFINE_UNQUOTED(PER_THREAD,$PER_THREAD,[storage class for thread-local variables])
   
   #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)
   
   #echo "machine='$machine'"
   
   dnl AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
   if test x$EC_MODE = xfalse
   then
     AS_IF([test -f $srcdir/arch/$machine/asm.fs],
           [asm_fs=arch/$machine/asm.fs])
   fi
 AC_SUBST(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)
   if test x$EC_MODE = xfalse
   then
     AS_IF([test -f $srcdir/arch/$machine/disasm.fs],
           [disasm_fs=arch/$machine/disasm.fs])
   fi
 AC_SUBST(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  case "$host_os" in
         *win32)          *darwin*)
                 EXE=".exe"                  #dar*win* must be first, not to confuse with cygwin, win32 or similar
                   #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])
                   ;;
           *win*)
                   # !!!FIXME!!! problems with cygwin and ';' as path separator
                   DIRSEP="/" # normal dirsep
                   PATHSEP=":" # colon as pathsep
                   #we don't 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 "
                   ;;
           *linux*)
                   DIRSEP="/"
                   PATHSEP=":"
                   DEFAULTSYSTEMPREFIX=""
                   if test -z "$LTDL_LIBRARY_PATH" -a "$wordsize" = 64; then
                      LTDL_LIBRARY_PATH=`/sbin/ldconfig -p |tail -n +2 |sed 's/^.* => //'|sed 's|/[[^/]]*$||'| grep 64 | sort -u | tr '\n' : | sed -e 's/:$//'`
                   fi
                 ;;                  ;;
         *)          *)
                 EXE=""                  DIRSEP="/"
                   PATHSEP=":"
                   DEFAULTSYSTEMPREFIX=""
                 ;;                  ;;
 esac  esac
 AC_SUBST(EXE)  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])
   if test -n "$LTDL_LIBRARY_PATH"; then
      AC_DEFINE_UNQUOTED(LTDL_LIBRARY_PATH,"$LTDL_LIBRARY_PATH",[Define LTDL_LIBRARY_PATH for 64 bit Linux])
   fi                                                                
   
   #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  dnl Now a little support for DOS/DJGCC
   GFORTHFAST_EXE="$GFORTH_EXE"
   GFORTHITC_EXE="$GFORTH_EXE"
   GFORTHDITC_EXE="$GFORTH_EXE"
 AC_SUBST(GFORTH_EXE)  AC_SUBST(GFORTH_EXE)
 GFORTH_EXE=""  
 AC_SUBST(GFORTHFAST_EXE)  AC_SUBST(GFORTHFAST_EXE)
 GFORTHFAST_EXE=""  AC_SUBST(GFORTHITC_EXE)
 AC_SUBST(GFORTHDITC_EXE)  AC_SUBST(GFORTHDITC_EXE)
 GFORTHDITC_EXE=""  
   
 PATHSEP=":"  
 AC_SUBST(PATHSEP)  
 AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP')  
   
 AC_SUBST(FORTHSIZES)  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  dnl copy commands for systems that don't have links
 AC_SUBST(LINK_KERNL)  AC_SUBST(LINK_KERNL)
 LINK_KERNL=""  LINK_KERNL=""
Line 319  dnl the following macro produces a warni Line 854  dnl the following macro produces a warni
 AC_C_BIGENDIAN  AC_C_BIGENDIAN
 AC_SUBST(KERNEL)  AC_SUBST(KERNEL)
 dnl ac_cv_c_bigendian is an undocumented variable of autoconf-2.1  dnl ac_cv_c_bigendian is an undocumented variable of autoconf-2.1
 if test $ac_cv_c_bigendian = yes; then  if test $ac_cv_c_bigendian != no; then
   bytesex=b    bytesex=b
   KERNEL="kernl16b.fi kernl16l.fi kernl32b.fi kernl32l.fi kernl64b.fi kernl64l.fi"    KERNEL="kernl16b.fi kernl16l.fi kernl32b.fi kernl32l.fi kernl64b.fi kernl64l.fi"
 else  else
Line 327  else Line 862  else
   KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi"    KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi"
 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" && test x$cross_compiling = xyes; then
      # we cannot perform the AC_TRY_RUN check when cross-compiling.  
      skipcode=no
      AC_MSG_RESULT([$skipcode, can't run checks since cross-compiling])
   elif 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,asm(""),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.  dnl Checks for programs.
 AC_PROG_LN_S  AC_PROG_LN_S
 dnl AM_PROG_INSTALL #performed by AM_INIT_AUTOMAKE  AC_PROG_INSTALL
   AC_CHECK_PROGS(TEXI2DVI,texi2dvi4a2ps texi2dvi)
   
   dnl check for the presence of Emacs
   AC_CHECK_PROGS(EMACS,emacs xemacs)
   test -n "$EMACS" && gforth_elc=gforth.elc
   AC_SUBST(gforth_elc)
   
   dnl MacOS X has a libtool that does something else
   AC_CHECK_PROGS(GNU_LIBTOOL,"glibtool --tag=CC" libtool)
   
 dnl Checks for library functions  dnl Checks for library functions
 dnl This check is just for making later checks link with libm.  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  dnl using sin here is no good idea since it is built-into gcc and typechecked
 AC_CHECK_LIB(m,asin)  AC_CHECK_LIB(m,asin)
 AC_CHECK_LIB(dl,dlopen)  AC_CHECK_LIB(ltdl,lt_dlinit)
   dnl ,LIB_SUFFIX=.la,LIB_SUFFIX=.so)
   if test "x$ac_cv_lib_ltdl_lt_dlinit" = xyes; then
     LIB_SUFFIX=.la
   else
     LIB_SUFFIX=.so
   fi
   AC_SUBST(LIB_SUFFIX)
   AC_CHECK_LIB(rt,clock_gettime)
   
   if test -n "$GNU_LIBTOOL" -a $ac_cv_lib_ltdl_lt_dlinit = yes; then
     build_libcc_named=build-libcc-named
   else
     AC_MSG_WARN([No GNU_LIBTOOL found, skip pre-building libcc-based libraries])
   fi
   AC_SUBST(build_libcc_named)
   
   
   if test -z "$GNU_LIBTOOL"; then
     AC_MSG_WARN([No GNU_LIBTOOL found, using "libtool" as name.])
     AC_MSG_WARN([libcc.fs won't work until you have installed (GNU) libtool.])
     GNU_LIBTOOL=libtool
   fi
   
   #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,LIBS="$LIBS")
   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,LIBS="$LIBS")
   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"  if test "$host_os" != "nextstep3"
 then  then
         AC_FUNC_MEMCMP          AC_FUNC_MEMCMP
 fi  fi
 AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh)  AC_REPLACE_FUNCS(memmove strtoul pow10 sincos strerror strsignal atanh)
 AC_CHECK_FUNCS(dlopen sys_siglist)  AC_FUNC_FSEEKO
   AC_CHECK_FUNCS(ftello dlopen sys_siglist getrusage nanosleep clock_gettime)
   AC_CHECK_TYPES(stack_t,,,[#include <signal.h>])
 AC_DECL_SYS_SIGLIST  AC_DECL_SYS_SIGLIST
 AC_CHECK_FUNC(getopt_long,true,LIBOBJS="$LIBOBJS getopt.o getopt1.o")  AC_CHECK_FUNC(getopt_long,[true],[AC_LIBOBJ(getopt) AC_LIBOBJ(getopt1)])
 AC_CHECK_FUNCS(rint expm1 log1p)  AC_CHECK_FUNCS(expm1 log1p)
 AC_REPLACE_FUNCS(ecvt)  AC_REPLACE_FUNCS(rint ecvt)
 dnl No check for select, because our replacement is no good under  dnl No check for select, because our replacement is no good under
 dnl anything but DOS  dnl anything but DOS
 AC_CHECK_HEADERS(sys/mman.h fnmatch.h)  AC_CHECK_HEADERS(sys/mman.h fnmatch.h alloca.h wchar.h endian.h)
 AC_FUNC_FNMATCH  AC_FUNC_FNMATCH
 test $ac_cv_func_fnmatch_works = yes || LIBOBJS="$LIBOBJS fnmatch.o"  test $ac_cv_func_fnmatch_works = yes || AC_LIBOBJ(fnmatch)
 AC_CHECK_FUNCS(mmap sysconf getpagesize)  AC_CHECK_FUNCS(mmap sysconf getpagesize wcwidth)
 AM_PATH_LISPDIR  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(kernel_fi)
   AC_SUBST(include_fi)
   
 dnl replace srource directory by absolute value  # Find installed Gforth
 if test $srcdir = "."; then srcdir=`pwd`   AC_MSG_CHECKING([for gforth])
   GFORTH="`cd / && which gforth 2>/dev/null`"
   #the "$srcdir" = "." test defends agains the "../" bug in gforth-0.6.2
   (cd / && $GFORTH -e bye >/dev/null 2>/dev/null  && test "$srcdir" = ".") || GFORTH=""
   if test -z "$GFORTH"; then
     PREFORTH='echo "You need to configure with a gforth in \$PATH to build this part" && false'
     GFORTHKER='echo "You need to configure with a gforth in \$PATH to build this part" && false'
     kernel_anti_dependence=''
   else
     GFORTH_FI=`cd / && $GFORTH --debug -e bye 2>&1 |grep "Opened image file: "|sed 's/Opened image file: //'`
     PREFORTH="$GFORTH -i $GFORTH_FI" ;
     KERNLX_FI1=`echo $GFORTH_FI | sed -e s/lib[64]*/share/g -e s/gforth.fi/kernl*.fi/g`
     KERNLX_FI2=`echo $GFORTH_FI | sed -e s/gforth.fi/kernl*.fi/g`
     test -f $KERNLX_FI1 && KERNLX_FI=$KERNLX_FI1
     test -f $KERNLX_FI2 && KERNLX_FI=$KERNLX_FI2
     GFORTHKER="$GFORTH -i `echo $KERNLX_FI`" ;
     kernel_anti_dependence='$(kernel_fi)'
 fi  fi
   AC_SUBST(PREFORTH)
   AC_SUBST(GFORTHKER)
   AC_SUBST(kernel_anti_dependence)
   AC_MSG_RESULT($PREFORTH)
   AC_DEFINE_UNQUOTED(KERNEL, "$kernel_fi", [The kernel to load in the image])
   AC_DEFINE_UNQUOTED(ARCH, "$machine", [architecture to run on ])
   
   #this breaks bindists
   #dnl replace srource directory by absolute value
   #if test $srcdir = "."; then srcdir=`pwd` 
   #fi
   
 AC_SUBST(machine)  AC_SUBST(machine)
 dnl AC_LINK_FILES(arch/$machine,arch/machine) #no longer needed  AC_CONFIG_FILES([
 AC_OUTPUT([  
 Makefile  Makefile
 Makedist  Makedist
 gforthmi  gforthmi
   gforthmi.sh
   vmgen
   machpc.fs
   envos.fs
   preforth
   libforth
   gforthker
 engine/Makefile  engine/Makefile
 doc/version.texi ],  engine/libcc.h
 echo timestamp > stamp-h  doc/version.texi
   build-ec ])
   AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h
 chmod +x gforthmi  chmod +x gforthmi
 test -d kernel||mkdir kernel)  chmod +x vmgen
   chmod +x build-ec
   chmod +x preforth
   chmod +x libforth
   chmod +x gforthker
   test -d kernel||mkdir kernel
   if test $srcdir != "."; then ln -sf $srcdir/gforth.el .; fi
   $srcdir/mkinstalldirs include/gforth$ARCH/$PACKAGE_VERSION
   $srcdir/mkinstalldirs arch/$machine
   ln -sf ../../../engine/config.h ../../../engine/libcc.h include/gforth$ARCH/$PACKAGE_VERSION]],
   [PACKAGE_VERSION=$PACKAGE_VERSION
    machine=$machine
    ARCH=$ARCH])
   AC_OUTPUT

Removed from v.1.66  
changed lines
  Added in v.1.320


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>