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