X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/02fbff5e8d78c0815dc4d1e278671529382565d6..089067091c8d8b7e0e8df4345d4725d94fcca698:/aclocal.m4 diff --git a/aclocal.m4 b/aclocal.m4 index 110c93999..eff9309c2 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -1,4 +1,14 @@ -dnl aclocal.m4 generated automatically by aclocal 1.1p +dnl aclocal.m4 generated automatically by aclocal 1.3 + +dnl Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc. +dnl This Makefile.in is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl This program is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without +dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A +dnl PARTICULAR PURPOSE. dnl On the NeXT, #including doesn't give you a definition for dnl struct utime, unless you #define _POSIX_SOURCE. @@ -105,6 +115,45 @@ ifelse([$4], , , [$4 fi ]) + + +dnl Check checks whether dlsym (if present) requires a leading underscore. +dnl Written by Dan Hagerty for scsh-0.5.0. +AC_DEFUN(GUILE_DLSYM_USCORE, [ + AC_MSG_CHECKING(for underscore before symbols) + AC_CACHE_VAL(guile_cv_uscore,[ + echo "main(){int i=1;} + fnord(){int i=23; int ltuae=42;}" > conftest.c + ${CC} conftest.c > /dev/null + if (nm a.out | grep _fnord) > /dev/null; then + guile_cv_uscore=yes + else + guile_cv_uscore=no + fi]) + AC_MSG_RESULT($guile_cv_uscore) + rm -f conftest.c a.out + + if test $guile_cv_uscore = yes; then + AC_DEFINE(USCORE) + + if test $ac_cv_func_dlopen = yes -o $ac_cv_lib_dl_dlopen = yes ; then + AC_MSG_CHECKING(whether dlsym always adds an underscore for us) + AC_CACHE_VAL(guile_cv_dlsym_adds_uscore,AC_TRY_RUN( [ +#include +#include +fnord() { int i=42;} +main() { void *self, *ptr1, *ptr2; self=dlopen(NULL,RTLD_LAZY); + if(self) { ptr1=dlsym(self,"fnord"); ptr2=dlsym(self,"_fnord"); + if(ptr1 && !ptr2) exit(0); } exit(1); } +], [guile_cv_dlsym_adds_uscore=yes + AC_DEFINE(DLSYM_ADDS_USCORE) ], guile_cv_dlsym_adds_uscore=no, + guile_cv_dlsym_adds_uscore=no)) + + AC_MSG_RESULT($guile_cv_dlsym_adds_uscore) + fi + fi +]) + # Do all the work for Automake. This macro actually does too much -- # some checks are only needed if your package does certain things. # But this isn't really a big deal. @@ -127,8 +176,8 @@ fi ifelse([$3],, AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE") AC_DEFINE_UNQUOTED(VERSION, "$VERSION")) -AM_SANITY_CHECK -AC_ARG_PROGRAM +AC_REQUIRE([AM_SANITY_CHECK]) +AC_REQUIRE([AC_ARG_PROGRAM]) dnl FIXME This is truly gross. missing_dir=`cd $ac_aux_dir && pwd` AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir) @@ -136,7 +185,7 @@ AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir) AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir) AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir) AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir) -AC_PROG_MAKE_SET]) +AC_REQUIRE([AC_PROG_MAKE_SET])]) # serial 1 @@ -163,10 +212,21 @@ echo timestamp > conftestfile # directory). if ( set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null` - if test "$@" = "X"; then + if test "[$]*" = "X"; then # -L didn't work. set X `ls -t $srcdir/configure conftestfile` fi + if test "[$]*" != "X $srcdir/configure conftestfile" \ + && test "[$]*" != "X conftestfile $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken +alias in your environment]) + fi + test "[$]2" = conftestfile ) then @@ -242,94 +302,187 @@ done<<>>dnl>>) changequote([,]))]) -# serial 9 AM_PROG_LIBTOOL +# serial 24 AM_PROG_LIBTOOL AC_DEFUN(AM_PROG_LIBTOOL, -[AC_REQUIRE([AC_CANONICAL_HOST]) -AC_REQUIRE([AC_PROG_CC]) -AC_REQUIRE([AC_PROG_RANLIB]) -AC_REQUIRE([AM_PROG_LD]) -AC_REQUIRE([AC_PROG_LN_S]) - +[AC_REQUIRE([AM_ENABLE_SHARED])dnl +AC_REQUIRE([AM_ENABLE_STATIC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_PROG_RANLIB])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AM_PROG_LD])dnl +AC_REQUIRE([AM_PROG_NM])dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +dnl # Always use our own libtool. -LIBTOOL='$(top_builddir)/libtool' -AC_SUBST(LIBTOOL) - -dnl Allow the --disable-shared flag to stop us from building shared libs. -AC_ARG_ENABLE(shared, -[ --enable-shared build shared libraries [default=yes]], -test "$enableval" = no && libtool_shared=" --disable-shared", -libtool_shared=) +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl -dnl Allow the --disable-static flag to stop us from building static libs. -AC_ARG_ENABLE(static, -[ --enable-static build static libraries [default=yes]], -test "$enableval" = no && libtool_static=" --disable-static", -libtool_static=) - -libtool_flags="$libtool_shared$libtool_static" +# Check for any special flags to pass to ltconfig. +libtool_flags= +test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared" +test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static" test "$silent" = yes && libtool_flags="$libtool_flags --silent" test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc" test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld" # Some flags need to be propagated to the compiler or linker for good # libtool support. -[case "$host" in +case "$host" in *-*-irix6*) - for f in '-32' '-64' '-cckr' '-n32' '-mips1' '-mips2' '-mips3' '-mips4'; do - if echo " $CC $CFLAGS " | egrep -e "[ ]$f[ ]" > /dev/null; then - LD="${LD-ld} $f" - fi - done + # Find out which ABI we are using. + echo '[#]line __oline__ "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case "`/usr/bin/file conftest.o`" in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + rm -rf conftest* ;; *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. CFLAGS="$CFLAGS -belf" ;; -esac] +esac # Actually configure libtool. ac_aux_dir is where install-sh is found. CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \ -LD="$LD" RANLIB="$RANLIB" LN_S="$LN_S" \ +LD="$LD" NM="$NM" RANLIB="$RANLIB" LN_S="$LN_S" \ ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig \ $libtool_flags --no-verify $ac_aux_dir/ltmain.sh $host \ || AC_MSG_ERROR([libtool configure failed]) ]) +# AM_ENABLE_SHARED - implement the --enable-shared flag +# Usage: AM_ENABLE_SHARED[(DEFAULT)] +# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to +# `yes'. +AC_DEFUN(AM_ENABLE_SHARED, +[define([AM_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE(shared, +changequote(<<, >>)dnl +<< --enable-shared build shared libraries [default=>>AM_ENABLE_SHARED_DEFAULT] +changequote([, ])dnl +[ --enable-shared=PKGS only build shared libraries if the current package + appears as an element in the PKGS list], +[p=${PACKAGE-default} +case "$enableval" in +yes) enable_shared=yes ;; +no) enable_shared=no ;; +*) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," + for pkg in $enableval; do + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$ac_save_ifs" + ;; +esac], +enable_shared=AM_ENABLE_SHARED_DEFAULT)dnl +]) + +# AM_DISABLE_SHARED - set the default shared flag to --disable-shared +AC_DEFUN(AM_DISABLE_SHARED, +[AM_ENABLE_SHARED(no)]) + +# AM_DISABLE_STATIC - set the default static flag to --disable-static +AC_DEFUN(AM_DISABLE_STATIC, +[AM_ENABLE_STATIC(no)]) + +# AM_ENABLE_STATIC - implement the --enable-static flag +# Usage: AM_ENABLE_STATIC[(DEFAULT)] +# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to +# `yes'. +AC_DEFUN(AM_ENABLE_STATIC, +[define([AM_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl +AC_ARG_ENABLE(static, +changequote(<<, >>)dnl +<< --enable-static build static libraries [default=>>AM_ENABLE_STATIC_DEFAULT] +changequote([, ])dnl +[ --enable-static=PKGS only build shared libraries if the current package + appears as an element in the PKGS list], +[p=${PACKAGE-default} +case "$enableval" in +yes) enable_static=yes ;; +no) enable_static=no ;; +*) + enable_static=no + # Look at the argument we got. We use all the common list separators. + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," + for pkg in $enableval; do + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$ac_save_ifs" + ;; +esac], +enable_static=AM_ENABLE_STATIC_DEFAULT)dnl +]) + + # AM_PROG_LD - find the path to the GNU or non-GNU linker AC_DEFUN(AM_PROG_LD, [AC_ARG_WITH(gnu-ld, [ --with-gnu-ld assume the C compiler uses GNU ld [default=no]], test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no) -if test "$with_gnu_ld" = yes; then +AC_REQUIRE([AC_PROG_CC]) +ac_prog=ld +if test "$ac_cv_prog_gcc" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by GCC]) + ac_prog=`($CC -print-prog-name=ld) 2>&5` + case "$ac_prog" in + # Accept absolute paths. + /* | [A-Za-z]:\\*) + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL(ac_cv_path_LD, -[case "$LD" in - /*) - ac_cv_path_LD="$LD" # Let the user override the test with a path. - ;; - *) +[if test -z "$LD"; then IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. - if test -f "$ac_dir/ld"; then - ac_cv_path_LD="$ac_dir/ld" + if test -f "$ac_dir/$ac_prog"; then + ac_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some GNU ld's only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. - if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU ld|with BFD)' > /dev/null; then - test "$with_gnu_ld" = yes && break + if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then + test "$with_gnu_ld" != no && break else test "$with_gnu_ld" != yes && break fi fi done IFS="$ac_save_ifs" - ;; -esac]) +else + ac_cv_path_LD="$LD" # Let the user override the test with a path. +fi]) LD="$ac_cv_path_LD" if test -n "$LD"; then AC_MSG_RESULT($LD) @@ -342,115 +495,299 @@ AM_PROG_LD_GNU ]) AC_DEFUN(AM_PROG_LD_GNU, -[AC_CACHE_CHECK([whether we are using GNU ld], ac_cv_prog_gnu_ld, +[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld, [# I'd rather use --version here, but apparently some GNU ld's only accept -v. -if $LD -v 2>&1 /dev/null; then +if $LD -v 2>&1 &5; then ac_cv_prog_gnu_ld=yes else ac_cv_prog_gnu_ld=no fi]) ]) -dnl -dnl CY_AC_WITH_THREADS determines which thread library the user intends -dnl to put underneath guile. Pass it the path to find the guile top-level -dnl source directory. Eg CY_AC_WITH_THREADS(../..) for tcl/unix. -dnl +# AM_PROG_NM - find the path to a BSD-compatible name lister +AC_DEFUN(AM_PROG_NM, +[AC_MSG_CHECKING([for BSD-compatible nm]) +AC_CACHE_VAL(ac_cv_path_NM, +[case "$NM" in +/* | [A-Za-z]:\\*) + ac_cv_path_NM="$NM" # Let the user override the test with a path. + ;; +*) + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" + for ac_dir in /usr/ucb /usr/ccs/bin $PATH /bin; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/nm; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then + ac_cv_path_NM="$ac_dir/nm -B" + elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then + ac_cv_path_NM="$ac_dir/nm -p" + else + ac_cv_path_NM="$ac_dir/nm" + fi + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm + ;; +esac]) +NM="$ac_cv_path_NM" +AC_MSG_RESULT([$NM]) +AC_SUBST(NM) +]) -AC_DEFUN([CY_AC_WITH_THREADS],[ -AC_CACHE_CHECK("threads package type",cy_cv_threads_package,[ -AC_CACHE_VAL(cy_cv_threads_cflags,[ -AC_CACHE_VAL(cy_cv_threads_libs,[ -use_threads=no; -AC_ARG_WITH(threads,[ --with-threads thread interface], - use_threads=$withval, use_threads=no) -test -n "$use_threads" || use_threads=qt -threads_package=unknown -if test "$use_threads" != no; then -dnl -dnl Test for the qt threads package - used for cooperative threads -dnl This may not necessarily be built yet - so just check for the -dnl header files. -dnl - if test "$use_threads" = yes || test "$use_threads" = qt; then - # Look for qt in source directory. - if test -f $srcdir/qt/qt.c; then - qtsrcdir="`(cd $srcdir; pwd)`/qt" - threads_package=COOP - cy_cv_threads_cflags="-I$qtsrcdir -I../qt" - cy_cv_threads_libs="../qt/libqt.a" - fi - else - if test -f $use_threads/qt.c; then - # FIXME seems as though we should try to use an installed qt here. - threads_package=COOP - cy_cv_threads_cflags="-I$use_threads -I../qt" - cy_cv_threads_libs="../qt/libqt.a" - fi - fi - if test "$use_threads" = pthreads; then - # Look for pthreads in srcdir. See above to understand why - # we always set threads_package. - if test -f $srcdir/../../pthreads/pthreads/queue.c \ - || test -f $srcdir/../pthreads/pthreads/queue.c; then - threads_package=MIT - cy_cv_threads_cflags="-I$srcdir/../../pthreads/include" - cy_cv_threads_libs="-L../../pthreads/lib -lpthread" - fi - fi - saved_CPP="$CPPFLAGS" - saved_LD="$LDFLAGS" - saved_LIBS="$LIBS" - if test "$threads_package" = unknown; then -dnl -dnl Test for the FSU threads package + +# serial 1 + +# @defmac AC_PROG_CC_STDC +# @maindex PROG_CC_STDC +# @ovindex CC +# If the C compiler in not in ANSI C mode by default, try to add an option +# to output variable @code{CC} to make it so. This macro tries various +# options that select ANSI C on some system or another. It considers the +# compiler to be in ANSI C mode if it handles function prototypes correctly. +# +# If you use this macro, you should check after calling it whether the C +# compiler has been set to accept ANSI C; if not, the shell variable +# @code{am_cv_prog_cc_stdc} is set to @samp{no}. If you wrote your source +# code in ANSI C, you can make an un-ANSIfied copy of it by using the +# program @code{ansi2knr}, which comes with Ghostscript. +# @end defmac + +AC_DEFUN(AM_PROG_CC_STDC, +[AC_REQUIRE([AC_PROG_CC]) +AC_BEFORE([$0], [AC_C_INLINE]) +AC_BEFORE([$0], [AC_C_CONST]) +dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require +dnl a magic option to avoid problems with ANSI preprocessor commands +dnl like #elif. +dnl FIXME: can't do this because then AC_AIX won't work due to a +dnl circular dependency. +dnl AC_BEFORE([$0], [AC_PROG_CPP]) +AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C) +AC_CACHE_VAL(am_cv_prog_cc_stdc, +[am_cv_prog_cc_stdc=no +ac_save_CC="$CC" +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX -Aa -D_HPUX_SOURCE +# SVR4 -Xc -D__EXTENSIONS__ +for ac_arg in "" -qlanglvl=ansi -std1 "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + AC_TRY_COMPILE( +[#include +#include +#include +#include +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +], [ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; +], +[am_cv_prog_cc_stdc="$ac_arg"; break]) +done +CC="$ac_save_CC" +]) +if test -z "$am_cv_prog_cc_stdc"; then + AC_MSG_RESULT([none needed]) +else + AC_MSG_RESULT($am_cv_prog_cc_stdc) +fi +case "x$am_cv_prog_cc_stdc" in + x|xno) ;; + *) CC="$CC $am_cv_prog_cc_stdc" ;; +esac +]) + +dnl Autoconf macros for configuring the QuickThreads package +dnl Jim Blandy --- July 1998 dnl - CPPFLAGS="-I$use_threads/include" - LDFLAGS="-L$use_threads/lib" - LIBS="-lgthreads -lmalloc" - AC_TRY_LINK([#include ],[ -pthread_equal(NULL,NULL); -], threads_package=FSU) - fi - if test "$threads_package" = unknown; then +dnl Copyright (C) 1998 Free Software Foundation, Inc. dnl -dnl Test for the MIT threads package +dnl This file is part of GUILE. +dnl +dnl GUILE is free software; you can redistribute it and/or modify +dnl it under the terms of the GNU General Public License as +dnl published by the Free Software Foundation; either version 2, or +dnl (at your option) any later version. +dnl +dnl GUILE is distributed in the hope that it will be useful, but +dnl WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +dnl GNU General Public License for more details. +dnl +dnl You should have received a copy of the GNU General Public +dnl License along with GUILE; see the file COPYING. If not, write +dnl to the Free Software Foundation, Inc., 59 Temple Place, Suite +dnl 330, Boston, MA 02111-1307 USA + + + +dnl QTHREADS_CONFIGURE configures the QuickThreads package. The QT +dnl sources should be in $srcdir/qt. If configuration succeeds, this +dnl macro creates the appropriate symlinks in the qt object directory, +dnl and sets the following variables, used in building libqthreads.a: +dnl QTHREAD_LTLIBS --- set to libqthreads.la if configuration +dnl succeeds, or the empty string if configuration fails. +dnl qtmd_h, qtmds_s, qtmdc_c, qtdmdb_s --- the names of the machine- +dnl dependent source files. +dnl qthread_asflags --- flags to pass to the compiler when processing +dnl assembly-language files. dnl - LIBS="-lpthread" - AC_TRY_LINK([#include ],[ -pthread_equal(NULL,NULL); -], threads_package=MIT) - fi - if test "$threads_package" = unknown; then +dnl It also sets the following variables, which describe how clients +dnl can link against libqthreads.a: +dnl THREAD_PACKAGE --- set to "QT" if configuration succeeds, or +dnl the empty string if configuration fails. +dnl THREAD_CPPFLAGS --- set to `-I' flags for thread header files +dnl THREAD_LIBS_LOCAL --- linker options for use in this source tree +dnl THREAD_LIBS_INSTALLED --- linker options for use after this package +dnl is installed +dnl It would be nice if all thread configuration packages for Guile +dnl followed the same conventions. dnl -dnl Test for the PCthreads package +dnl All of the above variables will be substituted into Makefiles in +dnl the usual autoconf fashion. dnl - LIBS="-lpthreads" - AC_TRY_LINK([#include ],[ -pthread_equal(NULL,NULL); -], threads_package=PCthreads) - fi +dnl We distinguish between THREAD_LIBS_LOCAL and +dnl THREAD_LIBS_INSTALLED because the thread library might be in +dnl this tree, and be built using libtool. This means that: +dnl 1) when building other executables in this tree, one must +dnl pass the relative path to the ../libfoo.la file, but +dnl 2) once the whole package has been installed, users should +dnl link using -lfoo. +dnl Normally, we only care about the first case, but since the +dnl guile-config script needs to give users all the flags they need +dnl to link programs against guile, the GUILE_WITH_THREADS macro +dnl needs to supply the second piece of information as well. dnl -dnl Set the appropriate flags! -dnl - cy_cv_threads_cflags="$CPPFLAGS $cy_cv_threads_cflags" - cy_cv_threads_libs="$LDFLAGS $LIBS $cy_cv_threads_libs" - cy_cv_threads_package=$threads_package - CPPFLAGS="$saved_CPP" - LDFLAGS="$saved_LD" - LIBS="$saved_LIBS" - if test "$threads_package" = unknown; then - AC_MSG_ERROR("cannot find thread library installation") +dnl This whole thing is a little confused about what ought to be +dnl done in the top-level configure script, and what ought to be +dnl taken care of in the subdirectory. For example, qtmds_s and +dnl friends really ought not to be even mentioned in the top-level +dnl configure script, but here they are. + +AC_DEFUN([QTHREADS_CONFIGURE],[ + AC_REQUIRE([AC_PROG_LN_S]) + + AC_MSG_CHECKING(QuickThreads configuration) + # How can we refer to the qt source directory from within the qt build + # directory? For headers, we can rely on the fact that the qt src + # directory appears in the #include path. + qtsrcdir="`(cd $srcdir; pwd)`/qt" + + changequote(,)dnl We use [ and ] in a regexp in the case + + THREAD_PACKAGE=QT + qthread_asflags='' + case "$host" in + i[3456]86-*-*) + port_name=i386 + qtmd_h=md/i386.h + qtmds_s=md/i386.s + qtmdc_c=md/null.c + qtdmdb_s= + case "$host" in + *-*-netbsd* ) + ## NetBSD needs to be told to pass the assembly code through + ## the C preprocessor. Other GCC installations seem to do + ## this by default, but NetBSD's doesn't. We could get the + ## same effect by giving the file a name ending with .S + ## instead of .s, but I don't see how to tell automake to do + ## that. + qthread_asflags='-x assembler-with-cpp' + ;; + esac + ;; + mips-sgi-irix[56]*) + port_name=irix + qtmd_h=md/mips.h + qtmds_s=md/mips-irix5.s + qtmdc_c=md/null.c + qtdmdb_s=md/mips_b.s + ;; + mips-*-*) + port_name=mips + qtmd_h=md/mips.h + qtmds_s=md/mips.s + qtmdc_c=md/null.c + qtdmdb_s=md/mips_b.s + ;; + sparc-*-sunos*) + port_name=sparc-sunos + qtmd_h=md/sparc.h + qtmds_s=md/_sparc.s + qtmdc_c=md/null.c + qtdmdb_s=md/_sparc_b.s + ;; + sparc-*-*) + port_name=sparc + qtmd_h=md/sparc.h + qtmds_s=md/sparc.s + qtmdc_c=md/null.c + qtdmdb_s=md/sparc_b.s + ;; + alpha-*-*) + port_name=alpha + qtmd_h=md/axp.h + qtmds_s=md/axp.s + qtmdc_c=md/null.c + qtdmdb_s=md/axp_b.s + ;; + *) + echo "Unknown configuration; threads package disabled" + THREAD_PACKAGE="" + ;; + esac + changequote([, ]) + + # Did configuration succeed? + if test -n "$THREAD_PACKAGE"; then + AC_MSG_RESULT($port_name) + QTHREAD_LTLIBS=libqthreads.la + THREAD_CPPFLAGS="-I$qtsrcdir -I../qt" + THREAD_LIBS_LOCAL="../qt/libqthreads.la" + THREAD_LIBS_INSTALLED="-lqthreads" + else + AC_MSG_RESULT(none; disabled) fi -fi -]) -]) -], -dnl -dnl Set flags according to what is cached. -dnl -CPPFLAGS="$cy_cv_threads_cflags" -LIBS="$cy_cv_threads_libs" -) + + AC_SUBST(QTHREAD_LTLIBS) + AC_SUBST(qtmd_h) + AC_SUBST(qtmds_s) + AC_SUBST(qtmdc_c) + AC_SUBST(qtdmdb_s) + AC_SUBST(qthread_asflags) + AC_SUBST(THREAD_PACKAGE) + AC_SUBST(THREAD_CPPFLAGS) + AC_SUBST(THREAD_LIBS_LOCAL) + AC_SUBST(THREAD_LIBS_INSTALLED) ])