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
 876 if test "x$HAVE_LIBGMP" != "xyes"; then
 877   AC_MSG_ERROR([GNU MP 4.1 or greater not found, see README])
 878 fi
 879
 880 dnl GNU libunistring is checked for by Gnulib's `libunistring' module.
 881 if test "x$LTLIBUNISTRING" != "x"; then
 882   LIBS="$LTLIBUNISTRING $LIBS"
 883 else
 884   AC_MSG_ERROR([GNU libunistring is required, please install it.])
 885 fi
 886
 887 dnl Libffi is needed to compile Guile's foreign function interface, but its
 888 dnl interface isn't exposed in Guile's API.
 889 PKG_CHECK_MODULES(LIBFFI, libffi)
 890 AC_SUBST(LIBFFI_CFLAGS)
 891 AC_SUBST(LIBFFI_LIBS)
 892
 893 dnl figure out approriate ffi type for size_t
 894 AC_CHECK_SIZEOF(size_t)
 895 AC_CHECK_SIZEOF(ssize_t)
 896 ffi_size_type=uint$(($ac_cv_sizeof_size_t*8))
 897 ffi_ssize_type=sint$(($ac_cv_sizeof_ssize_t*8))
 898 AC_DEFINE_UNQUOTED(ffi_type_size_t, ffi_type_${ffi_size_type},
 899                    [ffi type for size_t])
 900 AC_DEFINE_UNQUOTED(ffi_type_ssize_t, ffi_type_${ffi_ssize_type},
 901                    [ffi type for ssize_t])
 902
 903 dnl i18n tests
 904 #AC_CHECK_HEADERS([libintl.h])
 905 #AC_CHECK_FUNCS(gettext)
 906 #if test $ac_cv_func_gettext = no; then
 907 #   AC_CHECK_LIB(intl, gettext)
 908 #fi
 909 #AC_CHECK_FUNCS([bindtextdomain textdomain])
 910 AM_GNU_GETTEXT([external], [need-ngettext])
 911
 912 ### Some systems don't declare some functions.  On such systems, we
 913 ### need to at least provide our own K&R-style declarations.
 914
 915 ### GUILE_FUNC_DECLARED(function, headerfile)
 916
 917 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
 918 ### not there, #define MISSING_FUNCTION_DECL.
 919 AC_DEFUN([GUILE_FUNC_DECLARED], [
 920   AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
 921     AC_EGREP_HEADER($1, $2,
 922                     guile_cv_func_$1_declared=yes,
 923                     guile_cv_func_$1_declared=no))
 924   if test [x$guile_cv_func_]$1[_declared] = xno; then
 925     AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
 926       [Define if the operating system supplies $1 without declaring it.])
 927   fi
 928 ])
 929
 930 GUILE_FUNC_DECLARED(sleep, unistd.h)
 931 GUILE_FUNC_DECLARED(usleep, unistd.h)
 932
 933 AC_CHECK_DECLS([strptime],,,
 934 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
 935 #include <time.h>])
 936
 937 ### On some systems usleep has no return value.  If it does have one,
 938 ### we'd like to return it; otherwise, we'll fake it.
 939 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
 940   [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),
 941                    unistd.h,
 942                    [guile_cv_func_usleep_return_type=void],
 943                    [guile_cv_func_usleep_return_type=int])])
 944 case "$guile_cv_func_usleep_return_type" in
 945   "void" )
 946     AC_DEFINE([USLEEP_RETURNS_VOID], 1,
 947       [Define if the system headers declare usleep to return void.])
 948   ;;
 949 esac
 950
 951 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
 952 if test -n "$have_sys_un_h" ; then
 953   AC_DEFINE([HAVE_UNIX_DOMAIN_SOCKETS], 1,
 954     [Define if the system supports Unix-domain (file-domain) sockets.])
 955 fi
 956
 957 AC_CHECK_FUNCS(getrlimit setrlimit)
 958
 959 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
 960
 961 AC_CHECK_FUNCS(sethostent   gethostent   endhostent   dnl
 962                setnetent    getnetent    endnetent    dnl
 963                setprotoent  getprotoent  endprotoent  dnl
 964                setservent   getservent   endservent   dnl
 965                getnetbyaddr getnetbyname dnl
 966                inet_lnaof inet_makeaddr inet_netof hstrerror)
 967
 968 # struct sockaddr field sin_len is only present on BSD systems.
 969 # On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems
 970 # (eg. FreeBSD 4.9) it doesn't and we must use this configure check
 971 AC_CHECK_MEMBERS([struct sockaddr.sin_len],,,
 972 [#ifdef HAVE_SYS_TYPES_H
 973 #include <sys/types.h>
 974 #endif
 975 #include <netinet/in.h>])
 976
 977 AC_MSG_CHECKING(for __libc_stack_end)
 978 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
 979 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>
 980 extern char *__libc_stack_end;]],
 981    [[printf("%p", (char*) __libc_stack_end);]])],
 982    [guile_cv_have_libc_stack_end=yes],
 983    [guile_cv_have_libc_stack_end=no])])
 984 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
 985
 986 if test $guile_cv_have_libc_stack_end = yes; then
 987   AC_DEFINE([HAVE_LIBC_STACK_END], 1,
 988            [Define if you have the __libc_stack_end variable.])
 989 fi
 990
 991 dnl Some systems do not declare this.  Some systems do declare it, as a
 992 dnl macro.  With cygwin it may be in a DLL.
 993
 994 AC_MSG_CHECKING(whether netdb.h declares h_errno)
 995 AC_CACHE_VAL(guile_cv_have_h_errno,
 996   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]],
 997                                       [[int a = h_errno;]])],
 998   [guile_cv_have_h_errno=yes],
 999   [guile_cv_have_h_errno=no])])
1000 AC_MSG_RESULT($guile_cv_have_h_errno)
1001 if test $guile_cv_have_h_errno = yes; then
1002   AC_DEFINE([HAVE_H_ERRNO], 1, [Define if h_errno is declared in netdb.h.])
1003 fi
1004
1005 AC_MSG_CHECKING(whether uint32_t is defined)
1006 AC_CACHE_VAL(guile_cv_have_uint32_t,
1007   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
1008                    #if HAVE_STDINT_H
1009                    #include <stdint.h>
1010                    #endif
1011                    #ifndef HAVE_NETDB_H
1012                    #include <netdb.h>
1013                    #endif]],
1014                    [[uint32_t a;]])],
1015                    [guile_cv_have_uint32_t=yes],
1016                    [guile_cv_have_uint32_t=no])])
1017 AC_MSG_RESULT($guile_cv_have_uint32_t)
1018 if test $guile_cv_have_uint32_t = yes; then
1019   AC_DEFINE([HAVE_UINT32_T], 1,
1020     [Define if uint32_t typedef is defined when netdb.h is include.])
1021 fi
1022
1023 AC_MSG_CHECKING(for working IPv6 support)
1024 AC_CACHE_VAL(guile_cv_have_ipv6,
1025 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1026 #ifdef HAVE_SYS_TYPES_H
1027 #include <sys/types.h>
1028 #endif
1029 #include <netinet/in.h>
1030 #include <sys/socket.h>]],
1031 [[struct sockaddr_in6 a;  a.sin6_family = AF_INET6;]])],
1032 [guile_cv_have_ipv6=yes],
1033 [guile_cv_have_ipv6=no])])
1034 AC_MSG_RESULT($guile_cv_have_ipv6)
1035 if test $guile_cv_have_ipv6 = yes; then
1036   AC_DEFINE([HAVE_IPV6], 1, [Define if you want support for IPv6.])
1037 fi
1038
1039 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
1040 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
1041 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
1042 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1043 #ifdef HAVE_SYS_TYPES_H
1044 #include <sys/types.h>
1045 #endif
1046 #include <netinet/in.h>]],
1047 [[struct sockaddr_in6 sok;  sok.sin6_scope_id = 0;]])],
1048 [guile_cv_have_sin6_scope_id=yes],
1049 [guile_cv_have_sin6_scope_id=no])])
1050 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
1051 if test $guile_cv_have_sin6_scope_id = yes; then
1052   AC_DEFINE([HAVE_SIN6_SCOPE_ID], 1,
1053     [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
1054 fi
1055
1056 # struct sockaddr_in6 field sin_len is only present on BSD systems
1057 AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,,
1058 [#ifdef HAVE_SYS_TYPES_H
1059 #include <sys/types.h>
1060 #endif
1061 #include <netinet/in.h>])
1062
1063 AC_MSG_CHECKING(whether localtime caches TZ)
1064 AC_CACHE_VAL(guile_cv_localtime_cache,
1065 [if test x$ac_cv_func_tzset = xyes; then
1066 AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <time.h>
1067 #if STDC_HEADERS
1068 # include <stdlib.h>
1069 #endif
1070 extern char **environ;
1071 unset_TZ ()
1072 {
1073   char **from, **to;
1074   for (to = from = environ; (*to = *from); from++)
1075     if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
1076       to++;
1077 }
1078 char TZ_GMT0[] = "TZ=GMT0";
1079 char TZ_PST8[] = "TZ=PST8";
1080 main()
1081 {
1082   time_t now = time ((time_t *) 0);
1083   int hour_GMT0, hour_unset;
1084   if (putenv (TZ_GMT0) != 0)
1085     exit (1);
1086   hour_GMT0 = localtime (&now)->tm_hour;
1087   unset_TZ ();
1088   hour_unset = localtime (&now)->tm_hour;
1089   if (putenv (TZ_PST8) != 0)
1090     exit (1);
1091   if (localtime (&now)->tm_hour == hour_GMT0)
1092     exit (1);
1093   unset_TZ ();
1094   if (localtime (&now)->tm_hour != hour_unset)
1095     exit (1);
1096   exit (0);
1097 }]])],
1098 [guile_cv_localtime_cache=no],
1099 [guile_cv_localtime_cache=yes],
1100 [# If we have tzset, assume the worst when cross-compiling.
1101 guile_cv_localtime_cache=yes])
1102 else
1103         # If we lack tzset, report that localtime does not cache TZ,
1104         # since we can't invalidate the cache if we don't have tzset.
1105         guile_cv_localtime_cache=no
1106 fi])dnl
1107 AC_MSG_RESULT($guile_cv_localtime_cache)
1108 if test $guile_cv_localtime_cache = yes; then
1109   AC_DEFINE([LOCALTIME_CACHE], 1, [Define if localtime caches the TZ setting.])
1110 fi
1111
1112 if test "$enable_regex" = yes; then
1113    if test "$ac_cv_header_regex_h" = yes ||
1114       test "$ac_cv_header_rxposix_h" = yes ||
1115       test "$ac_cv_header_rx_rxposix_h" = yes; then
1116      GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
1117      [AC_CHECK_LIB(rx, main)
1118       GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
1119      [AC_CHECK_LIB(regex, main)
1120       GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
1121      )
1122      dnl The following should not be necessary, but for some reason
1123      dnl autoheader misses it if we don't include it!
1124      if test "$ac_cv_func_regcomp_norx" = yes ||
1125         test "$ac_cv_func_regcomp_regex" = yes ||
1126         test "$ac_cv_func_regcomp_rx" = yes; then
1127        AC_DEFINE([HAVE_REGCOMP], 1,
1128          [This is included as part of a workaround for a autoheader bug.])
1129      fi
1130    fi
1131 fi
1132
1133 AC_REPLACE_FUNCS([strerror memmove mkstemp])
1134
1135 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
1136
1137 # Reasons for testing:
1138 #   asinh, acosh, atanh, trunc - C99 standard, generally not available on
1139 #                                older systems
1140 #   sincos - GLIBC extension
1141 #
1142 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
1143
1144 # C99 specifies isinf and isnan as macros.
1145 # HP-UX provides only macros, no functions.
1146 # glibc 2.3.2 provides both macros and functions.
1147 # IRIX 6.5 and Solaris 8 only provide functions.
1148 #
1149 # The following tests detect isinf and isnan either as functions or as
1150 # macros from <math.h>.  Plain AC_CHECK_FUNCS is insufficient, it doesn't
1151 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
1152 #
1153 AC_MSG_CHECKING([for isinf])
1154 AC_LINK_IFELSE(AC_LANG_SOURCE(
1155 [[#include <math.h>
1156 volatile double x = 0.0;
1157 int main () { return (isinf(x) != 0); }]]),
1158   [AC_MSG_RESULT([yes])
1159    AC_DEFINE([HAVE_ISINF], 1,
1160              [Define to 1 if you have the `isinf' macro or function.])],
1161   [AC_MSG_RESULT([no])])
1162 AC_MSG_CHECKING([for isnan])
1163 AC_LINK_IFELSE(AC_LANG_SOURCE(
1164 [[#include <math.h>
1165 volatile double x = 0.0;
1166 int main () { return (isnan(x) != 0); }]]),
1167   [AC_MSG_RESULT([yes])
1168    AC_DEFINE([HAVE_ISNAN], 1,
1169              [Define to 1 if you have the `isnan' macro or function.])],
1170   [AC_MSG_RESULT([no])])
1171
1172 # Reasons for checking:
1173 #
1174 #     st_rdev
1175 #     st_blksize
1176 #     st_blocks   not in mingw
1177 #     tm_gmtoff   BSD+GNU, not in C99
1178 #
1179 # Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the
1180 # AC_LIBOBJ(fileblocks) replacement which that macro gives.
1181 #
1182 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],,,
1183                  [#define _GNU_SOURCE
1184 AC_INCLUDES_DEFAULT
1185 ])
1186
1187 AC_STRUCT_TIMEZONE
1188 AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,
1189 [#include <time.h>
1190 #ifdef TIME_WITH_SYS_TIME
1191 # include <sys/time.h>
1192 # include <time.h>
1193 #else
1194 # if HAVE_SYS_TIME_H
1195 #  include <sys/time.h>
1196 # else
1197 #  include <time.h>
1198 # endif
1199 #endif
1200 ])
1201 GUILE_STRUCT_UTIMBUF
1202
1203
1204 #--------------------------------------------------------------------
1205 #
1206 # Which way does the stack grow?
1207 #
1208 # Following code comes from Autoconf 2.61's internal _AC_LIBOBJ_ALLOCA
1209 # macro (/usr/share/autoconf/autoconf/functions.m4).  Gnulib has
1210 # very similar code, so in future we could look at using that.
1211 #
1212 # An important detail is that the code involves find_stack_direction
1213 # calling _itself_ - which means that find_stack_direction (or at
1214 # least the second find_stack_direction() call) cannot be inlined.
1215 # If the code could be inlined, that might cause the test to give
1216 # an incorrect answer.
1217 #--------------------------------------------------------------------
1218
1219 SCM_I_GSC_STACK_GROWS_UP=0
1220 AC_RUN_IFELSE([AC_LANG_SOURCE(
1221 [AC_INCLUDES_DEFAULT
1222 int
1223 find_stack_direction ()
1224 {
1225   static char *addr = 0;
1226   auto char dummy;
1227   if (addr == 0)
1228     {
1229       addr = &dummy;
1230       return find_stack_direction ();
1231     }
1232   else
1233     return (&dummy > addr) ? 1 : -1;
1234 }
1235
1236 int
1237 main ()
1238 {
1239   return find_stack_direction () < 0;
1240 }])],
1241                [SCM_I_GSC_STACK_GROWS_UP=1],
1242                [],
1243                [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])
1244
1245 #--------------------------------------------------------------------
1246 #
1247 # Boehm's GC library
1248 #
1249 #--------------------------------------------------------------------
1250 PKG_CHECK_MODULES([BDW_GC], [bdw-gc])
1251
1252 CFLAGS="$BDW_GC_CFLAGS $CFLAGS"
1253 LIBS="$BDW_GC_LIBS $LIBS"
1254
1255 # `GC_do_blocking ()' is available in GC 7.1 but not declared.
1256 AC_CHECK_FUNCS([GC_do_blocking])
1257 AC_CHECK_DECL([GC_do_blocking],
1258   [AC_DEFINE([HAVE_DECL_GC_DO_BLOCKING], [1],
1259     [Define this if the `GC_do_blocking ()' function is declared])],
1260   [],
1261   [#include <gc/gc.h>])
1262
1263 # `GC_fn_type' is not available in GC 7.1 and earlier.
1264 AC_CHECK_TYPE([GC_fn_type],
1265   [AC_DEFINE([HAVE_GC_FN_TYPE], [1],
1266     [Define this if the `GC_fn_type' type is available.])],
1267   [],
1268   [#include <gc/gc.h>])
1269
1270
1271 AC_CHECK_SIZEOF(float)
1272 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1273     AC_DEFINE([SCM_SINGLES], 1,
1274               [Define this if floats are the same size as longs.])
1275 fi
1276
1277 AC_MSG_CHECKING(for struct linger)
1278 AC_CACHE_VAL(scm_cv_struct_linger,
1279         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1280 #include <sys/types.h>
1281 #include <sys/socket.h>]],
1282                           [[struct linger lgr;  lgr.l_linger = 100]])],
1283                           [scm_cv_struct_linger="yes"],
1284                           [scm_cv_struct_linger="no"]))
1285 AC_MSG_RESULT($scm_cv_struct_linger)
1286 if test $scm_cv_struct_linger = yes; then
1287         AC_DEFINE([HAVE_STRUCT_LINGER], 1,
1288           [Define this if your system defines struct linger, for use with the
1289            getsockopt and setsockopt system calls.])
1290 fi
1291
1292
1293 # On mingw, struct timespec is in <pthread.h>.
1294 #
1295 AC_MSG_CHECKING(for struct timespec)
1296 AC_CACHE_VAL(scm_cv_struct_timespec,
1297         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1298 #include <time.h>
1299 #if HAVE_PTHREAD_H
1300 #include <pthread.h>
1301 #endif]], [[struct timespec t;  t.tv_nsec = 100]])],
1302           [scm_cv_struct_timespec="yes"],
1303           [scm_cv_struct_timespec="no"]))
1304 AC_MSG_RESULT($scm_cv_struct_timespec)
1305 if test $scm_cv_struct_timespec = yes; then
1306   AC_DEFINE([HAVE_STRUCT_TIMESPEC], 1,
1307     [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1308 fi
1309
1310 #--------------------------------------------------------------------
1311 #
1312 # Flags for thread support
1313 #
1314 #--------------------------------------------------------------------
1315
1316 SCM_I_GSC_USE_PTHREAD_THREADS=0
1317 SCM_I_GSC_USE_NULL_THREADS=0
1318 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1319 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1320
1321 ### What thread package has the user asked for?
1322 AC_ARG_WITH(threads, [  --with-threads          thread interface],
1323             , with_threads=yes)
1324
1325 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1326 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER, 0)
1327
1328 case "$with_threads" in
1329   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1330
1331     build_pthread_support="yes"
1332
1333     ACX_PTHREAD([CC="$PTHREAD_CC"
1334        LIBS="$PTHREAD_LIBS $LIBS"
1335        SCM_I_GSC_USE_PTHREAD_THREADS=1
1336        with_threads="pthreads"],
1337       [with_threads="null"
1338        build_pthread_support="no"])
1339
1340     old_CFLAGS="$CFLAGS"
1341     CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1342
1343     # Reasons for testing:
1344     #     pthread_getattr_np - "np" meaning "non portable" says it
1345     #         all; not present on MacOS X or Solaris 10
1346     #     pthread_get_stackaddr_np - "np" meaning "non portable" says it
1347     #         all; specific to MacOS X
1348     #     pthread_sigmask - not available on mingw
1349     #
1350     AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1351
1352     # On past versions of Solaris, believe 8 through 10 at least, you
1353     # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1354     # This is contrary to POSIX:
1355     # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1356     # Check here if this style is required.
1357     #
1358     # glibc (2.3.6 at least) works both with or without braces, so the
1359     # test checks whether it works without.
1360     #
1361
1362     if test "$GCC" = "yes"; then
1363       # Since GCC only issues a warning for missing braces, so we need
1364       # `-Werror' to catch it.
1365       CFLAGS="-Werror -Wmissing-braces $CFLAGS"
1366     fi
1367
1368     AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1369       guile_cv_need_braces_on_pthread_once_init,
1370       [AC_COMPILE_IFELSE([#include <pthread.h>
1371          pthread_once_t foo = PTHREAD_ONCE_INIT;],
1372         [guile_cv_need_braces_on_pthread_once_init=no],
1373         [guile_cv_need_braces_on_pthread_once_init=yes])])
1374     if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1375       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1376     fi
1377
1378     # Same problem with `PTHREAD_MUTEX_INITIALIZER', e.g., on IRIX
1379     # 6.5.30m with GCC 3.3.
1380     AC_CACHE_CHECK([whether PTHREAD_MUTEX_INITIALIZER needs braces],
1381       guile_cv_need_braces_on_pthread_mutex_initializer,
1382       [AC_COMPILE_IFELSE([#include <pthread.h>
1383          pthread_mutex_t foo = PTHREAD_MUTEX_INITIALIZER;],
1384         [guile_cv_need_braces_on_pthread_mutex_initializer=no],
1385         [guile_cv_need_braces_on_pthread_mutex_initializer=yes])])
1386     if test "$guile_cv_need_braces_on_pthread_mutex_initializer" = yes; then
1387       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER=1
1388     fi
1389
1390     CFLAGS="$old_CFLAGS"
1391
1392     # On Solaris, sched_yield lives in -lrt.
1393     AC_SEARCH_LIBS(sched_yield, rt)
1394
1395   ;;
1396 esac
1397
1398 case "$with_threads" in
1399   "pthreads")
1400   ;;
1401   "no" | "null")
1402     SCM_I_GSC_USE_NULL_THREADS=1
1403     SCM_I_GSC_HAVE_THREAD_STORAGE_CLASS=0
1404     with_threads="null-threads"
1405   ;;
1406   * )
1407     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1408   ;;
1409 esac
1410
1411 AC_MSG_CHECKING(what kind of threads to support)
1412 AC_MSG_RESULT($with_threads)
1413
1414 AM_CONDITIONAL([BUILD_PTHREAD_SUPPORT],
1415   [test "x$build_pthread_support" = "xyes"])
1416
1417
1418 ## Check whether pthread_attr_getstack works for the main thread
1419
1420 if test "$with_threads" = pthreads; then
1421
1422 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1423 old_CFLAGS="$CFLAGS"
1424 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1425 AC_RUN_IFELSE([AC_LANG_SOURCE([[
1426 #if HAVE_PTHREAD_ATTR_GETSTACK
1427 #include <pthread.h>
1428
1429 int main ()
1430 {
1431   pthread_attr_t attr;
1432   void *start, *end;
1433   size_t size;
1434
1435   pthread_getattr_np (pthread_self (), &attr);
1436   pthread_attr_getstack (&attr, &start, &size);
1437   end = (char *)start + size;
1438
1439   if ((void *)&attr < start || (void *)&attr >= end)
1440     return 1;
1441   else
1442     return 0;
1443 }
1444 #else
1445 int main ()
1446 {
1447   return 1;
1448 }
1449 #endif
1450 ]])],
1451 [works=yes
1452 AC_DEFINE([PTHREAD_ATTR_GETSTACK_WORKS], [1], [Define when pthread_att_get_stack works for the main thread])],
1453 [works=no],
1454 [])
1455 CFLAGS="$old_CFLAGS"
1456 AC_MSG_RESULT($works)
1457
1458 GUILE_THREAD_LOCAL_STORAGE
1459
1460 fi # with_threads=pthreads
1461
1462
1463 ## Cross building
1464 if test "$cross_compiling" = "yes"; then
1465   AC_MSG_CHECKING(cc for build)
1466   ## /usr/bin/cc still uses wrong assembler
1467   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1468   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1469 else
1470   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1471 fi
1472
1473 ## AC_MSG_CHECKING("if we are cross compiling")
1474 ## AC_MSG_RESULT($cross_compiling)
1475 if test "$cross_compiling" = "yes"; then
1476    AC_MSG_RESULT($CC_FOR_BUILD)
1477 fi
1478
1479 ## No need as yet to be more elaborate
1480 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1481
1482 AC_SUBST(cross_compiling)
1483 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1484 AC_SUBST(CCLD_FOR_BUILD)
1485
1486 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1487 ## --HOST is the platform that PACKAGE is compiled for.
1488 HOST_CC="$CC_FOR_BUILD"
1489 AC_SUBST(HOST_CC)
1490
1491 if test "$cross_compiling" = "yes"; then
1492   AC_MSG_CHECKING(guile for build)
1493   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1494 else
1495   GUILE_FOR_BUILD='$(preinstguile)'
1496 fi
1497
1498 ## AC_MSG_CHECKING("if we are cross compiling")
1499 ## AC_MSG_RESULT($cross_compiling)
1500 if test "$cross_compiling" = "yes"; then
1501    AC_MSG_RESULT($GUILE_FOR_BUILD)
1502 fi
1503 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1504 AC_SUBST(GUILE_FOR_BUILD)
1505
1506 ## If we're using GCC, ask for aggressive warnings.
1507 GCC_CFLAGS=""
1508 case "$GCC" in
1509   yes )
1510     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1511     ## much stuff with generic function pointers for that to really be
1512     ## less than exasperating.
1513     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1514     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1515     POTENTIAL_GCC_CFLAGS="-Wall -Wmissing-prototypes \
1516       -Wdeclaration-after-statement -Wundef \
1517       -Wswitch-enum"
1518     # Do this here so we don't screw up any of the tests above that might
1519     # not be "warning free"
1520     if test "${GUILE_ERROR_ON_WARNING}" = yes
1521     then
1522         POTENTIAL_GCC_CFLAGS="${POTENTIAL_GCC_CFLAGS} -Werror"
1523         enable_compile_warnings=no
1524     fi
1525
1526     for flag in $POTENTIAL_GCC_CFLAGS
1527     do
1528         gl_WARN_ADD([$flag], [GCC_CFLAGS])
1529     done
1530     ;;
1531 esac
1532
1533 AC_SUBST(GCC_CFLAGS)
1534
1535 # Check for GNU ld's "-z relro".
1536 GUILE_GNU_LD_RELRO
1537
1538
1539 ## If we're creating a shared library (using libtool!), then we'll
1540 ## need to generate a list of .lo files corresponding to the .o files
1541 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1542 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1543
1544 ## We also need to create corresponding .doc and .x files
1545 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1546 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1547
1548 # GNU Readline bindings.
1549 GUILE_READLINE
1550
1551 AC_SUBST(GUILE_MAJOR_VERSION)
1552 AC_SUBST(GUILE_MINOR_VERSION)
1553 AC_SUBST(GUILE_MICRO_VERSION)
1554 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1555 AC_SUBST(GUILE_VERSION)
1556
1557 #######################################################################
1558 # library versioning
1559
1560 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1561 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1562 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1563 AC_SUBST(LIBGUILE_INTERFACE)
1564
1565 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1566 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1567 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1568 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1569 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1570
1571 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1572 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1573 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1574 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1575 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1576
1577 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1578 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1579 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1580 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1581 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1582
1583 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1584 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1585 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1586 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1587 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1588
1589 AC_SUBST(LIBGUILE_I18N_MAJOR)
1590 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1591 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1592 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1593 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1594
1595
1596 #######################################################################
1597
1598 dnl Tell guile-config what flags guile users should compile and link with.
1599 GUILE_LIBS="$LDFLAGS $LIBS"
1600 GUILE_CFLAGS="$CPPFLAGS $PTHREAD_CFLAGS"
1601 AC_SUBST(GUILE_LIBS)
1602 AC_SUBST(GUILE_CFLAGS)
1603
1604 AC_SUBST(AWK)
1605 AC_SUBST(LIBLOBJS)
1606 AC_SUBST(EXTRA_DOT_DOC_FILES)
1607 AC_SUBST(EXTRA_DOT_X_FILES)
1608
1609 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1610 top_builddir_absolute=`pwd`
1611 AC_SUBST(top_builddir_absolute)
1612 top_srcdir_absolute=`(cd $srcdir && pwd)`
1613 AC_SUBST(top_srcdir_absolute)
1614
1615 dnl We need `sitedir' in `guile-1.8.pc'.
1616 dnl Note: `sitedir' must be kept in sync with `GUILE_SITE_DIR' in `guile.m4'.
1617 pkgdatadir="$datadir/$PACKAGE_TARNAME"
1618 sitedir="$pkgdatadir/site"
1619 AC_SUBST([sitedir])
1620
1621 # Additional SCM_I_GSC definitions are above.
1622 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1623 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1624 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1625 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1626 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1627 AC_SUBST([SCM_I_GSC_C_INLINE])
1628 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1629
1630 AC_CONFIG_FILES([
1631   Makefile
1632   am/Makefile
1633   lib/Makefile
1634   benchmark-suite/Makefile
1635   doc/Makefile
1636   doc/r5rs/Makefile
1637   doc/ref/Makefile
1638   emacs/Makefile
1639   examples/Makefile
1640   libguile/Makefile
1641   srfi/Makefile
1642   guile-readline/Makefile
1643   test-suite/Makefile
1644   test-suite/standalone/Makefile
1645   meta/Makefile
1646   module/Makefile
1647   testsuite/Makefile
1648 ])
1649
1650 AC_CONFIG_FILES([meta/guile-2.0.pc])
1651 AC_CONFIG_FILES([meta/guile-2.0-uninstalled.pc])
1652 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1653 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1654 AC_CONFIG_FILES([meta/guile], [chmod +x meta/guile])
1655 AC_CONFIG_FILES([meta/uninstalled-env], [chmod +x meta/uninstalled-env])
1656 AC_CONFIG_FILES([meta/gdb-uninstalled-guile], [chmod +x meta/gdb-uninstalled-guile])
1657 AC_CONFIG_FILES([meta/guile-tools], [chmod +x meta/guile-tools])
1658 AC_CONFIG_FILES([libguile/guile-snarf],
1659                 [chmod +x libguile/guile-snarf])
1660 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1661                 [chmod +x libguile/guile-doc-snarf])
1662 AC_CONFIG_FILES([libguile/guile-func-name-check],
1663                 [chmod +x libguile/guile-func-name-check])
1664 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1665                 [chmod +x libguile/guile-snarf-docs])
1666 AC_CONFIG_FILES([test-suite/standalone/test-use-srfi],
1667                 [chmod +x test-suite/standalone/test-use-srfi])
1668 AC_CONFIG_FILES([test-suite/standalone/test-fast-slot-ref],
1669                 [chmod +x test-suite/standalone/test-fast-slot-ref])
1670 AC_CONFIG_FILES([doc/ref/effective-version.texi])
1671
1672 AC_OUTPUT
1673
1674 dnl Local Variables:
1675 dnl comment-start: "dnl "
1676 dnl comment-end: ""
1677 dnl comment-start-skip: "\\bdnl\\b\\s *"
1678 dnl End: