[ --disable-regex omit regular expression interfaces],,
enable_regex=yes)
+AC_ARG_ENABLE([discouraged],
+ AC_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]))
AC_CHECK_SIZEOF(intptr_t)
AC_CHECK_SIZEOF(uintptr_t)
AC_CHECK_SIZEOF(ptrdiff_t)
+AC_CHECK_SIZEOF(size_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"'
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
### 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)
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
###
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
###
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])
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 <sys/types.h>
+#endif
+#include <netinet/in.h>])
+
AC_MSG_CHECKING(for __libc_stack_end)
AC_CACHE_VAL(guile_cv_have_libc_stack_end,
[AC_TRY_LINK([#include <stdio.h>
[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 <sys/types.h>
+#endif
+#include <netinet/in.h>])
+
AC_MSG_CHECKING(whether localtime caches TZ)
AC_CACHE_VAL(guile_cv_localtime_cache,
[if test x$ac_cv_func_tzset = xyes; then
# 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 <math.h>. Plain AC_CHECK_FUNCS is insufficient, it doesn't
+# use <math.h> so doesn't detect on macro-only systems like HP-UX.
#
AC_MSG_CHECKING([for isinf])
AC_LINK_IFELSE(
AC_MSG_CHECKING([for isnan])
AC_LINK_IFELSE(
[#include <math.h>
+#ifdef __MINGW32__
+#define isnan _isnan
+#endif
int main () { return (isnan(0.0) != 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.
+# We must have a proper stack-using alloca in order for stack-copying
+# continuations to work properly. If we don't find a native one,
+# abort.
+
AC_FUNC_ALLOCA
if test "$ALLOCA" = "alloca.o"
then
- AC_LIBOBJ([alloca])
+ AC_ERROR([No native alloca found.])
fi
AC_CHECK_MEMBERS([struct stat.st_rdev])
#######################################################################
# 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)
# 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])
HCoop / bpt / guile.git / blobdiff