dnl configuration script for Guile
dnl Process this file with autoconf to produce configure.
dnl
-dnl Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+dnl Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
dnl
dnl This file is part of GUILE
dnl
AC_PREREQ(2.53)
AC_INIT
-AC_CONFIG_SRCDIR([Makefile.in])
+AC_CONFIG_SRCDIR([GUILE-VERSION])
. $srcdir/GUILE-VERSION
AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)
AM_MAINTAINER_MODE
-AM_CONFIG_HEADER(libguile/scmconfig.h)
+AM_CONFIG_HEADER([config.h])
#--------------------------------------------------------------------
#
AC_CONFIG_SUBDIRS(guile-readline)
+#--------------------------------------------------------------------
+
+dnl Some more checks for Win32
+AC_CYGWIN
+AC_MINGW32
+AC_LIBTOOL_WIN32_DLL
+
+AC_PROG_INSTALL
+AC_PROG_CC
+AC_PROG_CPP
+AC_PROG_AWK
+
+AC_AIX
+AC_ISC_POSIX
+AC_MINIX
+
+AM_PROG_CC_STDC
+
+AC_LIBTOOL_DLOPEN
+AM_PROG_LIBTOOL
+AC_LIB_LTDL
+
+AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
+AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
+
#--------------------------------------------------------------------
#
-# User options
+# User options (after above tests that may set default CFLAGS etc.)
#
#--------------------------------------------------------------------
*) AC_MSG_ERROR(bad value ${enableval} for --enable-error-on-warning) ;;
esac])
+SCM_I_GSC_GUILE_DEBUG_FREELIST=0
AC_ARG_ENABLE(debug-freelist,
[ --enable-debug-freelist include garbage collector freelist debugging code],
- if test "$enable_debug_freelist" = y || test "$enable_debug_freelist" = yes; then
- AC_DEFINE(GUILE_DEBUG_FREELIST, 1,
- [Define this if you want to debug the free list (helps w/ GC bugs).])
+ if test "$enable_debug_freelist" = y \
+ || test "$enable_debug_freelist" = yes; then
+ SCM_I_GSC_GUILE_DEBUG_FREELIST=1
fi)
AC_ARG_ENABLE(debug-malloc,
[Define this if you want to debug scm_must_malloc/realloc/free calls.])
fi)
+SCM_I_GSC_GUILE_DEBUG=0
AC_ARG_ENABLE(guile-debug,
- [ --enable-guile-debug include internal debugging functions],
+ [AC_HELP_STRING([--enable-guile-debug],
+ [include internal debugging functions])],
if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then
- AC_DEFINE(GUILE_DEBUG, 1,
- [Define this to include various undocumented functions used to debug.])
+ SCM_I_GSC_GUILE_DEBUG=1
fi)
AC_ARG_ENABLE(arrays,
- [ --disable-arrays omit array and uniform array support],,
+ [AC_HELP_STRING([--disable-arrays],[omit array and uniform array support])],
+ ,
enable_arrays=yes)
AC_ARG_ENABLE(posix,
AM_CONDITIONAL(HTMLDOC, test x$htmldoc_enabled = xyes)
-AC_ARG_ENABLE(deprecated,
- [ --disable-deprecated omit deprecated features])
-
-AH_TEMPLATE([SCM_ENABLE_DEPRECATED],
- [Define this to 1 if you want to include deprecated features.])
+AC_ARG_ENABLE([deprecated],
+ AC_HELP_STRING([--disable-deprecated],[omit deprecated features]))
if test "$enable_deprecated" = no; then
- AC_DEFINE(SCM_ENABLE_DEPRECATED, 0)
+ SCM_I_GSC_ENABLE_DEPRECATED=0
else
if test "$enable_deprecated" = yes || test "$enable_deprecated" = ""; then
warn_default=summary
else
warn_default=$enable_deprecated
fi
- AC_DEFINE(SCM_ENABLE_DEPRECATED, 1)
+ SCM_I_GSC_ENABLE_DEPRECATED=1
AC_DEFINE_UNQUOTED(SCM_WARN_DEPRECATED_DEFAULT, "$warn_default",
[Define this to control the default warning level for deprecated features.])
fi
-dnl The --disable-debug used to control these two. But now they are
-dnl a required part of the distribution.
-AC_DEFINE(DEBUG_EXTENSIONS, 1,
- [Define if you want support for debugging Scheme programs.])
-AC_DEFINE(READER_EXTENSIONS, 1,
- [Define if you want support for debugging Scheme programs.])
-
AC_ARG_ENABLE(elisp,
[ --disable-elisp omit Emacs Lisp support],,
enable_elisp=yes)
#--------------------------------------------------------------------
-dnl Some more checks for Win32
-AC_CYGWIN
-AC_MINGW32
-AC_LIBTOOL_WIN32_DLL
-
-AC_PROG_INSTALL
-AC_PROG_CC
-AC_PROG_CPP
-AC_PROG_AWK
-
-AC_AIX
-AC_ISC_POSIX
-AC_MINIX
-
-AM_PROG_CC_STDC
-
-AC_LIBTOOL_DLOPEN
-AM_PROG_LIBTOOL
-AC_LIB_LTDL
-
-AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
-AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
-
dnl Check for dynamic linking
use_modules=yes
test -z "$use_modules" && use_modules=yes
DLPREOPEN=
if test "$use_modules" != no; then
- AC_DEFINE(DYNAMIC_LINKING, 1,
- [Define if you want support for dynamic linking.])
if test "$use_modules" = yes; then
DLPREOPEN="-dlpreopen force"
else
AC_LIBOBJ([dynl])
fi
+SCM_I_GSC_HAVE_ARRAYS=0
if test "$enable_arrays" = yes; then
AC_LIBOBJ([ramap])
AC_LIBOBJ([unif])
- AC_DEFINE(HAVE_ARRAYS, 1,
- [Define this if you want support for arrays and uniform arrays.])
+ SCM_I_GSC_HAVE_ARRAYS=1
fi
if test "$enable_posix" = yes; then
fi
if test "$enable_elisp" = yes; then
- AC_DEFINE(SCM_ENABLE_ELISP, 1,
- [Define this if you want Elisp support (in addition to Scheme).])
+ SCM_I_GSC_ENABLE_ELISP=1
+else
+ SCM_I_GSC_ENABLE_ELISP=0
fi
-
AC_C_CONST
-AC_C_INLINE
-AC_C_BIGENDIAN
+AC_C_INLINE
if test "$ac_cv_c_inline" != no; then
- AC_DEFINE(HAVE_INLINE, 1,
- [Define if the compiler supports inline functions.])
+ SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\""
+else
+ SCM_I_GSC_C_INLINE=NULL
fi
+AC_C_BIGENDIAN
+
+AC_CHECK_SIZEOF(char)
+AC_CHECK_SIZEOF(unsigned char)
AC_CHECK_SIZEOF(short)
+AC_CHECK_SIZEOF(unsigned short)
AC_CHECK_SIZEOF(int)
+AC_CHECK_SIZEOF(unsigned int)
AC_CHECK_SIZEOF(long)
+AC_CHECK_SIZEOF(unsigned long)
AC_CHECK_SIZEOF(size_t)
-
-dnl Check for integral types that can represent the range of pointers.
-dnl If these types don't exist on this platform, they are replaced by
-dnl "unsigned long" and "long", respectively.
-
-AC_CHECK_HEADERS(stdint.h)
-AC_CHECK_HEADERS(inttypes.h)
-AC_CHECK_SIZEOF(uintptr_t)
-AC_CHECK_SIZEOF(ptrdiff_t)
-
AC_CHECK_SIZEOF(long long)
-
+AC_CHECK_SIZEOF(unsigned long long)
AC_CHECK_SIZEOF(void *)
+AC_CHECK_SIZEOF(intptr_t)
+AC_CHECK_SIZEOF(uintptr_t)
+AC_CHECK_SIZEOF(ptrdiff_t)
if test "$ac_cv_sizeof_long" -ne "$ac_cv_sizeof_void_p"; then
AC_MSG_ERROR(sizes of long and void* are not identical)
fi
+if test "$ac_cv_sizeof_ptrdiff_t" -eq 0; then
+ SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"'
+else
+ SCM_I_GSC_T_PTRDIFF='"long"'
+fi
+AC_SUBST([SCM_I_GSC_T_PTRDIFF])
+
+AC_CHECK_HEADERS([stdint.h])
+AC_CHECK_HEADERS([inttypes.h])
+
+SCM_I_GSC_NEEDS_STDINT_H=0
+SCM_I_GSC_NEEDS_INTTYPES_H=0
+
+### intptr and uintptr (try not to use inttypes if we don't have to)
+if test "$ac_cv_header_inttypes_h" = yes; then
+ if test "$ac_cv_sizeof_intptr_t" -eq 0; then
+ AC_CHECK_SIZEOF([intptr_t],,[#include <inttypes.h>
+#include <stdio.h>])
+ if test "$ac_cv_sizeof_intptr_t" -ne 0; then
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+ fi
+ fi
+ if test "$ac_cv_sizeof_uintptr_t" -eq 0; then
+ AC_CHECK_SIZEOF([uintptr_t],,[#include <inttypes.h>
+#include <stdio.h>])
+ if test "$ac_cv_sizeof_uintptr_t" -ne 0; then
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+ fi
+ fi
+fi
+
+### See what's provided by stdint.h
+if test "$ac_cv_header_stdint_h" = yes; then
+ AC_CHECK_TYPE([int8_t],[scm_stdint_has_int8=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([uint8_t],[scm_stdint_has_uint8=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([int16_t],[scm_stdint_has_int16=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([uint16_t],[scm_stdint_has_uint16=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([int32_t],[scm_stdint_has_int32=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([uint32_t],[scm_stdint_has_uint32=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([int64_t],[scm_stdint_has_int64=1],,[#include <stdint.h>])
+ AC_CHECK_TYPE([uint64_t],[scm_stdint_has_uint64=1],,[#include <stdint.h>])
+fi
+
+# so we don't get confused by the cache (wish there was a better way
+# to check particular headers for the same type...)
+
+unset ac_cv_type_int8_t
+unset ac_cv_type_uint8_t
+unset ac_cv_type_int16_t
+unset ac_cv_type_uint16_t
+unset ac_cv_type_int32_t
+unset ac_cv_type_uint32_t
+unset ac_cv_type_int64_t
+unset ac_cv_type_uint64_t
+
+### See what's provided by inttypes.h
+if test "$ac_cv_header_inttypes_h" = yes; then
+ AC_CHECK_TYPE([int8_t],[scm_inttypes_has_int8=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([uint8_t],[scm_inttypes_has_uint8=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([int16_t],[scm_inttypes_has_int16=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([uint16_t],[scm_inttypes_has_uint16=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([int32_t],[scm_inttypes_has_int32=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([uint32_t],[scm_inttypes_has_uint32=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([int64_t],[scm_inttypes_has_int64=1],,[#include <inttypes.h>])
+ AC_CHECK_TYPE([uint64_t],[scm_inttypes_has_uint64=1],,[#include <inttypes.h>])
+fi
+
+# Try hard to find definitions for some required scm_t_*int* types.
+
+### Required type scm_t_int8
+if test "$ac_cv_sizeof_char" -eq 1; then
+ SCM_I_GSC_T_INT8='"char"'
+elif test "$scm_stdint_has_int8"; then
+ SCM_I_GSC_T_INT8='"int8_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_int8"; then
+ SCM_I_GSC_T_INT8='"int8_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.])
+fi
+AC_SUBST([SCM_I_GSC_T_INT8])
+
+### Required type scm_t_uint8
+if test "$ac_cv_sizeof_unsigned_char" -eq 1; then
+ SCM_I_GSC_T_UINT8='"unsigned char"'
+elif test "$scm_stdint_has_uint8"; then
+ SCM_I_GSC_T_UINT8='"uint8_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_uint8"; then
+ SCM_I_GSC_T_UINT8='"uint8_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.])
+fi
+AC_SUBST([SCM_I_GSC_T_UINT8])
+
+
+### Required type scm_t_int16 (ANSI C says int or short might work)
+if test "$ac_cv_sizeof_int" -eq 2; then
+ SCM_I_GSC_T_INT16='"int"'
+elif test "$ac_cv_sizeof_short" -eq 2; then
+ SCM_I_GSC_T_INT16='"short"'
+elif test "$scm_stdint_has_int16"; then
+ SCM_I_GSC_T_INT16='"int16_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_int16"; then
+ SCM_I_GSC_T_INT16='"int16_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.])
+fi
+AC_SUBST([SCM_I_GSC_T_INT16])
+
+### Required type scm_t_uint16 (ANSI C says int or short might work)
+if test "$ac_cv_sizeof_unsigned_int" -eq 2; then
+ SCM_I_GSC_T_UINT16='"unsigned int"'
+elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then
+ SCM_I_GSC_T_UINT16='"unsigned short"'
+elif test "$scm_stdint_has_uint16"; then
+ SCM_I_GSC_T_UINT16='"uint16_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_uint16"; then
+ SCM_I_GSC_T_UINT16='"uint16_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.])
+fi
+AC_SUBST([SCM_I_GSC_T_UINT16])
+
+
+### Required type scm_t_int32 (ANSI C says int, short, or long might work)
+if test "$ac_cv_sizeof_int" -eq 4; then
+ SCM_I_GSC_T_INT32='"int"'
+elif test "$ac_cv_sizeof_long" -eq 4; then
+ SCM_I_GSC_T_INT32='"long"'
+elif test "$ac_cv_sizeof_short" -eq 4; then
+ SCM_I_GSC_T_INT32='"short"'
+elif test "$scm_stdint_has_int32"; then
+ SCM_I_GSC_T_INT32='"int32_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_int32"; then
+ SCM_I_GSC_T_INT32='"int32_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.])
+fi
+AC_SUBST([SCM_I_GSC_T_INT32])
+
+### Required type scm_t_uint32 (ANSI C says int, short, or long might work)
+if test "$ac_cv_sizeof_unsigned_int" -eq 4; then
+ SCM_I_GSC_T_UINT32='"unsigned int"'
+elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then
+ SCM_I_GSC_T_UINT32='"unsigned long"'
+elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then
+ SCM_I_GSC_T_UINT32='"unsigned short"'
+elif test "$scm_stdint_has_uint32"; then
+ SCM_I_GSC_T_UINT32='"uint32_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_uint32"; then
+ SCM_I_GSC_T_UINT32='"uint32_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.])
+fi
+AC_SUBST([SCM_I_GSC_T_UINT32])
+
+### Optional type scm_t_int64 (ANSI C says int, short, or long might work)
+### Also try long long if we have it.
+SCM_I_GSC_T_INT64=0
+if test "$ac_cv_sizeof_int" -eq 8; then
+ SCM_I_GSC_T_INT64='"int"'
+elif test "$ac_cv_sizeof_long" -eq 8; then
+ SCM_I_GSC_T_INT64='"long"'
+elif test "$ac_cv_sizeof_short" -eq 8; then
+ SCM_I_GSC_T_INT64='"short"'
+elif test "$ac_cv_sizeof_long_long" -eq 8; then
+ SCM_I_GSC_T_INT64='"long long"'
+elif test "$scm_stdint_has_int64"; then
+ SCM_I_GSC_T_INT64='"int64_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_int64"; then
+ SCM_I_GSC_T_INT64='"int64_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.])
+fi
+AC_SUBST([SCM_I_GSC_T_INT64])
+
+### Optional type scm_t_uint64 (ANSI C says int, short, or long might work)
+### Also try long long if we have it.
+SCM_I_GSC_T_UINT64=0
+if test "$ac_cv_sizeof_unsigned_int" -eq 8; then
+ SCM_I_GSC_T_UINT64='"unsigned int"'
+elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then
+ SCM_I_GSC_T_UINT64='"unsigned long"'
+elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then
+ SCM_I_GSC_T_UINT64='"unsigned short"'
+elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then
+ SCM_I_GSC_T_UINT64='"unsigned long long"'
+elif test "$scm_stdint_has_uint64"; then
+ SCM_I_GSC_T_UINT64='"uint64_t"'
+ SCM_I_GSC_NEEDS_STDINT_H=1
+elif test "$scm_inttypes_has_uint64"; then
+ SCM_I_GSC_T_UINT64='"uint64_t"'
+ SCM_I_GSC_NEEDS_INTTYPES_H=1
+else
+ AC_MSG_ERROR([Can't find appropriate type for scm_t_uint64.])
+fi
+AC_SUBST([SCM_I_GSC_T_UINT64])
+
+
+AC_SUBST([SCM_I_GSC_NEEDS_STDINT_H])
+AC_SUBST([SCM_I_GSC_NEEDS_INTTYPES_H])
+
AC_HEADER_STDC
AC_HEADER_DIRENT
AC_HEADER_TIME
AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
AC_CHECK_LIB(crypt, crypt)
+dnl GMP tests
+AC_CHECK_LIB([gmp], [__gmpz_init], ,
+ [AC_MSG_ERROR([GNU MP not found, see http://swox.com/gmp])])
+
+# mpz_import is a macro so we need to include <gmp.h>
+AC_TRY_LINK([#include <gmp.h>],
+ [mpz_import (0, 0, 0, 0, 0, 0, 0);] , ,
+ [AC_MSG_ERROR([At least GNU MP 4.1 is required, see http://swox.com/gmp])])
+
### Some systems don't declare some functions. On such systems, we
### need to at least provide our own K&R-style declarations.
#
#--------------------------------------------------------------------
+SCM_I_GSC_STACK_GROWS_UP=0
AC_TRY_RUN(aux (l) unsigned long l;
{ int x; exit (l >= ((unsigned long)&x)); }
main () { int q; aux((unsigned long)&q); },
- [AC_DEFINE([SCM_STACK_GROWS_UP], 1,
- [Define this if a callee's stack frame has a higher address
- than the caller's stack frame. On most machines, this is
- not the case.])],
+ SCM_I_GSC_STACK_GROWS_UP=1
[],
- [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h.in)])
+ [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
AH_TEMPLATE([SCM_SINGLES],
[Define this if floats are the same size as longs.])
#
#--------------------------------------------------------------------
+SCM_I_GSC_USE_PTHREAD_THREADS=0
+SCM_I_GSC_USE_NULL_THREADS=0
+SCM_I_GSC_USE_COOP_THREADS=0
+AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
+AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
+AC_SUBST([SCM_I_GSC_USE_COOP_THREADS])
+
### What thread package has the user asked for?
AC_ARG_WITH(threads, [ --with-threads thread interface],
- , with_threads=no)
+ , with_threads=yes)
-### Turn $with_threads into either the name of a threads package, like
-### `qt', or `no', meaning that threads should not be supported.
-AC_MSG_CHECKING(what kind of threads to support)
case "$with_threads" in
- "yes" | "qt" | "coop" | "")
- with_threads=qt
- ;;
- "no" | "null")
- with_threads=null
- ;;
- "coop-pthreads" | "copt" )
- with_threads="coop-pthreads"
- ;;
- * )
- AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
+ "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
+ AC_CHECK_LIB(pthread, main,
+ LIBS="-lpthread $LIBS"
+ SCM_I_GSC_USE_PTHREAD_THREADS=1
+ with_threads="pthreads",
+ with_threads="null")
+
+ if test $GCC = yes; then
+ AC_DEFINE(_THREAD_SAFE, 1,
+ [Use thread safe versions of GNU Libc functions.])
+ fi
+
+ AC_MSG_CHECKING(if pthread_mutexattr_settype is declared)
+ AC_CACHE_VAL(guile_cv_mutexattr_settype_declared,
+ [AC_TRY_COMPILE([#include <pthread.h>],
+ [int pthread_mutexattr_settype (int, int);],
+ guile_cv_mutexattr_settype_declared=no,
+ guile_cv_mutexattr_settype_declared=yes)])
+ AC_MSG_RESULT($guile_cv_mutexattr_settype_declared)
+ if test $guile_cv_mutexattr_settype_declared = yes; then
+ AC_DEFINE(SCM_MUTEXATTR_SETTYPE_DECLARED, 1,
+ [Define if pthread.h declares pthread_mutexattr_settype.])
+ fi
+
+ AC_MSG_CHECKING(how to get a fast mutex)
+ AC_CACHE_VAL(guile_cv_have_mutex_fast,
+ [AC_TRY_COMPILE([#include <pthread.h>],
+ [int a = PTHREAD_MUTEX_ADAPTIVE_NP;],
+ guile_cv_have_mutex_fast=PTHREAD_MUTEX_ADAPTIVE_NP,
+ guile_cv_have_mutex_fast=none)])
+ AC_MSG_RESULT($guile_cv_have_mutex_fast)
+ if test ! $guile_cv_have_mutex_fast = none; then
+ AC_DEFINE_UNQUOTED(SCM_MUTEX_FAST, $guile_cv_have_mutex_fast,
+ [The mutex kind enum for fast mutexes.])
+ fi
+
+ AC_MSG_CHECKING(how to get a recursive mutex)
+ AC_CACHE_VAL(guile_cv_have_mutex_recursive,
+ [AC_TRY_COMPILE([#include <pthread.h>],
+ [int a = PTHREAD_MUTEX_RECURSIVE_NP;],
+ guile_cv_have_mutex_recursive=PTHREAD_MUTEX_RECURSIVE_NP)
+ if test -z "$guile_cv_have_mutex_recursive"; then
+ AC_TRY_COMPILE([#include <pthread.h>],
+ [int a = PTHREAD_MUTEX_RECURSIVE;],
+ guile_cv_have_mutex_recursive=PTHREAD_MUTEX_RECURSIVE,
+ guile_cv_have_mutex_recursive=none)
+ fi])
+ AC_MSG_RESULT($guile_cv_have_mutex_recursive)
+ if test ! $guile_cv_have_mutex_recursive = none; then
+ AC_DEFINE_UNQUOTED(SCM_MUTEX_RECURSIVE, $guile_cv_have_mutex_recursive,
+ [The mutex kind enum for recursive mutexes.])
+ fi
;;
esac
-AC_MSG_RESULT($with_threads)
-
-## Make sure the threads package we've chosen is actually supported on
-## the present platform.
-case "${with_threads}" in
- "qt" )
- ## This configures the QuickThreads package, and sets or clears
- ## the THREAD_PACKAGE variable if qthreads don't configure
- ## correctly. In that case, we fall back on null-threads.
- QTHREADS_CONFIGURE
- ;;
- * )
- THREAD_PACKAGE="${with_threads}"
- ;;
-esac
-
-## We always provide the thread API now and thus, USE_THREADS is
-## always defined and threads.o is always included.
-AC_DEFINE(USE_THREADS, 1, [Define if providing the thread API.])
-AC_LIBOBJ([threads])
-
-## Also, we always provide scm_internal_select.
-
-AC_DEFINE(GUILE_ISELECT, 1, [Define to implement scm_internal_select.])
-
-case "${THREAD_PACKAGE}" in
- "QT" )
- AC_DEFINE(USE_COOP_THREADS, 1,
- [Define if using cooperative multithreading.])
-
- AC_ARG_ENABLE(linuxthreads,
- [ --disable-linuxthreads disable linuxthreads workaround],,
- enable_linuxthreads=yes)
-
- ## Workaround for linuxthreads (optionally disabled)
- if test $host_os = linux-gnu -a "$enable_linuxthreads" = yes; then
- AC_DEFINE(GUILE_PTHREAD_COMPAT, 1,
- [Define to enable workaround for COOP-linuxthreads compatibility.])
- AC_CHECK_LIB(pthread, main)
- fi
-
- ;;
- "null" | "" )
- AC_DEFINE(USE_NULL_THREADS, 1,
- [Define if using one-thread 'multi'threading.])
+case "$with_threads" in
+ "pthreads")
;;
- "coop-pthreads" )
- AC_DEFINE(USE_COPT_THREADS, 1,
- [Define if using coop-pthread multithreading.])
- AC_CHECK_LIB(pthread, main)
+ "no" | "null")
+ SCM_I_GSC_USE_NULL_THREADS=1
+ with_threads="null-threads"
;;
* )
- AC_MSG_ERROR(invalid value for THREAD_PACKAGE: ${THREAD_PACKAGE})
+ AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
;;
esac
+AC_MSG_CHECKING(what kind of threads to support)
+AC_MSG_RESULT($with_threads)
## Cross building
if test "$cross_compiling" = "yes"; then
AC_SUBST(GUILE_MAJOR_VERSION)
AC_SUBST(GUILE_MINOR_VERSION)
AC_SUBST(GUILE_MICRO_VERSION)
+AC_SUBST(GUILE_EFFECTIVE_VERSION)
AC_SUBST(GUILE_VERSION)
#######################################################################
AC_SUBST(LIBGUILE_INTERFACE_AGE)
AC_SUBST(LIBGUILE_INTERFACE)
+AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
+AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
+AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
+AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
+
AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
top_builddir_absolute=`pwd`
AC_SUBST(top_builddir_absolute)
-top_srcdir_absolute=`(cd $srcdir ; pwd)`
+top_srcdir_absolute=`(cd $srcdir && pwd)`
AC_SUBST(top_srcdir_absolute)
+# Additional SCM_I_GSC definitions are above.
+AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
+AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
+AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
+AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
+AC_SUBST([SCM_I_GSC_HAVE_ARRAYS])
+AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
+AC_SUBST([SCM_I_GSC_C_INLINE])
+AC_CONFIG_FILES([libguile/gen-scmconfig.h])
+
AC_CONFIG_FILES([
Makefile
am/Makefile
- libguile/Makefile
- libguile/guile-snarf
- libguile/guile-doc-snarf
- libguile/guile-func-name-check
- libguile/guile-snarf-docs
- libguile/version.h
- libguile-ltdl/Makefile
- libguile-ltdl/upstream/Makefile
+ benchmark-suite/Makefile
+ doc/Makefile
+ doc/goops/Makefile
+ doc/r5rs/Makefile
+ doc/ref/Makefile
+ doc/tutorial/Makefile
+ examples/Makefile
+ examples/box-dynamic-module/Makefile
+ examples/box-dynamic/Makefile
+ examples/box-module/Makefile
+ examples/box/Makefile
+ examples/modules/Makefile
+ examples/safe/Makefile
+ examples/scripts/Makefile
+ guile-config/Makefile
ice-9/Makefile
ice-9/debugger/Makefile
ice-9/debugger/breakpoints/Makefile
lang/elisp/Makefile
lang/elisp/internals/Makefile
lang/elisp/primitives/Makefile
+ libguile-ltdl/Makefile
+ libguile-ltdl/upstream/Makefile
+ libguile/Makefile
oop/Makefile
oop/goops/Makefile
scripts/Makefile
srfi/Makefile
- qt/Makefile
- qt/qt.h
- qt/md/Makefile
- qt/time/Makefile
- guile-config/Makefile
- doc/Makefile
- doc/ref/Makefile
- doc/tutorial/Makefile
- doc/goops/Makefile
- doc/r5rs/Makefile
- examples/Makefile
- examples/scripts/Makefile
- examples/box/Makefile
- examples/box-module/Makefile
- examples/box-dynamic/Makefile
- examples/box-dynamic-module/Makefile
- examples/modules/Makefile
- examples/safe/Makefile
test-suite/Makefile
- check-guile
- benchmark-suite/Makefile
- benchmark-guile
- guile-tools
- pre-inst-guile])
-
-AC_CONFIG_COMMANDS(default,
- [ chmod +x libguile/guile-snarf \
- libguile/guile-doc-snarf \
- libguile/guile-func-name-check \
- libguile/guile-snarf-docs \
- check-guile \
- benchmark-guile \
- guile-tools \
- pre-inst-guile])
+ test-suite/standalone/Makefile
+])
+
+AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
+AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
+AC_CONFIG_FILES([guile-tools], [chmod +x guile-tools])
+AC_CONFIG_FILES([pre-inst-guile], [chmod +x pre-inst-guile])
+AC_CONFIG_FILES([pre-inst-guile-env], [chmod +x pre-inst-guile-env])
+AC_CONFIG_FILES([libguile/guile-snarf],
+ [chmod +x libguile/guile-snarf])
+AC_CONFIG_FILES([libguile/guile-doc-snarf],
+ [chmod +x libguile/guile-doc-snarf])
+AC_CONFIG_FILES([libguile/guile-func-name-check],
+ [chmod +x libguile/guile-func-name-check])
+AC_CONFIG_FILES([libguile/guile-snarf-docs],
+ [chmod +x libguile/guile-snarf-docs])
AC_OUTPUT
HCoop / bpt / guile.git / blobdiff