Introduction à la programmation en Bash

En premier lieu, un shell doit fournir un environnement de travail agréable et puissant. Par exemple, bash permet (entre autres) :

• le rappel des commandes précédentes (gestion de l’historique) ; cela évite de taper plusieurs fois la même commande
• la modification en ligne du texte de la commande courante (ajout, retrait, remplacement de caractères) en utilisant les commandes d’édition de l’éditeur de texte vi ou emacs
• la gestion des travaux lancés en arrière-plan (appelés jobs) ; ceux-ci peuvent être démarrés, stoppés ou repris suivant les besoins
• l’initialisation adéquate de variables de configuration (chaîne d’appel de l’interpréteur, chemins de recherche par défaut) ou la création de raccourcis de commandes (commande alias).

Illustrons cet ajustement de configuration par un exemple. Le shell permet d’exécuter une commande en mode interactif ou bien par l'intermédiaire de fichiers de commandes (scripts). En mode interactif, bash affiche à l’écran une chaîne d’appel (appelée également prompt ou invite), qui se termine par défaut par le caractère # suivi d’un caractère espace pour l’administrateur système (utilisateur root) et par le caractère $ suivi d’un caractère espace pour les autres utilisateurs. Cette chaîne d’appel peut être relativement longue.

sanchis@jade:/bin$

Celle-ci est constituée du nom de connexion de l’utilisateur (sanchis), du nom de la machine sur laquelle l’utilisateur travaille (jade) et du chemin absolu du répertoire courant de l’utilisateur (/bin). Elle indique que le shell attend que l’utilisateur saisisse une commande et la valide en appuyant sur la touche entrée. Bash exécute alors la commande puis réaffiche la chaîne d’appel. Si l’on souhaite raccourcir cette chaîne d’appel, il suffit de modifier la valeur de la variable prédéfinie du shell PS1 (Prompt Shell 1).

sanchis@jade:/bin$ PS1='$ '
$ pwd
  /home/sanchis 	=> pwd affiche le chemin absolu du répertoire courant
$

La nouvelle chaîne d’appel est constituée par le caractère $ suivi d’un caractère espace.

Les shells ne sont pas seulement des interpréteurs de commandes mais également de véritables langages de programmation. Un shell comme bash intègre :

• les notions de variable, d’opérateur arithmétique, de structure de contrôle, de fonction, présentes dans tout langage de programmation classique, mais aussi
• des opérateurs spécifiques (ex : |, ;)

$ a=5			=> affectation de la valeur 5 à la variable a
$
$ echo $((a +3 ))	=> affiche la valeur de l’expression a+3
8
$

L’opérateur |, appelé tube, est un opérateur caractéristique des shells et connecte la sortie d’une commande à l’entrée de la commande suivante.

$ ruptime
iutbis        up
jade          up
mobile1       up
mobile2       up
quartz        up
sigma         up
$
$ ruptime | wc -l
6
$

La commande unix ruptime affiche les noms et autres informations relatives aux machines visibles sur le réseau. La commande unix wc munie de l’option l affiche le nombre de lignes qu’elle a été en mesure de lire. (La commande ruptime est contenue dans le paquetage rwho. Ce paquetage n’est pas systématiquement installé par les distributions Linux.)
En connectant avec un tube la sortie de ruptime à l’entrée de la commande wc –l, on obtient le nombre de machines visibles du réseau.

Même si au fil du temps de nouveaux types de données comme les entiers ou les tableaux ont été introduits dans certains shells, ces derniers manipulent essentiellement des chaînes de caractères :
ce sont des langages de programmation orientés chaînes de caractères. C’est ce qui rend les shells à la fois si puissants et si délicats à utiliser.

L’objet de ce document est de présenter de manière progressive les caractéristiques de bash comme langage de programmation.

L’étude d’un shell tel que bash en tant que langage de programmation possède plusieurs avantages :

• c’est un langage interprété : les erreurs peuvent être facilement localisées et traitées ; d’autre part, des modifications de fonctionnalités sont facilement apportées à l’application sans qu’il soit nécessaire de recompiler et faire l’édition de liens de l’ensemble
• le shell manipule essentiellement des chaînes de caractères: on ne peut donc construire des structures de données complexes à l’aide de pointeurs, ces derniers n’existant pas en shell. Ceci a pour avantage d’éviter des erreurs de typage et de pointeurs mal gérés. Le développeur raisonne de manière uniforme en termes de chaînes de caractères
• le langage est adapté au prototypage rapide d’applications : les tubes, les substitutions de commandes et de variables favorisent la construction d’une application par assemblage de commandes préexistantes dans l’environnement Unix
• c’est un langage « glu » : il permet de connecter des composants écrits dans des langages différents. Ces derniers doivent uniquement respecter quelques règles particulièrement simples. Le composant doit être capable : de lire sur l’entrée standard, d’accepter des arguments et options éventuels, d’écrire ses résultats sur la sortie standard, d’écrire les messages d’erreur sur la sortie standard dédiée aux messages d’erreur.

Cependant, bash et les autres shells en général ne possèdent pas que des avantages :

• issus d’Unix, système d’exploitation écrit à l’origine par des développeurs pour des développeurs, les shells utilisent une syntaxe « ésotérique » d’accès difficile pour le débutant
• l’oubli ou l’ajout d’un caractère espace provoque facilement une erreur de syntaxe
• bash possède plusieurs syntaxes pour implanter la même fonctionnalité, comme la substitution de commande ou l’écriture d’une chaîne à l’écran. Cela est principalement dû à la volonté de fournir une compatibilité ascendante avec le Bourne shell, shell historique des systèmes Unix
• certains caractères spéciaux, comme les parenthèses, ont des significations différentes suivant le contexte ; en effet, les parenthèses peuvent introduire une liste de commandes, une définition de fonction ou bien imposer un ordre d’évaluation d’une expression arithmétique. Toutefois, afin de rendre l’étude de bash plus aisée, nous n’aborderons pas sa syntaxe de manière exhaustive ; en particulier, lorsqu’il existera plusieurs syntaxes pour mettre en oeuvre la même fonctionnalité, une seule d’entre elles sera présentée.

La manière la plus simple de connaître le shell que l’on utilise est d’exécuter la commande unix ps qui liste les processus de l’utilisateur :

$ ps
PID   TTY   TIME    CMD
6908 pts/4 00:00:00 bash       => l’interpréteur utilisé est bash
6918 pts/4 00:00:00 ps
$

Comme il existe plusieurs versions de bash présentant des caractéristiques différentes, il est important de connaître la version utilisée. Pour cela, on utilise l'option –-version de bash.

$ bash --version
GNU bash, version 3.1.14(1)-release (i486-pc-linux-gnu)
Copyright (C) 2005 Free Software Foundation, Inc.
$

La dernière version majeure de bash est la version 3. C’est celle qui sera étudiée.

Une commande interne est une commande dont le code est implanté au sein de l’interpréteur de commande. Cela signifie que, lorsqu’on change de shell courant ou de connexion, par exemple en passant de bash au C-shell, on ne dispose plus des mêmes commandes internes. Exemples de commandes internes : cd , echo , for , pwd Sauf dans quelques cas particuliers, l’interpréteur ne crée pas de processus pour exécuter une commande interne. Les commandes internes de bash peuvent se décomposer en deux groupes :

