4048 lines
129 KiB
Bash
4048 lines
129 KiB
Bash
##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||
## Fonctions de base
|
||
##@cooked nocomments
|
||
##@*inc[base.ulib
|
||
## Support des fonctions uprovided(), uprovide() et urequire() de ulib dans le
|
||
## cas où cette librairie n'est pas chargée
|
||
if [ -z "$ULIBDIR" -o "$ULIBDIR" != "$ULIBINIT" ]; then
|
||
ULIBPROVIDED=()
|
||
function uprovided() {
|
||
local module
|
||
for module in "${ULIBPROVIDED[@]}"; do
|
||
[ "$module" == "$1" ] && return 0
|
||
done
|
||
return 1
|
||
}
|
||
function uprovide() {
|
||
uprovided "$1" && return 1
|
||
ULIBPROVIDED=("${ULIBPROVIDED[@]}" "$1")
|
||
}
|
||
function urequire() {
|
||
local module r=0
|
||
for module in "$@"; do
|
||
uprovided "$module" && continue
|
||
echo "error: $module: this module is required but cannot be automatically loaded" 1>&2
|
||
r=1
|
||
done
|
||
return $r
|
||
}
|
||
uprovide base.ulib
|
||
fi
|
||
##@*inc]base.ulib
|
||
##@include base.init
|
||
##@include base.core
|
||
##@include base.string
|
||
##@include base.num
|
||
##@include base.bool
|
||
##@include base.array
|
||
##@include base.quote
|
||
##@include base.split
|
||
##@include base.args
|
||
##@include base.tools
|
||
##@include base.compat
|
||
uprovide base
|
||
urequire base.init base.core base.string base.num base.bool base.array base.quote base.split base.args base.tools base.compat
|
||
|
||
## Informations sur l'hôte sur lequel tourne ce script
|
||
# Type de système
|
||
UNAME_SYSTEM=`uname -s`
|
||
[ "${UNAME_SYSTEM#CYGWIN}" != "$UNAME_SYSTEM" ] && UNAME_SYSTEM=Cygwin
|
||
[ "${UNAME_SYSTEM#MINGW32}" != "$UNAME_SYSTEM" ] && UNAME_SYSTEM=Mingw
|
||
UNAME_MACHINE=`uname -m`
|
||
if [ -n "$UTOOLS_CHROOT" ]; then
|
||
# Dans un chroot, il est possible de forcer les valeurs
|
||
[ -n "$UTOOLS_UNAME_SYSTEM" ] && eval "UNAME_SYSTEM=$UTOOLS_UNAME_SYSTEM"
|
||
[ -n "$UTOOLS_UNAME_MACHINE" ] && eval "UNAME_MACHINE=$UTOOLS_UNAME_MACHINE"
|
||
fi
|
||
|
||
## valeurs
|
||
function setyesval() {
|
||
# mettre la valeur normalisée de la valeur "oui" de $2 dans la variable $1
|
||
is_yes "$2" && set_var "$1" 1 || set_var "$1" ""
|
||
}
|
||
function normyesval() {
|
||
# remplacer la valeur de la variable $1 par la valeur normalisée de sa valeur "oui"
|
||
# Si $2 est non vide, prendre cette valeur plutôt que la valeur de la variable $1
|
||
is_yes "${2:-"${!1}"}" && set_var "$1" 1 || set_var "$1" ""
|
||
}
|
||
function normyesvals() {
|
||
# remplacer les valeur des variables $1..* par les valeurs normalisées
|
||
# respectives de leur valeur "oui"
|
||
local __nyv_yesvar
|
||
for __nyv_yesvar in "$@"; do
|
||
is_yes "${!__nyv_yesvar}" && set_var "$__nyv_yesvar" 1 || set_var "$__nyv_yesvar" ""
|
||
done
|
||
}
|
||
function quote_in() {
|
||
# Comme quote_arg pour une chaine lue sur stdin
|
||
sed 's/\\/\\\\/g
|
||
s/"/\\"/g
|
||
s/\$/\\$/g
|
||
s/`/\\`/g'
|
||
}
|
||
function quote_sin() {
|
||
# Pour la chaine lue sur stdin, remplacer ' par '\''. Cela permet de protéger une
|
||
# chaine à mettre entre quotes
|
||
sed "s/'/'\\\\''/g"
|
||
}
|
||
function quote_sarg() {
|
||
# Dans la chaine $1, remplacer ' par '\''. Cette fonction utilise quote_sin,
|
||
# puisque le shell a des difficultés à faire le rechercher/remplacer approprié
|
||
quote_sin <<<"$1"
|
||
}
|
||
function quoted_sarg() {
|
||
# Dans la chaine $1, remplacer ' par '\'', et afficher la chaine entourée de
|
||
# quotes
|
||
echo "'$(quote_sarg "$1")'"
|
||
}
|
||
function quoted_sargs() {
|
||
# Comme quoted_sarg, mais tous les arguments sont quotés et affichés entourés de
|
||
# quotes, ce qui permet de construire des arguments d'une ligne de commande
|
||
local a s
|
||
for a in "$@"; do
|
||
s="${s:+$s }$(quoted_sarg "$a")"
|
||
done
|
||
rawecho "$s"
|
||
}
|
||
|
||
## variables tableaux
|
||
function set_array_cmd() {
|
||
# Afficher la commande permettant d'initialiser le tableau $1 avec les valeurs:
|
||
# soit du tableau $2, soit de $3..$n si $2=="@"
|
||
# S'il n'y a que l'argument $1, alors afficher la commande permettant de
|
||
# recréer le tableau $1
|
||
[ $# -eq 1 ] && set -- "$1" "$1"
|
||
local __sac_s __sac_v __sac_f
|
||
__sac_s="$1=("; shift
|
||
if [ "$1" == "@" ]; then
|
||
shift
|
||
else
|
||
eval "set -- \"\${$1[@]}\""
|
||
fi
|
||
__sac_f=1
|
||
for __sac_v in "$@"; do
|
||
[ -n "$__sac_f" ] && __sac_f= || __sac_s="$__sac_s "
|
||
__sac_s="$__sac_s$(quoted_arg "$__sac_v")"
|
||
done
|
||
__sac_s="$__sac_s)"
|
||
echo "$__sac_s"
|
||
}
|
||
function set_array() {
|
||
# Soit $1 un tableau à créer. Si $2=="@", créer le tableau $1 avec les valeurs
|
||
# $3..$n. Sinon, créer le tableau $1 avec les valeurs du tableau $2.
|
||
# Cette fonction n'existe que comme un pendant de set_var(), mais le véritable
|
||
# intérêt est la fonction set_array_cmd(). cf array_copy() pour une version plus
|
||
# efficace de la copie de tableaux
|
||
eval "$(set_array_cmd "$@")"
|
||
}
|
||
function array_count() {
|
||
# retourner le nombre d'éléments du tableau $1
|
||
eval "echo \${#$1[*]}"
|
||
}
|
||
function array_isempty() {
|
||
# tester si le tableau $1 est vide
|
||
[ $(array_count "$1") -eq 0 ]
|
||
}
|
||
function array_new() {
|
||
# créer un tableau vide dont le nom est $1
|
||
eval "$1=()"
|
||
}
|
||
function array_add() {
|
||
# ajouter les valeurs $2..@ au tableau dont le nom est $1
|
||
local __aa_a="$1"; shift
|
||
eval "$__aa_a=(\"\${$__aa_a[@]}\" \"\$@\")"
|
||
#eval "$1=(\"\${$1[@]}\" \"$(quote_arg "$2")\")"
|
||
}
|
||
function array_ins() {
|
||
# insérer les valeurs $2..@ au début du tableau dont le nom est $1
|
||
local __aa_a="$1"; shift
|
||
eval "$__aa_a=(\"\$@\" \"\${$__aa_a[@]}\")"
|
||
#eval "$1=(\"$(quote_arg "$2")\" \"\${$1[@]}\")"
|
||
}
|
||
function array_del() {
|
||
# supprimer *les* valeurs $2 du tableau dont le nom est $1
|
||
local __ad_v
|
||
local -a __ad_vs
|
||
eval 'for __ad_v in "${'"$1"'[@]}"; do
|
||
if [ "$__ad_v" != '"$(quoted_arg "$2")"' ]; then
|
||
array_add __ad_vs "$__ad_v"
|
||
fi
|
||
done'
|
||
array_copy "$1" __ad_vs
|
||
}
|
||
function array_addu() {
|
||
# ajouter la valeur $2 au tableau dont le nom est $1, si la valeur n'y est pas
|
||
# déjà. Retourner vrai si la valeur a été ajoutée
|
||
local __as_v
|
||
eval 'for __as_v in "${'"$1"'[@]}"; do
|
||
if [ "$__as_v" == '"$(quoted_arg "$2")"' ]; then
|
||
return 1
|
||
fi
|
||
done'
|
||
array_add "$1" "$2"
|
||
return 0
|
||
}
|
||
function array_set() {
|
||
array_addu "$@"
|
||
}
|
||
function array_insu() {
|
||
# insérer la valeur $2 au début du tableau tableau dont le nom est $1, si la
|
||
# valeur n'y est pas déjà. Retourner vrai si la valeur a été ajoutée.
|
||
local __as_v
|
||
eval 'for __as_v in "${'"$1"'[@]}"; do
|
||
if [ "$__as_v" == '"$(quoted_arg "$2")"' ]; then
|
||
return 1
|
||
fi
|
||
done'
|
||
array_ins "$1" "$2"
|
||
return 0
|
||
}
|
||
function array_fillrange() {
|
||
# Initialiser le tableau $1 avec les nombres de $2(=1) à $3(=10) avec un step de $4(=1)
|
||
local -a __af_vs
|
||
local __af_i="${2:-1}" __af_to="${3:-10}" __af_step="${4:-1}"
|
||
while [ "$__af_i" -le "$__af_to" ]; do
|
||
__af_vs=("${__af_vs[@]}" "$__af_i")
|
||
__af_i=$(($__af_i + $__af_step))
|
||
done
|
||
array_copy "$1" __af_vs
|
||
}
|
||
function array_eq() {
|
||
# tester l'égalité des tableaux $1 et $2
|
||
local -a __ae_a1 __ae_a2
|
||
array_copy __ae_a1 "$1"
|
||
array_copy __ae_a2 "$2"
|
||
[ ${#__ae_a1[*]} -eq ${#__ae_a2[*]} ] || return 1
|
||
local __ae_v __ae_i=0
|
||
for __ae_v in "${__ae_a1[@]}"; do
|
||
[ "$__ae_v" == "${__ae_a2[$__ae_i]}" ] || return 1
|
||
__ae_i=$(($__ae_i + 1))
|
||
done
|
||
return 0
|
||
}
|
||
function array_contains() {
|
||
# tester si le tableau dont le nom est $1 contient la valeur $2
|
||
local __ac_v
|
||
eval 'for __ac_v in "${'"$1"'[@]}"; do
|
||
if [ "$__ac_v" == '"$(quoted_arg "$2")"' ]; then
|
||
return 0
|
||
fi
|
||
done'
|
||
return 1
|
||
}
|
||
function array_icontains() {
|
||
# tester si le tableau dont le nom est $1 contient la valeur $2, sans tenir
|
||
# compte de la casse
|
||
local __ac_v
|
||
eval 'for __ac_v in "${'"$1"'[@]}"; do
|
||
if [ "$(strlower "$__ac_v")" == '"$(strlower "$(quoted_arg "$2")")"' ]; then
|
||
return 0
|
||
fi
|
||
done'
|
||
return 1
|
||
}
|
||
function array_find() {
|
||
# si le tableau $1 contient la valeur $2, retourner l'index de la valeur. Si le
|
||
# tableau $3 est spécifié, retourner la valeur à l'index dans ce tableau
|
||
local __af_i __af_v
|
||
__af_i=0
|
||
eval 'for __af_v in "${'"$1"'[@]}"; do
|
||
if [ "$__af_v" == '"$(quoted_arg "$2")"' ]; then
|
||
if [ -n "$3" ]; then
|
||
echo "${'"$3"'[$__af_i]}"
|
||
else
|
||
echo "$__af_i"
|
||
fi
|
||
return 0
|
||
fi
|
||
__af_i=$(($__af_i + 1))
|
||
done'
|
||
return 1
|
||
}
|
||
function array_reverse() {
|
||
# Inverser l'ordre des élément du tableau $1
|
||
local -a __ar_vs
|
||
local __ar_v
|
||
array_copy __ar_vs "$1"
|
||
array_new "$1"
|
||
for __ar_v in "${__ar_vs[@]}"; do
|
||
array_ins "$1" "$__ar_v"
|
||
done
|
||
}
|
||
|
||
function array_replace() {
|
||
# dans le tableau $1, remplacer toutes les occurences de $2 par $3..*
|
||
local __ar_sn="$1"; shift
|
||
local __ar_f="$1"; shift
|
||
local -a __ar_s __ar_d
|
||
local __ar_v
|
||
array_copy __ar_s "$__ar_sn"
|
||
for __ar_v in "${__ar_s[@]}"; do
|
||
if [ "$__ar_v" == "$__ar_f" ]; then
|
||
__ar_d=("${__ar_d[@]}" "$@")
|
||
else
|
||
__ar_d=("${__ar_d[@]}" "$__ar_v")
|
||
fi
|
||
done
|
||
array_copy "$__ar_sn" __ar_d
|
||
}
|
||
function array_each() {
|
||
# Pour chacune des valeurs 'v' du tableau $1, appeler la fonction $2 avec les
|
||
# arguments '$v $3..$n'
|
||
local __ae_an="$1"; shift
|
||
local __ae_f="$1"; shift
|
||
local -a __ae_a
|
||
local __ae_v
|
||
array_copy __ae_a "$__ae_an"
|
||
for __ae_v in "${__ae_a[@]}"; do
|
||
"$__ae_f" "$__ae_v" "$@"
|
||
done
|
||
}
|
||
function array_map() {
|
||
# Pour chacune des valeurs 'v' du tableau $1, appeler la fonction $2 avec les
|
||
# arguments '$v $3..$n', et remplacer la valeur par le résultat de la fonction
|
||
local __am_an="$1"; shift
|
||
local __am_f="$1"; shift
|
||
local -a __am_a __am_vs
|
||
local __am_v
|
||
array_copy __am_a "$__am_an"
|
||
for __am_v in "${__am_a[@]}"; do
|
||
__am_vs=("${__am_vs[@]}" "$("$__am_f" "$__am_v" "$@")")
|
||
done
|
||
array_copy "$__am_an" __am_vs
|
||
}
|
||
function first_value() {
|
||
# retourner la première valeur du tableau $1
|
||
eval "rawecho \"\${$1[@]:0:1}\""
|
||
}
|
||
function last_value() {
|
||
# retourner la dernière valeur du tableau $1
|
||
eval "rawecho \"\${$1[@]:\$((-1)):1}\""
|
||
}
|
||
function array_copy() {
|
||
# copier le contenu du tableau $2 dans le tableau $1
|
||
eval "$1=(\"\${$2[@]}\")"
|
||
}
|
||
function array_copy_firsts() {
|
||
# copier tous les valeurs du tableau $2(=$1) dans le tableau $1, excepté la dernière
|
||
eval "$1=(\"\${${2:-$1}[@]:0:\$((\${#${2:-$1}[@]}-1))}\")"
|
||
}
|
||
function array_del_last() {
|
||
array_copy_firsts "$1"
|
||
}
|
||
function array_copy_lasts() {
|
||
# copier tous les valeurs du tableau $2(=$1) dans le tableau $1, excepté la première
|
||
eval "$1=(\"\${${2:-$1}[@]:1}\")"
|
||
}
|
||
function array_del_first() {
|
||
array_copy_lasts "$1"
|
||
}
|
||
function array_extend() {
|
||
# ajouter le contenu du tableau $2 au tableau $1
|
||
eval "$1=(\"\${$1[@]}\" \"\${$2[@]}\")"
|
||
}
|
||
function array_extendu() {
|
||
# ajouter chacune des valeurs du tableau $2 au tableau $1, si ces valeurs n'y
|
||
# sont pas déjà. Retourner vrai si au moins une valeur a été ajoutée
|
||
local __ae_v __ae_s=1
|
||
eval 'for __ae_v in "${'"$2"'[@]}"; do
|
||
array_addu "$1" "$__ae_v" && __ae_s=0
|
||
done'
|
||
return "$__ae_s"
|
||
}
|
||
function array_extend_firsts() {
|
||
# ajouter toutes les valeurs du tableau $2 dans le tableau $1, excepté la dernière
|
||
eval "$1=(\"\${$1[@]}\" \"\${$2[@]:0:\$((\${#$2[@]}-1))}\")"
|
||
}
|
||
function array_extend_lasts() {
|
||
# ajouter toutes les valeurs du tableau $2 dans le tableau $1, excepté la première
|
||
eval "$1=(\"\${$1[@]}\" \"\${$2[@]:1}\")"
|
||
}
|
||
function array_xsplit() {
|
||
# créer le tableau $1 avec chaque élément de $2 (un ensemble d'éléments séparés
|
||
# par $3, qui vaut ':' par défaut).
|
||
eval "$1=($(recho_ "$2" | awkrun RS="${3:-:}" '
|
||
{
|
||
gsub(/'\''/, "'\'\\\\\'\''")
|
||
print "'\''" $0 "'\''"
|
||
}'))" #"
|
||
}
|
||
function array_split() {
|
||
# créer le tableau $1 avec chaque élément de $2 (un ensemble d'éléments séparés
|
||
# par $3, qui vaut ':' par défaut). Les éléments vides sont ignorés. par exemple
|
||
# "a::b" est équivalent à "a:b"
|
||
eval "$1=($(recho_ "$2" | awkrun RS="${3:-:}" '
|
||
/^$/ { next }
|
||
{
|
||
gsub(/'\''/, "'\'\\\\\'\''")
|
||
print "'\''" $0 "'\''"
|
||
}'))" #"
|
||
}
|
||
function array_from_path() {
|
||
array_split "$1" "$2" ":"
|
||
}
|
||
function array_from_xlines() {
|
||
# créer le tableau $1 avec chaque ligne de $2.
|
||
eval "$1=($(recho_ "$2" | _nl2lf | awk '
|
||
{
|
||
gsub(/'\''/, "'\'\\\\\'\''")
|
||
print "'\''" $0 "'\''"
|
||
}'))" #"
|
||
}
|
||
function array_from_lines() {
|
||
# créer le tableau $1 avec chaque ligne de $2. Les lignes vides sont ignorés.
|
||
eval "$1=($(recho_ "$2" | _nl2lf | awk '
|
||
/^$/ { next }
|
||
{
|
||
gsub(/'\''/, "'\'\\\\\'\''")
|
||
print "'\''" $0 "'\''"
|
||
}'))" #"
|
||
}
|
||
function array_join() {
|
||
# afficher le contenu du tableau dont le nom est $1 sous forme d'une liste de
|
||
# valeurs séparées par $2 (par défaut, une virgule)
|
||
# Si $1=="@", alors les éléments du tableaux sont les arguments de la fonction à
|
||
# partir de $3
|
||
# Si $1!="@" et que le tableau est vide, afficher $3
|
||
# Si $1!="@", $4 et $5 sont des préfixes et suffixes à rajouter à chaque élément
|
||
local __aj_an __aj_l __aj_j __aj_s="${2:-,}" __aj_pf __aj_sf
|
||
if [ "$1" == "@" ]; then
|
||
__aj_an="\$@"
|
||
shift; shift
|
||
else
|
||
__aj_an="\${$1[@]}"
|
||
__aj_pf="$4"
|
||
__aj_sf="$5"
|
||
fi
|
||
eval 'for __aj_l in "'"$__aj_an"'"; do
|
||
__aj_j="${__aj_j:+$__aj_j'"$__aj_s"'}$__aj_pf$__aj_l$__aj_sf"
|
||
done'
|
||
if [ -n "$__aj_j" ]; then
|
||
rawecho "$__aj_j"
|
||
elif [ "$__aj_an" != "\$@" -a -n "$3" ]; then
|
||
rawecho "$3"
|
||
fi
|
||
}
|
||
function array_mapjoin() {
|
||
# map le tableau $1 avec la fonction $2, puis afficher le résultat en séparant
|
||
# chaque élément par $3. Les arguments et la sémantique sont les mêmes que pour
|
||
# array_join en tenant compte de l'argument supplémentaire $2 qui est la
|
||
# fonction pour array_map (les autres arguments sont décalés en conséquence)
|
||
local __amj_src="$1" __amj_func="$2" __amj_sep="$3"
|
||
shift; shift; shift
|
||
if [ "$__amj_src" == "@" ]; then
|
||
local -a __amj_tmpsrc
|
||
__amj_tmpsrc=("$@")
|
||
__amj_src=__amj_tmpsrc
|
||
set --
|
||
fi
|
||
local -a __amj_tmp
|
||
array_copy __amj_tmp "$__amj_src"
|
||
array_map __amj_tmp "$__amj_func"
|
||
array_join __amj_tmp "$__amj_sep" "$@"
|
||
}
|
||
function array_to_lines() {
|
||
# afficher le tableau dont le nom est $1 sous forme de lignes
|
||
array_join "$1" "
|
||
" "$2" "$3" "$4"
|
||
}
|
||
function array_to_path() {
|
||
# afficher le tableau dont le nom est $1 sous forme d'une liste de chemins
|
||
# séparés par ':')
|
||
array_join "$1" ":" "$2" "$3" "$4"
|
||
}
|
||
function array_fix_paths() {
|
||
# Corriger les valeurs du tableau $1. Les valeurs contenant le séparateur
|
||
# $2(=':') sont séparées en plusieurs valeurs. Par exemple avec le tableau
|
||
# input=(a b:c), le résultat est input=(a b c)
|
||
local __afp_an="$1" __afp_s="${2:-:}"
|
||
local -a __afp_vs
|
||
local __afp_v
|
||
array_copy __afp_vs "$__afp_an"
|
||
array_new "$__afp_an"
|
||
for __afp_v in "${__afp_vs[@]}"; do
|
||
array_split __afp_v "$__afp_v" "$__afp_s"
|
||
array_extend "$__afp_an" __afp_v
|
||
done
|
||
}
|
||
|
||
################################################################################
|
||
## dates
|
||
|
||
function get_date_rfc822() {
|
||
LC_TIME=C date +"%a, %d %b %Y %H:%M:%S %Z"
|
||
}
|
||
function get_date_fr() {
|
||
LC_TIME=C date +"%d/%m/%Y"
|
||
}
|
||
function get_time_fr() {
|
||
LC_TIME=C date +"%Hh%M"
|
||
}
|
||
function parse_date() {
|
||
local value="$1" type="${2:-date}"
|
||
local now="$(awk 'BEGIN { print mktime(strftime("%Y %m %d 00 00 00 +0400")) }')"
|
||
case "$value" in
|
||
+*)
|
||
value="$(($now + ${value#+} * 86400))"
|
||
;;
|
||
*)
|
||
value="$(<<<"$value" awk -F/ '{
|
||
nd = strftime("%d"); nm = strftime("%m"); ny = strftime("%Y")
|
||
d = $1 + 0; if (d < 1) d = nd;
|
||
m = $2 + 0; if (m < 1) m = nm;
|
||
if ($3 == "") y = ny;
|
||
else { y = $3 + 0; if (y < 100) y = y + 2000; }
|
||
print mktime(sprintf("%04i %02i %02i 00 00 00 +0400", y, m, d));
|
||
}')"
|
||
esac
|
||
case "$type" in
|
||
d|date) awk '{ print strftime("%d/%m/%Y", $0 + 0) }' <<<"$value";;
|
||
l|ldap) awk '{ print strftime("%Y%m%d%H%M%S+0400", $0 + 0) }' <<<"$value";;
|
||
m|mysql) awk '{ print strftime("%Y-%m-%d", $0 + 0) }' <<<"$value";;
|
||
*)
|
||
rawecho "$value"
|
||
;;
|
||
esac
|
||
}
|
||
|
||
################################################################################
|
||
## chemins
|
||
|
||
function udelpath() {
|
||
# supprimer le chemin $1 de $2(=PATH)
|
||
local _qdir="${1//\//\\/}"
|
||
eval "export ${2:-PATH}; ${2:-PATH}"'="${'"${2:-PATH}"'#$1:}"; '"${2:-PATH}"'="${'"${2:-PATH}"'%:$1}"; '"${2:-PATH}"'="${'"${2:-PATH}"'//:$_qdir:/:}"; [ "$'"${2:-PATH}"'" == "$1" ] && '"${2:-PATH}"'='
|
||
}
|
||
function uaddpath() {
|
||
# Ajouter le chemin $1 à la fin, dans $2(=PATH), s'il n'y existe pas déjà
|
||
local _qdir="${1//\//\\/}"
|
||
eval "export ${2:-PATH}; "'[ "${'"${2:-PATH}"'#$1:}" == "$'"${2:-PATH}"'" -a "${'"${2:-PATH}"'%:$1}" == "$'"${2:-PATH}"'" -a "${'"${2:-PATH}"'//:$_qdir:/:}" == "$'"${2:-PATH}"'" -a "$'"${2:-PATH}"'" != "$1" ] && '"${2:-PATH}"'="${'"${2:-PATH}"':+$'"${2:-PATH}"':}$1"'
|
||
}
|
||
function uinspathm() {
|
||
# Ajouter le chemin $1 au début, dans $2(=PATH), s'il n'y existe pas déjà
|
||
local _qdir="${1//\//\\/}"
|
||
eval "export ${2:-PATH}; "'[ "${'"${2:-PATH}"'#$1:}" == "$'"${2:-PATH}"'" -a "${'"${2:-PATH}"'%:$1}" == "$'"${2:-PATH}"'" -a "${'"${2:-PATH}"'//:$_qdir:/:}" == "$'"${2:-PATH}"'" -a "$'"${2:-PATH}"'" != "$1" ] && '"${2:-PATH}"'="$1${'"${2:-PATH}"':+:$'"${2:-PATH}"'}"'
|
||
}
|
||
function uinspath() {
|
||
# S'assurer que le chemin $1 soit au début de $2(=PATH)
|
||
udelpath "$@"
|
||
uinspathm "$@"
|
||
}
|
||
|
||
function withpath() {
|
||
# tester si le chemin est relatif à . ou à .., ou est absolu. i.e 'withpath a/b'
|
||
# renvoie faux alors que 'withpath ./a/b' renvoie vrai
|
||
[ "${1#./}" != "$1" -o "${1#../}" != "$1" -o "${1#/}" != "$1" ]
|
||
}
|
||
function withext() {
|
||
# tester si le fichier a une extension
|
||
local basename="$(basename -- "$1")"
|
||
[ "${basename%.*}" != "$basename" ]
|
||
}
|
||
function normpath() {
|
||
# normaliser le chemin $1, qui est soit absolu, soit relatif à $2 (qui vaut
|
||
# $(pwd) par défaut)
|
||
local -a parts
|
||
local part ap
|
||
array_split parts "$1" /
|
||
if [ "${1#/}" != "$1" ]; then
|
||
ap=/
|
||
elif [ -n "$2" ]; then
|
||
ap="$2"
|
||
else
|
||
ap="$(pwd)"
|
||
fi
|
||
for part in "${parts[@]}"; do
|
||
if [ "$part" == "." ]; then
|
||
continue
|
||
elif [ "$part" == ".." ]; then
|
||
ap="${ap%/*}"
|
||
[ -n "$ap" ] || ap=/
|
||
else
|
||
[ "$ap" != "/" ] && ap="$ap/"
|
||
ap="$ap$part"
|
||
fi
|
||
done
|
||
rawecho "$ap"
|
||
}
|
||
function abspath() {
|
||
# Retourner un chemin absolu vers $1. Si $2 est non nul et si $1 est un chemin
|
||
# relatif, alors $1 est exprimé par rapport à $2, sinon il est exprimé par
|
||
# rapport au répertoire courant.
|
||
# Si le chemin n'existe pas, il n'est PAS normalisé. Sinon, les meilleurs
|
||
# efforts sont faits pour normaliser le chemin.
|
||
local ap="$1"
|
||
if [ "${ap#/}" != "$ap" ]; then
|
||
# chemin absolu. on peut ignorer $2
|
||
__normpath "$ap" && return
|
||
else
|
||
# chemin relatif. il faut exprimer le chemin par rapport à $2
|
||
local cwd
|
||
if [ -n "$2" ]; then
|
||
cwd="$(abspath "$2")"
|
||
else
|
||
cwd="$(pwd)"
|
||
fi
|
||
ap="$cwd/$ap"
|
||
__normpath "$ap" && return
|
||
fi
|
||
# dans les cas spéciaux, il faut calculer "manuellement" le répertoire absolu
|
||
normpath "$ap"
|
||
}
|
||
function __normpath() {
|
||
# normaliser dans les cas simple le chemin absolu $1. sinon retourner 1.
|
||
# cette fonction est utilisée par abspath()
|
||
if [ -d "$1" ]; then
|
||
if [ -x "$1" ]; then
|
||
# le cas le plus simple: un répertoire dans lequel on peut entrer
|
||
(cd "$1"; pwd)
|
||
return 0
|
||
fi
|
||
elif [ -f "$1" ]; then
|
||
local dn="$(dirname -- "$1")" bn="$(basename -- "$1")"
|
||
if [ -x "$dn" ]; then
|
||
# autre cas simple: un fichier situé dans un répertoire dans lequel
|
||
# on peut entrer
|
||
(cd "$dn"; echo "$(pwd)/$bn")
|
||
return 0
|
||
fi
|
||
fi
|
||
return 1
|
||
}
|
||
function parentdirs() {
|
||
# Obtenir la liste de tous les parents du répertoire $2 dans le tableau $1, du
|
||
# répertoire $2 vers la racine. Si $3 commence par 'r' (comme reverse), l'ordre
|
||
# est inversé: le tableau contient les répertoire de la racine vers $2.
|
||
array_new "$1"
|
||
local __pd_d="$(abspath "$2")"
|
||
if [[ "$3" == r* ]]; then
|
||
while [ "$__pd_d" != "/" ]; do
|
||
array_ins "$1" "$__pd_d"
|
||
__pd_d="$(dirname "$__pd_d")"
|
||
done
|
||
else
|
||
while [ "$__pd_d" != "/" ]; do
|
||
array_add "$1" "$__pd_d"
|
||
__pd_d="$(dirname "$__pd_d")"
|
||
done
|
||
fi
|
||
}
|
||
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"
|
||
|
||
path="$(abspath "$path")" # essayer de normaliser le chemin
|
||
[ -n "$cwd" ] || cwd="$(pwd)"
|
||
|
||
[ "$path" = "$cwd" ] && path="."
|
||
[ "$cwd" != "/" -a "$cwd" != "$HOME" ] && path="${path/#$cwd\//}"
|
||
path="${path/#$HOME/~}"
|
||
|
||
rawecho "$path"
|
||
}
|
||
function relpath() {
|
||
# Afficher le chemin relatif de $1 par rapport à $2. Si $2 n'est pas spécifié,
|
||
# on prend le répertoire courant. Si $1 ou $2 ne sont pas des chemins absolus,
|
||
# il sont transformés en chemins absolus par rapport à $3. Si $1==$2, retourner
|
||
# une chaine vide
|
||
local p="$(abspath "$1" "$3")" cwd="$2"
|
||
if [ -z "$cwd" ]; then
|
||
cwd="$(pwd)"
|
||
else
|
||
cwd="$(abspath "$cwd" "$3")"
|
||
fi
|
||
if [ "$p" == "$cwd" ]; then
|
||
echo ""
|
||
elif [ "${p#$cwd/}" != "$p" ]; then
|
||
rawecho "${p#$cwd/}"
|
||
else
|
||
local rp
|
||
while [ -n "$cwd" -a "${p#$cwd/}" == "$p" ]; do
|
||
rp="${rp:+$rp/}.."
|
||
cwd="${cwd%/*}"
|
||
done
|
||
rp="$rp/${p#$cwd/}"
|
||
# ${rp%//} traite le cas $1==/
|
||
echo "${rp%//}"
|
||
fi
|
||
}
|
||
function relpathx() {
|
||
# Comme relpath, mais pour un chemin vers un exécutable qu'il faut lancer:
|
||
# s'assurer qu'il y a une spécification de chemin, e.g. ./script
|
||
local p="$(relpath "$@")"
|
||
if [ -z "$p" ]; then
|
||
echo .
|
||
elif [ "${p#../}" != "$p" -o "${p#./}" != "$p" ]; then
|
||
echo "$p"
|
||
else
|
||
echo "./$p"
|
||
fi
|
||
}
|
||
function withinpath() {
|
||
# Tester si le chemin absolu $2 se trouve dans le chemin absolu "$1" (appelée
|
||
# barrière). Soit un chemin P, on considère que P est dans P. Si ce comportement
|
||
# n'est pas souhaité, $3(=N) doit valoir O, auquel cas P est dans Q implique que
|
||
# P != Q.
|
||
local b="$1" p="$2" strict="${3:-N}"
|
||
b="$(abspath "$b")"
|
||
p="$(abspath "$p")"
|
||
if is_yes "$strict"; then
|
||
[ "${p#$b/}" != "$p" ]
|
||
else
|
||
[ "$p" == "$b" -o "${p#$b/}" != "$p" ]
|
||
fi
|
||
}
|
||
function safe_abspath() {
|
||
# Afficher le chemin absolu de $1, par rapport à $2, si et seulement si le
|
||
# chemin résultat ne se trouve pas en dehors de la barrière $3. Si $2 n'est pas
|
||
# spécifié, prendre le répertoire courant. S'il est relatif, l'exprimer par
|
||
# rapport au répertoire courant. Si $3 est relatif, l'exprimer par rapport à $2.
|
||
# Si le chemin résultat est sité en dehors de la barrière, ne rien afficher et
|
||
# retourner un code d'erreur.
|
||
# Si le chemin $1 n'existe pas, il n'est PAS normalisé. Sinon, les meilleurs
|
||
# efforts sont faits pour normaliser le chemin résultat.
|
||
local p="$1" ba="$2" br="$3"
|
||
# calculer basedir
|
||
if [ -n "$ba" ]; then
|
||
ba="$(abspath "$ba")"
|
||
else
|
||
ba="$(pwd)"
|
||
fi
|
||
# calculer barrier. l'exprimer relativement à basedir le cas échéant
|
||
[ -n "$br" ] || br="$ba"
|
||
br="$(abspath "$br" "$ba")"
|
||
# puis calculer le chemin absolu
|
||
p="$(abspath "$p" "$ba")"
|
||
# vérifier la barrière
|
||
if [ "$p" == "$br" -o "${p#$br/}" != "$p" ]; then
|
||
echo "$p"
|
||
else
|
||
return 1
|
||
fi
|
||
}
|
||
function safe_relpath() {
|
||
# Afficher le chemin relatif de $1 par rapport à $2 si et seulement si le chemin
|
||
# résultat ne se trouve pas en dehors de la barrière $3. Si $2 n'est pas
|
||
# spécifié, prendre le répertoire courant. S'il est relatif, l'exprimer par
|
||
# rapport au répertoire courant. Si $3 est relatif, l'exprimer par rapport à $2.
|
||
# Si le chemin résultat est sité en dehors de la barrière, ne rien afficher et
|
||
# retourner un code d'erreur.
|
||
local p
|
||
if p="$(safe_abspath "$1" "$2" "$3")"; then
|
||
relpath "$p" "$2" "$(pwd)"
|
||
else
|
||
return 1
|
||
fi
|
||
}
|
||
function splitwcs() {
|
||
# Découper un nom de chemin $1 entre la partie sans wildcards, qui est placée dans
|
||
# la variables $2(=basedir), et la partie avec wildcards, qui est placée dans la
|
||
# variable $3(=filespec)
|
||
local __sw_p="$1"
|
||
local __sw_dd="${2:-basedir}" __sw_df="${3:-filespec}" __sw_part __sw_d __sw_f
|
||
local -a __sw_parts
|
||
array_split __sw_parts "$__sw_p" "/"
|
||
for __sw_part in "${__sw_parts[@]}"; do
|
||
if [[ "$__sw_part" == *\** ]] || [[ "$__sw_part" == *\?* ]] || [ -n "$__sw_f" ]; then
|
||
__sw_f="${__sw_f:+$__sw_f/}$__sw_part"
|
||
else
|
||
__sw_d="${__sw_d:+$__sw_d/}$__sw_part"
|
||
fi
|
||
done
|
||
[ "${__sw_p#/}" != "$__sw_p" ] && __sw_d="/$__sw_d"
|
||
set_var "$__sw_dd" "$__sw_d"
|
||
set_var "$__sw_df" "$__sw_f"
|
||
}
|
||
function deref() {
|
||
# Retourner un chemin absolu vers le fichier $1, dans lequel toutes les
|
||
# composantes "lien symbolique" ont été supprimées.
|
||
# DEPRECATED: Cette fonction est dépréciée. Utiliser à la place readlinkm()
|
||
local OENC="$UTF8"
|
||
|
||
local max_deref=50
|
||
local file="$1"
|
||
local basedir link
|
||
while [ -L "$file" ]; do
|
||
basedir="$(dirname "$file")"
|
||
link="$(readlink "$file")"
|
||
if first_char_is "$link" "/"; then
|
||
# lien absolu
|
||
file="$link"
|
||
else
|
||
# lien relatif
|
||
file="$basedir/$link"
|
||
fi
|
||
|
||
max_deref=$(($max_deref - 1))
|
||
[ $max_deref -eq 0 ] && die "Plus de 50 indirection. Le lien $file est-il récursif?"
|
||
done
|
||
abspath "$file"
|
||
}
|
||
function readlinka() {
|
||
# Afficher un chemin absolu vers la destination du fichier $1. Si $1 n'est pas
|
||
# un lien, afficher simplement le chemin du fichier
|
||
if [ -L "$1" ]; then
|
||
local linkdir="$(dirname -- "$1")"
|
||
abspath "$(readlink "$1")" "$linkdir"
|
||
else
|
||
abspath "$1"
|
||
fi
|
||
}
|
||
function readlinkm() {
|
||
# Retourner un chemin absolu vers le fichier $1, dans lequel toutes les
|
||
# composantes "lien symbolique" ont été supprimées. Il n'est pas requis que les
|
||
# composantes du chemin existent.
|
||
readlink -m "$1"
|
||
}
|
||
function path_if_test() {
|
||
# afficher un chemin si le fichier $2 existe (en utilisant l'opérateur $1) dans
|
||
# l'un des chemins absolus $4..n. si $3==relative, afficher le chemin relatif,
|
||
# sinon le chemin absolu. note: $3 peut être de la forme relative:path, auquel
|
||
# cas le chemin affiché est exprimé relativement à path
|
||
local op="$1"; shift
|
||
local file="$1"; shift
|
||
local rel="$1" reldir=; shift
|
||
if beginswith "$rel" relative; then
|
||
reldir="${rel#relative}"
|
||
if beginswith "$reldir" :; then
|
||
# on a un argument de la forme relative:path
|
||
reldir="${reldir#:}"
|
||
if [ -n "$reldir" ]; then
|
||
reldir="${reldir}/"
|
||
fi
|
||
else
|
||
# argument vide ou format non valide
|
||
reldir=
|
||
fi
|
||
else
|
||
rel=
|
||
fi
|
||
|
||
while [ -n "$1" ]; do
|
||
local basedir="$1"
|
||
if [ $op "$basedir/$file" ]; then
|
||
if [ -n "$rel" ]; then
|
||
rawecho "$reldir$file"
|
||
else
|
||
rawecho "$basedir/$file"
|
||
fi
|
||
break
|
||
fi
|
||
shift
|
||
done
|
||
}
|
||
function update_link() {
|
||
# mettre à jour le lien $2 pour qu'il pointe vers le fichier $1
|
||
[ -L "$2" ] || return 1
|
||
local dest link="$2"
|
||
local linkdir="$(dirname "$link")"
|
||
local ldest="$(readlink "$link")"
|
||
if [ "${ldest#/}" != "$ldest" ]; then
|
||
# c'est un lien absolu, faire un lien absolu
|
||
dest="$(abspath "$1")"
|
||
else
|
||
# c'est un lien relatif, faire un lien relatif
|
||
dest="$(relpath "$1" "$linkdir")"
|
||
fi
|
||
if [ "$dest" == "$ldest" ]; then
|
||
: # pas besoin de mettre à jour
|
||
elif [ -d "$link" ]; then
|
||
rm -f "$link" && ln -s "$dest" "$link"
|
||
else
|
||
ln -sf "$dest" "$link"
|
||
fi
|
||
}
|
||
function update_links() {
|
||
# Mettre à jour les liens $2..@ pour qu'ils pointent vers la nouvelle
|
||
# destination $1
|
||
[ -n "$1" ] || return 1
|
||
local dest="$1"; shift
|
||
local r=0 link
|
||
for link in "$@"; do
|
||
update_link "$dest" "$link" || r=$?
|
||
done
|
||
return $r
|
||
}
|
||
function move_link() {
|
||
# Déplacer le lien $1 vers $2, et mettre à jour la destination du lien si
|
||
# elle est exprimée de façon relative
|
||
# Si $1 n'est pas un lien, le déplacer normalement avec mv
|
||
[ -n "$1" -a -n "$2" ] || return 1
|
||
local link="$1" dest="$2"
|
||
[ -d "$dest" ] && dest="$dest/$(basename -- "$link")"
|
||
dest="$(abspath "$dest")"
|
||
if [ -L "$link" ]; then
|
||
link="$(abspath "$link")"
|
||
[ "$dest" == "$link" ] && return 0
|
||
ldest="$(readlinka "$link")"
|
||
mv "$link" "$dest" || return 1
|
||
update_link "$ldest" "$dest"
|
||
else
|
||
[ "$dest" == "$link" ] && return 0
|
||
mv "$link" "$dest"
|
||
fi
|
||
}
|
||
function copy_link() {
|
||
# Copier le lien $1 vers $2, et mettre à jour la destination du lien si
|
||
# elle est exprimée de façon relative
|
||
# Si $1 n'est pas un lien, le copier normalement avec cp
|
||
[ -n "$1" -a -n "$2" ] || return 1
|
||
local link="$1" dest="$2"
|
||
[ -d "$dest" ] && dest="$dest/$(basename -- "$link")"
|
||
dest="$(abspath "$dest")"
|
||
if [ -L "$link" ]; then
|
||
link="$(abspath "$link")"
|
||
[ "$dest" == "$link" ] && return 0
|
||
ldest="$(readlinka "$link")"
|
||
cp -P "$link" "$dest" || return 1
|
||
update_link "$ldest" "$dest"
|
||
else
|
||
[ "$dest" == "$link" ] && return 0
|
||
cp "$link" "$dest"
|
||
fi
|
||
}
|
||
function array_find_links() {
|
||
# Chercher dans le répertoire $3 (qui est par défaut le répertoire courant)
|
||
# les liens vers le fichier $2, et ajouter leurs chemins absolus dans le
|
||
# tableau $1
|
||
local -a __afl_links __afl_result
|
||
local __afl_dir="${3:-.}"
|
||
local __afl_dest __afl_destname __afl_link __afl_linkdir __afl_ldest
|
||
__afl_dest="$(abspath "$2")"
|
||
__afl_destname="${__afl_dest##*/}"
|
||
array_from_lines __afl_links "$(find "$__afl_dir" -type l)"
|
||
for __afl_link in "${__afl_links[@]}"; do
|
||
__afl_ldest="$(readlink "$__afl_link")"
|
||
# optimiser le calcul: pas besoin d'aller plus loin si les noms ne
|
||
# correspondent pas
|
||
if [ "$__afl_ldest" != "$__afl_destname" ]; then
|
||
[[ "$__afl_ldest" == */"$__afl_destname" ]] || continue
|
||
fi
|
||
# nous avons un candidate, tester si les chemins correspondent
|
||
__afl_link="$(abspath "$__afl_link" "$__afl_dir")"
|
||
__afl_linkdir="$(dirname -- "$__afl_link")"
|
||
__afl_ldest="$(abspath "$__afl_ldest" "$__afl_linkdir")"
|
||
if [ "$__afl_ldest" == "$__afl_dest" ]; then
|
||
array_add __afl_result "$__afl_link"
|
||
fi
|
||
done
|
||
array_copy "$1" __afl_result
|
||
}
|
||
function list_links() {
|
||
# Chercher dans le répertoire $2 les liens vers le fichier $1, et les
|
||
# afficher, un par ligne.
|
||
local -a links
|
||
array_find_links links "$@"
|
||
array_to_lines links
|
||
}
|
||
function move_file() {
|
||
# Déplacer le fichier $1 vers $2, et mettre à jour les liens $3..@ pour
|
||
# qu'ils pointent vers la nouvelle destination
|
||
[ -n "$1" -a -n "$2" ] || return 1
|
||
local src="$1" dest="$2" link
|
||
shift; shift
|
||
[ -d "$dest" ] && dest="$dest/$(basename -- "$src")"
|
||
move_link "$src" "$dest" || return 1
|
||
update_links "$dest" "$@"
|
||
}
|
||
|
||
################################################################################
|
||
## utilitaires
|
||
function get_nblines() {
|
||
# Afficher le nombre de lignes d'un fichier
|
||
[ -f "$1" ] && sed -ne '$=' "$1" || echo 0
|
||
}
|
||
function mktempf() {
|
||
# générer un fichier temporaire et retourner son nom
|
||
mktemp "${1:-"$TMPDIR/tmp.XXXXXX"}"
|
||
}
|
||
function mktempd() {
|
||
# générer un répertoire temporaire et retourner son nom
|
||
mktemp -d "${1:-"$TMPDIR/tmp.XXXXXX"}"
|
||
}
|
||
function mkdirof() {
|
||
# Créer le répertoire correspondant à un fichier
|
||
mkdir -p "$(dirname -- "$1")"
|
||
}
|
||
function cp_a() {
|
||
# copier des fichiers en gardant le maximum de propriétés
|
||
/bin/cp -a "$@"
|
||
}
|
||
function cp_R() {
|
||
# copier des fichiers récursivement, en suivant les liens symboliques
|
||
/bin/cp -pR "$@"
|
||
}
|
||
function quietgrep() {
|
||
# tester la présence d'un pattern dans un fichier
|
||
grep -q "$@" 2>/dev/null
|
||
}
|
||
function quietdiff() {
|
||
# tester si deux fichiers sont identiques
|
||
diff -q "$@" >&/dev/null
|
||
}
|
||
function testsame() {
|
||
# tester si deux fichiers sont identiques/différents
|
||
quietdiff "$@"
|
||
}
|
||
function testdiff() {
|
||
! quietdiff "$@"
|
||
}
|
||
function testupdated() {
|
||
# test si $2 n'existe pas ou si $1 est différent de $2
|
||
if [ -f "$2" ]; then
|
||
testdiff "$1" "$2"
|
||
else
|
||
return 0
|
||
fi
|
||
}
|
||
function testnewer() {
|
||
# test si $2 n'existe pas ou si $1 est plus récent que $2
|
||
test ! -e "$2" -o "$1" -nt "$2"
|
||
}
|
||
function ps_all() {
|
||
# afficher tous les processus avec le maximum d'informations
|
||
ps -axww
|
||
}
|
||
function progexists() {
|
||
# tester l'existence d'un programme dans le PATH
|
||
test -n "$1" -a -x "$(which "$1" 2>/dev/null)"
|
||
}
|
||
function has_python() {
|
||
# tester la présence de python
|
||
progexists python
|
||
}
|
||
function has_gawk() {
|
||
# tester la présence de gnuawk
|
||
progexists gawk
|
||
}
|
||
function is_root() {
|
||
# tester si on est root
|
||
test `id -u` -eq 0
|
||
}
|
||
function source_ifexists() {
|
||
# sourcer un fichier s'il existe
|
||
if [ -f "$1" ]; then source "$1" || die; fi
|
||
}
|
||
function little_sleep {
|
||
# s'endormir pour une très petite période de temps
|
||
LC_NUMERIC=C sleep 0.1
|
||
}
|
||
function random_sleep {
|
||
# s'endormir pour une durée allant de 0 à $1 secondes. Par défaut, $1=1800 (soit 30 minutes)
|
||
sleep $(($RANDOM % ${1:-1800}))
|
||
}
|
||
function is_running() {
|
||
# tester si un programme dont on donne le PID tourne
|
||
kill -0 "$1" >&/dev/null
|
||
}
|
||
function sedi() {
|
||
# Lancer sed sur un fichier en le modifiant en place
|
||
sed -i "$@"
|
||
}
|
||
function csort() {
|
||
# Lancer sort avec LANG=C pour éviter les problèmes avec la locale. en effet,
|
||
# avec LANG!=C, sort utilise les règles de la locale pour le tri, et par
|
||
# exemple, avec LANG=fr_FR.UTF-8, la locale indique que les ponctuations doivent
|
||
# être ignorées.
|
||
LANG=C sort "$@"
|
||
}
|
||
function lsort() { sort "$@"; }
|
||
function cgrep() {
|
||
# Lancer grep avec LANG=C pour éviter les problèmes avec la locale. cf csort
|
||
# pour une explication.
|
||
LANG=C grep "$@"
|
||
}
|
||
function lgrep() { grep "$@"; }
|
||
function csed() {
|
||
# Lancer sed avec LANG=C pour éviter les problèmes avec la locale. cf csort pour
|
||
# une explication.
|
||
LANG=C sed "$@"
|
||
}
|
||
function lsed() { sed "$@"; }
|
||
function cawk() {
|
||
# Lancer awk avec LANG=C pour éviter les problèmes avec la locale. cf csort pour
|
||
# une explication.
|
||
LANG=C awk "$@"
|
||
}
|
||
function lawk() { awk "$@"; }
|
||
function cdiff() {
|
||
# Lancer diff avec LANG=C pour éviter les problèmes avec la locale. cf csort
|
||
# pour une explication.
|
||
LANG=C diff "$@"
|
||
}
|
||
function ldiff() { diff "$@"; }
|
||
|
||
################################################################################
|
||
## utilitaires de haut niveau
|
||
|
||
function fix_mode() {
|
||
# Si le fichier $1 n'est pas writable, le rendre writable temporairement. Si
|
||
# nécessaire, le fichier est créé.
|
||
# Cette fonction s'utilise de cette façon:
|
||
# mode="$(fix_mode file)"
|
||
# ...
|
||
# unfix_mode file "$mode"
|
||
local file="$1"
|
||
[ -f "$file" ] || touch "$file" || return 1
|
||
if [ ! -w "$file" ]; then
|
||
local mode="$(stat -c %a "$file")"
|
||
chmod ${mode:0:${#mode}-3}6${mode:${#mode}-2:2} "$file"
|
||
echo "$mode"
|
||
fi
|
||
}
|
||
function unfix_mode() {
|
||
# Restaurer le mode $2 du fichier $1 traité par fix_mode
|
||
[ -n "$2" ] && chmod "$2" "$1"
|
||
}
|
||
function get_mode() {
|
||
# Obtenir le mode du fichier $1, en le créant si nécessaire. A utiliser avec
|
||
# unfix_mode pour restaurer le mode d'un fichier qui a été traité avec un
|
||
# fichier temporaire intermédiaire
|
||
[ -f "$1" ] || touch "$1" || return 1
|
||
stat -c %a "$1"
|
||
}
|
||
function rm_maybe() {
|
||
# Supprimer les fichiers dont on donne la liste. Si aucun fichier n'est
|
||
# spécifié, cette fonction est un NOP
|
||
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 "$@"
|
||
}
|
||
__CPDIR_RSYNC_SLOW=1 # synchro potentiellement plus lente, mais plus fidèle (option -c)
|
||
__CPDIR_RSYNC_ARGS=(-q)
|
||
function cpdir() {
|
||
# 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...
|
||
# La copie est faite avec rsync si possible. Les options du tableau
|
||
# __CPDIR_RSYNC_ARGS sont rajoutées aux options standard de rsync.
|
||
|
||
if progexists rsync; then
|
||
[ -d "$2" ] || mkdir -p "$2" || return 1
|
||
if [ -d "$1" ]; then
|
||
rsync -a ${__CPDIR_RSYNC_SLOW:+-c} "${__CPDIR_RSYNC_ARGS[@]}" "$1/" "$2/"
|
||
else
|
||
rsync -a ${__CPDIR_RSYNC_SLOW:+-c} "${__CPDIR_RSYNC_ARGS[@]}" "$1" "$2/"
|
||
fi
|
||
else
|
||
__cpdir "$@"
|
||
fi
|
||
}
|
||
function __cpdir() {
|
||
# implémentation avec bash de cpdir(). cette fonction est utilisée par
|
||
# cpdir() quand rsync n'est pas disponible
|
||
# $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
|
||
[ -d "$dest" ] || mkdir -p "$dest" || return 1
|
||
|
||
# ensuite on fait la copie
|
||
local prevdir="$(pwd)"
|
||
|
||
dest="$(abspath "$dest")"
|
||
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 dans le répertoire $dest qui est créé pour la
|
||
# circonstance
|
||
mkdir -p "$dest"
|
||
"$method" "$src" "$dest"
|
||
fi
|
||
fi
|
||
}
|
||
__CPNOVCS_RSYNC_SLOW=1 # synchro potentiellement plus lente, mais plus fidèle (option -c)
|
||
__CPNOVCS_RSYNC_ARGS=(-q)
|
||
__CPNOVCS_INCLUDE_VCS= # ne pas ignorer les répertoires de VCS
|
||
function cpnovcs() {
|
||
# copier le fichier/répertoire $1 *dans* le *répertoire* $2 avec rsync. Les
|
||
# options du tableau __CPNOVCS_RSYNC_ARGS sont rajoutées aux options standard
|
||
# de rsync.
|
||
# Si $1 est un répertoire, la copie est faite en ignorant les sous-répertoires
|
||
# de VCS (.svn, CVS). En ce qui concerne les répertoire de VCS, git aussi est
|
||
# supporté, mais uniquement s'il est à la racine du transfert.
|
||
# Si $1 se termine par un '/', c'est le contenu du répertoire qui est copié, pas
|
||
# le répertoire lui-même. Si rsync n'est pas trouvé sur le système, alors on
|
||
# fait une copie standard qui inclue les répertoires de VCS.
|
||
local src="$1" destdir="$2"
|
||
[ -d "$destdir" ] || mkdir -p "$destdir" || return 1
|
||
if progexists rsync; then
|
||
local -a novcs
|
||
if [ -z "$__CPNOVCS_INCLUDE_VCS" ]; then
|
||
local gitexclude=/.git/
|
||
[ "${src%/}" == "$src" ] && gitexclude="/$(basename -- "$src")$gitexclude"
|
||
novcs=(--exclude CVS/ --exclude .svn/ --exclude "$gitexclude")
|
||
fi
|
||
rsync -a ${__CPNOVCS_RSYNC_SLOW:+-c} "${novcs[@]}" "${__CPNOVCS_RSYNC_ARGS[@]}" "$src" "$destdir/"
|
||
elif [ "${src%/}" != "$src" ]; then
|
||
__cpdir "$src" "$destdir"
|
||
else
|
||
local srcname="$(basename -- "$src")"
|
||
mkdir -p "$destdir/$srcname"
|
||
__cpdir "$src" "$destdir/$srcname"
|
||
fi
|
||
}
|
||
function cpvcs() {
|
||
# comme cpnovcs, mais ne pas ignorer les répertoires de VCS
|
||
local __CPNOVCS_INCLUDE_VCS=1
|
||
cpnovcs "$@"
|
||
}
|
||
function cpdirnovcs() {
|
||
# Le pendant de cpdir, mais en ignorant les sous-répertoires de VCS: copier le
|
||
# contenu du répertoire $1 dans le répertoire $2
|
||
if [ -d "$1" ]; then
|
||
cpnovcs "$1/" "$2"
|
||
else
|
||
cpnovcs "$1" "$2"
|
||
fi
|
||
}
|
||
function doinplace() {
|
||
# Filtrer le fichier $1 à travers la commande $2..$*, puis remplacer le fichier
|
||
# s'il n'y a pas eu d'erreur. Retourner le code d'erreur de la commande. Si $1
|
||
# n'est pas spécifié ou vaut -, filtrer l'entrée standard vers la sortie
|
||
# standard.
|
||
# La variante doinplacef remplace le fichier quelque soit le code de retour de
|
||
# la commande. A utiliser avec des commandes comme grep qui peuvent retourner
|
||
# FAUX s'ils ne trouvent pas le motif
|
||
if [ -n "$1" -a "$1" != "-" ]; then
|
||
local __dip_file="$1"; shift
|
||
autoclean "$__dip_file.tmp.$$"
|
||
"$@" <"$__dip_file" >"$__dip_file.tmp.$$"
|
||
local s=$?
|
||
[ "$s" == 0 ] && /bin/cat "$__dip_file.tmp.$$" >"$__dip_file"
|
||
/bin/rm -f "$__dip_file.tmp.$$"
|
||
return $s
|
||
else
|
||
shift
|
||
"$@"
|
||
fi
|
||
}
|
||
function doinplacef() {
|
||
if [ -n "$1" -a "$1" != "-" ]; then
|
||
local __dip_file="$1"; shift
|
||
autoclean "$__dip_file.tmp.$$"
|
||
"$@" <"$__dip_file" >"$__dip_file.tmp.$$"
|
||
local s=$?
|
||
/bin/cat "$__dip_file.tmp.$$" >"$__dip_file"
|
||
/bin/rm -f "$__dip_file.tmp.$$"
|
||
return $s
|
||
else
|
||
shift
|
||
"$@"
|
||
fi
|
||
}
|
||
function stripnl() {
|
||
# Supprimer les caractères de fin de ligne de la chaine en entrée
|
||
tr -d '\r\n'
|
||
}
|
||
function _nl2lf() {
|
||
# transformer les fins de ligne en LF
|
||
awk 'BEGIN {RS="\r|\r\n|\n"} {print}'
|
||
}
|
||
function nl2lf() {
|
||
doinplace "$1" _nl2lf
|
||
}
|
||
function _nl2crlf() {
|
||
# transformer les fins de ligne en CRLF
|
||
awk 'BEGIN {RS="\r|\r\n|\n"} {print $0 "\r"}'
|
||
}
|
||
function nl2crlf() {
|
||
doinplace "$1" _nl2crlf
|
||
}
|
||
function _nl2cr() {
|
||
# transformer les fins de ligne en CR
|
||
awk 'BEGIN {RS="\r|\r\n|\n"; ORS=""} {print $0 "\r"}'
|
||
}
|
||
function nl2cr() {
|
||
doinplace "$1" _nl2cr
|
||
}
|
||
function _latin1compat() {
|
||
# transformer certains caractères UTF-8 en leur équivalent UTF-8 transformable
|
||
# en latin1.
|
||
LANG=fr_FR.UTF-8 sed $'
|
||
s/[\xE2\x80\x90\xE2\x80\x91\xE2\x80\x92\xE2\x80\x93\xE2\x80\x94\xE2\x80\x95]/-/g
|
||
s/[‘’]/\x27/g
|
||
s/[«»“”]/"/g
|
||
s/[\xC2\xA0\xE2\x80\x87\xE2\x80\xAF\xE2\x81\xA0]/ /g
|
||
s/[œ]/oe/g
|
||
s/[Œ]/OE/g
|
||
s/[æ]/ae/g
|
||
s/[Æ]/AE/g
|
||
'
|
||
}
|
||
function _noaccents() {
|
||
# supprimer les accents d'un flux en UTF-8
|
||
LANG=fr_FR.UTF-8 sed '
|
||
s/[à]/a/g
|
||
s/[éèêë]/e/g
|
||
s/[ïî]/i/g
|
||
s/[ôö]/o/g
|
||
s/[üû]/u/g
|
||
s/[ç]/c/g
|
||
s/[À]/A/g
|
||
s/[ÉÈÊË]/E/g
|
||
s/[ÏÎ]/I/g
|
||
s/[ÔÖ]/O/g
|
||
s/[ÜÛ]/U/g
|
||
s/[Ç]/C/g
|
||
'
|
||
}
|
||
function list_all() {
|
||
# Lister les fichiers ou répertoires du répertoire $1, un par ligne
|
||
# Les répertoires . et .. sont enlevés de la liste
|
||
# $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 "$(__la_cmd "$@")" | while read f; do
|
||
[ "$f" == "." -o "$f" == ".." ] && continue
|
||
rawecho "$f"
|
||
done
|
||
cd "$curdir"
|
||
}
|
||
function __la_cmd() {
|
||
[ $# -gt 0 ] || set '*'
|
||
local arg
|
||
local cmd="/bin/ls -1d"
|
||
for arg in "$@"; do
|
||
arg="$(qwc "$arg")"
|
||
cmd="$cmd $arg"
|
||
done
|
||
cmd="$cmd 2>/dev/null"
|
||
echo "$cmd"
|
||
}
|
||
function list_files() {
|
||
# Lister les fichiers du répertoire $1, un par ligne
|
||
# $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 "$(__la_cmd "$@")" | while read f; do
|
||
[ -f "$f" ] && rawecho "$f"
|
||
done
|
||
cd "$curdir"
|
||
}
|
||
function list_dirs() {
|
||
# Lister les répertoires du répertoire $1, un par ligne
|
||
# Les répertoires . et .. sont enlevés de la liste
|
||
# $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 "$(__la_cmd "$@")" | while read f; do
|
||
[ "$f" == "." -o "$f" == ".." ] && continue
|
||
[ -d "$f" ] && rawecho "$f"
|
||
done
|
||
cd "$curdir"
|
||
}
|
||
function __array_ls() {
|
||
# Lister les fichiers avec `list_$1 $3 $4...`, et les mettre dans le tableau
|
||
# $2. Note: le tableau contient les chemins complets, par seulement les noms
|
||
# comme avec list_$1
|
||
local __al_l="list_${1:-all}"; shift
|
||
local __al_an="$1"; shift
|
||
local __al_d="${1:-.}"; shift
|
||
local -a __al_fs
|
||
array_from_lines __al_fs "$("$__al_l" "$__al_d" "$@")"
|
||
local __al_f
|
||
array_new "$__al_an"
|
||
for __al_f in "${__al_fs[@]}"; do
|
||
array_add "$__al_an" "$__al_d/$__al_f"
|
||
done
|
||
}
|
||
function array_lsall() {
|
||
# Lister les fichiers avec `list_all $2 $3...`, et les mettre dans le
|
||
# tableau $1. Le tableau contient les chemins complets, par seulement les
|
||
# noms comme avec list_all
|
||
__array_ls all "$@"
|
||
}
|
||
function array_lsdirs() {
|
||
# Lister les fichiers avec `list_dirs $2 $3...`, et les mettre dans le
|
||
# tableau $1. Le tableau contient les chemins complets, par seulement les
|
||
# noms comme avec list_dirs
|
||
__array_ls dirs "$@"
|
||
}
|
||
function array_lsfiles() {
|
||
# Lister les fichiers avec `list_files $2 $3...`, et les mettre dans le
|
||
# tableau $1. Le tableau contient les chemins complets, par seulement les
|
||
# noms comme avec list_files
|
||
__array_ls files "$@"
|
||
}
|
||
function filter_empty() {
|
||
# Filtrer l'entrée standard en enlevant les lignes vides
|
||
sed '/^$/d'
|
||
}
|
||
function filter_vcspath() {
|
||
# L'entrée standard étant une liste de chemins, filtrer les fichiers et
|
||
# répertoire qui ont un rapport avec subversion ou git
|
||
sed '
|
||
/^.git$/d
|
||
/^.git\//d
|
||
/\/.git$/d
|
||
/\/.git\//d
|
||
/^.svn$/d
|
||
/^.svn\//d
|
||
/\/.svn$/d
|
||
/\/.svn\//d
|
||
'
|
||
}
|
||
function merge_contlines() {
|
||
# Avec les lignes lues sur stdin, fusionner celles qui se terminent par \ avec
|
||
# les suivantes.
|
||
awk 'substr($0, length($0)) == "\\" {
|
||
while (getline nextline) {
|
||
$0 = substr($0, 1, length($0) - 1) nextline
|
||
if (substr($0, length($0)) != "\\") break
|
||
}
|
||
print
|
||
next
|
||
}
|
||
{print}'
|
||
}
|
||
function filter_comment() {
|
||
# Filtrer un fichier de configuration lu sur stdin en enlevant les commentaires
|
||
# et les lignes vides.
|
||
# Avec $1==-m, fusionner les lignes qui se terminent par \ avec les suivantes
|
||
# Comme filter_conf(), les commentaires doivent être sur une ligne à part.
|
||
# Contrairement à filter_conf, il n'est pas nécessaire que le caractère '#' soit
|
||
# en début de ligne: il peut apparaitre après des espaces et des tabulations. De
|
||
# même, une ligne qui ne contient que des espaces et des tabulations est
|
||
# considérée comme vide.
|
||
local -a merge
|
||
[ "$1" == -m ] && merge=(merge_contlines) || merge=(cat)
|
||
awk '
|
||
/^[ \t]*#/ { next }
|
||
/^[ \t]*$/ { next }
|
||
{ print }' | "${merge[@]}"
|
||
}
|
||
function filter_conf() {
|
||
# filtrer un fichier de configuration lu sur stdin en enlevant les commentaires
|
||
# et les lignes vides. Une ligne n'est considérée commentaire que si '#' est un
|
||
# première position. Utiliser filter_comment() si les commentaire peuvent
|
||
# commencer par des caractères espace et tabulation.
|
||
# Si $1==-m, fusionner les lignes qui se terminent par \ avec les suivantes
|
||
local -a merge
|
||
[ "$1" == -m ] && merge=(merge_contlines) || merge=(cat)
|
||
grep -v '^#' | grep -v '^$' | "${merge[@]}"
|
||
}
|
||
function is_archive() {
|
||
# tester si l'extension d'un fichier indique que c'est une archive
|
||
local name="${1%.zip}"
|
||
name="${name%.tgz}"
|
||
name="${name%.tbz2}"
|
||
name="${name%.tar.gz}"
|
||
name="${name%.tar.bz2}"
|
||
name="${name%.tar}"
|
||
name="${name%.jar}"
|
||
name="${name%.war}"
|
||
name="${name%.ear}"
|
||
[ "$name" != "$1" ]
|
||
}
|
||
function extract_archive() {
|
||
# Extraire le contenu de l'archive $1 dans le répertoire ${2:-.}
|
||
# Les autres arguments, s'ils sont spécifiés, indiquent les fichiers à extraire
|
||
local arch="$1" destdir="${2:-.}"
|
||
shift; shift
|
||
if endswith "$arch" .zip; then
|
||
unzip -q -d "$destdir" "$arch" "$@" || return
|
||
elif endswith "$arch" .tgz || endswith "$arch" .tar.gz; then
|
||
tar xzf "$arch" -C "$destdir" "$@" || return
|
||
elif endswith "$arch" .tbz2 || endswith "$arch" .tar.bz2; then
|
||
tar xjf "$arch" -C "$destdir" "$@" || return
|
||
elif endswith "$arch" .tar; then
|
||
tar xf "$arch" -C "$destdir" "$@" || return
|
||
elif endswith "$arch" .jar || endswith "$arch" .war || endswith "$arch" .ear; then
|
||
(
|
||
arch="$(abspath "$arch")"
|
||
cd "$destdir"
|
||
jar xf "$arch" "$@"
|
||
) || return
|
||
else
|
||
return 1
|
||
fi
|
||
}
|
||
function get_archive_basename() {
|
||
# Obtenir le nom de base de l'archive $1
|
||
local basename="$(basename -- "$1")"
|
||
# supprimer l'extension
|
||
basename="${basename%.zip}"
|
||
basename="${basename%.tgz}"
|
||
basename="${basename%.tbz2}"
|
||
basename="${basename%.gz}"
|
||
basename="${basename%.bz2}"
|
||
basename="${basename%.tar}"
|
||
basename="${basename%.jar}"
|
||
basename="${basename%.war}"
|
||
basename="${basename%.ear}"
|
||
# résultat
|
||
echo "$basename"
|
||
}
|
||
function get_archive_appname() {
|
||
# Obtenir le nom probable de l'application ou du framework contenu dans
|
||
# l'archive $1, e.g:
|
||
# get_archive_versionsuffix app-0.1.tgz
|
||
# --> app
|
||
local appname="$(basename -- "$1")"
|
||
# supprimer l'extension
|
||
appname="${appname%.zip}"
|
||
appname="${appname%.tgz}"
|
||
appname="${appname%.tbz2}"
|
||
appname="${appname%.gz}"
|
||
appname="${appname%.bz2}"
|
||
appname="${appname%.tar}"
|
||
appname="${appname%.jar}"
|
||
appname="${appname%.war}"
|
||
appname="${appname%.ear}"
|
||
# supprimer la version et afficher
|
||
echo "$appname" | awk '{
|
||
if (match($0, /[-_.]([0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/)) {
|
||
print substr($0, 1, RSTART - 1)
|
||
} else if (match($0, /([0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/)) {
|
||
print substr($0, 1, RSTART - 1)
|
||
} else if (match($0, /([0-9]+[a-z][a-z][a-z0-9]?)$/, vs)) {
|
||
# version style AMUE, e.g. 430la
|
||
print substr($0, 1, RSTART - 1)
|
||
} else {
|
||
print $0
|
||
}
|
||
}'
|
||
}
|
||
function get_archive_versionsuffix() {
|
||
# Obtenir la valeur probable de la version de l'application ou du framework
|
||
# contenu dans l'archive $1, avec le caractère de séparation, e.g:
|
||
# get_archive_versionsuffix app-0.1.tgz
|
||
# --> -0.1
|
||
local basename="$(get_archive_basename "$1")"
|
||
echo "$basename" | awk '{
|
||
if (match($0, /([-_.][0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/, vs)) {
|
||
print vs["1"]
|
||
} else if (match($0, /([0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/, vs)) {
|
||
print vs["1"]
|
||
} else if (match($0, /([0-9]+[a-z][a-z][a-z0-9]?)$/, vs)) {
|
||
# version style AMUE, e.g. 430la
|
||
print vs["1"]
|
||
}
|
||
}'
|
||
}
|
||
function get_archive_version() {
|
||
# Obtenir la valeur probable de la version de l'application ou du framework
|
||
# contenu dans l'archive $1, e.g:
|
||
# get_archive_versionsuffix app-0.1.tgz
|
||
# --> 0.1
|
||
local basename="$(get_archive_basename "$1")"
|
||
echo "$basename" | awk '{
|
||
if (match($0, /[-_.]([0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/, vs)) {
|
||
print vs["1"]
|
||
} else if (match($0, /([0-9]+([-_.][0-9]+)*([a-zA-Z][0-9]*|[-_.][0-9]+[a-zA-Z][0-9]*)?)$/, vs)) {
|
||
print vs["1"]
|
||
} else if (match($0, /([0-9]+[a-z][a-z][a-z0-9]?)$/, vs)) {
|
||
# version style AMUE, e.g. 430la
|
||
print vs["1"]
|
||
}
|
||
}'
|
||
}
|
||
function __dump_usernames() {
|
||
</etc/passwd awkrun FS=: '($3 + 0) >= 500 && $6 ~ /^\/home\// { print $1 }'
|
||
}
|
||
function dump_usernames() {
|
||
# Placer dans le tableau $1 la liste des utilisateurs du système
|
||
# Cette implémentation consulte /etc/passwd et liste tous les utilisateurs dont
|
||
# le homedir se trouve dans /home, et dont l'uid est >=500
|
||
array_from_lines "${1:-usernames}" "$(__dump_usernames)"
|
||
}
|
||
function __resolv_ips() {
|
||
LANG=C host "$1" 2>/dev/null | awk '/address / { gsub(/^.*address /, ""); print }'
|
||
}
|
||
function resolv_ips() {
|
||
# Placer dans le tableau $1(=ips) la liste des adresses ip correspondant à
|
||
# l'hôte $2. La résolution est effectuée avec la commande host.
|
||
array_from_lines "${1:-ips}" "$(__resolv_ips "$2")"
|
||
}
|
||
function __resolv_hosts() {
|
||
LANG=C host "$1" 2>/dev/null | awk '/domain name pointer / { gsub(/^.*domain name pointer /, ""); gsub(/\.$/, ""); print }'
|
||
}
|
||
function resolv_hosts() {
|
||
# Placer dans le tableau $1(=hosts) la liste des hôtes correspondant à
|
||
# l'adresse ip $2. La résolution est effectuée avec la commande host.
|
||
array_from_lines "${1:-hosts}" "$(__resolv_hosts "$2")"
|
||
}
|
||
function runscript_as() {
|
||
# Utiliser bash pour lancer le script $2 avec les arguments $3..$n afin qu'il
|
||
# tourne avec les droits d'un autre user $1(=root). Si $2=exec, utiliser exec
|
||
# pour lancer le script et ses arguments qui commencent à partir de $3, ce qui
|
||
# fait que cette fonction ne retourne pas.
|
||
# Attention! cette fonction ne teste pas avec si on est déjà le user $1. Il y a
|
||
# donc un risque de boucle infinie si on ne teste pas le user courant.
|
||
local OENC="$UTF8"
|
||
local user="${1:-root}"; shift
|
||
local exec_maybe=
|
||
if [ "$1" = "exec" ]; then
|
||
exec_maybe=exec
|
||
shift
|
||
fi
|
||
|
||
local cmd
|
||
cmd="\
|
||
__estack=$(quoted_arg "$__estack")
|
||
__tlevel=$(quoted_args "$__tlevel")
|
||
export __estack __tlevel
|
||
exec ${BASH:-/bin/sh} $(quoted_args "$@")"
|
||
|
||
if is_yes "$UTOOLS_USES_SU" || ! progexists sudo; then
|
||
eecho "Entrez le mot de passe de root"
|
||
$exec_maybe su "$user" -c "$cmd"
|
||
else
|
||
if [ "$user" == "root" ]; then
|
||
$exec_maybe sudo -p "Entrez le mot de passe de %u: " "${BASH:-/bin/sh}" -c "$cmd"
|
||
else
|
||
$exec_maybe sudo -p "Entrez le mot de passe de %u: " su "$user" -c "$cmd"
|
||
fi
|
||
fi
|
||
}
|
||
function runscript_as_root() {
|
||
# Utiliser bash pour lancer le script $1 avec les arguments $2..$* avec les
|
||
# droits de root. Si on est déjà en root, le script est simplement lancé. Sinon,
|
||
# utiliser runscript_as pour lancer le script avec les droits de root.
|
||
if is_root; then
|
||
local exec_maybe=
|
||
if [ "$1" = "exec" ]; then
|
||
exec_maybe=exec
|
||
shift
|
||
fi
|
||
$exec_maybe "${BASH:-/bin/sh}" "$@"
|
||
else
|
||
runscript_as root "$@"
|
||
fi
|
||
}
|
||
function run_as() {
|
||
# Relancer le script courant afin qu'il tourne avec les droits d'un autre user
|
||
# $1(=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.
|
||
# Il faut 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 user="${1:-root}"; shift
|
||
local exec_maybe=exec
|
||
if [ "$1" = "--noexec" ]; then
|
||
exec_maybe=
|
||
shift
|
||
fi
|
||
|
||
runscript_as "$user" $exec_maybe "$0" "$@"
|
||
}
|
||
function run_as_root() {
|
||
# relancer le script courant afin qu'il tourne en root si on est pas en déjà
|
||
# root. Sinon, cette fonction est un nop.
|
||
is_root || run_as root "$@"
|
||
}
|
||
function check_user() {
|
||
# Vérifier si le user courant est l'un des users $1..*
|
||
local user
|
||
for user in "$@"; do
|
||
[ "$USER" == "$user" ] && return 0
|
||
done
|
||
return 1
|
||
}
|
||
function ensure_user() {
|
||
# Vérifier si le user courant est l'un des users $1..N où N est la position du
|
||
# premier "--". Si ce n'est pas le cas et que l'on est root, relancer le script
|
||
# avec ce user grâce à la fonction run_as()
|
||
# Retourner 1 si ce n'était pas le bon user. Retourner 10 si ce n'était pas le
|
||
# bon user et que l'on n'est pas root (donc impossible à priori de relancer le
|
||
# script avec le bon user). Retourner 11 si l'utilisateur a choisi de ne pas
|
||
# lancer le script avec le bon utilisateur
|
||
# A utiliser de cette manière:
|
||
# if ensure_user users... -- args; then
|
||
# # ... on est avec le bon user; faire les opérations
|
||
# else
|
||
# # ... ce code n'est exécuté que si une erreur s'est produite, ou si ce
|
||
# # n'était pas le bon user et que l'option --noexec est utilisée
|
||
# fi
|
||
local -a users
|
||
while [ $# -gt 0 -a "$1" != "--" ]; do
|
||
array_add users "$1"
|
||
shift
|
||
done
|
||
[ "$1" == "--" ] && shift
|
||
|
||
if ! check_user "${users[@]}"; then
|
||
if [ ${#users[*]} -gt 1 ]; then
|
||
ewarn "Cette commande doit être lancée avec l'un des users ${users[*]}"
|
||
else
|
||
ewarn "Cette commande doit être lancée avec le user ${users[0]}"
|
||
fi
|
||
if ask_yesno "Voulez-vous tenter de relancer la commande avec le bon user?" O; then
|
||
estep "Lancement du script avec le user ${users[0]}"
|
||
run_as "${users[0]}" "$@"
|
||
return 1
|
||
elif is_root; then
|
||
return 11
|
||
else
|
||
return 10
|
||
fi
|
||
fi
|
||
return 0
|
||
}
|
||
function check_hostname() {
|
||
# Vérifier si le hostname courant est l'un des hôtes $1..*
|
||
# localhost matche toujours
|
||
local userhost user host path
|
||
for userhost in "$@"; do
|
||
splitfsep "$userhost" : userhost path
|
||
splituserhost "$userhost" user host
|
||
host="${host%%.*}"
|
||
[ "$host" == localhost -o "$host" == "$MYHOSTNAME" ] && return 0
|
||
done
|
||
return 1
|
||
}
|
||
function check_userhostname() {
|
||
# Vérifier si le hostname et éventuellement le user courant sont l'un des
|
||
# arguments $1..*
|
||
# Chaque argument est de la forme [user@]host, mais le test ne tient compte que
|
||
# du nom de l'hôte, sans tenir compte du domaine. Si le user n'est pas spécifié,
|
||
# le test ne porte que sur hostname.
|
||
local userhost path user host
|
||
for userhost in "$@"; do
|
||
if check_hostname "$userhost"; then
|
||
[[ "$userhost" == *@* ]] || return 0
|
||
splitfsep "$userhost" : userhost path
|
||
splituserhost "$userhost" user host
|
||
check_user "$user" && return 0
|
||
fi
|
||
done
|
||
return 1
|
||
}
|
||
UTOOLS_ENSURE_HOSTNAME_SSH_OPTS=()
|
||
function ensure_hostname() {
|
||
# Vérifier si le hostname et le user courant sont l'un des arguments $1..*
|
||
# Chaque argument est de la forme [user@]host, mais le test ne tient compte que
|
||
# du nom de l'hôte, sans tenir compte du domaine.
|
||
# Si user est spécifié:
|
||
# - Si on est sur le bon hôte mais pas le bon user, ensure_user est lancé avec
|
||
# l'argument approprié pour relancer le script
|
||
# Si l'argument était de la forme userhost:path, le répertoire courant est
|
||
# changé avant de lancer le script avec le bon utilisateur.
|
||
# Sinon (si user n'est pas spécifié):
|
||
# - Si on n'est pas sur le bon hôte, après confirmation le script est lancé avec
|
||
# ssh sur l'hôte distant avec le user spécifié (qui vaut par défaut root). Ce
|
||
# script DOIT exister sur l'hôte distant avec le même chemin.
|
||
# Si l'argument était de la forme userhost:path, le répertoire courant distant
|
||
# est changé avant de lancer le script
|
||
# Si on est avec le bon user sur le bon hôte, le répertoire courant n'est jamais
|
||
# changé.
|
||
# Retourner 1 si ce n'était pas le bon user. Retourner 10 si ce n'était pas le
|
||
# bon user et que l'on n'est pas root (donc impossible à priori de relancer le
|
||
# script avec le bon user). Retourner 11 si l'utilisateur a choisi de ne pas
|
||
# lancer le script sur l'hôte distant. Retourner 12 si une erreur s'est produite
|
||
# avec ssh.
|
||
# A utiliser de cette manière:
|
||
# if ensure_hostname user@host... -- args; then
|
||
# # ... on est [avec le bon user] sur le bon hôte; faire les opérations
|
||
# else
|
||
# # ... ce code n'est exécuté que si une erreur s'est produite, ou si ce
|
||
# # n'était pas le bon user et que l'option --noexec est utilisée
|
||
# fi
|
||
local -a userhosts
|
||
while [ $# -gt 0 -a "$1" != "--" ]; do
|
||
array_add userhosts "$1"
|
||
shift
|
||
done
|
||
[ "$1" == "--" ] && shift
|
||
|
||
local userhost user host path
|
||
if ! check_hostname "${userhosts[@]}"; then
|
||
if [ ${#userhosts[*]} -gt 1 ]; then
|
||
ewarn "Cette commande n'est valide que sur l'un des hôtes ${userhosts[*]}"
|
||
else
|
||
ewarn "Cette commande n'est valide que sur l'hôte ${userhosts[0]}"
|
||
fi
|
||
|
||
enote "Vous pouvez tenter de relancer le script sur ${userhosts[0]}, mais cela requière que ce script ET les données dont il a besoin soient installés dans la même version et dans le même répertoire sur l'hôte distant"
|
||
if ask_yesno "Voulez-vous tenter de relancer le script sur l'hôte distant?" N; then
|
||
splitfsep "${userhosts[0]}" : userhost path
|
||
splituserhost "$userhost" user host
|
||
[ -n "$user" ] || user=root
|
||
|
||
estep "Lancement de la commande sur l'hôte distant $user@$host"
|
||
local cmd
|
||
[ -n "$path" ] && cmd="$(quoted_args cd "$path"); "
|
||
cmd="$cmd$(quoted_args "$script" "$@")"
|
||
ssh -qt "${UTOOLS_ENSURE_HOSTNAME_SSH_OPTS[@]}" "$user@$host" "$cmd"
|
||
[ $? -eq 255 ] && return 12
|
||
return 1
|
||
else
|
||
return 11
|
||
fi
|
||
fi
|
||
# nous sommes sur le bon hôte. Si user est spécifié, le vérifier aussi
|
||
local userhost user host
|
||
for userhost in "${userhosts[@]}"; do
|
||
[[ "$userhost" == *@* ]] || continue
|
||
if check_hostname "$userhost"; then
|
||
splitfsep "$userhost" : userhost path
|
||
splituserhost "$userhost" user host
|
||
[ -n "$path" ] && cd "$path"
|
||
ensure_user "$user" -- "$@"
|
||
return $?
|
||
fi
|
||
done
|
||
return 0
|
||
}
|
||
|
||
__AWKDEF_FUNCTIONS='
|
||
function num(s) {
|
||
if (s ~ /^[0-9]+$/) return int(s)
|
||
else return s
|
||
}
|
||
function ord(s, i) {
|
||
s = substr(s, 1, 1)
|
||
i = index(" !\"#$%&'\''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", s)
|
||
if (i != 0) i += 32 - 1
|
||
return i
|
||
}
|
||
function hex(i, s) {
|
||
s = sprintf("%x", i)
|
||
if (length(s) < 2) s = "0" s
|
||
return s
|
||
}
|
||
function qhtml(s) {
|
||
gsub(/&/, "\\&", s)
|
||
gsub(/"/, "\\"", s)
|
||
gsub(/>/, "\\>", s)
|
||
gsub(/</, "\\<", s)
|
||
return s
|
||
}
|
||
function unquote_html(s) {
|
||
gsub(/</, "<", s)
|
||
gsub(/>/, ">", s)
|
||
gsub(/"/, "\"", s)
|
||
gsub(/&/, "\\&", s)
|
||
return s
|
||
}
|
||
function qval(s) {'"
|
||
gsub(/'/, \"'\\\\''\", s)
|
||
return \"'\" s \"'\"
|
||
"'}
|
||
function sqval(s) {
|
||
return " " qval(s)
|
||
}
|
||
function qvals( i, line) {
|
||
line = ""
|
||
for (i = 1; i <= NF; i++) {
|
||
if (i > 1) line = line " "
|
||
line = line quote_value($i)
|
||
}
|
||
return line
|
||
}
|
||
function sqvals() {
|
||
return " " qvals()
|
||
}
|
||
function qregexp(s) {
|
||
gsub(/[[\\.^$*+?()|{]/, "\\\\&", s)
|
||
return s
|
||
}
|
||
function qsubrepl(s) {
|
||
gsub(/\\/, "\\\\", s)
|
||
gsub(/&/, "\\\\&", s)
|
||
return s
|
||
}
|
||
function qgrep(s) {
|
||
gsub(/[[\\.^$*]/, "\\\\&", s)
|
||
return s
|
||
}
|
||
function qegrep(s) {
|
||
gsub(/[[\\.^$*+?()|{]/, "\\\\&", s)
|
||
return s
|
||
}
|
||
function qsql(s) {'"
|
||
gsub(/'/, \"''\", s)
|
||
return \"'\" s \"'\"
|
||
"'}
|
||
function cqsql(s) {
|
||
return "," qsql(s)
|
||
}
|
||
function unquote_mysqlcsv(s) {
|
||
gsub(/\\n/, "\n", s)
|
||
gsub(/\\t/, "\t", s)
|
||
gsub(/\\0/, "\0", s)
|
||
gsub(/\\\\/, "\\", s)
|
||
return s
|
||
}
|
||
function sval(s) {
|
||
if (s == "") return s
|
||
else return " " s
|
||
}
|
||
function cval(s) {
|
||
if (s == "") return s
|
||
else return "," s
|
||
}
|
||
# aliases pour compatibilité
|
||
function quote_html(s) { return qhtml(s) }
|
||
function quote_value(s) { return qval(s) }
|
||
function qsval(s) { return sqval(s) }
|
||
function quoted_values() { return qvals() }
|
||
function qsvals(s) { return sqvals(s) }
|
||
function quote_regexp(s) { return qregexp(s) }
|
||
function quote_subrepl(s) { return qsubrepl(s) }
|
||
function quote_grep(s) { return qgrep(s) }
|
||
function quote_egrep(s) { return qegrep(s) }
|
||
function quote_sql(s) { return qsql(s) }
|
||
|
||
function __parse_date_fr(date, parts, y, m, d) {
|
||
if (match(date, /([0-9][0-9]?)\/([0-9][0-9]?)\/([0-9][0-9][0-9][0-9])/, parts)) {
|
||
y = int(parts[3])
|
||
m = int(parts[2])
|
||
d = int(parts[1])
|
||
return mktime(sprintf("%04i %02i %02i 00 00 00 +0400", y, m, d))
|
||
}
|
||
return -1
|
||
}
|
||
function __parse_date_mysql(date, parts, y, m, d) {
|
||
if (match(date, /([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])/, parts)) {
|
||
y = int(parts[1])
|
||
m = int(parts[2])
|
||
d = int(parts[3])
|
||
return mktime(sprintf("%04i %02i %02i 00 00 00 +0400", y, m, d))
|
||
}
|
||
return -1
|
||
}
|
||
function __parse_date_any(date, serial) {
|
||
serial = __parse_date_fr(date)
|
||
if (serial == -1) serial = __parse_date_mysql(date)
|
||
return serial
|
||
}
|
||
function date_serial(date) {
|
||
return __parse_date_any(date)
|
||
}
|
||
function date_parse(date, serial) {
|
||
serial = __parse_date_any(date)
|
||
if (serial == -1) return date
|
||
return strftime("%d/%m/%Y", serial)
|
||
}
|
||
function date_monday(date, serial, dow) {
|
||
serial = __parse_date_any(date)
|
||
if (serial == -1) return date
|
||
dow = strftime("%u", serial)
|
||
serial -= (dow - 1) * 86400
|
||
return strftime("%d/%m/%Y", serial)
|
||
}
|
||
function date_add(date, nbdays, serial) {
|
||
serial = __parse_date_any(date)
|
||
if (serial == -1) return date
|
||
serial += nbdays * 86400
|
||
return strftime("%d/%m/%Y", serial)
|
||
}
|
||
|
||
function mkindices(values, indices, i, j) {
|
||
array_new(indices)
|
||
j = 1
|
||
for (i in values) {
|
||
indices[j++] = int(i)
|
||
}
|
||
return asort(indices)
|
||
}
|
||
function array_new(dest) {
|
||
dest[0] = 0 # forcer awk à considérer dest comme un tableau
|
||
delete dest
|
||
}
|
||
function array_newsize(dest, size, i) {
|
||
dest[0] = 0 # forcer awk à considérer dest comme un tableau
|
||
delete dest
|
||
size = int(size)
|
||
for (i = 1; i <= size; i++) {
|
||
dest[i] = ""
|
||
}
|
||
}
|
||
function array_len(values, count, i) {
|
||
# length(array) a un bug sur awk 3.1.5
|
||
# cette version est plus lente mais fonctionne toujours
|
||
count = 0
|
||
for (i in values) {
|
||
count++
|
||
}
|
||
return count
|
||
}
|
||
function array_copy(dest, src, count, indices, i) {
|
||
array_new(dest)
|
||
count = mkindices(src, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
dest[indices[i]] = src[indices[i]]
|
||
}
|
||
}
|
||
function array_getlastindex(src, count, indices) {
|
||
count = mkindices(src, indices)
|
||
if (count == 0) return 0
|
||
return indices[count]
|
||
}
|
||
function array_add(dest, value, lastindex) {
|
||
lastindex = array_getlastindex(dest)
|
||
dest[lastindex + 1] = value
|
||
}
|
||
function array_deli(dest, i, l) {
|
||
i = int(i)
|
||
if (i == 0) return
|
||
l = array_len(dest)
|
||
while (i < l) {
|
||
dest[i] = dest[i + 1]
|
||
i++
|
||
}
|
||
delete dest[l]
|
||
}
|
||
function array_del(dest, value, ignoreCase, i) {
|
||
do {
|
||
i = key_index(value, dest, ignoreCase)
|
||
if (i != 0) array_deli(dest, i)
|
||
} while (i != 0)
|
||
}
|
||
function array_extend(dest, src, count, lastindex, indices, i) {
|
||
lastindex = array_getlastindex(dest)
|
||
count = mkindices(src, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
dest[lastindex + i] = src[indices[i]]
|
||
}
|
||
}
|
||
function array_fill(dest, i) {
|
||
array_new(dest)
|
||
for (i = 1; i <= NF; i++) {
|
||
dest[i] = $i
|
||
}
|
||
}
|
||
function array_getline(src, count, indices, i, j) {
|
||
$0 = ""
|
||
count = mkindices(src, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
j = indices[i]
|
||
$j = src[j]
|
||
}
|
||
}
|
||
function array_appendline(src, count, indices, i, nf, j) {
|
||
count = mkindices(src, indices)
|
||
nf = NF
|
||
for (i = 1; i <= count; i++) {
|
||
j = nf + indices[i]
|
||
$j = src[indices[i]]
|
||
}
|
||
}
|
||
function in_array(value, values, ignoreCase, i) {
|
||
if (ignoreCase) {
|
||
value = tolower(value)
|
||
for (i in values) {
|
||
if (tolower(values[i]) == value) return 1
|
||
}
|
||
} else {
|
||
for (i in values) {
|
||
if (values[i] == value) return 1
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
function key_index(value, values, ignoreCase, i) {
|
||
if (ignoreCase) {
|
||
value = tolower(value)
|
||
for (i in values) {
|
||
if (tolower(values[i]) == value) return int(i)
|
||
}
|
||
} else {
|
||
for (i in values) {
|
||
if (values[i] == value) return int(i)
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
function array2s(values, prefix, sep, suffix, noindices, first, i, s) {
|
||
if (!prefix) prefix = "["
|
||
if (!sep) sep = ", "
|
||
if (!suffix) suffix = "]"
|
||
s = prefix
|
||
first = 1
|
||
for (i in values) {
|
||
if (first) first = 0
|
||
else s = s sep
|
||
if (!noindices) s = s "[" i "]="
|
||
s = s values[i]
|
||
}
|
||
s = s suffix
|
||
return s
|
||
}
|
||
function array2so(values, prefix, sep, suffix, noindices, count, indices, i, s) {
|
||
if (!prefix) prefix = "["
|
||
if (!sep) sep = ", "
|
||
if (!suffix) suffix = "]"
|
||
s = prefix
|
||
count = mkindices(values, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
if (i > 1) s = s sep
|
||
if (!noindices) s = s "[" indices[i] "]="
|
||
s = s values[indices[i]]
|
||
}
|
||
s = s suffix
|
||
return s
|
||
}
|
||
function array_join(values, sep, prefix, suffix, count, indices, i, s) {
|
||
s = prefix
|
||
count = mkindices(values, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
if (i > 1) s = s sep
|
||
s = s values[indices[i]]
|
||
}
|
||
s = s suffix
|
||
return s
|
||
}
|
||
function printto(s, output) {
|
||
if (output == "") {
|
||
print s
|
||
} else if (output ~ /^>>/) {
|
||
sub(/^>>/, "", output)
|
||
print s >>output
|
||
} else if (output ~ /^>/) {
|
||
sub(/^>/, "", output)
|
||
print s >output
|
||
# XXX désactivé pour le moment parce que affiche une erreur de syntaxe si
|
||
# utilisé avec une version de awk autre que gnuawk
|
||
#} else if (output ~ /^\|&/) {
|
||
# sub(/^\|&/, "", output)
|
||
# print s |&output
|
||
#} else if (output ~ /^\|/) {
|
||
# sub(/^\|/, "", output)
|
||
# print s |output
|
||
} else {
|
||
print s >output
|
||
}
|
||
}
|
||
function find_line(input, field, value, orig, line) {
|
||
orig = $0
|
||
line = ""
|
||
while ((getline <input) > 0) {
|
||
if ($field == value) {
|
||
line = $0
|
||
break
|
||
}
|
||
}
|
||
close(input)
|
||
$0 = orig
|
||
return line
|
||
}
|
||
function merge_line(input, field, key, line) {
|
||
line = find_line(input, field, $key)
|
||
if (line != "") $0 = $0 FS line
|
||
}
|
||
function __csv_parse_quoted(line, destl, colsep, qchar, echar, pos, tmpl, nextc, resl) {
|
||
line = substr(line, 2)
|
||
resl = ""
|
||
while (1) {
|
||
pos = index(line, qchar)
|
||
if (pos == 0) {
|
||
# chaine mal terminee
|
||
resl = resl line
|
||
destl[0] = ""
|
||
destl[1] = 0
|
||
return resl
|
||
}
|
||
if (echar != "" && pos > 1) {
|
||
# tenir compte du fait qu"un caratère peut être mis en échappement
|
||
prevc = substr(line, pos - 1, 1)
|
||
quotec = substr(line, pos, 1)
|
||
nextc = substr(line, pos + 1, 1)
|
||
if (prevc == echar) {
|
||
# qchar en échappement
|
||
tmpl = substr(line, 1, pos - 2)
|
||
resl = resl tmpl quotec
|
||
line = substr(line, pos + 1)
|
||
continue
|
||
}
|
||
tmpl = substr(line, 1, pos - 1)
|
||
if (nextc == colsep || nextc == "") {
|
||
# fin de champ ou fin de ligne
|
||
resl = resl tmpl
|
||
destl[0] = substr(line, pos + 2)
|
||
destl[1] = nextc == colsep
|
||
return resl
|
||
} else {
|
||
# erreur de syntaxe: guillemet non mis en échappement
|
||
# ignorer cette erreur et prendre le guillemet quand meme
|
||
resl = resl tmpl quotec
|
||
line = substr(line, pos + 1)
|
||
}
|
||
} else {
|
||
# pas d"échappement pour qchar. il est éventuellement doublé
|
||
tmpl = substr(line, 1, pos - 1)
|
||
quotec = substr(line, pos, 1)
|
||
nextc = substr(line, pos + 1, 1)
|
||
if (nextc == colsep || nextc == "") {
|
||
# fin de champ ou fin de ligne
|
||
resl = resl tmpl
|
||
destl[0] = substr(line, pos + 2)
|
||
destl[1] = nextc == colsep
|
||
return resl
|
||
} else if (nextc == qchar) {
|
||
# qchar en echappement
|
||
resl = resl tmpl quotec
|
||
line = substr(line, pos + 2)
|
||
} else {
|
||
# erreur de syntaxe: guillemet non mis en échappement
|
||
# ignorer cette erreur et prendre le guillemet quand meme
|
||
resl = resl tmpl quotec
|
||
line = substr(line, pos + 1)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function __csv_parse_unquoted(line, destl, colsep, qchar, echar, pos) {
|
||
pos = index(line, colsep)
|
||
if (pos == 0) {
|
||
destl[0] = ""
|
||
destl[1] = 0
|
||
return line
|
||
} else {
|
||
destl[0] = substr(line, pos + 1)
|
||
destl[1] = 1
|
||
return substr(line, 1, pos - 1)
|
||
}
|
||
}
|
||
function __array_parsecsv(fields, line, nbfields, colsep, qchar, echar, shouldparse, destl, i) {
|
||
array_new(fields)
|
||
array_new(destl)
|
||
i = 1
|
||
shouldparse = 0
|
||
# shouldparse permet de gérer le cas où un champ vide est en fin de ligne.
|
||
# en effet, après "," il faut toujours parser, même si line==""
|
||
while (shouldparse || line != "") {
|
||
if (index(line, qchar) == 1) {
|
||
value = __csv_parse_quoted(line, destl, colsep, qchar, echar)
|
||
line = destl[0]
|
||
shouldparse = destl[1]
|
||
} else {
|
||
value = __csv_parse_unquoted(line, destl, colsep, qchar, echar)
|
||
line = destl[0]
|
||
shouldparse = destl[1]
|
||
}
|
||
fields[i] = value
|
||
i = i + 1
|
||
}
|
||
if (nbfields) {
|
||
nbfields = int(nbfields)
|
||
i = array_len(fields)
|
||
while (i < nbfields) {
|
||
i++
|
||
fields[i] = ""
|
||
}
|
||
}
|
||
return array_len(fields)
|
||
}
|
||
BEGIN {
|
||
DEFAULT_COLSEP = ","
|
||
DEFAULT_QCHAR = "\""
|
||
DEFAULT_ECHAR = ""
|
||
}
|
||
function array_parsecsv2(fields, line, nbfields, colsep, qchar, echar) {
|
||
return __array_parsecsv(fields, line, nbfields, colsep, qchar, echar)
|
||
}
|
||
function array_parsecsv(fields, line, nbfields, colsep, qchar, echar) {
|
||
if (colsep == "") colsep = DEFAULT_COLSEP
|
||
if (qchar == "") qchar = DEFAULT_QCHAR
|
||
if (echar == "") echar = DEFAULT_ECHAR
|
||
return __array_parsecsv(fields, line, nbfields, colsep, qchar, echar)
|
||
}
|
||
function parsecsv(line, fields) {
|
||
array_parsecsv(fields, line)
|
||
array_getline(fields)
|
||
return NF
|
||
}
|
||
function getlinecsv(file, fields) {
|
||
if (file) {
|
||
getline <file
|
||
} else {
|
||
getline
|
||
}
|
||
return parsecsv($0)
|
||
}
|
||
function __csv_should_quote(s) {
|
||
if (s ~ /^[[:blank:][:cntrl:][:space:]]/) return 1
|
||
if (s ~ /[[:blank:][:cntrl:][:space:]]$/) return 1
|
||
return 0
|
||
}
|
||
function array_formatcsv2(fields, colsep, mvsep, qchar, echar, count, indices, line, i, value) {
|
||
line = ""
|
||
count = mkindices(fields, indices)
|
||
for (i = 1; i <= count; i++) {
|
||
value = fields[indices[i]]
|
||
if (i > 1) line = line colsep
|
||
if (qchar != "" && index(value, qchar) != 0) {
|
||
if (echar != "") gsub(qchar, quote_subrepl(echar) "&", value);
|
||
else gsub(qchar, "&&", value);
|
||
}
|
||
if (qchar != "" && (index(value, mvsep) != 0 || index(value, colsep) != 0 || index(value, qchar) != 0 || __csv_should_quote(value))) {
|
||
line = line qchar value qchar
|
||
} else {
|
||
line = line value
|
||
}
|
||
}
|
||
return line
|
||
}
|
||
function array_formatcsv(fields) {
|
||
return array_formatcsv2(fields, ",", ";", "\"", "")
|
||
}
|
||
function array_printcsv(fields, output) {
|
||
printto(array_formatcsv(fields), output)
|
||
}
|
||
function get_formatcsv( fields) {
|
||
array_fill(fields)
|
||
return array_formatcsv(fields)
|
||
}
|
||
function formatcsv() {
|
||
$0 = get_formatcsv()
|
||
}
|
||
function printcsv(output, fields) {
|
||
array_fill(fields)
|
||
array_printcsv(fields, output)
|
||
}
|
||
function array_findcsv(fields, input, field, value, nbfields, orig, found, i) {
|
||
array_new(orig)
|
||
array_fill(orig)
|
||
array_new(fields)
|
||
found = 0
|
||
while ((getline <input) > 0) {
|
||
array_parsecsv(fields, $0, nbfields)
|
||
if (fields[field] == value) {
|
||
found = 1
|
||
break
|
||
}
|
||
}
|
||
close(input)
|
||
array_getline(orig)
|
||
if (!found) {
|
||
delete fields
|
||
if (nbfields) {
|
||
nbfields = int(nbfields)
|
||
i = array_len(fields)
|
||
while (i < nbfields) {
|
||
i++
|
||
fields[i] = ""
|
||
}
|
||
}
|
||
}
|
||
return found
|
||
}
|
||
|
||
function __and(var, x, l_res, l_i) {
|
||
l_res=0;
|
||
for (l_i=0; l_i < 8; l_i++){
|
||
if (var%2 == 1 && x%2 == 1) l_res=l_res/2 + 128;
|
||
else l_res/=2;
|
||
var=int(var/2);
|
||
x=int(x/2);
|
||
}
|
||
return l_res;
|
||
}
|
||
# Rotate bytevalue left x times
|
||
function __lshift(var, x) {
|
||
while(x > 0){
|
||
var*=2;
|
||
x--;
|
||
}
|
||
return var;
|
||
}
|
||
# Rotate bytevalue right x times
|
||
function __rshift(var, x) {
|
||
while(x > 0){
|
||
var=int(var/2);
|
||
x--;
|
||
}
|
||
return var;
|
||
}
|
||
BEGIN {
|
||
__BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||
}
|
||
function b64decode(src, result, base1, base2, base3, base4) {
|
||
result = ""
|
||
while (length(src) > 0) {
|
||
# Specify byte values
|
||
base1 = substr(src, 1, 1)
|
||
base2 = substr(src, 2, 1)
|
||
base3 = substr(src, 3, 1); if (base3 == "") base3 = "="
|
||
base4 = substr(src, 4, 1); if (base4 == "") base4 = "="
|
||
# Now find numerical position in BASE64 string
|
||
byte1 = index(__BASE64, base1) - 1
|
||
if (byte1 < 0) byte1 = 0
|
||
byte2 = index(__BASE64, base2) - 1
|
||
if (byte2 < 0) byte2 = 0
|
||
byte3 = index(__BASE64, base3) - 1
|
||
if (byte3 < 0) byte3 = 0
|
||
byte4 = index(__BASE64, base4) - 1
|
||
if (byte4 < 0) byte4 = 0
|
||
# Reconstruct ASCII string
|
||
result = result sprintf( "%c", __lshift(__and(byte1, 63), 2) + __rshift(__and(byte2, 48), 4) )
|
||
if (base3 != "=") result = result sprintf( "%c", __lshift(__and(byte2, 15), 4) + __rshift(__and(byte3, 60), 2) )
|
||
if (base4 != "=") result = result sprintf( "%c", __lshift(__and(byte3, 3), 6) + byte4 )
|
||
# Decrease incoming string with 4
|
||
src = substr(src, 5)
|
||
}
|
||
return result
|
||
}
|
||
'
|
||
function awkdef() {
|
||
# Afficher un script à insérer au début d'un script awk. Ce script définit dans
|
||
# une section BEGIN{} les variables donnés en arguments, et avec l'option -f,
|
||
# des fonctions utiles. Si une valeur ne ressemble pas à une définition de
|
||
# variable, l'analyse des variables s'arrête et le reste des arguments est
|
||
# inséré tel quel. Cette fonction peut être utilisée de cette manière:
|
||
# awk "$(awkdef -f var=value... 'script awk')"
|
||
# Normalement, les variables définies sont scalaires, avec une syntaxe de la
|
||
# forme var[:type]=value. type peut valoir str ou int, pour forcer le type de la
|
||
# variable créée dans awk.
|
||
# Il est possible d'utiliser la syntaxe awk_array[@]=bash_array ou array[@] (qui
|
||
# est équivalente à array[@]=array) pour initialiser le tableau awk_array, qui
|
||
# contiendra toute les valeurs du tableau nommé bash_array, avec les indices de
|
||
# 1 à N, N étant le nombre d'éléments du tableau bash_array. La variable
|
||
# awk_array_count est aussi initialisée, et contient le nombre d'éléments du
|
||
# tableau
|
||
# La syntaxe "awk_array[@]=<\n..." permet de spécifier les valeurs du tableau,
|
||
# une par ligne, e.g:
|
||
# $'values[@]=<\nvalue1\nvalue2'
|
||
# pour un tableau values qui contiendra deux valeurs: value1 et value2
|
||
# Avec l'option -f, des fonctions supplémentaires sont définies. Elles sont
|
||
# décrites dans le module awk.
|
||
|
||
if [ "${1:0:3}" == "-f" ]; then
|
||
shift
|
||
echo "$__AWKDEF_FUNCTIONS"
|
||
fi
|
||
if [ $# -gt 0 ]; then
|
||
local __ad_arg __ad_vpos __ad_name __ad_value
|
||
echo "BEGIN {"
|
||
while [ -n "${1:0:1}" ]; do
|
||
# considérer seulement les 256 premiers caractères. en effet, si
|
||
# l'argument a une taille trop importante, il y a des délais
|
||
# insupportables
|
||
__ad_arg="${1:0:256}"
|
||
local __ad_array=
|
||
if [ "${__ad_arg%\[@\]}" != "$__ad_arg" ]; then
|
||
__ad_array=1
|
||
__ad_name="${__ad_arg%\[@\]}"
|
||
[ -z "${__ad_name//[a-zA-Z0-9_]/}" ] || break
|
||
__ad_value="$__ad_name"
|
||
elif [[ "$__ad_arg" == *\[@\]=* ]]; then
|
||
__ad_array=1
|
||
__ad_name="${__ad_arg%%\[@\]=*}"
|
||
[ -z "${__ad_name//[a-zA-Z0-9_]/}" ] || break
|
||
__ad_vpos=$((${#__ad_name} + 4))
|
||
__ad_value="${1:$__ad_vpos}"
|
||
[ ${#__ad_value} -ne 0 ] || __ad_value="$__ad_name"
|
||
elif [[ "$__ad_arg" == *=* ]]; then
|
||
local __ad_int= __ad_str=
|
||
__ad_name="${__ad_arg%%=*}"
|
||
__ad_vpos=$((${#__ad_name} + 1))
|
||
if [ "${__ad_name%:int}" != "$__ad_name" ]; then
|
||
__ad_int=1
|
||
__ad_name="${__ad_name%:int}"
|
||
elif [ "${__ad_name%:str}" != "$__ad_name" ]; then
|
||
__ad_str=1
|
||
__ad_name="${__ad_name%:str}"
|
||
fi
|
||
[ -z "${__ad_name//[a-zA-Z0-9_]/}" ] || break
|
||
__ad_value="${1:$__ad_vpos}"
|
||
if [ -n "$__ad_int" ]; then
|
||
# valeur entière
|
||
echo "$__ad_name = int($(quoted_awk "$__ad_value") + 0)"
|
||
elif [ -n "$__ad_str" ]; then
|
||
# valeur chaine
|
||
echo "$__ad_name = $(quoted_awk "$__ad_value")"
|
||
elif [ ${#__ad_value} -lt 256 ] && isnum "$__ad_value"; then
|
||
# considérer qu'une nombre fait moins de 256 chiffres
|
||
echo "$__ad_name = $__ad_value"
|
||
else
|
||
echo "$__ad_name = $(quoted_awk "$__ad_value")"
|
||
fi
|
||
else
|
||
# fin de l'analyse des définitions de variable
|
||
break
|
||
fi
|
||
if [ -n "$__ad_array" ]; then
|
||
if [ "${__ad_value:0:2}" == $'<\n' ]; then
|
||
local -a __ad_values
|
||
array_from_lines __ad_values "${__ad_value:2}"
|
||
__ad_value=__ad_values
|
||
fi
|
||
__ad_value="${__ad_value}[@]"
|
||
local __ad_i=1
|
||
echo "$__ad_name[0] = 0; delete $__ad_name"
|
||
for __ad_arg in "${!__ad_value}"; do
|
||
echo "$__ad_name[$__ad_i]=$(quoted_awk "$__ad_arg")"
|
||
__ad_i=$(($__ad_i + 1))
|
||
done
|
||
eval "echo \"\${__ad_name}_count = \${#$__ad_value}\""
|
||
fi
|
||
shift
|
||
done
|
||
echo "}"
|
||
for __ad_arg in "$@"; do
|
||
rawecho "$__ad_arg"
|
||
done
|
||
fi
|
||
}
|
||
function lawkrun() {
|
||
# wrapper pour lancer awk avec un script préparé par awkdef. Les définitions et
|
||
# les arguments sont séparés par --, e.g.
|
||
# awkrun var0=value0 var1=value1 script -- input0 input1
|
||
local -a __ar_defs __ar_args
|
||
while [ $# -gt 0 -a "$1" != "--" ]; do
|
||
__ar_defs=("${__ar_defs[@]}" "$1")
|
||
shift
|
||
done
|
||
shift
|
||
while [ $# -gt 0 ]; do
|
||
__ar_args=("${__ar_args[@]}" "$1")
|
||
shift
|
||
done
|
||
local __ar_script="$(awkdef "${__ar_defs[@]}")"
|
||
[ -n "$UTOOLS_AWKRUN_DEBUG" ] && estep "Script awkrun: $__ar_script"
|
||
#pgawk -p "$__ar_script" "${__ar_args[@]}"
|
||
awk "$__ar_script" "${__ar_args[@]}"
|
||
}
|
||
function cawkrun() { LANG=C lawkrun "$@"; }
|
||
function awkrun() { LANG=C lawkrun "$@"; }
|
||
|
||
function __lf_get_age() {
|
||
local y=$(date "+%Y")
|
||
local dy=$(date "+%j"); while [ "${dy#0}" != "$dy" ]; do dy="${dy#0}"; done
|
||
[ -n "$dy" ] || dy=0
|
||
local h=$(date "+%H"); while [ "${h#0}" != "$h" ]; do h="${h#0}"; done
|
||
[ -n "$h" ] || h=0
|
||
echo $((($y * 365 + $dy) * 24 + $h))
|
||
}
|
||
function lf_trylock() {
|
||
# USAGE
|
||
# lf_trylock [-h max_hours] /path/to/lockfile
|
||
# OPTIONS
|
||
# lockfile
|
||
# fichier qui doit contenir le verrou
|
||
# -h max_hours
|
||
# Nombre d'heures (par défaut 4) au bout duquel afficher stale
|
||
# Sinon, afficher locked
|
||
# Retourne 0 si le verrou a été placé correctement. Il ne faut pas oublier de
|
||
# supprimer le fichier. Le mieux est de le faire supprimer automatiquement par
|
||
# autoclean:
|
||
# lockfile=...
|
||
# case "$(lf_trylock "$lockfile")" in
|
||
# locked) ...;;
|
||
# stale) ...;;
|
||
# esac
|
||
# autoclean "$lockfile"
|
||
# Sinon, retourner 1 et afficher l'une des deux valeurs suivantes:
|
||
# - stale si le verrou a déjà été placé, depuis au moins max_hours heures
|
||
# - locked si le verrou a déjà été placé
|
||
# - retry si une erreur s'est produite pendant la pose du verrou ou sa
|
||
# lecture. Cela peut se produire si les droits ne sont pas suffisants pour
|
||
# écrire dans le répertoire destination, ou si le fichier a été supprimé
|
||
# avant sa lecture (race-condition). Dans ce dernier cas, reessayer permettra
|
||
# d'acquérir le verrou
|
||
local eoo lockfile max_hours=4
|
||
while [ -n "$1" ]; do
|
||
case "$1" in
|
||
-h) shift; max_hours="$1";;
|
||
--) shift; eoo=1;;
|
||
*) eoo=1;;
|
||
esac
|
||
[ -n "$eoo" ] && break
|
||
shift
|
||
done
|
||
|
||
lockfile="$1"
|
||
[ -n "$lockfile" ] || die "il faut spécifier un fichier pour le verrou"
|
||
|
||
local now="$(__lf_get_age)"
|
||
if (set -C; echo "$now" >"$lockfile") 2>/dev/null; then
|
||
return 0
|
||
fi
|
||
local prev diff
|
||
if prev="$(<"$lockfile")"; then
|
||
diff="$(($now - $prev))"
|
||
if [ "$diff" -gt "$max_hours" ]; then
|
||
echo stale
|
||
else
|
||
echo locked
|
||
fi
|
||
elif [ -f "$lockfile" ]; then
|
||
echo retry
|
||
fi
|
||
return 1
|
||
}
|
||
function pidfile_set() {
|
||
# USAGE
|
||
# pidfile_set [-p pid] /path/to/pidfile
|
||
# OPTIONS
|
||
# pidfile
|
||
# fichier qui doit contenir le pid du script
|
||
# -p pid
|
||
# spécifier le pid. par défaut, utiliser $$
|
||
# -r si pidfile existe mais que le processus ne tourne plus, faire
|
||
# comme si le fichier n'existe pas.
|
||
# Retourner 0 si le pid a été correctement écrit dans le fichier. Ce fichier
|
||
# sera supprimé automatiquement en fin de script
|
||
# Retourner 1 si le fichier existe déjà et que le processus est en train de
|
||
# tourner.
|
||
# Retourner 2 si le fichier existe déjà mais que le processus ne tourne plus.
|
||
# Retourner 10 si autre erreur grave s'est produite (par exemple, s'il manque le
|
||
# chemin vers pidfile, ou si le fichier n'est pas accessible en écriture.)
|
||
local eoo pidfile pid=$$ replace=
|
||
while [ -n "$1" ]; do
|
||
case "$1" in
|
||
-p)
|
||
shift
|
||
pid="$1"
|
||
;;
|
||
-r)
|
||
replace=1
|
||
;;
|
||
--)
|
||
shift
|
||
eoo=1
|
||
;;
|
||
*)
|
||
eoo=1
|
||
;;
|
||
esac
|
||
[ -n "$eoo" ] && break
|
||
shift
|
||
done
|
||
|
||
pidfile="$1"
|
||
[ -n "$pidfile" ] || return 10
|
||
|
||
if [ -f "$pidfile" ]; then
|
||
local curpid="$(<"$pidfile")"
|
||
if is_running "$curpid"; then
|
||
return 1
|
||
elif [ -n "$replace" ]; then
|
||
/bin/rm -f "$pidfile" || return 10
|
||
else
|
||
return 2
|
||
fi
|
||
fi
|
||
|
||
echo_ "$pid" >"$pidfile" || return 10
|
||
autoclean "$pidfile"
|
||
return 0
|
||
}
|
||
function pidfile_check() {
|
||
# USAGE
|
||
# pidfile_check /path/to/pidfile
|
||
# OPTIONS
|
||
# pidfile
|
||
# fichier qui doit contenir le pid d'un processus
|
||
# Cette fonction permet de vérifier si le processus associé à un fichier de pid
|
||
# est en train de tourner.
|
||
# Retourner 0 si le fichier de pid existe et que le process du pid spécifié est
|
||
# en train de tourner. Retourner 1 sinon.
|
||
# Retourner 10 si erreur grave s'est produite (par exemple, s'il manque le
|
||
# chemin vers pidfile, ou si le fichier n'est pas accessible en lecture.)
|
||
local pidfile="$1"
|
||
[ -n "$pidfile" ] || return 10
|
||
|
||
if [ -f "$pidfile" ]; then
|
||
[ -r "$pidfile" ] || return 10
|
||
local pid="$(<"$pidfile")"
|
||
is_running "$pid" && return 0
|
||
fi
|
||
return 1
|
||
}
|
||
function page_maybe() {
|
||
# Utiliser less, si possible, pour afficher le flux en entrée. Si le terminal
|
||
# n'est pas interactif ou si le nombre de lignes en entrée est inférieur au
|
||
# nombre de lignes du terminal, afficher simplement le flux.
|
||
# Les arguments de cette fonction sont passés à less
|
||
if isatty; then
|
||
less -XF "$@"
|
||
else
|
||
cat
|
||
fi
|
||
}
|
||
|
||
################################################################################
|
||
## entrée/sortie
|
||
|
||
function utools_local() {
|
||
# Afficher les commandes pour rendre locales certaines variables en fonction des
|
||
# arguments:
|
||
# - opts rend locale args, pour utiliser parse_opts() à l'intérieur d'une
|
||
# fonction.
|
||
# - verbosity et interaction rendent respectivement locales __verbosity et
|
||
# __interaction. Ceci est utile pour pouvoir appeler sans risque de pollution
|
||
# de l'environnement une fonction qui utilise parse_opts() avec les
|
||
# définitions de PRETTYOPTS.
|
||
# Si aucun arguments n'est fourni, toutes les définitions sont affichées.
|
||
local arg
|
||
[ $# -gt 0 ] || set -- opts verbosity interaction
|
||
for arg in "$@"; do
|
||
case "$arg" in
|
||
parse_opts|opts|o|args) echo "local -a args";;
|
||
verbosity|v) echo "local __verbosity='$__verbosity'";;
|
||
interaction|i) echo "local __interaction='$__interaction'";;
|
||
esac
|
||
done
|
||
}
|
||
|
||
function isatty() {
|
||
# tester si STDOUT n'est pas une redirection
|
||
tty -s <&1
|
||
}
|
||
function in_isatty() {
|
||
# tester si STDIN n'est pas une redirection
|
||
tty -s
|
||
}
|
||
function out_isatty() {
|
||
# tester si STDOUT n'est pas une redirection
|
||
tty -s <&1
|
||
}
|
||
function err_isatty() {
|
||
# tester si STDERR n'est pas une redirection
|
||
tty -s <&2
|
||
}
|
||
function die() { [ $# -gt 0 ] && eerror "$@"; exit 1; }
|
||
function exit_with { if [ $# -gt 0 ]; then "$@"; fi; exit $?; }
|
||
function die_with { [ $# -gt 0 ] && eerror "$1"; shift; [ $# -gt 0 ] && "$@"; exit 1; }
|
||
function die_unless() {
|
||
# Afficher $-1 et quitter le script avec die() si la commande $1..-2 retourne
|
||
# FAUX
|
||
local count=$#
|
||
if [ $count -eq 0 ]; then
|
||
exit 1
|
||
elif [ $count -eq 1 ]; then
|
||
"$@" || exit $?
|
||
else
|
||
local m r
|
||
m="${@:$count}"
|
||
count=$(($count - 1))
|
||
set -- "${@:1:$count}"
|
||
if "$@"; then
|
||
:
|
||
else
|
||
r=$?
|
||
eerror "$m"
|
||
exit $r
|
||
fi
|
||
fi
|
||
}
|
||
function eerror_unless() {
|
||
# Afficher $-1 avec eerror() et retourner $? si la commande $1..-2 retourne FAUX
|
||
local count=$#
|
||
if [ $count -eq 0 ]; then
|
||
return 1
|
||
elif [ $count -eq 1 ]; then
|
||
"$@" || return $?
|
||
else
|
||
local m r
|
||
m="${@:$count}"
|
||
count=$(($count - 1))
|
||
set -- "${@:1:$count}"
|
||
if "$@"; then
|
||
:
|
||
else
|
||
r=$?
|
||
eerror "$m"
|
||
return $r
|
||
fi
|
||
fi
|
||
}
|
||
function die_if() {
|
||
# Afficher $-1 et quitter le script avec die() si la commande $1..-2 retourne
|
||
# VRAI
|
||
local count=$#
|
||
if [ $count -eq 0 ]; then
|
||
:
|
||
elif [ $count -eq 1 ]; then
|
||
"$@" && exit 1
|
||
else
|
||
local m r
|
||
m="${@:$count}"
|
||
count=$(($count - 1))
|
||
set -- "${@:1:$count}"
|
||
if "$@"; then
|
||
eerror "$m"
|
||
exit 1
|
||
fi
|
||
fi
|
||
}
|
||
function eerror_if() {
|
||
# Afficher $-1 avec eerror() et retourner le code d'erreur 1 si la commande
|
||
# $1..-2 retourne VRAI
|
||
local count=$#
|
||
if [ $count -eq 0 ]; then
|
||
:
|
||
elif [ $count -eq 1 ]; then
|
||
"$@" && return 1
|
||
else
|
||
local m r
|
||
m="${@:$count}"
|
||
count=$(($count - 1))
|
||
set -- "${@:1:$count}"
|
||
if "$@"; then
|
||
eerror "$m"
|
||
return 1
|
||
fi
|
||
fi
|
||
}
|
||
|
||
TAB=$'\t'
|
||
LATIN1=iso-8859-1
|
||
LATIN9=iso-8859-15
|
||
UTF8=utf-8
|
||
OENC="$UTF8"
|
||
|
||
if ! progexists iconv; then
|
||
function iconv() { cat; }
|
||
fi
|
||
|
||
function __lang_encoding() {
|
||
local lang="$(<<<"$LANG" awk '{ print tolower($0) }')"
|
||
case "$lang" in
|
||
*@euro) echo "iso-8859-15";;
|
||
*.utf-8|*.utf8) echo "utf-8";;
|
||
*) echo "iso-8859-1";;
|
||
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 == "utf" || 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"
|
||
}
|
||
|
||
if [ -n "$UTOOLS_LANG" -a -z "$LANG" ]; then
|
||
export UTOOLS_LANG
|
||
export LANG="$UTOOLS_LANG"
|
||
fi
|
||
__init_encoding
|
||
|
||
function tooenc() {
|
||
# Transformer la valeur $1 de l'encoding $2(=$OENC) vers l'encoding de sortie
|
||
# $3=($UTOOLS_OUTPUT_ENCODING)
|
||
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
|
||
if [ "$from" == "$to" ]; then
|
||
rawecho "$src"
|
||
else
|
||
iconv -f "$from" -t "$to" <<<"$src"
|
||
fi
|
||
}
|
||
function uecho() {
|
||
tooenc "$*"
|
||
}
|
||
function tooenc_() {
|
||
# Transformer la valeur $1 de l'encoding $2(=$OENC) vers l'encoding de sortie
|
||
# $3=($UTOOLS_OUTPUT_ENCODING)
|
||
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
|
||
if [ "$from" == "$to" ]; then
|
||
rawecho_ "$src"
|
||
else
|
||
rawecho_ "$src" | iconv -f "$from" -t "$to"
|
||
fi
|
||
}
|
||
function uecho_() {
|
||
tooenc_ "$*"
|
||
}
|
||
function toienc() {
|
||
# Transformer la valeur $1 de $2(=$IENC) vers l'encoding d'entrée
|
||
# $3(=$UTOOLS_INPUT_ENCODING)
|
||
local __tie_var="$1" __tie_to="${2:-$IENC}" __tie_from="${3:-$UTOOLS_INPUT_ENCODING}"
|
||
if [ "$__tie_from" != "$__tie_to" ]; then
|
||
set_var "$__tie_var" "$(iconv -f "$__tie_from" -t "$__tie_to" <<<"${!__tie_var}")"
|
||
fi
|
||
}
|
||
function uread() {
|
||
# Lire une valeur sur stdin et la placer dans la variable $1. On assume que la
|
||
# valeur en entrée est encodée dans l'encoding d'entrée par défaut
|
||
[ $# -gt 0 ] || set -- REPLY
|
||
local __r_var
|
||
read "$@"
|
||
for __r_var in "$@"; do
|
||
[ -z "$__r_var" -o "${__r_var:0:1}" == "-" ] && continue # ignorer les options
|
||
toienc "$__r_var"
|
||
done
|
||
}
|
||
|
||
function stooenc() {
|
||
# Transformer la valeur lue sur stdin de $OENC vers l'encoding de sortie par
|
||
# défaut ($UTOOLS_OUTPUT_ENCODING)
|
||
local from="${1:-$OENC}" to="${2:-$UTOOLS_OUTPUT_ENCODING}"
|
||
if [ "$from" == "$to" ]; then
|
||
cat
|
||
else
|
||
iconv -f "$from" -t "$to"
|
||
fi
|
||
}
|
||
function stoienc() {
|
||
# Transformer la valeur lue sur stdin de $IENC vers l'encoding d'entrée par
|
||
# défaut ($UTOOLS_INPUT_ENCODING)
|
||
local to="${1:-$IENC}" from="${2:-$UTOOLS_INPUT_ENCODING}"
|
||
if [ "$from" == "$to" ]; then
|
||
cat
|
||
else
|
||
iconv -f "$from" -t "$to"
|
||
fi
|
||
}
|
||
|
||
# faut-il dater les messages de etitle, estep, ebegin?
|
||
# Faire UTOOLS_EDATE=1 en début de script pour activer cette fonctionnalité
|
||
export UTOOLS_EDATE
|
||
function __edate() { [ -n "$UTOOLS_EDATE" ] && date +"[%d/%m/%Y-%H:%M:%S] "; }
|
||
|
||
export UTOOLS_ELOG_OVERWRITE
|
||
function __set_no_colors() { :; }
|
||
function elogto() {
|
||
# Activer UTOOLS_EDATE et rediriger STDOUT et STDERR vers le fichier $1
|
||
# Si deux fichiers sont spécifiés, rediriger STDOUT vers $1 et STDERR vers $2
|
||
# Si aucun fichier n'est spécifié, ne pas faire de redirection
|
||
# Si la redirection est activée, forcer l'utilisation de l'encoding UTF8
|
||
# Si UTOOLS_ELOG_OVERWRITE=1, alors le fichier en sortie est écrasé. Sinon, les
|
||
# lignes en sortie lui sont ajoutées
|
||
UTOOLS_EDATE=1
|
||
if [ -n "$1" -a -n "$2" ]; then
|
||
LANG=fr_FR.UTF8
|
||
UTOOLS_OUTPUT_ENCODING="$UTF8"
|
||
__set_no_colors 1
|
||
if [ -n "$UTOOLS_ELOG_OVERWRITE" ]; then
|
||
exec >"$1" 2>"$2"
|
||
else
|
||
exec >>"$1" 2>>"$2"
|
||
fi
|
||
elif [ -n "$1" ]; then
|
||
LANG=fr_FR.UTF8
|
||
UTOOLS_OUTPUT_ENCODING="$UTF8"
|
||
__set_no_colors 1
|
||
if [ -n "$UTOOLS_ELOG_OVERWRITE" ]; then
|
||
exec >"$1" 2>&1
|
||
else
|
||
exec >>"$1" 2>&1
|
||
fi
|
||
fi
|
||
}
|
||
|
||
# variables utilisées pour l'affichage indenté des messages et des titres
|
||
# __estack est la liste des invocations de 'ebegin' et 'etitle' en cours
|
||
# __tlevel est l'indentation à appliquer avant d'afficher le message
|
||
export __estack __tlevel
|
||
function __indent() {
|
||
# indenter les lignes de $1, sauf la première
|
||
if [ "${1/
|
||
/}" != "$1" ]; then
|
||
sed "2,\$s/^/${__tlevel}/g" <<<"$1"
|
||
else
|
||
rawecho "$1"
|
||
fi
|
||
}
|
||
# fonctions à surcharger pour modifier la façon dont les messages sont affichés
|
||
function __eerror() { tooenc "$(__edate)${__tlevel}ERROR $(__indent "$1")"; }
|
||
function __ewarn() { tooenc "$(__edate)${__tlevel}WARNING $(__indent "$1")"; }
|
||
function __enote() { tooenc "$(__edate)${__tlevel}NOTE $(__indent "$1")"; }
|
||
function __ebanner() {
|
||
local maxi="${COLUMNS:-80}"
|
||
local -a lines
|
||
local psfix line
|
||
|
||
psfix="$(__edate)${__tlevel}"
|
||
while [ ${#psfix} -lt $maxi ]; do psfix="$psfix="; done
|
||
|
||
tooenc "$psfix"
|
||
maxi=$(($maxi - 1))
|
||
array_from_xlines lines "$1"
|
||
for line in "" "${lines[@]}" ""; do
|
||
line="$(__edate)${__tlevel}= $line"
|
||
if [ ${#line} -le $maxi ]; then
|
||
while [ ${#line} -lt $maxi ]; do line="$line "; done
|
||
line="$line="
|
||
fi
|
||
tooenc "$line"
|
||
done
|
||
tooenc "$psfix"
|
||
}
|
||
function __eimportant() { tooenc "$(__edate)${__tlevel}IMPORTANT $(__indent "$1")"; }
|
||
function __eattention() { tooenc "$(__edate)${__tlevel}ATTENTION $(__indent "$1")"; }
|
||
function __einfo() { tooenc "$(__edate)${__tlevel}INFO $(__indent "$1")"; }
|
||
function __eecho() { tooenc "$(__edate)${__tlevel}$(__indent "$1")"; }
|
||
function __eecho_() { tooenc_ "$(__edate)${__tlevel}$(__indent "$1")"; }
|
||
function __edebug() { tooenc "$(__edate)${__tlevel}DEBUG $(__indent "$1")"; }
|
||
function __estep() { tooenc "$(__edate)${__tlevel}. $(__indent "$1")"; }
|
||
function __estepe() { tooenc "$(__edate)${__tlevel}.E $(__indent "$1")"; }
|
||
function __estepw() { tooenc "$(__edate)${__tlevel}.W $(__indent "$1")"; }
|
||
function __estepn() { tooenc "$(__edate)${__tlevel}.N $(__indent "$1")"; }
|
||
function __estepi() { tooenc "$(__edate)${__tlevel}.I $(__indent "$1")"; }
|
||
function __estep_() { tooenc_ "$(__edate)${__tlevel}. $(__indent "$1")"; }
|
||
function __estepe_() { tooenc_ "$(__edate)${__tlevel}.E $(__indent "$1")"; }
|
||
function __estepw_() { tooenc_ "$(__edate)${__tlevel}.W $(__indent "$1")"; }
|
||
function __estepn_() { tooenc_ "$(__edate)${__tlevel}.N $(__indent "$1")"; }
|
||
function __estepi_() { tooenc_ "$(__edate)${__tlevel}.I $(__indent "$1")"; }
|
||
function __etitle() { tooenc "$(__edate)${__tlevel}=== $(__indent "$1")"; }
|
||
function __ebegin() { tooenc_ "$(__edate)${__tlevel}. $(__indent "$1"): "; }
|
||
function __edoto() { echo_ "."; }
|
||
function __edotw() { echo_ "w"; }
|
||
function __edotx() { echo_ "x"; }
|
||
function __edotp() { echo_ "+"; }
|
||
function __edotd() { tooenc "($1)"; }
|
||
function __eendo() { echo "[ok]"; }
|
||
function __eendx() { echo "[error]"; }
|
||
PRETTYOPTS=()
|
||
function set_verbosity() { :;}
|
||
function set_interaction() { :;}
|
||
function show_error() {
|
||
# tester respectivement si on doit afficher les messages d'erreur,
|
||
# d'avertissement, d'information, de debug
|
||
return 0
|
||
}
|
||
function show_warn() {
|
||
return 0
|
||
}
|
||
function show_info() {
|
||
return 0
|
||
}
|
||
function show_verbose() {
|
||
return 0
|
||
}
|
||
function show_debug() {
|
||
[ -n "$DEBUG" ]
|
||
}
|
||
function check_verbosity() {
|
||
return 0
|
||
}
|
||
function get_verbosity_option() { :;}
|
||
function check_interaction() {
|
||
return 0
|
||
}
|
||
function is_interaction() {
|
||
return 1
|
||
}
|
||
function get_interaction_option() { :;}
|
||
# note: toutes les fonctions d'affichage e* écrivent sur stderr
|
||
__epending=
|
||
function eflush() {
|
||
# Afficher les messages en attente
|
||
if [ -n "$__epending" ]; then rawecho "$__epending" 1>&2; __epending=; fi
|
||
}
|
||
function eclearp() {
|
||
# Supprimer les message en attente
|
||
__epending=
|
||
}
|
||
function eerror() {
|
||
# Afficher un message d'erreur
|
||
show_error || return; eflush; __eerror "$*" 1>&2
|
||
}
|
||
function ewarn() {
|
||
# Afficher un message d'avertissement
|
||
show_warn || return; eflush; __ewarn "$*" 1>&2
|
||
}
|
||
function enote() {
|
||
# Afficher un message d'information de même niveau qu'un avertissement
|
||
show_info || return; eflush; __enote "$*" 1>&2
|
||
}
|
||
function ebanner() {
|
||
# Afficher un message très important encadré, puis attendre 5 secondes
|
||
show_error || return; eflush; __ebanner "$*" 1>&2; sleep 5
|
||
}
|
||
function eimportant() {
|
||
# Afficher un message très important
|
||
show_error || return; eflush; __eimportant "$*" 1>&2
|
||
}
|
||
function eattention() {
|
||
# Afficher un message important
|
||
show_warn || return; eflush; __eattention "$*" 1>&2
|
||
}
|
||
function einfo() {
|
||
# Afficher un message d'information
|
||
show_info || return; eflush; __einfo "$*" 1>&2
|
||
}
|
||
function eecho() {
|
||
# Afficher un message d'information sans préfixe
|
||
show_info || return; eflush; __eecho "$*" 1>&2
|
||
}
|
||
function eecho_() {
|
||
show_info || return; eflush; __eecho_ "$*" 1>&2
|
||
}
|
||
function edebug() {
|
||
# Afficher un message de debug
|
||
show_debug || return; eflush; __edebug "$*" 1>&2
|
||
}
|
||
function trace() {
|
||
# Afficher la commande $1..@, la lancer, puis afficher son code d'erreur si une
|
||
# erreur se produit
|
||
local r cmd="$(quoted_args "$@")"
|
||
show_info && { eflush; __eecho "\$ $cmd" 1>&2; }
|
||
"$@"; r=$?
|
||
if [ $r -ne 0 ]; then
|
||
if show_info; then
|
||
eflush; __eecho "^ [EC #$r]" 1>&2
|
||
elif show_error; then
|
||
eflush; __eecho "^ $cmd [EC #$r]" 1>&2;
|
||
fi
|
||
fi
|
||
return $r
|
||
}
|
||
function trace_error() {
|
||
# Lancer la commande $1..@, puis afficher son code d'erreur si une erreur se
|
||
# produit. La différence avec trace() est que la commande n'est affichée que si
|
||
# une erreur se produit.
|
||
local r
|
||
"$@"; r=$?
|
||
if [ $r -ne 0 ]; then
|
||
local cmd="$(quoted_args "$@")"
|
||
show_error && { eflush; __eecho "^ $cmd [EC #$r]" 1>&2; }
|
||
fi
|
||
return $r
|
||
}
|
||
|
||
function etitle() {
|
||
# Afficher le titre $1, qui est le début éventuel d'une section. Les section
|
||
# imbriquées sont affichées indentées. La section n'est pas terminée, et il faut
|
||
# la terminer explicitement avec eend, sauf dans certains cas précis:
|
||
# - Si $2..$* est spécifié, c'est une commande. Lancer la commande dans le
|
||
# contexte de la section. Puis, la section est automatiquement terminée sauf si
|
||
# l'option -s est spécifiée, auquel cas la section reste ouverte. Si l'option -p
|
||
# est spécifiée, eclearp() est appelé pour purger les messages en attente
|
||
# - Dans le cas contraire, l'option -s est ignorée: la section doit toujours
|
||
# être terminée explicitement.
|
||
# La fonction etitled() est comme etitle(), mais le titre n'est pas affiché
|
||
# immédiatement. L'affichage effectif est effectué dès qu'une fonction e* est
|
||
# utilisée. Ceci permet, avec la fonction eclearp(), de ne pas afficher de titre
|
||
# pour une section vide.
|
||
local __t_deferred=
|
||
__t_etitle "$@"
|
||
}
|
||
function etitled() {
|
||
local __t_deferred=1
|
||
__t_etitle "$@"
|
||
}
|
||
function __t_etitle() {
|
||
local __t_eend=default
|
||
local __t_clearp=
|
||
while [ -n "$1" ]; do
|
||
if [ "$1" == "--" ]; then
|
||
shift
|
||
break
|
||
elif [ "$1" == "-s" ]; then
|
||
__t_eend=
|
||
shift
|
||
elif [ "$1" == "--eend" ]; then
|
||
__t_eend=1
|
||
shift
|
||
elif [ "$1" == "-p" ]; then
|
||
__t_clearp=1
|
||
shift
|
||
else
|
||
break
|
||
fi
|
||
done
|
||
local __t_title="$1"; shift
|
||
local __t_s=0
|
||
# etitle
|
||
[ -n "$__estack" ] && __tlevel="${__tlevel} "
|
||
__estack="$__estack:t"
|
||
if show_info; then
|
||
if [ -n "$__t_deferred" ]; then
|
||
__epending="${__epending:+$__epending
|
||
}$(__etitle "$__t_title")"
|
||
else
|
||
eflush
|
||
__etitle "$__t_title" 1>&2
|
||
fi
|
||
fi
|
||
# commande
|
||
if [ $# -gt 0 ]; then
|
||
"$@"
|
||
__t_s=$?
|
||
[ "$__t_eend" == "default" ] && __t_eend=1
|
||
fi
|
||
# eend
|
||
[ "$__t_eend" == "default" ] && __t_eend=
|
||
if [ -n "$__t_eend" ]; then
|
||
eend $__t_s
|
||
[ -n "$__t_clearp" ] && eclearp
|
||
fi
|
||
return $__t_s
|
||
}
|
||
function estep() {
|
||
# Afficher la description d'une opération. Cette fonction est particulièrement
|
||
# appropriée dans le contexte d'un etitle.
|
||
# Les variantes e (error), w (warning), n (note), i (info) permettent d'afficher
|
||
# des couleurs différentes, mais toutes sont du niveau info.
|
||
show_info || return; eflush; __estep "$*" 1>&2
|
||
}
|
||
function estepe() {
|
||
show_info || return; eflush; __estepe "$*" 1>&2
|
||
}
|
||
function estepw() {
|
||
show_info || return; eflush; __estepw "$*" 1>&2
|
||
}
|
||
function estepn() {
|
||
show_info || return; eflush; __estepn "$*" 1>&2
|
||
}
|
||
function estepi() {
|
||
show_info || return; eflush; __estepi "$*" 1>&2
|
||
}
|
||
function estep_() {
|
||
show_info || return; eflush; __estep_ "$*" 1>&2
|
||
}
|
||
function estepe_() {
|
||
show_info || return; eflush; __estepe_ "$*" 1>&2
|
||
}
|
||
function estepw_() {
|
||
show_info || return; eflush; __estepw_ "$*" 1>&2
|
||
}
|
||
function estepn_() {
|
||
show_info || return; eflush; __estepn_ "$*" 1>&2
|
||
}
|
||
function estepi_() {
|
||
show_info || return; eflush; __estepi_ "$*" 1>&2
|
||
}
|
||
function ebegin() {
|
||
# Afficher le message $1, qui décrit le début d'une opération. Cette fonction
|
||
# débute une section, qu'il faut terminer avec eend.
|
||
# Si $2..$* est spécifié, c'est une commande. Lancer la commande dans le
|
||
# contexte de la section. Puis, la section est terminée automatiquement, sauf si
|
||
# l'option -s est spécifiée, auquel cas la section reste ouverte.
|
||
local __b_eend=default
|
||
while [ -n "$1" ]; do
|
||
if [ "$1" == "--" ]; then
|
||
shift
|
||
break
|
||
elif [ "$1" == "-s" ]; then
|
||
__b_eend=
|
||
shift
|
||
elif [ "$1" == "--eend" ]; then
|
||
__b_eend=1
|
||
shift
|
||
else
|
||
break
|
||
fi
|
||
done
|
||
local __b_msg="$1"; shift
|
||
local __b_s=0
|
||
# ebegin
|
||
__estack="$__estack:b"
|
||
if show_info; then
|
||
eflush
|
||
__ebegin "$__b_msg" 1>&2
|
||
fi
|
||
# commande
|
||
if [ $# -gt 0 ]; then
|
||
"$@"
|
||
__b_s=$?
|
||
[ "$__b_eend" == "default" ] && __b_eend=1
|
||
fi
|
||
# eend
|
||
[ "$__b_eend" == "default" ] && __b_eend=
|
||
[ -n "$__b_eend" ] && eend $__b_s
|
||
return $__b_s
|
||
}
|
||
function edot() {
|
||
# Afficher une étape d'une opération, matérialisée par un point '.' ou une
|
||
# croix 'x' en cas de succès ou d'erreur. Cette fonction est particulièrement
|
||
# appropriée dans le contexte d'un ebegin.
|
||
local s=$?
|
||
show_info || return
|
||
eflush
|
||
[ -n "$1" ] && s="$1"
|
||
shift
|
||
if [ "$s" == "0" ]; then
|
||
__edoto 1>&2
|
||
else
|
||
__edotx 1>&2
|
||
fi
|
||
show_verbose && [ $# -gt 0 ] && __edotd "$*" 1>&2
|
||
return $s
|
||
}
|
||
function edotw() {
|
||
# Afficher un avertissement comme étape d'une opération, matérialisée par une
|
||
# lettre 'w' (typiquement de couleur jaune). Cette fonction est particulièrement
|
||
# appropriée dans le contexte d'un ebegin.
|
||
local s=$?
|
||
show_info || return
|
||
eflush
|
||
[ -n "$1" ] && s="$1"
|
||
shift
|
||
__edotw 1>&2
|
||
show_verbose && [ $# -gt 0 ] && __edotd "$*" 1>&2
|
||
return $s
|
||
}
|
||
function ewait() {
|
||
# Afficher les étapes d'une opération qui dure, matérialisées par des '+' toutes
|
||
# les secondes tant que le processus $1 tourne.
|
||
# A utiliser de cette manière:
|
||
# ebegin "msg"
|
||
# cmd &
|
||
# ewait $!
|
||
# eend
|
||
[ -n "$1" ] || return 1
|
||
if show_info; then
|
||
local count=2
|
||
eflush
|
||
little_sleep # certains processus retournent tout de suite
|
||
while is_running "$1"; do
|
||
sleep 1
|
||
if [ $count -gt 0 ]; then
|
||
# attendre 2 secondes avant de commencer à afficher des '+'
|
||
count=$(($count - 1))
|
||
else
|
||
__edotp 1>&2
|
||
fi
|
||
done
|
||
# terminer par un '.'
|
||
__edoto 1>&2
|
||
else
|
||
# ne rien afficher, mais attendre quand même la fin de l'opération
|
||
wait "$1"
|
||
fi
|
||
}
|
||
function eend() {
|
||
# Terminer une section.
|
||
# Avec l'option -c, remettre à zéro toutes les informations de section
|
||
# Si la section en cours est un ebegin, afficher la fin de l'opération: [ok] ou
|
||
# [error] en fonction du code de retour de la dernière commande (ou de $1 si
|
||
# cette valeur est donnée)
|
||
# Si la section en cours est un etitle, marquer la fin de la section concernée
|
||
# par le titre.
|
||
local s=$?
|
||
if [ "$1" == "-c" ]; then
|
||
__estack=
|
||
__tlevel=
|
||
elif [ "${__estack%:b}" != "$__estack" ]; then
|
||
# terminer ebegin
|
||
__estack="${__estack%:b}"
|
||
show_info || return
|
||
eflush
|
||
[ -n "$1" ] && s="$1"
|
||
if [ "$s" == "0" ]; then
|
||
__eendo 1>&2
|
||
else
|
||
__eendx 1>&2
|
||
fi
|
||
elif [ "${__estack%:t}" != "$__estack" ]; then
|
||
# terminer etitle -s
|
||
__estack="${__estack%:t}"
|
||
__tlevel="${__tlevel% }"
|
||
fi
|
||
}
|
||
function __elinedots() {
|
||
ebegin "$1"
|
||
local line
|
||
if show_debug; then
|
||
while read line; do
|
||
__edoto 1>&2
|
||
__edotd "$line" 1>&2
|
||
done
|
||
else
|
||
while read line; do
|
||
__edoto 1>&2
|
||
done
|
||
fi
|
||
eend
|
||
}
|
||
function elinedots() {
|
||
# Afficher un message comme avec ebegin "$1", puis afficher un point '.' pour
|
||
# chaque ligne lue sur stdin. Cela permet de suivre une opération. En mode
|
||
# DEBUG, afficher la ligne affichée plutôt qu'un point.
|
||
# Si $2..$* sont spécifiés, lancer la commande et suivre sa sortie. Ainsi,
|
||
# 'elinedots msg cmd args' est un raccourci pour 'cmd args | elinedots msg'
|
||
local msg="$1"; shift
|
||
if [ $# -gt 0 ]; then
|
||
"$@" | __elinedots "$msg"
|
||
else
|
||
__elinedots "$msg"
|
||
fi
|
||
}
|
||
function ask_yesno() {
|
||
# Afficher le message $1 suivi de [oN] ou [On] suivant que $2 vaut O ou N, puis
|
||
# lire la réponse. Retourner 0 si la réponse est vrai, 1 sinon.
|
||
# Si $1 est une option, elle est utilisée avec check_interaction pour savoir si
|
||
# on est en mode interactif ou non. A ce moment-là, les valeurs sont décalées
|
||
# ($2=message, $3=default)
|
||
# Si $2 vaut C, la valeur par défaut est N si on est interactif, O sinon
|
||
# Si $2 vaut X, la valeur par défaut est O si on est interactif, N sinon
|
||
local interactive=1
|
||
if [[ "$1" == -* ]]; then
|
||
if [ "$1" != -- ]; then
|
||
check_interaction "$1" || interactive=
|
||
fi
|
||
shift
|
||
else
|
||
check_interaction -c || interactive=
|
||
fi
|
||
local default="${2:-N}"
|
||
if [ "$default" == "C" ]; then
|
||
[ -n "$interactive" ] && default=N || default=O
|
||
elif [ "$default" == "X" ]; then
|
||
[ -n "$interactive" ] && default=O || default=N
|
||
fi
|
||
if [ -n "$interactive" ]; then
|
||
eflush
|
||
local message="$1"
|
||
local prompt="[oN]"
|
||
local r
|
||
is_yes "$default" && prompt="[On]"
|
||
if [ -n "$message" ]; then
|
||
tooenc_ "$message" 1>&2
|
||
else
|
||
tooenc_ "Voulez-vous continuer?" "$UTF8" 1>&2
|
||
fi
|
||
tooenc_ " $prompt " "$UTF8" 1>&2
|
||
uread r
|
||
is_yes "${r:-$default}"
|
||
else
|
||
is_yes "$default"
|
||
fi
|
||
}
|
||
function read_value() {
|
||
# Afficher le message $1 suivi de la valeur par défaut [$3] si elle est non
|
||
# vide, puis lire la valeur donnée par l'utilisateur. Cette valeur doit être non
|
||
# vide si $4(=O) est vrai. La valeur saisie est placée dans la variable
|
||
# $2(=value)
|
||
# Si $1 est une option, elle est utilisée avec check_interaction pour savoir si
|
||
# on est en mode interactif ou non. A ce moment-là, les valeurs sont décalées
|
||
# ($2=message, $3=variable, $4=default, $5=required)
|
||
# En mode non interactif, c'est la valeur par défaut qui est sélectionnée. Si
|
||
# l'utilisateur requière que la valeur soit non vide et que la valeur par défaut
|
||
# est vide, afficher un message d'erreur et retourner faux
|
||
# read_password() est comme read_value(), mais la valeur saisie n'est pas
|
||
# affichée, ce qui la rend appropriée pour la lecture d'un mot de passe.
|
||
local -a __rv_opts __rv_readline=1 __rv_showdef=1 __rv_nl=
|
||
__rv_opts=()
|
||
[ -n "$UTOOLS_NO_READLINE" ] && __rv_readline=
|
||
__rv_read "$@"
|
||
}
|
||
function read_password() {
|
||
local -a __rv_opts __rv_readline= __rv_showdef= __rv_nl=1
|
||
__rv_opts=(-s)
|
||
__rv_read "$@"
|
||
}
|
||
function __rv_read() {
|
||
local __rv_int=1
|
||
if [[ "$1" == -* ]]; then
|
||
if [ "$1" != -- ]; then
|
||
check_interaction "$1" || __rv_int=
|
||
fi
|
||
shift
|
||
else
|
||
check_interaction -c || __rv_int=
|
||
fi
|
||
local __rv_msg="$1" __rv_v="${2:-value}" __rv_d="$3" __rv_re="${4:-O}"
|
||
if [ -z "$__rv_int" ]; then
|
||
# En mode non interactif, retourner la valeur par défaut
|
||
if is_yes "$__rv_re" && [ -z "$__rv_d" ]; then
|
||
OENC="$UTF8" eerror "La valeur par défaut de $__rv_v doit être non vide"
|
||
return 1
|
||
fi
|
||
set_var "$__rv_v" "$__rv_d"
|
||
return 0
|
||
fi
|
||
|
||
eflush
|
||
local __rv_r
|
||
while true; do
|
||
if [ -n "$__rv_msg" ]; then
|
||
tooenc_ "$__rv_msg" 1>&2
|
||
else
|
||
tooenc_ "Entrez la valeur" "$UTF8" 1>&2
|
||
fi
|
||
if [ -n "$__rv_readline" ]; then
|
||
tooenc_ ": " "$UTF8" 1>&2
|
||
uread -e ${__rv_d:+-i"$__rv_d"} "${__rv_opts[@]}" __rv_r
|
||
else
|
||
if [ -n "$__rv_d" ]; then
|
||
if [ -n "$__rv_showdef" ]; then
|
||
tooenc_ " [$__rv_d]" 1>&2
|
||
else
|
||
tooenc_ " [****]" 1>&2
|
||
fi
|
||
fi
|
||
tooenc_ ": " "$UTF8" 1>&2
|
||
uread "${__rv_opts[@]}" __rv_r
|
||
[ -n "$__rv_nl" ] && echo
|
||
fi
|
||
__rv_r="${__rv_r:-$__rv_d}"
|
||
if [ -n "$__rv_r" ] || ! is_yes "$__rv_re"; then
|
||
set_var "$__rv_v" "$__rv_r"
|
||
return 0
|
||
fi
|
||
done
|
||
}
|
||
function simple_menu() {
|
||
# Afficher un menu simple dont les éléments sont les valeurs du tableau
|
||
# $2(=options). L'option choisie est placée dans la variable $1(=option)
|
||
# -t TITLE: spécifier le titre du menu
|
||
# -m YOUR_CHOICE: spécifier le message d'invite pour la sélection de l'option
|
||
# -d DEFAULT: spécifier l'option par défaut. Par défaut, prendre la valeur
|
||
# actuelle de la variable $1(=option)
|
||
local __sm_title= __sm_yourchoice= __sm_default=
|
||
local -a __sm_args
|
||
parse_opts -t: __sm_title= -m: __sm_yourchoice= -d: __sm_default= @ __sm_args -- "$@" &&
|
||
set -- "${__sm_args[@]}" || ewarn "$__sm_args"
|
||
|
||
local __sm_option_var="${1:-option}" __sm_options_var="${2:-options}"
|
||
local __sm_option __sm_options
|
||
__sm_options="$__sm_options_var[*]"
|
||
if [ -z "${!__sm_options}" ]; then
|
||
OENC="$UTF8" eerror "Le tableau $__sm_options_var doit être non vide"
|
||
return 1
|
||
fi
|
||
[ -z "$__sm_default" ] && __sm_default="${!__sm_option_var}"
|
||
|
||
eflush
|
||
array_copy __sm_options "$__sm_options_var"
|
||
local __sm_c=0 __sm_i __sm_choice
|
||
while true; do
|
||
if [ "$__sm_c" == "0" ]; then
|
||
# Afficher le menu
|
||
[ -n "$__sm_title" ] && tooenc "=== $__sm_title ===" 1>&2
|
||
__sm_i=1
|
||
for __sm_option in "${__sm_options[@]}"; do
|
||
if [ "$__sm_option" == "$__sm_default" ]; then
|
||
tooenc "$__sm_i*- $__sm_option" 1>&2
|
||
else
|
||
tooenc "$__sm_i - $__sm_option" 1>&2
|
||
fi
|
||
let __sm_i=$__sm_i+1
|
||
done
|
||
fi
|
||
|
||
# Afficher les choix
|
||
if [ -n "$__sm_yourchoice" ]; then
|
||
tooenc_ "$__sm_yourchoice" 1>&2
|
||
else
|
||
tooenc_ "Entrez le numéro de l'option choisie" "$UTF8" 1>&2
|
||
fi
|
||
tooenc_ ": " "$UTF8" 1>&2
|
||
uread __sm_choice
|
||
|
||
# Valeur par défaut
|
||
if [ -z "$__sm_choice" -a -n "$__sm_default" ]; then
|
||
__sm_option="$__sm_default"
|
||
break
|
||
fi
|
||
# Vérifier la saisie
|
||
if [ -n "$__sm_choice" -a -z "${__sm_choice//[0-9]/}" ]; then
|
||
if [ "$__sm_choice" -gt 0 -a "$__sm_choice" -le "${#__sm_options[*]}" ]; then
|
||
__sm_option="${__sm_options[$(($__sm_choice - 1))]}"
|
||
break
|
||
else
|
||
OENC="$UTF8" eerror "Numéro d'option incorrect"
|
||
fi
|
||
else
|
||
OENC="$UTF8" eerror "Vous devez saisir le numéro de l'option choisie"
|
||
fi
|
||
|
||
let __sm_c=$__sm_c+1
|
||
if [ "$__sm_c" -eq 5 ]; then
|
||
# sauter une ligne toutes les 4 tentatives
|
||
tooenc "" "$UTF8" 1>&2
|
||
__sm_c=0
|
||
fi
|
||
done
|
||
set_var "$__sm_option_var" "$__sm_option"
|
||
}
|
||
|
||
function actions_menu() {
|
||
# Afficher un menu dont les éléments sont les valeurs du tableau $4(=options),
|
||
# et une liste d'actions tirées du tableau $3(=actions). L'option choisie est
|
||
# placée dans la variable $2(=option). L'action choisie est placée dans la
|
||
# variable $1(=action)
|
||
# Un choix est saisi sous la forme [action]num_option
|
||
# -t TITLE: spécifier le titre du menu
|
||
# -m OPT_YOUR_CHOICE: spécifier le message d'invite pour la sélection de
|
||
# l'action et de l'option
|
||
# -M ACT_YOUR_CHOICE: spécifier le message d'invite dans le cas où aucune option
|
||
# n'est disponible. Dans ce cas, seules les actions vides sont possibles.
|
||
# -e VOID_ACTION: spécifier qu'une action est vide, c'est à dire qu'elle ne
|
||
# requière pas d'être associée à une option. Par défaut, la dernière action
|
||
# est classée dans cette catégorie puisque c'est l'action "quitter"
|
||
# -d DEFAULT_ACTION: choisir l'action par défaut. par défaut, c'est la première
|
||
# action.
|
||
# -q QUIT_ACTION: choisir l'option "quitter" qui provoque la sortie du menu sans
|
||
# choix. par défaut, c'est la dernière action.
|
||
# -o DEFAULT_OPTION: choisir l'option par défaut. par défaut, prendre la valeur
|
||
# actuelle de la variable $2(=option)
|
||
local -a __am_action_descs __am_options __am_void_actions
|
||
local __am_tmp __am_select_action __am_select_option __am_title __am_optyc __am_actyc
|
||
local __am_default_action=auto __am_quit_action=auto
|
||
local __am_default_option=
|
||
local -a __am_args
|
||
parse_opts \
|
||
-t: __am_title= \
|
||
-m: __am_optyc= \
|
||
-M: __am_actyc= \
|
||
-e: __am_void_actions \
|
||
-d: __am_default_action= \
|
||
-q: __am_quit_action= \
|
||
-o: __am_default_option= \
|
||
@ __am_args -- "$@" && set -- "${__am_args[@]}" || { eerror "$__am_args"; return 1; }
|
||
|
||
__am_tmp="${1:-action}"; __am_select_action="${!__am_tmp}"
|
||
__am_tmp="${2:-option}"; __am_select_option="${!__am_tmp}"
|
||
[ -n "$__am_default_option" ] && __am_select_option="$__am_default_option"
|
||
array_copy __am_action_descs "${3:-actions}"
|
||
array_copy __am_options "${4:-options}"
|
||
|
||
eerror_unless [ ${#__am_action_descs[*]} -gt 0 ] "Vous devez spécifier le tableau des actions" || return
|
||
__actions_menu || return 1
|
||
setv "${1:-action}" "$__am_select_action"
|
||
setv "${2:-option}" "$__am_select_option"
|
||
}
|
||
function __actions_menu() {
|
||
local title="$__am_title"
|
||
local optyc="$__am_optyc" actyc="$__am_actyc"
|
||
local default_action="$__am_default_action"
|
||
local quit_action="$__am_quit_action"
|
||
local select_action="$__am_select_action"
|
||
local select_option="$__am_select_option"
|
||
local -a action_descs options void_actions
|
||
array_copy action_descs __am_action_descs
|
||
array_copy options __am_options
|
||
array_copy void_actions __am_void_actions
|
||
|
||
# Calculer la liste des actions valides
|
||
local no_options
|
||
array_isempty options && no_options=1
|
||
|
||
local -a actions
|
||
local tmp action name
|
||
for tmp in "${action_descs[@]}"; do
|
||
splitfsep2 "$tmp" : action name
|
||
[ -n "$action" ] || action="${name:0:1}"
|
||
action="$(strlower "$action")"
|
||
array_addu actions "$action"
|
||
done
|
||
|
||
# Calculer l'action par défaut
|
||
if [ "$default_action" == auto ]; then
|
||
# si action par défaut non spécifiée, alors prendre la première action
|
||
default_action="$select_action"
|
||
if [ -n "$default_action" ]; then
|
||
array_contains actions "$default_action" || default_action=
|
||
fi
|
||
[ -n "$default_action" ] || default_action="${actions[0]}"
|
||
fi
|
||
default_action="${default_action:0:1}"
|
||
default_action="$(strlower "$default_action")"
|
||
|
||
# Calculer l'action quitter par défaut
|
||
if [ "$quit_action" == auto ]; then
|
||
# si action par défaut non spécifiée, alors prendre la dernière action,
|
||
# s'il y a au moins 2 actions
|
||
if [ ${#actions[*]} -gt 1 ]; then
|
||
quit_action="${actions[@]:$((-1)):1}"
|
||
array_addu void_actions "$quit_action"
|
||
fi
|
||
fi
|
||
quit_action="${quit_action:0:1}"
|
||
quit_action="$(strlower "$quit_action")"
|
||
|
||
# Calculer la ligne des actions à afficher
|
||
local action_title
|
||
for tmp in "${action_descs[@]}"; do
|
||
splitfsep2 "$tmp" : action name
|
||
[ -n "$action" ] || action="${name:0:1}"
|
||
[ -n "$name" ] || name="$action"
|
||
action="$(strlower "$action")"
|
||
if [ -n "$no_options" ]; then
|
||
if ! array_contains void_actions "$action"; then
|
||
array_del actions "$action"
|
||
continue
|
||
fi
|
||
fi
|
||
[ "$action" == "$default_action" ] && name="$name*"
|
||
action_title="${action_title:+$action_title/}$name"
|
||
done
|
||
if [ -n "$default_action" ]; then
|
||
# si action par défaut invalide, alors pas d'action par défaut
|
||
array_contains actions "$default_action" || default_action=
|
||
fi
|
||
if [ -n "$quit_action" ]; then
|
||
# si action quitter invalide, alors pas d'action quitter
|
||
array_contains actions "$quit_action" || quit_action=
|
||
fi
|
||
|
||
# Type de menu
|
||
if [ -n "$no_options" ]; then
|
||
if array_isempty void_actions; then
|
||
eerror "Aucune option n'est définie. Il faut définir le tableau des actions vides"
|
||
return 1
|
||
fi
|
||
__void_actions_menu
|
||
else
|
||
__options_actions_menu
|
||
fi
|
||
}
|
||
function __void_actions_menu() {
|
||
eflush
|
||
local c=0 choice
|
||
while true; do
|
||
if [ $c -eq 0 ]; then
|
||
[ -n "$title" ] && __etitle "$title" 1>&2
|
||
__eecho_ "=== Actions disponibles: " 1>&2
|
||
tooenc "$action_title" 1>&2
|
||
fi
|
||
if [ -n "$actyc" ]; then
|
||
__eecho_ "$actyc" 1>&2
|
||
elif [ -n "$optyc" ]; then
|
||
__eecho_ "$optyc" 1>&2
|
||
else
|
||
__eecho_ "Entrez l'action à effectuer" 1>&2
|
||
fi
|
||
tooenc_ ": " 1>&2
|
||
uread choice
|
||
if [ -z "$choice" -a -n "$default_action" ]; then
|
||
select_action="$default_action"
|
||
break
|
||
fi
|
||
|
||
# vérifier la saisie
|
||
choice="${choice:0:1}"
|
||
choice="$(strlower "$choice")"
|
||
if array_contains actions "$choice"; then
|
||
select_action="$choice"
|
||
break
|
||
elif [ -n "$choice" ]; then
|
||
eerror "$choice: action incorrecte"
|
||
else
|
||
eerror "vous devez saisir l'action à effectuer"
|
||
fi
|
||
let c=$c+1
|
||
if [ $c -eq 5 ]; then
|
||
# sauter une ligne toutes les 4 tentatives
|
||
tooenc "" 1>&2
|
||
c=0
|
||
fi
|
||
done
|
||
__am_select_action="$select_action"
|
||
__am_select_option=
|
||
}
|
||
function __options_actions_menu() {
|
||
eflush
|
||
local c=0 option choice action option
|
||
while true; do
|
||
if [ $c -eq 0 ]; then
|
||
[ -n "$title" ] && __etitle "$title" 1>&2
|
||
i=1
|
||
for option in "${options[@]}"; do
|
||
if [ "$option" == "$select_option" ]; then
|
||
tooenc "$i*- $option" 1>&2
|
||
else
|
||
tooenc "$i - $option" 1>&2
|
||
fi
|
||
let i=$i+1
|
||
done
|
||
__estepn_ "Actions disponibles: " 1>&2
|
||
tooenc "$action_title" 1>&2
|
||
fi
|
||
if [ -n "$optyc" ]; then
|
||
__eecho_ "$optyc" 1>&2
|
||
else
|
||
__eecho_ "Entrez l'action et le numéro de l'option choisie" 1>&2
|
||
fi
|
||
tooenc_ ": " 1>&2
|
||
uread choice
|
||
|
||
# vérifier la saisie
|
||
if [ -z "$choice" -a -n "$default_action" ]; then
|
||
action="$default_action"
|
||
if array_contains void_actions "$action"; then
|
||
select_action="$action"
|
||
select_option=
|
||
break
|
||
elif [ -n "$select_option" ]; then
|
||
select_action="$action"
|
||
break
|
||
fi
|
||
fi
|
||
action="${choice:0:1}"
|
||
action="$(strlower "$action")"
|
||
if array_contains actions "$action"; then
|
||
# on commence par un code d'action valide. cool :-)
|
||
if array_contains void_actions "$action"; then
|
||
select_action="$action"
|
||
select_option=
|
||
break
|
||
else
|
||
option="${choice:1}"
|
||
option="${option// /}"
|
||
if [ -z "$option" -a -n "$select_option" ]; then
|
||
select_action="$action"
|
||
break
|
||
elif [ -z "$option" ]; then
|
||
eerror "vous devez saisir le numéro de l'option"
|
||
elif isnum "$option"; then
|
||
if [ $option -gt 0 -a $option -le ${#options[*]} ]; then
|
||
select_action="$action"
|
||
select_option="${options[$(($option - 1))]}"
|
||
break
|
||
fi
|
||
else
|
||
eerror "$option: numéro d'option incorrecte"
|
||
fi
|
||
fi
|
||
elif isnum "$choice"; then
|
||
# on a simplement donné un numéro d'option
|
||
action="$default_action"
|
||
if [ -n "$action" ]; then
|
||
if array_contains void_actions "$action"; then
|
||
select_action="$action"
|
||
select_option=
|
||
break
|
||
else
|
||
option="${choice// /}"
|
||
if [ -z "$option" ]; then
|
||
eerror "vous devez saisir le numéro de l'option"
|
||
elif isnum "$option"; then
|
||
if [ $option -gt 0 -a $option -le ${#options[*]} ]; then
|
||
select_action="$action"
|
||
select_option="${options[$(($option - 1))]}"
|
||
break
|
||
fi
|
||
else
|
||
eerror "$option: numéro d'option incorrecte"
|
||
fi
|
||
fi
|
||
else
|
||
eerror "Vous devez spécifier l'action à effectuer"
|
||
fi
|
||
elif [ -n "$choice" ]; then
|
||
eerror "$choice: action et/ou option incorrecte"
|
||
else
|
||
eerror "vous devez saisir l'action à effectuer"
|
||
fi
|
||
let c=$c+1
|
||
if [ $c -eq 5 ]; then
|
||
# sauter une ligne toutes les 4 tentatives
|
||
tooenc "" 1>&2
|
||
c=0
|
||
fi
|
||
done
|
||
__am_select_action="$select_action"
|
||
__am_select_option="$select_option"
|
||
}
|
||
|
||
################################################################################
|
||
## fichiers temporaires
|
||
|
||
# autoclean: gérer une liste de fichiers temporaires à supprimer en fin de
|
||
# programme
|
||
function __ac_forgetall() { __ac_files=(); }
|
||
__ac_forgetall
|
||
function __ac_trap() {
|
||
local file
|
||
for file in "${__ac_files[@]}"; do
|
||
[ -e "$file" ] && rm -rf "$file" 2>/dev/null
|
||
done
|
||
__ac_forgetall
|
||
}
|
||
trap __ac_trap 1 3 15 EXIT
|
||
function autoclean() {
|
||
# Ajouter $1..$n à la liste des fichiers à supprimer à la fin du programme
|
||
local file
|
||
for file in "$@"; do
|
||
[ -n "$file" ] && array_add __ac_files "$file"
|
||
done
|
||
}
|
||
function ac_cleanall() {
|
||
# Supprimer *tous* les fichiers temporaires gérés par autoclean tout de suite.
|
||
__ac_trap
|
||
}
|
||
function ac_clean() {
|
||
# Supprimer les fichier temporaires $1..$* si et seulement s'ils ont été générés
|
||
# par ac_set_tmpfile ou ac_set_tmpdir
|
||
local file
|
||
for file in "$@"; do
|
||
if array_contains __ac_files "$file"; then
|
||
[ -e "$file" ] && rm -rf "$file" 2>/dev/null
|
||
array_del __ac_files "$file"
|
||
fi
|
||
done
|
||
}
|
||
function ac_set_tmpfile() {
|
||
# Créer un fichier temporaire avec le motif $2, l'ajouter à la liste des
|
||
# fichiers à supprimer en fin de programme, et mettre sa valeur dans la
|
||
# variable $1
|
||
# En mode debug, si ($5 est vide ou ${!5} est une valeur vraie), et si $3 n'est
|
||
# pas vide, prendre ce fichier au lieu de générer un nouveau fichier
|
||
# temporaire. Si $4==keep, ne pas écraser le fichier $3 s'il existe.
|
||
local __acst_d
|
||
if show_debug; then
|
||
if [ -n "$5" ]; then
|
||
is_yes "${!5}" && __acst_d=1
|
||
else
|
||
__acst_d=1
|
||
fi
|
||
fi
|
||
if [ -n "$__acst_d" -a -n "$3" ]; then
|
||
set_var "$1" "$3"
|
||
[ -f "$3" -a "$4" == keep ] || >"$3"
|
||
else
|
||
local __acst_t="$(mktempf "$2")"
|
||
autoclean "$__acst_t"
|
||
set_var "$1" "$__acst_t"
|
||
fi
|
||
}
|
||
function ac_set_tmpdir() {
|
||
# Créer un répertoire temporaire avec le motif $2, l'ajouter à la liste des
|
||
# fichiers à supprimer en fin de programme, et mettre sa valeur dans la
|
||
# variable $1
|
||
# En mode debug, si ($4 est vide ou ${!4} est une valeur vraie), et si $3 n'est
|
||
# pas vide, prendre ce nom de répertoire au lieu de créer un nouveau répertoire
|
||
# temporaire
|
||
local __acst_d
|
||
if show_debug; then
|
||
if [ -n "$4" ]; then
|
||
is_yes "${!4}" && __acst_d=1
|
||
else
|
||
__acst_d=1
|
||
fi
|
||
fi
|
||
if [ -n "$__acst_d" -a -n "$3" ]; then
|
||
set_var "$1" "$3"
|
||
mkdir -p "$3"
|
||
else
|
||
local __acst_t="$(mktempd "$2")"
|
||
autoclean "$__acst_t"
|
||
set_var "$1" "$__acst_t"
|
||
fi
|
||
}
|
||
function debug_tee() {
|
||
# En mode debug, passer le flux à travers la commande 'tee "$@"'. Sinon, le flux
|
||
# est passé inchangé.
|
||
if show_debug; then
|
||
tee "$@"
|
||
else
|
||
cat
|
||
fi
|
||
}
|
||
|
||
################################################################################
|
||
## environnement
|
||
|
||
function get_defaults_files() {
|
||
# Initialiser le tableau $1(=defaults) avec la liste des fichiers qui seraient
|
||
# chargés par la commande 'set_defaults $2..N'
|
||
local __gd_dest="${1:-defaults}"; shift
|
||
local -a __gd_fs
|
||
local __gd_f __gd_found
|
||
for __gd_f in "$@"; do
|
||
__gd_found=
|
||
if [ -r "/etc/default/$__gd_f" ]; then
|
||
__gd_fs=("${__gd_fs[@]}" "/etc/default/$__gd_f")
|
||
__gd_found=1
|
||
fi
|
||
if [ -r "$HOME/etc/default.${HOSTNAME%%.*}/$__gd_f" ]; then
|
||
__gd_fs=("${__gd_fs[@]}" "$HOME/etc/default.${HOSTNAME%%.*}/$__gd_f")
|
||
__gd_found=1
|
||
elif [ -r "$HOME/etc/default/$__gd_f" ]; then
|
||
__gd_fs=("${__gd_fs[@]}" "$HOME/etc/default/$__gd_f")
|
||
__gd_found=1
|
||
fi
|
||
if [ -z "$__gd_found" -a -r "$scriptdir/lib/default/$__gd_f" ]; then
|
||
# si pas de fichier dans /etc/default ni dans ~/etc/default,
|
||
# utiliser $scriptdir/lib/default/$arg en dernier lieu
|
||
__gd_fs=("${__gd_fs[@]}" "$scriptdir/lib/default/$__gd_f")
|
||
fi
|
||
done
|
||
array_copy "$__gd_dest" __gd_fs
|
||
}
|
||
|
||
function set_defaults() {
|
||
# Pour chaque argument, sourcer /etc/default/$arg *et* (en priorité
|
||
# ~/etc/default.$HOSTNAME/$arg ou à défaut ~/etc/default/$arg) si ceux-ci
|
||
# existent. *Sinon*, lire $scriptdir/lib/default/$arg si ce fichier existe
|
||
local -a __sd_fs
|
||
local __sd_f
|
||
get_defaults_files __sd_fs "$@"
|
||
for __sd_f in "${__sd_fs[@]}"; do
|
||
source "$__sd_f"
|
||
done
|
||
}
|
||
|
||
################################################################################
|
||
## Informations sur le système local
|
||
|
||
# Nom d'hôte respectivement avec et sans domaine
|
||
# contrairement à $HOSTNAME, cette valeur peut être spécifiée, comme par ruinst
|
||
: "${MYHOST:=$HOSTNAME}"
|
||
: "${MYHOSTNAME:=${MYHOST%%.*}}"
|
||
export MYHOST MYHOSTNAME
|
||
|
||
function myhost() {
|
||
# Afficher le nom d'hôte pleinement qualifié, en faisant appel à la commande
|
||
# hostname. Par comparaison, $MYHOST est fourni par bash.
|
||
hostname -f 2>/dev/null || echo "$MYHOST"
|
||
}
|
||
function myhostname() {
|
||
# Afficher le nom d'hôte sans domaine, en faisant appel à la commande
|
||
# hostname. Par comparaison, $MYHOSTNAME est fourni par bash.
|
||
hostname -s 2>/dev/null || echo "$MYHOSTNAME"
|
||
}
|