File:  [gforth] / gforth / configure.in
Revision 1.75: download - view: text, annotated - select for diffs
Sat Sep 23 18:59:00 2000 UTC (19 years ago) by anton
Branches: MAIN
CVS tags: v0-5-0, HEAD
updated version number and README

dnl Process this file with autoconf to produce a configure script.

#Copyright (C) 1995,1996,1997,1998,2000 Free Software Foundation, Inc.

#This file is part of Gforth.

#Gforth is free software; you can redistribute it and/or
#modify it under the terms of the GNU General Public License
#as published by the Free Software Foundation; either version 2
#of the License, or (at your option) any later version.

#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.#See the
#GNU General Public License for more details.

#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.

AC_INIT(engine/engine.c)

dnl We use some automake macros here,
dnl but don't use automake for creating Makefile.in
AM_INIT_AUTOMAKE(gforth,0.5.0)
#snapshots have numbers major.minor.release-YYYYMMDD
#note that lexicographic ordering bust be heeded.
#I.e., 0.4.1-YYYYMMDD must not exist before 0.4.1!
AM_CONFIG_HEADER(engine/config.h)
#AM_CYGWIN32

AC_ARG_ENABLE(force-reg,
[  --enable-force-reg	  Use explicit register declarations if they appear in
			  the machine.h file. This can cause a good speedup,
			  but also incorrect code with some gcc versions on
			  some processors (default disabled).],

AC_DEFINE(FORCE_REG))
dnl this is not quite according to the autoconf manual, it causes a replacement
AC_ARG_ENABLE(direct-threaded,
[  --enable-direct-threaded	Force direct threading. This may not work on
				some machines and may cause slowdown on others.
				(default processor-dependent)],
AC_DEFINE(DIRECT_THREADED))
AC_ARG_ENABLE(indirect-threaded,
[  --enable-indirect-threaded	Force indirect threading. This can cause a
				slowdown on some machines.
				(default processor-dependent)],
AC_DEFINE(INDIRECT_THREADED))

AC_ARG_WITH(debug,
[  --with-debug     specifies option -g to compile with debug info (default)
  --without-debug  omits the -g switch and creates smaller images on
                   machines where "strip" has problems with gcc style
                   debugging informations.],
if test "$withval" = "yes"; then DEBUGFLAG=-g; fi)

CFLAGS=$CFLAGS

AC_PROG_CC

if test "$GCC" = "yes"
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(DEBUGFLAG)

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_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
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
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])
OLDLDFLAGS=$LDFLAGS
LDFLAGS="$LDFLAGS -export-dynamic"
dnl AC_TRY_LINK gives false positive on rs6000-ibm-aix4.2.1.0
dnl AC_TRY_LINK(,,ac_export_dynamic=yes,ac_export_dynamic=no)
AC_TRY_RUN(main(){exit(0);},ac_export_dynamic=yes,ac_export_dynamic=no,ac_export_dynamic=no)
test $ac_export_dynamic = yes|| LDFLAGS=$OLDLDFLAGS
AC_MSG_RESULT($ac_export_dynamic)

