[gforth] / gforth / configure.in  

gforth: gforth/configure.in

Diff for /gforth/configure.in between version 1.98 and 1.138

version 1.98, Tue Jan 7 09:31:19 2003 UTC version 1.138, Sat Apr 10 10:15:06 2004 UTC
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 Free Software Foundation, Inc.  #Copyright (C) 1995,1996,1997,1998,2000,2003 Free Software Foundation, Inc.
   
 #This file is part of Gforth.  #This file is part of Gforth.
   
Line 18 
Line 18 
 #along with this program; if not, write to the Free Software  #along with this program; if not, write to the Free Software
 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.  #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.5.9-20021227],[https://savannah.gnu.org/bugs/?func=addbug&group=gforth])  AC_INIT([gforth],[0.6.2-20030910],[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 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="27 December 2002"  UPDATED="September 10, 2003"
 AC_SUBST(UPDATED)  AC_SUBST(UPDATED)
 AC_CONFIG_HEADERS(engine/config.h)  AC_CONFIG_HEADERS(engine/config.h)
   
 #default setting that may be changed later:  #suppress the "-g -O2" default
 no_dynamic_default=0  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  [  --enable-force-reg     Use explicit register declarations if they appear in
Line 37 
Line 39 
                           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).],
 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_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_SUBST(PROFEXES)
   AC_SUBST(PROFOBJS)
   AC_ARG_ENABLE(prof,
   [  --enable-prof          Build gforth-prof, which outputs frequently occuring
                             sequences of primitives.],
   PROFEXES="gforth-prof\$(EXE)"; PROFOBJS="engine-prof.o main-prof.o profile.o")
   
 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)
   
 PEEPHOLE="yes"  dnl PEEPHOLE="yes"
 AC_ARG_WITH(peephole,  dnl AC_ARG_WITH(peephole,
 [  --with-peephole      Enable peephole optimization (default)  dnl [  --with-peephole  Enable peephole optimization (default)
   --without-peephole    disables peephole optimization. Creates smaller,  dnl   --without-peephole        disables peephole optimization. Creates smaller,
                         but slower images.],  dnl                     but slower images.],
 PEEPHOLE="$withval")  dnl PEEPHOLE="$withval")
   
   #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(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_c_bigendian, [Is the target big-endian ("yes" or "no")?])
   AC_ARG_VAR(no_dynamic_default, [run gforth with --dynamic (0) or --no-dynamic (1) by default])
   AC_ARG_VAR(skip_code, [assembly code for skipping 16 bytes of code])
   
 #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 64 
Line 87 
 dnl AC_DEFINE_UNQUOTED([_POSIX_C_SOURCE],199506L,[feature test macro])  dnl AC_DEFINE_UNQUOTED([_POSIX_C_SOURCE],199506L,[feature test macro])
 dnl AC_DEFINE_UNQUOTED([_XOPEN_SOURCE],600,[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  # turn on large file support with 64-bit off_t where available
 AC_DEFINE_UNQUOTED([_LARGEFILE_SOURCE],1,[feature test macro])  AC_SYS_LARGEFILE
 AC_DEFINE_UNQUOTED([_FILE_OFFSET_BITS],64,[feature test macro])  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  #currently we force direct threading this way.  Eventually we should
 #setup in the arch and engine files right  #setup in the arch and engine files right
   
 CFLAGS=$CFLAGS  
   
 AC_PROG_CC  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)
Line 79 
Line 101 
 AC_SUBST(CC)  AC_SUBST(CC)
 AC_SUBST(DEBUGFLAG)  AC_SUBST(DEBUGFLAG)
   
 dnl gcc-3.2 seems to work fine now  AC_MSG_CHECKING(make type)
 dnl AC_MSG_CHECKING(gcc version)  make_type=`make -v 2>&1|grep 'ake version'|sed 's/ version .*//'`
 dnl gcc_version=`$CC -v 2>&1|grep 'gcc version'|sed 's/.*gcc version //'`  
 dnl AC_MSG_RESULT($gcc_version)  
 dnl if expr "$gcc_version" \> 3.0.4 >/dev/null && expr "$gcc_version" \< 3.2.1 >/dev/null  
 dnl then  
 dnl    no_dynamic_default=1  
 dnl    AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))  
 dnl fi  
   
 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)  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_MSG_CHECKING([for a C type for cells])  AC_MSG_RESULT($make_type)
 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"  
     ;;  
 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 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"  
     ;;  
 esac  
 AC_MSG_RESULT($ac_cv_int_type_double_cell)  
 if test "$ac_cv_int_type_double_cell" = 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])  
 fi  
   
 AC_TYPE_OFF_T  AC_SUBST(GNUMAKE)
 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])  
   
 AC_MSG_CHECKING([whether the linker accepts -export-dynamic])  AC_MSG_CHECKING([whether the linker accepts -export-dynamic])
 OLDLDFLAGS=$LDFLAGS  OLDLDFLAGS=$LDFLAGS
