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