# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8

# base: fonctions et variables de base pour utilisation sous Linux. requière
# l'utilisation de bash

##@provide sysinc/basevars

# === Variables diverses ===
# répertoire temporaire
export TMPDIR="${TMPDIR:-${TMP:-${TEMP:-/tmp}}}"
# BASEHOST est le nom d'hote *sans* domaine
export BASEHOST="${HOSTNAME%%.*}"
# FQDNHOST est le nom d'hote avec le domaine
if [ "$BASEHOST" != "$HOSTNAME" ]; then
    export FQDNHOST="$HOSTNAME"
else
    export FQDNHOST="$HOSTNAME.$(dnsdomainname)"
fi
# emplacement du script courant
scriptname="$(basename -- "$0")"
scriptdir="$(cd "$(dirname -- "$0")"; pwd)"
script="$scriptdir/$scriptname"

# fonction pour charger automatiquement /etc/default/$name et ~/etc/default/$name
function set_defaults() {
    local __f __s
    for __f in "$@"; do
        __s=
        if [ -r "/etc/default/$__f" ]; then
            source "/etc/default/$__f"
            __s=1
        fi
        if [ -r "$HOME/etc/default/$__f" ]; then
            source "$HOME/etc/default/$__f"
            __s=1
        fi
        if [ -z "$__s" ]; then
            # si pas de fichier dans ~/etc/default ni dans /etc/default, lire
            # $scriptdir/lib/default/$scriptname en dernier lieu
            if [ -r "$scriptdir/lib/default/$__f" ]; then
                source "$scriptdir/lib/default/$__f"
            fi
        fi
    done
}

# === diverses fonctions ===
function is_yes() {
    # retourner vrai si $1 est une valeur "oui"
    [ "$1" == "o" -o "$1" == "O" -o "$1" == "oui" -o "$1" == "OUI" ] && return 0
    [ "$1" == "y" -o "$1" == "Y" -o "$1" == "yes" -o "$1" == "YES" ] && return 0
    [ "$1" == "v" -o "$1" == "V" -o "$1" == "vrai" -o "$1" == "VRAI" ] && return 0
    [ "$1" == "t" -o "$1" == "T" -o "$1" == "true" -o "$1" == "TRUE" ] && return 0
    [ "$1" == "1" ] && return 0
    return 1
}

function is_no() {
    # retourner vrai si $1 est une valeur "non"
    [ "$1" == "n" -o "$1" == "N" -o "$1" == "non" -o "$1" == "NON" ] && return 0
    [ "$1" == "no" -o "$1" == "NO" ] && return 0
    [ "$1" == "f" -o "$1" == "F" -o "$1" == "faux" -o "$1" == "FAUX" ] && return 0
    [ "$1" == "false" -o "$1" == "FALSE" ] && return 0
    [ "$1" == "0" ] && return 0
    return 1
}

