modules
/
nutools
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
nutools/lib/uinst/system_caps.legacy

1480 lines
50 KiB
Plaintext
Raw Normal View History

importation initiale dans git
2013-08-27 15:14:44 +04:00
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
##@inc[../../legacy/sysinc/base
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
# base: fonctions et variables de base pour utilisation sous Linux. requière
# l'utilisation de bash
##@provide sysinc/basevars
# === Variables diverses ===
# répertoire temporaire
export TMPDIR="${TMPDIR:-${TMP:-${TEMP:-/tmp}}}"
# BASEHOST est le nom d'hote *sans* domaine
export BASEHOST="${HOSTNAME%%.*}"
# FQDNHOST est le nom d'hote avec le domaine
if [ "$BASEHOST" != "$HOSTNAME" ]; then
export FQDNHOST="$HOSTNAME"
else
export FQDNHOST="$HOSTNAME.$(dnsdomainname)"
fi
# emplacement du script courant
scriptname="$(basename -- "$0")"
scriptdir="$(cd "$(dirname -- "$0")"; pwd)"
script="$scriptdir/$scriptname"
# fonction pour charger automatiquement /etc/default/$name et ~/etc/default/$name
function set_defaults() {
local __f __s
for __f in "$@"; do
__s=
if [ -r "/etc/default/$__f" ]; then
source "/etc/default/$__f"
__s=1
fi
if [ -r "$HOME/etc/default/$__f" ]; then
source "$HOME/etc/default/$__f"
__s=1
fi
if [ -z "$__s" ]; then
# si pas de fichier dans ~/etc/default ni dans /etc/default, lire
# $scriptdir/lib/default/$scriptname en dernier lieu
if [ -r "$scriptdir/lib/default/$__f" ]; then
source "$scriptdir/lib/default/$__f"
fi
fi
done
}
# === diverses fonctions ===
function is_yes() {
# retourner vrai si $1 est une valeur "oui"
[ "$1" == "o" -o "$1" == "O" -o "$1" == "oui" -o "$1" == "OUI" ] && return 0
[ "$1" == "y" -o "$1" == "Y" -o "$1" == "yes" -o "$1" == "YES" ] && return 0
[ "$1" == "v" -o "$1" == "V" -o "$1" == "vrai" -o "$1" == "VRAI" ] && return 0
[ "$1" == "t" -o "$1" == "T" -o "$1" == "true" -o "$1" == "TRUE" ] && return 0
[ "$1" == "1" ] && return 0
return 1
}
function is_no() {
# retourner vrai si $1 est une valeur "non"
[ "$1" == "n" -o "$1" == "N" -o "$1" == "non" -o "$1" == "NON" ] && return 0
[ "$1" == "no" -o "$1" == "NO" ] && return 0
[ "$1" == "f" -o "$1" == "F" -o "$1" == "faux" -o "$1" == "FAUX" ] && return 0
[ "$1" == "false" -o "$1" == "FALSE" ] && return 0
[ "$1" == "0" ] && return 0
return 1
}
# retourner le premier caractère de la chaine $1
function first_char() { echo "${1:0:1}"; }
# retourner le dernier caractère de la chaine $1
function last_char() { echo "${1:$((-1)):1}"; }
# retourner tous les caractères de la chaine $1, excepté le dernier
function first_chars() { echo "${1:0:$((${#1}-1))}"; }
# retourner tous les caractères de la chaine $1, excepté le premier
function last_chars() { echo "${1:1}"; }
# Tester si le premier caractère de la chaine $1 est $2
function first_char_is() { test "${1:0:1}" = "$2"; }
# Tester si le dernier caractère de la chaine $1 est $2
function last_char_is() { test "${1:$((-1)):1}" = "$2"; }
# Tester si la chaine $1 commence par le wildcard $2
function beginswith() { eval 'test "${1#'"$(quote_arg "$2")"'}" != "$1"'; }
# Tester si la chaine $1 se termine par le wildcard $2
function endswith() { eval 'test "${1%'"$(quote_arg "$2")"'}" != "$1"'; }
# Dans la chaine $1, remplacer \ par \\, " par \" et $ par \$, et l'afficher
function quote_arg() {
local s
s="${1//\\/\\\\}"
s="${s//\"/\\\"}"
s="${s//$/\\$}"
echo "$s"
## ou:
#echo "$1" | awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
}
# Dans une chaine lue sur stdin, remplacer \ par \\, " par \" et $ par \$ et
# l'afficher
function quote_string() {
awk '{ gsub(/\\/, "\\\\"); gsub(/"/, "\\\""); gsub(/\$/, "\\$"); print }'
##ou:
#quote_arg "`cat`"
## mais cet dernière version est très lente sur un gros fichier
}
# Dans la chaine $1, remplacer '%' par '%25', '+' par '%2B', '&' par '%26', '=' par '%3D', ' ' par '+'
function quote_formvalue() {
local s="$1"
s="${s//\%/%25}"
s="${s//+/%2B}"
s="${s//&/%26}"
s="${s//=/%3D}"
s="${s// /+}"
echo "$s"
}
# Afficher le nombre de lignes d'un fichier
function get_nblines() {
[ -f "$1" ] && sed -ne '$=' "$1" || echo 0
}
# générer un fichier temporaire et retourner son nom
function mktempf() {
mktemp "${1:-"$TMPDIR/tmp.XXXXXX"}"
}
# générer un répertoire temporaire et retourner son nom
function mktempd() {
mktemp -d "${1:-"$TMPDIR/tmp.XXXXXX"}"
}
# Créer le répertoire correspondant à un fichier
function mkdirof() {
mkdir -p "$(dirname "$1")"
}
# dans la chaine $1, remplacer \ par \\ et " par \", et l'afficher. ceci est
# utile pour quoter des valeur à insérer dans un script awk
function quote_awk() {
local s
s="${1//\\\\/\\\\}"
s="${s//\"/\\\"}"
echo "$s"
}
# tester si gawk est disponible
function require_gawk() {
local OENC="$UTF8"
if [ -n "$__legacy_awk__" ]; then
ewarn "Cette fonction requière gnuawk"
return 1
fi
return 0
}
# lancer awk en essayant d'émuler des fonctionnalités de gnuawk (comme l'option
# -v et la fonction gensub (XXX à faire))
function uawk() {
if [ -z "$__legacy_awk__" ]; then
awk "$@"
else
# essayer d'émuler l'option -v
local script='BEGIN {'
local done=
while [ -n "$1" ]; do
case "$1" in
--)
shift
done=1
;;
-v)
shift
local name=${1%%=*}
local value=${1:$((${#name} + 1))}
if [ "$value" == "" ]; then
# valeur vide
script="$script
$name = \"\""
elif [ "${value//[0-9]*/}" == "" ]; then
# valeur numérique
script="$script
$name = $value"
else
# valeur alphanumérique
script="$script
$name = \"$(quote_awk "$value")\""
fi
;;
-*)
#ewarn "option non reconnue: $1"
;;
*)
done=1
;;
esac
[ -n "$done" ] && break
shift
done
script="$script
}
$1"
shift
awk "$script" "$@"
fi
}
# Retourner la commande permettant de donner à la variable ${!1} la valeur $2
function set_var_cmd() { echo "$1=\"$(quote_arg "$2")\""; }
# donner à la variable ${!1} la valeur $2
function set_var() { eval "$1=\"$(quote_arg "$2")\""; }
# donner à la variable ${!1} la valeur $2. on assume que les valeur sont déjà
# quotées comme il faut
function set_var_literal() { eval "$1=$2"; }
# copier en gardant le maximum de propriétés
function cp_a() { /bin/cp -a "$@"; }
# copier récursivement, en suivant les liens symboliques
function cp_R() { /bin/cp -pR "$@"; }
# supprimer les fichiers dont on donne éventuellement la liste
function rm_maybe() {
local parse_opts=1 arg rm
for arg in "$@"; do
# chercher s'il y a un argument autre que des options
if [ -n "$parse_opts" ]; then
if [ "$arg" == "--" ]; then
parse_opts=
elif [[ "$arg" == "-*" ]]; then
continue
elif [ -n "$arg" ]; then
rm=1
break
fi
elif [ -n "$arg" ]; then
rm=1
break
fi
done
[ -n "$rm" ] && /bin/rm "$@"
}
# lister les fichiers ou répertoires du répertoire $1, un par ligne
function list_all() {
# $1=un répertoire dont le contenu doit être listé
# $2..@=un ensemble de patterns pour le listage
local curdir="$(pwd)"
local b="${1:-.}"; shift
cd "$b" 2>/dev/null || return
eval "/bin/ls -1d ${*:-*} 2>/dev/null"
cd "$curdir"
}
# lister les fichiers du répertoire $1, un par ligne
function list_files() {
# $1=un répertoire dont le contenu doit être listé.
# $2..@=un ensemble de patterns pour le listage
local f
local curdir="$(pwd)"
local b="${1:-.}"; shift
cd "$b" 2>/dev/null || return
eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
[ -f "$f" ] && echo "$f"
done
cd "$curdir"
}
# lister les répertoires du répertoire $1, un par ligne
function list_dirs() {
# $1=un répertoire dont le contenu doit être listé.
# $2..@=un ensemble de patterns pour le listage
local f
local curdir="$(pwd)"
local b="${1:-.}"; shift
cd "$b" 2>/dev/null || return
eval "/bin/ls -1d ${*:-*} 2>/dev/null" | while read f; do
[ -d "$f" ] && echo "$f"
done
cd "$curdir"
}
# copier un fichier dans un répertoire, ou le contenu d'un répertoire dans un
# autre répertoire, que le répertoire source soit un lien symbolique ou
# non. Cette fonction existe parce que le comportement de "cp_a src dest" n'est
# pas consistant selon les plateformes, surtout si src est un lien symbolique
# sur un répertoire: parfois on copie le lien, parfois on copie le contenu du
# répertoire, parfois on copie le répertoire...
function cpdir() {
# $1=src, $2=dest, $3=method (cp_a par défaut)
local src="$1" dest="$2" method="${3:-cp_a}"
if [ -d "$src" ]; then
# si c'est un répertoire, traitement particulier
# tout d'abord, s'assurer que la destination existe
if [ ! -d "$dest" ]; then
mkdir -p "$dest"
fi
# ensuite on fait la copie
local prevdir="$(pwd)"
dest="$(abspath "$dest")" # XXX abspath défini dans functions!
cd "$src"
if [ -n "$(/bin/ls -a1)" ]; then
# copier les fichiers
[ -n "$(/bin/ls -1)" ] && "$method" * "$dest"
# ne pas oublier les fichiers cachés...
local i
for i in .*; do
[ "$i" == "." -o "$i" == ".." ] && continue
"$method" "$i" "$dest"
done
fi
cd "$prevdir"
else
# sinon, on assume que c'est un fichier
if [ -f "$dest" ]; then
# copie du fichier avec remplacement
"$method" "$src" "$dest"
elif [ -d "$dest" ]; then
# copie du fichier dans le répertoire
"$method" "$src" "$dest"
else
# Copie du fichier avec le nom $dest
mkdirof "$dest"
"$method" "$src" "$dest"
fi
fi
}
# transformer les fins de ligne en LF
function nl2lf() {
if [ -n "$1" -a "$1" != "-" ]; then
tr -d '\r' <"$1" >"$1.tmp.$$" &&
/bin/mv "$1.tmp.$$" "$1"
[ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
else
tr -d '\r'
fi
}
# transformer les fins de ligne en CRLF
function _nl2crlf() {
tr -d '\r' | awk '{print $0 "\r"}'
}
function nl2crlf() {
if [ -n "$1" -a "$1" != "-" ]; then
_nl2crlf <"$1" >"$1.tmp.$$" &&
/bin/mv "$1.tmp.$$" "$1"
[ -f "$1.tmp.$$" ] && /bin/rm -f "$1.tmp.$$"
else
_nl2crlf
fi
}
# tester la présence d'un pattern dans un fichier
function quietgrep() { grep -q "$@"; }
# tester si deux fichiers sont identiques
function quietdiff() { diff -q "$@" >&/dev/null; }
# tester si deux fichiers sont identiques/différents
function testsame() { quietdiff "$@"; }
function testdiff() { ! quietdiff "$@"; }
# test si $2 n'existe pas ou si $1 est plus récent que $2
function testnewer() { test ! -e "$2" -o "$1" -nt "$2"; }
# afficher tous les processus avec le maximum d'informations
function ps_all() { ps -axww; }
# tester l'existence d'un programme dans le PATH
function progexists() { test -n "$1" -a -x "$(which "$1" 2>/dev/null)"; }
# tester si on est root
function is_root() { test `id -u` -eq 0; }
# sourcer un fichier s'il existe
function source_ifexists() { if [ -f "$1" ]; then source "$1" || die; fi; }
# s'endormir pour une très petite période de temps
function little_sleep { LC_NUMERIC=C sleep 0.1; }
# tester si un programme dont on donne le PID tourne
function is_running() { test -n "$(ps -o pid -p "$1" | grep -v PID)"; }
# afficher des chemins "jolis"
function ppath() {
# Dans un chemin *absolu*, remplacer "$HOME" par "~" et "$(pwd)/" par "",
# afin que le chemin soit plus facile à lire. Le répertoire courant est
# spécifié par $2 ou $(pwd) si $2 est vide
local path="$1" cwd="$2"
# essayer de normaliser le chemin
if [ -d "$path" ]; then path="$(cd "$path"; pwd)"
elif [ -f "$path" ]; then path="$(cd "$(dirname "$path")"; pwd)/$(basename "$path")"
else
: # chemin inexistant, on espère que le chemin est bien formé
fi
if [ -z "$2" ]; then
cwd="$(pwd)"
fi
[ "$path" = "$cwd" ] && path="."
[ "$cwd" != "/" -a "$cwd" != "$HOME" ] && path="${path/#$cwd\//}"
path="${path/#$HOME/~}"
echo "$path"
}
# un équivalent de basename écris en bash. note: le cas $1=/ n'est pas traité correctement
function bname() {
local bn="${1%%/}"
bn="${p##*/}"
[ -n "$2" ] && bn="${p%%$2}"
echo "$bn"
}
# un équivalent de dirname écris en bash
function dname() {
local dn="${1%%/}"
case "$dn" in
*/*)
dn="${dn%/*}"
;;
*)
dn="."
;;
esac
echo "$dn"
}
# sed qui modifie le fichier en place. pour compatibilité avec d'autres
# plateformes (cf system_caps), cette version ne devrait être appelée que de
# cette manière::
# sedi "script" [files...]
# toute autre utilisation fonctionnerait sur Linux mais pas sur MacOS X ou SunOS
function sedi() {
sed -i "$@"
}
# run_as: fonction pour relancer le script courant afin qu'il tourne avec les
# droits d'un autre user (typiquement root). Attention! cette fonction ne teste
# pas avec si on est déjà ce user. Il y a donc un risque de boucle infinie si on
# ne teste pas le user courant.
function run_as() {
# Lancer cette fonction avec les arguments du script en cours. Par exemple::
# run_as root "$@"
# Si $2=--noexec, on n'utilise pas la fonction exec, ce qui fait que la
# fonction retourne. Sinon, on peut considérer que cette fonction ne
# retourne jamais
local OENC="$UTF8"
local user="${1:-root}"; shift
local exec_maybe=exec
if [ "$1" = "--noexec" ]; then
exec_maybe=
shift
fi
# on peut spécifer localement le niveau de verbosité
local VERBOSITY="$VERBOSITY" INTERACTION="$INTERACTION"
set_verbosity "$1" && shift
estep "Lancement du script sur $HOSTNAME en tant que $user"
if is_yes "$UTOOLS_USES_SU" || ! progexists sudo; then
einfo "Entrez le mot de passe de root"
$exec_maybe su "$user" -c "${BASH:-/bin/sh} \"$0\" $*"
else
einfo "Entrez le mot de passe de $USER (si nécessaire)"
if [ "$user" == "root" ]; then
$exec_maybe sudo "${BASH:-/bin/sh}" "$0" "$@"
else
local args="$*"
args="${args//|/\\|}"
args="${args//</\\<}"
args="${args//>/\\>}"
args="${args//;/\\;}"
$exec_maybe sudo su "$user" -c "${BASH:-/bin/sh} \"$0\" $args"
fi
fi
}
# run_as_root: fonction pour relancer le script courant afin qu'il tourne en
# root. Attention! cette fonction ne teste pas avec is_root si on est déjà en
# root ou non. Ne pas appeler cette fonction si is_root est vrai, on risque une
# boucle infinie.
function run_as_root() {
run_as root "$@"
}
# === fonctions pour contrôler l'encoding en sortie et en entrée ===
LATIN1=iso-8859-1
LATIN9=iso-8859-15
UTF8=utf-8
if ! progexists iconv; then
function iconv() { cat; }
fi
function __lang_encoding() {
local lang="$(<<<"$LANG" awk '{ print tolower($0) }')"
case "$lang" in
fr_fr@euro) echo "iso-8859-15";;
fr_fr) echo "iso-8859-1";;
*.utf-8) echo "utf-8";;
*) ;;
esac
}
function __norm_encoding() {
awk '{
enc = tolower($0)
gsub(/^latin$/, "latin1", enc)
gsub(/^latin1$/, "iso-8859-1", enc)
gsub(/^latin9$/, "iso-8859-15", enc)
gsub(/[-_]/, "", enc)
if (enc == "iso8859" || enc == "iso88591" || enc == "8859" || enc == "88591") print "iso-8859-1"
else if (enc == "iso885915" || enc == "885915") print "iso-8859-15"
else if (enc == "utf8") print "utf-8"
else print $0
}' <<<"$1"
}
function __init_encoding() {
local DEFAULT_ENCODING="$(__lang_encoding)"
[ -n "$DEFAULT_ENCODING" ] || DEFAULT_ENCODING=utf-8
[ -n "$UTOOLS_OUTPUT_ENCODING" ] || UTOOLS_OUTPUT_ENCODING="$DEFAULT_ENCODING"
UTOOLS_OUTPUT_ENCODING="$(__norm_encoding "$UTOOLS_OUTPUT_ENCODING")"
[ -n "$UTOOLS_INPUT_ENCODING" ] || UTOOLS_INPUT_ENCODING="$UTOOLS_OUTPUT_ENCODING"
UTOOLS_INPUT_ENCODING="$(__norm_encoding "$UTOOLS_INPUT_ENCODING")"
[ -n "$UTOOLS_EDITOR_ENCODING" ] || UTOOLS_EDITOR_ENCODING="$UTOOLS_INPUT_ENCODING"
UTOOLS_EDITOR_ENCODING="$(__norm_encoding "$UTOOLS_EDITOR_ENCODING")"
IENC="$UTOOLS_INPUT_ENCODING"
OENC="$UTOOLS_OUTPUT_ENCODING"
}
__init_encoding
function tooenc() {
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
if [ "$from" == "$to" ]; then
echo "$src"
else
iconv -f "$from" -t "$to" <<<"$src"
fi
}
function uecho() { tooenc "$*"; }
function tooenc_() {
local src="$1" from="${2:-$OENC}" to="${3:-$UTOOLS_OUTPUT_ENCODING}"
if [ "$from" == "$to" ]; then
echo_ "$src"
else
echo_ "$src" | iconv -f "$from" -t "$to"
fi
}
function uecho_() { tooenc_ "$*"; }
function toienc() {
local var_="$1" to_="${2:-$IENC}" from_="${3:-$UTOOLS_INPUT_ENCODING}"
if [ "$from_" != "$to_" ]; then
set_var "$var_" "$(iconv -f "$from_" -t "$to_" <<<"${!1}")"
fi
}
function uread() {
local var_
[ $# == 0 ] && set -- REPLY
read "$@"
for var_ in "$@"; do
[ -z "$var_" -o "${var_:0:1}" == "-" ] && continue # ignorer les options
toienc "$var_"
done
}
function stooenc() {
local from="${1:-$OENC}" to="${2:-$UTOOLS_OUTPUT_ENCODING}"
if [ "$from" == "$to" ]; then
cat
else
iconv -f "$from" -t "$to"
fi
}
function stoolatin1() { stooenc "iso-8859-1"; }
function stoolatin9() { stooenc "iso-8859-15"; }
function stooutf8() { stooenc "utf-8"; }
function stoienc() {
local to="${1:-$IENC}" from="${2:-$UTOOLS_INPUT_ENCODING}"
if [ "$from" == "$to" ]; then
cat
else
iconv -f "$from" -t "$to"
fi
}
function stoilatin1() { stoienc "iso-8859-1"; }
function stoilatin9() { stoienc "iso-8859-15"; }
function stoiutf8() { stoienc "utf-8"; }
# === fonctions pour contrôler l'affichage et l'interaction utilisateur ===
# ces fonctions n'affiche le message que si le niveau de "verbosité" est
# suffisant:
# 4=afficher les messages de debug; 3=afficher les message informatifs;
# 2=afficher les warnings et les notes; 1=afficher les erreurs
# 0=ne rien afficher
# niveau de "verbosité". on commence par défaut à 3
MIN_VERBOSITY=0
DEF_VERBOSITY=3
MAX_VERBOSITY=4
export VERBOSITY="${VERBOSITY:-$DEF_VERBOSITY}"
# niveau d'interaction.
MIN_INTERACTION=0
DEF_INTERACTION=2
MAX_INTERACTION=3
export INTERACTION="${INTERACTION:-$DEF_INTERACTION}"
function set_verbosity() {
# Configurer le niveau de verbosité ou d'interaction en fonction de la
# valeur de $1. Retourner 0 si l'argument a été utilisé, 1 sinon
# $2 est la valeur d'un préfixe pour reconnaitre des options courtes
# supplémentaires. Par défaut, les options suivantes sont reconnues: -c, -q,
# -v, -Q, -D, ... Si le préfixe est -v par exemple, les options reconnues
# seront -vc, -vq, -vv, -vQ, -vD, ... *en plus* de -c, -q, -v, -Q, -D, ...
local retval=0
local enable_fake_arg=
local prefix="-"
if [ "$1" = "--enable-fake-arg" ]; then
shift
enable_fake_arg=1
fi
[ -n "$2" ] && prefix="$2"
case "$1" in
# Ne changer, ni le niveau de verbosité, ni le niveau d'interaction, mais
# seulement si --enable-fake-arg a été activé
# Cette option permet à ask_yesno() et read_value() de spécifier les
# messages qui doivent être affichés dans le niveau par défaut de
# verbosité/interaction
-c|"${prefix}c"|--default)
[ -n "$enable_fake_arg" ] || retval=1
;;
# Configurer le niveau de verbosité en fonction de l'argument: -q le
# diminue, -Q le met au minimum, -v l'augmente, -D le met au maximum
-q|"${prefix}q"|--quiet)
[ $VERBOSITY -gt $MIN_VERBOSITY ] && VERBOSITY=$(($VERBOSITY - 1))
;;
-v|"${prefix}v"|--verbose)
[ $VERBOSITY -lt $MAX_VERBOSITY ] && VERBOSITY=$(($VERBOSITY + 1))
;;
-Q|"${prefix}Q"|--very-quiet)
VERBOSITY=$MIN_VERBOSITY
;;
-D|"${prefix}D"|--debug)
VERBOSITY=$MAX_VERBOSITY
;;
# Configurer le niveau d'interaction en fonction de l'argument: -b le met au
# minimum, -y le diminue, -i l'augmente
-b|"${prefix}b"|--batch)
# niveau d'interaction minimum
INTERACTION=$MIN_INTERACTION
;;
-y|"${prefix}y"|--automatic)
# Dimininuer le niveau d'interaction
[ $INTERACTION -gt $MIN_INTERACTION ] && INTERACTION=$(($INTERACTION - 1))
;;
-i|"${prefix}i"|--interactive)
# Augmenter le niveau d'interaction. Augmenter aussi le niveau de verbosité
[ $INTERACTION -lt $MAX_INTERACTION ] && INTERACTION=$(($INTERACTION + 1))
;;
*)
retval=1
;;
esac
return $retval
}
function check_verbosity() {
# Teste si le niveau de verbosité/interaction courant est suffisant pour une
# opération dont le niveau est donné par $1
# Par exemple, 'check_verbosity -y' ne retourne vrai que si le niveau
# d'interaction courant est supérieur ou égal à ($DEF_INTERACTION - 1). Cela
# permet d'afficher un message ou d'effectuer une opération si on est au
# moins en mode automatic (par contre, en mode batch, l'opération ne sera
# pas effectué
# De même 'check_verbosity -v' ne retourne vrai que si le niveau de
# verbosité courant est supérieur ou égal à ($DEF_VERBOSITY+1). Cela permet
# de n'afficher un message que si l'on est en mode verbose par exemple.
# 'check_verbosity -c' retourne toujours vrai
# Si $1 n'est pas un argument valide pour set_verbosity, alors on teste le
# niveau de verbosité ou d'interaction par défaut. si $2!="", alors on teste
# si le niveau de verbosité courant est supérieur à $2. Si $3!="", alors on
# teste sur le niveau d'interaction est supérieur à $3
# Si le premier argument est --action, alors on affiche "shift", "return",
# ou ":" suivant l'action à effectuer. Sinon, retourner 0 si le niveau est
# correct (Si $2="" et $3="", l'argument a été interprété et il faut faire
# un shift. Sinon l'argument a peut-être été interprété. On ne sait pas
# alors, sauf si on spécifie --action, s'il faut faire un shift ou non), 1
# si le niveau n'est pas correct, mais l'argument $1 a été interprété (donc
# il faut faire un shift) et 2 si l'argument n'est pas correct (n'a pas été
# interprété)
local verbosity="$VERBOSITY" interaction="$INTERACTION"
local VERBOSITY="$DEF_VERBOSITY" INTERACTION="$DEF_INTERACTION"
local action=
if [ "$1" = "--action" ]; then
shift
action=1
fi
if set_verbosity --enable-fake-arg "$1"; then
shift
if [ $interaction -ne $INTERACTION -a $interaction -ge $INTERACTION ] ||
[ $verbosity -ne $VERBOSITY -a $verbosity -ge $VERBOSITY ] ||
[ $interaction -eq $INTERACTION -a $verbosity -eq $VERBOSITY ]; then
[ -n "$action" ] && echo shift
return 0
else
[ -n "$action" ] && echo return
return 1
fi
else
if [ -n "$2" ] && [ "$verbosity" -gt "$2" ]; then
[ -n "$action" ] && echo :
return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
elif [ -n "$3" ] && [ "$interaction" -gt "$3" ]; then
[ -n "$action" ] && echo :
return 0 # ce cas n'est pas équivalent à celui ci-dessus (pas de shift à faire!)
else
[ -n "$action" ] && echo return
return 2
fi
fi
}
function echo_() { echo -n "$*"; }
# Couleurs
tty -s <&1 && NO_COLORS= || NO_COLORS=1
function get_color() {
[ -n "$NO_COLORS" ] && return
[ -z "$*" ] && set RESET
echo_ $'\e['
local sep
while [ -n "$1" ]; do
[ -n "$sep" ] && echo_ ";"
case "$1" in
z|RESET) echo_ "0";;
o|BLACK) echo_ "30";;
r|RED) echo_ "31";;
g|GREEN) echo_ "32";;
y|YELLOW) echo_ "33";;
b|BLUE) echo_ "34";;
m|MAGENTA) echo_ "35";;
c|CYAN) echo_ "36";;
w|WHITE) echo_ "37";;
DEFAULT) echo_ "39";;
O|BLACK_BG) echo_ "40";;
R|RED_BG) echo_ "41";;
G|GREEN_BG) echo_ "42";;
Y|YELLOW_BG) echo_ "43";;
B|BLUE_BG) echo_ "44";;
M|MAGENTA_BG) echo_ "45";;
C|CYAN_BG) echo_ "46";;
W|WHITE_BG) echo_ "47";;
DEFAULT_BG) echo_ "49";;
@|BOLD) echo_ "1";;
-|FAINT) echo_ "2";;
_|UNDERLINED) echo_ "4";;
~|REVERSE) echo_ "7";;
n|NORMAL) echo_ "22";;
esac
sep=1
shift
done
echo_ "m"
}
COULEUR_ROUGE="$(get_color RED BOLD)"
COULEUR_VERTE="$(get_color GREEN BOLD)"
COULEUR_JAUNE="$(get_color YELLOW BOLD)"
COULEUR_BLEUE="$(get_color BLUE BOLD)"
COULEUR_BLANCHE="$(get_color WHITE BOLD)"
COULEUR_NORMALE="$(get_color RESET)"
# tester le niveau de "verbosité" ou d'interaction
function is_quiet() { [ $VERBOSITY -lt $DEF_VERBOSITY ]; }
function is_verbose() { ! is_quiet; }
function is_interactive() { [ $INTERACTION -ge $DEF_INTERACTION ]; }
function is_automatic() { [ $INTERACTION -lt $DEF_INTERACTION ]; }
function is_batch() { [ $INTERACTION -eq $MIN_INTERACTION ]; }
# afficher une erreur *sur stderr*
function display_error() { [ $VERBOSITY -gt 0 ]; }
function eerror() {
eval `check_verbosity --action "$1" 0`
echo_ "${COULEUR_ROUGE}error:${COULEUR_NORMALE} " 1>&2
tooenc "$*" 1>&2
}
# afficher un warning ou une note *sur stderr*
function display_warning() { [ $VERBOSITY -gt 1 ]; }
function ewarn() {
eval `check_verbosity --action "$1" 1`
echo_ "${COULEUR_JAUNE}warning:${COULEUR_NORMALE} " 1>&2
tooenc "$*" 1>&2
}
function enote() {
eval `check_verbosity --action "$1" 1`
echo_ "${COULEUR_VERTE}note:${COULEUR_NORMALE} " 1>&2
tooenc "$*" 1>&2
}
# afficher une information
function display_info() { [ $VERBOSITY -gt 2 ]; }
function etitle() {
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_BLANCHE}>>> "
tooenc_ "$*"
echo " <<<${COULEUR_NORMALE}"
}
function esubtitle() {
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_BLANCHE}*** "
tooenc_ "$*"
echo "${COULEUR_NORMALE}"
}
function eimportant() {
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_ROUGE}important:${COULEUR_NORMALE} "
tooenc "$*"
}
function eattention() {
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_JAUNE}attention:${COULEUR_NORMALE} "
tooenc "$*"
}
function ecomment() {
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_VERTE}commentaire:${COULEUR_NORMALE} "
tooenc "$*"
}
function einfo() {
eval `check_verbosity --action "$1" 2`
tooenc "$*"
}
function einfon() {
eval `check_verbosity --action "$1" 2`
tooenc_ "$*"
}
# afficher un message de debug
function is_debug() { [ $VERBOSITY -gt 3 ]; }
function edebug() {
eval `check_verbosity --action "$1" 3`
echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
tooenc "$*"
}
function edebugn() {
eval `check_verbosity --action "$1" 3`
echo_ "${COULEUR_BLANCHE}debug:${COULEUR_NORMALE} "
tooenc_ "$*"
}
# Fonctions d'affichage pour suivre la progression d'opérations
function estep() {
# Une opération entière
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
tooenc "$*"
}
function estepn() {
# Une opération entière
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
tooenc_ "$*"
}
function ebegin() {
# Le début d'une opération
eval `check_verbosity --action "$1" 2`
echo_ "${COULEUR_BLANCHE}*${COULEUR_NORMALE} "
tooenc_ "$*"
echo_ ":"
utools_ESTATUS_=0
utools_edot_first_=1
}
function edot() {
# Une étape d'une opération commencée par ebegin, matérialisée par un "."
# Si l'argument est un fichier, utiliser -f pour que "$HOME" et "$(pwd)/"
# soient remplacés respectivement par "~" et "" (afin que les chemins soient
# plus courts)
# Si l'argument est un commentaire, utiliser -m pour le spécifier. -w
# indique que l'argument est un warning: un x jaune est affiché, avec le
# message associé si on est en mode debug.
# Sinon, l'argument est un status. 0 affiche un ".", sinon on affiche un "x"
local status=$?
local warn= color=
if [ -n "$utools_edot_first_" ]; then
# au premier dot, afficher un espace d'abord
echo_ " "
utools_edot_first_=
fi
eval `check_verbosity --action "$1" 2`
if is_debug; then
local msg paths path
if [ "$1" = "-f" ]; then
# chemins
shift
for path in "$@"; do
paths="${paths:+$paths,}$(ppath "$path")"
done
msg="$paths"
elif [ "$1" = "-m" -o "$1" = "-w" ]; then
# message
[ "$1" = "-w" ] && warn=1 # message de warning
shift
msg="$(tooenc "$*")"
else
# status
[ -n "$1" ] && status="$1"
fi
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
if [ "$status" -eq 0 -a -z "$warn" ]; then
echo_ "${msg:+
}.${msg:+($msg)}"
else
color="$COULEUR_ROUGE"
[ -n "$warn" ] && color="$COULEUR_JAUNE"
echo_ "${msg:+
}${color}x${COULEUR_NORMALE}${msg:+($msg)}"
fi
else
if [ "$1" = "-f" -o "$1" = "-m" -o "$1" = "-w" ]; then
[ "$1" = "-w" ] && warn=1 # message de warning
shift
else
[ -n "$1" ] && status="$1"
fi
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
if [ "$status" -eq 0 -a -z "$warn" ]; then
echo_ "."
else
color="$COULEUR_ROUGE"
[ -n "$warn" ] && color="$COULEUR_JAUNE"
echo_ "${color}x${COULEUR_NORMALE}"
fi
fi
}
function ewait() {
# Une étape d'un opération commencée par ebegin, matérialisée par des "+"
# qui s'affichent tant que le processus de PID $1 tourne
# à utiliser de cette manière:
# ebegin "lancement de cmd"
# cmd &
# ewait $!
# eend
local action status
action="$(check_verbosity --action "$1" 2)"
status=$? # le status de check_verbosity
if [ "$action" == "return" ]; then #
# ne rien afficher, mais attendre quand même que le processus s'arrête
[ $status -eq 1 ] && shift
local pid="$1"
[ -n "$pid" ] && wait "$pid"
return
fi
eval "$action"
if [ -n "$utools_edot_first_" ]; then
# au premier dot, afficher un espace d'abord
echo_ " "
utools_edot_first_=
fi
local pid="$1"
local count=2 # attendre 2 secondes avant de commencer à afficher des "+"
[ -z "$pid" ] && return
little_sleep # certains processus retournent tout de suite
while is_running "$pid"; do
sleep 1
if [ $count -gt 0 ]; then
count=$(($count - 1))
else
echo_ "+"
fi
done
echo_ "." # terminer par un "."
}
function eend() {
# la fin d'une opération commencée par ebegin
local status=0
eval `check_verbosity --action "$1" 2`
[ -n "$1" ] && status="$1"
[ "$utools_ESTATUS_" -eq 0 -a "$status" -ne 0 ] && utools_ESTATUS_="$status"
if [ "$utools_ESTATUS_" -eq 0 ]; then
echo " ${COULEUR_VERTE}ok${COULEUR_NORMALE}"
else
echo " ${COULEUR_ROUGE}error${COULEUR_NORMALE}"
fi
status=$utools_ESTATUS_
unset utools_ESTATUS_
return $status
}
# Arrêter le script avec un message d'erreur
function die() { [ -n "$*" ] && eerror "$@"; exit 1; }
# === Nom du système ===
export SYSTEM_NAME="`uname -s`"
beginswith "$SYSTEM_NAME" CYGWIN && SYSTEM_NAME=Cygwin
beginswith "$SYSTEM_NAME" MINGW32 && SYSTEM_NAME=Mingw
export SYSTEM_MACHINE="`uname -m`"
if [ "$SYSTEM_NAME" == "Linux" ]; then
if [ -f /etc/debian_version ]; then
LINUX_FLAVOUR=debian
elif [ -f /etc/gentoo-release ]; then
LINUX_FLAVOUR=gentoo
elif [ -f /etc/redhat-release ]; then
LINUX_FLAVOUR=redhat
else
LINUX_FLAVOUR=
fi
if [ "$SYSTEM_MACHINE" == "x86_64" ]; then
SYSTEM_BITS=64
else
SYSTEM_BITS=32
fi
elif [ "$SYSTEM_NAME" == "Darwin" ]; then
MACOSX_VERSION="$(grep -A 1 CFBundleShortVersionString /System/Library/Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Resources/version.plist | grep string | sed 's/.*<string>//g
s/<\/string>.*$//g')"
MACOSX_NAME=UNSUPPORTED
if beginswith "$MACOSX_VERSION" 10.5; then
MACOSX_NAME=LEOPARD
elif beginswith "$MACOSX_VERSION" 10.4; then
MACOSX_NAME=TIGER
fi
SYSTEM_BITS=
fi
# === vérifications ===
[ -d "$TMPDIR" ] || ewarn "TMPDIR ($TMPDIR) n'existe pas"
##@inc]../../legacy/sysinc/base
__MAKE_SYSTEM_CAPS__="$(dirname "$0")/../../legacy/system_caps"
##@inc[../../legacy/sysinc/system_caps
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
##@require base
# system_caps: Déterminer les capacités du syteme sur lequel nous tournons. Ces
# scripts sont prévus pour adapter un système non Linux pour qu'il fonctionne a
# peu près comme Linux. Les fonctions de base qui doivent être adaptées le sont
# en fonction du système sur lequel on tourne. Il suffit d'inclure ce fichier
# pour bénéficier des nouvelles fonctionnalités
# note: sous Linux, ces scripts sont essentiellement un no-op
__SYSTEM_CAPS_COMPUTED__=
if [ -z "$__MAKE_SYSTEM_CAPS__" -a -z "$__FORCE_COMPUTE_SYSTEM_CAPS__" -a -f "@@dest@@/legacy/system_caps" ]; then
source "@@dest@@/legacy/system_caps"
fi
unset __FORCE_COMPUTE_SYSTEM_CAPS__
if [ -z "$__SYSTEM_CAPS_COMPUTED__" ]; then
if [ -n "$__MAKE_SYSTEM_CAPS__" ]; then
>"$__MAKE_SYSTEM_CAPS__"
fi
function __define_and_eval__() {
if [ -n "$__MAKE_SYSTEM_CAPS__" ]; then
echo "$1" >>"$__MAKE_SYSTEM_CAPS__"
fi
eval "$1"
}
function __verify_system__() {
# Vérifier que le système est supporté
local OENC="$UTF8"
local system
for system in Linux SunOS Darwin Cygwin Mingw unsupported; do
[ "$system" = "$SYSTEM_NAME" ] && break
[ "$system" = "unsupported" ] && die "$SYSTEM_NAME: Système non supporté"
done
}
__verify_system__; unset -f __verify_system__
function __get_which_caps__() {
[ "$SYSTEM_NAME" = "Linux" ] && return
# Obtenir les capacités de which: certaines implémentations affichent "no x
# in ..." sur stdout au lieu de l'afficher sur stderr
local OENC="$UTF8"
local tmpout="$TMPDIR/which_test.$$.out"
local tmperr="$TMPDIR/which_test.$$.err"
which __une_appli_qui_existe_pas__ >"$tmpout" 2>"$tmperr"
if [ -s "$tmpout" ]; then
__legacy_which__=1 # legacy
elif [ -s "$tmperr" ]; then
: # cas normal
else
__legacy_which__=2 # MacOSX 10.5
fi
/bin/rm -f "$tmpout"
/bin/rm -f "$tmperr"
if [ "$__legacy_which__" == 1 ]; then
local grep="${grep:-`which grep 2>&1`}"
if [ -x "$grep" ]; then
__define_and_eval__ 'function progexists() { test -n "$1" -a -z "$(which "$1" 2>&1 | '"$grep"' "^no $1")"; }'
else
die "grep est requis pour l'implémentation de progexists() sur ce système"
fi
elif [ "$__legacy_which__" == 2 ]; then
__define_and_eval__ 'function progexists() { which "$1" >&/dev/null; }'
fi
}
__get_which_caps__; unset -f __get_which_caps__
function __set_prog_func__() {
# Tester la présence d'un programme sur le système en cours, et si
# le programme doit être accedé avec un chemin absolu, créer une
# fonction du nom de ce programme qui pourra être utilisée pour
# appeler ce programme.
# $1 == nom de la fonction a créer. Il s'agit géneralement du nom du
# programme, mais ce n'est pas une obligation.
# $2 == nom à afficher si le programme n'est pas trouvé. Le message
# affiché sera de la forme "Ce script requière $2....". Si cette
# valeur est non vide, le programme *doit exister* sinon le script
# se termine. Si la valeur est "-", alors il s'agit de $1.
# $3..$n == chemins dans lesquels il faut chercher le programme. Si
# la valeur est "-", on teste si le programme est disponible dans le
# path.
local OENC="$UTF8"
local prog="$1"; shift
local req="$1"; shift
if [ -z "$prog" ]; then
die "USAGE: __set_prog_func__ prog_func req? path [paths...]"
fi
if [ -n "${!prog}" ]; then
# Si une variable de ce nom est deja definie, on assume qu'il
# s'agit du chemin vers le programme
__define_and_eval__ 'function '"$prog"'() { '"${!prog}"' "$@"; }'
return 0
fi
local found=
while [ -n "$1" ]; do
local path="$1"; shift
if [ "$path" = "--legacy" ]; then
# Declarer que les programmes qui suivent sont "legacy"
__define_and_eval__ 'export __legacy_'"$prog"'__=1'
continue
fi
if [ "${path#/}" = "$path" ] && progexists "$path"; then
# Si on donne un nom de programme, et que ce programme se
# trouve dans le path, l'adopter avec son chemin absolu
if [ "$path" != "$prog" ]; then
path="$(type -p "$path")"
__define_and_eval__ 'function '"$prog"'() { "'"$path"'" "$@"; }'
fi
found=1
break
fi
if [ "$path" = "-" ] && progexists "$prog"; then
# pas la peine de creer une fonction, la commande existe
# deja avec ce nom-la dans le path
found=1
break
fi
if [ -d "$path" ]; then path="$path/$prog"; fi
if [ -d "$path" ]; then continue; fi
if [ -x "$path" ]; then
__define_and_eval__ 'function '"$prog"'() { "'"$path"'" "$@"; }'
found=1
break
fi
done
if [ -z "$found" -a -n "$req" ]; then
if [ "$req" = "-" ]; then req="$prog"; fi
die "Ce script requière $req
Si ce programme est installé, faites
export $prog=/path/to/$prog
et relancez ce script"
fi
test -n "$found"
}
function __get_tools_path_and_caps__() {
[ "$SYSTEM_NAME" = "Linux" ] && return
# Obtenir l'emplacement d'outils standards, tels que:
# cp, awk, grep, diff, tar, ps, date
local system
# cp
for system in SunOS Darwin; do
[ "$SYSTEM_NAME" = "$system" ] && __define_and_eval__ 'export __legacy_cp__=1'
done
[ -n "$__legacy_cp__" ] && __define_and_eval__ 'function cp_a() { /bin/cp -pR "$@"; }'
# awk
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ awk "gawk or nawk" \
gawk \
/usr/sfw/bin/gawk \
/opt/sfw/bin/gawk \
--legacy nawk \
/usr/bin/nawk
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
# note: gensub() n'est supporté que sur gnuawk
# si __legacy_awk__ est défini, on sait que cette fonction n'est pas
# disponible
__set_prog_func__ awk "gawk or nawk" \
gawk \
/sw/bin/gawk \
/sw/bin/awk \
--legacy /usr/bin/awk
fi
# grep
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ grep - \
ggrep \
/usr/sfw/bin/ggrep \
/opt/sfw/bin/ggrep \
--legacy /usr/bin/grep
fi
if [ -n "$__legacy_grep__" ]; then
__define_and_eval__ 'function quietgrep() { grep "$@" >&/dev/null; }'
fi
# diff
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ diff - \
gdiff \
/usr/sfw/bin/gdiff \
/opt/sfw/bin/gdiff \
--legacy /usr/bin/diff
fi
if [ -n "$__legacy_diff__" ]; then
__define_and_eval__ 'function quietdiff() { diff "$@" >&/dev/null; }'
fi
# tar
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ tar - \
gtar \
/usr/sfw/bin/gtar \
/opt/sfw/bin/gtar \
--legacy /usr/bin/tar
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
__set_prog_func__ tar - \
gnutar gtar \
/sw/bin/gtar \
--legacy /usr/bin/tar
fi
# ps
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ ps - \
/usr/ucb/ps \
--legacy /usr/bin/ps
__set_prog_func__ legacyps - \
/usr/bin/ps
__define_and_eval__ 'function is_running() { test -n "$(legacyps -o pid -p "$1" | grep -v PID)"; }'
fi
if [ -n "$__legacy_ps__" ]; then
__define_and_eval__ 'function ps_all() { ps -ef; }'
fi
# sleep
if [ "$SYSTEM_NAME" = "SunOS" -o "$SYSTEM_NAME" = "Darwin" ]; then
__define_and_eval__ 'function little_sleep() { n=1000; while [ $n -gt 0 ]; do n=$(($n - 1)); done; }'
fi
# date
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__set_prog_func__ date - \
gdate \
/usr/sfw/bin/gdate \
/opt/sfw/bin/gdate \
--legacy /usr/bin/date
elif [ "$SYSTEM_NAME" = "Darwin" ]; then
__set_prog_func__ date - \
--legacy /bin/date
fi
# readlink
if ! progexists readlink; then
__define_and_eval__ 'function readlink() { if [ -L "$1" ]; then /bin/ls -ld "$1" | awk '"'"'{print $11'"'"'}; fi; }'
fi
# mktemp
if ! progexists mktemp; then
__define_and_eval__ 'function mktemp() { make_tempfile "$@"; }'
fi
# curl/wget (pour dumpurl)
if ! progexists curl; then
if [ "$SYSTEM_NAME" = "SunOS" ]; then
if __set_prog_func__ curl "" /usr/local/bin/curl; then
__define_and_eval__ 'export __curl_EXISTS__=1'
fi
fi
fi
if ! progexists wget; then
if [ "$SYSTEM_NAME" = "SunOS" ]; then
if __set_prog_func__ wget "" /usr/sfw/bin/wget /opt/sfw/bin/wget; then
__define_and_eval__ 'export __wget_EXISTS__=1'
fi
fi
fi
# is_root
if [ "$SYSTEM_NAME" = "SunOS" ]; then
__define_and_eval__ 'function is_root() { id | quietgrep "uid=0"; }'
elif [ "$SYSTEM_NAME" = "Cygwin" -o "$SYSTEM_NAME" = "Mingw" ]; then
# on assume que sur ces systèmes, l'utilisateur est maitre à bord.
__define_and_eval__ 'function is_root() { true; }'
fi
# sedi
if [ "$SYSTEM_NAME" = "Darwin" ]; then
__define_and_eval__ 'function __1sedi() {
local script="$1" input="$2"
if sed -i.bak "$script" "$input"; then
/bin/rm -f "$input.bak"
fi
}
function sedi() {
local script="$1" input
shift
for input in "$@"; do
__1sedi "$script" "$input"
done
}'
elif [ "$SYSTEM_NAME" = "SunOS" ]; then
__define_and_eval__ 'function __1sedi() {
local script="$1" input="$2"
if sed "$script" "$input" >"$input.out.$$"; then
chmod "$(/bin/ls -l "$input" | awk '\''function oct(mod) {
value = 0
if (substr(mod, 1, 1) == "r") value = value + 4
if (substr(mod, 2, 1) == "w") value = value + 2
if (substr(mod, 3, 1) == "x") value = value + 1
return value
}
{
print oct(substr($1, 2, 3)) oct(substr($1, 5, 3)) oct(substr($1, 8, 3))
}'\'')" "$input.out.$$"
/bin/mv -f "$input.out.$$" "$input"
fi
}
function sedi() {
local script="$1" input
shift
for input in "$@"; do
__1sedi "$script" "$input"
done
}'
fi
# parse_date
if [ "$SYSTEM_NAME" = "Darwin" ]; then
function __pd_isleap() {
# tester si l'année $1 est bissextile
[ $(($1 % 4)) -eq 0 -a \( $(($1 % 100)) -ne 0 -o $(($1 % 400)) -eq 0 \) ]
}
function __pd_fix_month() {
# soit $1 le nom d'une variable contenant une année, et $2 le nom d'une
# variable contenant un mois, normaliser les valeurs de ces variables, en
# ajustant si nécessaire les valeurs.
local __pdfm_y="${!1}" __pdfm_m="${!2}"
let __pdfm_m=$__pdfm_m-1
while [ $__pdfm_m -gt 11 ]; do
let __pdfm_m=$__pdfm_m-12
let __pdfm_y=$__pdfm_y+1
done
while [ $__pdfm_m -lt 0 ]; do
let __pdfm_m=$__pdfm_m+12
let __pdfm_y=$__pdfm_y-1
done
let __pdfm_m=$__pdfm_m+1
eval "$1=$__pdfm_y; $2=$__pdfm_m"
}
__PD_MONTHDAYS=(0 31 28 31 30 31 30 31 31 30 31 30 31)
function __pd_monthdays() {
# calculer le nombre de jours du mois $2 de l'année $1
local y="$1" m="$2" mds
__pd_fix_month y m
mds="${__PD_MONTHDAYS[$m]}"
[ "$m" -eq 2 ] && __pd_isleap "$y" && let mds=$mds+1
echo $mds
}
function __pd_fix_day() {
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
# valeurs. cette fonction assume que la valeur de $2 est déjà corrigée avec
# __pd_fix_month
local __pdfd_y="${!1}" __pdfd_m="${!2}" __pdfd_d="${!3}" __pdfd_mds
let __pdfd_d=$__pdfd_d-1
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
while [ $__pdfd_d -gt $(($__pdfd_mds-1)) ]; do
let __pdfd_d=$__pdfd_d-$__pdfd_mds
let __pdfd_m=$__pdfd_m+1
__pd_fix_month __pdfd_y __pdfd_m
let __pdfd_mds=$(__pd_monthdays $__pdfd_y $__pdfd_m)
done
while [ $__pdfd_d -lt 0 ]; do
let __pdfd_m=$__pdfd_m-1
__pd_fix_month __pdfd_y __pdfd_m
let __pdfd_d=$__pdfd_d-$(__pd_monthdays $__pdfd_y $__pdfd_m)
done
let __pdfd_d=$__pdfd_d+1
eval "$1=$__pdfd_y; $2=$__pdfd_m; $3=$__pdfd_d"
}
function __pd_fix_date() {
# soit $1 le nom d'une variable contenant une année, $2 le nom d'une
# variable contenant un mois et $3 le nom d'une variable contenant un jour,
# normaliser les valeurs de ces variables, en ajustant si nécessaire les
# valeurs.
local __pdf_y="${!1}" __pdf_m="${!2}" __pdf_d="${!3}"
}
function parse_date() {
local value="$1" type="${2:-date}"
local d m y
# date courante
eval "$(date +%d/%m/%Y | awk -F/ '{
print "d=" $1 "; m=" $2 "; y=" $3
}')"
if [ "${value#+}" != "$value" ]; then
# ajouter $1 jours
d="$(($d+${value#+}))"
else
# parser une nouvelle date, en complétant avec les informations de la
# date du jour
eval "$(<<<"$value" awk -F/ "BEGIN {
dn=$dn; mn=$mn; yn=$yn
}"'
{
d = $1 + 0; if (d < 1) d = dn + 0;
m = $2 + 0; if (m < 1) m = mn + 0;
if ($3 == "") y = yn + 0;
else { y = $3 + 0; if (y < 100) y = y + 2000; }
print "d=" d "; m=" m "; y=" y
}')"
fi
# ensuite corriger les champs si nécessaire
__pd_fix_month y m
__pd_fix_day y m d
# enfin formater la date selon les volontés de l'utilisateur
case "$type" in
d|date)
awk "BEGIN { d=$d; m=$m; y=$y; "'printf "%02i/%02i/%04i\n", d, m, y }'
;;
l|ldap)
awk "BEGIN { d=$d; m=$m; y=$y; "'printf "%04i%02i%02i000000+0400\n", y, m, d }'
;;
esac
}
fi
}
__get_tools_path_and_caps__
unset -f __set_prog_func__ __get_tools_path_and_caps__
__define_and_eval__ "__SYSTEM_CAPS_COMPUTED__=1"
unset -f __define_and_eval__
fi
##@inc]../../legacy/sysinc/system_caps