Provided by: manpages-fr-extra_20111118_all bug

NOM

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

SYNOPSIS

       bash [options] [fichier]

COPYRIGHT

       Bash is Copyright (C) 1989-2009 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  COMMANDES  INTERNES  DE  L'INTERPRÉTEUR  plus  bas).  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  ou  ~/.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 ou 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 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 ni de lire,  ni  d'exécuter
       des  commandes  d'un  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é avec son entrée standard relié à  une  connexion
       réseau,  comme  par le démon lançant les interpréteurs de commandes distants, généralement
       rshd, ou le démon de shell sécurisé sshd. Si bash  conclut  qu'il  est  exécuté  de  cette
       façon,  il  lit  et exécute les commandes de /etc/bash.bashrc et ~/.bashrc si ces fichiers
       existent et sont accessibles en lecture. 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 indiquer.

       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,  les  variables  SHELLOPTS,  BASHOPTS,  CDPATH,  et
       GLOBIGNORE,  si  présentes  dans  l'environnement,  sont  ignorées,  et  l'identifiant  de
       l'utilisateur effectif est configuré à 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  tirets  bas
              (« underscore »), commençant par  une  lettre  ou  un  tiret  bas.  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 GRAMMAIRE DE L'INTERPRÉTEUR plus bas) 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  indique  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 un des
       opérateurs de contrôle | ou |&. 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 indiquée par la commande
       elle-même (voir REDIRECTIONS plus bas). Si |& est utilisé, la sortie d'erreur standard  de
       la  commande_1  est connectée à l'entrée standard de la commande_2 dans le tube ; c'est un
       raccourci pour 2>&1 |. Cette redirection implicite de  la  sortie  d'erreur  standard  est
       réalisée après toute redirection précisée par la commande.

       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 indiqué 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 ;, & ou <newline>.

       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 listes ET et OU sont des suites d'une ou plusieurs conduites  séparées  respectivement
       par  les  opérateurs  de  contrôle  &&  et  ⎪⎪.  Les  listes  ET et OU sont exécutées avec
       associativité à gauche. 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  ENVIRONNEMENT  D'EXÉCUTION  DES
              COMMANDES  plus  bas).  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 un blanc ou un autre métacaractère de l'interpréteur.

       ((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.

              Lorsqu'ils sont utilisés avec [[, les opérateurs < et > ordonnent d'un point de vue
              lexicographique en utilisant les paramètres linguistiques régionaux courants.

              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. Toute partie du motif peut être protégée
              pour la forcer à correspondre  en  tant  que  chaîne.  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-iè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 l'une 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 l'une 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 si l'opérateur ;; est utilisé. Si ;& est
              utilisé au lieu de ;;, l'exécution continue avec la liste associée au jeu de motifs
              suivant. Si ;;& est utilisé au lieu de ;;, l'interpréteur essaye la liste de motifs
              suivant, si elle existe, et exécute toute liste associée à un motif  correspondant.
              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.

   Coprocessus
       Un  coprocessus  est  une  commande  d'interpréteur précédée par le mot réservé coproc. Un
       coprocessus est exécuté de  façon  asynchrone  dans  un  sous-interpréteur,  comme  si  la
       commande  se  terminait  par l'opérateur de contrôle &, avec un tube bidirectionnel établi
       entre l'interpréteur d'exécution et le coprocessus.

       Le format d'un coprocessus est :

              coproc [NOM] commande [redirections]

       Un coprocessus appelé NOM est créé. Si NOM n'est pas fourni, le nom par défaut est COPROC.
       NOM  ne doit pas être fourni si commande est une commande simple (voir plus haut) ; sinon,
       il est interprété comme le premier mot d'une commande simple.  Quand  le  coprocessus  est
       exécuté,  l'interpréteur  crée  une  variable tableau (voir Tableaux plus bas) appelée NOM
       dans le contexte de  l'interpréteur  d'exécution.  La  sortie  standard  de  commande  est
       connecté  par  un  tube à un descripteur de fichier dans l'interpréteur d'exécution, et ce
       descripteur de fichier est affecté à NOM[0]. L'entrée standard de  commande  est  connecté
       par un tube à un descripteur de fichier dans l'interpréteur d'exécution, et ce descripteur
       de fichier est affecté à NOM[1]. Ce tube est établi avant toute redirection  indiquée  par
       la  commande   (voir  REDIRECTIONS  plus  bas).  Les  descripteurs de fichier peuvent être
       utilisés comme arguments  aux  commandes  d'interpréteur  et  redirections  utilisant  les
       développements  standards  de  mot.  L'identifiant  du  processus  (PID) de l'interpréteur
       engendré pour exécuter le coprocessus est disponible comme valeur de la variable NAME_PID.
       La commande interne wait peut être utilisée pour attendre que le coprocessus soit terminé.

       L'état renvoyé d'un coprocessus est l'état final de commande.

   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 n'importe quelle commande décrite dans Commandes composées plus haut. La
              commande-composée est exécutée chaque fois que nom est indiqué comme le  nom  d'une
              commande  normale.  Toutes  les redirections (voir REDIRECTIONS plus bas) indiqué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 ne se produise ou qu'une fonction en lecture seule n'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 COMMANDES INTERNES DE
       L'INTERPRÉTEUR plus bas), un mot commençant par # conduit à 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.

PROTECTIONS

       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
       DÉVELOPPEMENT  DE  L'HISTORIQUE  plus bas), 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 quotes ») et les guillemets doubles (« double quotes »).

       Le  caractère d'échappement est une contre-oblique (\) non protégée. Il préserve la valeur
       littérale du caractère qui le suit, à l'exception du <newline>. Si  un  couple  \<newline>
       apparaît  et  si la contre-oblique n'est pas elle-même protégée, l'ensemble \<newline> est
       considéré comme une continuation  de  ligne  (c'est-à-dire  qu'il  est  supprimé  du  flux
       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 <newline>. 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  !  n'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 indiqué 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
              \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 ;
              \"     guillemet double ;
              \nnn   le caractère 8 bits dont la valeur octale est nnn (un à trois chiffres) ;
              \xHH   le  caractère 8 bits dont la valeur hexadécimale est HH (un ou deux chiffres
                     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 ($"chaîne") 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 dans COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).

       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 COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).

       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
       configuré, 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é positionné, 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 lorsque
       = est utilisé) et les nouvelles valeurs sont ajoutées au tableau, en commençant à l'indice
       maximum  du  tableau plus un (pour les tableaux indicés) ou ajoutées comme comme un couple
       clé-valeur pour un tableau associatif. Lorsque l'opérateur est appliqué à une variable  de
       type chaîne, la valeur est développée et concaténée en 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 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 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 état final 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 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.  Contient  également le chemin d'accès
              complet de chaque commande exécutée et se retrouve dans l'environnement  exporté  à
              cette  commande.  Lors de la vérification de l'arrivée de courrier, contient le nom
              du fichier de courrier en cours de 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.
       BASHOPTS
              Liste des options activées de l'interpréteur, séparées par des  deux-points  « : ».
              Chaque  mot  de  la  liste  est un argument correct pour l'option -s de la commande
              interne shopt (voir COMMANDES INTERNES DE L'INTERPRÉTEUR  plus  bas).  Les  options
              apparaissant  dans BASHOPTS sont celles indiquées comme actives par shopt. Si cette
              variable est dans l'environnement au lancement de bash, chaque option de  la  liste
              est  activée  avant de lire n'importe quel fichier d'initialisation. Cette variable
              est en lecture seule.
       BASHPID
              Se transforme en PID de l'interpréteur bash courant. Diffère de $$  sous  certaines
              conditions,  comme  dans  les  sous-interpréteurs  ne nécessitant pas que bash soit
              réinitialisé.
       BASH_ALIASES
              Une variable de type tableau associatif dont les éléments correspondent à une liste
              interne  d'alias  comme  celle  gérée  par  la commande interne alias. Les éléments
              ajoutés à ce tableau apparaissent dans la liste d'alias ; la destruction d'éléments
              du tableau implique le retrait des alias de la liste.
       BASH_ARGC
              Une  variable  de type tableau contenant le nombre de paramètres de chaque trame de
              la pile d'appel d'exécution de l'interpréteur bash 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  bash  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. BASH_ARGV est créé uniquement dans le mode de traçage étendu
              (voir plus bas la description de l'option extdebug de la commande interne shopt).
       BASH_CMDS
              Une variable de type tableau associatif dont les éléments correspondent à une table
              de hachage interne de commandes comme celle gérée par la commande interne hash. Les
              éléments ajoutés à ce tableau apparaissent dans la  liste  table  de  hachage ;  la
              destruction  d'éléments du tableau implique le retrait des commandes de la table de
              hachage.
       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[$i]}  a été appelé (ou ${BASH_LINENO[$i-1]} si consulté depuis une autre
              fonction  de  l'interpréteur).  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ée  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 (par exemple 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  courante  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_KEY
              La  touche  (ou  dernière  touche  d'une suite de touches) utilisée pour appeler la
              fonction de complètement courante.

       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_TYPE
              Configurée  à une valeur entière correspondant au type de complètement essayé qui a
              provoqué l'appel d'une fonction de complètement : TAB pour un complètement  normal,
              ?  pour  l'affichage  des  complètements  après  tabulations  successives,  !  pour
              l'affichage des alternatives de complètement de mot partiel, @  pour  afficher  les
              complètements si le mot n'est pas modifié, ou % pour le menu de complètement. 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 mot. 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  mots
              individuels  de  la ligne de commande courante. La ligne est découpée en mots comme
              readline la découperait, en utilisant COMP_WORDBREAKS tel  que  décrit  plus  haut.
              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  de  l'une  des  fonctions  en  cours d'exécution dans l'interpréteur.
              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 configurée au nom de la machine courante.

       HOSTTYPE
              Automatiquement configurée en chaîne décrivant 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  configurée  en 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 tel que configuré par la commande cd.

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

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

       OSTYPE Automatiquement configurée en chaîne décrivant 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 tel que configuré 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  Configurée en 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  deux-points  « : ».
              Chaque  mot  de  la  liste  est un argument correct pour l'option -o de la commande
              interne set (voir COMMANDES INTERNES  DE  L'INTERPRÉTEUR  plus  bas).  Les  options
              apparaissant  dans  SHELLOPTS  sont  celles  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 n'importe quel 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".
       BASH_XTRACEFD
              Si configurée à une valeur  entière  correspondant  à  un  descripteur  de  fichier
              correct, bash écrira la trace de sortie si set -x est activé vers ce descripteur de
              fichier. Le descripteur de fichier est fermé quand BASH_XTRACEFD  est  détruite  ou
              qu'une  nouvelle valeur lui est affectée. Détruire BASH_XTRACEFD ou lui affecter la
              chaîne vide conduit la trace de sortie  à  être  envoyé  vers  la  sortie  d'erreur
              standard.  Remarquez que configurer BASH_XTRACEFD à 2 (le descripteur de fichier de
              la sortie d'erreur standard) puis la détruite revient à fermer la  sortie  d'erreur
              standard.
       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 configurée à  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 d'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 application  des
              vérifications   de   HISTCONTROL.   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ée  par  une  contre-oblique ; la contre-oblique 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é par la commande interne history. Si cette variable existe,
              les horodatages sont écrits dans le fichier d'historique afin d'être  conservés  au
              fur  et  à  mesure  des  sessions  de  l'interpréteur. Cela utilise le caractère de
              commentaire  d'historique  pour  distinguer  l'horodatage  des  autres  lignes   de
              l'historique.
       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, ou désigne un fichier  non  accessible
              en  lecture, 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 interneInternal 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 « <space><tab><newline> ».
       IGNOREEOF
              Commande  le  comportement  d'un interpréteur interactif à réception d'un caractère
              EOF (fin de fichier) comme unique saisie. Si elle existe, 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 ne 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_ indiquant 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 configurée à 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
              indiqué.
       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 courrier  électronique  avant  d'afficher
              son  invite  de  base.  Si  cette  variable est inexistante, ou contient une valeur
              strictement négative, l'interpréteur désactive la vérification du courrier.
       MAILPATH
              Une liste de noms de fichiers séparés par des deux-points « : », dans  lesquels  on
              vérifiera  l'arrivée  de  courrier.  Le nom d'un fichier peut être suivi d'un point
              d'interrogation « ? », puis d'une chaîne  de  caractères  indiquant  le  message  à
              afficher  en  cas de courrier. Dans cette chaîne, le paramètre $_ correspond au nom
              du fichier de courrier courant. Exemple :
              MAILPATH='/usr/spool/mail/bfox?"Vous  avez  du  courrier":~/shell-mail?"$_   a   du
              courrier !"'
              Bash  fournit  une  valeur  par  défaut  pour cette variable, mais l'emplacement du
              fichier boîte à lettres dépend du système (par exemple /usr/spool/mail/$USER).
       OPTERR Si positionné à la valeur 1, bash affiche les messages d'erreurs engendrés  par  la
              commande  interne  getopts  (voir  COMMANDES  INTERNES DE L'INTERPRÉTEUR plus bas).
              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  EXÉCUTION  DES  COMMANDES  plus  bas).  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.
       PROMPT_DIRTRIM
              Si elle contient un nombre supérieur à zéro, cette valeur est utilisée comme nombre
              de répertoires finaux à conserver lors du développement des protections  de  chaîne
              d'invite  \w et \W (voir INVITES plus bas). Les caractères supprimés sont remplacés
              par une ellipse.
       PS1    La valeur de ce paramètre est développée puis utilisée  comme  chaîne  d'invite  de
              base (voir INVITES 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 invite de  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 indiquant
              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 valeur  de  temps  ou  autre  information.  Les
              suites de caractères d'échappement et leurs significations sont les suivantes ; les
              crochets 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 valeur supérieure  à  3  sera
              modifiée en 3. Si p n'est pas précisé, la valeur 3 est utilisée.

              Le  l  facultatif  indique  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  configurée en valeur strictement positive, TMOUT est traitée comme le délai par
              défaut pour la commande interne read. La commande select se 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  une  saisie  après  avoir affiché l'invite de base. Bash se 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 nom de répertoire dans lequel bash  crée
              les 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 configurée à la
              valeur exact, la chaîne fournie doit correspondre exactement  au  nom  d'une  tâche
              suspendue ;  si  configurée  à 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 CONTRÔLE DES TÂCHES
              plus bas). Si configurée à toute autre valeur,  la  chaîne  fournie  doit  être  le
              préfixe  du  nom d'une tâche suspendue ; cela fournit une fonctionnalité analogue à
              l'identificateur de tâche %string.

       histchars
              Les deux ou trois caractères commandant le  développement  de  l'historique  et  le
              découpage  en  lexèmes  (voir  DÉVELOPPEMENT  DE L'HISTORIQUE plus bas). Le premier
              caractère est le caractère de développement de l'historique, 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 « ^ »). 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 « # »). 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 de type tableau indicé ou associatif, à  une  dimension.  Toute
       variable peut être utilisée comme tableau indicé ; 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  à  indicer les éléments ou les affecter de façon contiguë. Les
       tableaux  indicés   sont   consultés   avec   des   entiers   (évaluations   arithmétiques
       comprises)commençant  à  zéro ;  les  tableaux associatifs sont consultés avec des chaînes
       arbitraires.

       Un tableau indicé 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
       indicé,  on  utilise  declare -a nom (voir COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).
       declare -a nom[indice] est aussi accepté ; l'indice est ignoré.

       Les tableaux associatifs sont créés en utilisant declare -A nom.

       Des attributs peuvent être indiqué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.  Les  affectations  de
       tableau  indicé  ne  nécessitent ni crochets ni indices. Lors de l'affectation de tableaux
       indicés, 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. L'indexation commence à zéro.

       Lors de l'affectation d'un tableau associatif, l'indice est obligatoire.

       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.

       Tout  élément  d'un  tableau est accessible avec 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 longueur de  l'élément
       ${nom[indice]}.  Si  l'indice  est  * ou @, s'évalue en nombre d'éléments dans le tableau.
       Accéder à une variable tableau sans indice est équivalent à accéder à l'élément de tableau
       d'indice 0.

       Une  variable  tableau est considérée configurée si une valeur a été affectée à un indice.
       La chaîne vide est une valeur correcte.

       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 le développement des chemins. 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
       préciser  un  tableau  indicé  et  une  option  -A pour préciser un tableau associatif. 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 avoir é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  permettent,  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 soit par une série de chaînes séparées par des virgules,
       soit par  l'expression  d'une  série  entre  accolades,  et  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  de série est de la forme {x..y[..incr]}, où x et y sont soit des entiers,
       soit des caractères uniques, et incr, un incrément facultatif, est  un  entier.  Lorsqu'il
       s'agit d'entiers, l'expression est remplacée par la liste des nombres entre x et y inclus.
       Les entiers fournis peuvent être préfixés par 0 pour forcer chaque terme à avoir  la  même
       longueur.  Si  x  ou  y commencent par un zéro, l'interpréteur essaiera de forcer tous les
       termes créés à la même  longueur,  en  ajoutant  des  zéros  au  besoin.  S'il  s'agit  de
       caractères,  l'expression se développe en 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.  Si
       l'incrément  est  fourni,  il est utilisé comme différence entre chaque terme. L'incrément
       par défaut est 1 ou -1 suivant les valeurs de x et y.

       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 ouvrante et
       fermante non protégées et au moins une virgule non protégée ou  une  expression  de  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 le mot file{1,2} est fourni
       à sh, il reste inchangé en sortie. En revanche, 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
       COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).

   Développement du tilde
       Si  un  mot  commence  par  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
       identifiant de connexion possible. 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  n'existe  pas,
       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 indiqué.

       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 facultatives mais permettant d'éviter le développement
       de  la  variable  à  partir  de caractères la suivant immédiatement et 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  « } » ni protégé par une contre-oblique, ni inclus dans une chaîne protégée, 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écessaires 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'imbrication 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 imbriqué. Les exceptions à celui-ci
       sont les développements de ${!préfixe*} et  de  ${!nom[@]}  décrits  plus  bas.  Le  point
       d'exclamation   doit   immédiatement   suivre   l'accolade   ouvrante   afin  d'introduire
       l'imbrication.

       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,  en  utilisant  les  formes
       documentées  ci-dessous,  bash  teste si le paramètre est inexistant ou vide. L'absence de
       deux-points induit un test sur la seule inexistence du paramètre.uand il n'effectue pas de
       développem

       ${paramètre:-mot}
              Utilisation  de  valeur  par  défaut.  Si  le  paramètre est inexistant ou vide, le
              développement du mot est substitué. Sinon, c'est la valeur  du  paramètre  qui  est
              substituée.
       ${paramètre:=mot}
              Affectation  de  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  de  valeur  alternative.  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}
              Développement des  sous-chaînes.  Se  développe  pour  fournir  la  sous-chaîne  de
              longueur  indiqué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 valeur 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.
              Le  développement  de  sous-chaîne  s'applique  aux tableaux associatifs. 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  par  défaut.  Si  début  est 0, et que les paramètres
              positionnels sont utilisés, la liste sera préfixée par $0.

       ${!préfixe*}
       ${!préfixe@}
              Noms correspondant au préfixe. Se développe en noms des  variables  dont  les  noms
              commencent  par  préfixe,  séparés par le premier caractère de la variable spéciale
              IFS. Si @ est utilisé et que le développement apparaît  entre  guillemets  doubles,
              chaque nom de variable se développe séparément.

       ${!nom[@]}
       ${!nom[*]}
              Liste  des  clefs  du  tableau.  Si  nom  est une variable de type tableau, elle se
              développe en 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}
              Longueur du 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 du tableau.

       ${paramètre#mot}
       ${paramètre##mot}
              Retrait du motif correspondant au préfixe. 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}
              Retrait du motif correspondant au suffixe. 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}
              Substitution de motif. 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 / suivant 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.

       ${paramètre^motif}
       ${paramètre^^motif}
       ${paramètre,motif}
       ${paramètre,,motif}
              Modification de  la  casse.  Ce  développement  modifie  la  casse  des  caractères
              alphabétiques  du  paramètre.  Le mottif est développé pour fournir un motif, comme
              dans le développement des chemins. L'opérateur ^ convertit  les  lettre  minuscules
              correspondant  à  ce  motif  en  majuscule ;  l'opérateur  ,  convertit  les lettre
              majuscules correspondant à ce motif en  minuscule.  Les  développements  ^^  et  ,,
              convertissent  tous  les  caractères  correspondant  à leur valeur développée ; les
              développements ^ et , convertissent seulement le premier  caractère  de  la  valeur
              développée  correspondant.  Si  motif  est  omis,  il est traité comme un ?, ce qui
              correspond à n'importe quel caractère. Si le paramètre est @ ou *, la  modification
              de  casse s'applique à 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
              *,  la  modification de casse 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 <space><tab><newline>, la  valeur  par  défaut,  alors  les
       suites  de  caractères  <space>,  <tab>  et <newline> au début ou à la fin du résultat des
       développements précédents sont ignorés, et toute suite de caractères de IFS ni au début ni
       à  la fin 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 n'est pas activé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 à n'importe quel chaîne, chaîne vide comprise. Si l'option  globstar  de
              l'interpréteur  est activée, et que * est utilisé dans un contexte de développement
              des chemins, deux * adjacents sont utilisés pour un seul motif correspondant à tous
              les  fichier  et  zéro  ou  plus de répertoires et sous-répertoires. Lorsqu'il sont
              suivis  de  /,  deux  *  adjacents  correspondront  seulement  aux  répertoires  et
              sous-répertoires.
       ?      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  à  n'importe  quel  caractère 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.

       Toutes  les  redirections  pouvant  être précédées par un numéro de descripteur de fichier
       peuvent aussi être précédées par un mot de la forme {nom_de_variable}. Dans ce  cas,  pour
       chaque  opérateur de redirection à part >&- et <&-, l'interpréteur de commande allouera un
       descripteur de fichier supérieur à 10 et l'affectera à nom_de_variable. Si >&- ou <&-  est
       précédé  de  {nom_de_variable},  la  valeur  de  nom_de_variable définit le descripteur de
       fichier à fermer.

       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 de  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.

       Un échec à l'ouverture ou à la création de fichier conduit à l'échec de la redirection.

       Les redirections utilisant des descripteurs  de  fichiers  supérieurs  à  9  doivent  être
       utilisées  avec  précaution  car  des  conflits  peuvent survenir avec les descripteurs de
       fichiers utilisés en interne par l'interpréteur.

       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 indiqué.

       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 indiqué. Si le fichier n'existe pas, il est
       créé. S'il existait déjà, sa taille est réduite à zéro.

       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 indiqué. 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
       Cette  construction 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.

       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

   Ajout de la sortie standard et de la sortie d'erreur standard
       Cette construction permet l'ajout simultané 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.

       La forme pour ajouter les sortie standard et sortie d'erreur standard est :

              &>>mot

       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  délimiteur  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 n'importe quel
       caractère 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 \<newline> 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 indiqué. 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 indiqué.

   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  COMMANDES INTERNES DE
       L'INTERPRÉTEUR plus bas). 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  la
       description de shopt dans COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).

       Les  règles concernant la définition et l'utilisation des alias sont un peu confuses. Bash
       lit toujours au moins une ligne d'entrée complètement avant d'exécuter une  des  commandes
       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.

       Les alias sont  surpassés  par  les  fonctions  de  l'interpréteur  dans  la  plupart  des
       situations.

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 contient le 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, aux exceptions suivantes : les captures de DEBUG
       et  RETURN  (voir  la  description  de la commande interne trap dans COMMANDES INTERNES DE
       L'INTERPRÉTEUR plus bas) ne sont pas héritées,  à  moins  que  l'attribut  trace  ne  soit
       positionné  pour la fonction (voir la description de la commande interne declare plus bas)
       ou que l'option d'interpréteur -o functrace n'ait été activée avec la commande interne set
       (auquel  cas  toutes  les  fonctions  hériteront  des  captures de DEBUG et RETURN), et la
       capture ERR n'est pas héritée à moins que l'option d'interpréteur -o  errtrace  n'ait  été
       activée.

       Les  variables  locales  d'une  fonction  peuvent  être déclarées avec la commande interne
       local. Dans le cas général, les  variables  et  leurs  valeurs  sont  partagées  entre  la
       fonction et le contexte d'appel.

       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 la fonction.

       Les  noms  de  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 de 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
       - +    moins et plus 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

       Les  variables  de  l'interpréteur  sont utilisables 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  vide   ou
       inexistante est évaluée à 0 lorsqu'elle est consultée 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'elle est consultée, ou lorsqu'une valeur lui est affecté alors que son
       attribut integer (entier) a été positionné en utilisant declare -i. Une  valeur  vide  est
       évaluée  à 0. Une variable d'interpréteur n'a donc pas besoin d'avoir son attribut integer
       positionné pour être utilisable dans un calcul.

       Les constantes commençant par 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 où 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 sont 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 n'importe quel 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.

       Lorsqu'ils sont utilisés avec [[, les opérateurs <  et  >  ordonnent  d'un  point  de  vue
       lexicographique en utilisant les paramètres linguistiques régionaux courants.

       Voir la description de la commande interne test (voir 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 positionné.
       -h fichier
              Vrai si le fichier existe et est un lien symbolique.
       -k fichier
              Vrai si le fichier existe et a son bit « sticky » positionné.
       -p fichier
              Vrai si le fichier existe et est un tube nommé (FIFO).
       -r fichier
              Vrai si le fichier existe et est accessible en lecture.
       -s fichier
              Vrai si le fichier existe et a une taille 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 positionné.
       -w fichier
              Vrai si le fichier existe et est accessible en écriture.
       -x fichier
              Vrai si le fichier existe et est exécutable.
       -O fichier
              Vrai si le fichier existe et appartient à l'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 ancien que le fichier_2 ou si fichier_2 existe et non
              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'inœuds.
       -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
       chaîne_1 = chaîne_2
              Vrai si les deux chaînes sont égales. Le symbole = devrait  être  utilisé  avec  la
              commande test pour être en 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.

       chaîne_1 > chaîne_2
              Vrai si chaîne_1 se trouve après chaîne_2 dans l'ordre lexicographique.

       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  signe  =  de  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  l'une  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 la
       commande hash dans COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas). 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 recherche une  fonction
       de  l'interpréteur  appelée  command_not_found_handle.  Si cette fonction existe, elle est
       appelée avec pour arguments la commande d'origine et ses arguments, et l'état final de  la
       fonction  devient  l'état  final  de  l'interpréteur. Si cette fonction n'est pas définie,
       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 configuré au nom indiqué et les éventuels arguments restants de
       la commande sont configurés 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 dans COMMANDES INTERNES  DE  L'INTERPRÉTEUR
       plus bas).

       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  l'interprète  indiqué
       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 configuré par cd, pushd ou  popd  ou  hérité
              par l'interpréteur à son appel ;

       ·      le  masque  de création de fichier comme configuré par umask ou hérité du parent de
              l'interpréteur ;

       ·      les captures courantes configurées par trap ;

       ·      les paramètres de l'interpréteur configurés par des affectations de variables, 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 ;

       ·      les 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 différente d'une commande interne ou d'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
              précisé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,  mais  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'un
       sous-interpréteur n'affectent aucunement l'environnement d'exécution de l'interpréteur.

       Les  sous-interpréteurs engendrés pour exécuter les substitutions de commande héritent des
       valeurs de l'option -e de l'interpréteur parent. En dehors  du  mode  posix,  bash  efface
       l'option -e de tels sous-interpréteurs.

       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, sans les éléments supprimés par la commande unset, et avec
       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 configurée (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 configurée  en  chemin  d'accès
       complet à cette commande et elle est transmise dans l'environnement.

ÉTAT FINAL

       L'état final d'une commande exécutée est la valeur renvoyée par l'appel système waitpid ou
       fonction équivalente. Les états finaux prennent leurs valeurs entre 0 et  255,  néanmoins,
       comme  expliqué  plus  bas,  l'interpréteur peut utiliser les valeurs supérieures à 125 de
       façon particulière. Les états finaux des commandes internes et  composées  sont  également
       limitées  à  cette  plage. Sous certaines conditions, l'interpréteur utilisera des valeurs
       particulières pour indiquer des modes d'échec particuliers.

       Du point de vue de l'interpréteur, une commande qui termine avec état final valant 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 se 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 ne 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 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 configurés 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
       COMMANDES  INTERNES  DE  L'INTERPRÉTEUR  plus  bas) ou marquée comme exemptée de SIGHUP en
       utilisant disown -h.

       Si l'option d'interpréteur huponexit a été configurée 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é configurée, 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é configurée 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 noyau de système d'exploitation 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 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,  si  l'utilisateur
       l'indique  avec  stty  tostop,  y  écrire.  Les  processus en arrière-plan qui tentent une
       lecture (ou une écriture si stty tostop est actif) dans le terminal  reçoivent  un  signal
       SIGTTIN (SIGTTOU) émis par le pilote du terminal du noyau, 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.

       Plusieurs façons permettent de se rapporter à une tâche.  Le  caractère  %  introduit  une
       spécification de tâche (jobspec). Il est possible de se rapporter à la tâche numéro n avec
       %n. Il est également possible de se rapporter à une tâche en utilisant un préfixe  du  nom
       utilisé  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 %-. Si une seule tâche existe, %+  et  %-  peuvent  tous  deux  être
       utilisés  pour  se  rapporter  à cette tâche. 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 visant à terminer bash est réalisée alors que des tâches sont  suspendues
       (ou,  si l'option d'interpréteur checkjobs a été activée par la commande interne shopt, en
       cours d'exécution), l'interpréteur affiche un message  d'avertissement,  et,  si  l'option
       d'interpréteur  checkjobs  est  activée,  affiche  la  liste les tâches et leurs états. La
       commande jobs peut alors être utilisée pour examiner leur état. Si une deuxième  tentative
       est  faite  pour 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 caractères spéciaux protégés 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 la 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 au format HH:MM sur 12 heures ;
              \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 « ~ » (utilise
                     la valeur de la variable PROMPT_DIRTRIM) ;
              \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 ;
              \]     finit 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 ait é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 la description de  shopt  dans
       COMMANDES INTERNES DE L'INTERPRÉTEUR plus bas).

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 COMMANDES INTERNES DE L'INTERPRÉTEUR  plus
       bas).

   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 exemple 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  (« kill  ring »).  Les  suppressions  successives   conduisent   à
       l'accumulation  du texte en un seul bloc qui peut être récupéré en une fois. Les commandes
       non destructives séparent les blocs de textes dans le tampon circulaire.

   Initialisation de readline
       Readline est personnalisé en plaçant 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  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 indiqué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 indiqué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 (un à trois chiffres) ;
              \xHH   le caractère 8 bits dont la valeur hexadécimale est HH (un ou deux  chiffres
                     hexadécimaux) ;

       Lorsqu'on  saisit le texte d'une macro, il faut utiliser des guillemets simples ou 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  COMMANDES  INTERNES  DE
       L'INTERPRÉTEUR plus bas).

   Variables de readline
       Readline dispose de variables permettant de personnaliser encore  plus  son  comportement.
       Une variable peut être configurée 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
              configurée à none, readline  n'émet  jamais  d'alarme.  Si  configurée  à  visible,
              readline  utilise  une  alarme visuelle s'il y en a une disponible. Si configurée à
              audible, readline essaie de faire sonner l'alarme du terminal.
       bind-tty-special-chars (On)
              Si configurée à 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 configurée à On, readline effectue les correspondances et complètements de  noms
              de fichiers sans tenir compte de la casse.
       completion-prefix-display-length (0)
              La  longueur,  en  caractères,  du  préfixe  commun  d'une  liste  de complètements
              possibles affiché sans modification. Si configurée en valeur positive, les préfixes
              communs  plus  longs  que  cette  valeur  sont  remplacés  par  une ellipse lors de
              l'affichage des complètements possibles.
       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 configurée à 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 configurée à 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 configurée à 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 positionné soit à emacs, soit à vi.
       echo-control-characters (On)
              Si configurée à On, sur les systèmes d'exploitation le permettant, readline affiche
              un caractère correspondant à un signal provenant du clavier.
       enable-keypad (Off)
              Quand  configurée  à  On,  readline  essayera  d'activer  le  pavé   numérique   de
              l'application  une  fois  appelée.  Sur  certains  systèmes,  c'est nécessaire pour
              utiliser les flèches.
       enable-meta-key (On)
              Quand  configurée  à  On,  readline  essayera  d'activer  toutes  les  touches   de
              modificateur  Méta  que  le terminal peut prendre en charge une fois appelé. Sur de
              nombreux terminaux, la touche Méta est utilisée pour saisir des caractères sur huit
              bits.
       expand-tilde (Off)
              Si  configurée  à On, le développement du tilde est effectué lorsque readline tente
              un complètement de commandes.
       history-preserve-point (Off)
              Si configurée à On, le programme d'historique tente de placer le  curseur  au  même
              endroit   sur   chaque   ligne  d'historique  récupérée  avec  previous-history  ou
              next-history.
       history-size (0)
              Configure le nombre  d'éléments  sauvegardés  dans  la  file  de  l'historique.  Si
              configurée  à  zéro,  le  nombre  d'éléments  de  la file de l'historique n'est pas
              limité.
       horizontal-scroll-mode (Off)
              Quand configurée à 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 configurée à 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 de caractères qui doit 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 configurée à On, une barre oblique est ajoutée aux noms de répertoires.
       mark-modified-lines (Off)
              Si configurée à 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 configurée à On, une barre oblique est ajoutée aux noms complétés si ce sont des
              liens symboliques vers des répertoires (selon la valeur de mark-directories).
       match-hidden-files (On)
              Cette  variable,  quand  elle  est  configurée  à  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  ne  soit  fourni
              par l'utilisateur dans le nom de fichier à compléter.
       output-meta (Off)
              Si  configurée  à  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  configurée  à  On,  readline utilise un afficheur de texte interne du type more
              pour afficher les complètements possibles sur un seul plein écran.
       print-completions-horizontally (Off)
              Si configurée à On,  readline  affichera  les  complètements  correspondants  triés
              horizontalement dans l'ordre alphabétique plutôt que verticalement.
       revert-all-at-newline (Off)
              Si  configurée  à  On,  readline  annulera  toutes  les  modifications  des  lignes
              d'historique avant de s'arrêter quand  accept-line  est  exécuté.  Par  défaut  les
              lignes  d'historique  peuvent  être modifiées et conservent les listes d'annulation
              individuelles au fur et à mesure des appels à readline.
       show-all-if-ambiguous (Off)
              Ceci  modifie  le  comportement  par  défaut  des  fonctions  de  complètement.  Si
              configurée  à  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 configurée à 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.
       skip-completed-text (Off)
              Si configurée à On, modifie le comportement par  défaut  du  complètement  lors  de
              l'insertion d'une unique correspondance dans la ligne. Elle n'est utilisée que lors
              d'un complètement effectué au milieu  d'un  mot.  Si  elle  est  activée,  readline
              n'insère  pas  de  caractères de complètement correspondant à des caractères situés
              après le curseur dans le mot en train d'être complété, ainsi les  parties  du  mots
              situées après le curseur ne sont pas dupliquées.
       visible-stats (Off)
              Si  configurée  à  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  configurer  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. Ce  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 n'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).
       shell-forward-word
              Avancer jusqu'à la fin du mot suivant. Les mots sont séparés par des métacaractères
              non protégés de l'interpréteur.
       shell-backward-word
              Reculer  jusqu'au  début  du mot courant ou du précédent. Les mots sont séparés par
              des métacaractères non protégés de l'interpréteur.
       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 ligne d'historique modifiée, 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é indiqué.
       yank-last-arg (M-., M-_)
              Insérer  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é indiqué.
       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 d'historique, ainsi que tous les développements de mot
              de  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, $VISUAL, $EDITOR
              et emacs comme éditeur.

   Commande d'édition de texte
       delete-char (C-d)
              Effacer le caractère sous le curseur. Si la  ligne  est  vide  et  que  le  dernier
              caractère saisi n'était pas associé à delete-char, alors renvoyer EOF.
       backward-delete-char (Effacement ou « Rubout »)
              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.
       shell-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 shell-forward-word.
       shell-backward-kill-word (M-Effacement)
              Effacer le mot sous le curseur. Les  limites  de  mots  sont  identiques  à  celles
              utilisées par shell-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
              Effacer le texte de 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 d'indiquer 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.
       menu-complete-backward
              Identique  à  menu-complete,  mais  se  déplace  en  arrière  dans  la  liste   des
              complètements   possibles,   comme  si  un  argument  négatif  avait  été  passé  à
              menu-complete. Cette commande n'est associée à aucune touche 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.
       dabbrev-expand
              Essayer  le  menu  de 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 configurée à
              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.
       skip-csi-sequence
              Lit  suffisamment  de  caractères pour consommer une suite multitouche comme celles
              définies pour des touches comme Début et Fin. De telles suites  commencent  par  un
              indicateur   de   suite  de  contrôle  (« control  sequence  indicator »  ou  CSI),
              habituellement ESC-[.  Si  cette  suite  est  associée  à  "\[",  les  touches  qui
              produisent  de  telles  suites  n'auront  pas  d'effet à moins d'être explicitement
              associées à une commande readline, au lieu d'insérer des caractères égarés dans  le
              tampon  d'édition.  N'est  associée  à  aucune  touche par défaut, mais est souvent
              associé à ESC-[.
       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 de 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 flux 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 flux  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-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 de façon à ê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  COMMANDES  INTERNES  DE  L'INTERPRÉTEUR  plus  bas),  les  outils  de  complètement
       programmables sont appelés.

       En  premier  lieu,  le  nom  de  la commande est identifié. Si le mot de commande est vide
       (complètement essayé en début de ligne vide), toutes les  spécifications  de  complètement
       définies  par l'option -E de complete sont utilisées. 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  partie  située  après  la  barre  oblique  finale.  Si ces recherches ne donnent aucun
       résultat sous forme  de  spécification  de  complètement,  toutes  les  spécifications  de
       complètement définies par l'option -D de complete sont utilisées par défaut.

       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  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  indiqués  par le motif de développement de chemin 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 indiqué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. Les protections de l'interpréteur sont  prises  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 la création de ces correspondances, toute fonction  de  l'interpréteur  ou  commande
       indiquée  avec  les  options  -F et -C est appelée. Lorsque la commande ou la fonction est
       appelée, les variables COMP_LINE, COMP_POINT,  COMP_LINKEY,  et  COMP_POINTYPE  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 indiqué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  indiqué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 la création de tous les complètements possibles, tout filtre, indiqué avec  l'option
       -X,  est  appliqué  à  la  liste.  Ce  filtre est un motif comme 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 indiqué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  de  fichiers  par
       défaut de readline est désactivé. 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  produit  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.

       La modification dynamique des complètements est également possible. C'est particulièrement
       utile combiné avec un complètement par  défaut  indiqué  à  l'aide  de  complete  -D.  Les
       fonctions  de  l'interpréteur  exécutés  comme  gestionnaires  de  complètement permettent
       d'annoncer que le complètement devrait être réessayé en renvoyant un état final de 124. Si
       une  fonction  de  l'interpréteur renvoie 124, et modifie la spécification de complètement
       associée à la commande sur laquelle le complètement  est  essayé  (fournie  comme  premier
       argument  quand  la fonction est exécutée), le complètement programmable recommence depuis
       le début, en essayant de trouver une spécification de complètement pour cette commande. Un
       jeu  de  complètements peut ainsi être construit dynamiquement lorsque le complètement est
       essayé, plutôt que d'être chargé entièrement au début.

       Par  exemple,  en  supposant  l'existence  d'une   bibliothèque   de   spécifications   de
       complètement,  chacune  conservée  dans un fichier correspondant au nom de la commande, la
       fonction de complètement  par  défaut  suivante  chargerait  les  complètements  de  façon
       dynamique :

       _completion_loader()
       {
            . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124
       }
       complete -D -F _completion_loader

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 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
       précisé  par HISTFILESIZE. Quand le fichier d'historique est lu, les lignes commençant par
       le  caractère  de  commentaire  d'historique  suivi  immédiatement  par  un  chiffre  sont
       considérées  comme  des  horodatages  de la ligne d'historique précédente. Ces horodatages
       sont facultativement affichés en fonction de la  valeur  de  la  variable  HISTTIMEFORMAT.
       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 la description de shopt dans COMMANDES INTERNES DE L'INTERPRÉTEUR plus
       bas), 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é. Si  la  variable  HISTTIMEFORMAT  est  configurée,  les
       horodatages  sont  écrits  dans  le  fichier  d'historique,  repérés  par  le caractère de
       commentaire d'historique, afin d'être conservés  au  fur  et  à  mesure  des  sessions  de
       l'interpréteur.  Le  caractère  de  commentaire  d'historique  est utilisé pour distinguer
       l'horodatage des autres lignes de l'historique. 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  COMMANDES  INTERNES  DE  L'INTERPRÉTEUR  plus  bas)  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 COMMANDES INTERNES DE
       L'INTERPRÉTEUR   plus   bas).  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
       flux  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 du développement de  l'historique.  Si  l'option  d'interpréteur
       histverify  est  activée (voir la description de la commande interne shopt plus bas) et si
       readline est utilisée, les substitutions d'historique 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). L'interpréteur utilise le caractère de commentaire  d'historique  pour
       repérer l'horodatage lors de l'écriture du fichier d'historique.

   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      Supprime 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      Supprime tout sauf le suffixe final.
       p      Affiche la nouvelle commande sans l'exécuter.
       q      Protège les mots substitués, pour éviter des substitutions futures.
       x      Protège les mots substitués comme avec q, mais avec séparation des mots aux  blancs
              et sauts de ligne.
       s/ancien/nouveau/
              Remplace  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 configuré 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ète 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      Applique le modificateur « s » suivant une fois à  chacun  des  mots  de  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 par - accepte également la notation --  pour  signaler  la
       fin  des  options. Les commandes internes :, true, false et test n'acceptent aucune option
       et -- est ignoré. Les commandes internes exit,  logout,  break,  continue,  let  et  shift
       acceptent  et  traitent les arguments commençant par - sans avoir besoin de --. Les autres
       commandes internes qui acceptent les arguments mais qui ne sont pas déclarés explicitement
       comme  acceptant  des options considèrent les arguments commençant par - comme des options
       non valides, donc -- est obligatoire pour éviter cette interprétation.
       : [arguments]
              Sans effet ; cette commande ne fait rien d'autre que développer  les  arguments  et
              effectuer toute redirection indiquée. Un code final de zéro est renvoyé.

        .  fichier [arguments]
       source fichier [arguments]
              Lit  et  exécute  les  commandes  contenues  dans  fichier  avec l'environnement de
              l'interpréteur courant, puis renvoie 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'un nom n'ait été
              indiqué 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 sauf si le contrôle  des  tâches  est  désactivé,  ou,
              quand  le contrôle des tâches est activé, si une tâche précisée n'a pas été trouvée
              ou a é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     Afficher  les  noms  des  fonctions  readline et leurs raccourcis de façon à
                     pouvoir les relire.
              -P     Afficher les noms des fonctions readline et leurs raccourcis.
              -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.
              -v     Afficher les noms des variables readline et leurs valeurs de façon à pouvoir
                     les relire.
              -V     Afficher les noms des variables readline et leurs valeurs.
              -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
                     Conduire  la  commande_de_l'interpréteur  à être exécutée chaque fois que la
                     suite_de_touches  est  saisie.  Quand  la   commande_de_l'interpréteur   est
                     exécutée,  l'interpréteur  configure la variable READLINE_LINE au contenu du
                     tampon de ligne de readline et la  variable  READLINE_POINT  à  la  position
                     courante du curseur d'insertion. Si la commande exécutée modifie les valeurs
                     de READLINE_LINE ou READLINE_POINT, ces nouvelles valeurs seront  prises  en
                     considération dans l'état d'édition.

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

       break [n]
              Sort d'une boucle for, while, until ou select. Si n est indiqué, sort 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 n  ne  soit
              pas plus grand ou égal à 1.

       builtin commande_interne [arguments]
              Exécute  la  commande  interne  de  l'interpréteur  indiquée,  en  lui  passant les
              arguments, puis renvoie son état final. Ceci  est  utile  lorsqu'une  fonction  est
              définie avec le même nom qu'une commande interne, et que cette commande est appelée
              depuis l'intérieur de la fonction. La commande interne cd est souvent redéfinie  de
              cette  façon. L'état renvoyé est faux si la commande_interne n'est pas une commande
              interne de l'interpréteur.

       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.

       cd [-L|-P] [rép]
              Remplace  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 indique 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.

       command [-pVv] commande [arguments ...]
              Lance  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 l'option -V ou -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 indiqué, seuls
              les complètements qui correspondent à mot sont affichés.

              La valeur renvoyée est vrai, sauf si une option incorrecte  a  été  fournie  ou  si
              aucune correspondance n'a été produite.

       complete  [-abcdefgjksuv]  [-o  option-complètement]  [-DE]  [-A  action] [-G globpat] [-W
       liste_de_mots] [-F fonction] [-C commande]
              [-X motif_filtre] [-P préfixe] [-S suffixe] nom [nom ...]
       complete -pr [-DE] [nom ...]
              Indique 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.  L'option
              -D  indique  que  les  options  restantes et les actions devraient s'appliquer à la
              commande de complètement par « défaut », c'est-à-dire le  complètement  essayé  sur
              une  commande  pour  laquelle  aucun  complètement  n'a  été  préalablement défini.
              L'option -E indique que les options restantes et les actions devraient  s'appliquer
              à la commande de complètement « vide », c'est-à-dire le complètement essayé sur une
              ligne vide.

              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 indiqué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 éviter leur développement avant que la commande interne complete ne
              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,  protéger  les  caractères  spéciaux ou
                              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 création  de  toutes  les  correspondances  définies  par  la
                              spécification de complètement, 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 indiquée avec -a.
                      arrayvar
                              Noms de variable de type tableau.
                      binding Noms de raccourci clavier readline.
                      builtin Noms de commandes internes de l'interpréteur. Peut  également  être
                              indiquée avec -b.
                      command Noms de commande. Peut également être indiquée avec -c.
                      directory
                              Noms de répertoire. Peut également être indiquée avec -d.
                      disabled
                              Noms de commandes internes de l'interpréteur désactivées.
                      enabled Noms de commandes internes de l'interpréteur activées.
                      export  Noms  de variables de l'interpréteur exportées. Peut également être
                              indiquée avec -e.
                      file    Noms de fichier. Peut également être indiquée avec -f.
                      function
                              Noms de fonctions de l'interpréteur.
                      group   Noms de groupe. Peut également être indiquée avec -g.
                      helptopic
                              Sujets de l'aide acceptés par la commande interne help.
                      hostname
                              Noms de machine tels qu'ils sont extraits du fichier indiqué par la
                              variable de l'interpréteur HOSTFILE.
                      job     Noms  de  tâche si le contrôle des tâches est actif. Peut également
                              être indiquée avec -j.
                      keyword Mots réservés de l'interpréteur. Peut également être indiquée  avec
                              -k.
                      running Noms  de  tâches en cours d'exécution si le contrôle des tâches est
                              actif.
                      service Noms de service. Peut également être indiqué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 de signaux.
                      stopped Noms de tâches suspendues si le contrôle des tâches est actif.
                      user    Noms d'utilisateur. Peut également être indiquée avec -u.
                      variable
                              Noms de toutes les variables de l'interpréteur. Peut également être
                              indiquée avec -v.
              -G globpat
                      Le motif de développement des chemins 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 chemins. 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 préfixe
                      préfixe  est  ajouté  au  début  de  chaque  complètement  possible   après
                      application de toutes les autres options.
              -S suffixe
                      suffixe  est  ajouté  à  chaque  complètement possible après application de
                      toutes les autres options.

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

       compopt [-o option] [-DE] [+o option] [nom]
              Modifie les options de complétion pour chaque nom en fonction des options, ou  pour
              le  complètement  en  cours d'exécution si aucun nom n'est fourni. Si aucune option
              n'est donnée, affiche les  options  de  complétion  pour  chaque  nom  ou  pour  le
              complètement  courant.  Les  valeurs  possible  d'option  sont les options valables
              décrites plus haut pour la commande interne complete. L'option -D indique  que  les
              options   restantes   et  les  actions  devraient  s'appliquer  à  la  commande  de
              complètement par « défaut » ; c'est-à-dire le complètement essayé sur une  commande
              pour  laquelle aucun complètement n'a été préalablement défini. L'option -E indique
              que les options restantes et les actions devraient s'appliquer  à  la  commande  de
              complètement par « vide » ; c'est-à-dire le complètement essayé sur une ligne vide.

       La  valeur  renvoyée  est  vrai,  à moins qu'une option incorrecte ait été fournie, qu'une
       tentative ait été faite pour modifier les options pour un nom pour lequel il n'existe  pas
       de spécification de complètement, ou bien qu'une erreur de sortie soit survenue.

       continue [n]
              Reprend l'exécution à l'itération suivante d'une boucle for, while, until ou encore
              select. Si n est indiqué, reprend 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 n ne soit plus grand ou égal à 1.

       declare [-aAfFilrtux] [-p] [nom[=valeur] ...]
       typeset [-aAfFilrtux] [-p] [nom[=valeur] ...]
              Déclare  des  variables  ou leur fournit des attributs. Si aucun nom n'est indiqué,
              affiche les valeurs des variables. L'option  -p  affichera  les  attributs  et  les
              valeurs  de  chaque  nom. Quand -p est utilisée avec des arguments nom, les options
              supplémentaires sont ignorées. Quand -p est fourni sans argument nom, les attributs
              et  valeurs  de  toutes  les variables ayant des attributs indiqués par les options
              additionnelles seront affichés. Si aucune  autre  option  n'est  fournie  avec  -p,
              declare   affichera   les   attributs   et  valeurs  de  toutes  les  variables  de
              l'interpréteur. L'option -f limite l'affichage  aux  fonctions  de  l'interpréteur.
              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  indicé  (voir  Tableaux  plus
                     haut).
              -A     Chaque  nom  est une variable de type tableau associatif (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  plus  haut)  est  effectuée  lorsqu'une valeur est
                     affectée à la variable.
              -l     Quand cette variable contient  une  valeur,  toutes  les  majuscules  seront
                     converties en minuscules. L'attribut majuscule est désactivé.
              -r     Rendre  les  noms accessibles en lecture seule. Plus aucune valeur ne pourra
                     leur être affectée et ils ne pourront plus être détruits.
              -t     Donner à 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.
              -u     Quand cette variable contient  une  valeur,  toutes  les  minuscules  seront
                     converties en majuscules. L'attribut minuscule est désactivé.
              -x     Marquer  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é, aux
              exceptions  que  +a  ne peut pas être utilisé pour détruire une variable tableau et
              que +r n'enlèvera pas l'attribut lecture seule. Quand utilisé  dans  une  fonction,
              chaque  nom  devient local, comme avec la commande local. Si un nom de variable est
              suivi par =valeur, la valeur de cette variable est configurée à valeur.  La  valeur
              renvoyée  est 0, sauf si une option incorrecte est rencontrée, si une tentative est
              faite de définir une fonction en utilisant ``-f foo=bar'',  si  une  tentative  est
              faite  d'affecter  une valeur à une variable en lecture seule, si une tentative est
              faite d'affecter une valeur  à  une  variable  tableau  sans  employer  la  syntaxe
              d'affectation  composée  (voir Tableaux plus haut), si un des noms n'est pas un nom
              correct pour une  variable  de  l'interpréteur,  si  une  tentative  est  faite  de
              supprimer  l'attribut  lecture-seule  d'une  variable  en  lecture  seule,  si  une
              tentative est faite de supprimer l'attribut tableau d'une variable tableau,  ou  si
              une tentative est faite avec -f d'afficher une fonction inexistante.

       dirs [+n] [-n] [-cplv]
              Sans  option,  affiche la liste des répertoires actuellement mémorisés. L'affichage
              par défaut est réalisé sur une seule ligne, les noms de répertoires  étant  séparés
              par  des espaces. Les répertoires sont ajoutés à la liste avec la commande pushd et
              supprimés avec la commande popd.
              +n     Afficher 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     Afficher  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     Produire 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, sauf si  une  option  incorrecte  a  été  fournie  ou  si
              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 aucune
              tâche n'est précisée, et que ni -a ni -r n'est fournie, la notion d'interpréteur de
              tâche  courante  est  utilisée.  Si  l'option  -h  est indiquée, aucune tâche n'est
              supprimée de la table, mais chaque tâche est 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,
              sauf si tâche n'indique 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 indiqué, 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     supprime tout affichage suivant ;
              \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 est nnn (zéro à  trois  chiffres
                     octaux) ;
              \xHH   le  caractère 8 bits dont la valeur hexadécimale est HH (un ou deux chiffres
                     hexadécimaux) ;

       enable [-a] [-dnps] [-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  à  indiquer  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  désactivations.  Si
              -s  est  fournie,  la sortie est limitée aux commandes internes spéciales POSIX. La
              valeur renvoyée est 0, sauf si nom n'est pas une commande interne ou qu'il y a  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 raison
              quelconque,  un  interpréteur  non  interactif  termine,  sauf   si   l'option   de
              l'interpréteur  execfail  est  activée,  auquel  cas  une  erreur  est renvoyée. Un
              interpréteur interactif renvoie une 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]
              Termine  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 ne se 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  configurée  à  mot.  export  renvoie un état final de 0, sauf si une
              option incorrecte est rencontrée, si un des  noms  n'est  pas  un  nom  correct  de
              variable de l'interpréteur, ou si l'option -f est fournie avec un nom qui n'est pas
              une fonction.

       fc [-e éditeur] [-lnr] [première] [dernière]
       fc -s [motif=nouveau] [commande]
              Commande  épinglée  (« 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  indiqué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 indiquée, elle est configurée à la  commande  courante  si  l'on
              veut  afficher la liste (ainsi ``fc -l -10'' affiche les 10 dernières commandes) et
              à l'identique de la première sinon. Si la première n'est  pas  indiquée,  elle  est
              configurée  à  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, sauf si une
              option incorrecte est trouvée ou si  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, sauf si commande n'indique pas une ligne correcte
              de l'historique, auquel cas fc renvoie un échec.

       fg [tâche]
              Reprend  la  tâche  au  premier plan qui devient 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 la tâche
              n'indique  pas  une  tâche  correcte  ou  si la tâche indique une tâche 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 un  deux-points,  l'option  est  censée
              avoir  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 positionné à l'indice du premier argument
              obligatoire et un point d'interrogation (?) est placé dans la variable nom.

              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 configurée à 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 place 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 positionné à l'option
              monocaractère trouvée.

              getopts renvoie vrai si une option, indiqué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  associé.
              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, sauf si nom
              n'est pas trouvé ou si une option incorrecte est fournie.

       help [-dms] [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.
              -d     Afficher une courte description de chaque motif.
              -m     Afficher  la  description  de  chaque  motif dans un format du type pages de
                     manuel.
              -s     Afficher seulement un court synopsis d'utilisation de chaque motif.
       L'état renvoyé est 0, sauf si aucune commande ne correspond 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 chaîne de format
              pour  strftime(3)  afin  d'afficher  l'horodatage  associé  à  chaque  élément   de
              l'historique.  Aucun  blanc  ne  sépare l'horodatage ainsi mis en forme de la ligne
              d'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  d'historique  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 ne soient ajoutés.

              Si  la  variable  HISTTIMEFORMAT  existe, les informations d'horodatage associées à
              chaque élément de l'historique sont écrites dans le fichier  d'historique,  repérés
              par le caractère de commentaire d'historique. Quand le fichier d'historique est lu,
              les  lignes  commençant  par  le  caractère  de  commentaire   d'historique   suivi
              immédiatement  par  un  chiffre  sont  considérés comme des horodatages de la ligne
              d'historique précédente. La valeur renvoyée est 0, sauf si  une  option  incorrecte
              est  fournie,  si une erreur se produit durant la lecture ou l'écriture du fichier,
              si un nombre incorrect est fourni comme argument à -d ou  si  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     Afficher les PID, en plus des informations normales.
              -p     Afficher uniquement le PID du meneur du groupe de processus de la tâche.
              -n     Afficher uniquement des informations sur les tâches  dont  l'état  a  changé
                     depuis la dernière notification de leur état à l'utilisateur.
              -r     Restreindre l'affichage aux tâches en cours d'exécution.
              -s     Restreindre l'affichage aux tâches suspendues.

              Si  une  tâche est indiquée, l'affichage est restreint aux informations relatives à
              cette tâche. L'état renvoyé est 0, sauf si une option incorrecte est rencontrée  ou
              si une tâche incorrecte est fournie.

              Si  l'option  -x est fournie, jobs remplace toute tâche trouvée dans la commande ou
              dans ses arguments avec les Process Group ID  correspondant,  puis  il  exécute  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]
              Envoie le signal indiqué par signal ou num-signal aux processus indiqué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 provoque l'affichage de 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 indiquant 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  plus  haut). 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 nom  est  créée  et  la  valeur  lui  est
              affectée.  L'option  peut  être n'importe quelle 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  hors  des
              fonctions  est  erronée.  La  valeur renvoyée est 0, sauf si local est utilisé hors
              d'une fonction, si un nom incorrect est fourni  ou  si  nom  est  une  variable  en
              lecture seule.

       logout Termine un interpréteur de connexion.

       mapfile  [-n  nombre]  [-O  origine]  [-s  nombre]  [-t]  [-u fd] [-C rappel] [-c quantum]
       [tableau]
       readarray [-n nombre] [-O origine] [-s nombre] [-t]  [-u  fd]  [-C  rappel]  [-c  quantum]
       [tableau]
              Lit  les  lignes  depuis  l'entrée standard vers la variable de type tableau indicé
              tableau, ou depuis le descripteur de fichier fd si  l'option  -u  est  fournie.  La
              variable  MAPFILE  est  le  tableau  par  défaut. Les options, si fournies, ont les
              significations suivantes :
              -n     Copier au plus nombre lignes. Si  nombre  est  0,  toutes  les  lignes  sont
                     copiées.
              -O     Commencer  l'affectation  de tableau à l'indice origine. L'indice par défaut
                     est 0.
              -s     Supprimer les nombre premières lignes lues.
              -t     Éliminer le saut de ligne de chaque ligne lue.
              -u     Lire les lignes à partir du descripteur de  fichier  fd  plutôt  que  depuis
                     l'entrée standard.
              -C     Évaluer  rappel  à  chaque  fois  que  quantum lignes sont lues. L'option -c
                     précise le quantum.
              -c     Préciser le nombre de lignes entre chaque appel à rappel.

              Si -C est précisé sans -c, le quantum par défaut est 5000. Quand rappel est évalué,
              l'indice  du  prochain  élément  de  tableau  à  affecter  est  fourni  en argument
              supplémentaire. rappel est  évalué  après  la  lecture  de  la  ligne,  mais  avant
              l'affectation de l'élément de tableau.

              Si  aucune  origine  explicite n'est fournie, mapfile effacera tableau avant de lui
              affecter des valeurs.

              mapfile termine avec succès sauf si une option ou un de  ses  arguments  n'est  pas
              valable,  ou  si  tableau  n'est pas valable, n'est pas un tableau indicé ou si son
              affectation est impossible.

       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     Empêcher le changement normal de répertoire  lors  de  la  suppression  d'un
                     répertoire de la pile. Seule la pile est manipulée.
              +n     Supprimer  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     Supprimer  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''  supprime  le
                     dernier répertoire et ``popd -1'' l'avant-dernier.

              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  le  répertoire  indiqué  est  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  (à
              l'exception  de \c qui termine la sortie, des contre-obliques dans \', \" et \? qui
              ne sont pas supprimées et des suites de caractères d'échappement pour  les  nombres
              en  octal  commençant  par  \0  qui 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,  suivant  le  besoin,  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] [+n] [-n]
       pushd [-n] [rép]
              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, sauf si la  pile  est
              vide. Les arguments, si fournis, ont les significations suivantes :
              -n     Empêcher  le  changement  normal de répertoire lors d'un ajout dans la pile.
                     Seule la pile est manipulée.
              +n     Effectuer 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 depuis la gauche à
                     partir de zéro).
              -n     Effectuer 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 depuis la gauche à
                     partir de zéro).
              rép    Ajouter 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é. Avec la première forme,
              pushd renvoie 0 sauf si le déplacement vers rép  échoue.  Avec  la  seconde  forme,
              pushd  renvoie  0,  sauf si la pile est vide, si un élément inexistant dans la pile
              est indiqué ou si le changement de répertoire vers le  nouveau  répertoire  indiqué
              é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,  sauf  si
              une erreur s'est produite lors de la lecture du nom du répertoire courant ou si une
              option incorrecte est fournie.

       read [-ers] [-a tableau] [-d délimiteur] [-i texte] [-n nb_car] [-N  nb_car]  [-p  invite]
       [-t délai] [-u fd] [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
              flux  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 tableau
                     Les  mots sont affectés aux indices successifs d'une variable tableau de nom
                     tableau, en commençant à 0. tableau  est  détruit  avant  que  de  nouvelles
                     valeurs ne 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. Readline utilise les
                     configurations d'édition en cours (ou par  défaut,  si  l'édition  de  ligne
                     n'était pas préalablement active).
              -i texte
                     Si  readline est utilisée pour lire la ligne, texte est placé dans le tampon
                     d'édition avant le début de l'édition.
              -n nb_car
                     read s'arrête après avoir lu nb_car caractères  plutôt  que  d'attendre  une
                     ligne complète en entrée, mais un délimiteur est respecté si moins de nb_car
                     caractères ont été lus avant le délimiteur.
              -N nb_car
                     read s'arrête  après  avoir  lu  exactement  nb_car  caractères  plutôt  que
                     d'attendre  une  ligne  complète en entrée, sauf si une fin de fichier (EOF)
                     est rencontrée ou si read dépasse son  délai  de  réponse.  Les  délimiteurs
                     rencontrés  en  entrée ne sont pas pris en compte et n'entraînent pas la fin
                     de read avant que nb_car caractères n'aient été lus.
              -p invite
                     Afficher 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  une  contre-oblique  suivie  d'un  saut  de  ligne  n'est   pas
                     considérée 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
                     Conduire 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. délai est un nombre décimal avec
                     éventuellement des chiffres après la virgule (NdT : point en  l'occurrence).
                     Cette  option  n'est  effective  que  si  read  lit  l'entrée  à partir d'un
                     terminal, d'un tube, ou depuis un autre fichier  spécial ;  elle  n'a  aucun
                     effet lors de la lecture d'un fichier normal. Si délai est nul, read termine
                     avec succès si une entrée est disponible  pour  le  descripteur  de  fichier
                     indiqué,  en  échec  sinon. L'état final est supérieur à 128 si le délai est
                     dépassé.
              -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, sauf si une fin de fichier (EOF) est rencontrée,
              si read dépasse son délai de réponse (auquel cas le code renvoyé est plus grand que
              128) ou si un descripteur de fichier incorrect est fourni en argument de -u.

       readonly [-aApf] [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  indicés ;  l'option  -A
              restreint  l'action aux variables tableaux associatifs. 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 configurée à mot. L'état renvoyé est 0, sauf si une option incorrecte
              a été rencontrée, si l'un des  noms  n'est  pas  un  nom  correct  de  variable  de
              l'interpréteur  ou  si  l'option  -f  est  fournie  avec  un  nom qui n'est pas une
              fonction.

       return [n]
              Termine une fonction en renvoyant la valeur indiquée par  n.  Si  n  est  omis,  la
              valeur  renvoyée  est  celle  de  la dernière commande exécutée dans le corps de la
              fonction. Si utilisée hors d'une fonction, mais durant l'exécution d'un script  par
              la  commande  .  (source)  elle  conduit  à  l'arrêt  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 hors d'une fonction ou
              d'un script exécuté par ., l'état renvoyé est faux. Toute commande  associée  à  la
              capture de RETURN est exécutée avant la reprise de l'exécution après la fonction ou
              le script.

       set [--abefhkmnptuvxBCEHPT] [-o nom_d_option] [argument ...]
       set [+abefhkmnptuvxBCEHPT] [+o nom_d_option] [argument ...]
              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 indiqué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  indiquées,  ont  les
              significations suivantes :
              -a      Marquer automatiquement 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      Terminer  immédiatement si une conduite (qui peut être réduite à une unique
                      commande simple), une commande de sous-interpréteur entre  parenthèses,  ou
                      une  liste  de  commandes entre accolades (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, d'un test suivant  les
                      mots  réservés  if  ou elif, d'une commande exécuté dans une liste && ou ⎪⎪
                      sauf si la commande est située après le dernier && ou ⎪⎪, d'une commande de
                      conduite  à  l'exception  de  la  dernière, 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 ne se termine. Cette option s'applique à
                      l'environnement de l'interpréteur  ainsi  qu'à  l'environnement  de  chaque
                      sous-interpréteur  individuellement  (voir  ENVIRONNEMENT  D'EXÉCUTION  DES
                      COMMANDES plus haut), et peut conduire des sous-interpréteurs à se terminer
                      avant d'y avoir exécuté toutes les commandes.
              -f      Désactiver le développement des chemins.
              -h      Mémoriser  l'emplacement  des commandes lors de leur exécution. Activée 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. Le contrôle des  tâches  est  activé.  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, sauf si l'interpréteur  est  démarré
                              avec  l'option --noediting. L'interface d'édition utilisée par read
                              -e est modifiée également.
                      errexit Identique à -e.
                      errtrace
                              Identique à -E.
                      functrace
                              Identique à -T.
                      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ée.
                      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. 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 ».  L'interface  d'édition  utilisée  par  read  -e est modifiée
                              également.
                      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  les  variables  SHELLOPTS,  BASHOPTS,  CDPATH, et
                      GLOBIGNORE,  si  présentes  dans   l'environnement,   sont   ignorées.   Si
                      l'interpréteur  démarre  avec  un  UID  (ou respectivement un 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 positionné à l'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 configuration 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  et  les  paramètres  différents  des
                      paramètres  spéciaux « @ » et « * » comme des erreurs lors du développement
                      des paramètres. Si un développement de variable inexistante ou de paramètre
                      est  tenté,  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      Afficher 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, afficher la valeur
                      développée de PS4, suivie de 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). Activée par défaut.
              -C      Si configurée, 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  configurée,  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 d'historique. C'est le comportement  par
                      défaut lorsque l'interpréteur est interactif.
              -P      Si  configurée,  l'interpréteur ne doit pas suivre les liens symboliques en
                      exécutant des commandes comme cd qui modifient le répertoire de travail. Il
                      utilise  à  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 configurée, 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 configurés aux
                      arguments, même si certains d'entre eux commencent par un -.
              -       Marquer la fin des options, tous les arguments restants sont alors 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  « - »,  les  options sont désactivées. Les options peuvent
              également être fournies 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,
              sauf si une option incorrecte est 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
              positif si n est supérieur à $# ou strictement négatif, sinon 0 est renvoyé.

       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 de nom_opt à 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 :

              autocd  Si existante, un nom de commande qui est le nom d'un répertoire est exécuté
                      comme  s'il  était l'argument de la commande interne cd. Cette option n'est
                      utilisée que par les interpréteurs interactifs.
              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.
              checkjobs
                      Si existante, bash affiche la liste des états de toutes les tâches en cours
                      et arrêtées avant de terminer un interpréteur  interactif.  Si  des  tâches
                      sont  en  cours,  la  sortie est différée jusqu'à ce qu'une nouvelle sortie
                      soit tentée sans commande intermédiaire  (voir  CONTRÔLE  DES  TÂCHES  plus
                      haut).  L'interpréteur  repousse  toujours  la  sortie  si  des tâches sont
                      arrêtées.
              checkwinsize
                      Si existante, bash vérifie la taille de la fenêtre  après  chaque  commande
                      et, au besoin, met à 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
                      Si  existante,  bash  modifie  son  comportement de manière compatible à la
                      version 3.1 en respectant les arguments protégés de l'opérateur de commande
                      conditionnelle =~.
              compat32
                      Si  existante,  bash  modifie  son  comportement de manière compatible à la
                      version 3.2 en respectant  les  comparaisons  de  chaînes  spécifiques  aux
                      paramètres  linguistiques régionaux lors de l'utilisation des opérateurs de
                      commande conditionnelle < et >.
              compat40
                      Si existante, bash modifie son comportement  de  manière  compatible  à  la
                      version 4.0  en  respectant  les  comparaisons  de  chaînes spécifiques aux
                      paramètres linguistiques régionaux lors de l'utilisation des opérateurs  de
                      commande  conditionnelle  <  et  >  et  l'effet  d'interruption de liste de
                      commandes.
              dirspell
                      Si existante, bash essaie de corriger les erreurs de frappe sur les noms de
                      répertoire lors du complètement de mot si le nom de répertoire initialement
                      fourni n'existe pas.
              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 indiqué 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  indiqués  par  la variable de l'interpréteur
                      FIGNORE conduiront des mots à être ignorés lors  du  complètement  de  mot,
                      même  si  les  mots  ignorés  sont  les seuls complètements possibles. Voir
                      VARIABLES DE L'INTERPRÉTEUR plus haut  pour  une  description  de  FIGNORE.
                      Cette option est activée par défaut.
              globstar
                      Si  existante,  le  motif  ** utilisé dans un contexte de développement des
                      chemins correspondra à un fichier  et  zéro  ou  plusieurs  répertoires  et
                      sous-répertoires.  Si  le  motif  est  suivi de /, seuls les répertoires et
                      sous-répertoires correspondent.
              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ésultante 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
                      courriers  depuis  sa  dernière vérification, le message « Le courrier dans
                      fichier_de_courrier a été lu. » 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ées 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
                      INTERPRÉTEUR  RESTREINT  plus  bas). 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.  Un
              interpréteur  de  connexion  ne  peut  pas  être  suspendu ;  l'option -f permet de
              surpasser ce comportement et force sa suspension. L'état renvoyé  est  0,  sauf  si
              l'interpréteur  est un interpréteur de connexion et que l'option -f est absente, ou
              si le contrôle des tâches n'est 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.  L'évaluation dépend du nombre d'arguments, voir
              plus bas.
              ! 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.  Les  opérateurs -a et -o sont considérés comme des opérateurs
                     binaires quand ils sont avec trois arguments. 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.
              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] [[argument] signal ...]
              La commande argument doit être lue et exécutée quand l'interpréteur reçoit au moins
              un  signal.  Si  argument est absent (et qu'un seul signal est fourni) ou -, chaque
              signal indiqué est réinitialisé à sa position d'origine (la valeur qu'il avait lors
              de  l'entrée  dans  l'interpréteur).  Si argument est la chaîne vide, chaque signal
              indiqué est ignoré par l'interpréteur  et  par  les  commandes  qu'il  appelle.  Si
              argument  n'est pas présent et que -p est fourni, les commandes capturées associées
              à chaque signal sont affichées. Si aucun argument n'est fourni, ou si seul  -p  est
              donné,  trap  affiche la liste des commandes associées à chaque signal. L'option -l
              conduit l'interpréteur a afficher une liste des  noms  de  signal  et  leur  numéro
              correspondant. Chaque signal est soit un nom de signal défini dans <signal.h>, soit
              un numéro de signal. Les noms de signal sont insensibles la casse et le préfixe SIG
              est optionnel.

              Si  un  signal est EXIT (0), la commande argument est exécutée lors de la sortie de
              l'interpréteur. Si un signal est DEBUG, la commande  argument  est  exécutée  avant
              toute commande simple, commande for, commande case, commande select, toute commande
              for arithmétique, et avant que la  première  commande  n'exécute  une  fonction  de
              l'interpréteur  (voir  GRAMMAIRE  DE  L'INTERPRÉTEUR plus haut). Reportez-vous à la
              description de l'option extdebug de la commande  interne  shopt  pour  obtenir  des
              renseignements  sur  les  effets  de  la capture DEBUG. Si un signal est RETURN, la
              commande argument est exécutée à chaque fois qu'une fonction de l'interpréteur,  ou
              un script exécuté avec les commandes internes . ou source, termine son exécution.

              Si un signal est ERR, la commande argument est exécutée chaque fois qu'une commande
              simple renvoie un état final différent de zéro, sujet aux conditions suivantes.  La
              capture  ERR  n'est  pas exécutée si la commande échouée fait partie d'une liste de
              commandes immédiatement suivie par un mot-clef while ou until, d'un test if,  d'une
              commande  exécutée au sein d'une liste de && ou de ⎪⎪, ou si la valeur renvoyée par
              la commande est inversée par !. Se sont les mêmes conditions que  celles  observées
              par l'option errexit.

              Les  signaux  ignorés  en  entrant  dans l'interpréteur ne peuvent être capturés ou
              réinitialisés. Les signaux capturés qui ne sont pas ignorés  sont  réinitialisés  à
              leur   valeur   d'origine   dans   un  sous-interpréteur  ou  un  environnement  de
              sous-interpréteur quand il est créé. L'état renvoyé est faux si un signal n'est pas
              valable, 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 tous les arguments sont  trouvés  et
              faux si aucun n'a pas été trouvé.

       ulimit [-HSTabcdefilmnpqrstuvx [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  indiquent  si la limitation est stricte (« hard ») ou flexible
              (« soft ») pour la ressource indiquée. Une limitation  stricte  ne  peut  pas  être
              augmentée par un utilisateur non privilégié une fois qu'elle a été configurée ; une
              limitation flexible peut être augmentée jusqu'à la valeur de la limitation  stricte
              correspondante. Si ni -H ni -S n'est indiqué, les limitations strictes et flexibles
              sont toutes deux configurées. 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 indiqué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
              -b     La taille maximum du tampon de « socket »
              -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 (« resident set
                     size » ou RSS, la plupart des systèmes ne respectent pas cette limite)
              -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
              -T     Le nombre maximum de processus légers (« threads »)

              Si  une  limitation  est  indiquée,  elle sera la nouvelle valeur pour la ressource
              indiqué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 -T, -b, -n et -u, qui n'ont pas d'unités. L'état renvoyé est 0,
              sauf si une option ou un argument incorrect a  été  fourni  ou  si  une  erreur  se
              produit en configurant la nouvelle limitation.

       umask [-p] [-S] [mode]
              Le  masque  de  création  de fichier de l'utilisateur est configuré à 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,  sauf  si  un
              nom fourni n'est pas un alias défini.

       unset [-fv] [nom ...]
              Pour  chaque  nom  indiqué,  supprime 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 indiqué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  l'une  des  variables  COMP_WORDBREAKS,  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 sauf
              si un des noms est en lecture seule.

       wait [n ...]
              Attend que chaque processus indiqué 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  indique  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 . ;

       ·      indiquer  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  de  n'importe  quel  fichier  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.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.ramey@case.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 variables de type tableau ne peuvent pas (encore) être exportées.

       Il ne peut exister qu'un seul coprocessus actif à la fois.

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  par  Frédéric  Lehobey
       <Frederic   AT   Lehobey   DOT   net>   et  est  dorénavant  maintenue  par  David  Prévot
       david@tilapin.org et les membres de la liste debian-l10n-french@lists.debian.org.

       Veuillez signaler toute erreur de traduction  par  un  rapport  de  bogue  sur  le  paquet
       manpages-fr-extra.