1 dnl configuration script for Guile
2 dnl Process this file with autoconf to produce configure.
5 define(GUILE_CONFIGURE_COPYRIGHT,[[
7 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
9 This file is part of GUILE
11 GUILE is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your
14 option) any later version.
16 GUILE is distributed in the hope that it will be useful, but
17 WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GUILE; see the file COPYING. If not, write to the
23 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA.
30 dnl `patsubst' here deletes the newline which "echo" prints. We can't use
31 dnl "echo -n" since -n is not portable (see autoconf manual "Limitations of
32 dnl Builtins"), in particular on solaris it results in a literal "-n" in
35 AC_INIT(patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${PACKAGE}),[
37 patsubst(m4_esyscmd(. ./GUILE-VERSION && echo ${GUILE_VERSION}),[
40 AC_CONFIG_AUX_DIR([build-aux])
41 AC_CONFIG_MACRO_DIR([m4])
42 AC_CONFIG_SRCDIR(GUILE-VERSION)
44 AM_INIT_AUTOMAKE([gnu no-define check-news -Wall -Wno-override])
46 AC_COPYRIGHT(GUILE_CONFIGURE_COPYRIGHT)
47 AC_CONFIG_SRCDIR([GUILE-VERSION])
49 . $srcdir/GUILE-VERSION
52 AC_CONFIG_HEADERS([config.h])
53 AH_TOP(/*GUILE_CONFIGURE_COPYRIGHT*/)
55 #--------------------------------------------------------------------
57 # Independent Subdirectories
59 #--------------------------------------------------------------------
61 AC_CONFIG_SUBDIRS(guile-readline)
63 #--------------------------------------------------------------------
67 dnl Some more checks for Win32
83 # for per-target cflags in the libguile subdir
88 AC_CHECK_LIB([ltdl], [lt_dlinit], ,
89 [AC_MSG_ERROR([libltdl not found. See README.])])
93 AC_CHECK_PROG(have_makeinfo, makeinfo, yes, no)
94 AM_CONDITIONAL(HAVE_MAKEINFO, test "$have_makeinfo" = yes)
98 #--------------------------------------------------------------------
100 # User options (after above tests that may set default CFLAGS etc.)
102 #--------------------------------------------------------------------
104 GUILE_ERROR_ON_WARNING="yes"
106 AC_ARG_ENABLE(error-on-warning,
107 [ --enable-error-on-warning treat compile warnings as errors],
108 [case "${enableval}" in
109 yes | y) GUILE_ERROR_ON_WARNING="yes" ;;
110 no | n) GUILE_ERROR_ON_WARNING="no" ;;
111 *) AC_MSG_ERROR(bad value ${enableval} for --enable-error-on-warning) ;;
114 SCM_I_GSC_GUILE_DEBUG_FREELIST=0
115 AC_ARG_ENABLE(debug-freelist,
116 [ --enable-debug-freelist include garbage collector freelist debugging code],
117 if test "$enable_debug_freelist" = y \
118 || test "$enable_debug_freelist" = yes; then
119 SCM_I_GSC_GUILE_DEBUG_FREELIST=1
122 AC_ARG_ENABLE(debug-malloc,
123 [ --enable-debug-malloc include malloc debugging code],
124 if test "$enable_debug_malloc" = y || test "$enable_debug_malloc" = yes; then
125 AC_DEFINE(GUILE_DEBUG_MALLOC, 1,
126 [Define this if you want to debug scm_must_malloc/realloc/free calls.])
129 SCM_I_GSC_GUILE_DEBUG=0
130 AC_ARG_ENABLE(guile-debug,
131 [AS_HELP_STRING([--enable-guile-debug],
132 [include internal debugging functions])],
133 if test "$enable_guile_debug" = y || test "$enable_guile_debug" = yes; then
134 SCM_I_GSC_GUILE_DEBUG=1
138 [ --disable-posix omit posix interfaces],,
141 AC_ARG_ENABLE(networking,
142 [ --disable-networking omit networking interfaces],,
143 enable_networking=yes)
146 [ --disable-regex omit regular expression interfaces],,
149 AC_ARG_ENABLE([discouraged],
150 AS_HELP_STRING([--disable-discouraged],[omit discouraged features]))
152 if test "$enable_discouraged" = no; then
153 SCM_I_GSC_ENABLE_DISCOURAGED=0
155 SCM_I_GSC_ENABLE_DISCOURAGED=1
158 AC_ARG_ENABLE([deprecated],
159 AS_HELP_STRING([--disable-deprecated],[omit deprecated features]))
161 if test "$enable_deprecated" = no; then
162 SCM_I_GSC_ENABLE_DEPRECATED=0
164 if test "$enable_deprecated" = yes || test "$enable_deprecated" = ""; then
166 elif test "$enable_deprecated" = shutup; then
169 warn_default=$enable_deprecated
171 SCM_I_GSC_ENABLE_DEPRECATED=1
172 AC_DEFINE_UNQUOTED(SCM_WARN_DEPRECATED_DEFAULT, "$warn_default",
173 [Define this to control the default warning level for deprecated features.])
177 [ --disable-elisp omit Emacs Lisp support],,
180 dnl Added the following configure option in January 2008 following
181 dnl investigation of problems with "64" system and library calls on
182 dnl Darwin (MacOS X). The libguile code (_scm.h) assumes that if a
183 dnl system has stat64, it will have all the other 64 APIs too; but on
184 dnl Darwin, stat64 is there but other APIs are missing.
186 dnl It also appears, from the Darwin docs, that most system call APIs
187 dnl there (i.e. the traditional ones _without_ "64" in their names) have
188 dnl been 64-bit-capable for a long time now, so it isn't necessary to
189 dnl use "64" versions anyway. For example, Darwin's off_t is 64-bit.
191 dnl A similar problem has been reported for HP-UX:
192 dnl http://www.nabble.com/Building-guile-1.8.2-on-hpux-td13106681.html
194 dnl Therefore, and also because a Guile without LARGEFILE64 support is
195 dnl better than no Guile at all, we provide this option to suppress
196 dnl trying to use "64" calls.
198 dnl It may be that for some 64-bit function on Darwin/HP-UX we do need
199 dnl to use a "64" call, and hence that by using --without-64-calls we're
200 dnl missing out on that. If so, someone can work on that in the future.
201 dnl For now, --without-64-calls allows Guile to build on OSs where it
202 dnl wasn't building before.
203 AC_MSG_CHECKING([whether to use system and library "64" calls])
204 AC_ARG_WITH([64-calls],
205 AS_HELP_STRING([--without-64-calls],
206 [don't attempt to use system and library calls with "64" in their names]),
207 [use_64_calls=$withval],
217 AC_MSG_RESULT($use_64_calls)
218 case "$use_64_calls" in
220 AC_DEFINE(GUILE_USE_64_CALLS, 1,
221 [Define to 1 in order to try to use "64" versions of system and library calls.])
225 #--------------------------------------------------------------------
227 dnl Check for dynamic linking
231 [ --with-modules[=FILES] Add support for dynamic modules],
232 use_modules="$withval")
233 test -z "$use_modules" && use_modules=yes
235 if test "$use_modules" != no; then
236 if test "$use_modules" = yes; then
237 DLPREOPEN="-dlpreopen force"
239 DLPREOPEN="-export-dynamic"
240 for module in $use_modules; do
241 DLPREOPEN="$DLPREOPEN -dlopen $module"
246 dnl files which are destined for separate modules.
248 if test "$use_modules" != no; then
252 if test "$enable_posix" = yes; then
255 AC_DEFINE(HAVE_POSIX, 1,
256 [Define this if you want support for POSIX system calls in Guile.])
259 if test "$enable_networking" = yes; then
262 AC_DEFINE(HAVE_NETWORKING, 1,
263 [Define this if you want support for networking in Guile.])
266 if test "$enable_debug_malloc" = yes; then
267 AC_LIBOBJ([debug-malloc])
270 if test "$enable_elisp" = yes; then
271 SCM_I_GSC_ENABLE_ELISP=1
273 SCM_I_GSC_ENABLE_ELISP=0
275 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
279 # "volatile" is used in a couple of tests below.
283 if test "$ac_cv_c_inline" != no; then
284 SCM_I_GSC_C_INLINE="\"${ac_cv_c_inline}\""
286 SCM_I_GSC_C_INLINE=NULL
288 AC_CHECK_LIB(uca, __uc_get_ar_bsp)
292 AC_CHECK_SIZEOF(char)
293 AC_CHECK_SIZEOF(unsigned char)
294 AC_CHECK_SIZEOF(short)
295 AC_CHECK_SIZEOF(unsigned short)
297 AC_CHECK_SIZEOF(unsigned int)
298 AC_CHECK_SIZEOF(long)
299 AC_CHECK_SIZEOF(unsigned long)
300 AC_CHECK_SIZEOF(size_t)
301 AC_CHECK_SIZEOF(long long)
302 AC_CHECK_SIZEOF(unsigned long long)
303 AC_CHECK_SIZEOF(__int64)
304 AC_CHECK_SIZEOF(unsigned __int64)
305 AC_CHECK_SIZEOF(void *)
306 AC_CHECK_SIZEOF(intptr_t)
307 AC_CHECK_SIZEOF(uintptr_t)
308 AC_CHECK_SIZEOF(ptrdiff_t)
309 AC_CHECK_SIZEOF(size_t)
310 AC_CHECK_SIZEOF(off_t)
312 if test "$ac_cv_sizeof_long" -ne "$ac_cv_sizeof_void_p"; then
313 AC_MSG_ERROR(sizes of long and void* are not identical)
316 if test "$ac_cv_sizeof_ptrdiff_t" -ne 0; then
317 SCM_I_GSC_T_PTRDIFF='"ptrdiff_t"'
319 SCM_I_GSC_T_PTRDIFF='"long"'
321 AC_SUBST([SCM_I_GSC_T_PTRDIFF])
323 AC_CHECK_HEADERS([stdint.h])
324 AC_CHECK_HEADERS([inttypes.h])
326 AC_CHECK_SIZEOF(intmax_t)
328 SCM_I_GSC_NEEDS_STDINT_H=0
329 SCM_I_GSC_NEEDS_INTTYPES_H=0
331 ### intptr and uintptr (try not to use inttypes if we don't have to)
332 if test "$ac_cv_header_inttypes_h" = yes; then
333 if test "$ac_cv_sizeof_intptr_t" -eq 0; then
334 AC_CHECK_SIZEOF([intptr_t],,[#include <inttypes.h>
336 if test "$ac_cv_sizeof_intptr_t" -ne 0; then
337 SCM_I_GSC_NEEDS_INTTYPES_H=1
340 if test "$ac_cv_sizeof_uintptr_t" -eq 0; then
341 AC_CHECK_SIZEOF([uintptr_t],,[#include <inttypes.h>
343 if test "$ac_cv_sizeof_uintptr_t" -ne 0; then
344 SCM_I_GSC_NEEDS_INTTYPES_H=1
349 ### See what's provided by stdint.h
350 if test "$ac_cv_header_stdint_h" = yes; then
351 AC_CHECK_TYPE([int8_t],[scm_stdint_has_int8=1],,[#include <stdint.h>])
352 AC_CHECK_TYPE([uint8_t],[scm_stdint_has_uint8=1],,[#include <stdint.h>])
353 AC_CHECK_TYPE([int16_t],[scm_stdint_has_int16=1],,[#include <stdint.h>])
354 AC_CHECK_TYPE([uint16_t],[scm_stdint_has_uint16=1],,[#include <stdint.h>])
355 AC_CHECK_TYPE([int32_t],[scm_stdint_has_int32=1],,[#include <stdint.h>])
356 AC_CHECK_TYPE([uint32_t],[scm_stdint_has_uint32=1],,[#include <stdint.h>])
357 AC_CHECK_TYPE([int64_t],[scm_stdint_has_int64=1],,[#include <stdint.h>])
358 AC_CHECK_TYPE([uint64_t],[scm_stdint_has_uint64=1],,[#include <stdint.h>])
359 AC_CHECK_TYPE([intmax_t],[scm_stdint_has_intmax=1],,[#include <stdint.h>])
360 AC_CHECK_TYPE([uintmax_t],[scm_stdint_has_uintmax=1],,[#include <stdint.h>])
363 # so we don't get confused by the cache (wish there was a better way
364 # to check particular headers for the same type...)
366 unset ac_cv_type_int8_t
367 unset ac_cv_type_uint8_t
368 unset ac_cv_type_int16_t
369 unset ac_cv_type_uint16_t
370 unset ac_cv_type_int32_t
371 unset ac_cv_type_uint32_t
372 unset ac_cv_type_int64_t
373 unset ac_cv_type_uint64_t
374 unset ac_cv_type_intmax_t
375 unset ac_cv_type_uintmax_t
377 ### See what's provided by inttypes.h
378 if test "$ac_cv_header_inttypes_h" = yes; then
379 AC_CHECK_TYPE([int8_t],[scm_inttypes_has_int8=1],,[#include <inttypes.h>])
380 AC_CHECK_TYPE([uint8_t],[scm_inttypes_has_uint8=1],,[#include <inttypes.h>])
381 AC_CHECK_TYPE([int16_t],[scm_inttypes_has_int16=1],,[#include <inttypes.h>])
382 AC_CHECK_TYPE([uint16_t],[scm_inttypes_has_uint16=1],,[#include <inttypes.h>])
383 AC_CHECK_TYPE([int32_t],[scm_inttypes_has_int32=1],,[#include <inttypes.h>])
384 AC_CHECK_TYPE([uint32_t],[scm_inttypes_has_uint32=1],,[#include <inttypes.h>])
385 AC_CHECK_TYPE([int64_t],[scm_inttypes_has_int64=1],,[#include <inttypes.h>])
386 AC_CHECK_TYPE([uint64_t],[scm_inttypes_has_uint64=1],,[#include <inttypes.h>])
387 AC_CHECK_TYPE([intmax_t],[scm_inttypes_has_intmax=1],,[#include <inttypes.h>])
388 AC_CHECK_TYPE([uintmax_t],[scm_inttypes_has_uintmax=1],,[#include <inttypes.h>])
391 # Try hard to find definitions for some required scm_t_*int* types.
393 ### Required type scm_t_int8
394 if test "$scm_stdint_has_int8"; then
395 SCM_I_GSC_T_INT8='"int8_t"'
396 SCM_I_GSC_NEEDS_STDINT_H=1
397 elif test "$scm_inttypes_has_int8"; then
398 SCM_I_GSC_T_INT8='"int8_t"'
399 SCM_I_GSC_NEEDS_INTTYPES_H=1
400 elif test "$ac_cv_sizeof_char" -eq 1; then
401 SCM_I_GSC_T_INT8='"signed char"'
403 AC_MSG_ERROR([Can't find appropriate type for scm_t_int8.])
405 AC_SUBST([SCM_I_GSC_T_INT8])
407 ### Required type scm_t_uint8
408 if test "$scm_stdint_has_uint8"; then
409 SCM_I_GSC_T_UINT8='"uint8_t"'
410 SCM_I_GSC_NEEDS_STDINT_H=1
411 elif test "$scm_inttypes_has_uint8"; then
412 SCM_I_GSC_T_UINT8='"uint8_t"'
413 SCM_I_GSC_NEEDS_INTTYPES_H=1
414 elif test "$ac_cv_sizeof_unsigned_char" -eq 1; then
415 SCM_I_GSC_T_UINT8='"unsigned char"'
417 AC_MSG_ERROR([Can't find appropriate type for scm_t_uint8.])
419 AC_SUBST([SCM_I_GSC_T_UINT8])
421 ### Required type scm_t_int16 (ANSI C says int or short might work)
422 if test "$scm_stdint_has_int16"; then
423 SCM_I_GSC_T_INT16='"int16_t"'
424 SCM_I_GSC_NEEDS_STDINT_H=1
425 elif test "$scm_inttypes_has_int16"; then
426 SCM_I_GSC_T_INT16='"int16_t"'
427 SCM_I_GSC_NEEDS_INTTYPES_H=1
428 elif test "$ac_cv_sizeof_int" -eq 2; then
429 SCM_I_GSC_T_INT16='"int"'
430 elif test "$ac_cv_sizeof_short" -eq 2; then
431 SCM_I_GSC_T_INT16='"short"'
433 AC_MSG_ERROR([Can't find appropriate type for scm_t_int16.])
435 AC_SUBST([SCM_I_GSC_T_INT16])
437 ### Required type scm_t_uint16 (ANSI C says int or short might work)
438 if test "$scm_stdint_has_uint16"; then
439 SCM_I_GSC_T_UINT16='"uint16_t"'
440 SCM_I_GSC_NEEDS_STDINT_H=1
441 elif test "$scm_inttypes_has_uint16"; then
442 SCM_I_GSC_T_UINT16='"uint16_t"'
443 SCM_I_GSC_NEEDS_INTTYPES_H=1
444 elif test "$ac_cv_sizeof_unsigned_int" -eq 2; then
445 SCM_I_GSC_T_UINT16='"unsigned int"'
446 elif test "$ac_cv_sizeof_unsigned_short" -eq 2; then
447 SCM_I_GSC_T_UINT16='"unsigned short"'
449 AC_MSG_ERROR([Can't find appropriate type for scm_t_uint16.])
451 AC_SUBST([SCM_I_GSC_T_UINT16])
454 ### Required type scm_t_int32 (ANSI C says int, short, or long might work)
455 if test "$scm_stdint_has_int32"; then
456 SCM_I_GSC_T_INT32='"int32_t"'
457 SCM_I_GSC_NEEDS_STDINT_H=1
458 elif test "$scm_inttypes_has_int32"; then
459 SCM_I_GSC_T_INT32='"int32_t"'
460 SCM_I_GSC_NEEDS_INTTYPES_H=1
461 elif test "$ac_cv_sizeof_int" -eq 4; then
462 SCM_I_GSC_T_INT32='"int"'
463 elif test "$ac_cv_sizeof_long" -eq 4; then
464 SCM_I_GSC_T_INT32='"long"'
465 elif test "$ac_cv_sizeof_short" -eq 4; then
466 SCM_I_GSC_T_INT32='"short"'
468 AC_MSG_ERROR([Can't find appropriate type for scm_t_int32.])
470 AC_SUBST([SCM_I_GSC_T_INT32])
472 ### Required type scm_t_uint32 (ANSI C says int, short, or long might work)
473 if test "$scm_stdint_has_uint32"; then
474 SCM_I_GSC_T_UINT32='"uint32_t"'
475 SCM_I_GSC_NEEDS_STDINT_H=1
476 elif test "$scm_inttypes_has_uint32"; then
477 SCM_I_GSC_T_UINT32='"uint32_t"'
478 SCM_I_GSC_NEEDS_INTTYPES_H=1
479 elif test "$ac_cv_sizeof_unsigned_int" -eq 4; then
480 SCM_I_GSC_T_UINT32='"unsigned int"'
481 elif test "$ac_cv_sizeof_unsigned_long" -eq 4; then
482 SCM_I_GSC_T_UINT32='"unsigned long"'
483 elif test "$ac_cv_sizeof_unsigned_short" -eq 4; then
484 SCM_I_GSC_T_UINT32='"unsigned short"'
486 AC_MSG_ERROR([Can't find appropriate type for scm_t_uint32.])
488 AC_SUBST([SCM_I_GSC_T_UINT32])
490 ### Optional type scm_t_int64 (ANSI C says int, short, or long might work)
491 ### Also try 'long long' and '__int64' if we have it.
493 if test "$scm_stdint_has_int64"; then
494 SCM_I_GSC_T_INT64='"int64_t"'
495 SCM_I_GSC_NEEDS_STDINT_H=1
496 elif test "$scm_inttypes_has_int64"; then
497 SCM_I_GSC_T_INT64='"int64_t"'
498 SCM_I_GSC_NEEDS_INTTYPES_H=1
499 elif test "$ac_cv_sizeof_int" -eq 8; then
500 SCM_I_GSC_T_INT64='"int"'
501 elif test "$ac_cv_sizeof_long" -eq 8; then
502 SCM_I_GSC_T_INT64='"long"'
503 elif test "$ac_cv_sizeof_short" -eq 8; then
504 SCM_I_GSC_T_INT64='"short"'
505 elif test "$ac_cv_sizeof_long_long" -eq 8; then
506 SCM_I_GSC_T_INT64='"long long"'
507 elif test "$ac_cv_sizeof___int64" -eq 8; then
508 SCM_I_GSC_T_INT64='"__int64"'
510 AC_MSG_ERROR([Can't find appropriate type for scm_t_int64.])
512 AC_SUBST([SCM_I_GSC_T_INT64])
515 ### Optional type scm_t_uint64 (ANSI C says int, short, or long might work)
516 ### Also try 'long long' and '__int64' if we have it.
518 if test "$scm_stdint_has_uint64"; then
519 SCM_I_GSC_T_UINT64='"uint64_t"'
520 SCM_I_GSC_NEEDS_STDINT_H=1
521 elif test "$scm_inttypes_has_uint64"; then
522 SCM_I_GSC_T_UINT64='"uint64_t"'
523 SCM_I_GSC_NEEDS_INTTYPES_H=1
524 elif test "$ac_cv_sizeof_unsigned_int" -eq 8; then
525 SCM_I_GSC_T_UINT64='"unsigned int"'
526 elif test "$ac_cv_sizeof_unsigned_long" -eq 8; then
527 SCM_I_GSC_T_UINT64='"unsigned long"'
528 elif test "$ac_cv_sizeof_unsigned_short" -eq 8; then
529 SCM_I_GSC_T_UINT64='"unsigned short"'
530 elif test "$ac_cv_sizeof_unsigned_long_long" -eq 8; then
531 SCM_I_GSC_T_UINT64='"unsigned long long"'
532 elif test "$ac_cv_sizeof_unsigned___int64" -eq 8; then
533 SCM_I_GSC_T_UINT64='"unsigned __int64"'
535 AC_MSG_ERROR([Can't find appropriate type for scm_t_uint64.])
537 AC_SUBST([SCM_I_GSC_T_UINT64])
539 ### Required type scm_t_intmax
541 ### We try 'intmax_t', '__int64', 'long long' in this order. When
542 ### none of them is available, we use 'long'.
545 if test "$scm_stdint_has_intmax"; then
546 SCM_I_GSC_T_INTMAX='"intmax_t"'
547 SCM_I_GSC_NEEDS_STDINT_H=1
548 elif test "$scm_inttypes_has_intmax"; then
549 SCM_I_GSC_T_INTMAX='"intmax_t"'
550 SCM_I_GSC_NEEDS_INTTYPES_H=1
551 elif test "$ac_cv_sizeof___int64" -ne 0; then
552 SCM_I_GSC_T_INTMAX='"__int64"'
553 elif test "$ac_cv_sizeof_long_long" -ne 0; then
554 SCM_I_GSC_T_INTMAX='"long long"'
556 SCM_I_GSC_T_INTMAX='"long"'
558 AC_SUBST([SCM_I_GSC_T_INTMAX])
560 ### Required type scm_t_uintmax
562 ### We try 'uintmax_t', 'unsigned __int64', 'unsigned long long' in
563 ### this order. When none of them is available, we use 'unsigned long'.
565 SCM_I_GSC_T_UINTMAX=0
566 if test "$scm_stdint_has_uintmax"; then
567 SCM_I_GSC_T_UINTMAX='"uintmax_t"'
568 SCM_I_GSC_NEEDS_STDINT_H=1
569 elif test "$scm_inttypes_has_uintmax"; then
570 SCM_I_GSC_T_UINTMAX='"uintmax_t"'
571 SCM_I_GSC_NEEDS_INTTYPES_H=1
572 elif test "$ac_cv_sizeof_unsigned___int64" -ne 0; then
573 SCM_I_GSC_T_UINTMAX='"unsigned __int64"'
574 elif test "$ac_cv_sizeof_unsigned_long_long" -ne 0; then
575 SCM_I_GSC_T_UINTMAX='"unsigned long long"'
577 SCM_I_GSC_T_UINTMAX='"unsigned long"'
579 AC_SUBST([SCM_I_GSC_T_UINTMAX])
582 AC_SUBST([SCM_I_GSC_NEEDS_STDINT_H])
583 AC_SUBST([SCM_I_GSC_NEEDS_INTTYPES_H])
590 # Reasons for testing:
591 # complex.h - new in C99
592 # fenv.h - available in C99, but not older systems
593 # process.h - mingw specific
594 # langinfo.h, nl_types.h - SuS v2
596 AC_CHECK_HEADERS([complex.h fenv.h io.h libc.h limits.h malloc.h memory.h process.h string.h \
597 regex.h rxposix.h rx/rxposix.h sys/dir.h sys/ioctl.h sys/select.h \
598 sys/time.h sys/timeb.h sys/times.h sys/stdtypes.h sys/types.h \
599 sys/utime.h time.h unistd.h utime.h pwd.h grp.h sys/utsname.h \
600 direct.h langinfo.h nl_types.h])
602 # "complex double" is new in C99, and "complex" is only a keyword if
603 # <complex.h> is included
604 AC_CHECK_TYPES(complex double,,,
609 # On MacOS X <sys/socklen.h> contains socklen_t, so must include that
611 AC_CHECK_TYPE(socklen_t, ,
612 [AC_DEFINE_UNQUOTED(socklen_t, int,
613 [Define to `int' if <sys/socket.h> does not define.])],
614 [#if HAVE_SYS_TYPES_H
615 #include <sys/types.h>
617 #include <sys/socket.h>
619 AC_CHECK_TYPE(struct ip_mreq)
621 GUILE_HEADER_LIBC_WITH_UNISTD
627 # On mingw -lm is empty, so this test is unnecessary, but it's
628 # harmless so we don't hard-code to suppress it.
632 AC_CHECK_FUNCS(gethostbyname)
633 if test $ac_cv_func_gethostbyname = no; then
634 AC_CHECK_LIB(nsl, gethostbyname)
637 AC_CHECK_FUNCS(connect)
638 if test $ac_cv_func_connect = no; then
639 AC_CHECK_LIB(socket, connect)
643 dnl Check for Winsock and other functionality on Win32 (*not* CygWin)
648 AC_CHECK_HEADER(winsock2.h, [AC_DEFINE([HAVE_WINSOCK2_H], 1,
649 [Define if you have the <winsock2.h> header file.])])
650 AC_CHECK_LIB(ws2_32, main)
651 AC_LIBOBJ([win32-uname])
652 AC_LIBOBJ([win32-dirent])
653 if test "$enable_networking" = yes ; then
654 AC_LIBOBJ([win32-socket])
656 if test "$enable_shared" = yes ; then
657 EXTRA_DEFS="-DSCM_IMPORT"
658 AC_DEFINE(USE_DLL_IMPORT, 1,
659 [Define if you need additional CPP macros on Win32 platforms.])
665 # Reasons for testing:
666 # crt_externs.h - Darwin specific
668 AC_CHECK_HEADERS([assert.h crt_externs.h])
670 # Reasons for testing:
671 # DINFINITY - OSF specific
672 # DQNAN - OSF specific
673 # (DINFINITY and DQNAN are actually global variables, not functions)
674 # chsize - an MS-DOS-ism, found in mingw
675 # cexp, clog - not in various pre-c99 systems, and note that it's possible
676 # for gcc to provide the "complex double" type but the system to not
677 # have functions like cexp and clog
678 # clog10 - not in mingw (though others like clog and csqrt are)
679 # fesetround - available in C99, but not older systems
680 # ftruncate - posix, but probably not older systems (current mingw
681 # has it as an inline for chsize)
682 # ioctl - not in mingw.
683 # gmtime_r - recent posix, not on old systems
684 # pipe - not in mingw
685 # _pipe - specific to mingw, taking 3 args
686 # readdir_r - recent posix, not on old systems
687 # stat64 - SuS largefile stuff, not on old systems
688 # sysconf - not on old systems
689 # truncate - not in mingw
690 # isblank - available as a GNU extension or in C99
691 # _NSGetEnviron - Darwin specific
692 # strcoll_l, newlocale - GNU extensions (glibc), also available on Darwin
693 # nl_langinfo - X/Open, not available on Windows.
695 AC_CHECK_FUNCS([DINFINITY DQNAN cexp chsize clog clog10 ctermid fesetround ftime ftruncate fchown getcwd geteuid gettimeofday gmtime_r ioctl lstat mkdir mknod nice pipe _pipe readdir_r readlink rename rmdir select setegid seteuid setlocale setpgid setsid sigaction siginterrupt stat64 strftime strptime symlink sync sysconf tcgetpgrp tcsetpgrp times uname waitpid strdup system usleep atexit on_exit chown link fcntl ttyname getpwent getgrent kill getppid getpgrp fork setitimer getitimer strchr strcmp index bcopy memcpy rindex truncate unsetenv isblank _NSGetEnviron strcoll strcoll_l newlocale nl_langinfo])
697 # Reasons for testing:
698 # netdb.h - not in mingw
699 # sys/param.h - not in mingw
700 # pthread.h - only available with pthreads. ACX_PTHREAD doesn't
701 # check this specifically, we need it for the timespec test below.
702 # sethostname - the function itself check because it's not in mingw,
703 # the DECL is checked because Solaris 10 doens't have in any header
704 # xlocale.h - needed on Darwin for the `locale_t' API
706 AC_CHECK_HEADERS(crypt.h netdb.h pthread.h sys/param.h sys/resource.h sys/file.h xlocale.h)
707 AC_CHECK_FUNCS(chroot flock getlogin cuserid getpriority setpriority getpass sethostname gethostname)
708 AC_CHECK_DECLS([sethostname])
710 # crypt() may or may not be available, for instance in some countries there
711 # are restrictions on cryptography.
713 # crypt() might be in libc (eg. OpenBSD), or it might be in a separate
714 # -lcrypt library (eg. Debian GNU/Linux).
716 # On HP-UX 11, crypt() is in libc and there's a dummy libcrypt.a. We must
717 # be careful to avoid -lcrypt in this case, since libtool will see there's
718 # only a static libcrypt and decide to build only a static libguile.
720 # AC_SEARCH_LIBS lets us add -lcrypt to LIBS only if crypt() is not in the
721 # libraries already in that list.
723 AC_SEARCH_LIBS(crypt, crypt,
724 [AC_DEFINE(HAVE_CRYPT,1,
725 [Define to 1 if you have the `crypt' function.])])
727 # When compiling with GCC on some OSs (Solaris, AIX), _Complex_I doesn't
728 # work; in the reported cases so far, 1.0fi works well instead. According
729 # to the C99 spec, the complex.h header must provide a working definition
730 # of _Complex_I, so we always try _Complex_I first. The 1.0fi fallback
731 # is a workaround for the failure of some systems to conform to C99.
732 if test "$ac_cv_type_complex_double" = yes; then
733 AC_MSG_CHECKING([for i])
734 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
742 [AC_DEFINE(GUILE_I,_Complex_I,[The imaginary unit (positive square root of -1).])
743 AC_MSG_RESULT([_Complex_I])],
744 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
752 [AC_DEFINE(GUILE_I,1.0fi)
753 AC_MSG_RESULT([1.0fi])],
754 [ac_cv_type_complex_double=no
755 AC_MSG_RESULT([not available])])])
758 # glibc 2.3.6 (circa 2006) and various prior versions had a bug where
759 # csqrt(-i) returned a negative real part, when it should be positive
760 # for the principal root.
762 if test "$ac_cv_type_complex_double" = yes; then
764 AC_CACHE_CHECK([whether csqrt is usable],
766 [AC_RUN_IFELSE([AC_LANG_SOURCE([[
768 /* "volatile" is meant to prevent gcc from calculating the sqrt as a
769 constant, we want to test libc. */
770 volatile complex double z = - _Complex_I;
780 [guile_cv_use_csqrt=yes],
781 [guile_cv_use_csqrt="no, glibc 2.3 bug"],
782 [guile_cv_use_csqrt="yes, hopefully (cross-compiling)"])])
783 case $guile_cv_use_csqrt in
785 AC_DEFINE(HAVE_USABLE_CSQRT, 1, [Define to 1 if csqrt is bug-free])
792 AC_CHECK_LIB([gmp], [__gmpz_init], ,
793 [AC_MSG_ERROR([GNU MP not found, see README])])
795 # mpz_import is a macro so we need to include <gmp.h>
796 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <gmp.h>]],
797 [[mpz_import (0, 0, 0, 0, 0, 0, 0); ]])],
799 [AC_MSG_ERROR([At least GNU MP 4.1 is required, see README])])
802 #AC_CHECK_HEADERS([libintl.h])
803 #AC_CHECK_FUNCS(gettext)
804 #if test $ac_cv_func_gettext = no; then
805 # AC_CHECK_LIB(intl, gettext)
807 #AC_CHECK_FUNCS([bindtextdomain textdomain])
808 AM_GNU_GETTEXT([external], [need-ngettext])
810 ### Some systems don't declare some functions. On such systems, we
811 ### need to at least provide our own K&R-style declarations.
813 ### GUILE_FUNC_DECLARED(function, headerfile)
815 ### Check for a declaration of FUNCTION in HEADERFILE; if it is
816 ### not there, #define MISSING_FUNCTION_DECL.
817 AC_DEFUN([GUILE_FUNC_DECLARED], [
818 AC_CACHE_CHECK(for $1 declaration, guile_cv_func_$1_declared,
819 AC_EGREP_HEADER($1, $2,
820 guile_cv_func_$1_declared=yes,
821 guile_cv_func_$1_declared=no))
822 if test [x$guile_cv_func_]$1[_declared] = xno; then
823 AC_DEFINE([MISSING_]translit($1, [a-z], [A-Z])[_DECL], 1,
824 [Define if the operating system supplies $1 without declaring it.])
828 GUILE_FUNC_DECLARED(sleep, unistd.h)
829 GUILE_FUNC_DECLARED(usleep, unistd.h)
831 AC_CHECK_DECLS([strptime],,,
832 [#define _GNU_SOURCE /* ask glibc to give strptime prototype */
835 ### On some systems usleep has no return value. If it does have one,
836 ### we'd like to return it; otherwise, we'll fake it.
837 AC_CACHE_CHECK([return type of usleep], guile_cv_func_usleep_return_type,
838 [AC_EGREP_HEADER(changequote(<, >)<void[ ]+usleep>changequote([, ]),
840 [guile_cv_func_usleep_return_type=void],
841 [guile_cv_func_usleep_return_type=int])])
842 case "$guile_cv_func_usleep_return_type" in
844 AC_DEFINE(USLEEP_RETURNS_VOID, 1,
845 [Define if the system headers declare usleep to return void.])
849 AC_CHECK_HEADER(sys/un.h, have_sys_un_h=1)
850 if test -n "$have_sys_un_h" ; then
851 AC_DEFINE(HAVE_UNIX_DOMAIN_SOCKETS, 1,
852 [Define if the system supports Unix-domain (file-domain) sockets.])
855 AC_CHECK_FUNCS(socketpair getgroups setgroups setpwent pause tzset)
857 AC_CHECK_FUNCS(sethostent gethostent endhostent dnl
858 setnetent getnetent endnetent dnl
859 setprotoent getprotoent endprotoent dnl
860 setservent getservent endservent dnl
861 getnetbyaddr getnetbyname dnl
862 inet_lnaof inet_makeaddr inet_netof hstrerror dnl
865 # struct sockaddr field sin_len is only present on BSD systems.
866 # On 4.4BSD apparently a #define SIN_LEN exists, but on other BSD systems
867 # (eg. FreeBSD 4.9) it doesn't and we must use this configure check
868 AC_CHECK_MEMBERS([struct sockaddr.sin_len],,,
869 [#ifdef HAVE_SYS_TYPES_H
870 #include <sys/types.h>
872 #include <netinet/in.h>])
874 AC_MSG_CHECKING(for __libc_stack_end)
875 AC_CACHE_VAL(guile_cv_have_libc_stack_end,
876 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stdio.h>
877 extern char *__libc_stack_end;]],
878 [[printf("%p", (char*) __libc_stack_end);]])],
879 [guile_cv_have_libc_stack_end=yes],
880 [guile_cv_have_libc_stack_end=no])])
881 AC_MSG_RESULT($guile_cv_have_libc_stack_end)
883 if test $guile_cv_have_libc_stack_end = yes; then
884 AC_DEFINE(HAVE_LIBC_STACK_END, 1,
885 [Define if you have the __libc_stack_end variable.])
888 dnl Some systems do not declare this. Some systems do declare it, as a
889 dnl macro. With cygwin it may be in a DLL.
891 AC_MSG_CHECKING(whether netdb.h declares h_errno)
892 AC_CACHE_VAL(guile_cv_have_h_errno,
893 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]],
894 [[int a = h_errno;]])],
895 [guile_cv_have_h_errno=yes],
896 [guile_cv_have_h_errno=no])])
897 AC_MSG_RESULT($guile_cv_have_h_errno)
898 if test $guile_cv_have_h_errno = yes; then
899 AC_DEFINE(HAVE_H_ERRNO, 1, [Define if h_errno is declared in netdb.h.])
902 AC_MSG_CHECKING(whether uint32_t is defined)
903 AC_CACHE_VAL(guile_cv_have_uint32_t,
904 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <sys/types.h>
912 [guile_cv_have_uint32_t=yes],
913 [guile_cv_have_uint32_t=no])])
914 AC_MSG_RESULT($guile_cv_have_uint32_t)
915 if test $guile_cv_have_uint32_t = yes; then
916 AC_DEFINE(HAVE_UINT32_T, 1,
917 [Define if uint32_t typedef is defined when netdb.h is include.])
920 AC_MSG_CHECKING(for working IPv6 support)
921 AC_CACHE_VAL(guile_cv_have_ipv6,
922 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
923 #ifdef HAVE_SYS_TYPES_H
924 #include <sys/types.h>
926 #include <netinet/in.h>
927 #include <sys/socket.h>]],
928 [[struct sockaddr_in6 a; a.sin6_family = AF_INET6;]])],
929 [guile_cv_have_ipv6=yes],
930 [guile_cv_have_ipv6=no])])
931 AC_MSG_RESULT($guile_cv_have_ipv6)
932 if test $guile_cv_have_ipv6 = yes; then
933 AC_DEFINE(HAVE_IPV6, 1, [Define if you want support for IPv6.])
936 # included in rfc2553 but not in older implementations, e.g., glibc 2.1.3.
937 AC_MSG_CHECKING(whether sockaddr_in6 has sin6_scope_id)
938 AC_CACHE_VAL(guile_cv_have_sin6_scope_id,
939 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
940 #ifdef HAVE_SYS_TYPES_H
941 #include <sys/types.h>
943 #include <netinet/in.h>]],
944 [[struct sockaddr_in6 sok; sok.sin6_scope_id = 0;]])],
945 [guile_cv_have_sin6_scope_id=yes],
946 [guile_cv_have_sin6_scope_id=no])])
947 AC_MSG_RESULT($guile_cv_have_sin6_scope_id)
948 if test $guile_cv_have_sin6_scope_id = yes; then
949 AC_DEFINE(HAVE_SIN6_SCOPE_ID, 1,
950 [Define this if your IPv6 has sin6_scope_id in sockaddr_in6 struct.])
953 # struct sockaddr_in6 field sin_len is only present on BSD systems
954 AC_CHECK_MEMBERS([struct sockaddr_in6.sin6_len],,,
955 [#ifdef HAVE_SYS_TYPES_H
956 #include <sys/types.h>
958 #include <netinet/in.h>])
960 AC_MSG_CHECKING(whether localtime caches TZ)
961 AC_CACHE_VAL(guile_cv_localtime_cache,
962 [if test x$ac_cv_func_tzset = xyes; then
963 AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <time.h>
967 extern char **environ;
971 for (to = from = environ; (*to = *from); from++)
972 if (! (to[0][0] == 'T' && to[0][1] == 'Z' && to[0][2] == '='))
975 char TZ_GMT0[] = "TZ=GMT0";
976 char TZ_PST8[] = "TZ=PST8";
979 time_t now = time ((time_t *) 0);
980 int hour_GMT0, hour_unset;
981 if (putenv (TZ_GMT0) != 0)
983 hour_GMT0 = localtime (&now)->tm_hour;
985 hour_unset = localtime (&now)->tm_hour;
986 if (putenv (TZ_PST8) != 0)
988 if (localtime (&now)->tm_hour == hour_GMT0)
991 if (localtime (&now)->tm_hour != hour_unset)
995 [guile_cv_localtime_cache=no],
996 [guile_cv_localtime_cache=yes],
997 [# If we have tzset, assume the worst when cross-compiling.
998 guile_cv_localtime_cache=yes])
1000 # If we lack tzset, report that localtime does not cache TZ,
1001 # since we can't invalidate the cache if we don't have tzset.
1002 guile_cv_localtime_cache=no
1004 AC_MSG_RESULT($guile_cv_localtime_cache)
1005 if test $guile_cv_localtime_cache = yes; then
1006 AC_DEFINE(LOCALTIME_CACHE, 1, [Define if localtime caches the TZ setting.])
1009 dnl Test whether system calls are restartable by default on the
1010 dnl current system. If they are not, we put a loop around every system
1011 dnl call to check for EINTR (see SCM_SYSCALL) and do not attempt to
1012 dnl change from the default behaviour. On the other hand, if signals
1013 dnl are restartable then the loop is not installed and when libguile
1014 dnl initialises it also resets the behaviour of each signal to cause a
1015 dnl restart (in case a different runtime had a different default
1016 dnl behaviour for some reason: e.g., different versions of linux seem
1017 dnl to behave differently.)
1019 AC_SYS_RESTARTABLE_SYSCALLS
1021 if test "$enable_regex" = yes; then
1022 if test "$ac_cv_header_regex_h" = yes ||
1023 test "$ac_cv_header_rxposix_h" = yes ||
1024 test "$ac_cv_header_rx_rxposix_h" = yes; then
1025 GUILE_NAMED_CHECK_FUNC(regcomp, norx, [AC_LIBOBJ([regex-posix])],
1026 [AC_CHECK_LIB(rx, main)
1027 GUILE_NAMED_CHECK_FUNC(regcomp, rx, [AC_LIBOBJ([regex-posix])],
1028 [AC_CHECK_LIB(regex, main)
1029 GUILE_NAMED_CHECK_FUNC(regcomp, regex, [AC_LIBOBJ([regex-posix])])])]
1031 dnl The following should not be necessary, but for some reason
1032 dnl autoheader misses it if we don't include it!
1033 if test "$ac_cv_func_regcomp_norx" = yes ||
1034 test "$ac_cv_func_regcomp_regex" = yes ||
1035 test "$ac_cv_func_regcomp_rx" = yes; then
1036 AC_DEFINE(HAVE_REGCOMP, 1,
1037 [This is included as part of a workaround for a autoheader bug.])
1042 AC_REPLACE_FUNCS(inet_aton putenv strerror memmove mkstemp)
1044 AC_CHECK_HEADERS(floatingpoint.h ieeefp.h nan.h)
1046 # Reasons for testing:
1047 # asinh, acosh, atanh, trunc - C99 standard, generally not available on
1049 # sincos - GLIBC extension
1051 AC_CHECK_FUNCS(asinh acosh atanh copysign finite sincos trunc)
1053 # C99 specifies isinf and isnan as macros.
1054 # HP-UX provides only macros, no functions.
1055 # glibc 2.3.2 provides both macros and functions.
1056 # IRIX 6.5 and Solaris 8 only provide functions.
1058 # The following tests detect isinf and isnan either as functions or as
1059 # macros from <math.h>. Plain AC_CHECK_FUNCS is insufficient, it doesn't
1060 # use <math.h> so doesn't detect on macro-only systems like HP-UX.
1062 AC_MSG_CHECKING([for isinf])
1063 AC_LINK_IFELSE(AC_LANG_SOURCE(
1065 volatile double x = 0.0;
1066 int main () { return (isinf(x) != 0); }]]),
1067 [AC_MSG_RESULT([yes])
1068 AC_DEFINE(HAVE_ISINF, 1,
1069 [Define to 1 if you have the `isinf' macro or function.])],
1070 [AC_MSG_RESULT([no])])
1071 AC_MSG_CHECKING([for isnan])
1072 AC_LINK_IFELSE(AC_LANG_SOURCE(
1074 volatile double x = 0.0;
1075 int main () { return (isnan(x) != 0); }]]),
1076 [AC_MSG_RESULT([yes])
1077 AC_DEFINE(HAVE_ISNAN, 1,
1078 [Define to 1 if you have the `isnan' macro or function.])],
1079 [AC_MSG_RESULT([no])])
1081 # Reasons for checking:
1085 # st_blocks not in mingw
1086 # tm_gmtoff BSD+GNU, not in C99
1088 # Note AC_STRUCT_ST_BLOCKS is not used here because we don't want the
1089 # AC_LIBOBJ(fileblocks) replacement which that macro gives.
1091 AC_CHECK_MEMBERS([struct stat.st_rdev, struct stat.st_blksize, struct stat.st_blocks])
1094 AC_CHECK_MEMBERS([struct tm.tm_gmtoff],,,
1096 #ifdef TIME_WITH_SYS_TIME
1097 # include <sys/time.h>
1100 # if HAVE_SYS_TIME_H
1101 # include <sys/time.h>
1107 GUILE_STRUCT_UTIMBUF
1110 #--------------------------------------------------------------------
1112 # Which way does the stack grow?
1114 # Following code comes from Autoconf 2.61's internal _AC_LIBOBJ_ALLOCA
1115 # macro (/usr/share/autoconf/autoconf/functions.m4). Gnulib has
1116 # very similar code, so in future we could look at using that.
1118 # An important detail is that the code involves find_stack_direction
1119 # calling _itself_ - which means that find_stack_direction (or at
1120 # least the second find_stack_direction() call) cannot be inlined.
1121 # If the code could be inlined, that might cause the test to give
1122 # an incorrect answer.
1123 #--------------------------------------------------------------------
1125 SCM_I_GSC_STACK_GROWS_UP=0
1126 AC_CACHE_CHECK([stack direction],
1127 [SCM_I_GSC_STACK_GROWS_UP],
1128 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1129 [AC_INCLUDES_DEFAULT
1131 find_stack_direction ()
1133 static char *addr = 0;
1138 return find_stack_direction ();
1141 return (&dummy > addr) ? 1 : -1;
1147 return find_stack_direction () < 0;
1149 [SCM_I_GSC_STACK_GROWS_UP=1],
1151 [AC_MSG_WARN(Guessing that stack grows down -- see scmconfig.h)])])
1153 AC_CHECK_SIZEOF(float)
1154 if test "$ac_cv_sizeof_float" -le "$ac_cv_sizeof_long"; then
1155 AC_DEFINE(SCM_SINGLES, 1,
1156 [Define this if floats are the same size as longs.])
1159 AC_MSG_CHECKING(for struct linger)
1160 AC_CACHE_VAL(scm_cv_struct_linger,
1161 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1162 #include <sys/types.h>
1163 #include <sys/socket.h>]],
1164 [[struct linger lgr; lgr.l_linger = 100]])],
1165 [scm_cv_struct_linger="yes"],
1166 [scm_cv_struct_linger="no"]))
1167 AC_MSG_RESULT($scm_cv_struct_linger)
1168 if test $scm_cv_struct_linger = yes; then
1169 AC_DEFINE(HAVE_STRUCT_LINGER, 1,
1170 [Define this if your system defines struct linger, for use with the
1171 getsockopt and setsockopt system calls.])
1175 # On mingw, struct timespec is in <pthread.h>.
1177 AC_MSG_CHECKING(for struct timespec)
1178 AC_CACHE_VAL(scm_cv_struct_timespec,
1179 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1182 #include <pthread.h>
1183 #endif]], [[struct timespec t; t.tv_nsec = 100]])],
1184 [scm_cv_struct_timespec="yes"],
1185 [scm_cv_struct_timespec="no"]))
1186 AC_MSG_RESULT($scm_cv_struct_timespec)
1187 if test $scm_cv_struct_timespec = yes; then
1188 AC_DEFINE(HAVE_STRUCT_TIMESPEC, 1,
1189 [Define this if your system defines struct timespec via either <time.h> or <pthread.h>.])
1192 #--------------------------------------------------------------------
1194 # Flags for thread support
1196 #--------------------------------------------------------------------
1198 SCM_I_GSC_USE_PTHREAD_THREADS=0
1199 SCM_I_GSC_USE_NULL_THREADS=0
1200 AC_SUBST([SCM_I_GSC_USE_PTHREAD_THREADS])
1201 AC_SUBST([SCM_I_GSC_USE_NULL_THREADS])
1203 ### What thread package has the user asked for?
1204 AC_ARG_WITH(threads, [ --with-threads thread interface],
1207 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT, 0)
1208 AC_SUBST(SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER, 0)
1210 case "$with_threads" in
1211 "yes" | "pthread" | "pthreads" | "pthread-threads" | "")
1213 build_pthread_support="yes"
1215 ACX_PTHREAD(CC="$PTHREAD_CC"
1216 LIBS="$PTHREAD_LIBS $LIBS"
1217 SCM_I_GSC_USE_PTHREAD_THREADS=1
1218 with_threads="pthreads",
1219 with_threads="null")
1221 old_CFLAGS="$CFLAGS"
1222 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1224 # Reasons for testing:
1225 # pthread_getattr_np - "np" meaning "non portable" says it
1226 # all; not present on MacOS X or Solaris 10
1227 # pthread_get_stackaddr_np - "np" meaning "non portable" says it
1228 # all; specific to MacOS X
1229 # pthread_sigmask - not available on mingw
1231 AC_CHECK_FUNCS(pthread_attr_getstack pthread_getattr_np pthread_get_stackaddr_np pthread_sigmask)
1233 # On past versions of Solaris, believe 8 through 10 at least, you
1234 # had to write "pthread_once_t foo = { PTHREAD_ONCE_INIT };".
1235 # This is contrary to POSIX:
1236 # http://www.opengroup.org/onlinepubs/000095399/functions/pthread_once.html
1237 # Check here if this style is required.
1239 # glibc (2.3.6 at least) works both with or without braces, so the
1240 # test checks whether it works without.
1243 if test "$GCC" = "yes"; then
1244 # Since GCC only issues a warning for missing braces, so we need
1245 # `-Werror' to catch it.
1246 CFLAGS="-Werror -Wmissing-braces $CFLAGS"
1249 AC_CACHE_CHECK([whether PTHREAD_ONCE_INIT needs braces],
1250 guile_cv_need_braces_on_pthread_once_init,
1251 [AC_COMPILE_IFELSE([#include <pthread.h>
1252 pthread_once_t foo = PTHREAD_ONCE_INIT;],
1253 [guile_cv_need_braces_on_pthread_once_init=no],
1254 [guile_cv_need_braces_on_pthread_once_init=yes])])
1255 if test "$guile_cv_need_braces_on_pthread_once_init" = yes; then
1256 SCM_I_GSC_NEED_BRACES_ON_PTHREAD_ONCE_INIT=1
1259 # Same problem with `PTHREAD_MUTEX_INITIALIZER', e.g., on IRIX
1260 # 6.5.30m with GCC 3.3.
1261 AC_CACHE_CHECK([whether PTHREAD_MUTEX_INITIALIZER needs braces],
1262 guile_cv_need_braces_on_pthread_mutex_initializer,
1263 [AC_COMPILE_IFELSE([#include <pthread.h>
1264 pthread_mutex_t foo = PTHREAD_MUTEX_INITIALIZER;],
1265 [guile_cv_need_braces_on_pthread_mutex_initializer=no],
1266 [guile_cv_need_braces_on_pthread_mutex_initializer=yes])])
1267 if test "$guile_cv_need_braces_on_pthread_mutex_initializer" = yes; then
1268 SCM_I_GSC_NEED_BRACES_ON_PTHREAD_MUTEX_INITIALIZER=1
1271 CFLAGS="$old_CFLAGS"
1273 # On Solaris, sched_yield lives in -lrt.
1274 AC_SEARCH_LIBS(sched_yield, rt)
1279 case "$with_threads" in
1283 SCM_I_GSC_USE_NULL_THREADS=1
1284 with_threads="null-threads"
1287 AC_MSG_ERROR(invalid value for --with-threads: $with_threads)
1291 AC_MSG_CHECKING(what kind of threads to support)
1292 AC_MSG_RESULT($with_threads)
1294 AM_CONDITIONAL([BUILD_PTHREAD_SUPPORT],
1295 [test "x$build_pthread_support" = "xyes"])
1298 ## Check whether pthread_attr_getstack works for the main thread
1300 if test "$with_threads" = pthreads; then
1302 AC_MSG_CHECKING(whether pthread_attr_getstack works for the main thread)
1303 old_CFLAGS="$CFLAGS"
1304 CFLAGS="$PTHREAD_CFLAGS $CFLAGS"
1305 AC_RUN_IFELSE([AC_LANG_SOURCE([[
1306 #if HAVE_PTHREAD_ATTR_GETSTACK
1307 #include <pthread.h>
1311 pthread_attr_t attr;
1315 pthread_getattr_np (pthread_self (), &attr);
1316 pthread_attr_getstack (&attr, &start, &size);
1317 end = (char *)start + size;
1319 if ((void *)&attr < start || (void *)&attr >= end)
1332 AC_DEFINE(PTHREAD_ATTR_GETSTACK_WORKS, [1], [Define when pthread_att_get_stack works for the main thread])],
1335 CFLAGS="$old_CFLAGS"
1336 AC_MSG_RESULT($works)
1338 fi # with_threads=pthreads
1342 if test "$cross_compiling" = "yes"; then
1343 AC_MSG_CHECKING(cc for build)
1344 ## /usr/bin/cc still uses wrong assembler
1345 ## CC_FOR_BUILD="${CC_FOR_BUILD-/usr/bincc}"
1346 CC_FOR_BUILD="${CC_FOR_BUILD-PATH=/usr/bin:$PATH cc}"
1348 CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"
1351 ## AC_MSG_CHECKING("if we are cross compiling")
1352 ## AC_MSG_RESULT($cross_compiling)
1353 if test "$cross_compiling" = "yes"; then
1354 AC_MSG_RESULT($CC_FOR_BUILD)
1357 ## No need as yet to be more elaborate
1358 CCLD_FOR_BUILD="$CC_FOR_BUILD"
1360 AC_SUBST(cross_compiling)
1361 AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
1362 AC_SUBST(CCLD_FOR_BUILD)
1364 ## libtool erroneously calls CC_FOR_BUILD HOST_CC;
1365 ## --HOST is the platform that PACKAGE is compiled for.
1366 HOST_CC="$CC_FOR_BUILD"
1369 if test "$cross_compiling" = "yes"; then
1370 AC_MSG_CHECKING(guile for build)
1371 GUILE_FOR_BUILD="${GUILE_FOR_BUILD-guile}"
1373 GUILE_FOR_BUILD='$(preinstguile)'
1376 ## AC_MSG_CHECKING("if we are cross compiling")
1377 ## AC_MSG_RESULT($cross_compiling)
1378 if test "$cross_compiling" = "yes"; then
1379 AC_MSG_RESULT($GUILE_FOR_BUILD)
1381 AC_ARG_VAR(GUILE_FOR_BUILD,[guile for build system])
1382 AC_SUBST(GUILE_FOR_BUILD)
1384 ## If we're using GCC, ask for aggressive warnings.
1387 ## We had -Wstrict-prototypes in here for a bit, but Guile does too
1388 ## much stuff with generic function pointers for that to really be
1389 ## less than exasperating.
1390 ## -Wpointer-arith was here too, but something changed in gcc/glibc
1391 ## and it became equally exasperating (gcc 2.95 and/or glibc 2.1.2).
1392 CFLAGS="$CFLAGS -Wall -Wmissing-prototypes"
1393 # Do this here so we don't screw up any of the tests above that might
1394 # not be "warning free"
1395 if test "${GUILE_ERROR_ON_WARNING}" = yes
1397 CFLAGS="${CFLAGS} -Werror"
1398 enable_compile_warnings=no
1403 ## If we're creating a shared library (using libtool!), then we'll
1404 ## need to generate a list of .lo files corresponding to the .o files
1405 ## given in LIBOBJS. We'll call it LIBLOBJS.
1406 LIBLOBJS="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.lo ,g;s,\.[[^.]]*$,.lo,'`"
1408 ## We also need to create corresponding .doc and .x files
1409 EXTRA_DOT_DOC_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.doc ,g;s,\.[[^.]]*$,.doc,'`"
1410 EXTRA_DOT_X_FILES="`echo ${LIB@&t@OBJS} | sed 's,\.[[^.]]* ,.x ,g;s,\.[[^.]]*$,.x,'`"
1412 AC_SUBST(GUILE_MAJOR_VERSION)
1413 AC_SUBST(GUILE_MINOR_VERSION)
1414 AC_SUBST(GUILE_MICRO_VERSION)
1415 AC_SUBST(GUILE_EFFECTIVE_VERSION)
1416 AC_SUBST(GUILE_VERSION)
1418 #######################################################################
1419 # library versioning
1421 AC_SUBST(LIBGUILE_INTERFACE_CURRENT)
1422 AC_SUBST(LIBGUILE_INTERFACE_REVISION)
1423 AC_SUBST(LIBGUILE_INTERFACE_AGE)
1424 AC_SUBST(LIBGUILE_INTERFACE)
1426 AC_SUBST(LIBGUILE_SRFI_SRFI_1_MAJOR)
1427 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_CURRENT)
1428 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_REVISION)
1429 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE_AGE)
1430 AC_SUBST(LIBGUILE_SRFI_SRFI_1_INTERFACE)
1432 AC_SUBST(LIBGUILE_SRFI_SRFI_4_MAJOR)
1433 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_CURRENT)
1434 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_REVISION)
1435 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE_AGE)
1436 AC_SUBST(LIBGUILE_SRFI_SRFI_4_INTERFACE)
1438 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_MAJOR)
1439 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_CURRENT)
1440 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_REVISION)
1441 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE_AGE)
1442 AC_SUBST(LIBGUILE_SRFI_SRFI_13_14_INTERFACE)
1444 AC_SUBST(LIBGUILE_SRFI_SRFI_60_MAJOR)
1445 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_CURRENT)
1446 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_REVISION)
1447 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE_AGE)
1448 AC_SUBST(LIBGUILE_SRFI_SRFI_60_INTERFACE)
1450 AC_SUBST(LIBGUILE_I18N_MAJOR)
1451 AC_SUBST(LIBGUILE_I18N_INTERFACE_CURRENT)
1452 AC_SUBST(LIBGUILE_I18N_INTERFACE_REVISION)
1453 AC_SUBST(LIBGUILE_I18N_INTERFACE_AGE)
1454 AC_SUBST(LIBGUILE_I18N_INTERFACE)
1457 #######################################################################
1459 dnl Tell guile-config what flags guile users should compile and link with.
1460 GUILE_LIBS="$LDFLAGS $LIBS"
1461 GUILE_CFLAGS="$CPPFLAGS $PTHREAD_CFLAGS"
1462 AC_SUBST(GUILE_LIBS)
1463 AC_SUBST(GUILE_CFLAGS)
1467 AC_SUBST(EXTRA_DOT_DOC_FILES)
1468 AC_SUBST(EXTRA_DOT_X_FILES)
1470 dnl See also top_builddir in info node: (libtool)AC_PROG_LIBTOOL
1471 top_builddir_absolute=`pwd`
1472 AC_SUBST(top_builddir_absolute)
1473 top_srcdir_absolute=`(cd $srcdir && pwd)`
1474 AC_SUBST(top_srcdir_absolute)
1476 dnl We need `sitedir' in `guile-1.8.pc'.
1477 dnl Note: `sitedir' must be kept in sync with `GUILE_SITE_DIR' in `guile.m4'.
1478 pkgdatadir="$datadir/guile"
1479 sitedir="$pkgdatadir/site"
1482 # Additional SCM_I_GSC definitions are above.
1483 AC_SUBST([SCM_I_GSC_GUILE_DEBUG])
1484 AC_SUBST([SCM_I_GSC_GUILE_DEBUG_FREELIST])
1485 AC_SUBST([SCM_I_GSC_ENABLE_DISCOURAGED])
1486 AC_SUBST([SCM_I_GSC_ENABLE_DEPRECATED])
1487 AC_SUBST([SCM_I_GSC_ENABLE_ELISP])
1488 AC_SUBST([SCM_I_GSC_STACK_GROWS_UP])
1489 AC_SUBST([SCM_I_GSC_C_INLINE])
1490 AC_CONFIG_FILES([libguile/gen-scmconfig.h])
1496 benchmark-suite/Makefile
1501 doc/tutorial/Makefile
1504 examples/box-dynamic-module/Makefile
1505 examples/box-dynamic/Makefile
1506 examples/box-module/Makefile
1507 examples/box/Makefile
1508 examples/modules/Makefile
1509 examples/safe/Makefile
1510 examples/scripts/Makefile
1511 guile-config/Makefile
1513 ice-9/debugger/Makefile
1514 ice-9/debugging/Makefile
1517 lang/elisp/internals/Makefile
1518 lang/elisp/primitives/Makefile
1525 test-suite/standalone/Makefile
1528 AC_CONFIG_FILES([guile-1.8.pc])
1529 AC_CONFIG_FILES([check-guile], [chmod +x check-guile])
1530 AC_CONFIG_FILES([benchmark-guile], [chmod +x benchmark-guile])
1531 AC_CONFIG_FILES([guile-tools], [chmod +x guile-tools])
1532 AC_CONFIG_FILES([pre-inst-guile], [chmod +x pre-inst-guile])
1533 AC_CONFIG_FILES([pre-inst-guile-env], [chmod +x pre-inst-guile-env])
1534 AC_CONFIG_FILES([libguile/guile-snarf],
1535 [chmod +x libguile/guile-snarf])
1536 AC_CONFIG_FILES([libguile/guile-doc-snarf],
1537 [chmod +x libguile/guile-doc-snarf])
1538 AC_CONFIG_FILES([libguile/guile-func-name-check],
1539 [chmod +x libguile/guile-func-name-check])
1540 AC_CONFIG_FILES([libguile/guile-snarf-docs],
1541 [chmod +x libguile/guile-snarf-docs])
1545 dnl Local Variables:
1546 dnl comment-start: "dnl "
1548 dnl comment-start-skip: "\\bdnl\\b\\s *"