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 chane Si  l'option  -c est présente, les commandes sont lues depuis
                 la chane fournie. S'il y a des arguments  après  la  chane,
                 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 lexme  ayant  une  fonction  de  contrôle.  C'est  l'un  des
              symboles suivants :
              || & && ; ;; ( ) | |& <newline>

MOTS RÉSERVÉS

       Les mots rservs 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 oprateur  de  contrle.  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 arrire-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 compose 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 groupes. L'état renvoyé est
              l'état final  de  la  liste.  Remarquez  que  contrairement  aux
              métacaractères  (  et  ),  {  et } sont des mots rservs 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-compose [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-compose  (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-compose
              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 mtacaractres 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
       dveloppement 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  caractre 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 $'chane' sont traités spécialement. Le mot est
       développé en chane 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
       ($"chane")  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  paramtre 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 paramtre 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-systme. 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 sparateur 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 prcision, 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 caractre de
              dveloppement 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]=chane. 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
       dveloppement   des   accolades,   le   dveloppement   du   tilde,  le
       dveloppement des paramtres  et  des  variables,  la  substitution  de
       commande,  le  dveloppement  arithmtique,  le dcoupage en mots et le
       dveloppement 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 dveloppement des accolades est un mécanisme permettant de  produire
       des chaînes quelconques. Il est similaire au dveloppement 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  prambule
       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 prfixe 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.

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

       Si le premier caractère du paramtre 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  paramtre 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 paramtre
       lui-même. On  appelle  ce  mécanisme  le  dveloppement  imbriqu.  Les
       exceptions  à  celui-ci  sont  les développements de ${!prfixe*} 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

       ${paramtre:-mot}
              Utilisation de valeur par défaut. Si le paramtre est inexistant
              ou  vide, le développement du mot est substitué. Sinon, c'est la
              valeur du paramtre qui est substituée.
       ${paramtre:=mot}
              Affectation de valeur par défaut. Si le paramtre est inexistant
              ou  vide,  le développement du mot lui est affecté. La valeur du
              paramtre est alors substitué. Les  paramètres  positionnels  et
              spéciaux ne peuvent pas être affectés de cette façon.
       ${paramtre:?mot}
              Affichage  d'erreur  si  vide ou inexistant. Si le paramtre 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 paramtre est substituée.
       ${paramtre:+mot}
              Utilisation  de  valeur alternative. Si le paramtre est vide ou
              inexistant, rien n'est substitué. Sinon le développement du  mot
              est substitué.
       ${paramtre:dbut}
       ${paramtre:dbut: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
              dbut.   Si  la  longueur  est  omise,  fournit  la  sous-chaîne
              commençant au caractère de dbut et s'étendant jusqu'à la fin du
              paramtre.   La  longueur  et  le  dbut  sont  des  expressions
              arithmétiques  (voir  ÉVALUATION  ARITHMÉTIQUE  plus  bas).   La
              longueur  doit être positive. Si le dbut est négatif, sa valeur
              est considérée à partir de la fin du contenu du  paramtre.  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  paramtre  est  @,  le  résultat  correspond  aux
              longueur  paramètres  positionnels  commençant  au  dbut. Si le
              paramtre est un nom de tableau indicé par @ ou *,  le  résultat
              est    les   longueur   éléments   du   tableau   commençant   à
              ${paramtre[dbut]}. Une valeur  négative  de  dbut  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 dbut 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  dbut  est  0,  et  que  les  paramètres
              positionnels sont utilisés, la liste sera préfixée par $0.

       ${!prfixe*}
       ${!prfixe@}
              Noms   correspondant  au  préfixe.  Se  développe  en  noms  des
              variables dont les noms commencent par prfixe, 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é.

       ${#paramtre}
              Longueur  du  paramètre.  Est  remplacé  par  la  longueur,   en
              caractères,  de la valeur du paramtre. Si le paramtre est * ou
              @, la valeur est le nombre de  paramètres  positionnels.  Si  le
              paramtre  est  un  nom  de tableau indicé par * ou @, la valeur
              donnée est le nombre d'éléments du tableau.

       ${paramtre#mot}
       ${paramtre##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 paramtre, alors
              le  développement  prend la valeur développée du paramtre après
              suppression du plus court (cas  « # »)  ou  du  plus  long  (cas
              « ## »)  motif  correspondant.  Si  le  paramtre  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  paramtre  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.

       ${paramtre%mot}
       ${paramtre%%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 paramtre, alors le développement prend la  valeur
              développée  du  paramtre  après  suppression du plus court (cas
              « % ») ou du plus long (cas « %% ») motif correspondant.  Si  le
              paramtre  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 paramtre 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.

       ${paramtre/motif/chane}
              Substitution de motif. Le motif  est  développé  comme  dans  le
              traitement  des  chemins.  Le paramtre est développé et la plus
              longue portion correspondant  au  motif  est  remplacée  par  la
              chane.  Si  le motif commence par /, toutes les correspondances
              au motif sont remplacées par la chane.  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
              paramtre. Si le motif commence par %, il doit correspondre à la
              fin du développement du paramtre. Si la chane  est  vide,  les
              portions  correspondant au motif sont supprimées et le / suivant
              le motif peut être omis. Si le paramtre 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 paramtre 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.

       ${paramtre^motif}
       ${paramtre^^motif}
       ${paramtre,motif}
       ${paramtre,,motif}
              Modification de la casse. Ce développement modifie la casse  des
              caractères  alphabétiques  du paramtre. 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
              paramtre  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 paramtre 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
       dcoupage 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 caractre 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_rpertoires, alors que la commande

              ls 2>&1 > liste_répertoires

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

       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  dlimiteur  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
              dlimiteur

       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é,
       dlimiteur 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 dlimiteur. 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
       mtacaractre 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 chane
              Vrai si la longueur de la chane est nulle.
       chane
       -n chane
              Vrai si la longueur de la chane est non nulle.

       chane_1 == chane_2
       chane_1 = chane_2
              Vrai  si les deux chaînes sont égales. Le symbole = devrait être
              utilisé avec la commande test pour être en conformité POSIX.

       chane_1 != chane_2
              Vrai si les deux chaînes sont différentes.

       chane_1 < chane_2
              Vrai  si  chane_1  se  trouve  avant  chane_2   dans   l'ordre
              lexicographique.

       chane_1 > chane_2
              Vrai   si   chane_1  se  trouve  après  chane_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'excution  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  contrle  des tches 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  tche à 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 arrire-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 tche 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 associs  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 arrire-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 diffre
       (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  tche  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  tche prcdente 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
       Mta sont notées par M-touche, ainsi  M-x  signifie  Méta-X.  (Sur  les
       claviers sans touches Mta, M-x signifie ESC x, c'est-à-dire presser la
       touche d'Échappement puis la touche x. Cela  fait  de  ESC  le  prfixe
       mta. 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 dtruisant 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 prfixe mta).
       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  Mta  que le terminal peut prendre en
              charge une fois appelé. Sur de  nombreux  terminaux,  la  touche
              Mta 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 :  incrmental   et   non
       incrmental.

       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'vnement 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
       mtacaractres  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 ».
       !chane
              Se rapporte à la plus récente commande commençant par chane.
       !?chane[?]
              Se  rapporte  à  la plus récente commande contenant chane. Le ?
              final peut être omis si chane  est  immédiatement  suivie  d'un
              saut de ligne.
       ^chane_1^chane_2^
              Substitution  rapide. Répéter la dernière commande en remplaçant
              chane_1 par chane_2. Équivalent à  « !!:s/chane_1/chane_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  « ?chane? »  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 chane dans une  recherche
              !?chane[?].
       &      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 [tche ...]
              Reprend en arrière-plan chaque tche suspendue,  comme  si  elle
              avait  été  lancée  avec  &.  Si aucune tche n'est précisée, la
              notion d'interpréteur de tche courante est utilisée.  bg  tche
              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  tche  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'interprteur
       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'interprteur
                     Conduire  la  commande_de_l'interprteur  à être exécutée
                     chaque fois que la suite_de_touches est saisie. Quand  la
                     commande_de_l'interprteur  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] [rp]
              Remplace  le  répertoire de travail courant par rp. La variable
              HOME est la valeur par défaut de rp. La variable CDPATH définit
              des  chemins  de  recherche pour trouver le répertoire contenant
              rp. 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  rp 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-compltement] [-DE] [-A action] [-G
       globpat] [-W liste_de_mots] [-F fonction] [-C commande]
              [-X motif_filtre] [-P prfixe] [-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-compltement
                      L'option-compltement  commande  plusieurs  aspects   du
                      comportement  des spécifications de complètement au-delà
                      de    la    simple    production    de     complètement.
                      option-compltement 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 prfixe
                      prfixe 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] [tche ...]
              Sans options, chaque tche est supprimée de la table des  tâches
              actives.  Si  aucune  tche  n'est  précisée, et que ni -a ni -r
              n'est fournie, la notion d'interpréteur de  tche  courante  est
              utilisée.  Si  l'option  -h  est  indiquée,  aucune  tche n'est
              supprimée de la table, mais chaque tche est marquée pour que le
              signal SIGHUP ne lui soit pas envoyé si l'interpréteur reçoit un
              signal SIGHUP. Si aucune tche n'est indiquée et que ni l'option
              -a   ni  l'option  -r  n'est  fournie,  la  tche  courante  est
              concernée. Si aucune tche n'est fournie, l'option  -a  signifie
              la suppression ou le marquage de toutes les tâches ; l'option -r
              sans l'argument tche restreint les  opérations  aux  tâches  en
              cours  d'exécution.  La  valeur  renvoyée  est  0, sauf si tche
              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 spciales 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] [premire] [dernire]
       fc -s [motif=nouveau] [commande]
              Commande épinglée (« fix command »). Dans la première forme, une
              plage de commandes,  entre  la  premire  et  la  dernire,  est
              sélectionné  dans  la  file  d'historique.  La  premire  et  la
              dernire 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  dernire  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 premire sinon. Si la premire
              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  premire  ou
              dernire  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 [tche]
              Reprend  la tche au premier plan qui devient la tâche courante.
              Si aucune tche n'est précisée, l'interpréteur utilise la notion
              de  tche  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
              tche n'indique pas une tâche correcte ou si  la  tche  indique
              une tâche lancée sans contrôle des tâches.

       getopts chane_d_options nom [arguments]
              getopts est utilisé par les scripts d'interpréteur pour analyser
              les  paramètres  positionnels.  La   chane_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 chane_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
              chane_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] [ tche ... ]
       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  tche  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  tche
              incorrecte est fournie.

              Si  l'option  -x  est fournie, jobs remplace toute tche 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 | tche] ...
       kill -l [signal | tat_final]
              Envoie le signal indiqué par signal ou num-signal aux  processus
              indiqués  par pid ou par tche. 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] [rp]
              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  rp  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
              rp  é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 dlimiteur] [-i texte] [-n nb_car] [-N
       nb_car] [-p invite] [-t dlai] [-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 dlimiteur
                     Le premier  caractère  de  dlimiteur  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 dlai
                     Conduire read à expirer et renvoyer un échec si une ligne
                     complète  en  entrée  n'a  pas  été  lue dans le dlai en
                     secondes. dlai 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 dlai 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-interprteur 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 privilgi. 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 $'chane' et $"chane"
                      est  effectuée  à  l'intérieur  des  développements   de
                      ${paramtres} 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 rfrence 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.