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 #   cexp, clog - not in various pre-c99 systems, and note that it's possible
 627 #       for gcc to provide the "complex double" type but the system to not
 628 #       have functions like cexp and clog
 629 #   clog10 - not in mingw (though others like clog and csqrt are)
 630 #   fesetround - available in C99, but not older systems
 631 #   ftruncate - posix, but probably not older systems (current mingw
 632 #               has it as an inline for chsize)
 633 #   ioctl - not in mingw.
 634 #   gmtime_r - recent posix, not on old systems
 635 #   pipe - not in mingw
 636 #   _pipe - specific to mingw, taking 3 args
 637 #   readdir_r - recent posix, not on old systems
 638 #   stat64 - SuS largefile stuff, not on old systems
 639 #   sysconf - not on old systems
 640 #   truncate - not in mingw
 641 #   isblank - available as a GNU extension or in C99
 642 #   _NSGetEnviron - Darwin specific
 643 #   strcoll_l, newlocale - GNU extensions (glibc), also available on Darwin
 644 #   nl_langinfo - X/Open, not available on Windows.
 645 #
 646 AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid fesetround ftime ftruncate fchown getcwd geteuid gettimeofday gmtime_r ioctl lstat mkdir mknod nice pipe _pipe readdir_r 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])
 647
 648 # Reasons for testing:
 649 #   netdb.h - not in mingw
 650 #   sys/param.h - not in mingw
 651 #   pthread.h - only available with pthreads.  ACX_PTHREAD doesn't
 652 #       check this specifically, we need it for the timespec test below.
 653 #   sethostname - the function itself check because it's not in mingw,
 654 #       the DECL is checked because Solaris 10 doens't have in any header
 655 #   xlocale.h - needed on Darwin for the `locale_t' API
 656 #
 657 AC_CHECK_HEADERS(crypt.h netdb.h pthread.h sys/param.h sys/resource.h sys/file.h xlocale.h)
 658 AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
 659 AC_CHECK_DECLS([sethostname])
 660
 661 # crypt() may or may not be available, for instance in some countries there
 662 # are restrictions on cryptography.
 663 #
 664 # crypt() might be in libc (eg. OpenBSD), or it might be in a separate
 665 # -lcrypt library (eg. Debian GNU/Linux).
 666 #
 667 # On HP-UX 11, crypt() is in libc and there's a dummy libcrypt.a.  We must
 668 # be careful to avoid -lcrypt in this case, since libtool will see there's
 669 # only a static libcrypt and decide to build only a static libguile.
 670 #
 671 # AC_SEARCH_LIBS lets us add -lcrypt to LIBS only if crypt() is not in the
 672 # libraries already in that list.
 673 #
 674 AC_SEARCH_LIBS(crypt, crypt,
 675   [AC_DEFINE(HAVE_CRYPT,1,
 676              [Define to 1 if you have the `crypt' function.])])
 677
 678 # glibc 2.3.6 (circa 2006) and various prior versions had a bug where
 679 # csqrt(-i) returned a negative real part, when it should be positive
 680 # for the principal root.
 681 #
 682 if test "$ac_cv_type_complex_double" = yes; then
 683
 684   AC_CACHE_CHECK([whether csqrt is usable],
 685     guile_cv_use_csqrt,
 686     [AC_TRY_RUN([
 687 #include <complex.h>
 688 /* "volatile" is meant to prevent gcc from calculating the sqrt as a
 689    constant, we want to test libc. */
 690 volatile complex double z = - _Complex_I;
 691 int
 692 main (void)
 693 {
 694   z = csqrt (z);
 695   if (creal (z) > 0.0)
 696     return 0;  /* good */
 697   else
 698     return 1;  /* bad */
 699 }],
 700     [guile_cv_use_csqrt=yes],
 701     [guile_cv_use_csqrt="no, glibc 2.3 bug"],
 702     [guile_cv_use_csqrt="yes, hopefully (cross-compiling)"])])
 703   case $guile_cv_use_csqrt in
 704     yes*)
 705       AC_DEFINE(HAVE_USABLE_CSQRT, 1, [Define to 1 if csqrt is bug-free])
 706       ;;
 707   esac
 708 fi
 709
 710
 711 dnl GMP tests
 712 AC_CHECK_LIB([gmp], [__gmpz_init], ,
 713   [AC_MSG_ERROR([GNU MP not found, see README])])
 714
 715 # mpz_import is a macro so we need to include <gmp.h>
 716 AC_TRY_LINK([#include <gmp.h>],
 717             [mpz_import (0, 0, 0, 0, 0, 0, 0);] , ,
 718   [AC_MSG_ERROR([At least GNU MP 4.1 is required, see README])])
 719
 720 dnl i18n tests
 721 #AC_CHECK_HEADERS([libintl.h])
 722 #AC_CHECK_FUNCS(gettext)
 723 #if test $ac_cv_func_gettext = no; then
 724 #   AC_CHECK_LIB(intl, gettext)
 725 #fi
 726 #AC_CHECK_FUNCS([bindtextdomain textdomain])
 727 AM_GNU_GETTEXT([external], [need-ngettext])
 728
 729 ### Some systems don't declare some functions.  On such systems, we
 730 ### need to at least provide our own K&R-style declarations.
 731
 732 ### GUILE_FUNC_DECLARED(function, headerfile)
 733
 734 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
 735 ### not there, #define MISSING_FUNCTION_DECL.
 736 AC_DEFUN([GUILE_FUNC_DECLARED], [
 737   AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
 738     AC_EGREP_HEADER($1, $2,
 739                     guile_cv_func_$1_declared=yes,
 740                     guile_cv_func_$1_declared=no))
 741   if test [x$guile_cv_func_]$1[_declared] = xno; then
 742     AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
 743       [Define if the operating system supplies $1 without declaring it.])
 744   fi
 745 ])
 746
 747 GUILE_FUNC_DECLARED(sleep, unistd.h)
 748 GUILE_FUNC_DECLARED(usleep, unistd.h)
 749
 750 AC_CHECK_DECLS([strptime],,,
 751 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
 752 #include <time.h>])
 753
 754 ### On some systems usleep has no return value.  If it does have one,
 755 ### we'd like to return it; otherwise, we'll fake it.
 756 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
 757   [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),
 758                    unistd.h,
 759                    [guile_cv_func_usleep_return_type=void],
 760                    [guile_cv_func_usleep_return_type=int])])
 761 case "$guile_cv_func_usleep_return_type" in
 762   "void" )
 763     AC_DEFINE(USLEEP_RETURNS_VOID, 1,
 764       [Define if the system headers declare usleep to return void.])
 765   ;;
 766 esac
 767
 768 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
 769 if test -n "$have_sys_un_h" ; then
 770   AC_DEFINE(HAVE_UNIX_DOMAIN_SOCKETS, 1,
 771     [Define if the system supports Unix-domain (file-domain) sockets.])
 772 fi
 773
 774 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
 775
 776 AC_CHECK_FUNCS(sethostent   gethostent   endhostent   dnl
 777                setnetent    getnetent    endnetent    dnl
 778                setprotoent  getprotoent  endprotoent  dnl
 779                setservent   getservent   endservent   dnl
 780                getnetbyaddr getnetbyname dnl
 781                inet_lnaof inet_makeaddr inet_netof hstrerror dnl
 782                inet_pton inet_ntop)
 783
 784 # struct sockaddr field sin_len is only present on BSD systems.
 785 # On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems
 786 # (eg. FreeBSD 4.9) it doesn't and we must use this configure check
 787 AC_CHECK_MEMBERS([struct sockaddr.sin_len],,,
 788 [#ifdef HAVE_SYS_TYPES_H
 789 #include <sys/types.h>
 790 #endif
 791 #include <netinet/in.h>])
 792
 793 AC_MSG_CHECKING(for __libc_stack_end)
 794 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
 795 [AC_TRY_LINK([#include <stdio.h>
 796 extern char *__libc_stack_end;],
 797              [printf("%p", (char*) __libc_stack_end);],
 798              guile_cv_have_libc_stack_end=yes,
 799              guile_cv_have_libc_stack_end=no)])
 800 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
 801
 802 if test $guile_cv_have_libc_stack_end = yes; then
 803   AC_DEFINE(HAVE_LIBC_STACK_END, 1,
 804            [Define if you have the __libc_stack_end variable.])
 805 fi
 806
 807 dnl Some systems do not declare this.  Some systems do declare it, as a
 808 dnl macro.  With cygwin it may be in a DLL.
 809
 810 AC_MSG_CHECKING(whether netdb.h declares h_errno)
 811 AC_CACHE_VAL(guile_cv_have_h_errno,
 812 [AC_TRY_COMPILE([#include <netdb.h>],
 813 [int a = h_errno;],
 814 guile_cv_have_h_errno=yes, guile_cv_have_h_errno=no)])
 815 AC_MSG_RESULT($guile_cv_have_h_errno)
 816 if test $guile_cv_have_h_errno = yes; then
 817   AC_DEFINE(HAVE_H_ERRNO, 1, [Define if h_errno is declared in netdb.h.])
 818 fi
 819
 820 AC_MSG_CHECKING(whether uint32_t is defined)
 821 AC_CACHE_VAL(guile_cv_have_uint32_t,
 822   [AC_TRY_COMPILE([#include <sys/types.h>
 823                    #if HAVE_STDINT_H
 824                    #include <stdint.h>
 825                    #endif
 826                    #ifndef HAVE_NETDB_H
 827                    #include <netdb.h>
 828                    #endif],
 829                   [uint32_t a;],
 830                   guile_cv_have_uint32_t=yes, guile_cv_have_uint32_t=no)])
 831 AC_MSG_RESULT($guile_cv_have_uint32_t)
 832 if test $guile_cv_have_uint32_t = yes; then
 833   AC_DEFINE(HAVE_UINT32_T, 1,
 834     [Define if uint32_t typedef is defined when netdb.h is include.])
 835 fi
 836
 837 AC_MSG_CHECKING(for working IPv6 support)
 838 AC_CACHE_VAL(guile_cv_have_ipv6,
 839 [AC_TRY_COMPILE([
 840 #ifdef HAVE_SYS_TYPES_H
 841 #include <sys/types.h>
 842 #endif
 843 #include <netinet/in.h>
 844 #include <sys/socket.h>],
 845 [struct sockaddr_in6 a;  a.sin6_family = AF_INET6;],
 846 guile_cv_have_ipv6=yes, guile_cv_have_ipv6=no)])
 847 AC_MSG_RESULT($guile_cv_have_ipv6)
 848 if test $guile_cv_have_ipv6 = yes; then
 849   AC_DEFINE(HAVE_IPV6, 1, [Define if you want support for IPv6.])
 850 fi
 851
 852 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
 853 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
 854 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
 855 [AC_TRY_COMPILE([
 856 #ifdef HAVE_SYS_TYPES_H
 857 #include <sys/types.h>
 858 #endif
 859 #include <netinet/in.h>],
 860 [struct sockaddr_in6 sok;  sok.sin6_scope_id = 0;],
 861 guile_cv_have_sin6_scope_id=yes, guile_cv_have_sin6_scope_id=no)])
 862 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
 863 if test $guile_cv_have_sin6_scope_id = yes; then
 864   AC_DEFINE(HAVE_SIN6_SCOPE_ID, 1,
 865     [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
 866 fi
 867
 868 # struct sockaddr_in6 field sin_len is only present on BSD systems
 869 AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,,
 870 [#ifdef HAVE_SYS_TYPES_H
 871 #include <sys/types.h>
 872 #endif
 873 #include <netinet/in.h>])
 874
 875 AC_MSG_CHECKING(whether localtime caches TZ)
 876 AC_CACHE_VAL(guile_cv_localtime_cache,
 877 [if test x$ac_cv_func_tzset = xyes; then
 878 AC_TRY_RUN([#include <time.h>
 879 #if STDC_HEADERS
 880 # include <stdlib.h>
 881 #endif
 882 extern char **environ;
 883 unset_TZ ()
 884 {
 885   char **from, **to;
 886   for (to = from = environ; (*to = *from); from++)
 887     if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
 888       to++;
 889 }
 890 char TZ_GMT0[] = "TZ=GMT0";
 891 char TZ_PST8[] = "TZ=PST8";
 892 main()
 893 {
 894   time_t now = time ((time_t *) 0);
 895   int hour_GMT0, hour_unset;
 896   if (putenv (TZ_GMT0) != 0)
 897     exit (1);
 898   hour_GMT0 = localtime (&now)->tm_hour;
 899   unset_TZ ();
 900   hour_unset = localtime (&now)->tm_hour;
 901   if (putenv (TZ_PST8) != 0)
 902     exit (1);
 903   if (localtime (&now)->tm_hour == hour_GMT0)
 904     exit (1);
 905   unset_TZ ();
 906   if (localtime (&now)->tm_hour != hour_unset)
 907     exit (1);
 908   exit (0);
 909 }], guile_cv_localtime_cache=no, guile_cv_localtime_cache=yes,
 910 [# If we have tzset, assume the worst when cross-compiling.
 911 guile_cv_localtime_cache=yes])
 912 else
 913         # If we lack tzset, report that localtime does not cache TZ,
 914         # since we can't invalidate the cache if we don't have tzset.
 915         guile_cv_localtime_cache=no
 916 fi])dnl
 917 AC_MSG_RESULT($guile_cv_localtime_cache)
 918 if test $guile_cv_localtime_cache = yes; then
 919   AC_DEFINE(LOCALTIME_CACHE, 1, [Define if localtime caches the TZ setting.])
 920 fi
 921
 922 dnl Test whether system calls are restartable by default on the
 923 dnl current system.  If they are not, we put a loop around every system
 924 dnl call to check for EINTR (see SCM_SYSCALL) and do not attempt to
 925 dnl change from the default behaviour.  On the other hand, if signals
 926 dnl are restartable then the loop is not installed and when libguile
 927 dnl initialises it also resets the behaviour of each signal to cause a
 928 dnl restart (in case a different runtime had a different default
 929 dnl behaviour for some reason: e.g., different versions of linux seem
 930 dnl to behave differently.)
 931
 932 AC_SYS_RESTARTABLE_SYSCALLS
 933
 934 if test "$enable_regex" = yes; then
 935    if test "$ac_cv_header_regex_h" = yes ||
 936       test "$ac_cv_header_rxposix_h" = yes ||
 937       test "$ac_cv_header_rx_rxposix_h" = yes; then
 938      GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
 939      [AC_CHECK_LIB(rx, main)
 940       GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
 941      [AC_CHECK_LIB(regex, main)
 942       GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
 943      )
 944      dnl The following should not be necessary, but for some reason
 945      dnl autoheader misses it if we don't include it!
 946      if test "$ac_cv_func_regcomp_norx" = yes ||
 947         test "$ac_cv_func_regcomp_regex" = yes ||
 948         test "$ac_cv_func_regcomp_rx" = yes; then
 949        AC_DEFINE(HAVE_REGCOMP, 1,
 950          [This is included as part of a workaround for a autoheader bug.])
 951      fi
 952    fi
 953 fi
 954
 955 AC_REPLACE_FUNCS(inet_aton putenv strerror memmove mkstemp)
 956
 957 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
 958
 959 # Reasons for testing:
 960 #   asinh, acosh, atanh, trunc - C99 standard, generally not available on
 961 #                                older systems
 962 #   sincos - GLIBC extension
 963 #
 964 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
 965
 966 # C99 specifies isinf and isnan as macros.
 967 # HP-UX provides only macros, no functions.
 968 # glibc 2.3.2 provides both macros and functions.
 969 # IRIX 6.5 and Solaris 8 only provide functions.
 970 #
 971 # The following tests detect isinf and isnan either as functions or as
 972 # macros from <math.h>.  Plain AC_CHECK_FUNCS is insufficient, it doesn't
 973 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
 974 #
 975 AC_MSG_CHECKING([for isinf])
 976 AC_LINK_IFELSE(AC_LANG_SOURCE(
 977 [[#include <math.h>
 978 volatile double x = 0.0;
 979 int main () { return (isinf(x) != 0); }]]),
 980   [AC_MSG_RESULT([yes])
 981    AC_DEFINE(HAVE_ISINF, 1,
 982              [Define to 1 if you have the `isinf' macro or function.])],
 983   [AC_MSG_RESULT([no])])
 984 AC_MSG_CHECKING([for isnan])
 985 AC_LINK_IFELSE(AC_LANG_SOURCE(
 986 [[#include <math.h>
 987 volatile double x = 0.0;
 988 int main () { return (isnan(x) != 0); }]]),
 989   [AC_MSG_RESULT([yes])
 990    AC_DEFINE(HAVE_ISNAN, 1,
 991              [Define to 1 if you have the `isnan' macro or function.])],
 992   [AC_MSG_RESULT([no])])
 993
 994 # Reasons for checking:
 995 #
 996 #     st_rdev
 997 #     st_blksize
 998 #     st_blocks   not in mingw
 999 #     tm_gmtoff   BSD+GNU, not in C99
1000 #
1001 # Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the
1002 # AC_LIBOBJ(fileblocks) replacement which that macro gives.
1003 #
1004 AC_CHECK_MEMBERS([struct stat.st_rdev, struct stat.st_blksize, struct stat.st_blocks])
1005
1006 AC_STRUCT_TIMEZONE
1007 AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,
1008 [#include <time.h>
1009 #ifdef TIME_WITH_SYS_TIME
1010 # include <sys/time.h>
1011 # include <time.h>
1012 #else
1013 # if HAVE_SYS_TIME_H
1014 #  include <sys/time.h>
1015 # else
1016 #  include <time.h>
1017 # endif
1018 #endif
1019 ])
1020 GUILE_STRUCT_UTIMBUF
1021
1022
1023 #--------------------------------------------------------------------
1024 #
1025 # Which way does the stack grow?
1026 #
1027 #--------------------------------------------------------------------
1028
1029 SCM_I_GSC_STACK_GROWS_UP=0
1030 AC_TRY_RUN(aux (l) unsigned long l;
1031              { int x; exit (l >= ((unsigned long)&x)); }
1032            main () { int q; aux((unsigned long)&q); },
1033            [SCM_I_GSC_STACK_GROWS_UP=1],
1034            [],
1035            [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
1036
1037 #--------------------------------------------------------------------
1038 #
1039 # Boehm's GC library
1040 #
1041 #--------------------------------------------------------------------
1042 AC_CHECK_LIB([gc], [GC_collect_a_little],
1043   [LIBS="-lgc $LIBS"],
1044   [AC_MSG_ERROR([`libgc' (Boehm's GC library) not found.])])
1045 AC_CHECK_HEADER([gc/gc.h], [],
1046   [AC_MSG_ERROR([`libgc' (Boehm's GC library) header files not found.])])
1047
1048
1049 AC_CHECK_SIZEOF(float)
1050 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1051     AC_DEFINE(SCM_SINGLES, 1,
1052               [Define this if floats are the same size as longs.])
1053 fi
1054
1055 AC_MSG_CHECKING(for struct linger)
1056 AC_CACHE_VAL(scm_cv_struct_linger,
1057         AC_TRY_COMPILE([
1058 #include <sys/types.h>
1059 #include <sys/socket.h>],
1060                         [struct linger lgr;  lgr.l_linger = 100],
1061                         scm_cv_struct_linger="yes",
1062                         scm_cv_struct_linger="no"))
1063 AC_MSG_RESULT($scm_cv_struct_linger)
1064 if test $scm_cv_struct_linger = yes; then
1065         AC_DEFINE(HAVE_STRUCT_LINGER, 1,
1066           [Define this if your system defines struct linger, for use with the
1067            getsockopt and setsockopt system calls.])
1068 fi
1069
1070
1071 # On mingw, struct timespec is in <pthread.h>.
1072 #
1073 AC_MSG_CHECKING(for struct timespec)
1074 AC_CACHE_VAL(scm_cv_struct_timespec,
1075         AC_TRY_COMPILE([
1076 #include <time.h>
1077 #if HAVE_PTHREAD_H
1078 #include <pthread.h>
1079 #endif],
1080                         [struct timespec t;  t.tv_nsec = 100],
1081                         scm_cv_struct_timespec="yes",
1082                         scm_cv_struct_timespec="no"))
1083 AC_MSG_RESULT($scm_cv_struct_timespec)
1084 if test $scm_cv_struct_timespec = yes; then
1085   AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1,
1086     [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1087 fi
1088
1089 #--------------------------------------------------------------------
1090 #
1091 # Flags for thread support
1092 #
1093 #--------------------------------------------------------------------
1094
1095 SCM_I_GSC_USE_PTHREAD_THREADS=0
1096 SCM_I_GSC_USE_NULL_THREADS=0
1097 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1098 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1099
1100 ### What thread package has the user asked for?
1101 AC_ARG_WITH(threads, [  --with-threads          thread interface],
1102             , with_threads=yes)
1103
1104 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1105
1106 case "$with_threads" in
1107   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1108     ACX_PTHREAD(CC="$PTHREAD_CC"
1109       LIBS="$PTHREAD_LIBS $LIBS"
1110       SCM_I_GSC_USE_PTHREAD_THREADS=1
1111       with_threads="pthreads",
1112       with_threads="null")
1113
1114     old_CFLAGS="$CFLAGS"
1115     CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1116
1117     # Reasons for testing:
1118     #     pthread_getattr_np - "np" meaning "non portable" says it
1119     #         all; not present on MacOS X or Solaris 10
1120     #     pthread_get_stackaddr_np - "np" meaning "non portable" says it
1121     #         all; specific to MacOS X
1122     #     pthread_sigmask - not available on mingw
1123     #
1124     AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1125
1126     # On past versions of Solaris, believe 8 through 10 at least, you
1127     # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1128     # This is contrary to posix:
1129     # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1130     # Check here if this style is required.
1131     #
1132     # glibc (2.3.6 at least) works both with or without braces, so the
1133     # test checks whether it works without.
1134     #
1135     AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1136       guile_cv_need_braces_on_pthread_once_init,
1137       [AC_TRY_COMPILE([#include <pthread.h>],
1138         [pthread_once_t foo = PTHREAD_ONCE_INIT;],
1139         [guile_cv_need_braces_on_pthread_once_init=no],
1140         [guile_cv_need_braces_on_pthread_once_init=yes])])
1141     if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1142       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1143     fi
1144
1145     CFLAGS="$old_CFLAGS"
1146
1147     # On Solaris, sched_yield lives in -lrt.
1148     AC_SEARCH_LIBS(sched_yield, rt)
1149
1150   ;;
1151 esac
1152
1153 case "$with_threads" in
1154   "pthreads")
1155   ;;
1156   "no" | "null")
1157     SCM_I_GSC_USE_NULL_THREADS=1
1158     with_threads="null-threads"
1159   ;;
1160   * )
1161     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1162   ;;
1163 esac
1164
1165 AC_MSG_CHECKING(what kind of threads to support)
1166 AC_MSG_RESULT($with_threads)
1167
1168 ## Check whether pthread_attr_getstack works for the main thread
1169
1170 if test "$with_threads" = pthreads; then
1171
1172 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1173 old_CFLAGS="$CFLAGS"
1174 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1175 AC_TRY_RUN(
1176 [
1177 #if HAVE_PTHREAD_ATTR_GETSTACK
1178 #include <pthread.h>
1179
1180 int main ()
1181 {
1182   pthread_attr_t attr;
1183   void *start, *end;
1184   size_t size;
1185
1186   pthread_getattr_np (pthread_self (), &attr);
1187   pthread_attr_getstack (&attr, &start, &size);
1188   end = (char *)start + size;
1189
1190   if ((void *)&attr < start || (void *)&attr >= end)
1191     return 1;
1192   else
1193     return 0;
1194 }
1195 #else
1196 int main ()
1197 {
1198   return 1;
1199 }
1200 #endif
1201 ],
1202 [works=yes
1203 AC_DEFINE(PTHREAD_ATTR_GETSTACK_WORKS, [1], [Define when pthread_att_get_stack works for the main thread])],
1204 [works=no])
1205 CFLAGS="$old_CFLAGS"
1206 AC_MSG_RESULT($works)
1207
1208 fi # with_threads=pthreads
1209
1210
1211 ## Cross building
1212 if test "$cross_compiling" = "yes"; then
1213   AC_MSG_CHECKING(cc for build)
1214   ## /usr/bin/cc still uses wrong assembler
1215   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1216   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1217 else
1218   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1219 fi
1220
1221 ## AC_MSG_CHECKING("if we are cross compiling")
1222 ## AC_MSG_RESULT($cross_compiling)
1223 if test "$cross_compiling" = "yes"; then
1224    AC_MSG_RESULT($CC_FOR_BUILD)
1225 fi
1226
1227 ## No need as yet to be more elaborate
1228 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1229
1230 AC_SUBST(cross_compiling)
1231 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1232 AC_SUBST(CCLD_FOR_BUILD)
1233
1234 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1235 ## --HOST is the platform that PACKAGE is compiled for.
1236 HOST_CC="$CC_FOR_BUILD"
1237 AC_SUBST(HOST_CC)
1238
1239 if test "$cross_compiling" = "yes"; then
1240   AC_MSG_CHECKING(guile for build)
1241   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1242 else
1243   GUILE_FOR_BUILD='$(preinstguile)'
1244 fi
1245
1246 ## AC_MSG_CHECKING("if we are cross compiling")
1247 ## AC_MSG_RESULT($cross_compiling)
1248 if test "$cross_compiling" = "yes"; then
1249    AC_MSG_RESULT($GUILE_FOR_BUILD)
1250 fi
1251 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1252 AC_SUBST(GUILE_FOR_BUILD)
1253
1254 ## If we're using GCC, ask for aggressive warnings.
1255 case "$GCC" in
1256   yes )
1257     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1258     ## much stuff with generic function pointers for that to really be
1259     ## less than exasperating.
1260     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1261     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1262     CFLAGS="$CFLAGS -Wall -Wmissing-prototypes"
1263     # Do this here so we don't screw up any of the tests above that might
1264     # not be "warning free"
1265     if test "${GUILE_ERROR_ON_WARNING}" = yes
1266     then
1267         CFLAGS="${CFLAGS} -Werror"
1268         enable_compile_warnings=no
1269     fi
1270     ;;
1271 esac
1272
1273 ## If we're creating a shared library (using libtool!), then we'll
1274 ## need to generate a list of .lo files corresponding to the .o files
1275 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1276 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1277
1278 ## We also need to create corresponding .doc and .x files
1279 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1280 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1281
1282 AC_SUBST(GUILE_MAJOR_VERSION)
1283 AC_SUBST(GUILE_MINOR_VERSION)
1284 AC_SUBST(GUILE_MICRO_VERSION)
1285 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1286 AC_SUBST(GUILE_VERSION)
1287
1288 #######################################################################
1289 # library versioning
1290
1291 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1292 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1293 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1294 AC_SUBST(LIBGUILE_INTERFACE)
1295
1296 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1297 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1298 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1299 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1300 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1301
1302 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1303 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1304 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1305 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1306 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1307
1308 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1309 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1310 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1311 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1312 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1313
1314 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1315 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1316 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1317 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1318 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1319
1320 AC_SUBST(LIBGUILE_I18N_MAJOR)
1321 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1322 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1323 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1324 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1325
1326
1327 #######################################################################
1328
1329 dnl Tell guile-config what flags guile users should compile and link with.
1330 GUILE_LIBS="$LDFLAGS $LIBS"
1331 GUILE_CFLAGS="$PTHREAD_CFLAGS"
1332 AC_SUBST(GUILE_LIBS)
1333 AC_SUBST(GUILE_CFLAGS)
1334
1335 AC_SUBST(AWK)
1336 AC_SUBST(LIBLOBJS)
1337 AC_SUBST(EXTRA_DOT_DOC_FILES)
1338 AC_SUBST(EXTRA_DOT_X_FILES)
1339
1340 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1341 top_builddir_absolute=`pwd`
1342 AC_SUBST(top_builddir_absolute)
1343 top_srcdir_absolute=`(cd $srcdir && pwd)`
1344 AC_SUBST(top_srcdir_absolute)
1345
1346 # Additional SCM_I_GSC definitions are above.
1347 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1348 AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
1349 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1350 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1351 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1352 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1353 AC_SUBST([SCM_I_GSC_C_INLINE])
1354 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1355
1356 AC_CONFIG_FILES([
1357   Makefile
1358   am/Makefile
1359   lib/Makefile
1360   benchmark-suite/Makefile
1361   doc/Makefile
1362   doc/goops/Makefile
1363   doc/r5rs/Makefile
1364   doc/ref/Makefile
1365   doc/tutorial/Makefile
1366   emacs/Makefile
1367   examples/Makefile
1368   examples/box-dynamic-module/Makefile
1369   examples/box-dynamic/Makefile
1370   examples/box-module/Makefile
1371   examples/box/Makefile
1372   examples/modules/Makefile
1373   examples/safe/Makefile
1374   examples/scripts/Makefile
1375   guile-config/Makefile
1376   ice-9/Makefile
1377   ice-9/debugger/Makefile
1378   ice-9/debugging/Makefile
1379   lang/Makefile
1380   lang/elisp/Makefile
1381   lang/elisp/internals/Makefile
1382   lang/elisp/primitives/Makefile
1383   libguile/Makefile
1384   oop/Makefile
1385   oop/goops/Makefile
1386   scripts/Makefile
1387   srfi/Makefile
1388   test-suite/Makefile
1389   test-suite/standalone/Makefile
1390 ])
1391
1392 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1393 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1394 AC_CONFIG_FILES([guile-tools], [chmod +x guile-tools])
1395 AC_CONFIG_FILES([pre-inst-guile], [chmod +x pre-inst-guile])
1396 AC_CONFIG_FILES([pre-inst-guile-env], [chmod +x pre-inst-guile-env])
1397 AC_CONFIG_FILES([libguile/guile-snarf],
1398                 [chmod +x libguile/guile-snarf])
1399 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1400                 [chmod +x libguile/guile-doc-snarf])
1401 AC_CONFIG_FILES([libguile/guile-func-name-check],
1402                 [chmod +x libguile/guile-func-name-check])
1403 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1404                 [chmod +x libguile/guile-snarf-docs])
1405
1406 AC_OUTPUT
1407
1408 dnl Local Variables:
1409 dnl comment-start: "dnl "
1410 dnl comment-end: ""
1411 dnl comment-start-skip: "\\bdnl\\b\\s *"
1412 dnl End: