Diff for /gforth/configure.in between versions 1.58 and 1.170

version 1.58, 2000/02/04 14:52:30 version 1.170, 2007/02/15 13:39:04
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 Free Software Foundation, Inc.
   
 #This file is part of Gforth.  #This file is part of Gforth.
   
Line 16  dnl Process this file with autoconf to p Line 16  dnl Process this file with autoconf to p
   
 #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, write to the Free Software
 #Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, 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-19990617)  AC_INIT([gforth],[0.6.2-20060527],[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="April 09, 2006"
 #AM_CYGWIN32  AC_SUBST(UPDATED)
   AC_CONFIG_HEADERS(engine/config.h)
   
   #suppress the "-g -O2" default
   test "$CFLAGS" || CFLAGS=-O2
   
 AC_ARG_ENABLE(force-reg,  AC_ARG_ENABLE(force-reg,
 [  --enable-force-reg     Use explicit register declarations if they appear in          AC_HELP_STRING([--enable-force-reg],
                           [ Use explicit register declarations if they appear in
                           the machine.h file. This can cause a good speedup,                            the machine.h file. This can cause a good speedup,
                           but also incorrect code with some gcc versions on                            but also incorrect code with some gcc versions on
                           some processors (default disabled).],                            some processors (default disabled).]),
           ,enable_force_reg=no)
 AC_DEFINE(FORCE_REG))  test "$enable_force_reg" = "no"||
 dnl this is not quite according to the autoconf manual, it causes a replacement    AC_DEFINE(FORCE_REG,,[Define if you want to use explicit register declarations for better performance or for more convenient CODE words (does not work with all GCC versions on all machines)])
 AC_ARG_ENABLE(direct-threaded,  
 [  --enable-direct-threaded     Force direct threading. This may not work on  AC_ARG_ENABLE(force-ll,
                                 some machines and may cause slowdown on others.          AC_HELP_STRING([--enable-force-ll],
                                 (default processor-dependent)],                         [  Use explicit long long declarations if they appear in
 AC_DEFINE(DIRECT_THREADED))                            the machine.h file. This can cause a good speedup,
 AC_ARG_ENABLE(indirect-threaded,                            but also incorrect code with some gcc versions on
 [  --enable-indirect-threaded   Force indirect threading. This can cause a                            some processors (default disabled).]),
                                 slowdown on some machines.          ,enable_force_ll=no)
                                 (default processor-dependent)],  test "$enable_force_ll" = "no"||
 AC_DEFINE(INDIRECT_THREADED))    AC_DEFINE(FORCE_LL,,[Define if you want to use explicit long long declarations for better performance (does not work with all GCC versions on all machines)])
   
   AC_ARG_ENABLE(gcc-pr15242-workaround,
                 AC_HELP_STRING([--disable-gcc-pr15242-workaround],[Disables
                                dynamic code generation on some versions of gcc
                                (slowdown~2 on Athlon) and causes slower building
                                of gforth (but gforth speedups) on others.
                                (default enabled)]),
                   ,enable_gcc_pr15242_workaround=yes)
   test "$enable_gcc_pr15242_workaround" = "no"||
   AC_DEFINE(GCC_PR15242_WORKAROUND,,[Define if you want to get dynamic code
   generation on gccs affected by PR15242])
   
   AC_ARG_ENABLE(force-cdiv,
           AC_HELP_STRING([--enable-force-cdiv],
                          [  Use the native C division - symmetric - instead of
                             floored division (default disabled).]),
           ,enable_force_cdiv=no)
   test "$enable_force_cdiv" = "no"||
     AC_DEFINE(FORCE_CDIV,,[Define if you want to use explicit symmetric division for better performance])
   
   AC_SUBST(PROFEXES)
   AC_SUBST(PROFOBJS)
   AC_ARG_ENABLE(prof,
           AC_HELP_STRING([--enable-prof],
                           [ Build gforth-prof, which outputs frequently occuring
                             sequences of primitives.]),
           ,enable_prof=no)
   if test "$enable_prof" = "no"; then
     PROFEXES="gforth-prof\$(EXE)"; PROFOBJS="engine-prof.o main-prof.o profile.o"
   fi
   
 AC_ARG_WITH(debug,  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  dnl PEEPHOLE="yes"
   dnl AC_ARG_WITH(peephole,
   dnl [  --with-peephole  Enable peephole optimization (default)
   dnl   --without-peephole        disables peephole optimization. Creates smaller,
   dnl                     but slower images.],
   dnl PEEPHOLE="$withval")
   
   AC_ARG_ENABLE(ec,
           AC_HELP_STRING([--enable-ec],
                           [  Build gforth for systems without OS.]),
           ,enable_ec=no)
   if test "$enable_ec" = "yes"; then
     echo "defining standalone system"
     AC_DEFINE(STANDALONE,,[Define if you want a Gforth without OS])
     EC_MODE="true"
   else
     echo "defining hosted system"
     EC_MODE="false"
   fi
   
   #variables mentioned in INSTALL
   AC_ARG_VAR(CC, [The C compiler (must support GNU C 2.x); gcc-2.95 recommended.])
   AC_ARG_VAR(FORTHSIZES, [Gforth command line options for the default stack and dictionary sizes (see INSTALL).])
   AC_ARG_VAR(STACK_CACHE_DEFAULT_FAST, [number of registers in the default stack cache state for gforth-fast and gforth-native (default 1).])
   AC_ARG_VAR(ac_cv_sizeof_char_p, [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_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(skipcode, [assembly code for skipping 16 bytes of code])
   
   #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"  
 else  
    cat <<'EOF'  
 Gforth requires GCC-2.0 or higher (it uses GNU C extensions).  
 It does not work with other C compilers. Please install the GNU C compiler,  
 and try again (or search for a binary distribution for your platform).  
 EOF  
    exit 1  
 fi  
   
 AC_SUBST(CC)  AC_SUBST(CC)
 AC_SUBST(DEBUGFLAG)  AC_SUBST(DEBUGFLAG)
   AC_SUBST(EC_MODE)
   
 dnl the following macro produces a warning with autoconf-2.1  AC_MSG_CHECKING(make type)
 AC_CHECK_SIZEOF(char *)  make_type=`make -v 2>&1|grep 'ake'|sed 's/ake .*/ake/'`
 case "$ac_cv_sizeof_char_p" in  
   2)  
     wordsize=16  
     ;;  
   4)  
     wordsize=32  
     ;;  
   8)  
     wordsize=64  
     ;;  
 esac  
   
 AC_CHECK_SIZEOF(char)  GNUMAKE='#'
 AC_CHECK_SIZEOF(short)  test "$make_type" = "GNU Make" && GNUMAKE=''
 AC_CHECK_SIZEOF(int)  
 AC_CHECK_SIZEOF(long)  
 AC_CHECK_SIZEOF(long long)  
   
 ac_cv_int_type_cell=none  AC_MSG_RESULT($make_type)
 case "$ac_cv_sizeof_char_p" in  
   $ac_cv_sizeof_int)  
     ac_cv_int_type_cell=int  
     ;;  
   $ac_cv_sizeof_short)  
     ac_cv_int_type_cell=short  
     ;;  
   $ac_cv_sizeof_char)  
     ac_cv_int_type_cell=char  
     ;;  
   $ac_cv_sizeof_long)  
     ac_cv_int_type_cell=long  
     ;;  
   $ac_cv_sizeof_long_long)  
     ac_cv_int_type_cell="long long"  
     ;;  
 esac  
 if test "$ac_cv_int_type_cell" != int; then  
         echo "So, sizeof(pointer)!=sizeof(int); looks like a DOS C compiler to me."  
         echo "Since you don't have a proper C on this machine, that's one more reason"  
         echo "to use Forth;-)"  
 fi  
 AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell)  
   
 ac_cv_int_type_double_cell=none  AC_SUBST(GNUMAKE)
 case `expr 2 '*' "$ac_cv_sizeof_char_p"` in  
   $ac_cv_sizeof_short)  
     ac_cv_int_type_double_cell=short  
     ;;  
   $ac_cv_sizeof_int)  
     ac_cv_int_type_double_cell=int  
     ;;  
   $ac_cv_sizeof_long)  
     ac_cv_int_type_double_cell=long  
     ;;  
   $ac_cv_sizeof_long_long)  
     ac_cv_int_type_double_cell="long long"  
     ;;  
 esac  
 if test "$ac_cv_int_type_double_cell" = none; then  
         echo "Emulating double-cell arithmetic. This may be slow."  
         echo "If you find this unacceptable, ask the GCC maintainers to provide proper"  
         echo 'long longs for your machine (the GCC manual states that they \"are twice as'  
         echo "long as \`long int\'\")."  
         LIBOBJS="$LIBOBJS dblsub.o"  
         AC_DEFINE(BUGGY_LONG_LONG)  
 else  
   AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell)  
 fi  
   
 AC_MSG_CHECKING([whether the linker accepts -export-dynamic])  AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
 OLDLDFLAGS=$LDFLAGS  OLDLDFLAGS=$LDFLAGS
 LDFLAGS="$LDFLAGS -export-dynamic"  LDFLAGS="$LDFLAGS -export-dynamic"
 AC_TRY_LINK(,,ac_export_dynamic=yes,ac_export_dynamic=no)  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  test $ac_export_dynamic = yes|| LDFLAGS=$OLDLDFLAGS
 AC_MSG_RESULT($ac_export_dynamic)  AC_MSG_RESULT($ac_export_dynamic)
   
Line 156  AC_MSG_RESULT($ac_export_dynamic) Line 177  AC_MSG_RESULT($ac_export_dynamic)
 #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  AC_CANONICAL_HOST
 case "$host_cpu" in  case "$host_cpu" in
           arm*)
                   machine=arm
                   CFLAGS="$CFLAGS -fomit-frame-pointer"
                   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
                   ;;
         hppa*)          hppa*)
                 machine=hppa                  machine=hppa
                 $srcdir/mkinstalldirs arch/hppa                  $srcdir/mkinstalldirs arch/hppa
                 LIBOBJS="$LIBOBJS ../arch/hppa/cache.o"                  AC_LIBOBJ(../arch/hppa/cache)
                   #-N needed for --dynamic <M4U3b.3790$9d.317@news.cpqcorp.net>
                 LDFLAGS="$LDFLAGS -Xlinker -N"                  LDFLAGS="$LDFLAGS -Xlinker -N"
                 LIBS="$LIBS -L/lib/pa1.1/"                  LIBS="$LIBS -L/lib/pa1.1/"
                 if test "${enable_direct_threaded+set}" = ""  
                 then  
                         AC_DEFINE(DIRECT_THREADED)  
                 fi  
                 ;;                  ;;
         sparc*)          sparc*)
                 machine=sparc                  machine=sparc
