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