configure.in

   1 dnl   configuration script for Guile
   2 dnl   Process this file with autoconf to produce configure.
   3 dnl
   4
   5 define(GUILE_CONFIGURE_COPYRIGHT,[[
   6
   7 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   8
   9 This file is part of GUILE
  10
  11 GUILE is free software; you can redistribute it and/or modify it
  12 under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2, or (at your
  14 option) any later version.
  15
  16 GUILE is distributed in the hope that it will be useful, but
  17 WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19 General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GUILE; see the file COPYING.  If not, write to the
  23 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 Boston, MA 02111-1307, USA.
  25
  26 ]])
  27
  28 AC_PREREQ(2.53)
  29
  30 AC_INIT(m4_esyscmd(. ./GUILE-VERSION && echo -n ${PACKAGE}),
  31         m4_esyscmd(. ./GUILE-VERSION && echo -n ${GUILE_VERSION}))
  32 AC_CONFIG_SRCDIR(GUILE-VERSION)
  33 AM_INIT_AUTOMAKE([no-define])
  34
  35 AC_COPYRIGHT(GUILE_CONFIGURE_COPYRIGHT)
  36 AC_CONFIG_SRCDIR([GUILE-VERSION])
  37
  38 . $srcdir/GUILE-VERSION
  39
  40 AM_MAINTAINER_MODE
  41 AM_CONFIG_HEADER([config.h])
  42 AH_TOP(/*GUILE_CONFIGURE_COPYRIGHT*/)
  43
  44 #--------------------------------------------------------------------
  45 #
  46 # Independent Subdirectories
  47 #
  48 #--------------------------------------------------------------------
  49
  50 AC_CONFIG_SUBDIRS(guile-readline)
  51
  52 #--------------------------------------------------------------------
  53
  54 dnl Some more checks for Win32
  55 AC_CYGWIN
  56 AC_MINGW32
  57 AC_LIBTOOL_WIN32_DLL
  58
  59 AC_PROG_INSTALL
  60 AC_PROG_CC
  61 AC_PROG_CPP
  62 AC_PROG_AWK
  63
  64 AC_AIX
  65 AC_ISC_POSIX
  66 AC_MINIX
  67
  68 AM_PROG_CC_STDC
  69
  70 AC_LIBTOOL_DLOPEN
  71 AC_PROG_LIBTOOL
  72 AC_LIB_LTDL
  73
  74 AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
  75 AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
  76
  77 AM_PATH_LISPDIR
  78
  79 #--------------------------------------------------------------------
  80 #
  81 # User options (after above tests that may set default CFLAGS etc.)
  82 #
  83 #--------------------------------------------------------------------
  84
  85 GUILE_ERROR_ON_WARNING="yes"
  86
  87 AC_ARG_ENABLE(error-on-warning,
  88   [  --enable-error-on-warning    treat compile warnings as errors],
  89   [case "${enableval}" in
  90      yes | y) GUILE_ERROR_ON_WARNING="yes" ;;
  91      no | n)  GUILE_ERROR_ON_WARNING="no" ;;
  92      *) AC_MSG_ERROR(bad value ${enableval} for --enable-error-on-warning) ;;
  93    esac])
  94
  95 SCM_I_GSC_GUILE_DEBUG_FREELIST=0
  96 AC_ARG_ENABLE(debug-freelist,
  97   [  --enable-debug-freelist include garbage collector freelist debugging code],
  98   if test "$enable_debug_freelist" = y \
  99      || test "$enable_debug_freelist" = yes; then
 100     SCM_I_GSC_GUILE_DEBUG_FREELIST=1
 101   fi)
 102
 103 AC_ARG_ENABLE(debug-malloc,
 104   [  --enable-debug-malloc   include malloc debugging code],
 105   if test "$enable_debug_malloc" = y || test "$enable_debug_malloc" = yes; then
 106     AC_DEFINE(GUILE_DEBUG_MALLOC, 1,
 107       [Define this if you want to debug scm_must_malloc/realloc/free calls.])
 108   fi)
 109
 110 SCM_I_GSC_GUILE_DEBUG=0
 111 AC_ARG_ENABLE(guile-debug,
 112   [AC_HELP_STRING([--enable-guile-debug],
 113                   [include internal debugging functions])],
 114   if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then
 115     SCM_I_GSC_GUILE_DEBUG=1
 116   fi)
 117
 118 AC_ARG_ENABLE(arrays,
 119   [AC_HELP_STRING([--disable-arrays],[omit array and uniform array support])],
 120   ,
 121   enable_arrays=yes)
 122
 123 AC_ARG_ENABLE(posix,
 124   [  --disable-posix         omit posix interfaces],,
 125   enable_posix=yes)
 126
 127 AC_ARG_ENABLE(networking,
 128   [  --disable-networking    omit networking interfaces],,
 129   enable_networking=yes)
 130
 131 AC_ARG_ENABLE(regex,
 132   [  --disable-regex         omit regular expression interfaces],,
 133   enable_regex=yes)
 134
 135 AC_ARG_ENABLE([deprecated],
 136   AC_HELP_STRING([--disable-deprecated],[omit deprecated features]))
 137
 138 if test "$enable_deprecated" = no; then
 139   SCM_I_GSC_ENABLE_DEPRECATED=0
 140 else
 141   if test "$enable_deprecated" = yes || test "$enable_deprecated" = ""; then
 142     warn_default=summary
 143   elif test "$enable_deprecated" = shutup; then
 144     warn_default=no
 145   else
 146     warn_default=$enable_deprecated
 147   fi
 148   SCM_I_GSC_ENABLE_DEPRECATED=1
 149   AC_DEFINE_UNQUOTED(SCM_WARN_DEPRECATED_DEFAULT, "$warn_default",
 150   [Define this to control the default warning level for deprecated features.])
 151 fi
 152
 153 AC_ARG_ENABLE(elisp,
 154   [  --disable-elisp         omit Emacs Lisp support],,
 155   enable_elisp=yes)
 156
 157 #--------------------------------------------------------------------
 158
 159 dnl Check for dynamic linking
 160
 161 use_modules=yes
 162 AC_ARG_WITH(modules,
 163 [  --with-modules[=FILES]  Add support for dynamic modules],
 164 use_modules="$withval")
 165 test -z "$use_modules" && use_modules=yes
 166 DLPREOPEN=
 167 if test "$use_modules" != no; then
 168   if test "$use_modules" = yes; then
 169     DLPREOPEN="-dlpreopen force"
 170   else
 171     DLPREOPEN="-export-dynamic"
 172     for module in $use_modules; do
 173       DLPREOPEN="$DLPREOPEN -dlopen $module"
 174     done
 175   fi
 176 fi
 177
 178 dnl files which are destined for separate modules.
 179
 180 if test "$use_modules" != no; then
 181    AC_LIBOBJ([dynl])
 182 fi
 183
 184 SCM_I_GSC_HAVE_ARRAYS=0
 185 if test "$enable_arrays" = yes; then
 186    AC_LIBOBJ([ramap])
 187    AC_LIBOBJ([unif])
 188    SCM_I_GSC_HAVE_ARRAYS=1
 189 fi
 190
 191 if test "$enable_posix" = yes; then
 192    AC_LIBOBJ([filesys])
 193    AC_LIBOBJ([posix])
 194    AC_DEFINE(HAVE_POSIX, 1,
 195      [Define this if you want support for POSIX system calls in Guile.])
 196 fi
 197
 198 if test "$enable_networking" = yes; then
 199    AC_LIBOBJ([net_db])
 200    AC_LIBOBJ([socket])
 201    AC_DEFINE(HAVE_NETWORKING, 1,
 202      [Define this if you want support for networking in Guile.])
 203 fi
 204
 205 if test "$enable_debug_malloc" = yes; then
 206    AC_LIBOBJ([debug-malloc])
 207 fi
 208
 209 if test "$enable_elisp" = yes; then
 210   SCM_I_GSC_ENABLE_ELISP=1
 211 else
 212   SCM_I_GSC_ENABLE_ELISP=0
 213 fi
 214
 215 AC_C_CONST
 216
 217 AC_C_INLINE
 218 if test "$ac_cv_c_inline" != no; then
 219   SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\""
 220 else
 221   SCM_I_GSC_C_INLINE=NULL
 222 fi
 223
 224 AC_C_BIGENDIAN
 225
 226 AC_CHECK_SIZEOF(char)
 227 AC_CHECK_SIZEOF(unsigned char)
 228 AC_CHECK_SIZEOF(short)
 229 AC_CHECK_SIZEOF(unsigned short)
 230 AC_CHECK_SIZEOF(int)
 231 AC_CHECK_SIZEOF(unsigned int)
 232 AC_CHECK_SIZEOF(long)
 233 AC_CHECK_SIZEOF(unsigned long)
 234 AC_CHECK_SIZEOF(size_t)
 235 AC_CHECK_SIZEOF(long long)
 236 AC_CHECK_SIZEOF(unsigned long long)
 237 AC_CHECK_SIZEOF(__int64)
 238 AC_CHECK_SIZEOF(unsigned __int64)
 239 AC_CHECK_SIZEOF(void *)
 240 AC_CHECK_SIZEOF(intptr_t)
 241 AC_CHECK_SIZEOF(uintptr_t)
 242 AC_CHECK_SIZEOF(ptrdiff_t)
 243 AC_CHECK_SIZEOF(size_t)
 244
 245 if test "$ac_cv_sizeof_long" -ne "$ac_cv_sizeof_void_p"; then
 246   AC_MSG_ERROR(sizes of long and void* are not identical)
 247 fi
 248
 249 if test "$ac_cv_sizeof_ptrdiff_t" -ne 0; then
 250   SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"'
 251 else
 252   SCM_I_GSC_T_PTRDIFF='"long"'
 253 fi
 254 AC_SUBST([SCM_I_GSC_T_PTRDIFF])
 255
 256 AC_CHECK_HEADERS([stdint.h])
 257 AC_CHECK_HEADERS([inttypes.h])
 258
 259 AC_CHECK_SIZEOF(intmax_t)
 260
 261 SCM_I_GSC_NEEDS_STDINT_H=0
 262 SCM_I_GSC_NEEDS_INTTYPES_H=0
 263
 264 ### intptr and uintptr (try not to use inttypes if we don't have to)
 265 if test "$ac_cv_header_inttypes_h" = yes; then
 266   if test "$ac_cv_sizeof_intptr_t" -eq 0; then
 267     AC_CHECK_SIZEOF([intptr_t],,[#include <inttypes.h>
 268 #include <stdio.h>])
 269     if test "$ac_cv_sizeof_intptr_t" -ne 0; then
 270       SCM_I_GSC_NEEDS_INTTYPES_H=1
 271     fi
 272   fi
 273   if test "$ac_cv_sizeof_uintptr_t" -eq 0; then
 274     AC_CHECK_SIZEOF([uintptr_t],,[#include <inttypes.h>
 275 #include <stdio.h>])
 276     if test "$ac_cv_sizeof_uintptr_t" -ne 0; then
 277       SCM_I_GSC_NEEDS_INTTYPES_H=1
 278     fi
 279   fi
 280 fi
 281
 282 ### See what's provided by stdint.h
 283 if test "$ac_cv_header_stdint_h" = yes; then
 284    AC_CHECK_TYPE([int8_t],[scm_stdint_has_int8=1],,[#include <stdint.h>])
 285    AC_CHECK_TYPE([uint8_t],[scm_stdint_has_uint8=1],,[#include <stdint.h>])
 286    AC_CHECK_TYPE([int16_t],[scm_stdint_has_int16=1],,[#include <stdint.h>])
 287    AC_CHECK_TYPE([uint16_t],[scm_stdint_has_uint16=1],,[#include <stdint.h>])
 288    AC_CHECK_TYPE([int32_t],[scm_stdint_has_int32=1],,[#include <stdint.h>])
 289    AC_CHECK_TYPE([uint32_t],[scm_stdint_has_uint32=1],,[#include <stdint.h>])
 290    AC_CHECK_TYPE([int64_t],[scm_stdint_has_int64=1],,[#include <stdint.h>])
 291    AC_CHECK_TYPE([uint64_t],[scm_stdint_has_uint64=1],,[#include <stdint.h>])
 292    AC_CHECK_TYPE([intmax_t],[scm_stdint_has_intmax=1],,[#include <stdint.h>])
 293    AC_CHECK_TYPE([uintmax_t],[scm_stdint_has_uintmax=1],,[#include <stdint.h>])
 294 fi
 295
 296 # so we don't get confused by the cache (wish there was a better way
 297 # to check particular headers for the same type...)
 298
 299 unset ac_cv_type_int8_t
 300 unset ac_cv_type_uint8_t
 301 unset ac_cv_type_int16_t
 302 unset ac_cv_type_uint16_t
 303 unset ac_cv_type_int32_t
 304 unset ac_cv_type_uint32_t
 305 unset ac_cv_type_int64_t
 306 unset ac_cv_type_uint64_t
 307 unset ac_cv_type_intmax_t
 308 unset ac_cv_type_uintmax_t
 309
 310 ### See what's provided by inttypes.h
 311 if test "$ac_cv_header_inttypes_h" = yes; then
 312   AC_CHECK_TYPE([int8_t],[scm_inttypes_has_int8=1],,[#include <inttypes.h>])
 313   AC_CHECK_TYPE([uint8_t],[scm_inttypes_has_uint8=1],,[#include <inttypes.h>])
 314   AC_CHECK_TYPE([int16_t],[scm_inttypes_has_int16=1],,[#include <inttypes.h>])
 315   AC_CHECK_TYPE([uint16_t],[scm_inttypes_has_uint16=1],,[#include <inttypes.h>])
 316   AC_CHECK_TYPE([int32_t],[scm_inttypes_has_int32=1],,[#include <inttypes.h>])
 317   AC_CHECK_TYPE([uint32_t],[scm_inttypes_has_uint32=1],,[#include <inttypes.h>])
 318   AC_CHECK_TYPE([int64_t],[scm_inttypes_has_int64=1],,[#include <inttypes.h>])
 319   AC_CHECK_TYPE([uint64_t],[scm_inttypes_has_uint64=1],,[#include <inttypes.h>])
 320   AC_CHECK_TYPE([intmax_t],[scm_inttypes_has_intmax=1],,[#include <inttypes.h>])
 321   AC_CHECK_TYPE([uintmax_t],[scm_inttypes_has_uintmax=1],,[#include <inttypes.h>])
 322 fi
 323
 324 # Try hard to find definitions for some required scm_t_*int* types.
 325
 326 ### Required type scm_t_int8
 327 if test "$scm_stdint_has_int8"; then
 328   SCM_I_GSC_T_INT8='"int8_t"'
 329   SCM_I_GSC_NEEDS_STDINT_H=1
 330 elif test "$scm_inttypes_has_int8"; then
 331   SCM_I_GSC_T_INT8='"int8_t"'
 332   SCM_I_GSC_NEEDS_INTTYPES_H=1
 333 elif test "$ac_cv_sizeof_char" -eq 1; then
 334   SCM_I_GSC_T_INT8='"signed char"'
 335 else
 336   AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.])
 337 fi
 338 AC_SUBST([SCM_I_GSC_T_INT8])
 339
 340 ### Required type scm_t_uint8
 341 if test "$scm_stdint_has_uint8"; then
 342   SCM_I_GSC_T_UINT8='"uint8_t"'
 343   SCM_I_GSC_NEEDS_STDINT_H=1
 344 elif test "$scm_inttypes_has_uint8"; then
 345   SCM_I_GSC_T_UINT8='"uint8_t"'
 346   SCM_I_GSC_NEEDS_INTTYPES_H=1
 347 elif test "$ac_cv_sizeof_unsigned_char" -eq 1; then
 348   SCM_I_GSC_T_UINT8='"unsigned char"'
 349 else
 350   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.])
 351 fi
 352 AC_SUBST([SCM_I_GSC_T_UINT8])
 353
 354 ### Required type scm_t_int16 (ANSI C says int or short might work)
 355 if test "$scm_stdint_has_int16"; then
 356   SCM_I_GSC_T_INT16='"int16_t"'
 357   SCM_I_GSC_NEEDS_STDINT_H=1
 358 elif test "$scm_inttypes_has_int16"; then
 359   SCM_I_GSC_T_INT16='"int16_t"'
 360   SCM_I_GSC_NEEDS_INTTYPES_H=1
 361 elif test "$ac_cv_sizeof_int" -eq 2; then
 362   SCM_I_GSC_T_INT16='"int"'
 363 elif test "$ac_cv_sizeof_short" -eq 2; then
 364   SCM_I_GSC_T_INT16='"short"'
 365 else
 366   AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.])
 367 fi
 368 AC_SUBST([SCM_I_GSC_T_INT16])
 369
 370 ### Required type scm_t_uint16 (ANSI C says int or short might work)
 371 if test "$scm_stdint_has_uint16"; then
 372   SCM_I_GSC_T_UINT16='"uint16_t"'
 373   SCM_I_GSC_NEEDS_STDINT_H=1
 374 elif test "$scm_inttypes_has_uint16"; then
 375   SCM_I_GSC_T_UINT16='"uint16_t"'
 376   SCM_I_GSC_NEEDS_INTTYPES_H=1
 377 elif test "$ac_cv_sizeof_unsigned_int" -eq 2; then
 378   SCM_I_GSC_T_UINT16='"unsigned int"'
 379 elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then
 380   SCM_I_GSC_T_UINT16='"unsigned short"'
 381 else
 382   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.])
 383 fi
 384 AC_SUBST([SCM_I_GSC_T_UINT16])
 385
 386
 387 ### Required type scm_t_int32 (ANSI C says int, short, or long might work)
 388 if test "$scm_stdint_has_int32"; then
 389   SCM_I_GSC_T_INT32='"int32_t"'
 390   SCM_I_GSC_NEEDS_STDINT_H=1
 391 elif test "$scm_inttypes_has_int32"; then
 392   SCM_I_GSC_T_INT32='"int32_t"'
 393   SCM_I_GSC_NEEDS_INTTYPES_H=1
 394 elif test "$ac_cv_sizeof_int" -eq 4; then
 395   SCM_I_GSC_T_INT32='"int"'
 396 elif test "$ac_cv_sizeof_long" -eq 4; then
 397   SCM_I_GSC_T_INT32='"long"'
 398 elif test "$ac_cv_sizeof_short" -eq 4; then
 399   SCM_I_GSC_T_INT32='"short"'
 400 else
 401   AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.])
 402 fi
 403 AC_SUBST([SCM_I_GSC_T_INT32])
 404
 405 ### Required type scm_t_uint32 (ANSI C says int, short, or long might work)
 406 if test "$scm_stdint_has_uint32"; then
 407   SCM_I_GSC_T_UINT32='"uint32_t"'
 408   SCM_I_GSC_NEEDS_STDINT_H=1
 409 elif test "$scm_inttypes_has_uint32"; then
 410   SCM_I_GSC_T_UINT32='"uint32_t"'
 411   SCM_I_GSC_NEEDS_INTTYPES_H=1
 412 elif test "$ac_cv_sizeof_unsigned_int" -eq 4; then
 413   SCM_I_GSC_T_UINT32='"unsigned int"'
 414 elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then
 415   SCM_I_GSC_T_UINT32='"unsigned long"'
 416 elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then
 417   SCM_I_GSC_T_UINT32='"unsigned short"'
 418 else
 419   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.])
 420 fi
 421 AC_SUBST([SCM_I_GSC_T_UINT32])
 422
 423 ### Optional type scm_t_int64 (ANSI C says int, short, or long might work)
 424 ### Also try 'long long' and '__int64' if we have it.
 425 SCM_I_GSC_T_INT64=0
 426 if test "$scm_stdint_has_int64"; then
 427   SCM_I_GSC_T_INT64='"int64_t"'
 428   SCM_I_GSC_NEEDS_STDINT_H=1
 429 elif test "$scm_inttypes_has_int64"; then
 430   SCM_I_GSC_T_INT64='"int64_t"'
 431   SCM_I_GSC_NEEDS_INTTYPES_H=1
 432 elif test "$ac_cv_sizeof_int" -eq 8; then
 433   SCM_I_GSC_T_INT64='"int"'
 434 elif test "$ac_cv_sizeof_long" -eq 8; then
 435   SCM_I_GSC_T_INT64='"long"'
 436 elif test "$ac_cv_sizeof_short" -eq 8; then
 437   SCM_I_GSC_T_INT64='"short"'
 438 elif test "$ac_cv_sizeof_long_long" -eq 8; then
 439   SCM_I_GSC_T_INT64='"long long"'
 440 elif test "$ac_cv_sizeof___int64" -eq 8; then
 441   SCM_I_GSC_T_INT64='"__int64"'
 442 else
 443   AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.])
 444 fi
 445 AC_SUBST([SCM_I_GSC_T_INT64])
 446
 447
 448 ### Optional type scm_t_uint64 (ANSI C says int, short, or long might work)
 449 ### Also try 'long long' and '__int64' if we have it.
 450 SCM_I_GSC_T_UINT64=0
 451 if test "$scm_stdint_has_uint64"; then
 452   SCM_I_GSC_T_UINT64='"uint64_t"'
 453   SCM_I_GSC_NEEDS_STDINT_H=1
 454 elif test "$scm_inttypes_has_uint64"; then
 455   SCM_I_GSC_T_UINT64='"uint64_t"'
 456   SCM_I_GSC_NEEDS_INTTYPES_H=1
 457 elif test "$ac_cv_sizeof_unsigned_int" -eq 8; then
 458   SCM_I_GSC_T_UINT64='"unsigned int"'
 459 elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then
 460   SCM_I_GSC_T_UINT64='"unsigned long"'
 461 elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then
 462   SCM_I_GSC_T_UINT64='"unsigned short"'
 463 elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then
 464   SCM_I_GSC_T_UINT64='"unsigned long long"'
 465 elif test "$ac_cv_sizeof_unsigned___int64" -eq 8; then
 466   SCM_I_GSC_T_UINT64='"unsigned __int64"'
 467 else
 468   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint64.])
 469 fi
 470 AC_SUBST([SCM_I_GSC_T_UINT64])
 471
 472 ### Required type scm_t_intmax
 473 ###
 474 ### We try 'intmax_t', '__int64', 'long long' in this order.  When
 475 ### none of them is available, we use 'long'.
 476 ###
 477 SCM_I_GSC_T_INTMAX=0
 478 if test "$scm_stdint_has_intmax"; then
 479   SCM_I_GSC_T_INTMAX='"intmax_t"'
 480   SCM_I_GSC_NEEDS_STDINT_H=1
 481 elif test "$scm_inttypes_has_intmax"; then
 482   SCM_I_GSC_T_INTMAX='"intmax_t"'
 483   SCM_I_GSC_NEEDS_INTTYPES_H=1
 484 elif test "$ac_cv_sizeof___int64" -ne 0; then
 485   SCM_I_GSC_T_INTMAX='"__int64"'
 486 elif test "$ac_cv_sizeof_long_long" -ne 0; then
 487   SCM_I_GSC_T_INTMAX='"long long"'
 488 else
 489   SCM_I_GSC_T_INTMAX='"long"'
 490 fi
 491 AC_SUBST([SCM_I_GSC_T_INTMAX])
 492
 493 ### Required type scm_t_uintmax
 494 ###
 495 ### We try 'uintmax_t', 'unsigned __int64', 'unsigned long long' in
 496 ### this order.  When none of them is available, we use 'unsigned long'.
 497 ###
 498 SCM_I_GSC_T_UINTMAX=0
 499 if test "$scm_stdint_has_uintmax"; then
 500   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 501   SCM_I_GSC_NEEDS_STDINT_H=1
 502 elif test "$scm_inttypes_has_uintmax"; then
 503   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 504   SCM_I_GSC_NEEDS_INTTYPES_H=1
 505 elif test "$ac_cv_sizeof_unsigned___int64" -ne 0; then
 506   SCM_I_GSC_T_UINTMAX='"unsigned __int64"'
 507 elif test "$ac_cv_sizeof_unsigned_long_long" -ne 0; then
 508   SCM_I_GSC_T_UINTMAX='"unsigned long long"'
 509 else
 510   SCM_I_GSC_T_UINTMAX='"unsigned long"'
 511 fi
 512 AC_SUBST([SCM_I_GSC_T_UINTMAX])
 513
 514
 515 AC_SUBST([SCM_I_GSC_NEEDS_STDINT_H])
 516 AC_SUBST([SCM_I_GSC_NEEDS_INTTYPES_H])
 517
 518 AC_HEADER_STDC
 519 AC_HEADER_DIRENT
 520 AC_HEADER_TIME
 521 AC_HEADER_SYS_WAIT
 522
 523 # Reasons for testing:
 524 #   fenv.h - available in C99, but not older systems
 525 #
 526 AC_CHECK_HEADERS([fenv.h io.h libc.h limits.h malloc.h memory.h string.h \
 527 regex.h rxposix.h rx/rxposix.h sys/dir.h sys/ioctl.h sys/select.h \
 528 sys/time.h sys/timeb.h sys/times.h sys/stdtypes.h sys/types.h \
 529 sys/utime.h time.h unistd.h utime.h pwd.h grp.h sys/utsname.h \
 530 direct.h])
 531
 532 GUILE_HEADER_LIBC_WITH_UNISTD
 533
 534 AC_TYPE_GETGROUPS
 535 AC_TYPE_SIGNAL
 536 AC_TYPE_MODE_T
 537
 538 if test $MINGW32 = no; then
 539         AC_CHECK_LIB(m, main)
 540 fi
 541 AC_CHECK_FUNCS(gethostbyname)
 542 if test $ac_cv_func_gethostbyname = no; then
 543     AC_CHECK_LIB(nsl, gethostbyname)
 544 fi
 545
 546 AC_CHECK_FUNCS(connect)
 547 if test $ac_cv_func_connect = no; then
 548     AC_CHECK_LIB(socket, connect)
 549 fi
 550
 551 dnl
 552 dnl Check for Winsock and other functionality on Win32 (*not* CygWin)
 553 dnl
 554 EXTRA_DEFS=""
 555 if test "$MINGW32" = "yes" ; then
 556     AC_CHECK_HEADER(winsock2.h, [AC_DEFINE([HAVE_WINSOCK2_H], 1,
 557       [Define if you have the <winsock2.h> header file.])])
 558     AC_CHECK_LIB(ws2_32, main)
 559     AC_LIBOBJ([win32-uname])
 560     AC_LIBOBJ([win32-dirent])
 561     if test "$enable_networking" = yes ; then
 562       AC_LIBOBJ([win32-socket])
 563     fi
 564     if test "$enable_shared" = yes ; then
 565       EXTRA_DEFS="-DSCM_IMPORT"
 566       AC_DEFINE(USE_DLL_IMPORT, 1,
 567         [Define if you need additional CPP macros on Win32 platforms.])
 568     fi
 569     if test x"$enable_ltdl_install" = x"yes" ; then
 570       INCLTDL="-DLIBLTDL_DLL_IMPORT $INCLTDL"
 571     fi
 572 fi
 573 AC_SUBST(EXTRA_DEFS)
 574
 575 # FIXME: check to see if we still need these.
 576 #AC_SUBST(INCLTDL)
 577 #AC_SUBST(LIBLTDL)
 578
 579 AC_SUBST(DLPREOPEN)
 580
 581 # Reasons for testing:
 582 #   crt_externs.h - Darwin specific
 583 #
 584 AC_CHECK_HEADERS([assert.h crt_externs.h])
 585
 586 # Reasons for testing:
 587 #   DINFINITY - OSF specific
 588 #   DQNAN - OSF specific
 589 #       (DINFINITY and DQNAN are actually global variables, not functions)
 590 #   fesetround - available in C99, but not older systems
 591 #   gmtime_r - recent posix, not on old systems
 592 #   readdir_r - recent posix, not on old systems
 593 #   sysconf - not on old systems
 594 #   _NSGetEnviron - Darwin specific
 595 #
 596 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])
 597
 598 # Reasons for testing:
 599 #   netdb.h - not in mingw
 600 #   sys/param.h - not in mingw
 601 #
 602 AC_CHECK_HEADERS(crypt.h netdb.h sys/param.h sys/resource.h sys/file.h)
 603 AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
 604
 605 # crypt() may or may not be available, for instance in some countries there
 606 # are restrictions on cryptography.
 607 #
 608 # crypt() might be in libc (eg. OpenBSD), or it might be in a separate
 609 # -lcrypt library (eg. Debian GNU/Linux).
 610 #
 611 # On HP-UX 11, crypt() is in libc and there's a dummy libcrypt.a.  We must
 612 # be careful to avoid -lcrypt in this case, since libtool will see there's
 613 # only a static libcrypt and decide to build only a static libguile.
 614 #
 615 # AC_SEARCH_LIBS lets us add -lcrypt to LIBS only if crypt() is not in the
 616 # libraries already in that list.
 617 #
 618 AC_SEARCH_LIBS(crypt, crypt,
 619   [AC_DEFINE(HAVE_CRYPT,1,
 620              [Define to 1 if you have the `crypt' function.])])
 621
 622 dnl GMP tests
 623 AC_CHECK_LIB([gmp], [__gmpz_init], ,
 624   [AC_MSG_ERROR([GNU MP not found, see http://swox.com/gmp])])
 625
 626 # mpz_import is a macro so we need to include <gmp.h>
 627 AC_TRY_LINK([#include <gmp.h>],
 628             [mpz_import (0, 0, 0, 0, 0, 0, 0);] , ,
 629   [AC_MSG_ERROR([At least GNU MP 4.1 is required, see http://swox.com/gmp])])
 630
 631 ### Some systems don't declare some functions.  On such systems, we
 632 ### need to at least provide our own K&R-style declarations.
 633
 634 ### GUILE_FUNC_DECLARED(function, headerfile)
 635
 636 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
 637 ### not there, #define MISSING_FUNCTION_DECL.
 638 AC_DEFUN([GUILE_FUNC_DECLARED], [
 639   AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
 640     AC_EGREP_HEADER($1, $2,
 641                     guile_cv_func_$1_declared=yes,
 642                     guile_cv_func_$1_declared=no))
 643   if test [x$guile_cv_func_]$1[_declared] = xno; then
 644     AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
 645       [Define if the operating system supplies $1 without declaring it.])
 646   fi
 647 ])
 648
 649 GUILE_FUNC_DECLARED(sleep, unistd.h)
 650 GUILE_FUNC_DECLARED(usleep, unistd.h)
 651
 652 AC_CHECK_DECLS([strptime],,,
 653 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
 654 #include <time.h>])
 655
 656 ### On some systems usleep has no return value.  If it does have one,
 657 ### we'd like to return it; otherwise, we'll fake it.
 658 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
 659   [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),
 660                    unistd.h,
 661                    [guile_cv_func_usleep_return_type=void],
 662                    [guile_cv_func_usleep_return_type=int])])
 663 case "$guile_cv_func_usleep_return_type" in
 664   "void" )
 665     AC_DEFINE(USLEEP_RETURNS_VOID, 1,
 666       [Define if the system headers declare usleep to return void.])
 667   ;;
 668 esac
 669
 670 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
 671 if test -n "$have_sys_un_h" ; then
 672   AC_DEFINE(HAVE_UNIX_DOMAIN_SOCKETS, 1,
 673     [Define if the system supports Unix-domain (file-domain) sockets.])
 674 fi
 675
 676 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
 677
 678 AC_CHECK_FUNCS(sethostent   gethostent   endhostent   dnl
 679                setnetent    getnetent    endnetent    dnl
 680                setprotoent  getprotoent  endprotoent  dnl
 681                setservent   getservent   endservent   dnl
 682                getnetbyaddr getnetbyname dnl
 683                inet_lnaof inet_makeaddr inet_netof hstrerror dnl
 684                inet_pton inet_ntop)
 685
 686 AC_MSG_CHECKING(for __libc_stack_end)
 687 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
 688 [AC_TRY_LINK([#include <stdio.h>
 689 extern char *__libc_stack_end;],
 690              [printf("%p", (char*) __libc_stack_end);],
 691              guile_cv_have_libc_stack_end=yes,
 692              guile_cv_have_libc_stack_end=no)])
 693 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
 694
 695 if test $guile_cv_have_libc_stack_end = yes; then
 696   AC_DEFINE(HAVE_LIBC_STACK_END, 1,
 697            [Define if you have the __libc_stack_end variable.])
 698 fi
 699
 700 dnl Some systems do not declare this.  Some systems do declare it, as a
 701 dnl macro.  With cygwin it may be in a DLL.
 702
 703 AC_MSG_CHECKING(whether netdb.h declares h_errno)
 704 AC_CACHE_VAL(guile_cv_have_h_errno,
 705 [AC_TRY_COMPILE([#include <netdb.h>],
 706 [int a = h_errno;],
 707 guile_cv_have_h_errno=yes, guile_cv_have_h_errno=no)])
 708 AC_MSG_RESULT($guile_cv_have_h_errno)
 709 if test $guile_cv_have_h_errno = yes; then
 710   AC_DEFINE(HAVE_H_ERRNO, 1, [Define if h_errno is declared in netdb.h.])
 711 fi
 712
 713 AC_MSG_CHECKING(whether uint32_t is defined)
 714 AC_CACHE_VAL(guile_cv_have_uint32_t,
 715   [AC_TRY_COMPILE([#include <sys/types.h>
 716                    #if HAVE_STDINT_H
 717                    #include <stdint.h>
 718                    #endif
 719                    #ifndef __MINGW32__
 720                    #include <netdb.h>
 721                    #endif],
 722                   [uint32_t a;],
 723                   guile_cv_have_uint32_t=yes, guile_cv_have_uint32_t=no)])
 724 AC_MSG_RESULT($guile_cv_have_uint32_t)
 725 if test $guile_cv_have_uint32_t = yes; then
 726   AC_DEFINE(HAVE_UINT32_T, 1,
 727     [Define if uint32_t typedef is defined when netdb.h is include.])
 728 fi
 729
 730 AC_MSG_CHECKING(for working IPv6 support)
 731 AC_CACHE_VAL(guile_cv_have_ipv6,
 732 [AC_TRY_COMPILE([
 733 #ifdef HAVE_SYS_TYPES_H
 734 #include <sys/types.h>
 735 #endif
 736 #include <netinet/in.h>
 737 #include <sys/socket.h>],
 738 [struct sockaddr_in6 a;  a.sin6_family = AF_INET6;],
 739 guile_cv_have_ipv6=yes, guile_cv_have_ipv6=no)])
 740 AC_MSG_RESULT($guile_cv_have_ipv6)
 741 if test $guile_cv_have_ipv6 = yes; then
 742   AC_DEFINE(HAVE_IPV6, 1, [Define if you want support for IPv6.])
 743 fi
 744
 745 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
 746 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
 747 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
 748 [AC_TRY_COMPILE([
 749 #ifdef HAVE_SYS_TYPES_H
 750 #include <sys/types.h>
 751 #endif
 752 #include <netinet/in.h>],
 753 [struct sockaddr_in6 sok;  sok.sin6_scope_id = 0;],
 754 guile_cv_have_sin6_scope_id=yes, guile_cv_have_sin6_scope_id=no)])
 755 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
 756 if test $guile_cv_have_sin6_scope_id = yes; then
 757   AC_DEFINE(HAVE_SIN6_SCOPE_ID, 1,
 758     [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
 759 fi
 760
 761 AC_MSG_CHECKING(whether localtime caches TZ)
 762 AC_CACHE_VAL(guile_cv_localtime_cache,
 763 [if test x$ac_cv_func_tzset = xyes; then
 764 AC_TRY_RUN([#include <time.h>
 765 #if STDC_HEADERS
 766 # include <stdlib.h>
 767 #endif
 768 extern char **environ;
 769 unset_TZ ()
 770 {
 771   char **from, **to;
 772   for (to = from = environ; (*to = *from); from++)
 773     if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
 774       to++;
 775 }
 776 char TZ_GMT0[] = "TZ=GMT0";
 777 char TZ_PST8[] = "TZ=PST8";
 778 main()
 779 {
 780   time_t now = time ((time_t *) 0);
 781   int hour_GMT0, hour_unset;
 782   if (putenv (TZ_GMT0) != 0)
 783     exit (1);
 784   hour_GMT0 = localtime (&now)->tm_hour;
 785   unset_TZ ();
 786   hour_unset = localtime (&now)->tm_hour;
 787   if (putenv (TZ_PST8) != 0)
 788     exit (1);
 789   if (localtime (&now)->tm_hour == hour_GMT0)
 790     exit (1);
 791   unset_TZ ();
 792   if (localtime (&now)->tm_hour != hour_unset)
 793     exit (1);
 794   exit (0);
 795 }], guile_cv_localtime_cache=no, guile_cv_localtime_cache=yes,
 796 [# If we have tzset, assume the worst when cross-compiling.
 797 guile_cv_localtime_cache=yes])
 798 else
 799         # If we lack tzset, report that localtime does not cache TZ,
 800         # since we can't invalidate the cache if we don't have tzset.
 801         guile_cv_localtime_cache=no
 802 fi])dnl
 803 AC_MSG_RESULT($guile_cv_localtime_cache)
 804 if test $guile_cv_localtime_cache = yes; then
 805   AC_DEFINE(LOCALTIME_CACHE, 1, [Define if localtime caches the TZ setting.])
 806 fi
 807
 808 dnl Test whether system calls are restartable by default on the
 809 dnl current system.  If they are not, we put a loop around every system
 810 dnl call to check for EINTR (see SCM_SYSCALL) and do not attempt to
 811 dnl change from the default behaviour.  On the other hand, if signals
 812 dnl are restartable then the loop is not installed and when libguile
 813 dnl initialises it also resets the behaviour of each signal to cause a
 814 dnl restart (in case a different runtime had a different default
 815 dnl behaviour for some reason: e.g., different versions of linux seem
 816 dnl to behave differently.)
 817
 818 AC_SYS_RESTARTABLE_SYSCALLS
 819
 820 if test "$enable_regex" = yes; then
 821    if test "$ac_cv_header_regex_h" = yes ||
 822       test "$ac_cv_header_rxposix_h" = yes ||
 823       test "$ac_cv_header_rx_rxposix_h" = yes; then
 824      GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
 825      [AC_CHECK_LIB(rx, main)
 826       GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
 827      [AC_CHECK_LIB(regex, main)
 828       GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
 829      )
 830      dnl The following should not be necessary, but for some reason
 831      dnl autoheader misses it if we don't include it!
 832      if test "$ac_cv_func_regcomp_norx" = yes ||
 833         test "$ac_cv_func_regcomp_regex" = yes ||
 834         test "$ac_cv_func_regcomp_rx" = yes; then
 835        AC_DEFINE(HAVE_REGCOMP, 1,
 836          [This is included as part of a workaround for a autoheader bug.])
 837      fi
 838    fi
 839 fi
 840
 841 AC_REPLACE_FUNCS(inet_aton putenv strerror memmove mkstemp)
 842
 843 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
 844
 845 # Reasons for testing:
 846 #   asinh, acosh, atanh, trunc - C99 standard, generally not available on
 847 #                                older systems
 848 #   sincos - GLIBC extension
 849 #
 850 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
 851
 852 # C99 specifies isinf and isnan as macros.
 853 # HP-UX provides only macros, no functions.
 854 # glibc 2.3.2 provides both macros and functions.
 855 # IRIX 6.5 and Solaris 8 only provide functions.
 856 #
 857 # The following tests detect isinf and isnan either as functions or as
 858 # macros from <math.h>.  Plain AC_CHECK_FUNCS is insufficient, it doesn't
 859 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
 860 #
 861 AC_MSG_CHECKING([for isinf])
 862 AC_LINK_IFELSE(
 863 [#include <math.h>
 864 int main () { return (isinf(0.0) != 0); }],
 865   [AC_MSG_RESULT([yes])
 866    AC_DEFINE(HAVE_ISINF, 1,
 867              [Define to 1 if you have the `isinf' macro or function.])],
 868   [AC_MSG_RESULT([no])])
 869 AC_MSG_CHECKING([for isnan])
 870 AC_LINK_IFELSE(
 871 [#include <math.h>
 872 int main () { return (isnan(0.0) != 0); }],
 873   [AC_MSG_RESULT([yes])
 874    AC_DEFINE(HAVE_ISNAN, 1,
 875              [Define to 1 if you have the `isnan' macro or function.])],
 876   [AC_MSG_RESULT([no])])
 877
 878 # When testing for the presence of alloca, we need to add alloca.o
 879 # explicitly to LIBOBJS to make sure that it is translated to
 880 # `alloca.lo' for libtool later on.  This can and should be done more cleanly.
 881 AC_FUNC_ALLOCA
 882 if test "$ALLOCA" = "alloca.o"
 883 then
 884   AC_LIBOBJ([alloca])
 885 fi
 886
 887 AC_CHECK_MEMBERS([struct stat.st_rdev])
 888 AC_CHECK_MEMBERS([struct stat.st_blksize])
 889
 890 AC_STRUCT_ST_BLOCKS
 891
 892 AC_CACHE_CHECK([for S_ISLNK in sys/stat.h], ac_cv_macro_S_ISLNK,
 893   [AC_TRY_CPP([#include <sys/stat.h>
 894                #ifndef S_ISLNK
 895                #error no S_ISLNK
 896                #endif],
 897                ac_cv_macro_S_ISLNK=yes,
 898                ac_cv_macro_S_ISLNK=no)])
 899 if test $ac_cv_macro_S_ISLNK = yes; then
 900   AC_DEFINE(HAVE_S_ISLNK, 1,
 901     [Define this if your system defines S_ISLNK in sys/stat.h.])
 902 fi
 903
 904 AC_STRUCT_TIMEZONE
 905 GUILE_STRUCT_UTIMBUF
 906
 907 #--------------------------------------------------------------------
 908 #
 909 # Which way does the stack grow?
 910 #
 911 #--------------------------------------------------------------------
 912
 913 SCM_I_GSC_STACK_GROWS_UP=0
 914 AC_TRY_RUN(aux (l) unsigned long l;
 915              { int x; exit (l >= ((unsigned long)&x)); }
 916            main () { int q; aux((unsigned long)&q); },
 917            [SCM_I_GSC_STACK_GROWS_UP=1],
 918            [],
 919            [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
 920
 921 AC_CHECK_SIZEOF(float)
 922 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
 923     AC_DEFINE(SCM_SINGLES, 1,
 924               [Define this if floats are the same size as longs.])
 925 fi
 926
 927 AC_MSG_CHECKING(for struct linger)
 928 AC_CACHE_VAL(scm_cv_struct_linger,
 929         AC_TRY_COMPILE([
 930 #include <sys/types.h>
 931 #include <sys/socket.h>],
 932                         [struct linger lgr;  lgr.l_linger = 100],
 933                         scm_cv_struct_linger="yes",
 934                         scm_cv_struct_linger="no"))
 935 AC_MSG_RESULT($scm_cv_struct_linger)
 936 if test $scm_cv_struct_linger = yes; then
 937         AC_DEFINE(HAVE_STRUCT_LINGER, 1,
 938           [Define this if your system defines struct linger, for use with the
 939            getsockopt and setsockopt system calls.])
 940 fi
 941
 942
 943 AC_MSG_CHECKING(for struct timespec)
 944 AC_CACHE_VAL(scm_cv_struct_timespec,
 945         AC_TRY_COMPILE([
 946 #include <time.h>],
 947                         [struct timespec t;  t.tv_nsec = 100],
 948                         scm_cv_struct_timespec="yes",
 949                         scm_cv_struct_timespec="no"))
 950 AC_MSG_RESULT($scm_cv_struct_timespec)
 951 if test $scm_cv_struct_timespec = yes; then
 952   AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1,
 953     [Define this if your system defines struct timespec via <time.h>.])
 954 fi
 955
 956 #--------------------------------------------------------------------
 957 #
 958 # Flags for thread support
 959 #
 960 #--------------------------------------------------------------------
 961
 962 SCM_I_GSC_USE_PTHREAD_THREADS=0
 963 SCM_I_GSC_USE_NULL_THREADS=0
 964 SCM_I_GSC_USE_COOP_THREADS=0
 965 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
 966 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
 967 AC_SUBST([SCM_I_GSC_USE_COOP_THREADS])
 968
 969 ### What thread package has the user asked for?
 970 AC_ARG_WITH(threads, [  --with-threads          thread interface],
 971             , with_threads=yes)
 972
 973 case "$with_threads" in
 974   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
 975     AC_CHECK_LIB(pthread, main,
 976       LIBS="-lpthread $LIBS"
 977       SCM_I_GSC_USE_PTHREAD_THREADS=1
 978       with_threads="pthreads",
 979       with_threads="null")
 980
 981     if test $GCC = yes; then
 982     AC_DEFINE(_THREAD_SAFE, 1,
 983       [Use thread safe versions of GNU Libc functions.])
 984     fi
 985
 986     AC_MSG_CHECKING(if pthread_mutexattr_settype is declared)
 987     AC_CACHE_VAL(guile_cv_mutexattr_settype_declared,
 988       [AC_TRY_COMPILE([#include <pthread.h>],
 989           [int pthread_mutexattr_settype (int, int);],
 990           guile_cv_mutexattr_settype_declared=no,
 991           guile_cv_mutexattr_settype_declared=yes)])
 992     AC_MSG_RESULT($guile_cv_mutexattr_settype_declared)
 993     if test $guile_cv_mutexattr_settype_declared = yes; then
 994       AC_DEFINE(SCM_MUTEXATTR_SETTYPE_DECLARED, 1,
 995           [Define if pthread.h declares pthread_mutexattr_settype.])
 996     fi
 997
 998     AC_MSG_CHECKING(how to get a fast mutex)
 999     AC_CACHE_VAL(guile_cv_have_mutex_fast,
1000       [AC_TRY_COMPILE([#include <pthread.h>],
1001           [int a = PTHREAD_MUTEX_ADAPTIVE_NP;],
1002           guile_cv_have_mutex_fast=PTHREAD_MUTEX_ADAPTIVE_NP,
1003           guile_cv_have_mutex_fast=none)])
1004     AC_MSG_RESULT($guile_cv_have_mutex_fast)
1005     if test ! $guile_cv_have_mutex_fast = none; then
1006       AC_DEFINE_UNQUOTED(SCM_MUTEX_FAST, $guile_cv_have_mutex_fast,
1007           [The mutex kind enum for fast mutexes.])
1008     fi
1009
1010     AC_MSG_CHECKING(how to get a recursive mutex)
1011     AC_CACHE_VAL(guile_cv_have_mutex_recursive,
1012       [AC_TRY_COMPILE([#include <pthread.h>],
1013         [int a = PTHREAD_MUTEX_RECURSIVE_NP;],
1014          guile_cv_have_mutex_recursive=PTHREAD_MUTEX_RECURSIVE_NP)
1015       if test -z "$guile_cv_have_mutex_recursive"; then
1016           AC_TRY_COMPILE([#include <pthread.h>],
1017             [int a = PTHREAD_MUTEX_RECURSIVE;],
1018             guile_cv_have_mutex_recursive=PTHREAD_MUTEX_RECURSIVE,
1019             guile_cv_have_mutex_recursive=none)
1020         fi])
1021     AC_MSG_RESULT($guile_cv_have_mutex_recursive)
1022     if test ! $guile_cv_have_mutex_recursive = none; then
1023       AC_DEFINE_UNQUOTED(SCM_MUTEX_RECURSIVE, $guile_cv_have_mutex_recursive,
1024          [The mutex kind enum for recursive mutexes.])
1025     fi
1026
1027     # On Solaris, sched_yield lives in -lrt.
1028     AC_SEARCH_LIBS(sched_yield, rt)
1029
1030   ;;
1031 esac
1032
1033 case "$with_threads" in
1034   "pthreads")
1035   ;;
1036   "no" | "null")
1037     SCM_I_GSC_USE_NULL_THREADS=1
1038     with_threads="null-threads"
1039   ;;
1040   * )
1041     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1042   ;;
1043 esac
1044
1045 AC_MSG_CHECKING(what kind of threads to support)
1046 AC_MSG_RESULT($with_threads)
1047
1048 ## Cross building
1049 if test "$cross_compiling" = "yes"; then
1050   AC_MSG_CHECKING(cc for build)
1051   ## /usr/bin/cc still uses wrong assembler
1052   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1053   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1054 else
1055   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1056 fi
1057
1058 ## AC_MSG_CHECKING("if we are cross compiling")
1059 ## AC_MSG_RESULT($cross_compiling)
1060 if test "$cross_compiling" = "yes"; then
1061    AC_MSG_RESULT($CC_FOR_BUILD)
1062 fi
1063
1064 ## No need as yet to be more elaborate
1065 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1066
1067 AC_SUBST(cross_compiling)
1068 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1069 AC_SUBST(CCLD_FOR_BUILD)
1070
1071 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1072 ## --HOST is the platform that PACKAGE is compiled for.
1073 HOST_CC="$CC_FOR_BUILD"
1074 AC_SUBST(HOST_CC)
1075
1076 if test "$cross_compiling" = "yes"; then
1077   AC_MSG_CHECKING(guile for build)
1078   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1079 else
1080   GUILE_FOR_BUILD='$(preinstguile)'
1081 fi
1082
1083 ## AC_MSG_CHECKING("if we are cross compiling")
1084 ## AC_MSG_RESULT($cross_compiling)
1085 if test "$cross_compiling" = "yes"; then
1086    AC_MSG_RESULT($GUILE_FOR_BUILD)
1087 fi
1088 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1089 AC_SUBST(GUILE_FOR_BUILD)
1090
1091 ## If we're using GCC, ask for aggressive warnings.
1092 case "$GCC" in
1093   yes )
1094     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1095     ## much stuff with generic function pointers for that to really be
1096     ## less than exasperating.
1097     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1098     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1099     CFLAGS="$CFLAGS -Wall -Wmissing-prototypes"
1100     # Do this here so we don't screw up any of the tests above that might
1101     # not be "warning free"
1102     if test "${GUILE_ERROR_ON_WARNING}" = yes
1103     then
1104         CFLAGS="${CFLAGS} -Werror"
1105         enable_compile_warnings=no
1106     fi
1107     ;;
1108 esac
1109
1110 ## NOTE the code below sets LIBOBJS directly and so is now forbidden
1111 ## -- I'm disabling it for now in the hopes that the newer autoconf
1112 ## will DTRT -- if not, we need to fix up the sed command to match the
1113 ## others...
1114 ##
1115 ## Remove fileblocks.o from the object list.  This file gets added by
1116 ## the Autoconf macro AC_STRUCT_ST_BLOCKS.  But there is no need.
1117 #LIBOBJS="`echo ${LIBOBJS} | sed 's/fileblocks\.o//g'`"
1118
1119 ## If we're creating a shared library (using libtool!), then we'll
1120 ## need to generate a list of .lo files corresponding to the .o files
1121 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1122 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1123
1124 ## We also need to create corresponding .doc and .x files
1125 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1126 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1127
1128 AC_SUBST(GUILE_MAJOR_VERSION)
1129 AC_SUBST(GUILE_MINOR_VERSION)
1130 AC_SUBST(GUILE_MICRO_VERSION)
1131 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1132 AC_SUBST(GUILE_VERSION)
1133
1134 #######################################################################
1135 # library versioning
1136
1137 AC_SUBST(LIBQTHREADS_INTERFACE_CURRENT)
1138 AC_SUBST(LIBQTHREADS_INTERFACE_REVISION)
1139 AC_SUBST(LIBQTHREADS_INTERFACE_AGE)
1140 AC_SUBST(LIBQTHREADS_INTERFACE)
1141
1142 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1143 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1144 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1145 AC_SUBST(LIBGUILE_INTERFACE)
1146
1147 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1148 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1149 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1150 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1151
1152 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1153 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1154 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1155 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1156
1157 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1158 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1159 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1160 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1161
1162 #######################################################################
1163
1164 dnl Tell guile-config what flags guile users should link against.
1165 GUILE_LIBS="$LDFLAGS $THREAD_LIBS_INSTALLED $LIBS"
1166 AC_SUBST(GUILE_LIBS)
1167
1168 AC_SUBST(AWK)
1169 AC_SUBST(LIBLOBJS)
1170 AC_SUBST(EXTRA_DOT_DOC_FILES)
1171 AC_SUBST(EXTRA_DOT_X_FILES)
1172
1173 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1174 top_builddir_absolute=`pwd`
1175 AC_SUBST(top_builddir_absolute)
1176 top_srcdir_absolute=`(cd $srcdir && pwd)`
1177 AC_SUBST(top_srcdir_absolute)
1178
1179 # Additional SCM_I_GSC definitions are above.
1180 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1181 AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
1182 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1183 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1184 AC_SUBST([SCM_I_GSC_HAVE_ARRAYS])
1185 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1186 AC_SUBST([SCM_I_GSC_C_INLINE])
1187 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1188
1189 AC_CONFIG_FILES([
1190   Makefile
1191   am/Makefile
1192   benchmark-suite/Makefile
1193   doc/Makefile
1194   doc/goops/Makefile
1195   doc/r5rs/Makefile
1196   doc/ref/Makefile
1197   doc/tutorial/Makefile
1198   emacs/Makefile
1199   examples/Makefile
1200   examples/box-dynamic-module/Makefile
1201   examples/box-dynamic/Makefile
1202   examples/box-module/Makefile
1203   examples/box/Makefile
1204   examples/modules/Makefile
1205   examples/safe/Makefile
1206   examples/scripts/Makefile
1207   guile-config/Makefile
1208   ice-9/Makefile
1209   ice-9/debugger/Makefile
1210   ice-9/debugger/breakpoints/Makefile
1211   lang/Makefile
1212   lang/elisp/Makefile
1213   lang/elisp/internals/Makefile
1214   lang/elisp/primitives/Makefile
1215   libguile-ltdl/Makefile
1216   libguile-ltdl/upstream/Makefile
1217   libguile/Makefile
1218   oop/Makefile
1219   oop/goops/Makefile
1220   scripts/Makefile
1221   srfi/Makefile
1222   test-suite/Makefile
1223   test-suite/standalone/Makefile
1224 ])
1225
1226 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1227 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1228 AC_CONFIG_FILES([guile-tools], [chmod +x guile-tools])
1229 AC_CONFIG_FILES([pre-inst-guile], [chmod +x pre-inst-guile])
1230 AC_CONFIG_FILES([pre-inst-guile-env], [chmod +x pre-inst-guile-env])
1231 AC_CONFIG_FILES([libguile/guile-snarf],
1232                 [chmod +x libguile/guile-snarf])
1233 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1234                 [chmod +x libguile/guile-doc-snarf])
1235 AC_CONFIG_FILES([libguile/guile-func-name-check],
1236                 [chmod +x libguile/guile-func-name-check])
1237 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1238                 [chmod +x libguile/guile-snarf-docs])
1239
1240 AC_OUTPUT
1241
1242 dnl Local Variables:
1243 dnl comment-start: "dnl "
1244 dnl comment-end: ""
1245 dnl comment-start-skip: "\\bdnl\\b\\s *"
1246 dnl End: