# ulib/base.core

## `echo_`
~~~
afficher la valeur $* sans passer à la ligne
~~~
## `recho`
~~~
afficher une valeur brute. contrairement à la commande echo, ne reconnaitre
aucune option (i.e. -e, -E, -n ne sont pas signifiants)
~~~
## `recho_`
~~~
afficher une valeur brute, sans passer à la ligne. contrairement à la commande
echo, ne reconnaitre aucune option (i.e. -e, -E, -n ne sont pas signifiants)
~~~
## `should_quote`
~~~
Tester si la chaine $* doit être mise entre quotes
~~~
## `qval`
~~~
Afficher la chaine $* quotée avec "
~~~
## `qvalm`
~~~
Afficher la chaine $* quotée si nécessaire avec "
~~~
## `qvalr`
~~~
Afficher la chaine $* quotée si nécessaire avec ", sauf si elle est vide
~~~
## `qvals`
~~~
Afficher chaque argument de cette fonction quotée le cas échéant avec "
Chaque valeur est séparée par un espace.
~~~
## `qwc`
~~~
Dans la chaine $*, remplacer \ par \\, " par \", $ par \$, ` par \`, puis
quoter la chaine avec ", sauf les wildcards * et ?
Cela permet de quoter une chaine permettant de glober des fichiers, e.g
eval "ls $(qwc "$value")"
Note: la protection de ! n'est pas effectuée, parce que le comportement du
shell est incohérent entre le shell interactif et les scripts. Pour une
version plus robuste, il est nécessaire d'utiliser un programme externe tel
que sed ou awk
~~~
## `qlines`
~~~
Traiter chaque ligne de l'entrée standard pour en faire des chaines quotées
avec '
~~~
## `setv`
~~~
initialiser la variable $1 avec la valeur $2*
note: en principe, la syntaxe est 'setv var values...'. cependant, la
syntaxe 'setv var=values...' est supportée aussi
~~~
## `echo_setv`
~~~
Afficher la commande qui serait lancée par setv "$@"
~~~
## `setx`
~~~
syntaxe 1: setx var cmd
initialiser la variable $1 avec le résultat de la commande "$2..@"
note: en principe, la syntaxe est 'setx var cmd args...'. cependant, la
syntaxe 'setx var=cmd args...' est supportée aussi
syntaxe 2: setx -a array cmd
initialiser le tableau $1 avec le résultat de la commande "$2..@", chaque
ligne du résultat étant un élément du tableau
note: en principe, la syntaxe est 'setx -a array cmd args...'. cependant, la
syntaxe 'setx -a array=cmd args...' est supportée aussi
~~~
## `evalx`
~~~
Implémenter une syntaxe lisible et naturelle permettant d'enchainer des
traitements sur une valeur. Par exemple, la commande
evalx cmd1 [args1...] // cmd2 [args2...] // cmd3 [args3...]
est équivalente à la commande
cmd3 args3 "$(cmd2 args2 "$(cmd1 args1)")"
Retourner le dernier code d'erreur non nul, ou 0 si toutes les commandes se
sont exécutées sans erreur.
~~~
## `setxx`
~~~
équivalent à setx $1 evalx $2..@
~~~
## `evalp`
~~~
Implémenter une syntaxe alternative permettant d'enchainer des traitements sur
un flux de données. Par exemple, la commande
evalp cmd1... // cmd2... // cmd3...
affiche le résultat de la commande "$(cmd1 | cmd2 | cmd3)"
Typiquement, cette fonction permet de faciliter la *construction* d'un
enchainement de commandes par programme, ou de faciliter l'utilisation de la
fonction setx() pour récupérer le résultat d'un enchainement. Dans les autres
cas, il est plus simple et naturel d'écrire les enchainements avec la syntaxe
de bash.
~~~
## `setxp`
~~~
équivalent à setx $1 evalp $2..@
~~~
## `testx`
~~~
Faire un test unaire avec la commande [ sur une valeur calculée avec evalx.
Utiliser la syntaxe 'testx op cmds...' e.g.
testx -z cmd1 // cmd2
~~~
## `test2x`
~~~
Faire une test binaire avec la commande [ entre une valeur spécifiée et une
valeur calculée avec evalx. Utiliser la syntaxe 'test2x value op cmds...' e.g.
test2x value == cmd1 // cmd2
~~~
## `testrx`
~~~
Faire une test binaire avec la commande [[ entre une valeur spécifiée et une
valeur calculée avec evalx. Utiliser la syntaxe 'testrx value op cmds...' e.g.
testrx value == cmd1 // cmd2
~~~
## `testp`
~~~
Faire un test unaire avec la commande [ sur une valeur calculée avec evalp.
Utiliser la syntaxe 'testp op cmds...' e.g.
testp -z cmd1 // cmd2
~~~
## `test2p`
~~~
Faire une test binaire avec la commande [ entre une valeur spécifiée et une
valeur calculée avec evalp. Utiliser la syntaxe 'test2p value op cmds...' e.g.
test2p value == cmd1 // cmd2
~~~
## `testrp`
~~~
Faire une test binaire avec la commande [[ entre une valeur spécifiée et une
valeur calculée avec evalp. Utiliser la syntaxe 'testrp value op cmds...' e.g.
testrp value == cmd1 // cmd2
~~~
## `err2out`
~~~
lancer la commande $@ en redirigeant la sortie d'erreur sur la sortie standard
~~~
## `is_defined`
~~~
tester si la variable $1 est définie
~~~
## `is_array`
~~~
tester si la variable $1 est un tableau
~~~
## `upvar`
~~~
Assign variable one scope above the caller
Usage: local "$1" && upvar $1 "value(s)"
Param: $1  Variable name to assign value to
Param: $*  Value(s) to assign.  If multiple values, an array is
assigned, otherwise a single value is assigned.
~~~
## `array_upvar`
~~~
Comme upvar() mais force la création d'un tableau
~~~
## `upvars`
~~~
Version modifiée par rapport à l'original. Il n'est plus nécessaire de
préfixer une variable scalaire avec -v, et -a peut être spécifié sans
argument.
Usage:
local varname [varname ...] && upvars [varname value] | [-aN varname [value ...]] ...
Options:
-a
assigns remaining values to varname as array
-aN
assigns next N values to varname as array. Returns 1 if wrong number of
options occurs
~~~
## `array_buildcmd`
~~~
Construire un tableau dont les éléments sont calculés à partir d'une chaine
dont les éléments sont séparés par des marqueurs ++X, e.g:
++ ou ++c[md] une chaine simple résultat de la commande
++s[split] un ensemble d'arguments résultat du split du résultat de la
commande sur espaces
++l[split] un ensemble d'arguments résultat du split du résultat de la
commande sur les lignes
++a[dd] un ensemble d'arguments donnés directement
Exemple:
array_buildcmd args echo Copie de ++ ppath "$src" ++a vers ++ ppath "$dest"
~~~
## `buildcmd`
## `evalcmd`

-*- coding: utf-8 mode: markdown -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8:noeol:binary