Discussion :

[NeoType]

Salut !

Je travaille sur un petit projet en ce moment qui consiste à faire du "wrapping" de scripts shell.
Ce qui m'amène à travailler sur les codes retour de commandes.
Hors je me suis rendu compte d'un truc un peu étrange selon moi, une bête histoire de syntaxe.
Voici un petit script pour illustrer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/bin/bash
 
var=$(une_commande_qui_n_existe_pas 1>/dev/null 2>&1)
echo -e 'var=$(une_commande_qui_n_existe_pas 1>/dev/null 2>&1) donne ce code retour: '$?"\n"
 
function une_commande_qui_réussit { return 0; }
 
var=$(une_commande_qui_réussit 1>/dev/null 2>&1)
echo -e 'var=$(une_commande_qui_réussit 1>/dev/null 2>&1) donne ce code retour: '$?"\n"
 
echo -e "--> Tout le monde est d'accord ? :-)\n"
 
var=$(( 10 - 1 ))
echo -e 'var=$(( 10 - 1 )) donne ce code retour: '$?"\n"
 
var=$(( var = 10 - 1 ))
echo -e 'var=$(( var = 10 - 1 )) donne ce code retour: '$?"\n"
 
echo -e "--> Toujours d'accord ? :-)\n"
 
var=$(( 1 - 1 ))
echo -e 'var=$(( 1 - 1 )) donne ce code retour: '$?"\n"
 
echo -e "--> Normal !\n"
 
echo -e "OK, maintenant ça devient bizarre !\n"
 
(( var = 1 - 1 ))
echo -e '--> (( var = 1 - 1 )) donne ce code retour: '$?"\n"

Et voilà ce que ça donne:

var=$(une_commande_qui_n_existe_pas 1>/dev/null 2>&1) donne ce code retour: 127

var=$(une_commande_qui_réussit 1>/dev/null 2>&1) donne ce code retour: 0

--> Tout le monde est d'accord ? :-)

var=$(( 10 - 1 )) donne ce code retour: 0

var=$(( var = 10 - 1 )) donne ce code retour: 0

--> Toujours d'accord ? :-)

var=$(( 1 - 1 )) donne ce code retour: 0

--> Normal !

OK, maintenant ça devient bizarre !

--> (( var = 1 - 1 )) donne ce code retour: 1

En résumé:

var=$(( 1 - 1 )) donne ce code retour: 0

Mais...

(( var = 1 - 1 )) donne ce code retour: 1

Ça me laisse songeur.

[Flodelarab]

Bonjour

Tout est normal.

((expression))
L'expression est évaluée selon les règles décrites ci-dessous dans ÉVALUATION ARITHMÉTIQUE. Si la valeur arithmétique de l'expression est différente de zéro, l'état renvoyé est 0 ; sinon l'état renvoyé est 1. C'est exactement équivalent à let "expression".

Comme "1-1" vaut zéro, l'évaluation arithmétique renvoie 1.

[NeoType]

OK,
Mais alors pourquoi var=$(( 1 - 1 )) donne 0 en code retour ?

[xdelatour]

Bonjour,

Parce que 1-1 vaut 0

Toujours dans la page de manuel de Bash:

Le développement arithmétique permet de remplacer une expression arithmétique par le résultat de son évaluation. Le format du développement arithmétique est :

$((expression))

[NeoType]

Bon après quelques heures de sommeil, je pense qu'il ne s'agit pas ici de deux syntaxes différentes pour une même commande mais bien de deux "commandes" différentes qui donnent donc des codes retours qui leurs sont propres. De là même façon qu'il est absurde de vouloir comparer les codes retour de grep et de ls ou de find avec wc.
Mon "explication" si j'ose dire vaut ce qu'elle vaut.

La seule chose un peu troublante au final, c'est que pour moi un code retour = 0 est sensé représenter avant tout une "expression valide".
Or manifestement l'expression (( 18 - 18 )) par exemple parfaitement valide renvoie un code retour non nul. (A ne pas confondre avec le résultat du calcul lui-même) On dirait du booléen qui ne dirait pas son nom. Je trouve ça étrange et je ne vois pas d'autre exemple de ce type là tout de suite.
A part les tests du type [ expression ] bien entendu.

