1827 lines
55 KiB
Bash
1827 lines
55 KiB
Bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
##################################################
|
|
# Gestion des fichiers
|
|
|
|
function filter_conf() {
|
|
# filtrer un fichier de configuration en enlevant les commentaires et les lignes vides
|
|
# $1==-m fusionner les lignes qui se terminent par \
|
|
local merge=cat
|
|
if [ "$1" == -m ]; then
|
|
merge='awk '\''substr($0, length($0)) == "\\" { while (substr($0, length($0)) == "\\") { getline nextline; $0 = substr($0, 1, length($0) - 1) nextline }; print; next } {print}'\'
|
|
fi
|
|
grep -v '^#' | grep -v '^$' | eval "$merge"
|
|
}
|
|
|
|
##################################################
|
|
# Gestion des fichiers et répertoires temporaires
|
|
function make_tempfile() {
|
|
# $1=template du fichier à créer
|
|
local mktmpdir=
|
|
if [ "$1" == "-d" ]; then
|
|
shift
|
|
mktmpdir=1
|
|
fi
|
|
local template="${1:-$TMPDIR/tmp.XXXXXX}"
|
|
local base="${template%%X*}"
|
|
local XXXs="${template#$base}"
|
|
[ -z "$XXXs" ] && XXXs="XXXXXX"
|
|
local nbX="${#XXXs}"
|
|
|
|
local n="$$0" suff
|
|
while true; do
|
|
suff="$n"
|
|
while [ ${#suff} -lt $nbX ]; do suff="0$suff"; done
|
|
|
|
tempfile="$base$suff"
|
|
if [ -n "$mktmpdir" ]; then
|
|
# répertoire temporaire
|
|
if [ ! -d "$tempfile" ]; then
|
|
mkdir "$tempfile"
|
|
break
|
|
fi
|
|
else
|
|
# fichier temporaire
|
|
if [ ! -f "$tempfile" ]; then
|
|
touch "$tempfile"
|
|
break
|
|
fi
|
|
fi
|
|
|
|
n=$(($n + 1))
|
|
done
|
|
|
|
echo "$tempfile"
|
|
}
|
|
|
|
# autoclean: gérer une liste de fichiers temporaires à supprimer en fin de programme
|
|
__ac_files=()
|
|
function __ac_trap() {
|
|
local file_
|
|
for file_ in "${__ac_files[@]}"; do
|
|
[ -e "$file_" ] && rm -rf "$file_"
|
|
done
|
|
}
|
|
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_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
|
|
local tmpfile_="$(mktempf "$2")"
|
|
autoclean "$tmpfile_"
|
|
set_var "$1" "$tmpfile_"
|
|
}
|
|
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
|
|
local tmpdir_="$(mktempd "$2")"
|
|
autoclean "$tmpdir_"
|
|
set_var "$1" "$tmpdir_"
|
|
}
|
|
|
|
##################################################
|
|
# args: gestion d'un ensemble d'arguments
|
|
|
|
function read_args() {
|
|
# Lire les arguments et les mettre sur plusieurs lignes dans la variable
|
|
# dont le nom est donné dans $1. Ceci permet de façon fiable de traiter des
|
|
# arguments avec des espaces dedans.
|
|
|
|
# note: cela suppose bien sûr que les arguments ne contiennent pas de retour
|
|
# à la ligne!!!
|
|
if [ -z "$1" ]; then return 1; fi
|
|
|
|
local varname_="$1"; shift
|
|
local args_ arg_
|
|
|
|
for arg_ in "$@"; do
|
|
args_="${args_:+$args_
|
|
}$arg_"
|
|
done
|
|
set_var "$varname_" "$args_"
|
|
}
|
|
|
|
function next_arg() {
|
|
# Soit la variable args dont le nom est donné dans $1, et la variable next
|
|
# dont le nom est donné dans $2. Mettre à jour next avec la première ligne
|
|
# de la variable args. Mettre à jour args avec le reste des lignes.
|
|
if [ -z "$1" -o -z "$2" ]; then return 1; fi
|
|
|
|
local args_="$1"
|
|
local arg_="$2"
|
|
local line_ first_=1 first_line_ last_lines_
|
|
|
|
eval "$((echo "${!args_}"; echo "---<eof>---") | while read line_; do
|
|
if [ "$line_" == "---<eof>---" ]; then
|
|
echo "first_line_=\"$(quote_arg "$first_line_")\"
|
|
last_lines_=\"$(echo "$last_lines_" | awk '/.+/ { print; next }' | quote_string)\""
|
|
elif [ -n "$first_" ]; then
|
|
first_=
|
|
first_line_="$line_"
|
|
else
|
|
last_lines_="$last_lines_
|
|
$line_"
|
|
fi
|
|
done)"
|
|
set_var "$args_" "$last_lines_"
|
|
set_var "$arg_" "$first_line_"
|
|
if [ -z "$first_line_" ]; then return 1; fi
|
|
}
|
|
|
|
function get_option() {
|
|
# $1 est un argument de la forme "option:value"
|
|
# $2 est une liste d'options valides, séparées par des espaces
|
|
# $3 est un suffixe à rajouter au nom de variable
|
|
|
|
# Si $1 est une option valide (de la forme 'option:value' avec option
|
|
# faisant partie de la liste (optionnelle) des options valides) alors mettre
|
|
# à jour la variable $option avec la valeur value. sinon, retourner un code
|
|
# d'erreur
|
|
|
|
local arg_="$1"
|
|
local valid_options_="$2" valid_option_ is_valid_ option_ value_
|
|
local suffix_="$3"
|
|
|
|
option_="$(expr "$arg_" : "\(..*\):")"
|
|
[ -z "$option_" ] && return 1
|
|
|
|
if [ -n "$2" ]; then
|
|
# vérifier que $option est valide
|
|
is_valid_=
|
|
for valid_option_ in $valid_options_; do
|
|
if [ "$option_" == "$valid_option_" ]; then
|
|
is_valid_=1
|
|
break
|
|
fi
|
|
done
|
|
[ -z "$is_valid_" ] && return 1
|
|
fi
|
|
|
|
value_="${1##$option_:}"
|
|
set_var "$option_$suffix_" "$value_"
|
|
}
|
|
|
|
##################################################
|
|
# input: fonctions pour poser des question et saisir des valeurs
|
|
|
|
function ask_yesno() {
|
|
# $1=message, $2=default (N par défaut)
|
|
# Afficher le message $message suivi de [oN] ou [On] suivant que $default
|
|
# vaut O ou N. Retourner 0 si la réponse est oui, 1 sinon
|
|
|
|
# Si default vaut C, alors la valeur par défaut dépend du niveau
|
|
# d'interactivité: N si on est interactif et O si on est pas interactif
|
|
|
|
# Support de l'affichage de la question suivant le niveau d'interaction
|
|
# et/ou de verbosité Le message ne sera affiché que si le niveau
|
|
# d'interaction (ou de verbosité) courant est supérieur ou égal à celui qui
|
|
# est spécifié en argument. Sinon, la valeur par défaut est retournée
|
|
local r
|
|
check_verbosity "$1"; r=$?; [ $r -le 1 ] && shift
|
|
|
|
local message="$1"
|
|
local prompt="[oN]"
|
|
local default="${2:-N}"
|
|
if [ "$default" == "C" ]; then
|
|
if [ $r -ne 1 ]; then
|
|
default=N
|
|
else
|
|
default=O
|
|
fi
|
|
fi
|
|
is_yes "$default" && prompt="[On]"
|
|
|
|
if [ $r -ne 1 ]; then
|
|
if [ -n "$message" ]; then
|
|
tooenc_ "$message"
|
|
else
|
|
tooenc_ "Voulez-vous continuer?" "$UTF8"
|
|
fi
|
|
echo_ " $prompt "
|
|
uread r
|
|
else
|
|
r=
|
|
fi
|
|
|
|
is_yes "${r:-$default}"
|
|
}
|
|
|
|
function read_value() {
|
|
# $1=message, $2=varname, $3=default, $4=refuse_empty
|
|
# Afficher le message $message suivi la valeur par défaut [$default] si elle
|
|
# est non vide, puis lire la valeur donnée par l'utilisateur. Cette valeur
|
|
# doit être non vide si $refuse_empty est vrai (ce qui est le cas par
|
|
# défaut)
|
|
# La valeur saisie est placée dans la variable $varname (par défaut value)
|
|
|
|
# note: les variables locales sont suffixées de _ pour éviter que $varname
|
|
# soit égal à une des variables locales.
|
|
|
|
# Support l'affichage de la question suivant le niveau de "verbosité"
|
|
# Le message ne sera affiché que si le niveau de verbosité courant est
|
|
# supérieur ou égal à celui qui est spécifié en argument. Sinon, la valeur
|
|
# par défaut est retournée. (note: si l'utilisateur requière que la valeur
|
|
# soit non vide et que la valeur par défaut est vide, le script s'arrête
|
|
# avec une erreur)
|
|
local r_
|
|
check_verbosity "$1"; r_=$?; [ $r_ -le 1 ] && shift
|
|
|
|
local message_="$1"
|
|
local varname_="${2:-value}"
|
|
local default_="$3"
|
|
local refuse_empty_="${4:-O}"
|
|
|
|
local read_value_=
|
|
if [ $r_ -ne 1 ]; then
|
|
read_value_=1
|
|
elif [ -z "$default_" ] && is_yes "$refuse_empty_"; then
|
|
read_value_=1
|
|
fi
|
|
|
|
if [ -n "$read_value_" ]; then
|
|
while true; do
|
|
if [ -n "$message_" ]; then
|
|
tooenc_ "$message_"
|
|
else
|
|
tooenc_ "Entrez la valeur" "$UTF8"
|
|
fi
|
|
[ -n "$default_" ] && tooenc_ " [$default_]"
|
|
echo_ ": "
|
|
uread r_; r_="${r_:-$default_}"
|
|
if [ -n "$r_" ] || ! is_yes "$refuse_empty_"; then
|
|
set_var "$varname_" "$r_"
|
|
return 0
|
|
fi
|
|
done
|
|
else
|
|
if [ -z "$default_" ] && is_yes "$refuse_empty_"; then
|
|
OENC="$UTF8" die "La valeur par défaut de $varname_ doit être non vide"
|
|
else
|
|
set_var "$varname_" "$default_"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
##################################################
|
|
# menu: fonctions afficher un menu
|
|
|
|
function simple_menu() {
|
|
# $1=option_varname
|
|
# $2=options (une par ligne)
|
|
# $3..*=votre_choix:, titre_du_menu:, choix_par_defaut:
|
|
|
|
# Afficher un menu dont les membres sont les lignes de $options. Un choix
|
|
# doit être saisi sous la forme num_option. L'option choisie est placée dans
|
|
# la variable $option_varname
|
|
|
|
# note: les variables locales sont suffixées de _ pour éviter que
|
|
# $option_varname soit égal à une des variables locales.
|
|
|
|
local tab_=" " # contient une tabulation
|
|
local i_ c_
|
|
local options_one_by_line_ options_ option_
|
|
local choice_ choice_option_
|
|
local option_varname_
|
|
local votre_choix_ titre_du_menu_ choix_par_defaut_
|
|
|
|
# nom de la variable destination
|
|
option_varname_="$1"; shift
|
|
if [ -z "$option_varname_" ]; then
|
|
OENC="$UTF8" eerror "option_varname doit être spécifié"
|
|
return 1
|
|
fi
|
|
choix_par_defaut_="${!option_varname_}"
|
|
|
|
# Construire le tableau des options
|
|
options_one_by_line_="$1"; shift
|
|
if [ -z "$options_one_by_line_" ]; then
|
|
OENC="$UTF8" eerror "options doit être non vide"
|
|
return 1
|
|
fi
|
|
i_=0
|
|
while next_arg options_one_by_line_ option_; do
|
|
options_[$i_]="$option_"
|
|
i_=$(($i_ + 1))
|
|
done
|
|
|
|
# autres paramètres
|
|
while [ -n "$1" ]; do
|
|
! get_option "$1" "votre_choix titre_du_menu choix_par_defaut" _ && break
|
|
shift
|
|
done
|
|
|
|
c_=0
|
|
while true; do
|
|
if [ "$c_" == "0" ]; then
|
|
# Afficher le menu
|
|
[ -n "$titre_du_menu_" ] && tooenc "=== $titre_du_menu_ ==="
|
|
i_=1
|
|
for option_ in "${options_[@]}"; do
|
|
if [ "$option_" == "$choix_par_defaut_" ]; then
|
|
echo "$i_*- $option_"
|
|
else
|
|
echo "$i_ - $option_"
|
|
fi
|
|
i_=$(($i_ + 1))
|
|
done
|
|
fi
|
|
|
|
# Afficher les choix
|
|
if [ -n "$votre_choix_" ]; then
|
|
tooenc_ "$votre_choix_"
|
|
else
|
|
tooenc_ "Entrez le numéro de l'option choisie" "$UTF8"
|
|
fi
|
|
echo_ ": "
|
|
uread choice_
|
|
|
|
# valeur par défaut
|
|
if [ -z "$choice_" -a -n "$choix_par_defaut_" ]; then
|
|
choice_option_="$choix_par_defaut_"
|
|
break
|
|
fi
|
|
# vérifier la saisie
|
|
choice_option_="$(expr "$choice_" : "[ $tab_]*\([0-9]*\)")"
|
|
if [ -n "$choice_option_" ] && [ "$choice_option_" -gt "0" -a "$choice_option_" -le "${#options_[*]}" ]; then
|
|
# numéro d'option correct
|
|
choice_option_="${options_[$(($choice_option_ - 1))]}"
|
|
break
|
|
else
|
|
OENC="$UTF8" eerror "Numéro d'option incorrect"
|
|
fi
|
|
|
|
c_=$(($c_ + 1))
|
|
if [ "$c_" == "5" ]; then
|
|
echo "" # sauter une ligne toutes les 4 tentatives
|
|
c_=0
|
|
fi
|
|
done
|
|
|
|
set_var "$option_varname_" "$choice_option_"
|
|
}
|
|
|
|
function actions_menu() {
|
|
# $1=action_varname, $2=option_varname
|
|
# $3=actions (séparées par des espaces), $4=options (une par ligne)
|
|
# $5..*=action_quitter:, action_par_defaut:, actions_vides:, votre_choix:,
|
|
# titre_du_menu:, message_sans_options:
|
|
|
|
# Afficher un menu dont les membres sont les lignes de $options. Sur
|
|
# chacunes de ces entrées de menu, les actions de $actions peuvent être
|
|
# appliquées. Un choix doit être saisi sous la forme [action]num_option. Si
|
|
# action n'est pas précisé, il s'agit de l'action par défaut qui est
|
|
# sélectionnée. Par défaut, action_par_defaut est la première action, et
|
|
# action_quitter (qui provoque la sortie du menu sans choix) est la dernière
|
|
# action
|
|
|
|
# actions est une chaine d'éléments de la forme "k:Description" séparés par
|
|
# des espaces, où k est un lettre, et Description une description de
|
|
# l'action. Dans la chaine Description, les caractères '_' sont remplacés
|
|
# par des espaces pour l'affichage
|
|
|
|
# l'action choisie est placée dans la variable $action_varname. l'option
|
|
# choisie est placée dans la variable $option_varname
|
|
|
|
# note: les variables locales sont suffixées de _ pour éviter que
|
|
# $action_varname ou $option_varname soient égals à une des variables
|
|
# locales.
|
|
|
|
local tab_=" " # contient une tabulation
|
|
local i_ c_ error_displayed_
|
|
local options_one_by_line_ options_ option_
|
|
local actions_sep_by_space_ actions_ action_ action_key_ action_name_ action_names_
|
|
local actions_vides_ action_vide_
|
|
local action_quitter_
|
|
local action_par_defaut_
|
|
local choice_ choice_ok_ choice_action_ choice_option_
|
|
local action_varname_ option_varname_
|
|
local sans_options_ message_sans_options_
|
|
|
|
action_varname_="$1"; shift
|
|
option_varname_="$1"; shift
|
|
if [ -z "$action_varname_" -o -z "$option_varname_" ]; then
|
|
OENC="$UTF8" eerror "action_varname et option_varname doivent être spécifiés"
|
|
return 1
|
|
fi
|
|
|
|
# actions possibles
|
|
actions_sep_by_space_="$1"; shift
|
|
if [ -z "$actions_sep_by_space_" ]; then
|
|
OENC="$UTF8" eerror "actions doit être non vide"
|
|
return 1
|
|
fi
|
|
|
|
# Construire le tableau des options
|
|
options_one_by_line_="$1"; shift
|
|
if [ -n "$options_one_by_line_" ]; then
|
|
i_=0
|
|
while next_arg options_one_by_line_ option_; do
|
|
options_[$i_]="$option_"
|
|
i_=$(($i_ + 1))
|
|
done
|
|
else
|
|
sans_options_=1
|
|
fi
|
|
|
|
# autres paramètres
|
|
while [ -n "$1" ]; do
|
|
! get_option "$1" "actions_vides action_quitter action_par_defaut votre_choix titre_du_menu message_sans_options" _ && break
|
|
shift
|
|
done
|
|
if [ -n "$sans_options_" -a -z "$actions_vides_" ]; then
|
|
OENC="$UTF8" eerror "options doit être non vide"
|
|
return 1
|
|
fi
|
|
|
|
# Construire le tableau des actions
|
|
i_=0
|
|
for action_ in $actions_sep_by_space_; do
|
|
action_key_="$(first_char "$action_")"
|
|
action_="$(last_chars "$action_")"
|
|
if [ "$(first_char "$action_")" == ":" ]; then
|
|
action_name_="$(last_chars "$action_")"
|
|
action_name_="${action_name_//_/ }"
|
|
else
|
|
action_name_="$action_key_"
|
|
fi
|
|
|
|
[ -z "$action_par_defaut_" ] && action_par_defaut_="$action_key_"
|
|
[ "$action_key_" == "$action_par_defaut_" ] && action_name_="$action_name_*"
|
|
action_names_="${action_names_:+$action_names_/}$action_name_"
|
|
|
|
actions_[$i_]="$(echo $action_key_ | awk '{print tolower($0)}')"
|
|
i_=$(($i_ + 1))
|
|
done
|
|
[ -z "$action_quitter_" ] && action_quitter_="$action_key_"
|
|
if [ "$action_par_defaut_" == "$action_quitter_" ]; then
|
|
OENC="$UTF8" eerror "action_par_defaut et action_quitter doivent être différents"
|
|
return 1
|
|
fi
|
|
actions_vides_="$actions_vides_ $action_quitter_"
|
|
|
|
# Lecture des choix de l'utilisateur
|
|
c_=0
|
|
while true; do
|
|
if [ "$c_" == "0" ]; then
|
|
# Afficher le menu
|
|
[ -n "$titre_du_menu_" ] && tooenc "=== $titre_du_menu_ ==="
|
|
if [ -z "$sans_options_" ]; then
|
|
i_=1
|
|
for option_ in "${options_[@]}"; do
|
|
tooenc "$i_ - $option_"
|
|
i_=$(($i_ + 1))
|
|
done
|
|
else
|
|
if [ -n "$message_sans_options_" ]; then
|
|
tooenc "$message_sans_options_"
|
|
else
|
|
tooenc "Pas d'options disponibles" "$UTF8"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Afficher les choix
|
|
tooenc_ "
|
|
Actions disponibles: " "$UTF8"
|
|
tooenc "$action_names_"
|
|
if [ -n "$votre_choix_" ]; then
|
|
tooenc_ "$votre_choix_"
|
|
else
|
|
tooenc_ "Entrez le numéro de l'option choisie" "$UTF8"
|
|
fi
|
|
echo_ ": "
|
|
read choice_
|
|
|
|
# vérifier la saisie
|
|
choice_option_="$(expr "$choice_" : "\([0-9]*\)")"
|
|
if [ -n "$choice_option_" ]; then
|
|
# on a donné le numéro de l'option sans l'action. retourner l'action par défaut
|
|
if [ -z "$sans_options_" -a "$choice_option_" -gt "0" -a "$choice_option_" -le "${#options_[*]}" ]; then
|
|
# numéro d'option correct
|
|
choice_option_="${options_[$(($choice_option_ - 1))]}"
|
|
choice_action_="$action_par_defaut_"
|
|
break
|
|
else
|
|
OENC="$UTF8" eerror "Numéro d'option incorrect"
|
|
fi
|
|
|
|
else
|
|
choice_action_="$(expr "$choice_" : "\([^ $tab_]\)")"
|
|
choice_ok_=
|
|
error_displayed_=
|
|
for action_ in "${actions_[@]}"; do
|
|
if [ "$choice_action_" == "$action_" ]; then
|
|
# action correcte
|
|
|
|
# est-ce une action vide (une action qui ne requière pas de numéro d'option)
|
|
for action_vide_ in $actions_vides_; do
|
|
if [ "$choice_action_" == "$action_vide_" ]; then
|
|
# retourner comme option tous les arguments de
|
|
# l'action vide, en trimant les espaces de début
|
|
choice_option_="$(expr "$choice_" : "[^ $tab_][ $tab_]*\(.*\)")"
|
|
choice_ok_=1
|
|
break
|
|
fi
|
|
done
|
|
[ -n "$choice_ok_" ] && break
|
|
|
|
# lire le numéro d'option associé à l'action
|
|
choice_option_="$(expr "$choice_" : "[^ $tab_][ $tab_]*\([0-9]*\)")"
|
|
if [ -n "$choice_option_" ] && [ "$choice_option_" -gt "0" -a "$choice_option_" -le "${#options_[*]}" ]; then
|
|
# numéro d'option correct
|
|
choice_option_="${options_[$(($choice_option_ - 1))]}"
|
|
choice_ok_=1
|
|
else
|
|
OENC="$UTF8" eerror "Il faut spécifier un numéro d'option correct avec l'action"
|
|
error_displayed_=1
|
|
fi
|
|
[ -n "$choice_ok_" ] && break
|
|
fi
|
|
done
|
|
[ -n "$choice_ok_" ] && break
|
|
[ -z "$error_displayed_" ] && OENC="$UTF8" eerror "Action incorrecte"
|
|
fi
|
|
|
|
c_=$(($c_ + 1))
|
|
if [ "$c_" == "5" ]; then
|
|
echo "" # sauter une ligne toutes les 4 tentatives
|
|
c_=0
|
|
fi
|
|
done
|
|
|
|
set_var "$action_varname_" "$choice_action_"
|
|
set_var "$option_varname_" "$choice_option_"
|
|
}
|
|
|
|
##################################################
|
|
# fileopts: opérations sur les fichiers
|
|
|
|
function file_get_vars() {
|
|
# lire les variables dans un fichier
|
|
local OENC="$UTF8"
|
|
local done_ prefix_ whole_file_ file_ vars_ var_ script_
|
|
|
|
# traiter les arguments
|
|
done_=
|
|
while [ -z "$done_" ]; do
|
|
case "$1" in
|
|
--prefix|-p)
|
|
# prefixe pour la variable
|
|
prefix_="$2"
|
|
shift; shift
|
|
;;
|
|
--whole-file|-w)
|
|
# lire les variables dans le fichier en entier, et pas seulement
|
|
# dans l'en-tête.
|
|
whole_file_=1
|
|
shift
|
|
;;
|
|
*)
|
|
done_=1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# obtenir le nom du fichier
|
|
file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
# fichier inexistant
|
|
ewarn "Fichier inexistant: $file_"
|
|
return 1
|
|
fi
|
|
|
|
# initialiser les valeurs par défaut
|
|
vars_=
|
|
while [ -n "$1" ]; do
|
|
var_="$1"; shift
|
|
vars_="${vars_:+$vars_ }$var_"
|
|
set_var "$var_" "$1"; shift
|
|
done
|
|
|
|
# puis parcourir le fichier pour initialiser la valeur définitive des
|
|
# variables
|
|
if [ -z "$whole_file_" ]; then
|
|
script_="/^ *$/ { exit }
|
|
"
|
|
fi
|
|
|
|
for var_ in $vars_; do
|
|
script_="$script_
|
|
"'$0 ~ "^ *#* *" prefix "'"$var_"'=" {
|
|
# enlever les caractères inutiles
|
|
sub(" *#* *" prefix "'"$var_"'=", "")
|
|
# enlever éventuellement les quotes autour de la valeur
|
|
if ($0 ~ /^".*" *$/) {
|
|
$0 = substr($0, 2) # premier quote
|
|
match($0, /" *$/)
|
|
$0 = substr($0, 1, RSTART - 1) # dernier quote
|
|
}
|
|
# remplacer dans les valeurs les occurences de quotes
|
|
gsub("\"", "\\\"")
|
|
# afficher la ligne à évaluer
|
|
print "'"$var_"'=\"" $0 "\""
|
|
}
|
|
'
|
|
done
|
|
|
|
eval "$(uawk -v prefix="$prefix_" "$script_" <"$file_")"
|
|
}
|
|
|
|
function file_set_vars() {
|
|
# écrire les variables dans un fichier. Le fichier *doit exister*
|
|
local OENC="$UTF8"
|
|
local done_ quote_ comment_ prefix_ whole_file_ file_ var_ script_
|
|
|
|
# traiter les arguments
|
|
done_=
|
|
while [ -z "$done_" ]; do
|
|
case "$1" in
|
|
--quote-always|-q)
|
|
# toujours mettre les valeurs entre quotes
|
|
quote_=1
|
|
shift
|
|
;;
|
|
--comment-prefix|-c)
|
|
# commentaire à préfixer
|
|
comment_="$2"
|
|
shift; shift
|
|
;;
|
|
--prefix|-p)
|
|
# prefixe pour la variable
|
|
prefix_="$2"
|
|
shift; shift
|
|
;;
|
|
--whole-file|-w)
|
|
# écrire les variables dans le fichier en entier, et pas seulement
|
|
# dans l'en-tête.
|
|
whole_file_=1
|
|
shift
|
|
;;
|
|
*)
|
|
done_=1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# obtenir le nom du fichier
|
|
file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
# fichier inexistant
|
|
ewarn "Fichier inexistant: $file_"
|
|
return 1
|
|
fi
|
|
|
|
# puis parcourir le fichier pour mettre à jour les valeurs
|
|
script_='BEGIN {
|
|
# faut-il mettre à jour les variables?
|
|
update_vars = 1'
|
|
for var_ in "$@"; do
|
|
script_="$script_
|
|
${var_}_done = 0"
|
|
done
|
|
script_="$script_
|
|
}"
|
|
|
|
script_="$script_"'
|
|
function quote_value_maybe(value) {
|
|
if (quote_always || index(value, " ") != 0) {
|
|
return "\"" value "\""
|
|
} else {
|
|
return value
|
|
}
|
|
}
|
|
|
|
function write_all_remaining_vars() {'
|
|
for var_ in "$@"; do
|
|
value="${!var_}"
|
|
script_="$script_"'
|
|
if (! '"$var_"'_done) {
|
|
print comment prefix "'"$var_"'=" quote_value_maybe("'"${value//\"/\\\"}"'")
|
|
'"$var_"'_done = 1
|
|
}'
|
|
done
|
|
script_="$script_
|
|
}"
|
|
|
|
if [ -z "$whole_file_" ]; then
|
|
script_="$script_"'
|
|
/^[ \t]*$/ {
|
|
write_all_remaining_vars()
|
|
update_vars = 0
|
|
}'
|
|
fi
|
|
|
|
script_="$script_"'
|
|
update_vars && comment == "" && $0 ~ "^ *#* *.*=.*$" {
|
|
#comment = gensub("^( *#* *).*=.*$", "\\1", 1)
|
|
comment = ""
|
|
if (match($0, /^ *#* */) != 0) {
|
|
comment = substr($0, RSTART, RLENGTH)
|
|
}
|
|
}'
|
|
|
|
for var_ in "$@"; do
|
|
value="${!var_}"
|
|
script_="$script_"'
|
|
update_vars && ! '"$var_"'_done && $0 ~ "^ *#* *" prefix "'"$var_"'=" {
|
|
#$0 = gensub("^( *#* *" prefix "'"$var_"'=).*$", "\\1", 1)
|
|
match($0, "^ *#* *" prefix "'"$var_"'=")
|
|
$0 = substr($0, RSTART, RLENGTH)
|
|
$0 = $0 quote_value_maybe("'"${value//\"/\\\"}"'")
|
|
print
|
|
'"$var_"'_done = 1
|
|
next
|
|
}'
|
|
done
|
|
|
|
script_="$script_"'
|
|
{
|
|
print
|
|
}
|
|
END {
|
|
if (update_vars) {
|
|
write_all_remaining_vars()
|
|
}
|
|
}'
|
|
|
|
uawk -v quote_always="$quote_" -v comment="$comment_" -v prefix="$prefix_" "$script_" <"$file_" >"$file_.$$" &&
|
|
/bin/mv "$file_.$$" "$file_"
|
|
}
|
|
|
|
function file_get_properties() {
|
|
# lire les propriétés d'un fichier de propriété java ou xml
|
|
if endswith "$1" .xml; then
|
|
file_get_xml_properties "$@"
|
|
else
|
|
file_get_java_properties "$@"
|
|
fi
|
|
}
|
|
|
|
function file_set_properties() {
|
|
# écrire les propriétés d'un fichier de propriété java ou xml
|
|
local done_ create_
|
|
while [ -z "$done_" ]; do
|
|
case "$1" in
|
|
--create|-c)
|
|
create_=1
|
|
shift
|
|
;;
|
|
*)
|
|
done_=1
|
|
;;
|
|
esac
|
|
done
|
|
if endswith "$1" .xml; then
|
|
file_set_xml_properties ${create_:+-c} "$@"
|
|
else
|
|
file_set_java_properties ${create_:+-c} "$@"
|
|
fi
|
|
}
|
|
|
|
|
|
function file_get_java_properties() {
|
|
# lire les propriétés d'un fichier de propriétés java. note: les noms de
|
|
# propriété java peuvent contenir le caractère "." mais pas les noms de
|
|
# variable bash. La conversion est faite automatiquement. Par exemple::
|
|
# file_get_properties build.properties path.to.package "default value"
|
|
# charge la valeur de la propriété dans la variable path_to_package
|
|
|
|
# $1=nom du fichier de propriété
|
|
# $2..n=propriétés qu'il faut lire et valeurs par défaut de ces propriétés
|
|
# $__2*i __=nom de la propriété
|
|
# $__2*i+1__=valeur par défaut de la propriété si la valeur n'existe pas
|
|
# dans le fichier
|
|
local OENC="$UTF8"
|
|
local file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
# fichier inexistant
|
|
ewarn "Fichier de propriété inexistant: $file_"
|
|
return 1
|
|
fi
|
|
|
|
local var_ sh_var_ awk_var_
|
|
local script
|
|
while [ -n "$1" ]; do
|
|
# pour chacune des variables...
|
|
var_="$1"; shift
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
|
|
# initialiser la valeur par défaut
|
|
set_var "$sh_var_" "$1"; shift
|
|
|
|
# et créer le script qui affichera sa valeur
|
|
script="$script"'
|
|
$0 ~ "^[ \t]*'"$(quote_awk "$awkre_var_")"'=" {
|
|
# enlever les caractères de début
|
|
sub("^[ \t]*'"$(quote_awk "$awkre_var_")"'=", "")
|
|
value = $0
|
|
# éventuellement ajouter les lignes de continuation
|
|
while (substr(value, length(value), 1) == "\\") {
|
|
getline
|
|
sub("^[ \t]*", "")
|
|
value = substr(value, 1, length(value) - 1) $0
|
|
}
|
|
gsub("\"", "\\\"", value)
|
|
print "'"$sh_var_"'=\"" value "\""
|
|
}
|
|
'
|
|
done
|
|
|
|
eval "$(awk "$script" <"$file_")"
|
|
}
|
|
|
|
function file_set_java_properties() {
|
|
# écrire des propriétés dans un fichier de propriétés java.
|
|
|
|
# $1=nom du fichier de propriété
|
|
# $2..n=propriétés qu'il faut écrire et valeurs de ces propriétés
|
|
# $__2*i __=nom de la propriété
|
|
# $__2*i+1__=valeur de la propriété
|
|
# traiter les arguments
|
|
local OENC="$UTF8"
|
|
local done_ create_
|
|
while [ -z "$done_" ]; do
|
|
case "$1" in
|
|
--create|-c)
|
|
# créer le fichier s'il n'existe pas
|
|
create_=1
|
|
shift
|
|
;;
|
|
*)
|
|
done_=1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
if [ -n "$create_" ]; then
|
|
touch "$file_"
|
|
else
|
|
# fichier inexistant
|
|
ewarn "Fichier de propriété inexistant: $file_"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
# récupérer les noms des propriétés et leur valeur
|
|
local var_ arg_ sh_var_ awkre_var_ value_
|
|
local -a vars_ values_
|
|
value_=vars_
|
|
for arg_ in "$@"; do
|
|
array_add "$value_" "$arg_"
|
|
if [ "$value_" == "vars_" ]; then
|
|
value_=values_
|
|
else
|
|
value_=vars_
|
|
fi
|
|
done
|
|
|
|
# créer le script qui va parcourir le fichier pour mettre à jour les valeurs
|
|
script_="BEGIN {"
|
|
for var_ in "${vars_[@]}"; do
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
script_="$script_
|
|
${sh_var_}_done = 0"
|
|
done
|
|
script_="$script_"'
|
|
}
|
|
function write_all_remaining_vars() {'
|
|
local i=0
|
|
while [ $i -lt ${#vars_[*]} ]; do
|
|
var_="${vars_[$i]}"
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
value_="${values_[$i]}"
|
|
|
|
script_="$script_"'
|
|
if (! '"$sh_var_"'_done) {
|
|
print "'"$var_"'=" "'"${value_//\"/\\\"}"'"
|
|
'"$sh_var_"'_done = 1
|
|
}'
|
|
i=$((i + 1))
|
|
done
|
|
script_="$script_
|
|
}"
|
|
|
|
local i=0
|
|
while [ $i -lt ${#vars_[*]} ]; do
|
|
var_="${vars_[$i]}"
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
value_="${values_[$i]}"
|
|
script_="$script_"'
|
|
! '"$sh_var_"'_done && $0 ~ "^[ \t]*'"$awkre_var_"'=" {
|
|
#name = gensub("^([ \t]*'"$awkre_var_"'=).*$", "\\1", 1)
|
|
match($0, "^[ \t]*'"$awkre_var_"'=")
|
|
name = substr($0, RSTART, RLENGTH)
|
|
value = substr($0, length(name) + 1)
|
|
|
|
while (substr(value, length(value), 1) == "\\") {
|
|
getline
|
|
value = value $0
|
|
}
|
|
line = name "'"${value_//\"/\\\"}"'"
|
|
prefix = ""
|
|
max_len = 75
|
|
if (length(line) > max_len) {
|
|
do {
|
|
print prefix substr(line, 1, max_len) "\\"
|
|
line = substr(line, max_len + 1)
|
|
prefix = " "
|
|
max_len = 71
|
|
} while (length(line) > max_len)
|
|
}
|
|
print prefix line
|
|
'"$sh_var_"'_done = 1
|
|
next
|
|
}'
|
|
i=$((i + 1))
|
|
done
|
|
|
|
script_="$script_
|
|
{
|
|
print
|
|
}
|
|
END {
|
|
write_all_remaining_vars()
|
|
}"
|
|
|
|
awk "$script_" <"$file_" >"$file_.$$" &&
|
|
/bin/mv "$file_.$$" "$file_"
|
|
}
|
|
|
|
function file_get_xml_properties() {
|
|
# lire les propriétés d'un fichier de propriétés xml. Limitation: les
|
|
# propriétés ne doivent pas être continuées sur plusieurs lignes. Les
|
|
# propriétés doivent être écrites sous la forme::
|
|
# <propname>propvalue</propname>
|
|
|
|
# note: les noms de propriété java peuvent contenir le caractère "." mais
|
|
# pas les noms de variable bash. La conversion est faite
|
|
# automatiquement. Par exemple::
|
|
# file_get_properties build.properties path.to.package "default value"
|
|
# charge la valeur de la propriété dans la variable path_to_package
|
|
|
|
# $1=nom du fichier de propriété
|
|
# $2..n=propriétés qu'il faut lire et valeurs par défaut de ces propriétés
|
|
# $__2*i __=nom de la propriété
|
|
# $__2*i+1__=valeur par défaut de la propriété si la valeur n'existe pas
|
|
# dans le fichier
|
|
local OENC="$UTF8"
|
|
local file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
# fichier inexistant
|
|
ewarn "Fichier de propriété inexistant: $file_"
|
|
return 1
|
|
fi
|
|
|
|
local var_ sh_var_ awk_var_
|
|
local script
|
|
while [ -n "$1" ]; do
|
|
# pour chacune des variables...
|
|
var_="$1"; shift
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
|
|
# initialiser la valeur par défaut
|
|
set_var "$sh_var_" "$1"; shift
|
|
|
|
# et créer le script qui affichera sa valeur
|
|
script="$script"'
|
|
$0 ~ /^[ \t]*<'"$awkre_var_"'>.*<\/'"$awkre_var_"'>/ {
|
|
sub(/^[ \t]*<'"$awkre_var_"'>/, "")
|
|
sub(/<\/'"$awkre_var_"'>.*$/, "")
|
|
gsub("\"", "\\\"", $0)
|
|
print "'"$sh_var_"'=\"" $0 "\""
|
|
}
|
|
'
|
|
done
|
|
|
|
eval "$(awk "$script" <"$file_")"
|
|
}
|
|
|
|
function file_set_xml_properties() {
|
|
# écrire des propriétés dans un fichier de propriétés java.
|
|
|
|
# $1=nom du fichier de propriété
|
|
# $2..n=propriétés qu'il faut écrire et valeurs de ces propriétés
|
|
# $__2*i __=nom de la propriété
|
|
# $__2*i+1__=valeur de la propriété
|
|
# traiter les arguments
|
|
local OENC="$UTF8"
|
|
local done_ create_
|
|
while [ -z "$done_" ]; do
|
|
case "$1" in
|
|
--create|-c)
|
|
# créer le fichier s'il n'existe pas
|
|
create_=1
|
|
shift
|
|
;;
|
|
*)
|
|
done_=1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
local file_="$1"; shift
|
|
if [ ! -f "$file_" ]; then
|
|
if [ -n "$create_" ]; then
|
|
touch "$file_"
|
|
else
|
|
# fichier inexistant
|
|
ewarn "Fichier de propriété inexistant: $file_"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
# récupérer les noms des propriétés et leur valeur
|
|
local var_ arg_ sh_var_ awkre_var_ value_
|
|
local -a vars_ values_
|
|
value_=vars_
|
|
for arg_ in "$@"; do
|
|
array_add "$value_" "$arg_"
|
|
if [ "$value_" == "vars_" ]; then
|
|
value_=values_
|
|
else
|
|
value_=vars_
|
|
fi
|
|
done
|
|
|
|
# créer le script qui va parcourir le fichier pour mettre à jour les valeurs
|
|
script_='BEGIN {
|
|
rootElement = ""'
|
|
for var_ in "${vars_[@]}"; do
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
script_="$script_
|
|
${sh_var_}_done = 0"
|
|
done
|
|
script_="$script_"'
|
|
}
|
|
function write_all_remaining_vars() {'
|
|
local i=0
|
|
while [ $i -lt ${#vars_[*]} ]; do
|
|
var_="${vars_[$i]}"
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
value_="${values_[$i]}"
|
|
|
|
script_="$script_"'
|
|
if (! '"$sh_var_"'_done) {
|
|
print "<'"$var_"'>'"${value_//\"/\\\"}"'</'"$var_"'>"
|
|
'"$sh_var_"'_done = 1
|
|
}'
|
|
i=$((i + 1))
|
|
done
|
|
script_="$script_
|
|
}"'
|
|
rootElement == "" {
|
|
match($0, /<.*>/)
|
|
element = substr($0, RSTART + 1, RLENGTH - 2)
|
|
firstChar = substr(element, 1, 1)
|
|
if (firstChar != "?" && firstChar != "!") {
|
|
rootElement = element
|
|
}
|
|
}'
|
|
|
|
local i=0
|
|
while [ $i -lt ${#vars_[*]} ]; do
|
|
var_="${vars_[$i]}"
|
|
sh_var_="${var_//./_}" # nom de la variable shell traduite ("." --> "_")
|
|
sh_var_="${sh_var_//-/_}" # ("-" --> "_")
|
|
awkre_var_="${var_//./\\\\.}" # nom de la variable pour une expression régulière awk
|
|
value_="${values_[$i]}"
|
|
script_="$script_"'
|
|
rootElement != "" && ! '"$sh_var_"'_done && $0 ~ /^[ \t]*<'"$awkre_var_"'>.*<\/'"$awkre_var_"'>/ {
|
|
match($0, /^[ \t]*<'"$awkre_var_"'>/)
|
|
first = substr($0, RSTART, RLENGTH)
|
|
value = substr($0, length(first) + 1)
|
|
match(value, /<\/'"$awkre_var_"'>.*$/)
|
|
last = substr(value, RSTART, RLENGTH)
|
|
value = substr(value, 1, RSTART)
|
|
|
|
print first "'"${value_//\"/\\\"}"'" last
|
|
'"$sh_var_"'_done = 1
|
|
next
|
|
}'
|
|
i=$((i + 1))
|
|
done
|
|
|
|
script_="$script_"'
|
|
rootElement != "" && $0 ~ "</" rootElement ">" {
|
|
rootElement = ""
|
|
write_all_remaining_vars()
|
|
}
|
|
{
|
|
print
|
|
}
|
|
END {
|
|
write_all_remaining_vars()
|
|
}'
|
|
|
|
awk "$script_" <"$file_" >"$file_.$$" &&
|
|
/bin/mv "$file_.$$" "$file_"
|
|
}
|
|
|
|
##################################################
|
|
# date: fonction pour afficher la date en français et au format RFC-822
|
|
|
|
function get_date_rfc822() {
|
|
if [ -n "$__legacy_date__" ]; then
|
|
LC_TIME=C date +"%a, %d %b %Y %H:%M:%S %Z"
|
|
else
|
|
date -R
|
|
fi
|
|
}
|
|
|
|
function get_date_fr() {
|
|
date +"%d/%m/%Y"
|
|
}
|
|
|
|
function get_time_fr() {
|
|
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 > 31) d = nd;
|
|
if ($2 == "") m = nm;
|
|
else { m = $2 + 0; if (m < 1 || m > 12) 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"
|
|
;;
|
|
*)
|
|
echo "$value"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
##################################################
|
|
# path: fonctions pour gérer les chemins
|
|
|
|
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.
|
|
local pwd="$(pwd)"
|
|
if [ -n "$2" ]; then
|
|
# tout d'abord, calculer le répertoire à partir duquel on exprime les
|
|
# chemin relatifs
|
|
if [ -d "$2" ]; then
|
|
pwd="$(cd "$2"; pwd)"
|
|
else
|
|
pwd="$(abspath "$2")"
|
|
fi
|
|
fi
|
|
|
|
if [ -e "$1" ]; then
|
|
local dn="$(dirname "$1")" bn="$(basename "$1")"
|
|
if [ "$bn" == "." ]; then
|
|
echo "$(cd "$pwd"; cd "$dn"; pwd)"
|
|
elif [ "$bn" == ".." ]; then
|
|
echo "$(cd "$pwd"; cd "$dn/.."; pwd)"
|
|
elif [ "$dn" == "/" ]; then
|
|
echo "/$bn"
|
|
else
|
|
echo "$(cd "$pwd"; cd "$dn"; pwd)/$bn"
|
|
fi
|
|
else
|
|
if first_char_is "$1" "/"; then
|
|
echo "$1"
|
|
else
|
|
echo "$pwd/$1"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function relpath() {
|
|
# Retourner 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
|
|
# répertoires 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
|
|
echo "${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 deref() {
|
|
# Retourner un chemin absolu vers le fichier $1, dans lequel
|
|
# toutes les composantes "lien symbolique" ont été supprimées.
|
|
local OENC="$UTF8"
|
|
|
|
local max_deref=50
|
|
local file="$1"
|
|
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 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
|
|
echo "$reldir_$file_"
|
|
else
|
|
echo "$basedir_/$file_"
|
|
fi
|
|
break
|
|
fi
|
|
shift
|
|
done
|
|
}
|
|
|
|
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%.tar.gz}"
|
|
name="${name%.tar}"
|
|
name="${name%.tar.bz2}"
|
|
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 indiquent les fichiers à extraire
|
|
local arch="$1" destdir="${2:-.}"
|
|
shift; shift
|
|
if endswith "$arch" .zip; then
|
|
unzip -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
|
|
jar xf "$arch" -C "$destdir" "$@" || return
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
|
|
##################################################
|
|
# array: fonctions pour gérer des tableaux
|
|
|
|
# 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
|
|
function set_array_cmd() {
|
|
[ $# -eq 1 ] && set -- "$1" "$1"
|
|
local s_ v_ f_
|
|
s_="$1=("; shift
|
|
if [ "$1" == "@" ]; then
|
|
shift
|
|
else
|
|
eval "set -- \"\${$1[@]}\""
|
|
fi
|
|
f_=1
|
|
for v_ in "$@"; do
|
|
[ -n "$f_" ] && f_= || s_="$s_ "
|
|
s_="$s_\"$(quote_arg "$v_")\""
|
|
done
|
|
s_="$s_)"
|
|
echo "$s_"
|
|
}
|
|
# 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
|
|
function set_array() {
|
|
eval "$(set_array_cmd "$@")"
|
|
}
|
|
|
|
function array_count() {
|
|
# retourner le nombre d'éléments du tableau $1
|
|
eval "echo \${#$1[*]}"
|
|
}
|
|
|
|
function array_isempty() {
|
|
# tester si un tableau est vide
|
|
test $(array_count "$1") -eq 0
|
|
}
|
|
|
|
function array_new() {
|
|
# créer un tableau vide dont le nom est $1
|
|
eval "$1=()"
|
|
}
|
|
|
|
function array_add() {
|
|
# ajouter la valeur $2 au tableau dont le nom est $1
|
|
eval "$1=(\"\${$1[@]}\" \"$(quote_arg "$2")\")"
|
|
}
|
|
|
|
# insérer la valeur $2 au début du tableau dont le nom est $1
|
|
function array_ins() { eval "$1=(\"$(quote_arg "$2")\" \"\${$1[@]}\")"; }
|
|
|
|
function array_add_values() {
|
|
# Ajouter les valeurs $2 au tableau dont le nom est $1
|
|
# $2 est une liste de valeurs séparées par des espaces ou le caractère ':'
|
|
local array_="$1" value_
|
|
if [[ "$2" == *:* ]]; then
|
|
local IFS=:
|
|
set -- $2
|
|
unset IFS
|
|
else
|
|
set -- $2
|
|
fi
|
|
for value_ in "$@"; do
|
|
array_add "$array_" "$value_"
|
|
done
|
|
}
|
|
|
|
function array_del() {
|
|
# supprimer les valeurs $2 du tableau dont le nom est $1
|
|
local arg_="$(quote_arg "$2")" value_
|
|
local -a array_
|
|
eval 'for value_ in "${'"$1"'[@]}"; do if [ "$value_" != "'"$arg_"'" ]; then array_add array_ "$value_"; fi; done'
|
|
array_copy "$1" array_
|
|
}
|
|
|
|
function array_set() {
|
|
# 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 value_="$(quote_arg "$2")" i_
|
|
eval "for i_ in \"\${$1[@]}\"; do if [ \"\$i_\" == \"$value_\" ]; then return 1; fi; done"
|
|
array_add "$1" "$2"
|
|
return 0
|
|
}
|
|
|
|
function array_contains() {
|
|
# tester si le tableau dont le nom est $1 contient la valeur $2
|
|
local value_="$(quote_arg "$2")" i_
|
|
eval "for i_ in \"\${$1[@]}\"; do if [ \"\$i_\" == \"$value_\" ]; then return; fi; done"
|
|
return 1
|
|
}
|
|
|
|
function array_copy() {
|
|
# copier le contenu du tableau $2 dans le tableau $1
|
|
eval "$1=(\"\${$2[@]}\")"
|
|
}
|
|
|
|
function array_extend() {
|
|
# Ajouter le contenu du tableau $2 au tableau $1
|
|
eval "$1=(\"\${$1[@]}\" \"\${$2[@]}\")"
|
|
}
|
|
# dans le tableau $1, remplacer toutes les occurences de $2 par $3..*
|
|
function array_replace() {
|
|
local srcname_="$1"; shift
|
|
local from_="$1"; shift
|
|
local -a dest_
|
|
local src_ v_
|
|
src_="$srcname_[@]"
|
|
for value_ in "${!src_}"; do
|
|
if [ "$value_" == "$from_" ]; then
|
|
dest_=("${dest_[@]}" "$@")
|
|
else
|
|
dest_=("${dest_[@]}" "$value_")
|
|
fi
|
|
done
|
|
array_copy "$srcname_" dest_
|
|
}
|
|
# Pour chacune des valeurs 'v' du tableau $1, appeler la fonction $2 avec les
|
|
# arguments '$v $3..$n'
|
|
function array_each() {
|
|
local an_="$1"; shift
|
|
local f_="$1"; shift
|
|
local a_="$an_[@]" v
|
|
for v_ in "${!a_}"; do
|
|
"$f_" "$v_" "$@"
|
|
done
|
|
}
|
|
# retourner la première valeur du tableau $1
|
|
function first_value() { eval "echo \"\${$1[@]:0:1}\""; }
|
|
# retourner la dernière valeur du tableau $1
|
|
function last_value() { eval "echo \"\${$1[@]:\$((-1)):1}\""; }
|
|
# copier le contenu du tableau $2 dans le tableau $1
|
|
function array_copy() { eval "$1=(\"\${$2[@]}\")"; }
|
|
# copier tous les valeurs du tableau $2(=$1) dans le tableau $1, excepté la dernière
|
|
function array_copy_firsts() { eval "$1=(\"\${${2:-$1}[@]:0:\$((\${#${2:-$1}[@]}-1))}\")"; }
|
|
function array_del_last() { array_copy_firsts "$1"; }
|
|
# copier tous les valeurs du tableau $2(=$1) dans le tableau $1, excepté la première
|
|
function array_copy_lasts() { eval "$1=(\"\${${2:-$1}[@]:1}\")"; }
|
|
function array_del_first() { array_copy_lasts "$1"; }
|
|
# ajouter le contenu du tableau $2 au tableau $1
|
|
function array_extend() { eval "$1=(\"\${$1[@]}\" \"\${$2[@]}\")"; }
|
|
# ajouter toutes les valeurs du tableau $2 dans le tableau $1, excepté la dernière
|
|
function array_extend_firsts() { eval "$1=(\"\${$1[@]}\" \"\${$2[@]:0:\$((\${#$2[@]}-1))}\")"; }
|
|
# ajouter toutes les valeurs du tableau $2 dans le tableau $1, excepté la première
|
|
function array_extend_lasts() { eval "$1=(\"\${$1[@]}\" \"\${$2[@]:1}\")"; }
|
|
# 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
|
|
function array_map() {
|
|
local an_="$1"; shift
|
|
local f_="$1"; shift
|
|
local a_="$an_[@]" v
|
|
local -a vs_
|
|
for v_ in "${!a_}"; do
|
|
vs_=("${vs_[@]}" "$("$f_" "$v_" "$@")")
|
|
done
|
|
array_copy "$an_" vs_
|
|
}
|
|
|
|
function array_from_args() {
|
|
# créer le tableau dont le nom est $1 avec les arguments à partir de $2
|
|
local array_="$1"; shift
|
|
eval "$array_"'=("$@")'
|
|
}
|
|
|
|
function array_from_file() {
|
|
# créer le tableau dont le nom est $1 avec les lignes du fichier $2
|
|
# si $3=all, ne pas supprimer les lignes vide ou de commentaire
|
|
eval "$(<"$2" uawk -v name="$1" -v all="$3" '
|
|
BEGIN {
|
|
print name "=("
|
|
}
|
|
all != "all" && $0 ~ /^$/ { next }
|
|
all != "all" && $0 ~ /^#/ { next }
|
|
{
|
|
gsub(/'\''/, "'\'\\\\\'\''")
|
|
print "'\''" $0 "'\''"
|
|
}
|
|
END {
|
|
print ")"
|
|
}')" #"
|
|
}
|
|
|
|
function array_from_lines() {
|
|
# créer le tableau $1 avec chaque ligne de $2. Les lignes vides sont
|
|
# ignorés.
|
|
eval "$(<<<"$2" uawk -v name="$1" '
|
|
BEGIN {
|
|
print name "=("
|
|
}
|
|
/^$/ { next }
|
|
{
|
|
gsub(/'\''/, "'\'\\\\\'\''")
|
|
print "'\''" $0 "'\''"
|
|
}
|
|
END {
|
|
print ")"
|
|
}')" #"
|
|
}
|
|
|
|
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 "$(<<<"$2" uawk -v RS="" -v ORS="" '{ gsub("\r*\n$", ""); print }' |
|
|
uawk -v name="$1" -v RS="${3:-:}" '
|
|
BEGIN {
|
|
print name "=("
|
|
}
|
|
/^$/ { next }
|
|
{
|
|
gsub(/'\''/, "'\'\\\\\'\''")
|
|
print "'\''" $0 "'\''"
|
|
}
|
|
END {
|
|
print ")"
|
|
}')" #"
|
|
}
|
|
|
|
function array_from_path() {
|
|
array_split "$1" "$2" ":"
|
|
}
|
|
|
|
function array_join() {
|
|
# afficher le contenu du tableau dont le nom est $1 sous forme d'une liste
|
|
# de chemins séparés par $2
|
|
# 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 array_ line_ joined_ sep_="${2:-,}" pfix_ sfix_
|
|
if [ "$1" == "@" ]; then
|
|
array_="\$@"
|
|
shift; shift
|
|
else
|
|
array_="\${$1[@]}"
|
|
pfix_="$4"
|
|
sfix_="$5"
|
|
fi
|
|
eval 'for line_ in "'"$array_"'"; do joined_="${joined_:+$joined_'"$sep_"'}$pfix_$line_$sfix_"; done'
|
|
if [ -n "$joined_" ]; then
|
|
echo "$joined_"
|
|
elif [ "$array_" != "\$@" -a -n "$3" ]; then
|
|
echo "$3"
|
|
fi
|
|
}
|
|
|
|
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_enum_start() {
|
|
# Commencer l'énumération du tableau $1
|
|
[ -z "$1" ] && return 1
|
|
set_var_literal "${1}_enum_index" 0
|
|
}
|
|
|
|
function array_enum_next() {
|
|
# Soit la variable array dont le nom est donné dans $1, et la variable next
|
|
# dont le nom est donné dans $2. Mettre à jour next avec l'élément
|
|
# $1_enum_index du tableau array, supprimer cet élément, et incrémenter
|
|
# $1_enum_index. Retourner faux s'il n'y a plus d'éléments dans le tableau
|
|
|
|
local arrayname_="$1" varname_="$2"
|
|
[ -z "$arrayname_" -o -z "$varname_" ] && return 1
|
|
|
|
eval "local count_=\${#$arrayname_[*]}"
|
|
[ $count_ -eq 0 ] && return 1
|
|
|
|
# calculer l'index de départ
|
|
local index_="${arrayname_}_enum_index"
|
|
[ -z "${!index_}" ] && set_var_literal "$index_" 0
|
|
# lire la valeur
|
|
local item_="$arrayname_[${!index_}]"
|
|
set_var "$varname_" "${!item_}"
|
|
# la supprimer du tableau
|
|
unset "$item_"
|
|
# incrémenter le compteur
|
|
set_var_literal "$index_" $((${!index_} + 1))
|
|
}
|
|
|
|
function __array_ls() {
|
|
# Lister les fichiers avec `list_$1 $3 $4...`, et les mettre dans le tableau $2
|
|
# Le tableau contient les chemins complets, par seulement les noms comme avec list_$1
|
|
local list_="list_${1:-all}"; shift
|
|
local arrayname_="$1"; shift
|
|
local basedir_="${1:-.}"; shift
|
|
local -a files_
|
|
array_from_lines files_ "$("$list_" "$basedir_" "$@")"
|
|
local file_
|
|
array_new "$arrayname_"
|
|
for file_ in "${files_[@]}"; do
|
|
array_add "$arrayname_" "$basedir_/$file_"
|
|
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 "$@"
|
|
}
|
|
|
|
##################################################
|
|
# Accès à une resource web
|
|
|
|
function _dumpurl_method_available() {
|
|
# $1=dumpurl_method
|
|
local m="$1"
|
|
if [ "$m" == "curl" ]; then
|
|
progexists curl || [ -n "$__curl_EXISTS__" ]
|
|
elif [ "$m" == "wget" ]; then
|
|
if progexists wget || [ -n "$__wget_EXISTS__" ]; then
|
|
# vérifier la version ce doit être >= 1.9
|
|
wget --version | grep "^GNU Wget" | awk '{
|
|
v = $0
|
|
major = 0
|
|
minor = 0
|
|
if (match(v, /[0-9][0-9]*/) != 0) {
|
|
major = substr(v, RSTART, RLENGTH) + 0
|
|
v = substr(v, RSTART + RLENGTH + 1)
|
|
}
|
|
if (match(v, /[0-9][0-9]*/) != 0) {
|
|
minor = substr(v, RSTART, RLENGTH) + 0
|
|
v = substr(v, RSTART + RLENGTH + 1)
|
|
}
|
|
|
|
if (major >= 1 && minor >= 9) {
|
|
exit 0
|
|
} else {
|
|
exit 1
|
|
}
|
|
}'
|
|
fi
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
function dumpurl_method() {
|
|
if [ -z "$DUMPURL_METHOD" ]; then
|
|
local DUMPURL_METHOD
|
|
if _dumpurl_method_available curl; then
|
|
DUMPURL_METHOD=curl
|
|
elif _dumpurl_method_available wget; then
|
|
DUMPURL_METHOD=wget
|
|
## XXX telnet non supporté pour le moment
|
|
#elif progexists telnet; then
|
|
# DUMPURL_METHOD=telnet
|
|
fi
|
|
fi
|
|
echo "$DUMPURL_METHOD"
|
|
}
|
|
|
|
function dumpurl_available() {
|
|
# retourner vrai si dumpurl est disponible (si wget ou curl sont trouvés)
|
|
_dumpurl_method_available "$(dumpurl_method)"
|
|
}
|
|
|
|
function dumpurl() {
|
|
# afficher le résultat du téléchargement de l'url $1, ou une chaine vide si
|
|
# une erreur s'est produite.
|
|
# l'option -m choisit la méthode: GET ou POST (suivi de la chaine à envoyer)
|
|
# l'option -H permet d'ajouter des en-têtes
|
|
|
|
local done= http_method=GET postdata headers header url no_proxy
|
|
local -a headers
|
|
while [ -n "$1" ]; do
|
|
case "$1" in
|
|
--)
|
|
shift
|
|
done=1
|
|
;;
|
|
|
|
-m)
|
|
shift
|
|
http_method="$1"
|
|
if [ "$http_method" == "POST" ]; then
|
|
postdata="$2"
|
|
shift
|
|
fi
|
|
;;
|
|
|
|
-H)
|
|
shift
|
|
array_add headers "$1: $2"
|
|
shift
|
|
;;
|
|
|
|
-X)
|
|
no_proxy=1
|
|
;;
|
|
|
|
-*)
|
|
#ewarn "option non reconnue: $1"
|
|
;;
|
|
|
|
*)
|
|
done=1
|
|
;;
|
|
esac
|
|
[ -n "$done" ] && break
|
|
shift
|
|
done
|
|
url="$1"
|
|
|
|
dumpurl_available || return 1
|
|
local dumpurl_method="$(dumpurl_method)"
|
|
|
|
if [ "$dumpurl_method" == "curl" ]; then
|
|
curl="curl${no_proxy:+ -x ''}"
|
|
for header in "${headers[@]}"; do
|
|
curl="$curl --header \"$(quote_arg "$header")\""
|
|
done
|
|
if [ "$http_method" == "GET" ]; then
|
|
:
|
|
elif [ "$http_method" == "POST" ]; then
|
|
curl="$curl --data-binary \"$(quote_arg "$postdata")\""
|
|
else
|
|
# méthode inconnue
|
|
return 1
|
|
fi
|
|
curl="$curl -f -s \"$(quote_arg "$url")\""
|
|
|
|
eval "$curl"
|
|
|
|
elif [ "$dumpurl_method" == "wget" ]; then
|
|
wget="wget${no_proxy:+ --no-proxy}"
|
|
for header in "${headers[@]}"; do
|
|
wget="$wget --header=\"$(quote_arg "$header")\""
|
|
done
|
|
if [ "$http_method" == "GET" ]; then
|
|
:
|
|
elif [ "$http_method" == "POST" ]; then
|
|
wget="$wget --post-data=\"$(quote_arg "$postdata")\""
|
|
else
|
|
# méthode inconnue
|
|
return 1
|
|
fi
|
|
wget="$wget -q -O - \"$(quote_arg "$url")\""
|
|
|
|
eval "$wget"
|
|
|
|
# XXX pas encore implémenté
|
|
#elif [ "$dumpurl_method" == "telnet" ]; then
|
|
# return 1
|
|
|
|
else
|
|
return 1
|
|
fi
|
|
}
|