configure.ac

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