X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/af3d28494d23f912626364055bef814ac0068e58..6f03035fe80d1c25ffadc42ec59c473402f65f60:/configure.in diff --git a/configure.in b/configure.in index 4d9aefb7f..817a1e5b5 100644 --- a/configure.in +++ b/configure.in @@ -4,7 +4,7 @@ dnl define(GUILE_CONFIGURE_COPYRIGHT,[[ -Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GUILE @@ -20,25 +20,35 @@ General Public License for more details. You should have received a copy of the GNU General Public License along with GUILE; see the file COPYING. If not, write to the -Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. ]]) -AC_PREREQ(2.53) +AC_PREREQ(2.61) -AC_INIT(m4_esyscmd(. ./GUILE-VERSION && echo -n ${PACKAGE}), - m4_esyscmd(. ./GUILE-VERSION && echo -n ${GUILE_VERSION})) +dnl `patsubst' here deletes the newline which "echo" prints. We can't use +dnl "echo -n" since -n is not portable (see autoconf manual "Limitations of +dnl Builtins"), in particular on solaris it results in a literal "-n" in +dnl the output. +dnl +AC_INIT(patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${PACKAGE}),[ +]), + patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${GUILE_VERSION}),[ +]), + [bug-guile@gnu.org]) +AC_CONFIG_AUX_DIR([build-aux]) +AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_SRCDIR(GUILE-VERSION) -AM_INIT_AUTOMAKE([no-define]) + +AM_INIT_AUTOMAKE([gnu no-define check-news -Wall -Wno-override]) AC_COPYRIGHT(GUILE_CONFIGURE_COPYRIGHT) AC_CONFIG_SRCDIR([GUILE-VERSION]) . $srcdir/GUILE-VERSION -AM_MAINTAINER_MODE -AM_CONFIG_HEADER([config.h]) +AC_CONFIG_HEADERS([config.h]) AH_TOP(/*GUILE_CONFIGURE_COPYRIGHT*/) #-------------------------------------------------------------------- @@ -51,25 +61,33 @@ AC_CONFIG_SUBDIRS(guile-readline) #-------------------------------------------------------------------- +AC_LANG([C]) + dnl Some more checks for Win32 -AC_CYGWIN -AC_MINGW32 +AC_CANONICAL_HOST + AC_LIBTOOL_WIN32_DLL AC_PROG_INSTALL AC_PROG_CC +gl_EARLY AC_PROG_CPP AC_PROG_AWK -AC_AIX -AC_ISC_POSIX -AC_MINIX +dnl Gnulib. +gl_INIT -AM_PROG_CC_STDC +AC_PROG_CC_C89 + +# for per-target cflags in the libguile subdir +AM_PROG_CC_C_O AC_LIBTOOL_DLOPEN AC_PROG_LIBTOOL -AC_LIB_LTDL +AC_CHECK_LIB([ltdl], [lt_dlinit], , + [AC_MSG_ERROR([libltdl not found. See README.])]) + +AC_SUBST(DLPREOPEN) AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no) AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes) @@ -109,17 +127,12 @@ AC_ARG_ENABLE(debug-malloc, SCM_I_GSC_GUILE_DEBUG=0 AC_ARG_ENABLE(guile-debug, - [AC_HELP_STRING([--enable-guile-debug], + [AS_HELP_STRING([--enable-guile-debug], [include internal debugging functions])], if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then SCM_I_GSC_GUILE_DEBUG=1 fi) -AC_ARG_ENABLE(arrays, - [AC_HELP_STRING([--disable-arrays],[omit array and uniform array support])], - , - enable_arrays=yes) - AC_ARG_ENABLE(posix, [ --disable-posix omit posix interfaces],, enable_posix=yes) @@ -132,8 +145,17 @@ AC_ARG_ENABLE(regex, [ --disable-regex omit regular expression interfaces],, enable_regex=yes) +AC_ARG_ENABLE([discouraged], + AS_HELP_STRING([--disable-discouraged],[omit discouraged features])) + +if test "$enable_discouraged" = no; then + SCM_I_GSC_ENABLE_DISCOURAGED=0 +else + SCM_I_GSC_ENABLE_DISCOURAGED=1 +fi + AC_ARG_ENABLE([deprecated], - AC_HELP_STRING([--disable-deprecated],[omit deprecated features])) + AS_HELP_STRING([--disable-deprecated],[omit deprecated features])) if test "$enable_deprecated" = no; then SCM_I_GSC_ENABLE_DEPRECATED=0 @@ -154,6 +176,51 @@ AC_ARG_ENABLE(elisp, [ --disable-elisp omit Emacs Lisp support],, enable_elisp=yes) +dnl Added the following configure option in January 2008 following +dnl investigation of problems with "64" system and library calls on +dnl Darwin (MacOS X). The libguile code (_scm.h) assumes that if a +dnl system has stat64, it will have all the other 64 APIs too; but on +dnl Darwin, stat64 is there but other APIs are missing. +dnl +dnl It also appears, from the Darwin docs, that most system call APIs +dnl there (i.e. the traditional ones _without_ "64" in their names) have +dnl been 64-bit-capable for a long time now, so it isn't necessary to +dnl use "64" versions anyway. For example, Darwin's off_t is 64-bit. +dnl +dnl A similar problem has been reported for HP-UX: +dnl http://www.nabble.com/Building-guile-1.8.2-on-hpux-td13106681.html +dnl +dnl Therefore, and also because a Guile without LARGEFILE64 support is +dnl better than no Guile at all, we provide this option to suppress +dnl trying to use "64" calls. +dnl +dnl It may be that for some 64-bit function on Darwin/HP-UX we do need +dnl to use a "64" call, and hence that by using --without-64-calls we're +dnl missing out on that. If so, someone can work on that in the future. +dnl For now, --without-64-calls allows Guile to build on OSs where it +dnl wasn't building before. +AC_MSG_CHECKING([whether to use system and library "64" calls]) +AC_ARG_WITH([64-calls], + AS_HELP_STRING([--without-64-calls], + [don't attempt to use system and library calls with "64" in their names]), + [use_64_calls=$withval], + [use_64_calls=yes + case $host in + *-apple-darwin* ) + use_64_calls=no + ;; + powerpc-ibm-aix* ) + use_64_calls=no + ;; + esac]) +AC_MSG_RESULT($use_64_calls) +case "$use_64_calls" in + y* ) + AC_DEFINE(GUILE_USE_64_CALLS, 1, + [Define to 1 in order to try to use "64" versions of system and library calls.]) + ;; +esac + #-------------------------------------------------------------------- dnl Check for dynamic linking @@ -181,13 +248,6 @@ if test "$use_modules" != no; then AC_LIBOBJ([dynl]) fi -SCM_I_GSC_HAVE_ARRAYS=0 -if test "$enable_arrays" = yes; then - AC_LIBOBJ([ramap]) - AC_LIBOBJ([unif]) - SCM_I_GSC_HAVE_ARRAYS=1 -fi - if test "$enable_posix" = yes; then AC_LIBOBJ([filesys]) AC_LIBOBJ([posix]) @@ -211,15 +271,20 @@ if test "$enable_elisp" = yes; then else SCM_I_GSC_ENABLE_ELISP=0 fi +AC_CHECK_LIB(uca, __uc_get_ar_bsp) AC_C_CONST +# "volatile" is used in a couple of tests below. +AC_C_VOLATILE + AC_C_INLINE if test "$ac_cv_c_inline" != no; then SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\"" else SCM_I_GSC_C_INLINE=NULL fi +AC_CHECK_LIB(uca, __uc_get_ar_bsp) AC_C_BIGENDIAN @@ -240,12 +305,14 @@ AC_CHECK_SIZEOF(void *) AC_CHECK_SIZEOF(intptr_t) AC_CHECK_SIZEOF(uintptr_t) AC_CHECK_SIZEOF(ptrdiff_t) +AC_CHECK_SIZEOF(size_t) +AC_CHECK_SIZEOF(off_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 +if test "$ac_cv_sizeof_ptrdiff_t" -ne 0; then SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"' else SCM_I_GSC_T_PTRDIFF='"long"' @@ -255,6 +322,8 @@ AC_SUBST([SCM_I_GSC_T_PTRDIFF]) AC_CHECK_HEADERS([stdint.h]) AC_CHECK_HEADERS([inttypes.h]) +AC_CHECK_SIZEOF(intmax_t) + SCM_I_GSC_NEEDS_STDINT_H=0 SCM_I_GSC_NEEDS_INTTYPES_H=0 @@ -323,161 +392,123 @@ fi ### Required type scm_t_int8 if test "$scm_stdint_has_int8"; then SCM_I_GSC_T_INT8='"int8_t"' - SCM_I_GSC_T_INT8_LIMITS='"INT8"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_int8"; then SCM_I_GSC_T_INT8='"int8_t"' - SCM_I_GSC_T_INT8_LIMITS='"INT8"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_char" -eq 1; then SCM_I_GSC_T_INT8='"signed char"' - SCM_I_GSC_T_INT8_LIMITS='"SCHAR"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.]) fi AC_SUBST([SCM_I_GSC_T_INT8]) -AC_SUBST([SCM_I_GSC_T_INT8_LIMITS]) ### Required type scm_t_uint8 if test "$scm_stdint_has_uint8"; then SCM_I_GSC_T_UINT8='"uint8_t"' - SCM_I_GSC_T_UINT8_LIMITS='"UINT8"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_uint8"; then SCM_I_GSC_T_UINT8='"uint8_t"' - SCM_I_GSC_T_UINT8_LIMITS='"UINT8"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_unsigned_char" -eq 1; then SCM_I_GSC_T_UINT8='"unsigned char"' - SCM_I_GSC_T_UINT8_LIMITS='"UCHAR"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.]) fi AC_SUBST([SCM_I_GSC_T_UINT8]) -AC_SUBST([SCM_I_GSC_T_UINT8_LIMITS]) ### Required type scm_t_int16 (ANSI C says int or short might work) if test "$scm_stdint_has_int16"; then SCM_I_GSC_T_INT16='"int16_t"' - SCM_I_GSC_T_INT16_LIMITS='"INT16"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_int16"; then SCM_I_GSC_T_INT16='"int16_t"' - SCM_I_GSC_T_INT16_LIMITS='"INT16"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_int" -eq 2; then SCM_I_GSC_T_INT16='"int"' - SCM_I_GSC_T_INT16_LIMITS='"INT"' elif test "$ac_cv_sizeof_short" -eq 2; then SCM_I_GSC_T_INT16='"short"' - SCM_I_GSC_T_INT16_LIMITS='"SHRT"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.]) fi AC_SUBST([SCM_I_GSC_T_INT16]) -AC_SUBST([SCM_I_GSC_T_INT16_LIMITS]) ### Required type scm_t_uint16 (ANSI C says int or short might work) if test "$scm_stdint_has_uint16"; then SCM_I_GSC_T_UINT16='"uint16_t"' - SCM_I_GSC_T_UINT16_LIMITS='"UINT16"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_uint16"; then SCM_I_GSC_T_UINT16='"uint16_t"' - SCM_I_GSC_T_UINT16_LIMITS='"UINT16"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_unsigned_int" -eq 2; then SCM_I_GSC_T_UINT16='"unsigned int"' - SCM_I_GSC_T_UINT16_LIMITS='"UINT"' elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then SCM_I_GSC_T_UINT16='"unsigned short"' - SCM_I_GSC_T_UINT16_LIMITS='"USHRT"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.]) fi AC_SUBST([SCM_I_GSC_T_UINT16]) -AC_SUBST([SCM_I_GSC_T_UINT16_LIMITS]) ### Required type scm_t_int32 (ANSI C says int, short, or long might work) if test "$scm_stdint_has_int32"; then SCM_I_GSC_T_INT32='"int32_t"' - SCM_I_GSC_T_INT32_LIMITS='"INT32"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_int32"; then SCM_I_GSC_T_INT32='"int32_t"' - SCM_I_GSC_T_INT32_LIMITS='"INT32"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_int" -eq 4; then SCM_I_GSC_T_INT32='"int"' - SCM_I_GSC_T_INT32_LIMITS='"INT"' elif test "$ac_cv_sizeof_long" -eq 4; then SCM_I_GSC_T_INT32='"long"' - SCM_I_GSC_T_INT32_LIMITS='"LONG"' elif test "$ac_cv_sizeof_short" -eq 4; then SCM_I_GSC_T_INT32='"short"' - SCM_I_GSC_T_INT32_LIMITS='"SHRT"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.]) fi AC_SUBST([SCM_I_GSC_T_INT32]) -AC_SUBST([SCM_I_GSC_T_INT32_LIMITS]) ### Required type scm_t_uint32 (ANSI C says int, short, or long might work) if test "$scm_stdint_has_uint32"; then SCM_I_GSC_T_UINT32='"uint32_t"' - SCM_I_GSC_T_UINT32_LIMITS='"UINT32"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_uint32"; then SCM_I_GSC_T_UINT32='"uint32_t"' - SCM_I_GSC_T_UINT32_LIMITS='"UINT32"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_unsigned_int" -eq 4; then SCM_I_GSC_T_UINT32='"unsigned int"' - SCM_I_GSC_T_UINT32_LIMITS='"UINT"' elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then SCM_I_GSC_T_UINT32='"unsigned long"' - SCM_I_GSC_T_UINT32_LIMITS='"ULONG"' elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then SCM_I_GSC_T_UINT32='"unsigned short"' - SCM_I_GSC_T_UINT32_LIMITS='"USHRT"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.]) fi AC_SUBST([SCM_I_GSC_T_UINT32]) -AC_SUBST([SCM_I_GSC_T_UINT32_LIMITS]) ### Optional type scm_t_int64 (ANSI C says int, short, or long might work) ### Also try 'long long' and '__int64' if we have it. SCM_I_GSC_T_INT64=0 if test "$scm_stdint_has_int64"; then SCM_I_GSC_T_INT64='"int64_t"' - SCM_I_GSC_T_INT64_LIMITS='"INT64"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_int64"; then SCM_I_GSC_T_INT64='"int64_t"' - SCM_I_GSC_T_INT64_LIMITS='"INT64"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_int" -eq 8; then SCM_I_GSC_T_INT64='"int"' - SCM_I_GSC_T_INT64_LIMITS='"INT"' elif test "$ac_cv_sizeof_long" -eq 8; then SCM_I_GSC_T_INT64='"long"' - SCM_I_GSC_T_INT64_LIMITS='"LONG"' elif test "$ac_cv_sizeof_short" -eq 8; then SCM_I_GSC_T_INT64='"short"' - SCM_I_GSC_T_INT64_LIMITS='"SHRT"' elif test "$ac_cv_sizeof_long_long" -eq 8; then SCM_I_GSC_T_INT64='"long long"' - SCM_I_GSC_T_INT64_LIMITS='"SCM_I_LLONG"' elif test "$ac_cv_sizeof___int64" -eq 8; then SCM_I_GSC_T_INT64='"__int64"' - SCM_I_GSC_T_INT64_LIMITS='"unknown"' else AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.]) fi AC_SUBST([SCM_I_GSC_T_INT64]) -AC_SUBST([SCM_I_GSC_T_INT64_LIMITS]) ### Optional type scm_t_uint64 (ANSI C says int, short, or long might work) @@ -485,32 +516,24 @@ AC_SUBST([SCM_I_GSC_T_INT64_LIMITS]) SCM_I_GSC_T_UINT64=0 if test "$scm_stdint_has_uint64"; then SCM_I_GSC_T_UINT64='"uint64_t"' - SCM_I_GSC_T_UINT64_LIMITS='"UINT64"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_uint64"; then SCM_I_GSC_T_UINT64='"uint64_t"' - SCM_I_GSC_T_UINT64_LIMITS='"UINT64"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_unsigned_int" -eq 8; then SCM_I_GSC_T_UINT64='"unsigned int"' - SCM_I_GSC_T_UINT64_LIMITS='"UINT"' elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then SCM_I_GSC_T_UINT64='"unsigned long"' - SCM_I_GSC_T_UINT64_LIMITS='"ULONG"' elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then SCM_I_GSC_T_UINT64='"unsigned short"' - SCM_I_GSC_T_UINT64_LIMITS='"USHRT"' elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then SCM_I_GSC_T_UINT64='"unsigned long long"' - SCM_I_GSC_T_UINT64_LIMITS='"SCM_I_ULLONG"' elif test "$ac_cv_sizeof_unsigned___int64" -eq 8; then SCM_I_GSC_T_UINT64='"unsigned __int64"' - SCM_I_GSC_T_UINT64_LIMITS='"unknown"' 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_T_UINT64_LIMITS]) ### Required type scm_t_intmax ### @@ -520,24 +543,18 @@ AC_SUBST([SCM_I_GSC_T_UINT64_LIMITS]) SCM_I_GSC_T_INTMAX=0 if test "$scm_stdint_has_intmax"; then SCM_I_GSC_T_INTMAX='"intmax_t"' - SCM_I_GSC_T_INTMAX_LIMITS='"INTMAX"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_intmax"; then SCM_I_GSC_T_INTMAX='"intmax_t"' - SCM_I_GSC_T_INTMAX_LIMITS='"INTMAX"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof___int64" -ne 0; then SCM_I_GSC_T_INTMAX='"__int64"' - SCM_I_GSC_T_INTMAX_LIMITS='"unknown"' elif test "$ac_cv_sizeof_long_long" -ne 0; then SCM_I_GSC_T_INTMAX='"long long"' - SCM_I_GSC_T_INTMAX_LIMITS='"SCM_I_LLONG"' else SCM_I_GSC_T_INTMAX='"long"' - SCM_I_GSC_T_INTMAX_LIMITS='"LONG"' fi AC_SUBST([SCM_I_GSC_T_INTMAX]) -AC_SUBST([SCM_I_GSC_T_INTMAX_LIMITS]) ### Required type scm_t_uintmax ### @@ -547,42 +564,87 @@ AC_SUBST([SCM_I_GSC_T_INTMAX_LIMITS]) SCM_I_GSC_T_UINTMAX=0 if test "$scm_stdint_has_uintmax"; then SCM_I_GSC_T_UINTMAX='"uintmax_t"' - SCM_I_GSC_T_UINTMAX_LIMITS='"UINTMAX"' SCM_I_GSC_NEEDS_STDINT_H=1 elif test "$scm_inttypes_has_uintmax"; then SCM_I_GSC_T_UINTMAX='"uintmax_t"' - SCM_I_GSC_T_UINTMAX_LIMITS='"UINTMAX"' SCM_I_GSC_NEEDS_INTTYPES_H=1 elif test "$ac_cv_sizeof_unsigned___int64" -ne 0; then SCM_I_GSC_T_UINTMAX='"unsigned __int64"' - SCM_I_GSC_T_UINTMAX_LIMITS='"unknown"' elif test "$ac_cv_sizeof_unsigned_long_long" -ne 0; then SCM_I_GSC_T_UINTMAX='"unsigned long long"' - SCM_I_GSC_T_UINTMAX_LIMITS='"SCM_I_ULLONG"' else SCM_I_GSC_T_UINTMAX='"unsigned long"' - SCM_I_GSC_T_UINTMAX_LIMITS='"ULONG"' fi AC_SUBST([SCM_I_GSC_T_UINTMAX]) -AC_SUBST([SCM_I_GSC_T_UINTMAX_LIMITS]) 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_HEADER_SYS_WAIT +AC_HEADER_DIRENT + +# Reason for checking: +# +# HP-UX 11.11 (at least) doesn't provide `struct dirent64', even +# with `_LARGEFILE64_SOURCE', so check whether it's available. +# +AC_CHECK_MEMBER([struct dirent64.d_name], + [SCM_I_GSC_HAVE_STRUCT_DIRENT64=1], [SCM_I_GSC_HAVE_STRUCT_DIRENT64=0], + [ #ifndef _LARGEFILE64_SOURCE + # define _LARGEFILE64_SOURCE + #endif + + /* Per Autoconf manual. */ + #include + #ifdef HAVE_DIRENT_H + # include + #else + # define dirent direct + # ifdef HAVE_SYS_NDIR_H + # include + # endif + # ifdef HAVE_SYS_DIR_H + # include + # endif + # ifdef HAVE_NDIR_H + # include + # endif + #endif ]) +AC_SUBST([SCM_I_GSC_HAVE_STRUCT_DIRENT64]) # Reasons for testing: +# complex.h - new in C99 # fenv.h - available in C99, but not older systems +# process.h - mingw specific +# langinfo.h, nl_types.h - SuS v2 # -AC_CHECK_HEADERS([fenv.h io.h libc.h limits.h malloc.h memory.h string.h \ +AC_CHECK_HEADERS([complex.h fenv.h io.h libc.h limits.h malloc.h memory.h process.h string.h \ regex.h rxposix.h rx/rxposix.h sys/dir.h sys/ioctl.h sys/select.h \ sys/time.h sys/timeb.h sys/times.h sys/stdtypes.h sys/types.h \ sys/utime.h time.h unistd.h utime.h pwd.h grp.h sys/utsname.h \ -direct.h]) +direct.h langinfo.h nl_types.h]) + +# "complex double" is new in C99, and "complex" is only a keyword if +# is included +AC_CHECK_TYPES(complex double,,, +[#if HAVE_COMPLEX_H +#include +#endif]) + +# On MacOS X contains socklen_t, so must include that +# when testing. +AC_CHECK_TYPE(socklen_t, , + [AC_DEFINE_UNQUOTED(socklen_t, int, + [Define to `int' if does not define.])], + [#if HAVE_SYS_TYPES_H +#include +#endif +#include +]) +AC_CHECK_TYPE(struct ip_mreq) GUILE_HEADER_LIBC_WITH_UNISTD @@ -590,9 +652,11 @@ AC_TYPE_GETGROUPS AC_TYPE_SIGNAL AC_TYPE_MODE_T -if test $MINGW32 = no; then - AC_CHECK_LIB(m, main) -fi +# On mingw -lm is empty, so this test is unnecessary, but it's +# harmless so we don't hard-code to suppress it. +# +AC_CHECK_LIB(m, cos) + AC_CHECK_FUNCS(gethostbyname) if test $ac_cv_func_gethostbyname = no; then AC_CHECK_LIB(nsl, gethostbyname) @@ -607,7 +671,8 @@ dnl dnl Check for Winsock and other functionality on Win32 (*not* CygWin) dnl EXTRA_DEFS="" -if test "$MINGW32" = "yes" ; then +case $host in + *-*-mingw*) AC_CHECK_HEADER(winsock2.h, [AC_DEFINE([HAVE_WINSOCK2_H], 1, [Define if you have the header file.])]) AC_CHECK_LIB(ws2_32, main) @@ -621,18 +686,10 @@ if test "$MINGW32" = "yes" ; then AC_DEFINE(USE_DLL_IMPORT, 1, [Define if you need additional CPP macros on Win32 platforms.]) fi - if test x"$enable_ltdl_install" = x"yes" ; then - INCLTDL="-DLIBLTDL_DLL_IMPORT $INCLTDL" - fi -fi + ;; +esac AC_SUBST(EXTRA_DEFS) -# FIXME: check to see if we still need these. -#AC_SUBST(INCLTDL) -#AC_SUBST(LIBLTDL) - -AC_SUBST(DLPREOPEN) - # Reasons for testing: # crt_externs.h - Darwin specific # @@ -642,20 +699,42 @@ AC_CHECK_HEADERS([assert.h crt_externs.h]) # DINFINITY - OSF specific # DQNAN - OSF specific # (DINFINITY and DQNAN are actually global variables, not functions) +# chsize - an MS-DOS-ism, found in mingw +# cexp, clog - not in various pre-c99 systems, and note that it's possible +# for gcc to provide the "complex double" type but the system to not +# have functions like cexp and clog +# clog10 - not in mingw (though others like clog and csqrt are) # fesetround - available in C99, but not older systems +# ftruncate - posix, but probably not older systems (current mingw +# has it as an inline for chsize) +# ioctl - not in mingw. # gmtime_r - recent posix, not on old systems +# pipe - not in mingw +# _pipe - specific to mingw, taking 3 args # readdir_r - recent posix, not on old systems +# readdir64_r - not available on HP-UX 11.11 +# stat64 - SuS largefile stuff, not on old systems # sysconf - not on old systems +# truncate - not in mingw +# isblank - available as a GNU extension or in C99 # _NSGetEnviron - Darwin specific +# strcoll_l, newlocale - GNU extensions (glibc), also available on Darwin +# nl_langinfo - X/Open, not available on Windows. # -AC_CHECK_FUNCS([DINFINITY DQNAN ctermid fesetround ftime fchown getcwd geteuid gettimeofday gmtime_r lstat mkdir mknod nice readdir_r readlink rename rmdir select setegid seteuid setlocale setpgid setsid sigaction siginterrupt strftime strptime symlink sync sysconf tcgetpgrp tcsetpgrp times uname waitpid strdup system usleep atexit on_exit chown link fcntl ttyname getpwent getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp index bcopy memcpy rindex unsetenv _NSGetEnviron]) +AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid fesetround ftime ftruncate fchown getcwd geteuid gettimeofday gmtime_r ioctl lstat mkdir mknod nice pipe _pipe readdir_r readdir64_r readlink rename rmdir select setegid seteuid setlocale setpgid setsid sigaction siginterrupt stat64 strftime strptime symlink sync sysconf tcgetpgrp tcsetpgrp times uname waitpid strdup system usleep atexit on_exit chown link fcntl ttyname getpwent getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp index bcopy memcpy rindex truncate unsetenv isblank _NSGetEnviron strcoll strcoll_l newlocale nl_langinfo]) # Reasons for testing: # netdb.h - not in mingw # sys/param.h - not in mingw +# pthread.h - only available with pthreads. ACX_PTHREAD doesn't +# check this specifically, we need it for the timespec test below. +# sethostname - the function itself check because it's not in mingw, +# the DECL is checked because Solaris 10 doens't have in any header +# xlocale.h - needed on Darwin for the `locale_t' API # -AC_CHECK_HEADERS(crypt.h netdb.h sys/param.h sys/resource.h sys/file.h) +AC_CHECK_HEADERS(crypt.h netdb.h pthread.h sys/param.h sys/resource.h sys/file.h xlocale.h) AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname) +AC_CHECK_DECLS([sethostname]) # crypt() may or may not be available, for instance in some countries there # are restrictions on cryptography. @@ -674,14 +753,88 @@ AC_SEARCH_LIBS(crypt, crypt, [AC_DEFINE(HAVE_CRYPT,1, [Define to 1 if you have the `crypt' function.])]) +# When compiling with GCC on some OSs (Solaris, AIX), _Complex_I doesn't +# work; in the reported cases so far, 1.0fi works well instead. According +# to the C99 spec, the complex.h header must provide a working definition +# of _Complex_I, so we always try _Complex_I first. The 1.0fi fallback +# is a workaround for the failure of some systems to conform to C99. +if test "$ac_cv_type_complex_double" = yes; then + AC_MSG_CHECKING([for i]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_COMPLEX_H +#include +#endif +complex double z; +]], [[ +z = _Complex_I; +]])], + [AC_DEFINE(GUILE_I,_Complex_I,[The imaginary unit (positive square root of -1).]) + AC_MSG_RESULT([_Complex_I])], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if HAVE_COMPLEX_H +#include +#endif +complex double z; +]],[[ +z = 1.0fi; +]])], + [AC_DEFINE(GUILE_I,1.0fi) + AC_MSG_RESULT([1.0fi])], + [ac_cv_type_complex_double=no + AC_MSG_RESULT([not available])])]) +fi + +# glibc 2.3.6 (circa 2006) and various prior versions had a bug where +# csqrt(-i) returned a negative real part, when it should be positive +# for the principal root. +# +if test "$ac_cv_type_complex_double" = yes; then + + AC_CACHE_CHECK([whether csqrt is usable], + guile_cv_use_csqrt, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include +/* "volatile" is meant to prevent gcc from calculating the sqrt as a + constant, we want to test libc. */ +volatile complex double z = - _Complex_I; +int +main (void) +{ + z = csqrt (z); + if (creal (z) > 0.0) + return 0; /* good */ + else + return 1; /* bad */ +}]])], + [guile_cv_use_csqrt=yes], + [guile_cv_use_csqrt="no, glibc 2.3 bug"], + [guile_cv_use_csqrt="yes, hopefully (cross-compiling)"])]) + case $guile_cv_use_csqrt in + yes*) + AC_DEFINE(HAVE_USABLE_CSQRT, 1, [Define to 1 if csqrt is bug-free]) + ;; + esac +fi + + dnl GMP tests AC_CHECK_LIB([gmp], [__gmpz_init], , - [AC_MSG_ERROR([GNU MP not found, see http://swox.com/gmp])]) + [AC_MSG_ERROR([GNU MP not found, see README])]) # mpz_import is a macro so we need to include -AC_TRY_LINK([#include ], - [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])]) +AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[mpz_import (0, 0, 0, 0, 0, 0, 0); ]])], + [], + [AC_MSG_ERROR([At least GNU MP 4.1 is required, see README])]) + +dnl i18n tests +#AC_CHECK_HEADERS([libintl.h]) +#AC_CHECK_FUNCS(gettext) +#if test $ac_cv_func_gettext = no; then +# AC_CHECK_LIB(intl, gettext) +#fi +#AC_CHECK_FUNCS([bindtextdomain textdomain]) +AM_GNU_GETTEXT([external], [need-ngettext]) ### Some systems don't declare some functions. On such systems, we ### need to at least provide our own K&R-style declarations. @@ -738,13 +891,22 @@ AC_CHECK_FUNCS(sethostent gethostent endhostent dnl inet_lnaof inet_makeaddr inet_netof hstrerror dnl inet_pton inet_ntop) +# struct sockaddr field sin_len is only present on BSD systems. +# On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems +# (eg. FreeBSD 4.9) it doesn't and we must use this configure check +AC_CHECK_MEMBERS([struct sockaddr.sin_len],,, +[#ifdef HAVE_SYS_TYPES_H +#include +#endif +#include ]) + AC_MSG_CHECKING(for __libc_stack_end) AC_CACHE_VAL(guile_cv_have_libc_stack_end, -[AC_TRY_LINK([#include -extern char *__libc_stack_end;], - [printf("%p", (char*) __libc_stack_end);], - guile_cv_have_libc_stack_end=yes, - guile_cv_have_libc_stack_end=no)]) +[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include +extern char *__libc_stack_end;]], + [[printf("%p", (char*) __libc_stack_end);]])], + [guile_cv_have_libc_stack_end=yes], + [guile_cv_have_libc_stack_end=no])]) AC_MSG_RESULT($guile_cv_have_libc_stack_end) if test $guile_cv_have_libc_stack_end = yes; then @@ -757,9 +919,10 @@ dnl macro. With cygwin it may be in a DLL. AC_MSG_CHECKING(whether netdb.h declares h_errno) AC_CACHE_VAL(guile_cv_have_h_errno, -[AC_TRY_COMPILE([#include ], -[int a = h_errno;], -guile_cv_have_h_errno=yes, guile_cv_have_h_errno=no)]) + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[int a = h_errno;]])], + [guile_cv_have_h_errno=yes], + [guile_cv_have_h_errno=no])]) AC_MSG_RESULT($guile_cv_have_h_errno) if test $guile_cv_have_h_errno = yes; then AC_DEFINE(HAVE_H_ERRNO, 1, [Define if h_errno is declared in netdb.h.]) @@ -767,15 +930,16 @@ fi AC_MSG_CHECKING(whether uint32_t is defined) AC_CACHE_VAL(guile_cv_have_uint32_t, - [AC_TRY_COMPILE([#include + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include #if HAVE_STDINT_H #include #endif - #ifndef __MINGW32__ + #ifndef HAVE_NETDB_H #include - #endif], - [uint32_t a;], - guile_cv_have_uint32_t=yes, guile_cv_have_uint32_t=no)]) + #endif]], + [[uint32_t a;]])], + [guile_cv_have_uint32_t=yes], + [guile_cv_have_uint32_t=no])]) AC_MSG_RESULT($guile_cv_have_uint32_t) if test $guile_cv_have_uint32_t = yes; then AC_DEFINE(HAVE_UINT32_T, 1, @@ -784,14 +948,15 @@ fi AC_MSG_CHECKING(for working IPv6 support) AC_CACHE_VAL(guile_cv_have_ipv6, -[AC_TRY_COMPILE([ +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #ifdef HAVE_SYS_TYPES_H #include #endif #include -#include ], -[struct sockaddr_in6 a; a.sin6_family = AF_INET6;], -guile_cv_have_ipv6=yes, guile_cv_have_ipv6=no)]) +#include ]], +[[struct sockaddr_in6 a; a.sin6_family = AF_INET6;]])], +[guile_cv_have_ipv6=yes], +[guile_cv_have_ipv6=no])]) AC_MSG_RESULT($guile_cv_have_ipv6) if test $guile_cv_have_ipv6 = yes; then AC_DEFINE(HAVE_IPV6, 1, [Define if you want support for IPv6.]) @@ -800,23 +965,31 @@ fi # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3. AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id) AC_CACHE_VAL(guile_cv_have_sin6_scope_id, -[AC_TRY_COMPILE([ +[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #ifdef HAVE_SYS_TYPES_H #include #endif -#include ], -[struct sockaddr_in6 sok; sok.sin6_scope_id = 0;], -guile_cv_have_sin6_scope_id=yes, guile_cv_have_sin6_scope_id=no)]) +#include ]], +[[struct sockaddr_in6 sok; sok.sin6_scope_id = 0;]])], +[guile_cv_have_sin6_scope_id=yes], +[guile_cv_have_sin6_scope_id=no])]) AC_MSG_RESULT($guile_cv_have_sin6_scope_id) if test $guile_cv_have_sin6_scope_id = yes; then AC_DEFINE(HAVE_SIN6_SCOPE_ID, 1, [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.]) fi +# struct sockaddr_in6 field sin_len is only present on BSD systems +AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,, +[#ifdef HAVE_SYS_TYPES_H +#include +#endif +#include ]) + AC_MSG_CHECKING(whether localtime caches TZ) AC_CACHE_VAL(guile_cv_localtime_cache, [if test x$ac_cv_func_tzset = xyes; then -AC_TRY_RUN([#include +AC_RUN_IFELSE([AC_LANG_SOURCE([[#include #if STDC_HEADERS # include #endif @@ -847,7 +1020,9 @@ main() if (localtime (&now)->tm_hour != hour_unset) exit (1); exit (0); -}], guile_cv_localtime_cache=no, guile_cv_localtime_cache=yes, +}]])], +[guile_cv_localtime_cache=no], +[guile_cv_localtime_cache=yes], [# If we have tzset, assume the worst when cross-compiling. guile_cv_localtime_cache=yes]) else @@ -906,70 +1081,113 @@ AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc) # C99 specifies isinf and isnan as macros. # HP-UX provides only macros, no functions. -# Glibc 2.3.2 provides both macros and functions. +# glibc 2.3.2 provides both macros and functions. +# IRIX 6.5 and Solaris 8 only provide functions. # -# We're concerned that some systems may have only functions, the following -# tests are designed to detect both functions and macros. +# The following tests detect isinf and isnan either as functions or as +# macros from . Plain AC_CHECK_FUNCS is insufficient, it doesn't +# use so doesn't detect on macro-only systems like HP-UX. # AC_MSG_CHECKING([for isinf]) -AC_LINK_IFELSE( -[#include -int main () { return (isinf(0.0) != 0); }], +AC_LINK_IFELSE(AC_LANG_SOURCE( +[[#include +volatile double x = 0.0; +int main () { return (isinf(x) != 0); }]]), [AC_MSG_RESULT([yes]) AC_DEFINE(HAVE_ISINF, 1, [Define to 1 if you have the `isinf' macro or function.])], [AC_MSG_RESULT([no])]) AC_MSG_CHECKING([for isnan]) -AC_LINK_IFELSE( -[#include -int main () { return (isnan(0.0) != 0); }], +AC_LINK_IFELSE(AC_LANG_SOURCE( +[[#include +volatile double x = 0.0; +int main () { return (isnan(x) != 0); }]]), [AC_MSG_RESULT([yes]) AC_DEFINE(HAVE_ISNAN, 1, [Define to 1 if you have the `isnan' macro or function.])], [AC_MSG_RESULT([no])]) -# When testing for the presence of alloca, we need to add alloca.o -# explicitly to LIBOBJS to make sure that it is translated to -# `alloca.lo' for libtool later on. This can and should be done more cleanly. -AC_FUNC_ALLOCA -if test "$ALLOCA" = "alloca.o" -then - AC_LIBOBJ([alloca]) -fi - -AC_CHECK_MEMBERS([struct stat.st_rdev]) -AC_CHECK_MEMBERS([struct stat.st_blksize]) - -AC_STRUCT_ST_BLOCKS - -AC_CACHE_CHECK([for S_ISLNK in sys/stat.h], ac_cv_macro_S_ISLNK, - [AC_TRY_CPP([#include - #ifndef S_ISLNK - #error no S_ISLNK - #endif], - ac_cv_macro_S_ISLNK=yes, - ac_cv_macro_S_ISLNK=no)]) -if test $ac_cv_macro_S_ISLNK = yes; then - AC_DEFINE(HAVE_S_ISLNK, 1, - [Define this if your system defines S_ISLNK in sys/stat.h.]) -fi +# Reasons for checking: +# +# st_rdev +# st_blksize +# st_blocks not in mingw +# tm_gmtoff BSD+GNU, not in C99 +# +# Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the +# AC_LIBOBJ(fileblocks) replacement which that macro gives. +# +AC_CHECK_MEMBERS([struct stat.st_rdev, struct stat.st_blksize, struct stat.st_blocks]) AC_STRUCT_TIMEZONE +AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,, +[#include +#ifdef TIME_WITH_SYS_TIME +# include +# include +#else +# if HAVE_SYS_TIME_H +# include +# else +# include +# endif +#endif +]) GUILE_STRUCT_UTIMBUF + #-------------------------------------------------------------------- # # Which way does the stack grow? # +# Following code comes from Autoconf 2.61's internal _AC_LIBOBJ_ALLOCA +# macro (/usr/share/autoconf/autoconf/functions.m4). Gnulib has +# very similar code, so in future we could look at using that. +# +# An important detail is that the code involves find_stack_direction +# calling _itself_ - which means that find_stack_direction (or at +# least the second find_stack_direction() call) cannot be inlined. +# If the code could be inlined, that might cause the test to give +# an incorrect answer. #-------------------------------------------------------------------- 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); }, - [SCM_I_GSC_STACK_GROWS_UP=1], - [], - [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)]) +AC_RUN_IFELSE([AC_LANG_SOURCE( +[AC_INCLUDES_DEFAULT +int +find_stack_direction () +{ + static char *addr = 0; + auto char dummy; + if (addr == 0) + { + addr = &dummy; + return find_stack_direction (); + } + else + return (&dummy > addr) ? 1 : -1; +} + +int +main () +{ + return find_stack_direction () < 0; +}])], + [SCM_I_GSC_STACK_GROWS_UP=1], + [], + [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)]) + +#-------------------------------------------------------------------- +# +# Boehm's GC library +# +#-------------------------------------------------------------------- +AC_CHECK_LIB([gc], [GC_collect_a_little], + [LIBS="-lgc $LIBS"], + [AC_MSG_ERROR([`libgc' (Boehm's GC library) not found.])]) +AC_CHECK_HEADER([gc/gc.h], [], + [AC_MSG_ERROR([`libgc' (Boehm's GC library) header files not found.])]) + AC_CHECK_SIZEOF(float) if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then @@ -979,12 +1197,12 @@ fi AC_MSG_CHECKING(for struct linger) AC_CACHE_VAL(scm_cv_struct_linger, - AC_TRY_COMPILE([ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include -#include ], - [struct linger lgr; lgr.l_linger = 100], - scm_cv_struct_linger="yes", - scm_cv_struct_linger="no")) +#include ]], + [[struct linger lgr; lgr.l_linger = 100]])], + [scm_cv_struct_linger="yes"], + [scm_cv_struct_linger="no"])) AC_MSG_RESULT($scm_cv_struct_linger) if test $scm_cv_struct_linger = yes; then AC_DEFINE(HAVE_STRUCT_LINGER, 1, @@ -993,17 +1211,21 @@ if test $scm_cv_struct_linger = yes; then fi +# On mingw, struct timespec is in . +# AC_MSG_CHECKING(for struct timespec) AC_CACHE_VAL(scm_cv_struct_timespec, - AC_TRY_COMPILE([ -#include ], - [struct timespec t; t.tv_nsec = 100], - scm_cv_struct_timespec="yes", - scm_cv_struct_timespec="no")) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include +#if HAVE_PTHREAD_H +#include +#endif]], [[struct timespec t; t.tv_nsec = 100]])], + [scm_cv_struct_timespec="yes"], + [scm_cv_struct_timespec="no"])) AC_MSG_RESULT($scm_cv_struct_timespec) if test $scm_cv_struct_timespec = yes; then AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1, - [Define this if your system defines struct timespec via .]) + [Define this if your system defines struct timespec via either or .]) fi #-------------------------------------------------------------------- @@ -1014,69 +1236,79 @@ fi 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=yes) +AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0) +AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER, 0) + case "$with_threads" in "yes" | "pthread" | "pthreads" | "pthread-threads" | "") - AC_CHECK_LIB(pthread, main, - LIBS="-lpthread $LIBS" + + build_pthread_support="yes" + + ACX_PTHREAD(CC="$PTHREAD_CC" + LIBS="$PTHREAD_LIBS $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 ], - [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.]) + + old_CFLAGS="$CFLAGS" + CFLAGS="$PTHREAD_CFLAGS $CFLAGS" + + # Reasons for testing: + # pthread_getattr_np - "np" meaning "non portable" says it + # all; not present on MacOS X or Solaris 10 + # pthread_get_stackaddr_np - "np" meaning "non portable" says it + # all; specific to MacOS X + # pthread_sigmask - not available on mingw + # + AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask) + + # On past versions of Solaris, believe 8 through 10 at least, you + # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };". + # This is contrary to POSIX: + # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html + # Check here if this style is required. + # + # glibc (2.3.6 at least) works both with or without braces, so the + # test checks whether it works without. + # + + if test "$GCC" = "yes"; then + # Since GCC only issues a warning for missing braces, so we need + # `-Werror' to catch it. + CFLAGS="-Werror -Wmissing-braces $CFLAGS" fi - - AC_MSG_CHECKING(how to get a fast mutex) - AC_CACHE_VAL(guile_cv_have_mutex_fast, - [AC_TRY_COMPILE([#include ], - [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.]) + + AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces], + guile_cv_need_braces_on_pthread_once_init, + [AC_COMPILE_IFELSE([#include + pthread_once_t foo = PTHREAD_ONCE_INIT;], + [guile_cv_need_braces_on_pthread_once_init=no], + [guile_cv_need_braces_on_pthread_once_init=yes])]) + if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then + SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1 fi - - AC_MSG_CHECKING(how to get a recursive mutex) - AC_CACHE_VAL(guile_cv_have_mutex_recursive, - [AC_TRY_COMPILE([#include ], - [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 ], - [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.]) + + # Same problem with `PTHREAD_MUTEX_INITIALIZER', e.g., on IRIX + # 6.5.30m with GCC 3.3. + AC_CACHE_CHECK([whether PTHREAD_MUTEX_INITIALIZER needs braces], + guile_cv_need_braces_on_pthread_mutex_initializer, + [AC_COMPILE_IFELSE([#include + pthread_mutex_t foo = PTHREAD_MUTEX_INITIALIZER;], + [guile_cv_need_braces_on_pthread_mutex_initializer=no], + [guile_cv_need_braces_on_pthread_mutex_initializer=yes])]) + if test "$guile_cv_need_braces_on_pthread_mutex_initializer" = yes; then + SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER=1 fi - + + CFLAGS="$old_CFLAGS" + # On Solaris, sched_yield lives in -lrt. AC_SEARCH_LIBS(sched_yield, rt) @@ -1098,6 +1330,53 @@ esac AC_MSG_CHECKING(what kind of threads to support) AC_MSG_RESULT($with_threads) +AM_CONDITIONAL([BUILD_PTHREAD_SUPPORT], + [test "x$build_pthread_support" = "xyes"]) + + +## Check whether pthread_attr_getstack works for the main thread + +if test "$with_threads" = pthreads; then + +AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread) +old_CFLAGS="$CFLAGS" +CFLAGS="$PTHREAD_CFLAGS $CFLAGS" +AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#if HAVE_PTHREAD_ATTR_GETSTACK +#include + +int main () +{ + pthread_attr_t attr; + void *start, *end; + size_t size; + + pthread_getattr_np (pthread_self (), &attr); + pthread_attr_getstack (&attr, &start, &size); + end = (char *)start + size; + + if ((void *)&attr < start || (void *)&attr >= end) + return 1; + else + return 0; +} +#else +int main () +{ + return 1; +} +#endif +]])], +[works=yes +AC_DEFINE(PTHREAD_ATTR_GETSTACK_WORKS, [1], [Define when pthread_att_get_stack works for the main thread])], +[works=no], +[]) +CFLAGS="$old_CFLAGS" +AC_MSG_RESULT($works) + +fi # with_threads=pthreads + + ## Cross building if test "$cross_compiling" = "yes"; then AC_MSG_CHECKING(cc for build) @@ -1149,25 +1428,18 @@ case "$GCC" in ## less than exasperating. ## -Wpointer-arith was here too, but something changed in gcc/glibc ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2). - CFLAGS="$CFLAGS -Wall -Wmissing-prototypes" + GCC_CFLAGS="-Wall -Wmissing-prototypes" # Do this here so we don't screw up any of the tests above that might # not be "warning free" if test "${GUILE_ERROR_ON_WARNING}" = yes then - CFLAGS="${CFLAGS} -Werror" + GCC_CFLAGS="${GCC_CFLAGS} -Werror" enable_compile_warnings=no fi ;; esac -## NOTE the code below sets LIBOBJS directly and so is now forbidden -## -- I'm disabling it for now in the hopes that the newer autoconf -## will DTRT -- if not, we need to fix up the sed command to match the -## others... -## -## Remove fileblocks.o from the object list. This file gets added by -## the Autoconf macro AC_STRUCT_ST_BLOCKS. But there is no need. -#LIBOBJS="`echo ${LIBOBJS} | sed 's/fileblocks\.o//g'`" +AC_SUBST(GCC_CFLAGS) ## If we're creating a shared library (using libtool!), then we'll ## need to generate a list of .lo files corresponding to the .o files @@ -1187,36 +1459,49 @@ AC_SUBST(GUILE_VERSION) ####################################################################### # library versioning -AC_SUBST(LIBQTHREADS_INTERFACE_CURRENT) -AC_SUBST(LIBQTHREADS_INTERFACE_REVISION) -AC_SUBST(LIBQTHREADS_INTERFACE_AGE) -AC_SUBST(LIBQTHREADS_INTERFACE) - AC_SUBST(LIBGUILE_INTERFACE_CURRENT) AC_SUBST(LIBGUILE_INTERFACE_REVISION) AC_SUBST(LIBGUILE_INTERFACE_AGE) AC_SUBST(LIBGUILE_INTERFACE) +AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR) 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_MAJOR) AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT) AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION) AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE) AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE) +AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR) AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT) AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION) AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE) AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE) +AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR) +AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT) +AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION) +AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE) +AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE) + +AC_SUBST(LIBGUILE_I18N_MAJOR) +AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT) +AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION) +AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE) +AC_SUBST(LIBGUILE_I18N_INTERFACE) + + ####################################################################### -dnl Tell guile-config what flags guile users should link against. -GUILE_LIBS="$LDFLAGS $THREAD_LIBS_INSTALLED $LIBS" +dnl Tell guile-config what flags guile users should compile and link with. +GUILE_LIBS="$LDFLAGS $LIBS" +GUILE_CFLAGS="$CPPFLAGS $PTHREAD_CFLAGS" AC_SUBST(GUILE_LIBS) +AC_SUBST(GUILE_CFLAGS) AC_SUBST(AWK) AC_SUBST(LIBLOBJS) @@ -1229,12 +1514,18 @@ AC_SUBST(top_builddir_absolute) top_srcdir_absolute=`(cd $srcdir && pwd)` AC_SUBST(top_srcdir_absolute) +dnl We need `sitedir' in `guile-1.8.pc'. +dnl Note: `sitedir' must be kept in sync with `GUILE_SITE_DIR' in `guile.m4'. +pkgdatadir="$datadir/guile" +sitedir="$pkgdatadir/site" +AC_SUBST([sitedir]) + # 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_DISCOURAGED]) 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]) @@ -1242,6 +1533,7 @@ AC_CONFIG_FILES([libguile/gen-scmconfig.h]) AC_CONFIG_FILES([ Makefile am/Makefile + lib/Makefile benchmark-suite/Makefile doc/Makefile doc/goops/Makefile @@ -1260,13 +1552,11 @@ AC_CONFIG_FILES([ guile-config/Makefile ice-9/Makefile ice-9/debugger/Makefile - ice-9/debugger/breakpoints/Makefile + ice-9/debugging/Makefile lang/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 @@ -1276,6 +1566,7 @@ AC_CONFIG_FILES([ test-suite/standalone/Makefile ]) +AC_CONFIG_FILES([guile-1.8.pc]) 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])