configure.ac

   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, 2008, 2009, 2010 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 under
  12 the terms of the GNU Lesser General Public License as published by the
  13 Free Software Foundation; either version 3, or (at your option) any
  14 later version.
  15
  16 GUILE is distributed in the hope that it will be useful, but WITHOUT
  17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  19 License for more details.
  20
  21 You should have received a copy of the GNU Lesser General Public
  22 License along with GUILE; see the file COPYING.LESSER.  If not, write
  23 to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  24 Floor, Boston, MA 02110-1301, USA.
  25
  26 ]])
  27
  28 AC_PREREQ(2.61)
  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([GNU Guile],
  36         patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${GUILE_VERSION}),[
  37 ]),
  38         [bug-guile@gnu.org])
  39 AC_CONFIG_AUX_DIR([build-aux])
  40 AC_CONFIG_MACRO_DIR([m4])
  41 AC_CONFIG_SRCDIR(GUILE-VERSION)
  42
  43 AM_INIT_AUTOMAKE([gnu no-define check-news -Wall -Wno-override])
  44
  45 AC_COPYRIGHT(GUILE_CONFIGURE_COPYRIGHT)
  46 AC_CONFIG_SRCDIR([GUILE-VERSION])
  47
  48 . $srcdir/GUILE-VERSION
  49
  50 AC_CONFIG_HEADERS([config.h])
  51 AH_TOP(/*GUILE_CONFIGURE_COPYRIGHT*/)
  52
  53 #--------------------------------------------------------------------
  54
  55 AC_LANG([C])
  56
  57 dnl Some more checks for Win32
  58 AC_CANONICAL_HOST
  59
  60 AC_LIBTOOL_WIN32_DLL
  61
  62 AC_PROG_INSTALL
  63 AC_PROG_CC
  64 gl_EARLY
  65 AC_PROG_CPP
  66 AC_PROG_SED
  67 AC_PROG_AWK
  68
  69 dnl Gnulib.
  70 gl_INIT
  71
  72 AC_PROG_CC_C89
  73
  74 # for per-target cflags in the libguile subdir
  75 AM_PROG_CC_C_O
  76
  77 AC_LIBTOOL_DLOPEN
  78 AC_PROG_LIBTOOL
  79 AC_CHECK_LIB([ltdl], [lt_dlinit], ,
  80   [AC_MSG_ERROR([libltdl not found.  See README.])])
  81 AC_CHECK_HEADER([ltdl.h], [],
  82   [AC_MSG_ERROR([<ltdl.h> not found.  See README.])])
  83
  84 AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
  85 AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
  86
  87 AM_PATH_LISPDIR
  88
  89 AC_DEFINE_UNQUOTED([HOST_TYPE], ["$host"],
  90   [Define to the host's GNU triplet.])
  91
  92 #--------------------------------------------------------------------
  93 #
  94 # User options (after above tests that may set default CFLAGS etc.)
  95 #
  96 #--------------------------------------------------------------------
  97
  98 GUILE_ERROR_ON_WARNING="no"
  99
 100 AC_ARG_ENABLE(error-on-warning,
 101   [  --enable-error-on-warning    treat compile warnings as errors],
 102   [case "${enableval}" in
 103      yes | y) GUILE_ERROR_ON_WARNING="yes" ;;
 104      no | n)  GUILE_ERROR_ON_WARNING="no" ;;
 105      *) AC_MSG_ERROR(bad value ${enableval} for --enable-error-on-warning) ;;
 106    esac])
 107
 108 AC_ARG_ENABLE(debug-malloc,
 109   [  --enable-debug-malloc   include malloc debugging code],
 110   if test "$enable_debug_malloc" = y || test "$enable_debug_malloc" = yes; then
 111     AC_DEFINE([GUILE_DEBUG_MALLOC], 1,
 112       [Define this if you want to debug scm_must_malloc/realloc/free calls.])
 113   fi)
 114
 115 SCM_I_GSC_GUILE_DEBUG=0
 116 AC_ARG_ENABLE(guile-debug,
 117   [AS_HELP_STRING([--enable-guile-debug],
 118                   [include internal debugging functions])],
 119   if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then
 120     SCM_I_GSC_GUILE_DEBUG=1
 121   fi)
 122
 123 AC_ARG_ENABLE(posix,
 124   [  --disable-posix         omit posix interfaces],,
 125   enable_posix=yes)
 126
 127 AC_ARG_ENABLE(networking,
 128   [  --disable-networking    omit networking interfaces],,
 129   enable_networking=yes)
 130
 131 AC_ARG_ENABLE(regex,
 132   [  --disable-regex         omit regular expression interfaces],,
 133   enable_regex=yes)
 134
 135 AC_ARG_ENABLE([discouraged],
 136   AS_HELP_STRING([--disable-discouraged],[omit discouraged features]))
 137
 138 if test "$enable_discouraged" = no; then
 139   SCM_I_GSC_ENABLE_DISCOURAGED=0
 140 else
 141   SCM_I_GSC_ENABLE_DISCOURAGED=1
 142 fi
 143
 144 AC_ARG_ENABLE([deprecated],
 145   AS_HELP_STRING([--disable-deprecated],[omit deprecated features]))
 146
 147 if test "$enable_deprecated" = no; then
 148   SCM_I_GSC_ENABLE_DEPRECATED=0
 149   warn_default=no
 150 else
 151   if test "$enable_deprecated" = yes || test "$enable_deprecated" = ""; then
 152     warn_default=summary
 153   elif test "$enable_deprecated" = shutup; then
 154     warn_default=no
 155   else
 156     warn_default=$enable_deprecated
 157   fi
 158   SCM_I_GSC_ENABLE_DEPRECATED=1
 159 fi
 160 AC_DEFINE_UNQUOTED([SCM_WARN_DEPRECATED_DEFAULT], "$warn_default",
 161 [Define this to control the default warning level for deprecated features.])
 162
 163 AC_ARG_ENABLE(elisp,
 164   [  --disable-elisp         omit Emacs Lisp support],,
 165   enable_elisp=yes)
 166
 167 dnl  Added the following configure option in January 2008 following
 168 dnl  investigation of problems with "64" system and library calls on
 169 dnl  Darwin (MacOS X).  The libguile code (_scm.h) assumes that if a
 170 dnl  system has stat64, it will have all the other 64 APIs too; but on
 171 dnl  Darwin, stat64 is there but other APIs are missing.
 172 dnl
 173 dnl  It also appears, from the Darwin docs, that most system call APIs
 174 dnl  there (i.e. the traditional ones _without_ "64" in their names) have
 175 dnl  been 64-bit-capable for a long time now, so it isn't necessary to
 176 dnl  use "64" versions anyway.  For example, Darwin's off_t is 64-bit.
 177 dnl
 178 dnl  A similar problem has been reported for HP-UX:
 179 dnl  http://www.nabble.com/Building-guile-1.8.2-on-hpux-td13106681.html
 180 dnl
 181 dnl  Therefore, and also because a Guile without LARGEFILE64 support is
 182 dnl  better than no Guile at all, we provide this option to suppress
 183 dnl  trying to use "64" calls.
 184 dnl
 185 dnl  It may be that for some 64-bit function on Darwin/HP-UX we do need
 186 dnl  to use a "64" call, and hence that by using --without-64-calls we're
 187 dnl  missing out on that.  If so, someone can work on that in the future.
 188 dnl  For now, --without-64-calls allows Guile to build on OSs where it
 189 dnl  wasn't building before.
 190 AC_MSG_CHECKING([whether to use system and library "64" calls])
 191 AC_ARG_WITH([64-calls],
 192   AS_HELP_STRING([--without-64-calls],
 193                  [don't attempt to use system and library calls with "64" in their names]),
 194   [use_64_calls=$withval],
 195   [use_64_calls=yes
 196    case $host in
 197      *-apple-darwin* )
 198        use_64_calls=no
 199        ;;
 200      powerpc-ibm-aix* )
 201        use_64_calls=no
 202        ;;
 203    esac])
 204 AC_MSG_RESULT($use_64_calls)
 205 case "$use_64_calls" in
 206   y* )
 207     AC_DEFINE([GUILE_USE_64_CALLS], 1,
 208       [Define to 1 in order to try to use "64" versions of system and library calls.])
 209     ;;
 210 esac
 211
 212 #--------------------------------------------------------------------
 213
 214 dnl Check for dynamic linking
 215
 216 use_modules=yes
 217 AC_ARG_WITH(modules,
 218 [  --with-modules[=FILES]  Add support for dynamic modules],
 219 use_modules="$withval")
 220 test -z "$use_modules" && use_modules=yes
 221 DLPREOPEN=
 222 if test "$use_modules" != no; then
 223   if test "$use_modules" = yes; then
 224     DLPREOPEN="-dlpreopen force"
 225   else
 226     DLPREOPEN="-export-dynamic"
 227     for module in $use_modules; do
 228       DLPREOPEN="$DLPREOPEN -dlopen $module"
 229     done
 230   fi
 231 fi
 232
 233 dnl files which are destined for separate modules.
 234
 235 if test "$use_modules" != no; then
 236    AC_LIBOBJ([dynl])
 237 fi
 238
 239 if test "$enable_posix" = yes; then
 240    AC_LIBOBJ([filesys])
 241    AC_LIBOBJ([posix])
 242    AC_DEFINE([HAVE_POSIX], 1,
 243      [Define this if you want support for POSIX system calls in Guile.])
 244 fi
 245
 246 if test "$enable_networking" = yes; then
 247    AC_LIBOBJ([net_db])
 248    AC_LIBOBJ([socket])
 249    AC_DEFINE([HAVE_NETWORKING], 1,
 250      [Define this if you want support for networking in Guile.])
 251 fi
 252
 253 if test "$enable_debug_malloc" = yes; then
 254    AC_LIBOBJ([debug-malloc])
 255 fi
 256
 257 if test "$enable_elisp" = yes; then
 258   SCM_I_GSC_ENABLE_ELISP=1
 259 else
 260   SCM_I_GSC_ENABLE_ELISP=0
 261 fi
 262 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
 263
 264 AC_C_CONST
 265
 266 # "volatile" is used in a couple of tests below.
 267 AC_C_VOLATILE
 268
 269 AC_C_INLINE
 270 if test "$ac_cv_c_inline" != no; then
 271   SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\""
 272 else
 273   SCM_I_GSC_C_INLINE=NULL
 274 fi
 275 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
 276
 277 AC_C_BIGENDIAN
 278
 279 AC_C_LABELS_AS_VALUES
 280
 281 AC_CHECK_SIZEOF(char)
 282 AC_CHECK_SIZEOF(unsigned char)
 283 AC_CHECK_SIZEOF(short)
 284 AC_CHECK_SIZEOF(unsigned short)
 285 AC_CHECK_SIZEOF(int)
 286 AC_CHECK_SIZEOF(unsigned int)
 287 AC_CHECK_SIZEOF(long)
 288 AC_CHECK_SIZEOF(unsigned long)
 289 AC_CHECK_SIZEOF(size_t)
 290 AC_CHECK_SIZEOF(long long)
 291 AC_CHECK_SIZEOF(unsigned long long)
 292 AC_CHECK_SIZEOF(__int64)
 293 AC_CHECK_SIZEOF(unsigned __int64)
 294 AC_CHECK_SIZEOF(void *)
 295 AC_CHECK_SIZEOF(intptr_t)
 296 AC_CHECK_SIZEOF(uintptr_t)
 297 AC_CHECK_SIZEOF(ptrdiff_t)
 298 AC_CHECK_SIZEOF(size_t)
 299 AC_CHECK_SIZEOF(off_t)
 300
 301 if test "$ac_cv_sizeof_long" -ne "$ac_cv_sizeof_void_p"; then
 302   AC_MSG_ERROR(sizes of long and void* are not identical)
 303 fi
 304
 305 if test "$ac_cv_sizeof_ptrdiff_t" -ne 0; then
 306   SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"'
 307 else
 308   SCM_I_GSC_T_PTRDIFF='"long"'
 309 fi
 310 AC_SUBST([SCM_I_GSC_T_PTRDIFF])
 311
 312 AC_CHECK_HEADERS([stdint.h])
 313 AC_CHECK_HEADERS([inttypes.h])
 314
 315 AC_CHECK_SIZEOF(intmax_t)
 316
 317 SCM_I_GSC_NEEDS_STDINT_H=0
 318 SCM_I_GSC_NEEDS_INTTYPES_H=0
 319
 320 ### intptr and uintptr (try not to use inttypes if we don't have to)
 321 if test "$ac_cv_header_inttypes_h" = yes; then
 322   if test "$ac_cv_sizeof_intptr_t" -eq 0; then
 323     AC_CHECK_SIZEOF([intptr_t],,[#include <inttypes.h>
 324 #include <stdio.h>])
 325     if test "$ac_cv_sizeof_intptr_t" -ne 0; then
 326       SCM_I_GSC_NEEDS_INTTYPES_H=1
 327     fi
 328   fi
 329   if test "$ac_cv_sizeof_uintptr_t" -eq 0; then
 330     AC_CHECK_SIZEOF([uintptr_t],,[#include <inttypes.h>
 331 #include <stdio.h>])
 332     if test "$ac_cv_sizeof_uintptr_t" -ne 0; then
 333       SCM_I_GSC_NEEDS_INTTYPES_H=1
 334     fi
 335   fi
 336 fi
 337
 338 ### See what's provided by stdint.h
 339 if test "$ac_cv_header_stdint_h" = yes; then
 340    AC_CHECK_TYPE([int8_t],[scm_stdint_has_int8=1],,[#include <stdint.h>])
 341    AC_CHECK_TYPE([uint8_t],[scm_stdint_has_uint8=1],,[#include <stdint.h>])
 342    AC_CHECK_TYPE([int16_t],[scm_stdint_has_int16=1],,[#include <stdint.h>])
 343    AC_CHECK_TYPE([uint16_t],[scm_stdint_has_uint16=1],,[#include <stdint.h>])
 344    AC_CHECK_TYPE([int32_t],[scm_stdint_has_int32=1],,[#include <stdint.h>])
 345    AC_CHECK_TYPE([uint32_t],[scm_stdint_has_uint32=1],,[#include <stdint.h>])
 346    AC_CHECK_TYPE([int64_t],[scm_stdint_has_int64=1],,[#include <stdint.h>])
 347    AC_CHECK_TYPE([uint64_t],[scm_stdint_has_uint64=1],,[#include <stdint.h>])
 348    AC_CHECK_TYPE([intmax_t],[scm_stdint_has_intmax=1],,[#include <stdint.h>])
 349    AC_CHECK_TYPE([uintmax_t],[scm_stdint_has_uintmax=1],,[#include <stdint.h>])
 350    AC_CHECK_TYPE([intptr_t],[scm_stdint_has_intptr=1],,[#include <stdint.h>])
 351    AC_CHECK_TYPE([uintptr_t],[scm_stdint_has_uintptr=1],,[#include <stdint.h>])
 352 fi
 353
 354 # so we don't get confused by the cache (wish there was a better way
 355 # to check particular headers for the same type...)
 356
 357 unset ac_cv_type_int8_t
 358 unset ac_cv_type_uint8_t
 359 unset ac_cv_type_int16_t
 360 unset ac_cv_type_uint16_t
 361 unset ac_cv_type_int32_t
 362 unset ac_cv_type_uint32_t
 363 unset ac_cv_type_int64_t
 364 unset ac_cv_type_uint64_t
 365 unset ac_cv_type_intmax_t
 366 unset ac_cv_type_uintmax_t
 367
 368 ### See what's provided by inttypes.h
 369 if test "$ac_cv_header_inttypes_h" = yes; then
 370   AC_CHECK_TYPE([int8_t],[scm_inttypes_has_int8=1],,[#include <inttypes.h>])
 371   AC_CHECK_TYPE([uint8_t],[scm_inttypes_has_uint8=1],,[#include <inttypes.h>])
 372   AC_CHECK_TYPE([int16_t],[scm_inttypes_has_int16=1],,[#include <inttypes.h>])
 373   AC_CHECK_TYPE([uint16_t],[scm_inttypes_has_uint16=1],,[#include <inttypes.h>])
 374   AC_CHECK_TYPE([int32_t],[scm_inttypes_has_int32=1],,[#include <inttypes.h>])
 375   AC_CHECK_TYPE([uint32_t],[scm_inttypes_has_uint32=1],,[#include <inttypes.h>])
 376   AC_CHECK_TYPE([int64_t],[scm_inttypes_has_int64=1],,[#include <inttypes.h>])
 377   AC_CHECK_TYPE([uint64_t],[scm_inttypes_has_uint64=1],,[#include <inttypes.h>])
 378   AC_CHECK_TYPE([intmax_t],[scm_inttypes_has_intmax=1],,[#include <inttypes.h>])
 379   AC_CHECK_TYPE([uintmax_t],[scm_inttypes_has_uintmax=1],,[#include <inttypes.h>])
 380   AC_CHECK_TYPE([intptr_t],[scm_inttypes_has_intptr=1],,[#include <inttypes.h>])
 381   AC_CHECK_TYPE([uintptr_t],[scm_inttypes_has_uintptr=1],,[#include <inttypes.h>])
 382 fi
 383
 384 # Try hard to find definitions for some required scm_t_*int* types.
 385
 386 ### Required type scm_t_int8
 387 if test "$scm_stdint_has_int8"; then
 388   SCM_I_GSC_T_INT8='"int8_t"'
 389   SCM_I_GSC_NEEDS_STDINT_H=1
 390 elif test "$scm_inttypes_has_int8"; then
 391   SCM_I_GSC_T_INT8='"int8_t"'
 392   SCM_I_GSC_NEEDS_INTTYPES_H=1
 393 elif test "$ac_cv_sizeof_char" -eq 1; then
 394   SCM_I_GSC_T_INT8='"signed char"'
 395 else
 396   AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.])
 397 fi
 398 AC_SUBST([SCM_I_GSC_T_INT8])
 399
 400 ### Required type scm_t_uint8
 401 if test "$scm_stdint_has_uint8"; then
 402   SCM_I_GSC_T_UINT8='"uint8_t"'
 403   SCM_I_GSC_NEEDS_STDINT_H=1
 404 elif test "$scm_inttypes_has_uint8"; then
 405   SCM_I_GSC_T_UINT8='"uint8_t"'
 406   SCM_I_GSC_NEEDS_INTTYPES_H=1
 407 elif test "$ac_cv_sizeof_unsigned_char" -eq 1; then
 408   SCM_I_GSC_T_UINT8='"unsigned char"'
 409 else
 410   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.])
 411 fi
 412 AC_SUBST([SCM_I_GSC_T_UINT8])
 413
 414 ### Required type scm_t_int16 (ANSI C says int or short might work)
 415 if test "$scm_stdint_has_int16"; then
 416   SCM_I_GSC_T_INT16='"int16_t"'
 417   SCM_I_GSC_NEEDS_STDINT_H=1
 418 elif test "$scm_inttypes_has_int16"; then
 419   SCM_I_GSC_T_INT16='"int16_t"'
 420   SCM_I_GSC_NEEDS_INTTYPES_H=1
 421 elif test "$ac_cv_sizeof_int" -eq 2; then
 422   SCM_I_GSC_T_INT16='"int"'
 423 elif test "$ac_cv_sizeof_short" -eq 2; then
 424   SCM_I_GSC_T_INT16='"short"'
 425 else
 426   AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.])
 427 fi
 428 AC_SUBST([SCM_I_GSC_T_INT16])
 429
 430 ### Required type scm_t_uint16 (ANSI C says int or short might work)
 431 if test "$scm_stdint_has_uint16"; then
 432   SCM_I_GSC_T_UINT16='"uint16_t"'
 433   SCM_I_GSC_NEEDS_STDINT_H=1
 434 elif test "$scm_inttypes_has_uint16"; then
 435   SCM_I_GSC_T_UINT16='"uint16_t"'
 436   SCM_I_GSC_NEEDS_INTTYPES_H=1
 437 elif test "$ac_cv_sizeof_unsigned_int" -eq 2; then
 438   SCM_I_GSC_T_UINT16='"unsigned int"'
 439 elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then
 440   SCM_I_GSC_T_UINT16='"unsigned short"'
 441 else
 442   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.])
 443 fi
 444 AC_SUBST([SCM_I_GSC_T_UINT16])
 445
 446
 447 ### Required type scm_t_int32 (ANSI C says int, short, or long might work)
 448 if test "$scm_stdint_has_int32"; then
 449   SCM_I_GSC_T_INT32='"int32_t"'
 450   SCM_I_GSC_NEEDS_STDINT_H=1
 451 elif test "$scm_inttypes_has_int32"; then
 452   SCM_I_GSC_T_INT32='"int32_t"'
 453   SCM_I_GSC_NEEDS_INTTYPES_H=1
 454 elif test "$ac_cv_sizeof_int" -eq 4; then
 455   SCM_I_GSC_T_INT32='"int"'
 456 elif test "$ac_cv_sizeof_long" -eq 4; then
 457   SCM_I_GSC_T_INT32='"long"'
 458 elif test "$ac_cv_sizeof_short" -eq 4; then
 459   SCM_I_GSC_T_INT32='"short"'
 460 else
 461   AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.])
 462 fi
 463 AC_SUBST([SCM_I_GSC_T_INT32])
 464
 465 ### Required type scm_t_uint32 (ANSI C says int, short, or long might work)
 466 if test "$scm_stdint_has_uint32"; then
 467   SCM_I_GSC_T_UINT32='"uint32_t"'
 468   SCM_I_GSC_NEEDS_STDINT_H=1
 469 elif test "$scm_inttypes_has_uint32"; then
 470   SCM_I_GSC_T_UINT32='"uint32_t"'
 471   SCM_I_GSC_NEEDS_INTTYPES_H=1
 472 elif test "$ac_cv_sizeof_unsigned_int" -eq 4; then
 473   SCM_I_GSC_T_UINT32='"unsigned int"'
 474 elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then
 475   SCM_I_GSC_T_UINT32='"unsigned long"'
 476 elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then
 477   SCM_I_GSC_T_UINT32='"unsigned short"'
 478 else
 479   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.])
 480 fi
 481 AC_SUBST([SCM_I_GSC_T_UINT32])
 482
 483 ### Optional type scm_t_int64 (ANSI C says int, short, or long might work)
 484 ### Also try 'long long' and '__int64' if we have it.
 485 SCM_I_GSC_T_INT64=0
 486 if test "$scm_stdint_has_int64"; then
 487   SCM_I_GSC_T_INT64='"int64_t"'
 488   SCM_I_GSC_NEEDS_STDINT_H=1
 489 elif test "$scm_inttypes_has_int64"; then
 490   SCM_I_GSC_T_INT64='"int64_t"'
 491   SCM_I_GSC_NEEDS_INTTYPES_H=1
 492 elif test "$ac_cv_sizeof_int" -eq 8; then
 493   SCM_I_GSC_T_INT64='"int"'
 494 elif test "$ac_cv_sizeof_long" -eq 8; then
 495   SCM_I_GSC_T_INT64='"long"'
 496 elif test "$ac_cv_sizeof_short" -eq 8; then
 497   SCM_I_GSC_T_INT64='"short"'
 498 elif test "$ac_cv_sizeof_long_long" -eq 8; then
 499   SCM_I_GSC_T_INT64='"long long"'
 500 elif test "$ac_cv_sizeof___int64" -eq 8; then
 501   SCM_I_GSC_T_INT64='"__int64"'
 502 else
 503   AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.])
 504 fi
 505 AC_SUBST([SCM_I_GSC_T_INT64])
 506
 507
 508 ### Optional type scm_t_uint64 (ANSI C says int, short, or long might work)
 509 ### Also try 'long long' and '__int64' if we have it.
 510 SCM_I_GSC_T_UINT64=0
 511 if test "$scm_stdint_has_uint64"; then
 512   SCM_I_GSC_T_UINT64='"uint64_t"'
 513   SCM_I_GSC_NEEDS_STDINT_H=1
 514 elif test "$scm_inttypes_has_uint64"; then
 515   SCM_I_GSC_T_UINT64='"uint64_t"'
 516   SCM_I_GSC_NEEDS_INTTYPES_H=1
 517 elif test "$ac_cv_sizeof_unsigned_int" -eq 8; then
 518   SCM_I_GSC_T_UINT64='"unsigned int"'
 519 elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then
 520   SCM_I_GSC_T_UINT64='"unsigned long"'
 521 elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then
 522   SCM_I_GSC_T_UINT64='"unsigned short"'
 523 elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then
 524   SCM_I_GSC_T_UINT64='"unsigned long long"'
 525 elif test "$ac_cv_sizeof_unsigned___int64" -eq 8; then
 526   SCM_I_GSC_T_UINT64='"unsigned __int64"'
 527 else
 528   AC_MSG_ERROR([Can't find appropriate type for scm_t_uint64.])
 529 fi
 530 AC_SUBST([SCM_I_GSC_T_UINT64])
 531
 532 ### Required type scm_t_intmax
 533 ###
 534 ### We try 'intmax_t', '__int64', 'long long' in this order.  When
 535 ### none of them is available, we use 'long'.
 536 ###
 537 SCM_I_GSC_T_INTMAX=0
 538 if test "$scm_stdint_has_intmax"; then
 539   SCM_I_GSC_T_INTMAX='"intmax_t"'
 540   SCM_I_GSC_NEEDS_STDINT_H=1
 541 elif test "$scm_inttypes_has_intmax"; then
 542   SCM_I_GSC_T_INTMAX='"intmax_t"'
 543   SCM_I_GSC_NEEDS_INTTYPES_H=1
 544 elif test "$ac_cv_sizeof___int64" -ne 0; then
 545   SCM_I_GSC_T_INTMAX='"__int64"'
 546 elif test "$ac_cv_sizeof_long_long" -ne 0; then
 547   SCM_I_GSC_T_INTMAX='"long long"'
 548 else
 549   SCM_I_GSC_T_INTMAX='"long"'
 550 fi
 551 AC_SUBST([SCM_I_GSC_T_INTMAX])
 552
 553 ### Required type scm_t_uintmax
 554 ###
 555 ### We try 'uintmax_t', 'unsigned __int64', 'unsigned long long' in
 556 ### this order.  When none of them is available, we use 'unsigned long'.
 557 ###
 558 SCM_I_GSC_T_UINTMAX=0
 559 if test "$scm_stdint_has_uintmax"; then
 560   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 561   SCM_I_GSC_NEEDS_STDINT_H=1
 562 elif test "$scm_inttypes_has_uintmax"; then
 563   SCM_I_GSC_T_UINTMAX='"uintmax_t"'
 564   SCM_I_GSC_NEEDS_INTTYPES_H=1
 565 elif test "$ac_cv_sizeof_unsigned___int64" -ne 0; then
 566   SCM_I_GSC_T_UINTMAX='"unsigned __int64"'
 567 elif test "$ac_cv_sizeof_unsigned_long_long" -ne 0; then
 568   SCM_I_GSC_T_UINTMAX='"unsigned long long"'
 569 else
 570   SCM_I_GSC_T_UINTMAX='"unsigned long"'
 571 fi
 572 AC_SUBST([SCM_I_GSC_T_UINTMAX])
 573
 574 ### Required type scm_t_intptr
 575 ###
 576 SCM_I_GSC_T_INTPTR=0
 577 if test "$scm_stdint_has_intptr"; then
 578   SCM_I_GSC_T_INTPTR='"intptr_t"'
 579   SCM_I_GSC_NEEDS_STDINT_H=1
 580 elif test "$scm_inttypes_has_intptr"; then
 581   SCM_I_GSC_T_INTPTR='"intptr_t"'
 582   SCM_I_GSC_NEEDS_INTTYPES_H=1
 583 elif test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_void_p"; then
 584   SCM_I_GSC_T_INTPTR='"int"'
 585 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_void_p"; then
 586   SCM_I_GSC_T_INTPTR='"long"'
 587 elif test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_void_p"; then
 588   SCM_I_GSC_T_INTPTR='"long long"'
 589 else
 590   AC_MSG_ERROR([Can't find appropriate type for `scm_t_intptr'.])
 591 fi
 592 AC_SUBST([SCM_I_GSC_T_INTPTR])
 593
 594 ### Required type scm_t_uintptr
 595 ###
 596 SCM_I_GSC_T_UINTPTR=0
 597 if test "$scm_stdint_has_uintptr"; then
 598   SCM_I_GSC_T_UINTPTR='"uintptr_t"'
 599   SCM_I_GSC_NEEDS_STDINT_H=1
 600 elif test "$scm_inttypes_has_uintptr"; then
 601   SCM_I_GSC_T_UINTPTR='"uintptr_t"'
 602   SCM_I_GSC_NEEDS_INTTYPES_H=1
 603 elif test "$ac_cv_sizeof_int" = "$ac_cv_sizeof_void_p"; then
 604   SCM_I_GSC_T_UINTPTR='"unsigned int"'
 605 elif test "$ac_cv_sizeof_long" = "$ac_cv_sizeof_void_p"; then
 606   SCM_I_GSC_T_UINTPTR='"unsigned long"'
 607 elif test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_void_p"; then
 608   SCM_I_GSC_T_UINTPTR='"unsigned long long"'
 609 else
 610   AC_MSG_ERROR([Can't find appropriate type for `scm_t_uintptr'.])
 611 fi
 612 AC_SUBST([SCM_I_GSC_T_UINTPTR])
 613
 614
 615 AC_SUBST([SCM_I_GSC_NEEDS_STDINT_H])
 616 AC_SUBST([SCM_I_GSC_NEEDS_INTTYPES_H])
 617
 618 AC_HEADER_STDC
 619 AC_HEADER_TIME
 620 AC_HEADER_SYS_WAIT
 621 AC_HEADER_DIRENT
 622
 623 # Reason for checking:
 624 #
 625 #   HP-UX 11.11 (at least) doesn't provide `struct dirent64', even
 626 #   with `_LARGEFILE64_SOURCE', so check whether it's available.
 627 #
 628 AC_CHECK_MEMBER([struct dirent64.d_name],
 629   [SCM_I_GSC_HAVE_STRUCT_DIRENT64=1], [SCM_I_GSC_HAVE_STRUCT_DIRENT64=0],
 630   [ #ifndef _LARGEFILE64_SOURCE
 631     # define _LARGEFILE64_SOURCE
 632     #endif
 633
 634     /* Per Autoconf manual.  */
 635     #include <sys/types.h>
 636     #ifdef HAVE_DIRENT_H
 637     # include <dirent.h>
 638     #else
 639     # define dirent direct
 640     # ifdef HAVE_SYS_NDIR_H
 641     #  include <sys/ndir.h>
 642     # endif
 643     # ifdef HAVE_SYS_DIR_H
 644     #  include <sys/dir.h>
 645     # endif
 646     # ifdef HAVE_NDIR_H
 647     #  include <ndir.h>
 648     # endif
 649     #endif ])
 650 AC_SUBST([SCM_I_GSC_HAVE_STRUCT_DIRENT64])
 651
 652 # Reasons for testing:
 653 #   complex.h - new in C99
 654 #   fenv.h - available in C99, but not older systems
 655 #   machine/fpu.h - on Tru64 5.1b, the declaration of fesetround(3) is in
 656 #     this file instead of <fenv.h>
 657 #   process.h - mingw specific
 658 #   langinfo.h, nl_types.h - SuS v2
 659 #
 660 AC_CHECK_HEADERS([complex.h fenv.h io.h libc.h limits.h malloc.h memory.h process.h string.h \
 661 regex.h rxposix.h rx/rxposix.h sys/dir.h sys/ioctl.h sys/select.h \
 662 sys/time.h sys/timeb.h sys/times.h sys/stdtypes.h sys/types.h \
 663 sys/utime.h time.h unistd.h utime.h pwd.h grp.h sys/utsname.h \
 664 direct.h langinfo.h nl_types.h machine/fpu.h])
 665
 666 # Reasons for testing:
 667 #   nl_item - lacking on Cygwin
 668 AC_CHECK_TYPES([nl_item], [], [],
 669   [[#ifdef HAVE_LANGINFO_H
 670     # include <langinfo.h>
 671     #endif
 672     #ifdef HAVE_NL_TYPES_H
 673     # include <nl_types.h>
 674     #endif]])
 675
 676 # "complex double" is new in C99, and "complex" is only a keyword if
 677 # <complex.h> is included
 678 AC_CHECK_TYPES(complex double,,,
 679 [#if HAVE_COMPLEX_H
 680 #include <complex.h>
 681 #endif])
 682
 683 # On MacOS X <sys/socklen.h> contains socklen_t, so must include that
 684 # when testing.
 685 AC_CHECK_TYPE(socklen_t, ,
 686   [AC_DEFINE_UNQUOTED([socklen_t], int,
 687                       [Define to `int' if <sys/socket.h> does not define.])],
 688   [#if HAVE_SYS_TYPES_H
 689 #include <sys/types.h>
 690 #endif
 691 #include <sys/socket.h>
 692 ])
 693 AC_CHECK_TYPE(struct ip_mreq)
 694
 695 GUILE_HEADER_LIBC_WITH_UNISTD
 696
 697 AC_TYPE_GETGROUPS
 698 AC_TYPE_SIGNAL
 699 AC_TYPE_MODE_T
 700
 701 # On mingw -lm is empty, so this test is unnecessary, but it's
 702 # harmless so we don't hard-code to suppress it.
 703 #
 704 AC_CHECK_LIB(m, cos)
 705
 706 AC_CHECK_FUNCS(gethostbyname)
 707 if test $ac_cv_func_gethostbyname = no; then
 708     AC_CHECK_LIB(nsl, gethostbyname)
 709 fi
 710
 711 AC_CHECK_FUNCS(connect)
 712 if test $ac_cv_func_connect = no; then
 713     AC_CHECK_LIB(socket, connect)
 714 fi
 715
 716 dnl
 717 dnl Check for Winsock and other functionality on Win32 (*not* CygWin)
 718 dnl
 719 EXTRA_DEFS=""
 720 case $host in
 721   *-*-mingw*)
 722     AC_CHECK_HEADER(winsock2.h, [AC_DEFINE([HAVE_WINSOCK2_H], 1,
 723       [Define if you have the <winsock2.h> header file.])])
 724     AC_CHECK_LIB(ws2_32, main)
 725     AC_LIBOBJ([win32-uname])
 726     AC_LIBOBJ([win32-dirent])
 727     if test "$enable_networking" = yes ; then
 728       AC_LIBOBJ([win32-socket])
 729     fi
 730     if test "$enable_shared" = yes ; then
 731       EXTRA_DEFS="-DSCM_IMPORT"
 732       AC_DEFINE([USE_DLL_IMPORT], 1,
 733         [Define if you need additional CPP macros on Win32 platforms.])
 734     fi
 735     ;;
 736 esac
 737 AC_SUBST(EXTRA_DEFS)
 738
 739 # Reasons for testing:
 740 #   crt_externs.h - Darwin specific
 741 #
 742 AC_CHECK_HEADERS([assert.h crt_externs.h])
 743
 744 # Reasons for testing:
 745 #   DINFINITY - OSF specific
 746 #   DQNAN - OSF specific
 747 #       (DINFINITY and DQNAN are actually global variables, not functions)
 748 #   chsize - an MS-DOS-ism, found in mingw
 749 #   cexp, clog - not in various pre-c99 systems, and note that it's possible
 750 #       for gcc to provide the "complex double" type but the system to not
 751 #       have functions like cexp and clog
 752 #   clog10 - not in mingw (though others like clog and csqrt are)
 753 #   fesetround - available in C99, but not older systems
 754 #   ftruncate - posix, but probably not older systems (current mingw
 755 #               has it as an inline for chsize)
 756 #   ioctl - not in mingw.
 757 #   gmtime_r - recent posix, not on old systems
 758 #   pipe - not in mingw
 759 #   _pipe - specific to mingw, taking 3 args
 760 #   readdir_r - recent posix, not on old systems
 761 #   readdir64_r - not available on HP-UX 11.11
 762 #   stat64 - SuS largefile stuff, not on old systems
 763 #   sysconf - not on old systems
 764 #   truncate - not in mingw
 765 #   isblank - available as a GNU extension or in C99
 766 #   _NSGetEnviron - Darwin specific
 767 #   strcoll_l, newlocale - GNU extensions (glibc), also available on Darwin
 768 #   nl_langinfo - X/Open, not available on Windows.
 769 #   utimensat: posix.1-2008
 770 #
 771 AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid fesetround ftime ftruncate fchown getcwd geteuid getsid gettimeofday gmtime_r ioctl lstat mkdir mknod nice pipe _pipe readdir_r readdir64_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 utimensat])
 772
 773 # Reasons for testing:
 774 #   netdb.h - not in mingw
 775 #   sys/param.h - not in mingw
 776 #   pthread.h - only available with pthreads.  ACX_PTHREAD doesn't
 777 #       check this specifically, we need it for the timespec test below.
 778 #   sethostname - the function itself check because it's not in mingw,
 779 #       the DECL is checked because Solaris 10 doens't have in any header
 780 #   hstrerror - on Tru64 5.1b the symbol is available in libc but the
 781 #       declaration isn't anywhere.
 782 #   cuserid - on Tru64 5.1b the declaration is documented to be available
 783 #       only with `_XOPEN_SOURCE' or some such.
 784 #
 785 AC_CHECK_HEADERS([crypt.h netdb.h pthread.h sys/param.h sys/resource.h sys/file.h])
 786 AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
 787 AC_CHECK_DECLS([sethostname, hstrerror, cuserid])
 788
 789 # crypt() may or may not be available, for instance in some countries there
 790 # are restrictions on cryptography.
 791 #
 792 # crypt() might be in libc (eg. OpenBSD), or it might be in a separate
 793 # -lcrypt library (eg. Debian GNU/Linux).
 794 #
 795 # On HP-UX 11, crypt() is in libc and there's a dummy libcrypt.a.  We must
 796 # be careful to avoid -lcrypt in this case, since libtool will see there's
 797 # only a static libcrypt and decide to build only a static libguile.
 798 #
 799 # AC_SEARCH_LIBS lets us add -lcrypt to LIBS only if crypt() is not in the
 800 # libraries already in that list.
 801 #
 802 AC_SEARCH_LIBS(crypt, crypt,
 803   [AC_DEFINE([HAVE_CRYPT],1,
 804              [Define to 1 if you have the `crypt' function.])])
 805
 806 # When compiling with GCC on some OSs (Solaris, AIX), _Complex_I doesn't
 807 # work; in the reported cases so far, 1.0fi works well instead.  According
 808 # to the C99 spec, the complex.h header must provide a working definition
 809 # of _Complex_I, so we always try _Complex_I first.  The 1.0fi fallback
 810 # is a workaround for the failure of some systems to conform to C99.
 811 if test "$ac_cv_type_complex_double" = yes; then
 812   AC_MSG_CHECKING([for i])
 813   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 814 #if HAVE_COMPLEX_H
 815 #include <complex.h>
 816 #endif
 817 complex double z;
 818 ]], [[
 819 z = _Complex_I;
 820 ]])],
 821     [AC_DEFINE([GUILE_I],_Complex_I,[The imaginary unit (positive square root of -1).])
 822      AC_MSG_RESULT([_Complex_I])],
 823     [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 824 #if HAVE_COMPLEX_H
 825 #include <complex.h>
 826 #endif
 827 complex double z;
 828 ]],[[
 829 z = 1.0fi;
 830 ]])],
 831   [AC_DEFINE([GUILE_I],1.0fi)
 832    AC_MSG_RESULT([1.0fi])],
 833   [ac_cv_type_complex_double=no
 834    AC_MSG_RESULT([not available])])])
 835 fi
 836
 837 # glibc 2.3.6 (circa 2006) and various prior versions had a bug where
 838 # csqrt(-i) returned a negative real part, when it should be positive
 839 # for the principal root.
 840 #
 841 if test "$ac_cv_type_complex_double" = yes; then
 842
 843   AC_CACHE_CHECK([whether csqrt is usable],
 844     guile_cv_use_csqrt,
 845     [AC_RUN_IFELSE([AC_LANG_SOURCE([[
 846 #include <complex.h>
 847 /* "volatile" is meant to prevent gcc from calculating the sqrt as a
 848    constant, we want to test libc. */
 849 volatile complex double z = - _Complex_I;
 850 int
 851 main (void)
 852 {
 853   z = csqrt (z);
 854   if (creal (z) > 0.0)
 855     return 0;  /* good */
 856   else
 857     return 1;  /* bad */
 858 }]])],
 859     [guile_cv_use_csqrt=yes],
 860     [guile_cv_use_csqrt="no, glibc 2.3 bug"],
 861     [guile_cv_use_csqrt="yes, hopefully (cross-compiling)"])])
 862   case $guile_cv_use_csqrt in
 863     yes*)
 864       AC_DEFINE([HAVE_USABLE_CSQRT], 1, [Define to 1 if csqrt is bug-free])
 865       ;;
 866   esac
 867 fi
 868
 869
 870 dnl GMP tests
 871 AC_LIB_HAVE_LINKFLAGS(gmp,
 872   [],
 873   [#include <gmp.h>],
 874   [mpz_import (0, 0, 0, 0, 0, 0, 0);],
 875   AC_MSG_ERROR([GNU MP 4.1 or greater not found, see README]))
 876
 877 dnl GNU libunistring is checked for by Gnulib's `libunistring' module.
 878 if test "x$LTLIBUNISTRING" != "x"; then
 879   LIBS="$LTLIBUNISTRING $LIBS"
 880 else
 881   AC_MSG_ERROR([GNU libunistring is required, please install it.])
 882 fi
 883
 884 dnl Libffi is needed to compile Guile's foreign function interface, but its
 885 dnl interface isn't exposed in Guile's API.
 886 PKG_CHECK_MODULES(LIBFFI, libffi)
 887 AC_SUBST(LIBFFI_CFLAGS)
 888 AC_SUBST(LIBFFI_LIBS)
 889
 890 dnl figure out approriate ffi type for size_t
 891 AC_CHECK_SIZEOF(size_t)
 892 AC_CHECK_SIZEOF(ssize_t)
 893 ffi_size_type=uint$(($ac_cv_sizeof_size_t*8))
 894 ffi_ssize_type=sint$(($ac_cv_sizeof_ssize_t*8))
 895 AC_DEFINE_UNQUOTED(ffi_type_size_t, ffi_type_${ffi_size_type},
 896                    [ffi type for size_t])
 897 AC_DEFINE_UNQUOTED(ffi_type_ssize_t, ffi_type_${ffi_ssize_type},
 898                    [ffi type for ssize_t])
 899
 900 dnl i18n tests
 901 #AC_CHECK_HEADERS([libintl.h])
 902 #AC_CHECK_FUNCS(gettext)
 903 #if test $ac_cv_func_gettext = no; then
 904 #   AC_CHECK_LIB(intl, gettext)
 905 #fi
 906 #AC_CHECK_FUNCS([bindtextdomain textdomain])
 907 AM_GNU_GETTEXT([external], [need-ngettext])
 908
 909 ### Some systems don't declare some functions.  On such systems, we
 910 ### need to at least provide our own K&R-style declarations.
 911
 912 ### GUILE_FUNC_DECLARED(function, headerfile)
 913
 914 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
 915 ### not there, #define MISSING_FUNCTION_DECL.
 916 AC_DEFUN([GUILE_FUNC_DECLARED], [
 917   AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
 918     AC_EGREP_HEADER($1, $2,
 919                     guile_cv_func_$1_declared=yes,
 920                     guile_cv_func_$1_declared=no))
 921   if test [x$guile_cv_func_]$1[_declared] = xno; then
 922     AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
 923       [Define if the operating system supplies $1 without declaring it.])
 924   fi
 925 ])
 926
 927 GUILE_FUNC_DECLARED(sleep, unistd.h)
 928 GUILE_FUNC_DECLARED(usleep, unistd.h)
 929
 930 AC_CHECK_DECLS([strptime],,,
 931 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
 932 #include <time.h>])
 933
 934 ### On some systems usleep has no return value.  If it does have one,
 935 ### we'd like to return it; otherwise, we'll fake it.
 936 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
 937   [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),
 938                    unistd.h,
 939                    [guile_cv_func_usleep_return_type=void],
 940                    [guile_cv_func_usleep_return_type=int])])
 941 case "$guile_cv_func_usleep_return_type" in
 942   "void" )
 943     AC_DEFINE([USLEEP_RETURNS_VOID], 1,
 944       [Define if the system headers declare usleep to return void.])
 945   ;;
 946 esac
 947
 948 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
 949 if test -n "$have_sys_un_h" ; then
 950   AC_DEFINE([HAVE_UNIX_DOMAIN_SOCKETS], 1,
 951     [Define if the system supports Unix-domain (file-domain) sockets.])
 952 fi
 953
 954 AC_CHECK_FUNCS(getrlimit setrlimit)
 955
 956 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
 957
 958 AC_CHECK_FUNCS(sethostent   gethostent   endhostent   dnl
 959                setnetent    getnetent    endnetent    dnl
 960                setprotoent  getprotoent  endprotoent  dnl
 961                setservent   getservent   endservent   dnl
 962                getnetbyaddr getnetbyname dnl
 963                inet_lnaof inet_makeaddr inet_netof hstrerror)
 964
 965 # struct sockaddr field sin_len is only present on BSD systems.
 966 # On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems
 967 # (eg. FreeBSD 4.9) it doesn't and we must use this configure check
 968 AC_CHECK_MEMBERS([struct sockaddr.sin_len],,,
 969 [#ifdef HAVE_SYS_TYPES_H
 970 #include <sys/types.h>
 971 #endif
 972 #include <netinet/in.h>])
 973
 974 AC_MSG_CHECKING(for __libc_stack_end)
 975 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
 976 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>
 977 extern char *__libc_stack_end;]],
 978    [[printf("%p", (char*) __libc_stack_end);]])],
 979    [guile_cv_have_libc_stack_end=yes],
 980    [guile_cv_have_libc_stack_end=no])])
 981 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
 982
 983 if test $guile_cv_have_libc_stack_end = yes; then
 984   AC_DEFINE([HAVE_LIBC_STACK_END], 1,
 985            [Define if you have the __libc_stack_end variable.])
 986 fi
 987
 988 dnl Some systems do not declare this.  Some systems do declare it, as a
 989 dnl macro.  With cygwin it may be in a DLL.
 990
 991 AC_MSG_CHECKING(whether netdb.h declares h_errno)
 992 AC_CACHE_VAL(guile_cv_have_h_errno,
 993   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]],
 994                                       [[int a = h_errno;]])],
 995   [guile_cv_have_h_errno=yes],
 996   [guile_cv_have_h_errno=no])])
 997 AC_MSG_RESULT($guile_cv_have_h_errno)
 998 if test $guile_cv_have_h_errno = yes; then
 999   AC_DEFINE([HAVE_H_ERRNO], 1, [Define if h_errno is declared in netdb.h.])
1000 fi
1001
1002 AC_MSG_CHECKING(whether uint32_t is defined)
1003 AC_CACHE_VAL(guile_cv_have_uint32_t,
1004   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
1005                    #if HAVE_STDINT_H
1006                    #include <stdint.h>
1007                    #endif
1008                    #ifndef HAVE_NETDB_H
1009                    #include <netdb.h>
1010                    #endif]],
1011                    [[uint32_t a;]])],
1012                    [guile_cv_have_uint32_t=yes],
1013                    [guile_cv_have_uint32_t=no])])
1014 AC_MSG_RESULT($guile_cv_have_uint32_t)
1015 if test $guile_cv_have_uint32_t = yes; then
1016   AC_DEFINE([HAVE_UINT32_T], 1,
1017     [Define if uint32_t typedef is defined when netdb.h is include.])
1018 fi
1019
1020 AC_MSG_CHECKING(for working IPv6 support)
1021 AC_CACHE_VAL(guile_cv_have_ipv6,
1022 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1023 #ifdef HAVE_SYS_TYPES_H
1024 #include <sys/types.h>
1025 #endif
1026 #include <netinet/in.h>
1027 #include <sys/socket.h>]],
1028 [[struct sockaddr_in6 a;  a.sin6_family = AF_INET6;]])],
1029 [guile_cv_have_ipv6=yes],
1030 [guile_cv_have_ipv6=no])])
1031 AC_MSG_RESULT($guile_cv_have_ipv6)
1032 if test $guile_cv_have_ipv6 = yes; then
1033   AC_DEFINE([HAVE_IPV6], 1, [Define if you want support for IPv6.])
1034 fi
1035
1036 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
1037 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
1038 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
1039 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1040 #ifdef HAVE_SYS_TYPES_H
1041 #include <sys/types.h>
1042 #endif
1043 #include <netinet/in.h>]],
1044 [[struct sockaddr_in6 sok;  sok.sin6_scope_id = 0;]])],
1045 [guile_cv_have_sin6_scope_id=yes],
1046 [guile_cv_have_sin6_scope_id=no])])
1047 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
1048 if test $guile_cv_have_sin6_scope_id = yes; then
1049   AC_DEFINE([HAVE_SIN6_SCOPE_ID], 1,
1050     [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
1051 fi
1052
1053 # struct sockaddr_in6 field sin_len is only present on BSD systems
1054 AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,,
1055 [#ifdef HAVE_SYS_TYPES_H
1056 #include <sys/types.h>
1057 #endif
1058 #include <netinet/in.h>])
1059
1060 AC_MSG_CHECKING(whether localtime caches TZ)
1061 AC_CACHE_VAL(guile_cv_localtime_cache,
1062 [if test x$ac_cv_func_tzset = xyes; then
1063 AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <time.h>
1064 #if STDC_HEADERS
1065 # include <stdlib.h>
1066 #endif
1067 extern char **environ;
1068 unset_TZ ()
1069 {
1070   char **from, **to;
1071   for (to = from = environ; (*to = *from); from++)
1072     if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
1073       to++;
1074 }
1075 char TZ_GMT0[] = "TZ=GMT0";
1076 char TZ_PST8[] = "TZ=PST8";
1077 main()
1078 {
1079   time_t now = time ((time_t *) 0);
1080   int hour_GMT0, hour_unset;
1081   if (putenv (TZ_GMT0) != 0)
1082     exit (1);
1083   hour_GMT0 = localtime (&now)->tm_hour;
1084   unset_TZ ();
1085   hour_unset = localtime (&now)->tm_hour;
1086   if (putenv (TZ_PST8) != 0)
1087     exit (1);
1088   if (localtime (&now)->tm_hour == hour_GMT0)
1089     exit (1);
1090   unset_TZ ();
1091   if (localtime (&now)->tm_hour != hour_unset)
1092     exit (1);
1093   exit (0);
1094 }]])],
1095 [guile_cv_localtime_cache=no],
1096 [guile_cv_localtime_cache=yes],
1097 [# If we have tzset, assume the worst when cross-compiling.
1098 guile_cv_localtime_cache=yes])
1099 else
1100         # If we lack tzset, report that localtime does not cache TZ,
1101         # since we can't invalidate the cache if we don't have tzset.
1102         guile_cv_localtime_cache=no
1103 fi])dnl
1104 AC_MSG_RESULT($guile_cv_localtime_cache)
1105 if test $guile_cv_localtime_cache = yes; then
1106   AC_DEFINE([LOCALTIME_CACHE], 1, [Define if localtime caches the TZ setting.])
1107 fi
1108
1109 if test "$enable_regex" = yes; then
1110    if test "$ac_cv_header_regex_h" = yes ||
1111       test "$ac_cv_header_rxposix_h" = yes ||
1112       test "$ac_cv_header_rx_rxposix_h" = yes; then
1113      GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
1114      [AC_CHECK_LIB(rx, main)
1115       GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
1116      [AC_CHECK_LIB(regex, main)
1117       GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
1118      )
1119      dnl The following should not be necessary, but for some reason
1120      dnl autoheader misses it if we don't include it!
1121      if test "$ac_cv_func_regcomp_norx" = yes ||
1122         test "$ac_cv_func_regcomp_regex" = yes ||
1123         test "$ac_cv_func_regcomp_rx" = yes; then
1124        AC_DEFINE([HAVE_REGCOMP], 1,
1125          [This is included as part of a workaround for a autoheader bug.])
1126      fi
1127    fi
1128 fi
1129
1130 AC_REPLACE_FUNCS([strerror memmove mkstemp])
1131
1132 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
1133
1134 # Reasons for testing:
1135 #   asinh, acosh, atanh, trunc - C99 standard, generally not available on
1136 #                                older systems
1137 #   sincos - GLIBC extension
1138 #
1139 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
1140
1141 # C99 specifies isinf and isnan as macros.
1142 # HP-UX provides only macros, no functions.
1143 # glibc 2.3.2 provides both macros and functions.
1144 # IRIX 6.5 and Solaris 8 only provide functions.
1145 #
1146 # The following tests detect isinf and isnan either as functions or as
1147 # macros from <math.h>.  Plain AC_CHECK_FUNCS is insufficient, it doesn't
1148 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
1149 #
1150 AC_MSG_CHECKING([for isinf])
1151 AC_LINK_IFELSE(AC_LANG_SOURCE(
1152 [[#include <math.h>
1153 volatile double x = 0.0;
1154 int main () { return (isinf(x) != 0); }]]),
1155   [AC_MSG_RESULT([yes])
1156    AC_DEFINE([HAVE_ISINF], 1,
1157              [Define to 1 if you have the `isinf' macro or function.])],
1158   [AC_MSG_RESULT([no])])
1159 AC_MSG_CHECKING([for isnan])
1160 AC_LINK_IFELSE(AC_LANG_SOURCE(
1161 [[#include <math.h>
1162 volatile double x = 0.0;
1163 int main () { return (isnan(x) != 0); }]]),
1164   [AC_MSG_RESULT([yes])
1165    AC_DEFINE([HAVE_ISNAN], 1,
1166              [Define to 1 if you have the `isnan' macro or function.])],
1167   [AC_MSG_RESULT([no])])
1168
1169 # Reasons for checking:
1170 #
1171 #     st_rdev
1172 #     st_blksize
1173 #     st_blocks   not in mingw
1174 #     tm_gmtoff   BSD+GNU, not in C99
1175 #
1176 # Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the
1177 # AC_LIBOBJ(fileblocks) replacement which that macro gives.
1178 #
1179 AC_CHECK_MEMBERS([struct stat.st_rdev, struct stat.st_blksize, struct stat.st_blocks, struct stat.st_atim, struct stat.st_mtim, struct stat.st_ctim],,,
1180                  [#define _GNU_SOURCE
1181 AC_INCLUDES_DEFAULT
1182 ])
1183
1184 AC_STRUCT_TIMEZONE
1185 AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,
1186 [#include <time.h>
1187 #ifdef TIME_WITH_SYS_TIME
1188 # include <sys/time.h>
1189 # include <time.h>
1190 #else
1191 # if HAVE_SYS_TIME_H
1192 #  include <sys/time.h>
1193 # else
1194 #  include <time.h>
1195 # endif
1196 #endif
1197 ])
1198 GUILE_STRUCT_UTIMBUF
1199
1200
1201 #--------------------------------------------------------------------
1202 #
1203 # Which way does the stack grow?
1204 #
1205 # Following code comes from Autoconf 2.61's internal _AC_LIBOBJ_ALLOCA
1206 # macro (/usr/share/autoconf/autoconf/functions.m4).  Gnulib has
1207 # very similar code, so in future we could look at using that.
1208 #
1209 # An important detail is that the code involves find_stack_direction
1210 # calling _itself_ - which means that find_stack_direction (or at
1211 # least the second find_stack_direction() call) cannot be inlined.
1212 # If the code could be inlined, that might cause the test to give
1213 # an incorrect answer.
1214 #--------------------------------------------------------------------
1215
1216 SCM_I_GSC_STACK_GROWS_UP=0
1217 AC_RUN_IFELSE([AC_LANG_SOURCE(
1218 [AC_INCLUDES_DEFAULT
1219 int
1220 find_stack_direction ()
1221 {
1222   static char *addr = 0;
1223   auto char dummy;
1224   if (addr == 0)
1225     {
1226       addr = &dummy;
1227       return find_stack_direction ();
1228     }
1229   else
1230     return (&dummy > addr) ? 1 : -1;
1231 }
1232
1233 int
1234 main ()
1235 {
1236   return find_stack_direction () < 0;
1237 }])],
1238                [SCM_I_GSC_STACK_GROWS_UP=1],
1239                [],
1240                [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
1241
1242 #--------------------------------------------------------------------
1243 #
1244 # Boehm's GC library
1245 #
1246 #--------------------------------------------------------------------
1247 PKG_CHECK_MODULES([BDW_GC], [bdw-gc])
1248
1249 CFLAGS="$BDW_GC_CFLAGS $CFLAGS"
1250 LIBS="$BDW_GC_LIBS $LIBS"
1251
1252 # `GC_do_blocking ()' is available in GC 7.1 but not declared.
1253 AC_CHECK_FUNCS([GC_do_blocking])
1254 AC_CHECK_DECL([GC_do_blocking],
1255   [AC_DEFINE([HAVE_DECL_GC_DO_BLOCKING], [1],
1256     [Define this if the `GC_do_blocking ()' function is declared])],
1257   [],
1258   [#include <gc/gc.h>])
1259
1260 # `GC_fn_type' is not available in GC 7.1 and earlier.
1261 AC_CHECK_TYPE([GC_fn_type],
1262   [AC_DEFINE([HAVE_GC_FN_TYPE], [1],
1263     [Define this if the `GC_fn_type' type is available.])],
1264   [],
1265   [#include <gc/gc.h>])
1266
1267
1268 AC_CHECK_SIZEOF(float)
1269 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1270     AC_DEFINE([SCM_SINGLES], 1,
1271               [Define this if floats are the same size as longs.])
1272 fi
1273
1274 AC_MSG_CHECKING(for struct linger)
1275 AC_CACHE_VAL(scm_cv_struct_linger,
1276         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1277 #include <sys/types.h>
1278 #include <sys/socket.h>]],
1279                           [[struct linger lgr;  lgr.l_linger = 100]])],
1280                           [scm_cv_struct_linger="yes"],
1281                           [scm_cv_struct_linger="no"]))
1282 AC_MSG_RESULT($scm_cv_struct_linger)
1283 if test $scm_cv_struct_linger = yes; then
1284         AC_DEFINE([HAVE_STRUCT_LINGER], 1,
1285           [Define this if your system defines struct linger, for use with the
1286            getsockopt and setsockopt system calls.])
1287 fi
1288
1289
1290 # On mingw, struct timespec is in <pthread.h>.
1291 #
1292 AC_MSG_CHECKING(for struct timespec)
1293 AC_CACHE_VAL(scm_cv_struct_timespec,
1294         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1295 #include <time.h>
1296 #if HAVE_PTHREAD_H
1297 #include <pthread.h>
1298 #endif]], [[struct timespec t;  t.tv_nsec = 100]])],
1299           [scm_cv_struct_timespec="yes"],
1300           [scm_cv_struct_timespec="no"]))
1301 AC_MSG_RESULT($scm_cv_struct_timespec)
1302 if test $scm_cv_struct_timespec = yes; then
1303   AC_DEFINE([HAVE_STRUCT_TIMESPEC], 1,
1304     [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1305 fi
1306
1307 #--------------------------------------------------------------------
1308 #
1309 # Flags for thread support
1310 #
1311 #--------------------------------------------------------------------
1312
1313 SCM_I_GSC_USE_PTHREAD_THREADS=0
1314 SCM_I_GSC_USE_NULL_THREADS=0
1315 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1316 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1317
1318 ### What thread package has the user asked for?
1319 AC_ARG_WITH(threads, [  --with-threads          thread interface],
1320             , with_threads=yes)
1321
1322 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1323 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER, 0)
1324
1325 case "$with_threads" in
1326   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1327
1328     build_pthread_support="yes"
1329
1330     ACX_PTHREAD([CC="$PTHREAD_CC"
1331        LIBS="$PTHREAD_LIBS $LIBS"
1332        SCM_I_GSC_USE_PTHREAD_THREADS=1
1333        with_threads="pthreads"],
1334       [with_threads="null"
1335        build_pthread_support="no"])
1336
1337     old_CFLAGS="$CFLAGS"
1338     CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1339
1340     # Reasons for testing:
1341     #     pthread_getattr_np - "np" meaning "non portable" says it
1342     #         all; not present on MacOS X or Solaris 10
1343     #     pthread_get_stackaddr_np - "np" meaning "non portable" says it
1344     #         all; specific to MacOS X
1345     #     pthread_sigmask - not available on mingw
1346     #
1347     AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1348
1349     # On past versions of Solaris, believe 8 through 10 at least, you
1350     # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1351     # This is contrary to POSIX:
1352     # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1353     # Check here if this style is required.
1354     #
1355     # glibc (2.3.6 at least) works both with or without braces, so the
1356     # test checks whether it works without.
1357     #
1358
1359     if test "$GCC" = "yes"; then
1360       # Since GCC only issues a warning for missing braces, so we need
1361       # `-Werror' to catch it.
1362       CFLAGS="-Werror -Wmissing-braces $CFLAGS"
1363     fi
1364
1365     AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1366       guile_cv_need_braces_on_pthread_once_init,
1367       [AC_COMPILE_IFELSE([#include <pthread.h>
1368          pthread_once_t foo = PTHREAD_ONCE_INIT;],
1369         [guile_cv_need_braces_on_pthread_once_init=no],
1370         [guile_cv_need_braces_on_pthread_once_init=yes])])
1371     if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1372       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1373     fi
1374
1375     # Same problem with `PTHREAD_MUTEX_INITIALIZER', e.g., on IRIX
1376     # 6.5.30m with GCC 3.3.
1377     AC_CACHE_CHECK([whether PTHREAD_MUTEX_INITIALIZER needs braces],
1378       guile_cv_need_braces_on_pthread_mutex_initializer,
1379       [AC_COMPILE_IFELSE([#include <pthread.h>
1380          pthread_mutex_t foo = PTHREAD_MUTEX_INITIALIZER;],
1381         [guile_cv_need_braces_on_pthread_mutex_initializer=no],
1382         [guile_cv_need_braces_on_pthread_mutex_initializer=yes])])
1383     if test "$guile_cv_need_braces_on_pthread_mutex_initializer" = yes; then
1384       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER=1
1385     fi
1386
1387     CFLAGS="$old_CFLAGS"
1388
1389     # On Solaris, sched_yield lives in -lrt.
1390     AC_SEARCH_LIBS(sched_yield, rt)
1391
1392   ;;
1393 esac
1394
1395 case "$with_threads" in
1396   "pthreads")
1397   ;;
1398   "no" | "null")
1399     SCM_I_GSC_USE_NULL_THREADS=1
1400     SCM_I_GSC_HAVE_THREAD_STORAGE_CLASS=0
1401     with_threads="null-threads"
1402   ;;
1403   * )
1404     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1405   ;;
1406 esac
1407
1408 AC_MSG_CHECKING(what kind of threads to support)
1409 AC_MSG_RESULT($with_threads)
1410
1411 AM_CONDITIONAL([BUILD_PTHREAD_SUPPORT],
1412   [test "x$build_pthread_support" = "xyes"])
1413
1414
1415 ## Check whether pthread_attr_getstack works for the main thread
1416
1417 if test "$with_threads" = pthreads; then
1418
1419 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1420 old_CFLAGS="$CFLAGS"
1421 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1422 AC_RUN_IFELSE([AC_LANG_SOURCE([[
1423 #if HAVE_PTHREAD_ATTR_GETSTACK
1424 #include <pthread.h>
1425
1426 int main ()
1427 {
1428   pthread_attr_t attr;
1429   void *start, *end;
1430   size_t size;
1431
1432   pthread_getattr_np (pthread_self (), &attr);
1433   pthread_attr_getstack (&attr, &start, &size);
1434   end = (char *)start + size;
1435
1436   if ((void *)&attr < start || (void *)&attr >= end)
1437     return 1;
1438   else
1439     return 0;
1440 }
1441 #else
1442 int main ()
1443 {
1444   return 1;
1445 }
1446 #endif
1447 ]])],
1448 [works=yes
1449 AC_DEFINE([PTHREAD_ATTR_GETSTACK_WORKS], [1], [Define when pthread_att_get_stack works for the main thread])],
1450 [works=no],
1451 [])
1452 CFLAGS="$old_CFLAGS"
1453 AC_MSG_RESULT($works)
1454
1455 GUILE_THREAD_LOCAL_STORAGE
1456
1457 fi # with_threads=pthreads
1458
1459
1460 ## Cross building
1461 if test "$cross_compiling" = "yes"; then
1462   AC_MSG_CHECKING(cc for build)
1463   ## /usr/bin/cc still uses wrong assembler
1464   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1465   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1466 else
1467   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1468 fi
1469
1470 ## AC_MSG_CHECKING("if we are cross compiling")
1471 ## AC_MSG_RESULT($cross_compiling)
1472 if test "$cross_compiling" = "yes"; then
1473    AC_MSG_RESULT($CC_FOR_BUILD)
1474 fi
1475
1476 ## No need as yet to be more elaborate
1477 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1478
1479 AC_SUBST(cross_compiling)
1480 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1481 AC_SUBST(CCLD_FOR_BUILD)
1482
1483 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1484 ## --HOST is the platform that PACKAGE is compiled for.
1485 HOST_CC="$CC_FOR_BUILD"
1486 AC_SUBST(HOST_CC)
1487
1488 if test "$cross_compiling" = "yes"; then
1489   AC_MSG_CHECKING(guile for build)
1490   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1491 else
1492   GUILE_FOR_BUILD='$(preinstguile)'
1493 fi
1494
1495 ## AC_MSG_CHECKING("if we are cross compiling")
1496 ## AC_MSG_RESULT($cross_compiling)
1497 if test "$cross_compiling" = "yes"; then
1498    AC_MSG_RESULT($GUILE_FOR_BUILD)
1499 fi
1500 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1501 AC_SUBST(GUILE_FOR_BUILD)
1502
1503 ## If we're using GCC, ask for aggressive warnings.
1504 GCC_CFLAGS=""
1505 case "$GCC" in
1506   yes )
1507     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1508     ## much stuff with generic function pointers for that to really be
1509     ## less than exasperating.
1510     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1511     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1512     POTENTIAL_GCC_CFLAGS="-Wall -Wmissing-prototypes \
1513       -Wdeclaration-after-statement -Wundef \
1514       -Wswitch-enum"
1515     # Do this here so we don't screw up any of the tests above that might
1516     # not be "warning free"
1517     if test "${GUILE_ERROR_ON_WARNING}" = yes
1518     then
1519         POTENTIAL_GCC_CFLAGS="${POTENTIAL_GCC_CFLAGS} -Werror"
1520         enable_compile_warnings=no
1521     fi
1522
1523     for flag in $POTENTIAL_GCC_CFLAGS
1524     do
1525         gl_WARN_ADD([$flag], [GCC_CFLAGS])
1526     done
1527     ;;
1528 esac
1529
1530 AC_SUBST(GCC_CFLAGS)
1531
1532 # Check for GNU ld's "-z relro".
1533 GUILE_GNU_LD_RELRO
1534
1535
1536 ## If we're creating a shared library (using libtool!), then we'll
1537 ## need to generate a list of .lo files corresponding to the .o files
1538 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1539 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1540
1541 ## We also need to create corresponding .doc and .x files
1542 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1543 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1544
1545 # GNU Readline bindings.
1546 GUILE_READLINE
1547
1548 AC_SUBST(GUILE_MAJOR_VERSION)
1549 AC_SUBST(GUILE_MINOR_VERSION)
1550 AC_SUBST(GUILE_MICRO_VERSION)
1551 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1552 AC_SUBST(GUILE_VERSION)
1553
1554 #######################################################################
1555 # library versioning
1556
1557 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1558 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1559 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1560 AC_SUBST(LIBGUILE_INTERFACE)
1561
1562 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1563 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1564 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1565 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1566 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1567
1568 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1569 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1570 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1571 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1572 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1573
1574 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1575 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1576 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1577 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1578 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1579
1580 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1581 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1582 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1583 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1584 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1585
1586 AC_SUBST(LIBGUILE_I18N_MAJOR)
1587 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1588 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1589 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1590 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1591
1592
1593 #######################################################################
1594
1595 dnl Tell guile-config what flags guile users should compile and link with.
1596 GUILE_LIBS="$LDFLAGS $LIBS"
1597 GUILE_CFLAGS="$CPPFLAGS $PTHREAD_CFLAGS"
1598 AC_SUBST(GUILE_LIBS)
1599 AC_SUBST(GUILE_CFLAGS)
1600
1601 AC_SUBST(AWK)
1602 AC_SUBST(LIBLOBJS)
1603 AC_SUBST(EXTRA_DOT_DOC_FILES)
1604 AC_SUBST(EXTRA_DOT_X_FILES)
1605
1606 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1607 top_builddir_absolute=`pwd`
1608 AC_SUBST(top_builddir_absolute)
1609 top_srcdir_absolute=`(cd $srcdir && pwd)`
1610 AC_SUBST(top_srcdir_absolute)
1611
1612 dnl We need `sitedir' in `guile-1.8.pc'.
1613 dnl Note: `sitedir' must be kept in sync with `GUILE_SITE_DIR' in `guile.m4'.
1614 pkgdatadir="$datadir/$PACKAGE_TARNAME"
1615 sitedir="$pkgdatadir/site"
1616 AC_SUBST([sitedir])
1617
1618 # Additional SCM_I_GSC definitions are above.
1619 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1620 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1621 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1622 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1623 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1624 AC_SUBST([SCM_I_GSC_C_INLINE])
1625 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1626
1627 AC_CONFIG_FILES([
1628   Makefile
1629   am/Makefile
1630   lib/Makefile
1631   benchmark-suite/Makefile
1632   doc/Makefile
1633   doc/r5rs/Makefile
1634   doc/ref/Makefile
1635   emacs/Makefile
1636   examples/Makefile
1637   libguile/Makefile
1638   srfi/Makefile
1639   guile-readline/Makefile
1640   test-suite/Makefile
1641   test-suite/standalone/Makefile
1642   meta/Makefile
1643   module/Makefile
1644   testsuite/Makefile
1645 ])
1646
1647 AC_CONFIG_FILES([meta/guile-2.0.pc])
1648 AC_CONFIG_FILES([meta/guile-2.0-uninstalled.pc])
1649 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1650 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1651 AC_CONFIG_FILES([meta/guile], [chmod +x meta/guile])
1652 AC_CONFIG_FILES([meta/uninstalled-env], [chmod +x meta/uninstalled-env])
1653 AC_CONFIG_FILES([meta/gdb-uninstalled-guile], [chmod +x meta/gdb-uninstalled-guile])
1654 AC_CONFIG_FILES([meta/guile-tools], [chmod +x meta/guile-tools])
1655 AC_CONFIG_FILES([libguile/guile-snarf],
1656                 [chmod +x libguile/guile-snarf])
1657 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1658                 [chmod +x libguile/guile-doc-snarf])
1659 AC_CONFIG_FILES([libguile/guile-func-name-check],
1660                 [chmod +x libguile/guile-func-name-check])
1661 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1662                 [chmod +x libguile/guile-snarf-docs])
1663 AC_CONFIG_FILES([test-suite/standalone/test-use-srfi],
1664                 [chmod +x test-suite/standalone/test-use-srfi])
1665 AC_CONFIG_FILES([test-suite/standalone/test-fast-slot-ref],
1666                 [chmod +x test-suite/standalone/test-fast-slot-ref])
1667 AC_CONFIG_FILES([doc/ref/effective-version.texi])
1668
1669 AC_OUTPUT
1670
1671 dnl Local Variables:
1672 dnl comment-start: "dnl "
1673 dnl comment-end: ""
1674 dnl comment-start-skip: "\\bdnl\\b\\s *"
1675 dnl End: