path: root/aclocal.m4

dnl aclocal.m4 generated automatically by aclocal 1.4-p4

dnl Copyright (C) 1994, 1995-8, 1999 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.

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	<vicente@cena.fr>
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 <<EOT
#include <sys/types.h>
#include <sys/stat.h>

#include <unistd.h>

#include <stdlib.h>

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 # [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-tclconfig 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]]* 2>/dev/null` \
			../../tcl \
			`ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
			../../../tcl \
			`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 ${prefix}/lib 2>/dev/null` \
			`ls -d /usr/local/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_tcliconfig}" = x ; then
		for i in \
			${srcdir}/../tcl \
			`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]]* 2>/dev/null` \
			../../tk \
			`ls -dr ../../tk[[8-9]].[[0-9]]* 2>/dev/null` \
			../../../tk \
			`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 ${prefix}/lib 2>/dev/null` \
			`ls -d /usr/local/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]]* 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

    #
    # The eval is required to do the TCL_DBGX substitution in the
    # TCL_LIB_FILE variable
    #

    eval TCL_LIB_FILE=${TCL_LIB_FILE}
    eval TCL_LIB_FLAG=${TCL_LIB_FLAG}

    AC_SUBST(TCL_BIN_DIR)
    AC_SUBST(TCL_SRC_DIR)
    AC_SUBST(TCL_INC_DIR)
    AC_SUBST(TCL_LIB_FILE)
])

#------------------------------------------------------------------------
# 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 $TCLCONFIG])

    if test -f "$TK_BIN_DIR/tkConfig.sh" ; then
        AC_MSG_CHECKING([loading $TK_BIN_DIR/tkConfig.sh])
	. $TK_BIN_DIR/tkConfig.sh
    else
        AC_MSG_RESULT([could not find $TK_BIN_DIR/tkConfig.sh])
    fi

    AC_SUBST(TK_BIN_DIR)
    AC_SUBST(TK_SRC_DIR)
    AC_SUBST(TK_LIB_DIR)
    AC_SUBST(TK_LIB_FILE)
])

#------------------------------------------------------------------------
# SC_ENABLE_GCC --
#
#	Allows the use of GCC if available
#
# Arguments:
#	none
#	
# Results:
#
#	Adds the following arguments to configure:
#		--enable-gcc
#
#	Sets the following vars:
#		CC	Command to use for the compiler
#------------------------------------------------------------------------

AC_DEFUN(SC_ENABLE_GCC, [
    AC_ARG_ENABLE(gcc, [  --enable-gcc            allow use of gcc if available [--disable-gcc]],
	[ok=$enableval], [ok=no])
    if test "$ok" = "yes"; then
	CC=gcc
	AC_PROG_CC
    else
	CC=${CC-cc}
    fi
])

#------------------------------------------------------------------------
# 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_THREADS --
#
#	Specify if thread support should be enabled
#
# 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"; then
	AC_MSG_RESULT(yes)
	TCL_THREADS=1
	AC_DEFINE(TCL_THREADS)
	AC_DEFINE(_REENTRANT)
	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
	    	    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

	# Does the pthread-implementation provide
	# 'pthread_attr_setstacksize' ?

	AC_CHECK_FUNCS(pthread_attr_setstacksize)
    else
	TCL_THREADS=0
	AC_MSG_RESULT([no (default)])
    fi
])

#------------------------------------------------------------------------
# SC_ENABLE_SYMBOLS --
#
#	Specify if debugging symbols should be used
#
# Arguments:
#	none
#	
#	Requires the following vars to be set:
#		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])
    if test "$tcl_ok" = "yes"; then
	CFLAGS_DEFAULT="${CFLAGS_DEBUG}"
	LDFLAGS_DEFAULT="${LDFLAGS_DEBUG}"
	DBGX=g
	AC_MSG_RESULT([yes])
    else
	CFLAGS_DEFAULT="${CFLAGS_OPTIMIZE}"
	LDFLAGS_DEFAULT="${LDFLAGS_OPTIMIZE}"
	DBGX=""
	AC_MSG_RESULT([no])
    fi
])

#--------------------------------------------------------------------
# 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 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.
#       MAKE_LIB -      Command to execute to build the Tcl library;
#                       differs depending on whether or not Tcl is being
#                       compiled as a shared 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_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_LIB_FILE -  Name of the file that contains the Tcl library, such
#                       as libtcl7.8.so or libtcl7.8.a.
#       TCL_LIB_SUFFIX -Specifies everything that comes after the "libtcl"
#                       in the 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 the Tcl 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
#
#	EXTRA_CFLAGS
#
#	Subst's the following vars:
#		DL_LIBS
#		CFLAGS_DEBUG
#		CFLAGS_OPTIMIZE
#--------------------------------------------------------------------

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
	    AC_MSG_RESULT($system)
	fi
    fi

    AC_MSG_CHECKING([if gcc is being used])
    if test "$CC" = "gcc" -o `$CC -v 2>&1 | grep -c gcc` != "0" ; then
	using_gcc="yes"
    else
	using_gcc="no"
    fi

    AC_MSG_RESULT([$using_gcc ($CC)])

    # 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)

    # Step 3: set configuration options based on system name and version.

    do64bit_ok=no
    fullSrcDir=`cd $srcdir; pwd`
    EXTRA_CFLAGS=""
    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 "$using_gcc" = "yes" ; then
	CFLAGS_WARNING="-Wall -Wconversion -Wno-implicit-int"
    else
	CFLAGS_WARNING=""
    fi
    TCL_NEEDS_EXP_FILE=0
    TCL_BUILD_EXP_FILE=""
    TCL_EXP_FILE=""
    STLIB_LD="ar cr"
    case $system in
	AIX-5.*)
	    if test "${TCL_THREADS}" = "1" -a "$using_gcc" = "no" ; 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
	    # AIX-5 uses ELF style dynamic libraries
	    SHLIB_CFLAGS=""
	    SHLIB_LD="/usr/ccs/bin/ld -G -z text"

	    # 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"
	    # AIX-5 has dl* in libc.so
	    DL_LIBS=""
	    LDFLAGS=""
	    if test "$using_gcc" = "yes" ; then
		LD_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
	    else
		LD_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}'
	    fi

	    if test "$do64bit" = "yes" ; then
		if test "$using_gcc" = "no" ; then
		    do64bit_ok=yes
		    EXTRA_CFLAGS="-q64"
		    LDFLAGS="-q64"
		else 
		    AC_MSG_WARN("64bit mode not supported with GCC on $system")
		fi
	    fi
	    ;;
	AIX-*)
	    if test "${TCL_THREADS}" = "1" -a "$using_gcc" = "no" ; 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
	    SHLIB_CFLAGS=""
	    SHLIB_LD="$fullSrcDir/ldAix /bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS="-ldl"
	    LDFLAGS=""
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	    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

	    # 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
	    ;;
	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"
	    LDFLAGS=""
	    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="-export-dynamic"
	    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"
	    LDFLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*|HP-UX-*.11.*)
	    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="-Wl,-E"
		LD_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
	    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="-Wl,-D,08000000"
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	    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=""
	    LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	    EXTRA_CFLAGS=""
	    LDFLAGS=""
	    ;;
	IRIX-6.*|IRIX64-6.5*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="ld -n32 -shared -rdata_shared"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	    if test "$using_gcc" = "yes" ; then
		EXTRA_CFLAGS="-mabi=n32"
		LDFLAGS="-mabi=n32"
	    else
		case $system in
		    IRIX-6.3)
			# Use to build 6.2 compatible binaries on 6.3.
			EXTRA_CFLAGS="-n32 -D_OLD_TERMIOS"
			;;
		    *)
			EXTRA_CFLAGS="-n32"
			;;
		esac
		LDFLAGS="-n32"
	    fi
	    ;;
	IRIX64-6.*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="ld -32 -shared -rdata_shared"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    LDFLAGS=""
	    LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	    ;;
	Linux*)
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".so"

	    # 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="-rdynamic"
		LD_SEARCH_FLAGS=''
	    else
		AC_CHECK_HEADER(dld.h, [
		    SHLIB_LD="ld -shared"
		    DL_OBJS="tclLoadDld.o"
		    DL_LIBS="-ldld"
		    LDFLAGS=""
		    LD_SEARCH_FLAGS=""])
	    fi
	    if test "`uname -m`" = "alpha" ; then
		EXTRA_CFLAGS="-mieee"
	    fi
	    ;;
	GNU*)
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD_LIBS='${LIBS}'
	    SHLIB_SUFFIX=".so"

	    if test "$have_dl" = yes; then
		SHLIB_LD="${CC} -shared"
		DL_OBJS=""
		DL_LIBS="-ldl"
		LDFLAGS="-rdynamic"
		LD_SEARCH_FLAGS=""
	    else
		AC_CHECK_HEADER(dld.h, [
		    SHLIB_LD="ld -shared"
		    DL_OBJS=""
		    DL_LIBS="-ldld"
		    LDFLAGS=""
		    LD_SEARCH_FLAGS=""])
	    fi
	    if test "`uname -m`" = "alpha" ; then
		EXTRA_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"
	    LDFLAGS=""
	    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="-Wl,-Bexport"
	    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="${CC} -shared"
		SHLIB_LD_LIBS=""
		SHLIB_SUFFIX=".so"
		DL_OBJS="tclLoadDl.o"
		DL_LIBS=""
		LDFLAGS=""
		LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
		AC_MSG_CHECKING(for ELF)
		AC_EGREP_CPP(yes, [
#ifdef __ELF__
	yes
#endif
		],
		    AC_MSG_RESULT(yes)
		    SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.so',
		    AC_MSG_RESULT(no)
		    SHARED_LIB_SUFFIX='${VERSION}\$\{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=""
		LDFLAGS=""
		LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
		SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
	    ])
	    ;;
	FreeBSD-*)
	    # FreeBSD 3.* and greater have ELF.
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD="ld -Bshareable -x"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    LDFLAGS="-export-dynamic"
	    LD_SEARCH_FLAGS=""

	    # FreeBSD doesn't handle version numbers with dots.

	    UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
	    TCL_LIB_VERSIONS_OK=nodots
	    ;;
	Rhapsody-*|Darwin-*)
	    SHLIB_CFLAGS="-fno-common"
	    SHLIB_LD="cc -dynamiclib \${LDFLAGS} -compatibility_version ${TCL_MAJOR_VERSION} -current_version \${VERSION} -install_name \${LIB_RUNTIME_DIR}/\${TCL_LIB_FILE}"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".dylib"
	    DL_OBJS="tclLoadDyld.o"
	    DL_LIBS=""
	    LDFLAGS=""
	    LD_SEARCH_FLAGS=""
	    CFLAGS_OPTIMIZE="-O3"
	    ;;
	NEXTSTEP-*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="cc -nostdlib -r"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadNext.o"
	    DL_LIBS=""
	    LDFLAGS=""
	    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=""
	    LDFLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	OSF1-1.*)
	    # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD="ld -shared"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    LDFLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	OSF1-V*)
	    # Digital OSF/1
	    SHLIB_CFLAGS=""
	    SHLIB_LD='ld -shared -expect_unresolved "*"'
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    LDFLAGS=""
	    LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
	    if test "$using_gcc" = "no" ; then
		EXTRA_CFLAGS="-DHAVE_TZSET -std1"
	    fi
	    # see pthread_intro(3) for pthread support on osf1, k.furukawa
	    if test "${TCL_THREADS}" = "1" ; then
		EXTRA_CFLAGS="${EXTRA_CFLAGS} -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
		if test "$using_gcc" = "no" ; then
		    EXTRA_CFLAGS="${EXTRA_CFLAGS} -pthread"
		    LDFLAGS="-pthread"
		else
		    LIBS=`echo $LIBS | sed s/-lpthreads//`
		    LIBS="$LIBS -lpthread -lmach -lexc"
		fi
	    fi

	    ;;
	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="-Wl,-D,08000000"
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	    ;;
	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 "$using_gcc" = "yes" ; then
	    	SHLIB_CFLAGS="-fPIC -melf"
	    	LDFLAGS="-melf -Wl,-Bexport"
	    else
	    	SHLIB_CFLAGS="-Kpic -belf"
	    	LDFLAGS="-belf -Wl,-Bexport"
	    fi
	    SHLIB_LD="ld -G"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS=""
	    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"
	    LDFLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	SunOS-4*)
	    SHLIB_CFLAGS="-PIC"
	    SHLIB_LD="ld"
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    DL_OBJS="tclLoadDl.o"
	    DL_LIBS="-ldl"
	    LDFLAGS=""
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'

	    # 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]]*)
	    SHLIB_CFLAGS="-KPIC"
	    SHLIB_LD="/usr/ccs/bin/ld -G -z text"

	    # 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"
	    LDFLAGS=""
	    LD_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
	    ;;
	SunOS-5*)
	    SHLIB_CFLAGS="-KPIC"
	    SHLIB_LD="/usr/ccs/bin/ld -G -z text"
	    LDFLAGS=""
    
	    if test "$do64bit" = "yes" ; then
		arch=`isainfo`
		if test "$arch" = "sparcv9 sparc" ; then
			if test "$using_gcc" = "no" ; then
			    do64bit_ok=yes
			    if test "$do64bitVIS" = "yes" ; then
				EXTRA_CFLAGS="-xarch=v9a"
			    	LDFLAGS="-xarch=v9a"
			    else
				EXTRA_CFLAGS="-xarch=v9"
			    	LDFLAGS="-xarch=v9"
			    fi
			else 
			    AC_MSG_WARN("64bit mode not supported with GCC on $system")
			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 "$using_gcc" = "yes" ; then
		LD_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
	    else
		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="-Wl,-D,08000000"
	    LD_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
	    if test "$using_gcc" = "no" ; then
		EXTRA_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, found=no)
	    LDFLAGS=$hold_ldflags
	    AC_MSG_RESULT($found)
	    if test $found = yes; then
	    LDFLAGS="-Wl,-Bexport"
	    else
	    LDFLAGS=""
	    fi
	    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 <sys/exec.h>],[
	    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 <a.out.h>],[
		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 <sys/exec_aout.h>],[
		    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=""
	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 "$using_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

    AC_SUBST(DL_LIBS)
    AC_SUBST(CFLAGS_DEBUG)
    AC_SUBST(CFLAGS_OPTIMIZE)
    AC_SUBST(CFLAGS_WARNING)
])