#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'
AC_CANONICAL_HOST
case "$host_cpu" in
	hppa*)
		machine=hppa
		$srcdir/mkinstalldirs arch/hppa
		LIBOBJS="$LIBOBJS ../arch/hppa/cache.o"
		LDFLAGS="$LDFLAGS -Xlinker -N"
		LIBS="$LIBS -L/lib/pa1.1/"
		if test "${enable_direct_threaded+set}" = ""
		then
			AC_DEFINE(DIRECT_THREADED)
		fi
		;;
	sparc*)
		machine=sparc
		;;
	i386)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
		if test "${enable_direct_threaded+set}" = "" \
			-a "${enable_indirect_threaded+set}" = ""
		then
			echo "Using direct threaded code on 386"
			AC_DEFINE(DIRECT_THREADED)
		fi
		;;
	i486)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem -m486"
		if test "${enable_direct_threaded+set}" = "" \
			-a "${enable_indirect_threaded+set}" = ""
		then
			echo "Using direct threaded code on 486"
			AC_DEFINE(DIRECT_THREADED)
		fi
		;;
	i586)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
		CFLAGS_1="$CFLAGS"
		CFLAGS="$CFLAGS -mpentium"
		AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
		if test "${enable_direct_threaded+set}" = "" \
			-a "${enable_indirect_threaded+set}" = ""
		then
			echo "Using indirect threaded code on Pentium/K5/K6"
			AC_DEFINE(INDIRECT_THREADED)
		fi
		;;
	i686)
		machine=386
		CFLAGS="$CFLAGS -fomit-frame-pointer -fforce-addr -fforce-mem"
		CFLAGS_1="$CFLAGS"
		CFLAGS="$CFLAGS -mpentium"
		AC_TRY_COMPILE(,,,CFLAGS="$CFLAGS_1 -m486")
		if test "${enable_direct_threaded+set}" = "" \
			-a "${enable_indirect_threaded+set}" = ""
		then
			echo "Using direct threaded code on Athlon/PPro/Pentium II/Pentium III"
			AC_DEFINE(DIRECT_THREADED)
		fi
		;;
	ia64*)
		machine=ia64
		;;
        m68k)
		machine=m68k
		CFLAGS="$CFLAGS -fomit-frame-pointer"
		if test "$host_os" = "nextstep3"
		then
			LIBOBJS="$LIBOBJS termios.o"
		fi
		;;
	mips*)
		machine=mips
		#link text and data segment into the same 256M region!
		AC_MSG_CHECKING([whether the linker accepts -T])
		OLDLDFLAGS=$LDFLAGS
		LDFLAGS="$LDFLAGS -Xlinker -T -Xlinker 10000000"
		AC_TRY_LINK(,,ac_link_mips_t=yes,ac_link_mips_t=no)
		test $ac_link_mips_t = yes||LDFLAGS=$OLDLDFLAGS
		AC_MSG_RESULT($ac_link_mips_t)
		test $ac_link_mips_t = yes||(echo cannot link text and data into same 256M region, using indirect threading; AC_DEFINE(INDIRECT_THREADED))
		AC_MSG_CHECKING([whether the linker accepts -D])
		OLDLDFLAGS=$LDFLAGS
		LDFLAGS="$LDFLAGS -Xlinker -D -Xlinker 10400000"
		AC_TRY_LINK(,,ac_link_mips_d=yes,ac_link_mips_d=no)
		test $ac_link_mips_d = yes||LDFLAGS=$OLDLDFLAGS
		AC_MSG_RESULT($ac_link_mips_d)
		;;
	alpha*)
		machine=alpha
		#full IEEE FP support for more uniformity across platforms:
		CFLAGS="$CFLAGS -mieee"
		;;
	power*|rs6000)
		machine=power
		$srcdir/mkinstalldirs arch/power
		AC_CHECK_FUNC(_sync_cache_range,true,LIBOBJS="$LIBOBJS ../arch/power/_sync_cache_range.o")
		#link text segment into first 32MB
		AC_MSG_CHECKING([whether the linker accepts --script=arch/power/elf32ppc.x])
		OLDLDFLAGS=$LDFLAGS
                #the -L../$srcdir helps when $srcdir is relative
		LDFLAGS="$LDFLAGS -L$srcdir -L../$srcdir -Xlinker --script=$srcdir/arch/power/elf32ppc.x"
		AC_TRY_LINK(,,ac_link_script=yes,ac_link_script=no)
		test $ac_link_script = yes||LDFLAGS=$OLDLDFLAGS
		AC_MSG_RESULT($ac_link_script)
		AC_MSG_CHECKING([whether the code is in the first 32MB])
		AC_TRY_RUN([main(){label: exit(((unsigned long)&&label)>32000000UL);}],ac_code_under_32=yes,ac_code_under_32=no,ac_code_under_32=no)
                AC_MSG_RESULT($ac_code_under_32)
		test $ac_code_under_32 = yes||(AC_MSG_WARN([Using indirect threading]); AC_DEFINE(INDIRECT_THREADED))
		;;
	*)
		echo "No direct threading support for $host_cpu, using indirect threading."
		echo "Using a generic machine description."
		echo "I'll assume that C floats and doubles are represented by IEEE single and"
		echo "double numbers. If this is not so, SF@ etc. will not work correctly."
		echo "FLUSH-ICACHE will do nothing, so END-CODE may not work properly!"
		machine=generic
esac
AC_SUBST(host)
AC_SUBST(ENGINE_FLAGS)

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)

case "$host_os" in
	*win32)
		EXE=".exe"
		;;
	*)
		EXE=""
		;;
esac
AC_SUBST(EXE)

dnl Now a little support for DOS/DJGCC
AC_SUBST(GFORTH_EXE)
GFORTH_EXE=""
AC_SUBST(GFORTHFAST_EXE)
GFORTHFAST_EXE=""
AC_SUBST(GFORTHDITC_EXE)
GFORTHDITC_EXE=""

PATHSEP=":"
AC_SUBST(PATHSEP)
AC_DEFINE_UNQUOTED(PATHSEP,'$PATHSEP')

AC_SUBST(FORTHSIZES)

dnl copy commands for systems that don't have links
AC_SUBST(LINK_KERNL)
LINK_KERNL=""

#if test $host_os=dos
#then
#  echo Configuring for DOS!!!
#  MAKE_EXE="coff2exe gforth"
#  LINK_KERNL='$(CP) kernl32l.fi kernel.fi'
#fi

dnl the following macro produces a warning with autoconf-2.1
AC_C_BIGENDIAN
AC_SUBST(KERNEL)
dnl ac_cv_c_bigendian is an undocumented variable of autoconf-2.1
if test $ac_cv_c_bigendian = yes; then
  bytesex=b
  KERNEL="kernl16b.fi kernl16l.fi kernl32b.fi kernl32l.fi kernl64b.fi kernl64l.fi"
else
  bytesex=l
  KERNEL="kernl16l.fi kernl16b.fi kernl32l.fi kernl32b.fi kernl64l.fi kernl64b.fi"
fi

dnl Checks for programs.
AC_PROG_LN_S
dnl AM_PROG_INSTALL #performed by AM_INIT_AUTOMAKE

dnl Checks for library functions
dnl This check is just for making later checks link with libm.
dnl using sin here is no good idea since it is built-into gcc and typechecked
AC_CHECK_LIB(m,asin)
AC_CHECK_LIB(dl,dlopen)
if test "$host_os" != "nextstep3"
then
	AC_FUNC_MEMCMP
fi
AC_REPLACE_FUNCS(memmove strtoul pow10 strerror strsignal atanh)
AC_CHECK_FUNCS(dlopen sys_siglist getrusage)
AC_DECL_SYS_SIGLIST
AC_CHECK_FUNC(getopt_long,true,LIBOBJS="$LIBOBJS getopt.o getopt1.o")
AC_CHECK_FUNCS(rint expm1 log1p)
AC_REPLACE_FUNCS(ecvt)
dnl No check for select, because our replacement is no good under
dnl anything but DOS
AC_CHECK_HEADERS(sys/mman.h fnmatch.h)
AC_FUNC_FNMATCH
test $ac_cv_func_fnmatch_works = yes || LIBOBJS="$LIBOBJS fnmatch.o"
AC_CHECK_FUNCS(mmap sysconf getpagesize)
AM_PATH_LISPDIR

kernel_fi=kernl${wordsize}${bytesex}.fi
AC_SUBST(kernel_fi)

dnl replace srource directory by absolute value
if test $srcdir = "."; then srcdir=`pwd` 
fi

AC_SUBST(machine)
dnl AC_LINK_FILES(arch/$machine,arch/machine) #no longer needed
AC_OUTPUT([
Makefile
Makedist
gforthmi
engine/Makefile
doc/version.texi ],
echo timestamp > stamp-h
chmod +x gforthmi
test -d kernel||mkdir kernel)


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