Provided by: manpages-fr-extra_20080921_all bug

NOM

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

SYNOPSIS

       bash [options] [fichier]

COPYRIGHT

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

DESCRIPTION

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

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

OPTIONS

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

       -c 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  plus  bas  COMMANDES
                 INTERNES  DE  LINTERPRÉTEUR ). Si option_shopt est présente,
                 -O crée cette option ; +O la détruit. Si  option_shopt  n’est
                 pas   fournie,   les   noms   et   valeurs   des  options  de
                 l’interpréteur acceptées  par  shopt  sont  affichés  sur  la
                 sortie  standard.  Si  l’option d’appel est +O, la sortie est
                 affichée dans un format réutilisable en entrée.
       --        Deux  caractères  --  indiquent  la  fin   des   options   et
                 désactivent  le  traitement des arguments. Tous les arguments
                 après le -- sont  traités  comme  des  noms  de  fichiers  et
                 paramètres. - est équivalent à --.

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

       --debugger
              Prend  les  dispositions pour que le paramétrage du traçage soit
              exécuté avant que l’interpréteur démarre. Enclenche le  mode  de
              traçage  étendu  (voir  plus  bas  la  description  de  l’option
              extdebug de  la  commande  interne  shopt)  et  le  traçage  des
              fonctions  de  l’interpréteur  (voir  plus bas la description de
              l’option -o functrace de la commande interne set).
       --dump-po-strings
              Équivalent à -D, mais la sortie est dans le format des  fichiers
              po (objets portables) de l’outil GNU gettext.
       --dump-strings
              Équivalent à -D.
       --help Affiche un message d’aide sur la sortie standard et termine avec
              succès.
       --init-file fichier
       --rcfile fichier
              Exécuter les commandes contenues dans fichier plutôt que  celles
              du   fichier   d’initialisation   commun   à   tout  le  système
              /etc/bash.bashrc et que le  fichier  d’initialisation  personnel
              standard  ~/.bashrc si l’interpréteur est interactif (voir APPEL
              plus bas).

       --login
              Équivalent à -l.

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

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

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

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

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

       --verbose
              Équivalent à -v.

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

ARGUMENTS

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

APPEL

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

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

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

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

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

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

       Quand  bash  est  démarré  de  façon  non interactive, par exemple pour
       lancer   un   script,   il   consulte   la   variable   BASH_ENV   dans
       l’environnement,  développe  son  contenu  si  elle existe et considère
       cette valeur comme le nom d’un fichier à  lire  et  exécuter.  Bash  se
       comporte comme si la commande suivante était exécutée :
              if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
       mais  la  valeur de la variable PATH n’est pas utilisée pour rechercher
       le fichier.

       Si bash est appelé sous le nom sh, il essaye d’imiter  le  comportement
       de  démarrage  des  versions  historiques  de  sh  aussi fidèlement que
       possible, tout en restant conforme aux spécifications POSIX.  Lorsqu’il
       est  appelé  comme interpréteur de commandes de connexion interactif ou
       non interactif avec l’option --login, il  essaye  d’abord  de  lire  et
       exécuter,  dans  cet  ordre,  les  commandes  de  /etc/profile  puis de
       ~/.profile. L’option --noprofile peut être utilisée  pour  empêcher  ce
       comportement.  Quand  il  est appelé en tant qu’interpréteur interactif
       sous le nom sh, bash consulte la variable ENV, développe sa  valeur  si
       elle  est  définie  et utilise le résultat en tant que nom de fichier à
       lire et exécuter. Comme un interpréteur appelé sous le nom sh  n’essaye
       pas  de  lire et d’exécuter des commandes d’un quelconque autre fichier
       de démarrage, l’option --rcfile n’a aucun effet.  Un  interpréteur  non
       interactif  appelé  sous le nom sh n’essaie de lire aucun autre fichier
       d’initialisation. Quand il est appelé sous le nom  sh,  bash  entre  en
       mode posix après avoir lu les fichiers d’initialisation.

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

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

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

DÉFINITIONS

       Les définitions  suivantes  sont  utilisées  dans  toute  la  suite  ce
       document.
       blanc  Une espace ou une tabulation.
       mot    Une  suite  de caractères considérée comme une unité élémentaire
              par l’interpréteur. On parle également de lexème (token).
       nom    Un mot ne contenant que des  caractères  alphanumériques  ou  le
              soulignement  (underscore),  commençant  par  une  lettre  ou un
              soulignement.  On   s’y   réfère   également   sous   le   terme
              identificateur.
       métacaractère
              Un caractère qui, non protégé, sépare les mots. Un de ceux-ci :
              |  & ; ( ) < > space tab
       opérateur de contrôle
              Un  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  plus bas GRAMMAIRE DE LINTERPRÉTEUR ) soit le
       troisième mot d’une commande case ou for :

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

