Diff for /gforth/configure.in between versions 1.147 and 1.286

version 1.147, 2005/01/23 09:55:12 version 1.286, 2010/12/27 18:13:39
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,2000,2003,2004 Free Software Foundation, Inc.  #Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006,2007,2008,2009 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., 59 Temple Place, Suite 330, Boston, MA 02111, USA.  
   
   
 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
 AC_INIT([gforth],[0.6.2-20030910],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])  AC_INIT([gforth],[0.7.9-20101227],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])
 AC_PREREQ(2.54)  AC_PREREQ(2.54)
 #snapshots have numbers major.minor.release-YYYYMMDD  #snapshots have numbers major.minor.release-YYYYMMDD
 #note that lexicographic ordering must 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!
 UPDATED="September 10, 2003"  UPDATED="December 27, 2010"
 AC_SUBST(UPDATED)  AC_SUBST(UPDATED)
 AC_CONFIG_HEADERS(engine/config.h)  AC_CONFIG_HEADERS(engine/config.h)
   
   #remnants from having ltdl as convenience library
   LTDLDEPS=""
   LTDLINCL=""
   LIBLTDL=""
   LTDL_LDLIBS=""
   AC_SUBST(LTDLDEPS)
   AC_SUBST(LTDLINCL)
   AC_SUBST(LIBLTDL)
   AC_SUBST(LTDL_LDLIBS)
   
 #suppress the "-g -O2" default  #suppress the "-g -O2" default
 test "$CFLAGS" || CFLAGS=-O2  test "$CFLAGS" || CFLAGS=-O2
   
 AC_ARG_ENABLE(force-reg,  AC_ARG_ENABLE(force-cdiv,
 [  --enable-force-reg     Use explicit register declarations if they appear in          AC_HELP_STRING([--enable-force-cdiv],
                           the machine.h file. This can cause a good speedup,                         [  Use the native C division - symmetric - instead of
                           but also incorrect code with some gcc versions on                            floored division (default disabled).]),
                           some processors (default disabled).],          ,enable_force_cdiv=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)]))  test "$enable_force_cdiv" = "no"||
 AC_ARG_ENABLE(force-ll,    AC_DEFINE(FORCE_CDIV,,[Define if you want to use explicit symmetric division for better performance])
 [  --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_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_SUBST(PROFEXES)  AC_SUBST(PROFEXES)
 AC_SUBST(PROFOBJS)  AC_SUBST(PROFOBJS)
   
 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(prof,  AC_ARG_ENABLE(prof,
 [  --enable-prof          Build gforth-prof, which outputs frequently occuring          AC_HELP_STRING([--enable-prof],
                           sequences of primitives.],                          [ Build gforth-prof, which outputs frequently occuring
 PROFEXES="gforth-prof\$(EXE)"; PROFOBJS="engine-prof.o main-prof.o profile.o")                            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  [  --with-debug           specifies option -g to compile with debug info
Line 71  AC_ARG_WITH(debug, Line 68  AC_ARG_WITH(debug,
                           debugging informations.],                            debugging informations.],
 if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)  if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)
   
 dnl PEEPHOLE="yes"  GCC_LD="\$(GCC)"
 dnl AC_ARG_WITH(peephole,  EC_MODE="false"
 dnl [  --with-peephole  Enable peephole optimization (default)  NO_EC=""
 dnl   --without-peephole        disables peephole optimization. Creates smaller,  EC=""
 dnl                     but slower images.],  engine2='engine2$(OPT).o'
 dnl PEEPHOLE="$withval")  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="#"
     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])
   
 #variables mentioned in INSTALL  #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(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_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_char, [sizeof(char)])
 AC_ARG_VAR(ac_cv_sizeof_short, [sizeof(short)])  AC_ARG_VAR(ac_cv_sizeof_short, [sizeof(short)])
 AC_ARG_VAR(ac_cv_sizeof_int, [sizeof(int)])  AC_ARG_VAR(ac_cv_sizeof_int, [sizeof(int)])
Line 92  AC_ARG_VAR(ac_cv_sizeof_int128_t, [sizeo Line 128  AC_ARG_VAR(ac_cv_sizeof_int128_t, [sizeo
 AC_ARG_VAR(ac_cv_sizeof_uint128_t, [sizeof(uint128_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(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(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)])
   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:  #set up feature test macros, so the tests get them right:
 # turn on all POSIX, SUSv3, and GNU features if available  # turn on all POSIX, SUSv3, and GNU features if available
Line 117  AC_PROG_CC Line 157  AC_PROG_CC
   
 test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher)  test "$GCC" = "yes" || AC_MSG_ERROR(Gforth uses GNU C extensions and requires GCC 2.0 or higher)
   
   AC_MSG_CHECKING([whether to use two dispatches per conditional branch])
   test x$condbranch_opt = x && 
   if ($CC -v 2>&1 |grep 'gcc version 3' >/dev/null); then
      condbranch_opt=0
   else
      condbranch_opt=1
   fi
   AC_MSG_RESULT($condbranch_opt)
   AC_SUBST(condbranch_opt)
   
 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(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)  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='#'  GNUMAKE='#'
 test "$make_type" = "GNU Make" && GNUMAKE=''  test "$make_type" = "GNU Make" && GNUMAKE=''
   
 AC_MSG_RESULT($make_type)  AC_MSG_RESULT($make_type)
   
 AC_SUBST(GNUMAKE)  AC_SUBST(GNUMAKE)
   
 AC_MSG_CHECKING([whether the linker accepts -export-dynamic])  AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
Line 141  AC_MSG_RESULT($ac_export_dynamic) Line 200  AC_MSG_RESULT($ac_export_dynamic)
   
 #terminology is a bit unusual here: The host is the system on which  #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'  #gforth will run; the system on which configure will run is the `build'
 AC_CANONICAL_HOST  
 case "$host_cpu" in  case "$host_cpu" in
         arm*)          arm*)
                 machine=arm                  machine=arm
                 CFLAGS="$CFLAGS -fomit-frame-pointer"                  CFLAGS="$CFLAGS -fomit-frame-pointer"
                 if test -z $no_dynamic_default; then                  if test x$platform = xnxt; then
                     no_dynamic_default=1                     CFLAGS="$CFLAGS -mthumb -mthumb-interwork"
                     AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])                  fi
                   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                  fi
                   #longer skipcodes lead to problems on ARM, and it uses
                   #only 4-byte alignment anyway
                   test "$skipcode" || skipcode="nop"
                 ;;                  ;;
         hppa*)          hppa*)
                 machine=hppa                  machine=hppa
                 $srcdir/mkinstalldirs arch/hppa  
                 AC_LIBOBJ(../arch/hppa/cache)                  AC_LIBOBJ(../arch/hppa/cache)
                 #-N needed for --dynamic <M4U3b.3790$9d.317@news.cpqcorp.net>                  #-N needed for --dynamic <M4U3b.3790$9d.317@news.cpqcorp.net>
                 LDFLAGS="$LDFLAGS -Xlinker -N"                  LDFLAGS="$LDFLAGS -Xlinker -N"
Line 164  case "$host_cpu" in Line 238  case "$host_cpu" in
                 ;;                  ;;
         i386)          i386)
                 machine=386                  machine=386
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"                  CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
                 ;;                  ;;
         i486)          i486)
                 machine=386                  machine=386
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"                  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)          i*86)
                 machine=386                  machine=386
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"                  CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr"
                 CFLAGS_1="$CFLAGS"                  CFLAGS_1="$CFLAGS"
                 CFLAGS="$CFLAGS -march=pentium"                  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 -m486")
                   AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1")
                 ;;                  ;;
         x86_64)          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*)          ia64*)
                 machine=ia64                  machine=ia64
Line 197  case "$host_cpu" in Line 288  case "$host_cpu" in
                 ;;                  ;;
         mips*)          mips*)
                 machine=mips                  machine=mips
                   AC_LIBOBJ(../arch/mips/check_prim) 
                 #dynamic native code has the following problems on MIPS:                  #dynamic native code has the following problems on MIPS:
                 #                  #
                 #1) J/JAL seems relocatable, but is are only                  #1) J/JAL seems relocatable, but is are only
Line 210  case "$host_cpu" in Line 302  case "$host_cpu" in
                 #particular, the delay slots of LW, MFLO, etc.)                  #particular, the delay slots of LW, MFLO, etc.)
                 #                  #
                 #Therefore we disable dynamic native code by default:                  #Therefore we disable dynamic native code by default:
                 if test -z $no_dynamic_default; then                  if test -z "$no_dynamic_default"; then
                     no_dynamic_default=1                      no_dynamic_default=1
                     AC_MSG_WARN([Disabling default dynamic native code generation (relocation and delay slot issues)])                      AC_MSG_WARN([Disabling default dynamic native code generation (relocation and delay slot issues)])
                 fi                  fi
Line 222  case "$host_cpu" in Line 314  case "$host_cpu" in
                 ;;                  ;;
         power*|rs6000)          power*|rs6000)
                 machine=power                  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                  #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 '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([Using a generic machine description])
Line 240  case "$host_cpu" in Line 340  case "$host_cpu" in
 esac  esac
 AC_SUBST(host)  AC_SUBST(host)
   
 if test "${enable_force_ll+set}" = set; then  MAKEINC=""
    ac_includes_default="$ac_includes_default  GFORTH_EXE="true"
 #include \"arch/generic/128bit.h\""  
   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  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 259  case "$ac_cv_sizeof_char_p" in Line 389  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)
Line 289  case "$ac_cv_sizeof_char_p" in Line 432  case "$ac_cv_sizeof_char_p" in
   $ac_cv_sizeof_intptr_t)    $ac_cv_sizeof_intptr_t)
     ac_cv_int_type_cell="intptr_t"      ac_cv_int_type_cell="intptr_t"
     ;;      ;;
   $ac_cv_sizeof_int128_t)  
     ac_cv_int_type_cell="int128_t"  
     ;;  
 esac  esac
 AC_MSG_RESULT($ac_cv_int_type_cell)  AC_MSG_RESULT($ac_cv_int_type_cell)
 AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer])  AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer])
   
   AC_MSG_CHECKING([for a C type for wydes])
   ac_cv_wyde_type_cell=none
   case 2 in
     $ac_cv_sizeof_int)
       ac_cv_wyde_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_wyde_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_wyde_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_wyde_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_wyde_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_wyde_type_cell="intptr_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_wyde_type_cell)
   AC_DEFINE_UNQUOTED(WYDE_TYPE,$ac_cv_wyde_type_cell,[an integer type that is 2 bytes long])
   
   AC_MSG_CHECKING([for a C type for tetrabytes])
   ac_cv_tetrabyte_type_cell=none
   case 4 in
     $ac_cv_sizeof_int)
       ac_cv_tetrabyte_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_tetrabyte_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_tetrabyte_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_tetrabyte_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_tetrabyte_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_tetrabyte_type_cell="intptr_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_tetrabyte_type_cell)
   AC_DEFINE_UNQUOTED(TETRABYTE_TYPE,$ac_cv_tetrabyte_type_cell,[an integer type that is 4 bytes long])
   
   AC_MSG_CHECKING([for a C type for 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_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
Line 344  case `expr 2 '*' "$ac_cv_sizeof_char_p"` Line 559  case `expr 2 '*' "$ac_cv_sizeof_char_p"`
 esac  esac
 AC_MSG_RESULT($ac_cv_int_type_double_ucell)  AC_MSG_RESULT($ac_cv_int_type_double_ucell)
   
 if test "$ac_cv_int_type_double_cell" = none || \  if test "$ac_cv_int_type_double_cell" != none && \
    test "$ac_cv_int_type_double_ucell" = none     test "$ac_cv_int_type_double_ucell" != none
 then  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_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])          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  fi
   AC_SUBST(OPTS)
   
 AC_TYPE_OFF_T  AC_TYPE_OFF_T
 AC_CHECK_SIZEOF(off_t)  AC_CHECK_SIZEOF(off_t)
