dnl aclocal.m4 generated automatically by aclocal 1.4-p6 dnl Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc. dnl This file 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. # lib-prefix.m4 serial 4 (gettext-0.14.2) dnl Copyright (C) 2001-2005 Free Software Foundation, Inc. dnl This file 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 From Bruno Haible. dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't dnl require excessive bracketing. ifdef([AC_HELP_STRING], [AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])], [AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])]) dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed dnl to access previously installed libraries. The basic assumption is that dnl a user will want packages to use other packages he previously installed dnl with the same --prefix option. dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate dnl libraries, but is otherwise very convenient. AC_DEFUN([AC_LIB_PREFIX], [ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) AC_REQUIRE([AC_PROG_CC]) AC_REQUIRE([AC_CANONICAL_HOST]) AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) dnl By default, look in $includedir and $libdir. use_additional=yes AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) AC_LIB_ARG_WITH([lib-prefix], [ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib --without-lib-prefix don't search for libraries in includedir and libdir], [ if test "X$withval" = "Xno"; then use_additional=no else if test "X$withval" = "X"; then AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) else additional_includedir="$withval/include" additional_libdir="$withval/lib" fi fi ]) if test $use_additional = yes; then dnl Potentially add $additional_includedir to $CPPFLAGS. dnl But don't add it dnl 1. if it's the standard /usr/include, dnl 2. if it's already present in $CPPFLAGS, dnl 3. if it's /usr/local/include and we are using GCC on Linux, dnl 4. if it doesn't exist as a directory. if test "X$additional_includedir" != "X/usr/include"; then haveit= for x in $CPPFLAGS; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-I$additional_includedir"; then haveit=yes break fi done if test -z "$haveit"; then if test "X$additional_includedir" = "X/usr/local/include"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then if test -d "$additional_includedir"; then dnl Really add $additional_includedir to $CPPFLAGS. CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" fi fi fi fi dnl Potentially add $additional_libdir to $LDFLAGS. dnl But don't add it dnl 1. if it's the standard /usr/lib, dnl 2. if it's already present in $LDFLAGS, dnl 3. if it's /usr/local/lib and we are using GCC on Linux, dnl 4. if it doesn't exist as a directory. if test "X$additional_libdir" != "X/usr/lib"; then haveit= for x in $LDFLAGS; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test "X$additional_libdir" = "X/usr/local/lib"; then if test -n "$GCC"; then case $host_os in linux*) haveit=yes;; esac fi fi if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LDFLAGS. LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" fi fi fi fi fi ]) dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, dnl acl_final_exec_prefix, containing the values to which $prefix and dnl $exec_prefix will expand at the end of the configure script. AC_DEFUN([AC_LIB_PREPARE_PREFIX], [ dnl Unfortunately, prefix and exec_prefix get only finally determined dnl at the end of configure. if test "X$prefix" = "XNONE"; then acl_final_prefix="$ac_default_prefix" else acl_final_prefix="$prefix" fi if test "X$exec_prefix" = "XNONE"; then acl_final_exec_prefix='${prefix}' else acl_final_exec_prefix="$exec_prefix" fi acl_save_prefix="$prefix" prefix="$acl_final_prefix" eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" prefix="$acl_save_prefix" ]) dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the dnl variables prefix and exec_prefix bound to the values they will have dnl at the end of the configure script. AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], [ acl_save_prefix="$prefix" prefix="$acl_final_prefix" acl_save_exec_prefix="$exec_prefix" exec_prefix="$acl_final_exec_prefix" $1 exec_prefix="$acl_save_exec_prefix" prefix="$acl_save_prefix" ]) # lib-link.m4 serial 6 (gettext-0.14.3) dnl Copyright (C) 2001-2005 Free Software Foundation, Inc. dnl This file 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 From Bruno Haible. AC_PREREQ(2.50) dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and dnl the libraries corresponding to explicit and implicit dependencies. dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and dnl augments the CPPFLAGS variable. AC_DEFUN([AC_LIB_LINKFLAGS], [ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) define([Name],[translit([$1],[./-], [___])]) define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ac_cv_lib[]Name[]_libs="$LIB[]NAME" ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME" ac_cv_lib[]Name[]_cppflags="$INC[]NAME" ]) LIB[]NAME="$ac_cv_lib[]Name[]_libs" LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs" INC[]NAME="$ac_cv_lib[]Name[]_cppflags" AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) AC_SUBST([LIB]NAME) AC_SUBST([LTLIB]NAME) dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the dnl results of this search when this library appears as a dependency. HAVE_LIB[]NAME=yes undefine([Name]) undefine([NAME]) ]) dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode) dnl searches for libname and the libraries corresponding to explicit and dnl implicit dependencies, together with the specified include files and dnl the ability to compile and link the specified testcode. If found, it dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty. AC_DEFUN([AC_LIB_HAVE_LINKFLAGS], [ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) define([Name],[translit([$1],[./-], [___])]) define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME dnl accordingly. AC_LIB_LINKFLAGS_BODY([$1], [$2]) dnl Add $INC[]NAME to CPPFLAGS before performing the following checks, dnl because if the user has installed lib[]Name and not disabled its use dnl via --without-lib[]Name-prefix, he wants to use it. ac_save_CPPFLAGS="$CPPFLAGS" AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [ ac_save_LIBS="$LIBS" LIBS="$LIBS $LIB[]NAME" AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no]) LIBS="$ac_save_LIBS" ]) if test "$ac_cv_lib[]Name" = yes; then HAVE_LIB[]NAME=yes AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.]) AC_MSG_CHECKING([how to link with lib[]$1]) AC_MSG_RESULT([$LIB[]NAME]) else HAVE_LIB[]NAME=no dnl If $LIB[]NAME didn't lead to a usable library, we don't need dnl $INC[]NAME either. CPPFLAGS="$ac_save_CPPFLAGS" LIB[]NAME= LTLIB[]NAME= fi AC_SUBST([HAVE_LIB]NAME) AC_SUBST([LIB]NAME) AC_SUBST([LTLIB]NAME) undefine([Name]) undefine([NAME]) ]) dnl Determine the platform dependent parameters needed to use rpath: dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator, dnl hardcode_direct, hardcode_minus_L. AC_DEFUN([AC_LIB_RPATH], [ dnl Tell automake >= 1.10 to complain if config.rpath is missing. m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])]) AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [ CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \ ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh . ./conftest.sh rm -f ./conftest.sh acl_cv_rpath=done ]) wl="$acl_cv_wl" libext="$acl_cv_libext" shlibext="$acl_cv_shlibext" hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" hardcode_direct="$acl_cv_hardcode_direct" hardcode_minus_L="$acl_cv_hardcode_minus_L" dnl Determine whether the user wants rpath handling at all. AC_ARG_ENABLE(rpath, [ --disable-rpath do not hardcode runtime library paths], :, enable_rpath=yes) ]) dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and dnl the libraries corresponding to explicit and implicit dependencies. dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. AC_DEFUN([AC_LIB_LINKFLAGS_BODY], [ define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) dnl By default, look in $includedir and $libdir. use_additional=yes AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) AC_LIB_ARG_WITH([lib$1-prefix], [ --with-lib$1-prefix[=DIR] search for lib$1 in DIR/include and DIR/lib --without-lib$1-prefix don't search for lib$1 in includedir and libdir], [ if test "X$withval" = "Xno"; then use_additional=no else if test "X$withval" = "X"; then AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) else additional_includedir="$withval/include" additional_libdir="$withval/lib" fi fi ]) dnl Search the library and its dependencies in $additional_libdir and dnl $LDFLAGS. Using breadth-first-seach. LIB[]NAME= LTLIB[]NAME= INC[]NAME= rpathdirs= ltrpathdirs= names_already_handled= names_next_round='$1 $2' while test -n "$names_next_round"; do names_this_round="$names_next_round" names_next_round= for name in $names_this_round; do already_handled= for n in $names_already_handled; do if test "$n" = "$name"; then already_handled=yes break fi done if test -z "$already_handled"; then names_already_handled="$names_already_handled $name" dnl See if it was already located by an earlier AC_LIB_LINKFLAGS dnl or AC_LIB_HAVE_LINKFLAGS call. uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'` eval value=\"\$HAVE_LIB$uppername\" if test -n "$value"; then if test "$value" = yes; then eval value=\"\$LIB$uppername\" test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" eval value=\"\$LTLIB$uppername\" test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" else dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined dnl that this library doesn't exist. So just drop it. : fi else dnl Search the library lib$name in $additional_libdir and $LDFLAGS dnl and the already constructed $LIBNAME/$LTLIBNAME. found_dir= found_la= found_so= found_a= if test $use_additional = yes; then if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then found_dir="$additional_libdir" found_so="$additional_libdir/lib$name.$shlibext" if test -f "$additional_libdir/lib$name.la"; then found_la="$additional_libdir/lib$name.la" fi else if test -f "$additional_libdir/lib$name.$libext"; then found_dir="$additional_libdir" found_a="$additional_libdir/lib$name.$libext" if test -f "$additional_libdir/lib$name.la"; then found_la="$additional_libdir/lib$name.la" fi fi fi fi if test "X$found_dir" = "X"; then for x in $LDFLAGS $LTLIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) case "$x" in -L*) dir=`echo "X$x" | sed -e 's/^X-L//'` if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then found_dir="$dir" found_so="$dir/lib$name.$shlibext" if test -f "$dir/lib$name.la"; then found_la="$dir/lib$name.la" fi else if test -f "$dir/lib$name.$libext"; then found_dir="$dir" found_a="$dir/lib$name.$libext" if test -f "$dir/lib$name.la"; then found_la="$dir/lib$name.la" fi fi fi ;; esac if test "X$found_dir" != "X"; then break fi done fi if test "X$found_dir" != "X"; then dnl Found the library. LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" if test "X$found_so" != "X"; then dnl Linking with a shared library. We attempt to hardcode its dnl directory into the executable's runpath, unless it's the dnl standard /usr/lib. if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then dnl No hardcoding is needed. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else dnl Use an explicit option to hardcode DIR into the resulting dnl binary. dnl Potentially add DIR to ltrpathdirs. dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. haveit= for x in $ltrpathdirs; do if test "X$x" = "X$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then ltrpathdirs="$ltrpathdirs $found_dir" fi dnl The hardcoding into $LIBNAME is system dependent. if test "$hardcode_direct" = yes; then dnl Using DIR/libNAME.so during linking hardcodes DIR into the dnl resulting binary. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then dnl Use an explicit option to hardcode DIR into the resulting dnl binary. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" dnl Potentially add DIR to rpathdirs. dnl The rpathdirs will be appended to $LIBNAME at the end. haveit= for x in $rpathdirs; do if test "X$x" = "X$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then rpathdirs="$rpathdirs $found_dir" fi else dnl Rely on "-L$found_dir". dnl But don't add it if it's already contained in the LDFLAGS dnl or the already constructed $LIBNAME haveit= for x in $LDFLAGS $LIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" fi if test "$hardcode_minus_L" != no; then dnl FIXME: Not sure whether we should use dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" dnl here. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH dnl here, because this doesn't fit in flags passed to the dnl compiler. So give up. No hardcoding. This affects only dnl very old systems. dnl FIXME: Not sure whether we should use dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" dnl here. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" fi fi fi fi else if test "X$found_a" != "X"; then dnl Linking with a static library. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" else dnl We shouldn't come here, but anyway it's good to have a dnl fallback. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" fi fi dnl Assume the include files are nearby. additional_includedir= case "$found_dir" in */lib | */lib/) basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'` additional_includedir="$basedir/include" ;; esac if test "X$additional_includedir" != "X"; then dnl Potentially add $additional_includedir to $INCNAME. dnl But don't add it dnl 1. if it's the standard /usr/include, dnl 2. if it's /usr/local/include and we are using GCC on Linux, dnl 3. if it's already present in $CPPFLAGS or the already dnl constructed $INCNAME, dnl 4. if it doesn't exist as a directory. if test "X$additional_includedir" != "X/usr/include"; then haveit= if test "X$additional_includedir" = "X/usr/local/include"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then for x in $CPPFLAGS $INC[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-I$additional_includedir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_includedir"; then dnl Really add $additional_includedir to $INCNAME. INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" fi fi fi fi fi dnl Look for dependencies. if test -n "$found_la"; then dnl Read the .la file. It defines the variables dnl dlname, library_names, old_library, dependency_libs, current, dnl age, revision, installed, dlopen, dlpreopen, libdir. save_libdir="$libdir" case "$found_la" in */* | *\\*) . "$found_la" ;; *) . "./$found_la" ;; esac libdir="$save_libdir" dnl We use only dependency_libs. for dep in $dependency_libs; do case "$dep" in -L*) additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME. dnl But don't add it dnl 1. if it's the standard /usr/lib, dnl 2. if it's /usr/local/lib and we are using GCC on Linux, dnl 3. if it's already present in $LDFLAGS or the already dnl constructed $LIBNAME, dnl 4. if it doesn't exist as a directory. if test "X$additional_libdir" != "X/usr/lib"; then haveit= if test "X$additional_libdir" = "X/usr/local/lib"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then haveit= for x in $LDFLAGS $LIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LIBNAME. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir" fi fi haveit= for x in $LDFLAGS $LTLIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LTLIBNAME. LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir" fi fi fi fi ;; -R*) dir=`echo "X$dep" | sed -e 's/^X-R//'` if test "$enable_rpath" != no; then dnl Potentially add DIR to rpathdirs. dnl The rpathdirs will be appended to $LIBNAME at the end. haveit= for x in $rpathdirs; do if test "X$x" = "X$dir"; then haveit=yes break fi done if test -z "$haveit"; then rpathdirs="$rpathdirs $dir" fi dnl Potentially add DIR to ltrpathdirs. dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. haveit= for x in $ltrpathdirs; do if test "X$x" = "X$dir"; then haveit=yes break fi done if test -z "$haveit"; then ltrpathdirs="$ltrpathdirs $dir" fi fi ;; -l*) dnl Handle this in the next round. names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` ;; *.la) dnl Handle this in the next round. Throw away the .la's dnl directory; it is already contained in a preceding -L dnl option. names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` ;; *) dnl Most likely an immediate library name. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" ;; esac done fi else dnl Didn't find the library; assume it is in the system directories dnl known to the linker and runtime loader. (All the system dnl directories known to the linker should also be known to the dnl runtime loader, otherwise the system is severely misconfigured.) LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" fi fi fi done done if test "X$rpathdirs" != "X"; then if test -n "$hardcode_libdir_separator"; then dnl Weird platform: only the last -rpath option counts, the user must dnl pass all path elements in one option. We can arrange that for a dnl single library, but not when more than one $LIBNAMEs are used. alldirs= for found_dir in $rpathdirs; do alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir" done dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl. acl_save_libdir="$libdir" libdir="$alldirs" eval flag=\"$hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" else dnl The -rpath options are cumulative. for found_dir in $rpathdirs; do acl_save_libdir="$libdir" libdir="$found_dir" eval flag=\"$hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" done fi fi if test "X$ltrpathdirs" != "X"; then dnl When using libtool, the option that works for both libraries and dnl executables is -R. The -R options are cumulative. for found_dir in $ltrpathdirs; do LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" done fi ]) dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, dnl unless already present in VAR. dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes dnl contains two or three consecutive elements that belong together. AC_DEFUN([AC_LIB_APPENDTOVAR], [ for element in [$2]; do haveit= for x in $[$1]; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X$element"; then haveit=yes break fi done if test -z "$haveit"; then [$1]="${[$1]}${[$1]:+ }$element" fi done ]) # lib-ld.m4 serial 3 (gettext-0.13) dnl Copyright (C) 1996-2003 Free Software Foundation, Inc. dnl This file 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 Subroutines of libtool.m4, dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision dnl with libtool.m4. dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no. AC_DEFUN([AC_LIB_PROG_LD_GNU], [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld, [# I'd rather use --version here, but apparently some GNU ld's only accept -v. case `$LD -v 2>&1 conf$$.sh echo "exit 0" >>conf$$.sh chmod +x conf$$.sh if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=';' else PATH_SEPARATOR=: fi rm -f conf$$.sh fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by GCC]) case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [[\\/]* | [A-Za-z]:[\\/]*)] [re_direlt='/[^/][^/]*/\.\./'] # Canonicalize the path of ld ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` done 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(acl_cv_path_LD, [if test -z "$LD"; then IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then acl_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. case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in *GNU* | *'with BFD'*) test "$with_gnu_ld" != no && break ;; *) test "$with_gnu_ld" != yes && break ;; esac fi done IFS="$ac_save_ifs" else acl_cv_path_LD="$LD" # Let the user override the test with a path. fi]) LD="$acl_cv_path_LD" if test -n "$LD"; then AC_MSG_RESULT($LD) else AC_MSG_RESULT(no) fi test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) AC_LIB_PROG_LD_GNU ]) dnl # -*- shell-script -*- dnl ########################################################################### dnl # dnl # LAYER-SYSTEM -- tool for configuring, building, and installing software dnl # Copyright (C) 1996-2001, Martin Vicente dnl # Copyright (C) 2002-2004, Centre d'Etudes de la Navigation Aérienne dnl # dnl # This software is free software; you can redistribute it and/or modify dnl # it under the terms of the GNU General Public License as published by dnl # the Free Software Foundation; either version 2 of the License, or dnl # (at your option) any later version. dnl # dnl # This software is distributed in the hope that it will be useful, dnl # but WITHOUT ANY WARRANTY; without even the implied warranty of dnl # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. dnl # See the GNU General Public License for more details. dnl # dnl # You should have received a copy of the GNU General Public License dnl # along with this software (see the file COPYING). dnl # If not, write to the Free Software Foundation, Inc., dnl # 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. dnl # dnl ########################################################################### dnl # dnl # LAYER-SYSTEM -- TOOL FOR CONFIGURING, BUILDING, AND INSTALLING SOFTWARE dnl # © Martin Vicente, 1996-2001 dnl # © Centre d'Etudes de la Navigation Aérienne, 2002-2004 dnl # dnl # MY LOCAL ADDITIONS TO AUTOCONF MACROS dnl # dnl # Project: LAYER-SYSTEM dnl # Purpose: Tool for configuring, building, and installing software dnl # Version: 1.0 (first official release) dnl # ------------------------------------------------------------------------ dnl # File : martin.m4 dnl # Purpose: My local additions to Autoconf macros dnl # Version: 1.0.5 dnl # Dialect: Autoconf (m4 and Bourne shell) dnl # Creator: Martin Vicente dnl # Created: 20 juin 2002 dnl # Remarks: From XCLIB - "Les outils de Martin" dnl # Contact: vicente@cena.fr dnl # dnl # Last Modified On: 24 janvier 2004 dnl # Last Modified By: Martin Vicente dnl # dnl # DESCRIPTION: dnl # LAYER-SYSTEM est une évolution du système de fabrication de XCLIB. dnl # XCLIB est une bibliothèque de fonctions à usage général. dnl # La bibliothèque "mini XCLIB" en est une mouture allégée destinée en dnl # particulier à une application locale au CENA (Centre d'Etudes de la dnl # Navigation Aérienne). dnl # dnl # Ce fichier apporte quelques macros supplémentaires pour Autoconf. dnl # Certaines offrent des fonctionnalités génériques, et ont pour ambition dnl # d'intégrer un jour la distribution Autoconf; et d'autres sont ici dnl # essentiellement pour alléger l'écriture du fichier «configure.in». dnl # Afin de les distinguer sans ambiguïté des macros standards Autoconf, dnl # elles sont préfixées par «MV_». dnl # dnl # REMARKS: dnl # dnl # ENVIRONMENT/PARAMETERS/OPTIONS: dnl # dnl # PROBLEMS: dnl # dnl # TODO: dnl # dnl # REVISION HISTORY: dnl # ## 21 novembre 2003 - Martin Vicente dnl # - Renommage de ce fichier en «martin.m4» pour tenir compte d'autres dnl # jeux de macros et éviter un conflit possible. dnl # ## 20 juin 2002 - Martin Vicente dnl # - Création du fichier «aclocal.m4» à partir de celui de XCLIB. dnl # dnl # MAINTAINERS: dnl # Martin Vicente dnl ########################################################################### dnl #++ dnl # LISTE DES MACROS: dnl # ================= dnl # dnl # MV_AUTOCONF_ERROR(TEXT) dnl # MV_LOWER dnl # MV_UPPER dnl # MV_DEL_ACCENT dnl # MV_CONCAT(VAR, N, STR) dnl # MV_SET_BRACKETS dnl # MV_PROG_ECHO_E dnl # MV_PROG_ECHO_N dnl # MV_PROG_ECHO dnl # MV_PROG_ECHO_ESCAPE dnl # MV_DEF_SET_COLORS dnl # MV_DEF_UNSET_COLORS dnl # MV_SET_COLORS dnl # MV_UNSET_COLORS dnl # MV_CONFIG_FD_IS_CHAR_DEVICE dnl # MV_SETUP_COLORS(FD) dnl # MV_COLOR_ON(FOREGROUND, BACKGROUND) dnl # MV_COLOR_OFF dnl # MV_TERM_SIZE dnl # MV_MSG(TEXT [, COLOR-ATTRIBUTS ]) dnl # MV_MSG_N(TEXT [, COLOR-ATTRIBUTS ]) dnl # MV_ERR_MSG(PREFIX, TEXT [, COLOR ]) dnl # MV_WARNING(TEXT [, COLOR ]) dnl # MV_ERROR(TEXT [, COLOR ]) dnl # MV_MSG_RESULT dnl # MV_ARG_ENABLE dnl # MV_FILL_COLUMNS(VAR, CH) dnl # MV_FILL_BACKGROUND(VAR, CH) dnl # MV_PROG_AUTOCONF dnl # MV_PROG_ACLOCAL dnl # MV_PROG_CTRACE dnl # MV_TOPDIR dnl # MV_STANDARD dnl # MV_TRANSFORM_MODULES(SRC-DIRS, LNK-DIR, &MODULES) dnl # MV_CONFIG_RULES(CONFIG-FILES, PRE-COMMAND, FILENAME) dnl # MV_OUTPUT(CONFIG-FILES, EXTRA-CMDS, INIT-CMDS) dnl # MV_MKLOG dnl # MV_MK_STANDARD dnl # MV_MK_OUTPUT(MAKEFILE-NAME, SUBDIRS, CONFIG-FILES, EXTRA-CMDS, INIT-CMDS) dnl # MV_SET_GCC_OPTIONS dnl # MV_SET_GXX_OPTIONS dnl # MV_PROG_GCC(-pipe -ansi -pedantic ...) dnl # MV_PROG_GXX(-pipe -ansi -pedantic ...) dnl # MV_PROG_CC dnl # MV_PROG_CXX dnl # dnl # -- A REVOIR -- dnl # dnl # MV_PREFIX_PROGRAM dnl # MV_PROG_MKDIRHIER dnl # MV_PROG_RMDIRHIER dnl # MV_PROG_LD dnl # MV_PROG_PERL(MIN-VERSION) dnl # MV_AUTOCONF_DIRS dnl # MV_DO_MICO dnl # MV_DO_OMNIORB dnl # MV_DO_OMNIORB2 dnl # MV_CHECK_XCLIB dnl # MV_CHECK_DPKG_VERSION dnl # MV_CHECK_CONFIG_FILES dnl #-- dnl ########################################################################### dnl # forloop(I, MIN, MAX, CMD) dnl # dnl # Extension M4. dnl # define([forloop], [pushdef([$1], [$2])_forloop([$1], [$2], [$3], [$4])popdef([$1])]) define([_forloop], [$4[]ifelse($1, [$3], , [define([$1], incr($1))_forloop([$1], [$2], [$3], [$4])])]) dnl ########################################################################### dnl # MV_AUTOCONF_ERROR(TEXT) dnl # dnl # Fonction d'erreur interne souvent utilisée pour, par exemple, tester dnl # l'invocation correcte d'une macro Autoconf. dnl # define(MV_AUTOCONF_ERROR, [dnl errprint([autoconf: *** Error: $1 - File "]__file__[" at line ]__line__[ ])dnl m4exit(1)]) dnl ########################################################################### dnl # MV_TOLOWER dnl # dnl # Transposition des caractères en minuscules. dnl # AC_DEFUN(MV_TOLOWER, [dnl TOLOWER="tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'" AC_SUBST(TOLOWER)]) dnl ########################################################################### dnl # MV_TOUPPER dnl # dnl # Transposition des caractères en majuscules. dnl # AC_DEFUN(MV_TOUPPER, [dnl TOUPPER="tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'" AC_SUBST(TOUPPER)]) dnl ########################################################################### dnl # MV_DEL_ACCENT dnl # dnl # Elimination des accents. dnl # define(MV_DEL_ACCENT, [dnl tr 'àçéèêëîïôöùüÂÇÉÈÊËÎÏÔÖÙÜ' 'aceeeeiioouuACEEEEIIOOUU']) dnl ########################################################################### dnl # MV_CONCAT(VAR, N, STR) dnl # dnl # Concatène «N» fois la chaîne «STR». L'ajoute à «VAR». dnl # define(MV_CONCAT, [dnl ifelse($#,3,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl { mv_v="$[]$1" mv_i=$2 while >/dev/null expr $mv_i; do mv_v="${mv_v}$3" mv_i=`expr $mv_i - 1` done $1=$mv_v }]) dnl ########################################################################### dnl # MV_SET_BRACKETS dnl # dnl # Pour utiliser le caractère «[», en évitant de jongler avec les dnl # «changequote». dnl # AC_DEFUN(MV_SET_BRACKETS, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl dnl changequote(«,»)dnl mv_LB=[ mv_RB=]«»dnl changequote([,])]) dnl ########################################################################### dnl # MV_PROG_ECHO_E dnl # dnl # Recherche une commande «echo» qui supporte la représentation dnl # "backslash-escaped" («\n», «\a», etc); et donc aussi la notation octale dnl # (ex: «\033»). dnl # Si une telle command est trouvée, la variable «ECHO_E» sera renseignée dnl # en conséquence, sinon elle sera vide. dnl # dnl # Le test canonique: define(mv_prog_echo_e__try, [dnl dnl # - la commande doit d'abord fonctionner sans retourner de statut d'erreur, >/dev/null 2>&1 $1 dnl dnl # - la notation "backslash-escaped" doit être interprétée, && test -z "`$1 '\a'|fgrep a`" dnl # alert character && test -z "`$1 '\b'|fgrep b`" dnl # backspace && test -z "`$1 '\c'|fgrep c`" dnl # print line without new-line && test -z "`$1 '\f'|fgrep f`" dnl # form-feed && test -z "`$1 '\n'|fgrep n`" dnl # new-line && test -z "`$1 '\r'|fgrep r`" dnl # carriage return && test -z "`$1 '\t'|fgrep t`" dnl # tab && test -z "`$1 '\v'|fgrep v`" dnl # vertical tab dnl # - et aussi la représentation octale. && test -z "`$1 '\033'|fgrep 33`"]) dnl # dnl # AC_DEFUN(MV_PROG_ECHO_E, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_MSG_CHECKING([if «echo» support backslash-escaped characters]) AC_CACHE_VAL(mv_cv_prog_ECHO_E, [dnl if mv_prog_echo_e__try(echo); then ECHO_E='echo' elif mv_prog_echo_e__try(echo -e); then ECHO_E='echo -e' elif mv_prog_echo_e__try(/bin/echo); then ECHO_E='/bin/echo' elif mv_prog_echo_e__try(/bin/echo -e); then ECHO_E='/bin/echo -e' else ECHO_E= fi mv_cv_prog_ECHO_E=$ECHO_E])dnl ECHO_E=$mv_cv_prog_ECHO_E if test -n "$ECHO_E"; then AC_MSG_RESULT([yes ($ECHO_E)]) else AC_MSG_RESULT([no]) fi[]dnl AC_SUBST(ECHO_E)]) dnl ########################################################################### dnl # MV_PROG_ECHO_N dnl # dnl # Si je trouve une commande «echo» qui permet de supprimer le passage à dnl # la ligne suivante, j'affecte les variables «ECHO_N», «_N», et «_C» en dnl # conséquence; et sinon, ces variable seront vides. dnl # Et si cette commande peut supporter également les séquences dnl # "backslash-escaped" (et la notation octale), c'est pas plus mal. dnl # dnl # Exemple d'utilisation: @ECHO_N@ @_N@ "Hello World!@_C@" dnl # dnl # Comme pour «MV_PROG_ECHO_E», le test se déroule en 2 phases: dnl # - vérifier que la commande ne renvoie pas un statut d'erreur; dnl # - vérifier que l'option «-n» ou la séquence «\c» est interprété. dnl # dnl # Test avec «-n»: define(mv_prog_echo_n__try_n, [dnl >/dev/null 2>&1 $1 && test -z "`$1 -n ''|fgrep n`"]) dnl # dnl # Test avec «\c»: define(mv_prog_echo_n__try_c, [dnl >/dev/null 2>&1 $1 && test -z "`$1 '\c'|fgrep c`"]) dnl # dnl # AC_DEFUN(MV_PROG_ECHO_N, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_PROG_ECHO_E])dnl AC_MSG_CHECKING([if «echo» can suppress trailing newline]) AC_CACHE_VAL(mv_cv_prog_ECHO_N, [dnl if test -n "$ECHO_E" && mv_prog_echo_n__try_n([$ECHO_E]); then ECHO_N=$ECHO_E; _N=-n; _C= elif test -n "$ECHO_E" && mv_prog_echo_n__try_c([$ECHO_E]); then ECHO_N=$ECHO_E; _N=; _C=\\c elif mv_prog_echo_n__try_n([echo]); then ECHO_N=echo; _N=-n; _C= elif mv_prog_echo_n__try_c([echo]); then ECHO_N=echo; _N=; _C=\\c elif mv_prog_echo_n__try_n([/bin/echo]); then ECHO_N=/bin/echo; _N=-n; _C= elif mv_prog_echo_n__try_c([/bin/echo]); then ECHO_N=/bin/echo; _N=; _C=\\c else ECHO_N=; _N=; _C= fi mv_cv_prog_ECHO_N=$ECHO_N; mv_cv_prog_ECHO_N_N=$_N; mv_cv_prog_ECHO_N_C=$_C])dnl ECHO_N=$mv_cv_prog_ECHO_N; _N=$mv_cv_prog_ECHO_N_N; _C=$mv_cv_prog_ECHO_N_C if test -n "$ECHO_N"; then AC_MSG_RESULT([yes (\$ECHO_N \$_N \"...\$_C\")]) else AC_MSG_RESULT([no]) fi[]dnl AC_SUBST(ECHO_N)AC_SUBST(_N)AC_SUBST(_C)]) dnl ########################################################################### dnl # MV_PROG_ECHO dnl # dnl # Recherche la "meilleur" commande pour la fonction «echo». dnl # La variable «ECHO» est renseignée en conséquence, ainsi que: dnl # «ECHO_E», «ECHO_N», «_N» et «_C». dnl # AC_DEFUN(MV_PROG_ECHO, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_PROG_ECHO_N])dnl AC_REQUIRE([MV_PROG_ECHO_E])dnl AC_MSG_CHECKING([the \"best\" «echo» command]) AC_CACHE_VAL(mv_cv_prog_ECHO, [dnl if test -n "$ECHO_N"; then ECHO=$ECHO_N elif test -n "$ECHO_E"; then ECHO=$ECHO_E else ECHO=echo fi mv_cv_prog_ECHO=$ECHO])dnl ECHO=$mv_cv_prog_ECHO if test -n "$ECHO"; then AC_MSG_RESULT([$ECHO]) else AC_MSG_RESULT([no]) AC_MSG_ERROR([NO ECHO COMMAND!!!]) fi[]dnl AC_SUBST(ECHO)]) dnl ########################################################################### dnl # MV_PROG_ECHO_ESCAPE dnl # dnl # Si «echo» supporte les séquences d'échappement, j'affecte la variable dnl # «ESC» avec la notation à utiliser; et sinon, cette dernière sera vide. dnl # Dans la foulée, on recherche aussi la meilleur commande «echo». dnl # Les variables remplacées sont: dnl # dnl # «ECHO», «ECHO_E», «ECHO_N», «_N», «_C» et «ESC». dnl # AC_DEFUN(MV_PROG_ECHO_ESCAPE, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_PROG_ECHO])dnl AC_MSG_CHECKING([if «$ECHO» support the escape character]) AC_CACHE_VAL(mv_cv_prog_ECHO_ESC, [dnl if >/dev/null 2>&1 $ECHO '\e' && test -z "`$ECHO '\e'|fgrep e`"; then ESC=\\e elif >/dev/null 2>&1 $ECHO '\033' && test -z "`$ECHO '\033'|fgrep 33`"; then ESC=\\033 else ESC= fi mv_cv_prog_ECHO_ESC=$ESC])dnl ESC=$mv_cv_prog_ECHO_ESC if test -n "$ESC"; then AC_MSG_RESULT([yes (\$ESC)]) else AC_MSG_RESULT([no]) fi[]dnl AC_SUBST(ESC)]) dnl ########################################################################### dnl # MV_DEF_SET_COLORS dnl # dnl # Définit la fonction «mv_set_colors» qui (ré-)active l'utilisation de la dnl # couleur et des attributs graphiques. dnl # AC_DEFUN(MV_DEF_SET_COLORS, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_SET_BRACKETS])dnl AC_REQUIRE([MV_PROG_ECHO_ESCAPE])dnl AC_REQUIRE([MV_DEF_UNSET_COLORS])dnl mv_set_colors() { if test -n "$ESC"; then RESET=${ESC}${mv_LB}0m # video attributes BOLD=${ESC}${mv_LB}1m BOLD_OFF=${ESC}${mv_LB}22m UNDERLINE=${ESC}${mv_LB}4m UNDERLINE_OFF=${ESC}${mv_LB}24m BLINK=${ESC}${mv_LB}5m BLINK_OFF=${ESC}${mv_LB}25m REVERSE=${ESC}${mv_LB}7m REVERSE_OFF=${ESC}${mv_LB}27m # foreground colors BLACK=${ESC}${mv_LB}30m RED=${ESC}${mv_LB}31m GREEN=${ESC}${mv_LB}32m YELLOW=${ESC}${mv_LB}33m BLUE=${ESC}${mv_LB}34m MAGENTA=${ESC}${mv_LB}35m CYAN=${ESC}${mv_LB}36m WHITE=${ESC}${mv_LB}37m DEFAULT=${ESC}${mv_LB}39m # background colors BG_BLACK=${ESC}${mv_LB}40m BG_RED=${ESC}${mv_LB}41m BG_GREEN=${ESC}${mv_LB}42m BG_YELLOW=${ESC}${mv_LB}43m BG_BLUE=${ESC}${mv_LB}44m BG_MAGENTA=${ESC}${mv_LB}45m BG_CYAN=${ESC}${mv_LB}46m BG_WHITE=${ESC}${mv_LB}47m BG_DEFAULT=${ESC}${mv_LB}49m # abreviations B=$BOLD b=$BOLD_OFF U=$UNDERLINE u=$UNDERLINE_OFF else mv_unset_colors fi }]) dnl ########################################################################### dnl # MV_DEF_UNSET_COLORS dnl # dnl # Définit la fonction «mv_unset_colors» qui supprime l'utilisation de la dnl # couleur et des attributs graphiques. dnl # AC_DEFUN(MV_DEF_UNSET_COLORS, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl mv_unset_colors() { RESET= # video attributes BOLD= BOLD_OFF= UNDERLINE= UNDERLINE_OFF= BLINK= BLINK_OFF= REVERSE= REVERSE_OFF= # foreground colors BLACK= RED= GREEN= YELLOW= BLUE= MAGENTA= CYAN= WHITE= DEFAULT= # background colors BG_BLACK= BG_RED= BG_GREEN= BG_YELLOW= BG_BLUE= BG_MAGENTA= BG_CYAN= BG_WHITE= BG_DEFAULT= # abreviations B= b= U= u= }]) dnl ########################################################################### dnl # MV_SET_COLORS dnl # dnl # (Ré-)active l'utilisation de la couleur, et du rendu en général. dnl # La réactivation sera effective, seulement si elle est possible. dnl # AC_DEFUN(MV_SET_COLORS, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_DEF_SET_COLORS])dnl mv_set_colors]) dnl ########################################################################### dnl # MV_UNSET_COLORS dnl # dnl # Supprime l'utilisation de la couleur, et du rendu en général. dnl # AC_DEFUN(MV_UNSET_COLORS, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_DEF_UNSET_COLORS])dnl mv_unset_colors]) dnl ########################################################################### dnl # MV_CONFIG_FD_IS_CHAR_DEVICE dnl # dnl # *** A REVOIR POUR DES ENVIRONNEMENTS NON GNU *** dnl # Les séquences d'échappement propre au rendu des terminaux, ne seront dnl # interprétées que si le périphérique est effectivement un terminal. dnl # Evident, mais encore fallait-il l'écrire :-) dnl # Cette macro permet donc de lever un peu le doute sur la nature du dnl # périphérique. «MV_CONFIG_FD_IS_CHAR_DEVICE» va générer le programme dnl # «config.fd_is_char_device». Il suffira de lui fournir en paramètre le dnl # descripteur de fichier utilisé pour accéder au périphérique en dnl # question. dnl # AC_DEFUN(MV_CONFIG_FD_IS_CHAR_DEVICE, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl { if test -z "$CC"; then >&2 echo "__file__:__line__: *** FATAL ERROR: NO C COMPILER DEFINED" exit 1 fi pgm=config.fd_is_char_device if test ! -f $pgm; then changequote(«,»)dnl cat >$pgm.c < #include #include #include int main(int argc, char *argv[]) { int fd; struct stat stat; if (argc != 2) return -1; fd = atoi(argv[1]); if (fstat(fd, &stat) == -1) return -1; return S_ISCHR(stat.st_mode) == 0; } EOT changequote([,])dnl $CC -o $pgm $pgm.c rm $pgm.c elif test ! -x $pgm; then chmod +x $pgm fi CONFIGURE_FILES="$pgm $CONFIGURE_FILES" unset pgm }]) dnl ########################################################################### dnl # MV_SETUP_COLORS(FD) dnl # AC_DEFUN(MV_SETUP_COLORS, [dnl ifelse($#,0,mv_fd=1,ifelse($#,1,mv_fd=$1,[[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])]])) AC_REQUIRE([MV_PROG_ECHO_ESCAPE])dnl AC_REQUIRE([MV_DEF_SET_COLORS])dnl AC_REQUIRE([MV_DEF_UNSET_COLORS])dnl if test -n "$ESC" && test -t $mv_fd; then MV_SET_COLORS mv_colors_on_fd_$1=yes else MV_UNSET_COLORS mv_colors_on_fd_$1=no fi]) dnl ########################################################################### dnl # MV_COLOR_ON(FOREGROUND, BACKGROUND) dnl # AC_DEFUN(MV_COLOR_ON, [dnl ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl if test "$silent" != yes; then MV_SETUP_COLORS(1) if test "$mv_colors_on_fd_1" = yes; then FOREGROUND=$[$1] BACKGROUND=$BG_[$2] $ECHO "COLOR ON${FOREGROUND}${BACKGROUND}" fi fi]) dnl ########################################################################### dnl # MV_COLOR_OFF dnl # AC_DEFUN(MV_COLOR_OFF, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl if test "$silent" != yes; then MV_SETUP_COLORS(1) if test "$mv_colors_on_fd_1" = yes; then $ECHO "COLOR OFF${RESET}" fi fi]) dnl ########################################################################### dnl # MV_TERM_SIZE dnl # dnl # Récupère les dimensions du terminal. dnl # Substitue «LINES» et «COLUMNS». dnl # dnl # o Pas portable entre U*ix: améliorer la portabilité. dnl # o Je préfère ne pas "cacher" ces valeurs afin de permettre une dnl # reconfiguration rapide par l'utilisateur. dnl # AC_DEFUN(MV_TERM_SIZE, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl dnl AC_MSG_CHECKING(terminal size) case `uname` in Linux) mv_term_spec=`stty size` LINES=`echo $mv_term_spec|awk '{ print $[]1 }'` COLUMNS=`echo $mv_term_spec|awk '{ print $[]2 }'` unset mv_term_spec ;; SunOS) mv_term_spec=`stty` changequote(,)dnl LINES=`echo $mv_term_spec|fgrep 'rows ='|sed 's/.*rows = \([0-9]*\).*/\1/'` COLUMNS=`echo $mv_term_spec|fgrep 'rows ='|sed 's/.*columns = \([0-9]*\).*/\1/'` changequote([, ])dnl unset mv_term_spec ;; *) LINES=0 COLUMNS=0 ;; esac AC_MSG_RESULT($COLUMNS x $LINES) AC_SUBST(LINES)dnl AC_SUBST(COLUMNS)]) dnl ########################################################################### dnl # MV_MSG(TEXT [, COLOR-ATTRIBUTS ]) dnl # dnl # Affiche un message. dnl # AC_DEFUN(MV_MSG, [dnl ifelse($#,1,,[ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])])dnl dnl if test "$silent" != yes; then MV_SETUP_COLORS(1) $ECHO "ifelse($#,2,[$2],${FOREGROUND})""$1""${RESET}${FOREGROUND-$DEFAULT}${BACKGROUND-$BG_DEFAULT}" fi]) dnl ########################################################################### dnl # MV_MSG_N(TEXT [, COLOR-ATTRIBUTS ]) dnl # dnl # Affiche un message sans passage à la ligne suivante. dnl # AC_DEFUN(MV_MSG_N, [dnl ifelse($#,1,,[ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])])dnl dnl if test "$silent" != yes; then MV_SETUP_COLORS(1) $ECHO_N $_N "ifelse($#,2,[$2],${FOREGROUND})""$1$_C""${RESET}${FOREGROUND-$DEFAULT}${BACKGROUND-$BG_DEFAULT}" fi]) dnl ########################################################################### dnl # MV_ERR_MSG(PREFIX, TEXT [, COLOR ]) dnl # dnl # Affiche un message d'erreur bien visible. dnl # AC_DEFUN(MV_ERR_MSG, [dnl ifelse($#,2,,[ifelse($#,3,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])])dnl AC_REQUIRE([MV_TERM_SIZE])dnl dnl { MV_SETUP_COLORS(2) dnl mv_prefix=`basename ${0}` mv_n=`expr length $mv_prefix` mv_n=`expr $mv_n + 2` # ": " mv_n=`expr $COLUMNS - $mv_n` mv_decor= mv_i=$mv_n while >/dev/null expr $mv_i; do mv_i=`expr $mv_i - 1` mv_decor="*$mv_decor" done unset mv_i unset mv_n if test -n "$1"; then mv_severity="${BOLD}$1${BOLD_OFF}: " else mv_severity= fi >&2 $ECHO "ifelse($#,3,${$3},${RED})${mv_prefix}: ${mv_decor}" >&2 $ECHO "ifelse($#,3,${$3},${RED})${mv_prefix}: *** ${mv_severity}patsubst([$2], [ ], [" >&2 $ECHO "ifelse($#,3,${$3},${RED})${mv_prefix}: *** ${mv_severity}])" >&2 $ECHO "ifelse($#,3,${$3},${RED})${mv_prefix}: ${mv_decor}${FOREGROUND-$RESET}" unset mv_prefix unset mv_decor if test "$silent" = yes; then $ECHO $_N "$RESET$_C"; fi }]) dnl ########################################################################### dnl # MV_WARNING(TEXT [, COLOR ]) dnl # dnl # Le texte du message sera affiché avec l'attribut "bold". dnl # Exemple d'utilisation: dnl # dnl # MV_WARNING([dnl dnl # Ligne 1 dnl # Ligne 2]) dnl # AC_DEFUN(MV_WARNING, [dnl ifelse($#,1,,[ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])])dnl dnl MV_ERR_MSG(Warning,${BOLD}patsubst([$1], [ ], [${BOLD_OFF} ${BOLD}])${BOLD_OFF})]) dnl ########################################################################### dnl # MV_ERROR(TEXT [, COLOR ]) dnl # dnl # Le texte du message sera affiché avec l'attribut "bold". dnl # Exemple d'utilisation: dnl # dnl # MV_ERROR([dnl dnl # Ligne 1 dnl # Ligne 2]) dnl # AC_DEFUN(MV_ERROR, [dnl ifelse($#,1,,[ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])])dnl dnl { MV_ERR_MSG(Error,${BOLD}patsubst([$1], [ ], [${BOLD_OFF} ${BOLD}])${BOLD_OFF}); exit 1; }]) dnl ########################################################################### dnl # MV_MSG_RESULT dnl # define(MV_MSG_RESULT, [dnl AC_REQUIRE([MV_PROG_ECHO])dnl $ECHO $_N "${CYAN}${_C}" AC_MSG_RESULT([$1]) $ECHO $_N "${FOREGROUND-$DEFAULT}$_C"]) dnl ########################################################################### dnl # MV_ARG_ENABLE dnl # AC_DEFUN(MV_ARG_ENABLE, [dnl { AC_ARG_ENABLE([$1],, [dnl enable_$1=`echo "$enableval"|MV_LOWER` if test "$enable_$1" != yes; then enable_$1=no; fi], [enable_$1=yes]) MV_MSG_RESULT([$3: $enable_$1]) dnl # Présentation de l'aide: AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl mv_len=`expr length "$2"` n=`expr 24 - $mv_len` v="$2" i=$n while >/dev/null expr $i; do v="$v " i=`expr $i - 1` done ac_help="$ac_help ${v}$3 (default=yes)" AC_DIVERT_POP() if test "$enable_$1" = yes; then : $4 else : $5 fi }dnl AC_SUBST(enable_$1)]) dnl ########################################################################### dnl # MV_FILL_COLUMNS(VAR, CH) dnl # dnl # Remplit la chaîne «VAR» avec (le caractère) «CH», autant de fois que la dnl # largeur du teminal. dnl # AC_DEFUN(MV_FILL_COLUMNS, [dnl ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_TERM_SIZE])dnl MV_CONCAT($1, $COLUMNS, $2)]) dnl ########################################################################### dnl # MV_FILL_BACKGROUND(VAR, CH) dnl # dnl # Remplit la chaîne «VAR» avec (le caractère) «CH», autant de fois que la dnl # largeur du teminal, et ajoute le caractère «\r». dnl # AC_DEFUN(MV_FILL_BACKGROUND, [dnl ifelse($#,2,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl MV_FILL_COLUMNS($1, $2); $1="$[]$1\r"]) dnl ########################################################################### dnl # MV_PROG_AUTOCONF dnl # AC_DEFUN(MV_PROG_AUTOCONF, [AC_CHECK_PROGS(AUTOCONF, autoconf, :)]) dnl ########################################################################### dnl # MV_PROG_ACLOCAL dnl # AC_DEFUN(MV_PROG_ACLOCAL, [AC_CHECK_PROGS(ACLOCAL, aclocal, :)]) dnl ########################################################################### dnl # MV_PROG_CTRACE dnl # AC_DEFUN(MV_PROG_CTRACE, [AC_CHECK_PROGS(CTRACE, ctrace, cat)]) AC_DEFUN(MV_PROG_CTRACE2, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl dnl { if test "$CTRACE" = yes; then PATH_saved=$PATH if test "$with_xc_libraries" = yes; then PATH=.:$PATH AC_PATH_PROG(CTRACE, ctrace) elif test -n "$with_xc_libraries" -a "$with_xc_libraries" != no; then CTRACE="LD_LIBRARY_PATH=$with_xc_libraries:$LD_LIBRARY_PATH `cd $with_xc_libraries && pwd`/ctrace" AC_MSG_RESULT(ctrace path set to $with_xc_libraries/ctrace) else PATH=.:$PATH LD_LIBRARY_PATH_saved=$LD_LIBRARY_PATH LD_LIBRARY_PATH=$with_xc_libraries:$LD_LIBRARY_PATH AC_PATH_PROG(CTRACE, ctrace) LD_LIBRARY_PATH=$LD_LIBRARY_PATH_saved fi PATH=$PATH_saved else CTRACE=cat fi AC_SUBST(CTRACE) }]) dnl ########################################################################### dnl # MV_TOPDIR dnl # AC_DEFUN(MV_TOPDIR, [dnl topdir=`/bin/pwd` AC_SUBST(topdir)]) dnl ########################################################################### dnl # MV_STANDARD dnl # AC_DEFUN(MV_STANDARD, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([MV_PROG_ECHO_ESCAPE])dnl AC_REQUIRE([MV_DEF_SET_COLORS])dnl AC_REQUIRE([AC_PROG_LN_S])dnl AC_REQUIRE([MV_PROG_AUTOCONF])dnl AC_REQUIRE([MV_PROG_ACLOCAL])dnl AC_REQUIRE([MV_PROG_CTRACE])dnl AC_REQUIRE([AC_PROG_RANLIB])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl AC_REQUIRE([MV_TOPDIR])dnl ]) dnl ########################################################################### dnl # MV_TRANSFORM_MODULES(SRC-DIRS, LNK-DIR, &MODULES) dnl # AC_DEFUN(MV_TRANSFORM_MODULES, [dnl ifelse($#,3,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_REQUIRE([AC_PROG_LN_S])dnl { AC_MSG_RESULT(transforming module's names) mv_SRC_DIRS=$1 mv_LNK_DIR=$2 mv_MODULES=$$3 for mv_dir in $mv_SRC_DIRS; do if test ! -d $mv_dir; then MV_WARNING([dnl No «`basename $mv_dir`» directory in `dirname $mv_dir`]) fi done if test ! -d $mv_LNK_DIR; then mkdir -p $mv_LNK_DIR; fi TRANSFORM_MODULES= for m in $mv_MODULES; do m=`echo $m|sed 's/\.o$//'` ok=no for d in $mv_SRC_DIRS; do fs=$d/$m.cc if test -f $fs; then ok=yes fl=$mv_LNK_DIR/`echo $m.cc|sed 's/\//__/g'` TRANSFORM_MODULES="$TRANSFORM_MODULES $fl" if test ! -L $fl; then MV_MSG_RESULT([ ]- `basename $fl`) ( cd `dirname $fl` && $LN_S $fs `basename $fl` ) fi else fs=$d/$m.c if test -f $fs; then ok=yes fl=$mv_LNK_DIR/`echo $m.c|sed 's/\//__/g'` TRANSFORM_MODULES="$TRANSFORM_MODULES $fl" if test ! -L $fl; then MV_MSG_RESULT([ ]- `basename $fl`) ( cd `dirname $fl` && $LN_S $fs `basename $fl` ) fi fi fi if test $ok = no; then MV_ERROR(Le fichier «$fs» n'existe pas); fi done done mv_modules= for mv_mod in $mv_MODULES; do mv_modules="$mv_modules `echo $mv_mod|sed 's/\//__/g'`" done $3=$mv_modules AC_SUBST(TRANSFORM_MODULES)dnl }]) dnl ########################################################################### dnl # MV_CONFIG_RULES(CONFIG-FILES, PRE-COMMAND, FILENAME) dnl # dnl # Génère le fichier, dont le nom sera par défaut «config.rules», dnl # contenant les règles destinées à la mise-à-jour des fichiers FILES. dnl # define(MV_CONFIG_RULES, [dnl AC_REQUIRE([MV_TOPDIR])dnl mv_config_files="$1" ifelse($#,3,[CONFIG_RULES=$3],[CONFIG_RULES=config.rules]) if test ! -f $CONFIG_RULES; then echo "creating $CONFIG_RULES" touch $CONFIG_RULES >>$CONFIG_RULES echo '## -*- makefile -*-' >>$CONFIG_RULES echo '## Generated automatically by configure.' >>$CONFIG_RULES echo '' >>$CONFIG_RULES echo '##--------------------------------------------------' >>$CONFIG_RULES echo '## Inclure ce fichier dans un makefile pour gérer la' >>$CONFIG_RULES echo '## mise-à-jour des fichiers configurés.' >>$CONFIG_RULES echo '##--------------------------------------------------' >>$CONFIG_RULES echo '' else echo "updating $CONFIG_RULES" fi for mv_cf in $mv_config_files; do case $mv_cf in *:*) mv_of=`echo $mv_cf|sed 's%:.*$%%'` mv_cf=`echo $mv_cf|sed 's%^.*:%%'` ;; *) mv_of=$mv_cf mv_cf=$mv_cf.in ;; esac mv_string1='$(topdir)/'$mv_of': $(top_srcdir)/'$mv_cf mv_string2=' cd $(topdir) && CONFIG_FILES='$mv_of':'$mv_cf' ./config.status' if >/dev/null grep -Fx "$mv_string1" $CONFIG_RULES; then continue fi >>$CONFIG_RULES echo "$mv_string1" ifelse($#,2,[dnl >>$CONFIG_RULES echo ' ]$2[' ], ifelse($#,3,[dnl >>$CONFIG_RULES echo ' ]$2[' ])) >>$CONFIG_RULES echo "$mv_string2" >>$CONFIG_RULES echo '' done dnl # Il faudra que je trouve la technique M4 (et non shell) pour que le dnl # traitement final effectif de MV_CONFIG_RULES, se fasse lors du dernier dnl # appel de la macro (voir AC_DIVERSION...). >>$CONFIG_RULES echo '## [END OF FILE]' CONFIGURE_FILES="`echo $CONFIG_RULES $CONFIGURE_FILES`" AC_SUBST(CONFIG_RULES)]) dnl ########################################################################### dnl # MV_OUTPUT(CONFIG-FILES, EXTRA-CMDS, INIT-CMDS) dnl # dnl # Idem que «AC_OUTPUT», et substitue «OUTPUT_FILES» et «CONFIGURE_FILES». dnl # Ces deux variables sont utiles pour nettoyer la distribution. Exemple: dnl # dnl # distclean:: ; $(RM) @OUTPUT_FILES@ @CONFIGURE_FILES@ dnl # AC_DEFUN(MV_OUTPUT, [dnl mv_config_files="$1" OUTPUT_FILES= for mv_cf in $mv_config_files; do case $mv_cf in *:*) OUTPUT_FILES="$OUTPUT_FILES `echo $mv_cf|sed 's%:.*$%%'`";; *) OUTPUT_FILES="$OUTPUT_FILES $mv_cf";; esac done OUTPUT_FILES=`echo $OUTPUT_FILES` CONFIGURE_FILES="`echo $CONFIGURE_FILES config.log config.status config.cache`" AC_SUBST(OUTPUT_FILES)dnl AC_SUBST(CONFIGURE_FILES)dnl AC_OUTPUT($mv_config_files, $2, $3)]) dnl ########################################################################### dnl # MV_MKLOG dnl # dnl # Macro très spécialisée destinée à l'affichage dans LAYER-SYSTEM. dnl # Substitue «MK_MKLOG» et «MK_BG_SPACES». dnl # Remis à jour à chaque appel de configure. dnl # AC_DEFUN(MV_MKLOG, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl MV_FILL_BACKGROUND(MK_MKLOG, [.]) MV_CONCAT(MK_MKLOG,`expr $COLUMNS / 8`,\\t) MV_FILL_BACKGROUND(MK_BG_SPACES, [[[ ]]]) AC_SUBST(MK_MKLOG)dnl AC_SUBST(MK_BG_SPACES)]) dnl ########################################################################### dnl # MV_MK_STANDARD dnl # AC_DEFUN(MV_MK_STANDARD, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl AC_CONFIG_AUX_DIR(mk) MV_STANDARD MV_TOLOWER MV_TOUPPER MV_MKLOG PACKAGE=${PACKAGE-PACKAGE} VERSION=${VERSION-0.0.0} SOMAJOR=${SOMAJOR-`echo $VERSION|sed 's/\..*//'`} pkgdatadir=$datadir/$PACKAGE pkgsysconfdir=$sysconfdir/$PACKAGE pkglocalstatedir=$localstatedir/$PACKAGE pkgsharedstatedir=$sharedstatedir/$PACKAGE package_data=$pkgdatadir/data dnl # Obligatoires: AC_SUBST(PACKAGE)dnl AC_SUBST(VERSION)dnl dnl # Ici car très communément utilisés: AC_SUBST(PROGRAMS)dnl AC_SUBST(INCNAME)dnl AC_SUBST(LIBNAME)dnl AC_SUBST(ARCHIVE)dnl AC_SUBST(LIBRARY)dnl AC_SUBST(SOMAJOR)dnl AC_SUBST(LIBSONAME)dnl AC_SUBST(MODULES)dnl AC_SUBST(PLUGINS)dnl AC_SUBST(HEADERS)dnl AC_SUBST(MANUALS)dnl AC_SUBST(SUBDIRS)dnl dnl # Diverses variables employées par LAYER-SYSTEM: AC_SUBST(LAYERS)dnl AC_SUBST(DEPINCS)dnl AC_SUBST(DEPLIBS)dnl AC_SUBST(DEFINES)dnl AC_SUBST(INCLUDES)dnl AC_SUBST(LIBRARIES)dnl AC_SUBST(RPATH)dnl AC_SUBST(LOCAL_LNK_DIR)dnl AC_SUBST(LOCAL_SRC_DIRS)dnl AC_SUBST(LOCAL_INC_DIRS)dnl AC_SUBST(LOCAL_MAN_DIRS)dnl AC_SUBST(pkgdatadir)dnl AC_SUBST(pkgsysconfdir)dnl AC_SUBST(pkglocalstatedir)dnl AC_SUBST(pkgsharedstatedir)dnl AC_SUBST(package_data)dnl dnl ## dnl # PERL PART AC_SUBST(PERL)dnl dnl ## dnl # PYTHON PART AC_SUBST(PYTHON)dnl AC_SUBST(PYTHON_VERSION)dnl AC_SUBST(PYTHON_LIBDIR)dnl dnl ## dnl # C PART AC_SUBST(CC)dnl AC_SUBST(CPP)dnl dnl ## dnl # C++ PART AC_SUBST(CXX)dnl AC_SUBST(CXXCPP)dnl ]) dnl ########################################################################### dnl # MV_MK_OUTPUT(MAKEFILE-NAME, SUBDIRS, CONFIG-FILES, EXTRA-CMDS, INIT-CMDS) dnl # dnl # Idem que «MV_OUTPUT», mais gère en plus les fichiers pour LAYER-SYSTEM dnl # grâce au fichier «system.rules» qui sera généré. dnl # Prend 2 paramètres supplémentaires afin d'indiquer les makefile à créer dnl # à l'aide de la liste des répertoires fournis. dnl # Substitue les variables «topdir» et «makefile». dnl # Appel également MV_TRANSFORM_MODULES. dnl # AC_DEFUN(MV_MK_OUTPUT, [dnl MV_MK_STANDARD dnl # Cette partie est certainement à isoler dans une macro à part... abssrcdir=`cd $srcdir && /bin/pwd` LOCAL_INC_DIRS=`for d in $LOCAL_INC_DIRS; do echo -n " $abssrcdir/$d"; done` LOCAL_SRC_DIRS=`for d in $LOCAL_SRC_DIRS; do echo -n " $abssrcdir/$d"; done` LOCAL_MAN_DIRS=`for d in $LOCAL_MAN_DIRS; do echo -n " $abssrcdir/$d"; done` if test -n "$LOCAL_LNK_DIR"; then LOCAL_LNK_DIR=$topdir/$LOCAL_LNK_DIR MV_TRANSFORM_MODULES($LOCAL_SRC_DIRS, $LOCAL_LNK_DIR, MODULES) fi dnl # makefile=$1 mv_subdirs="$2" if test ! -d $srcdir/mk; then MV_ERROR([dnl No «mk» (LAYER-SYSTEM) directory in «$srcdir»]) fi if test ! -f $srcdir/mk/private.mk.in; then MV_ERROR([dnl No «mk/private.mk.in» (LAYER-SYSTEM) file in «$srcdir»]) fi # Prise en compte automatique des fichiers de LAYER-SYSTEM mv_system_files=`cd $srcdir && 2>/dev/null ls mk/*.in|fgrep -xv mk/private.mk.in|sed 's/\.in$//g'` if test -z "$mv_system_files"; then MV_WARNING([dnl No LAYER-SYSTEM files in «$srcdir/mk/»]) fi MV_CONFIG_RULES($mv_system_files, [@ $(~autoconf)], system.rules) mv_config_files=$mv_system_files if test -n "$makefile" -a -n "$mv_subdirs"; then for mv_subdir in $mv_subdirs; do if test ! -d $srcdir/$mv_subdir; then MV_ERROR([No «$mv_subdir» directory!]) fi if test ! -f $srcdir/$mv_subdir/$makefile.in; then MV_ERROR([No $makefile in «$mv_subdir» source directory!]) fi mv_config_files="$mv_config_files $mv_subdir/.private.mk:mk/private.mk.in" mv_config_files="$mv_config_files $mv_subdir/$makefile" done fi AC_SUBST(makefile)dnl MV_OUTPUT($mv_config_files $3, $4, $5)]) dnl ########################################################################### dnl # MV_SET_GCC_OPTIONS dnl # AC_DEFUN(MV_SET_GCC_OPTIONS, [dnl dnl GCC_OVERALL_OPTIONS=" -pipe" GCC_WARNING_OPTIONS=" -Wall -W -Wmissing-prototypes -Wshadow -Wwrite-strings\ -Wcast-qual -Winline" GCC_DEBUG_OPTIONS=" -fno-builtin -g" # OPTIMIZE: Attention «-fshort-enums» est très délicat à utiliser. Il impose # que tous les composants d'une application aient été générés de cette manière. GCC_OPTIMIZE_OPTIONS=" -O2 -ffast-math -fomit-frame-pointer" GCC_PIC_OPTIONS=" -fPIC" GNU_LINKER_OPTIONS=" -warn-once -warn-common" if test -n "`echo $GNU_LINKER_OPTIONS`"; then GCC_LINKER_OPTIONS="\ $GCC_LINKER_OPTIONS -Wl,`echo $GNU_LINKER_OPTIONS|sed 's/ /,/g'`" fi GCC_SHARED_OPTIONS=" -shared" dnl AC_SUBST(GCC_WARNING_OPTIONS)dnl AC_SUBST(GCC_DEBUG_OPTIONS)dnl AC_SUBST(GCC_OPTIMIZE_OPTIONS)dnl AC_SUBST(GCC_PIC_OPTIONS)dnl AC_SUBST(GCC_LINKER_OPTIONS)dnl AC_SUBST(GCC_SHARED_OPTIONS)]) dnl ########################################################################### dnl # MV_SET_GXX_OPTIONS dnl # AC_DEFUN(MV_SET_GXX_OPTIONS, [dnl dnl GXX_OVERALL_OPTIONS=" -pipe" GXX_WARNING_OPTIONS=" -Wall -W -Wmissing-prototypes -Wshadow -Wwrite-strings\ -Wcast-qual -Winline" GXX_DEBUG_OPTIONS=" -fno-builtin -g" # OPTIMIZE: Attention «-fshort-enums» est très délicat à utiliser. Il impose # que tous les composants d'une application aient été générés de cette manière. GXX_OPTIMIZE_OPTIONS=" -O2 -ffast-math -fomit-frame-pointer" GXX_PIC_OPTIONS=" -fPIC" GNU_LINKER_OPTIONS=" -warn-once -warn-common" if test -n "`echo $GNU_LINKER_OPTIONS`"; then GXX_LINKER_OPTIONS="\ $GXX_LINKER_OPTIONS -Wl,`echo $GNU_LINKER_OPTIONS|sed 's/ /,/g'`" fi GXX_SHARED_OPTIONS=" -shared" dnl AC_SUBST(GXX_WARNING_OPTIONS)dnl AC_SUBST(GXX_DEBUG_OPTIONS)dnl AC_SUBST(GXX_OPTIMIZE_OPTIONS)dnl AC_SUBST(GXX_PIC_OPTIONS)dnl AC_SUBST(GXX_LINKER_OPTIONS)dnl AC_SUBST(GXX_SHARED_OPTIONS)]) dnl ########################################################################### dnl # MV_PROG_GCC(-pipe -ansi -pedantic ...) dnl # dnl # Vite fait, bien fait ;-) dnl # Impose gcc comme compilateur C. dnl # Définit CC et CPP, ainsi que d'autres variables à utiliser dans un dnl # makefile. dnl # AC_DEFUN(MV_PROG_GCC, [dnl AC_BEFORE([$0], MV_CONFIG_FD_IS_CHAR_DEVICE)dnl AC_REQUIRE([MV_SET_GCC_OPTIONS])dnl MV_MSG_RESULT([GNU C compiler set]) AC_CACHE_VAL(ac_cv_prog_CC, [ac_cv_prog_CC=`echo gcc $1`]) CC=$ac_cv_prog_CC AC_PROG_CC_WORKS AC_PROG_CC_GNU AC_PROG_CC_G if test $ac_cv_prog_gcc = yes; then GCC=yes; else GCC=; fi AC_CACHE_VAL(ac_cv_prog_CPP, [ac_cv_prog_CPP="$CC -E"]) CPP=$ac_cv_prog_CPP CC_WARNING_OPTIONS='$(GCC_WARNING_OPTIONS)' CC_DEBUG_OPTIONS='$(GCC_DEBUG_OPTIONS)' CC_OPTIMIZE_OPTIONS='$(GCC_OPTIMIZE_OPTIONS)' CC_PIC_OPTIONS='$(GCC_PIC_OPTIONS)' CC_LINKER_OPTIONS='$(GCC_LINKER_OPTIONS)' CC_SHARED_OPTIONS='$(GCC_SHARED_OPTIONS)' AC_SUBST(GCC)dnl AC_SUBST(CC)dnl AC_SUBST(CPP)dnl AC_SUBST(CC_WARNING_OPTIONS)dnl AC_SUBST(CC_DEBUG_OPTIONS)dnl AC_SUBST(CC_OPTIMIZE_OPTIONS)dnl AC_SUBST(CC_PIC_OPTIONS)dnl AC_SUBST(CC_LINKER_OPTIONS)dnl AC_SUBST(CC_SHARED_OPTIONS)]) dnl ########################################################################### dnl # MV_PROG_GXX(-pipe -ansi -pedantic ...) dnl # dnl # Vite fait, bien fait ;-) dnl # Impose g++ comme compilateur C++. dnl # Définit CXX et CXXCPP, ainsi que d'autres variables à utiliser dans un dnl # makefile. dnl # AC_DEFUN(MV_PROG_GXX, [dnl AC_BEFORE([$0], MV_CONFIG_FD_IS_CHAR_DEVICE)dnl AC_REQUIRE([MV_SET_GXX_OPTIONS])dnl MV_MSG_RESULT([GNU C++ compiler set]) AC_CACHE_VAL(ac_cv_prog_CXX, [ac_cv_prog_CXX=`echo g++ $1`]) CXX=$ac_cv_prog_CXX AC_PROG_CXX_WORKS AC_PROG_CXX_GNU AC_PROG_CXX_G if test $ac_cv_prog_gxx = yes; then GXX=yes; else GXX=; fi AC_CACHE_VAL(ac_cv_prog_CXXCPP, [ac_cv_prog_CXXCPP="$CXX -E"]) CXXCPP=$ac_cv_prog_CXXCPP CXX_WARNING_OPTIONS='$(GXX_WARNING_OPTIONS)' CXX_DEBUG_OPTIONS='$(GXX_DEBUG_OPTIONS)' CXX_OPTIMIZE_OPTIONS='$(GXX_OPTIMIZE_OPTIONS)' CXX_PIC_OPTIONS='$(GXX_PIC_OPTIONS)' CXX_LINKER_OPTIONS='$(GXX_LINKER_OPTIONS)' CXX_SHARED_OPTIONS='$(GXX_SHARED_OPTIONS)' AC_SUBST(GXX)dnl AC_SUBST(CXX)dnl AC_SUBST(CXXCPP)dnl AC_SUBST(CXX_WARNING_OPTIONS)dnl AC_SUBST(CXX_DEBUG_OPTIONS)dnl AC_SUBST(CXX_OPTIMIZE_OPTIONS)dnl AC_SUBST(CXX_PIC_OPTIONS)dnl AC_SUBST(CXX_LINKER_OPTIONS)dnl AC_SUBST(CXX_SHARED_OPTIONS)]) dnl ########################################################################### dnl # MV_PROG_CC dnl # dnl # Comme AC_PROG_CC, avec AC_PROG_CPP, et quelques trucs en plus. dnl # Définit également des options qui seront choisies en appelant make. dnl # AC_DEFUN(MV_PROG_CC, [dnl AC_BEFORE([$0], MV_CONFIG_FD_IS_CHAR_DEVICE)dnl AC_REQUIRE([MV_SET_GCC_OPTIONS])dnl { dnl # If the user did not set CFLAGS, set it now to keep dnl # the AC_PROG_CC macro from adding "-g -O2". if test "${CFLAGS+set}" != set; then CFLAGS=; fi AC_PROG_CC if test "$GCC" = yes; then MV_MSG_RESULT([Congratulations: You are using GNU CC ($CC). The best!]) CC_OVERALL_OPTIONS=$GCC_OVERALL_OPTIONS CC_WARNING_OPTIONS='$(GCC_WARNING_OPTIONS)' CC_DEBUG_OPTIONS='$(GCC_DEBUG_OPTIONS)' CC_OPTIMIZE_OPTIONS='$(GCC_OPTIMIZE_OPTIONS)' CC_PIC_OPTIONS='$(GCC_PIC_OPTIONS)' CC_SHARED_OPTIONS='$(GCC_SHARED_OPTIONS)' CC_LINKER_OPTIONS='$(GCC_LINKER_OPTIONS)' else AC_MSG_RESULT([Why don't use GNU CC?]) fi CC=`echo $CC $CC_OVERALL_OPTIONS` AC_PROG_CPP } AC_SUBST(GCC)dnl AC_SUBST(CC_WARNING_OPTIONS)dnl AC_SUBST(CC_DEBUG_OPTIONS)dnl AC_SUBST(CC_OPTIMIZE_OPTIONS)dnl AC_SUBST(CC_PIC_OPTIONS)dnl AC_SUBST(CC_LINKER_OPTIONS)dnl AC_SUBST(CC_SHARED_OPTIONS)dnl ]) dnl ########################################################################### dnl # MV_PROG_CXX dnl # dnl # Comme AC_PROG_CXX, avec AC_PROG_CXXCPP, et quelques trucs en plus. dnl # Définit également des options qui seront choisies en appelant make. dnl # AC_DEFUN(MV_PROG_CXX, [dnl AC_BEFORE([$0], MV_CONFIG_FD_IS_CHAR_DEVICE)dnl AC_REQUIRE([MV_SET_GXX_OPTIONS])dnl { dnl # If the user did not set CFLAGS, set it now to keep dnl # the AC_PROG_CXX macro from adding "-g -O2". if test "${CFLAGS+set}" != set; then CFLAGS=; fi AC_PROG_CXX if test "$GXX" = yes; then MV_MSG_RESULT([Congratulations: You are using GNU CXX ($CXX). The best!]) CXX_OVERALL_OPTIONS=$GXX_OVERALL_OPTIONS CXX_WARNING_OPTIONS='$(GXX_WARNING_OPTIONS)' CXX_DEBUG_OPTIONS='$(GXX_DEBUG_OPTIONS)' CXX_OPTIMIZE_OPTIONS='$(GXX_OPTIMIZE_OPTIONS)' CXX_PIC_OPTIONS='$(GXX_PIC_OPTIONS)' CXX_SHARED_OPTIONS='$(GXX_SHARED_OPTIONS)' CXX_LINKER_OPTIONS='$(GXX_LINKER_OPTIONS)' else AC_MSG_RESULT([Why don't use GNU C++?]) fi CXX=`echo $CXX $CXX_OVERALL_OPTIONS` AC_PROG_CXXCPP } AC_SUBST(GXX)dnl AC_SUBST(CXX_WARNING_OPTIONS)dnl AC_SUBST(CXX_DEBUG_OPTIONS)dnl AC_SUBST(CXX_OPTIMIZE_OPTIONS)dnl AC_SUBST(CXX_PIC_OPTIONS)dnl AC_SUBST(CXX_LINKER_OPTIONS)dnl AC_SUBST(CXX_SHARED_OPTIONS)dnl ]) dnl ########################################################################### dnl # A REVOIR/A RELIRE dnl ########################################################################### dnl ########################################################################### dnl # MV_PREFIX_PROGRAM dnl # dnl # Une simple ré-écriture de «AC_PREFIX_PROGRAM» juste pour autoriser le dnl # caractère «-» dans le nom du programme. dnl # AC_DEFUN(MV_PREFIX_PROGRAM, [dnl if test "x$prefix" = xNONE; then changequote(«, »)dnl define(«AC_VAR_NAME», translit($1, -[a-z], _[A-Z]))dnl changequote([,])dnl dnl We reimplement AC_MSG_CHECKING (mostly) to avoid the ... in the middle. echo $ac_n "checking for prefix by $ac_c" 1>&AC_FD_MSG AC_PATH_PROG(AC_VAR_NAME, $1) changequote(«,»)dnl if test -n "$ac_cv_path_«»AC_VAR_NAME"; then prefix=`echo $ac_cv_path_«»AC_VAR_NAME|sed 's%/[^/][^/]*//*[^/][^/]*$%%'` changequote([,])dnl fi fi undefine([AC_VAR_NAME])]) dnl ########################################################################### dnl # MV_PROG_MKDIRHIER dnl # AC_DEFUN(MV_PROG_MKDIRHIER, [dnl if test `uname` = Linux; then AC_PATH_PROGS(MKDIRHIER, mkinstalldirs mkdirhier, install -d, $PATH:$srcdir) else AC_PATH_PROGS(MKDIRHIER, mkinstalldirs mkdirhier, mkdir -p, $PATH:$srcdir) fi]) dnl ########################################################################### dnl # MV_PROG_RMDIRHIER dnl # AC_DEFUN(MV_PROG_RMDIRHIER, [dnl if test `uname` = Linux; then AC_PATH_PROG(RMDIRHIER, rmdirhier, rmdir -p, $PATH:$srcdir) else RMDIRHIER="rmdir -p" fi]) dnl ########################################################################### dnl # MV_PROG_LD dnl # AC_DEFUN(MV_PROG_LD, [dnl AC_MSG_CHECKING(for the \"front-end\" linker to use) ifelse(AC_LANG, C, [ LD=$CC AC_MSG_RESULT($LD)], ifelse(AC_LANG, CPLUSPLUS, [ LD=$CXX AC_MSG_RESULT($LD)], LD=${CC:-cc} AC_MSG_RESULT($LD))) AC_SUBST(LD)]) dnl ########################################################################### dnl # MV_PROG_PERL(MIN-VERSION) dnl # AC_DEFUN(MV_PROG_PERL, [{dnl mv_requested_version=$1 changequote(,) mv_requested_major_version=`echo $mv_requested_version|sed -n 's/^\([^.]*\).*$/\1/p'` mv_requested_version=`echo $mv_requested_version|sed -n "s/^$mv_requested_major_version\.\(.*$\)/\1/p"` mv_requested_minor_version=`echo $mv_requested_version|sed -n 's/^\([^.]*\).*$/\1/p'` mv_requested_version=`echo $mv_requested_version|sed -n "s/^$mv_requested_minor_version\.\(.*$\)/\1/p"` mv_requested_micro_version=`echo $mv_requested_version|sed -n 's/^\([^.]*\).*$/\1/p'` mv_requested_version=`echo $mv_requested_version|sed -n "s/^$mv_requested_micro_version\.\(.*$\)/\1/p"` changequote([,]) if test -z "$mv_requested_major_version"\ -o -z "$mv_requested_minor_version"\ -o -z "$mv_requested_micro_version"\ -o -n "$mv_requested_version"; then test "$silent" != yes && MV_WARNING(Un problème d'analyse de la version demandée de Perl) fi mv_requested_major_version=`echo $mv_requested_major_version|sed 's/^0*//'` mv_requested_minor_version=`echo $mv_requested_minor_version|sed 's/^0*//'` mv_requested_micro_version=`echo $mv_requested_micro_version|sed 's/^0*//'` mv_requested_version=$mv_requested_major_version.$mv_requested_minor_version.$mv_requested_micro_version MV_MSG(You want Perl version \"$mv_requested_version\":, $CYAN) AC_CHECK_PROGS(PERL, perl) if test -z "$PERL"; then MV_ERROR(No PERL interpreter found!!!); fi AC_REQUIRE([MV_SET_BRACKETS])dnl mv_string='print $'"${mv_RB};" PERL_VERSION=`$PERL -e "$mv_string;"` MV_MSG_N(Perl version found is \"$PERL_VERSION\"..., $CYAN) changequote(,) PERL_MAJOR_VERSION=`echo $PERL_VERSION|sed -n 's/^\([^.]*\).*$/\1/p'` PERL_VERSION=`echo $PERL_VERSION|sed -n "s/^$PERL_MAJOR_VERSION\.\(.*$\)/\1/p"` PERL_MINOR_VERSION=`echo $PERL_VERSION|sed -n 's/^\(...\).*$/\1/p'` PERL_VERSION=`echo $PERL_VERSION|sed -n "s/^$PERL_MINOR_VERSION\(.*$\)/\1/p"` dnl # Un doute ici: 03 doit-il correspondre à 3 ou 30? PERL_MICRO_VERSION=$PERL_VERSION changequote([,]) if test -z "$PERL_MAJOR_VERSION"\ -o -z "$PERL_MINOR_VERSION"\ -o -z "$PERL_MICRO_VERSION"; then test "$silent" != yes && MV_MSG(); MV_WARNING(Un problème d'analyse de la version trouvée de Perl) fi PERL_MAJOR_VERSION=`echo $PERL_MAJOR_VERSION|sed 's/^0*//'` PERL_MINOR_VERSION=`echo $PERL_MINOR_VERSION|sed 's/^0*//'` PERL_MICRO_VERSION=`echo $PERL_MICRO_VERSION|sed 's/^0*//'` AC_SUBST(PERL_MAJOR_VERSION)dnl AC_SUBST(PERL_MINOR_VERSION)dnl AC_SUBST(PERL_MICRO_VERSION)dnl PERL_VERSION=$PERL_MAJOR_VERSION.$PERL_MINOR_VERSION.$PERL_MICRO_VERSION AC_SUBST(PERL_VERSION)dnl MV_MSG([ ]and standardized version is \"$PERL_VERSION\", $CYAN) if test $PERL_MAJOR_VERSION -lt $mv_requested_major_version\ -o $PERL_MINOR_VERSION -lt $mv_requested_minor_version\ -o $PERL_MICRO_VERSION -lt $mv_requested_micro_version; then test "$silent" != yes && MV_WARNING(La version demandée de Perl n'a pas été trouvée) else MV_MSG(Fine: Version of Perl requested is found, $CYAN) fi }]) dnl ########################################################################### dnl # MV_AUTOCONF_DIRS dnl # AC_DEFUN(MV_AUTOCONF_DIRS, [dnl dnl # test "$prefix" = NONE && prefix=$ac_default_prefix test "$exec_prefix" = NONE && exec_prefix=$prefix dnl # test "$libdir" = '${exec_prefix}/lib' && libdir=${exec_prefix}/lib test "$libexecdir" = '${exec_prefix}/libexec' && libexecdir=${exec_prefix}/libexec test "$sbindir" = '${exec_prefix}/sbin' && sbindir=${exec_prefix}/sbin test "$bindir" = '${exec_prefix}/bin' && bindir=${exec_prefix}/bin test "$datadir" = '${prefix}/share' && datadir=${prefix}/share test "$sysconfdir" = '${prefix}/etc' && sysconfdir=${prefix}/etc test "$localstatedir" = '${prefix}/var' && localstatedir=${prefix}/var test "$sharedstatedir" = '${prefix}/com' && sharedstatedir=${prefix}/com test "$mandir" = '${prefix}/man' && mandir=${prefix}/man test "$infodir" = '${prefix}/info' && infodir=${prefix}/info test "$includedir" = '${prefix}/include' && includedir=${prefix}/include]) dnl ########################################################################### dnl # MV_CHECK_CONFIG_FILES dnl # AC_DEFUN(MV_CHECK_CONFIG_FILES, [dnl for i in $CONFIG_FILES; do case $i in *:*) t=`echo $i | sed 's/^.*://'` ;; *) t=$i.in ;; esac if test ! -f $srcdir/$t; then dir=`dirname $srcdir/$t` if test ! -d $dir; then MV_ERROR([Le répertoire «$dir» n'existe pas]) fi MV_ERROR([Le fichier «$srcdir/$t» n'existe pas]) fi done]) dnl ########################################################################### dnl # MV_DO_MICO dnl # AC_DEFUN(MV_DO_MICO, [dnl AC_CHECK_PROGS(IDL, idl) if test -n "$IDL"; then version_string=`$IDL --version` if test "`echo $version_string | awk '{ print [$]1 }'`" = MICO; then AC_DEFINE(__MICO__) MICO_VERSION=`echo $version_string | awk '{ print [$]3 }'` echo "MICO Version $MICO_VERSION found" IDL='idl --c++-suffix=$(strip $''1) --hh-suffix=$(strip $''2)' AC_SUBST(IDL) IDL_BOA="$IDL --boa --no-poa" IDL_POA="$IDL --poa --no-boa" IDL_BOA_POA="$IDL --boa --poa" IDL_POA_BOA="$IDL --poa --boa" AC_SUBST(IDL_BOA) AC_SUBST(IDL_POA) AC_SUBST(IDL_BOA_POA) AC_SUBST(IDL_POA_BOA) AC_CHECK_LIB(mico$MICO_VERSION, main) fi fi]) dnl ########################################################################### dnl # MV_DO_OMNIORB dnl # AC_DEFUN(MV_DO_OMNIORB, [dnl AC_CHECK_PROGS(IDL, omniidl) if test -n "$IDL"; then version_string=`2>&1 omniidl -V | head -1` if test "`echo $version_string | awk '{ print [$]1 }'`" = Omniidl; then AC_DEFINE(__OMNIORB__) OMNIORB_VERSION=`echo $version_string | awk '{ print [$]2 }'` echo "omniORB Version $OMNIORB_VERSION found" IDL='idl -s $(strip $''1) -h $(strip $''2)' AC_SUBST(IDL) IDL_BOA="$IDL" IDL_POA="$IDL" IDL_BOA_POA="$IDL" IDL_POA_BOA="$IDL" AC_SUBST(IDL_BOA) AC_SUBST(IDL_POA) AC_SUBST(IDL_BOA_POA) AC_SUBST(IDL_POA_BOA) AC_CHECK_LIB(omniGK_alone, main) AC_CHECK_LIB(omniORB, main) fi fi]) dnl ########################################################################### dnl # MV_DO_OMNIORB2 dnl # AC_DEFUN(MV_DO_OMNIORB2, [dnl AC_CHECK_PROGS(IDL, omniidl2) if test -n "$IDL"; then version_string=`2>&1 omniidl2 -V | head -1` if test "`echo $version_string | awk '{ print [$]1 }'`" = Omniidl; then AC_DEFINE(__OMNIORB__) OMNIORB_VERSION=`echo $version_string | awk '{ print [$]2 }'` echo "omniORB Version $OMNIORB_VERSION found" IDL='idl -s $(strip $''1) -h $(strip $''2)' AC_SUBST(IDL) IDL_BOA="$IDL" IDL_POA="$IDL" IDL_BOA_POA="$IDL" IDL_POA_BOA="$IDL" AC_SUBST(IDL_BOA) AC_SUBST(IDL_POA) AC_SUBST(IDL_BOA_POA) AC_SUBST(IDL_POA_BOA) AC_CHECK_LIB(omniGK_alone, main) AC_CHECK_LIB(omniORB2, main) fi fi]) dnl ########################################################################### dnl # MV_CHECK_OMLIB dnl # AC_DEFUN(MV_CHECK_OMLIB, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])]) { AC_ARG_WITH(om_includes, [] --with-om-includes=DIR OMLIB include files are in DIR) AC_ARG_WITH(om_libraries, [] --with-om-libraries=DIR OMLIB library files are in DIR) if test -z "$with_om_includes" -o "$with_om_includes" = yes; then found=false if test -n "$subdirs"; then for dir in $subdirs; do if test -f "$dir/OverlapMan2.h"; then found=true AC_MSG_RESULT(omlib: include file \"OverlapMan2.h\" found in $dir/include) depinc="`cd $dir && /bin/pwd`/OverlapMan2.h" DEPINCS="$depinc $DEPINCS" AC_MSG_RESULT(omlib: $depinc add to DEPINCS) break fi done fi if ! $found; then AC_CHECK_HEADER(OverlapMan2.h,, AC_ERROR(Overlap Manger Library required)) fi elif test "$with_om_includes" != no; then if test -f "$srcdir/$with_om_includes/OverlapMan2.h"; then AC_MSG_RESULT(omlib: include file \"OverlapMan2.h\" found in $srcdir/$with_om_includes) DEPINCS="`cd $srcdir/$with_om_includes && /bin/pwd`/OverlapMan2.h $DEPINCS" else AC_ERROR(OverlapMan2.h not found in $srcdir/$with_om_includes) fi fi if test -z "$with_om_libraries" -o "$with_om_libraries" = yes; then found=false if test -n "$subdirs"; then for dir in $subdirs; do if test -f "$dir/OverlapMan2.h"; then found=true dir="`cd $dir && /bin/pwd`" RPATH="$dir $RPATH" deplib=$dir/libom.so DEPLIBS="$deplib $DEPLIBS" AC_MSG_RESULT(omlib: $deplib add to DEPLIBS) break fi done fi if ! $found; then if test "$with_om_libraries" = yes; then AC_CHECK_LIB(om, puterrmsg,, AC_ERROR(Overlap Manger required)) else AC_CHECK_LIB(om, puterrmsg) fi fi elif test "$with_om_libraries" != no; then if test -f "$srcdir/$with_om_libraries/configure"; then AC_CONFIG_SUBDIRS($with_om_libraries) AC_MSG_RESULT(omlib: $with_om_libraries added to directories to configure) LDFLAGS="-L`cd $with_om_libraries && /bin/pwd` $LDFLAGS" LIBS="-lom $LIBS" elif test -f "$srcdir/$with_om_libraries/libom.so"; then AC_MSG_RESULT(omlib: library file \"libom.so\" found in $srcdir/$with_om_libraries) DEPLIBS="`cd $srcdir/$with_om_libraries && /bin/pwd`/libom.so $DEPLIBS" elif test -f "$srcdir/$with_om_libraries/libom.a"; then AC_MSG_RESULT(omlib: library file \"libom.a\" found in $srcdir/$with_om_libraries) DEPLIBS="`cd $srcdir/$with_om_libraries && /bin/pwd`/libom.a $DEPLIBS" else AC_ERROR(no Overlap Manger library found and don't know how to built it) fi fi AC_SUBST(RPATH) }]) dnl ########################################################################### dnl # MV_CHECK_XCLIB dnl # AC_DEFUN(MV_CHECK_XCLIB, [dnl ifelse($#,0,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])]) { AC_ARG_WITH(xc_includes, [] --with-xc-includes=DIR XCLIB include files are in DIR) AC_ARG_WITH(xc_libraries, [] --with-xc-libraries=DIR XCLIB library files are in DIR) if test -z "$with_xc_includes" -o "$with_xc_includes" = yes; then found=false if test -n "$subdirs"; then for dir in $subdirs; do if test -f "$dir/include/xclib.h"; then found=true AC_MSG_RESULT(xclib: include file \"xclib.h\" found in $dir/include) depinc="`cd $dir/include && /bin/pwd`/xclib.h" DEPINCS="$depinc $DEPINCS" AC_MSG_RESULT(xclib: $depinc add to DEPINCS) break fi done fi if ! $found; then AC_CHECK_HEADER(xclib.h,, AC_ERROR(eXtended C Library required)) fi elif test "$with_xc_includes" != no; then if test -f "$srcdir/$with_xc_includes/xclib.h"; then AC_MSG_RESULT(xclib: include file \"xclib.h\" found in $srcdir/$with_xc_includes) DEPINCS="`cd $srcdir/$with_xc_includes && /bin/pwd`/xclib.h $DEPINCS" else AC_ERROR(xclib.h not found in $srcdir/$with_xc_includes) fi fi if test -z "$with_xc_libraries" -o "$with_xc_libraries" = yes; then found=false if test -n "$subdirs"; then for dir in $subdirs; do if test -f "$dir/include/xclib.h"; then found=true dir="`cd $dir && /bin/pwd`" RPATH="$dir $RPATH" deplib=$dir/libxc.so DEPLIBS="$deplib $DEPLIBS" AC_MSG_RESULT(xclib: $deplib add to DEPLIBS) break fi done fi if ! $found; then if test "$with_xc_libraries" = yes; then AC_CHECK_LIB(xc, puterrmsg,, AC_ERROR(eXtended C Library required)) else AC_CHECK_LIB(xc, puterrmsg) fi fi elif test "$with_xc_libraries" != no; then if test -f "$srcdir/$with_xc_libraries/configure"; then AC_CONFIG_SUBDIRS($with_xc_libraries) AC_MSG_RESULT(xclib: $with_xc_libraries added to directories to configure) LDFLAGS="-L`cd $with_xc_libraries && /bin/pwd` $LDFLAGS" LIBS="-lxc $LIBS" elif test -f "$srcdir/$with_xc_libraries/libxc.so"; then AC_MSG_RESULT(xclib: library file \"libxc.so\" found in $srcdir/$with_xc_libraries) DEPLIBS="`cd $srcdir/$with_xc_libraries && /bin/pwd`/libxc.so $DEPLIBS" elif test -f "$srcdir/$with_xc_libraries/libxc.a"; then AC_MSG_RESULT(xclib: library file \"libxc.a\" found in $srcdir/$with_xc_libraries) DEPLIBS="`cd $srcdir/$with_xc_libraries && /bin/pwd`/libxc.a $DEPLIBS" else AC_ERROR(no \"eXtended C\" library found and don't know how to built it) fi fi AC_SUBST(RPATH) }]) dnl ########################################################################### dnl # MV_CHECK_DPKG_VERSION dnl # AC_DEFUN(MV_CHECK_DPKG_VERSION, [dnl ifelse($#,1,,[MV_AUTOCONF_ERROR([Invalid invocation of «$0»])])dnl dnl mv_version="$1" dnl AC_CHECK_PROG(PARSECHANGELOG, dpkg-parsechangelog, dpkg-parsechangelog)dnl dnl if test -n "$PARSECHANGELOG"; then changequote(«,»)dnl DPKG_VERSION=`$PARSECHANGELOG -l$srcdir/debian/changelog|sed -n 's/^Version: \([^-]*\).*$/\1/p'` changequote([,])dnl if test "$DPKG_VERSION" != "$mv_version"; then AC_ERROR(Version in debian/changelog is different ------------------------------------------------------------------------------ `$PARSECHANGELOG` ------------------------------------------------------------------------------) fi fi]) dnl ########################################################################### dnl # [END OF FILE] dnl ########################################################################### dnl # -*- autoconf -*- dnl #++ dnl # LISTE DES MACROS: dnl # ================= dnl # dnl # MV_PROG_PYTHON dnl # MV_LOAD_TCL_CONFIG dnl # MV_LOAD_TK_CONFIG dnl # MV_SET_TCL_CONFIG dnl # MV_SET_TCL_STUB_CONFIG dnl # MV_SET_TK_STUB_CONFIG dnl #-- dnl ########################################################################### dnl # MV_PROG_PYTHON dnl # AC_DEFUN(MV_PROG_PYTHON, [dnl AC_CHECK_PROGS(PYTHON, python2.3 python2.2 python2.1 python) if test -z "$PYTHON"; then MV_ERROR(No Python interpreter found) fi changequote(,) PYTHON_VERSION=`$PYTHON -c "import sys; print sys.version[:3]"` changequote([, ]) MV_MSG(You are using Python version $PYTHON_VERSION, $CYAN) AC_SUBST(PYTHON_VERSION)dnl mv_tmp=`type -p $PYTHON` # filespec mv_tmp=`dirname $mv_tmp` # bindir mv_tmp=`dirname $mv_tmp` # topdir if test ! -d $mv_tmp/include; then MV_ERROR(No «$mv_tmp/include» found) fi if test ! -d $mv_tmp/include/python$PYTHON_VERSION; then MV_ERROR(No «$mv_tmp/include/python$PYTHON_VERSION» found) fi if test ! -f $mv_tmp/include/python$PYTHON_VERSION/Python.h; then MV_ERROR(No «$mv_tmp/include/python$PYTHON_VERSION/Python.h» found) fi PYTHON_INCLUDEDIR=$mv_tmp/include PYTHON_LIBDIR=$mv_tmp/lib PYTHON_COMPILER=$PYTHON_LIBDIR/python$PYTHON_VERSION/compileall.py AC_SUBST(PYTHON_INCLUDEDIR) AC_SUBST(PYTHON_LIBDIR) AC_SUBST(PYTHON_COMPILER) dnl # A FAIRE: dnl # S'assurer de bien utiliser cette version de la bibliotheque python! pyexecdir=\${exec_prefix}/lib/python$PYTHON_VERSION/site-packages pythondir=\${exec_prefix}/lib/python$PYTHON_VERSION/site-packages AC_SUBST(pyexecdir) AC_SUBST(pythondir) pkgpyexecdir=\${pyexecdir}/$PACKAGE pkgpythondir=\${pythondir}/$PACKAGE AC_SUBST(pkgpyexecdir) AC_SUBST(pkgpythondir) ]) dnl ########################################################################### dnl # MV_LOAD_TCL_CONFIG dnl # dnl # Find and load the tclConfig.sh file dnl # AC_DEFUN(MV_LOAD_TCL_CONFIG, [dnl SC_PATH_TCLCONFIG SC_LOAD_TCLCONFIG MV_MSG([You are using Tcl $TCL_VERSION], $CYAN)]) dnl ########################################################################### dnl # MV_LOAD_TK_CONFIG dnl # dnl # Find and load the tkConfig.sh file dnl # AC_DEFUN(MV_LOAD_TK_CONFIG, [dnl SC_PATH_TKCONFIG SC_LOAD_TKCONFIG MV_MSG([You are using Tk $TK_VERSION], $CYAN) if test "$TCL_VERSION" != "$TK_VERSION"; then MV_ERROR([dnl $TCL_BIN_DIR/tclConfig.sh is for Tcl $TCL_VERSION. Tk $TK_VERSION$TK_PATCH_LEVEL needs Tcl $TK_VERSION. Use --with-tcl= option to indicate location of tclConfig.sh file for Tcl $TK_VERSION.]) else MV_MSG([Good: Tcl and Tk have the same version], $CYAN) fi ]) dnl ########################################################################### dnl # MV_SET_TCL_CONFIG dnl # dnl # Find and load the tcl configuration dnl # AC_DEFUN(MV_SET_TCL_CONFIG, [dnl AC_REQUIRE([MV_LOAD_TCL_CONFIG])dnl TCL_INCLUDES= TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}/unix" TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}/generic" TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}" DEFINES=" $DEFINES $TCL_DEFS" INCLUDES=" $TCL_INCLUDES $INCLUDES" LIBRARIES=" $TCL_LIB_SPEC $LIBRARIES" AC_SUBST(DEFINES)dnl AC_SUBST(INCLUDES)dnl AC_SUBST(LIBRARIES)]) dnl ########################################################################### dnl # MV_SET_TCL_STUB_CONFIG dnl # dnl # Find and load the tcl configuration for stub operation dnl # AC_DEFUN(MV_SET_TCL_STUB_CONFIG, [dnl DEFINES="$DEFINES -DUSE_TCL_STUBS=1" AC_REQUIRE([MV_LOAD_TCL_CONFIG])dnl TCL_INCLUDES= TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}/unix" TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}/generic" TCL_INCLUDES="$TCL_INCLUDES ${TCL_INCLUDE_SPEC-"-I$TCL_SRC_DIR"}" DEFINES=" $DEFINES $TCL_DEFS" INCLUDES=" $TCL_INCLUDES $INCLUDES" LIBRARIES=" $TCL_STUB_LIB_SPEC $LIBRARIES" AC_SUBST(DEFINES)dnl AC_SUBST(INCLUDES)dnl AC_SUBST(LIBRARIES)]) dnl ########################################################################### dnl # MV_SET_TK_STUB_CONFIG dnl # dnl # Find and load the tk configuration for stub operation dnl # AC_DEFUN(MV_SET_TK_STUB_CONFIG, [dnl DEFINES="$DEFINES -DUSE_TK_STUBS=1" AC_REQUIRE([MV_LOAD_TK_CONFIG])dnl INCLUDES=" $TK_XINCLUDES $INCLUDES" LIBRARIES="$TK_XLIBSW $LIBRARIES" TK_INCLUDES= TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tk$TK_VERSION/unix" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tk$TK_VERSION/generic" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tk$TK_VERSION" dnl # La galère sur la woody... TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tcl$TK_VERSION/tk-private/unix" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tcl$TK_VERSION/tk-private/generic" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/tcl$TK_VERSION/tk-private" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/unix" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include/generic" TK_INCLUDES="$TK_INCLUDES -I$TK_PREFIX/include" DEFINES=" $DEFINES $TK_DEFS" INCLUDES=" $TK_INCLUDES $INCLUDES" LIBRARIES=" $TK_STUB_LIB_SPEC $LIBRARIES" AC_SUBST(DEFINES)dnl AC_SUBST(INCLUDES)dnl AC_SUBST(LIBRARIES)]) dnl ########################################################################### dnl # OS_SET_IVY_C dnl # dnl # Find and load the IVY_C configuration AC_DEFUN(OS_SET_IVY_C, [dnl AC_ARG_WITH([ivy-c], AC_HELP_STRING([--with-ivy-c], [ivy-c root location (default is EMPTY)]), [ivy_c_location=$withval], [ivy_c_location=""]) if test -n "$ivy_c_location"; then CPPFLAGS="$CPPFLAGS -I$ivy_c_location/include/Ivy" AC_CHECK_HEADERS([ivy.h],,AC_MSG_ERROR([ivy.h not found please provide valid --with-ivy-c directory])) LDFLAGS="$LDFLAGS -L$ivy_c_location/lib -livy" else AC_CHECK_HEADERS([Ivy/ivy.h],,AC_MSG_ERROR([ivy.h not found please provide valid --with-ivy-c directory])) fi ]) dnl ########################################################################### dnl # [END OF FILE] dnl ########################################################################### #------------------------------------------------------------------------ # SC_PATH_TCLCONFIG -- # # Locate the tclConfig.sh file and perform a sanity check on # the Tcl compile flags # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --with-tcl=... # # Defines the following vars: # TCL_BIN_DIR Full path to the directory containing # the tclConfig.sh file #------------------------------------------------------------------------ AC_DEFUN(SC_PATH_TCLCONFIG, [ # # Ok, lets find the tcl configuration # First, look for one uninstalled. # the alternative search directory is invoked by --with-tcl # if test x"${no_tcl}" = x ; then # we reset no_tcl in case something fails here no_tcl=true AC_ARG_WITH(tcl, [ --with-tcl directory containing tcl configuration (tclConfig.sh)], with_tclconfig=${withval}) AC_MSG_CHECKING([for Tcl configuration]) AC_CACHE_VAL(ac_cv_c_tclconfig,[ # First check to see if --with-tcl was specified. if test x"${with_tclconfig}" != x ; then if test -f "${with_tclconfig}/tclConfig.sh" ; then ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)` else AC_MSG_ERROR([${with_tclconfig} directory doesn't contain tclConfig.sh]) fi fi # then check for a private Tcl installation if test x"${ac_cv_c_tclconfig}" = x ; then for i in \ ../tcl \ `ls -dr ../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../tcl[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../tcl[[8-9]].[[0-9]]* 2>/dev/null` \ ../../tcl \ `ls -dr ../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../../tcl[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \ ../../../tcl \ `ls -dr ../../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../../../tcl[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../../../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do if test -f "$i/unix/tclConfig.sh" ; then ac_cv_c_tclconfig=`(cd $i/unix; pwd)` break fi done fi # check in a few common install locations if test x"${ac_cv_c_tclconfig}" = x ; then for i in `ls -d ${libdir} 2>/dev/null` \ `ls -d /usr/local/lib 2>/dev/null` \ `ls -d /usr/contrib/lib 2>/dev/null` \ `ls -d /usr/lib 2>/dev/null` \ ; do if test -f "$i/tclConfig.sh" ; then ac_cv_c_tclconfig=`(cd $i; pwd)` break fi done fi # check in a few other private locations if test x"${ac_cv_c_tclconfig}" = x ; then for i in \ ${srcdir}/../tcl \ `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do if test -f "$i/unix/tclConfig.sh" ; then ac_cv_c_tclconfig=`(cd $i/unix; pwd)` break fi done fi ]) if test x"${ac_cv_c_tclconfig}" = x ; then TCL_BIN_DIR="# no Tcl configs found" AC_MSG_WARN(Can't find Tcl configuration definitions) exit 0 else no_tcl= TCL_BIN_DIR=${ac_cv_c_tclconfig} AC_MSG_RESULT(found $TCL_BIN_DIR/tclConfig.sh) fi fi ]) #------------------------------------------------------------------------ # SC_PATH_TKCONFIG -- # # Locate the tkConfig.sh file # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --with-tk=... # # Defines the following vars: # TK_BIN_DIR Full path to the directory containing # the tkConfig.sh file #------------------------------------------------------------------------ AC_DEFUN(SC_PATH_TKCONFIG, [ # # Ok, lets find the tk configuration # First, look for one uninstalled. # the alternative search directory is invoked by --with-tk # if test x"${no_tk}" = x ; then # we reset no_tk in case something fails here no_tk=true AC_ARG_WITH(tk, [ --with-tk directory containing tk configuration (tkConfig.sh)], with_tkconfig=${withval}) AC_MSG_CHECKING([for Tk configuration]) AC_CACHE_VAL(ac_cv_c_tkconfig,[ # First check to see if --with-tkconfig was specified. if test x"${with_tkconfig}" != x ; then if test -f "${with_tkconfig}/tkConfig.sh" ; then ac_cv_c_tkconfig=`(cd ${with_tkconfig}; pwd)` else AC_MSG_ERROR([${with_tkconfig} directory doesn't contain tkConfig.sh]) fi fi # then check for a private Tk library if test x"${ac_cv_c_tkconfig}" = x ; then for i in \ ../tk \ `ls -dr ../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../tk[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../tk[[8-9]].[[0-9]]* 2>/dev/null` \ ../../tk \ `ls -dr ../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../../tk[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../../tk[[8-9]].[[0-9]]* 2>/dev/null` \ ../../../tk \ `ls -dr ../../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ../../../tk[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ../../../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do if test -f "$i/unix/tkConfig.sh" ; then ac_cv_c_tkconfig=`(cd $i/unix; pwd)` break fi done fi # check in a few common install locations if test x"${ac_cv_c_tkconfig}" = x ; then for i in `ls -d ${libdir} 2>/dev/null` \ `ls -d /usr/local/lib 2>/dev/null` \ `ls -d /usr/contrib/lib 2>/dev/null` \ `ls -d /usr/lib 2>/dev/null` \ ; do if test -f "$i/tkConfig.sh" ; then ac_cv_c_tkconfig=`(cd $i; pwd)` break fi done fi # check in a few other private locations if test x"${ac_cv_c_tkconfig}" = x ; then for i in \ ${srcdir}/../tk \ `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \ `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]] 2>/dev/null` \ `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do if test -f "$i/unix/tkConfig.sh" ; then ac_cv_c_tkconfig=`(cd $i/unix; pwd)` break fi done fi ]) if test x"${ac_cv_c_tkconfig}" = x ; then TK_BIN_DIR="# no Tk configs found" AC_MSG_WARN(Can't find Tk configuration definitions) exit 0 else no_tk= TK_BIN_DIR=${ac_cv_c_tkconfig} AC_MSG_RESULT(found $TK_BIN_DIR/tkConfig.sh) fi fi ]) #------------------------------------------------------------------------ # SC_LOAD_TCLCONFIG -- # # Load the tclConfig.sh file # # Arguments: # # Requires the following vars to be set: # TCL_BIN_DIR # # Results: # # Subst the following vars: # TCL_BIN_DIR # TCL_SRC_DIR # TCL_INC_DIR # TCL_LIB_FILE # #------------------------------------------------------------------------ AC_DEFUN(SC_LOAD_TCLCONFIG, [ AC_MSG_CHECKING([for existence of $TCL_BIN_DIR/tclConfig.sh]) if test -f "$TCL_BIN_DIR/tclConfig.sh" ; then AC_MSG_RESULT([loading]) . $TCL_BIN_DIR/tclConfig.sh else AC_MSG_RESULT([file not found]) fi # # If the TCL_BIN_DIR is the build directory (not the install directory), # then set the common variable name to the value of the build variables. # For example, the variable TCL_LIB_SPEC will be set to the value # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC # instead of TCL_BUILD_LIB_SPEC since it will work with both an # installed and uninstalled version of Tcl. # if test -f $TCL_BIN_DIR/Makefile ; then TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC} TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC} TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH} fi # # eval is required to do the TCL_DBGX substitution # eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\"" eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\"" eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\"" eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\"" eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\"" eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\"" AC_SUBST(TCL_VERSION) AC_SUBST(TCL_BIN_DIR) AC_SUBST(TCL_INC_DIR) AC_SUBST(TCL_SRC_DIR) AC_SUBST(TCL_LIB_FILE) AC_SUBST(TCL_LIB_FLAG) AC_SUBST(TCL_LIB_SPEC) AC_SUBST(TCL_STUB_LIB_FILE) AC_SUBST(TCL_STUB_LIB_FLAG) AC_SUBST(TCL_STUB_LIB_SPEC) ]) #------------------------------------------------------------------------ # SC_LOAD_TKCONFIG -- # # Load the tkConfig.sh file # # Arguments: # # Requires the following vars to be set: # TK_BIN_DIR # # Results: # # Sets the following vars that should be in tkConfig.sh: # TK_BIN_DIR #------------------------------------------------------------------------ AC_DEFUN(SC_LOAD_TKCONFIG, [ AC_MSG_CHECKING([for existence of $TK_BIN_DIR/tkConfig.sh]) if test -f "$TK_BIN_DIR/tkConfig.sh" ; then AC_MSG_RESULT([loading]) . $TK_BIN_DIR/tkConfig.sh else AC_MSG_RESULT([could not find $TK_BIN_DIR/tkConfig.sh]) fi AC_SUBST(TK_VERSION) AC_SUBST(TK_BIN_DIR) AC_SUBST(TK_SRC_DIR) AC_SUBST(TK_LIB_DIR) AC_SUBST(TK_LIB_FILE) ]) #------------------------------------------------------------------------ # SC_ENABLE_SHARED -- # # Allows the building of shared libraries # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --enable-shared=yes|no # # Defines the following vars: # STATIC_BUILD Used for building import/export libraries # on Windows. # # Sets the following vars: # SHARED_BUILD Value of 1 or 0 #------------------------------------------------------------------------ AC_DEFUN(SC_ENABLE_SHARED, [ AC_MSG_CHECKING([how to build libraries]) AC_ARG_ENABLE(shared, [ --enable-shared build and link with shared libraries [--enable-shared]], [tcl_ok=$enableval], [tcl_ok=yes]) if test "${enable_shared+set}" = set; then enableval="$enable_shared" tcl_ok=$enableval else tcl_ok=yes fi if test "$tcl_ok" = "yes" ; then AC_MSG_RESULT([shared]) SHARED_BUILD=1 else AC_MSG_RESULT([static]) SHARED_BUILD=0 AC_DEFINE(STATIC_BUILD) fi ]) #------------------------------------------------------------------------ # SC_ENABLE_FRAMEWORK -- # # Allows the building of shared libraries into frameworks # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --enable-framework=yes|no # # Sets the following vars: # FRAMEWORK_BUILD Value of 1 or 0 #------------------------------------------------------------------------ AC_DEFUN(SC_ENABLE_FRAMEWORK, [ AC_MSG_CHECKING([how to package libraries]) AC_ARG_ENABLE(framework, [ --enable-framework package shared libraries in MacOSX frameworks [--disable-framework]], [tcl_ok=$enableval], [tcl_ok=no]) if test "${enable_framework+set}" = set; then enableval="$enable_framework" tcl_ok=$enableval else tcl_ok=no fi if test "$tcl_ok" = "yes" ; then AC_MSG_RESULT([framework]) FRAMEWORK_BUILD=1 if test "${SHARED_BUILD}" = "0" ; then AC_MSG_WARN("Frameworks can only be built if --enable-shared is yes") FRAMEWORK_BUILD=0 fi else AC_MSG_RESULT([standard shared library]) FRAMEWORK_BUILD=0 fi ]) #------------------------------------------------------------------------ # SC_ENABLE_THREADS -- # # Specify if thread support should be enabled. TCL_THREADS is # checked so that if you are compiling an extension against a # threaded core, your extension must be compiled threaded as well. # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --enable-threads # # Sets the following vars: # THREADS_LIBS Thread library(s) # # Defines the following vars: # TCL_THREADS # _REENTRANT # _THREAD_SAFE # #------------------------------------------------------------------------ AC_DEFUN(SC_ENABLE_THREADS, [ AC_MSG_CHECKING(for building with threads) AC_ARG_ENABLE(threads, [ --enable-threads build with threads], [tcl_ok=$enableval], [tcl_ok=no]) if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then if test "${TCL_THREADS}" = 1; then AC_MSG_RESULT([yes (threaded core)]) else AC_MSG_RESULT([yes]) fi TCL_THREADS=1 AC_DEFINE(TCL_THREADS) # USE_THREAD_ALLOC tells us to try the special thread-based # allocator that significantly reduces lock contention AC_DEFINE(USE_THREAD_ALLOC) AC_DEFINE(_REENTRANT) if test "`uname -s`" = "SunOS" ; then AC_DEFINE(_POSIX_PTHREAD_SEMANTICS) fi AC_DEFINE(_THREAD_SAFE) AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no) if test "$tcl_ok" = "no"; then # Check a little harder for __pthread_mutex_init in the same # library, as some systems hide it there until pthread.h is # defined. We could alternatively do an AC_TRY_COMPILE with # pthread.h, but that will work with libpthread really doesn't # exist, like AIX 4.2. [Bug: 4359] AC_CHECK_LIB(pthread,__pthread_mutex_init,tcl_ok=yes,tcl_ok=no) fi if test "$tcl_ok" = "yes"; then # The space is needed THREADS_LIBS=" -lpthread" else AC_CHECK_LIB(pthreads,pthread_mutex_init,tcl_ok=yes,tcl_ok=no) if test "$tcl_ok" = "yes"; then # The space is needed THREADS_LIBS=" -lpthreads" else AC_CHECK_LIB(c,pthread_mutex_init,tcl_ok=yes,tcl_ok=no) if test "$tcl_ok" = "no"; then AC_CHECK_LIB(c_r,pthread_mutex_init,tcl_ok=yes,tcl_ok=no) if test "$tcl_ok" = "yes"; then # The space is needed THREADS_LIBS=" -pthread" else TCL_THREADS=0 AC_MSG_WARN("Don t know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile...") fi fi fi fi # Does the pthread-implementation provide # 'pthread_attr_setstacksize' ? ac_saved_libs=$LIBS LIBS="$LIBS $THREADS_LIBS" AC_CHECK_FUNCS(pthread_attr_setstacksize) AC_CHECK_FUNCS(pthread_atfork) LIBS=$ac_saved_libs AC_CHECK_FUNCS(readdir_r) if test "x$ac_cv_func_readdir_r" = "xyes"; then AC_MSG_CHECKING([how many args readdir_r takes]) # IRIX 5.3 has a 2 arg version of readdir_r # while other systems have a 3 arg version. AC_CACHE_VAL(tcl_cv_two_arg_readdir_r, AC_TRY_COMPILE([#include #include #ifdef NO_DIRENT_H # include /* logic from tcl/compat/dirent.h * # define dirent direct * */ #else # include #endif ], [readdir_r(NULL, NULL);], tcl_cv_two_arg_readdir_r=yes, tcl_cv_two_arg_readdir_r=no)) AC_CACHE_VAL(tcl_cv_three_arg_readdir_r, AC_TRY_COMPILE([#include #include #ifdef NO_DIRENT_H # include /* logic from tcl/compat/dirent.h * # define dirent direct * */ #else # include #endif ], [readdir_r(NULL, NULL, NULL);], tcl_cv_three_arg_readdir_r=yes, tcl_cv_three_arg_readdir_r=no)) if test "x$tcl_cv_two_arg_readdir_r" = "xyes" ; then AC_MSG_RESULT([2]) AC_DEFINE(HAVE_TWO_ARG_READDIR_R) elif test "x$tcl_cv_three_arg_readdir_r" = "xyes" ; then AC_MSG_RESULT([3]) AC_DEFINE(HAVE_THREE_ARG_READDIR_R) else AC_MSG_ERROR([unknown number of args for readdir_r]) fi fi else TCL_THREADS=0 AC_MSG_RESULT([no (default)]) fi AC_SUBST(TCL_THREADS) ]) #------------------------------------------------------------------------ # SC_ENABLE_SYMBOLS -- # # Specify if debugging symbols should be used. # Memory (TCL_MEM_DEBUG) and compile (TCL_COMPILE_DEBUG) debugging # can also be enabled. # # Arguments: # none # # Requires the following vars to be set in the Makefile: # CFLAGS_DEBUG # CFLAGS_OPTIMIZE # LDFLAGS_DEBUG # LDFLAGS_OPTIMIZE # # Results: # # Adds the following arguments to configure: # --enable-symbols # # Defines the following vars: # CFLAGS_DEFAULT Sets to $(CFLAGS_DEBUG) if true # Sets to $(CFLAGS_OPTIMIZE) if false # LDFLAGS_DEFAULT Sets to $(LDFLAGS_DEBUG) if true # Sets to $(LDFLAGS_OPTIMIZE) if false # DBGX Debug library extension # #------------------------------------------------------------------------ AC_DEFUN(SC_ENABLE_SYMBOLS, [ AC_MSG_CHECKING([for build with symbols]) AC_ARG_ENABLE(symbols, [ --enable-symbols build with debugging symbols [--disable-symbols]], [tcl_ok=$enableval], [tcl_ok=no]) # FIXME: Currently, LDFLAGS_DEFAULT is not used, it should work like CFLAGS_DEFAULT. if test "$tcl_ok" = "no"; then CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)' LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)' DBGX="" AC_MSG_RESULT([no]) else CFLAGS_DEFAULT='$(CFLAGS_DEBUG)' LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)' DBGX=g if test "$tcl_ok" = "yes"; then AC_MSG_RESULT([yes (standard debugging)]) fi fi AC_SUBST(CFLAGS_DEFAULT) AC_SUBST(LDFLAGS_DEFAULT) if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then AC_DEFINE(TCL_MEM_DEBUG) fi if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then AC_DEFINE(TCL_COMPILE_DEBUG) AC_DEFINE(TCL_COMPILE_STATS) fi if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then if test "$tcl_ok" = "all"; then AC_MSG_RESULT([enabled symbols mem compile debugging]) else AC_MSG_RESULT([enabled $tcl_ok debugging]) fi fi ]) #------------------------------------------------------------------------ # SC_ENABLE_LANGINFO -- # # Allows use of modern nl_langinfo check for better l10n. # This is only relevant for Unix. # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --enable-langinfo=yes|no (default is yes) # # Defines the following vars: # HAVE_LANGINFO Triggers use of nl_langinfo if defined. # #------------------------------------------------------------------------ AC_DEFUN(SC_ENABLE_LANGINFO, [ AC_ARG_ENABLE(langinfo, [ --enable-langinfo use nl_langinfo if possible to determine encoding at startup, otherwise use old heuristic], [langinfo_ok=$enableval], [langinfo_ok=yes]) HAVE_LANGINFO=0 if test "$langinfo_ok" = "yes"; then if test "$langinfo_ok" = "yes"; then AC_CHECK_HEADER(langinfo.h,[langinfo_ok=yes],[langinfo_ok=no]) fi fi AC_MSG_CHECKING([whether to use nl_langinfo]) if test "$langinfo_ok" = "yes"; then AC_TRY_COMPILE([#include ], [nl_langinfo(CODESET);],[langinfo_ok=yes],[langinfo_ok=no]) if test "$langinfo_ok" = "no"; then langinfo_ok="no (could not compile with nl_langinfo)"; fi if test "$langinfo_ok" = "yes"; then AC_DEFINE(HAVE_LANGINFO) fi fi AC_MSG_RESULT([$langinfo_ok]) ]) #-------------------------------------------------------------------- # SC_CONFIG_MANPAGES # # Decide whether to use symlinks for linking the manpages, # whether to compress the manpages after installation, and # whether to add a package name suffix to the installed # manpages to avoidfile name clashes. # If compression is enabled also find out what file name suffix # the given compression program is using. # # Arguments: # none # # Results: # # Adds the following arguments to configure: # --enable-man-symlinks # --enable-man-compression=PROG # --enable-man-suffix[=STRING] # # Defines the following variable: # # MAN_FLAGS - The apropriate flags for installManPage # according to the user's selection. # #-------------------------------------------------------------------- AC_DEFUN(SC_CONFIG_MANPAGES, [ AC_MSG_CHECKING([whether to use symlinks for manpages]) AC_ARG_ENABLE(man-symlinks, [ --enable-man-symlinks use symlinks for the manpages], test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks", enableval="no") AC_MSG_RESULT([$enableval]) AC_MSG_CHECKING([whether to compress the manpages]) AC_ARG_ENABLE(man-compression, [ --enable-man-compression=PROG compress the manpages with PROG], test "$enableval" = "yes" && AC_MSG_ERROR([missing argument to --enable-man-compression]) test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --compress $enableval", enableval="no") AC_MSG_RESULT([$enableval]) if test "$enableval" != "no"; then AC_MSG_CHECKING([for compressed file suffix]) touch TeST $enableval TeST Z=`ls TeST* | sed 's/^....//'` rm -f TeST* MAN_FLAGS="$MAN_FLAGS --extension $Z" AC_MSG_RESULT([$Z]) fi AC_MSG_CHECKING([whether to add a package name suffix for the manpages]) AC_ARG_ENABLE(man-suffix, [ --enable-man-suffix=STRING use STRING as a suffix to manpage file names (default: $1)], test "$enableval" = "yes" && enableval="$1" test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --suffix $enableval", enableval="no") AC_MSG_RESULT([$enableval]) AC_SUBST(MAN_FLAGS) ]) #-------------------------------------------------------------------- # SC_CONFIG_CFLAGS # # Try to determine the proper flags to pass to the compiler # for building shared libraries and other such nonsense. # # Arguments: # none # # Results: # # Defines and substitutes the following vars: # # DL_OBJS - Name of the object file that implements dynamic # loading for Tcl on this system. # DL_LIBS - Library file(s) to include in tclsh and other base # applications in order for the "load" command to work. # LDFLAGS - Flags to pass to the compiler when linking object # files into an executable application binary such # as tclsh. # LD_SEARCH_FLAGS-Flags to pass to ld, such as "-R /usr/local/tcl/lib", # that tell the run-time dynamic linker where to look # for shared libraries such as libtcl.so. Depends on # the variable LIB_RUNTIME_DIR in the Makefile. Could # be the same as CC_SEARCH_FLAGS if ${CC} is used to link. # CC_SEARCH_FLAGS-Flags to pass to ${CC}, such as "-Wl,-rpath,/usr/local/tcl/lib", # that tell the run-time dynamic linker where to look # for shared libraries such as libtcl.so. Depends on # the variable LIB_RUNTIME_DIR in the Makefile. # MAKE_LIB - Command to execute to build the a library; # differs when building shared or static. # MAKE_STUB_LIB - # Command to execute to build a stub library. # INSTALL_LIB - Command to execute to install a library; # differs when building shared or static. # INSTALL_STUB_LIB - # Command to execute to install a stub library. # STLIB_LD - Base command to use for combining object files # into a static library. # SHLIB_CFLAGS - Flags to pass to cc when compiling the components # of a shared library (may request position-independent # code, among other things). # SHLIB_LD - Base command to use for combining object files # into a shared library. # SHLIB_LD_FLAGS -Flags to pass when building a shared library. This # differes from the SHLIB_CFLAGS as it is not used # when building object files or executables. # SHLIB_LD_LIBS - Dependent libraries for the linker to scan when # creating shared libraries. This symbol typically # goes at the end of the "ld" commands that build # shared libraries. The value of the symbol is # "${LIBS}" if all of the dependent libraries should # be specified when creating a shared library. If # dependent libraries should not be specified (as on # SunOS 4.x, where they cause the link to fail, or in # general if Tcl and Tk aren't themselves shared # libraries), then this symbol has an empty string # as its value. # SHLIB_SUFFIX - Suffix to use for the names of dynamically loadable # extensions. An empty string means we don't know how # to use shared libraries on this platform. # TCL_SHLIB_LD_EXTRAS - Additional element which are added to SHLIB_LD_LIBS # TK_SHLIB_LD_EXTRAS for the build of Tcl and Tk, but not recorded in the # tclConfig.sh, since they are only used for the build # of Tcl and Tk. # Examples: MacOS X records the library version and # compatibility version in the shared library. But # of course the Tcl version of this is only used for Tcl. # LIB_SUFFIX - Specifies everything that comes after the "libfoo" # in a static or shared library name, using the $VERSION variable # to put the version in the right place. This is used # by platforms that need non-standard library names. # Examples: ${VERSION}.so.1.1 on NetBSD, since it needs # to have a version after the .so, and ${VERSION}.a # on AIX, since a shared library needs to have # a .a extension whereas shared objects for loadable # extensions have a .so extension. Defaults to # ${VERSION}${SHLIB_SUFFIX}. # TCL_NEEDS_EXP_FILE - # 1 means that an export file is needed to link to a # shared library. # TCL_EXP_FILE - The name of the installed export / import file which # should be used to link to the Tcl shared library. # Empty if Tcl is unshared. # TCL_BUILD_EXP_FILE - # The name of the built export / import file which # should be used to link to the Tcl shared library. # Empty if Tcl is unshared. # CFLAGS_DEBUG - # Flags used when running the compiler in debug mode # CFLAGS_OPTIMIZE - # Flags used when running the compiler in optimize mode # CFLAGS - Additional CFLAGS added as necessary (usually 64-bit) # #-------------------------------------------------------------------- AC_DEFUN(SC_CONFIG_CFLAGS, [ # Step 0.a: Enable 64 bit support? AC_MSG_CHECKING([if 64bit support is requested]) AC_ARG_ENABLE(64bit,[ --enable-64bit enable 64bit support (where applicable)],,enableval="no") if test "$enableval" = "yes"; then do64bit=yes else do64bit=no fi AC_MSG_RESULT($do64bit) # Step 0.b: Enable Solaris 64 bit VIS support? AC_MSG_CHECKING([if 64bit Sparc VIS support is requested]) AC_ARG_ENABLE(64bit-vis,[ --enable-64bit-vis enable 64bit Sparc VIS support],,enableval="no") if test "$enableval" = "yes"; then # Force 64bit on with VIS do64bit=yes do64bitVIS=yes else do64bitVIS=no fi AC_MSG_RESULT($do64bitVIS) # Step 1: set the variable "system" to hold the name and version number # for the system. This can usually be done via the "uname" command, but # there are a few systems, like Next, where this doesn't work. AC_MSG_CHECKING([system version (for dynamic loading)]) if test -f /usr/lib/NextStep/software_version; then system=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version` else system=`uname -s`-`uname -r` if test "$?" -ne 0 ; then AC_MSG_RESULT([unknown (can't find uname command)]) system=unknown else # Special check for weird MP-RAS system (uname returns weird # results, and the version is kept in special file). if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then system=MP-RAS-`awk '{print $3}' /etc/.relid'` fi if test "`uname -s`" = "AIX" ; then system=AIX-`uname -v`.`uname -r` fi if test "`uname -s`" = "NetBSD" -a -f /etc/debian_version ; then system=NetBSD-Debian fi AC_MSG_RESULT($system) fi fi # Step 2: check for existence of -ldl library. This is needed because # Linux can use either -ldl or -ldld for dynamic loading. AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no) # Require ranlib early so we can override it in special cases below. AC_REQUIRE([AC_PROG_RANLIB]) # Step 3: set configuration options based on system name and version. do64bit_ok=no LDFLAGS_ORIG="$LDFLAGS" TCL_EXPORT_FILE_SUFFIX="" UNSHARED_LIB_SUFFIX="" TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`' ECHO_VERSION='`echo ${VERSION}`' TCL_LIB_VERSIONS_OK=ok CFLAGS_DEBUG=-g CFLAGS_OPTIMIZE=-O if test "$GCC" = "yes" ; then CFLAGS_WARNING="-Wall -Wno-implicit-int -fno-strict-aliasing" else CFLAGS_WARNING="" fi TCL_NEEDS_EXP_FILE=0 TCL_BUILD_EXP_FILE="" TCL_EXP_FILE="" dnl FIXME: Replace AC_CHECK_PROG with AC_CHECK_TOOL once cross compiling is fixed. dnl AC_CHECK_TOOL(AR, ar) AC_CHECK_PROG(AR, ar, ar) if test "${AR}" = "" ; then AC_MSG_ERROR([Required archive tool 'ar' not found on PATH.]) fi STLIB_LD='${AR} cr' LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH" PLAT_OBJS="" SHLIB_LD_FLAGS="-Wl,-soname,\${TCL_LIB_FILE}.0" case $system in AIX-5.*) if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then # AIX requires the _r compiler when gcc isn't being used if test "${CC}" != "cc_r" ; then CC=${CC}_r fi AC_MSG_RESULT(Using $CC for compiling with threads) fi LIBS="$LIBS -lc" # AIX-5 uses ELF style dynamic libraries SHLIB_CFLAGS="" # Note: need the LIBS below, otherwise Tk won't find Tcl's # symbols when dynamically loaded into tclsh. SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" LD_LIBRARY_PATH_VAR="LIBPATH" # Check to enable 64-bit flags for compiler/linker if test "$do64bit" = "yes" ; then if test "$GCC" = "yes" ; then AC_MSG_WARN("64bit mode not supported with GCC on $system") else do64bit_ok=yes CFLAGS="$CFLAGS -q64" LDFLAGS="$LDFLAGS -q64" RANLIB="${RANLIB} -X64" AR="${AR} -X64" SHLIB_LD_FLAGS="-b64" fi fi if test "`uname -m`" = "ia64" ; then # AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC SHLIB_LD="/usr/ccs/bin/ld -G -z text" # AIX-5 has dl* in libc.so DL_LIBS="" if test "$GCC" = "yes" ; then CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}' else CC_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}' fi LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}' else SHLIB_LD="${TCL_SRC_DIR}/unix/ldAix /bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry ${SHLIB_LD_FLAGS}" DL_LIBS="-ldl" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} TCL_NEEDS_EXP_FILE=1 TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp' fi ;; AIX-*) if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then # AIX requires the _r compiler when gcc isn't being used if test "${CC}" != "cc_r" ; then CC=${CC}_r fi AC_MSG_RESULT(Using $CC for compiling with threads) fi LIBS="$LIBS -lc" SHLIB_CFLAGS="" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} LD_LIBRARY_PATH_VAR="LIBPATH" TCL_NEEDS_EXP_FILE=1 TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp' # AIX v<=4.1 has some different flags than 4.2+ if test "$system" = "AIX-4.1" -o "`uname -v`" -lt "4" ; then LIBOBJS="$LIBOBJS tclLoadAix.o" DL_LIBS="-lld" fi # Check to enable 64-bit flags for compiler/linker if test "$do64bit" = "yes" ; then if test "$GCC" = "yes" ; then AC_MSG_WARN("64bit mode not supported with GCC on $system") else do64bit_ok=yes CFLAGS="$CFLAGS -q64" LDFLAGS="$LDFLAGS -q64" RANLIB="${RANLIB} -X64" AR="${AR} -X64" SHLIB_LD_FLAGS="-b64" fi fi SHLIB_LD="${TCL_SRC_DIR}/unix/ldAix /bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry ${SHLIB_LD_FLAGS}" # On AIX <=v4 systems, libbsd.a has to be linked in to support # non-blocking file IO. This library has to be linked in after # the MATH_LIBS or it breaks the pow() function. The way to # insure proper sequencing, is to add it to the tail of MATH_LIBS. # This library also supplies gettimeofday. # # AIX does not have a timezone field in struct tm. When the AIX # bsd library is used, the timezone global and the gettimeofday # methods are to be avoided for timezone deduction instead, we # deduce the timezone by comparing the localtime result on a # known GMT value. AC_CHECK_LIB(bsd, gettimeofday, libbsd=yes, libbsd=no) if test $libbsd = yes; then MATH_LIBS="$MATH_LIBS -lbsd" AC_DEFINE(USE_DELTA_FOR_TZ) fi ;; BeOS*) SHLIB_CFLAGS="-fPIC" SHLIB_LD="${CC} -nostart" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" #----------------------------------------------------------- # Check for inet_ntoa in -lbind, for BeOS (which also needs # -lsocket, even if the network functions are in -lnet which # is always linked to, for compatibility. #----------------------------------------------------------- AC_CHECK_LIB(bind, inet_ntoa, [LIBS="$LIBS -lbind -lsocket"]) ;; BSD/OS-2.1*|BSD/OS-3*) SHLIB_CFLAGS="" SHLIB_LD="shlicc -r" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; BSD/OS-4.*) SHLIB_CFLAGS="-export-dynamic -fPIC" SHLIB_LD="cc -shared" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" LDFLAGS="$LDFLAGS -export-dynamic" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; dgux*) SHLIB_CFLAGS="-K PIC" SHLIB_LD="cc -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; HP-UX-*.11.*) # Use updated header definitions where possible AC_DEFINE(_XOPEN_SOURCE) # Use the XOPEN network library AC_DEFINE(_XOPEN_SOURCE_EXTENDED) # Use the XOPEN network library LIBS="$LIBS -lxnet" # Use the XOPEN network library SHLIB_SUFFIX=".sl" AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no) if test "$tcl_ok" = yes; then SHLIB_CFLAGS="+z" SHLIB_LD="ld -b" SHLIB_LD_LIBS='${LIBS}' DL_OBJS="tclLoadShl.o" DL_LIBS="-ldld" LDFLAGS="$LDFLAGS -Wl,-E" CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.' LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.' LD_LIBRARY_PATH_VAR="SHLIB_PATH" fi if test "$GCC" = "yes" ; then SHLIB_LD="gcc -shared" SHLIB_LD_LIBS='${LIBS}' LD_SEARCH_FLAGS='' CC_SEARCH_FLAGS='' fi # Users may want PA-RISC 1.1/2.0 portable code - needs HP cc #CFLAGS="$CFLAGS +DAportable" # Check to enable 64-bit flags for compiler/linker if test "$do64bit" = "yes" ; then if test "$GCC" = "yes" ; then hpux_arch=`gcc -dumpmachine` case $hpux_arch in hppa64*) # 64-bit gcc in use. Fix flags for GNU ld. do64bit_ok=yes SHLIB_LD="gcc -shared" SHLIB_LD_LIBS='${LIBS}' LD_SEARCH_FLAGS='' CC_SEARCH_FLAGS='' ;; *) AC_MSG_WARN("64bit mode not supported with GCC on $system") ;; esac else do64bit_ok=yes CFLAGS="$CFLAGS +DD64" LDFLAGS="$LDFLAGS +DD64" fi fi ;; HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*) SHLIB_SUFFIX=".sl" AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no) if test "$tcl_ok" = yes; then SHLIB_CFLAGS="+z" SHLIB_LD="ld -b" SHLIB_LD_LIBS="" DL_OBJS="tclLoadShl.o" DL_LIBS="-ldld" LDFLAGS="$LDFLAGS -Wl,-E" CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.' LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.' LD_LIBRARY_PATH_VAR="SHLIB_PATH" fi ;; IRIX-4.*) SHLIB_CFLAGS="-G 0" SHLIB_SUFFIX=".a" SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0" SHLIB_LD_LIBS='${LIBS}' DL_OBJS="tclLoadAout.o" DL_LIBS="" LDFLAGS="$LDFLAGS -Wl,-D,08000000" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a' ;; IRIX-5.*) SHLIB_CFLAGS="" SHLIB_LD="ld -shared -rdata_shared" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' ;; IRIX-6.*) SHLIB_CFLAGS="" SHLIB_LD="ld -n32 -shared -rdata_shared" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' if test "$GCC" = "yes" ; then CFLAGS="$CFLAGS -mabi=n32" LDFLAGS="$LDFLAGS -mabi=n32" else case $system in IRIX-6.3) # Use to build 6.2 compatible binaries on 6.3. CFLAGS="$CFLAGS -n32 -D_OLD_TERMIOS" ;; *) CFLAGS="$CFLAGS -n32" ;; esac LDFLAGS="$LDFLAGS -n32" fi ;; IRIX64-6.*) SHLIB_CFLAGS="" SHLIB_LD="ld -n32 -shared -rdata_shared" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' # Check to enable 64-bit flags for compiler/linker if test "$do64bit" = "yes" ; then if test "$GCC" = "yes" ; then AC_MSG_WARN([64bit mode not supported by gcc]) else do64bit_ok=yes SHLIB_LD="ld -64 -shared -rdata_shared" CFLAGS="$CFLAGS -64" LDFLAGS="$LDFLAGS -64" fi fi ;; Linux*) SHLIB_CFLAGS="-fPIC" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" CFLAGS_OPTIMIZE=-O2 # egcs-2.91.66 on Redhat Linux 6.0 generates lots of warnings # when you inline the string and math operations. Turn this off to # get rid of the warnings. #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES" if test "$have_dl" = yes; then SHLIB_LD="${CC} -shared" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" LDFLAGS="$LDFLAGS -Wl,--export-dynamic" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} else AC_CHECK_HEADER(dld.h, [ SHLIB_LD="ld -shared" DL_OBJS="tclLoadDld.o" DL_LIBS="-ldld" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS=""]) fi if test "`uname -m`" = "alpha" ; then CFLAGS="$CFLAGS -mieee" fi # The combo of gcc + glibc has a bug related # to inlining of functions like strtod(). The # -fno-builtin flag should address this problem # but it does not work. The -fno-inline flag # is kind of overkill but it works. # Disable inlining only when one of the # files in compat/*.c is being linked in. if test x"${LIBOBJS}" != x ; then CFLAGS="$CFLAGS -fno-inline" fi # XIM peeking works under XFree86. AC_DEFINE(PEEK_XCLOSEIM) ;; GNU*) SHLIB_CFLAGS="-fPIC" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" if test "$have_dl" = yes; then SHLIB_LD="${CC} -shared" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" LDFLAGS="$LDFLAGS -Wl,--export-dynamic" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="${CC_SEARCH_FLAGS}" else AC_CHECK_HEADER(dld.h, [ SHLIB_LD="ld -shared" DL_OBJS="tclLoadDld.o" DL_LIBS="-ldld" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS=""]) fi if test "`uname -m`" = "alpha" ; then CFLAGS="$CFLAGS -mieee" fi ;; MP-RAS-02*) SHLIB_CFLAGS="-K PIC" SHLIB_LD="cc -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; MP-RAS-*) SHLIB_CFLAGS="-K PIC" SHLIB_LD="cc -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" LDFLAGS="$LDFLAGS -Wl,-Bexport" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; NetBSD-Debian) SHLIB_CFLAGS="-fPIC" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" SHLIB_LD="${CC} -shared" DL_OBJS="tclLoadDl.o" DL_LIBS="" LDFLAGS="$LDFLAGS -Wl,--export-dynamic" LD_SEARCH_FLAGS="" ;; NetBSD-*|FreeBSD-[[1-2]].*|OpenBSD-*) # Not available on all versions: check for include file. AC_CHECK_HEADER(dlfcn.h, [ # NetBSD/SPARC needs -fPIC, -fpic will not do. SHLIB_CFLAGS="-fPIC" SHLIB_LD="ld -Bshareable -x" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' AC_MSG_CHECKING(for ELF) AC_EGREP_CPP(yes, [ #ifdef __ELF__ yes #endif ], AC_MSG_RESULT(yes) SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so', AC_MSG_RESULT(no) SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0' ) ], [ SHLIB_CFLAGS="" SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".a" DL_OBJS="tclLoadAout.o" DL_LIBS="" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a' ]) # FreeBSD doesn't handle version numbers with dots. UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a' TCL_LIB_VERSIONS_OK=nodots ;; OpenBSD-*) SHLIB_LD="${CC} -shared" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" AC_MSG_CHECKING(for ELF) AC_EGREP_CPP(yes, [ #ifdef __ELF__ yes #endif ], [AC_MSG_RESULT(yes) SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'], [AC_MSG_RESULT(no) SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'] ) # OpenBSD doesn't do version numbers with dots. UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a' TCL_LIB_VERSIONS_OK=nodots ;; FreeBSD-*) # FreeBSD 3.* and greater have ELF. SHLIB_CFLAGS="-fPIC" SHLIB_LD="ld -Bshareable -x" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" LDFLAGS="$LDFLAGS -export-dynamic" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' if test "${TCL_THREADS}" = "1" ; then # The -pthread needs to go in the CFLAGS, not LIBS LIBS=`echo $LIBS | sed s/-pthread//` CFLAGS="$CFLAGS -pthread" LDFLAGS="$LDFLAGS -pthread" fi case $system in FreeBSD-3.*) # FreeBSD-3 doesn't handle version numbers with dots. UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a' SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so' TCL_LIB_VERSIONS_OK=nodots ;; esac ;; Rhapsody-*|Darwin-*) SHLIB_CFLAGS="-fno-common" SHLIB_LD="cc -dynamiclib \${LDFLAGS}" TCL_SHLIB_LD_EXTRAS="-compatibility_version ${TCL_VERSION} -current_version \${VERSION} -install_name \${DYLIB_INSTALL_DIR}/\${TCL_LIB_FILE} -prebind -seg1addr 0xa000000" TK_SHLIB_LD_EXTRAS="-compatibility_version ${TK_VERSION} -current_version \${VERSION} -install_name \${DYLIB_INSTALL_DIR}/\${TK_LIB_FILE} -prebind -seg1addr 0xb000000" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".dylib" DL_OBJS="tclLoadDyld.o" PLAT_OBJS=\$\(MAC\_OSX_OBJS\) DL_LIBS="" LDFLAGS="$LDFLAGS -prebind" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" CFLAGS_OPTIMIZE="-Os" LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH" AC_DEFINE(MAC_OSX_TCL) AC_DEFINE(HAVE_CFBUNDLE) AC_DEFINE(USE_VFORK) AC_DEFINE(TCL_DEFAULT_ENCODING,"utf-8") LIBS="$LIBS -framework CoreFoundation" ;; NEXTSTEP-*) SHLIB_CFLAGS="" SHLIB_LD="cc -nostdlib -r" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadNext.o" DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; OS/390-*) CFLAGS_OPTIMIZE="" # Optimizer is buggy AC_DEFINE(_OE_SOCKETS) # needed in sys/socket.h ;; OSF1-1.0|OSF1-1.1|OSF1-1.2) # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1 SHLIB_CFLAGS="" # Hack: make package name same as library name SHLIB_LD='ld -R -export $@:' SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadOSF.o" DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; OSF1-1.*) # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2 SHLIB_CFLAGS="-fPIC" if test "$SHARED_BUILD" = "1" ; then SHLIB_LD="ld -shared" else SHLIB_LD="ld -non_shared" fi SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; OSF1-V*) # Digital OSF/1 SHLIB_CFLAGS="" if test "$SHARED_BUILD" = "1" ; then SHLIB_LD='ld -shared -expect_unresolved "*"' else SHLIB_LD='ld -non_shared -expect_unresolved "*"' fi SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}' if test "$GCC" = "yes" ; then CFLAGS="$CFLAGS -mieee" else CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee" fi # see pthread_intro(3) for pthread support on osf1, k.furukawa if test "${TCL_THREADS}" = "1" ; then CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE" CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64" LIBS=`echo $LIBS | sed s/-lpthreads//` if test "$GCC" = "yes" ; then LIBS="$LIBS -lpthread -lmach -lexc" else CFLAGS="$CFLAGS -pthread" LDFLAGS="$LDFLAGS -pthread" fi fi ;; QNX-6*) # QNX RTP # This may work for all QNX, but it was only reported for v6. SHLIB_CFLAGS="-fPIC" SHLIB_LD="ld -Bshareable -x" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" # dlopen is in -lc on QNX DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; RISCos-*) SHLIB_CFLAGS="-G 0" SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0" SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".a" DL_OBJS="tclLoadAout.o" DL_LIBS="" LDFLAGS="$LDFLAGS -Wl,-D,08000000" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} ;; SCO_SV-3.2*) # Note, dlopen is available only on SCO 3.2.5 and greater. However, # this test works, since "uname -s" was non-standard in 3.2.4 and # below. if test "$GCC" = "yes" ; then SHLIB_CFLAGS="-fPIC -melf" LDFLAGS="$LDFLAGS -melf -Wl,-Bexport" else SHLIB_CFLAGS="-Kpic -belf" LDFLAGS="$LDFLAGS -belf -Wl,-Bexport" fi SHLIB_LD="ld -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; SINIX*5.4*) SHLIB_CFLAGS="-K PIC" SHLIB_LD="cc -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; SunOS-4*) SHLIB_CFLAGS="-PIC" SHLIB_LD="ld" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} # SunOS can't handle version numbers with dots in them in library # specs, like -ltcl7.5, so use -ltcl75 instead. Also, it # requires an extra version number at the end of .so file names. # So, the library has to have a name like libtcl75.so.1.0 SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0' UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a' TCL_LIB_VERSIONS_OK=nodots ;; SunOS-5.[[0-6]]*) # Note: If _REENTRANT isn't defined, then Solaris # won't define thread-safe library routines. AC_DEFINE(_REENTRANT) AC_DEFINE(_POSIX_PTHREAD_SEMANTICS) SHLIB_CFLAGS="-KPIC" # Note: need the LIBS below, otherwise Tk won't find Tcl's # symbols when dynamically loaded into tclsh. SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" if test "$GCC" = "yes" ; then SHLIB_LD="$CC -shared" CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} else SHLIB_LD="/usr/ccs/bin/ld -G -z text" CC_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} fi ;; SunOS-5*) # Note: If _REENTRANT isn't defined, then Solaris # won't define thread-safe library routines. AC_DEFINE(_REENTRANT) AC_DEFINE(_POSIX_PTHREAD_SEMANTICS) SHLIB_CFLAGS="-KPIC" # Check to enable 64-bit flags for compiler/linker if test "$do64bit" = "yes" ; then arch=`isainfo` if test "$arch" = "sparcv9 sparc" ; then if test "$GCC" = "yes" ; then AC_MSG_WARN("64bit mode not supported with GCC on $system") else do64bit_ok=yes if test "$do64bitVIS" = "yes" ; then CFLAGS="$CFLAGS -xarch=v9a" LDFLAGS="$LDFLAGS -xarch=v9a" else CFLAGS="$CFLAGS -xarch=v9" LDFLAGS="$LDFLAGS -xarch=v9" fi fi else AC_MSG_WARN("64bit mode only supported sparcv9 system") fi fi # Note: need the LIBS below, otherwise Tk won't find Tcl's # symbols when dynamically loaded into tclsh. SHLIB_LD_LIBS='${LIBS}' SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" if test "$GCC" = "yes" ; then SHLIB_LD="$CC -shared" CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} else SHLIB_LD="/usr/ccs/bin/ld -G -z text" CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}' fi ;; ULTRIX-4.*) SHLIB_CFLAGS="-G 0" SHLIB_SUFFIX=".a" SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0" SHLIB_LD_LIBS='${LIBS}' DL_OBJS="tclLoadAout.o" DL_LIBS="" LDFLAGS="$LDFLAGS -Wl,-D,08000000" CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}' LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} if test "$GCC" != "yes" ; then CFLAGS="$CFLAGS -DHAVE_TZSET -std1" fi ;; UNIX_SV* | UnixWare-5*) SHLIB_CFLAGS="-KPIC" SHLIB_LD="cc -G" SHLIB_LD_LIBS="" SHLIB_SUFFIX=".so" DL_OBJS="tclLoadDl.o" DL_LIBS="-ldl" # Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers # that don't grok the -Bexport option. Test that it does. hold_ldflags=$LDFLAGS AC_MSG_CHECKING(for ld accepts -Bexport flag) LDFLAGS="$LDFLAGS -Wl,-Bexport" AC_TRY_LINK(, [int i;], [found=yes], [LDFLAGS=$hold_ldflags found=no]) AC_MSG_RESULT($found) CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" ;; esac if test "$do64bit" = "yes" -a "$do64bit_ok" = "no" ; then AC_MSG_WARN("64bit support being disabled -- don\'t know magic for this platform") fi # Step 4: If pseudo-static linking is in use (see K. B. Kenny, "Dynamic # Loading for Tcl -- What Became of It?". Proc. 2nd Tcl/Tk Workshop, # New Orleans, LA, Computerized Processes Unlimited, 1994), then we need # to determine which of several header files defines the a.out file # format (a.out.h, sys/exec.h, or sys/exec_aout.h). At present, we # support only a file format that is more or less version-7-compatible. # In particular, # - a.out files must begin with `struct exec'. # - the N_TXTOFF on the `struct exec' must compute the seek address # of the text segment # - The `struct exec' must contain a_magic, a_text, a_data, a_bss # and a_entry fields. # The following compilation should succeed if and only if either sys/exec.h # or a.out.h is usable for the purpose. # # Note that the modified COFF format used on MIPS Ultrix 4.x is usable; the # `struct exec' includes a second header that contains information that # duplicates the v7 fields that are needed. if test "x$DL_OBJS" = "xtclLoadAout.o" ; then AC_MSG_CHECKING(sys/exec.h) AC_TRY_COMPILE([#include ],[ struct exec foo; unsigned long seek; int flag; #if defined(__mips) || defined(mips) seek = N_TXTOFF (foo.ex_f, foo.ex_o); #else seek = N_TXTOFF (foo); #endif flag = (foo.a_magic == OMAGIC); return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry; ], tcl_ok=usable, tcl_ok=unusable) AC_MSG_RESULT($tcl_ok) if test $tcl_ok = usable; then AC_DEFINE(USE_SYS_EXEC_H) else AC_MSG_CHECKING(a.out.h) AC_TRY_COMPILE([#include ],[ struct exec foo; unsigned long seek; int flag; #if defined(__mips) || defined(mips) seek = N_TXTOFF (foo.ex_f, foo.ex_o); #else seek = N_TXTOFF (foo); #endif flag = (foo.a_magic == OMAGIC); return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry; ], tcl_ok=usable, tcl_ok=unusable) AC_MSG_RESULT($tcl_ok) if test $tcl_ok = usable; then AC_DEFINE(USE_A_OUT_H) else AC_MSG_CHECKING(sys/exec_aout.h) AC_TRY_COMPILE([#include ],[ struct exec foo; unsigned long seek; int flag; #if defined(__mips) || defined(mips) seek = N_TXTOFF (foo.ex_f, foo.ex_o); #else seek = N_TXTOFF (foo); #endif flag = (foo.a_midmag == OMAGIC); return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry; ], tcl_ok=usable, tcl_ok=unusable) AC_MSG_RESULT($tcl_ok) if test $tcl_ok = usable; then AC_DEFINE(USE_SYS_EXEC_AOUT_H) else DL_OBJS="" fi fi fi fi # Step 5: disable dynamic loading if requested via a command-line switch. AC_ARG_ENABLE(load, [ --disable-load disallow dynamic loading and "load" command], [tcl_ok=$enableval], [tcl_ok=yes]) if test "$tcl_ok" = "no"; then DL_OBJS="" fi if test "x$DL_OBJS" != "x" ; then BUILD_DLTEST="\$(DLTEST_TARGETS)" else echo "Can't figure out how to do dynamic loading or shared libraries" echo "on this system." SHLIB_CFLAGS="" SHLIB_LD="" SHLIB_SUFFIX="" DL_OBJS="tclLoadNone.o" DL_LIBS="" LDFLAGS="$LDFLAGS_ORIG" CC_SEARCH_FLAGS="" LD_SEARCH_FLAGS="" BUILD_DLTEST="" fi # If we're running gcc, then change the C flags for compiling shared # libraries to the right flags for gcc, instead of those for the # standard manufacturer compiler. if test "$DL_OBJS" != "tclLoadNone.o" ; then if test "$GCC" = "yes" ; then case $system in AIX-*) ;; BSD/OS*) ;; IRIX*) ;; NetBSD-*|FreeBSD-*|OpenBSD-*) ;; Rhapsody-*|Darwin-*) ;; RISCos-*) ;; SCO_SV-3.2*) ;; ULTRIX-4.*) ;; *) SHLIB_CFLAGS="-fPIC" ;; esac fi fi if test "$SHARED_LIB_SUFFIX" = "" ; then SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}${SHLIB_SUFFIX}' fi if test "$UNSHARED_LIB_SUFFIX" = "" ; then UNSHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a' fi if test "${SHARED_BUILD}" = "1" && test "${SHLIB_SUFFIX}" != "" ; then LIB_SUFFIX=${SHARED_LIB_SUFFIX} MAKE_LIB='${SHLIB_LD} -o [$]@ ${SHLIB_LD_FLAGS} ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}' INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)' else LIB_SUFFIX=${UNSHARED_LIB_SUFFIX} if test "$RANLIB" = "" ; then MAKE_LIB='$(STLIB_LD) [$]@ ${OBJS}' INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)' else MAKE_LIB='${STLIB_LD} [$]@ ${OBJS} ; ${RANLIB} [$]@' INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(LIB_FILE))' fi dnl Not at all clear what this was doing in Tcl's configure.in dnl or why it was needed was needed. In any event, this sort of dnl things needs to be done in the big loop above. dnl REMOVE THIS BLOCK LATER! (mdejong) dnl case $system in dnl BSD/OS*) dnl ;; dnl AIX-[[1-4]].*) dnl ;; dnl *) dnl SHLIB_LD_LIBS="" dnl ;; dnl esac fi # Stub lib does not depend on shared/static configuration if test "$RANLIB" = "" ; then MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS}' INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)' else MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS} ; ${RANLIB} [$]@' INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(STUB_LIB_FILE))' fi AC_SUBST(DL_LIBS) AC_SUBST(DL_OBJS) AC_SUBST(PLAT_OBJS) AC_SUBST(CFLAGS) AC_SUBST(CFLAGS_DEBUG) AC_SUBST(CFLAGS_OPTIMIZE) AC_SUBST(CFLAGS_WARNING) AC_SUBST(LDFLAGS) AC_SUBST(LDFLAGS_DEBUG) AC_SUBST(LDFLAGS_OPTIMIZE) AC_SUBST(CC_SEARCH_FLAGS) AC_SUBST(LD_SEARCH_FLAGS) AC_SUBST(STLIB_LD) AC_SUBST(SHLIB_LD) AC_SUBST(TCL_SHLIB_LD_EXTRAS) AC_SUBST(TK_SHLIB_LD_EXTRAS) AC_SUBST(SHLIB_LD_FLAGS) AC_SUBST(SHLIB_LD_LIBS) AC_SUBST(SHLIB_CFLAGS) AC_SUBST(SHLIB_SUFFIX) AC_SUBST(MAKE_LIB) AC_SUBST(MAKE_STUB_LIB) AC_SUBST(INSTALL_LIB) AC_SUBST(INSTALL_STUB_LIB) AC_SUBST(RANLIB) ]) #-------------------------------------------------------------------- # SC_SERIAL_PORT # # Determine which interface to use to talk to the serial port. # Note that #include lines must begin in leftmost column for # some compilers to recognize them as preprocessor directives, # and some build environments have stdin not pointing at a # pseudo-terminal (usually /dev/null instead.) # # Arguments: # none # # Results: # # Defines only one of the following vars: # HAVE_SYS_MODEM_H # USE_TERMIOS # USE_TERMIO # USE_SGTTY # #-------------------------------------------------------------------- AC_DEFUN(SC_SERIAL_PORT, [ AC_CHECK_HEADERS(sys/modem.h) AC_MSG_CHECKING([termios vs. termio vs. sgtty]) AC_CACHE_VAL(tcl_cv_api_serial, [ AC_TRY_RUN([ #include int main() { struct termios t; if (tcgetattr(0, &t) == 0) { cfsetospeed(&t, 0); t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB; return 0; } return 1; }], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no) if test $tcl_cv_api_serial = no ; then AC_TRY_RUN([ #include int main() { struct termio t; if (ioctl(0, TCGETA, &t) == 0) { t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB; return 0; } return 1; }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no) fi if test $tcl_cv_api_serial = no ; then AC_TRY_RUN([ #include int main() { struct sgttyb t; if (ioctl(0, TIOCGETP, &t) == 0) { t.sg_ospeed = 0; t.sg_flags |= ODDP | EVENP | RAW; return 0; } return 1; }], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=no, tcl_cv_api_serial=no) fi if test $tcl_cv_api_serial = no ; then AC_TRY_RUN([ #include #include int main() { struct termios t; if (tcgetattr(0, &t) == 0 || errno == ENOTTY || errno == ENXIO || errno == EINVAL) { cfsetospeed(&t, 0); t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB; return 0; } return 1; }], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no) fi if test $tcl_cv_api_serial = no; then AC_TRY_RUN([ #include #include int main() { struct termio t; if (ioctl(0, TCGETA, &t) == 0 || errno == ENOTTY || errno == ENXIO || errno == EINVAL) { t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB; return 0; } return 1; }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no) fi if test $tcl_cv_api_serial = no; then AC_TRY_RUN([ #include #include int main() { struct sgttyb t; if (ioctl(0, TIOCGETP, &t) == 0 || errno == ENOTTY || errno == ENXIO || errno == EINVAL) { t.sg_ospeed = 0; t.sg_flags |= ODDP | EVENP | RAW; return 0; } return 1; }], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=none, tcl_cv_api_serial=none) fi]) case $tcl_cv_api_serial in termios) AC_DEFINE(USE_TERMIOS);; termio) AC_DEFINE(USE_TERMIO);; sgtty) AC_DEFINE(USE_SGTTY);; esac AC_MSG_RESULT($tcl_cv_api_serial) ]) #-------------------------------------------------------------------- # SC_MISSING_POSIX_HEADERS # # Supply substitutes for missing POSIX header files. Special # notes: # - stdlib.h doesn't define strtol, strtoul, or # strtod insome versions of SunOS # - some versions of string.h don't declare procedures such # as strstr # # Arguments: # none # # Results: # # Defines some of the following vars: # NO_DIRENT_H # NO_ERRNO_H # NO_VALUES_H # HAVE_LIMITS_H or NO_LIMITS_H # NO_STDLIB_H # NO_STRING_H # NO_SYS_WAIT_H # NO_DLFCN_H # HAVE_UNISTD_H # HAVE_SYS_PARAM_H # # HAVE_STRING_H ? # #-------------------------------------------------------------------- AC_DEFUN(SC_MISSING_POSIX_HEADERS, [ AC_MSG_CHECKING(dirent.h) AC_TRY_LINK([#include #include ], [ #ifndef _POSIX_SOURCE # ifdef __Lynx__ /* * Generate compilation error to make the test fail: Lynx headers * are only valid if really in the POSIX environment. */ missing_procedure(); # endif #endif DIR *d; struct dirent *entryPtr; char *p; d = opendir("foobar"); entryPtr = readdir(d); p = entryPtr->d_name; closedir(d); ], tcl_ok=yes, tcl_ok=no) if test $tcl_ok = no; then AC_DEFINE(NO_DIRENT_H) fi AC_MSG_RESULT($tcl_ok) AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H)]) AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H)]) AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H)]) AC_CHECK_HEADER(limits.h, [AC_DEFINE(HAVE_LIMITS_H)], [AC_DEFINE(NO_LIMITS_H)]) AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0) AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0) AC_EGREP_HEADER(strtoul, stdlib.h, , tcl_ok=0) AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0) if test $tcl_ok = 0; then AC_DEFINE(NO_STDLIB_H) fi AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0) AC_EGREP_HEADER(strstr, string.h, , tcl_ok=0) AC_EGREP_HEADER(strerror, string.h, , tcl_ok=0) # See also memmove check below for a place where NO_STRING_H can be # set and why. if test $tcl_ok = 0; then AC_DEFINE(NO_STRING_H) fi AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H)]) AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H)]) # OS/390 lacks sys/param.h (and doesn't need it, by chance). AC_HAVE_HEADERS(unistd.h sys/param.h) ]) #-------------------------------------------------------------------- # SC_PATH_X # # Locate the X11 header files and the X11 library archive. Try # the ac_path_x macro first, but if it doesn't find the X stuff # (e.g. because there's no xmkmf program) then check through # a list of possible directories. Under some conditions the # autoconf macro will return an include directory that contains # no include files, so double-check its result just to be safe. # # Arguments: # none # # Results: # # Sets the the following vars: # XINCLUDES # XLIBSW # #-------------------------------------------------------------------- AC_DEFUN(SC_PATH_X, [ AC_PATH_X not_really_there="" if test "$no_x" = ""; then if test "$x_includes" = ""; then AC_TRY_CPP([#include ], , not_really_there="yes") else if test ! -r $x_includes/X11/Intrinsic.h; then not_really_there="yes" fi fi fi if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then AC_MSG_CHECKING(for X11 header files) found_xincludes="no" AC_TRY_CPP([#include ], found_xincludes="yes", found_xincludes="no") if test "$found_xincludes" = "no"; then dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/X11R6/include /usr/X11R5/include /usr/include/X11R5 /usr/include/X11R4 /usr/openwin/include /usr/X11/include /usr/sww/include" for i in $dirs ; do if test -r $i/X11/Intrinsic.h; then AC_MSG_RESULT($i) XINCLUDES=" -I$i" found_xincludes="yes" break fi done fi else if test "$x_includes" != ""; then XINCLUDES="-I$x_includes" found_xincludes="yes" fi fi if test found_xincludes = "no"; then AC_MSG_RESULT(couldn't find any!) fi if test "$no_x" = yes; then AC_MSG_CHECKING(for X11 libraries) XLIBSW=nope dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/X11R6/lib /usr/X11R5/lib /usr/lib/X11R5 /usr/lib/X11R4 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib" for i in $dirs ; do if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then AC_MSG_RESULT($i) XLIBSW="-L$i -lX11" x_libraries="$i" break fi done else if test "$x_libraries" = ""; then XLIBSW=-lX11 else XLIBSW="-L$x_libraries -lX11" fi fi if test "$XLIBSW" = nope ; then AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow) fi if test "$XLIBSW" = nope ; then AC_MSG_RESULT(couldn't find any! Using -lX11.) XLIBSW=-lX11 fi ]) #-------------------------------------------------------------------- # SC_BLOCKING_STYLE # # The statements below check for systems where POSIX-style # non-blocking I/O (O_NONBLOCK) doesn't work or is unimplemented. # On these systems (mostly older ones), use the old BSD-style # FIONBIO approach instead. # # Arguments: # none # # Results: # # Defines some of the following vars: # HAVE_SYS_IOCTL_H # HAVE_SYS_FILIO_H # USE_FIONBIO # O_NONBLOCK # #-------------------------------------------------------------------- AC_DEFUN(SC_BLOCKING_STYLE, [ AC_CHECK_HEADERS(sys/ioctl.h) AC_CHECK_HEADERS(sys/filio.h) AC_MSG_CHECKING([FIONBIO vs. O_NONBLOCK for nonblocking I/O]) if test -f /usr/lib/NextStep/software_version; then system=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version` else system=`uname -s`-`uname -r` if test "$?" -ne 0 ; then system=unknown else # Special check for weird MP-RAS system (uname returns weird # results, and the version is kept in special file). if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then system=MP-RAS-`awk '{print $3}' /etc/.relid'` fi if test "`uname -s`" = "AIX" ; then system=AIX-`uname -v`.`uname -r` fi fi fi case $system in # There used to be code here to use FIONBIO under AIX. However, it # was reported that FIONBIO doesn't work under AIX 3.2.5. Since # using O_NONBLOCK seems fine under AIX 4.*, I removed the FIONBIO # code (JO, 5/31/97). OSF*) AC_DEFINE(USE_FIONBIO) AC_MSG_RESULT(FIONBIO) ;; SunOS-4*) AC_DEFINE(USE_FIONBIO) AC_MSG_RESULT(FIONBIO) ;; ULTRIX-4.*) AC_DEFINE(USE_FIONBIO) AC_MSG_RESULT(FIONBIO) ;; *) AC_MSG_RESULT(O_NONBLOCK) ;; esac ]) #-------------------------------------------------------------------- # SC_TIME_HANLDER # # Checks how the system deals with time.h, what time structures # are used on the system, and what fields the structures have. # # Arguments: # none # # Results: # # Defines some of the following vars: # USE_DELTA_FOR_TZ # HAVE_TM_GMTOFF # HAVE_TM_TZADJ # HAVE_TIMEZONE_VAR # #-------------------------------------------------------------------- AC_DEFUN(SC_TIME_HANDLER, [ AC_CHECK_HEADERS(sys/time.h) AC_HEADER_TIME AC_STRUCT_TIMEZONE AC_CHECK_FUNCS(gmtime_r localtime_r) AC_MSG_CHECKING([tm_tzadj in struct tm]) AC_CACHE_VAL(tcl_cv_member_tm_tzadj, AC_TRY_COMPILE([#include ], [struct tm tm; tm.tm_tzadj;], tcl_cv_member_tm_tzadj=yes, tcl_cv_member_tm_tzadj=no)) AC_MSG_RESULT($tcl_cv_member_tm_tzadj) if test $tcl_cv_member_tm_tzadj = yes ; then AC_DEFINE(HAVE_TM_TZADJ) fi AC_MSG_CHECKING([tm_gmtoff in struct tm]) AC_CACHE_VAL(tcl_cv_member_tm_gmtoff, AC_TRY_COMPILE([#include ], [struct tm tm; tm.tm_gmtoff;], tcl_cv_member_tm_gmtoff=yes, tcl_cv_member_tm_gmtoff=no)) AC_MSG_RESULT($tcl_cv_member_tm_gmtoff) if test $tcl_cv_member_tm_gmtoff = yes ; then AC_DEFINE(HAVE_TM_GMTOFF) fi # # Its important to include time.h in this check, as some systems # (like convex) have timezone functions, etc. # AC_MSG_CHECKING([long timezone variable]) AC_CACHE_VAL(tcl_cv_var_timezone, AC_TRY_COMPILE([#include ], [extern long timezone; timezone += 1; exit (0);], tcl_cv_timezone_long=yes, tcl_cv_timezone_long=no)) AC_MSG_RESULT($tcl_cv_timezone_long) if test $tcl_cv_timezone_long = yes ; then AC_DEFINE(HAVE_TIMEZONE_VAR) else # # On some systems (eg IRIX 6.2), timezone is a time_t and not a long. # AC_MSG_CHECKING([time_t timezone variable]) AC_CACHE_VAL(tcl_cv_timezone_time, AC_TRY_COMPILE([#include ], [extern time_t timezone; timezone += 1; exit (0);], tcl_cv_timezone_time=yes, tcl_cv_timezone_time=no)) AC_MSG_RESULT($tcl_cv_timezone_time) if test $tcl_cv_timezone_time = yes ; then AC_DEFINE(HAVE_TIMEZONE_VAR) fi fi ]) #-------------------------------------------------------------------- # SC_BUGGY_STRTOD # # Under Solaris 2.4, strtod returns the wrong value for the # terminating character under some conditions. Check for this # and if the problem exists use a substitute procedure # "fixstrtod" (provided by Tcl) that corrects the error. # Also, on Compaq's Tru64 Unix 5.0, # strtod(" ") returns 0.0 instead of a failure to convert. # # Arguments: # none # # Results: # # Might defines some of the following vars: # strtod (=fixstrtod) # #-------------------------------------------------------------------- AC_DEFUN(SC_BUGGY_STRTOD, [ AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0) if test "$tcl_strtod" = 1; then AC_MSG_CHECKING([for Solaris2.4/Tru64 strtod bugs]) AC_CACHE_VAL(tcl_cv_strtod_buggy,[ AC_TRY_RUN([ extern double strtod(); int main() { char *infString="Inf", *nanString="NaN", *spaceString=" "; char *term; double value; value = strtod(infString, &term); if ((term != infString) && (term[-1] == 0)) { exit(1); } value = strtod(nanString, &term); if ((term != nanString) && (term[-1] == 0)) { exit(1); } value = strtod(spaceString, &term); if (term == (spaceString+1)) { exit(1); } exit(0); }], tcl_cv_strtod_buggy=1, tcl_cv_strtod_buggy=0, tcl_cv_strtod_buggy=0)]) if test "$tcl_cv_strtod_buggy" = 1; then AC_MSG_RESULT(ok) else AC_MSG_RESULT(buggy) LIBOBJS="$LIBOBJS fixstrtod.o" AC_DEFINE(strtod, fixstrtod) fi fi ]) #-------------------------------------------------------------------- # SC_TCL_LINK_LIBS # # Search for the libraries needed to link the Tcl shell. # Things like the math library (-lm) and socket stuff (-lsocket vs. # -lnsl) are dealt with here. # # Arguments: # Requires the following vars to be set in the Makefile: # DL_LIBS # LIBS # MATH_LIBS # # Results: # # Subst's the following var: # TCL_LIBS # MATH_LIBS # # Might append to the following vars: # LIBS # # Might define the following vars: # HAVE_NET_ERRNO_H # #-------------------------------------------------------------------- AC_DEFUN(SC_TCL_LINK_LIBS, [ #-------------------------------------------------------------------- # On a few very rare systems, all of the libm.a stuff is # already in libc.a. Set compiler flags accordingly. # Also, Linux requires the "ieee" library for math to work # right (and it must appear before "-lm"). #-------------------------------------------------------------------- AC_CHECK_FUNC(sin, MATH_LIBS="", MATH_LIBS="-lm") AC_CHECK_LIB(ieee, main, [MATH_LIBS="-lieee $MATH_LIBS"]) #-------------------------------------------------------------------- # Interactive UNIX requires -linet instead of -lsocket, plus it # needs net/errno.h to define the socket-related error codes. #-------------------------------------------------------------------- AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"]) AC_CHECK_HEADER(net/errno.h, [AC_DEFINE(HAVE_NET_ERRNO_H)]) #-------------------------------------------------------------------- # Check for the existence of the -lsocket and -lnsl libraries. # The order here is important, so that they end up in the right # order in the command line generated by make. Here are some # special considerations: # 1. Use "connect" and "accept" to check for -lsocket, and # "gethostbyname" to check for -lnsl. # 2. Use each function name only once: can't redo a check because # autoconf caches the results of the last check and won't redo it. # 3. Use -lnsl and -lsocket only if they supply procedures that # aren't already present in the normal libraries. This is because # IRIX 5.2 has libraries, but they aren't needed and they're # bogus: they goof up name resolution if used. # 4. On some SVR4 systems, can't use -lsocket without -lnsl too. # To get around this problem, check for both libraries together # if -lsocket doesn't work by itself. #-------------------------------------------------------------------- tcl_checkBoth=0 AC_CHECK_FUNC(connect, tcl_checkSocket=0, tcl_checkSocket=1) if test "$tcl_checkSocket" = 1; then AC_CHECK_FUNC(setsockopt, , [AC_CHECK_LIB(socket, setsockopt, LIBS="$LIBS -lsocket", tcl_checkBoth=1)]) fi if test "$tcl_checkBoth" = 1; then tk_oldLibs=$LIBS LIBS="$LIBS -lsocket -lnsl" AC_CHECK_FUNC(accept, tcl_checkNsl=0, [LIBS=$tk_oldLibs]) fi AC_CHECK_FUNC(gethostbyname, , [AC_CHECK_LIB(nsl, gethostbyname, [LIBS="$LIBS -lnsl"])]) # Don't perform the eval of the libraries here because DL_LIBS # won't be set until we call SC_CONFIG_CFLAGS TCL_LIBS='${DL_LIBS} ${LIBS} ${MATH_LIBS}' AC_SUBST(TCL_LIBS) AC_SUBST(MATH_LIBS) ]) #-------------------------------------------------------------------- # SC_TCL_EARLY_FLAGS # # Check for what flags are needed to be passed so the correct OS # features are available. # # Arguments: # None # # Results: # # Might define the following vars: # _ISOC99_SOURCE # _LARGEFILE64_SOURCE # #-------------------------------------------------------------------- AC_DEFUN(SC_TCL_EARLY_FLAG,[ AC_CACHE_VAL([tcl_cv_flag_]translit($1,[A-Z],[a-z]), AC_TRY_COMPILE([$2], $3, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no, AC_TRY_COMPILE([[#define ]$1[ 1 ]$2], $3, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=yes, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no))) if test ["x${tcl_cv_flag_]translit($1,[A-Z],[a-z])[}" = "xyes"] ; then AC_DEFINE($1) tcl_flags="$tcl_flags $1" fi]) AC_DEFUN(SC_TCL_EARLY_FLAGS,[ AC_MSG_CHECKING([for required early compiler flags]) tcl_flags="" SC_TCL_EARLY_FLAG(_ISOC99_SOURCE,[#include ], [char *p = (char *)strtoll; char *q = (char *)strtoull;]) SC_TCL_EARLY_FLAG(_LARGEFILE64_SOURCE,[#include ], [struct stat64 buf; int i = stat64("/", &buf);]) if test "x${tcl_flags}" = "x" ; then AC_MSG_RESULT(none) else AC_MSG_RESULT(${tcl_flags}) fi]) #-------------------------------------------------------------------- # SC_TCL_64BIT_FLAGS # # Check for what is defined in the way of 64-bit features. # # Arguments: # None # # Results: # # Might define the following vars: # TCL_WIDE_INT_IS_LONG # TCL_WIDE_INT_TYPE # HAVE_STRUCT_DIRENT64 # HAVE_STRUCT_STAT64 # HAVE_TYPE_OFF64_T # #-------------------------------------------------------------------- AC_DEFUN(SC_TCL_64BIT_FLAGS, [ AC_MSG_CHECKING([for 64-bit integer type]) AC_CACHE_VAL(tcl_cv_type_64bit,[ tcl_cv_type_64bit=none # See if the compiler knows natively about __int64 AC_TRY_COMPILE(,[__int64 value = (__int64) 0;], tcl_type_64bit=__int64, tcl_type_64bit="long long") # See if we should use long anyway Note that we substitute in the # type that is our current guess for a 64-bit type inside this check # program, so it should be modified only carefully... AC_TRY_COMPILE(,[switch (0) { case 1: case (sizeof(]${tcl_type_64bit}[)==sizeof(long)): ; }],tcl_cv_type_64bit=${tcl_type_64bit})]) if test "${tcl_cv_type_64bit}" = none ; then AC_DEFINE(TCL_WIDE_INT_IS_LONG) AC_MSG_RESULT(using long) else AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit}) AC_MSG_RESULT(${tcl_cv_type_64bit}) # Now check for auxiliary declarations AC_MSG_CHECKING([for struct dirent64]) AC_CACHE_VAL(tcl_cv_struct_dirent64,[ AC_TRY_COMPILE([#include #include ],[struct dirent64 p;], tcl_cv_struct_dirent64=yes,tcl_cv_struct_dirent64=no)]) if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then AC_DEFINE(HAVE_STRUCT_DIRENT64) fi AC_MSG_RESULT(${tcl_cv_struct_dirent64}) AC_MSG_CHECKING([for struct stat64]) AC_CACHE_VAL(tcl_cv_struct_stat64,[ AC_TRY_COMPILE([#include ],[struct stat64 p; ], tcl_cv_struct_stat64=yes,tcl_cv_struct_stat64=no)]) if test "x${tcl_cv_struct_stat64}" = "xyes" ; then AC_DEFINE(HAVE_STRUCT_STAT64) fi AC_MSG_RESULT(${tcl_cv_struct_stat64}) AC_MSG_CHECKING([for off64_t]) AC_CACHE_VAL(tcl_cv_type_off64_t,[ AC_TRY_COMPILE([#include ],[off64_t offset; ], tcl_cv_type_off64_t=yes,tcl_cv_type_off64_t=no)]) AC_CHECK_FUNCS(open64 lseek64) dnl Define HAVE_TYPE_OFF64_T only when the off64_t type and the dnl functions lseek64 and open64 are defined. if test "x${tcl_cv_type_off64_t}" = "xyes" && \ test "x${ac_cv_func_lseek64}" = "xyes" && \ test "x${ac_cv_func_open64}" = "xyes" ; then AC_DEFINE(HAVE_TYPE_OFF64_T, 1, [Is off64_t in ?]) AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi fi])