configure.ac

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