Line 175 
Line 124 
 #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
                 AC_LIBOBJ(../arch/hppa/cache)                  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/"
                 ;;                  ;;
Line 200 
Line 158 
                 CFLAGS="$CFLAGS -march=pentium"                  CFLAGS="$CFLAGS -march=pentium"
                 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")                  AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
                 ;;                  ;;
 #generic should work for IA64          x86_64)
 #       ia64*)                  machine=amd64
 #               machine=ia64                  ;;
 #               ;;          ia64*)
                   machine=ia64
                   AC_LIBOBJ(../arch/ia64/flush_icache_block)
                   test "$skipcode" || skipcode="nop.i 0"
                   #".skip 16" passes the test below,
                   # but gives an assembler error in engine
                   ;;
         m68k)          m68k)
                 machine=m68k                  machine=m68k
                 CFLAGS="$CFLAGS -fomit-frame-pointer"                  CFLAGS="$CFLAGS -fomit-frame-pointer"
Line 211 
Line 175 
                 then                  then
                         AC_LIBOBJ(termios)                          AC_LIBOBJ(termios)
                 fi                  fi
                 #I-cache flushing would be needed for dynamic code generation  
                 no_dynamic_default=1  
                 AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))  
                 ;;                  ;;
         mips*)          mips*)
                 machine=mips                  machine=mips
Line 230 
Line 191 
                 #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
                 no_dynamic_default=1                  no_dynamic_default=1
                 AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))                      AC_MSG_WARN([Disabling default dynamic native code generation (relocation and delay slot issues)])
                 #link text and data segment into the same 256M region!                  fi
                 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)  
                 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*)          alpha*)
                 machine=alpha                  machine=alpha
Line 254 
Line 204 
         power*|rs6000)          power*|rs6000)
                 machine=power                  machine=power
                 $srcdir/mkinstalldirs arch/power                  $srcdir/mkinstalldirs arch/power
                 AC_CHECK_FUNC(_sync_cache_range,true,AC_LIBOBJ(../arch/power/_sync_cache_range))                  AC_CHECK_FUNC(_sync_cache_range,[true],[AC_LIBOBJ(../arch/power/_sync_cache_range)])
                   #long long is broken on (at least) gcc-2.95.* for PPC
                   test x$ac_cv_sizeof_long_long = x && ac_cv_sizeof_long_long=0
                 ;;                  ;;
         *)          *)
                 AC_MSG_WARN([Using a generic machine description])                  AC_MSG_WARN([Using a generic machine description])
Line 262 
Line 214 
                 AC_MSG_WARN([FLUSH-ICACHE will do nothing, so END-CODE may not work properly!])                  AC_MSG_WARN([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                  #I-cache flushing would be needed for dynamic code generation
                   if test -z $no_dynamic_default; then
                 no_dynamic_default=1                  no_dynamic_default=1
                 AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))                      AC_MSG_WARN([No I-cache flush code known, disabling dynamic native code generation])
                   fi
 esac  esac
 AC_SUBST(host)  AC_SUBST(host)
   
   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_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 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)
   if test "$ac_cv_int_type_double_cell" = 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])
   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-cross-jump  # Try if GCC understands -fno-gcse
   
   AC_MSG_CHECKING([if $CC understands -fno-gcse])
 CFLAGS_1="$CFLAGS"  CFLAGS_1="$CFLAGS"
 CFLAGS="$CFLAGS -fno-cross-jump"  CFLAGS="$CFLAGS -fno-gcse"
 AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1")  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_CHECK_PROG(asm_fs,asm.fs,arch/$machine/asm.fs,,$srcdir/arch/$machine)
 AC_SUBST(asm_fs)  AC_SUBST(asm_fs)
