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 AC_CHECK_SIZEOF(float)
1171 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1172     AC_DEFINE(SCM_SINGLES, 1,
1173               [Define this if floats are the same size as longs.])
1174 fi
1175
1176 AC_MSG_CHECKING(for struct linger)
1177 AC_CACHE_VAL(scm_cv_struct_linger,
1178         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1179 #include <sys/types.h>
1180 #include <sys/socket.h>]],
1181                           [[struct linger lgr;  lgr.l_linger = 100]])],
1182                           [scm_cv_struct_linger="yes"],
1183                           [scm_cv_struct_linger="no"]))
1184 AC_MSG_RESULT($scm_cv_struct_linger)
1185 if test $scm_cv_struct_linger = yes; then
1186         AC_DEFINE(HAVE_STRUCT_LINGER, 1,
1187           [Define this if your system defines struct linger, for use with the
1188            getsockopt and setsockopt system calls.])
1189 fi
1190
1191
1192 # On mingw, struct timespec is in <pthread.h>.
1193 #
1194 AC_MSG_CHECKING(for struct timespec)
1195 AC_CACHE_VAL(scm_cv_struct_timespec,
1196         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1197 #include <time.h>
1198 #if HAVE_PTHREAD_H
1199 #include <pthread.h>
1200 #endif]], [[struct timespec t;  t.tv_nsec = 100]])],
1201           [scm_cv_struct_timespec="yes"],
1202           [scm_cv_struct_timespec="no"]))
1203 AC_MSG_RESULT($scm_cv_struct_timespec)
1204 if test $scm_cv_struct_timespec = yes; then
1205   AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1,
1206     [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1207 fi
1208
1209 #--------------------------------------------------------------------
1210 #
1211 # Flags for thread support
1212 #
1213 #--------------------------------------------------------------------
1214
1215 SCM_I_GSC_USE_PTHREAD_THREADS=0
1216 SCM_I_GSC_USE_NULL_THREADS=0
1217 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1218 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1219
1220 ### What thread package has the user asked for?
1221 AC_ARG_WITH(threads, [  --with-threads          thread interface],
1222             , with_threads=yes)
1223
1224 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1225 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER, 0)
1226
1227 case "$with_threads" in
1228   "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1229
1230     build_pthread_support="yes"
1231
1232     ACX_PTHREAD([CC="$PTHREAD_CC"
1233        LIBS="$PTHREAD_LIBS $LIBS"
1234        SCM_I_GSC_USE_PTHREAD_THREADS=1
1235        with_threads="pthreads"],
1236       [with_threads="null"
1237        build_pthread_support="no"])
1238
1239     old_CFLAGS="$CFLAGS"
1240     CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1241
1242     # Reasons for testing:
1243     #     pthread_getattr_np - "np" meaning "non portable" says it
1244     #         all; not present on MacOS X or Solaris 10
1245     #     pthread_get_stackaddr_np - "np" meaning "non portable" says it
1246     #         all; specific to MacOS X
1247     #     pthread_sigmask - not available on mingw
1248     #
1249     AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1250
1251     # On past versions of Solaris, believe 8 through 10 at least, you
1252     # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1253     # This is contrary to POSIX:
1254     # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1255     # Check here if this style is required.
1256     #
1257     # glibc (2.3.6 at least) works both with or without braces, so the
1258     # test checks whether it works without.
1259     #
1260
1261     if test "$GCC" = "yes"; then
1262       # Since GCC only issues a warning for missing braces, so we need
1263       # `-Werror' to catch it.
1264       CFLAGS="-Werror -Wmissing-braces $CFLAGS"
1265     fi
1266
1267     AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1268       guile_cv_need_braces_on_pthread_once_init,
1269       [AC_COMPILE_IFELSE([#include <pthread.h>
1270          pthread_once_t foo = PTHREAD_ONCE_INIT;],
1271         [guile_cv_need_braces_on_pthread_once_init=no],
1272         [guile_cv_need_braces_on_pthread_once_init=yes])])
1273     if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1274       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1275     fi
1276
1277     # Same problem with `PTHREAD_MUTEX_INITIALIZER', e.g., on IRIX
1278     # 6.5.30m with GCC 3.3.
1279     AC_CACHE_CHECK([whether PTHREAD_MUTEX_INITIALIZER needs braces],
1280       guile_cv_need_braces_on_pthread_mutex_initializer,
1281       [AC_COMPILE_IFELSE([#include <pthread.h>
1282          pthread_mutex_t foo = PTHREAD_MUTEX_INITIALIZER;],
1283         [guile_cv_need_braces_on_pthread_mutex_initializer=no],
1284         [guile_cv_need_braces_on_pthread_mutex_initializer=yes])])
1285     if test "$guile_cv_need_braces_on_pthread_mutex_initializer" = yes; then
1286       SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER=1
1287     fi
1288
1289     CFLAGS="$old_CFLAGS"
1290
1291     # On Solaris, sched_yield lives in -lrt.
1292     AC_SEARCH_LIBS(sched_yield, rt)
1293
1294   ;;
1295 esac
1296
1297 case "$with_threads" in
1298   "pthreads")
1299   ;;
1300   "no" | "null")
1301     SCM_I_GSC_USE_NULL_THREADS=1
1302     with_threads="null-threads"
1303   ;;
1304   * )
1305     AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1306   ;;
1307 esac
1308
1309 AC_MSG_CHECKING(what kind of threads to support)
1310 AC_MSG_RESULT($with_threads)
1311
1312 AM_CONDITIONAL([BUILD_PTHREAD_SUPPORT],
1313   [test "x$build_pthread_support" = "xyes"])
1314
1315
1316 ## Check whether pthread_attr_getstack works for the main thread
1317
1318 if test "$with_threads" = pthreads; then
1319
1320 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1321 old_CFLAGS="$CFLAGS"
1322 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1323 AC_RUN_IFELSE([AC_LANG_SOURCE([[
1324 #if HAVE_PTHREAD_ATTR_GETSTACK
1325 #include <pthread.h>
1326
1327 int main ()
1328 {
1329   pthread_attr_t attr;
1330   void *start, *end;
1331   size_t size;
1332
1333   pthread_getattr_np (pthread_self (), &attr);
1334   pthread_attr_getstack (&attr, &start, &size);
1335   end = (char *)start + size;
1336
1337   if ((void *)&attr < start || (void *)&attr >= end)
1338     return 1;
1339   else
1340     return 0;
1341 }
1342 #else
1343 int main ()
1344 {
1345   return 1;
1346 }
1347 #endif
1348 ]])],
1349 [works=yes
1350 AC_DEFINE(PTHREAD_ATTR_GETSTACK_WORKS, [1], [Define when pthread_att_get_stack works for the main thread])],
1351 [works=no],
1352 [])
1353 CFLAGS="$old_CFLAGS"
1354 AC_MSG_RESULT($works)
1355
1356 fi # with_threads=pthreads
1357
1358
1359 ## Cross building
1360 if test "$cross_compiling" = "yes"; then
1361   AC_MSG_CHECKING(cc for build)
1362   ## /usr/bin/cc still uses wrong assembler
1363   ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1364   CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1365 else
1366   CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1367 fi
1368
1369 ## AC_MSG_CHECKING("if we are cross compiling")
1370 ## AC_MSG_RESULT($cross_compiling)
1371 if test "$cross_compiling" = "yes"; then
1372    AC_MSG_RESULT($CC_FOR_BUILD)
1373 fi
1374
1375 ## No need as yet to be more elaborate
1376 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1377
1378 AC_SUBST(cross_compiling)
1379 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1380 AC_SUBST(CCLD_FOR_BUILD)
1381
1382 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1383 ## --HOST is the platform that PACKAGE is compiled for.
1384 HOST_CC="$CC_FOR_BUILD"
1385 AC_SUBST(HOST_CC)
1386
1387 if test "$cross_compiling" = "yes"; then
1388   AC_MSG_CHECKING(guile for build)
1389   GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1390 else
1391   GUILE_FOR_BUILD='$(preinstguile)'
1392 fi
1393
1394 ## AC_MSG_CHECKING("if we are cross compiling")
1395 ## AC_MSG_RESULT($cross_compiling)
1396 if test "$cross_compiling" = "yes"; then
1397    AC_MSG_RESULT($GUILE_FOR_BUILD)
1398 fi
1399 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1400 AC_SUBST(GUILE_FOR_BUILD)
1401
1402 ## If we're using GCC, ask for aggressive warnings.
1403 case "$GCC" in
1404   yes )
1405     ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1406     ## much stuff with generic function pointers for that to really be
1407     ## less than exasperating.
1408     ## -Wpointer-arith was here too, but something changed in gcc/glibc
1409     ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1410     GCC_CFLAGS="-Wall -Wmissing-prototypes"
1411     # Do this here so we don't screw up any of the tests above that might
1412     # not be "warning free"
1413     if test "${GUILE_ERROR_ON_WARNING}" = yes
1414     then
1415         GCC_CFLAGS="${GCC_CFLAGS} -Werror"
1416         enable_compile_warnings=no
1417     fi
1418     ;;
1419 esac
1420
1421 AC_SUBST(GCC_CFLAGS)
1422
1423 ## If we're creating a shared library (using libtool!), then we'll
1424 ## need to generate a list of .lo files corresponding to the .o files
1425 ## given in LIBOBJS.  We'll call it LIBLOBJS.
1426 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1427
1428 ## We also need to create corresponding .doc and .x files
1429 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1430 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1431
1432 # GNU Readline bindings.
1433 GUILE_READLINE
1434
1435 AC_SUBST(GUILE_MAJOR_VERSION)
1436 AC_SUBST(GUILE_MINOR_VERSION)
1437 AC_SUBST(GUILE_MICRO_VERSION)
1438 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1439 AC_SUBST(GUILE_VERSION)
1440
1441 #######################################################################
1442 # library versioning
1443
1444 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1445 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1446 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1447 AC_SUBST(LIBGUILE_INTERFACE)
1448
1449 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1450 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1451 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1452 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1453 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1454
1455 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1456 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1457 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1458 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1459 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1460
1461 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1462 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1463 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1464 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1465 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1466
1467 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1468 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1469 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1470 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1471 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1472
1473 AC_SUBST(LIBGUILE_I18N_MAJOR)
1474 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1475 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1476 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1477 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1478
1479
1480 #######################################################################
1481
1482 dnl Tell guile-config what flags guile users should compile and link with.
1483 GUILE_LIBS="$LDFLAGS $LIBS"
1484 GUILE_CFLAGS="$CPPFLAGS $PTHREAD_CFLAGS"
1485 AC_SUBST(GUILE_LIBS)
1486 AC_SUBST(GUILE_CFLAGS)
1487
1488 AC_SUBST(AWK)
1489 AC_SUBST(LIBLOBJS)
1490 AC_SUBST(EXTRA_DOT_DOC_FILES)
1491 AC_SUBST(EXTRA_DOT_X_FILES)
1492
1493 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1494 top_builddir_absolute=`pwd`
1495 AC_SUBST(top_builddir_absolute)
1496 top_srcdir_absolute=`(cd $srcdir && pwd)`
1497 AC_SUBST(top_srcdir_absolute)
1498
1499 dnl We need `sitedir' in `guile-1.8.pc'.
1500 dnl Note: `sitedir' must be kept in sync with `GUILE_SITE_DIR' in `guile.m4'.
1501 pkgdatadir="$datadir/guile"
1502 sitedir="$pkgdatadir/site"
1503 AC_SUBST([sitedir])
1504
1505 # Additional SCM_I_GSC definitions are above.
1506 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1507 AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
1508 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1509 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1510 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1511 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1512 AC_SUBST([SCM_I_GSC_C_INLINE])
1513 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1514
1515 AC_CONFIG_FILES([
1516   Makefile
1517   am/Makefile
1518   lib/Makefile
1519   benchmark-suite/Makefile
1520   doc/Makefile
1521   doc/goops/Makefile
1522   doc/r5rs/Makefile
1523   doc/ref/Makefile
1524   doc/tutorial/Makefile
1525   emacs/Makefile
1526   examples/Makefile
1527   lang/Makefile
1528   libguile/Makefile
1529   srfi/Makefile
1530   guile-readline/Makefile
1531   guile-readline/ice-9/Makefile
1532   test-suite/Makefile
1533   test-suite/standalone/Makefile
1534   meta/Makefile
1535   module/Makefile
1536   testsuite/Makefile
1537 ])
1538
1539 AC_CONFIG_FILES([meta/guile-2.0.pc])
1540 AC_CONFIG_FILES([meta/guile-2.0-uninstalled.pc])
1541 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1542 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1543 AC_CONFIG_FILES([meta/guile], [chmod +x meta/guile])
1544 AC_CONFIG_FILES([meta/uninstalled-env], [chmod +x meta/uninstalled-env])
1545 AC_CONFIG_FILES([meta/gdb-uninstalled-guile], [chmod +x meta/gdb-uninstalled-guile])
1546 AC_CONFIG_FILES([meta/guile-tools], [chmod +x meta/guile-tools])
1547 AC_CONFIG_FILES([libguile/guile-snarf],
1548                 [chmod +x libguile/guile-snarf])
1549 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1550                 [chmod +x libguile/guile-doc-snarf])
1551 AC_CONFIG_FILES([libguile/guile-func-name-check],
1552                 [chmod +x libguile/guile-func-name-check])
1553 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1554                 [chmod +x libguile/guile-snarf-docs])
1555 AC_CONFIG_FILES([test-suite/standalone/test-use-srfi],
1556                 [chmod +x test-suite/standalone/test-use-srfi])
1557 AC_CONFIG_FILES([test-suite/standalone/test-fast-slot-ref],
1558                 [chmod +x test-suite/standalone/test-fast-slot-ref])
1559
1560 AC_OUTPUT
1561
1562 dnl Local Variables:
1563 dnl comment-start: "dnl "
1564 dnl comment-end: ""
1565 dnl comment-start-skip: "\\bdnl\\b\\s *"
1566 dnl End: