configure.in

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