Line 173  case "$host_cpu" in Line 199  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 -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)          i486)
                 machine=386                  machine=386
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"                  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)          i*86)
                 machine=386                  machine=386
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"                  CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
                 CFLAGS_1="$CFLAGS"                  CFLAGS_1="$CFLAGS"
                 CFLAGS="$CFLAGS -mpentium"                  CFLAGS="$CFLAGS -march=pentium"
                 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")                  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)          x86_64)
                 machine=386                  machine=amd64
                 CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"                  ;;
                 CFLAGS_1="$CFLAGS"          ia64*)
                 CFLAGS="$CFLAGS -mpentiumpro"                  machine=ia64
                 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")                  AC_LIBOBJ(../arch/ia64/flush_icache_block)
                 if test "${enable_direct_threaded+set}" = "" \                  test "$skipcode" || skipcode="nop.i 0"
                         -a "${enable_indirect_threaded+set}" = ""                  #".skip 16" passes the test below,
                 then                  # but gives an assembler error in engine
                         echo "Using direct threaded code on PPro/Pentium II"  
                         AC_DEFINE(DIRECT_THREADED)  
                 fi  
                 ;;                  ;;
         m68k)          m68k)
                 machine=m68k                  machine=m68k
                 CFLAGS="$CFLAGS -fomit-frame-pointer"                  CFLAGS="$CFLAGS -fomit-frame-pointer"
                 if test "$host_os" = "nextstep3"                  if test "$host_os" = "nextstep3"
                 then                  then
                         LIBOBJS="$LIBOBJS termios.o"                          AC_LIBOBJ(termios)
                 fi                  fi
                 ;;                  ;;
         mips*)          mips*)
                 machine=mips                  machine=mips
                 #link text and data segment into the same 256M region!                  #dynamic native code has the following problems on MIPS:
                 AC_MSG_CHECKING([whether the linker accepts -T])                  #
                 OLDLDFLAGS=$LDFLAGS                  #1) J/JAL seems relocatable, but is are only
                 LDFLAGS="$LDFLAGS -Xlinker -T -Xlinker 10000000"                  #relocatable within a 256MB-segment.  While we try to
                 AC_TRY_LINK(,,ac_link_mips_t=yes,ac_link_mips_t=no)                  #get the linker to arrange this, there is no guarantee
                 test $ac_link_mips_t = yes||LDFLAGS=$OLDLDFLAGS                  #that this will succeed (and if the user uses a lot of
                 AC_MSG_RESULT($ac_link_mips_t)                  #memory, it is likely to fail).
                 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])                  #2) The way we generate dynamic native code may
                 OLDLDFLAGS=$LDFLAGS                  #violate MIPS architectural restrictions (in
                 LDFLAGS="$LDFLAGS -Xlinker -D -Xlinker 10400000"                  #particular, the delay slots of LW, MFLO, etc.)
                 AC_TRY_LINK(,,ac_link_mips_d=yes,ac_link_mips_d=no)                  #
                 test $ac_link_mips_d = yes||LDFLAGS=$OLDLDFLAGS                  #Therefore we disable dynamic native code by default:
                 AC_MSG_RESULT($ac_link_mips_d)                  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*)          alpha*)
                 machine=alpha                  machine=alpha
                 #full IEEE FP support for more uniformity across platforms:                  #full IEEE FP support for more uniformity across platforms:
                 CFLAGS="$CFLAGS -mieee"                  CFLAGS="$CFLAGS -mieee"
                 ;;                  ;;
         power*)          power*|rs6000)
                 machine=power                  machine=power
                 $srcdir/mkinstalldirs arch/power                  $srcdir/mkinstalldirs arch/power
                 AC_CHECK_FUNC(_sync_cache_range,true,LIBOBJS="$LIBOBJS ../arch/power/_sync_cache_range.o")                  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 -q 'gcc version 2.95') &&
                   ac_cv_sizeof_long_long=0
                 ;;                  ;;
         *)          *)
                 echo "No direct threading support for $host_cpu, using indirect threading."                  AC_MSG_WARN([Using a generic machine description])
                 echo "Using a generic machine description."                  AC_MSG_WARN([Assuming C floats and doubles are IEEE floats and doubles (for SF@ DF@ SF! DF!)])
                 echo "I'll assume that C floats and doubles are represented by IEEE single and"                  AC_MSG_WARN([FLUSH-ICACHE will do nothing, so END-CODE may not work properly!])
                 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                  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  esac
 AC_SUBST(host)  AC_SUBST(host)
   
   test x$STACK_CACHE_DEFAULT_FAST = x && STACK_CACHE_DEFAULT_FAST=1
   AC_DEFINE_UNQUOTED(STACK_CACHE_DEFAULT_FAST, $STACK_CACHE_DEFAULT_FAST,
                      [number of registers in the default stack cache state for gforth-fast and gforth-native])
   
   if test "${enable_force_ll+set}" = set; then
      ac_includes_default="$ac_includes_default
   #include \"arch/generic/128bit.h\""
   fi
   
   dnl the following macro produces a warning with autoconf-2.1
   AC_CHECK_SIZEOF(char *)
   case "$ac_cv_sizeof_char_p" in
     2)
       wordsize=16
       ;;
     4)
       wordsize=32
       ;;
     8)
       wordsize=64
       ;;
   esac
   
   AC_CHECK_SIZEOF(char)
   AC_CHECK_SIZEOF(short)
   AC_CHECK_SIZEOF(int)
   AC_CHECK_SIZEOF(long)
   AC_CHECK_SIZEOF(long long)
   AC_CHECK_SIZEOF(intptr_t)
   AC_CHECK_SIZEOF(int128_t)
   AC_CHECK_SIZEOF(uint128_t)
   
   AC_MSG_CHECKING([for a C type for cells])
   ac_cv_int_type_cell=none
   case "$ac_cv_sizeof_char_p" in
     $ac_cv_sizeof_int)
       ac_cv_int_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_int_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_int_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_int_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_int_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_int_type_cell="intptr_t"
       ;;
     $ac_cv_sizeof_int128_t)
       ac_cv_int_type_cell="int128_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_int_type_cell)
   AC_DEFINE_UNQUOTED(CELL_TYPE,$ac_cv_int_type_cell,[an integer type that is as long as a pointer])
   
   AC_MSG_CHECKING([for a C type for wydes])
   ac_cv_wyde_type_cell=none
   case 2 in
     $ac_cv_sizeof_int)
       ac_cv_wyde_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_wyde_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_wyde_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_wyde_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_wyde_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_wyde_type_cell="intptr_t"
       ;;
     $ac_cv_sizeof_int128_t)
       ac_cv_wyde_type_cell="int128_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_wyde_type_cell)
   AC_DEFINE_UNQUOTED(WYDE_TYPE,$ac_cv_wyde_type_cell,[an integer type that is 2 bytes long])
   
   AC_MSG_CHECKING([for a C type for tetrabytes])
   ac_cv_tetrabyte_type_cell=none
   case 4 in
     $ac_cv_sizeof_int)
       ac_cv_tetrabyte_type_cell=int
       ;;
     $ac_cv_sizeof_short)
       ac_cv_tetrabyte_type_cell=short
       ;;
     $ac_cv_sizeof_char)
       ac_cv_tetrabyte_type_cell=char
       ;;
     $ac_cv_sizeof_long)
       ac_cv_tetrabyte_type_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_tetrabyte_type_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_tetrabyte_type_cell="intptr_t"
       ;;
     $ac_cv_sizeof_int128_t)
       ac_cv_tetrabyte_type_cell="int128_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_tetrabyte_type_cell)
   AC_DEFINE_UNQUOTED(TETRABYTE_TYPE,$ac_cv_tetrabyte_type_cell,[an integer type that is 4 bytes long])
   
   AC_MSG_CHECKING([for a C type for double-cells])
   ac_cv_int_type_double_cell=none
   case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
     $ac_cv_sizeof_short)
       ac_cv_int_type_double_cell=short
       ;;
     $ac_cv_sizeof_int)
       ac_cv_int_type_double_cell=int
       ;;
     $ac_cv_sizeof_long)
       ac_cv_int_type_double_cell=long
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_int_type_double_cell="long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_int_type_double_cell="intptr_t"
       ;;
     $ac_cv_sizeof_int128_t)
       ac_cv_int_type_double_cell="int128_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_int_type_double_cell)
   
   AC_MSG_CHECKING([for a C type for unsigned double-cells])
   ac_cv_int_type_double_ucell=none
   case `expr 2 '*' "$ac_cv_sizeof_char_p"` in
     $ac_cv_sizeof_short)
       ac_cv_int_type_double_ucell="unsigned short"
       ;;
     $ac_cv_sizeof_int)
       ac_cv_int_type_double_ucell="unsigned int"
       ;;
     $ac_cv_sizeof_long)
       ac_cv_int_type_double_ucell="unsigned long"
       ;;
     $ac_cv_sizeof_long_long)
       ac_cv_int_type_double_ucell="unsigned long long"
       ;;
     $ac_cv_sizeof_intptr_t)
       ac_cv_int_type_double_ucell="unsigned intptr_t"
       ;;
     $ac_cv_sizeof_uint128_t)
       ac_cv_int_type_double_ucell="uint128_t"
       ;;
   esac
   AC_MSG_RESULT($ac_cv_int_type_double_ucell)
   
   if test "$ac_cv_int_type_double_cell" = none || \
      test "$ac_cv_int_type_double_ucell" = none
   then
           AC_MSG_WARN([Emulating double-cell arithmetic. This may be slow.])
           AC_LIBOBJ(dblsub)
           AC_DEFINE(BUGGY_LONG_LONG,,[define this if there is no working DOUBLE_CELL_TYPE on your machine])
   else
           AC_DEFINE_UNQUOTED(DOUBLE_CELL_TYPE,$ac_cv_int_type_double_cell,[an integer type that is twice as long as a pointer])
           AC_DEFINE_UNQUOTED(DOUBLE_UCELL_TYPE,$ac_cv_int_type_double_ucell,[an unsigned integer type that is twice as long as a pointer])
   fi
   
   AC_TYPE_OFF_T
   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)
   
   # 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 __attribute__((unused))
   AC_MSG_CHECKING([how to suppress 'unused variable' warnings])
   AC_TRY_COMPILE(,[int __attribute__((unused)) foo;], MAYBE_UNUSED='__attribute__((unused))',)
   AC_DEFINE_UNQUOTED(MAYBE_UNUSED,$MAYBE_UNUSED,[attribute for possibly unused variables])
   AC_MSG_RESULT($MAYBE_UNUSED)
   
   AC_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
   AC_SUBST(asm_fs)
   
   AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)
   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)          *win32*)
                 EXE=".exe"                  # !!!FIXME!!! problems with cygwin and ';' as path separator
                   DIRSEP="\\\\"
                   PATHSEP=";"
                   #we want the builtins of command.com/cmd.exe and its
                   # handling of .com files.
                   #$COMSPEC contains the name of the Windows shell;
                   # the ./ is there, because the bash does not recognize
                   # absolute DOS filenames
                   DEFAULTSYSTEMPREFIX="./$COMSPEC /c "
                   ;;
           *darwin*)
                   #Darwin uses some funny preprocessor by default; eliminate it:
                   AC_MSG_NOTICE([using -no-cpp-precomp on Darwin])
                   CFLAGS="$CFLAGS -no-cpp-precomp"
                   DIRSEP="/"
                   PATHSEP=":"
                   DEFAULTSYSTEMPREFIX=""
                 ;;                  ;;
         *)          *)
                 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])
   
   #work around SELinux brain damage (from Andrew Haley <12t8f3jakb74g2c@news.supernews.com>)
   AC_CHECK_PROG([MASSAGE_EXE],[chcon],[chcon -t unconfined_execmem_exec_t $@])
   
 dnl Now a little support for DOS/DJGCC  dnl Now a little support for DOS/DJGCC
 AC_SUBST(GFORTH_EXE)  AC_SUBST(GFORTH_EXE)
 GFORTH_EXE=""  GFORTH_EXE=$MASSAGE_EXE
 AC_SUBST(GFORTHFAST_EXE)  AC_SUBST(GFORTHFAST_EXE)
 GFORTHFAST_EXE=""  GFORTHFAST_EXE=$MASSAGE_EXE
   AC_SUBST(GFORTHITC_EXE)
   GFORTHITC_EXE=""
 AC_SUBST(GFORTHDITC_EXE)  AC_SUBST(GFORTHDITC_EXE)
 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 309  else Line 588  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"; then
       skipcode=no
       CFLAGS_1="$CFLAGS"
       CFLAGS="$CFLAGS $ENGINE_FLAGS"
       for i in ".skip 16" ".block 16" ".org .+16" ".=.+16" ".space 16"
       do
           AC_TRY_RUN(
   [int foo(int,int,int);
   main()
   {
     exit(foo(0,0,0)!=16);
   }
   int foo(int x, int y, int z)
   {
     static void *labels[]={&&label1, &&label2};
     if (x) {
       y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */
     label1:
       asm("$i"); /* or ".space 16" or somesuch */
     label2: ;
     }
     {
     if (y) goto *labels[z]; /* workaround for gcc PR12108 */
     return labels[1]-labels[0];
     }
   }]
           ,skipcode=$i; break
           ,,)
       done
       CFLAGS=$CFLAGS_1
   fi
   AC_MSG_RESULT($skipcode)
   if test "$skipcode" = no
   then 
       if test -z $no_dynamic_default; then
           no_dynamic_default=1
           AC_MSG_WARN(Disabling default dynamic native code generation)
       fi
       AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes)
   else
       AC_DEFINE_UNQUOTED(SKIP16,asm("$skipcode"),statement for skipping 16 bytes)
   fi
   
   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 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(dl,dlopen)
   dnl check for libffi 2.x
   AC_CHECK_LIB(ffi,ffi_call)
   if test $ac_cv_lib_ffi_ffi_call = yes
   then
   LIBFFIFLAG="true"
   FFCALLFLAG="false"
   OLDCALLFLAG="false"
   AC_DEFINE(HAS_LIBFFI,,[define this if you want to use the ffcall interface with libffi 2.0])
   else
   dnl check for ffcall libraries
   dnl unfortunately, these four calls are separated out into a library each.
   AC_CHECK_LIB(avcall,__builtin_avcall)
   AC_CHECK_LIB(callback,__vacall_r)
   AC_CHECK_LIB(vacall,vacall)
   AC_CHECK_LIB(trampoline,alloc_trampoline)
   LIBFFIFLAG="false"
   FFCALLFLAG="false"
   OLDCALLFLAG="true"
   test $ac_cv_lib_avcall___builtin_avcall = yes && FFCALLFLAG="true" && OLDCALLFLAG="false" && AC_DEFINE(HAS_FFCALL,,[define this if you want to use the ffcall libraries])
   test $ac_cv_lib_avcall___builtin_avcall = no && AC_DEFINE(HAS_OLDCALL,,[define this if you want to use the old call libraries])
   fi
   AC_SUBST(LIBFFIFLAG)
   AC_SUBST(FFCALLFLAG)
   AC_SUBST(OLDCALLFLAG)
 if test "$host_os" != "nextstep3"  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_CHECK_FUNCS(dlopen sys_siglist)  AC_FUNC_FSEEKO
   AC_CHECK_FUNCS(ftello dlopen sys_siglist getrusage)
   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)  AC_CHECK_HEADERS(sys/mman.h fnmatch.h)
   AC_FUNC_FNMATCH
   test $ac_cv_func_fnmatch_works = yes || AC_LIBOBJ(fnmatch)
 AC_CHECK_FUNCS(mmap sysconf getpagesize)  AC_CHECK_FUNCS(mmap sysconf getpagesize)
 AM_PATH_LISPDIR  AM_PATH_LISPDIR
   
 kernel_fi=kernl${wordsize}${bytesex}.fi  kernel_fi=kernl${wordsize}${bytesex}.fi
 AC_SUBST(kernel_fi)  AC_SUBST(kernel_fi)
   
 dnl replace srource directory by absolute value  #this breaks bindists
 if test $srcdir = "."; then srcdir=`pwd`   #dnl replace srource directory by absolute value
 fi  #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
   vmgen
   machpc.fs
   envos.fs
 engine/Makefile  engine/Makefile
 doc/version.texi ],  doc/version.texi
 echo timestamp > stamp-h  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
   test -d kernel||mkdir kernel]],[[]])
   AC_OUTPUT
   

Removed from v.1.58  
changed lines
  Added in v.1.170


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