Line 397  AC_TRY_COMPILE(,,ac_noreorder_blocks=yes Line 624  AC_TRY_COMPILE(,,ac_noreorder_blocks=yes
 CFLAGS="$CFLAGS_1"  CFLAGS="$CFLAGS_1"
 AC_MSG_RESULT($ac_noreorder_blocks)  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))  # Try if GCC understands __attribute__((unused))
 AC_MSG_CHECKING([how to suppress 'unused variable' warnings])  AC_MSG_CHECKING([how to suppress 'unused variable' warnings])
 AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',)  AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',)
 AC_DEFINE_UNQUOTED(MAYBE_UNUSED,$MAYBE_UNUSED,[attribute for possibly unused variables])  AC_DEFINE_UNQUOTED(MAYBE_UNUSED,$MAYBE_UNUSED,[attribute for possibly unused variables])
 AC_MSG_RESULT($MAYBE_UNUSED)  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_MSG_RESULT($M4)
   
   # Find installed Gforth
   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'
     kernel_anti_dependence=''
   else
     PREFORTH="$GFORTH -i `cd / && $GFORTH --debug -e bye 2>&1 |grep "Opened image file: "|sed 's/Opened image file: //'`" ;
     kernel_anti_dependence='$(kernel_fi)'
   fi
   AC_SUBST(PREFORTH)
   AC_SUBST(kernel_anti_dependence)
   AC_MSG_RESULT($PREFORTH)
   
   #echo "machine='$machine'"
   
   dnl AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
   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)  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|cygwin)          *win32*)
                   # !!!FIXME!!! problems with cygwin and ';' as path separator
                 DIRSEP="\\\\"                  DIRSEP="\\\\"
                 PATHSEP=";"                  PATHSEP=";"
                 #we want the builtins of command.com/cmd.exe and its                  #we want the builtins of command.com/cmd.exe and its
Line 429  case "$host_os" in Line 734  case "$host_os" in
                 DIRSEP="/"                  DIRSEP="/"
                 PATHSEP=":"                  PATHSEP=":"
                 DEFAULTSYSTEMPREFIX=""                  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])
                   ;;
           *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
                 ;;                  ;;
         *)          *)
                 DIRSEP="/"                  DIRSEP="/"
Line 442  AC_SUBST(PATHSEP) Line 758  AC_SUBST(PATHSEP)
 AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character])  AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character])
 AC_SUBST(DEFAULTSYSTEMPREFIX)  AC_SUBST(DEFAULTSYSTEMPREFIX)
 AC_DEFINE_UNQUOTED(DEFAULTSYSTEMPREFIX,"$DEFAULTSYSTEMPREFIX",[default for environment variable GFORTHSYSTEMPREFIX])  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(GFORTHITC_EXE)
 GFORTHITC_EXE=""  
 AC_SUBST(GFORTHDITC_EXE)  AC_SUBST(GFORTHDITC_EXE)
 GFORTHDITC_EXE=""  
   
 AC_SUBST(FORTHSIZES)  AC_SUBST(FORTHSIZES)
   
Line 480  dnl the following macro produces a warni Line 802  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 489  else Line 811  else
 fi  fi
   
 #check how to do asm(".skip 16")  #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])  AC_MSG_CHECKING([if and how we can waste code space])
 if test -z "$skipcode"; then  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"      for i in ".skip 16" ".block 16" ".org .+16" ".=.+16" ".space 16"
     do      do
         AC_TRY_RUN(          AC_TRY_RUN(
Line 505  int foo(int x, int y, int z) Line 836  int foo(int x, int y, int z)
   if (x) {    if (x) {
     y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */      y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */
   label1:    label1:
     asm(".skip 16"); /* or ".space 16" or somesuch */      asm("$i"); /* or ".space 16" or somesuch */
   label2: ;    label2: ;
   }    }
   {    {
Line 516  int foo(int x, int y, int z) Line 847  int foo(int x, int y, int z)
         ,skipcode=$i; break          ,skipcode=$i; break
         ,,)          ,,)
     done      done
       CFLAGS=$CFLAGS_1
 fi  fi
 AC_MSG_RESULT($skipcode)  AC_MSG_RESULT($skipcode)
 if test "$skipcode" = no  if test "$skipcode" = no
Line 524  then Line 856  then
         no_dynamic_default=1          no_dynamic_default=1
         AC_MSG_WARN(Disabling default dynamic native code generation)          AC_MSG_WARN(Disabling default dynamic native code generation)
     fi      fi
     AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes)      AC_DEFINE_UNQUOTED(SKIP16,asm(""),statement for skipping 16 bytes)
 else  else
     AC_DEFINE_UNQUOTED(SKIP16,asm("$skipcode"),statement for skipping 16 bytes)      AC_DEFINE_UNQUOTED(SKIP16,asm("$skipcode"),statement for skipping 16 bytes)
 fi  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  test "$no_dynamic_default" || no_dynamic_default=0
 AC_DEFINE_UNQUOTED(NO_DYNAMIC_DEFAULT,$no_dynamic_default,default value for no_dynamic)  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
 AC_PROG_INSTALL  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 --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 check for ffcall libraries  
 dnl unfortunately, these four calls are separated out into a library each.  if test -n "$GNU_LIBTOOL" -a $ac_cv_lib_ltdl_lt_dlinit = yes; then
 AC_CHECK_LIB(avcall,__builtin_avcall)    build_libcc_named=build-libcc-named
 AC_CHECK_LIB(callback,__vacall_r)  else
 AC_CHECK_LIB(vacall,vacall)    build_libcc_named=""
 AC_CHECK_LIB(trampoline,alloc_trampoline)    AC_MSG_WARN([No GNU_LIBTOOL found, skip pre-building libcc-based libraries])
 FFCALLFLAG="false"  fi
 OLDCALLFLAG="true"  AC_SUBST(build_libcc_named)
 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])  
   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(FFCALLFLAG)
 AC_SUBST(OLDCALLFLAG)  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 strerror strsignal atanh)
 AC_FUNC_FSEEKO  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_CHECK_TYPES(stack_t,,,[#include <signal.h>])
 AC_DECL_SYS_SIGLIST  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)])
Line 567  AC_CHECK_FUNCS(expm1 log1p) Line 957  AC_CHECK_FUNCS(expm1 log1p)
 AC_REPLACE_FUNCS(rint 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 || AC_LIBOBJ(fnmatch)  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)
   
 #this breaks bindists  #this breaks bindists
 #dnl replace srource directory by absolute value  #dnl replace srource directory by absolute value
Line 588  Makedist Line 980  Makedist
 gforthmi  gforthmi
 vmgen  vmgen
 machpc.fs  machpc.fs
   envos.fs
   preforth
 engine/Makefile  engine/Makefile
 doc/version.texi ])  engine/libcc.h
   doc/version.texi
   build-ec ])
 AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h  AC_CONFIG_COMMANDS([stamp-h],[[echo timestamp > stamp-h
 chmod +x gforthmi  chmod +x gforthmi
 chmod +x vmgen  chmod +x vmgen
 test -d kernel||mkdir kernel]],[[]])  chmod +x build-ec
   chmod +x preforth
   test -d kernel||mkdir kernel
   if test $srcdir != "."; then ln -sf $srcdir/gforth.el .; fi
   $srcdir/mkinstalldirs include/gforth/$PACKAGE_VERSION
   $srcdir/mkinstalldirs arch/$machine
   ln -sf ../../../engine/config.h ../../../engine/libcc.h include/gforth/$PACKAGE_VERSION]],
   [PACKAGE_VERSION=$PACKAGE_VERSION
    machine=$machine])
 AC_OUTPUT  AC_OUTPUT
   

Removed from v.1.147  
changed lines
  Added in v.1.286


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