Chapitre 12. Programmation

La commande « echo » doit être utilisée avec les précautions suivantes car son implémentation diffère selon que l’on utilise les commandes internes ou externes de l’interpréteur de commandes :

	Note
	Bien que l’option « -n » ne soit pas vraiment de la syntaxe POSIX, elle est généralement acceptée.

	Astuce
	Utilisez la commande « printf » plutôt que la commande « echo » si vous avez besoin d’intégrer des séquences d’échappement dans la chaîne de sortie.

Des paramètres spéciaux de l’interpréteur de commandes sont souvent utilisés dans les scripts de l’interpréteur de commandes.

Les expansions de paramètre les plus courantes à retenir sont mentionnées ci-dessous :

Ici, les deux points « : » dans tous ces opérateurs sont en fait optionnels.

Chaque commande retourne un état de sortie qui peut être utilisé pour des expressions conditionnelles.

	Note
	« 0 » dans le contexte conditionnel de l’interpréteur signifie « Vrai » alors que « 0 » dans le contexte conditionnel de C signifie « Faux ».

	Note
	« [ » est l’équivalent de la commande test, qui évalue, comme expression conditionnelle, les paramètres jusqu’à « ] ».

Les idiomes conditionnels de base à retenir sont les suivants :

if [ conditional_expression ]; then
 if_success_run_this_command
else
 if_not_success_run_this_command
fi

Ici, le « || true » était nécessaire pour s’assurer que ce script de l’interpréteur ne se termine pas accidentellement à cette ligne lorsque l’interpréteur est appelé avec l’indicateur « -e ».

Les opérateurs de comparaison arithmétique entière dans les expressions conditionnelles sont « -eq », « -ne », « -lt », « -le », « -gt » et « -ge ».

Il existe un certains nombre d’idiomes de boucles qu’on peut utiliser avec un interpréteur de commandes POSIX.

	Astuce
	Les itérations numériques semblables à celles du langage C peuvent être réalisées en utilisant seq(1) comme générateur de « toto1 toto2 … ».

	Astuce
	Consultez Section 9.4.9, « Répéter une commande en bouclant entre des fichiers ».

Certaines variables d’environnement populaires pour l’invite de commande normale de l’interpréteur peuvent ne pas être disponibles dans l’environnement d’exécution de votre script.

En gros, l’interpréteur de commandes traite un script de la manière suivante :

Des guillemets simples dans des guillemets doubles n’ont pas d’effet.

Exécuter « set -x » dans le script de l’interpréteur ou l’appel du script avec l’option « -x » fait imprimer par l’interpréteur de commandes toutes les commandes exécutées. C’est assez pratique pour le débogage.

De façon à rendre vos programmes de l’interpréteur de commandes aussi portables que possible dans tous les systèmes Debian, c’est une bonne idée de limiter les programmes utilitaires à ceux fournis par les paquets essentiels.

La plupart des interpréteurs offrent des fonctionnalités de base de vérification de la syntaxe et de traçage du code :

Le script d’interpréteur peut être amélioré pour créer un programme graphique attrayant. L’astuce consiste à utiliser l’un des programmes dits de dialogue au lieu d’une interaction insipide utilisant les commandes echo et read.

Voici un exemple de programme graphique pour démontrer à quel point c’est facile avec un script d’interpréteur.

Ce script utilise zenity pour sélectionner un fichier (par défaut /etc/motd) et l'afficher.

Les programmes graphiques de gestionnaire de fichiers peuvent être étendus pour effectuer certaines actions fréquentes sur les fichiers sélectionnés à l’aide de paquets d’extension supplémentaires. Ils peuvent également effectuer des actions personnalisées très spécifiques en ajoutant vos scripts personnels.

Pour traiter les données, sh doit générer un sous-processus exécutant cut, grep, sed, etc., et est lent. D’autre part, perl a des capacités internes pour traiter les données et est rapide. Un certain nombre de scripts d’entretien du système Debian utilisent perl.

Considérons un bout de code uniligne en AWK et ses équivalents en Perl :

awk '($2=="1957") { print $3 }' |

Il est équivalent à l’une quelconque des lignes suivantes :

perl -ne '@f=split; if ($f[1] eq "1957") { print "$f[2]\n"}' |

perl -ne 'if ((@f=split)[1] eq "1957") { print "$f[2]\n"}' |

perl -ne '@f=split; print $f[2] if ( $f[1]==1957 )' |

perl -lane 'print $F[2] if $F[1] eq "1957"' |

perl -lane 'print$F[2]if$F[1]eq+1957' |

La dernière est une devinette. Elle tire parti des fonctionnalités suivantes de Perl :

Cette flexibilité est la force de Perl. En même temps, cela nous permet de créer des codes énigmatiques et fouillis. Soyez donc prudent.

Un exemple simple « example.c » peut être compilé avec la bibliothèque « libm » pour donner l’exécutable « run_example » par ce qui suit :

$ cat > example.c << EOF
#include <stdio.h>
#include <math.h>
#include <string.h>

int main(int argc, char **argv, char **envp){
        double x;
        char y[11];
        x=sqrt(argc+7.5);
        strncpy(y, argv[0], 10); /* prevent buffer overflow */
        y[10] = '\0'; /* fill to make sure string ends with '\0' */
        printf("%5i, %5.3f, %10s, %10s\n", argc, x, y, argv[1]);
        return 0;
}
EOF
$ gcc -Wall -g -o run_example example.c -lm
$ ./run_example
        1, 2.915, ./run_exam,     (null)
$ ./run_example 1234567890qwerty
        2, 3.082, ./run_exam, 1234567890qwerty

Ici, « -lm » est nécessaire pour lier la bibliothèque « /usr/lib/libm.so » depuis le paquet libc6 pour sqrt(3). La bibliothèque réelle se trouve dans « /lib/ » avec le nom de fichier « libm.so.6 » avec un lien symbolique vers « libm-2.7.so ».

Regardez le dernier paramètre du texte en sortie. Il y a plus de 10 caractères bien que « %10s » soit indiqué.

L’utilisation de fonctions effectuant des opérations sur des pointeurs en mémoire sans vérification des limites, telles que sprintf(3) et strcpy(3) a été rendue obsolète afin d’éviter les exploits de débordements de tampons qui utilisent les effets des débordements ci-dessus. Utilisez snprintf(3) et strncpy(3) en remplacement..

On trouve un didacticiel de bison(1) dans « info bison ».

Vous devez fournir vos propre « main() » et « yyerror() ». « main() » appelle « yyparse() » qui appelle « yylex() », habituellement créé avec Flex.

Voici un exemple de création de programme de calcul dans un terminal.

Créons example.y :

/* calculator source for bison */
%{
#include <stdio.h>
extern int yylex(void);
extern int yyerror(char *);
%}

/* declare tokens */
%token NUMBER
%token OP_ADD OP_SUB OP_MUL OP_RGT OP_LFT OP_EQU

%%
calc:
 | calc exp OP_EQU    { printf("Y: RESULT = %d\n", $2); }
 ;

exp: factor
 | exp OP_ADD factor  { $$ = $1 + $3; }
 | exp OP_SUB factor  { $$ = $1 - $3; }
 ;

factor: term
 | factor OP_MUL term { $$ = $1 * $3; }
 ;

term: NUMBER
 | OP_LFT exp OP_RGT  { $$ = $2; }
  ;
%%

int main(int argc, char **argv)
{
  yyparse();
}

int yyerror(char *s)
{
  fprintf(stderr, "error: '%s'\n", s);
}

Créons example.l :

/* calculator source for flex */
%{
#include "example.tab.h"
%}

%%
[0-9]+ { printf("L: NUMBER = %s\n", yytext); yylval = atoi(yytext); return NUMBER; }
"+"    { printf("L: OP_ADD\n"); return OP_ADD; }
"-"    { printf("L: OP_SUB\n"); return OP_SUB; }
"*"    { printf("L: OP_MUL\n"); return OP_MUL; }
"("    { printf("L: OP_LFT\n"); return OP_LFT; }
")"    { printf("L: OP_RGT\n"); return OP_RGT; }
"="    { printf("L: OP_EQU\n"); return OP_EQU; }
"exit" { printf("L: exit\n");   return YYEOF; } /* YYEOF = 0 */
.      { /* ignore all other */ }
%%

Puis exécutons comme suit à partir de l’invite de l’interpréteur pour tester cet exemple :

$ bison -d example.y
$ flex example.l
$ gcc -lfl example.tab.c lex.yy.c -o example
$ ./example
1 + 2 * ( 3 + 1 ) =
L: NUMBER = 1
L: OP_ADD
L: NUMBER = 2
L: OP_MUL
L: OP_LFT
L: NUMBER = 3
L: OP_ADD
L: NUMBER = 1
L: OP_RGT
L: OP_EQU
Y: RESULT = 9

exit
L: exit

Si vous rencontrez un plantage de programme, signaler le bogue avec un copier-coller des informations de trace est une bonne idée.

La trace d’appels peut être obtenue avec gdb en utilisant une des manières suivantes :

Utilisez ldd(1) pour trouver les dépendances d’un programme avec des bibliothèques :

$ ldd /usr/bin/ls
        librt.so.1 => /lib/librt.so.1 (0x4001e000)
        libc.so.6 => /lib/libc.so.6 (0x40030000)
        libpthread.so.0 => /lib/libpthread.so.0 (0x40153000)
        /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

Pour que ls(1) fonctionne dans un environnement `chroot`é, les bibliothèques ci-dessus doivent être disponibles dans votre environnement `chroot`é.

Si un programme apercu1 de GNOME a reçu une erreur X, vous devriez obtenir un message comme suit :

The program 'preview1' received an X Window System error.

Dans ce cas, vous pouvez essayer de faire tourner le programme avec « --sync » et arrêter sur la fonction « gdk_x_error » de manière à obtenir une trace.

Il y a plusieurs outils de détection des fuites de mémoire disponibles sous Debian.

Vous pouvez désassembler du code binaire avec objdump(1) en faisant ce qui suit :

$  objdump -m i386 -b binary -D /usr/lib/grub/x86_64-pc/stage1

	Note
	gdb(1) peut être utilisé pour désassembler du code de manière interactive.

Exécutez « make -p -f/dev/null » afin de voir les règles automatiques internes.

Le système de construction des logiciels a évolué :