configure.ac

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