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, 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor,
  24 Boston, MA 02110-1301, USA.
  25
  26 ]])
  27
  28 AC_PREREQ(2.59)
  29
  30 dnl  `patsubst' here deletes the newline which "echo" prints.  We can't use
  31 dnl  "echo -n" since -n is not portable (see autoconf manual "Limitations of
  32 dnl  Builtins"), in particular on solaris it results in a literal "-n" in
  33 dnl  the output.
  34 dnl
  35 AC_INIT(patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${PACKAGE}),[
  36 ]),
  37         patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${GUILE_VERSION}),[
  38 ]),
  39         [bug-guile@gnu.org])
  40 AC_CONFIG_AUX_DIR([build-aux])
  41 AC_CONFIG_MACRO_DIR([m4])
  42 AC_CONFIG_SRCDIR(GUILE-VERSION)
  43
  44 AM_INIT_AUTOMAKE([gnu no-define check-news])
  45
  46 AC_COPYRIGHT(GUILE_CONFIGURE_COPYRIGHT)
  47 AC_CONFIG_SRCDIR([GUILE-VERSION])
  48
  49 . $srcdir/GUILE-VERSION
  50
  51 AM_MAINTAINER_MODE
  52 AM_CONFIG_HEADER([config.h])
  53 AH_TOP(/*GUILE_CONFIGURE_COPYRIGHT*/)
  54
  55 #--------------------------------------------------------------------
  56 #
  57 # Independent Subdirectories
  58 #
  59 #--------------------------------------------------------------------
  60
  61 AC_CONFIG_SUBDIRS(guile-readline)
  62
  63 #--------------------------------------------------------------------
  64
  65 dnl Some more checks for Win32
  66 AC_CYGWIN
  67 AC_LIBTOOL_WIN32_DLL
  68
  69 AC_PROG_INSTALL
  70 AC_PROG_CC
  71 gl_EARLY
  72 AC_PROG_CPP
  73 AC_PROG_AWK
  74
  75 dnl Gnulib.
  76 gl_INIT
  77
  78 AM_PROG_CC_STDC
  79 # for per-target cflags in the libguile subdir
  80 AM_PROG_CC_C_O
  81
  82 AC_LIBTOOL_DLOPEN
  83 AC_PROG_LIBTOOL
  84 AC_CHECK_LIB([ltdl], [lt_dlinit], ,
  85   [AC_MSG_ERROR([libltdl not found.  See README.])])
  86
  87 AC_SUBST(DLPREOPEN)
  88
  89 AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
  90 AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
  91
  92 AM_PATH_LISPDIR
  93
  94 #--------------------------------------------------------------------
  95 #
  96 # User options (after above tests that may set default CFLAGS etc.)
  97 #
  98 #--------------------------------------------------------------------
  99
 100 GUILE_ERROR_ON_WARNING="yes"
 101
 102 AC_ARG_ENABLE(error-on-warning,
 103   [  --enable-error-on-warning    treat compile warnings as errors],
 104   [case "${enableval}" in
 105      yes | y) GUILE_ERROR_ON_WARNING="yes" ;;
 106      no | n)  GUILE_ERROR_ON_WARNING="no" ;;
 107      *) AC_MSG_ERROR(bad value ${enableval} for --enable-error-on-warning) ;;
 108    esac])
 109
 110 SCM_I_GSC_GUILE_DEBUG_FREELIST=0
 111 AC_ARG_ENABLE(debug-freelist,
 112   [  --enable-debug-freelist include garbage collector freelist debugging code],
 113   if test "$enable_debug_freelist" = y \
 114      || test "$enable_debug_freelist" = yes; then
 115     SCM_I_GSC_GUILE_DEBUG_FREELIST=1
 116   fi)
 117
 118 AC_ARG_ENABLE(debug-malloc,
 119   [  --enable-debug-malloc   include malloc debugging code],
 120   if test "$enable_debug_malloc" = y || test "$enable_debug_malloc" = yes; then
 121     AC_DEFINE(GUILE_DEBUG_MALLOC, 1,
 122       [Define this if you want to debug scm_must_malloc/realloc/free calls.])
 123   fi)
 124
 125 SCM_I_GSC_GUILE_DEBUG=0
 126 AC_ARG_ENABLE(guile-debug,
 127   [AC_HELP_STRING([--enable-guile-debug],
 128                   [include internal debugging functions])],
 129   if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then
 130     SCM_I_GSC_GUILE_DEBUG=1
 131   fi)
 132
 133 AC_ARG_ENABLE(posix,
 134   [  --disable-posix         omit posix interfaces],,
 135   enable_posix=yes)
 136
 137 AC_ARG_ENABLE(networking,
 138   [  --disable-networking    omit networking interfaces],,
 139   enable_networking=yes)
 140
 141 AC_ARG_ENABLE(regex,
 142   [  --disable-regex         omit regular expression interfaces],,
 143   enable_regex=yes)
 144
 145 AC_ARG_ENABLE([discouraged],
 146   AC_HELP_STRING([--disable-discouraged],[omit discouraged features]))
 147
 148 if test "$enable_discouraged" = no; then
 149   SCM_I_GSC_ENABLE_DISCOURAGED=0
 150 else
 151   SCM_I_GSC_ENABLE_DISCOURAGED=1
 152 fi
 153
 154 AC_ARG_ENABLE([deprecated],
 155   AC_HELP_STRING([--disable-deprecated],[omit deprecated features]))
 156
 157 if test "$enable_deprecated" = no; then
 158   SCM_I_GSC_ENABLE_DEPRECATED=0
 159 else
 160   if test "$enable_deprecated" = yes || test "$enable_deprecated" = ""; then
 161     warn_default=summary
 162   elif test "$enable_deprecated" = shutup; then
 163     warn_default=no
 164   else
 165     warn_default=$enable_deprecated
 166   fi
 167   SCM_I_GSC_ENABLE_DEPRECATED=1
 168   AC_DEFINE_UNQUOTED(SCM_WARN_DEPRECATED_DEFAULT, "$warn_default",
 169   [Define this to control the default warning level for deprecated features.])
 170 fi
 171
 172 AC_ARG_ENABLE(elisp,
 173   [  --disable-elisp         omit Emacs Lisp support],,
 174   enable_elisp=yes)
 175
 176 #--------------------------------------------------------------------
 177
 178 dnl Check for dynamic linking
 179
 180 use_modules=yes
 181 AC_ARG_WITH(modules,
 182 [  --with-modules[=FILES]  Add support for dynamic modules],
 183 use_modules="$withval")
 184 test -z "$use_modules" && use_modules=yes
 185 DLPREOPEN=
 186 if test "$use_modules" != no; then
 187   if test "$use_modules" = yes; then
 188     DLPREOPEN="-dlpreopen force"
 189   else
 190     DLPREOPEN="-export-dynamic"
 191     for module in $use_modules; do
 192       DLPREOPEN="$DLPREOPEN -dlopen $module"
 193     done
 194   fi
 195 fi
 196
 197 dnl files which are destined for separate modules.
 198
 199 if test "$use_modules" != no; then
 200    AC_LIBOBJ([dynl])
 201 fi
 202
 203 if test "$enable_posix" = yes; then
 204    AC_LIBOBJ([filesys])
 205    AC_LIBOBJ([posix])
 206    AC_DEFINE(HAVE_POSIX, 1,
 207      [Define this if you want support for POSIX system calls in Guile.])
 208 fi
 209
 210 if test "$enable_networking" = yes; then
 211    AC_LIBOBJ([net_db])
 212    AC_LIBOBJ([socket])
 213    AC_DEFINE(HAVE_NETWORKING, 1,
 214      [Define this if you want support for networking in Guile.])
 215 fi
 216
 217 if test "$enable_debug_malloc" = yes; then
 218    AC_LIBOBJ([debug-malloc])
 219 fi
 220
 221 if test "$enable_elisp" = yes; then
 222   SCM_I_GSC_ENABLE_ELISP=1
 223 else
 224   SCM_I_GSC_ENABLE_ELISP=0
 225 fi
 226 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
 227
 228 AC_C_CONST
 229
 230 # "volatile" is used in a couple of tests below.
 231 AC_C_VOLATILE
 232
 233 AC_C_INLINE
 234 if test "$ac_cv_c_inline" != no; then
 235   SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\""
 236 else
 237   SCM_I_GSC_C_INLINE=NULL
 238 fi
 239 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
 240
 241 AC_C_BIGENDIAN
 242
 243 AC_CHECK_SIZEOF(char)
 244 AC_CHECK_SIZEOF(unsigned char)
 245 AC_CHECK_SIZEOF(short)
 246 AC_CHECK_SIZEOF(unsigned short)
 247 AC_CHECK_SIZEOF(int)
 248 AC_CHECK_SIZEOF(unsigned int)
 249 AC_CHECK_SIZEOF(long)
 250 AC_CHECK_SIZEOF(unsigned long)
 251 AC_CHECK_SIZEOF(size_t)
 252 AC_CHECK_SIZEOF(long long)
 253 AC_CHECK_SIZEOF(unsigned long long)
 254 AC_CHECK_SIZEOF(__int64)
 255 AC_CHECK_SIZEOF(unsigned __int64)
 256 AC_CHECK_SIZEOF(void *)
 257 AC_CHECK_SIZEOF(intptr_t)
 258 AC_CHECK_SIZEOF(uintptr_t)
 259 AC_CHECK_SIZEOF(ptrdiff_t)
 260 AC_CHECK_SIZEOF(size_t)
 261 AC_CHECK_SIZEOF(off_t)
 262
 263 if test "$ac_cv_sizeof_long" -ne "$ac_cv_sizeof_void_p"; then
 264   AC_MSG_ERROR(sizes of long and void* are not identical)
 265 fi
 266
 267 if test "$ac_cv_sizeof_ptrdiff_t" -ne 0; then
 268   SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"'
 269 else
 270   SCM_I_GSC_T_PTRDIFF='"long"'
 271 fi
 272 AC_SUBST([SCM_I_GSC_T_PTRDIFF])
 273
 274 AC_CHECK_HEADERS([stdint.h])
 275 AC_CHECK_HEADERS([inttypes.h])
 276
 277 AC_CHECK_SIZEOF(intmax_t)
 278
 279 SCM_I_GSC_NEEDS_STDINT_H=0
 280 SCM_I_GSC_NEEDS_INTTYPES_H=0
 281
 282 ### intptr and uintptr (try not to use inttypes if we don't have to)
 283 if test "$ac_cv_header_inttypes_h" = yes; then
 284   if test "$ac_cv_sizeof_intptr_t" -eq 0; then
 285     AC_CHECK_SIZEOF([intptr_t],,[#include <inttypes.h>
 286 #include <stdio.h>])
 287     if test "$ac_cv_sizeof_intptr_t" -ne 0; then
 288       SCM_I_GSC_NEEDS_INTTYPES_H=1
 289     fi
 290   fi
 291   if test "$ac_cv_sizeof_uintptr_t" -eq 0; then
 292     AC_CHECK_SIZEOF([uintptr_t],,[#include <inttypes.h>
 293 #include <stdio.h>])
 294     if test "$ac_cv_sizeof_uintptr_t" -ne 0; then
 295       SCM_I_GSC_NEEDS_INTTYPES_H=1
 296     fi
 297   fi
 298 fi
 299
 300 ### See what's provided by stdint.h
 301 if test "$ac_cv_header_stdint_h" = yes; then
 302    AC_CHECK_TYPE([int8_t],[scm_stdint_has_int8=1],,[#include <stdint.h>])
 303    AC_CHECK_TYPE([uint8_t],[scm_stdint_has_uint8=1],,[#include <stdint.h>])
 304    AC_CHECK_TYPE([int16_t],[scm_stdint_has_int16=1],,[#include <stdint.h>])
 305    AC_CHECK_TYPE([uint16_t],[scm_stdint_has_uint16=1],,[#include <stdint.h>])
 306    AC_CHECK_TYPE([int32_t],[scm_stdint_has_int32=1],,[#include <stdint.h>])
 307    AC_CHECK_TYPE([uint32_t],[scm_stdint_has_uint32=1],,[#include <stdint.h>])
 308    AC_CHECK_TYPE([int64_t],[scm_stdint_has_int64=1],,[#include <stdint.h>])
 309    AC_CHECK_TYPE([uint64_t],[scm_stdint_has_uint64=1],,[#include <stdint.h>])
 310    AC_CHECK_TYPE([intmax_t],[scm_stdint_has_intmax=1],,[#include <stdint.h>])
 311    AC_CHECK_TYPE([uintmax_t],[scm_stdint_has_uintmax=1],,[#include <stdint.h>])
 312 fi
 313
 314 # so we don't get confused by the cache (wish there was a better way
 315 # to check particular headers for the same type...)
 316
 317 unset ac_cv_type_int8_t
 318 unset ac_cv_type_uint8_t
 319 unset ac_cv_type_int16_t
 320 unset ac_cv_type_uint16_t
 321 unset ac_cv_type_int32_t
 322 unset ac_cv_type_uint32_t
 323 unset ac_cv_type_int64_t
 324 unset ac_cv_type_uint64_t
 325 unset ac_cv_type_intmax_t
 326 unset ac_cv_type_uintmax_t
 327
 328 ### See what's provided by inttypes.h
 329 if test "$ac_cv_header_inttypes_h" = yes; then
 330   AC_CHECK_TYPE([int8_t],[scm_inttypes_has_int8=1],,[#include <inttypes.h>])
 331   AC_CHECK_TYPE([uint8_t],[scm_inttypes_has_uint8=1],,[#include <inttypes.h>])
 332   AC_CHECK_TYPE([int16_t],[scm_inttypes_has_int16=1],,[#include <inttypes.h>])
 333   AC_CHECK_TYPE([uint16_t],[scm_inttypes_has_uint16=1],,[#include <inttypes.h>])
 334   AC_CHECK_TYPE([int32_t],[scm_inttypes_has_int32=1],,[#include <inttypes.h>])
 335   AC_CHECK_TYPE([uint32_t],[scm_inttypes_has_uint32=1],,[#include <inttypes.h>])
 336   AC_CHECK_TYPE([int64_t],[scm_inttypes_has_int64=1],,[#include <inttypes.h>])
 337   AC_CHECK_TYPE([uint64_t],[scm_inttypes_has_uint64=1],,[#include <inttypes.h>])
 338   AC_CHECK_TYPE([intmax_t],[scm_inttypes_has_intmax=1],,[#include <inttypes.h>])
 339   AC_CHECK_TYPE([uintmax_t],[scm_inttypes_has_uintmax=1],,[#include <inttypes.h>])
 340 fi
 341
 342 # Try hard to find definitions for some required scm_t_*int* types.
 343
 344 ### Required type scm_t_int8
 345 if test "$scm_stdint_has_int8"; then
 346   SCM_I_GSC_T_INT8='"int8_t"'
 347   SCM_I_GSC_NEEDS_STDINT_H=1
 348 elif test "$scm_inttypes_has_int8"; then
 349   SCM_I_GSC_T_INT8='"int8_t"'
 350   SCM_I_GSC_NEEDS_INTTYPES_H=1
 351 elif test "$ac_cv_sizeof_char" -eq 1; then
 352   SCM_I_GSC_T_INT8='"signed char"'
 353 else
 354   AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.])
 355 fi
 356 AC_SUBST([SCM_I_GSC_T_INT8])
 357
 358 ### Required type scm_t_uint8
 359 if test "$scm_stdint_has_uint8"; then
 360   SCM_I_GSC_T_UINT8='"uint8_t"'
 361   SCM_I_GSC_NEEDS_STDINT_H=1
 362 elif test "$scm_inttypes_has_uint8"; then
 363   SCM_I_GSC_T_UINT8='"uint8_t"'
 364   SCM_I_GSC_NEEDS_INTTYPES_H=1
 365 elif test "$ac_cv_sizeof_unsigned_char" -eq 1; then
 366   SCM_I_GSC_T_UINT8='"unsigned char"'
 367 else
 368   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.])
 369 fi
 370 AC_SUBST([SCM_I_GSC_T_UINT8])
 371
 372 ### Required type scm_t_int16 (ANSI C says int or short might work)
 373 if test "$scm_stdint_has_int16"; then
 374   SCM_I_GSC_T_INT16='"int16_t"'
 375   SCM_I_GSC_NEEDS_STDINT_H=1
 376 elif test "$scm_inttypes_has_int16"; then
 377   SCM_I_GSC_T_INT16='"int16_t"'
 378   SCM_I_GSC_NEEDS_INTTYPES_H=1
 379 elif test "$ac_cv_sizeof_int" -eq 2; then
 380   SCM_I_GSC_T_INT16='"int"'
 381 elif test "$ac_cv_sizeof_short" -eq 2; then
 382   SCM_I_GSC_T_INT16='"short"'
 383 else
 384   AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.])
 385 fi
 386 AC_SUBST([SCM_I_GSC_T_INT16])
 387
 388 ### Required type scm_t_uint16 (ANSI C says int or short might work)
 389 if test "$scm_stdint_has_uint16"; then
 390   SCM_I_GSC_T_UINT16='"uint16_t"'
 391   SCM_I_GSC_NEEDS_STDINT_H=1
 392 elif test "$scm_inttypes_has_uint16"; then
 393   SCM_I_GSC_T_UINT16='"uint16_t"'
 394   SCM_I_GSC_NEEDS_INTTYPES_H=1
 395 elif test "$ac_cv_sizeof_unsigned_int" -eq 2; then
 396   SCM_I_GSC_T_UINT16='"unsigned int"'
 397 elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then
 398   SCM_I_GSC_T_UINT16='"unsigned short"'
 399 else
 400   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.])
 401 fi
 402 AC_SUBST([SCM_I_GSC_T_UINT16])
 403
 404
 405 ### Required type scm_t_int32 (ANSI C says int, short, or long might work)
 406 if test "$scm_stdint_has_int32"; then
 407   SCM_I_GSC_T_INT32='"int32_t"'
 408   SCM_I_GSC_NEEDS_STDINT_H=1
 409 elif test "$scm_inttypes_has_int32"; then
 410   SCM_I_GSC_T_INT32='"int32_t"'
 411   SCM_I_GSC_NEEDS_INTTYPES_H=1
 412 elif test "$ac_cv_sizeof_int" -eq 4; then
 413   SCM_I_GSC_T_INT32='"int"'
 414 elif test "$ac_cv_sizeof_long" -eq 4; then
 415   SCM_I_GSC_T_INT32='"long"'
 416 elif test "$ac_cv_sizeof_short" -eq 4; then
 417   SCM_I_GSC_T_INT32='"short"'
 418 else
 419   AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.])
 420 fi
 421 AC_SUBST([SCM_I_GSC_T_INT32])
 422
 423 ### Required type scm_t_uint32 (ANSI C says int, short, or long might work)
 424 if test "$scm_stdint_has_uint32"; then
 425   SCM_I_GSC_T_UINT32='"uint32_t"'
 426   SCM_I_GSC_NEEDS_STDINT_H=1
 427 elif test "$scm_inttypes_has_uint32"; then
 428   SCM_I_GSC_T_UINT32='"uint32_t"'
 429   SCM_I_GSC_NEEDS_INTTYPES_H=1
 430 elif test "$ac_cv_sizeof_unsigned_int" -eq 4; then
 431   SCM_I_GSC_T_UINT32='"unsigned int"'
 432 elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then
 433   SCM_I_GSC_T_UINT32='"unsigned long"'
 434 elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then
 435   SCM_I_GSC_T_UINT32='"unsigned short"'
 436 else
 437   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.])
 438 fi
 439 AC_SUBST([SCM_I_GSC_T_UINT32])
 440
 441 ### Optional type scm_t_int64 (ANSI C says int, short, or long might work)
 442 ### Also try 'long long' and '__int64' if we have it.
 443 SCM_I_GSC_T_INT64=0
 444 if 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 elif test "$ac_cv_sizeof_int" -eq 8; then
 451   SCM_I_GSC_T_INT64='"int"'
 452 elif test "$ac_cv_sizeof_long" -eq 8; then
 453   SCM_I_GSC_T_INT64='"long"'
 454 elif test "$ac_cv_sizeof_short" -eq 8; then
 455   SCM_I_GSC_T_INT64='"short"'
 456 elif test "$ac_cv_sizeof_long_long" -eq 8; then
 457   SCM_I_GSC_T_INT64='"long long"'
 458 elif test "$ac_cv_sizeof___int64" -eq 8; then
 459   SCM_I_GSC_T_INT64='"__int64"'
 460 else
 461   AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.])
 462 fi
 463 AC_SUBST([SCM_I_GSC_T_INT64])
 464
 465
 466 ### Optional type scm_t_uint64 (ANSI C says int, short, or long might work)
 467 ### Also try 'long long' and '__int64' if we have it.
 468 SCM_I_GSC_T_UINT64=0
 469 if test "$scm_stdint_has_uint64"; then
 470   SCM_I_GSC_T_UINT64='"uint64_t"'
 471   SCM_I_GSC_NEEDS_STDINT_H=1
 472 elif test "$scm_inttypes_has_uint64"; then
 473   SCM_I_GSC_T_UINT64='"uint64_t"'
 474   SCM_I_GSC_NEEDS_INTTYPES_H=1
 475 elif test "$ac_cv_sizeof_unsigned_int" -eq 8; then
 476   SCM_I_GSC_T_UINT64='"unsigned int"'
 477 elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then
 478   SCM_I_GSC_T_UINT64='"unsigned long"'
 479 elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then
 480   SCM_I_GSC_T_UINT64='"unsigned short"'
 481 elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then
 482   SCM_I_GSC_T_UINT64='"unsigned long long"'
 483 elif test "$ac_cv_sizeof_unsigned___int64" -eq 8; then
 484   SCM_I_GSC_T_UINT64='"unsigned __int64"'
 485 else
 486   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint64.])
 487 fi
 488 AC_SUBST([SCM_I_GSC_T_UINT64])
 489
 490 ### Required type scm_t_intmax
 491 ###
 492 ### We try 'intmax_t', '__int64', 'long long' in this order.  When
 493 ### none of them is available, we use 'long'.
 494 ###
 495 SCM_I_GSC_T_INTMAX=0
 496 if test "$scm_stdint_has_intmax"; then
 497   SCM_I_GSC_T_INTMAX='"intmax_t"'
 498   SCM_I_GSC_NEEDS_STDINT_H=1
 499 elif test "$scm_inttypes_has_intmax"; then
 500   SCM_I_GSC_T_INTMAX='"intmax_t"'
 501   SCM_I_GSC_NEEDS_INTTYPES_H=1
 502 elif test "$ac_cv_sizeof___int64" -ne 0; then
 503   SCM_I_GSC_T_INTMAX='"__int64"'
 504 elif test "$ac_cv_sizeof_long_long" -ne 0; then
 505   SCM_I_GSC_T_INTMAX='"long long"'
 506 else
 507   SCM_I_GSC_T_INTMAX='"long"'
 508 fi
 509 AC_SUBST([SCM_I_GSC_T_INTMAX])
 510
 511 ### Required type scm_t_uintmax
 512 ###
 513 ### We try 'uintmax_t', 'unsigned __int64', 'unsigned long long' in
 514 ### this order.  When none of them is available, we use 'unsigned long'.
 515 ###
 516 SCM_I_GSC_T_UINTMAX=0
 517 if test "$scm_stdint_has_uintmax"; then
 518   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 519   SCM_I_GSC_NEEDS_STDINT_H=1
 520 elif test "$scm_inttypes_has_uintmax"; then
 521   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 522   SCM_I_GSC_NEEDS_INTTYPES_H=1
 523 elif test "$ac_cv_sizeof_unsigned___int64" -ne 0; then
 524   SCM_I_GSC_T_UINTMAX='"unsigned __int64"'
 525 elif test "$ac_cv_sizeof_unsigned_long_long" -ne 0; then
 526   SCM_I_GSC_T_UINTMAX='"unsigned long long"'
 527 else
 528   SCM_I_GSC_T_UINTMAX='"unsigned long"'
 529 fi
 530 AC_SUBST([SCM_I_GSC_T_UINTMAX])
 531
 532
 533 AC_SUBST([SCM_I_GSC_NEEDS_STDINT_H])
 534 AC_SUBST([SCM_I_GSC_NEEDS_INTTYPES_H])
 535
 536 AC_HEADER_STDC
 537 AC_HEADER_DIRENT
 538 AC_HEADER_TIME
 539 AC_HEADER_SYS_WAIT
 540
 541 # Reasons for testing:
 542 #   complex.h - new in C99
 543 #   fenv.h - available in C99, but not older systems
 544 #   process.h - mingw specific
 545 #   langinfo.h, nl_types.h - SuS v2
 546 #
 547 AC_CHECK_HEADERS([complex.h fenv.h io.h libc.h limits.h malloc.h memory.h process.h string.h \
 548 regex.h rxposix.h rx/rxposix.h sys/dir.h sys/ioctl.h sys/select.h \
 549 sys/time.h sys/timeb.h sys/times.h sys/stdtypes.h sys/types.h \
 550 sys/utime.h time.h unistd.h utime.h pwd.h grp.h sys/utsname.h \
 551 direct.h langinfo.h nl_types.h])
 552
 553 # "complex double" is new in C99, and "complex" is only a keyword if
 554 # <complex.h> is included
 555 AC_CHECK_TYPES(complex double,,,
 556 [#if HAVE_COMPLEX_H
 557 #include <complex.h>
 558 #endif])
 559
 560 # On MacOS X <sys/socklen.h> contains socklen_t, so must include that
 561 # when testing.
 562 AC_CHECK_TYPE(socklen_t, ,
 563   [AC_DEFINE_UNQUOTED(socklen_t, int,
 564                       [Define to `int' if <sys/socket.h> does not define.])],
 565   [#if HAVE_SYS_TYPES_H
 566 #include <sys/types.h>
 567 #endif
 568 #include <sys/socket.h>
 569 ])
 570 AC_CHECK_TYPE(struct ip_mreq)
 571
 572 GUILE_HEADER_LIBC_WITH_UNISTD
 573
 574 AC_TYPE_GETGROUPS
 575 AC_TYPE_SIGNAL
 576 AC_TYPE_MODE_T
 577
 578 # On mingw -lm is empty, so this test is unnecessary, but it's
 579 # harmless so we don't hard-code to suppress it.
 580 #
 581 AC_CHECK_LIB(m, cos)
 582
 583 AC_CHECK_FUNCS(gethostbyname)
 584 if test $ac_cv_func_gethostbyname = no; then
 585     AC_CHECK_LIB(nsl, gethostbyname)
 586 fi
 587
 588 AC_CHECK_FUNCS(connect)
 589 if test $ac_cv_func_connect = no; then
 590     AC_CHECK_LIB(socket, connect)
 591 fi
 592
 593 dnl
 594 dnl Check for Winsock and other functionality on Win32 (*not* CygWin)
 595 dnl
 596 EXTRA_DEFS=""
 597 case $host in
 598   *-*-mingw*)
 599     AC_CHECK_HEADER(winsock2.h, [AC_DEFINE([HAVE_WINSOCK2_H], 1,
 600       [Define if you have the <winsock2.h> header file.])])
 601     AC_CHECK_LIB(ws2_32, main)
 602     AC_LIBOBJ([win32-uname])
 603     AC_LIBOBJ([win32-dirent])
 604     if test "$enable_networking" = yes ; then
 605       AC_LIBOBJ([win32-socket])
 606     fi
 607     if test "$enable_shared" = yes ; then
 608       EXTRA_DEFS="-DSCM_IMPORT"
 609       AC_DEFINE(USE_DLL_IMPORT, 1,
 610         [Define if you need additional CPP macros on Win32 platforms.])
 611     fi
 612     ;;
 613 esac
 614 AC_SUBST(EXTRA_DEFS)
 615
 616 # Reasons for testing:
 617 #   crt_externs.h - Darwin specific
 618 #
 619 AC_CHECK_HEADERS([assert.h crt_externs.h])
 620
 621 # Reasons for testing:
 622 #   DINFINITY - OSF specific
 623 #   DQNAN - OSF specific
 624 #       (DINFINITY and DQNAN are actually global variables, not functions)
 625 #   chsize - an MS-DOS-ism, found in mingw
 626 #   clog10 - not in mingw (though others like clog and csqrt are)
 627 #   fesetround - available in C99, but not older systems
 628 #   ftruncate - posix, but probably not older systems (current mingw
 629 #               has it as an inline for chsize)
 630 #   ioctl - not in mingw.
 631 #   gmtime_r - recent posix, not on old systems
 632 #   pipe - not in mingw
 633 #   _pipe - specific to mingw, taking 3 args
 634 #   readdir_r - recent posix, not on old systems
 635 #   stat64 - SuS largefile stuff, not on old systems
 636 #   sysconf - not on old systems
 637 #   truncate - not in mingw
 638 #   isblank - available as a GNU extension or in C99
 639 #   _NSGetEnviron - Darwin specific
 640 #   strcoll_l, newlocale - GNU extensions (glibc), also available on Darwin
 641 #   nl_langinfo - X/Open, not available on Windows.
 642 #
 643 AC_CHECK_FUNCS([DINFINITY DQNAN chsize clog10 ctermid fesetround ftime ftruncate fchown getcwd geteuid gettimeofday gmtime_r ioctl lstat mkdir mknod nice pipe _pipe readdir_r readlink rename rmdir select setegid seteuid setlocale setpgid setsid sigaction siginterrupt stat64 strftime strptime symlink sync sysconf tcgetpgrp tcsetpgrp times uname waitpid strdup system usleep atexit on_exit chown link fcntl ttyname getpwent getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp index bcopy memcpy rindex truncate unsetenv isblank _NSGetEnviron strcoll strcoll_l newlocale nl_langinfo])
 644
 645 # Reasons for testing:
 646 #   netdb.h - not in mingw
 647 #   sys/param.h - not in mingw
 648 #   pthread.h - only available with pthreads.  ACX_PTHREAD doesn't
 649 #       check this specifically, we need it for the timespec test below.
 650 #   sethostname - the function itself check because it's not in mingw,
 651 #       the DECL is checked because Solaris 10 doens't have in any header
 652 #   xlocale.h - needed on Darwin for the `locale_t' API
 653 #
 654 AC_CHECK_HEADERS(crypt.h netdb.h pthread.h sys/param.h sys/resource.h sys/file.h xlocale.h)
 655 AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
 656 AC_CHECK_DECLS([sethostname])
 657
 658 # crypt() may or may not be available, for instance in some countries there
 659 # are restrictions on cryptography.
 660 #
 661 # crypt() might be in libc (eg. OpenBSD), or it might be in a separate
 662 # -lcrypt library (eg. Debian GNU/Linux).
 663 #
 664 # On HP-UX 11, crypt() is in libc and there's a dummy libcrypt.a.  We must
 665 # be careful to avoid -lcrypt in this case, since libtool will see there's
 666 # only a static libcrypt and decide to build only a static libguile.
 667 #
 668 # AC_SEARCH_LIBS lets us add -lcrypt to LIBS only if crypt() is not in the
 669 # libraries already in that list.
 670 #
 671 AC_SEARCH_LIBS(crypt, crypt,
 672   [AC_DEFINE(HAVE_CRYPT,1,
 673              [Define to 1 if you have the `crypt' function.])])
 674
 675 # glibc 2.3.6 (circa 2006) and various prior versions had a bug where
 676 # csqrt(-i) returned a negative real part, when it should be positive
 677 # for the principal root.
 678 #
 679 if test "$ac_cv_type_complex_double" = yes; then
 680
 681   AC_CHECK_FUNCS(cexp clog carg)
 682   AC_CACHE_CHECK([whether csqrt is usable],
 683     guile_cv_use_csqrt,
 684     [AC_TRY_RUN([
 685 #include <complex.h>
 686 /* "volatile" is meant to prevent gcc from calculating the sqrt as a
 687    constant, we want to test libc. */
 688 volatile complex double z = - _Complex_I;
 689 int
 690 main (void)
 691 {
 692   z = csqrt (z);
 693   if (creal (z) > 0.0)
 694     return 0;  /* good */
 695   else
 696     return 1;  /* bad */
 697 }],
 698     [guile_cv_use_csqrt=yes],
 699     [guile_cv_use_csqrt="no, glibc 2.3 bug"],
 700     [guile_cv_use_csqrt="yes, hopefully (cross-compiling)"])])
 701   case $guile_cv_use_csqrt in
 702     yes*)
 703       AC_DEFINE(HAVE_USABLE_CSQRT, 1, [Define to 1 if csqrt is bug-free])
 704       ;;
 705   esac
 706 fi
 707
 708
 709 dnl GMP tests
 710 AC_CHECK_LIB([gmp], [__gmpz_init], ,
 711   [AC_MSG_ERROR([GNU MP not found, see README])])
 712
 713 # mpz_import is a macro so we need to include <gmp.h>
 714 AC_TRY_LINK([#include <gmp.h>],
 715             [mpz_import (0, 0, 0, 0, 0, 0, 0);] , ,
 716   [AC_MSG_ERROR([At least GNU MP 4.1 is required, see README])])
 717
 718 dnl i18n tests
 719 #AC_CHECK_HEADERS([libintl.h])
 720 #AC_CHECK_FUNCS(gettext)
 721 #if test $ac_cv_func_gettext = no; then
 722 #   AC_CHECK_LIB(intl, gettext)
 723 #fi
 724 #AC_CHECK_FUNCS([bindtextdomain textdomain])
 725 AM_GNU_GETTEXT([external], [need-ngettext])
 726
 727 ### Some systems don't declare some functions.  On such systems, we
 728 ### need to at least provide our own K&R-style declarations.
 729
 730 ### GUILE_FUNC_DECLARED(function, headerfile)
 731
 732 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
 733 ### not there, #define MISSING_FUNCTION_DECL.
 734 AC_DEFUN([GUILE_FUNC_DECLARED], [
 735   AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
 736     AC_EGREP_HEADER($1, $2,
 737                     guile_cv_func_$1_declared=yes,
 738                     guile_cv_func_$1_declared=no))
 739   if test [x$guile_cv_func_]$1[_declared] = xno; then
 740     AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
 741       [Define if the operating system supplies $1 without declaring it.])
 742   fi
 743 ])
 744
 745 GUILE_FUNC_DECLARED(sleep, unistd.h)
 746 GUILE_FUNC_DECLARED(usleep, unistd.h)
 747
 748 AC_CHECK_DECLS([strptime],,,
 749 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
 750 #include <time.h>])
 751
 752 ### On some systems usleep has no return value.  If it does have one,
 753 ### we'd like to return it; otherwise, we'll fake it.
 754 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
 755   [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),
 756                    unistd.h,
 757                    [guile_cv_func_usleep_return_type=void],
 758                    [guile_cv_func_usleep_return_type=int])])
 759 case "$guile_cv_func_usleep_return_type" in
 760   "void" )
 761     AC_DEFINE(USLEEP_RETURNS_VOID, 1,
 762       [Define if the system headers declare usleep to return void.])
 763   ;;
 764 esac
 765
 766 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
 767 if test -n "$have_sys_un_h" ; then
 768   AC_DEFINE(HAVE_UNIX_DOMAIN_SOCKETS, 1,
 769     [Define if the system supports Unix-domain (file-domain) sockets.])
 770 fi
 771
 772 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
 773
 774 AC_CHECK_FUNCS(sethostent   gethostent   endhostent   dnl
 775                setnetent    getnetent    endnetent    dnl
 776                setprotoent  getprotoent  endprotoent  dnl
 777                setservent   getservent   endservent   dnl
 778                getnetbyaddr getnetbyname dnl
 779                inet_lnaof inet_makeaddr inet_netof hstrerror dnl
 780                inet_pton inet_ntop)
 781
 782 # struct sockaddr field sin_len is only present on BSD systems.
 783 # On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems
 784 # (eg. FreeBSD 4.9) it doesn't and we must use this configure check
 785 AC_CHECK_MEMBERS([struct sockaddr.sin_len],,,
 786 [#ifdef HAVE_SYS_TYPES_H
 787 #include <sys/types.h>
 788 #endif
 789 #include <netinet/in.h>])
 790
 791 AC_MSG_CHECKING(for __libc_stack_end)
 792 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
 793 [AC_TRY_LINK([#include <stdio.h>
 794 extern char *__libc_stack_end;],
 795              [printf("%p", (char*) __libc_stack_end);],
 796              guile_cv_have_libc_stack_end=yes,
 797              guile_cv_have_libc_stack_end=no)])
 798 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
 799
 800 if test $guile_cv_have_libc_stack_end = yes; then
 801   AC_DEFINE(HAVE_LIBC_STACK_END, 1,
 802            [Define if you have the __libc_stack_end variable.])
 803 fi
 804
 805 dnl Some systems do not declare this.  Some systems do declare it, as a
 806 dnl macro.  With cygwin it may be in a DLL.
 807
 808 AC_MSG_CHECKING(whether netdb.h declares h_errno)
 809 AC_CACHE_VAL(guile_cv_have_h_errno,
 810 [AC_TRY_COMPILE([#include <netdb.h>],
 811 [int a = h_errno;],
 812 guile_cv_have_h_errno=yes, guile_cv_have_h_errno=no)])
 813 AC_MSG_RESULT($guile_cv_have_h_errno)
 814 if test $guile_cv_have_h_errno = yes; then
 815   AC_DEFINE(HAVE_H_ERRNO, 1, [Define if h_errno is declared in netdb.h.])
 816 fi
 817
 818 AC_MSG_CHECKING(whether uint32_t is defined)
 819 AC_CACHE_VAL(guile_cv_have_uint32_t,
 820   [AC_TRY_COMPILE([#include <sys/types.h>
 821                    #if HAVE_STDINT_H
 822                    #include <stdint.h>
 823                    #endif
 824                    #ifndef HAVE_NETDB_H
 825                    #include <netdb.h>
 826                    #endif],
 827                   [uint32_t a;],
 828                   guile_cv_have_uint32_t=yes, guile_cv_have_uint32_t=no)])
 829 AC_MSG_RESULT($guile_cv_have_uint32_t)
 830 if test $guile_cv_have_uint32_t = yes; then
 831   AC_DEFINE(HAVE_UINT32_T, 1,
 832     [Define if uint32_t typedef is defined when netdb.h is include.])
 833 fi
 834
 835 AC_MSG_CHECKING(for working IPv6 support)
 836 AC_CACHE_VAL(guile_cv_have_ipv6,
 837 [AC_TRY_COMPILE([
 838 #ifdef HAVE_SYS_TYPES_H
 839 #include <sys/types.h>
 840 #endif
 841 #include <netinet/in.h>
 842 #include <sys/socket.h>],
 843 [struct sockaddr_in6 a;  a.sin6_family = AF_INET6;],
 844 guile_cv_have_ipv6=yes, guile_cv_have_ipv6=no)])
 845 AC_MSG_RESULT($guile_cv_have_ipv6)
 846 if test $guile_cv_have_ipv6 = yes; then
 847   AC_DEFINE(HAVE_IPV6, 1, [Define if you want support for IPv6.])
 848 fi
 849
 850 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
 851 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
 852 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
 853 [AC_TRY_COMPILE([
 854 #ifdef HAVE_SYS_TYPES_H
 855 #include <sys/types.h>
 856 #endif
 857 #include <netinet/in.h>],
 858 [struct sockaddr_in6 sok;  sok.sin6_scope_id = 0;],
 859 guile_cv_have_sin6_scope_id=yes, guile_cv_have_sin6_scope_id=no)])
 860 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
 861 if test $guile_cv_have_sin6_scope_id = yes; then
 862   AC_DEFINE(HAVE_SIN6_SCOPE_ID, 1,
 863     [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
 864 fi
 865
 866 # struct sockaddr_in6 field sin_len is only present on BSD systems
 867 AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,,
 868 [#ifdef HAVE_SYS_TYPES_H
 869 #include <sys/types.h>
 870 #endif
 871 #include <netinet/in.h>])
 872
 873 AC_MSG_CHECKING(whether localtime caches TZ)
 874 AC_CACHE_VAL(guile_cv_localtime_cache,
 875 [if test x$ac_cv_func_tzset = xyes; then
 876 AC_TRY_RUN([#include <time.h>
 877 #if STDC_HEADERS
 878 # include <stdlib.h>
 879 #endif
 880 extern char **environ;
 881 unset_TZ ()
 882 {
 883   char **from, **to;
 884   for (to = from = environ; (*to = *from); from++)
 885     if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
 886       to++;
 887 }
 888 char TZ_GMT0[] = "TZ=GMT0";
 889 char TZ_PST8[] = "TZ=PST8";
 890 main()
 891 {
 892   time_t now = time ((time_t *) 0);
 893   int hour_GMT0, hour_unset;
 894   if (putenv (TZ_GMT0) != 0)
 895     exit (1);
 896   hour_GMT0 = localtime (&now)->tm_hour;
 897   unset_TZ ();
 898   hour_unset = localtime (&now)->tm_hour;
 899   if (putenv (TZ_PST8) != 0)
 900     exit (1);
 901   if (localtime (&now)->tm_hour == hour_GMT0)
 902     exit (1);
 903   unset_TZ ();
 904   if (localtime (&now)->tm_hour != hour_unset)
 905     exit (1);
 906   exit (0);
 907 }], guile_cv_localtime_cache=no, guile_cv_localtime_cache=yes,
 908 [# If we have tzset, assume the worst when cross-compiling.
 909 guile_cv_localtime_cache=yes])
 910 else
 911         # If we lack tzset, report that localtime does not cache TZ,
 912         # since we can't invalidate the cache if we don't have tzset.
 913         guile_cv_localtime_cache=no
 914 fi])dnl
 915 AC_MSG_RESULT($guile_cv_localtime_cache)
 916 if test $guile_cv_localtime_cache = yes; then
 917   AC_DEFINE(LOCALTIME_CACHE, 1, [Define if localtime caches the TZ setting.])
 918 fi
 919
 920 dnl Test whether system calls are restartable by default on the
 921 dnl current system.  If they are not, we put a loop around every system
 922 dnl call to check for EINTR (see SCM_SYSCALL) and do not attempt to
 923 dnl change from the default behaviour.  On the other hand, if signals
 924 dnl are restartable then the loop is not installed and when libguile
 925 dnl initialises it also resets the behaviour of each signal to cause a
 926 dnl restart (in case a different runtime had a different default
 927 dnl behaviour for some reason: e.g., different versions of linux seem
 928 dnl to behave differently.)
 929
 930 AC_SYS_RESTARTABLE_SYSCALLS
 931
 932 if test "$enable_regex" = yes; then
 933    if test "$ac_cv_header_regex_h" = yes ||
 934       test "$ac_cv_header_rxposix_h" = yes ||
 935       test "$ac_cv_header_rx_rxposix_h" = yes; then
 936      GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
 937      [AC_CHECK_LIB(rx, main)
 938       GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
 939      [AC_CHECK_LIB(regex, main)
 940       GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
 941      )
 942      dnl The following should not be necessary, but for some reason
 943      dnl autoheader misses it if we don't include it!
 944      if test "$ac_cv_func_regcomp_norx" = yes ||
 945         test "$ac_cv_func_regcomp_regex" = yes ||
 946         test "$ac_cv_func_regcomp_rx" = yes; then
 947        AC_DEFINE(HAVE_REGCOMP, 1,
 948          [This is included as part of a workaround for a autoheader bug.])
 949      fi
 950    fi
 951 fi
 952
 953 AC_REPLACE_FUNCS(inet_aton putenv strerror memmove mkstemp)
 954
 955 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
 956
 957 # Reasons for testing:
 958 #   asinh, acosh, atanh, trunc - C99 standard, generally not available on
 959 #                                older systems
 960 #   sincos - GLIBC extension
 961 #
 962 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
 963
 964 # C99 specifies isinf and isnan as macros.
 965 # HP-UX provides only macros, no functions.
 966 # glibc 2.3.2 provides both macros and functions.
 967 # IRIX 6.5 and Solaris 8 only provide functions.
 968 #
 969 # The following tests detect isinf and isnan either as functions or as
 970 # macros from <math.h>.  Plain AC_CHECK_FUNCS is insufficient, it doesn't
 971 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
 972 #
 973 AC_MSG_CHECKING([for isinf])
 974 AC_LINK_IFELSE(AC_LANG_SOURCE(
 975 [[#include <math.h>
 976 volatile double x = 0.0;
 977 int main () { return (isinf(x) != 0); }]]),
 978   [AC_MSG_RESULT([yes])
 979    AC_DEFINE(HAVE_ISINF, 1,
 980              [Define to 1 if you have the `isinf' macro or function.])],
 981   [AC_MSG_RESULT([no])])
 982 AC_MSG_CHECKING([for isnan])
 983 AC_LINK_IFELSE(AC_LANG_SOURCE(
 984 [[#include <math.h>
 985 volatile double x = 0.0;
 986 int main () { return (isnan(x) != 0); }]]),
 987   [AC_MSG_RESULT([yes])
 988    AC_DEFINE(HAVE_ISNAN, 1,
 989              [Define to 1 if you have the `isnan' macro or function.])],
 990   [AC_MSG_RESULT([no])])
 991
 992 # Reasons for checking:
 993 #
 994 #     st_rdev
 995 #     st_blksize
 996 #     st_blocks   not in mingw
 997 #     tm_gmtoff   BSD+GNU, not in C99
 998 #
 999 # Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the
1000 # AC_LIBOBJ(fileblocks) replacement which that macro gives.
1001 #
1002 AC_CHECK_MEMBERS([struct stat.st_rdev, struct stat.st_blksize, struct stat.st_blocks])
1003
1004 AC_STRUCT_TIMEZONE
1005 AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,
1006 [#include <time.h>
1007 #ifdef TIME_WITH_SYS_TIME
1008 # include <sys/time.h>
1009 # include <time.h>
1010 #else
1011 # if HAVE_SYS_TIME_H
1012 #  include <sys/time.h>
1013 # else
1014 #  include <time.h>
1015 # endif
1016 #endif
1017 ])
1018 GUILE_STRUCT_UTIMBUF
1019
1020
1021 #--------------------------------------------------------------------
1022 #
1023 # Which way does the stack grow?
1024 #
1025 #--------------------------------------------------------------------
1026
1027 SCM_I_GSC_STACK_GROWS_UP=0
1028 AC_TRY_RUN(aux (l) unsigned long l;
1029              { int x; exit (l >= ((unsigned long)&x)); }
1030            main () { int q; aux((unsigned long)&q); },
1031            [SCM_I_GSC_STACK_GROWS_UP=1],
1032            [],
1033            [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
1034
1035 AC_CHECK_SIZEOF(float)
1036 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1037     AC_DEFINE(SCM_SINGLES, 1,
1038               [Define this if floats are the same size as longs.])
1039 fi
1040
1041 AC_MSG_CHECKING(for struct linger)
1042 AC_CACHE_VAL(scm_cv_struct_linger,
1043         AC_TRY_COMPILE([
1044 #include <sys/types.h>
1045 #include <sys/socket.h>],
1046                         [struct linger lgr;  lgr.l_linger = 100],
1047                         scm_cv_struct_linger="yes",
1048                         scm_cv_struct_linger="no"))
1049 AC_MSG_RESULT($scm_cv_struct_linger)
1050 if test $scm_cv_struct_linger = yes; then
1051         AC_DEFINE(HAVE_STRUCT_LINGER, 1,
1052           [Define this if your system defines struct linger, for use with the
1053            getsockopt and setsockopt system calls.])
1054 fi
1055
1056
1057 # On mingw, struct timespec is in <pthread.h>.
1058 #
1059 AC_MSG_CHECKING(for struct timespec)
1060 AC_CACHE_VAL(scm_cv_struct_timespec,
1061         AC_TRY_COMPILE([
1062 #include <time.h>
1063 #if HAVE_PTHREAD_H
1064 #include <pthread.h>
1065 #endif],
1066                         [struct timespec t;  t.tv_nsec = 100],
1067                         scm_cv_struct_timespec="yes",
1068                         scm_cv_struct_timespec="no"))
1069 AC_MSG_RESULT($scm_cv_struct_timespec)
1070 if test $scm_cv_struct_timespec = yes; then
1071   AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1,
1072     [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1073 fi
1074
1075 #--------------------------------------------------------------------
1076 #
1077 # Flags for thread support
1078 #
1079 #--------------------------------------------------------------------
1080
1081 SCM_I_GSC_USE_PTHREAD_THREADS=0
1082 SCM_I_GSC_USE_NULL_THREADS=0
1083 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1084 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1085
1086 ### What thread package has the user asked for?
1087 AC_ARG_WITH(threads, [  --with-threads          thread interface],
1088             , with_threads=yes)
1089
1090 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1091
1092 case "$with_threads" in
1093   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1094     ACX_PTHREAD(CC="$PTHREAD_CC"
1095       LIBS="$PTHREAD_LIBS $LIBS"
1096       SCM_I_GSC_USE_PTHREAD_THREADS=1
1097       with_threads="pthreads",
1098       with_threads="null")
1099
1100     old_CFLAGS="$CFLAGS"
1101     CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1102
1103     # Reasons for testing:
1104     #     pthread_getattr_np - "np" meaning "non portable" says it
1105     #         all; not present on MacOS X or Solaris 10
1106     #     pthread_get_stackaddr_np - "np" meaning "non portable" says it
1107     #         all; specific to MacOS X
1108     #     pthread_sigmask - not available on mingw
1109     #
1110     AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1111
1112     # On past versions of Solaris, believe 8 through 10 at least, you
1113     # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1114     # This is contrary to posix:
1115     # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1116     # Check here if this style is required.
1117     #
1118     # glibc (2.3.6 at least) works both with or without braces, so the
1119     # test checks whether it works without.
1120     #
1121     AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1122       guile_cv_need_braces_on_pthread_once_init,
1123       [AC_TRY_COMPILE([#include <pthread.h>],
1124         [pthread_once_t foo = PTHREAD_ONCE_INIT;],
1125         [guile_cv_need_braces_on_pthread_once_init=no],
1126         [guile_cv_need_braces_on_pthread_once_init=yes])])
1127     if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1128       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1129     fi
1130
1131     CFLAGS="$old_CFLAGS"
1132
1133     # On Solaris, sched_yield lives in -lrt.
1134     AC_SEARCH_LIBS(sched_yield, rt)
1135
1136   ;;
1137 esac
1138
1139 case "$with_threads" in
1140   "pthreads")
1141   ;;
1142   "no" | "null")
1143     SCM_I_GSC_USE_NULL_THREADS=1
1144     with_threads="null-threads"
1145   ;;
1146   * )
1147     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1148   ;;
1149 esac
1150
1151 AC_MSG_CHECKING(what kind of threads to support)
1152 AC_MSG_RESULT($with_threads)
1153
1154 ## Check whether pthread_attr_getstack works for the main thread
1155
1156 if test "$with_threads" = pthreads; then
1157
1158 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1159 old_CFLAGS="$CFLAGS"
1160 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1161 AC_TRY_RUN(
1162 [
1163 #if HAVE_PTHREAD_ATTR_GETSTACK
1164 #include <pthread.h>
1165
1166 int main ()
1167 {
1168   pthread_attr_t attr;
1169   void *start, *end;
1170   size_t size;
1171
1172   pthread_getattr_np (pthread_self (), &attr);
1173   pthread_attr_getstack (&attr, &start, &size);
1174   end = (char *)start + size;
1175
1176   if ((void *)&attr < start || (void *)&attr >= end)
1177     return 1;
1178   else
1179     return 0;
1180 }
1181 #else
1182 int main ()
1183 {
1184   return 1;
1185 }
1186 #endif
1187 ],
1188 [works=yes
1189 AC_DEFINE(PTHREAD_ATTR_GETSTACK_WORKS, [1], [Define when pthread_att_get_stack works for the main thread])],
1190 [works=no])
1191 CFLAGS="$old_CFLAGS"
1192 AC_MSG_RESULT($works)
1193
1194 fi # with_threads=pthreads
1195
1196
1197 ## Cross building
1198 if test "$cross_compiling" = "yes"; then
1199   AC_MSG_CHECKING(cc for build)
1200   ## /usr/bin/cc still uses wrong assembler
1201   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1202   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1203 else
1204   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1205 fi
1206
1207 ## AC_MSG_CHECKING("if we are cross compiling")
1208 ## AC_MSG_RESULT($cross_compiling)
1209 if test "$cross_compiling" = "yes"; then
1210    AC_MSG_RESULT($CC_FOR_BUILD)
1211 fi
1212
1213 ## No need as yet to be more elaborate
1214 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1215
1216 AC_SUBST(cross_compiling)
1217 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1218 AC_SUBST(CCLD_FOR_BUILD)
1219
1220 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1221 ## --HOST is the platform that PACKAGE is compiled for.
1222 HOST_CC="$CC_FOR_BUILD"
1223 AC_SUBST(HOST_CC)
1224
1225 if test "$cross_compiling" = "yes"; then
1226   AC_MSG_CHECKING(guile for build)
1227   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1228 else
1229   GUILE_FOR_BUILD='$(preinstguile)'
1230 fi
1231
1232 ## AC_MSG_CHECKING("if we are cross compiling")
1233 ## AC_MSG_RESULT($cross_compiling)
1234 if test "$cross_compiling" = "yes"; then
1235    AC_MSG_RESULT($GUILE_FOR_BUILD)
1236 fi
1237 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1238 AC_SUBST(GUILE_FOR_BUILD)
1239
1240 ## If we're using GCC, ask for aggressive warnings.
1241 case "$GCC" in
1242   yes )
1243     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1244     ## much stuff with generic function pointers for that to really be
1245     ## less than exasperating.
1246     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1247     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1248     CFLAGS="$CFLAGS -Wall -Wmissing-prototypes"
1249     # Do this here so we don't screw up any of the tests above that might
1250     # not be "warning free"
1251     if test "${GUILE_ERROR_ON_WARNING}" = yes
1252     then
1253         CFLAGS="${CFLAGS} -Werror"
1254         enable_compile_warnings=no
1255     fi
1256     ;;
1257 esac
1258
1259 ## If we're creating a shared library (using libtool!), then we'll
1260 ## need to generate a list of .lo files corresponding to the .o files
1261 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1262 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1263
1264 ## We also need to create corresponding .doc and .x files
1265 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1266 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1267
1268 AC_SUBST(GUILE_MAJOR_VERSION)
1269 AC_SUBST(GUILE_MINOR_VERSION)
1270 AC_SUBST(GUILE_MICRO_VERSION)
1271 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1272 AC_SUBST(GUILE_VERSION)
1273
1274 #######################################################################
1275 # library versioning
1276
1277 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1278 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1279 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1280 AC_SUBST(LIBGUILE_INTERFACE)
1281
1282 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1283 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1284 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1285 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1286 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1287
1288 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1289 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1290 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1291 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1292 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1293
1294 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1295 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1296 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1297 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1298 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1299
1300 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1301 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1302 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1303 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1304 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1305
1306 AC_SUBST(LIBGUILE_I18N_MAJOR)
1307 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1308 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1309 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1310 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1311
1312
1313 #######################################################################
1314
1315 dnl Tell guile-config what flags guile users should compile and link with.
1316 GUILE_LIBS="$LDFLAGS $LIBS"
1317 GUILE_CFLAGS="$PTHREAD_CFLAGS"
1318 AC_SUBST(GUILE_LIBS)
1319 AC_SUBST(GUILE_CFLAGS)
1320
1321 AC_SUBST(AWK)
1322 AC_SUBST(LIBLOBJS)
1323 AC_SUBST(EXTRA_DOT_DOC_FILES)
1324 AC_SUBST(EXTRA_DOT_X_FILES)
1325
1326 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1327 top_builddir_absolute=`pwd`
1328 AC_SUBST(top_builddir_absolute)
1329 top_srcdir_absolute=`(cd $srcdir && pwd)`
1330 AC_SUBST(top_srcdir_absolute)
1331
1332 # Additional SCM_I_GSC definitions are above.
1333 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1334 AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
1335 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1336 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1337 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1338 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1339 AC_SUBST([SCM_I_GSC_C_INLINE])
1340 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1341
1342 AC_CONFIG_FILES([
1343   Makefile
1344   am/Makefile
1345   lib/Makefile
1346   benchmark-suite/Makefile
1347   doc/Makefile
1348   doc/goops/Makefile
1349   doc/r5rs/Makefile
1350   doc/ref/Makefile
1351   doc/tutorial/Makefile
1352   emacs/Makefile
1353   examples/Makefile
1354   examples/box-dynamic-module/Makefile
1355   examples/box-dynamic/Makefile
1356   examples/box-module/Makefile
1357   examples/box/Makefile
1358   examples/modules/Makefile
1359   examples/safe/Makefile
1360   examples/scripts/Makefile
1361   guile-config/Makefile
1362   ice-9/Makefile
1363   ice-9/debugger/Makefile
1364   ice-9/debugging/Makefile
1365   lang/Makefile
1366   lang/elisp/Makefile
1367   lang/elisp/internals/Makefile
1368   lang/elisp/primitives/Makefile
1369   libguile/Makefile
1370   oop/Makefile
1371   oop/goops/Makefile
1372   scripts/Makefile
1373   srfi/Makefile
1374   test-suite/Makefile
1375   test-suite/standalone/Makefile
1376 ])
1377
1378 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1379 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1380 AC_CONFIG_FILES([guile-tools], [chmod +x guile-tools])
1381 AC_CONFIG_FILES([pre-inst-guile], [chmod +x pre-inst-guile])
1382 AC_CONFIG_FILES([pre-inst-guile-env], [chmod +x pre-inst-guile-env])
1383 AC_CONFIG_FILES([libguile/guile-snarf],
1384                 [chmod +x libguile/guile-snarf])
1385 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1386                 [chmod +x libguile/guile-doc-snarf])
1387 AC_CONFIG_FILES([libguile/guile-func-name-check],
1388                 [chmod +x libguile/guile-func-name-check])
1389 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1390                 [chmod +x libguile/guile-snarf-docs])
1391
1392 AC_OUTPUT
1393
1394 dnl Local Variables:
1395 dnl comment-start: "dnl "
1396 dnl comment-end: ""
1397 dnl comment-start-skip: "\\bdnl\\b\\s *"
1398 dnl End: