Ubuntu Manpage: bash - Interpréteur de commandes GNU Bourne-Again SHell.

Provided by: manpages-fr-extra_20080921_all

NOM

       bash - Interpréteur de commandes GNU Bourne-Again SHell.

SYNOPSIS

       bash [options] [fichier]

COPYRIGHT

       Bash is Copyright (C) 1989-2005 by the Free Software Foundation, Inc.

DESCRIPTION

       Bash est un interpréteur de commandes (shell) compatible sh qui exécute
       les commandes lues depuis l’entrée standard ou depuis un fichier.  Bash
       inclut  aussi des fonctionnalités utiles des interpréteurs de commandes
       Korn et C (ksh et csh).

       Bash vise à être une implémentation conforme à la partie  relative  aux
       interpréteurs de commandes et utilitaires des spécifications IEEE POSIX
       (norme IEEE 1003.1). Bash peut être configuré pour  être  conforme  aux
       spécifications POSIX par défaut.

OPTIONS

En plus des options d’interpréteur monocaractères documentées dans la
description de la commande interne set, bash accepte les options
suivantes lors de son appel :

-c cha��ne Si l’option -c est présente, les commandes sont lues depuis
la cha��ne fournie. S’il y a des arguments après la cha��ne,
ils sont affectés aux paramètres positionnels, en commençant
par $0.
-i Si l’option -i est présente, l’interpréteur est interactif.
-l Faire que bash se comporte comme s’il avait été appelé comme
interpréteur de commandes de connexion (voir APPEL plus bas).
-r Si l’option -r est présente, l’interpréteur devient restreint
(voir INTERPRÉTEUR RESTREINT plus bas).
-s Si l’option -s est présente ou s’il ne reste plus d’argument
après le traitement des options, alors les commandes sont
lues depuis l’entrée standard. Cette option permet d’affecter
les paramètres positionnels tout en appelant un interpréteur
interactif.
-D Une liste de toutes les chaînes entre guillemets doubles
précédées de $ est affichée sur la sortie standard. Ce sont
les chaînes qui sont sujettes à une traduction quand le
paramètre linguistique régional n’est ni C ni POSIX. Cela
implique l’option -n ; aucune commande ne sera exécutée.
[-+]O [option_shopt]
option_shopt est une des options de l’interpréteur acceptées
par la commande interne shopt (voir plus bas COMMANDES
INTERNES DE L�’INTERPRÉTEUR ). Si option_shopt est présente,
-O crée cette option ; +O la détruit. Si option_shopt n’est
pas fournie, les noms et valeurs des options de
l’interpréteur acceptées par shopt sont affichés sur la
sortie standard. Si l’option d’appel est +O, la sortie est
affichée dans un format réutilisable en entrée.
-- Deux caractères -- indiquent la fin des options et
désactivent le traitement des arguments. Tous les arguments
après le -- sont traités comme des noms de fichiers et
paramètres. - est équivalent à --.

Bash reconnaît également plusieurs options multicaractères. Ces options
doivent, pour être reconnues, apparaître sur la ligne de commande avant
les options monocaractères.

--debugger
Prend les dispositions pour que le paramétrage du traçage soit
exécuté avant que l’interpréteur démarre. Enclenche le mode de
traçage étendu (voir plus bas la description de l’option
extdebug de la commande interne shopt) et le traçage des
fonctions de l’interpréteur (voir plus bas la description de
l’option -o functrace de la commande interne set).
--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 termine avec
succès.
--init-file fichier
--rcfile fichier
Exécuter les commandes contenues dans fichier plutôt que celles
du fichier d’initialisation commun à tout le système
/etc/bash.bashrc et que le fichier d’initialisation personnel
standard ~/.bashrc si l’interpréteur est interactif (voir APPEL
plus bas).

--login
Équivalent à -l.

--noediting
Ne pas utiliser la bibliothèque GNU readline pour lire les
lignes de commande, lorsque l’interpréteur est interactif.

--noprofile
Ne lire ni le fichier de configuration générale /etc/profile ni
les fichiers d’initialisation personnels ~/.bash_profile,
~/.bash_login, ni ~/.profile. Par défaut, bash lit ces fichiers
lorsqu’il est appelé comme interpréteur de commandes de
connexion (voir APPEL plus bas).

--norc Ne pas lire ni exécuter le fichier de configuration commun à
tout le système /etc/bash.bashrc ni le fichier personnel
d’initialisation ~/.bashrc lorsque l’interpréteur est
interactif. Cette option est activée par défaut si
l’interpréteur est appelé sous le nom sh.

--posix
Aligner le comportement de bash sur le standard POSIX, en ce qui
concerne les options dont l’action par défaut diffère de ce
standard (mode posix).

--restricted
L’interpréteur devient restreint (voir INTERPRÉTEUR RESTREINT
plus bas).

--verbose
Équivalent à -v.

--version
Affiche le numéro de version de bash sur la sortie standard et
termine avec succès.

ARGUMENTS

       S’il  reste des arguments sur la ligne de commande après traitement des
       options et que ni l’option -c, ni l’option -s n’ont  été  fournies,  le
       premier  argument  est  supposé être le nom du fichier dans lequel lire
       les commandes d’interpréteur. Si bash est appelé de cette façon, le nom
       du  ficher  est  affecté  à  $0  et  les  arguments restants aux autres
       paramètres positionnels. Bash lit et exécute les  commandes  depuis  ce
       fichier,  puis  termine.  L’état  final  de bash est l’état final de la
       dernière commande exécutée dans le script. Si aucune commande  n’a  été
       exécutée,  l’état  final  est  0.  Une  tentative  est d’abord faite de
       trouver le fichier dans le répertoire  courant  et,  si  aucun  fichier
       n’est  trouvé,  l’interpréteur  cherche  le script dans les répertoires
       contenus dans PATH.

APPEL

       Un interpréteur de commandes est dit de connexion (login shell)  si  le
       premier  caractère  de  son  argument  numéro zéro est un - ou s’il est
       appelé avec l’option --login.

       Un interpréteur est interactif s’il est appelé sans argument autre  que
       des  options  et  sans l’option -c, dont l’entrée standard et sa sortie
       d’erreur sont toutes deux connectées à des terminaux  (comme  déterminé
       par  la  fonction  isatty(3)) ou s’il est appelé avec l’option -i.  PS1
       est créée et $- contient la lettre i si bash  est  interactif,  ce  qui
       permet à un script ou à un fichier de démarrage de tester cet état.

       Le   paragraphe  suivant  décrit  comment  bash  exécute  ses  fichiers
       d’initialisation. Si un quelconque de ces fichiers  existe  mais  n’est
       pas  accessible  en  lecture,  bash signale une erreur. Les tildes sont
       remplacés  par  des  noms  de  fichiers  comme  décrit  plus  bas  dans
       Développement du tilde dans le paragraphe DÉVELOPPEMENTS.

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

       Lorsqu’un  interpréteur  de commandes de connexion termine, bash lit et
       exécute les commandes du fichier ~/.bash_logout, s’il existe.

       Quand un interpréteur interactif démarre sans être un  interpréteur  de
       commandes  de  connexion, bash lit et exécute les commandes se trouvant
       dans /etc/bash.bashrc et ~/.bashrc s’ils existent. Ce comportement peut
       être  empêché  à  l’aide  de l’option --norc. L’option --rcfile fichier
       forcera bash à lire et exécuter les commandes dans fichier  plutôt  que
       dans /etc/bash.bashrc et ~/.bashrc.

       Quand  bash  est  démarré  de  façon  non interactive, par exemple pour
       lancer   un   script,   il   consulte   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 était exécutée :
              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 appelé sous le nom sh, il essaye d’imiter  le  comportement
       de  démarrage  des  versions  historiques  de  sh  aussi fidèlement que
       possible, tout en restant conforme aux spécifications POSIX.  Lorsqu’il
       est  appelé  comme interpréteur de commandes de connexion interactif ou
       non interactif avec l’option --login, il  essaye  d’abord  de  lire  et
       exécuter,  dans  cet  ordre,  les  commandes  de  /etc/profile  puis de
       ~/.profile. L’option --noprofile peut être utilisée  pour  empêcher  ce
       comportement.  Quand  il  est appelé en tant qu’interpréteur 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 interpréteur appelé sous le nom sh  n’essaye
       pas  de  lire et d’exécuter des commandes d’un quelconque autre fichier
       de démarrage, l’option --rcfile n’a aucun effet.  Un  interpréteur  non
       interactif  appelé  sous le nom sh n’essaie de lire aucun autre fichier
       d’initialisation. Quand il est appelé sous le nom  sh,  bash  entre  en
       mode posix après avoir lu les fichiers d’initialisation.

       Quand  bash est appelé en mode posix comme avec l’option --posix sur la
       ligne de commande, il suit le  standard  POSIX  pour  les  fichiers  de
       démarrage.  Dans  ce mode, les interpréteurs interactifs développent la
       variable ENV et les commandes  sont  lues  et  exécutées  à  partir  du
       fichier  dont  le  nom  est  la  valeur développée. Aucun autre fichier
       d’initialisation n’est lu.

       Bash tente de déterminer s’il est exécuté  par  le  démon  lançant  les
       interpréteurs de commandes distants, généralement rshd. Si bash conclut
       qu’il est exécuté  par  rshd,  il  lit  et  exécute  les  commandes  de
       /etc/bash.bashrc   et  ~/.bashrc  si  ces  fichiers  existent  et  sont
       lisibles. Il n’a pas ce comportement lorsqu’il est appelé sous  le  nom
       sh. L’option --norc peut être utilisée pour empêcher ce comportement et
       l’option --rcfile peut être utilisée pour forcer la lecture d’un  autre
       fichier,  mais  rshd n’appelle généralement pas l’interpréteur avec ces
       options ni ne permet de les spécifier.

       Si  l’interpréteur  est  lancé  avec   un   identifiant   (de   groupe)
       d’utilisateur   effectif   différent   de   l’identifiant  (de  groupe)
       d’utilisateur réel et si l’option -p n’est pas fournie,  aucun  fichier
       d’initialisation  n’est lu, les fonctions de l’interpréteur ne sont pas
       importées depuis l’environnement, la variable  SHELLOPTS,  si  présente
       dans  l’environnement,  est  ignorée  et l’identifiant de l’utilisateur
       effectif est mis à celui de l’utilisateur  réel.  Si  l’option  -p  est
       fournie  à  l’appel,  le  comportement  au  démarrage  est le même mais
       l’identifiant d’utilisateur effectif n’est pas modifié.

DÉFINITIONS

       Les définitions  suivantes  sont  utilisées  dans  toute  la  suite  ce
       document.
       blanc  Une espace ou une tabulation.
       mot    Une  suite  de caractères considérée comme une unité élémentaire
              par l’interpréteur. On parle également de lexème (token).
       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étacaractère
              Un caractère qui, non protégé, sépare les mots. Un de ceux-ci :
              |  & ; ( ) < > space tab
       opérateur de contrôle
              Un  lex��me  ayant  une  fonction  de  contrôle.  C’est  l’un des
              symboles suivants :
              || & && ; ;; ( ) | <newline>

MOTS RÉSERVÉS

Les mots r��serv��s sont des mots qui ont une signification spéciale pour
l’interpréteur. Les mots suivants sont reconnus comme réservés
lorsqu’ils ne sont pas protégés et sont soit le premier mot d’une
commande simple (voir plus bas GRAMMAIRE DE L�’INTERPRÉTEUR ) soit le
troisième mot d’une commande case ou for :

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

GRAMMAIRE DE L�’INTERPRÉTEUR
Commandes simples
Une commande simple est une suite d’affectations facultatives de
variables, suivie de mots séparés par des blancs et de redirections, et
terminée par un op��rateur de contr��le. Le premier mot spécifie la
commande à exécuter et est passé comme argument zéro. Les mots restants
sont transmis comme arguments à la commande appelée.

La valeur renvoyée par une commande simple est son état final ou 128+n
si la commande a été terminée par le signal n.

Conduites
Une conduite (pipeline) est une suite d’une ou plusieurs commandes
séparées par le caractère tube |. Le format d’une conduite est :

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

La sortie standard de la commande_1 est connectée par un tube à
l’entrée standard de la commande_2. Cette connexion est effectuée avant
toute redirection spécifiée par la commande elle-même (voir
REDIRECTIONS plus bas).

L’état renvoyé par une conduite est l’état final de la dernière
commande, à moins que l’option pipefail soit activée. Si pipefail est
activée, l’état renvoyé par la conduite est la valeur de la dernière
commande (la plus à droite) à terminer avec un état différent de zéro
ou zéro si toutes les commandes se terminent avec succès. Si le mot
réservé ! précède une conduite, l’état final de cette conduite sera la
négation logique de l’état final tel que décrit plus haut.
L’interpréteur attend que toutes les commandes de la conduite soient
terminées avant de renvoyer une valeur.

Si le mot réservé time précède une conduite, les temps passés par le
programme en modes utilisateur et système sont indiqués quand la
conduite se termine. L’option -p modifie le format de sortie pour celui
spécifié par POSIX. La variable TIMEFORMAT peut contenir une chaîne de
format indiquant comment les informations de chronométrage doivent être
affichées ; consultez plus bas la descriptions de TIMEFORMAT dans
Variables de l�’interpréteur.

Chaque commande dans une conduite est exécutée comme un processus
indépendant (c’est-à-dire dans un sous-interpréteur).

Listes
Une liste est une suite d’une ou plusieurs conduites séparées par l’un
des opérateurs ;, &, && ou �│�│ et facultativement terminée par l’un au
choix des ;, & ou <saut de ligne>.

Dans cette liste d’opérateurs, && et �│�│ ont une priorité identique,
suivis par ; et &, qui ont également une priorité identique.

Une suite d’un ou plusieurs sauts de ligne peut apparaître dans une
liste à la place d’un point-virgule pour délimiter les commandes.

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-interpréteur.
L’interpréteur n’attend pas que la commande se termine et l’état
renvoyé est 0. Les commandes séparées par un ; sont exécutées
successivement, l’interpréteur attend que chaque commande se termine
tour à tour. L’état renvoyé est l’état final de la dernière commande
exécutée.

Les opérateurs de contrôle && et �│�│ indiquent respectivement des listes
de ET et des listes de OU. Une liste ET est de la forme

commande_1 && commande_2

commande_2 est exécutée si, et seulement si, commande_1 renvoie un état
final de zéro.

Une liste OU a la forme

commande_1 �│�│ commande_2

commande_2 est exécutée si et seulement si commande_1 renvoie un état
final différent de zéro. L’état renvoyé par des listes de ET et de OU
est l’état final 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-interpréteur (voir plus bas
ENVIRONNEMENT D�’EXÉCUTION DES COMMANDES ). 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. L’état renvoyé est l’état final de la
liste.

{ liste; }
liste est simplement exécutée avec l’environnement de
l’interpréteur en cours. liste doit se terminer par un caractère
de saut de ligne ou un point-virgule. Cette construction est
connue sous le nom de commandes group��es. L’état renvoyé est
l’état final de la liste. Remarquez que contrairement aux
métacaractères ( et ), { et } sont des mots r��serv��s qui ne
doivent apparaître que là où un mot réservé peut être reconnu.
Puisqu’ils ne conduiront pas un découpage en mots, ils doivent
être séparés de la liste par une espace.

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

[[ expression ]]
Renvoie un état de 0 ou 1 selon l’évaluation de la condition
expression. Les conditions sont composées de primitives décrites
plus bas dans CONDITIONS. Le découpage en mots et le
développement des chemins ne sont pas effectués sur les mots
entre [[ et ]] ; le développement des tildes, des paramètres,
des variables, le développement arithmétique, la substitution de
commande et de processus, ainsi que la suppression des
protections sont effectués. Les opérateurs conditionnels comme
-f ne doivent pas être protégés afin d’être reconnus comme
primitives.

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 dont
la correspondance est recherchée selon les règles décrites plus
bas dans Motifs génériques. Si l’option d’interpréteur
nocasematch est activée, la mise en correspondance est effectuée
sans tenir compte de la casse (différence majuscule/minuscule)
des caractères alphabétiques. La valeur renvoyée est 0 si les
chaînes correspondent (==) (ou respectivement ne correspondent
pas (!=) au motif et 1 sinon. Toute partie du motif peut être
protégée pour la forcer à correspondre en tant que chaîne.

Un opérateur binaire supplémentaire, =~, est disponible, avec la
même priorité que == et !=. Lorsqu’il est utilisé, la chaîne à
droite de l’opérateur est considérée comme une expression
rationnelle étendue et est mise en correspondance en conséquence
(comme avec regex(3)). La valeur renvoyée est 0 si la chaîne
correspond au motif et 1 si elle ne correspond pas. Si
l’expression rationnelle n’est pas syntaxiquement correcte, la
valeur renvoyée de l’expression conditionnelle est 2. Si
l’option d’interpréteur nocasematch est activée, la mise en
correspondance est effectuée sans tenir compte de la casse. Les
sous-chaînes mises en correspondance avec des sous-expressions
entre parenthèses dans l’expression rationnelle sont
sauvegardées dans la variable tableau BASH_REMATCH. L’élément
d’indice 0 de BASH_REMATCH est la partie de la chaîne
correspondant à l’expression rationnelle complète. L’élément
d’indice n de BASH_REMATCH est la partie de la chaîne
correspondant à la nème sous-expression entre parenthèses.

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

( expression )
Renvoie la valeur de l’expression. Cela peut être utilisé
pour surpasser la priorité normale des opérateurs.
! expression
Vrai si expression est fausse.
expression1 && expression2
Vrai si expression1 et expression2 sont toutes les deux
vraies.
expression1 || expression2
Vrai si expression1 ou expression2 est vraie.

Les opérateurs && et || n’évaluent pas expression2 si la valeur
de expression1 suffit à déterminer la valeur renvoyée par la
condition tout entière.

for nom [ in mot ] ; do liste ; done
La liste de mots suivant in est développée, produisant une liste
d’éléments. La variable nom prend tour à tour 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 existants (voir PARAMÈTRES
plus bas). L’état renvoyé est l’état final de la dernière
commande exécutée. Si le développement des éléments suivant in
conduit à une liste vide, aucune commande n’est exécutée et
l’état renvoyé est 0.

for (( expr1 ; expr2 ; expr3 )) ; do liste ; done
L’expression arithmétique expr1 est d’abord évaluée selon les
règles décrites plus bas sous ÉVALUATION ARITHMÉTIQUE.
L’expression arithmétique expr2 est ensuite évaluée
répétitivement jusqu’à valoir zéro. Chaque fois que expr2 est
évaluée en une valeur différente de zéro, liste est exécutée et
l’expression arithmétique expr3 est évaluée. Si une quelconque
des expressions est omise, elle est considérée comme s’évaluant
à 1. La valeur renvoyée est l’état final de la dernière commande
dans liste qui est exécutée ou faux si une quelconque des
expressions est incorrecte.

select nom [ in mot ] ; do liste ; done
La liste de mots à la suite de in est développée, produisant 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
PARAMÈTRES plus bas). L’invite PS3 est affichée 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, alors ce mot est
affecté à la valeur de la variable nom. Si la ligne est vide,
les mots et l’invite sont affichés à nouveau. Si une fin de
fichier (EOF) est lue, la commande se termine. Toute autre
valeur lue conduit à mettre à vide la variable nom. La ligne lue
est conservée dans la variable REPLY. La liste est exécutée
après chaque sélection, jusqu’à ce qu’une commande break soit
atteinte. L’état final de select est l’état final de la dernière
commande exécutée dans la liste ou zéro si aucune commande n’a
été exécutée.

case mot in [ [(] motif [ | motif ] ... ) liste ;; ] ... esac
Une commande case commence d’abord par développer le mot, puis
essaye de le mettre en correspondance tour à tour avec chacun
des motifs en utilisant les mêmes règles que pour le
développement des chemins (voir plus bas Développement des
chemins). Le mot est développé en utilisant le développement du
tilde, le développement des paramètres et des variables, la
substitution arithmétique, la substitution de commande, la
substitution de processus et la suppression des protections.
Chaque motif examiné est développé en utilisant le développement
du tilde, le développement des paramètres et des variables, la
substitution arithmétique, la substitution de commande et la
substitution de processus. Si l’option d’interpréteur
nocasematch est activée, la mise en correspondance est effectuée
sans tenir compte de la casse des caractères alphabétiques.
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 essai. L’état final est zéro si aucun motif ne
correspond. Sinon il est l’état final 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 état final est zéro, la
liste du then est exécutée. Sinon, chacune des listes des elif
est exécutée tour à tour et si son état final est zéro, la liste
du then associé est exécutée et la commande termine. Sinon, la
liste du else, si présente, est exécutée. L’état final est
l’état final de la dernière commande exécutée ou zéro si aucune
condition n’a été satisfaite.

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 état final de zéro. La
commande until est identique à la commande while, sauf que le
test est inversé ; la liste du do est exécutée tant que la
dernière commande de la liste renvoie un état final différent de
zéro. L’état final des commandes while et until est l’état final
de la dernière commande exécutée dans la liste du do ou zéro si
aucune commande n’a été exécutée.

Définitions des fonctions de l�’interpréteur
Une fonction de l’interpréteur est un objet qui est appelé comme une
commande simple et qui exécute une commande composée avec un nouveau
jeu de paramètres positionnels. Les fonctions de l’interpréteur sont
déclarées de la façon suivante :

[ function ] nom () commande-compos��e [redirection]
Ceci définit une fonction possédant le nom mentionné. Le mot
réservé function est facultatif. S’il est fourni, les
parenthèses sont facultatives. Le corps de la fonction est la
commande composée commande-compos��e (voir Commandes composées
plus haut). Cette commande est généralement une liste de
commandes entre { et }, mais peut être une quelconque des
commandes décrites dans Commandes composées plus haut. La
commande-compos��e est exécutée chaque fois que nom est spécifié
comme le nom d’une commande normale. Toutes redirections (voir
REDIRECTIONS plus bas) spécifiées lorsqu’une fonction est
définie sont effectuées lorsque la fonction est exécutée. L’état
final d’une définition de fonction est zéro, à moins qu’une
erreur de syntaxe se produise ou qu’une fonction en lecture
seule existe déjà avec le même nom. Lorsque la fonction est
exécutée, l’état final est celui de la dernière commande
exécutée dans le corps de la fonction. (Voir FONCTIONS plus
bas.)

COMMENTAIRES

       Dans un interpréteur non interactif ou dans un interpréteur  interactif
       avec  l’option  interactive_comments  activée  par  la commande interne
       shopt (voir plus bas COMMANDES INTERNES DE  L�’INTERPRÉTEUR  ),  un  mot
       commençant  par  #  conduira  à  ignorer  ce mot et tous les caractères
       restants  sur  la  ligne.  Un  interpréteur  interactif  sans  l’option
       interactive_comments   n’autorise   pas   les   commentaires.  L’option
       interactive_comments est activée  par  défaut  dans  les  interpréteurs
       interactifs.

PROTECTION

Les protections (quoting) permettent de forcer l’interpréteur à ignorer
la signification spéciale de certains caractères ou mots. Les
protections peuvent être utilisées pour désactiver le traitement des
caractères spéciaux, éviter la reconnaissance des mots réservés ou
empêcher le développement des paramètres.

Tous les m��tacaract��res décrits plus haut dans DÉFINITIONS ont des
significations spéciales pour l’interpréteur et doivent être protégés
pour ne représenter que leur propre caractère.

Lorsque les outils de développement de l’historique des commandes sont
utilisés (voir plus bas DÉVELOPPEMENT DE L�’HISTORIQUE ), le caractère
de d��veloppement de l���historique, généralement !, doit être protégé
pour éviter le développement de l’historique.

Il y a trois mécanismes de protection : le caractère d’échappement, les
guillemets simples (« single quote ») et les guillemets doubles
(« double quote »).

Un caractère contre-oblique (\) non protégé, est le caract��re
d�����chappement. Il préserve la valeur littérale du caractère qui le
suit, à l’exception du <saut de ligne>. Si un couple \<saut de ligne>
apparaît et si la contre-oblique n’est pas elle-même protégée,
l’ensemble \<saut de ligne> est considéré comme une continuation de
ligne (c’est-à-dire qu’il est supprimé du flot d’entrée et ignoré en
pratique).

Encadrer des caractères entre des guillemets simples préserve la valeur
littérale de chacun des caractères entre guillemets simples. Un
guillement simple ne peut pas être placé entre deux guillemets simples,
même s’il est précédé d’une contre-oblique.

Encadrer des caractères entre des guillemets doubles préserve la valeur
littérale de chacun des caractères sauf $, �‘, \ et, lorsque le
développement de l’historique est activé, !. Les caractères $ et �‘
conservent leurs significations spéciales entre guillemets doubles. La
contre-oblique ne conserve sa signification spéciale que lorsqu’elle
est suivie par l’un des caractères suivants : $, �‘, ", \ ou <saut de
ligne>. Un guillemet double peut être protégé entre deux guillemets
doubles en le faisant précéder d’une contre-oblique. S’il est activé,
le développement de l’historique sera effectué, à moins qu’un !
apparaissant entre guillemets doubles ne soit protégé par une
contre-oblique. La contre-oblique précédant le ! n’est pas supprimée.

Les caractères spéciaux * et @ ont des significations spéciales
lorsqu’ils se trouvent entre des guillemets doubles (voir PARAMÈTRES
plus bas).

Les mots de la forme $'cha��ne' sont traités spécialement. Le mot est
développé en cha��ne avec les caractères protégés par contre-oblique
remplacés comme spécifié par le standard ANSI C. Les suites
d’échappement par contre-oblique, si présentes, sont décodées comme
suit :
\a alerte (alarme)
\b effacement arrière (backspace)
\e caractère d’échappement
\f saut de page (form feed)
\n saut de ligne (new line)
\r retour chariot (carriage return)
\t tabulation horizontale
\v tabulation verticale
\\ contre-oblique
\' guillemet simple
\nnn le caractère 8 bits dont la valeur octale est nnn (de un
à trois chiffres)
\xHH le caractère 8 bits dont la valeur hexadécimale est HH
(un à deux symboles hexadécimaux)
\cx un caractère contrôle-x

Le résultat développé est protégé par des guillemets simples comme si
le symbole dollar n’avait pas été présent.

Une chaîne entre guillemets doubles précédée d’un symbole dollar ($)
conduira à la traduction de la chaîne selon le paramètre linguistique
régional en vigueur. Si le paramètre linguistique régional courant est
C ou POSIX, le symbole dollar est ignoré. Si la chaîne est traduite et
remplacée, le résultat est protégé par des guillemets doubles.

PARAMÈTRES

Un param��tre est une entité permettant de stocker des valeurs. Il peut
être un nom, un nombre ou un des caractères spéciaux décrits plus bas,
dans Paramètres spéciaux. Une variable est un paramètre noté par un
nom. Une variable possède une valeur et zéro ou plusieurs attributs.
Les attributs sont affectés en utilisant la commande interne declare
(voir declare plus bas dans COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

Un paramètre est créé si une valeur lui a été affectée. La chaîne vide
est une valeur correcte. Une fois qu’une variable est créée, elle ne
peut être détruite qu’en utilisant la commande interne unset (voir plus
bas COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

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

nom=[valeur]

Si aucune valeur n’est indiquée, une chaîne vide est affectée à la
variable. Toutes les valeurs sont sujettes au développement du tilde,
des paramètres et des variables, à la substitution de commande, au
développement arithmétique et à la suppression des protections (voir
DÉVELOPPEMENTS plus bas). Si une variable a son attribut integer de
mis, alors la valeur est soumise à l’évaluation arithmétique, même si
la syntaxe $((...)) n’est pas utilisée (voir Développement arithmétique
plus bas). Le découpage en mots n’est pas effectué, à l’exception de
"$@" comme expliqué plus bas dans Paramètres spéciaux. Le développement
des chemins n’est pas effectué. Les affectations peuvent également
apparaître comme argument des commandes internes suivantes : alias,
declare, typeset, export, readonly et local.

Dans le contexte où une affectation affecte une valeur à une variable
de l’interpréteur ou à un indice de tableau, l’opérateur += peut être
utilisé pour ajouter ou additionner à la précédente valeur de la
variable. Lorsque l’opérateur += est appliqué à une variable dont
l’attribut integer (entier) a été mis, la valeur est évaluée comme une
expression arithmétique et additionnée à la valeur actuelle de la
variable qui est également évaluée. Lorsque += est appliqué à une
variable tableau en utilisant l’affectation composée (voir Tableaux
plus bas), la valeur de la variable n’est pas détruite (comme elle
l’est lorsqu’on utilise =) et les nouvelles valeurs sont ajoutées au
tableau, en commençant à l’indice maximum du tableau plus un. Lorsque
l’opérateur est appliqué à une variable de type chaîne, la valeur est
développée et concaténée à la valeur de la variable.

Paramètres positionnels
Un param��tre positionnel est un paramètre noté par un ou plusieurs
chiffres (à l’exception du chiffre 0 seul). Les paramètres positionnels
sont affectés avec les arguments de l’interpréteur lors de son appel.
Ils peuvent être réaffectés avec la commande interne set. On ne peut
pas utiliser les affectations pour les paramètres positionnels. Ils
sont temporairement remplacés lors de l’exécution d’une fonction de
l’interpréteur (voir FONCTIONS plus bas).

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

Paramètres spéciaux
L’interpréteur traite plusieurs paramètres spécifiquement. Ces
paramètres peuvent uniquement être consultés, il n’est pas permis de
leur affecter une valeur.
* Se développe en l’ensemble des paramètres positionnels,
commençant par le premier. Quand le développement se produit
entre des guillemets doubles, * se transforme en un seul mot
constitué de la valeur de tous les paramètres positionnels
séparés par le premier caractère de la variable spéciale IFS.
C’est-à-dire que "$*" est équivalent à "$1c$2c...", où 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 vide, les paramètres sont accolés sans séparateurs.
@ Se développe en l’ensemble des paramètres positionnels,
commençant par le premier. Quand le développement a lieu entre
guillemets doubles, chaque paramètre se développe en un mot
distinct. C’est-à-dire que "$@" est équivalent à "$1" "$2" ....
Si le développement des guillemets doubles survient dans un mot,
le développement du premier paramètre est accolé à la première
partie du mot d’origine et le développement du dernier paramètre
est accolé à la dernière partie du mot d’origine. Quand il n’y a
pas de paramètres positionnels, "$@" et $@ ne se développent en
rien (c’est-à-dire qu’ils sont simplement éliminés).
# Correspond au nombre de paramètres positionnels, en base
décimale.
? Se développe en l’état de la dernière conduite exécutée au
premier plan.
- Est remplacé par la liste des options de l’interpréteur
indiquées durant l’appel, configurées avec la commande interne
set ou celles créées par l’interpréteur lui-même (comme avec
l’option -i).
$ Se transforme en PID de l’interpréteur. Dans un
sous-interpréteur (), il se transforme en PID de l’interpréteur
et non pas du sous-interpréteur.
! Se transforme en PID de la commande (asynchrone) exécutée en
arrière-plan le plus récemment.
0 Se développe en le nom de l’interpréteur ou du script. Ce
paramètre est créé lors de l’initialisation de l’interpréteur.
Si bash est appelé 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 nom de
fichier utilisé pour appeler bash, comme indiqué par l’argument
zéro.
_ Au lancement de l’interpréteur, contient le chemin d’accès
absolu utilisé pour appeler l’interpréteur ou le script en cours
d’exécution tel qu’il est passé dans l’environnement ou dans la
liste des arguments. Devient le dernier argument de la commande
précédente, après développement. Mis 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 courriel, contient le nom du
fichier de courriel en cours de consultation.

Variables de l�’interpréteur
Les variables suivantes sont créées par l’interpréteur :

BASH Se développe en chemin d’accès complet à l’instance courante de
bash.
BASH_ARGC
Une variable de type tableau dont les valeurs sont le nombre de
paramètres de chaque trame de la pile d’appel d’exécution de
l’interpréteur courant. Le nombre de paramètres du
sous-programme courant (fonction de l’interpréteur ou script
exécuté par . ou source) est au sommet de la pile. Lorsqu’un
sous-programme est exécuté, le nombre de paramètres passés est
placé dans BASH_ARGC. L’interpréteur crée BASH_ARGC seulement
dans le mode de traçage étendu (voir plus bas la description de
l’option extdebug de la commande interne shopt).
BASH_ARGV
Une variable de type tableau contenant tous les paramètres de la
pile d’appel d’exécution de l’interpréteur courant. Le dernier
paramètre du dernier sous-programme est au sommet de la pile ;
le premier paramètre de l’appel initial est en bas. Lorsqu’un
sous-programme est exécuté, les paramètres fournis sont placés
dans BASH_ARGV. L’interpréteur crée BASH_ARGV seulement dans le
mode de traçage étendu (voir plus bas la description de l’option
extdebug de la commande interne shopt).
BASH_COMMAND
La commande en cours d’exécution ou sur le point d’être
exécutée, à moins que l’interpréteur n’exécute une commande à la
suite d’une capture, auquel cas c’est la commande s’exécutant au
moment de la capture.
BASH_EXECUTION_STRING
L’argument commande de l’option d’appel -c.
BASH_LINENO
Une variable de type tableau dont les éléments sont les numéros
de ligne des fichiers sources correspondant à chacun des
éléments de FUNCNAME. ${BASH_LINENO[$i]} est le numéro de la
ligne dans le fichier source où ${FUNCNAME[$ifP]} a été appelé.
Le nom du fichier source correspondant est ${BASH_SOURCE[$i]}.
Utilisez LINENO pour obtenir le numéro de ligne courant.
BASH_REMATCH
Une variable de type tableau dont les éléments sont affectés
avec l’opérateur binaire =~ dans la commande conditionnelle [[.
L’élément d’indice 0 est la partie de la chaîne correspondant à
l’expression rationnelle complète. L’élément d’indice n est la
partie de la chaîne correspondant à la n-ième sous-expression
entre parenthèses. Cette variable est en lecture seule.
BASH_SOURCE
Une variable de type tableau dont les éléments sont les noms des
fichiers source correspondants aux éléments de la variable
tableau FUNCNAME.
BASH_SUBSHELL
Incrémenté chaque fois qu’un sous-interpréteur ou qu’un
environnement de sous-interpréteur est engendré. La valeur
initiale est 0.
BASH_VERSINFO
Une variable de type tableau protégée en écriture dont les
éléments représentent la version de cette instance de bash.
Cette valeur est affectée aux éléments du tableau comme suit :
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 correctif.
BASH_VERSINFO[3] Le numéro de compilation.
BASH_VERSINFO[4] Le statut de cette version (p. ex.,
beta1).
BASH_VERSINFO[5] La valeur de MACHTYPE.

BASH_VERSION
Se développe en une chaîne décrivant le numéro de version de
cette instance de bash.

COMP_CWORD
Un indice dans ${COMP_WORDS} du mot contenant la position
courant du curseur. Cette variable n’est disponible que dans les
fonctions de l’interpréteur appelées par les outils de
complètement programmables (voir Complètement programmable plus
bas).

COMP_LINE
La ligne de commande courante. Cette variable n’est disponible
que dans les fonctions de l’interpréteur appelées par les outils
de complètement programmables (voir Complètement programmable
plus bas).

COMP_POINT
L’indice de la position courante du curseur relatif au début de
la commande courante. Si la position courante du curseur est à
la fin de la commande courante, la valeur de cette variable est
égale à ${#COMP_LINE}. Cette variable n’est disponible que dans
les fonctions de l’interpréteur et les commandes externes
appelées par les outils de complètement programmables (voir
Complètement programmable plus bas).

COMP_WORDBREAKS
Le jeu de caractères que la bibliothèque readline considère
comme séparateurs de mots lors du complètement de mots. Si
COMP_WORDBREAKS est détruite, elle perd ses propriétés
spéciales, même si elle est recréée par la suite.

COMP_WORDS
Une variable de type tableau (voir Tableaux plus bas) consistant
en des mots individuels de la ligne de commande courante. Les
mots sont découpés au niveau des métacaractères de
l’interpréteur de commandes comme l’analyseur de l’interpréteur
de commandes le ferait. Cette variable n’est disponible que dans
les fonctions de l’interpréteur appelées par les outils de
complètement programmables (voir Complètement programmable plus
bas).

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. Les affectations des
éléments de cette variable tableau peuvent être utilisés pour
modifier les répertoires déjà dans la pile, mais les commandes
internes pushd et popd doivent être utilisées pour ajouter et
enlever des répertoires. L’affectation de 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 par
la suite.

EUID Contient l’UID effectif de l’utilisateur, initialisé au
démarrage de l’interpréteur. Cette variable est en lecture
seule.

FUNCNAME
Une variable de type tableau contenant le nom de toutes les
fonctions de l’interpréteur actuellement dans la pile d’appel
d’exécution. L’élément d’indice 0 est le nom d’une quelconque
des fonctions de l’interpréteur en cours d’exécution. L’élément
le plus bas est « main ». Cette variable n’existe que si une
fonction de l’interpréteur est en cours d’exécution. Les
affectations de FUNCNAME n’ont aucun effet et renvoient un état
d’erreur. Si FUNCNAME est détruite, elle perd ses propriétés
spéciales, même si elle est recréée par la suite.

GROUPS Une variable de type tableau contenant la liste des groupes dont
l’utilisateur est membre. Les affectations de GROUPS n’ont aucun
effet et renvoient un état d’erreur. Si GROUPS est détruite,
elle perd ses propriétés spéciales, même si elle est recréée par
la suite.

HISTCMD
Le numéro d’historique ou l’indice dans la file d’historique, de
la commande en cours. Si HISTCMD est détruite, elle perd ses
propriétés spéciales, même si elle est recréée par la suite.

HOSTNAME
Automatiquement mis au nom de la machine courante.

HOSTTYPE
Automatiquement mis à une chaîne qui décrit de façon unique le
type de machine sur laquelle bash s’exécute. La valeur par
défaut dépend du système.

LINENO Chaque fois que ce paramètre est consulté, l’interpréteur 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étruite, elle perd ses
propriétés spéciales, même si elle est recréée par la suite.

MACHTYPE
Automatiquement mis à 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.

OLDPWD Le répertoire de travail précédent comme mis par la commande cd.

OPTARG La valeur du dernier argument d’option traité par la commande
interne getopts (voir plus bas COMMANDES INTERNES DE
L�’INTERPRÉTEUR ).

OPTIND L’indice du prochain argument à traiter par la commande interne
getopts (voir plus bas COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

OSTYPE Automatiquement mis à 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.

PIPESTATUS
Une variable de type tableau (voir Tableaux plus bas) contenant
une liste des états finaux des processus exécutés dans la
conduite exécutée la plus récemment au premier plan (qui peut
éventuellement contenir une seule commande).

PPID L’identifiant du processus parent de l’interpréteur. Cette
variable est en lecture seule.

PWD Le répertoire de travail courant comme mis par la commande cd.

RANDOM À chaque fois que ce paramètre est consulté, un entier aléatoire
entre 0 et 32767 est engendré. Cette suite de nombres aléatoires
peut être initialisée en affectant une valeur à RANDOM. Si
RANDOM est détruite, elle perd ses propriétés spéciales, même si
elle est recréée par la suite.

REPLY Mis à la ligne de saisie lue par la commande interne read
lorsqu’aucun argument n’a été fourni.

SECONDS
À chaque fois que ce paramètre est consulté, le nombre de
secondes écoulées depuis le lancement de l’interpréteur est
renvoyé. Si une valeur est affectée à SECONDS, les valeurs
renvoyées lors des consultations ultérieures sont le nombre de
secondes écoulées depuis l’affectation, ajoutées à la valeur
affectée. Si SECONDS est détruite, elle perd ses propriétés
spéciales, même si elle est recréée par la suite.

SHELLOPTS
Liste des options activées de l’interpréteur, séparées par des
virgules. Chaque mot de la liste est un argument correct pour
l’option -o de la commande interne set (voir plus bas COMMANDES
INTERNES DE L�’INTERPRÉTEUR ). 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 un
quelconque fichier d’initialisation. Cette variable est en
lecture seule.

SHLVL Incrémenté de 1 à chaque appel d’une instance de bash.

UID Contient l’UID de l’utilisateur courant, initialisé au démarrage
de l’interpréteur. Cette variable est en lecture seule.

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.

BASH_ENV
Si ce paramètre existe 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 dans ~/.bashrc. La
valeur de BASH_ENV est soumise au développement des paramètres,
à la substitution de commande et au développement arithmétique
avant d’être considérée comme un nom de fichier. PATH n’est pas
utilisée pour rechercher le fichier obtenu.
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. Un exemple de valeur est
".:~:/usr".
COLUMNS
Utilisée par la commande interne select pour déterminer la
taille du terminal lors de l’affichage des listes de sélection.
Automatiquement mis à la réception d’un signal SIGWINCH.
COMPREPLY
Une variable de type tableau dans lequel bash lit les
complètements possibles produits par une fonction de
l’interpréteur appelée par les outils de complètement
programmables (voir Complètement programmable plus bas).
EMACS Si bash trouve cette variable dans l’environnement lorsque
l’interpréteur démarre avec la valeur "t", il considère que
l’interpréteur est lancé dans un tampon d’interpréteur emacs et
désactive l’édition en ligne.
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 du complètement des noms de fichiers (voir
READLINE plus bas). Un nom de fichier dont le suffixe correspond
à l’un de ceux mentionnés dans FIGNORE est exclu de la liste des
noms de fichiers correspondant pour le complètement. Par
exemple, cette variable peut prendre la valeur ".o:~" (Des
protections sont nécessaires pour l’affectation d’une valeur à
cette variable, qui contient des tildes).
GLOBIGNORE
Une liste de motifs séparés par des deux-points, définissant
l’ensemble des noms de fichiers à ignorer lors du développement
des chemins. Si un nom de fichier correspondant à un motif de
développement des chemins, correspond également à un motif dans
GLOBIGNORE, il est supprimé de la liste des correspondances.
HISTCONTROL
Une liste de valeurs, séparées par des deux-points, commandant
la façon dont les commandes sont sauvegardées dans la file
d’historique. Si la liste des valeurs contient la valeur
ignorespace, les lignes commençant par une espace ne sont pas
sauvegardées dans la file d’historique. La valeur ignoredups
conduit à ne pas sauvegarder une ligne correspondant exactement
à la ligne de commande précédente. La présence de ignoreboth est
un condensé pour ignorespace et ignoredups. La valeur erasedups
conduit à retirer de la file d’historique toutes les lignes
précédant la ligne courante et lui correspondant avant que cette
ligne y soit sauvegardée. Toute valeur qui ne fait pas partie de
la liste ci-dessus est ignorée. Si HISTCONTROL est inexistante
ou si elle ne contient pas une valeur correcte, toutes les
lignes lues par l’analyseur de l’interpréteur seront
sauvegardées dans la file d’historique, selon la valeur de
HISTIGNORE. La seconde ligne et les suivantes d’une commande
multiligne ne sont pas testées et sont ajoutées dans
l’historique indépendamment de la valeur de HISTCONTROL.
HISTFILE
Le nom du fichier dans lequel l’historique des commandes est
sauvegardé (voir HISTORIQUE plus bas). Par défaut, il s’agit de
~/.bash_history. Si inexistante, l’historique des commandes
n’est pas sauvegardé lorsqu’un interpréteur interactif termine.
HISTFILESIZE
Le nombre maximum de lignes contenues dans le fichier
d’historique. Quand cette variable contient une valeur, le
fichier historique est tronqué, si besoin, en enlevant les
entrées les plus anciennes, pour ne contenir que ce nombre de
lignes. La valeur par défaut est 500. Ce fichier est aussi
tronqué à cette taille après son écriture quand un interpréteur
interactif termine.
HISTIGNORE
Une liste de motifs, séparés par des deux-points, déterminant
quelles lignes de commande devraient être sauvegardées dans la
file d’historique. Chaque motif est accroché au début de la
ligne et doit lui correspondre en complètement (aucun ajout de
« * » implicite). Chaque motif est comparé à chaque ligne après
que les vérifications de HISTCONTROL ont été appliquées. En plus
des motifs génériques usuels de l’interpréteur, « & » correspond
à la ligne précédente de l’historique. « & » peut être protégé
par une contre-oblique ; elle est supprimée 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.
HISTSIZE
Le nombre de commandes à mémoriser dans l’historique (voir
HISTORIQUE plus bas). La valeur par défaut est 500.
HISTTIMEFORMAT
Si cette variable existe et n’est pas vide, sa valeur est
utilisée comme une chaîne de caractères par strftime(3) afin
d’imprimer l’horodatage associé à chaque élément de l’historique
affichée par la commande interne history. Si cette variable
existe, les horodatages sont écrits dans le fichier historique
afin d’être conservés au fur et à mesure des sessions de
l’interpréteur.
HOME Le répertoire d’accueil de l’utilisateur courant ; l’argument
par défaut de la commande interne cd. La valeur de cette
variable est aussi utilisée lors du développement du tilde.
HOSTFILE
Contient le nom d’un fichier ayant le même format que /etc/hosts
qui devra être lu lorsque l’interpréteur aura besoin de
compléter un nom de machine. La liste des complètements
possibles de noms de machines peut être changée pendant
l’exécution de l’interpréteur ; à la tentative de complètement
de nom de machine suivant le changement de valeur, bash ajoute
le contenu du nouveau fichier à la liste existante. Si HOSTFILE
existe mais est vide, bash essaie de lire /etc/hosts pour
obtenir la liste des complètements de noms de machines
possibles. Lorsque HOSTFILE est détruite, la liste des noms de
machines est effacée.
IFS Le s��parateur de champs interne (« Internal Field Separator »)
qui est utilisé pour le découpage en 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><saut de ligne> ».
IGNOREEOF
Commande le comportement d’un interpréteur interactif à
réception d’un caractère EOF (fin de fichier) comme unique
saisie. Si existante la valeur est le nombre de caractères EOF
consécutifs qui doivent être tapés comme premiers caractères sur
une ligne de saisie avant que bash termine. Si la variable
existe mais que sa valeur n’est pas numérique ou si elle n’a pas
de valeur, la valeur par défaut est 10. Si elle n’existe pas,
EOF signifie la fin de la saisie pour l’interpréteur.
INPUTRC
Le nom du fichier de configuration de readline prioritaire sur
le fichier par défaut ~/.inputrc (voir READLINE plus bas).
LANG Utilisée pour déterminer le paramètre linguistique régional pour
toute catégorie non spécifiquement sélectionnée par une variable
commençant par LC_.
LC_ALL Cette variable surpasse LANG et toute autre variable LC_
spécifiant une catégorie de paramètres linguistiques régionaux.
LC_COLLATE
Cette variable détermine l’ordre de collation utilisé pour trier
les résultats du développement des chemins et détermine le
comportement des expressions de plage, des classes
d’équivalences et des suites de collations dans le développement
des chemins et la correspondance de motifs.
LC_CTYPE
Cette variable détermine l’interprétation des caractères et le
comportement des classes de caractères lors du développement des
chemins et de la recherche de correspondances de motifs.
LC_MESSAGES
Cette variable détermine le paramètre linguistique régional
utilisé pour traduire les chaînes entre guillemets doubles
précédées d’un $.
LC_NUMERIC
Cette variable détermine le paramètre linguistique régional
utilisé pour formater les nombres.
LINES Utilisée par la commande interne select pour déterminer la
longueur de colonne lors de l’affichage des listes de sélection.
Automatiquement mise à la réception d’un signal SIGWINCH.
MAIL Si ce paramètre correspond à un nom de fichier et si la variable
MAILPATH est inexistante, bash informe l’utilisateur de
l’arrivée de messages dans le fichier spécifié.
MAILCHECK
Indique l’intervalle (en secondes) avec lequel bash vérifie si
un nouveau message est arrivé. La valeur par défaut est 60
secondes. Lorsque le délai est écoulé, l’interpréteur vérifiera
la présence d’un courriel avant d’afficher son invite de base.
Si cette variable est inexistante, ou mise à une valeur qui
n’est pas un nombre positif, l’interpréteur désactive la
vérification des courriels.
MAILPATH
Une liste de noms de fichiers séparés par des deux-points « : »,
dans lesquels on vérifiera l’arrivée de courriel. Le nom d’un
fichier peut être suivi d’un point d’interrogation « ? », puis
d’une chaîne de caractères spécifiant le message à afficher en
cas de courriel. Dans cette chaîne, le paramètre $_ correspond
au nom du fichier de courriel courant. Exemple :
MAILPATH='/usr/spool/mail/bfox?"Vous avez du
courriel":~/shell-mail?"$_ a du courriel !"'
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).
OPTERR Si mis à la valeur 1, bash affiche les messages d’erreurs
engendrés par la commande interne getopts (voir plus bas
COMMANDES INTERNES DE L�’INTERPRÉTEUR ). OPTERR est initialisée
avec la valeur 1 à chaque appel de l’interpréteur ou au
lancement d’un script.
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 « : » dans
lesquels l’interpréteur recherche les commandes (voir plus bas
EXÉCUTION DES COMMANDES ). Un nom de répertoire de taille nulle
(vide) dans la valeur de PATH désigne le répertoire courant. Un
répertoire vide peut apparaître comme deux deux-points
consécutifs ou comme des deux-points en début ou en fin. Le
chemin par défaut dépend du système et est choisi par
l’administrateur installant bash. Une valeur commune est
‘‘/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin’’.
POSIXLY_CORRECT
Si cette variable existe dans l’environnement lorsque bash
démarre, l’interpréteur passe en mode posix avant de lire les
fichiers de configuration comme si l’option --posix avait été
fournie. Si elle est créée pendant que l’interpréteur est en
cours d’exécution, bash active le mode posix comme si la
commande set -o posix avait été exécutée.
PROMPT_COMMAND
Si existante, sa valeur est exécutée comme commande
préalablement à l’affichage de chaque invite de base.
PS1 La valeur de ce paramètre est développée puis utilisée comme la
chaîne d’invite de base (voir INVITE plus bas). 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 chaîne d’invite secondaire. La valeur par défaut est
« > ».
PS3 La valeur de ce paramètre est utilisée comme l’invite pour la
commande select (voir GRAMMAIRE DE L�’INTERPRÉTEUR 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
« + ».
SHELL Le chemin d’accès complet à l’interpréteur de commandes est
conservé dans cette variable d’environnement. Si inexistante au
démarrage de l’interpréteur, bash lui affecte le chemin d’accès
complet à l’interpréteur de commandes de connexion de
l’utilisateur courant.
TIMEFORMAT
La valeur de ce paramètre est utilisée en tant que chaîne de
format spécifiant comment les informations de paramétrage
doivent être affichées pour les conduites précédées du mot
réservé time. Le caractère % introduit une suite de caractères
d’échappement qui est développée en une valeur de temps ou une
autre information. Les suites de caractères d’échappement et
leurs significations sont les suivantes ; les accolades marquent
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.

Le p facultatif est un chiffre indiquant la pr��cision, le nombre
de chiffres après la virgule. Une valeur de 0 conduit à
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 spécifié, la valeur 3 est utilisée.

Le l facultatif spécifie un format plus long, incluant les
minutes, de la forme MMmSS.DDs. La valeur de p détermine si la
partie décimale est affichée ou non.

Si cette variable n’existe pas, bash agit comme si elle avait la
valeur $'\nreal\t%3lR\nuser\t%3lU\nsys%3lS'. Si la valeur est
vide, aucune information de chronométrage n’est affichée. Un
caractère final de saut de ligne est ajouté quand la chaîne de
format est affichée.

TMOUT Si mise à une valeur strictement positive, TMOUT est traitée
comme le délai par défaut pour la commande interne read. La
commande select termine s’il n’y a pas de saisie au bout de
TMOUT secondes lorsque l’entrée vient d’un terminal. Dans un
interpréteur interactif, la valeur est interprétée comme le
nombre de secondes à attendre pour une saisie après avoir émis
l’interpréteur de base. bash termine après avoir attendu pendant
ce nombre de secondes si aucune saisie n’est arrivée.

TMPDIR Si existante, Bash utilise sa valeur comme le nom d’un
répertoire dans lequel Bash crée des fichiers temporaires
nécessaires au fonctionnement de l’interpréteur.

auto_resume
Cette variable commande le comportement de l’interpréteur
vis-à-vis de l’utilisateur et du contrôle des tâches. Si cette
variable existe, les commandes simples constituées d’un seul
mot, sans redirection, sont considérées comme de possibles
relances de tâches suspendues. Aucune ambiguïté n’est possible,
si plusieurs tâches commencent par la chaîne saisie, la tâche à
laquelle il a été accédé le plus récemment est sélectionnée. Le
nom d’une tâche suspendue, dans ce contexte, est la ligne de
commande utilisée pour la lancer. Si mise à la valeur exact, la
chaîne fournie doit correspondre exactement au nom d’une tâche
suspendue ; si mise à substring, la chaîne fournie doit
correspondre à une sous-chaîne du nom de la tâche suspendue. La
valeur substring donne une fonctionnalité analogue à
l’identificateur de tâche %? (voir plus bas CONTRÔLE DES TÂCHES
). Si mise à toute autre valeur, la chaîne fournie doit être le
préfixe du nom d’une tâche suspendue ; cela donne une
fonctionnalité analogue à l’identificateur de tâche %string.

command_not_found_handle
Le nom d’une fonction de l’interpréteur à appeler si une
commande ne peut être trouvée. La valeur renvoyée par cette
fonction devrait être 0, si la commande est disponible après
exécution de la fonction, sinon 127 (EX_NOTFOUND). Activé
seulement dans les interpréteurs interactif, en mode non POSIX.
C’est une extension Debian.

histchars
Les deux ou trois caractères commandant le développement de
l’historique et le découpage en lexèmes (voir plus bas
DÉVELOPPEMENT DE L�’HISTORIQUE ). 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 « ^ ». Le troisième caractère facultatif 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 le
développement de l’historique pour tous les mots restants sur la
ligne. Il ne conduit pas nécessairement l’analyseur de
l’interpréteur à considérer le reste de la ligne comme un
commentaire.

Tableaux
Bash fournit des variables tableaux à une dimension. Toute variable
peut être utilisée comme tableau ; la commande interne declare peut
servir à déclarer explicitement un tableau. Il n’y a pas de limitation
maximum à la taille d’un tableau, ni d’obligation que les éléments
soient indicés ou affectés de façon contiguë. Les tableaux sont indicés
par des entiers en commençant à zéro.

Un tableau est créé automatiquement si une variable quelconque est
affectée en utilisant la syntaxe nom[indice]=valeur. L’indice est
traité comme une expression arithmétique et s’évalue en un nombre
positif. Pour déclarer explicitement un tableau, on utilise declare -a
nom (voir plus bas COMMANDES INTERNES DE L�’INTERPRÉTEUR ). declare -a
nom[indice] est aussi accepté ; l’indice est ignoré. Des attributs
peuvent être spécifiés pour une variable tableau en utilisant les
commandes internes declare et readonly. Les attributs s’appliquent à
tous les éléments d’un tableau.

Les tableaux sont affectés en utilisant l’affectation composée de la
forme nom=(valeur_1 ... valeur_n), où chaque valeur est de la forme
[indice]=cha��ne. Seule la cha��ne est obligatoire. Si les crochets et
les indices facultatifs sont fournis, les affectations ont lieu en
conséquence ; sinon l’indice de l’élément affecté est le dernier indice
affecté plus un. Les indices commencent à zéro. Cette syntaxe est aussi
acceptée par la commande interne declare. Les éléments individuels du
tableau sont affectés en utilisant la syntaxe nom[indice]=valeur
présentée plus haut.

On peut accéder à tout élément d’un tableau en utilisant la notation
${nom[indice]}. Les accolades sont nécessaires pour éviter les conflits
avec le développement des chemins. Si indice est @ ou *, le mot se
développe en tous les éléments de nom. Ces deux indices ne diffèrent
que lorsque le mot apparaît entre guillemets doubles. Si le mot est
entre guillemets doubles, ${nom[*]} se développe en un seul mot
contenant les valeurs de chaque élément du tableau séparées par le
premier caractère de la variable spéciale IFS et ${nom[@]} développe
chaque élément de nom en un mot distinct. Quand il n’y a pas d’élément
dans le tableau, ${nom[@]} ne se développe en rien. Si le développement
entre guillemets doubles survient à l’intérieur d’un mot, le
développement du premier paramètre est accolé à la première partie du
mot original et le développement du dernier paramètre est accolé à la
dernière partie du mot original. Le comportement est analogue à celui
des paramètres spéciaux * et @ (voir Paramètres spéciaux plus haut).
${#nom[indice]} s’évalue en la longueur de l’élément ${nom[indice]}. Si
l’indice est * ou @, s’évalue en le nombre d’éléments dans le tableau.
Accéder à une variable tableau sans indice est équivalent à accéder à
l’élément zéro.

La commande interne unset sert à détruire les tableaux. unset
nom[indice] détruit l’élément de tableau d’indice indice. Un soin
particulier doit être apporté afin d’éviter des effets de bords non
désirés provoqués par la production des noms de fichiers. unset nom, où
nom est un tableau, ou unset nom[indice], avec indice valant * ou @
supprime 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 affecter une liste de mots lus depuis l’entrée
standard dans un tableau. Les commandes internes set et declare
affichent les valeurs d’un tableau d’une façon qui permet de les
réutiliser pour des affectations.

DÉVELOPPEMENTS

Les développements sont appliqués à la ligne de commande après qu’elle
a été découpée en mots. Sept types de développements sont effectués :
le d��veloppement des accolades, le d��veloppement du tilde, le
d��veloppement des param��tres et des variables, la substitution de
commande, le d��veloppement arithm��tique, le d��coupage en mots et le
d��veloppement des chemins.

L’ordre des développements est : développement des accolades, du tilde,
des paramètres, des variables, arithmétique et substitution de commande
(effectuée de la gauche vers la droite), découpage en mots et
développement des chemins.

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

Seuls le développement des accolades, le découpage en mots et le
développement des chemins 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 le développement de « $@ » et
« ${nom[@]} » comme expliqué plus haut (voir PARAMÈTRES ).

Développement des accolades
Le d��veloppement des accolades est un mécanisme permettant de produire
des chaînes quelconques. Il est similaire au d��veloppement des chemins,
mais les noms de fichiers produits n’existent pas nécessairement. Les
motifs qui seront développés prennent la forme d’un pr��ambule
facultatif, suivi par soit une série de chaînes séparées par des
virgules, soit l’expression d’une série entre accolades, suivi par un
post-scriptum facultatif. Le préambule est inséré devant chacune des
chaînes contenues entre les accolades et le post-scriptum est concaténé
à 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és, l’ordre de gauche
à droite est conservé. Par exemple a{d,c,b}e se développe en « ade ace
abe ».

Une expression d’une série est de la forme {x..y}, où x et y sont soit
des entiers, soit des caractères seuls. Lorsqu’il s’agit d’entiers,
l’expression est remplacée par la liste des nombres entre x et y, x et
y compris. S’il s’agit de caractères, l’expression se développe en
l’ensemble des caractères situés entre x et y d’un point de vue
lexicographique. Remarquez que x et y doivent être du même type.

Le développement des accolades est effectué avant tout autre
développement et tous les caractères ayant une signification spéciale
pour les autres développements 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.

Un développement d’accolades correctement formé doit contenir des
accolades ouvrantes et fermantes non protégées et au moins une virgule
non protégée ou une expression d’une série correcte. Tout développement
d’accolades incorrectement formé est laissé inchangé. Un { ou un ,
peuvent être protégés par une contre-oblique pour éviter d’être
considérés comme partie d’une expression entre accolades. Pour éviter
tout conflit avec le développement des paramètres, la chaîne ${ n’est
pas considérée comme éligible au développement des accolades.

Cette construction est typiquement utilisée comme raccourci lorsque le
préfixe commun aux chaînes à engendrer est plus long que dans l’exemple
ci-dessus :

mkdir /usr/local/src/bash/{old,new,dist,bugs}
ou
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

Le développement des accolades induit une légère incompatibilité avec
les versions historiques de 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 plus bas
COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

Développement du Tilde
Si un mot commence avec un caractère tilde (« ~ ») non protégé, tous
les caractères précédant la première barre oblique non protégée (voire
tous les caractères s’il n’y a pas de barre oblique non protégée), 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
possible identifiant de connexion. Si cet identifiant de connexion est
une chaîne vide, le tilde est remplacé par la valeur du paramètre
d’interpréteur HOME. Si HOME est inexistante, le répertoire d’accueil
de l’utilisateur exécutant l’interpréteur est utilisé à la place. Sinon
le préfixe tilde est remplacé par le répertoire d’accueil associé à
l’identifiant de connexion spécifié.

Si le préfixe tilde est « ~+ », la valeur de la variable de
l’interpréteur PWD le remplace. Si le préfixe tilde est « ~- », la
valeur de la variable de l’interpréteur OLDPWD, si existante, lui est
substituée. Si les caractères à la suite du tilde dans le préfixe tilde
représentent un nombre N préfixé facultativement par un « + » ou 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 appelé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 un
« + » ou « - » en tête, on suppose qu’il s’agit de « + ».

Si l’identifiant de connexion est incorrect ou si le développement du
tilde échoue, le mot est inchangé.

Chaque affectation de variable vérifie immédiatement la présence de
préfixes tilde non protégés suivant un : ou le premier =. Dans ces cas,
le développement des tildes est aussi effectué. On peut donc utiliser
des noms de fichiers avec des tildes dans des affectations de PATH,
MAILPATH et CDPATH et l’interpréteur affectera la valeur développée.

Remplacement des paramètres
Le caractère « $ » permet d’introduire le développement des paramètres,
la substitution de commande ou le développement arithmétique. Le nom du
paramètre ou du symbole à développer peut être encadré par des
accolades qui sont facultatives mais servent à éviter le développement
de la variable à partir de caractères la suivant immédiatement qui
pourraient être considérés comme appartenant à son nom.

Lorsque les accolades sont utilisées, l’accolade de fin correspondante
est le premier caractère « } » non protégé par une contre-oblique ni
inclus dans une chaîne protégée, ni dans un développement arithmétique,
une substitution de commande ou un développement des paramètres.

${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. Les
exceptions à celui-ci sont les développements de ${!prefix*} et de
${!nom[@]} décrits plus bas. Le point d’exclamation doit immédiatement
suivre l’accolade ouvrante afin d’introduire l’indirection.

Dans chacun des cas ci-dessous, le mot est soumis au développement du
tilde, au développement des paramètres, à la substitution de commande
et au développement arithmétique. Quand il n’effectue pas de
développement de sous-chaîne, bash teste si le paramètre est inexistant
ou vide ; l’absence des deux-points induit un test sur la seule
inexistence du paramètre.

${param��tre:-mot}
Utilisation de valeurs par défaut. Si le param��tre est
inexistant ou vide, le développement du mot et substitué. Sinon,
c’est la valeur du param��tre qui est substituée.
${param��tre:=mot}
Affectation d�’une valeur par défaut. Si le param��tre est
inexistant ou vide, le développement du mot lui est affecté. La
valeur du param��tre est alors substitué. Les paramètres
positionnels et spéciaux ne peuvent pas être affectés de cette
façon.
${param��tre:?mot}
Affichage d�’erreur si vide ou inexistant. Si le param��tre est
inexistant ou vide, 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 termine, s’il n’est pas
interactif. Sinon, la valeur du param��tre est substituée.
${param��tre:+mot}
Utilisation d�’une valeur différente. Si le param��tre est vide ou
inexistant, rien n’est substitué. Sinon le développement du mot
est substitué.
${param��tre:d��but}
${param��tre:d��but:longueur}
Extraction de sous-chaînes. Se développe pour fournir la
sous-chaîne de la longueur indiquée (comptée en caractères)
commençant au d��but. 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. Si le d��but est négatif,
sa valeur est considérée à partir de la fin du contenu du
param��tre. Les expressions arithmétiques commençant par un -
doivent être séparées par une espace des : (deux-points) les
précédant pour être distinguées du développement Utilisation de
valeurs par défaut. 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 indicé par @ ou *,
le résultat est les longueur éléments du tableau commençant à
${param��tre[d��but]}. Une valeur négative de d��but est prise
relativement à la valeur maximum de l’indice du tableau
considéré, augmentée de un. Remarquez qu’une valeur négative de
d��but doit être séparée du deux-points par au moins une espace
pour éviter toute confusion avec le développement de « :- ».
L’indexation des sous-chaînes débute à zéro, sauf pour les
paramètres positionnels pour lesquels l’indexation commence à 1.

${!pr��fixe*}
${!pr��fixe@}
Se développe en les noms des variables dont les noms commencent
par pr��fixe, séparés par le premier caractère de la variable
spéciale IFS.

${!nom[@]}
${!nom[*]}
Si nom est une variable de type tableau, elle se développe en la
liste des indices (clefs) du tableau affecté à nom. Si nom n’est
pas un tableau, se développe en 0 si nom existe et en vide
sinon. Quand @ est utilisé et que le développement apparaît
entre guillemets doubles, chaque clef se développe en un mot
séparé.

${#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 indicé par * ou @, la valeur donnée 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 le
développement des chemins. Si le motif correspond au début de la
valeur du param��tre, alors le développement prend la valeur
développée du param��tre après suppression du plus court (cas
« # ») ou du plus long (cas « ## ») motif correspondant. Si le
param��tre est @ ou *, l’opération de suppression de motif est
appliquée à chaque paramètre positionnel tour à tour et le
développement est la liste résultante. Si le param��tre est une
variable tableau indicée par @ ou *, l’opération de suppression
de motif est appliquée à chaque élément du tableau tour à tour
et le développement est la liste résultante.

${param��tre%mot}
${param��tre%%mot}
Le mot est développé pour fournir un motif, comme dans le
développement des chemins. Si le motif correspond à une portion
finale de la valeur développée du param��tre, alors le
développement prend la valeur développée du param��tre après
suppression du plus court (cas « % ») ou du plus long (cas
« %% ») motif correspondant. Si le param��tre est @ ou *,
l’opération de suppression de motif est appliquée à chaque
paramètre positionnel tour à tour et le développement est la
liste résultante. Si le param��tre est une variable tableau
indicée par @ ou *, l’opération de suppression de motif est
appliquée à chaque élément du tableau tour à tour et le
développement est la liste résultante.

${param��tre/motif/cha��ne}
Le motif est développé comme dans le traitement des chemins. Le
param��tre est développé et la plus longue portion correspondant
au motif est remplacée par la cha��ne. Si le motif commence par
/, toutes les correspondances au motif sont remplacées par la
chaîne. Normalement, seule la première correspondance est
remplacée. 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 vide, 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 tour à tour et le
développement est la liste résultante. Si le param��tre est une
variable tableau indicée par @ ou *, l’opération de substitution
s’applique à chaque élément du tableau tour à tour et le
développement est la liste résultante.

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

$(commande)
ou
�‘commande�‘

Bash effectue la substitution en exécutant la commande et en la
remplaçant par sa sortie standard, dont les éventuels sauts de lignes
finaux 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 accents graves « ` »
est utilisée, le caractère contre-oblique garde sa signification propre
sauf lorsqu’il est suivi de $, �‘ ou \. Le premier accent grave non
protégé par une contre-oblique termine la substitution de commande.
Quand on utilise la forme $(commande), tous les caractères entre
parenthèses constituent la commande ; aucun n’est traité
spécifiquement.

Les substitutions de commande peuvent être imbriquées. Pour imbriquer
en utilisant la forme à accents graves, il faut protéger les accents
graves internes avec des contre-obliques.

Si la substitution apparaît entre guillemets doubles, le découpage en
mots et le développement des chemins ne sont pas effectués sur ses
résultats.

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

$((expression))

L’ancien format $[expression] est obsolète et sera supprimé dans les
prochaines versions de bash.

L’expression est traitée comme si elle était entre guillemets doubles,
mais un guillemet double à l’intérieur de parenthèses n’est pas traité
spécifiquement. Tous les lexèmes dans l’expression sont sujet au
développement des paramètres, à la substitution de commande et à la
suppression des protections. Les développements arithmétiques peuvent
être imbriqués.

L’évaluation est effectuée en suivant les règles décrites plus bas dans
ÉVALUATION ARITHMÉTIQUE. Si l’expression est incorrecte, bash affiche
un message indiquant l’échec 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 (FIFO) 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 son entrée ou sa sortie 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 développement des paramètres et variables, à
la substitution de commande et au développement arithmétique.

Découpage en mots
Les résultats du développement des paramètres, de la substitution de
commande et du développement arithmétique qui ne se trouvent pas entre
guillemets doubles sont analysés par l’interpréteur afin d’appliquer le
d��coupage en mots.

L’interpréteur considère chaque caractère du paramètre IFS comme un
délimiteur et découpe le résultat des transformations précédentes en
fonction de ceux-ci. Si IFS est inexistante ou si sa valeur est
exactement <espace><tabulation><saut de ligne>, la valeur par défaut,
alors toute suite de caractères de IFS sert à délimiter les mots. Si
IFS a une valeur autre que celle par défaut, alors les suites 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 blanc de IFS ). Tout caractère de IFS qui n’est
pas un caractère blanc, se trouvant à côté d’un caractère blanc de IFS,
délimite un champ. Une suite de caractères blancs de IFS est également
traitée comme un délimiteur. Si la valeur de IFS est vide, aucun
découpage en mots n’a lieu.

Les arguments vides explicites ("" ou '') sont conservés. Les arguments
vides implicites non protégés, résultant du développement des
paramètres qui n’ont pas de valeurs, sont supprimés. Si un paramètre
sans valeur est développé entre guillemets doubles, le résultat est un
argument vide qui est conservé.

Remarquez que si aucun développement n’a lieu, le découpage en mots
n’est pas effectué.

Développement des chemins
Après le découpage en mots, à moins que l’option -f soit présente, 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 fichier ne correspond et si
l’option d’interpréteur nullglob est désactivée, le mot reste inchangé.
Si l’option nullglob existe et si aucune correspondance n’est trouvée,
le mot est supprimé. Si l’option d’interpréteur failglob existe et si
aucune correspondance n’est trouvée, un message d’erreur est affiché et
la commande n’est pas exécutée. Si l’option d’interpréteur nocaseglob
est activée, la correspondance est effectuée sans tenir compte de la
casse des caractères alphabétiques. Remarquez que lorsque des
expressions de plage comme [a-z] (voir plus bas) sont utilisées les
lettres de l’autre casse peuvent être incluses, selon le paramétrage de
LC_COLLATE. Quand un motif est utilisé pour le développement des
chemins, le caractère « . » au début d’un nom ou immédiatement à la
suite d’une barre oblique doit être explicitement mis en
correspondance, à moins que l’option d’interpréteur dotglob n’existe.
Lors de la correspondance avec un chemin, le caractère barre oblique
doit toujours être mis en correspondance explicitement. Dans les autres
cas, le caractère « . » n’est pas traité spécifiquement. Voyez la
description de la commande shopt dans COMMANDES INTERNES DE
L�’INTERPRÉTEUR pour une description des options d’interpréteur
nocaseglob, nullglob, failglob et dotglob.

La variable de l’interpréteur GLOBIGNORE peut servir à restreindre
l’ensemble des noms de fichiers correspondant à un motif. Si GLOBIGNORE
existe, 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 quand GLOBIGNORE existe
et n’est pas vide. Toutefois, configurer GLOBIGNORE avec une valeur non
vide a pour effet d’activer l’option d’interpréteur 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 est inexistante.

Motifs génériques

Tout caractère apparaissant dans un motif, hormis les caractères
spéciaux décrits plus bas correspond avec lui-même. Le caractère NUL ne
peut pas se trouver dans un motif. Une contre-oblique protège le
caractère qui la suit ; la contre-oblique de protection est supprimée
lors de la recherche de correspondance. Les caractères spéciaux de
motifs doivent être protégés s’ils sont destinés à une correspondance
littérale.

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

* Correspond à toute chaîne, y compris la chaîne vide.
? Correspond à n’importe quel caractère.
[...] Correspond à tout caractère entre les crochets. Un couple de
caractères séparés par un trait d’union indique une expression
de plage ; tout caractère qui correspond à n’importe quel
caractère situé entre les deux bornes incluses, en utilisant les
suites de collations des paramètres linguistiques régionaux
courants et le jeu de caractères. Si le premier caractère
suivant le [ est un ! ou un ^ alors la correspondance se fait
sur tous les caractères hors plage. L’ordre de tri des
caractères dans les expressions de plage est déterminé par les
paramètres linguistiques régionaux courants et par la valeur de
la variable de l’interpréteur LC_COLLATE si existante. 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 :
alnum alpha ascii blank cntrl digit graph lower print punct
space upper word xdigit
Une classe correspond à un caractère quelconque qui s’y trouve.
La classe de caractères word correspond aux lettres, aux
chiffres et au caractère souligné « _ ».

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 poids de collation (comme indiqué par
les paramètres linguistiques régionaux courants) que le
caractère c.

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

Si l’option extglob d’interpréteur est activée par la commande interne
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 l’un des 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 des
développements ci-dessus sont supprimées.

REDIRECTIONS

       Avant qu’une commande ne soit exécutée, il est  possible  de  rediriger
       son  entrée et sa sortie en utilisant une notation spéciale interprétée
       par l’interpréteur. Les redirections peuvent également servir à  ouvrir
       ou  fermer des fichiers dans l’environnement courant de l’interpréteur.
       Les opérateurs de redirection suivants peuvent précéder  ou  apparaître
       n’importe  où  dans  une  commande  simple  ou suivre une commande. Les
       redirections sont traitées dans leur ordre d’apparition,  de  gauche  à
       droite.

       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
       <,  la  redirection  se  rapporte  à  l’entrée standard (descripteur de
       fichier 0). Si le premier caractère de l’opérateur de  redirection  est
       >,  la  redirection  se  rapporte  à la sortie standard (descripteur de
       fichier 1).

       Le mot qui  suit  l’opérateur  de  redirection  dans  les  descriptions
       suivantes,  à  moins  qu’il  en soit fait état autrement, est soumis au
       développement  des  accolades,  du  tilde,   des   paramètres,   à   la
       substitution   de   commande,   au  développement  arithmétique,  à  la
       suppression  des  protections,  au  développement  des  chemins  et  au
       découpage  en  mots.  S’il se développe en plusieurs mots, bash signale
       une erreur.

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

              ls > liste_répertoires 2>&1

       redirige  à  la  fois la sortie standard et la sortie d’erreur standard
       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 standard a été dupliquée vers la sortie standard
       avant que celle-ci ne soit redirigée vers liste_r��pertoires.

       Bash gère plusieurs noms de fichiers de façon particulière,  lorsqu’ils
       sont  utilisés  dans  des  redirections,  comme  décrit  dans  la table
       suivante :

              /dev/fd/fd
                     Si fd est un entier correct, le descripteur de fichier fd
                     est dupliqué.
              /dev/stdin
                     Le descripteur de fichier 0 est dupliqué.
              /dev/stdout
                     Le descripteur de fichier 1 est dupliqué.
              /dev/stderr
                     Le descripteur de fichier 2 est dupliqué.
              /dev/tcp/host/port
                     Si  host  est  une  adresse Internet ou un nom de machine
                     correct et si port est un numéro de « port » entier ou un
                     nom  de  service, bash tentera d’ouvrir une connexion TCP
                     sur la « socket » correspondante.
              /dev/udp/host/port
                     Si host est un nom de  machine  correct  ou  une  adresse
                     Internet  et  si  port est un numéro de port entier ou un
                     nom de service, bash tentera d’ouvrir une  connexion  UDP
                     sur la « socket » correspondante.

       Remarque :   Bash,   comme   empaqueté   pour  Debian,  ne  permet  pas
       l’utilisation des fichiers /dev/tcp et /dev/udp.

       Un échec à l’ouverture ou à la création d’un fichier conduit à  l’échec
       de la redirection.

       Les  redirections qui utilisent des descripteurs de fichiers supérieurs
       à 9 doivent être utilisés avec précaution  car  il  peut  y  avoir  des
       conflits  avec  les descripteurs de fichiers que l’interpréteur utilise
       en interne.

       Notez  que  la  commande  interne  exec  peut   faire   appliquer   les
       redirections à l’interpréteur de commande en cours.

   Redirection d�’entrée
       Une  redirection  d’entrée  conduit  à  l’ouverture  en lecture avec le
       descripteur de fichier numéro n du  fichier  dont  le  nom  résulte  du
       développement  du  mot  ou  en  tant qu’entrée standard (descripteur de
       fichier 0) si n n’est pas spécifié.

       Le format général des redirections d’entrée est :

              [n]<mot

   Redirection de sortie
       Une redirection de sortie conduit à l’ouverture en écriture du  fichier
       dont  le  nom résulte du développement du mot avec comme descripteur de
       fichier n ou en tant que sortie standard (descripteur de fichier 1)  si
       n  n’est  pas  spécifié.  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
       normal.  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.

   Ajout d�’une sortie redirigée
       La redirection de la sortie de cette façon  conduit  à  l’ouverture  du
       fichier  dont  le  nom  résulte du développement du mot pour ajouter au
       descripteur de fichier n  ou  à  la  sortie  standard  (descripteur  de
       fichier  1) si n n’est pas spécifié. Si le fichier n’existe pas, il est
       créé.

       Le format général pour les sorties avec ajout est :

              [n]>>mot

   Redirection de la sortie standard et de la sortie d�’erreur standard
       Bash  permet  la  redirection  simultanée   de   la   sortie   standard
       (descripteur 1) et de la sortie d’erreur standard (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  rediriger  les  sortie standard et sortie
       d’erreur standard :

              &>mot
       et
              >&mot

       La première des deux  formes  est  préférée.  Ceci  est  sémantiquement
       équivalent à

              >mot 2>&1

   Document en ligne
       Ce  type de redirection commande à l’interpréteur de lire son entrée de
       la source courante jusqu’à ce qu’il voie une ligne contenant  seulement
       le  mot  prévu  (sans blancs finaux). Toutes les lignes lues jusqu’à ce
       point sont ensuite utilisées comme l’entrée standard pour une commande.

       Le format des documents en ligne est le suivant :

              <<[-]mot
                      document_en_ligne
              d��limiteur

       Il  n’y a ni développement des paramètres, ni substitution de commande,
       ni développement arithmétique, ni développement des chemins  d’effectué
       sur  le  mot.  Si  un  quelconque  des  caractères  du mot est protégé,
       d��limiteur est le résultat de la suppression des protections sur mot et
       les  lignes  du  document  en  ligne ne sont pas développées. Si le mot
       n’est pas protégé, toutes les lignes du document en ligne sont soumises
       au  développement  des  paramètres, à la substitution de commande et au
       développement arithmétique. Dans ce dernier cas, la suite de caractères
       \<saut  de ligne> est ignorée et \ doit être utilisée 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  de  l’entrée,  y compris dans la ligne
       contenant d��limiteur. Ceci permet d’indenter  de  façon  naturelle  les
       documents en ligne au sein des scripts.

   Chaînes en ligne
       Une variante aux documents en ligne, le format est :

              <<<mot

       Le mot est développé et fourni à la commande sur son entrée standard.

   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
       noté  par n devient une copie de ce descripteur. Si les chiffres du mot
       ne correspondent pas à un descripteur ouvert en lecture, une erreur  de
       redirection  se  produit.  Si le mot prend la forme -, le descripteur n
       est fermé. Si n n’est pas mentionné, l’entrée standard (descripteur  0)
       est utilisée.

       L’opérateur

              [n]>&mot

       est  utilisé  de  façon  similaire  pour  dupliquer les descripteurs de
       sortie. Si n n’est pas explicité, la sortie  standard  (descripteur  1)
       est  utilisée.  Si  les  chiffres  du  mot  ne  correspondent  pas à un
       descripteur en écriture, une erreur de redirection se produit. Dans  le
       cas  particulier  où  n est omis et où mot ne se développe pas en un ou
       plusieurs chiffres, les sorties  standard  et  d’erreur  standard  sont
       toutes deux redirigées comme décrit précédemment.

   Déplacement de descripteurs de fichiers
       L’opérateur de redirection

              [n]<&chiffre-

       déplace  le  descripteur  de  fichier  chiffre  vers  le descripteur de
       fichier n ou sur l’entrée standard (descripteur  de  fichier  0)  si  n
       n’est pas spécifié. chiffre est fermé après avoir été dupliqué en n.

       De la même façon, l’opérateur de redirection

              [n]>&chiffre-

       déplace  le  descripteur  de  fichier  chiffre  vers  le descripteur de
       fichier n ou sur la sortie standard (descripteur de  fichier  1)  si  n
       n’est pas spécifié.

   Ouverture en Lecture/Écriture d�’un descripteur de fichier
       L’opérateur de redirection

              [n]<>mot

       conduit  à  l’ouverture du 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 permettent de substituer une chaîne à un mot lorsqu’il est
utilisé comme premier mot d’une commande simple. L’interpréteur gère
une liste d’alias qui peuvent être créés et détruits avec les commandes
internes alias et unalias (voir plus bas COMMANDES INTERNES DE
L�’INTERPRÉTEUR ). L’interpréteur vérifie si le premier mot de chaque
commande simple, si non protégé, est un alias. Si c’est le cas, ce mot
est remplacé par le texte de l’alias. Les caractères /, $, ` et = et
tout m��tacaract��re de l’interpréteur ou caractère de protection décrits
plus haut ne peuvent pas apparaître dans un nom d’alias. Le texte de
remplacement peut contenir toute entrée correcte pour l’interpréteur, y
compris les métacaractères de l’interpréteur. L’interpréteur vérifie si
le premier mot du texte de remplacement est à son tour un alias, mais
un mot identique à un alias en cours de développement n’est pas
développé une seconde fois. Ceci signifie qu’on peut, par exemple,
créer un alias ls valant ls -F et bash n’essaiera pas de développer
récursivement le texte de substitution. Si le dernier caractère de la
valeur de l’alias est un blanc, alors le prochain mot de commande
suivant l’alias connaîtra aussi le développement d’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. S’ils sont nécessaires, une fonction de
l’interpréteur devrait être utilisée (voir FONCTIONS plus bas).

Les alias ne sont pas développés quand l’interpréteur n’est pas
interactif sauf si l’option expand_aliases de l’interpréteur est créée
par la commande shopt (voir plus bas la description de shopt dans
COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

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 quelconque 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
disponibles 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.

Pour quasiment chaque usage, les alias sont surpassés par les fonctions
de l’interpréteur.

FONCTIONS

       Une  fonction  de  l’interpréteur, définie comme décrit plus haut, dans
       GRAMMAIRE DE L�’INTERPRÉTEUR,  conserve  une  suite  de  commandes  pour
       exécution  ultérieure.  Lorsque le nom d’une fonction de l’interpréteur
       est utilisée comme un simple nom de commande, la  liste  des  commandes
       associées  à  ce  nom  de  fonction  est  exécutée.  Les fonctions sont
       exécutées dans le contexte de l’interpréteur  courant ;  aucun  nouveau
       processus  n’est  créé  pour  les  interpréter  (à  la  différence d’un
       script). Lorsqu’une fonction est exécutée, les arguments de la fonction
       deviennent  les  paramètres  positionnels  pendant  son  exécution.  Le
       paramètre spécial # est mis à jour en conséquence. Le paramètre spécial
       0 reste inchangé. Le premier élément de la variable FUNCNAME est mis au
       nom de la fonction pendant son exécution. Tous les  autres  aspects  de
       l’environnement  d’exécution de l’interpréteur sont identiques entre la
       fonction et le contexte d’appel, à  l’exception  que  les  captures  de
       DEBUG  et  RETURN  (voir plus bas la description de la commande interne
       trap dans COMMANDES INTERNES DE L�’INTERPRÉTEUR ) ne sont pas  héritées,
       à  moins  que la fonction ait l’attribut trace de positionné (voir plus
       bas la description de la commande  interne  declare)  ou  que  l’option
       d’interpréteur  -o  functrace  ait été activée avec la commande interne
       set (auquel cas toutes les fonctions hériteront des captures  de  DEBUG
       et RETURN).

       Les  variables  locales  d’une  fonction peuvent être déclarées avec la
       commande interne 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.  Toute  commande associée à la capture de RETURN est exécutée
       avant que l’exécution reprenne. 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 peuvent être 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  (et
       facultativement  le  fichier  source et le numéro de ligne, si l’option
       d’interpréteur  extdebug  est  activée).  Les  fonctions  peuvent  être
       exportées  avec  l’option -f de la commande interne export, afin d’être
       automatiquement définies dans les sous-interpréteurs. Une définition de
       fonction  peut  être  supprimée avec l’option -f de la commande interne
       unset. Remarquez que les fonctions et variables  de  l’interpréteur  de
       même  nom  pourront  induire  à  plusieurs  éléments de mêmes noms dans
       l’environnement  passé  aux  enfants   de   l’interpréteur.   Un   soin
       particulier  doit  être  pris  dans  les cas où cela peut conduire à un
       problème.

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

ÉVALUATION ARITHMÉTIQUE

       L’interpréteur   permet,  dans  certaines  circonstances,  l’évaluation
       d’expressions arithmétiques (voir les commandes internes let et declare
       ainsi  que  Développement  arithmétique). L’évaluation est effectuée en
       utilisant  des  entiers  de  longueur  fixe,   sans   vérification   du
       débordement. Néanmoins, la division par 0 est capturée et marquée comme
       une erreur. Les opérateurs, leur priorité, associativité et leur valeur
       sont identiques à ceux du langage C. La liste suivante d’opérateurs est
       entre opérateurs de niveaux de priorité identiques.  Les  niveaux  sont
       décrits par ordre de priorité décroissante.

       id++ id--
              post-incrément et post-décrément de variables
       ++id --id
              pré-incrément et pré-décrément de variables
       - +    plus et moins unaires
       ! ~    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
              opérateur conditionnel
       = *= /= %= += -= <<= >>= &= ^= |=
              affectations
       expr1 , expr2
              virgule

       On  peut  utiliser  les variables de l’interpréteur comme opérandes, le
       développement  des  paramètres  étant   effectué   avant   l’évaluation
       arithmétique.  Dans  une  expression,  les  variables de l’interpréteur
       peuvent également être référencées  par  leur  nom,  sans  utiliser  la
       syntaxe  de  développement  des paramètres. Une variable d’interpréteur
       qui est vide ou inexistante est évaluée à 0 lorsqu’on y accède par  son
       nom sans utiliser la syntaxe de développement des paramètres. La valeur
       d’une variable est évaluée comme une expression arithmétique  lorsqu’on
       y accède ou lorsqu’une variable, qui a vu son attribut integer (entier)
       positionné en utilisant declare -i, se voit affecter  une  valeur.  Une
       valeur  vide  est évaluée à 0. Une variable d’interpréteur n’a donc pas
       besoin d’avoir son attribut integer de positionné 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 est un nombre décimal entre 2
       et 64 représentant la base arithmétique et n est un nombre exprimé dans
       cette  base.  Si  la  base#  est  omise,  la  base 10 est utilisée. Les
       chiffres 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  façon interchangeable pour représenter les nombres entre
       10 et 35.

       Les opérateurs sont évalués par ordre de priorité. Les sous-expressions
       entre  parenthèses sont évaluées en premier, ce qui permet de surpasser
       les règles de priorité ci-dessus.

CONDITIONS

       Les conditions sont utilisées  par  la  commande  composée  [[  et  les
       commandes  internes  test  et  [  pour  vérifier l’état d’un fichier et
       effectuer des  comparaisons  arithmétiques  ou  sur  des  chaînes.  Les
       conditions  se  forment  à  partir  des  primitives unaires ou binaires
       suivantes. Si un quelconque argument fichier de  l’une  des  primitives
       est  de  la  forme  /dev/fd/n,  alors  le  descripteur de fichier n est
       examiné. Si l’argument  fichier  de  l’une  des  primitives  est  parmi
       /dev/stdin,  /dev/stdout ou /dev/stderr, le descripteur de fichier 0, 1
       ou 2, respectivement, est examiné.

       Sauf  indication  contraire,  les  primitives  relatives  aux  fichiers
       suivent  les  liens  symboliques et opèrent sur la cible du lien plutôt
       que sur le lien lui-même.

       Voir la description de la commande interne test  (paragraphe  COMMANDES
       INTERNES  DE  L’INTERPRÉTEUR  plus  bas) pour la gestion des paramètres
       (c’est-à-dire des paramètres manquants).

       -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 normal.
       -g fichier
              Vrai si le fichier existe et a son bit Set-GID de mis.
       -h fichier
              Vrai si le fichier existe et est un lien symbolique.
       -k fichier
              Vrai si le fichier existe et a son bit « sticky » de mis.
       -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 strictement  positive.
       -t fd  Vrai si le descripteur de fichier fd est ouvert et se rapporte à
              un terminal.
       -u fichier
              Vrai si le fichier existe et a son bit Set-UID de mis.
       -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’UID  effectif  de
              l’utilisateur.
       -G fichier
              Vrai  si  le  fichier  existe  et  appartient au GID effectif du
              groupe.
       -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 (selon les
              dates de dernière modification) ou si fichier_1  existe  et  non
              fichier_2.
       fichier_1 -ot fichier_2
              Vrai  si  le  fichier_1  est  plus  vieux que le fichier_2 ou si
              fichier_2 existe et non pas fichier_1.
       fichier_1 -ef fichier_2
              Vrai si le fichier_1 et  le  fichier_2  se  rapportent  au  même
              périphérique et ont les mêmes numéros d’i-noeuds.
       -o nom_opt
              Vrai  si  l’option d’interpréteur nom_opt est activée. Consulter
              la liste des options plus bas dans la description de l’option -o
              de la commande interne set.
       -z cha��ne
              Vrai si la longueur de la cha��ne est nulle.
       cha��ne
       -n 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 == pour une stricte conformité POSIX.

       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 des paramètres linguistiques régionaux courants.

       cha��ne_1 > cha��ne_2
              Vrai  si  cha��ne_1  se  trouve  après  cha��ne_2   dans   l’ordre
              lexicographique des paramètres linguistiques régionaux courants.

       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 vrai si
              arg1 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

       Lors de l’exécution d’une commande simple, l’interpréteur effectue  les
       développements,  affectations  et  redirections  suivants  de  gauche à
       droite.

       1.     Les  mots  que  l’analyseur  a  repéré  comme  affectations   de
              variables  (ceux  qui  précèdent  le  nom de la commande) et les
              redirections sont conservées pour un traitement ultérieur.

       2.     Les mots qui ne sont ni des affectations  de  variables  ni  des
              redirections  sont  développés.  S’il  reste  des  mots après le
              développement, le premier mot est considéré comme le  nom  d’une
              commande et les suivants comme ses arguments.

       3.     Les  redirections  sont  effectuées  comme décrit plus haut dans
              REDIRECTIONS.

       4.     Le texte suivant le = dans chaque affectation  de  variable  est
              sujet   au   développement   du  tilde,  des  paramètres,  à  la
              substitution de commande, au développement arithmétique et à  la
              suppression  des protections avant d’être affecté à la variable.

       Si aucun nom de commande ne résulte  des  précédentes  opérations,  les
       affectations   de   variables   modifient  l’environnement  courant  de
       l’interpréteur. Sinon les variables sont ajoutées à l’environnement  de
       la   commande   exécutée   et   n’affectent   pas   l’environnement  de
       l’interpréteur courant. Si une quelconque des tentatives  d’affectation
       concerne  une  variable  en  lecture seule, une erreur se produit et la
       commande termine avec un état différent de zéro.

       Si aucun nom de commande n’est obtenu, les redirections sont effectuées
       mais  ne  modifient  pas l’environnement de l’interpréteur courant. Une
       erreur de redirection conduit à la terminaison de la commande  avec  un
       état différent de zéro.

       S’il  reste  un  nom  de commande après le développement, l’exécution a
       lieu comme décrit plus bas. Sinon la  commande  termine.  Si  l’un  des
       développements  contient  une substitution de commande, l’état final de
       la commande est l’état final de la dernière  substitution  de  commande
       effectuée.  S’il n’y avait aucune substitution de commande, la commande
       termine avec un état de zéro.

EXÉCUTION DES COMMANDES

       Après le découpage de la ligne de commande en mots, si le résultat  est
       une  commande  simple  suivie  d’une liste facultative d’arguments, les
       actions suivantes sont effectuées.

       Si  le  nom  de  la  commande  ne  contient   aucune   barre   oblique,
       l’interpréteur  tente  de  la  localiser.  S’il  existe une fonction de
       l’interpréteur de ce nom, elle est appelée comme nous l’avons  vu  plus
       haut  dans  FONCTIONS.   Si  le  nom  n’est  pas  celui d’une fonction,
       l’interpréteur le recherche dans la liste des  commandes  internes.  Si
       une correspondance est trouvée, cette commande interne est appelée.

       Si  le  nom  n’est  ni celui d’une fonction de l’interpréteur, ni celui
       d’une commande interne et s’il ne contient pas de barre  oblique,  bash
       va chercher dans chacun des éléments de PATH un répertoire contenant un
       fichier exécutable du nom désiré. Bash utilise  une  table  de  hachage
       pour  mémoriser  les  chemins d’accès complets aux fichiers exécutables
       (voir  plus  bas  la  commande  hash   dans   COMMANDES   INTERNES   DE
       L�’INTERPRÉTEUR  ).  Une recherche complète dans les répertoires du PATH
       n’est effectuée 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 état final de 127.

       Si la recherche réussit ou si le nom de la  commande  contient  une  ou
       plusieurs  barres obliques, l’interpréteur exécute le programme demandé
       dans un environnement d’exécution distinct. L’argument 0 est mis au nom
       indiqué et les éventuels arguments restants de la commande sont mis aux
       arguments indiqués.

       Si  cette  exécution  échoue  parce  que  le  programme  n’est  pas  un
       exécutable  et  si le fichier n’est pas un répertoire, il est pris pour
       un script,  un  fichier  contenant  des  commandes  d’interpréteur.  Un
       sous-interpréteur   est   alors   créé  pour  exécuter  ce  script.  Ce
       sous-interpréteur  se  réinitialisera  lui-même,  comme  si  un  nouvel
       interpréteur  avait été appelé pour exécuter le script, à la différence
       qu’il continuera à mémoriser l’emplacement des commandes connues de son
       parent (voir hash plus bas dans COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

       Si le programme est un fichier  commençant  par  #!,  le  reste  de  la
       première  ligne indique un interprète pour ce programme. L’interpréteur
       se  chargera  d’exécuter  cet  interprète  spécifié  sur  les  systèmes
       d’exploitation  qui ne gèrent pas eux-mêmes ce format d’exécutable. Les
       arguments de l’interprète consistent en  un  seul  argument  facultatif
       fourni  sur  la  première  ligne  du  fichier  à  la  suite  du  nom de
       l’interprète, suivi du nom du programme,  suivi  des  arguments  de  la
       commande s’il y en a.

ENVIRONNEMENT D�’EXÉCUTION DES COMMANDES
       L’interpréteur  fournit  un  environnement  d���ex��cution  consistant  en
       l’ensemble des éléments suivants :

       ·      les fichiers ouverts hérités par l’interpréteur à son  appel  et
              modifiés  par  les  redirections  fournies à la commande interne
              exec

       ·      le répertoire de travail courant comme mis par cd, pushd ou popd
              ou hérité par l’interpréteur à son appel

       ·      le  masque  de création de fichier comme mis par umask ou hérité
              du parent de l’interpréteur

       ·      captures courantes mises par trap

       ·      les paramètres de l’interpréteur sont mis par  des  affectations
              de  variables  ou  avec  la  commande  interne set ou hérités de
              l’environnement du parent de l’interpréteur

       ·      les fonctions de l’interpréteur définies lors de l’exécution  ou
              héritées de l’environnement du parent de l’interpréteur ;

       ·      les options activées à l’appel (par défaut ou avec les arguments
              de ligne de commande) ou par set ;

       ·      options activées par shopt ;

       ·      les alias de l’interpréteur définies par la commande alias ;

       ·      les ID des divers  processus,  y  compris  ceux  des  tâches  en
              arrière-plan, la valeur de $$ et la valeur de $PPID

       Lorsqu’une  commande  autre  qu’une commande interne ou une fonction de
       l’interpréteur  doit  être  exécutée,  elle   est   appelé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  de
       l’interpréteur.

       ·      les   fichiers  ouverts  de  l’interpréteur,  ainsi  que  toutes
              modifications et ajouts spécifiés par  les  redirections  de  la
              commande ;

       ·      le répertoire de travail courant ;

       ·      le masque de création de fichiers ;

       ·      les  variables  et les fonctions de l’interpréteur marquées pour
              l’exportation, ainsi que les  variables  exportées  spécialement
              pour la commande ;

       ·      les captures interceptées par l’interpréteur sont réinitialisées
              aux valeurs héritées de l’interpréteur parent  et  les  captures
              ignorées par l’interpréteur restent ignorées

       Une  commande  appelée  dans  un  environnement  distinct  ne  peut pas
       affecter l’environnement d’exécution de l’interpréteur.

       Les substitutions de commande, les commandes groupées entre parenthèses
       et  les  commandes  asynchrones  sont appelées dans un environnement de
       sous-interpréteur qui est une copie de celui  de  l’interpréteur,  sauf
       que  les  captures  interceptées par l’interpréteur sont réinitialisées
       aux valeurs que l’interpréteur avait  héritées  de  son  parent  à  son
       appel.  Les  commandes  internes  appelées dans une conduite sont aussi
       exécutées dans un environnement de sous-interpréteur. Les modifications
       apportées   à   l’environnement   d’une  sous-interpréteur  n’affectent
       aucunement l’environnement d’exécution de l’interpréteur.

       Si une commande est suivie par un & et que le contrôle des tâches n’est
       pas  actif,  l’entrée standard par défaut de la commande est le fichier
       vide /dev/null. Sinon, la commande appelée hérite des  descripteurs  de
       fichiers   de   l’interpréteur   appelant   comme   modifiés   par  les
       redirections.

ENVIRONNEMENT

       Quand un programme est appelé, il reçoit un tableau de chaînes que l’on
       appelle  environnement. Il s’agit d’une liste de couples nom-valeur, de
       la forme nom=valeur.

       L’interpréteur fournit plusieurs façons de  gérer  l’environnement.  Au
       démarrage,  l’interpréteur  analyse son propre environnement et crée un
       paramètre pour chaque nom trouvé, en le marquant comme exportable  vers
       les   processus  enfants.  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  toute  commande  exécutée  est
       l’environnement  initial  de  l’interpréteur,  dont les valeurs peuvent
       être modifiées dans l’interpréteur, 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 des affectations de
       paramètres, comme nous l’avons  vu  plus  haut  dans  PARAMÈTRES.   Ces
       affectations ne concernent que l’environnement vu par cette commande.

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

       Quand bash appelle une commande externe, la  variable  _  est  mise  au
       chemin  d’accès  complet  à  cette  commande et elle est transmise dans
       l’environnement.

ÉTAT FINAL

       Du point de vue de l’interpréteur, une commande qui termine  avec  état
       final  de  zéro  a  réussi. Un état final de zéro indique le succès. Un
       état final différent de zéro  indique  un  échec.  Quand  une  commande
       termine par un signal mortel N, bash utilise la valeur 128+N comme état
       final.

       Si une commande n’est  pas  trouvée,  le  processus  enfant  créé  pour
       l’exécuter renvoie un état de 127. Si une commande est trouvée mais pas
       exécutable, la valeur renvoyée est 126.

       Si une  commande  échoue  à  cause  d’une  erreur  survenue  lors  d’un
       développement  ou  des  redirections, l’état final est strictement plus
       grand que zéro.

       Les commandes internes renvoient un état de 0 (vrai) si réussies et une
       valeur  différente de zéro (faux) si une erreur se produit pendant leur
       exécution. Toutes les commandes internes renvoient un état final  de  2
       pour indiquer un usage incorrect.

       Bash  lui-même renvoie l’état final de la dernière commande exécutée, à
       moins qu’une erreur de syntaxe se produise, auquel cas il termine  avec
       une  valeur différente de zéro. Voir aussi plus bas la commande interne
       exit.

SIGNAUX

       Quand bash fonctionne de  façon  interactive,  en  l’absence  de  toute
       capture,  il  ignore  SIGTERM  (c’est  ainsi  que  kill 0 ne tue pas un
       interpréteur interactif) et SIGINT est intercepté et géré (c’est  ainsi
       que  la  commande  interne  wait est interruptible). Dans tous les cas,
       bash ignore SIGQUIT.  Si le contrôle des tâches est actif, bash  ignore
       SIGTTIN, SIGTTOU et SIGTSTP.

       Les  commandes  externes  lancées  par  bash  ont  les gestionnaires de
       signaux mis aux valeurs héritées  par  l’interpréteur  de  son  parent.
       Quand   le   contrôle  des  tâches  n’est  pas  actif,  les  tâches  en
       arrière-plan ignorent  les  signaux  SIGINT  et  SIGQUIT  en  plus  des
       gestionnaires  hérités.  Les  commandes  exécutées en tant que résultat
       d’une substitution de commande ignorent  les  signaux  de  contrôle  de
       tâches émis par le clavier SIGTTIN, SIGTTOU et SIGTSTP.

       Par  défaut, l’interpréteur termine à la réception de SIGHUP.  Avant de
       terminer, un interpréteur interactif renvoie le  SIGHUP  à  toutes  les
       tâches  en  cours  ou suspendues. Les tâches suspendues reçoivent aussi
       SIGCONT  pour  s’assurer  qu’elles  reçoivent  bien  le  SIGHUP.   Pour
       empêcher  l’interpréteur  d’envoyer le signal à une tâche particulière,
       elle devrait être supprimée de la table des  tâches  avec  la  commande
       interne disown (voir plus bas COMMANDES INTERNES DE L�’INTERPRÉTEUR ) ou
       marquée comme exemptée de SIGHUP en utilisant disown -h.

       Si l’option d’interpréteur huponexit a été mise avec la fonction shopt,
       bash envoie un signal SIGHUP à toutes les tâches lorsqu’un interpréteur
       de commandes de connexion interactif termine.

       Lorsque bash attend qu’une commande  se  termine  et  qu’il  reçoit  un
       signal  pour  lequel  une  capture  a  été mise, la capture ne sera pas
       exécutée tant que la commande n’est pas terminée. Lorsque  bash  attend
       la  fin  d’une  commande  asynchrone  par  la commande interne wait, la
       réception d’un signal pour lequel une capture a été mise conduira à  un
       retour  immédiat  de  la  commande  interne  wait  avec  un  état final
       supérieur à 128, à la  suite  de  quoi  la  capture  est  immédiatement
       exécutée.

CONTRÔLE DES TÂCHES

Le contr��le des t��ches se réfère à la capacité de suspendre (suspend)
sélectivement l’exécution d’un processus et de la reprendre (resume)
ultérieurement. L’utilisateur bénéficie généralement de cette
possibilité grâce à l’action conjointe du pilote de terminal du système
et de bash.

L’interpréteur associe une t��che à chaque conduite. Il maintient une
table des tâches en cours d’exécution, cette table pouvant être
affichée avec la commande jobs. Quand bash lance une tâche de façon
asynchrone (en arri��re-plan), il affiche une ligne qui ressemble à :

[1] 25647

Cette ligne indique que la tâche est la tâche numéro 1 et que le PID du
dernier processus dans la conduite associée à cette tâche est 25647.
Tous les processus d’une même conduite font partie de la même tâche.
Bash utilise la notion de t��che comme base du contrôle des tâches.

Pour faciliter l’implémentation d’une interface utilisateur pour le
contrôle de tâches, le système introduit la notion d’ID de groupe de
processus associ��s �� un terminal. Les membres de ce groupe de processus
(processus dont le GID est égal au Process Group ID du terminal
courant) reçoivent les signaux émis par le clavier comme SIGINT. Ces
processus sont dits être au premier plan. Les processus en arri��re-plan
sont ceux dont le Process-GID diffère de celui du terminal ; ils sont
indifférents aux signaux émis par le clavier. Seuls les processus au
premier plan peuvent lire depuis le terminal ou y écrire. Les processus
en arrière-plan qui tentent une lecture (ou une écriture) dans le
terminal reçoivent un signal SIGTTIN (SIGTTOU) émis par le pilote du
terminal, qui, sauf interception, suspend le processus.

Si le système d’exploitation sur lequel bash fonctionne permet le
contrôle des tâches, bash fournit des outils pour l’utiliser. La frappe
d’un caractère de suspension (généralement ^Z, Contrôle-Z) pendant
l’exécution d’un processus conduit à la suspension de celui-ci et
redonne la main à bash. La frappe d’un caractère de suspension diff��r��e
(généralement ^Y, Contrôle-Y) conduira à la suspension du processus au
moment où il tentera de lire des saisies depuis le terminal et la main
reviendra à bash. L’utilisateur peut alors manipuler l’état de cette
tâche en utilisant la commande bg (background = arrière-plan) pour en
continuer l’exécution en arrière-plan, la commande fg (foreground =
premier plan) pour la continuer au premier plan ou encore la commande
kill pour la tuer. Un ^Z s’applique immédiatement et a pour effet de
bord d’éliminer les sorties et saisies en attente.

Il y a plusieurs façons de se rapporter à une tâche. Le caractère %
introduit un nom de tâche. On peut se rapporter à la tâche numéro n
comme %n. On peut également se rapporter une tâche en utilisant un
préfixe du nom utilise pour le lancer ou une sous-chaîne qui apparaît
dans sa ligne de commande. Par exemple, %ce se rapporte à une tâche
suspendue nommée ce. Si ce préfixe correspond à plusieurs tâches, bash
signale une erreur. Utiliser %?ce, d’un autre côté, se rapporte à toute
tâche contenant la chaîne ce dans sa ligne de commande. Si la
sous-chaîne correspond à plusieurs tâches, bash signale une erreur. Les
symboles %% et %+ se rapportent à la notion de t��che courante de
l’interpréteur, c’est-à-dire la dernière tâche suspendue alors qu’elle
était au premier plan ou démarrée en arrière-plan. La t��che pr��c��dente
peut être désignée en utilisant %-. Dans les affichages se rapportant
aux tâches (par exemple la sortie de la commande jobs), la tâche
courante est toujours annotée d’un + et la tâche précédente d’un -. Un
simple % (non accompagné de spécification de tâche) se rapporte
également à la tâche courante.

Il suffit de nommer une tâche pour la ramener au premier plan : %1 est
synonyme de « fg %1 » et ramène la tâche 1 de l’arrière-plan vers le
premier plan. De même, « %1 & » reprend la tâche 1 en arrière-plan, de
façon équivalente à « bg %1 ».

L’interpréteur est immédiatement prévenu lorsqu’une tâche change
d’état. Normalement bash attend d’être prêt à afficher son interpréteur
avant de signaler des changements dans l’état des tâches, afin de ne
pas interrompre toute autre sortie. Si l’option -b de la commande
interne set est activée, bash signalera de telles modifications
immédiatement. Toute capture sur SIGCHLD est exécutée pour chaque
enfant qui termine.

Si une tentative est faite de terminer bash alors que des tâches sont
suspendues, l’interpréteur affiche un message d’avertissement. La
commande jobs peut alors être utilisée pour examiner leur états. Si une
deuxième tentative est faite de terminer sans commande intercalaire,
l’interpréteur n’affiche aucun autre avertissement et les tâches
suspendues sont terminées.

INVITES

       Quand il est exécuté de façon interactive,  bash  affiche  l’invite  de
       base  PS1 dès qu’il est prêt à lire une commande et l’invite secondaire
       PS2 quand il a besoin de plus de saisies pour  exécuter  une  commande.
       Bash  permet  de  personnaliser  ces  chaînes  d’invite, en insérant un
       certain nombre de suites de caractères spéciaux d’échappement  par  des
       contre-obliques qui sont décodés comme suit :
              \a     un caractère ASCII d’alarme (07)
              \d     la  date  au format « Jour_de_la_semaine Mois Quantième »
                     (par exemple : « Tue May 26 »)
              \D{format}
                     le format est passé à  strftime(3)  et  le  résultat  est
                     inséré  dans  la  chaîne  de  l’invite ;  un  format vide
                     implique  une  représentation  du  temps  spécifique  aux
                     paramètres  linguistiques  régionaux.  Les accolades sont
                     nécessaires.
              \e     un caractère d’échappement ASCII (033)
              \h     le nom de la machine, jusqu’au premier point « . »
              \H     le nom de la machine
              \j     le   nombre   de   tâches   actuellement    gérées    par
                     l’interpréteur
              \l     le  nom  de  base  du  nom de périphérique de terminal de
                     l’interpréteur
              \n     saut de ligne
              \r     retour chariot (carriage return)
              \s     le nom de l’interpréteur, c’est-à-dire le nom de base  de
                     $0 (la portion suivant là dernière barre oblique)
              \t     l’heure actuelle au format HH:MM:SS sur 24 heures
              \T     l’heure actuelle au format HH:MM:SS sur 12 heures
              \@     l’heure actuelle sur 12 heures au format HH:MM am/pm
              \A     l’heure actuelle au format HH:MM sur 24 heures
              \u     le nom de l’utilisateur
              \v     la version de bash (par exemple, 2.00)
              \V     le  numéro de version complet (avec niveau de correctifs)
                     de bash, (par exemple, 2.00.0)
              \w     le répertoire de travail courant, avec  $HOME  abrégé  en
                     tilde (« ~ »)
              \W     le  nom  de  base  du répertoire de travail courant, avec
                     $HOME abrégé en tilde (« ~ »)
              \!     le numéro d’historique de la commande
              \#     le numéro de la commande
              \$     # si l’UID effectif est 0, $ sinon
              \nnn   le caractère de code octal nnn
              \\     une contre-oblique
              \[     débute une  suite  de  caractères  non  imprimables,  qui
                     peuvent   être   utilisés   pour  inclure  une  suite  de
                     caractères de contrôle du terminal dans l’interpréteur
              \]     fin d’une suite de caractères non imprimables

       Le numéro de commande  et  le  numéro  d’historique  sont  généralement
       différents :  le  numéro  d’historique  d’une  commande correspond à sa
       position dans la file d’historique  qui  peut  contenir  des  commandes
       relues  depuis  cette  liste  (voir  HISTORIQUE plus bas), alors que le
       numéro de commande  est  simplement  une  position  dans  la  suite  de
       commandes  exécutées  depuis  le  début  de  la  session d’interpréteur
       courante. Après que la chaîne  a  été  décodée,  elle  est  soumise  au
       développement  des  paramètres,  à  la  substitution  de  commande,  au
       développement arithmétique au découpage des mots et  à  la  suppression
       des  protections, selon la valeur de l’option d’interpréteur promptvars
       (voir plus bas la description  de  shopt  dans  COMMANDES  INTERNES  DE
       L�’INTERPRÉTEUR ).

READLINE

       C’est la bibliothèque qui gère la lecture des saisies lors des sessions
       interactives de l’interpréteur, à moins  que  l’option  --noediting  ne
       soit  indiquée  à  l’appel  de l’interpréteur. Par défaut les commandes
       d’édition de ligne sont similaires  à  celles  d’emacs.  Une  interface
       d’édition  de ligne dans le style vi est aussi disponible. Pour arrêter
       l’édition de ligne  après  le  démarrage  de  l’interpréteur,  utiliser
       l’option  +o  emacs  ou +o vi de la commande interne set (voir plus bas
       COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

   Notation readline
       Dans ce paragraphe  on  utilisera  la  notation  « à  la  emacs »  pour
       indiquer  les  frappes  de  touches.  Les  touches Contrôle sont notées
       C-touche, par exemple C-n signifie Contrôle-N.  De  même,  les  touches
       M��ta  sont  notées  par  M-touche,  ainsi M-x signifie Méta-X. (Sur les
       claviers sans touches M��ta, M-x signifie ESC x, c’est-à-dire presser la
       touche  d’Échappement  puis  la  touche  x. Cela fait de ESC le pr��fixe
       m��ta. La combinaison M-C-x signifie ESC-Contrôle-x ou encore presser la
       touche d’Échappement puis maintenez la touche Contrôle enfoncée tout en
       pressant la touche x.)

       Les commandes readline peuvent recevoir des arguments  numériques,  qui
       fonctionnent en règle générale comme compteurs de répétitions. Parfois,
       cependant,  c’est  le  signe  de  l’argument  qui   est   significatif.
       L’utilisation  d’un argument négatif pour une commande agissant dans un
       sens donné (par ex. kill-line) conduit cette commande à  agir  dans  la
       direction   opposée.  Les  commandes  dont  le  comportement  avec  les
       arguments diffère de ceci sont indiquées plus bas.

       Lorsqu’une commande est indiquée comme d��truisant du  texte,  le  texte
       effacé   est  en  fait  sauvegardé  pour  une  éventuelle  récupération
       ultérieure (yanking). Il est conservé dans un  tampon  circulaire.  Les
       suppressions  successives  conduisent  à  l’accumulation du texte en un
       seul bloc qui peut  être  récupéré  en  une  fois.  Les  commandes  non
       destructrices séparent les blocs de textes dans le tampon circulaire.

   Initialisation de readline
       Readline  est  personnalisé  en  mettant  des commandes dans un fichier
       d’initialisation (le fichier inputrc). Le nom de ce  fichier  est  pris
       dans  la  variable  de  l’interpréteur  INPUTRC.  Si cette variable est
       inexistante, le nom par  défaut  est  ~/.inputrc.  Lorsqu’un  programme
       utilisant la bibliothèque readline démarre, le fichier d’initialisation
       est lu et les raccourcis clavier et les variables sont mis en place. Il
       n’y  a  que  quelques  constructions  élémentaires de possibles dans le
       fichier  d’initialisation  de  readline.  Les  lignes   blanches   sont
       ignorées. Les lignes commençant par # sont des commentaires. Les lignes
       commençant par  $  indiquent  des  constructions  conditionnelles.  Les
       autres  lignes  indiquent des raccourcis clavier et des paramétrages de
       variables.

       Les raccourcis clavier par défaut peuvent être modifiés par un  fichier
       inputrc.  D’autres  programmes qui utilisent cette bibliothèque peuvent
       ajouter leurs propres commandes et raccourcis.

       Par exemple, en plaçant

              M-Control-u: universal-argument
       ou
              C-Meta-u: universal-argument
       dans le fichier inputrc, on associera la suite de touches  M-C-u  à  la
       commande readline universal-argument.

       Les  caractères  symboliques suivants sont acceptés : RUBOUT, DEL, ESC,
       LFD, NEWLINE, RET, RETURN, SPC, SPACE et TAB.

       En plus des noms de commandes, readline permet d’associer à une  touche
       une chaîne de caractères qui sera insérée lorsque la touche est pressée
       (une macro).

   Raccourcis clavier readline
       La syntaxe de définition des raccourcis clavier dans le fichier inputrc
       est  simple. Tout ce qui est nécessaire est le nom de la commande ou le
       texte d’une macro et la suite de touches à laquelle il faut l’associer.
       Les  noms  de touches peuvent être spécifiés de l’une des deux façons :
       comme un nom de touche symbolique, éventuellement précédé des  préfixes
       Meta- ou Control- ou sous forme d’une suite de touches.

       En  utilisant  la  forme touche:nom_de_fonction ou macro, touche est le
       nom de la touche en anglais. Par exemple :

              Control-u: universal-argument
              Meta-Rubout: backward-kill-word
              Control-o: "> output"

       Dans   l’exemple   ci-dessus,   C-u   est   associé   à   la   fonction
       universal-argument,  M-DEL  à  la  fonction backward-kill-word et C-o à
       l’exécution de la macro exprimée dans la partie  gauche  (c’est-à-dire,
       insérer le texte ‘‘> output’’ sur la ligne).

       Avec  la  seconde  forme,  "touches":nom_de_fonction  ou macro, touches
       diffère de touche ci-dessus en ce que  les  chaînes  notant  une  suite
       complète  de  touches  peut  être  spécifiée  en plaçant la suite entre
       guillemets doubles. Certaines suites de touches d’échappement  dans  le
       style  GNU  Emacs peuvent être utilisées, comme dans l’exemple suivant,
       mais les noms de caractères symboliques ne sont pas reconnus.

              "\C-u": universal-argument
              "\C-x\C-r": re-read-init-file
              "\e[11~": "Function Key 1"

       Dans  cet  exemple,  C-u  est  à  nouveau   associé   à   la   fonction
       universal-argument,  C-x C-r à la fonction re-read-init-file et ESC [ 1
       1 ~ à l’insertion du texte ‘‘Function Key 1’’.

       Le jeu complet des suites de caractères  d’échappements  du  style  GNU
       Emacs est
              \C-    préfixe Contrôle
              \M-    préfixe Méta
              \e     caractère d’échappement
              \\     contre-oblique
              \"     un guillemet " littéral
              \'     un guillemet ' littéral

       En plus des suites de caractères d’échappement dans le style GNU Emacs,
       un second jeu de suites de caractères d’échappement par contre-obliques
       est disponible :
              \a     alerte (alarme)
              \b     effacement arrière (backspace)
              \d     effacement
              \f     saut de page (form feed)
              \n     saut de ligne
              \r     retour chariot (carriage return)
              \t     tabulation horizontale
              \v     tabulation verticale
              \nnn   le  caractère 8 bits dont la valeur octale est nnn (de un
                     à trois chiffres)
              \xHH   le caractère 8 bits dont la valeur  hexadécimale  est  HH
                     (un à deux symboles hexadécimaux)

       Lorsqu’on  saisit le texte d’une macro, il faut utiliser des guillemets
       simples ou des doubles pour indiquer la définition  de  la  macro.  Les
       textes  non  protégés sont considérés comme des noms de fonctions. Dans
       le corps de la macro, les protections par contre-oblique décrites  plus
       haut sont développées. La contre-oblique protégera tout autre caractère
       dans le texte de la macro, y compris " et '.

       Bash permet d’afficher ou de modifier les raccourcis  clavier  readline
       avec  la  commande interne bind. On peut basculer d’un mode d’édition à
       l’autre en mode interactif en utilisant  l’option  -o  de  la  commande
       interne set (voir plus bas COMMANDES INTERNES DE L�’INTERPRÉTEUR ).

   Variables de readline
       Readline  dispose  de variables permettant de personnaliser encore plus
       son comportement. Une variable peut être mise dans le  fichier  inputrc
       avec une affectation de la forme

              set nom_de_variable valeur

       Sauf  indication  contraire,  les  variables  de  readline prennent les
       valeurs On ou Off  (la  casse  étant  sans  importance).  Les  noms  de
       variables non reconnues sont ignorés. Lorsqu’une valeur de variable est
       lue, les variables vides ou de valeur nulle, « on »  (insensible  à  la
       casse)  et  « 1 »  sont équivalent à On. Toutes les autres valeurs sont
       équivalentes à Off. Les variables et leurs valeurs par défaut, sont :

       bell-style (audible)
              Cette  variable  commande  readline  lorsqu’il  faut  déclencher
              l’alarme  du  terminal.  Si  mise à none, readline n’émet jamais
              d’alarme.  Si  mise  à  visible,  readline  utilise  une  alarme
              visuelle  s’il  en  est  une  de  disponible. Si mise à audible,
              readline essaie de faire sonner l’alarme du terminal.
       bind-tty-special-chars (On)
              Si mise à  On,  readline  tente  d’associer  les  caractères  de
              contrôle traités spécialement par le pilote de terminal du noyau
              à leurs équivalents readline.
       comment-begin (« # »)
              Cette  chaîne   est   insérée   quand   la   commande   readline
              insert-comment  est  exécutée. Cette commande est associée à M-#
              en mode emacs et à # en mode de commande vi.
       completion-ignore-case (Off)
              Si  mise  à  On,  readline  effectue  les   correspondances   et
              complètements de noms de fichiers sans tenir compte de la casse.
       completion-query-items (100)
              Ceci détermine quand l’utilisateur est interrogé  pour  voir  le
              nombre  de  complètements  possibles  produits  par  la commande
              possible-completions. Elle peut être mise à toute valeur entière
              positive.  Si le nombre de complètements possibles est supérieur
              ou égal à  la  valeur  de  cette  variable,  il  est  demandé  à
              l’utilisateur  s’il  veut  ou  non  les  voir ;  sinon, ils sont
              simplement affichés sur le terminal.
       convert-meta (On)
              Si mise à On, readline transformera  les  caractères  avec  leur
              huitième  bit  à 1 en suite de caractères ASCII en supprimant le
              huitième  bit  et  en  insérant  comme  préfixe   un   caractère
              d’échappement  (en fait, en utilisant le caractère d’échappement
              comme pr��fixe m��ta).
       disable-completion (Off)
              Si mise à On, readline empêchera le complètement des  mots.  Les
              caractères  de  complètement  seront  insérés sur la ligne comme
              s’ils avaient été associés à self-insert.
       editing-mode (emacs)
              Commande si readline doit démarrer avec des  raccourcis  clavier
              similaires  à  emacs  ou à vi. editing-mode peut être mis soit à
              emacs ou soit à vi.
       enable-keypad (Off)
              Quand mise à On,  readline  essayera  d’activer  le  clavier  de
              l’application  lorsqu’elle  sera appelée. Sur certains systèmes,
              cela est nécessaire pour utiliser les flêches.
       expand-tilde (Off)
              Si mise à on, le développement du  tilde  est  effectué  lorsque
              readline tente un complètement de commandes.
       history-preserve-point (Off)
              Si  mise  à  on,  le  programme  d’historique tente de placer le
              curseur au même endroit sur chaque ligne  de  l’historique  avec
              previous-history ou next-history.
       horizontal-scroll-mode (Off)
              Quand  mise à On, readline utilisera une seule ligne d’affichage
              et fera défiler la saisie horizontalement sur  une  seule  ligne
              d’écran  quand  elle  devient  plus  longue  que  la  largeur de
              l’écran, plutôt que de faire un retour à la ligne.
       input-meta (Off)
              Si mise à On, readline  acceptera  des  saisies  sur  huit  bits
              (autrement  dit  il ne supprimera pas le huitième bit), quel que
              soit le terminal utilisé. Le nom meta-flag est un synonyme  pour
              cette variable.
       isearch-terminators (« C-[C-J »)
              La  chaîne  des  caractères  qui  doivent terminer une recherche
              incrémentale sans que le caractère ne  soit  exécuté  comme  une
              commande.  Si  cette  variable  n’a  pas  reçu  de  valeur,  les
              caractères ESC et C-J termineront une recherche incrémentale.
       keymap (emacs)
              Configure le jeu de raccourcis readline courant. L’ensemble  des
              noms  corrects  de jeux de raccourcis est emacs, emacs-standard,
              emacs-meta, emacs-ctlx, vi,  vi-command  et  vi-insert.  vi  est
              équivalent à vi-command ; emacs est équivalent à emacs-standard.
              La valeur par défaut  est  emacs ;  la  valeur  de  editing-mode
              modifie aussi le jeu de raccourcis par défaut.
       mark-directories (On)
              Si  mise  à  On,  les  noms de répertoires ont une barre oblique
              d’ajoutée.
       mark-modified-lines (Off)
              Si mise à On, les lignes  d’historique  qui  ont  été  modifiées
              seront précédées à l’affichage d’un astérisque (*).
       mark-symlinked-directories (Off)
              Si  mise à On, les noms complétés qui sont des liens symboliques
              vers des répertoires ont une barre oblique d’ajoutée  (selon  la
              valeur de mark-directories).
       match-hidden-files (On)
              Cette  variable,  quand  mise  à  On,  conduit  readline à faire
              correspondre des fichiers dont le  nom  commence  par  un  « . »
              (fichiers  cachés)  lors  du complètement de noms de fichiers, à
              moins que le « . » de tête soit fourni par l’utilisateur dans le
              nom de fichier à compléter.
       output-meta (Off)
              Si  mise  à  On,  readline  affichera directement les caractères
              ayant leur huitième bit à 1, plutôt que d’utiliser une suite  de
              caractères d’échappement avec préfixe méta.
       page-completions (On)
              Si  mise à On, readline utilise un visualisateur interne du type
              more pour afficher un plein écran à la fois des complètements.
       print-completions-horizontally (Off)
              Si   mise   à   On,   readline   affichera   les   complètements
              correspondants  triés  horizontalement dans l’ordre alphabétique
              plutôt que verticalement.
       show-all-if-ambiguous (Off)
              Ceci  modifie  le  comportement  par  défaut  des  fonctions  de
              complètement.  Si  mise  à  on,  les  mots  qui  ont  plus  d’un
              complètement possibles conduisent  à  l’affichage  immédiat  des
              correspondances plutôt qu’à l’émission d’une alarme.
       show-all-if-unmodified (Off)
              Ceci  modifie  le  comportement  par  défaut  des  fonctions  de
              complètement de façon similaire à show-all-if-ambiguous. Si mise
              à  on,  les  mots  qui  ont plus d’un complètement possible sans
              aucun complètement partiel possible (les complètements possibles
              ne  partagent  pas  de  préfixe commun) conduisent à l’affichage
              immédiat  des  correspondances  plutôt  qu’à  l’émission   d’une
              alarme.
       visible-stats (Off)
              Si  mise  à On, un caractère indiquant le type de fichier, comme
              signalé par stat(2) est ajouté aux noms de fichiers en affichant
              les complètements possibles.

   Constructions conditionnelles de readline
       Readline   implémente  un  mécanisme  inspiré  des  fonctionnalités  de
       compilation conditionnelle du pré-processeur C qui  permet  d’effectuer
       le  paramétrage  des  raccourcis  clavier  et  des  variables selon les
       résultats de tests. Il y a quatre directives d’analyse utilisées.

       $if    La structure $if permet de choisir les raccourcis selon le  mode
              d’édition,   le  terminal  utilisé  ou  l’application  utilisant
              readline. Le texte du test va jusqu’à la fin de la ligne ; aucun
              caractère n’est nécessaire pour le délimiter.

              mode   La  forme  mode=  de  la  directive $if est utilisée pour
                     vérifier si readline est en mode emacs ou vi.  Ceci  peut
                     être  utilisé conjointement à la commande set keymap, par
                     exemple  pour  ne  mettre  les  raccourcis  des  jeux  de
                     raccourcis  emacs-standard  et emacs-ctlx que si readline
                     démarre en mode emacs.

              term   La forme  term=  peut  être  utilisée  pour  ajouter  des
                     raccourcis   clavier   spécifiques   au  terminal,  comme
                     associer des suites de touches produites par des  touches
                     de  fonction  du terminal. Le mot à droite du signe = est
                     comparé à la fois au nom complet  du  terminal  et  à  la
                     portion  de  nom du terminal qui précède le premier signe
                     -. Ceci permet, par exemple, de  faire  correspondre  sun
                     avec à la fois sun et sun-cmd.

              application
                     La  structure  application  est utilisée pour inclure des
                     paramétrages spécifiques  à  chaque  application.  Chaque
                     programme utilisant la bibliothèque readline configure un
                     nom d���application et  un  fichier  d’initialisation  peut
                     tester  une  valeur  particulière. Ceci peut être utilisé
                     pour associer des  suites  de  touches  à  des  fonctions
                     utiles  pour  un  certain  programme.  Par  exemple,  les
                     commandes suivantes ajoutent une  suite  de  touches  qui
                     protège le mot courant ou précédant dans Bash :

                     $if Bash
                     # Protéger le mot courant ou le précédant
                     "\C-xq": "\eb\"\ef\""
                     $endif

       $endif Cette  commande,  comme  on  l’a  vu  dans  l’exemple ci-dessus,
              termine une commande $if.

       $else  Permet d’ajouter des commandes qui seront exécutées  si  un  $if
              échoue.

       $include
              Cette directive prend un seul nom de fichier comme argument et y
              lit les commandes et les raccourcis. Par exemple,  la  directive
              suivante lirait le fichier /etc/inputrc :

              $include  /etc/inputrc

   Recherche
       Readline  fournit des commandes de recherche au sein de l’historique de
       commandes (voir HISTORIQUE plus bas) des lignes  contenant  une  chaîne
       donnée.   Il   y  a  deux  modes  de  recherche :  incr��mental  et  non
       incr��mental.

       Les recherches incrémentales commencent avant  même  que  l’utilisateur
       ait  terminé  de saisir la chaîne recherchée. À chaque caractère saisi,
       readline affiche l’élément suivant de l’historique qui correspond à  la
       chaîne  déjà  entrée. Une recherche incrémentale nécessite seulement le
       nombre   de   caractères   indispensable   pour   retrouver   l’élément
       d’historique  désiré.  Les  caractères  se  trouvant  dans  la variable
       isearch-terminators servent à terminer une recherche  incrémentale.  Si
       aucune  valeur  n’a  été  affectée  à  cette  variable  les  caractères
       Échappement   (Escape)   et   Contrôle-J   terminent   une    recherche
       incrémentale.    Contrôle-G    permet   d’interrompre   une   recherche
       incrémentale et de restaurer la ligne originale. Lorsque  la  recherche
       est  finie,  l’élément d’historique contenant la chaîne désirée devient
       la ligne courante.

       Pour  trouver  les  autres  éléments   correspondant   dans   la   file
       d’historique,   saisissez   selon   Contrôle-S   ou   Contrôle-R.  Ceci
       recherchera en avant ou en arrière dans l’historique l’élément  suivant
       correspondant  à  la  chaîne  saisie  jusque-là.  Toute  autre suite de
       touches associée à une commande readline interrompra  la  recherche  et
       exécutera  la  commande.  Par  exemple, un saut de ligne interrompra la
       recherche et acceptera la ligne, exécutant ainsi la commande de la file
       d’historique.

       Readline  se  souvient de la dernière chaîne de recherche incrémentale.
       Si deux Contrôle-R sont tapés sans caractère pour définir une  nouvelle
       recherche de chaîne, toute chaîne mémorisée sera utilisée.

       Les  recherches  non  incrémentales  lisent la chaîne désirée en entier
       avant  de  démarrer  la  recherche  de  correspondance  dans  la  liste
       d’historique.  La  chaîne  peut  être saisie par l’utilisateur ou faire
       partie du contenu de la ligne courante.

   Noms des commandes readline
       Ce qui suit est une liste des  noms  de  commandes  et  les  suites  de
       touches  auxquelles  elles  sont  associées  par  défaut.  Les  noms de
       commandes sans suite de touche les accompagnant ne sont  pas  associées
       par  défaut.  Dans  les  descriptions  suivantes, le curseur (point) se
       rapporte à la position courante du curseur et la marque se  rapporte  à
       une  position de curseur sauvegardée par la commande set-mark. Le texte
       entre le curseur et la marque est désigné comme la zone.

   Commandes de déplacement
       beginning-of-line (C-a)
              Saut au début de la ligne courante.
       end-of-line (C-e)
              Saut à la fin de la ligne.
       forward-char (C-f)
              Avancer d’un caractère.
       backward-char (C-b)
              Reculer d’un caractère.
       forward-word (M-f)
              Avancer jusqu’à la fin du mot suivant. Les mots sont composés de
              caractères alphanumériques (lettres et chiffres).
       backward-word (M-b)
              Reculer  jusqu’au début du mot courant ou du précédent. Les mots
              sont  composés  de  caractères   alphanumériques   (lettres   et
              chiffres).
       clear-screen (C-l)
              Effacer  l’écran,  en  laissant  la  ligne courante au sommet de
              l’écran. S’il y a un argument, rafraîchir la ligne courante sans
              effacer l’écran.
       redraw-current-line
              Rafraîchir la ligne courante.

   Commandes de manipulation de l�’historique
       accept-line (Saut de ligne, Retour-Chariot)
              Valider  la  ligne, sans se soucier de l’emplacement du curseur.
              Si la ligne n’est pas vide, l’ajouter à  la  file  d’historique,
              sous  contrôle  de  la variable HISTCONTROL.  Si cette ligne est
              une modification d’une ligne de  l’historique,  restaurer  cette
              dernière.
       previous-history (C-p)
              Récupérer  la  commande  précédente  de la file d’historique, en
              remontant dans la file.
       next-history (C-n)
              Récupérer la commande suivante dans  la  file  d’historique,  en
              descendant dans la file.
       beginning-of-history (M-<)
              Récupérer la première ligne de l’historique.
       end-of-history (M->)
              Retourner  à la fin de l’historique de saisie, c’est-à-dire à la
              ligne en cours de saisie.
       reverse-search-history (C-r)
              Rechercher en arrière dans l’historique, en remontant. C’est une
              recherche incrémentale.
       forward-search-history (C-s)
              Rechercher  en avant dans l’historique, en descendant. C’est une
              recherche incrémentale.
       non-incremental-reverse-search-history (M-p)
              Rechercher une chaîne en arrière dans l’historique, en remontant
              depuis   la   ligne   actuelle,   utiliser   une  recherche  non
              incrémentale pour une chaîne fournie par l’utilisateur.
       non-incremental-forward-search-history (M-n)
              Rechercher une chaîne en avant dans l’historique,  utiliser  une
              recherche   non   incrémentale   pour  une  chaîne  fournie  par
              l’utilisateur.
       history-search-forward
              Rechercher en avant dans l’historique la chaîne  comprise  entre
              le  début  de la ligne actuelle et la position du curseur. C’est
              une recherche non incrémentale.
       history-search-backward
              Rechercher en arrière dans l’historique la chaîne comprise entre
              le  début  de la ligne actuelle et la position du curseur. C’est
              une recherche non incrémentale.
       yank-nth-arg (M-C-y)
              Insérer, à l’emplacement du curseur, le premier argument  de  la
              commande précédente. Généralement, il s’agit du second mot de la
              ligne précédente. Avec un argument n, insérer le n-ième  mot  de
              la  commande précédente (les mots sont numérotés à partir de 0).
              Un argument négatif insère le n-ième mot en partant de la fin de
              la  commande  précédente.  Une fois que l’argument n est traité,
              l’argument est extrait comme si  le  développement  d’historique
              « !n » avait été spécifié.
       yank-last-arg (M-., M-_)
              Insérer  à  la  position  du  curseur  le dernier argument de la
              commande précédente (le dernier mot de l’élément précédent de la
              file  d’historique).  Avec  un  argument, se comporte exactement
              comme  yank-nth-arg.  Les  appels  successifs  à   yank-last-arg
              remontent  dans  la  file  d’historique  en  insérant le dernier
              argument  de  chaque  ligne  tour  à   tour.   Les   outils   de
              développement   d’historique  sont  utilisés  pour  extraire  le
              dernier argument, comme si le développement d’historique  « !$ »
              avait été spécifié.
       shell-expand-line (M-C-e)
              Développer,  comme  le  fait  l’interpréteur, la ligne courante.
              Ceci effectue le développement des  alias  et  de  l’historique,
              aussi  bien  que  l’ensemble  des  développements  effectués par
              l’interpréteur. Voir plus  bas  DÉVELOPPEMENT  DE  L�’HISTORIQUE,
              pour une description détaillée du développement de l’historique.
       history-expand-line (M-^)
              Effectuer le développement d’historique sur la  ligne  courante.
              Voir   plus   bas   DÉVELOPPEMENT   DE  L�’HISTORIQUE,  pour  une
              description détaillée.
       magic-space
              Effectuer le développement de l’historique sur la ligne courante
              et   insérer   une   espace.  Voir  plus  bas  DÉVELOPPEMENT  DE
              L�’HISTORIQUE, pour une description détaillée.
       alias-expand-line
              Effectuer le développement des alias sur la ligne courante. Voir
              ALIAS plus haut pour une description des développements d’alias.
       history-and-alias-expand-line
              Effectuer le développement de l’historique et des alias  sur  la
              ligne courante.
       insert-last-argument (M-., M-_)
              un synonyme de yank-last-arg.
       operate-and-get-next (C-o)
              Valider  la  ligne  courante  et  récupérer la ligne suivante de
              l’historique pour édition. Tout argument est ignoré.
       edit-and-execute-command (C-xC-e)
              Appelle un éditeur sur la ligne de commande courante et  exécute
              le  résultat  comme  une  commande  d’interpréteur.  Bash  tente
              d’appeler, dans cet  ordre,  $FCEDIT,  $EDITOR  et  emacs  comme
              éditeur.

   Commande d�’édition de texte
       delete-char (C-d)
              Effacer le caractère sous le curseur. Si le curseur est au début
              de la ligne, si celle-ci est vide et  si  le  dernier  caractère
              saisi n’était pas associé à delete-char, alors renvoyer EOF.
       backward-delete-char (« Rubout » : Effacement)
              Effacer  le  caractère  avant  le  curseur.  Lorsque un argument
              numérique est indiqué, le texte effacé est  sauvegardé  dans  le
              tampon circulaire.
       forward-backward-delete-char
              Effacer  le  caractère  sous le curseur, sauf s’il est en fin de
              ligne, auquel cas le caractère avant le curseur est effacé.
       quoted-insert (C-q, C-v)
              Ajouter littéralement sur la ligne le caractère  saisi  suivant.
              Ceci permet d’insérer des caractères comme C-q, par exemple.
       tab-insert (C-v TAB)
              Insérer un caractère de tabulation.
       self-insert (a, b, A, 1, !, ...)
              Insérer le caractère mentionné.
       transpose-chars (C-t)
              Échanger  les  caractères se trouvant devant et sous le curseur.
              Le curseur est avancé d’un caractère. À la fin d’une ligne,  les
              caractères  échangés  sont  les  deux  précédents. Les arguments
              négatifs n’ont aucun effet.
       transpose-words (M-t)
              Déplace le mot avant le curseur au-delà du mot après le  curseur
              et  déplace  aussi le curseur sur ce mot. Si le curseur est à la
              fin de la ligne, cela échange  les  deux  derniers  mots  de  la
              ligne.
       upcase-word (M-u)
              Transformer  le  mot courant (ou le suivant) en majuscules. Avec
              un argument négatif, agir sur  le  mot  précédent  mais  ne  pas
              déplacer le curseur.
       downcase-word (M-l)
              Transformer  le  mot courant (ou le suivant) en minuscules. Avec
              un argument négatif, agir sur  le  mot  précédent  mais  ne  pas
              déplacer le curseur.
       capitalize-word (M-c)
              Passer  en  majuscule l’initiale du mot courant (ou du suivant).
              Avec un argument négatif, agir sur le mot précédent mais ne  pas
              déplacer le curseur.
       overwrite-mode
              Basculer  en  mode  d’écrasement.  Avec  un  argument  numérique
              explicite strictement positif,  bascule  en  mode  d’écrasement.
              Avec  un argument numérique explicite négatif ou nul, bascule en
              mode d’insertion. Cette commande n’affecte que le  mode  emacs ;
              le mode vi écrase de façon différente. Chaque appel à readline()
              démarre  en  mode  d’insertion.  En   mode   d’écrasement,   les
              caractères  associés  à  self-insert remplacent le texte sous le
              curseur plutôt que de déplacer le  texte  vers  la  droite.  Les
              caractères   associés   à   backward-delete-char  remplacent  le
              caractère avant le curseur par une  espace.  Par  défaut,  cette
              commande n’est pas associée.

   Effacement et récupération
       kill-line (C-k)
              Effacer le texte depuis la position du curseur jusqu’à la fin de
              la ligne.
       backward-kill-line (C-x Effacement)
              Effacer en arrière jusqu’au début de ligne.
       unix-line-discard (C-u)
              Effacer le texte entre le début de la ligne et  la  position  du
              curseur. Le texte est sauvegardé dans le tampon circulaire.
       kill-whole-line
              Effacer  toute  la  ligne  sans  tenir  compte de la position du
              curseur.
       kill-word (M-d)
              Effacer le texte entre le curseur et la fin du mot  courant  ou,
              si  entre  des  mots, jusqu’à la fin du mot suivant. Les limites
              des mots sont identiques à celles utilisées par forward-word.
       backward-kill-word (M-Effacement)
              Effacer le mot  sous  le  curseur.  Les  limites  de  mots  sont
              identiques à celles utilisées par backward-word.
       unix-word-rubout (C-w)
              Effacer  le mot sous le curseur, en utilisant une espace blanche
              comme limite de mot. Le texte  effacé  est  sauvegardé  dans  le
              tampon circulaire.
       unix-filename-rubout
              Effacer le mot sous le curseur, en utilisant l’espace blanche et
              la barre oblique comme limites de mot.  Le  texte  supprimé  est
              sauvegardé dans le tampon circulaire.
       delete-horizontal-space (M-\)
              Effacer toutes les espaces blanches et les tabulations autour du
              curseur.
       kill-region
              Détruire le texte dans la zone courante.
       copy-region-as-kill
              Copier le texte de la zone vers le tampon circulaire.
       copy-backward-word
              Copier le mot précédant le curseur dans  le  tampon  circulaire.
              Les limites de mots sont identiques à celles de backward-word.
       copy-forward-word
              Copier  le mot suivant le curseur dans le tampon circulaire. Les
              limites de mots sont identiques à celles de forward-word.
       yank (C-y)
              Récupérer le texte au sommet du tampon circulaire à la  position
              du curseur dans le tampon.
       yank-pop (M-y)
              Exécuter une rotation du tampon circulaire et récupérer le texte
              situé à son nouveau sommet. Ceci ne fonctionne qu’après yank  ou
              yank-pop.

   Arguments numériques
       digit-argument (M-0, M-1, ..., M--)
              Ajouter  ce  chiffre à l’argument en cours de rédaction ou créer
              un nouvel argument. M-- crée un argument négatif.
       universal-argument
              Il s’agit d’une autre façon de spécifier un argument.  Si  cette
              commande  est  suivie d’un ou plusieurs chiffres facultativement
              précédés d’un signe moins, ces chiffres définissent  l’argument.
              Si la commande est suivie de chiffres, une nouvelle exécution de
              universal-argument  termine  l’argument  numérique,   mais   est
              ignorée  dans  les  autres cas. Par exception, si cette commande
              est suivie immédiatement  par  un  caractère  qui  n’est  ni  un
              chiffre  ni  le  signe  moins,  le  compteur  d’arguments  de la
              commande suivante est multiplié par 4. Le  compteur  d’arguments
              est  initialement  à  un,  donc  la  première exécution de cette
              commande amène le compteur d’arguments  à  quatre,  une  seconde
              fois porte le compteur d’arguments à seize et ainsi de suite.

   Complètement
       complete (TAB)
              Essayer  d’effectuer  un  complètement  du  texte situé avant le
              curseur. Bash effectue le complètement  en  considérant  tour  à
              tour  le  texte comme une variable (s’il commence par $), un nom
              d’utilisateur (s’il commence par ~), un  nom  de  machine  (s’il
              commence  par  @)  ou  une  commande (y compris les alias et les
              fonctions). Si aucun ne correspond, un complètement  de  nom  de
              fichier est essayé.
       possible-completions (M-?)
              Affiche les complètements possibles pour le texte situé avant le
              curseur.
       insert-completions (M-*)
              Insérer  avant  le  curseur  l’ensemble  des  complètements  qui
              auraient été produits par possible-completions.
       menu-complete
              Analogue  à  complete, mais en remplaçant le mot à compléter par
              une  seule  correspondance  de  la   liste   des   complètements
              possibles.  Des  exécutions répétées de menu-complete parcourent
              la  liste  des  complètements  possibles,  en  insérant   chaque
              correspondance   tour   à  tour.  À  la  fin  de  la  liste  des
              complètements, une alarme est émise (selon la  configuration  de
              bell-style)  et le texte original est restauré. Un argument de n
              déplace de n positions dans la  liste  des  correspondances.  Un
              argument  négatif peut être utilisé pour revenir en arrière dans
              la liste. Cette commande est  destinée  à  être  associée  à  la
              touche TAB, mais ne l’est pas par défaut.
       delete-char-or-list
              Effacer  le caractère sous le curseur sauf au début ou en fin de
              ligne (comme delete-char). En fin de ligne,  se  comporte  comme
              possible-completions.  Cette  commande  n’est  associée à aucune
              touche par défaut.
       complete-filename (M-/)
              Essayer le complètement des noms de fichiers sur le texte  situé
              avant le curseur.
       possible-filename-completions (C-x /)
              Afficher  les  complètements  possibles  du texte situé avant le
              curseur, traité comme un nom de fichier.
       complete-username (M-~)
              Essayer le complètement sur le texte situé avant le curseur,  en
              le traitant comme un nom d’utilisateur.
       possible-username-completions (C-x ~)
              Afficher  les  complètements  possibles  du texte situé avant le
              curseur, en le traitant comme un nom d’utilisateur.
       complete-variable (M-$)
              Essayer le complètement sur le texte situé avant le curseur,  en
              le traitant comme une variable de l’interpréteur.
       possible-variable-completions (C-x $)
              Afficher  les  complètements  possibles  du texte situé avant le
              curseur, en le traitant comme une variable de l’interpréteur.
       complete-hostname (M-@)
              Essayer le complètement sur le texte situé avant le curseur,  en
              le traitant comme un nom de machine.
       possible-hostname-completions (C-x @)
              Afficher  les  complètements  possibles  du texte situé avant le
              curseur, en le traitant comme un nom de machine.
       complete-command (M-!)
              Essayer le complètement sur le texte situé avant le curseur,  en
              le  traitant  comme  un  nom  de  commande.  Le complètement des
              commandes essaie de faire correspondre le texte, dans cet ordre,
              aux alias, mots réservés, fonctions de l’interpréteur, commandes
              internes de l’interpréteur et finalement les  noms  de  fichiers
              exécutables.
       possible-command-completions (C-x !)
              Afficher  les  complètements  possibles  du texte situé avant le
              curseur, en le traitant comme un nom de commande.
       dynamic-complete-history (M-TAB)
              Essayer le complètement du texte situé avant le curseur,  en  le
              comparant  aux  lignes de la file d’historique lui correspondant
              pour les complètements possibles.
       complete-into-braces (M-{)
              Effectuer un complètement en noms  de  fichiers  et  insérer  la
              liste  des  complètements  possibles entre accolades afin que la
              liste soit exploitable par  l’interpréteur  (voir  Développement
              des accolades plus haut).

   Macros clavier
       start-kbd-macro (C-x ()
              Démarre  la  mémorisation  dans la macro en cours des caractères
              tapés.
       end-kbd-macro (C-x ))
              Arrête la mémorisation dans la macro  en  cours  des  caractères
              saisis et conserve la définition.
       call-last-kbd-macro (C-x e)
              Ré-exécute  la  dernière macro définie, en agissant comme si les
              caractères contenus dans cette macro étaient saisis au  clavier.

   Divers
       re-read-init-file (C-x C-r)
              Lire  le  contenu  du  fichier inputrc et prendre en compte tous
              raccourcis ou affectations de variables qui s’y trouvent.
       abort (C-g)
              Abandonner l’édition en cours et émettre une alarme de  terminal
              (selon la configuration de la variable bell-style).
       do-uppercase-version (M-a, M-b, M-x, ...)
              Si  le caractère x précédé de Méta est en minuscule, exécuter la
              commande   qui   est   associée   aux   caractères    majuscules
              correspondants.
       prefix-meta (ESC)
              Considérer le prochain caractère saisi comme un Méta.  ESC f est
              équivalent à Meta-f.
       undo (C-_, C-x C-u)
              Fonction d’annulation incrémentale, chaque ligne étant mémorisée
              séparément.
       revert-line (M-r)
              Annuler  toutes  les  modifications  sur  cette  ligne. Ceci est
              équivalent à répéter undo en nombre suffisant  pour  ramener  la
              ligne à son état initial.
       tilde-expand (M-&)
              Effectuer le développement du tilde sur le mot courant.
       set-mark (C-@, M-<space>)
              Placer  la  marque  à  la  position  actuelle  du curseur. Si un
              argument numérique est fourni, la marque est posée à la position
              correspondante.
       exchange-point-and-mark (C-x C-x)
              Échanger  le  curseur  et  la  marque.  Le  position courante du
              curseur est mise  à  la  position  sauvegardée  précédemment  et
              l’ancienne position du curseur est mémorisée comme la marque.
       character-search (C-])
              Un  caractère  est  lu  et  le  curseur  déplacé  à l’occurrence
              suivante de ce caractère.  Un  argument  négatif  recherche  les
              occurrences précédentes.
       character-search-backward (M-C-])
              Un  caractère  est  lu  et  le  curseur  déplacé  à l’occurrence
              précédente de ce caractère. Un argument  négatif  recherche  les
              occurrences suivantes.
       insert-comment (M-#)
              Sans  argument numérique, la valeur de la variable comment-begin
              de readline est insérée au début de la  ligne  courante.  Si  un
              argument  numérique  est  fourni,  cette commande agit comme une
              bascule : si les caractères du début de ligne  ne  correspondent
              pas  à la valeur de comment-begin, la valeur est insérée, sinon,
              les caractères dans comment-begin sont effacés du  début  de  la
              ligne. Dans les deux cas, la ligne est acceptée comme si un saut
              de ligne avait été saisi. La valeur par défaut de  comment-begin
              conduit  cette  commande  à  transformer  la  ligne  courante de
              l’interpréteur en commentaire. Si un argument numérique  conduit
              à  l’effacement  du  caractère  de  commentaire,  la  ligne sera
              exécutée par l’interpréteur.
       glob-complete-word (M-g)
              Le mot avant le curseur  est  traité  comme  un  motif  pour  un
              développement   de  chemin,  avec  un  astérisque  implicitement
              ajouté. Ce motif est utilisé pour produire une liste de noms  de
              fichiers correspondants pour de possibles complètements.
       glob-expand-word (C-x *)
              Le  mot  précédant  le  curseur  est considéré comme un motif de
              développement de chemin et la liste des fichiers  correspondants
              est  insérée à sa place. Si un argument numérique est fourni, un
              astérisque est ajouté avant le développement du chemin.
       glob-list-expansions (C-x g)
              La  liste  des  développements  qui  aurait  été  produite   par
              glob-expand-word  est affichée et la ligne est rafraîchie. Si un
              argument numérique est fourni, un astérisque est  ajouté  devant
              le développement du chemin.
       dump-functions
              Afficher toutes les fonctions et leurs raccourcis clavier sur le
              flot de sortie de readline. Si un argument numérique est fourni,
              la  sortie  est mise en forme de façon à être incorporée dans un
              fichier inputrc.
       dump-variables
              Afficher toutes les  variables  readline  modifiables  et  leurs
              valeurs  sur  le  flot  de  sortie. Si un argument numérique est
              fourni, la sortie est mise en forme de façon qu’elle puisse être
              incorporée dans un fichier inputrc.
       dump-macros
              Afficher  toutes  les suites de touches readline associées à des
              macros et les chaînes  auxquelles  elles  correspondent.  Si  un
              argument numérique est fourni, la sortie est mise en forme d’une
              façon lui permettant d’être incorporée dans un fichier  inputrc.
       display-shell-version (C-x C-v)
              Afficher des informations sur la version courante de bash.

   Complètement programmable
       Lorsqu’un complètement de mot est tenté pour un argument d’une commande
       pour laquelle une  spécification  de  complètement  a  été  définie  en
       utilisant  la  commande  interne  complete  (voir  plus  bas  COMMANDES
       INTERNES DE L�’INTERPRÉTEUR ), les outils de complètement  programmables
       sont appelés.

       En  premier  lieu,  le  nom  de  la  commande  est  identifié.  Si  une
       spécification de complètement a été définie pour cette  commande,  elle
       est utilisée pour produire la liste des complètements possibles pour le
       mot. Si le mot de commande est un chemin d’accès complet, on cherche en
       premier  lieu  une spécification de complètement pour le chemin d’accès
       complet. Si aucune spécification de complètement n’est trouvée pour  le
       chemin  d’accès  complet,  une tentative est effectuée pour trouver une
       spécification de complètement pour la portion suivant la barre  oblique
       finale.

       Une  fois  qu’une spécification de complètement a été trouvée, elle est
       utilisée pour produire la liste  des  mots  correspondants.  Si  aucune
       spécification de complètement n’est trouvée, le complètement par défaut
       de bash, tel que décrit plus haut dans Complètement est effectué.

       Tout d’abord, les actions définies par la spécification de complètement
       sont  utilisées.  Seules  les correspondances qui sont préfixées par le
       mot à compléter sont renvoyées. Lorsque l’option -f ou -d est  utilisée
       pour le complètement des noms de fichiers ou de répertoire, la variable
       de   l’interpréteur   FIGNORE   est   utilisée   pour    filtrer    les
       correspondances.

       Tous  les  complètements spécifiés par le motif de développement de nom
       de  fichier  de  l’option  -G  sont  ensuite  produits.  Il  n’est  pas
       nécessaire  que  les  mots produits par le motif correspondent au mot à
       compléter. La variable de l’interpréteur GLOBIGNORE n’est pas  utilisée
       pour   filtrer  les  correspondances,  mais  la  variable  FIGNORE  est
       utilisée.

       Ensuite, la chaîne spécifiée comme argument à l’option -W est prise  en
       compte.  Cette  chaîne  est  tout  d’abord  découpée  en  utilisant les
       caractères de la variable spéciale IFS comme délimiteurs. La protection
       de  l’interprétation  est  prise  en  compte.  Chaque  mot  est ensuite
       développé en utilisant les développements d’accolades,  du  tilde,  des
       paramètres et des variables, de même que la substitution de commande et
       le   développement   arithmétique   comme   décrit   plus   haut   dans
       DÉVELOPPEMENTS.   Les  résultats  sont découpés en utilisant les règles
       décrites  plus  haut  dans  Découpage  en  mots.   Les   résultats   du
       développement  sont  comparés  au  mot  à  compléter  en considérant ce
       dernier  comme  préfixe  et  les  mots  correspondants  deviennent  les
       complètements possibles.

       Après  que  ces  correspondances  ont  été produites, toute fonction de
       l’interpréteur ou commande spécifiée avec les  options  -F  et  -C  est
       appelée.  Lorsque la commande ou la fonction est appelée, les variables
       COMP_LINE et COMP_POINT se voient affectées  de  valeurs  comme  décrit
       plus  haut  dans  Variables  de  l�’interpréteur.  Si  une  fonction  de
       l’interpréteur est appelée, les variables COMP_WORDS et COMP_CWORD sont
       également  créées.  Lorsqu’une fonction ou une commande est appelée, le
       premier argument est le nom de la commande dont les  arguments  doivent
       être  complétés,  le  second  argument  est  le  mot  à compléter et le
       troisième argument est le mot précédent celui devant être complété  sur
       la ligne de commande. Aucun filtrage des complètements produits pour le
       mot à compléter n’est effectué ; la fonction ou  la  commande  a  toute
       liberté dans la production des correspondances.

       Toute  fonction  spécifiée  avec -F est appelée en premier. La fonction
       peut utiliser tous les outils de l’interpréteur, incluant  la  commande
       interne  compgen  décrite  plus bas, pour produire les correspondances.
       Elle doit mettre les complètements possibles dans la  variable  tableau
       COMPREPLY.

       Ensuite,  toute commande spécifiée avec l’option -C est appelée dans un
       environnement équivalent à la substitution de  commande.  Elle  devrait
       afficher  une  liste des complètements possibles, une par ligne, sur la
       sortie standard. Si nécessaire, une contre-oblique peut  être  utilisée
       pour protéger un caractère de saut de ligne.

       Après  que  tous  les  complètements  possibles  ont été produits, tout
       filtre, spécifié avec l’option -X, est appliqué à la liste.  Ce  filtre
       est  un  motif  comme  utilisé dans le développement des chemins ; un &
       dans  le  motif  est  remplacé  par  le  texte  du  mot  en  cours   de
       complètement.  Un & littéral peut être protégé par une contre-oblique ;
       la  contre-oblique  est  supprimée  avant  la  tentative  de  mise   en
       correspondance. Tout complètement qui correspond au motif sera supprimé
       de la liste. Un ! au début du motif provoque la négation de ce  motif ;
       dans  ce  cas,  tout  complètement  ne  correspondant pas au motif sera
       supprimé de la liste.

       Finalement, tous préfixe et suffixe spécifiés avec les options -P et -S
       sont  ajoutés  à  chacun des éléments de la liste de complètement et le
       résultat est renvoyé au programme de  complètement  de  readline  comme
       étant la liste des complètements possibles.

       Si   les   opérations  précédemment  appliquées  ne  produisent  aucune
       correspondance et si l’option -o dirnames  a  été  fournie  à  complete
       lorsque la spécification de complètement a été définie, le complètement
       des noms de répertoire est tenté.

       Si l’option -o plusdirs a été fournie à complete lors de la  définition
       de  la  spécification  de  complètement,  le  complètement  des noms de
       répertoires est tenté et toute correspondance est ajoutée aux résultats
       des autres actions.

       Par  défaut,  si une spécification de complètement est trouvée, tout ce
       qu’elle produit est renvoyé au programme de complètement comme  un  jeu
       complet  des  complètements  possibles. Les complètements par défaut de
       bash ne sont pas tentés et le complètement par défaut de readline ou le
       complètement de fichiers est déactivé. Si l’option -o bashdefault a été
       fournie à complete  lors  de  la  définition  de  la  spécification  de
       complètement,  les  complètements  par défaut de bash sont tentés si la
       spécification de complètement  ne  produit  aucune  correspondance.  Si
       l’option  -o  default a été fournie à complete lors de la définition de
       la  spécification  de  complètement,  le  complètement  par  défaut  de
       readline  sera  effectué  si  la  spécification de complètement (et, si
       tentés, les complètements par défaut de bash)  ne  produise(nt)  aucune
       correspondance.

       Lorsqu’une  spécification de complètement indique qu’un complètement de
       nom  de  répertoire  est  souhaité,  les  fonctions   de   complètement
       programmable   forcent  readline  à  ajouter  une  barre  oblique  pour
       compléter les noms qui sont des liens symboliques vers des répertoires,
       selon   la   valeur   de  la  variable  mark-directories  de  readline,
       indépendamment du paramétrage de la variable mark-symlinked-directories
       de readline.

HISTORIQUE

Quand l’option -o history de la commande interne set est activée,
l’interpréteur donne accès à un historique des commandes, c’est-à-dire
la liste des commandes précédemment utilisées. La valeur de la variable
HISTSIZE est utilisée comme le nombre de commandes à sauvegarder dans
la file d’historique. Le texte des HISTSIZE dernières commandes (par
défaut 500) est sauvegardé. L’interpréteur conserve chaque commande
dans la file d’historique avant le développement des paramètres et des
variables (voir DÉVELOPPEMENTS plus haut) mais après avoir effectué le
développement de l’historique, selon les valeurs des variables de
l’interpréteur HISTIGNORE et HISTCONTROL.

Au démarrage, l’historique est initialisé avec le fichier dont le nom
est contenu dans la variable HISTFILE (par défaut ~/.bash_history). Le
fichier désigné par la valeur de HISTFILE est tronqué si nécessaire,
pour ne pas contenir plus de lignes que le nombre spécifié par
HISTFILESIZE. Lorsqu’un interpréteur interactif termine, les HISTSIZE
dernières lignes de la file d’historique sont copiées dans le fichier
HISTFILE. Si l’option d’interpréteur histappend est activée (voir plus
bas la description de shopt dans COMMANDES INTERNES DE L�’INTERPRÉTEUR
), les lignes sont ajoutées au fichier d’historique, sinon le fichier
est écrasé. Si HISTFILE est inexistante ou si le fichier d’historique
n’est pas accessible en écriture, l’historique n’est pas sauvegardé.
Après la sauvegarde de l’historique, le fichier d’historique est
tronqué pour ne pas contenir plus de HISTFILESIZE lignes. Si
HISTFILESIZE n’existe pas, aucune troncature n’est effectuée.

La commande interne fc (voir plus bas COMMANDES INTERNES DE
L�’INTERPRÉTEUR ) permet d’afficher, d’éditer ou de ré-exécuter une
partie de la file d’historique. La commande interne history permet
d’afficher la file d’historique et de manipuler le fichier
d’historique. Quelque soit le mode d’édition en ligne de commande, des
commandes de recherche donnent accès à la file d’historique.

L’interpréteur permet de configurer quelles commandes seront
sauvegardées dans la file d’historique. Les variables HISTCONTROL et
HISTIGNORE peuvent être configurées pour conduire l’interpréteur à ne
sauvegarder qu’un sous-ensemble des commandes saisies. L’option
d’interpréteur cmdhist, si activée, conduit l’interpréteur à essayer de
sauvegarder chaque ligne d’une commande multiligne dans le même élément
de l’historique, en ajoutant des points-virgules si nécessaire pour
préserver l’exactitude de la syntaxe. L’option d’interpréteur lithist
conduit l’interpréteur à sauvegarder les commandes avec des sauts de
lignes incorporés plutôt que des points-virgules. Voir plus bas la
description de la commande interne shopt dans COMMANDES INTERNES DE
L�’INTERPRÉTEUR pour des détails sur la création et la destruction des
options d’interpréteur.

DÉVELOPPEMENT DE L�’HISTORIQUE
L’interpréteur propose des possibilités de développement de
l’historique qui sont semblables à celles de csh. Ce paragraphe décrit
quelles syntaxes sont disponibles. Cette fonctionnalité est activée par
défaut dans les interpréteurs interactifs et peut être désactivée en
utilisant l’option +H de la commande interne set (voir plus bas
COMMANDES INTERNES DE L�’INTERPRÉTEUR ). Les interpréteurs non
interactifs n’effectuent pas de développement d’historique par défaut.

Le développement de l’historique permet d’insérer des mots de la file
d’historique dans le flot de saisie, facilitant la répétition de
commandes, l’insertion des arguments d’une ligne antérieure dans la
saisie en cours ou la correction rapide d’erreurs dans les commandes
précédentes.

Le développement de l’historique est effectué immédiatement après la
lecture d’une ligne complète, avant que l’interpréteur ne la décompose
en mots. Il se déroule en deux parties. La première consiste à
déterminer la ligne de la file d’historique à utiliser pour les
substitutions, la seconde permet de sélectionner les parties de la
ligne à inclure dans la nouvelle ligne. La ligne sélectionnée dans
l’historique est l’��v��nement et les parties de cette ligne à réutiliser
sont des mots. Plusieurs modificateurs permettent de manipuler les mots
sélectionnés. La ligne est découpée en mots de la même façon que lors
de la lecture d’une saisie, ainsi plusieurs mots séparés par des
m��tacaract��res et encadrés par des guillemets simples sont considérés
comme un unique mot. Le développement de l’historique est introduit par
l’apparition du caractère de développement, qui est ! par défaut. Seule
la contre-oblique (\) et les guillemets simples permettent de protéger
le caractère de développement de l’historique.

Plusieurs caractères empêchent le développement de l’historique s’ils
se trouvent immédiatement après le caractère de développement de
l’historique, même s’il n’est pas protégé : espace, tabulation, saut de
ligne, retour-chariot et =. Si l’option d’interpréteur extglob est
activée, ( empêchera aussi le développement.

Plusieurs options d’interpréteur, configurables avec la commande
interne shopt permettent d’ajuster le comportement de le développement
de l’historique. Si l’option d’interpréteur histverify est activée
(voir la description de la commande interne shopt) et si readline est
utilisée, les substitutions d’historiques ne sont pas transmises tout
de suite à l’analyseur de l’interpréteur. À la place, la ligne
développée est rechargée dans la mémoire tampon de readline pour
permettre des modifications ultérieures. Si readline est utilisée et si
l’option histreedit est activée, une substitution d’historique qui
échoue est rechargée dans la mémoire tampon de readline pour
correction. L’option -p de la commande interne history peut servir à
examiner ce qu’une substitution donnera avant de l’employer réellement.
L’option -s de la commande interne history permet d’ajouter des
commandes à la fin de la file d’historique sans les avoir effectivement
exécutées, afin qu’elles soient disponibles pour des rappels
ultérieurs.

L’interpréteur offre le contrôle des divers caractères utilisés par le
mécanisme de développement de l’historique (voir la description de
histchars plus haut dans Variables de l�’interpréteur).

Indicateur d�’événement
Un indicateur d’événement est une référence à un élément ligne de
commande dans la file d’historique.

! Débute une substitution d’historique, sauf s’il est suivi par un
blanc, saut de ligne, retour-chariot, = ou ( (lorsque l’option
d’interpréteur extglob est activée en utilisant la commande
interne shopt).
!n Se rapporte à la ligne de commande n.
!-n Se rapporte à la ligne de commande courante moins n.
!! Se rapporte à la commande précédente. C’est un synonyme de
« !-1 ».
!cha��ne
Se rapporte à la plus récente commande commençant par cha��ne.
!?cha��ne[?]
Se rapporte à la plus récente commande contenant cha��ne. Le ?
final peut être omis si cha��ne est immédiatement suivie d’un
saut de ligne.
^cha��ne_1^cha��ne_2^
Substitution rapide. Répéter la dernière commande en remplaçant
cha��ne_1 par cha��ne_2. Équivalent à « !!:s/cha��ne_1/cha��ne_2/ »
(voir Modificateurs plus bas).
!# La ligne entière tapée jusqu’à présent.

Indicateurs de mots
Ces indicateurs servent à sélectionner les mots désirés dans un
événement. Un : sépare l’indicateur d’événements de l’indicateur de
mot. On peut l’omettre si l’indicateur de mot commence par ^, $, *, -
ou %. Les mots sont numérotés depuis le début de la ligne, le premier
étant noté 0 (zéro). Les mots sont insérés dans la ligne courante,
séparés par des espaces.

0 (zéro)
Le zéro-ième mot. Pour l’interpréteur, c’est le nom de la
commande.
n Le n-ième mot.
^ Le premier argument, c’est-à-dire le mot 1.
$ Le dernier argument.
% Le mot correspondant à la recherche « ?cha��ne? » la plus
récente.
x-y Une plage de mots, « -y » permet d’abréger « 0-y ».
* Tous les mots sauf le zéro-ième. C’est un synonyme pour « 1-$ ».
Il n’est pas erroné d’utiliser * s’il n’y a qu’un mot dans
l’événement ; la chaîne vide est renvoyée dans ce cas.
x* Abréviation de x-$.
x- Abréviation de x-$ comme x*, mais sans le dernier mot.

Si un indicateur de mot est fourni sans indication d’événement, la
dernière commande est utilisée.

Modificateurs
Après un indicateur de mot facultatif, une suite d’un ou plusieurs des
modificateurs suivants peut apparaître, chacun précédé par un « : ».

h Élimine la fin du chemin d’accès, ne laissant que son début.
t Supprimer tout le début d’un chemin d’accès, en ne laissant que
la fin.
r Supprime un suffixe final de la forme .xxx, en ne laissant que
le nom de base.
e Tout supprimer sauf le suffixe final.
p Afficher la nouvelle commande sans l’exécuter.
q Protéger les mots substitués, pour éviter des substitutions
futures.
x Protéger les mots substitués comme avec q, mais en séparant des
mots aux blancs et aux sauts de ligne.
s/ancien/nouveau/
Remplacer par nouveau la première occurrence de ancien sur la
ligne d’événement. Tout délimiteur peut être utilisé à la place
de /. Le dernier délimiteur est facultatif si c’est le dernier
caractère de la ligne d’événement. Le délimiteur peut être
protégé dans ancien et nouveau avec une seule contre-oblique. Si
& apparaît dans nouveau, il est remplacé par ancien. Une seule
contre-oblique protégera le &. Si ancien est vide, il est mis au
dernier ancien substitué ou si aucune substitution n’a eu lieu
précédemment, la dernière cha��ne dans une recherche !?cha��ne[?].
& Répéter la substitution précédente.
g Conduit à l’application des changements sur la ligne d’événement
entière. Ceci est utilisé conjointement à « :s » (par exemple
« :gs/ancien/nouveau/ ») ou « :& ». Si utilisé avec « :s », tout
délimiteur peut être utilisé à la place de / et le dernier
délimiteur est facultatif si c’est le dernier caractère de la
ligne d’événement. Un a peut être utilisé en tant que synonyme
de g.
G Appliquer le modificateur « s » suivant une fois à chacun des
mots dans la ligne d’événements.

COMMANDES INTERNES DE L�’INTERPRÉTEUR
Sauf indication contraire, chaque commande interne décrite dans ce
paragraphe comme acceptant des options précédées de - accepte également
la notation -- pour signifier la fin des options. Par exemple, les
commandes internes :, true, false et test n’acceptent aucune option.
: [arguments]
Sans effet ; cette commande ne fait rien d’autre que développer
les arguments et effectuer toute redirection spécifiée. Un code
final de zéro est renvoyé.

. fichier [arguments]
source fichier [arguments]
Lire et exécuter les commandes contenues dans fichier avec
l’environnement de l’interpréteur courant, puis renvoyer l’état
final de la dernière commande exécutée dans fichier. Si le nom
du fichier ne contient pas de barre oblique, les chemins d’accès
contenus dans PATH sont parcourus pour rechercher le répertoire
contenant le fichier. Lorsqu’il est recherché dans PATH le
fichier n’a pas besoin d’être exécutable. Lorsque bash n’est pas
en mode posix, le répertoire de travail courant est finalement
examiné si aucun fichier n’est trouvé dans PATH. Si l’option
sourcepath de la commande interne shopt est désactivée, le PATH
n’est pas parcouru. Si des arguments sont fournis, ils sont
transmis dans les paramètres positionnels lorsque le fichier est
exécuté. Sinon les paramètres positionnels ne sont pas modifiés.
L’état renvoyé est l’état de la dernière commande terminée au
sein du script (0 si aucune commande n’a été exécutée) et faux
si le fichier n’est pas trouvé ou ne peut être lu.

alias [-p] [nom[=valeur] ...]
La commande alias sans argument ou avec l’option -p affiche sur
la sortie standard la liste des alias actuellement définis, sous
la forme nom=valeur. Lorsque des arguments sont fournis, un
alias est créé pour chaque nom auquel on a donné une valeur. Une
espace finale dans une valeur conduira à la recherche d’alias
dans le mot suivant lors du développement de l’alias. Pour
chacun des noms pour lesquels aucune valeur n’est fournie dans
la liste d’arguments, le nom et la valeur de l’alias sont
affichés. La commande alias renvoie vrai, à moins qu’ait été
indiqué un nom pour lequel aucun alias n’a été défini.

bg [t��che ...]
Reprend en arrière-plan chaque t��che suspendue, comme si elle
avait été lancée avec &. Si aucune t��che n’est précisée, la
notion d’interpréteur de t��che courante est utilisée. bg t��che
renvoie 0 à moins que le contrôle des tâches soit désactivé, ou,
quand le contrôle des tâches est activé, qu’une t��che spécifiée
n’ait pas été trouvée ou ait été lancée sans contrôle de tâches.

bind [-m jeu_de_raccourcis] [-lpsvPSV]
bind [-m jeu_de_raccourcis] [-q fonction] [-u fonction] [-r
suite_de_touches]
bind [-m jeu_de_raccourcis] -f fichier
bind [-m jeu_de_raccourcis] -x
suite_de_touches:commande_de_l���interpr��teur
bind [-m jeu_de_raccourcis] suite_de_touches:nom_de_fonction
bind commande_readline
Affiche les associations de touches readline courantes et les
raccourcis de fonctions, associe une suite de touches à une
fonction ou une macro readline ou crée une variable readline.
Chaque argument qui n’est pas une option est une commande comme
elle devrait apparaître dans .inputrc, mais chaque raccourci ou
commande doit être fourni comme un argument indépendant ; par
exemple « "\C-x\C-r": re-read-init-file ». Les options, si
fournies, ont les significations suivantes :
-m jeu_de_raccourcis
Utiliser le jeu_de_raccourcis comme jeu de raccourcis
devant être concerné par les raccourcis ultérieurs. Les
noms de jeux_de_raccourcis possibles sont emacs,
emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
vi-command et vi-insert. vi est équivalent à vi-command ;
emacs est équivalent à emacs-standard.
-l Afficher la liste des noms de toutes les fonctions
readline.
-p Affiche les noms des fonctions readline et leurs
raccourcis de façon à pouvoir les relire.
-P Affiche les noms des fonctions readline et leurs
raccourcis.
-v Affiche les noms des variables readline et leurs valeurs
de façon à pouvoir les relire.
-V Affiche les noms des variables readline et leurs valeurs.
-s Afficher les suites de touches readline associées aux
macros et les chaînes correspondantes, de façon à pouvoir
les relire.
-S Afficher les suites de touches readline associées aux
macros et les chaînes correspondantes.
-f fichier
Lire les raccourcis clavier dans fichier.
-q fonction
Rechercher les touches permettant d’appeler la fonction
indiquée.
-u fonction
Dissocier toutes les touches associées à fonction.
-r suite_de_touches
Supprimer tout raccourci courant pour la
suite_de_touches.
-x suite_de_touches:commande_de_l���interpr��teur
Conduit à l’exécution de commande_de_l���interpr��teur dès
que la suite de touches est saisie.

La valeur renvoyée est 0, à moins qu’une option inconnue soit
indiquée ou qu’une erreur se soit produite.

break [n]
Sortir d’une boucle for, while, until ou select. Si n est
spécifié, sortir de n niveaux de boucles. n doit être ≥ 1. Si n
est supérieur au nombre de boucles imbriquées, on sort de
l’ensemble d’entre elles. La valeur renvoyée est 0, à moins que
l’interpréteur ne soit pas en train d’exécuter une boucle
lorsque break est exécuté.

builtin commande_interne [arguments]
Exécuter la commande interne de l’interpréteur indiquée, en lui
passant les arguments, puis renvoyer son état final. Ceci est
utile lorsqu’on définit une fonction ayant le même nom qu’une
commande interne, mais qu’on a besoin d’appeler cette commande
depuis l’intérieur de la fonction. On redéfinit souvent la
commande interne cd de cette façon. L’état renvoyé est faux si
la commande_interne n’est pas une commande interne de
l’interpréteur.

cd [-L|-P] [r��p]
Remplacer le répertoire de travail courant par r��p. La variable
HOME est la valeur par défaut de r��p. La variable CDPATH définit
des chemins de recherche pour trouver le répertoire contenant
r��p. Les répertoires possibles y sont fournis dans une liste
séparées par des deux-points « : ». Un nom de répertoire vide
dans CDPATH est équivalent au répertoire courant, c’est-à-dire
« . ». Si r��p commence par une barre oblique (/), alors CDPATH
n’est pas utilisé. L’option -P dit de n’employer que la
structure de répertoires physiques au lieu de suivre les liens
symboliques (voir aussi l’option -P de la commande interne set)
l’option -L force à suivre les liens symboliques. Un argument -
est équivalent à $OLDPWD. Si un nom de répertoire non vide de
CDPATH est utilisé ou si - est le premier argument et si le
changement de répertoire réussit, le chemin absolu du nouveau
répertoire de travail est écrit sur la sortie standard. La
valeur renvoyée est vrai si le changement de répertoire a
réussi ; faux sinon.

caller [expr]
Renvoie le contexte de tout appel de sous-programme actif (une
fonction de l’interpréteur ou un script lancé avec les commandes
internes . ou source). Sans expr, caller affiche le numéro de
ligne et le nom de fichier du sous-programme courant. Si un
entier positif est fourni comme expr, caller affiche le numéro
de ligne, le nom du sous-programme et le nom de fichier source
correspondant à la position dans la pile d’appels d’exécution
courante. Cette information supplémentaire peut être utilisée,
par exemple, pour afficher une trace de la pile. La trame
courante est la trame 0. La valeur renvoyée est 0, à moins que
l’interpréteur ne soit pas en train d’exécuter un sous-programme
ou que expr ne corresponde pas à une position correcte dans la
pile d’appels.

command [-pVv] commande [arguments ...]
Lancer la commande avec les arguments indiqués, mais en
simplifiant le processus habituel de recherche des commandes.
Seules les commandes internes et les commandes trouvées dans
PATH seront exécutées. Si l’option -p est indiquée, la recherche
de la commande est effectuée en utilisant une valeur par défaut
pour PATH garantissant de trouver tous les utilitaires
standards. Si soit l’option -V soit l’option -v est fournie, une
description de la commande est affichée. L’option -v conduit à
n’afficher qu’un seul mot indiquant la commande ou le nom de
fichier utilisé pour appeler la commande. L’option -V fournit
une description plus prolixe. Si l’option -V ou -v est fournie,
l’état final est 0 si la commande a été trouvée et 1 sinon. Si
aucune option n’est fournie et si une erreur s’est produite ou
si la commande ne peut être trouvée, l’état final est 127.
Sinon, l’état final de la commande interne est l’état final de
commande.

compgen [option] [mot]
Produit les correspondances des complètements possibles pour mot
selon les options, qui peuvent être toute option acceptée par la
commande interne complete à l’exception de -p et -r et écrit le
résultat sur la sortie standard. Lorsqu’on utilise les options
-F ou -C, les diverses variables de l’interpréteur créées par
les outils de complètement programmables, lorsque disponibles,
n’auront pas de valeurs utilisables.

Les correspondances seront produites de la même façon que si le
programme de complètement programmable les avait produites
directement à partir d’une spécification de complètement avec
les mêmes attributs. Si mot est spécifié, seules les
complètements qui correspondent à mot sont affichés.

La valeur renvoyée est vrai, à moins qu’une option incorrecte
ait été fournie ou qu’aucune correspondance n’ait été produite.

complete [-abcdefgjksuv] [-o option-compl��tement] [-A action] [-G
globpat] [-W liste_de_mots] [-P prefix] [-S suffix]
[-X motif_filtre] [-F fonction] [-C commande] nom [nom ...]
complete -pr [nom ...]
Spécifie comment les arguments de chaque nom doivent être
complétés. Si l’option -p est fournie ou si aucune option n’est
fournie, les spécifications de complètement existantes sont
affichées de telle façon qu’elles puissent être réutilisées
comme entrée. L’option -r retire une spécification de
complètement à chaque nom fourni ou, si aucun nom n’est fourni,
toutes les spécifications de complètement.

Le processus d’application de ces spécifications de complètement
lorsqu’un complètement de mot est tenté est décrit plus haut
dans Complètement programmable.

Les autres options, si spécifiées, ont les significations
suivantes. Les arguments des options -G, -W et -X (et, si
nécessaire, les options -P et -S) devraient être protégées pour
leur éviter le développement avant que la commande interne
complete soit appelée.
-o option-compl��tement
L’option-compl��tement commande plusieurs aspects du
comportement des spécifications de complètement au-delà
de la simple production de complètement.
option-compl��tement peut être l’une des suivantes :
bashdefault
Effectuer le reste des complètements par défaut
de bash si la spécification de complètement ne
produit aucune correspondance.
default Utiliser le complètement de nom de fichier par
défaut de readline si la spécification de
complètement ne produit aucune correspondance.
dirnames
Effectuer le complètement de nom de répertoire
si la spécification de complètement ne produit
aucune correspondance.
filenames
Indiquer à readline que la spécification de
complètement produit des noms de fichiers, ainsi
il peut effectuer tout traitement spécifique aux
noms de fichiers (comme ajouter une barre
oblique aux noms de répertoires, supprimer les
espaces de fin de ligne). Destinée à être
utilisée avec les fonctions de l’interpréteur.
nospace Indiquer à readline de ne pas ajouter une espace
(comportement par défaut) aux mots complétés en
fin de ligne.
plusdirs
Après que toutes les correspondances définies
par la spécification de complètement ont été
produites, une tentative de complètement de nom
de répertoire est effectuée et toutes les
correspondances sont ajoutées aux résultats des
autres actions.
-A action
L’action peut être l’une des suivantes pour produire une
liste des complètements possibles :
alias Noms d’alias. Peut également être spécifiée avec
-a.
arrayvar
Noms des variables de type tableau.
binding Noms des raccourcis clavier readline.
builtin Noms des commandes internes de l’interpréteur.
Peut également être spécifiée avec -b.
command Nom des commandes. Peut également être spécifiée
avec -c.
directory
Noms des répertoires. Peut également être
spécifiée avec -d.
disabled
Noms des commandes internes de l’interpréteur
désactivées.
enabled Noms des commandes internes de l’interpréteur
activées.
export Noms des variables de l’interpréteur exportées.
Peut également être spécifiée avec -e.
file Noms des fichiers. Peut également être spécifiée
avec -f.
function
Noms des fonctions de l’interpréteur.
group Noms des groupes. Peut également être spécifiée
avec -g.
helptopic
Sujets de l’aide acceptés par la commande
interne help.
hostname
Noms de machines tels qu’ils sont extraits du
fichier spécifié par la variable de
l’interpréteur HOSTFILE.
job Noms des tâches si le contrôle des tâches est
actif. Peut également être spécifiée avec -j.
keyword Mots réservés de l’interpréteur. Peut également
être spécifiée avec -k.
running Noms des tâches en cours d’exécution si le
contrôle des tâches est actif.
service Noms des services. Peut également être spécifiée
avec -s.
setopt Arguments corrects de l’option -o de la commande
interne set.
shopt Noms des options d’interpréteur acceptées par la
commande interne shopt.
signal Noms des signaux.
stopped Noms des tâches suspendues si le contrôle des
tâches est actif.
user Noms des utilisateurs. Peut également être
spécifiée avec -u.
variable
Noms de toutes les variables de l’interpréteur.
Peut également être spécifiée avec -v.
-G globpat
Le motif de développement des noms de fichiers globpat
est développé pour produire les complètements possibles.
-W liste_de_mots
La liste_de_mots est découpée en utilisant les
caractères de la variable spéciale IFS comme délimiteurs
et chaque mot résultant est développé. Les complètements
possibles sont les éléments de la liste résultante qui
correspondent au mot en cours de complètement.
-C commande
La commande est exécutée dans un environnement de
sous-interpréteur et sa sortie est utilisée comme
complètements possibles.
-F fonction
La fonction de l’interpréteur est exécutée dans
l’interpréteur courant. Lorsqu’elle finit, les
complètements possibles sont récupérés à partir de la
valeur de la variable de type tableau COMPREPLY.
-X motif_filtre
motif_filtre est un motif utilisé pour le développement
des noms de fichiers. Il est appliqué à la liste des
complètements possibles produite par les options et
arguments précédents et chaque complètement
correspondant à motif_filtre est supprimé de la liste.
Un ! au début du motif_filtre inverse le motif ; dans ce
cas, tout complètement qui ne correspond pas à
motif_filtre est supprimé.
-P prefix
prefix est ajouté au début de chaque complètement
possible après que toutes les autres options ont été
appliquées.
-S suffix
suffix est ajouté à chaque complètement possible après
que toutes les autres options ont été appliquées.

La valeur renvoyée est vrai, à moins qu’une option incorrecte
ait été fournie, qu’une option comme -p ou -r ait été fournie
sans un nom d’argument, qu’une tentative ait été faite pour
supprimer une spécification de complètement pour un nom pour
lequel il n’existe pas de spécification, ou bien qu’une erreur
soit survenue lors de l’ajout d’une spécification de
complètement.

continue [n]
Reprendre l’exécution à l’itération suivante d’une boucle for,
while, until ou encore select. Si n est indiqué, reprendre
l’exécution à la n-ième boucle imbriquée. n doit être ≥ 1. Si n
est supérieur au nombre de boucles imbriquées, l’exécution
reprend à la boucle la plus externe (la boucle « au sommet »).
La valeur renvoyée est 0, à moins que l’interpréteur ne soit pas
en train d’exécuter une boucle lorsqu’il rencontre l’instruction
continue.

declare [-afFirtx] [-p] [nom[=valeur] ...]
typeset [-afFirtx] [-p] [nom[=valeur] ...]
Déclarer des variables et/ou leur fournir des attributs. Si
aucun nom n’est indiqué alors afficher les valeurs des
variables. L’option -p affichera les attributs et les valeurs de
chaque nom. Quand -p est utilisée, les options supplémentaires
sont ignorées. L’option -F empêche l’affichage des définitions
de fonctions ; seuls le nom de la fonction et ses attributs sont
affichés. Si l’option d’interpréteur extdebug est activée en
utilisant shopt, le nom du fichier source et le numéro de ligne
où la fonction est définie sont aussi affichés. L’option -F
implique -f. Les options suivantes permettent de restreindre
l’affichage aux variables dotées de certains attributs ou de
fixer les attributs des variables :
-a Chaque nom est une variable de type tableau (voir
Tableaux plus haut).
-f Utiliser seulement les noms de fonctions.
-i La variable est traitée comme un entier ; l’évaluation
arithmétique (voir ÉVALUATION ARITHMÉTIQUE) est effectuée
lorsqu’une valeur est affectée à la variable.
-r Rend les noms accessibles en lecture seule. Des valeurs
ne pourront alors plus être affectées à ces noms par des
affectations ultérieures. Ils ne pourront pas non plus
être détruits.
-t Donne à chaque nom l’attribut trace. Les fonctions
tracées héritent des captures de DEBUG et RETURN de
l’interpréteur appelant. L’attribut trace n’a pas de
signification spéciale pour les variables.
-x Marque les noms pour qu’ils soit exportés dans
l’environnement des commandes ultérieures.

En utilisant « + » à la place de « - », l’attribut correspondant
est désactivé, à l’exception que +a ne peut pas être utilisé
pour détruire une variable tableau. Quand utilisé dans une
fonction, chacun des noms devient local, comme avec la commande
local. Si un nom de variable est suivi par =valeur, la valeur de
cette variable est mise à valeur. La valeur renvoyée est 0, à
moins qu’une option incorrecte soit rencontrée, qu’une tentative
soit faite de définir une fonction en utilisant ‘‘-f foo=bar’’,
qu’une tentative soit faite d’affecter une valeur à une variable
en lecture seule, qu’une tentative soit faite d’affecter une
valeur à une variable tableau sans employer la syntaxe
d’affectation composée (voir Tableaux plus haut), qu’un des noms
ne soit pas un nom correct pour une variable de l’interpréteur,
qu’une tentative soit faite de supprimer l’attribut
lecture-seule d’une variable en lecture seule, ou qu’une
tentative soit faite de supprimer l’attribut tableau d’une
variable tableau, ou qu’une tentative soit faite avec -f
d’afficher une fonction inexistante.

dirs [-clpv] [+n] [-n]
Affiche la liste des répertoires actuellement mémorisés.
L’affichage par défaut se fait sur une seule ligne, les noms de
répertoires étant séparés par des espaces. On ajoute des
répertoires dans cette liste avec la commande pushd et on peut
en supprimer avec la commande popd.
+n Affiche le n-ième élément de la liste fournie par dirs,
lorsqu’appelé sans options, en comptant à partir de la
gauche en commençant à zéro.
-n Affiche le n-ième élément de la liste fournie par dirs,
lorsqu’appelé sans options, en comptant à partir de la
droite en commençant à zéro.
-c Effacer la liste des répertoires en les supprimant tous.
-l Produit une liste plus longue ; le format d’affichage par
défaut utilise le tilde pour représenter le répertoire
d’accueil.
-p Afficher la pile des répertoires avec un élément par
ligne.
-v Afficher la pile des répertoires avec un élément par
ligne, en préfixant chaque entrée avec son numéro
d’indice dans la pile.

La valeur renvoyée est 0, à moins qu’une option incorrecte ait
été fournie ou que l’indice n dépasse la longueur de la pile des
répertoires.

disown [-ar] [-h] [t��che ...]
Sans options, chaque t��che est supprimée de la table des tâches
actives. Si l’option -h est indiquée, chaque t��che n’est pas
supprimée de la table mais marquée pour que le signal SIGHUP ne
lui soit pas envoyé si l’interpréteur reçoit un signal SIGHUP.
Si aucune t��che n’est indiquée et que ni l’option -a ni l’option
-r n’est fournie, la t��che courante est concernée. Si aucune
t��che n’est fournie, l’option -a signifie la suppression ou le
marquage de toutes les tâches ; l’option -r sans l’argument
t��che restreint les opérations aux tâches en cours d’exécution.
La valeur renvoyée est 0, à moins que t��che ne spécifie pas une
tâche correcte.

echo [-neE] [arguments ...]
Affiche les arguments, séparés par des espaces, suivis par un
saut de ligne. La valeur renvoyée est toujours 0. Si -n est
spécifié, le saut de ligne final est supprimé. Si l’option -e
est indiquée, l’interprétation des caractères suivants
d’échappement par une contre-oblique est activée. L’option -E
désactive l’interprétation de ces caractères d’échappement, même
sur les systèmes où ils sont interprétés par défaut. L’option
d’interpréteur xpg_echo peut être utilisée dynamiquement pour
déterminer si echo développe ou non par défaut ces caractères
d’échappement. echo n’interprète pas -- comme signifiant la fin
des options. echo reconnaît les suites de caractères
d’échappement suivantes :
\a alerte (alarme)
\b effacement arrière (backspace)
\c suppression du saut de ligne final
\e caractère d’échappement
\f saut de page (form feed)
\n saut de ligne (new line)
\r retour chariot (carriage return)
\t tabulation horizontale
\v tabulation verticale
\\ contre-oblique
\0nnn le caractère 8 bits dont la valeur en octal vaut nnn
(zéro à trois chiffres octaux)
\xHH le caractère 8 bits dont la valeur hexadécimale est HH
(un à deux symboles hexadécimaux)

enable [-adnps] [-f fichier] [nom ...]
Active ou désactive les commandes internes de l’interpréteur.
Désactiver une commande interne permet d’exécuter une commande
disque ayant le même nom qu’une commande interne de
l’interpréteur, sans avoir à spécifier un chemin d’accès
complet, même quand l’interpréteur recherche normalement les
commandes internes avant les commandes du disque. Si -n est
utilisé, chaque nom indiqué est désactivé, sinon ils sont
activés. Par exemple, pour utiliser le programme binaire test
qui se trouve dans PATH plutôt que la commande interne, utilisez
‘‘enable -n test’’. L’option -f demande de charger la nouvelle
commande interne avec le nom indiqué depuis le fichier objet
partagé sur les systèmes qui le permettent. L’option -d permet
de supprimer une commande interne chargée précédemment avec -f.
Si aucun argument nom n’est indiqué ou si l’option -p est
fournie, une liste des commandes internes de l’interpréteur est
affichée. Sans autre option, la liste est celle des commandes
internes actives de l’interpréteur. Si -n est fournie, seules
les commandes désactivées sont affichées. Si -a est fournie, la
liste de toutes les commandes est affichée, avec une indication
des activations et inactivations. Si -s est fournie, la sortie
est limitée aux commandes internes sp��ciales POSIX. La valeur
renvoyée est 0, à moins que nom ne soit pas une commande interne
ou qu’il y ait une erreur au chargement d’une nouvelle commande
interne d’un objet partagé.

eval [arguments ...]
Les arguments sont lus et regroupés en une seule commande
simple. Cette commande est alors lue et exécutée par
l’interpréteur et son état final est renvoyé comme valeur de la
commande eval. S’il n’y a pas d’arguments ou uniquement des
arguments vides, eval renvoie 0.

exec [-cl] [-a nom] [commande [arguments]]
Si une commande est indiquée, elle remplace l’interpréteur.
Aucun nouveau processus n’est créé. Les arguments deviennent
ceux de la commande. Si l’option -l est fournie, l’interpréteur
place un tiret en guise de zéro-ième argument fourni a la
commande. C’est ce que fait login. L’option -c conduit à
l’exécution de la commande avec un environnement vide. Si
l’option -a est fournie, l’interpréteur transmet le nom comme
zéro-ième argument. Si la commande ne peut être exécutée pour
une certaine raison, un interpréteur non interactif termine, à
moins que l’option de l’interpréteur execfail soit activée,
auquel cas une erreur est renvoyée. Un interpréteur interactif
renvoie l’erreur si le fichier ne peut pas être exécuté. Si
aucune commande n’est indiquée, les éventuelles redirections
sont mises en place dans l’interpréteur courant et l’état
renvoyé est 0. S’il y a une erreur de redirection, l’état
renvoyé est 1.

exit [n]
Conduit à la terminaison de l’interpréteur avec un état de n. Si
n est omis, l’état final est celui de la dernière commande
exécutée. Une capture sur EXIT est exécutée avant que
l’interpréteur termine.

export [-fn] [nom[=mot]] ...
export -p
Les noms fournis sont marqués pour être exportés automatiquement
dans l’environnement des commandes exécutées par la suite. Si
l’option -f est indiquée, les noms se rapportent à des
fonctions. Si aucun nom n’est donné ou si l’option -p est
fournie, une liste est affichée indiquant l’ensemble des noms
exportés dans cet interpréteur. L’option -n conduit à supprimer
l’attribut d’exportation de chacune des variables nommées. Si un
nom de variable est suivi par =mot, la valeur de la variable est
mise à mot. export renvoie un état final de 0, à moins qu’une
option incorrecte soit rencontrée ou qu’un des noms ne soit pas
un nom correct de variable de l’interpréteur ou que l’option -f
soit fournie avec un nom qui n’est pas une fonction.

fc [-e ��diteur] [-nlr] [premier] [dernier]
fc -s [motif=nouveau] [commande]
Commandes épinglées (Fix Command). Dans la première forme, une
plage de commandes, entre la premi��re et la derni��re, est
sélectionné dans la file d’historique. La premi��re et la
derni��re peuvent être spécifiées sous forme de chaînes (pour
trouver la dernière commande commençant par cette chaîne) ou
sous forme numérique (un indice dans la file d’historique où un
nombre négatif est utilisé comme décalage par rapport au numéro
de la commande courante). Si la derni��re n’est pas spécifiée,
elle est mise à la commande courante si l’on veut afficher la
liste (ainsi ‘‘fc -l -10’’ affiche les 10 dernières commandes)
et qu’il s’agit de la même que la premi��re sinon. Si la premi��re
n’est pas spécifiée, elle est mise à la commande précédente pour
une édition et à -16 pour l’affichage de liste.

L’option -n supprime l’affichage des numéros dans la liste.
L’option -r inverse l’ordre des commandes. Si l’option -l est
indiquée, les commandes sont affichées sur la sortie standard.
Sinon, l’��diteur indiqué est appelé avec un fichier contenant
les commandes sélectionnées. Si aucun ��diteur n’est indiqué, on
utilise la valeur de la variable FCEDIT ou la valeur de EDITOR
si FCEDIT n’existe pas. Si aucune variable n’existe, vi est
utilisé. Lorsque l’édition se termine, les commandes sont
affichées puis exécutées.

Dans la seconde forme, la commande est ré-exécutée après avoir
remplacé chaque instance du motif par nouveau. Un alias utile
pour ceci est ‘‘r="fc -s"’’, ainsi en tapant ‘‘r cc’’ on relance
la dernière commande commençant par ‘‘cc’’ et en tapant ‘‘r’’ on
ré-exécute la commande précédente.

Lorsque la première forme est utilisée, la valeur renvoyée est
0, à moins qu’une option incorrecte soit trouvée ou que premi��re
ou derni��re indiquent des lignes d’historique hors d’atteinte.
Si l’option -e est fournie, la valeur renvoyée est celle de la
dernière commande exécutée ou un échec si une erreur s’est
produite avec le fichier temporaire des commandes. Avec la
seconde forme, l’état renvoyé est celui de la commande
ré-exécutée, à moins que commande ne spécifie pas une ligne
correcte de l’historique, auquel cas fc renvoie un échec.

fg [t��che]
Reprendre la t��che au premier plan et en faire la tâche
courante. Si aucune t��che n’est précisée, l’interpréteur utilise
la notion de t��che courante. La valeur renvoyée est celle de la
commande placée au premier plan ou un échec si le contrôle des
tâches est désactivé ou lorsque le contrôle des tâches est
activé, si t��che ne spécifie pas une tâche correcte ou si t��che
spécifie une tâche qui a été lancée sans contrôle des tâches.

getopts cha��ne_d_options nom [arguments]
getopts est utilisé par les scripts d’interpréteur pour analyser
les paramètres positionnels. La cha��ne_d_options contient
l’ensemble des caractères d’options à reconnaître ; si un
caractère est suivi par deux-points (:), l’option est censée
comprendre un argument, qui devrait en être séparé par une
espace. Les caractères deux-points et le point d’interrogation
ne peuvent pas être utilisés comme caractères d’option. À chaque
appel, getopts place l’option suivante dans la variable de
l’interpréteur dont le nom est fourni, en la créant si elle
n’existe pas et l’indice de l’argument suivant à traiter dans la
variable OPTIND. OPTIND est initialisée à 1 à chaque appel d’un
interpréteur ou d’un script. Quand une option nécessite un
argument, getopts place cet argument dans la variable OPTARG.
L’interpréteur ne réinitialise pas OPTIND automatiquement ; il
faut le faire manuellement entre des appels multiples à getopts
au sein du même appel d’interpréteur si un nouveau jeu de
paramètres doit être utilisé.

Lorsque la fin des options est atteinte, getopts termine avec
une valeur renvoyée strictement supérieure à zéro. OPTIND est
mis à l’indice du premier argument non-option et nom est mis à
?.

getopts analyse en principe les paramètres positionnels, mais si
plus d’arguments sont indiqués, getopts analysera ces derniers à
la place.

getopts peut signaler des erreurs de deux façons. Si le premier
caractère de la cha��ne_d_options est un deux-points, les erreurs
sont signalées de façon silencieuse. Lors d’un fonctionnement
normal, des messages de diagnostic sont affichés si une option
est incorrecte ou s’il manque un argument d’option. Si la
variable OPTERR est mise à 0, aucun message d’erreur ne sera
affiché, même si le premier caractère de la cha��ne_d_options
n’est pas un deux-points.

Si une option incorrecte est rencontrée, getopts met un point
d’interrogation (?) dans la variable nom, affiche un message
d’erreur (s’il n’est pas en mode silencieux) et détruit la
variable OPTARG. Si getopts fonctionne en mode silencieux, le
caractère d’option est placé dans OPTARG et aucun message de
diagnostic n’est affiché.

Lorsqu’un argument d’option nécessaire est absent et si getopts
n’est pas silencieux, un point d’interrogation (?) est placé
dans la variable nom, OPTARG est détruite et un message de
diagnostic est affiché. Si getopts est silencieux, un
deux-points (:) est placé dans la variable nom et OPTARG est mis
à l’option monocaractère trouvée.

getopts renvoie vrai si une option, spécifiée ou non, est
trouvée. Il renvoie faux si la fin des options est atteinte ou
si une erreur se produit.

hash [-lr] [-p fichier] [-dt] [nom]
Pour chaque nom fourni, le chemin d’accès complet de la commande
est déterminé, en examinant les répertoires de $PATH et
mémorisé. Si l’option -p est fournie, aucune recherche de chemin
d’accès n’est effectuée et le fichier est utilisé comme chemin
d’accès complet pour la commande. L’option -r conduit
l’interpréteur à oublier tous les emplacements mémorisés.
L’option -d conduit l’interpréteur à oublier tous les
emplacements mémorisés de chaque nom. Si l’option -t est
fournie, le chemin d’accès complet de chaque nom correspondant
est affiché. Si plusieurs arguments nom sont fournis avec -t, le
nom est affiché avant chaque chemin d’accès complet haché.
L’option -l conduit à afficher la sortie dans un format
réutilisable en entrée. Si aucun argument n’est indiqué ou si
seulement -l est fournie, des informations sur les commandes
mémorisées sont affichées. La valeur renvoyée est vrai, à moins
que nom ne soit pas trouvé ou qu’une option incorrecte soit
fournie.

help [-s] [motif]
Affiche des informations d’aide au sujet des commandes internes.
Si un motif est indiqué, help fournit de l’aide sur toutes les
commandes internes correspondant à ce motif, sinon, une liste
des commandes internes et des structures de contrôle de
l’interpréteur est affichée. L’option -s restreint l’affichage
de l’information à un court synopsis d’utilisation. L’état
renvoyé est 0, à moins qu’aucune commande ne corresponde au
motif.

history [n]
history -c
history -d nombre
history -anrw [fichier]
history -p argument [argument ...]
history -s argument [argument ...]
Sans options, affiche la liste des commandes de la file
d’historique, avec les numéros de ligne. Les lignes marquées
avec un * ont été modifiées. Un argument n permet de n’afficher
que les n dernières lignes. Si la variable de l’interpréteur
HISTTIMEFORMAT existe et n’est pas vide, elle est utilisée comme
une chaîne de format pour strftime(3) afin d’afficher
l’horodatage associé à chaque élément de l’historique affiché.
Aucun blanc intercalaire n’est affiché entre l’horodatage ainsi
mis en forme et la ligne de l’historique. Si un argument fichier
est fourni, il est utilisé comme nom de fichier d’historique ;
sinon la valeur de HISTFILE est utilisée. Les options, si
fournies, ont les significations suivantes :
-c Effacer la file de l’historique en supprimant tous les
éléments.
-d nombre
Détruire l’élément de l’historique à la position nombre.
-a Ajouter les « nouvelles » lignes d’historiques (celles
créées depuis le début de la session courante de bash)
dans le fichier d’historique.
-n Lire dans le fichier d’historique les lignes non encore
lues et les ajouter à la file d’historique courante. Il
s’agit des lignes qui ont été ajoutées dans le fichier
d’historique depuis le début de la session bash.
-r Lire le contenu du fichier et l’utiliser comme historique
courant.
-w Écrire dans le fichier l’historique actuel, en écrasant
le contenu précédent.
-p Effectuer la substitution sur les arguments suivants et
afficher le résultat sur la sortie standard. Ne pas
mémoriser les résultats dans la file d’historique. Chaque
argument doit être protégé pour désactiver le
développement normal de l’historique.
-s Conserver les arguments dans la file d’historique comme
un unique élément. La dernière commande de la file
d’historique est supprimée avant que les arguments soient
ajoutés.

Si la variable HISTTIMEFORMAT existe, l’information d’horodatage
associée à chaque élément de l’historique est écrite dans le
fichier d’historique. La valeur renvoyée est 0, à moins qu’une
option incorrecte soit fournie, qu’une erreur se produise durant
la lecture ou l’écriture du fichier, qu’un nombre incorrect soit
fourni comme argument à -d ou que le développement de
l’historique fourni en argument à -p échoue.

jobs [-lnprs] [ t��che ... ]
jobs -x commande [ arguments ... ]
La première forme affiche la liste des tâches actives. Les
options ont les significations suivantes :
-l Affiche les PID, en plus des informations normales.
-p N’affiche que le PID du meneur du groupe de processus de
la tâche.
-n N’affiche de l’information que sur les tâches dont l’état
a changé depuis la dernière notification de leur état à
l’utilisateur.
-r Restreint l’affichage aux tâches en cours d’exécution.
-s Restreint l’affichage aux tâches suspendues.

Si une t��che est indiquée, l’affichage est restreint aux
informations sur cette tâche. L’état renvoyé est 0, à moins
qu’une option incorrecte soit rencontrée ou qu’une t��che
incorrecte soit fournie.

Si l’option -x est fournie, jobs va remplacer toute t��che
trouvée dans la commande ou dans ses arguments avec les Process
Group ID correspondant, puis il exécutera la commande en lui
transmettant les arguments et en renvoyant son état final.

kill [-s signal | -n num-signal | -signal] [pid | t��che] ...
kill -l [signal | ��tat_final]
Envoyer le signal indiqué par signal ou num-signal aux processus
spécifiés par pid ou par t��che. signal est soit sous la forme de
nom de signal (indifférent à la casse), comme SIGKILL (avec ou
sans le préfixe SIG ), soit sous forme numérique ; num-signal
est un numéro de signal. Si signal est absent, SIGTERM est
supposé par défaut. Un argument -l affiche la liste des noms de
signaux. Si des arguments sont fournis quand -l est indiqué, les
noms des signaux correspondant aux arguments sont affichés et
l’état renvoyé est 0. L’argument ��tat_final de l’option -l est
un nombre spécifiant soit un numéro de signal, soit l’état final
d’un processus terminé par un signal. kill renvoie vrai si au
moins un signal a été envoyé avec succès ou faux si une erreur
s’est produite ou si une option incorrecte a été rencontrée.

let argument [argument ...]
Chaque argument est une expression arithmétique à évaluer (voir
ÉVALUATION ARITHMÉTIQUE ). Si l’évaluation du dernier argument
donne 0, let renvoie 1 ; sinon 0 est renvoyé.

local [option] [nom[=valeur] ...]
Pour chaque argument, une variable locale nommée nom est créée
et la valeur lui est affectée. L’option peut être toute option
acceptée par declare. Quand local est utilisé dans une fonction,
la variable nom possède une portée visible restreinte à cette
fonction et ses enfants. Sans opérandes, local affiche la liste
des variables locales sur la sortie standard. Une utilisation de
local en dehors des fonctions est erronée. La valeur renvoyée
est 0, à moins que local soit utilisé en dehors d’une fonction,
qu’un nom incorrect soit fourni ou que nom soit une variable en
lecture seule.

logout Termine un interpréteur de connexion.

popd [-n] [+n] [-n]
Enlève des éléments de la pile des répertoires. Sans arguments,
seul le répertoire du sommet de la pile est éliminé et un cd est
effectué en direction du nouveau répertoire au sommet. Les
argument, si fournis, ont les significations suivantes :
+n Supprime le n-ième élément de la liste affichée par dirs,
en comptant depuis la gauche à partir de zéro. Par
exemple : ‘‘popd +0’’ enlève le premier répertoire,
‘‘popd +1’’ le second.
-n Supprime le n-ième élément de la liste affichée par dirs,
en comptant depuis la droite à partir de zéro. Par
exemple : ‘‘popd -0’’ supprimer le dernier répertoire et
‘‘popd -1’’ l’avant-dernier.
-n Empêche le changement normal de répertoire lors de la
suppression d’un répertoire de la pile. On ne fait que
manipuler la pile.

Si la commande popd réussit, un dirs est effectué et l’état
renvoyé est 0. popd renvoie faux si une option incorrecte est
trouvée, si la pile de répertoires est vide, si on a indiqué un
répertoire absent de la pile ou si le changement de répertoire a
échoué.

printf [-v var] format [arguments]
Écrit les arguments mis en forme sur la sortie standard sous le
contrôle du format. Ce format est une chaîne contenant trois
types de caractères : normaux, qui sont simplement copiés sur la
sortie standard, les caractères d’échappement qui sont convertis
puis copiés sur la sortie standard et les spécifications de
format qui conduisent chacune à l’affichage des arguments
successifs. En plus des formats standards de printf(1), %b
conduit printf à développer les suites de caractères
d’échappement par contre-oblique se trouvant dans l’argument
correspondant (excepté que \c termine la sortie, que les
contre-obliques dans \', \" et \? ne sont pas supprimées et que
les suites de caractères d’échappement pour les nombres en octal
commençant par \0 peuvent contenir jusqu’à quatre chiffres) et
%q conduit printf à afficher l’argument correspondant dans un
format réutilisable en entrée de l’interpréteur.

L’option -v conduit à affecter la sortie à la variable var
plutôt que de l’afficher sur la sortie standard.

Le format est réutilisé jusqu’à consommer tous les arguments. Si
le format demande plus d’arguments que fournis, les
spécifications supplémentaires se comportent comme si des
valeurs zéro ou des chaînes vides, comme nécessaire, avaient été
fournies. La valeur renvoyée est zéro en cas de succès,
différente de zéro en cas d’échec.

pushd [-n] [r��p]
pushd [-n] [+n] [-n]
Ajoute un répertoire au sommet de la pile des répertoires ou
effectue une rotation dans la pile, en ramenant le répertoire
courant au sommet. Sans argument, cette commande échange les
deux répertoires au sommet et renvoie 0, à moins que la pile
soit vide. Les arguments, si fournis, ont les significations
suivantes :
+n Effectue une rotation dans la pile, de façon à amener au
sommet le n-ième répertoire (de la liste affichée par
dirs en comptant à partir de la gauche et en commençant à
zéro).
-n Effectue une rotation dans la pile, de façon à amener au
sommet le n-ième répertoire (en comptant à partir de la
droite dans la liste affichée par dirs, en commençant à
zéro).
-n Empêche le changement normal de répertoire lors d’un
ajout dans la pile. Seule la pile est manipulée.
rép Ajoute le répertoire r��p au sommet de la pile de
répertoires en en faisant le nouveau répertoire de
travail courant.

Si la commande pushd réussit, un dirs est aussi effectué. Si on
utilise la première forme, pushd renvoie 0 sauf si le
déplacement vers r��p échoue. Avec la seconde forme, pushd
renvoie 0, à moins que la pile soit vide, que soit spécifié un
élément inexistant dans la pile ou que le changement de
répertoire vers le nouveau répertoire spécifié échoue.

pwd [-LP]
Affiche le chemin d’accès absolu au répertoire de travail
actuel. Le chemin ne contiendra pas de liens symboliques si
l’option -P est fournie, ou si l’option -o physical de la
commande interne set est activée. Si l’option -L est utilisée,
le chemin affiché peut contenir des liens symboliques. L’état
renvoyé est 0, à moins qu’une erreur se soit produite durant la
lecture du nom du répertoire courant ou qu’une option incorrecte
soit fournie.

read [-ers] [-u fd] [-t d��lai] [-a nom_t] [-p invite] [-n nb_car] [-d
d��limiteur] [nom ...]
Une ligne est lue depuis l’entrée standard ou à partir du
descripteur de fichier fd fourni en argument à l’option -u, puis
le premier mot de cette ligne est affecté au premier nom, le
second mot au second nom, et ainsi de suite avec les mots
restants et leurs séparateurs affectés au dernier nom. S’il y a
moins de mots lus dans le flot d’entrée que de variables, des
valeurs vides sont affectées à celles restantes. Les caractères
contenus dans la variable IFS sont utilisés pour découper la
ligne en mots. Le caractère contre-oblique (\) permet de
supprimer toute signification spéciale pour le caractère suivant
et autorise la continuation de lignes. Les options, si fournies,
ont les significations suivantes :
-a nom_t
Les mots sont affectés aux indices successifs d’une
variable tableau de nom nom_t, en commençant à 0. nom_t
est détruit avant que de nouvelles valeurs soient
affectées. Les autres arguments nom sont ignorés.
-d d��limiteur
Le premier caractère de d��limiteur est utilisé pour
terminer la ligne de saisie, plutôt qu’un saut de ligne.
-e Si l’entrée standard provient d’un terminal, la
bibliothèque readline (voir READLINE plus haut) est
utilisée pour obtenir la ligne.
-n nb_car
read renvoie après avoir lu nb_car caractères plutôt que
d’attendre une ligne complète en entrée.
-p invite
Affiche invite sur la sortie d’erreur standard, sans
caractère final de saut de ligne, avant d’essayer de lire
toute nouvelle saisie. L’invite est affichée seulement si
l’entrée vient d’un terminal.
-r La contre-oblique n’agit pas comme un caractère
d’échappement. La contre-oblique est considérée comme
faisant partie de la ligne. En particulier, le couple
contre-oblique-saut de ligne ne peut être utilisé comme
une continuation de ligne.
-s Mode silencieux. Si une entrée arrive à partir d’un
terminal, les caractères ne sont pas affichés.
-t d��lai
Conduit read à expirer et renvoyer un échec si une ligne
complète en entrée n’a pas été lue dans le d��lai en
secondes. Cette option n’a aucun effet si read ne lit pas
l’entrée à partir d’un terminal ou d’un tube.
-u fd Lire l’entrée à partir du descripteur de fichier fd.

Si aucun nom n’est fourni, la ligne lue est affectée entièrement
à la variable REPLY. Le code renvoyé est zéro, à moins qu’une
fin-de-fichier soit rencontrée, que read dépasse son délai de
réponse ou qu’un descripteur de fichier incorrect ait été fourni
en argument de -u.

readonly [-apf] [nom[=mot] ...]
Les noms indiqués reçoivent un attribut lecture-seule ; les
valeurs de ces noms ne pourront plus être modifiées par des
affectations ultérieures. Si l’option -f est fournie, les
fonctions correspondant à ces noms sont marquées en conséquence.
L’option -a restreint l’action aux variables tableaux. Si aucun
argument nom n’est indiqué ou si l’option -p est fournie, une
liste de tous les noms en lecture-seule est affichée. L’option
-p conduit à afficher la sortie dans un format susceptible
d’être réutilisé en entrée. Si le nom d’une variable est suivi
par =mot, la variable est mise à mot. L’état renvoyé est 0, à
moins qu’une option incorrecte ait été rencontrée, que l’un des
noms ne soit pas un nom correct de variable de l’interpréteur ou
que l’option -f soit fournie avec un nom qui n’est pas une
fonction.

return [n]
Conduit à la terminaison d’une fonction en renvoyant la valeur
spécifiée par n. Si n est omis, la valeur renvoyée celle de la
dernière commande exécutée dans le corps de la fonction. Si
utilisée dehors d’une fonction, mais durant l’exécution d’un
script par la commande . (source) elle conduit à la suspension
de l’exécution du script par l’interpréteur et renvoie comme
état final du script soit n soit l’état final de la dernière
commande exécutée dans le script. Si utilisée en dehors d’une
fonction ni pendant un script exécuté par ., l’état renvoyé est
faux. Toute commande associée à la capture de RETURN est
exécutée avant que l’exécution reprenne après la fonction ou le
script.

set [--abefhkmnptuvxBCHP] [-o option] [arg ...]
Sans options, le nom et la valeur de chacune des variables de
l’interpréteur sont affichés dans un format susceptible d’être
réutilisé en entrée pour créer ou réinitialiser les variables
courantes. Les variables en lecture seule ne peuvent pas être
réinitialisées. Dans le mode posix, seules les variables de
l’interpréteur sont affichées. La sortie est triée en fonction
des paramètres linguistiques régionaux courants. Lorsque des
options sont spécifiées, elles créent ou détruisent des
attributs de l’interpréteur. Tous les arguments restant après
traitement des options sont considérés comme des valeurs pour
les paramètres positionnels et sont affectés, dans l’ordre, à :
$1, $2, ... $n. Les options, si spécifiées, ont les
significations suivantes :
-a Marquage automatique des variables et fonctions
modifiées ou créées pour qu’elles soient exportées dans
l’environnement des commandes exécutées ultérieurement.
-b Signaler l’état des tâches terminées en arrière-plan
immédiatement, plutôt que d’attendre l’affichage de la
prochaine invite de base. N’est effectif que si le
contrôle des tâches est activé.
-e Termine immédiatement si commande simple (voir GRAMMAIRE
DE L�’INTERPRÉTEUR plus haut) termine avec un état
différent de zéro. L’interpréteur ne termine pas si la
commande qui échoue fait partie d’une liste de commandes
immédiatement suivie par un mot-clef while ou until,
dans le test d’un if, dans une liste de && ou de �│�│ ou
si la valeur renvoyée par la commande est inversée par
!. Une capture sur ERR, si existante, est exécutée avant
que l’interpréteur termine.
-f Désactiver le développement des chemins.
-h Mémorisation de l’emplacement des commandes lors de leur
exécution. Activé par défaut.
-k Tous les arguments sous la forme d’affectations sont
placés dans l’environnement d’une commande, et non pas
seulement ceux qui précèdent le nom de la commande.
-m Mode supervision. Activation du contrôle des tâches.
Cette option est activée par défaut pour les
interpréteurs interactifs sur les systèmes qui le
permettent (voir CONTRÔLE DES TÂCHES plus haut). Les
processus en arrière-plan sont exécutés dans un groupe
de processus séparé et une ligne contenant leurs états
finaux est affichée lorsqu’ils terminent.
-n Lecture de commandes sans exécution. Ceci peut être
utilisé pour rechercher les erreurs de syntaxe dans un
script. Cette option est ignorée par les interpréteurs
interactifs.
-o nom_d_option
Le nom_d_option est l’un des suivants :
allexport
Identique à -a.
braceexpand
Identique à -B.
emacs Utiliser une interface d’édition des lignes de
commande « à la emacs ». C’est le comportement
activé par défaut quand l’interpréteur est
interactif, à moins que l’interpréteur soit
démarré avec l’option --noediting.
errtrace
Identique à -E.
functrace
Identique à -T.
errexit Identique à -e.
hashall Identique à -h.
histexpand
Identique à -H.
history Activer l’historique des commandes, comme décrit
plus haut dans HISTORY. Cette option est activée
par défaut dans les interpréteurs interactifs.
ignoreeof
Identique à l’exécution de la commande
d’interpréteur ‘‘IGNOREEOF=10’’ (voir Variables
de l�’interpréteur plus haut).
keyword Identique à -k.
monitor Identique à -m.
noclobber
Identique à -C.
noexec Identique à -n.
noglob Identique à -f. nolog Actuellement ignoré.
notify Identique à -b.
nounset Identique à -u.
onecmd Identique à -t.
physical
Identique à -P.
pipefail
Si existante, la valeur renvoyée par une
conduite est la valeur de la dernière commande
(la plus à droite) à terminer avec un état final
différent de zéro ou zéro si toutes les
commandes de la conduite terminent avec succès.
Cette option est désactivée par défaut.
posix Aligner le comportement de bash sur le standard
POSIX, en ce qui concerne les options dont
l’action par défaut diffère de ce standard (mode
posix).
privileged
Identique à -p.
verbose Identique à -v.
vi Utiliser une interface d’édition des lignes de
commande « à la vi ».
xtrace Identique à -x.
Si -o est fournie sans nom_d_option, les valeurs
actuelles des options sont affichées. Si +o est fournie
sans nom_d_option, la série de commandes set permettant
de recréer la configuration courante d’options est
affichée sur la sortie standard.
-p Basculer en mode privil��gi��. Dans ce mode, les fichiers
$ENV et $BASH_ENV ne sont pas traités, les fonctions de
l’interpréteur ne sont pas héritées de l’environnement
et la variable SHELLOPTS, si dans l’environnement, est
ignorée. Si l’interpréteur démarre avec un UID (resp.
GID) effectif différent de son UID (GID) réel et si
l’option -p n’est pas fournie, ce comportement est
appliqué et l’UID (GID) effectif est mis au UID (GID)
réel. Si l’option -p est fournie au démarrage l’UID
(GID) effectif n’est pas modifié. Désactiver cette
option conduit à la mise des UID et GID effectifs à la
valeur des UID et GID réels.
-t Terminer après lecture et exécution d’une commande.
-u Considérer les variables inexistantes comme des erreurs
lors du développement des paramètres. Si on tente de
développer une variable inexistante, l’interpréteur
affiche un message d’erreur et, s’il n’est pas
interactif, termine avec un état différent de zéro.
-v Affichage les lignes en entrée de l’interpréteur
lorsqu’elles sont lues.
-x Après le développement de chaque commande simple,
commande for, commande case, commande select ou commande
for arithmétique, bash affiche la valeur de PS4, suivie
par la commande et ses arguments développés ou la liste
de mots associés.
-B L’interpréteur effectue le développement des accolades
(voir Développement des accolades plus haut). Cette
option est active par défaut.
-C Si mise, bash n’écrasera pas un fichier existant avec
les opérateurs >, >& et <>. Ce comportement peut être
surpassé lors de la création d’un fichier de sortie en
utilisant l’opérateur de redirection >| à la place de >.
-E Si mise, toute capture sur ERR est héritée par les
fonctions d’interpréteur, les substitutions de commandes
et les commandes exécutées dans un sous-interpréteur. La
capture de ERR n’est normalement pas héritée dans de
tels cas.
-H Activer le style ! de substitution historique. C’est le
comportement par défaut lorsque l’interpréteur est
interactif.
-P Si mise, l’interpréteur ne doit pas suivre les liens
symboliques en exécutant des commandes comme cd qui
modifient le répertoire de travail. Utiliser à la place
le répertoire physique. Par défaut bash suit la chaîne
logique des répertoires lors des commandes qui modifient
le répertoire courant.
-T Si mise, toutes les captures de DEBUG et RETURN sont
héritées par les fonctions de l’interpréteur, les
substitutions de commande et les commandes exécutées
dans un sous-interpréteur. Les captures de DEBUG et
RETURN ne sont normalement pas héritées dans de tels
cas.
-- Si aucun argument ne suit cet option, alors les
paramètres positionnels sont détruits. Sinon, les
paramètres positionnels sont mis aux arguments, même si
certains d’entre eux commencent par un -.
- Marque la fin des options conduisant tous les arguments
restants à être affectés aux paramètres positionnels.
Les options -x et -v sont désactivées. S’il n’y a pas
d’arguments, les paramètres positionnels ne sont pas
modifiés.

Par défaut les attributs sont désactivés, sauf indication
contraire. En utilisant + à la place de - on désactive
explicitement un drapeau. Les attributs peuvent également être
fournis en argument lors de l’appel de l’interpréteur. Le jeu
courant des options peut être trouvé dans $-. La valeur renvoyée
est toujours vrai, à moins qu’une option incorrecte soit
rencontrée.

shift [n]
Les paramètres positionnels à partir de n+1 ... sont renommés en
$1 .... Les paramètres représentés par les nombres $# jusqu’à
$#-n+1 sont détruits. n doit être un entier positif inférieur ou
égal à $#. Si n vaut 0, aucun paramètres n’est modifié. Si n est
omis, on suppose qu’il vaut 1. Si n est supérieur à $#, les
paramètres positionnels ne sont pas modifiés. L’état renvoyé est
strictement plus grand que zéro si n est plus grand que $# ou
plus petit que zéro ; sinon 0.

shopt [-pqsu] [-o] [nom_opt ...]
Bascule la valeur des variables contrôlant le comportement
facultatif de l’interpréteur. Sans option ou avec l’option -p,
une liste de toutes les options configurables est affichée, avec
l’indication de l’état de chacune d’entre elles. L’option -p
conduit à un affichage de la sortie sous une forme susceptible
d’être réutilisée en entrée. Les autres options ont les
significations suivantes :
-s Activer (créer) chaque nom_opt.
-u Désactiver (détruire) chaque nom_opt.
-q Supprimer la sortie normale (mode silencieux) ; l’état
renvoyé indique si nom_opt est existante ou non. Si
plusieurs arguments nom_opt sont indiqués avec -q, l’état
renvoyé est zéro si tous les nom_opt sont activés ;
différent de zéro sinon.
-o Restreindre les valeurs des nom_opts à celles définies
pour l’option -o de la commande interne set.

Si l’option -s ou -u est utilisée sans argument nom_opt,
l’affichage est limité aux options qui sont respectivement
existantes ou non. Sauf indication contraire, les options shopt
sont désactivées (détruites) par défaut.

L’état renvoyé lors d’un affichage des options est zéro si tous
les nom_opt sont activés, différent de zéro sinon. Lors de la
création ou de la destruction d’options, l’état renvoyé est
zéro, à moins que nom_opt ne soit pas une option correcte de
l’interpréteur.

La liste des options shopt est :

cdable_vars
Si existante, un argument de la commande interne cd qui
n’est pas un répertoire est supposé être un nom de
variable dont la valeur est le répertoire visé.
cdspell Si existante, les erreurs minimes de frappe dans un
composant du répertoire en argument de la commande cd
seront corrigées. Les erreurs corrigées sont les
inversions d’un caractère, un caractère manquant et un
caractère en trop. Si une correction est possible, le
nom de répertoire corrigé est affiché et la commande est
exécuté. Cette option n’est utilisée que par les
interpréteurs interactifs.
checkhash
Si existante, bash vérifie si une commande trouvée dans
la table de hachage existe avant d’essayer de
l’exécuter. Si une commande hachée n’existe plus, une
recherche normale de chemin est effectuée.
checkwinsize
Si existante, bash vérifie la taille de la fenêtre après
chaque commande et, au besoin, mettra à jour les valeurs
des variables LINES et COLUMNS.
cmdhist Si existante, bash essaie de sauvegarder les commandes
s’étendant sur plusieurs lignes en un seul élément
d’historique. Ceci facilite l’édition ultérieure de
commandes multilignes.
compat31
If set, bash changes its behavior to that of version 3.1
with respect to quoted arguments to the conditional
command’s =~ operator.
dotglob Si existante, bash inclut les noms de fichiers
commençant par un « . » dans les résultats des
développements de chemins.
execfail
Si existante, un interpréteur non interactif ne
terminera pas s’il ne peut exécuter un fichier spécifié
en argument de la commande interne exec. Un interpréteur
interactif ne termine pas si exec échoue.
expand_aliases
Si existante, les alias sont développés comme décrit
plus haut, dans ALIAS. Cette option est activée par
défaut pour les interpréteurs interactifs.
extdebug
Si existante, le comportement attendu par les traceurs
est activé :
1. L’option -F de la commande interne declare
affiche le nom du fichier source et le numéro de
ligne correspondant à chaque nom de fonction
fourni comme argument.
2. Si la commande lancée par la capture de DEBUG
renvoie une valeur différente de zéro, la
commande suivante est sautée et n’est pas
exécutée.
3. Si la commande lancée par la capture de DEBUG
renvoie la valeur 2 et si l’interpréteur
s’exécute dans un sous-programme (une fonction de
l’interpréteur ou un script exécuté par les
commandes internes . ou source), un appel à
return est simulé.
4. BASH_ARGC et BASH_ARGV sont mises à jour comme
expliqué dans leurs descriptions plus haut.
5. Le traçage des fonctions est activé : la
substitution de commande, les fonctions de
l’interpréteur et les sous-interpréteurs appelés
avec ( command ) héritent des captures de DEBUG
et RETURN.
6. Le traçage d’erreur est activé : la substitution
de commande, les fonctions de l’interpréteur et
les sous-interpréteurs appelés avec ( command )
héritent de la capture de ERROR.
extglob Si existante, les fonctionnalités étendues de mise en
correspondance décrites plus haut dans Développement des
chemins sont activées.
extquote
Si existante, la protection par $'cha��ne' et $"cha��ne"
est effectuée à l’intérieur des développements de
${param��tres} entre guillemets doubles. Cette option est
activée par défaut.
failglob
Si existante, les motifs qui échouent à faire
correspondre les noms de fichiers pendant le
développement des chemins font qu’ils provoqueront une
erreur de développement.
force_fignore
Si existante, les suffixes spécifiés par la variable de
l’interpréteur FIGNORE conduiront les mots à être
ignorés lors du complètement de mots, même si les mots
ignorés sont des complètements possibles. Voir VARIABLES
DE L�’INTERPRÉTEUR plus haut pour une description de
FIGNORE. Cette option est activée par défaut.
gnu_errfmt
Si existante, les messages d’erreur de l’interpréteur
seront écrits dans le format standard GNU des messages
d’erreurs.
histappend
Si existante, la file d’historique est ajoutée au
fichier désigné par la valeur de la variable HISTFILE
lorsque l’interpréteur termine, plutôt que d’écraser ce
fichier.
histreedit
Si existante et si readline est utilisée, un utilisateur
peut rééditer une substitution d’historique qui a
échoué.
histverify
Si existante et si readline est utilisée, le résultat de
la substitution d’historique n’est pas transmise
immédiatement à l’analyseur de l’interpréteur. À la
place, la ligne résultant est chargée dans le tampon
d’édition de readline permettant des modifications
ultérieures.
hostcomplete
Si existante et si readline est utilisée, bash essayera
d’effectuer le complètement des noms de machines
lorsqu’un mot contient un @ (voir Complètement dans
READLINE plus haut). Cette option est activée par
défaut.
huponexit
Si existante, bash enverra un signal SIGHUP à toutes les
tâches lorsqu’un interpréteur de connexion interactif
termine.
interactive_comments
Si existante, un mot commençant par un # conduira ce mot
et tous les autres caractères restants de la ligne à
être ignorés dans un interpréteur interactif (voir
COMMENTAIRES plus haut). Cette option est activée par
défaut.
lithist Si existante et si l’option cmdhist est activée, les
commandes multilignes sont sauvegardées dans
l’historique avec des sauts de ligne incorporés comme
séparateurs plutôt que des points-virgules là où c’est
possible.
login_shell
L’interpréteur crée cette option s’il est démarré en
tant qu’interpréteur de connexion (voir APPEL plus
haut). La valeur ne peut être modifiée.
mailwarn
Si existante et s’il a été accédé à un fichier que bash
surveille pour les courriels depuis sa dernière
vérification, le message « The mail in
fichier_de_courriel has been read » est affiché.
no_empty_cmd_completion
Si existante et si readline est utilisée, bash
n’essaiera pas d’utiliser le PATH pour de possibles
complètements quand le complètement est tenté sur une
ligne vide.
nocaseglob
Si existante, bash fait correspondre les noms de
fichiers d’une façon insensible à la casse lors du
développement des chemins (voir Développement des
chemins plus haut).
nocasematch
Si existante, bash fait correspondre les motifs d’une
façon insensible à la casse lors de la mise en
correspondance pendant l’exécution des commandes
conditionnelles case ou [[.
nullglob
Si existante, bash autorise les motifs ne correspondant
à aucun fichier (voir Développement des chemins plus
haut) à se développer en une chaîne vide plutôt qu’en
une valeur littérale.
progcomp
Si existante, les outils de complètement programmables
(voir Complètement programmable plus haut) sont activés.
Cette option est activée par défaut.
promptvars
Si existante, les chaînes d’invite sont sujettes au
développement des paramètres, à la substitution de
commande, au développement arithmétique et à la
suppression des protections après avoir été développée
comme décrit plus haut dans INVITES. Cette option est
activée par défaut.
restricted_shell
L’interpréteur crée cette option s’il est démarré en
mode restreint (voir plus bas INTERPRÉTEUR RESTREINT ).
Cette valeur ne peut pas être changée. Elle n’est pas
réinitialisée lorsque les fichiers de démarrage sont
exécutés, ce qui permet à ces fichiers de découvrir si
un interpréteur est restreint ou non.
shift_verbose
Si existante, la commande interne shift affiche un
message d’erreur lorsque le nombre de décalages dépasse
le nombre de paramètres positionnels.
sourcepath
Si existante, la commande interne source (.) utilise la
valeur de la variable PATH pour trouver le répertoire
contenant le fichier fourni en argument. Cette option
est activée par défaut.
xpg_echo
Si existante, la commande interne echo développe par
défaut les suites de caractères d’échappement par
contre-oblique.
suspend [-f]
Suspend l’exécution de l’interpréteur jusqu’à la réception d’un
signal SIGCONT. L’option -f élimine le message d’erreur s’il
s’agit d’un interpréteur de connexion et force sa suspension.
L’état renvoyé est 0, à moins que l’interpréteur soit un
interpréteur de connexion et que l’option -f soit absente ou que
le contrôle des tâches ne soit pas activé.
test expr
[ expr ]
Renvoie un état de 0 ou 1 selon l’évaluation de la condition
expr. Chaque opérateur et opérande doit être représenté par un
argument distinct. Les conditions sont composées des primitives
décrites plus haut dans CONDITIONS. test n’accepte aucune
option, n’accepte pas non plus et ignore l’argument --
signifiant la fin des options.

Les conditions peuvent être combinées avec les opérateurs
suivant, décrits par ordre de priorité décroissante.
! expr Vrai si expr est fausse.
( expr )
Renvoie la valeur de expr. Peut servir à surpasser la
priorité normale des opérateurs.
expr1 -a expr2
Vrai si expr1 et expr2 sont toutes deux vraies.
expr1 -o expr2
Vrai si expr1 ou expr2 est vraie.

test et [ évaluent les conditions en fonction d’un jeu de règles
dépendant du nombre d’arguments.

0 argument
La condition est fausse.
1 argument
La condition est vraie si et seulement si l’argument
n’est pas vide.
2 arguments
Si le premier argument est !, la condition est vraie si
et seulement si le second argument est vide. Si le
premier argument est l’un des opérateurs conditionnel
unaires décrits plus haut dans CONDITIONS la condition
est vraie si le test unaire est vrai. Si le premier
argument n’est pas un opérateur conditionnel unaire
correct, la condition est fausse.
3 arguments
Si le second argument est l’un des opérateurs
conditionnels binaires décrits plus haut dans CONDITIONS,
le résultat de la condition est le résultat du test
binaire utilisant le premier et le troisième argument en
tant qu’opérandes. Si le premier argument est !, la
valeur est la négation du test binaire utilisant les
deuxième et troisième arguments. Si le premier argument
est exactement ( et le troisième argument est exactement
), le résultat est le test unaire du second argument.
Sinon la condition est fausse. Les opérateurs -a et -o
sont considérés comme des opérateurs binaires dans ce
cas.
4 arguments
Si le premier argument est !, le résultat est la négation
de la condition à trois arguments composée des arguments
restants. Sinon la condition est analysée et évaluée
selon les règles de priorité décrites ci-dessus.
5 arguments ou plus
La condition est analysée et évaluée selon les règles de
priorité décrites ci-dessus.

times Affiche les durées cumulées utilisateur et système pour
l’interpréteur et les processus lancés par cet interpréteur.
L’état renvoyé est 0.

trap [-lp] [[arg] sigspec ...]
La commande arg sera lue et exécutée lorsque l’interpréteur
reçoit l’un des signaux sigspec. Si arg est absent (et qu’il n’y
a qu’un sigspec) ou s’il est -, chaque signal spécifié est
réinitialisé dans son état d’origine (la valeur qu’il avait au
démarrage de l’interpréteur). Si arg est la chaîne vide, le
signal spécifié par chaque sigspec est ignoré par l’interpréteur
et par les commandes qu’il appelle. Si arg est absent et si -p a
été fournie alors les commandes de captures associées à chacun
des sigspec sont affichées. Si aucun argument n’est fourni ou si
seulement -p est indiqué, trap affiche la liste des commandes
associées à chaque signal. L’option -l conduit l’interpréteur à
afficher une liste de noms de signaux et leurs numéros
correspondants. Chaque sigspec est soit un nom de signal défini
dans <signal.h> ou un numéro de signal. Les noms de signaux sont
insensible à la casse et le préfixe SIG est facultatif. Si un
sigspec est EXIT (0) la commande arg est exécutée quand
l’interpréteur termine. Si un sigspec est DEBUG, la commande arg
est exécutée avant chaque commande simple, commande for,
commande case, commande select, chaque commande for arithmétique
et avant que la première commande soit exécutée dans une
fonction de l’interpréteur (voir plus haut GRAMMAIRE DE
L�’INTERPRÉTEUR ). Se rapporter à la description de l’option
extdebug de la commande interne shopt pour les détails de son
effet sur la capture de DEBUG. Si un sigspec est ERR, la
commande arg est exécutée chaque fois qu’une commande simple a
un état final différent de zéro, selon les conditions suivantes.
La capture de ERR n’est pas exécutée si la commande qui a échoué
fait partie d’une liste de commandes suivant immédiatement un
mot-clef while ou until, un test d’un if, d’un && ou d’une liste
�│�│ ou si la valeur renvoyée par la commande est inversée par !.
Ce sont les mêmes conditions que pour l’option errexit. Si un
sigspec est RETURN, la commande arg est exécutée chaque fois
qu’une fonction de l’interpréteur ou un script exécuté par les
commandes internes . ou source finit son exécution. Les signaux
ignorés lors de l’appel de l’interpréteur ne peuvent être
capturés ni réinitialisés. Les signaux capturés, qui ne sont pas
ignorés, sont réinitialisées à leurs valeurs originelles dans un
processus enfant lors de sa création. L’état renvoyé est faux si
un quelconque des sigspec est incorrect ; sinon trap renvoie
vrai.

type [-aftpP] nom [nom ...]
Sans option, indique comment chaque nom doit être interprété si
on l’utilise en nom de commande. Si l’attribut -t est utilisé,
type affiche une des phrases suivantes alias, keyword, function,
builtin ou file selon que le nom est un alias, un mot-clé
réservé de l’interpréteur, une fonction, une commande interne ou
un fichier sur le disque. Si le nom n’est pas trouvé, rien n’est
affiché et un état final à faux est renvoyé. Si l’option -p est
utilisée, type renvoie le nom du fichier qui sera exécuté si
l’on tape le nom en guise de commande ou rien si ‘‘type -t
name’’ ne renvoyait pas file. L’option -P force une recherche
dans PATH pour chaque nom, même si ‘‘type -t name’’ ne renvoyait
pas file. Si une commande est disponible dans la table de
hachage, -p et -P affichent la valeur de cette table, qui n’est
pas nécessairement le fichier apparaissant en premier dans PATH.
Si l’option -a est appelée, type affiche tous les emplacements
contenant un exécutable du nom indiqué. Ceci inclut les alias et
les fonctions, sauf si l’option -p est également présente. La
table de hachage des commandes n’est pas consultée avec l’option
-a. L’option -f supprime la fonction de l’interpréteur de
consultation de table, comme avec la commande interne command.
type renvoie vrai si un quelconque des arguments est trouvé et
faux si aucun n’a été trouvé.

ulimit [-SHacdefilmnpqrstuvx [limitation]]
Fournit, sur les systèmes qui le permettent, un mécanisme de
contrôle des ressources disponibles pour l’interpréteur et pour
les processus qu’il lance. Les options -H et -S spécifient si la
limitation est stricte (hard) ou flexible (soft) pour la
ressource indiquée. Une limitation stricte ne peut pas être
augmentée une fois qu’elle a été mise ; une limitation flexible
peut être augmentée jusqu’à la valeur de la limitation stricte
correspondante. Si ni -H ni -S n’est spécifié les limitations
strictes et flexibles sont toutes deux mises. La valeur de la
limitation peut être un nombre (utilisant les unités
particulières de la ressource) ou l’une des valeurs spéciales
hard, soft ou unlimited, qui signifient, respectivement, la
limitation stricte courante, la limitation flexible courante et
l’absence de limitation. Si la limitation est omise, la valeur
courante de la limitation flexible pour la ressource est
affichée, à moins que l’option -H soit indiquée. Quand plusieurs
ressources sont spécifiées, les noms des limitations et leurs
unités sont affichés avant les valeurs. Les autres options sont
interprétées comme suit :
-a Toutes les limitations courantes sont signalées
-c La taille maximum des fichiers core créés
-d La taille maximum du segment de données d’un processus
-e La priorité d’ordonnancement maximum (« nice »)
-f La taille maximum d’un fichier écrit par l’interpréteur
et ses fils
-i Le nombre maximum de signaux en attente
-l La taille maximum qui peut être verrouillée en mémoire
-m La taille maximum de la partie résidente d’un processus
-n Le nombre maximum de descripteurs de fichiers ouverts (la
plupart des systèmes ne permettent pas de modifier cette
valeur)
-p La taille d’un tube en blocs de 512 octets (parfois
inexistante)
-q Le nombre maximum d’octets dans les files de messages
POSIX
-r La priorité d’ordonnancement temps-réel maximale
-s La taille maximum de la pile
-t La durée maximum, en seconde, de temps CPU accordé à un
processus
-u Le nombre maximum de processus autorisés pour un seul
utilisateur
-v La quantité de mémoire virtuelle disponible pour
l’interpréteur
-x Le nombre maximum de verrous de fichiers

Si une limitation est indiquée, elle sera la nouvelle valeur
pour la ressource spécifiée (l’option -a correspond à
l’affichage seul). Si aucune option n’est indiquée alors -f est
supposée. Les valeurs s’expriment par pas de 1024 octets, sauf
pour -t qui est en secondes, -p, qui utilise des unités de blocs
de 512 octets, ainsi que -n et -u, qui n’ont pas d’unités.
L’état renvoyé est 0, à moins qu’une option ou un argument
incorrect ait été fourni ou qu’une erreur se produise en mettant
la nouvelle limitation.

umask [-p] [-S] [mode]
Le masque de création de fichier de l’utilisateur est mis à
mode. Si mode commence par un chiffre, il est interprété comme
un nombre octal, sinon il est considéré comme un masque
symbolique, semblable à ceux acceptés par chmod(1). Si mode est
omis ou si l’option -S est fournie, la valeur courante du masque
est affichée. L’option -S conduit à l’affichage du masque sous
forme symbolique, l’affichage par défaut étant en octal. Si
l’option -p est fournie et si le mode est omis, la sortie a lieu
dans un format réutilisable en entrée. L’état renvoyé est 0 si
le mode a pu être changé correctement ou si aucun argument mode
n’a été fourni, et faux sinon.

unalias [-a] [nom ...]
Supprime le nom de la liste des alias définis. Si l’option -a
est fournie, toutes les définitions d’alias sont supprimées. La
valeur renvoyée est vrai, à moins qu’un nom fourni ne soit pas
un alias défini.

unset [-fv] [nom ...]
Pour chaque nom indiqué, supprimer la variable ou la fonction
correspondante. Si aucune option n’est fournie ou si l’option -v
est indiquée, chaque nom se rapporte à une variable de
l’interpréteur. Les variables en lecture-seule ne peuvent pas
être détruites. Si l’option -f est spécifiée, chaque nom se
rapporte à une fonction de l’interpréteur et la définition de la
fonction est supprimée. Chaque variable ou fonction détruite est
supprimée de l’environnement transmis aux commandes ultérieures.
Si une quelconque des variables RANDOM, SECONDS, LINENO,
HISTCMD, FUNCNAME, GROUPS ou DIRSTACK est détruite, elle perd
ses propriétés spécifiques, même s’il elle est recréée
ultérieurement. L’état final est vrai, à moins qu’un des noms ne
soit en lecture seule.

wait [n ...]
Attend que chaque processus spécifié termine et renvoie son état
final. Chaque n peut être un PID ou une spécification de tâche ;
si une spécification de tâche est indiquée, la fin de tous les
processus de la conduite de cette tâche sera attendue. Si n est
omis, la fin de tous les processus enfants actuellement actifs
sera attendue et l’état renvoyé est zéro. Si n spécifie un
processus ou une tâche inexistants, l’état renvoyé est 127.
Sinon, l’état renvoyé est l’état final du dernier processus ou
tâche attendu.

INTERPRÉTEUR RESTREINT

       Si bash démarre sous le nom rbash ou si l’option -r est fournie lors de
       son appel, l’interpréteur devient restreint. Un interpréteur  restreint
       permet  de  créer  un  environnement  plus  contrôlé qu’un interpréteur
       standard. Il se comporte de même façon que bash  à  la  différence  des
       actions suivantes qui sont interdites ou non effectuées :

       ·      changer de répertoire avec cd

       ·      créer ou détruire les valeurs de SHELL, PATH, ENV ou BASH_ENV

       ·      indiquer des noms de commandes contenant un /

       ·      indiquer  un  nom de fichier contenant un / comme argument de la
              commande interne . ;

       ·      Spécifier un nom de fichier contenant une  barre  oblique  comme
              argument de l’option -p de la commande interne hash

       ·      importer  une  définition  de  fonction  dans l’environnement au
              démarrage ;

       ·      analyser les valeurs de SHELLOPTS au démarrage ;

       ·      rediriger la sortie en utilisant les opérateurs  de  redirection
              >, >|, <>, >&, &> et >>

       ·      utiliser  la commande interne exec pour remplacer l’interpréteur
              par une autre commande

       ·      ajouter ou supprimer des commandes internes avec les options  -f
              et -d de la commande interne enable ;

       ·      utiliser  la  commande interne enable pour activer les commandes
              internes de l’interpréteur désactivées ;

       ·      indiquer l’option -p à la commande interne commande

       ·      supprimer le mode restreint avec set +r ou set +o restricted.

       Ces restrictions sont mises en place après la lecture  d’un  quelconque
       des fichiers de démarrage.

       When  a  command  that  is  found to be a shell script is executed (see
       COMMAND  EXECUTION  above),  rbash  supprime  toute  restriction   dans
       l’interpréteur créé pour exécuter le script.

VOIR AUSSI

       Manuel de r��f��rence de Bash, Brian Fox et Chet Ramey
       The GNU Readline Library, Brian Fox et Chet Ramey
       The GNU History Library, Brian Fox et Chet Ramey
       Portable   Operating   System  Interface  (POSIX)  Part  2:  Shell  and
       Utilities, IEEE
       sh(1), ksh(1), csh(1)
       emacs(1), vi(1)
       readline(3)

FICHIERS

       /bin/bash
              L’exécutable bash
       /etc/profile
              Le  fichier  d’initialisation  commun à tout le système, exécuté
              pour les interpréteurs de commandes de connexion
       /etc/bash.bashrc
              Le fichier de démarrage commun à tout le système pour chacun des
              interpréteurs interactifs
       /etc/bash.logout
              Le  fichier de nettoyage des interpréteurs de connexion commun à
              tout le système, exécuté  lorsqu’un  interpréteur  de  connexion
              termine
       ~/.bash_profile
              Le   fichier   d’initialisation   personnel   exécuté  pour  les
              interpréteurs de commandes de connexion
       ~/.bashrc
              Le fichier de démarrage personnel, pour chacun des interpréteurs
              interactifs
       ~/.bash_logout
              Le fichier de nettoyage personnel des interpréteurs de commandes
              de connexion, exécuté lorsqu’un  interpréteur  de  commandes  de
              connexion termine
       ~/.inputrc
              Le fichier d’initialisation personnalisée de readline

AUTEURS

       Brian Fox, Free Software Foundation
       bfox@gnu.org

       Chet Ramey, Case Western Reserve University
       chet@po.cwru.edu

SIGNALEMENTS D�’ANOMALIES
       Si  vous trouvez une anomalie dans bash, vous devriez la signaler. Tout
       d’abord vous devez vous assurer qu’il s’agit réellement d’une  anomalie
       et  qu’elle  apparaît bien dans la dernière version de bash disponible.
       La   dernière   version   est   toujours   disponible   à   partir   de
       ftp://ftp.gnu.org/pub/bash/.

       Une  fois que vous avez déterminé qu’une anomalie existe effectivement,
       utilisez la commande bashbug pour envoyer un signalement d’anomalie. Si
       vous avez un correctif, vous êtes encouragé à l’envoyer en même temps !
       Les   suggestions   ou   les   signalements   d’anomalies   de   nature
       « philosophique »  peuvent être envoyés (en anglais) à bug-bash@gnu.org
       ou postés dans le groupe Usenet gnu.bash.bug.

       TOUS les signalements d’anomalie doivent contenir :

       Le numéro de version de bash
       Le matériel et le système d’exploitation utilisés
       Le compilateur utilisé pour compiler
       Une description (en anglais) de l’anomalie
       Un petit script ou une « recette » qui démontre l’anomalie

       bashbug insère automatiquement les trois  premiers  éléments  de  cette
       liste  dans  le  formulaire  qu’il  fournit pour remplir un signalement
       d’anomalie.

       Les commentaires  et  signalement  d’anomalies  concernant  la  version
       originale  de cette page de manuel (en anglais) doivent être transmis à
       chet@po.cwru.edu. Ceux concernant cette version française peuvent  être
       envoyés à debian-l10n-french@lists.debian.org.

ANOMALIES

       Cet interpréteur de commandes est trop gros et trop lent.

       Il  y a quelques différences subtiles de comportement entre bash et les
       versions  traditionnelles   de   sh,   principalement   à   cause   des
       spécifications POSIX.

       L’utilisation des alias peut avoir des conséquences inattendues.

       Les  commandes  internes  et les fonctions de l’interpréteur ne peuvent
       pas être suspendues/relancées.

       Les commandes  composées  et  les  suites  de  commandes  de  la  forme
       « a ; b ; c »  ne sont pas gérées élégamment lors d’une interruption de
       processus. En cas de suspension d’un processus, l’interpréteur  exécute
       immédiatement  la commande suivante. Il suffit de placer cette suite de
       commandes   entre   parenthèses   pour   la   forcer   à    créer    un
       sous-interpréteur, qui, lui, pourra être suspendu en bloc.

       Les  commandes  à  l’intérieur de la substitution de commande $(...) ne
       sont pas analysées avant la tentative de substitution.  Cela  retardera
       l’affichage de messages d’erreurs pendant un certain temps après que la
       commande a été saisie. Par exemple, des parenthèses qui  ne  concordent
       pas,  même  à  l’intérieur  de  commentaires, provoqueront des messages
       d’erreur lorsque la structure sera lue.

       Les variables de type tableau ne peuvent pas (encore) être exportées.

TRADUCTION

       Ce document est  une  traduction  réalisée  par  Christophe  Blaess  et
       Thierry  Vignaud  en  1997, et mise à jour par Alain Portal <aportal AT
       univ-montp2 DOT fr> en 2006.  La version présente  dans  Debian  a  été
       entièrement  retravaillée  et  est  dorénavant  maintenue  par Frédéric
       Lehobey <Frederic AT Lehobey DOT  net>  et  les  membres  de  la  liste
       <debian-l10n-french  AT  lists  DOT debian DOT org>.  Veuillez signaler
       toute erreur de traduction par  un  rapport  de  bogue  sur  le  paquet
       manpages-fr-extra.

Ubuntu manuals

NOM