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