GRAMMAIRE DE LINTERPRÉ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 spécifie la
       commande à exécuter et est passé comme argument zéro. Les mots restants
       sont transmis comme arguments à la commande appelée.

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

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

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

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

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

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

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

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

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

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

       Si   une   commande   se   termine   par  l’opérateur  de  contrôle  &,
       l’interpréteur l’exécute en 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 opérateurs de contrôle && et ││ indiquent respectivement des listes
       de ET et des listes de OU. Une liste ET est de la forme

              commande_1 && commande_2

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

       Une liste OU a la forme

              commande_1 ││ commande_2

       commande_2  est  exécutée si et seulement si commande_1 renvoie un état
       final différent de zéro. L’état renvoyé par des listes de ET et  de  OU
       est l’état final de la dernière commande exécutée dans la liste.

   Commandes composées
       Une commande compose est l’une des constructions suivantes :

       (liste)
              liste  est  exécutée  dans  un  sous-interpréteur (voir plus bas
              ENVIRONNEMENT DEXÉCUTION DES COMMANDES ). Les  affectations  de
              variables    et    les    commandes   internes   qui   affectent
              l’environnement de l’interpréteur n’ont pas d’effet une fois que
              la  commande  se  termine. L’état renvoyé est l’état final de la
              liste.

       { liste; }
              liste  est   simplement   exécutée   avec   l’environnement   de
              l’interpréteur en cours. liste doit se terminer par un caractère
              de saut de ligne ou un  point-virgule.  Cette  construction  est
              connue  sous  le  nom  de commandes 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 une espace.

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

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

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

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

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

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

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

       for nom [ in mot ] ; do liste ; done
              La liste de mots suivant in est développée, produisant une liste
              d’éléments.  La  variable  nom  prend  tour  à tour la valeur de
              chacun des éléments et liste est exécutée à chaque fois.  Si  in
              mot  est  omis,  la  commande for exécute la liste une fois pour
              chacun des paramètres positionnels  existants  (voir  PARAMÈTRES
              plus  bas).  L’état  renvoyé  est  l’état  final  de la dernière
              commande exécutée. Si le développement des éléments  suivant  in
              conduit  à  une  liste  vide,  aucune commande n’est exécutée et
              l’état renvoyé est 0.

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

       select nom [ in mot ] ; do liste ; done
              La liste de mots à la suite de in est développée, produisant une
              liste d’éléments. L’ensemble des mots développés est imprimé sur
              la sortie d’erreur standard, chacun précédé par un nombre. Si in
              mot est omis, les paramètres positionnels  sont  imprimés  (voir
              PARAMÈTRES plus bas). L’invite PS3 est affichée et une ligne est
              lue depuis l’entrée standard. Si la ligne  est  constituée  d’un
              nombre  correspondant à l’un des mots affichés, alors ce mot est
              affecté à la valeur de la variable nom. Si la  ligne  est  vide,
              les  mots  et  l’invite  sont  affichés à nouveau. Si une fin de
              fichier (EOF) est lue,  la  commande  se  termine.  Toute  autre
              valeur lue conduit à mettre à vide la variable nom. La ligne lue
              est conservée dans la variable  REPLY.  La  liste  est  exécutée
              après  chaque  sélection,  jusqu’à ce qu’une commande break soit
              atteinte. L’état final de select est l’état final de la dernière
              commande  exécutée  dans la liste ou zéro si aucune commande n’a
              été exécutée.

       case mot in [ [(] motif [ | motif ] ... ) liste ;; ] ... esac
              Une commande case commence d’abord par développer le  mot,  puis
              essaye  de  le  mettre en correspondance tour à tour avec chacun
              des  motifs  en  utilisant  les  mêmes  règles   que   pour   le
              développement  des  chemins  (voir  plus  bas  Développement des
              chemins). Le mot est développé en utilisant le développement  du
              tilde,  le  développement  des  paramètres  et des variables, la
              substitution  arithmétique,  la  substitution  de  commande,  la
              substitution  de  processus  et  la suppression des protections.
              Chaque motif examiné est développé en utilisant le développement
              du  tilde,  le développement des paramètres et des variables, la
              substitution arithmétique, la substitution  de  commande  et  la
              substitution    de   processus.   Si   l’option   d’interpréteur
              nocasematch est activée, la mise en correspondance est effectuée
              sans  tenir  compte  de  la  casse des caractères alphabétiques.
              Quand une correspondance est  trouvée,  la  liste  associée  est
              exécutée.  Dès  qu’un  motif correct a été trouvé, il n’y a plus
              d’autre  essai.  L’état  final  est  zéro  si  aucun  motif   ne
              correspond.  Sinon  il  est l’état final de la dernière commande
              exécutée dans la liste.

       if liste; then liste; [ elif liste; then liste; ] ... [ else  liste;  ]
       fi
              La liste du if est exécutée. Si son  état  final  est  zéro,  la
              liste  du  then est exécutée. Sinon, chacune des listes des elif
              est exécutée tour à tour et si son état final est zéro, la liste
              du  then  associé est exécutée et la commande termine. Sinon, la
              liste du else, si  présente,  est  exécutée.  L’état  final  est
              l’état  final de la dernière commande exécutée ou zéro si aucune
              condition n’a été satisfaite.

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

   Définitions des fonctions de linterpré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 une quelconque des
              commandes  décrites  dans  Commandes  composées  plus  haut.  La
              commande-compose  est exécutée chaque fois que nom est spécifié
              comme le nom d’une commande normale. Toutes  redirections  (voir
              REDIRECTIONS   plus  bas)  spécifiées  lorsqu’une  fonction  est
              définie sont effectuées lorsque la fonction est exécutée. L’état
              final  d’une  définition  de  fonction  est zéro, à moins qu’une
              erreur de syntaxe se produise  ou  qu’une  fonction  en  lecture
              seule  existe  déjà  avec  le  même nom. Lorsque la fonction est
              exécutée,  l’état  final  est  celui  de  la  dernière  commande
              exécutée  dans  le  corps  de  la fonction. (Voir FONCTIONS plus
              bas.)

COMMENTAIRES

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

