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