#--------------------------------------------------------------------
# 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.
#
# Arguments:
#	none
#	
# Results:
#
#	Defines only one of the following vars:
#		USE_TERMIOS
#		USE_TERMIO
#		USE_SGTTY
#
#--------------------------------------------------------------------

AC_DEFUN(SC_SERIAL_PORT, [
    AC_MSG_CHECKING([termios vs. termio vs. sgtty])

    AC_TRY_RUN([
#include <termios.h>

main()
{
    struct termios t;
    if (tcgetattr(0, &t) == 0) {
	cfsetospeed(&t, 0);
	t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
	return 0;
    }
    return 1;
}], tk_ok=termios, tk_ok=no, tk_ok=no)

    if test $tk_ok = termios; then
	AC_DEFINE(USE_TERMIOS)
    else
	AC_TRY_RUN([
#include <termio.h>

main()
{
    struct termio t;
    if (ioctl(0, TCGETA, &t) == 0) {
	t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
	return 0;
    }
    return 1;
    }], tk_ok=termio, tk_ok=no, tk_ok=no)

    if test $tk_ok = termio; then
	AC_DEFINE(USE_TERMIO)
    else
	AC_TRY_RUN([
#include <sgtty.h>

main()
{
    struct sgttyb t;
    if (ioctl(0, TIOCGETP, &t) == 0) {
	t.sg_ospeed = 0;
	t.sg_flags |= ODDP | EVENP | RAW;
	return 0;
    }
    return 1;
}], tk_ok=sgtty, tk_ok=none, tk_ok=none)

    if test $tk_ok = sgtty; then
	AC_DEFINE(USE_SGTTY)
    else
	AC_TRY_RUN([
#include <termios.h>
#include <errno.h>

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;
}], tk_ok=termios, tk_ok=no, tk_ok=no)

    if test $tk_ok = termios; then
	AC_DEFINE(USE_TERMIOS)
    else
	AC_TRY_RUN([
#include <termio.h>
#include <errno.h>

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;
    }], tk_ok=termio, tk_ok=no, tk_ok=no)

    if test $tk_ok = termio; then
	AC_DEFINE(USE_TERMIO)
    else
	AC_TRY_RUN([
#include <sgtty.h>
#include <errno.h>

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;
}], tk_ok=sgtty, tk_ok=none, tk_ok=none)

    if test $tk_ok = sgtty; then
	AC_DEFINE(USE_SGTTY)
    fi
    fi
    fi
    fi
    fi
    fi
    AC_MSG_RESULT($tk_ok)
])

#--------------------------------------------------------------------
# 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
#		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 <sys/types.h>
#include <dirent.h>], [
#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(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 <X11/XIntrinsic.h>], , 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)
	XINCLUDES="# no special path needed"
	AC_TRY_CPP([#include <X11/Intrinsic.h>], , XINCLUDES="nope")
	if test "$XINCLUDES" = nope; 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"
		    break
		fi
	    done
	fi
    else
	if test "$x_includes" != ""; then
	    XINCLUDES=-I$x_includes
	else
	    XINCLUDES="# no special path needed"
	fi
    fi
    if test "$XINCLUDES" = nope; then
	AC_MSG_RESULT(couldn't find any!)
	XINCLUDES="# no include files found"
    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_MSG_CHECKING([tm_tzadj in struct tm])
    AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_tzadj;],
	    [AC_DEFINE(HAVE_TM_TZADJ)
	    AC_MSG_RESULT(yes)],
	    AC_MSG_RESULT(no))

    AC_MSG_CHECKING([tm_gmtoff in struct tm])
    AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_gmtoff;],
	    [AC_DEFINE(HAVE_TM_GMTOFF)
	    AC_MSG_RESULT(yes)],
	    AC_MSG_RESULT(no))

    #
    # Its important to include time.h in this check, as some systems
    # (like convex) have timezone functions, etc.
    #
    have_timezone=no
    AC_MSG_CHECKING([long timezone variable])
    AC_TRY_COMPILE([#include <time.h>],
	    [extern long timezone;
	    timezone += 1;
	    exit (0);],
	    [have_timezone=yes
	    AC_DEFINE(HAVE_TIMEZONE_VAR)
	    AC_MSG_RESULT(yes)],
	    AC_MSG_RESULT(no))

    #
    # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
    #
    if test "$have_timezone" = no; then
    AC_MSG_CHECKING([time_t timezone variable])
    AC_TRY_COMPILE([#include <time.h>],
	    [extern time_t timezone;
	    timezone += 1;
	    exit (0);],
	    [AC_DEFINE(HAVE_TIMEZONE_VAR)
	    AC_MSG_RESULT(yes)],
	    AC_MSG_RESULT(no))
    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_TRY_RUN([
	    extern double strtod();
	    int main()
	    {
		char *string = "NaN", *spaceString = " ";
		char *term;
		double value;
		value = strtod(string, &term);
		if ((term != string) && (term[-1] == 0)) {
		    exit(1);
		}
		value = strtod(spaceString, &term);
		if (term == (spaceString+1)) {
		    exit(1);
		}
		exit(0);
	    }], tcl_ok=1, tcl_ok=0, tcl_ok=0)
	if test "$tcl_ok" = 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)
])