PROTECTION

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

       Tous  les  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 plus bas DÉVELOPPEMENT DE LHISTORIQUE ),  le  caractère
       de  dveloppement  de  lhistorique,  généralement !, doit être protégé
       pour éviter le développement de l’historique.

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

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

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

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

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

       Les  mots  de  la forme $'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   spécifié   par  le  standard  ANSI  C.  Les  suites
       d’échappement par contre-oblique, si  présentes,  sont  décodées  comme
       suit :
              \a     alerte (alarme)
              \b     effacement arrière (backspace)
              \e     caractère d’échappement
              \f     saut de page (form feed)
              \n     saut de ligne (new line)
              \r     retour chariot (carriage return)
              \t     tabulation horizontale
              \v     tabulation verticale
              \\     contre-oblique
              \'     guillemet simple
              \nnn   le  caractère 8 bits dont la valeur octale est nnn (de un
                     à trois chiffres)
              \xHH   le caractère 8 bits dont la valeur  hexadécimale  est  HH
                     (un à deux symboles hexadécimaux)
              \cx    un caractère contrôle-x

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

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

PARAMÈTRES

       Un 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 plus bas dans COMMANDES INTERNES DE LINTERPRÉTEUR ).

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

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

              nom=[valeur]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       HOSTNAME
              Automatiquement mis au nom de la machine courante.

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

       LINENO Chaque  fois  que  ce  paramètre est consulté, l’interpréteur le
              remplace par un nombre décimal  représentant  le  numéro  de  la
              ligne  actuelle  (commençant  à  1),  au sein du script ou de la
              fonction. Hors d’un script ou d’une fonction, la valeur n’a  pas
              nécessairement  de  sens.  Si LINENO est détruite, elle perd ses
              propriétés spéciales, même si elle est recréée par la suite.

       MACHTYPE
              Automatiquement mis à une chaîne décrivant le  type  du  système
              sur  lequel  bash  s’exécute,  dans  le  format  standard de GNU
              processeur-compagnie-systme. La valeur  par  défaut  dépend  du
              système.

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

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

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

       OSTYPE Automatiquement   mis   à  une  chaîne  qui  décrit  le  système
              d’exploitation sur lequel bash s’exécute. La valeur  par  défaut
              dépend du système.

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

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

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

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

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

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

       SHELLOPTS
              Liste des options activées de l’interpréteur, séparées  par  des
              virgules.  Chaque  mot  de la liste est un argument correct pour
              l’option -o de la commande interne set (voir plus bas  COMMANDES
              INTERNES  DE  LINTERPRÉTEUR  ).  Les  options apparaissant dans
              SHELLOPTS sont celle indiquées comme  actives  par  set  -o.  Si
              cette  variable  est  dans l’environnement au lancement de bash,
              chaque  option  de  la  liste  est  activée  avant  de  lire  un
              quelconque  fichier  d’initialisation.  Cette  variable  est  en
              lecture seule.

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

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

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

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

              Le p facultatif est un chiffre indiquant la 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  chiffre supérieur à 3 sera
              changé en 3. Si p n’est pas spécifié, la valeur 3 est  utilisée.

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

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

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

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

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

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

       histchars
              Les  deux  ou  trois  caractères  commandant le développement de
              l’historique  et  le  découpage  en  lexèmes  (voir   plus   bas
              DÉVELOPPEMENT  DE  LHISTORIQUE  ).  Le premier caractère est le
              caractre de dveloppement de lhistorique,  c’est-à-dire  celui
              qui   indique   le   début   d’un   développement   d’historique
              (normalement  « ! »).  Le  second   caractère   est   celui   de
              substitution  rapide,  utilisé  comme raccourci pour relancer la
              commande précédente, en modifiant une partie de la  chaîne.  Par
              défaut il s’agit de « ^ ». Le troisième caractère facultatif est
              celui qui indique, lorsqu’on le trouve en début de  mot  que  le
              reste  de la ligne est un commentaire. Normalement on utilise le
              caractère  « # ».  Ce  caractère  de  commentaire   empêche   le
              développement de l’historique pour tous les mots restants sur la
              ligne.  Il  ne  conduit  pas   nécessairement   l’analyseur   de
              l’interpréteur  à  considérer  le  reste  de  la  ligne comme un
              commentaire.

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

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

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

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

       La   commande  interne  unset  sert  à  détruire  les  tableaux.  unset
       nom[indice] détruit l’élément  de  tableau  d’indice  indice.  Un  soin
       particulier  doit  être  apporté  afin d’éviter des effets de bords non
       désirés provoqués par la production des noms de fichiers. unset nom, où
       nom  est  un  tableau,  ou unset nom[indice], avec indice valant * ou @
       supprime le tableau entier.

       Les commandes internes declare, local et readonly acceptent toutes  une
       option  -a  pour spécifier un tableau. La commande interne read accepte
       une option -a pour affecter une  liste  de  mots  lus  depuis  l’entrée
       standard  dans  un  tableau.  Les  commandes  internes  set  et declare
       affichent les valeurs d’un  tableau  d’une  façon  qui  permet  de  les
       réutiliser pour des affectations.