Bon, pourquoi pas. Chaque langage a ses petits "délires" propres. Lua que je connais assez bien par exemple a une façon d'envisager le calcul booléen originale.

[N_BaH]

l'assignation (var=peu\ importe) réussit et retourne donc 0.
l'évaluation arithmétique ((( 1-1 ))) retourne 1, parce que pour le shell 0 n'est pas une valeur valide, et est donc est une erreur. Ça a son utilité dans une boucle while par exemple.

[Flodelarab]

Oui ! Toutefois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
$ echo $var
 
$ (( var = 1 - 1 )) 
$ echo $?
1
$ echo $var
0
$ (( var = 3 - 1 )) 
$ echo $?
0
$ echo $var
2

L'assignation a bien été effectuée, dans les deux cas. Et c'est la valeur du calcul qui a été testée pour déterminer la valeur retour de la double parenthèse. Pas l'assignation.

[Sve@r]

Bonjour

Je trouve ça étrange et je ne vois pas d'autre exemple de ce type là tout de suite.

La commande "expr" a le même comportement.
Quand la commande "expr" réussit et affiche une valeur différente de 0, le code retour est 0
Quand la commande "expr" réussit et affiche 0, le code retour est 1
Quand la commande "expr" échoue (erreur de syntaxe ou autre), le code retour est 2.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
$ expr A; echo $?
A
0
$ expr 0; echo $?
0
1
$ expr 1 / 0; echo $?
expr: division par zéro
2

C'est un des rares cas où le code retour 1 ne veut pas dire "erreur"...

La seule chose un peu troublante au final, c'est que pour moi un code retour = 0 est sensé représenter avant tout une "expression valide".

En fait un code retour = 0 représente généralement le fait que le programme invoqué s'est bien déroulé (tu tapes rm -f /tmp l'expression est valide mais le programme "rm" échoue et tu as un code retour à 1). Mais c'est "généralement" et donc il peut exister (et de fait il existe) des programmes qui n'ont pas ce comportement.

Tu peux d'ailleurs parfaitement toi aussi créer un programme analogue. Tu crées un exécutable C qui finit par return 123 et quelle que soit ta façon de l'appeler, tu auras toujours $? qui vaudra 123. Ton programme ne respectera donc pas les conventions mais ce ne sont que des conventions...

lÇa a son utilité dans une boucle while par exemple.

Mouaip. Je reste dubitatif sur l'utilité parce que ça empêche toutes les autres écritures raccourcies style expr ... && echo "ok" || echo "erreur" ou if expr ....
Et même sans ce comportement, on peut quand-même avoir la boucle while (en utilisant alors le résultat du calcul et non le code retour)...

[NeoType]

Oui

Cela dit je sous-entendais par "valide", une syntaxe correcte et qui aboutit ("succeeds").

Or rm -rf / n'aboutit pas (et c'est heureux).
Alors que (( var = 1 - 1 )) aboutit et fournit bien le résultat attendu. (--> $var = 0)

Mais je chipote, en toute rigueur tu as raison.

[N_BaH]

pour la petite histoire, expr est une commande externe* inutile en shell compatible POSIX, contrairement à let qui est une commande interne (builtin) et qui ne fait que de l'évaluation arithmétique.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ let 0; echo $?
1
$

--
* mais elle a le mérite de ne pas faire que de l'évaluation arithmétique

[NeoType]

Comme vous avez tous été très sympa avec moi, j'explique un peu ce que je fais.

C'est un petit projet perso en fait qui traîne depuis au moins 10 ans dans ma tête et mes disques durs pour les premières tentatives.
Et que je viens enfin de finaliser ! J'avoue que je suis un peu content de moi parce que ça marche super bien.
Ca représente un peu moins de 2000 lignes de code que j'ai crachées en une quinzaine de jours à mi-temps.

Le but recherché est d'obtenir des logs uniformisés et facilement exploitables pour mes scripts. Tout en accélérant leur écriture.

L'idée est d'"envelopper" chacun de mes scripts par.... lui-même en fait et d'en reformater les flux stdout et stderr avec sed.
Il suffit pour cela de commencer chaque script par une simple inclusion de fichier via un lien symbolique dans mon $HOME. (en fait il suffit juste que le tout premier scripts, pas forcément les sous-scripts intègre les fonctions qui vont bien)

