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