configure.in

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