Et après, ça roule tout seul.
C'est pas magique non plus, ça ne fait ps le boulot tout seul mais ça facilite grandement l'habillage au moins.

Voilà 2 courts scripts bash qui ne font... pas grand chose, c'est juste pour l'exemple.

script1.sh:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#!/bin/bash
 
#Z_FLAG_ZENITY_EXIT=true		# avertissement de fin d'exécution par Zenity
#Z_FLAG_OUTFILE=true		# sortie brute des sous-scripts dans des fichiers '.out'
Z_FLAG_OUTLOG=true			# sortie formatée des sous-scripts dans le log
Z_FLAG_OUTMAINLOG=true		# sortie formatée agrégée dans le log
 
. ~/"Z_kit.sh"; if [ $? -ne 0 ]; then (typeset -r PID=$$; typeset -r MES="`date +%Y-%m-%d\ %T`\n[$0] a échoué !\npid=[$PID]"; echo -e "$MES" 1>&2; (zenity --notification --text="$MES" 2>/dev/null &); (zenity --error --text="$MES" 2>/dev/null &); kill -SIGTERM $PID 1>/dev/null 2>&1); exit 1; fi
 
###############################################################
 
 
Z_help
 
Z_env
 
Z_log "blablabla"
 
ls
 
Z_error "ohh on dirait bien que ça a foiré"
Z_info "tutti va bene !"
 
"$Z_BINDIR/test2.sh"
 
Z_error "ohh on dirait bien que ça a foiré"
Z_info "tutti va bene !"
 
Z_status
 
Z_warning "où suis je ? $(Z_where)"
 
Z_status -g
 
Z_error "décidément rien ne va plus !"
Z_info "tutti va bene !"

-------------------------------------------------
script2.sh:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#!/bin/bash
 
#Z_FLAG_ZENITY_EXIT=true		# avertissement de fin d'exécution par Zenity
#Z_FLAG_OUTFILE=true		# sortie brute des sous-scripts dans des fichiers '.out'
Z_FLAG_OUTLOG=true			# sortie formatée des sous-scripts dans le log
Z_FLAG_OUTMAINLOG=true		# sortie formatée agrégée dans le log
 
. ~/"Z_kit.sh"; if [ $? -ne 0 ]; then (typeset -r PID=$$; typeset -r MES="`date +%Y-%m-%d\ %T`\n[$0] a échoué !\npid=[$PID]"; echo -e "$MES" 1>&2; (zenity --notification --text="$MES" 2>/dev/null &); (zenity --error --text="$MES" 2>/dev/null &); kill -SIGTERM $PID 1>/dev/null 2>&1); exit 1; fi
 
###############################################################
 
ls sdlkjfglkdsjlgkj
 
Z_error "ohh on dirait bien que ça a foiré"
Z_info "tutti va bene !"
 
Z_quit "on arrête là ?"
Z_log "ou on continue ?"

-------------------------------------------------
quelques fonctions de base:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
function Z_int  { case ${1#[-+]} in '' | *[!0-9]*              ) return 1;; esac ;} # ATTENTION rupture du flux de $?
typeset -frx Z_int
 
function Z_info # écrit un message d'information sur &2: si $? -eq 0 --> formate "$@" >&2; return $?
{
	typeset my_code=$?
	[ $my_code -eq 0 ] && sed "s/^/I: $ZZ_TAB/" <<< "$@" 1>&2
	return $my_code
}
typeset -frx Z_info
 
function Z_quit # si $? -ne 0 --> exit $? sinon return 0 ATTENTION sortie anticipée
{
	typeset my_code=$?
	if [ $my_code -ne 0 ]
	then
		[ $# -eq 0 ]; Z_error "$@"
		[ ! 0 ]
		Z_error -s "Sortie anticipée dans [$$] [$0]"
		Z_error -s "$(Z_where -A)"
		exit $my_code
	fi
	return 0
}
typeset -frx Z_quit
 
function Z_status # ATTENTION modification du flux de $?
{
#	Z_echo "[$@] ZZ_STATUS = [$ZZ_STATUS]"
 
	typeset my_code=$?
#	ZZ_STATUS=${ZZ_STATUS:-0}
 
	if [ $# -eq 1 ]
	then
 
		case ${1} in
		-v) # Z_echo "[$@] si my_code = [$my_code] est non nul alors enregistrement dans ZZ_STATUS = [$ZZ_STATUS] puis echo et return de ZZ_STATUS"
#			le but ici est de faire un echo d'un status précédemment enregistré en consevvant le flux de $? (à utiliser typiquement en argument d'une fonction d'affichage) ATTENTION Le flux de $? est interrompu.
#			Z_echo "[$@] si my_code = [$my_code] est non nul alors enregistrement dans ZZ_STATUS = [$ZZ_STATUS] puis echo et return de ZZ_STATUS"
			[ $my_code -ne 0 ] && ZZ_STATUS=$my_code || ZZ_STATUS=${ZZ_STATUS:-0}
#			Z_echo "[$@] ZZ_STATUS = [$ZZ_STATUS]"
			echo "$ZZ_STATUS"
			return $ZZ_STATUS;;
 
		-g) # Z_echo "[$@] return simple de ZZ_STATUS = [$ZZ_STATUS]" 1>&2
#			le but ici est de restaurer un flux précédemment intrerrompu. ATTENTION Le flux de $? est interrompu.
#			Z_echo "[$@] return simple de ZZ_STATUS = [$ZZ_STATUS]"
			ZZ_STATUS=${ZZ_STATUS:-0}
#			Z_echo "[$@] maintenant ZZ_STATUS = [$ZZ_STATUS]"
			return $ZZ_STATUS;;
 
		*) # Z_echo "[$@] si l'argument = [$1] est non nul alors enregistrement dans ZZ_STATUS = [$ZZ_STATUS] puis return de l'argument"
#			le but ici est d'enregistrer un code status général personnalisé (mais uniquement si non nul). ATTENTION Le flux de $? est interrompu.
			Z_int "$1"
			Z_kill "Usage: argument 1:[$1] invalide"
 
#			Z_echo "[$@] si l'argument = [$1] est non nul alors enregistrement dans ZZ_STATUS = [$ZZ_STATUS] puis return de l'argument"
			[ $1 -ne 0 ] && ZZ_STATUS=$1
#			Z_echo "[$@] maintenant ZZ_STATUS = [$ZZ_STATUS]"
			return $1;;
 
		esac
 
	elif [ $# -ge 2 ] # Usage invalide
	then
			Z_kill "Usage: trop d'arguments @:[$@]"
	fi
 
#	Z_echo "[$@] si my_code = [$my_code] est non nul alors enregistrement dans ZZ_STATUS = [$ZZ_STATUS] puis return de my_code"
#	le but ici est d'enregistrer le flux de $?.
	[ $my_code -ne 0 ] && ZZ_STATUS=$my_code
#	Z_echo "[$@] maintenant ZZ_STATUS = [$ZZ_STATUS]"
	return $my_code
}
typeset -frx Z_status

-------------------------------------------------

Le log obtenu: (j'utilise la balise code au lieu de quote sinon les tabulations disparaissent.)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
Z:  -------------------------------------------------------------------------
Z: |           ZZ_checkConfig [223] (source) [/home/jf/Z_kit.sh]
Z:  -------------------------------------------------------------------------
Z: | script: [/home/jf/Documents/Z_KIT/BIN/test.sh]
Z: | pwd: [/home/jf/Documents/Z_KIT/BIN]
Z: | log: [/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/?_MAINLOG.log]
Z: | --------------------
Z: | -> [OK] Accès répertoire ZZ_HOME [/home/jf/Documents/Z_KIT]
Z: | -> [OK] Accès répertoire ZZ_LOGDIR [/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/LOG]
Z: | -> [OK] Accès répertoire ZZ_TMPDIR [/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/TMP]
Z: | -> [OK] Accès répertoire ZZ_OUTDIR [/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/OUT]
Z: | -> [OK] Accès répertoire ZZ_LIBDIR [/home/jf/Documents/Z_KIT/LIB]
Z: | -> [OK] Accès répertoire Z_BINDIR [/home/jf/Documents/Z_KIT/BIN]
Z: | --------------------
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/files.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/logs.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/processing.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/settings.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/status.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/time.sh]
Z: | -> [OK] Inclusion de la bibliothèque [/home/jf/Documents/Z_KIT/LIB/Z_kit/types.sh]
Z: | --------------------
Z: | -> [FALSE] avertissement de fin d'exécution par Zenity (Z_FLAG_ZENITY_EXIT)
Z: | -> [FALSE] sortie brute des sous-scripts dans des fichiers '.out' (Z_FLAG_OUTFILE)
Z: | -> [TRUE] sortie formatée des sous-scripts dans le log (Z_FLAG_OUTLOG)
Z: | -> [TRUE] sortie formatée agrégée dans le log (Z_FLAG_OUTMAINLOG)
Z:  -------------------------------------------------------------------------
S: 
S:  -------------------------------------------------------------------------
S: |           Lancement [/home/jf/Documents/Z_KIT/BIN/test.sh] [8] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh]
S: | -> [8] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh]
S: | -> [227] (source) [/home/jf/Z_kit.sh]
S: | -> [19] (ZZ_parser) [/home/jf/Documents/Z_KIT/LIB/Z_kit/processing.sh]
S: | (2023-10-13 21:24:14) Début: [352516] [352481] [/home/jf/Documents/Z_KIT/BIN/test.sh]
S:  -------------------------------------------------------------------------
S: 
Z:     
Z:      -------------------------------------------------------------------------
Z:     |           Z_help [13] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh]
Z:      -------------------------------------------------------------------------
Z:     | command: [/home/jf/Documents/Z_KIT/BIN/test.sh] (0)
Z:     | funcname: [Z_help main]
Z:     | lines: [13 0]
Z:     | sources: [environment /home/jf/Documents/Z_KIT/BIN/test.sh]
Z:     | --------------------
Z:     | script: [/home/jf/Documents/Z_KIT/BIN/test.sh]
Z:     | realpath: [/home/jf/Documents/Z_KIT/BIN/test.sh]
Z:     | --------------------
Z:     | pstree: systemd(1,1)---systemd(7893,7893)---gnome-terminal-(352481,352481)---test.sh(352516,352516)---test.sh(352626,352516)---pstree(352643,352516)
Z:     | first pid: [352516]
Z:     | pid: [352626]
Z:     | ppid: [352516]
Z:     | --------------------
Z:     | pwd: [/home/jf/Documents/Z_KIT/BIN]
Z:     | user: [jf]
Z:     | bash: [5 2 15 1 release x86_64-redhat-linux-gnu]
Z:     | hostname: [fedora]
Z:      -------------------------------------------------------------------------
Z:     
Z:     
Z:      -------------------------------------------------------------------------
Z:     |           Z_env [15] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh]
Z:      -------------------------------------------------------------------------
Z:     | -------- 36 fonctions Z_kit trouvées:
Z:     | ZZ_debug () 
Z:     | declare -fx ZZ_debug
Z:     | ZZ_debug_date () 
Z:     | declare -fx ZZ_debug_date
Z:     | ZZ_parser () 
Z:     | declare -fx ZZ_parser
Z:     | ZZ_special () 
Z:     | declare -fx ZZ_special
Z:     | ZZ_special_date () 
Z:     | declare -fx ZZ_special_date
Z:     | Z_check () 
Z:     | declare -fx Z_check
Z:     | Z_date () 
Z:     | declare -fx Z_date
Z:     | Z_echo () 
Z:     | declare -fr Z_echo
Z:     | Z_env () 
Z:     | declare -fx Z_env
Z:     | Z_error () 
Z:     | declare -fx Z_error
Z:     | Z_error_date () 
Z:     | declare -fx Z_error_date
Z:     | Z_help () 
Z:     | declare -fx Z_help
Z:     | Z_info () 
Z:     | declare -fx Z_info
Z:     | Z_info_date () 
Z:     | declare -fx Z_info_date
Z:     | Z_int () 
Z:     | declare -fx Z_int
Z:     | Z_kill () 
Z:     | declare -fx Z_kill
Z:     | Z_lib () 
Z:     | declare -fx Z_lib
Z:     | Z_log () 
Z:     | declare -fx Z_log
Z:     | Z_log_date () 
Z:     | declare -fx Z_log_date
Z:     | Z_logfile () 
Z:     | declare -fx Z_logfile
Z:     | Z_nohup () 
Z:     | declare -fx Z_nohup
Z:     | Z_num () 
Z:     | declare -fx Z_num
Z:     | Z_outfile () 
Z:     | declare -fx Z_outfile
Z:     | Z_quit () 
Z:     | declare -fx Z_quit
Z:     | Z_reverse () 
Z:     | declare -fx Z_reverse
Z:     | Z_run () 
Z:     | declare -fx Z_run
Z:     | Z_status () 
Z:     | declare -fx Z_status
Z:     | Z_test () 
Z:     | declare -fx Z_test
Z:     | Z_time () 
Z:     | declare -fx Z_time
Z:     | Z_timer () 
Z:     | declare -fx Z_timer
Z:     | Z_tmpfile () 
Z:     | declare -fx Z_tmpfile
Z:     | Z_uint () 
Z:     | declare -fx Z_uint
Z:     | Z_unum () 
Z:     | declare -fx Z_unum
Z:     | Z_warning () 
Z:     | declare -fx Z_warning
Z:     | Z_warning_date () 
Z:     | declare -fx Z_warning_date
Z:     | Z_where () 
Z:     | declare -fx Z_where
Z:     | 
Z:     | -------- 21 variables Z_kit trouvées:
Z:     | declare -x ZZ_FIRSTPID="352516"
Z:     | declare -x ZZ_HOME="/home/jf/Documents/Z_KIT"
Z:     | declare -x ZZ_INSTANCE="/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC"
Z:     | declare -x ZZ_KIT=""
Z:     | declare -x ZZ_LIBDIR="/home/jf/Documents/Z_KIT/LIB"
Z:     | declare -x ZZ_LOGDIR="/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/LOG"
Z:     | declare -x ZZ_MAINLOG="2023-10-13_21-24-14_352516_352516_MAINLOG_test.sh.log"
Z:     | declare -x ZZ_OUTDIR="/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/OUT"
Z:     | declare -x ZZ_PID="352626"
Z:     | declare -i ZZ_STATUS
Z:     | declare -x ZZ_TAB="    | "
Z:     | declare -x ZZ_TABULATION="    "
Z:     | declare -x ZZ_TAB_SAV="    "
Z:     | declare -x ZZ_TMPDIR="/home/jf/Documents/Z_KIT/INSTANCES/2023-10-13_21-24-14_test.sh_352516_352516_jTC/TMP"
Z:     | declare -x Z_BINDIR="/home/jf/Documents/Z_KIT/BIN"
Z:     | declare -x Z_FLAG_OUTFILE="FALSE"
Z:     | declare -x Z_FLAG_OUTLOG="true"
Z:     | declare -- Z_FLAG_OUTMAINLOG="true"
Z:     | declare -- Z_env_my_code="0"
Z:     | declare -- Z_env_my_count="36"
Z:     | declare -- Z_env_my_res=$'ZZ_debug () \ndeclare -fx ZZ_debug\nZZ_debug_date () \ndeclare -fx ZZ_debug_date\nZZ_parser () \ndeclare -fx ZZ_parser\nZZ_special () \ndeclare -fx ZZ_special\nZZ_special_date () \ndeclare -fx ZZ_special_date\nZ_check () \ndeclare -fx Z_check\nZ_date () \ndeclare -fx Z_date\nZ_echo () \ndeclare -fr Z_echo\nZ_env () \ndeclare -fx Z_env\nZ_error () \ndeclare -fx Z_error\nZ_error_date () \ndeclare -fx Z_error_date\nZ_help () \ndeclare -fx Z_help\nZ_info () \ndeclare -fx Z_info\nZ_info_date () \ndeclare -fx Z_info_date\nZ_int () \ndeclare -fx Z_int\nZ_kill () \ndeclare -fx Z_kill\nZ_lib () \ndeclare -fx Z_lib\nZ_log () \ndeclare -fx Z_log\nZ_log_date () \ndeclare -fx Z_log_date\nZ_logfile () \ndeclare -fx Z_logfile\nZ_nohup () \ndeclare -fx Z_nohup\nZ_num () \ndeclare -fx Z_num\nZ_outfile () \ndeclare -fx Z_outfile\nZ_quit () \ndeclare -fx Z_quit\nZ_reverse () \ndeclare -fx Z_reverse\nZ_run () \ndeclare -fx Z_run\nZ_status () \ndeclare -fx Z_status\nZ_test () \ndeclare -fx Z_test\nZ_time () \ndeclare -fx Z_time\nZ_timer () \ndeclare -fx Z_timer\nZ_tmpfile () \ndeclare -fx Z_tmpfile\nZ_uint () \ndeclare -fx Z_uint\nZ_unum () \ndeclare -fx Z_unum\nZ_warning () \ndeclare -fx Z_warning\nZ_warning_date () \ndeclare -fx Z_warning_date\nZ_where () \ndeclare -fx Z_where'
Z:      -------------------------------------------------------------------------
Z:     
I:     blablabla
I:     tutti va bene !
S:     
S:      -------------------------------------------------------------------------
S:     |           Lancement [/home/jf/Documents/Z_KIT/BIN/test2.sh] [8] (main) [/home/jf/Documents/Z_KIT/BIN/test2.sh]
S:     | -> [8] (main) [/home/jf/Documents/Z_KIT/BIN/test2.sh]
S:     | -> [25] (source) [/home/jf/Z_kit.sh]
S:     | (2023-10-13 21:24:14) Début: [352684] [352626] [/home/jf/Documents/Z_KIT/BIN/test2.sh]
S:      -------------------------------------------------------------------------
S:     
?: ls: impossible d'accéder à 'sdlkjfglkdsjlgkj': Aucun fichier ou dossier de ce type
E:         [14] (main) [/home/jf/Documents/Z_KIT/BIN/test2.sh] ohh on dirait bien que ça a foiré
E:         [3] (Z_quit) [environment] on arrête là ?
E:         Sortie anticipée dans [352701] [/home/jf/Documents/Z_KIT/BIN/test2.sh]
E:         -> [17] (main) [/home/jf/Documents/Z_KIT/BIN/test2.sh]
E:         -> [6] (Z_quit) [environment]
S:     
S:      -------------------------------------------------------------------------
S:     | (2023-10-13 21:24:14) Fin: [352684] [352626] [/home/jf/Documents/Z_KIT/BIN/test2.sh]
E:     | Status: [2]
S:     | Durée d'exécution: [0 seconde]
S:      -------------------------------------------------------------------------
S:     
E:     [26] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh] ohh on dirait bien que ça a foiré
W:     [31] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh] où suis je ? [31] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh]
E:     [35] (main) [/home/jf/Documents/Z_KIT/BIN/test.sh] décidément rien ne va plus !
S: 
S:  -------------------------------------------------------------------------
S: | (2023-10-13 21:24:14) Fin: [352516] [352481] [/home/jf/Documents/Z_KIT/BIN/test.sh]
E: | Status: [2]
S: | Durée d'exécution: [0 seconde]
S: | Avertissements: [1] ligne(s) détectée(s)
S: | Erreurs: [9] ligne(s) détectée(s)
S: | Shell: [1] ligne(s) détectée(s)
S: | Log: [/home/jf/Documents/Z_KIT/INSTANCES/KO_2023-10-13_21-24-14_test.sh_352516_352516_jTC/KO_MAINLOG.log
S: | --------------------
S: | Output: [9] ligne(s) dans le fichier [/home/jf/Documents/Z_KIT/INSTANCES/KO_2023-10-13_21-24-14_test.sh_352516_352516_jTC/OUT/2023-10-13_21-24-14_MAINOUT_5y4X.out]
O: | test0.sh
O: | test1.sh
O: | test2.sh
O: | test3.sh
O: | test4.sh
O: | test5.sh
O: | test6.sh
O: | test.sh
O: | to to.sh
S:  -------------------------------------------------------------------------
S:

-------------------------------------------------

Dans le log, chaque ligne débute par un tag. (grep est mon ami)
Z: --> débogage
S: --> pour obtenir un résumé de l'exécution.
I: --> purement informatif
E: --> lignes en erreur, explicites par le développeur.
W: --> simples warning, explicites par le développeur.
?: --> "erreurs shell", émises sur stderr typiquement par des commandes foireuses.
O: --> lignes brutes émises sur stdout. Utile pour "piper" le script par exemple. Tout en ayant une trace de ce qui sort.

Je vends mon petit kit allez 2000 Euros ? Sérieusement, il me reste quelques trucs à faire encore.
Une petite bibliothèque de fonctions:
- pour gérer les signaux.
- pour yad (un genre de zenity plus complet pour construire des interfaces graphiques simples)
- pour interfacer un sgbd quelconque
- pour quelques outils web comme wget
- autres ?

Et voilà !

Eviter les remarques futiles sur le code svp. Par exemple si je mets des typeset superflus partout, ce n'est pas juste parce que je suis mauvais codeur. Mais ça sert à faciliter la gestion de mes codes sources.
Quant au reste, je ne prétends pas que c'est parfaitement écrit.

A l'exécution, c'est forcément plus lourd, mais ce n'est pas non plus dément.

Mais si vous avez des remarques constructives, ça m'intéresse. Je ne m'appelle pas Linus, ni Richard

PS: désolé pour le bavardage. ^^

[Sve@r]

Mais si vous avez des remarques constructives, ça m'intéresse.

Ben... il nous faudrait "Z_kit.sh" pour ça... Après si c'est ça que tu vends 2000€...

Ce que j'aime bien c'est que tu prends soin de quoter tes chemins (exemple ~/"Z_kit.sh" et non ~/Z_kit.sh même si ce n'est pas vraiment utile ici c'est une bonne habitude).

Ce qui me fait un peu tiquer c'est ce . ~/"Z_kit.sh"; if [ $? -ne 0 ]; then (typeset -r PID=$$; typeset -r MES="`date +%Y-%m-%d\ %T`\n[$0] a échoué !\npid=[$PID]"; echo -e "$MES" 1>&2; (zenity --notification --text="$MES" 2>/dev/null &); (zenity --error --text="$MES" 2>/dev/null &); kill -SIGTERM $PID 1>/dev/null 2>&1); exit 1; fi. Ecrire un truc rapide sur une ligne c'est bien, écrire un gros truc immonde sur une ligne ça devient immonde (c'est pas le truc qui est immonde, c'est qu'il soit écrit sur une ligne).
Et puis source plutôt que "." et $(cmd) plutôt que `cmd` (ça ne coûte pas grand chose d'être explicite et ça aide à la lecture...)

Et puis grâce à toi je découvre "yad" que je ne connaissais pas...

[NeoType]

Merci Sver,

A une époque, j'avais utilisé deux ou trois fois pour voir un petit outil qui vérifiait la conformité de la syntaxe avec les standards.
Mais j'ai complètement oublié comment ça s'appelait, ça devrait se retrouver facilement.

La ligne d'inclusion est pourrie, c'est normal. Je n'y ai mis aucun soin. Et il n'y a pas de bonne raison de la développer sur plusieurs lignes.

C'est juste mon dernier petit joujou perso, et ce n'est pas destiné à être publié (ni encore moins vendu) à priori. C'est juste du code shell Pour moi ça n'a aucune valeur.
En plus ça s'appuie sur des fonctionnalités de la version de bash actuelle (je vous invite à faire un "set" ou un "env" dans vos terminaux).

Mais ça va peut-être me faciliter la vie pour développer quelques outils d'administration système, des outils de gestion de mes recettes de cuisine, de mes fichiers vidéo/photos, faire du "scrap" de sites web divers... Ou pas, je ne sais pas. C'est pour ça que j'ai pondu ce truc sur une vieille idée que j'avais eue dans un taf il y a 10 ans.)

Je sais aussi qu'il existe un "compilateur de scripts shell" (source Adrien de LinuxTricks). Je ne sais pas ce que ça vaut, il faudrait que je teste ça un jour.

[Sve@r]

Mais j'ai complètement oublié comment ça s'appelait, ça devrait se retrouver facilement.

J'ai trouvé ça...

Je sais aussi qu'il existe un "compilateur de scripts shell" (source Adrien de LinuxTricks). Je ne sais pas ce que ça vaut, il faudrait que je teste ça un jour.

https://www.linuxtricks.fr/wiki/shc-...un-script-bash

[NeoType]

Oui c'est bien ça. (j'avais recherché de mon côté entre temps)

Bon allez, il est temps de passer tout ça en <résolu>

Bon week-end à tous, merci