BASH

NOM

SYNOPSIS

COPYRIGHT

DESCRIPTION

Bash est conçu pour être conforme aux spécifications IEEE concernant les shells et les outils Posix (Groupe de travail de l'IEEE 1003.2).  

OPTIONS

-c chaîne

Si l'argument -c est présent, les commandes sont interprétées depuis la chaîne fournie. S'il existe d'autres arguments après la chaîne, ils sont transmis comme paramètres positionnels, en commençant par $0.

-r

Si l'option -r est présente, l'interpréteur est restreint (voir SHELLS RESTREINTS plus bas).

-i

Si l'option -i est présente, l'interpréteur est interactif.

-s

Si l'option -s est présente, ou s'il n'y a plus d'arguments sur la ligne de commande, après le traitement des options, l'interprétation se fera depuis l'entrée standard. Cette option permet de remplir les paramètres positionnels tout en invoquant un shell interactif.

-D

Une liste de toutes les chaînes entre '"' et précédées de $ est affichée sur la sortie standard. Ce sont les chaînes qui sont sujettes à une traduction quand la localisation n'est ni celle du C, ni celle du standard POSIX. Cela nécessite l'option -n ; aucune commande ne sera exécutée.

--

Deux caractères -- permettent d'indiquer la fin des options, et empêchent le traitement des arguments restants. Ces derniers sont alors traités comme des noms de fichiers et des paramètres. - est équivalent à --.

Bash reconnaît également plusieurs options multi-caractères. Ces options doivent, pour être reconnues, apparaître sur la ligne de commande avant les options mono-caractère.

--dump-po-strings

Équivalent à -D, mais la sortie est dans le format des fichiers po (objets portables) de l'outil Gnu gettext.

--dump-strings

Équivalent à -D.

--help

Affiche un message d'aide sur la sortie standard et se termine avec succès.

--login

Demande que bash Se comporte comme un shell de login. (Voir INVOCATION plus bas).

--noediting

Ne pas utiliser la bibliothèque GNU readline pour la lecture des lignes de commande, lorsque le shell est interactif.

--noprofile

Ne lire ni le fichier de configuration générale /etc/profile ni les fichiers personnalisés ~/.bash_profile, ~/.bash_login, ou ~/.profile. Par défaut bash lit ces fichiers lorsqu'il est invoqué comme shell de login (voir le paragraphe INVOCATION plus bas).

-norc

Ne pas lire le fichier de configuration personnalisée ~/.bashrc lorsque le shell est interactif. Cette option est activée par défaut lorsque bash est invoqué sous le nom sh.

--posix

Aligner le comportement de bash sur le standard Posix 1003.2, en ce qui concerne les options dont l'action par défaut diffère de ce standard.

--rcfile fichier

Exécuter les commandes contenues dans le fichier mentionne, plutôt que celles du fichier de configuration personnelle ~/.bashrc, si le shell est interactif (voir le paragraphe INVOCATION plus bas).

--restricted

Le shell devient restreint (voir le paragraphe SHELLS RESTREINTS plus bas).

--rpm-requires

Affiche une liste des fichiers qui sont nécessaires pour le lancement d'un script shell. Ceci nécessite l'option '-n' et est soumis aux mêmes limites que les vérifications d'erreurs à la compilation ; les back-quotes, les tests [] et les évalutations ne sont pas analysés, et certaines erreurs peuvent être oubliées.

--verbose

Équivalent à -v

--version

Afficher le numéro de version de bash sur la sortie standard et terminer avec succès.

ARGUMENTS

INVOCATION

Un shell est interactif si son entrée standard et sa sortie standard sont toutes deux connectées à un terminal (déterminé par la fonction isatty(3)), ou s'il est invoqué avec l'option -i. Le paramètre PS1 est positionné, et le paramètre $- contient la lettre i si bash est interactif, ce qui permet à un script ou à un fichier de démarrage de vérifier l'état du shell.

Le paragraphe suivant décrit comment bash exécute ses fichiers d'initialisation. Si l'un de ces fichiers existe mais n'est pas accessible en lecture, bash signale une erreur. Les tildes sont remplacées par des noms de fichiers comme décrit dans le paragraphe Développement du Tilde de la section Développement.

Lorsque bash est lancé comme shell de login interactif, ou comme shell non-interactif avec l'option --login, il lit et exécute tout d'abord les commandes se trouvant dans le fichier /etc/profile s'il existe. Après lecture de ce fichier, il recherche ~/.bash_profile, ~/.bash_login, et ~/.profile, dans cet ordre, et exécute les commande se trouvant dans le premier fichier existant et accessible en lecture. L'option --noprofile peut être utilisée au démarrage du shell pour empêcher ce comportement.

Lorsqu'un shell de login se termine, bash lit et exécute les commandes du fichier ~/.bash_logout, s'il existe.

Quand un shell interactif démarre sans être un shell de login, bash lit et exécute les commandes se trouvant dans ~/.bashrc s'il existe. Ce comportement peut être inhibé à l'aide de l'option --norc. L'option --rcfile fichier forcera bash à exécuter les commandes dans fichier plutôt que dans ~/.bashrc.

Quand bash est démarré de manière non-interactive, pour lancer un script shell par exemple, il recherche la variable BASH_ENV dans l'environnement, développe son contenu si elle existe, et considère cette valeur comme le nom d'un fichier à lire et exécuter. Bash se comporte comme si la commande suivante se trouvait en début de script :

if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi

mais la valeur de la variable PATH n'est pas utilisée pour rechercher le fichier.

Si bash est invoqué sous le nom sh, il essaye d'imiter le comportement de démarrage des versions historiques de sh autant que possible, tout en restant conforme au standard Posix. Lorsqu'il est invoqué comme shell de login interactif (ou non-interactif avec l'option --login), il essaye d'abord d'exécuter les commandes se trouvant dans /etc/profile et ~/.profile, dans cet ordre. L'option -noprofile peut toujours être utilisée pour désactiver ce comportement. Quand il est invoqué en tant que shell interactif sous le nom sh, bash consulte la variable ENV, développe sa valeur si elle est définie et utilise le résultat en tant que nom de fichier à lire et exécuter. Comme un shell invoqué sous le nom sh n'essaye pas d'exécuter d'autre fichier de démarrage, l'option --rcfile n'a aucun effet. Un shell non interactif invoqué sous le nom sh ne lit aucun autre fichier d'initialisation. Quand il est invoqué sous le nom sh, bash entre en mode posix après avoir lu les fichiers d'initialisation.

Quand bash est invoqué en mode posix, avec l'option -posix sur la ligne de commande, il suit ce standard en ce qui concerne les fichiers de démarrage. Dans ce cas, la variable ENV est développée, et le fichier qui en résulte est exécuté. On n'exécute pas d'autre fichier d'initialisation.

Bash tente de déterminer s'il est exécuté par le démon lançant les shells distants (généralement appelé rshd ). Si bash se rend compte qu'il est exécuté par rshd, il lit et exécute les commandes de ~/.bashrc si ce fichier existe et est lisible. Il n'a pas ce comportement lorsqu'il est invoqué sous le nom sh. L'option --norc peut être utilisé pour interdire ce comportement, et l'option --rcfile permet de forcer l'utilisation d'un autre fichier, mais rshd n'utilise généralement pas ces options et ne permet pas non plus leur utilisation.

Si le shell est lancé avec un identifiant effectif d'utilisateur (ou de groupe) différent de l'identifiant réel, et si l'option -p n'est pas utilisée, aucun fichier d'initialisation n'est lu, les fonctions du shell ne sont pas importées depuis l'environnement, la variable SHELLOPTS est ignorée si elle apparaît dans l'environnement, et l'identifiant effectif de l'utilisateur (du groupe) est remplacé par l'ID réel. Si l'option -p est fournie, le démarrage est le même mais l'ID effectif n'est pas modifié.  

DÉFINITIONS

Les définitions suivantes sont utilisées tout au long de ce document.

blanc

Un espace ou une tabulation.

mot

une séquence de caractères considérée comme une unité élémentaire par le shell. On parle également de token (jeton).

nom

un mot ne contenant que des caractères alphanumériques ou le soulignement (underscore), commençant par une lettre ou un soulignement. On s'y réfère également sous le terme identificateur.

méta-caractère

Un caractère qui, non protégé, sépare les mots. Un de ceux-ci :

| & ; ( ) < > espace tabulation

opérateur de contrôle

Un jeton ayant une fonction de contrôle. L'un des symboles suivants :

|| & && ; ;; ( ) | <retour-chariot>

MOTS RÉSERVÉS

! case do done elif else esac fi for function if in select then until while { } time [[ ]]  

GRAMMAIRE DU SHELL

Commandes simples

Une commande simple est une séquence d'affectations de variables facultative, suivie de mots séparés par des blancs et des redirections, et terminée par un opérateur de contrôle. Le premier mot indique la commande à exécuter. Les mots suivants sont transmis en argument à cette commande.

La valeur de retour d'une commande simple est son code de sortie, ou 128+n si la commande a été interrompue par le signal n.  

Pipelines

Un pipeline est une séquence d'une ou plusieurs commandes séparées par le caractère |. Le format d'un pipeline est :

[time [-p]] [ ! ] commande_1 [ | commande_2 ... ]

La sortie standard de la commande_1 est connectée à l'entrée standard de la commande_2. Cette connexion est établie avant toute redirection indiquée dans une commande elle-même (voir le paragraphe REDIRECTION plus bas).

Si le mot réservé ! précède un pipeline, la valeur de sortie de celui-ci sera la NÉGATION logique de la valeur de retour de la dernière commande. Sinon, le code de retour d'un pipeline sera celui de la dernière commande. L'interpréteur attend la fin de toutes les commandes du pipeline avant de renvoyer une valeur.

Si le mot réservé time précède le pipeline, les temps passés par le programme en mode utilisateur et système sont indiqués quand le pipeline se termine. L'option -p change le format de sortie pour celui spécifié par POSIX. La variable TIMEFORMAT peut être affectée avec une chaîne de format indiquant comment les informations horaires doivent être affichées; consultez la descriptions de TIMEFORMAT dans VariablesduShell plus bas.

Chaque commande du pipeline est exécutée comme un processus indépendant (c'est à dire dans un sous-shell).  

Listes

Une liste est une séquence d'un ou plusieurs pipelines séparés par l'un des opérateurs ;, &, &&, ou ||, et terminée éventuellement par ;, &, ou <retour-chariot>.

Dans cette liste d'opérateurs, && et || ont une précédence identique, suivis par ; et &, qui ont également une précédence identique.

Si une commande se termine par l'opérateur de contrôle &, l'interpréteur l'exécute en arrière-plan, dans un sous-shell. L'interpréteur n'attend pas que la commande se termine et retourne un code 0. Les commandes séparées par un ; sont exécutées successivement, l'interpréteur attend que chaque commande se termine avant de lancer la suivante. Le code de retour est celui de la dernière commande exécutée.

Les opérateurs de contrôle && et || indiquent respectivement une liste liée par un ET, et une liste liée par un OU. Une liste ET a la forme

commande_1 && commande_2

commande_2 est exécutée si, et seulement si, commande_1 renvoie un code de retour nul.

Une liste OU a la forme

commande_1 || commande_2

commande_2 est exécutée si, et seulement si commande_1 renvoie un code de retour non-nul. La valeur de retour des listes ET et OU est celle de la dernière commande exécutée dans la liste.  

Commandes composées

Une commande composée est l'une des constructions suivantes :

(liste)

liste est exécutée dans un sous-shell. Les affectations de variables, et les commandes internes qui affectent l'environnement de l'interpréteur n'ont pas d'effet une fois que la commande se termine. Le code de retour est celui de la liste.

{ liste; }

liste est simplement exécutée avec l'environnement du shell en cours. liste doit se terminer par un caractère fin-de-ligne ou un point-virgule. Cette construction est connue sous le nom de commandes groupées. Le code de retour est celui de la liste.

L'expression est évaluée selon les règles décrites plus bas au paragraphe ÉVALUATIONARITHMÉTIQUE. Si la valeur arithmétique de l'expression est non-nulle, le code renvoyé est zéro ; sinon 1 est renvoyé. Cela est strictement identique à let "expression".

[[ expression ]]

Renvoie 1 ou 0 selon la valeur de la condition expression. les expressions sont composées d'éléments primaires décrits dans EXPRESSIONSCONDITIONNELLES. Le coupage des mots et l'expansion des chemins ne sont pas réalisés sur les portions entre [[ et ]]; l'expansion des tildes, des paramètres, des variable, des expressions arithmétiques, la substitution des commandes et des processus, ainsi que la disparition des apostrophes sont réalisés.

Quand les opérateurs == et != sont utilisés, la chaîne placée à droite de l'opérateur est considérée comme étant un motif et est recherchée selon les règles décrites dans Motifs génériques. La valeur renvoyée est 0 si les chaînes correspondent (ou respectivement ne correspondent pas), et 1 sinon. Toute partie du motif peut être protégée avec des apostrophes pour forcer sa comparaison en tant que chaîne (sans développement).

Les expressions peuvent être combinées en utilisant les opérateurs suivants, par ordre décroissant de priorité :

( expression )

Retourne la valeur de l'expression. Cela peut être utilisé pour outrepasser la priorité normale des opérateurs.

! expression

Vraie si expression est vraie.

expression1 && expression2

Vraie si expression1 et expression2 sont toutes les deux vraies.

expression1 || expression2 Vraie si expression1 ou expression2 est vraie.

Les opérateurs && et || n'exécutent pas expression2 si la valeur de expression1 suffit à déterminer le code de retour de l'expression conditionnelle entière.

for nom [ in mot ] ; do liste ; done

La liste de mots à la suite de in est développée, créant une liste d'éléments. La variable nom prend successivement la valeur de chacun des éléments, et liste est exécutée à chaque fois. Si in mot est omis, la commande for exécute la liste une fois pour chacun des paramètres positionnels ayant une valeur (voir le paragraphe PARAMÈTRES plus bas). Le code de retour est celui de la dernière commande exécutée. Si le développement de ce qui suit in est une liste vide, aucune commande n'est exécutée et 0 est renvoyé.

select nom [ in mot ] ; do liste ; done

La liste de mots à la suite de in est développée, créant une liste d'éléments. L'ensemble des mots développés est imprimé sur la sortie d'erreur standard, chacun précédé par un nombre. Si in mot est omis, les paramètres positionnels sont imprimés (voir le paragraphe PARAMÈTRES plus bas). Le symbole d'accueil PS3 est affiché, et une ligne est lue depuis l'entrée standard. Si la ligne est constituée d'un nombre correspondant à l'un des mots affichés, la variable nom est remplie avec ce mot. Si la ligne est vide, les mots et le symbole d'accueil sont affichés à nouveau. Si une fin de fichier (EOF) est lue, la commande se termine. Pour toutes les autres valeurs, la variable nom est vidée. La ligne lue est stockée dans la variable REPLY. La liste est exécutée après chaque sélection, jusqu'à ce qu'une commande break ou return soit atteinte. Le code de retour de select est celui de la dernière commande exécutée dans la liste, ou zéro si aucune commande n'est exécutée.

case mot in [ motif [ | motif ]

Une commande case commence d'abord par développer le mot, puis essaye de le mettre en correspondance successivement avec chacun des motifs en utilisant les mêmes règles que pour les noms de fichiers (voir le paragraphe Développement des noms de fichiers plus bas). Quand une correspondance est trouvée, la liste associée est exécutée. Dès qu'un motif correct a été trouvé, il n'y a plus d'autre essais. Le code retour est zéro si aucun motif ne correspond, sinon il s'agit du code de la dernière commande exécutée dans la liste.

if liste ; then liste ; [ elif liste ; then liste ; ] ... [ else liste ; ] fi

La liste du if est exécutée. Si son code de retour est nul, la liste du then est exécutée. Sinon, chacune des listes des elif est exécutée successivement, et si un code de retour est nul, la liste du then associé est exécutée, et la commande se termine. En dernier ressort, la liste du else est exécutée. Le code de retour est celui de la dernière commande exécutée, ou zéro si aucune condition n'a été vérifiée.

while liste ; do liste ; done

until liste ; do liste ; done

La commande while répète la liste du do tant que la dernière commande de la liste du while renvoie un code de retour nul. La commande until agit de même manière, sauf que le test est négatif, et la liste du do est exécutée tant que la liste du until renvoie un code non-nul. Le code de retour des commandes while et until est celui de la dernière commande exécutée dans la liste do, ou zéro si aucune commande n'a été exécutée.

[ function ] nom () { liste; }

Ceci définit une fonction possédant le nom mentionné. Le corps de cette fonction est la liste de commandes entre { et }. Cette liste est exécutée dès que le nom de la fonction est invoqué en tant que commande simple. Le code de retour est celui de la dernière commande exécutée dans le corps de la fonction. (voir le paragraphe FONCTIONS plus bas)

COMMENTAIRES

PROTECTION

Tous les méta-caractères mentionnés dans le paragraphe DÉFINITIONS plus haut ont des significations spéciales pour le shell, et doivent être protégés pour garder leur propre valeur. Il y a trois mécanismes de protection : le caractère d'échappement, les apostrophes (quote) et les guillemets (double-quote).

Un caractère backslash (\), quand il n'est pas protégé, représente le caractère d'échappement. Il préserve la valeur littérale du caractère qui le suit, à l'exception du <retour-chariot>. Si une séquence \<retour-chariot> apparaît, et si le backslash n'est pas protégé, l'ensemble \<retour-chariot> est considéré comme une continuation de ligne (autrement dit, il est ignoré).

Encadrer des caractères entre des apostrophes simples préserve la valeur littérale de chacun des caractères. Une apostrophe ne peut pas être placée entre deux apostrophes, même si elle est précédée d'un backslash.

Encadrer des caractères entre des guillemets préserve la valeur littérale de chacun des caractères sauf $, `, et \. Les caractères $ et ` conservent leurs significations spéciales, même entre guillemets. Le backslash ne conserve sa signification que lorsqu'il est suivi par $, `, ", \, ou <fin-de-ligne>. Un guillemet peut être protégé entre deux guillemets, à condition de le faire précéder par un backslash.

Les caractères spéciaux * et @ ont des significations spéciales lorsqu'ils se trouvent entre guillemets (voir le paragraphe PARAMÈTRES ci-dessous).

Les mots de la forme $'chaîne' sont traités différemment. Le mot est développé en chaîne avec les séquences d'échappement remplacées par les séquences standards du C ANSI:

\a

alerte (cloche alias bip)

\b

effacement arrière

\e

un caractère escape

\f

fin de page

\n

fin de ligne

\r

retour chariot

\t

tabulation horizontale

\v

tabulation verticale

\\

anti-slash (backslash)

\nnn

le caractère dont le code ASCII en octal est nnn (un à trois chiffres)

\xnnn

le caractère dont le code ASCII en hexadécimal est nnn (un à trois chiffres)

Le résultat après traduction est protégé par des apostrophes comme si le symbole dollar n'avait pas été présent.

Une chaîne entre guillemets précédée d'un symbole dollar ($) sera traduite selon la localisation en vigueur. Si la locale courante est C ou POSIX, le symbole dollar est ignoré. Si la chaîne a subi une traduction ou des remplacements, le résultat est protégé par des guillemets.  

PARAMÈTRES

Un paramètre existe dès qu'on lui attribue une valeur. Une chaîne vide est une valeur valide. Une fois qu'une variable existe, elle ne peut être détruite qu'en utilisant la commande interne unset (voir COMMANDES INTERNES DU SHELL plus bas).

Une variable peut recevoir une valeur par une affectation de la forme

nom=[valeur]

Si aucune valeur n'est indiquée, la variable reçoit une chaîne vide. Toute valeur est soumise aux principes de développement du tilde, des paramètres et des variables, de la substitution de commandes, de l'évaluation arithmétique, et de la suppression des protections (voir EXPANSION plus bas). Si une variable a son attribut -i activé (voir declare plus bas, dans le paragraphe COMMANDESINTERNESDUSHELL) alors la valeur est soumise à l'évaluation arithmétique, même si la syntaxe $((...)) n'apparaît pas (voir ÉVALUATION ARITHMÉTIQUE plus bas). Les mots ne sont pas tronqués, sauf avec la séquence "$@" comme cela est expliqué dans le paragraphe Paramètres Spéciaux ci-dessous. Le développement des noms de fichiers n'est pas effectué.  

Paramètres Positionnels

Un paramètre positionnel est un paramètre indiqué par un ou plusieurs chiffres (à l'exception du chiffre 0 seul). Les paramètres positionnels sont remplis avec les arguments du shell lors de son invocation. Ils peuvent être modifiés avec la commande interne set. On ne peut pas utiliser d'assignation pour modifier le contenu d'un paramètre positionnel. Les paramètres positionnels sont temporairement modifiés lors de l'exécution d'une fonction du shell (voir le paragraphe FONCTIONS plus bas).

Un paramètre positionnel constitué de plusieurs chiffres doit être encadré par des accolades lors de son développement (voir EXPANSION plus bas).  

Paramètres Spéciaux

Il existe plusieurs paramètres ayant un comportement particulier. Ces paramètres peuvent uniquement être consultés, on ne peut pas les modifier.

*

Se développe en l'ensemble des paramètres positionnels, commençant à 1. Quand le développement se produit entre des guillemets, * se transforme en un seul mot constitué de la valeur de tous les paramètres positionnels séparées par le premier caractère de la variable spéciale IFS. Ceci signifie que "$*" est équivalent à "$1c$2c...", dans laquelle c est le premier caractère de la valeur de la variable IFS. Si IFS est inexistante, les paramètres sont séparés par des espaces. Si IFS est nulle, les paramètres sont juxtaposés sans séparation.

@

Se développe en l'ensemble des paramètres positionnels, commençant à 1. Quand le développement a lieu entre guillemets, chaque paramètre se transforme en un mot distinct. Ceci signifie que "$@" est équivalent à "$1" "$2" ... Quand il n'y a pas de paramètres positionnels, "$@" et $@ sont simplement éliminés.

#

Correspond au nombre de paramètres positionnels, en base décimale.

?

Fournit le code de retour du dernier pipeline exécuté à l'avant-plan.

-

Est remplacé par la liste des options du shell indiquées durant l'invocation, configurées avec la commande interne set ou positionnées par le shell lui-même (comme avec l'option -i ).

$

Se transforme en PID du shell. Dans un sous-shell (), il se transforme en PID du shell, et non pas du sous-shell.

!

Se transforme en PID de la commande (asynchrone) exécutée en arrière-plan le plus récemment.

0

Se développe pour donner le nom du shell ou du script. Ce paramètre est rempli lors de l'initialisation de l'interpréteur. Si bash est invoqué avec un fichier de commandes, $0 correspond au nom de ce fichier. Si bash est lancé avec l'option -c, alors $0 contient le premier argument, s'il y en a un, après la chaîne de commandes à exécuter. Sinon, ce paramètre contient le chemin d'accès utilisé pour invoquer bash, comme il l'a reçu en argument zéro.

_

Au lancement du shell, contient le chemin absolu du shell ou du script en cours d'exécution. Devient le dernier argument de la commande précédente, après développement. Correspond aussi au chemin d'accès complet de chaque commande exécutée, et se retrouve dans l'environnement exporté à cette commande. Lors de la vérification de l'arrivée de courrier, contient le nom du fichier de courrier en cours de vérification [Ndt: généralement /var/mail/nom_de_l_utilisateur].

Variables du Shell

Les variables suivantes sont remplies par l'interpréteur de commandes :

PPID

L'ID du processus parent du shell. Cette variables est protégée en écriture.

PWD

Le répertoire de travail en cours, tel qu'il est configuré par la commande cd.

OLDPWD

Le répertoire de travail précédent, configuré par la commande cd.

REPLY

Contient la ligne d'entrée lue par la commande interne read lorsqu'elle n'a pas d'argument.

UID

Contient l'ID de l'utilisateur, initialisé au démarrage du shell. C'est une variable en lecture seulement

EUID

Contient l'UID effectif de l'utilisateur, initialisé au démarrage du shell. Cette variable est en lecture seule.

GROUPS

Variable de type tableau contenant la liste des groupes dont l'utilisateur est membre. Cette variables est protégée en écriture.

BASH

Se développe en chemin d'accès complet à l'instance courrante de bash.

BASH_VERSION

Correspond au numéro de version de cette instance de bash.

BASH_VERSINFO

Une variable tableau protégée en écriture dont les membres représentent la version de cette instance de bash. Cette valeur est renseignée de la manière suivante:

BASH_VERSINFO[0]

Le numéro majeur de la version (release).

BASH_VERSINFO[1]

Le numéro mineur de la version (version).

BASH_VERSINFO[2]

Le niveau de patch.

BASH_VERSINFO[3]

Le numéro de compilation.

BASH_VERSINFO[4]

Le statut de cette version (e.g., beta1).

BASH_VERSINFO[5]

La valeur de MACHTYPE.

SHLVL

(NDT : Lire SH LVL - Shell Level - Niveau d'interpréteur) Incrémenté de 1 à chaque invocation d'une instance de bash.

RANDOM

A chaque fois que ce paramètre est référencé, un entier aléatoire entre 0 et 32767 est engendré. Cette séquence de nombres aléatoires peut être initialisée en assignant une valeur à RANDOM. Si RANDOM est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.

SECONDS

A chaque fois que ce paramètre est lu, le nombre de secondes écoulées depuis le lancement de l'interpréteur est renvoyé. Si une valeur est affectée à SECONDS, il renverra lors des lectures ultérieures le nombre de secondes écoulées depuis l'affectation, augmenté de la valeur fournie. Si SECONDS est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.

LINENO

Chaque fois que ce paramètre est référencé, le shell le remplace par un nombre décimal représentant le numéro de la ligne actuelle (commençant à 1), au sein du script ou de la fonction. Hors d'un script ou d'une fonction, la valeur n'a pas nécessairement de sens. Si LINENO est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.

HISTCMD

Le numéro d'historique, ou le rang dans la liste d'historique, de la commande en cours. Si HISTCMD est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.

DIRSTACK

Une variable de type tableau (voir Tableaux plus bas) représentant le contenu courant de la pile de répertoires. Les répertoires apparaissent dans la pile dans l'ordre dans lequel la commande interne dirs les affiche. Il est possible de modifier directement cette variables mais les commandes internes pushd et popd doivent être utilisées pour ajouter et enlever des répertoires. Modifier cette variable ne modifiera pas le répertoire courant. Si DIRSTACK est détruite, elle perd ses propriétés spéciales, même si elle est recréée.

PIPESTATUS

Une variable de type tableau (voir Tableaux plus bas) contenant une liste des codes de retour des derniers processus exécutés en avant-plan (éventuellement une seule commande).

OPTARG

La valeur du dernier argument d'option traité par la commande interne getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).

OPTIND

Le rang du prochain argument à traiter avec la commande getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).

HOSTNAME

Automatiquement affectée avec le nom de l'ordinateur.

HOSTTYPE

Automatiquement rempli avec une chaîne qui décrit de manière unique le type de machine sur laquelle bash s'exécute. La valeur par défaut dépend du système.

OSTYPE

Automatiquement rempli avec une chaîne qui décrit le système d'exploitation sur lequel bash s'exécute. La valeur par défaut dépend du système.

MACHTYPE

Automatiquement affectée avec une chaîne décrivant le type du système sur lequel bash s'exécute, dans le format standard de GNU processeur-compagnie-système. La valeur par défaut dépend du système.

SHELLOPTS

Liste des options activées du shell, séparées par des virgules. Chaque mot de la liste est un argument valide pour l'option -o de la commande interne set (voir COMMANDES INTERNES DU SHELL). Les options apparaissant dans SHELLOPTS sont celle indiquées comme actives par set -o. Si cette variable est dans l'environnement au lancement de bash, chaque option de la liste est activée avant de lire les fichiers d'initialisation. Cette variable est protégée en écriture.

Les variables suivantes sont utilisées par l'interpréteur. Dans certains cas, bash affecte des valeurs par défaut aux variables, ces cas sont décrits plus bas.

IFS

Le Séparateur de Champs Interne Internal Field Separator qui est utilisé pour séparer les mots après les développements, et pour découper les lignes en mots avec la commande interne read. La valeur par défaut est ``<espace><tabulation><retour-chariot>''.

PATH

Le chemin de recherche des commandes à exécuter. Il s'agit d'une liste de répertoires, séparés par des deux-points (`:') que l'interpréteur consulte lorsqu'il recherche une commande (voir le paragraphe EXÉCUTION DES COMMANDES plus bas). Le chemin par défaut dépend du système, et de la configuration choisie par la personne installant bash. Une configuration fréquente est ``/bin:/usr/bin:/usr/local/bin:.''.

HOME

Le répertoire personnel de l'utilisateur. C'est l'argument par défaut de la commande interne cd. Cette variable sert également lors du développement du tilde.

CDPATH

Le chemin de recherche de la commande interne cd. Il s'agit d'une liste de répertoires, séparés par des deux-points (`:') que l'interpréteur consulte lorsqu'il cherche un sous-répertoire destination de la commande cd. Une configuration possible serait ``.:~:/usr''.

BASH_ENV

Si ce paramètre est configuré lorsque bash exécute un script, sa valeur est considérée comme un nom de fichier, contenant les commandes d'initialisation de l'interpréteur, comme .bashrc. La valeur de BASH_ENV est soumise au remplacement des paramètres, substitution de commandes, et évaluation arithmétique avant d'être considérée comme nom de fichier. PATH n'est pas utilisée pour rechercher le fichier obtenu.

MAIL

Si ce paramètre correspond à un nom de fichier, et si la variable MAILPATH n'est pas configurée, bash informera l'utilisateur si un courrier arrive dans le fichier indiqué.

MAILCHECK

Indique une période (en secondes), par défaut 60, avec laquelle bash vérifiera si un nouveau courrier est arrivé. Lorsque le délai est écoulé, le shell vérifiera la présence d'un courrier avant d'afficher son symbole d'accueil. Si cette variable est détruite, le shell cessera la vérification.

MAILPATH

Il s'agit d'une liste de fichiers séparés par des deux-points (`:'), dans lesquels on vérifiera l'arrivée de courrier. Le nom d'un fichier peut être suivi d'un point d'interrogation, puis d'une chaîne de caractères indiquant le message à afficher en cas de courrier. Dans cette chaîne, le paramètre $_ correspond au nom du fichier. Exemple:

MAILPATH='/usr/spool/mail/bfox?"Tu as du courrier":~/shell-mail?"$_ a du courrier"'

Bash fournit une valeur par défaut pour cette variable, mais l'emplacement du fichier boîte à lettres dépend du système (par exemple /usr/spool/mail/$USER).

PS1

La valeur de ce paramètre est développée puis utilisée comme symbole d'accueil principal (voir le paragraphe SYMBOLE D'ACCUEIL ci-dessous). La valeur par défaut est ``\s-\v\$ ''.

PS2

La valeur de ce paramètre est développée comme PS1 puis utilisée comme symbole d'accueil secondaire. Par défaut il s'agit de ``> ''.

PS3

La valeur de ce paramètre est utilisée comme symbole pour la commande select (voir GRAMMAIRE DU SHELL plus haut).

PS4

La valeur de ce paramètre est développée comme PS1 puis affichée entre chaque commande lors d'un suivi d'exécution. Le premier caractère de PS4 est répété autant de fois que nécessaire pour indiquer le niveau d'imbrication. La valeur par défaut est ``+ ''.

TIMEFORMAT

La valeur de ce paramètre est utilisée en tant que chaîne de format pour afficher le temps consommé dans les pipelines préfixés avec le mot réservé time. Le caractère % introduit une séquence d'échappement qui est développée avec une valeur de temps ou une autre information. Les séquences d'échappement et leurs significations sont les suivantes; les accolades entourent les parties facultatives.

%%

Un % seul (non interprété).

%[p][l]R

Le temps écoulé en secondes.

%[p][l]U

Le temps processeur écoulé en mode utilisateur en secondes.

%[p][l]S

Le temps processeur écoulé en mode système en secondes.

%P

Le pourcentage de temps processeur utilisé calculé avec (%U + %S) / %R.

La séquence facultative p est un chiffre indiquant la précision, le nombre de chiffres après la virgule. Une valeur de 0 provoque l'affichage de nombre entiers. Trois chiffres au plus peuvent être affichés après la virgule; tout chiffre supérieur à 3 sera changé en 3. Si p n'est pas indiqué, 3 est utilisé.

La séquence optionnelle l spécifie un format étendu, incluant les minutes, de la forme MMmSS.FFs. La valeur de p détermine si la partie décimale est affichée ou non.

Si cette variable n'est pas assignée, bash réagit comme si la valeur $'\nreal\t%3lR\nuser\t%3lU\nsys %3lS' avait été affectée. Si la variable est vide, aucune information n'est affichée. Un caractère fin-de-ligne est ajouté à la fin de l'affichage.

HISTSIZE

Le nombre de commandes à mémoriser dans l'historique (voir le paragraphe HISTORIQUE plus bas). La valeur par défaut est 500.

HISTFILE

Le nom du fichier d'historique pour la mémorisation des commandes(voir HISTORIQUE plus bas). Par défaut, il s'agit de ~/.bash_history. Si cette variable est détruite, l'historique n'est pas enregistré en fin de shell.

HISTFILESIZE

Le nombre maximal de lignes contenues dans le fichier historique. Quand cette variable contient une valeur, le fichier historique est tronqué, si besoin est, pour ne contenir que ce nombre de lignes. La valeur par défaut est 500. Ce fichier est tronqué à cette taille après écriture quand un shell interactif se termine.

OPTERR

Si cette variable contient la valeur 1, bash affiche les messages d'erreurs déclenchés par la commande interne getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas). OPTERR est initialisé avec la valeur 1 à chaque invocation du shell, ou au lancement d'un script.

LANG

Détermine la localisation pour toutes les catégories non spécifiquement précisées par une variable commençant par LC_.

LC_ALL

Cette variable surcharge LANG et toute autre variable LC_ indiquant la localisation.

LC_COLLATE

Cette variable détermine l'ordre des lettres lors du tri des chemins ainsi que le comportement des expressions des intervalles, des classes d'équivalences, et de la comparaison de chaînes lors de la recherche de motifs et le développement des chemins.

LC_CTYPE

Cette variable détermine l'interprétation des caractères et le comportement des classes de caractères [Ndt: ex: [:alpha] ] lors du développement des chemins et de la recherche de motifs.

LC_MESSAGES

Cette variable détermine le langage des messages et celui utilisé pour traduire les chaînes entre guillemets précédés par un $.

PROMPT_COMMAND

Lorsque cette variable contient une valeur, celle-ci est exécutée en tant que commande, avant l'affichage du symbole d'accueil principal.

IGNOREEOF

Cette variable contrôle le comportement du shell lorsqu'il reçoit un caractère EOF (fin de fichier) comme unique entrée. Si elle configurée, la valeur de cette variable correspond au nombre de caractères EOF consécutifs apparaissant en début de ligne que bash ignorera avant de se terminer. Si cette variable existe mais que sa valeur n'est pas numérique, ou si elle n'a pas de valeur, bash accepte par défaut 10 EOF consécutifs avant de se terminer. Si elle n'existe pas, EOF est considéré comme un terminateur de saisie pour le shell.

TMOUT

Si cette variable contient une valeur supérieure a zéro, celle-ci est considérée comme un délai en secondes, à partir de l'affichage du symbole d'accueil principal. Lorsque ce délai sera écoulé, Bash se terminera si aucune saisie n'a eu lieu.

FCEDIT

L'éditeur par défaut utilisé par la commande interne fc.

FIGNORE

Une liste de suffixes, séparés par des deux-points `:', que bash ignorera lors de la complétion des noms de fichiers (voir le paragraphe READLINE plus bas). Un nom de fichier dont le suffixe correspond à l'un de ceux mentionnés dans FIGNORE est exclus de la liste des fichiers. Par exemple, cette variable peut prendre la valeur ``.o:~''.

GLOBIGNORE

Une liste de motifs séparés par des deux-points, définissant la liste des noms de fichiers à ignorer lors du développement des chemins. Si un nom de fichier correspondant à un motif d'expansion, correspond également à un motif dans GLOBIGNORE, il est supprimé de la liste des correspondances.

INPUTRC

Le nom du fichier de configuration de readline prioritaire sur le fichier par défaut ~/.inputrc (voir READLINE plus bas).

HISTCONTROL

Si cette variable contient la valeur ignorespace, les lignes commençant par un caractère d'espacement ne seront par mémorisées dans l'historique. Si elle contient la valeur ignoredups, une ligne correspondant exactement à la ligne de commande précédente ne sera pas dupliquée dans l'historique. La valeur ignoreboth permet de combiner ces deux comportements. Si la variable est détruite (commande unset), ou si elle contient une valeur différente des trois mentionnées ci-dessus, tous les lignes lues par l'interpréteur seront mémorisées dans la liste d'historique, sous contrôle de HISTIGNORE. Le fonctionnement de cette variable est surchargé par HISTIGNORE. La seconde ligne et les suivantes d'une commande multiligne ne sont pas testées, et sont ajoutées dans l'historique quelque soit la valeur de HISTCONTROL.

HISTIGNORE

Une liste de motifs séparés par des deux-points déterminant quelles lignes de commandes seront ajoutées à l'historique. Chaque motif est accroché au début de la ligne et doit lui correspondre en entier (il n'y a pas d'ajout de `*' implicite). Chaque motif est comparé à chaque ligne après que les vérifications de HISTCONTROL aient été appliquées. En plus des motifs génériques normaux du shell, `&' correspond à la ligne précédente de l'historique. `&' peut être protégé par un anti-slash. Ce dernier est éliminé avant de tenter une comparaison. La seconde ligne et les suivantes d'une commande multiligne ne sont pas testées, et sont ajoutées dans l'historique quelque soit la valeur de HISTIGNORE.

histchars

Cette variable contient deux ou trois caractères contrôlant le développement de l'historique, et le découpage en jetons (voir DÉVELOPPEMENT DE L'HISTORIQUE plus bas). Le premier caractère est le caractère de développement de l'historique, c'est à dire celui qui indique le début d'un développement d'historique (normalement `!'). Le second caractère est celui de substitution rapide, utilisé comme raccourci pour relancer la commande précédente, en modifiant une partie de la chaîne. Par défaut il s'agit de `^'. L'éventuel troisième caractère est celui qui indique, lorsqu'on le trouve en début de mot que le reste de la ligne est un commentaire. Normalement on utilise le caractère `#'. Ce caractère de commentaire empêche l'expansion de l'historique pour tous les mots restants sur la ligne. En revanche, il ne s'agit pas obligatoirement du caractère de commentaire pour l'interpréteur.

HOSTFILE

Contient le nom d'un fichier ayant le même format que /etc/hosts qui sera consulté lorsque le shell devra compléter un nom d'hôte. Ce fichier peut être changé de manière interactive. Lors de la prochaine tentative pour compléter un nom d'hôte, bash ajoutera le nouveau fichier à sa base de données déjà existantes.

auto_resume

Cette variable configure le comportement du shell interactif vis-à-vis de l'utilisateur et du contrôle de jobs. Si cette variable existe, les commandes simples constituées d'un seul mot sont considérées comme de possibles relances de travaux arrêtés. Aucune ambiguïté n'est possible, si plusieurs travaux arrêtés commencent par la chaîne saisie, bash sélectionne le job manipulé le plus récemment. Le nom du job arrêté correspond, dans ce contexte, à la ligne de commande utilisée pour le lancer. Si cette variable contient la valeur exact, la chaîne fournie doit correspondre exactement au nom d'un job arrêté. Si elle contient la valeur substring, la chaîne fournie doit correspondre à une sous-chaîne du nom du job arrêté. La valeur substring fournit un comportement analogue au job id %? (voir CONTRÔLE DES JOBS
 plus bas). Si la variable contient n'importe quelle autre valeur, la chaîne fournie doit correspondre à un préfixe du nom d'un job arrêté. C'est analogue au fonctionnement du job id %.

Tableaux

Un tableau est créé automatiquement si une variable est remplie en utilisant la syntaxe nom[index]=valeur. l'index est traîté comme une expression arithmétique, et s'évaluer en un nombre positif ou nul. Pour déclarer explicitement un tableau, on utilise declare -a nom (voir COMMANDES INTERNES DU SHELL plus bas). declare -a nom[index] est aussi accepté bien que l'index soit ignoré. Des attributs peuvent être spécifié pour une variable tableau en utilisant les commandes internes declare et readonly. Les attributs s'appliquent à tous les membres du tableau.

Les tableaux sont remplis en utilisant l'affectation composée de la forme nom=(valeur_1 ... valeur_n), où chaque valeur est de la forme [index]=chaîne. Seule la chaîne est obligatoire. Si les crochets et les index optionnels sont fournis, les affectations ont lieu en conséquence ; sinon le rang de l'elément rempli est le dernier rang rempli plus un. Les index commencent à zéro. Cette syntaxed est aussi acceptée par la commande interne declare. Les éléments individuels du tableaux sont remplis en utilisant la syntaxe nom[index]=valeur présentée plus haut.

Chaque élément d'un tableau peut référencé en utilisant la notation ${nom[index]}. Les accolades sont indispensables pour éviter les conflits avec le développement des noms de fichiers. Si index est @ ou *, le développement donne tous les membres de nom. Ces deux index diffèrent lorsqu'ils sont employés entre guillemets. Dans ce cas, ${nom[*]} correspond à un seul mot contenant les valeurs de tous les membres séparés par le premier caractère de la variable spéciale IFS, et ${nom[@]} développe chaque membre de nom en un mot distinct. Quant il n'y a pas de membre dans le tableau, ${nom[@]} n'a pas de valeur. Le comportement est analogue à celui des paramètres spéciaux * et @ (voir Paramètres spéciaux plus haut). ${#nom[index]} donne la longueur du membre ${nom[index]}. Si l'index est * ou @, le développement donne le nombre d'éléments dans le tableau. Référencer une variable sans index est équivalent à en référencer l'élément zéro.

La commande interne unset sert à détruire les tableaux. unset nom[index] détruit l'élément de rang index. unset nom, où nom est un tableau, ou unset nom[index], avec index valant * ou @ supprimer le tableau entier.

Les commandes internes declare, local, et readonly acceptent toutes une option -a pour spécifier un tableau. La commande interne read accepte une option -a pour remplir un tableau avec une liste de mots lus depuis l'entrée standard. Les commandes internes set et declare affiche les valeurs des tableaux d'une manière permettant de les réutiliser pour les affectations.  

EXPANSION

L'ordre est : expansion des accolades, du tilde, des paramètres, des variables, des commandes, évaluation arithmétique (selon la méthode gauche-à-droite), découpage des mots et développement des noms de fichiers.

Sur les systèmes qui le supportent, un développement supplémentaire a lieu : la substitution de processus.

Seuls l'expansion des accolades, le découpage des mots, et le développement des noms de fichiers peuvent modifier le nombre de mots. Les autres développement transforment un mot unique en un autre mot unique. La seule exception à cette règle est l'expansion de "$@" et "${nom[@]}" comme on l'a vu plus haut (voir le paragraphe PARAMÈTRES).  

Expansion des accolades

L'expansion des accolades est un mécanisme permettant la création de chaînes quelconques. Il est similaire au développement des noms de fichiers, mais les noms de fichiers créés n'existent pas nécessairement. Les motifs qui seront développes prennent la forme d'un préambule facultatif, suivi d'une série de chaînes séparées par des virgules, encadrée par des accolades. Un postambule peut éventuellement suivre la série de chaînes. Le préambule est inséré devant chacune des chaînes contenues entre les accolades, et le postambule est ajouté à la fin de chacune des chaînes résultantes, le développement se faisant de gauche à droite.

Plusieurs développements d'accolades peuvent être imbriqués. Les résultats de chaque développement ne sont pas triées, l'ordre gauche à droite est conservé. Par exemple a{d,c,b}e se développe en `ade ace abe'.

L'expansion des accolades est effectuée en premier, et tous les caractères ayant une signification spéciale pour les autres développement sont conservés dans le résultat. Il s'agit d'une modification purement littérale. Bash n'effectue aucune interprétation syntaxique du texte entre les accolades.

Une formule correcte pour le développement doit contenir des accolades ouvrantes et fermantes non protégées, et au moins une virgule non protégée. Toute formule incorrecte n'est pas développée et reste inchangée. Un { ou un , peuvent être protégés par un anti-slash pour éviter d'être considérés comme partie d'une expression entre accolades.

Cette construction est généralement utilisée comme raccourci lorsque le préfixe commun aux différentes chaînes est relativement long :

mkdir /usr/local/src/bash/{old,new,dist,bugs}

chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

Le développement des accolades induit une légère incompatibilité avec les versions traditionnelles de l'interpréteur Bourne sh. sh n'effectue aucun traitement sur les accolades ouvrantes et fermantes lorsqu'elles apparaissent dans un mot, et les laisse inchangées. Bash supprime les accolades dans les mots, après développement. Par exemple si l'on fournit à sh le mot file{1,2}, il reste inchangé en sortie. Par contre, il est transformé en file1 file2 par bash. Si une compatibilité stricte avec sh est nécessaire, lancez bash avec l'option +B ou désactivez le développement des accolades avec l'option +B de la commande set (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).  

Développement du Tilde

Si un mot commence avec le caractère tilde (`~'), tous les caractères précédant le premier slash non protégé (voire tous les caractères s'il n'y a pas de slash), sont considérés comme un préfixe tilde. Si aucun caractère du préfixe tilde n'est protégé, les caractères suivant le tilde sont traités comme un nom de login possible. Si ce nom de login est une chaîne nulle, le tilde est remplacé par la valeur du paramètre HOME. Si HOME n'existe pas, le tilde est remplacé par le répertoire de connexion de l'utilisateur exécutant le shell. Si le préfixe tilde est remplacé par le répertoire personnel associé au nom de login en question.

Si le préfixe tilde est `+', la valeur du paramètre shell PWD le remplace. Si le préfixe tilde est `-', la valeur du paramètre shell OLDPWD lui est substitué. Si les caractères à la suite du tilde dans le préfixe tilde représentent un nombre N préfixé éventuellement d'un `+' ou d'un `-' le préfixe tilde est remplacé par l'élément correspondant de la pile de répertoires telle qu'il serait affiché par la commande interne dirs invoquée avec le préfixe tilde en argument. Si les caractères à la suite du tilde dans le préfixe tilde représentent un nombre sans signe, on suppose qu'il s'agit de `+'.

Si le nom est invalide, ou si le développement du tilde échoue, le mot est inchangé.

Chaque affectation de variable est soumis au développement du tilde s'il suit immédiatement un : ou un =. On peut donc utiliser des chemins d'accès avec un tilde pour remplir les variables PATH, MAILPATH, et CDPATH, et le shell fournira la valeur correcte.  

Remplacement des paramètres

Le caractère `$' permet d'introduire le remplacement des paramètres, la substitution de commandes, ou l'expansion arithmétique. Le nom du paramètre ou du symbole à développer peut être encadré par des accolades, afin d'éviter que les caractères suivants ne soient considérés comme appartenant au nom de la variable.

Lorsque les accolades sont utilisées, l'accolade finale est le premier caractère `}' non protégé par un antislash ni inclus dans une chaîne protégé, ni dans une expresssion arithmétique, une substitution de commande ou un développement de paramètre.

${paramètre}

est remplacé par la valeur du paramètre. Les accolades sont nécessaire quand le paramètre est un paramètre positionnel ayant plusieurs chiffres, ou si le paramètre est suivi de caractères n'appartenant pas à son nom.

Si le premier caractère du paramètre est un point d'exclamation, un niveau d'indirection de variable est introduit. Bash utilise la valeur de la variable formée par le reste du paramètre comme un nom de variable. Cette variable est alors développée et la valeur utilisée pour le reste de la substitution plutôt que la valeur du paramètre lui-même. On appelle ce mécanisme le développement indirect.

Dans chacun des exemples suivants, le mot est soumis au développement du tilde, au remplacement des paramètres, à la substitution de commandes, et à l'évaluation arithmétique. Bash vérifie si un paramètre existe, et s'il n'est pas nul. L'omission du double point ne fournit qu'un test d'existence.

${paramètre:-mot}

Utilisation d'une valeur par défaut. Si le paramètre est inexistant ou nul, on substitue le développement du mot. Sinon, c'est la valeur du paramètre qui est fournie.

${paramètre:=mot}

Attribution d'une valeur par défaut. Si le paramètre est inexistant ou nul, le développement du mot lui est affecté. La valeur du paramètre est alors renvoyée. Les paramètres positionnels, et spéciaux ne peuvent pas être affectés de cette façon.

${paramètre:?mot}

Affichage d'une erreur si inexistant ou nul. Si le paramètre est inexistant, ou nul, le développement du mot (ou un message approprié si aucun mot n'est fourni) est affiché sur la sortie d'erreur standard, et l'interpréteur se termine, s'il n'est pas interactif. Autrement, la valeur du paramètre est utilisée.

${paramètre:+mot}

Utilisation d'une valeur différente. Si le paramètre est nul, ou inexistant, rien n'est substitué. Sinon le développement du mot est renvoyé.

${paramètre:début}

${paramètre:début:longueur}

Extraction de sous-chaîne Se développe pour fournir la sous-chaîne de la longueur indiquée (en caractères) commençant au début.D offset. Si la longueur est omise, fournit la sous-chaîne commençant au caractère de début et s'étendant jusqu'à la fin du paramètre. La longueur et le début sont des expressions arithmétiques (voir ÉVALUATION ARITHMÉTIQUE plus bas). La longueur doit être positive ou nulle. Si le début est négatif, sa valeur est considérée à partir de la fin du contenu du paramètre. Si le paramètre est @, le résultat correspond aux longueur paramètres positionnels commençant au début. Si le paramètre est un nom de tableau indexé par @ ou *, le résultat est les longueur membres du tableau commençant à ${paramètre[début]}. L'indexation des sous-chaînes débute à zéro, sauf pour les paramètres positionnels qui débute en 1.

${#paramètre}

Est remplacé par la longueur, en caractères, de la valeur du paramètre. Si le paramètre est * ou @, la valeur est le nombre de paramètres positionnels. Si le paramètre est un nom de tableau indexé par * ou @, la valeur est le nombre d'éléments dans le tableau.

${paramètre#mot}

${paramètre##mot}

Le mot est développé pour fournir un motif, comme dans l'expansion des noms de fichiers. Si le motif correspond au début de la valeur du paramètre, alors le développement prend la valeur du paramètre après suppression du plus petit motif commun (cas ``#''), ou du plus long motif (cas ``##''). Si le paramètre est @ ou *, l'opération de suppression de motif est appliquée à chaque paramètre positionnel successivement, et le développement donne la liste finale. Si le paramètre est une variable tableau indexée par @ ou *, l'opération de suppression de motif est appliquée à chaque membre du tableau successivement, et le développement donne la liste finale.

${paramètre%mot}

${paramètre%%mot}

est développé pour fournir un motif, comme dans l'expansion des noms de fichiers. Si le motif correspond à une portion finale de la valeur du paramètre, alors le développement prend la valeur du paramètre après suppression du plus petit motif commun (cas ``%''), ou du plus long motif (cas ``%%''). Si le paramètre est @ ou *, l'opération de suppression de motif est appliquée à chaque paramètre positionnel successivement, et le développement donne la liste finale. Si le paramètre est une variable tableau indexée par @ ou *, l'opération de suppression de motif est appliquée à chaque membre du tableau successivement, et le développement donne la liste finale.

${paramètre/motif/chaîne}

${paramètre//motif/chaîne}

Le motif est développé comme dans le traitement des noms de fichiers. Le paramètre est développé et la plus longue portion correspondant au motif est remplacée par la chaîneg. Dans la première forme, seule la première correspondance est remplacée, dans la seconde toutes les portions correspondant au motif sont remplacées par la chaîne. Si le motif commence par #, il doit correspondre au début de la valeur développée du paramètre. Si le motif commence par %, il doit correspondre à la fin du développement du paramètre. Si la chaîne est nulle, les portions correspondant au motif sont supprimées et le / après le motif peut être omis. Si le paramètre est @ ou *, l'opération de substitution est appliquée à chacun des paramètres positionnels successivement, et le résultat est la liste finale. Si le paramètre est une variable tableau indexée par @ ou *, l'opération de substitution s'applique à chaque membre du tableau successivement, et le résultat est la liste finale.

Substitution de commandes

La substitution de commandes permet de remplacer le nom d'une commande par son résultat. Il en existe deux formes :

$(commande)

`commande`

Bash effectue la substitution en exécutant la commande et en la remplaçant par sa sortie standard, dont les derniers sauts de lignes sont supprimés. Les sauts de lignes internes ne sont pas supprimés mais peuvent disparaître lors du découpage en mots. La substitution de commande $(cat fichier) peut être remplacée par l'équivalent plus rapide $(< fichier).

Quand l'ancienne forme de substitution avec les backquotes ` est utilisée, le caractère antislash garde sa signification littérale, sauf s'il est suivi de $, `, ou \. La première backquote non protégée par un antislash termine la substitution de commande. Quand on utilise la forme $(commande), tous les caractères entre parenthèses gardent leurs valeurs littérales. Aucun n'est traité spécialement.

Les substitutions de commandes peuvent être imbriquées. Avec l'ancienne forme, il faut protéger les backquotes internes avec un backslash.

Si la substitution apparaît entre guillemets, le découpage des mots, et l'expansion des noms de fichiers ne sont pas effectués.  

Évaluation Arithmétique

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

$((expression))

L'expression est manipulée de la même manière que si elle se trouvait entre guillemets, mais un guillemet se trouvant entre les parenthèses n'est pas traité spécifiquement. Tous les mots de l'expression subissent le développement des paramètres, la substitution des commandes et la suppression des apostrophes et guillemets. Les évaluations arithmétiques peuvent être imbriquées.

L'évaluation est effectuée en suivant les règles mentionnées dans le paragraphe CALCULARITHMÉTIQUE. Si l'expression est invalide, bash affiche un message indiquant l'erreur, et aucune substitution n'a lieu.  

Substitution de Processus

La substitution de processus n'est disponible que sur les systèmes acceptant le mécanisme des tubes nommés (FIFOs) ou la méthode /dev/fd de noms de fichiers Elle prend la forme <(liste) ou >(liste). La liste de processus est exécutée avec ses entrées et sorties connectée à une FIFO ou à un fichier dans /dev/fd. Le nom de ce fichier est passé en argument à la commande qui sera exécutée comme résultat de cette substitution. Si on utilise la forme >(liste), l'écriture dans le fichier fournira des entrées pour la liste. Si la forme <(liste) est utilisée, le fichier passe en argument devra être lu pour obtenir la sortie de la liste.

Sur les systèmes qui le permettent, la substitution de processus est effectuée simultanément au remplacement des paramètres et variables, a la substitution de commande, et à l'évaluation arithmétique.  

Séparation des mots

Les résultats du remplacement des paramètres, de la substitution de commandes, et de l'évaluation arithmétique, qui ne se trouvent pas entre guillemets sont analysés par le shell afin d'appliquer le découpage des mots.

L'interpréteur considère chaque caractère du paramètre IFS comme un délimiteur, et redécoupe le résultat des transformations précédentes en fonction de ceux-ci. Si la valeur du paramètre IFS est exactement <espace><tabulation><retour-chariot>, (la valeur par défaut), alors toute séquence de caractères IFS sert à délimiter les mots. Si IFS a une valeur autre que celle par défaut, alors les séquences de caractères blancs espace et tabulation sont ignorées en début et fin de mot, à condition que ces caractères blancs se trouvent dans la valeur de IFS (un caractère de IFS blanc). Tout autre caractère de IFS se trouvant à côté d'un caractère blanc de IFS, sert à délimiter un champ. Une séquence de caractères blancs de IFS est également traitée comme un séparateur. Si la valeur de IFS est nulle, aucun découpage de mot n'a lieu.

Les arguments nuls explicites ("" ou '') sont conservés. Les arguments nuls implicites, résultant du développement des paramètres n'ayant pas de valeurs, sont éliminés. Si un paramètre sans valeur est développé entre guillemets, le résultat est un argument nul qui est conservé.

Notez que si aucun développement n'a lieu, le découpage des mots n'est pas effectué.  

Développement des noms de fichiers

Après le découpage des mots, et si l'option -f n'est pas indiquée, bash recherche dans chaque mot les caractères *, ?, (, et [. Si l'un d'eux apparaît, le mot est considéré comme un motif, et remplacé par une liste, classée par ordre alphabétique, des noms de fichiers correspondant à ce motif. Si aucun nom de fichiers ne correspond, et si l'option shell nullglob n'est pas active, le mot reste inchangé. Si l'option nullglob est active, et si aucune correspondance n'est trouvée, le mot est supprimé. Si l'option shell nocaseglob est activée, la correspondance a lieu sans tenir compte des différences majuscules / minuscules. Quand un motif est utilisé pour créer des chemins d'accès, le caractère ``.'' au début d'un nom, ou immédiatement à la suite d'un slash doit être explicitement mis en correspondance, à moins que l'option shell dotglob ne soit active. Le caractère slash doit toujours être mis en correspondance explicitement. Dans tous les autres cas, le caractère ``.'' n'est pas traité spécifiquement. Voyez la description de la commande shopt dans COMMANDES INTERNES DU SHELL pour une description des options shell nocaseglob, nullglob, et dotglob.

la variable shell GLOBIGNORE peut servir à restreindre l'ensemble des noms de fichiers correspondant à un motif. Si GLOBIGNORE est remplie, chaque nom de fichier qui correspond aussi à un motif de GLOBIGNORE est supprimé de la liste des correspondances. Les noms de fichiers ``.'' et ``..'' sont toujours ignorés, même quand GLOBIGNORE est remplie. Toutefois, configurer GLOBIGNORE a pour effet d'activer l'option shell dotglob, ainsi tous les autres noms de fichiers commençant par ``.'' correspondront. Pour obtenir l'ancien comportement ignorant les noms commençant par ``.'', placez ``.*'' dans l'un des motifs de GLOBIGNORE. L'option dotglob est désactivée si la variable GLOBIGNORE n'existe pas.

Motifs génériques

Tout caractère apparaissant dans un motif, hormis les caractères spéciaux décrits ci-après correspond à lui-même. Le caractère NUL ne peut pas se trouver dans un motif. Les caractères spéciaux doivent être protégés si ils doivent se correspondre littéralement.

Les caractères spéciaux ont les significations suivantes :

*

Correspond à n'importe quelle chaîne, y compris la chaîne vide.

?

Correspond à n'importe quel caractère.

[...]

Correspond à l'un des caractères entre crochets. Une paire de caractères séparés par un signe "moins" indique un intervalle; qui correspond à n'importe quel caractère situé entre les deux bornes incluses. Si le premier caractère suivant le [ est un ! ou un ^ alors la correspondance se fait sur les caractères non-inclus. Un - peut être mis en correspondance en l'incluant en premier ou dernier caractère de l'ensemble. Un ] peut être mis en correspondance en l'incluant en premier caractère de l'ensemble.

Entre [ et ], on peut indiquer une classe de caractère en utilisant la syntaxe [:classe:], où classe est l'une des classes suivantes, définies dans le standard POSIX.2 :

alnum alpha ascii blank cntrl digit graph lower print punct space upper xdigit
Une classe correspond à un caractère quelconque qui s'y trouve.

Entre [ et ], on peut indiquer une classe d'équivalence en utilisant la syntaxe [=c=], qui correspond à n'importe quel caractère ayant le même ordre (comme indiqué dans la localisation en cours) que le caractère c.

Entre [ et ], la syntaxe [.symbole.] correspond au symbole de classement symbole.

Si l'option extglob du shell option est activée par la commande shopt plusieurs opérateurs de correspondance étendue sont reconnus. Dans la description suivante, une liste-motif est une liste d'un ou plusieurs motifs séparés par des |. Les motifs composés sont formés en utilisant un ou plusieurs sous-motifs comme suit :

?(liste-motif)

Correspond à zéro ou une occurrence des motifs indiqués

*(liste-motif)

Correspond à zéro ou plusieurs occurrences des motifs indiqués

+(liste-motif)

Correspond à une ou plusieurs occurrences des motifs indiqués

@(liste-motif)

Correspond à une occurrence exactement des motifs indiqués

!(liste-motif)

Correspond à tout sauf les motifs indiqués

Suppression des protections

Après les développements précédents, toutes les occurrences non-protégées des caractères \, `, et " qui ne résultent pas d'un développement sont supprimées.  

REDIRECTION

Dans les descriptions suivantes, si le numéro de descripteur de fichier est omis, et si le premier caractère de l'opérateur de redirection est <, celui-ci correspondra à l'entrée standard (descripteur de fichier 0). Si le premier caractère de l'opérateur est >, la redirection s'appliquera à la sortie standard (descripteur de fichier 1).

Le mot qui suit l'opérateur de redirection dans les descriptions suivantes est soumis à l'expansion des accolades, du tilde, des paramètres, à la substitution de commandes, à l'évaluation arithmétique, à la suppression des protections, et au développement des noms de fichiers. S'il se modifie pour donner plusieurs mots, bash détectera une erreur.

Remarquez que l'ordre des redirections est important. Par exemple, la commande

ls > liste_répertoires 2>&1

redirige a la fois la sortie standard et la sortie d'erreur vers le fichier liste_répertoires, alors que la commande

ls 2>&1 > liste_répertoires

ne redirige que la sortie standard vers le fichier liste_répertoires, car la sortie d'erreur a été renvoyée vers la sortie standard avant que celle-ci ne soit redirigée vers liste_répertoires.

Une erreur d'ouverture ou de création de fichier peut déclencher un échec.  

Redirection d'entrée

Lorsque l'on applique une redirection d'entrée, le fichier dont le nom résulte du développement du mot sera ouvert en lecture avec le descripteur de fichier numéro n, ou en tant qu'entrée standard (descripteur de fichier 0) si n n'est pas mentionné.

Le format général des redirections d'entrée est le suivant :

[n]<mot

Redirection de sortie

Lors d'une redirection de sortie, le fichier dont le nom résulte du développement du mot est ouvert en écriture, avec le descripteur de fichier n, ou en tant que sortie standard (descripteur de fichier 1) si n n'est pas mentionné. Si le fichier n'existe pas, il est créé. S'il existait déjà, sa taille est ramenée à 0.

Le format général des redirections de sortie est le suivant :

[n]>mot

Si l'opérateur de redirection est >, et si l'option noclobber de la commande interne set est activée, la redirection échouera si le fichier dont le nom résulte du développement du mot existe et est un fichier régulier. Si l'opérateur de redirection est >|, ou l'opérateur > avec l'option noclobber de la commande interne set n'est pas activée, la redirection sera tentée même si le fichier dont le nom résulte du développement du mot existe.  

Redirection pour Ajout en Sortie

Lorsqu'on redirige ainsi la sortie, le fichier dont le nom résulte du développement du mot est ouvert pour ajout en fin de fichier, avec le descripteur n, ou en tant que sortie standard (descripteur 1) si n n'est pas mentionné. Si le fichier n'existe pas, il est créé.

Le format général pour la redirection de sortie avec ajout est :

[n]>>mot

Redirection de la sortie standard et de la sortie d'erreur

Bash permet la redirection simultanée de la sortie standard (descripteur 1) et de la sortie d'erreur (descripteur 2), dans un fichier dont le nom est le résultat du développement du mot avec cette construction.

Il y a deux formes pour effectuer cette double redirection :

&>mot

>&mot

On préfère généralement la première. Elle est sémantiquement équivalente à

>mot 2>&1

Document en ligne

Avec ce type de redirection, le shell va lire son entrée standard jusqu'à ce qu'il atteigne une ligne contenant uniquement le mot prévu (sans espaces à la suite), nommée étiquette. Une fois cette étiquette atteinte, il exécutera la commande demandée en lui fournissant en entrée le texte lu avant l'étiquette, que l'on appelle document en ligne.

Le format des documents en ligne est le suivant :

<<[-]mot
        document en ligne
étiquette

Il n'y a ni remplacement de paramètre, ni substitution de commande, ni développement de chemin d'accès, ni évaluation arithmétique sur le mot. Si l'un des caractères du mot est protégé, l' étiquette est obtenue après suppression des protections dans le mot, et les lignes du document ne sont pas développées. Sinon, toutes les lignes du document sont soumises au remplacement des paramètres, à la substitution de commandes, et à l'évaluation arithmétique. Dans ce dernier cas, les couples \<retour-chariot> sont ignorés, et \ doit être utilisé pour protéger les caractères \, $, et `.

Si l'opérateur de redirection est <<-, alors les tabulations en tête de chaque ligne sont supprimées, y compris dans la ligne contenant étiquette. Ceci permet d'indenter de manière naturelle les documents en ligne au sein des scripts.  

Dédoublement de descripteur de fichier

L'opérateur de redirection

[n]<&mot

permet de dupliquer les descripteurs de fichiers en entrée. Si le mot se transforme en un ou plusieurs chiffres, le descripteur de fichier n devient une copie de ce descripteur. Si les chiffres du mot ne correspondent pas à un descripteur en lecture, une erreur se produit. Si le mot prend la forme -, le descripteur n est fermé. Si n n'est pas mentionné, on utilise l'entrée standard (descripteur 0).

L'opérateur

[n]>&mot

est utilisé de manière similaire pour dupliquer les descripteurs de sortie. Si n n'est pas précisé, on considère la sortie standard (descripteur 1). Si les chiffres du mot ne correspondent pas à un descripteur en écriture, une erreur se produit. Un cas particulier se produit si n est omis, et si mot ne se développe pas sous forme de chiffres. Alors, les sorties standard et d'erreurs sont toutes deux redirigées comme précédemment.  

Ouverture en Lecture/Écriture d'un descripteur de fichier

L'opérateur de redirection

[n]<>mot

ouvre le fichier dont le nom résulte du développement du mot, à la fois en lecture et en écriture et lui affecte le descripteur de fichier n, ou bien le descripteur 0 si n n'est pas mentionné. Si le fichier n'existe pas, il est créé.  

ALIAS

Les alias sont créés et affichés avec la commande alias, et supprimés avec la commande unalias.

Il n'existe pas de mécanisme permettant d'utiliser des arguments dans le texte de remplacement. Si on en a besoin, il faut utiliser une fonction du shell.

Les alias ne sont développés qu'avec les shells interactifs sauf si l'option expand_aliases du shell est activée par la commande shopt (voir la description de shopt au paragraphe COMMANDES INTERNES DU SHELL plus bas)

Les règles concernant la définition et l'utilisation des alias sont un peu confuses. Bash lit toujours au moins une ligne d'entrée complètement avant d'exécuter une commande de cette ligne. Les alias sont traités lorsque la commande est lue, et non pas lorsqu'elle est exécutée. Ainsi, une définition d'alias apparaissant sur la même ligne qu'une autre commande ne prend pas effet avant la lecture de la prochaine ligne d'entrée. Autrement dit, une commande placée à la suite d'une définition d'alias, sur la même ligne ne sera pas affectée par cet alias. Ce comportement est également important lors de l'exécution des fonctions. Les alias sont traités lorsque la définition de la fonction est lue, et non pas lors de l'exécution de cette fonction. Ainsi des alias définis dans une fonction ne sont pas actifs avant la fin de l'exécution de la fonction. Pour plus de tranquillité, placez toujours les définitions d'alias sur des lignes isolées, et n'utilisez jamais la commande alias dans les commandes composées.

Notez enfin que la plupart du temps les alias sont avantageusement remplacés par des fonctions du shell.  

FONCTIONS

Les variables locales d'une fonction peuvent être déclarées avec la commande local. Autrement, les variables et leurs valeurs sont partagées entre la fonction et son appelant.

Si la commande interne return est exécutée dans une fonction, celle-ci se termine et l'exécution reprend avec la commande suivant l'appel de fonction. Quand une fonction se termine, les paramètres positionnels et le paramètre spécial # reprennent les valeurs qu'ils avaient avant l'appel de fonction.

Les noms des fonctions et leurs définitions sont affichés avec l'option -f des commandes internes declare ou typeset. Les options -F de declare ou typeset n'afficheront que les noms des fonctions. Les fonctions peuvent être exportées automatiquement avec l'option -f de la commande interne export, afin de rester définies dans les sous-shells.

Les fonctions peuvent être récursives. Aucune limite n'est imposée quant au nombre d'appels récursifs.  

CALCUL ARITHMÉTIQUE

- +

plus et moins unaire

! ~

négations logique et binaire

**

exponentiation

* / %

multiplication, division, reste

+ -

addition, soustraction

<< >>

décalage arithmétique à gauche et à droite

<= >= < >

comparaisons

== !=

égalité et différence

&

ET binaire

^

OU exclusif binaire

|

OU binaire

&&

ET logique

||

OU logique

expr?expr:expr

évaluation conditionnelle

= *= /= %= += -= <<= >>= &= ^= |=

assignations

On peut utiliser les variables du shell comme opérandes, le développement des paramètres étant effectué avant l'évaluation arithmétique. Les valeurs des paramètres sont converties en entiers longs dans les expressions. Une variable shell n'a donc pas besoin d'avoir l'attribut "entier" pour être utilisable dans un calcul.

Les constantes commençant par un 0 sont interprétées comme des nombres octaux. Un entête 0x ou 0X indique une valeur hexadécimale. Sinon, les nombres ont la forme [base#]n, ou la base arithmétique est un nombre décimal entre 2 et 36, et n le nombre lui-même exprimé dans cette base. Si la base n'est pas mentionnée, le nombre est considéré comme décimal. Les chiffre supérieurs à 9 sont représentés par les lettres minuscules, les lettres majuscules, le _ et le @, dans cet ordre. Si la base est inférieure ou égale à 36 les minuscules et les majuscules peuvent être utilisées de manière interchangeable pour représenter les nombres entre 10 et 35.

Les opérateurs sont évalués dans l'ordre de précédence. Les sous-expressions entre parenthèses sont évaluées en premier, ce qui permet de surpasser les règles de précédence.  

EXPRESSIONS CONDITIONNELLES

-a fichier

Vrai si le fichier existe.

-b fichier

Vrai si le fichier existe et est un fichier spécial bloc.

-c fichier

Vrai si le fichier existe et est un fichier spécial caractère.

-d fichier

Vrai si le fichier existe et est un répertoire

-e fichier

Vrai si le fichier existe.

-f fichier

Vrai si le fichier existe et est un fichier régulier.

-g fichier

Vrai si le fichier existe et a son bit Set-GID positionné.

-h fichier

Vrai si le fichier existe et est un lien symbolique.

-k fichier

Vrai si le fichier existe et a son bit ``sticky'' positionné.

-p fichier

Vrai si le fichier existe et est un tube nommé (FIFO).

-r fichier

Vrai si le fichier existe et est accessible en lecture.

-s fichier

Vrai si le fichier existe et a une taille non nulle.

-t fd

Vrai si fd est ouvert sur un terminal.

-u fichier

Vrai si le fichier existe et a son bit Set-UID positionné.

-w fichier

Vrai si le fichier existe et est accessible en écriture.

-x fichier

Vrai si le fichier existe et est exécutable.

-O fichier

Vrai si le fichier existe et appartient à l'ID effectif de l'utilisateur.

-G fichier

Vrai si le fichier existe et appartient au groupe effectif de l'utilisateur.

-L fichier

Vrai si le fichier existe et est un lien symbolique.

-S fichier

Vrai si le fichier existe et est une socket

-N fichier

Vrai si le fichier existe et a été modifié depuis sa dernière lecture.

fichier_1 -nt fichier_2

Vrai si le fichier_1 est plus récent que le fichier_2, d'après les dates de modification.

fichier_1 -ot fichier_2

Vrai si le fichier_1 est plus vieux que le fichier_2.

fichier_1 -ef fichier_2

Vrai si lefichier_1 et le fichier_2 sont sur le même périphérique et ont les mêmes numéros d'i-noeuds.

-o nom_opt

Vrai si l'option shell nom_opt est active. Cosulter la liste des options dans la description de l'argument -o de la commande interne set plus bas.

-z chaîne

Vrai si la longueur de la chaîne est nulle.

-n chaîne

chaîne

Vrai si la longueur de la chaîne est non-nulle.

chaîne_1 == chaîne_2

Vrai si les deux chaînes sont égales. Le symbole = peut servir à remplacer ==

chaîne_1 != chaîne_2

Vrai si les deux chaînes sont différentes.

chaîne_1 < chaîne_2

Vrai si chaîne_1 se trouve avant chaîne_2 dans l'ordre lexicographique de la localisation en cours.

chaîne_1 > chaîne_2

Vrai si chaîne_1 se trouve après chaîne_2 dans l'ordre lexicographique de la localisation en cours.

arg1 OP arg2

OP est l'un des opérateurs suivants -eq, -ne, -lt, -le, -gt, ou -ge. Ces opérateurs arithmétiques binaires renvoient la valeur vraie si arg_1 est respectivement égal, différent, inférieur, inférieur ou égal, supérieur, supérieur ou égal à arg2. Arg1 et arg2 peuvent être des entiers positifs ou négatifs.

DÉVELOPPEMENT DES COMMANDES SIMPLES

1.

Les mots que l'analyser a repéré comme affectation de variables (ceux qui précèdent le nom de la commande) et les redirections sont mémorisés pour une mise en place ultérieure.

2.

Les autres mots sont développés. S'il reste des mots après le développement, le premier est considéré comme le nom d'une commande et les suivants comme ses arguments.

3.

Les redirections sont mises en place, comme décrit plus-haut au paragraphe REDIRECTION.

4.

Le texte suivant le = dans chaque affectation est soumis au dévelopement du tilde, des paramètres, à la substitution de commande, à l'évaluation arithmétique et à la suppression des protection avant de remplir la variable.

Si aucun nom de commande ne résulte des précédentes opérations, les assignations de variable modifie l'environnement en cours. Sinon elles sont ajoutées à celui de la commande exécutée et ne modifient pas l'environnement du shell. Si l'une des tentatives d'affectation concerne une variable en lecture seule, une erreur se produit, et la commande se termine sur un code non-nul.

Si aucun nom de commande n'est obtenu, les redirections sont réalisées mais ne modifient pas l'environnement du shell en cours. Une erreur de redirection renvoie un code de retour non-nul.

S'il reste un nom de commande après l'expansion, l'exécution a lieu comme décrit ci-dessous. Sinon la commande se termine. Si l'un des développement contient une substitution de commande, le code de retour est celui de la dernière substitution de commande réalisée. S'il n'y en a pas, la commande se termine avec un code de retour nul.  

EXÉCUTION DES COMMANDES

Si le nom de la commande ne contient pas de slash, le shell tente de la trouver. S'il existe une fonction shell de ce nom, elle est appelée comme nous l'avons vu dans le paragraphe FONCTIONS plus haut. Si le nom n'est pas celui d'une fonction, l'interpréteur le recherche dans la liste des fonctions internes. Si une équivalence est trouvée, la fonction interne est invoquée.

Si le nom n'est ni celui d'une fonction shell, ni celui d'une commande interne, et s'il ne contient pas de slash, bash va chercher dans chacun des membres de PATH un répertoire contenant un fichier exécutable du nom désiré. Bash utilise une table de hachage pour mémoriser les noms d'accès complets des fichiers (voir la commande hash au paragraphe COMMANDES INTERNES DU SHELL plus bas). Une recherche complète dans les répertoires du PATH n'est entreprise que si la commande ne se trouve pas dans la table de hachage. Si la recherche est infructueuse, l'interpréteur affiche un message d'erreur et renvoie un code de retour valant 127.

Si la recherche réussit, ou si le nom de la commande contient au moins un slash, le shell exécute le programme voulu dans un environnement distinct. L'argument 0 est rempli avec le nom fourni, et les autres arguments seront éventuellement remplis avec le reste de la ligne de commande.

Si l'exécution échoue parce que le programme n'est pas un exécutable, et si le fichier n'est pas un répertoire, on le considère alors comme un script shell, un fichier contenant une série de commandes. Un sous-shell est alors créé pour exécuter ce script. Ce sous-shell se réinitialisera lui-même, comme si un nouveau shell avait été invoqué pour exécuter le script, à la différence qu'il continuera à mémoriser l'emplacement des commandes connues de son parent (voir hash dans le paragraphe COMMANDES INTERNES DU SHELL plus bas).

Si le programme est un fichier commençant par #!, le reste de la première ligne indique un interpréteur pour ce programme. Le shell se chargera d'exécuter cet interpréteur, si le système d'exploitation ne gère pas lui-même ce format d'exécutable. Les arguments de l'interpréteur consistent en un premier argument éventuel fourni sur la première ligne du fichier à la suite du nom de l'interpréteur, suivi du nom du programme, suivi des arguments de la commande s'il y en a.  

ENVIRONNEMENT D'EXÉCUTION DES COMMANDES

*

les fichiers ouverts hérités par le shell à son lancement, et modifiés par les redirections de la commande interne exec ;

*

le répertoire de travail configuré par cd, pushd, ou popd, ou hérité par le shell son démarrage ;

*

le masque de création de fichier fixé par umask ou hérité du père du shell ;

*

la gestion des signaux configurée avec trap ;

*

les paramètres du shemm fixés par des affectation de variables ou avec la commande interne set ou hérité de l'environnement du père du shell ;

*

les fonctions du shell définies lors de l'exécution ou héritées de l'environnement du père du shell ;

*

les options fournies au démarrage (par défaut ou sur la ligne de commandes) ou par la commande interne set ;

*

les options activées par la commande interne shopt ;

*

les alias du shell définies par la commande alias ;

*

les ID des divers processus, y compris ceux à l'arrière-plan, la valeur de $$, et la valeur de $PPID.

Lorsqu'une commande autre qu'une fonction interne ou une fonction du shell doit être exécutée, elle est invoquée dans un environnement d'exécution séparé constitué de ce qui suit. Sauf indication contraire, les valeurs sont héritées de l'environnement du shell.

*

les fichier ouverts du shell, auxquels s'ajoutent les modification indiquées par le redirections apportées à la commande ;

*

le répertoire de travail en cours ;

*

le masque de création de fichiers ;

*

les variables du shell marquées pour l'exportation, ainsi que les variables exportées spécialement pour la commande ;

*

les signaux capturés par le shell reprennent le comportement hérité du père du shell, et les signaux ignorés par le shell restent ignorés.

Une commande invoquée dans un environnement distinct ne peut pas affecter l'environnement d'exécution du shell.

Les substitutions de commandes et les commandes asynchrones sont invoquées dans un environnement de sous-shell qui est une copie de celui du shell, sauf que les signaux capturés par le shell reprennent le comportement qu'ils avaient au lancement du shell. Les fonctions internes invoquées dans un pipeline sont aussi exécutées dans un environnement de sous-shell. Les modifications apportées à l'environnement d'un sous-shell n'affectent aucunement l'environnement du shell.  

ENVIRONNEMENT

Le shell permet de manipuler l'environnement de plusieurs façons. Au démarrage, le shell analyse son propre environnement, et crée un paramètre pour chaque nom trouvé, en le marquant comme exportable vers les processus fils. Les commandes exécutées héritent de cet environnement. Les commandes export et declare -x permettent d'ajouter ou de supprimer des paramètres ou des fonctions de l'environnement. Si la valeur d'un paramètre de l'environnement est modifiée, la nouvelle valeur devient une partie de l'environnement, et elle remplace l'ancienne. L'environnement hérité par les commandes exécutées est l'environnement initial du shell (dont les valeurs peuvent être modifiées), moins les éléments supprimés par la commande unset, plus les éléments ajoutés par les commandes export et declare -x.

L'environnement d'une commande simple ou d'une fonction peut être augmenté temporairement en la faisant précéder d'une affectation de paramètre, comme nous l'avons vu au paragraphe PARAMÈTRES. Ces affectations ne concernent que l'environnement vu par cette commande ou fonction.

Si l'option -k est utilisée (voir la commande interne set plus bas), alors toutes les affectations de paramètres sont placées dans l'environnement d'une commande exécutée, pas seulement celles qui précèdent son nom.

Quand bash invoque une commande externe, la variable _ contient le chemin d'accès complet à cette commande, et elle est transmise dans l'environnement.  

CODE DE RETOUR

Si une commande n'est pas trouvée, le processus fils créé pour l'exécuter renvoie la valeur 127. Si la commande est trouvée mais pas exécutable, la valeur renvoyée est 126.

Si une commande échoue à cause d'une erreur survenue lors du développement ou de la mise en place des redirections, le code de retour est supérieur à zéro.

Les fonctions interne renvoient zéro (vrai) si elles réussissent et une valeur non nulle (faux) si une erreur se produit durant leur exécution. Toutes les fonctions internes renvoient 2 en cas d'erreur de syntaxe.

Bash lui-même renvoie le code de retour de la dernière commande exécutée, à moins qu'une erreur de syntaxe ne se produise, auquel cas il renvoie une valeur non-nulle. Voir également la commande interne exit plus bas.  

SIGNAUX

Les jobs synchrones lancés par bash reçoivent les valeurs des signaux héritées par le shell de leur parent. Quand le contrôle de job n'est pas actif, les jobs en arrière-plan ignorent les signaux SIGINT et SIGQUIT également. Les commandes exécutées en tant que résultat de la substitution de commandes ignorent les signaux de contrôle de jobs émis par le clavier SIGTTIN, SIGTTOU, et SIGTSTP.

Par défaut, le shell se termine à la réception de SIGHUP. Avant de se terminer, il renvoie SIGHUP à tous les jobs en cours ou arrêtés. Les jobs arrêtés reçoivent aussi SIGCONT pour s'assurer qu'il recevront bien le SIGHUP. Pour empêcher le shell d'envoyer ce signal à un job particulier, il faut le retirer de la table des jobs à l'aide de la commande interne disown (voir FONCTIONS INTERNES DU SHELL plus bas) ou le marquer comme exempté de SIGHUP avec disown -h.

Si l'option du shell huponexit a été activée avec la fonction shopt, bash envoie un signal SIGHUP à tous les jobs lorsqu'un shell de login interactif se termine.

Lorsque bash reçoit un signal qu'il doit capturer, et qu'il attend la fin d'une commande, le gestionnaire de signal ne sera pas exécuté avan