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