Line 280 
Line 356 
 AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)  AC_CHECK_PROG(disasm_fs,disasm.fs,arch/$machine/disasm.fs,,$srcdir/arch/$machine)
 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)          *win32|cygwin)
                 EXE=".exe"                  DIRSEP="\\\\"
                 DIRSEP="\\"                  PATHSEP=";"
                 ;;                  ;;
         *darwin*)          *darwin*)
                 #Darwin uses some funny preprocessor by default; eliminate it:                  #Darwin uses some funny preprocessor by default; eliminate it:
                 AC_MSG_NOTICE([using -traditional-cpp on Darwin])                  AC_MSG_NOTICE([using -no-cpp-precomp on Darwin])
                 CFLAGS="$CFLAGS -traditional-cpp"                  CFLAGS="$CFLAGS -no-cpp-precomp"
                 EXE=""  
                 DIRSEP="/"                  DIRSEP="/"
                   PATHSEP=":"
                 ;;                  ;;
         *)          *)
                 EXE=""  
                 DIRSEP="/"                  DIRSEP="/"
                   PATHSEP=":"
                 ;;                  ;;
 esac  esac
 AC_SUBST(EXE)  
 AC_SUBST(DIRSEP)  AC_SUBST(DIRSEP)
 AC_DEFINE_UNQUOTED(DIRSEP,'$DIRSEP',[a directory separator character])  AC_DEFINE_UNQUOTED(DIRSEP,'$DIRSEP',[a directory separator character])
   AC_SUBST(PATHSEP)
   AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character])
   
   
 dnl Now a little support for DOS/DJGCC  dnl Now a little support for DOS/DJGCC
 AC_SUBST(GFORTH_EXE)  AC_SUBST(GFORTH_EXE)
Line 311 
Line 391 
 AC_SUBST(GFORTHDITC_EXE)  AC_SUBST(GFORTHDITC_EXE)
 GFORTHDITC_EXE=""  GFORTHDITC_EXE=""
   
 PATHSEP=":"  
 AC_SUBST(PATHSEP)  
 AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP',[a path separator character])  
   
 AC_SUBST(FORTHSIZES)  AC_SUBST(FORTHSIZES)
   
 if test "$PEEPHOLE" = "yes"  dnl if test "$PEEPHOLE" = "yes"
 then  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"     PEEPHOLEFLAG="true"
    AC_DEFINE(HAS_PEEPHOLE,,[Define if you want to use peephole optimization])  
 else  
    PEEPHOLEFLAG="false"  
 fi  
 AC_SUBST(PEEPHOLEFLAG)  AC_SUBST(PEEPHOLEFLAG)
   
 dnl copy commands for systems that don't have links  dnl copy commands for systems that don't have links
Line 351 
Line 428 
   
 #check how to do asm(".skip 16")  #check how to do asm(".skip 16")
 AC_MSG_CHECKING([if and how we can waste code space])  AC_MSG_CHECKING([if and how we can waste code space])
 skipcode=no  if test -z "$skipcode"; then
 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(
 int foo(int);  [int foo(int,int,int);
 main()  main()
 {  {
   exit(foo(0)!=16);    exit(foo(0,0,0)!=16);
 }  }
 int foo(int x)  int foo(int x, int y, int z)
 {  {
     static void *labels[]={&&label1, &&label2};
   if (x) {    if (x) {
       y++; /* workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12108 */
   label1:    label1:
     asm("$i");      asm(".skip 16"); /* or ".space 16" or somesuch */
   label2:    label2: ;
   }    }
   return (&&label2)-(&&label1);    {
     if (y) goto *labels[z]; /* workaround for gcc PR12108 */
     return labels[1]-labels[0];
 }  }
   }]
         ,skipcode=$i; break          ,skipcode=$i; break
         ,,)          ,,)
 done  done
   fi
 AC_MSG_RESULT($skipcode)  AC_MSG_RESULT($skipcode)
 if test "$skipcode" = no  if test "$skipcode" = no
 then  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)
       fi
     AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes)      AC_DEFINE_UNQUOTED(SKIP16,((void)0),statement for skipping 16 bytes)
     AC_MSG_WARN(Disabling dynamic native code generation by default (speed penalty factor ~2))  
 else  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
   
   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.
Line 393 
Line 479 
 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 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)
   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])
   AC_SUBST(FFCALLFLAG)
   AC_SUBST(OLDCALLFLAG)
 if test "$host_os" != "nextstep3"  if test "$host_os" != "nextstep3"
 then  then
         AC_FUNC_MEMCMP          AC_FUNC_MEMCMP
Line 400 
Line 498 
 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)
 AC_CHECK_TYPES(stack_t)  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)])
 AC_CHECK_FUNCS(expm1 log1p)  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

Generate output suitable for use with a patch program
Legend:
Removed from v.1.98  
changed lines
  Added in v.1.138
CVS Admin

Powered by ViewCVS 1.0-dev 		(Powered by ViewCVS)

ViewCVS and CVS Help