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