# retourner le premier caractère de la chaine $1
function first_char() { echo "${1:0:1}"; }
# retourner le dernier caractère de la chaine $1
function last_char() { echo "${1:$((-1)):1}"; }
# retourner tous les caractères de la chaine $1, excepté le dernier
function first_chars() { echo "${1:0:$((${#1}-1))}"; }
# retourner tous les caractères de la chaine $1, excepté le premier
function last_chars() { echo "${1:1}"; }
# Tester si le premier caractère de la chaine $1 est $2
function first_char_is() { test "${1:0:1}" = "$2"; }
# Tester si le dernier caractère de la chaine $1 est $2
function last_char_is() { test "${1:$((-1)):1}" = "$2"; }
# Tester si la chaine $1 commence par le wildcard $2
function beginswith() { eval 'test "${1#'"$(quote_arg "$2")"'}" != "$1"'; }
# Tester si la chaine $1 se termine par le wildcard $2
function endswith() { eval 'test "${1%'"$(quote_arg "$2")"'}" != "$1"'; }
# Dans la chaine $1, remplacer \ par \\, " par \" et $ par \$, et l'afficher
function quote_arg() {
    local s
    s="${1//\\/\\\\}"
    s="${s//\"/\\\"}"
    s="${s//$/\\$}"
    echo "$s"
    ## ou:
    #echo "$1" | awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
}
# Dans une chaine lue sur stdin, remplacer \ par \\, " par \" et $ par \$ et
# l'afficher
function quote_string() {
    awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
    ##ou:
    #quote_arg "`cat`"
    ## mais cet dernière version est très lente sur un gros fichier
}
# Dans la chaine $1, remplacer '%' par '%25', '+' par '%2B', '&' par '%26', '=' par '%3D', ' ' par '+'
function quote_formvalue() {
    local s="$1"
    s="${s//\%/%25}"
    s="${s//+/%2B}"
    s="${s//&/%26}"
    s="${s//=/%3D}"
    s="${s// /+}"
    echo "$s"
}
# Afficher le nombre de lignes d'un fichier
function get_nblines() {
    [ -f "$1" ] && sed -ne '$=' "$1" || echo 0
}
# générer un fichier temporaire et retourner son nom
function mktempf() {
    mktemp "${1:-"$TMPDIR/tmp.XXXXXX"}"
}
# générer un répertoire temporaire et retourner son nom
function mktempd() {
    mktemp -d "${1:-"$TMPDIR/tmp.XXXXXX"}"
}
# Créer le répertoire correspondant à un fichier
function mkdirof() {
    mkdir -p "$(dirname "$1")"
}
# dans la chaine $1, remplacer \ par \\ et " par \", et l'afficher. ceci est
# utile pour quoter des valeur à insérer dans un script awk
function quote_awk() {
    local s
    s="${1//\\\\/\\\\}"
    s="${s//\"/\\\"}"
    echo "$s"
}
# tester si gawk est disponible
function require_gawk() {
    local OENC="$UTF8"
    if [ -n "$__legacy_awk__" ]; then
        ewarn "Cette fonction requière gnuawk"
        return 1
    fi
    return 0
}
# lancer awk en essayant d'émuler des fonctionnalités de gnuawk (comme l'option
# -v et la fonction gensub (XXX à faire))
function uawk() {
    if [ -z "$__legacy_awk__" ]; then
        awk "$@"
    else
        # essayer d'émuler l'option -v
        local script='BEGIN {'
        local done=
        while [ -n "$1" ]; do
            case "$1" in
            --)
                shift
                done=1
                ;;

            -v)
                shift
                local name=${1%%=*}
                local value=${1:$((${#name} + 1))}
                if [ "$value" == "" ]; then
                    # valeur vide
                    script="$script
$name = \"\""
                elif [ "${value//[0-9]*/}" == "" ]; then
                    # valeur numérique
                    script="$script
$name = $value"
                else
                    # valeur alphanumérique
                    script="$script
$name = \"$(quote_awk "$value")\""
                fi
                ;;

            -*)
                #ewarn "option non reconnue: $1"
                ;;

            *)
                done=1
                ;;
            esac
            [ -n "$done" ] && break
            shift
        done

        script="$script
}
$1"
        shift
        awk "$script" "$@"
    fi
}
# Retourner la commande permettant de donner à la variable ${!1} la valeur $2
function set_var_cmd() { echo "$1=\"$(quote_arg "$2")\""; }
# donner à la variable ${!1} la valeur $2
function set_var() { eval "$1=\"$(quote_arg "$2")\""; }
# donner à la variable ${!1} la valeur $2. on assume que les valeur sont déjà
# quotées comme il faut
function set_var_literal() { eval "$1=$2"; }
# copier en gardant le maximum de propriétés
function cp_a() { /bin/cp -a "$@"; }
# copier récursivement, en suivant les liens symboliques
function cp_R() { /bin/cp -pR "$@"; }
# supprimer les fichiers dont on donne éventuellement la liste
function rm_maybe() {
    local parse_opts=1 arg rm
    for arg in "$@"; do
        # chercher s'il y a un argument autre que des options
        if [ -n "$parse_opts" ]; then
            if [ "$arg" == "--" ]; then
                parse_opts=
            elif [[ "$arg" == "-*" ]]; then
                continue
            elif [ -n "$arg" ]; then
                rm=1
                break
            fi
        elif [ -n "$arg" ]; then
            rm=1
            break
        fi
    done
    [ -n "$rm" ] && /bin/rm "$@"
}
# lister les fichiers ou répertoires du répertoire $1, un par ligne
function list_all() {
    # $1=un répertoire dont le contenu doit être listé
    # $2..@=un ensemble de patterns pour le listage
    local curdir="$(pwd)"
    local b="${1:-.}"; shift

    cd "$b" 2>/dev/null || return
    eval "/bin/ls -1d ${*:-*} 2>/dev/null"
    cd "$curdir"
}
# lister les fichiers du répertoire $1, un par ligne
function list_files() {
    # $1=un répertoire dont le contenu doit être listé.
    # $2..@=un ensemble de patterns pour le listage
    local f
    local curdir="$(pwd)"
    local b="${1:-.}"; shift

    cd "$b" 2>/dev/null || return
    eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
        [ -f "$f" ] && echo "$f"
    done
    cd "$curdir"
}
# lister les répertoires du répertoire $1, un par ligne
function list_dirs() {
    # $1=un répertoire dont le contenu doit être listé.
    # $2..@=un ensemble de patterns pour le listage
    local f
    local curdir="$(pwd)"
    local b="${1:-.}"; shift

    cd "$b" 2>/dev/null || return
    eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
        [ -d "$f" ] && echo "$f"
    done
    cd "$curdir"
}
# copier un fichier dans un répertoire, ou le contenu d'un répertoire dans un
# autre répertoire, que le répertoire source soit un lien symbolique ou
# non. Cette fonction existe parce que le comportement de "cp_a src dest" n'est
# pas consistant selon les plateformes, surtout si src est un lien symbolique
# sur un répertoire: parfois on copie le lien, parfois on copie le contenu du
# répertoire, parfois on copie le répertoire...
function cpdir() {
    # $1=src, $2=dest, $3=method (cp_a par défaut)
    local src="$1" dest="$2" method="${3:-cp_a}"

    if [ -d "$src" ]; then
        # si c'est un répertoire, traitement particulier
        # tout d'abord, s'assurer que la destination existe
        if [ ! -d "$dest" ]; then
            mkdir -p "$dest"
        fi

        # ensuite on fait la copie
        local prevdir="$(pwd)"

        dest="$(abspath "$dest")" # XXX abspath défini dans functions!
        cd "$src"
        if [ -n "$(/bin/ls -a1)" ]; then
            # copier les fichiers
            [ -n "$(/bin/ls -1)" ] && "$method" * "$dest"
            # ne pas oublier les fichiers cachés...
            local i
            for i in .*; do
                [ "$i" == "." -o "$i" == ".." ] && continue
                "$method" "$i" "$dest"
            done
        fi
        cd "$prevdir"
    else
        # sinon, on assume que c'est un fichier
        if [ -f "$dest" ]; then
            # copie du fichier avec remplacement
            "$method" "$src" "$dest"
        elif [ -d "$dest" ]; then
            # copie du fichier dans le répertoire
            "$method" "$src" "$dest"
        else
            # Copie du fichier avec le nom $dest
            mkdirof "$dest"
            "$method" "$src" "$dest"
        fi
    fi
}
# transformer les fins de ligne en LF
function nl2lf() {
    if [ -n "$1" -a "$1" != "-" ]; then
        tr -d '\r' <"$1" >"$1.tmp.$$" &&
        /bin/mv "$1.tmp.$$" "$1"
        [ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
    else
        tr -d '\r'
    fi
}
# transformer les fins de ligne en CRLF
function _nl2crlf() {
    tr -d '\r' | awk '{print $0 "\r"}'
}
function nl2crlf() {
    if [ -n "$1" -a "$1" != "-" ]; then
        _nl2crlf <"$1" >"$1.tmp.$$" &&
        /bin/mv "$1.tmp.$$" "$1"
        [ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
    else
        _nl2crlf
    fi
}
# tester la présence d'un pattern dans un fichier
function quietgrep() { grep -q "$@"; }
# tester si deux fichiers sont identiques
function quietdiff() { diff -q "$@" >&/dev/null; }
# tester si deux fichiers sont identiques/différents
function testsame() { quietdiff "$@"; }
function testdiff() { ! quietdiff "$@"; }
# test si $2 n'existe pas ou si $1 est plus récent que $2
function testnewer() { test ! -e "$2" -o "$1" -nt "$2"; }
# afficher tous les processus avec le maximum d'informations
function ps_all() { ps -axww; }
# tester l'existence d'un programme dans le PATH
function progexists() { test -n "$1" -a -x "$(which "$1" 2>/dev/null)"; }
# tester si on est root
function is_root() { test `id -u` -eq 0; }
# sourcer un fichier s'il existe
function source_ifexists() { if [ -f "$1" ]; then source "$1" || die; fi; }
# s'endormir pour une très petite période de temps
function little_sleep { LC_NUMERIC=C sleep 0.1; }
# tester si un programme dont on donne le PID tourne
function is_running() { test -n "$(ps -o pid -p "$1" | grep -v PID)"; }
# afficher des chemins "jolis"
function ppath() {
    # Dans un chemin *absolu*, remplacer "$HOME" par "~" et "$(pwd)/" par "",
    # afin que le chemin soit plus facile à lire. Le répertoire courant est
    # spécifié par $2 ou $(pwd) si $2 est vide
    local path="$1" cwd="$2"

    # essayer de normaliser le chemin
    if [ -d "$path" ]; then path="$(cd "$path"; pwd)"
    elif [ -f "$path" ]; then path="$(cd "$(dirname "$path")"; pwd)/$(basename "$path")"
    else
        : # chemin inexistant, on espère que le chemin est bien formé
    fi

    if [ -z "$2" ]; then
        cwd="$(pwd)"
    fi
    [ "$path" = "$cwd" ] && path="."
    [ "$cwd" != "/" -a "$cwd" != "$HOME" ] && path="${path/#$cwd\//}"
    path="${path/#$HOME/~}"

    echo "$path"
}
# un équivalent de basename écris en bash. note: le cas $1=/ n'est pas traité correctement
function bname() {
    local bn="${1%%/}"
    bn="${p##*/}"
    [ -n "$2" ] && bn="${p%%$2}"
    echo "$bn"
}
# un équivalent de dirname écris en bash
function dname() {
    local dn="${1%%/}"
    case "$dn" in
    */*)
        dn="${dn%/*}"
        ;;
    *)
        dn="."
        ;;
    esac
    echo "$dn"
}
# sed qui modifie le fichier en place. pour compatibilité avec d'autres
# plateformes (cf system_caps), cette version ne devrait être appelée que de
# cette manière::
#     sedi "script" [files...]
# toute autre utilisation fonctionnerait sur Linux mais pas sur MacOS X ou SunOS
function sedi() {
    sed -i "$@"
}
# run_as: fonction pour relancer le script courant afin qu'il tourne avec les
# droits d'un autre user (typiquement root). Attention! cette fonction ne teste
# pas avec si on est déjà ce user. Il y a donc un risque de boucle infinie si on
# ne teste pas le user courant.
function run_as() {
    # Lancer cette fonction avec les arguments du script en cours. Par exemple::
    #     run_as root "$@"
    # Si $2=--noexec, on n'utilise pas la fonction exec, ce qui fait que la
    # fonction retourne. Sinon, on peut considérer que cette fonction ne
    # retourne jamais
    local OENC="$UTF8"
    local user="${1:-root}"; shift
    local exec_maybe=exec
    if [ "$1" = "--noexec" ]; then
        exec_maybe=
        shift
    fi

    # on peut spécifer localement le niveau de verbosité
    local VERBOSITY="$VERBOSITY" INTERACTION="$INTERACTION"
    set_verbosity "$1" && shift

    estep "Lancement du script sur $HOSTNAME en tant que $user"
    if is_yes "$UTOOLS_USES_SU" || ! progexists sudo; then
        einfo "Entrez le mot de passe de root"
        $exec_maybe su "$user" -c "${BASH:-/bin/sh} \"$0\" $*"
    else
        einfo "Entrez le mot de passe de $USER (si nécessaire)"
        if [ "$user" == "root" ]; then
            $exec_maybe sudo "${BASH:-/bin/sh}" "$0" "$@"
        else
            local args="$*"
            args="${args//|/\\|}"
            args="${args//</\\<}"
            args="${args//>/\\>}"
            args="${args//;/\\;}"
            $exec_maybe sudo su "$user" -c "${BASH:-/bin/sh} \"$0\" $args"
        fi
    fi
}
# run_as_root: fonction pour relancer le script courant afin qu'il tourne en
# root. Attention! cette fonction ne teste pas avec is_root si on est déjà en
# root ou non. Ne pas appeler cette fonction si is_root est vrai, on risque une
# boucle infinie.
function run_as_root() {
    run_as root "$@"
}

# === fonctions pour contrôler l'encoding en sortie et en entrée ===
LATIN1=iso-8859-1
LATIN9=iso-8859-15
UTF8=utf-8

if ! progexists iconv; then
    function iconv() { cat; }
fi

function __lang_encoding() {
    local lang="$(<<<"$LANG" awk '{ print tolower($0) }')"
    case "$lang" in
    fr_fr@euro) echo "iso-8859-15";;
    fr_fr) echo "iso-8859-1";;
    *.utf-8) echo "utf-8";;
    *) ;;
    esac
}
function __norm_encoding() {
    awk '{
        enc = tolower($0)
        gsub(/^latin$/, "latin1", enc)
        gsub(/^latin1$/, "iso-8859-1", enc)
        gsub(/^latin9$/, "iso-8859-15", enc)
        gsub(/[-_]/, "", enc)
        if (enc == "iso8859" || enc == "iso88591"  || enc == "8859" || enc == "88591") print "iso-8859-1"
        else if (enc == "iso885915"  || enc == "885915") print "iso-8859-15"
        else if (enc == "utf8") print "utf-8"
        else print $0
    }' <<<"$1"
}
function __init_encoding() {
    local DEFAULT_ENCODING="$(__lang_encoding)"
    [ -n "$DEFAULT_ENCODING" ] || DEFAULT_ENCODING=utf-8
    [ -n "$UTOOLS_OUTPUT_ENCODING" ] || UTOOLS_OUTPUT_ENCODING="$DEFAULT_ENCODING"
    UTOOLS_OUTPUT_ENCODING="$(__norm_encoding "$UTOOLS_OUTPUT_ENCODING")"
    [ -n "$UTOOLS_INPUT_ENCODING" ] || UTOOLS_INPUT_ENCODING="$UTOOLS_OUTPUT_ENCODING"
    UTOOLS_INPUT_ENCODING="$(__norm_encoding "$UTOOLS_INPUT_ENCODING")"
    [ -n "$UTOOLS_EDITOR_ENCODING" ] || UTOOLS_EDITOR_ENCODING="$UTOOLS_INPUT_ENCODING"
    UTOOLS_EDITOR_ENCODING="$(__norm_encoding "$UTOOLS_EDITOR_ENCODING")"

    IENC="$UTOOLS_INPUT_ENCODING"
    OENC="$UTOOLS_OUTPUT_ENCODING"
}
__init_encoding

function tooenc() {
    local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
    if [ "$from" == "$to" ]; then
        echo "$src"
    else
        iconv -f "$from" -t "$to" <<<"$src"
    fi
}
function uecho() { tooenc "$*"; }
function tooenc_() {
    local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
    if [ "$from" == "$to" ]; then
        echo_ "$src"
    else
        echo_ "$src" | iconv -f "$from" -t "$to"
    fi
}
function uecho_() { tooenc_ "$*"; }
function toienc() {
    local var_="$1" to_="${2:-$IENC}" from_="${3:-$UTOOLS_INPUT_ENCODING}"
    if [ "$from_" != "$to_" ]; then
        set_var "$var_" "$(iconv -f "$from_" -t "$to_" <<<"${!1}")"
    fi
}
function uread() {
    local var_
    [ $# == 0 ] && set -- REPLY
    read "$@"
    for var_ in "$@"; do
        [ -z "$var_" -o "${var_:0:1}" == "-" ] && continue # ignorer les options
        toienc "$var_"
    done
}

function stooenc() {
    local from="${1:-$OENC}" to="${2:-$UTOOLS_OUTPUT_ENCODING}"
    if [ "$from" == "$to" ]; then
        cat
    else
        iconv -f "$from" -t "$to"
    fi
}
function stoolatin1() { stooenc "iso-8859-1"; }
function stoolatin9() { stooenc "iso-8859-15"; }
function stooutf8() { stooenc "utf-8"; }
function stoienc() {
    local to="${1:-$IENC}" from="${2:-$UTOOLS_INPUT_ENCODING}"
    if [ "$from" == "$to" ]; then
        cat
    else
        iconv -f "$from" -t "$to"
    fi
}
function stoilatin1() { stoienc "iso-8859-1"; }
function stoilatin9() { stoienc "iso-8859-15"; }
function stoiutf8() { stoienc "utf-8"; }

# === fonctions pour contrôler l'affichage et l'interaction utilisateur  ===
# ces fonctions n'affiche le message que si le niveau de "verbosité" est
# suffisant:
# 4=afficher les messages de debug; 3=afficher les message informatifs;
# 2=afficher les warnings et les notes; 1=afficher les erreurs
# 0=ne rien afficher

# niveau de "verbosité". on commence par défaut à 3
MIN_VERBOSITY=0
DEF_VERBOSITY=3
MAX_VERBOSITY=4
export VERBOSITY="${VERBOSITY:-$DEF_VERBOSITY}"
# niveau d'interaction.
MIN_INTERACTION=0
DEF_INTERACTION=2
MAX_INTERACTION=3
export INTERACTION="${INTERACTION:-$DEF_INTERACTION}"

function set_verbosity() {
    # Configurer le niveau de verbosité ou d'interaction en fonction de la
    # valeur de $1. Retourner 0 si l'argument a été utilisé, 1 sinon

    # $2 est la valeur d'un préfixe pour reconnaitre des options courtes
    # supplémentaires. Par défaut, les options suivantes sont reconnues: -c, -q,
    # -v, -Q, -D, ... Si le préfixe est -v par exemple, les options reconnues
    # seront -vc, -vq, -vv, -vQ, -vD, ... *en plus* de -c, -q, -v, -Q, -D, ...

    local retval=0
    local enable_fake_arg=
    local prefix="-"

    if [ "$1" = "--enable-fake-arg" ]; then
        shift
        enable_fake_arg=1
    fi

    [ -n "$2" ] && prefix="$2"
    case "$1" in
    # Ne changer, ni le niveau de verbosité, ni le niveau d'interaction, mais
    # seulement si --enable-fake-arg a été activé
    # Cette option permet à ask_yesno() et read_value() de spécifier les
    # messages qui doivent être affichés dans le niveau par défaut de
    # verbosité/interaction
    -c|"${prefix}c"|--default)
        [ -n "$enable_fake_arg" ] || retval=1
        ;;

    # Configurer le niveau de verbosité en fonction de l'argument: -q le
    # diminue, -Q le met au minimum, -v l'augmente, -D le met au maximum
    -q|"${prefix}q"|--quiet)
        [ $VERBOSITY -gt $MIN_VERBOSITY ] && VERBOSITY=$(($VERBOSITY - 1))
        ;;
    -v|"${prefix}v"|--verbose)
        [ $VERBOSITY -lt $MAX_VERBOSITY ] && VERBOSITY=$(($VERBOSITY + 1))
        ;;
    -Q|"${prefix}Q"|--very-quiet)
        VERBOSITY=$MIN_VERBOSITY
        ;;
    -D|"${prefix}D"|--debug)
        VERBOSITY=$MAX_VERBOSITY
        ;;

    # Configurer le niveau d'interaction en fonction de l'argument: -b le met au
    # minimum, -y le diminue, -i l'augmente
    -b|"${prefix}b"|--batch)
        # niveau d'interaction minimum
        INTERACTION=$MIN_INTERACTION
        ;;
    -y|"${prefix}y"|--automatic)
        # Dimininuer le niveau d'interaction
        [ $INTERACTION -gt $MIN_INTERACTION ] && INTERACTION=$(($INTERACTION - 1))
        ;;
    -i|"${prefix}i"|--interactive)
        # Augmenter le niveau d'interaction. Augmenter aussi le niveau de verbosité
        [ $INTERACTION -lt $MAX_INTERACTION ] && INTERACTION=$(($INTERACTION + 1))
        ;;

    *)
        retval=1
        ;;
    esac
    return $retval
}

function check_verbosity() {
    # Teste si le niveau de verbosité/interaction courant est suffisant pour une
    # opération dont le niveau est donné par $1

    # Par exemple, 'check_verbosity -y' ne retourne vrai que si le niveau
    # d'interaction courant est supérieur ou égal à ($DEF_INTERACTION - 1). Cela
    # permet d'afficher un message ou d'effectuer une opération si on est au
    # moins en mode automatic (par contre, en mode batch, l'opération ne sera
    # pas effectué

    # De même 'check_verbosity -v' ne retourne vrai que si le niveau de
    # verbosité courant est supérieur ou égal à ($DEF_VERBOSITY+1). Cela permet
    # de n'afficher un message que si l'on est en mode verbose par exemple.

    # 'check_verbosity -c' retourne toujours vrai

    # Si $1 n'est pas un argument valide pour set_verbosity, alors on teste le
    # niveau de verbosité ou d'interaction par défaut. si $2!="", alors on teste
    # si le niveau de verbosité courant est supérieur à $2. Si $3!="", alors on
    # teste sur le niveau d'interaction est supérieur à $3

    # Si le premier argument est --action, alors on affiche "shift", "return",
    # ou ":" suivant l'action à effectuer. Sinon, retourner 0 si le niveau est
    # correct (Si $2="" et $3="", l'argument a été interprété et il faut faire
    # un shift. Sinon l'argument a peut-être été interprété. On ne sait pas
    # alors, sauf si on spécifie --action, s'il faut faire un shift ou non), 1
    # si le niveau n'est pas correct, mais l'argument $1 a été interprété (donc
    # il faut faire un shift) et 2 si l'argument n'est pas correct (n'a pas été
    # interprété)

    local verbosity="$VERBOSITY" interaction="$INTERACTION"
    local VERBOSITY="$DEF_VERBOSITY" INTERACTION="$DEF_INTERACTION"
    local action=

    if [ "$1" = "--action" ]; then
        shift
        action=1
    fi

    if set_verbosity --enable-fake-arg "$1"; then
        shift
        if [ $interaction -ne $INTERACTION -a $interaction -ge $INTERACTION ] ||
           [ $verbosity -ne $VERBOSITY -a $verbosity -ge $VERBOSITY ] ||
           [ $interaction -eq $INTERACTION -a $verbosity -eq $VERBOSITY ]; then
            [ -n "$action" ] && echo shift
            return 0
        else
            [ -n "$action" ] && echo return
            return 1
        fi
    else
        if [ -n "$2" ] && [ "$verbosity" -gt "$2" ]; then
            [ -n "$action" ] && echo :
            return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
        elif [ -n "$3" ] && [ "$interaction" -gt "$3" ]; then
            [ -n "$action" ] && echo :
            return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
        else
            [ -n "$action" ] && echo return
            return 2
        fi
    fi
}

function echo_() { echo -n "$*"; }

# Couleurs
tty -s <&1 && NO_COLORS= || NO_COLORS=1
function get_color() {
    [ -n "$NO_COLORS" ] && return
    [ -z "$*" ] && set RESET

    echo_ $'\e['
    local sep
    while [ -n "$1" ]; do
        [ -n "$sep" ] && echo_ ";"
        case "$1" in
        z|RESET) echo_ "0";;
        o|BLACK) echo_ "30";;
        r|RED) echo_ "31";;
        g|GREEN) echo_ "32";;
        y|YELLOW) echo_ "33";;
        b|BLUE) echo_ "34";;
        m|MAGENTA) echo_ "35";;
        c|CYAN) echo_ "36";;
        w|WHITE) echo_ "37";;
        DEFAULT) echo_ "39";;
        O|BLACK_BG) echo_ "40";;
        R|RED_BG) echo_ "41";;
        G|GREEN_BG) echo_ "42";;
        Y|YELLOW_BG) echo_ "43";;
        B|BLUE_BG) echo_ "44";;
        M|MAGENTA_BG) echo_ "45";;
        C|CYAN_BG) echo_ "46";;
        W|WHITE_BG) echo_ "47";;
        DEFAULT_BG) echo_ "49";;
        @|BOLD) echo_ "1";;
        -|FAINT) echo_ "2";;
        _|UNDERLINED) echo_ "4";;
        ~|REVERSE) echo_ "7";;
        n|NORMAL) echo_ "22";;
        esac
        sep=1
        shift
    done
    echo_ "m"
}

COULEUR_ROUGE="$(get_color RED BOLD)"
COULEUR_VERTE="$(get_color GREEN BOLD)"
COULEUR_JAUNE="$(get_color YELLOW BOLD)"
COULEUR_BLEUE="$(get_color BLUE BOLD)"
COULEUR_BLANCHE="$(get_color WHITE BOLD)"
COULEUR_NORMALE="$(get_color RESET)"

# tester le niveau de "verbosité" ou d'interaction
function is_quiet() { [ $VERBOSITY -lt $DEF_VERBOSITY ]; }
function is_verbose() { ! is_quiet; }
function is_interactive() { [ $INTERACTION -ge $DEF_INTERACTION ]; }
function is_automatic() { [ $INTERACTION -lt $DEF_INTERACTION ]; }
function is_batch() { [ $INTERACTION -eq $MIN_INTERACTION ]; }

# afficher une erreur *sur stderr*
function display_error() { [ $VERBOSITY -gt 0 ]; }
function eerror() {
    eval `check_verbosity --action "$1" 0`
    echo_ "${COULEUR_ROUGE}error:${COULEUR_NORMALE} " 1>&2
    tooenc "$*" 1>&2
}

# afficher un warning ou une note *sur stderr*
function display_warning() { [ $VERBOSITY -gt 1 ]; }
function ewarn() {
    eval `check_verbosity --action "$1" 1`
    echo_ "${COULEUR_JAUNE}warning:${COULEUR_NORMALE} " 1>&2
    tooenc "$*" 1>&2
}
function enote() {
    eval `check_verbosity --action "$1" 1`
    echo_ "${COULEUR_VERTE}note:${COULEUR_NORMALE} " 1>&2
    tooenc "$*" 1>&2
}

# afficher une information
function display_info() { [ $VERBOSITY -gt 2 ]; }
function etitle() {
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_BLANCHE}>>> "
    tooenc_ "$*"
    echo " <<<${COULEUR_NORMALE}"
}
function esubtitle() {
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_BLANCHE}*** "
    tooenc_ "$*"
    echo "${COULEUR_NORMALE}"
}
function eimportant() {
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_ROUGE}important:${COULEUR_NORMALE} "
    tooenc "$*"
}
function eattention() {
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_JAUNE}attention:${COULEUR_NORMALE} "
    tooenc "$*"
}
function ecomment() {
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_VERTE}commentaire:${COULEUR_NORMALE} "
    tooenc "$*"
}
function einfo() {
    eval `check_verbosity --action "$1" 2`
    tooenc "$*"
}
function einfon() {
    eval `check_verbosity --action "$1" 2`
    tooenc_ "$*"
}

# afficher un message de debug
function is_debug() { [ $VERBOSITY -gt 3 ]; }
function edebug() {
    eval `check_verbosity --action "$1" 3`
    echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
    tooenc "$*"
}
function edebugn() {
    eval `check_verbosity --action "$1" 3`
    echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
    tooenc_ "$*"
}

# Fonctions d'affichage pour suivre la progression d'opérations
function estep() {
    # Une opération entière
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
    tooenc "$*"
}
function estepn() {
    # Une opération entière
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
    tooenc_ "$*"
}

function ebegin() {
    # Le début d'une opération
    eval `check_verbosity --action "$1" 2`
    echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
    tooenc_ "$*"
    echo_ ":"
    utools_ESTATUS_=0
    utools_edot_first_=1
}

function edot() {
    # Une étape d'une opération commencée par ebegin, matérialisée par un "."
    # Si l'argument est un fichier, utiliser -f pour que "$HOME" et "$(pwd)/"
    # soient remplacés respectivement par "~" et "" (afin que les chemins soient
    # plus courts)
    # Si l'argument est un commentaire, utiliser -m pour le spécifier. -w
    # indique que l'argument est un warning: un x jaune est affiché, avec le
    # message associé si on est en mode debug.
    # Sinon, l'argument est un status. 0 affiche un ".", sinon on affiche un "x"
    local status=$?
    local warn= color=

    if [ -n "$utools_edot_first_" ]; then
        # au premier dot, afficher un espace d'abord
        echo_ " "
        utools_edot_first_=
    fi

    eval `check_verbosity --action "$1" 2`
    if is_debug; then
        local msg paths path
        if [ "$1" = "-f" ]; then
            # chemins
            shift
            for path in "$@"; do
                paths="${paths:+$paths,}$(ppath "$path")"
            done
            msg="$paths"
        elif [ "$1" = "-m" -o "$1" = "-w" ]; then
            # message
            [ "$1" = "-w" ] && warn=1 # message de warning
            shift
            msg="$(tooenc "$*")"
        else
            # status
            [ -n "$1" ] && status="$1"
        fi

        [ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
        if [ "$status" -eq 0 -a -z "$warn" ]; then
            echo_ "${msg:+
  }.${msg:+($msg)}"
        else
            color="$COULEUR_ROUGE"
            [ -n "$warn" ] && color="$COULEUR_JAUNE"
            echo_ "${msg:+
  }${color}x${COULEUR_NORMALE}${msg:+($msg)}"
        fi
    else
        if [ "$1" = "-f" -o "$1" = "-m" -o "$1" = "-w" ]; then
            [ "$1" = "-w" ] && warn=1 # message de warning
            shift
        else
            [ -n "$1" ] && status="$1"
        fi

        [ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
        if [ "$status" -eq 0 -a -z "$warn" ]; then
            echo_ "."
        else
            color="$COULEUR_ROUGE"
            [ -n "$warn" ] && color="$COULEUR_JAUNE"
            echo_ "${color}x${COULEUR_NORMALE}"
        fi
    fi
}

function ewait() {
    # Une étape d'un opération commencée par ebegin, matérialisée par des "+"
    # qui s'affichent tant que le processus de PID $1 tourne
    # à utiliser de cette manière:
    #     ebegin "lancement de cmd"
    #     cmd &
    #     ewait $!
    #     eend
    local action status
    action="$(check_verbosity --action "$1" 2)"
    status=$? # le status de check_verbosity
    if [ "$action" == "return" ]; then #
        # ne rien afficher, mais attendre quand même que le processus s'arrête
        [ $status -eq 1 ] && shift

        local pid="$1"
        [ -n "$pid" ] && wait "$pid"
        return
    fi

    eval "$action"

    if [ -n "$utools_edot_first_" ]; then
        # au premier dot, afficher un espace d'abord
        echo_ " "
        utools_edot_first_=
    fi

    local pid="$1"
    local count=2 # attendre 2 secondes avant de commencer à afficher des "+"
    [ -z "$pid" ] && return

    little_sleep # certains processus retournent tout de suite
    while is_running "$pid"; do
        sleep 1
        if [ $count -gt 0 ]; then
            count=$(($count - 1))
        else
            echo_ "+"
        fi
    done
    echo_ "." # terminer par un "."
}

function eend() {
    # la fin d'une opération commencée par ebegin
    local status=0

    eval `check_verbosity --action "$1" 2`

    [ -n "$1" ] && status="$1"
    [ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
    if [ "$utools_ESTATUS_" -eq 0 ]; then
        echo " ${COULEUR_VERTE}ok${COULEUR_NORMALE}"
    else
        echo " ${COULEUR_ROUGE}error${COULEUR_NORMALE}"
    fi

    status=$utools_ESTATUS_
    unset utools_ESTATUS_
    return $status
}

# Arrêter le script avec un message d'erreur
function die() { [ -n "$*" ] && eerror "$@"; exit 1; }

# === Nom du système ===
export SYSTEM_NAME="`uname -s`"
beginswith "$SYSTEM_NAME" CYGWIN && SYSTEM_NAME=Cygwin
beginswith "$SYSTEM_NAME" MINGW32 && SYSTEM_NAME=Mingw
export SYSTEM_MACHINE="`uname -m`"

if [ "$SYSTEM_NAME" == "Linux" ]; then
    if [ -f /etc/debian_version ]; then
        LINUX_FLAVOUR=debian
    elif [ -f /etc/gentoo-release ]; then
        LINUX_FLAVOUR=gentoo
    elif [ -f /etc/redhat-release ]; then
        LINUX_FLAVOUR=redhat
    else
        LINUX_FLAVOUR=
    fi
    if [ "$SYSTEM_MACHINE" == "x86_64" ]; then
        SYSTEM_BITS=64
    else
        SYSTEM_BITS=32
    fi
elif [ "$SYSTEM_NAME" == "Darwin" ]; then
    MACOSX_VERSION="$(grep -A 1 CFBundleShortVersionString /System/Library/Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Resources/version.plist | grep string | sed 's/.*<string>//g
s/<\/string>.*$//g')"
    MACOSX_NAME=UNSUPPORTED
    if beginswith "$MACOSX_VERSION" 10.5; then
        MACOSX_NAME=LEOPARD
    elif beginswith "$MACOSX_VERSION" 10.4; then
        MACOSX_NAME=TIGER
    fi
    SYSTEM_BITS=
fi

# === vérifications ===
[ -d "$TMPDIR" ] || ewarn "TMPDIR ($TMPDIR) n'existe pas"