DÉVELOPPEMENTS

       Les  développements sont appliqués à la ligne de commande après qu’elle
       a été découpée en mots. Sept types de développements  sont  effectués :
       le   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 supportent, un développement supplémentaire a
       lieu : la substitution de processus.

       Seuls le développement des  accolades,  le  découpage  en  mots  et  le
       développement  des  chemins  peuvent  modifier  le  nombre de mots. Les
       autres développement transforment un mot unique en un autre mot unique.
       La  seule  exception  à  cette  règle est le développement de « $@ » et
       « ${nom[@]} » comme expliqué plus haut (voir PARAMÈTRES ).

   Développement des accolades
       Le 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 par soit  une  série  de  chaînes  séparées  par  des
       virgules,  soit  l’expression d’une série entre accolades, suivi par un
       post-scriptum facultatif. Le préambule est inséré  devant  chacune  des
       chaînes contenues entre les accolades et le post-scriptum est concaténé
       à la fin de  chacune  des  chaînes  résultantes,  le  développement  se
       faisant de gauche à droite.

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

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

       Le   développement   des   accolades  est  effectué  avant  tout  autre
       développement et tous les caractères ayant une  signification  spéciale
       pour  les  autres  développements  sont  conservés dans le résultat. Il
       s’agit d’une modification purement littérale.  Bash  n’effectue  aucune
       interprétation syntaxique du texte entre les accolades.

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

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

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

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

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

       Si   le  préfixe  tilde  est  « ~+ »,  la  valeur  de  la  variable  de
       l’interpréteur PWD le remplace. Si le  préfixe  tilde  est  « ~- »,  la
       valeur  de  la variable de l’interpréteur OLDPWD, si existante, lui est
       substituée. Si les caractères à la suite du tilde dans le préfixe tilde
       représentent  un  nombre  N  préfixé facultativement par un « + » ou un
       « - » le préfixe tilde est remplacé par l’élément correspondant  de  la
       pile  de répertoires telle qu’il serait affiché par la commande interne
       dirs appelée avec le préfixe tilde en argument. Si les caractères à  la
       suite  du  tilde  dans  le préfixe tilde représentent un nombre sans un
       « + » ou « - » en tête, on suppose qu’il s’agit de « + ».

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

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

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

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

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

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

       ${paramtre:-mot}
              Utilisation   de   valeurs  par  défaut.  Si  le  paramtre  est
              inexistant ou vide, le développement du mot et substitué. Sinon,
              c’est la valeur du paramtre qui est substituée.
       ${paramtre:=mot}
              Affectation  dune  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  derreur  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 dune valeur différente. Si le paramtre est vide ou
              inexistant, rien n’est substitué. Sinon le développement du  mot
              est substitué.
       ${paramtre:dbut}
       ${paramtre:dbut:longueur}
              Extraction   de  sous-chaînes.  Se  développe  pour  fournir  la
              sous-chaîne de la  longueur  indiquée  (comptée  en  caractères)
              commençant  au  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
              valeurs  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. 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.

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

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

       ${#paramtre}
              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 dans le tableau.

       ${paramtre#mot}
       ${paramtre##mot}
              Le mot est développé  pour  fournir  un  motif,  comme  dans  le
              développement des chemins. Si le motif correspond au début de la
              valeur du 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}
              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}
              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
              chaîne.   Normalement,  seule  la  première  correspondance  est
              remplacée. Si le motif commence par #, il doit  correspondre  au
              début de la valeur développée du 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 / après 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.

   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
              ‘commandeBash  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  <espace><tabulation><saut  de ligne>, la valeur par défaut,
       alors toute suite de caractères de IFS sert à délimiter  les  mots.  Si
       IFS  a  une  valeur  autre  que  celle  par défaut, alors les suites de
       caractères blancs espace et tabulation sont ignorées en début et fin de
       mot,  à  condition que ces caractères blancs se trouvent dans la valeur
       de IFS (un caractère blanc de IFS ). Tout caractère de  IFS  qui  n’est
       pas un caractère blanc, se trouvant à côté d’un caractère blanc de IFS,
       délimite un champ. Une suite de caractères blancs de IFS est  également
       traitée  comme  un  délimiteur.  Si  la  valeur  de IFS est vide, aucun
       découpage en mots n’a lieu.

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

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

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

       La variable de l’interpréteur  GLOBIGNORE  peut  servir  à  restreindre
       l’ensemble des noms de fichiers correspondant à un motif. Si GLOBIGNORE
       existe, chaque nom de fichier  qui  correspond  aussi  à  un  motif  de
       GLOBIGNORE  est  supprimé  de la liste des correspondances. Les noms de
       fichiers « . » et « .. » sont toujours ignorés quand GLOBIGNORE  existe
       et n’est pas vide. Toutefois, configurer GLOBIGNORE avec une valeur non
       vide a pour effet d’activer l’option d’interpréteur dotglob, ainsi tous
       les  autres  noms de fichiers commençant par « . » correspondront. Pour
       obtenir l’ancien comportement ignorant les noms commençant  par  « . »,
       placez « .* » dans l’un des motifs de GLOBIGNORE.  L’option dotglob est
       désactivée si la variable GLOBIGNORE est inexistante.

       Motifs génériques

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

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

       *      Correspond à toute chaîne, y compris la chaîne vide.
       ?      Correspond à n’importe quel caractère.
       [...]  Correspond à tout caractère entre les  crochets.  Un  couple  de
              caractères  séparés  par un trait d’union indique une expression
              de plage ;  tout  caractère  qui  correspond  à  n’importe  quel
              caractère situé entre les deux bornes incluses, en utilisant les
              suites de  collations  des  paramètres  linguistiques  régionaux
              courants  et  le  jeu  de  caractères.  Si  le premier caractère
              suivant le [ est un ! ou un ^ alors la  correspondance  se  fait
              sur   tous  les  caractères  hors  plage.  L’ordre  de  tri  des
              caractères dans les expressions de plage est déterminé  par  les
              paramètres  linguistiques régionaux courants et par la valeur de
              la variable de l’interpréteur LC_COLLATE si existante. Un - peut
              être  mis  en correspondance en l’incluant en premier ou dernier
              caractère de l’ensemble. Un ] peut être mis en correspondance en
              l’incluant en premier caractère de l’ensemble.

              Entre  [  et  ],  on  peut  indiquer  une classe de 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 à un caractère quelconque qui s’y  trouve.
              La  classe  de  caractères  word  correspond  aux  lettres,  aux
              chiffres et au caractère souligné « _ ».

              Entre [ et ], on  peut  indiquer  une  classe  dquivalence  en
              utilisant  la  syntaxe  [=c=],  qui  correspond à n’importe quel
              caractère ayant le même poids de collation  (comme  indiqué  par
              les   paramètres   linguistiques   régionaux  courants)  que  le
              caractère c.

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

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

              ?(liste-motif)
                     Correspond à zéro ou une occurrence des motifs indiqués
              *(liste-motif)
                     Correspond  à  zéro  ou  plusieurs occurrences des motifs
                     indiqués
              +(liste-motif)
                     Correspond à une  ou  plusieurs  occurrences  des  motifs
                     indiqués
              @(liste-motif)
                     Correspond   à   une  occurrence  exactement  des  motifs
                     indiqués
              !(liste-motif)
                     Correspond à tout sauf l’un des motifs indiqués

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

REDIRECTIONS

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

       Dans les descriptions suivantes, si le numéro de descripteur de fichier
       est omis et si le premier caractère de l’opérateur de  redirection  est
       <,  la  redirection  se  rapporte  à  l’entrée standard (descripteur de
       fichier 0). Si le premier caractère de l’opérateur de  redirection  est
       >,  la  redirection  se  rapporte  à la sortie standard (descripteur de
       fichier 1).

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

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

              ls > liste_répertoires 2>&1

       redirige  à  la  fois la sortie standard et la sortie d’erreur standard
       vers le fichier liste_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 vers 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.

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

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

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

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

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

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

              [n]<mot

   Redirection de sortie
       Une redirection de sortie conduit à l’ouverture en écriture du  fichier
       dont  le  nom résulte du développement du mot avec comme descripteur de
       fichier n ou en tant que sortie standard (descripteur de fichier 1)  si
       n  n’est  pas  spécifié.  Si le fichier n’existe pas, il est créé. S’il
       existait déjà, sa taille est ramenée à 0.

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

              [n]>mot

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

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

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

              [n]>>mot

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

       Il  y  a  deux  formes  pour  rediriger  les  sortie standard et sortie
       d’erreur standard :

              &>mot
       et
              >&mot

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

              >mot 2>&1

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

       Le format des documents en ligne est le suivant :

              <<[-]mot
                      document_en_ligne
              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  quelconque  des  caractères  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
       \<saut  de ligne> est ignorée et \ doit être utilisée pour protéger les
       caractères \, $ et ‘.

       Si l’opérateur de redirection est <<-, alors les tabulations en tête de
       chaque  ligne  sont  supprimées  de  l’entrée,  y compris dans la ligne
       contenant 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 spécifié. chiffre est fermé après avoir été dupliqué en n.

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

              [n]>&chiffre-

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

   Ouverture en Lecture/Écriture dun descripteur de fichier
       L’opérateur de redirection

              [n]<>mot

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

ALIAS

       Les alias permettent de substituer une chaîne à un  mot  lorsqu’il  est
       utilisé  comme  premier  mot d’une commande simple. L’interpréteur gère
       une liste d’alias qui peuvent être créés et détruits avec les commandes
       internes  alias  et  unalias  (voir  plus  bas  COMMANDES  INTERNES  DE
       LINTERPRÉTEUR ). L’interpréteur vérifie si le premier  mot  de  chaque
       commande  simple, si non protégé, est un alias. Si c’est le cas, ce mot
       est remplacé par le texte de l’alias. Les caractères /, $, `  et  =  et
       tout 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 plus  bas  la  description  de  shopt  dans
       COMMANDES INTERNES DE LINTERPRÉTEUR ).

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

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

FONCTIONS

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

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

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

       Les noms des fonctions et leurs définitions peuvent être affichés  avec
       l’option  -f  des commandes internes declare ou typeset. Les options -F
       de declare ou typeset n’afficheront que  les  noms  des  fonctions  (et
       facultativement  le  fichier  source et le numéro de ligne, si l’option
       d’interpréteur  extdebug  est  activée).  Les  fonctions  peuvent  être
       exportées  avec  l’option -f de la commande interne export, afin d’être
       automatiquement définies dans les sous-interpréteurs. Une définition de
       fonction  peut  être  supprimée avec l’option -f de la commande interne
       unset. Remarquez que les fonctions et variables  de  l’interpréteur  de
       même  nom  pourront  induire  à  plusieurs  éléments de mêmes noms dans
       l’environnement  passé  aux  enfants   de   l’interpréteur.   Un   soin
       particulier  doit  être  pris  dans  les cas où cela peut conduire à un
       problème.

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

ÉVALUATION ARITHMÉTIQUE

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

       id++ id--
              post-incrément et post-décrément de variables
       ++id --id
              pré-incrément et pré-décrément de variables
       - +    plus et moins unaires
       ! ~    négations logique et binaire
       **     exponentiation
       * / %  multiplication, division, reste
       + -    addition, soustraction
       << >>  décalage arithmétique à gauche et à droite
       <= >= < >
              comparaisons
       == !=  égalité et différence
       &      ET binaire
       ^      OU exclusif binaire
       |      OU binaire
       &&     ET logique
       ||     OU logique
       expr?expr:expr
              opérateur conditionnel
       = *= /= %= += -= <<= >>= &= ^= |=
              affectations
       expr1 , expr2
              virgule

       On  peut  utiliser  les variables de l’interpréteur comme opérandes, le
       développement  des  paramètres  étant   effectué   avant   l’évaluation
       arithmétique.  Dans  une  expression,  les  variables de l’interpréteur
       peuvent également être référencées  par  leur  nom,  sans  utiliser  la
       syntaxe  de  développement  des paramètres. Une variable d’interpréteur
       qui est vide ou inexistante est évaluée à 0 lorsqu’on y accède par  son
       nom sans utiliser la syntaxe de développement des paramètres. La valeur
       d’une variable est évaluée comme une expression arithmétique  lorsqu’on
       y accède ou lorsqu’une variable, qui a vu son attribut integer (entier)
       positionné en utilisant declare -i, se voit affecter  une  valeur.  Une
       valeur  vide  est évaluée à 0. Une variable d’interpréteur n’a donc pas
       besoin d’avoir son attribut integer de positionné pour être  utilisable
       dans un calcul.

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

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

CONDITIONS

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

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

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

       -a fichier
              Vrai si le fichier existe.
       -b fichier
              Vrai si le fichier existe et est un fichier spécial bloc.
       -c fichier
              Vrai si le fichier existe et est un fichier spécial caractère.
       -d fichier
              Vrai si le fichier existe et est un répertoire.
       -e fichier
              Vrai si le fichier existe.
       -f fichier
              Vrai si le fichier existe et est un fichier normal.
       -g fichier
              Vrai si le fichier existe et a son bit Set-GID de mis.
       -h fichier
              Vrai si le fichier existe et est un lien symbolique.
       -k fichier
              Vrai si le fichier existe et a son bit « sticky » de mis.
       -p fichier
              Vrai si le fichier existe et est un tube nommé (FIFO).
       -r fichier
              Vrai si le fichier existe et est accessible en lecture.
       -s fichier
              Vrai si le fichier existe et a une taille strictement  positive.
       -t fd  Vrai si le descripteur de fichier fd est ouvert et se rapporte à
              un terminal.
       -u fichier
              Vrai si le fichier existe et a son bit Set-UID de mis.
       -w fichier
              Vrai si le fichier existe et est accessible en écriture.
       -x fichier
              Vrai si le fichier existe et est exécutable.
       -O fichier
              Vrai si le fichier existe et  appartient  à  l’UID  effectif  de
              l’utilisateur.
       -G fichier
              Vrai  si  le  fichier  existe  et  appartient au GID effectif du
              groupe.
       -L fichier
              Vrai si le fichier existe et est un lien symbolique.
       -S fichier
              Vrai si le fichier existe et est une « socket ».
       -N fichier
              Vrai si le fichier existe et a été modifié  depuis  sa  dernière
              lecture.
       fichier_1 -nt fichier_2
              Vrai si le fichier_1 est plus récent que le fichier_2 (selon les
              dates de dernière modification) ou si fichier_1  existe  et  non
              fichier_2.
       fichier_1 -ot fichier_2
              Vrai  si  le  fichier_1  est  plus  vieux que le fichier_2 ou si
              fichier_2 existe et non pas fichier_1.
       fichier_1 -ef fichier_2
              Vrai si le fichier_1 et  le  fichier_2  se  rapportent  au  même
              périphérique et ont les mêmes numéros d’i-noeuds.
       -o nom_opt
              Vrai  si  l’option d’interpréteur nom_opt est activée. Consulter
              la liste des options plus bas dans la description de l’option -o
              de la commande interne set.
       -z 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
              Vrai si les deux chaînes sont égales. Le symbole = peut servir à
              remplacer == pour une stricte 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 des paramètres linguistiques régionaux courants.

       chane_1 > chane_2
              Vrai  si  chane_1  se  trouve  après  chane_2   dans   l’ordre
              lexicographique des paramètres linguistiques régionaux courants.

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

DÉVELOPPEMENT DES COMMANDES SIMPLES

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

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

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

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

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

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

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

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

EXÉCUTION DES COMMANDES

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

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

       Si  le  nom  n’est  ni celui d’une fonction de l’interpréteur, ni celui
       d’une commande interne et s’il ne contient pas de barre  oblique,  bash
       va chercher dans chacun des éléments de PATH un répertoire contenant un
       fichier exécutable du nom désiré. Bash utilise  une  table  de  hachage
       pour  mémoriser  les  chemins d’accès complets aux fichiers exécutables
       (voir  plus  bas  la  commande  hash   dans   COMMANDES   INTERNES   DE
       LINTERPRÉTEUR  ).  Une recherche complète dans les répertoires du PATH
       n’est effectuée que si la commande ne se trouve pas dans  la  table  de
       hachage.  Si  la  recherche est infructueuse, l’interpréteur affiche un
       message d’erreur et renvoie un état final de 127.

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

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

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

ENVIRONNEMENT DEXÉCUTION DES COMMANDES
       L’interpréteur  fournit  un  environnement  dexcution  consistant  en
       l’ensemble des éléments suivants :

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

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

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

       ·      captures courantes mises par trap

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

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

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

       ·      options activées par shopt ;

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

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

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

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

       ·      le répertoire de travail courant ;

       ·      le masque de création de fichiers ;

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

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

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

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

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

ENVIRONNEMENT

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

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

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

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

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

ÉTAT FINAL

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

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

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

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

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

SIGNAUX

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

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

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

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

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

CONTRÔLE DES TÂCHES

       Le  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 système
       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 être 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 y écrire. Les processus
       en arrière-plan qui tentent une  lecture  (ou  une  écriture)  dans  le
       terminal  reçoivent  un  signal SIGTTIN (SIGTTOU) émis par le pilote du
       terminal, qui, sauf interception, suspend le processus.

       Si le système d’exploitation  sur  lequel  bash  fonctionne  permet  le
       contrôle des tâches, bash fournit des outils pour l’utiliser. La frappe
       d’un caractère de  suspension  (généralement  ^Z,  Contrôle-Z)  pendant
       l’exécution  d’un  processus  conduit  à  la  suspension de celui-ci et
       redonne la main à bash. La frappe d’un caractère de suspension 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.

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

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

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

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

INVITES

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

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

READLINE

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

   Notation readline
       Dans ce paragraphe  on  utilisera  la  notation  « à  la  emacs »  pour
       indiquer  les  frappes  de  touches.  Les  touches Contrôle sont notées
       C-touche, par exemple C-n signifie Contrôle-N.  De  même,  les  touches
       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 ex. kill-line) conduit cette commande à  agir  dans  la
       direction   opposée.  Les  commandes  dont  le  comportement  avec  les
       arguments diffère de ceci sont indiquées plus bas.

       Lorsqu’une commande est indiquée comme 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.  Les
       suppressions  successives  conduisent  à  l’accumulation du texte en un
       seul bloc qui peut  être  récupéré  en  une  fois.  Les  commandes  non
       destructrices séparent les blocs de textes dans le tampon circulaire.

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

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

       Par exemple, en plaçant

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              set nom_de_variable valeur

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

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

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

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

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

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

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

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

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

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

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

              $include  /etc/inputrc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

HISTORIQUE

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

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

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

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

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

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

       Le  développement  de  l’historique est effectué immédiatement après la
       lecture d’une ligne complète, avant que l’interpréteur ne la  décompose
       en  mots.  Il  se  déroule  en  deux  parties.  La  première consiste à
       déterminer la ligne  de  la  file  d’historique  à  utiliser  pour  les
       substitutions,  la  seconde  permet  de  sélectionner les parties de la
       ligne à inclure dans la nouvelle  ligne.  La  ligne  sélectionnée  dans
       l’historique est l’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 de le  développement
       de  l’historique.  Si  l’option  d’interpréteur  histverify est activée
       (voir la description de la commande interne shopt) et si  readline  est
       utilisée,  les  substitutions d’historiques ne sont pas transmises tout
       de suite  à  l’analyseur  de  l’interpréteur.  À  la  place,  la  ligne
       développée  est  rechargée  dans  la  mémoire  tampon  de readline pour
       permettre des modifications ultérieures. Si readline est utilisée et si
       l’option  histreedit  est  activée,  une  substitution d’historique qui
       échoue  est  rechargée  dans  la  mémoire  tampon  de   readline   pour
       correction.  L’option  -p  de la commande interne history peut servir à
       examiner ce qu’une substitution donnera avant de l’employer réellement.
       L’option  -s  de  la  commande  interne  history  permet  d’ajouter des
       commandes à la fin de la file d’historique sans les avoir effectivement
       exécutées,   afin   qu’elles   soient   disponibles  pour  des  rappels
       ultérieurs.

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

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

       !      Débute une substitution d’historique, sauf s’il est suivi par un
              blanc, saut de ligne, retour-chariot, = ou (  (lorsque  l’option
              d’interpréteur  extglob  est  activée  en  utilisant la commande
              interne shopt).
       !n     Se rapporte à la ligne de commande n.
       !-n    Se rapporte à la ligne de commande courante moins n.
       !!     Se rapporte à la  commande  précédente.  C’est  un  synonyme  de
              « !-1 ».
       !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      Supprimer tout le début d’un chemin d’accès, en ne laissant  que
              la fin.
       r      Supprime  un  suffixe final de la forme .xxx, en ne laissant que
              le nom de base.
       e      Tout supprimer sauf le suffixe final.
       p      Afficher la nouvelle commande sans l’exécuter.
       q      Protéger les mots  substitués,  pour  éviter  des  substitutions
              futures.
       x      Protéger  les mots substitués comme avec q, mais en séparant des
              mots aux blancs et aux sauts de ligne.
       s/ancien/nouveau/
              Remplacer par nouveau la première occurrence de  ancien  sur  la
              ligne  d’événement. Tout délimiteur peut être utilisé à la place
              de /. Le dernier délimiteur est facultatif si c’est  le  dernier
              caractère  de  la  ligne  d’événement.  Le  délimiteur peut être
              protégé dans ancien et nouveau avec une seule contre-oblique. Si
              &  apparaît  dans nouveau, il est remplacé par ancien. Une seule
              contre-oblique protégera le &. Si ancien est vide, il est mis au
              dernier  ancien  substitué ou si aucune substitution n’a eu lieu
              précédemment, la dernière chane dans une recherche !?chane[?].
       &      Répéter la substitution précédente.
       g      Conduit à l’application des changements sur la ligne d’événement
              entière. Ceci est utilisé conjointement à  « :s »  (par  exemple
              « :gs/ancien/nouveau/ ») ou « :& ». Si utilisé avec « :s », tout
              délimiteur peut être utilisé à la  place  de  /  et  le  dernier
              délimiteur  est  facultatif  si c’est le dernier caractère de la
              ligne d’événement. Un a peut être utilisé en tant  que  synonyme
              de g.
       G      Appliquer  le  modificateur  « s » suivant une fois à chacun des
              mots dans la ligne d’événements.

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

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

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

       bg [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 à moins que le contrôle des tâches soit désactivé, ou,
              quand  le contrôle des tâches est activé, qu’une tche spécifiée
              n’ait pas été trouvée ou ait été lancée sans contrôle de tâches.

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

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

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

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

       cd [-L|-P] [rp]
              Remplacer  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  dit  de  n’employer  que  la
              structure  de  répertoires physiques au lieu de suivre les liens
              symboliques (voir aussi l’option -P de la commande interne  set)
              l’option  -L force à suivre les liens symboliques. Un argument -
              est équivalent à $OLDPWD.  Si un nom de répertoire non  vide  de
              CDPATH  est  utilisé  ou  si  - est le premier argument et si le
              changement de répertoire réussit, le chemin  absolu  du  nouveau
              répertoire  de  travail  est  écrit  sur  la sortie standard. La
              valeur renvoyée est  vrai  si  le  changement  de  répertoire  a
              réussi ; faux sinon.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       disown [-ar] [-h] [tche ...]
              Sans options, chaque tche est supprimée de la table des  tâches
              actives.  Si  l’option  -h  est indiquée, chaque tche n’est pas
              supprimée de la table mais marquée pour que le signal SIGHUP  ne
              lui  soit  pas envoyé si l’interpréteur reçoit un signal SIGHUP.
              Si aucune 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, à moins que tche ne spécifie pas une
              tâche correcte.

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

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

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

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

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

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

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

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

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

              Lorsque  la  première forme est utilisée, la valeur renvoyée est
              0, à moins qu’une option incorrecte soit trouvée ou que 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, à moins que commande  ne  spécifie  pas  une  ligne
              correcte de l’historique, auquel cas fc renvoie un échec.

       fg [tche]
              Reprendre  la  tche  au  premier  plan  et  en  faire  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 tche ne spécifie pas une tâche correcte ou si  tche
              spécifie une tâche qui a été 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 deux-points  (:),  l’option  est  censée
              comprendre  un  argument,  qui  devrait  en  être séparé par une
              espace. Les caractères deux-points et le  point  d’interrogation
              ne peuvent pas être utilisés comme caractères d’option. À chaque
              appel, getopts place  l’option  suivante  dans  la  variable  de
              l’interpréteur  dont  le  nom  est  fourni, en la créant si elle
              n’existe pas et l’indice de l’argument suivant à traiter dans la
              variable OPTIND.  OPTIND est initialisée à 1 à chaque appel d’un
              interpréteur ou d’un  script.  Quand  une  option  nécessite  un
              argument,  getopts  place  cet argument dans la variable OPTARG.
              L’interpréteur ne réinitialise pas OPTIND  automatiquement ;  il
              faut  le faire manuellement entre des appels multiples à getopts
              au sein du même  appel  d’interpréteur  si  un  nouveau  jeu  de
              paramètres doit être utilisé.

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

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

              getopts peut signaler des erreurs de deux façons. Si le  premier
              caractère de la 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  mise  à 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 met un point
              d’interrogation (?) dans la variable  nom,  affiche  un  message
              d’erreur  (s’il  n’est  pas  en  mode  silencieux) et détruit la
              variable OPTARG.  Si getopts fonctionne en mode  silencieux,  le
              caractère  d’option  est  placé  dans OPTARG et aucun message de
              diagnostic n’est affiché.

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

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

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

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

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

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

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

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

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

       kill [-s signal | -n num-signal | -signal] [pid | tche] ...
       kill -l [signal | tat_final]
              Envoyer le signal indiqué par signal ou num-signal aux processus
              spécifié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 affiche la liste des noms  de
              signaux. Si des arguments sont fournis quand -l est indiqué, les
              noms des signaux correspondant aux arguments  sont  affichés  et
              l’état  renvoyé  est 0. L’argument tat_final de l’option -l est
              un nombre spécifiant soit un numéro de signal, soit l’état final
              d’un  processus  terminé  par un signal. kill renvoie vrai si au
              moins un signal a été envoyé avec succès ou faux si  une  erreur
              s’est produite ou si une option incorrecte a été rencontrée.

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

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

       logout Termine un interpréteur de connexion.

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

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

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

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

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

       pushd [-n] [rp]
       pushd [-n] [+n] [-n]
              Ajoute  un  répertoire  au  sommet de la pile des répertoires ou
              effectue une rotation dans la pile, en  ramenant  le  répertoire
              courant  au  sommet.  Sans  argument, cette commande échange les
              deux répertoires au sommet et renvoie 0, à  moins  que  la  pile
              soit  vide.  Les  arguments,  si fournis, ont les significations
              suivantes :
              +n     Effectue une rotation dans la pile, de façon à amener  au
                     sommet  le  n-ième  répertoire  (de la liste affichée par
                     dirs en comptant à partir de la gauche et en commençant à
                     zéro).
              -n     Effectue  une rotation dans la pile, de façon à amener au
                     sommet le n-ième répertoire (en comptant à partir  de  la
                     droite  dans  la liste affichée par dirs, en commençant à
                     zéro).
              -n     Empêche le changement  normal  de  répertoire  lors  d’un
                     ajout dans la pile. Seule la pile est manipulée.
              rép    Ajoute  le  répertoire  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é. Si on
              utilise  la  première  forme,  pushd  renvoie  0  sauf   si   le
              déplacement  vers  rp  échoue.  Avec  la  seconde  forme, pushd
              renvoie 0, à moins que la pile soit vide, que soit  spécifié  un
              élément  inexistant  dans  la  pile  ou  que  le  changement  de
              répertoire vers le nouveau répertoire spécifié échoue.

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

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

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

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

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

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

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

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

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

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

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

              La liste des options shopt est :

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

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

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

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

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

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

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

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

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

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

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

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

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

INTERPRÉTEUR RESTREINT

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

       ·      changer de répertoire avec cd

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

       ·      indiquer des noms de commandes contenant un /

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

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

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

       ·      analyser les valeurs de SHELLOPTS au démarrage ;

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

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

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

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

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

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

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

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

VOIR AUSSI

       Manuel de 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.logout
              Le  fichier de nettoyage des interpréteurs de connexion commun à
              tout le système, exécuté  lorsqu’un  interpréteur  de  connexion
              termine
       ~/.bash_profile
              Le   fichier   d’initialisation   personnel   exécuté  pour  les
              interpréteurs de commandes de connexion
       ~/.bashrc
              Le fichier de démarrage personnel, pour chacun des interpréteurs
              interactifs
       ~/.bash_logout
              Le fichier de nettoyage personnel des interpréteurs de commandes
              de connexion, exécuté lorsqu’un  interpréteur  de  commandes  de
              connexion termine
       ~/.inputrc
              Le fichier d’initialisation personnalisée de readline

AUTEURS

       Brian Fox, Free Software Foundation
       bfox@gnu.org

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

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

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

       TOUS les signalements d’anomalie doivent contenir :

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

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

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

ANOMALIES

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

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

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

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

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

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

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

TRADUCTION

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