configure.in

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