• les commandes simples (ex : cd, echo)
• les commandes composées (ex : for, ((, {).

Commandes simples▲

$ echo bonjour     tout le      monde
bonjour tout le monde
$

$ echo “bonjour         tout le                                monde”
bonjour       tout le                                 monde
$

$ echo -n bonjour
bonjour$

Commandes composées▲

case ... esac        if ... fi             for ... done   select ... done
until ... done       while ... done        [[ ... ]]       ( ... )
{ ... }              (( ... ))

Une commande externe est une commande dont le code se trouve dans un fichier ordinaire. Le shell crée un processus pour exécuter une commande externe. Parmi l’ensemble des commandes externes que l’on peut trouver dans un système, nous utiliserons principalement les commandes unix (ex : ls, mkdir, vi, sleep) et les fichiers shell.

La localisation du code d'une commande externe doit être connue du shell pour qu'il puisse exécuter cette commande. A cette fin, bash utilise la valeur de sa variable prédéfinie PATH. Celle-ci contient une liste de chemins séparés par le caractère : (ex : /bin:/usr/bin). Par exemple, lorsque l’utilisateur lance la commande unix cal, le shell est en mesure de l’exécuter et d’afficher le calendrier du mois courant car le code de cal est situé dans le répertoire /usr/bin présent dans PATH.

$ cal
   septembre 2006
di lu ma me je ve sa
                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
$

pour connaître le statut d’une commande, on utilise la commande interne type.

$ type sleep
sleep is /bin/sleep         => sleep est une commande externe
$ type echo
echo is a shell builtin
$

Le mode d’exécution par défaut d’une commande est l’exécution séquentielle : le shell lit la commande entrée par l’utilisateur, l’analyse, la prétraite et si elle est syntaxiquement correcte, l’exécute.
Une fois l’exécution terminée, le shell effectue le même travail avec la commande suivante. L’utilisateur doit donc attendre la fin de l’exécution de la commande précédente pour que la commande suivante puisse être exécutée : on dit que l’exécution est synchrone.

Si on tape la suite de commandes :

                 sleep 3 entrée date entrée

où entrée désigne la touche entrée, l’exécution de date débute après que le délai de 3 secondes se soit écoulé.

Pour lancer l’exécution séquentielle de plusieurs commandes sur la même ligne de commande, il suffit de les séparer par un caractère ;

$ cd /tmp ; pwd; echo bonjour; cd ; pwd
/tmp           => affichée par l’exécution de pwd
bonjour        => affichée par l’exécution de echo bonjour
/home/sanchis  => affichée par l’exécution de pwd
$

Pour terminer l’exécution d’une commande lancée en mode synchrone, on appuie simultanément sur les touches CTRL et C (notées control-C ou ^C).
En fait, la combinaison de touches appropriée pour arrêter l’exécution d’une commande en mode synchrone est indiquée par la valeur du champ intr lorsque la commande unix stty est lancée :

$ stty -a
speed 38400 baud; rows 24; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
...
$

Supposons que la commande cat soit lancée sans argument, son exécution semblera figée à un utilisateur qui débute dans l’apprentissage d’un système Unix. Il pourra utiliser la combinaison de touches mentionnée précédemment pour terminer l’exécution de cette commande.

$ cat
^C
$

L’exécution en arrière-plan permet à un utilisateur de lancer une commande et de récupérer immédiatement la main pour lancer « en parallèle » la commande suivante (parallélisme logique). On utilise le caractère & pour lancer une commande en arrière-plan.

Dans l’exemple ci-dessous, la commande sleep 5 (suspendre l’exécution pendant 5 secondes) est lancée en arrière-plan. Le système a affecté le numéro d’identification 696 au processus correspondant tandis que bash a affecté un numéro de travail (ou numéro de job) égal à 1 et affiché [1]. L’utilisateur peut, en parallèle, exécuter d’autres commandes (dans cet exemple, il s’agit de la commande ps). Lorsque la commande en arrière-plan se termine, le shell le signale à l'utilisateur après que ce dernier ait appuyé sur la touche entrée.

$ sleep 5 &
[1] 696
$ ps
PID TTY                TIME CMD
683 pts/0        00:00:00 bash
696 pts/0        00:00:00 sleep
697 pts/0        00:00:00 ps
$                => l’utilisateur a appuyé sur la touche entrée mais sleep n’était pas terminée
$                => l’utilisateur a appuyé sur la touche entrée et sleep était terminée
[1]+ Done                               sleep 5
$

Ainsi, outre la gestion des processus spécifique à Unix, bash introduit un niveau supplémentaire de contrôle de processus. En effet, bash permet de stopper, reprendre, mettre en arrière-plan un processus, ce qui nécessite une identification supplémentaire (numéro de job).
L’exécution en arrière-plan est souvent utilisée lorsqu’une commande est gourmande en temps CPU (ex : longue compilation d’un programme).