Provided by: manpages-fr-extra_20080618_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 is intended to be a conformant implementation  of  the  Shell  and
       Utilities  portion  of  the  IEEE  POSIX  specification  (IEEE Standard
       1003.1).  Bash can be configured to be POSIX-conformant by default.

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
              Change the behavior of bash where the default operation  differs
              from the POSIX standard to match the standard (posix mode).

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

       Of these list operators, && and ││ have equal precedence, followed by ;
       and &, which have equal precedence.

       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.

       Enclosing  characters  in  double quotes preserves the literal value of
       all characters within the quotes, with the exception of $, ‘,  \,  and,
       when  history  expansion  is enabled, !.  The characters $ and ‘ retain
       their special meaning within double quotes.  The backslash retains  its
       special  meaning only when followed by one of the following characters:
       $, ‘, ", \, or <newline>.  A double quote may be quoted  within  double
       quotes by preceding it with a backslash.  If enabled, history expansion
       will be performed unless an ! appearing in  double  quotes  is  escaped
       using a backslash.  The backslash preceding the ! is not removed.

       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
              An  array  variable  (see  Arrays  below)  consisting   of   the
              individual  words  in  the  current command line.  The words are
              split on shell metacharacters as the shell parser would separate
              them.   This  variable  is  available  only  in  shell functions
              invoked  by  the   programmable   completion   facilities   (see
              Programmable Completion below).

       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
              The maximum number of lines contained in the history file.  When
              this  variable  is  assigned  a  value,  the  history  file   is
              truncated,  if  necessary,  by  removing  the oldest entries, to
              contain no more than that number of lines.  The default value is
              500.   The  history  file  is  also truncated to this size after
              writing it when an interactive shell exits.
       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    The Internal Field Separator that is  used  for  word  splitting
              after  expansion  and  to  split  lines into words with the read
              builtin command.  The default value is  “<space><tab><newline>”.
       IGNOREEOF
              Commande   le   comportement   d’un  interpréteur  interactif  à
              réception d’un caractère  EOF  (fin  de  fichier)  comme  unique
              saisie.  Si  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    The  value  of  this parameter is expanded (see PROMPTING below)
              and used as the primary prompt string.   The  default  value  is
              “\s-\v\$ ”.
       PS2    The  value of this parameter is expanded as with PS1 and used as
              the secondary prompt string.  The default is “> ”.
       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    The  value  of  this  parameter  is expanded as with PS1 and the
              value is printed before each command  bash  displays  during  an
              execution  trace.   The  first  character  of  PS4 is replicated
              multiple times, as necessary, to  indicate  multiple  levels  of
              indirection.  The default is “+ ”.
       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}
              The  word  is  expanded to produce a pattern just as in pathname
              expansion.  If the pattern matches the beginning of the value of
              parameter,  then  the  result  of  the expansion is the expanded
              value of parameter with the shortest matching pattern  (the  “#”
              case)  or  the longest matching pattern (the “##” case) deleted.
              If parameter is @ or *, the pattern removal operation is applied
              to  each  positional parameter in turn, and the expansion is the
              resultant list.  If parameter is an array  variable  subscripted
              with  @  or  *, the pattern removal operation is applied to each
              member of the array in turn, and the expansion is the  resultant
              list.

       ${paramtre%mot}
       ${paramtre%%mot}
              The  word  is  expanded to produce a pattern just as in pathname
              expansion.  If the pattern matches a  trailing  portion  of  the
              expanded value of parameter, then the result of the expansion is
              the expanded value  of  parameter  with  the  shortest  matching
              pattern (the “%” case) or the longest matching pattern (the “%%”
              case) deleted.  If parameter is @  or  *,  the  pattern  removal
              operation  is  applied to each positional parameter in turn, and
              the expansion is the resultant list.  If parameter is  an  array
              variable  subscripted with @ or *, the pattern removal operation
              is applied to  each  member  of  the  array  in  turn,  and  the
              expansion is the resultant list.

       ${paramtre/motif/chane}
              The pattern is expanded to produce a pattern just as in pathname
              expansion.  Parameter is  expanded  and  the  longest  match  of
              pattern  against its value is replaced with string.  If Ipattern
              begins with /, all matches of pattern are replaced with  string.
              Normally  only  the  first match is replaced.  If pattern begins
              with #, it must match at the beginning of the expanded value  of
              parameter.   If  pattern begins with %, it must match at the end
              of the expanded value of parameter.  If string is null,  matches
              of  pattern  are  deleted  and  the  /  following pattern may be
              omitted.  If parameter is @ or *, the substitution operation  is
              applied  to each positional parameter in turn, and the expansion
              is the resultant  list.   If  parameter  is  an  array  variable
              subscripted  with  @ or *, the substitution operation is applied
              to each member of the array in turn, and the  expansion  is  the
              resultant list.

   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
              ‘commandBash 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).

       When  the  old-style  backquote form of substitution is used, backslash
       retains its literal meaning except when followed by $, ‘,  or  \.   The
       first  backquote  not  preceded  by  a backslash terminates the command
       substitution.  When using the $(command) form, all  characters  between
       the parentheses make up the command; none are treated specially.

       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
       After word splitting, unless the -f option has  been  set,  bash  scans
       each  word  for the characters *, ?, and [.  If one of these characters
       appears, then the word is regarded as a pattern, and replaced  with  an
       alphabetically  sorted  list of file names matching the pattern.  If no
       matching file names  are  found,  and  the  shell  option  nullglob  is
       disabled,  the  word is left unchanged.  If the nullglob option is set,
       and no matches are found, the word is removed.  If the  failglob  shell
       option  is  set,  and no matches are found, an error message is printed
       and the command is not executed.  If the  shell  option  nocaseglob  is
       enabled,  the  match  is  performed  without  regard  to  the  case  of
       alphabetic characters.  Note that when  using  range  expressions  like
       [a-z] (see below), letters of the other case may be included, depending
       on the setting of LC_COLLATE.  When a  pattern  is  used  for  pathname
       expansion,  the  character  “.”  at  the start of a name or immediately
       following a slash must be matched explicitly, unless the  shell  option
       dotglob  is  set.   When  matching a pathname, the slash character must
       always be matched explicitly.  In other cases, the “.” character is not
       treated  specially.   See  the  description  of shopt below under SHELL
       BUILTIN  COMMANDS  for  a  description  of  the  nocaseglob,  nullglob,
       failglob, and dotglob shell options.

       The  GLOBIGNORE  shell variable may be used to restrict the set of file
       names matching a pattern.  If GLOBIGNORE is  set,  each  matching  file
       name  that  also  matches  one of the patterns in GLOBIGNORE is removed
       from the list of matches.  The file names  “.”   and  “..”  are  always
       ignored  when  GLOBIGNORE  is  set  and  not  null.   However,  setting
       GLOBIGNORE to a non-null value has the effect of enabling  the  dotglob
       shell  option, so all other file names beginning with a “.” will match.
       To get the old behavior of ignoring file names beginning  with  a  “.”,
       make  “.*”  one  of  the patterns in GLOBIGNORE.  The dotglob option is
       disabled when GLOBIGNORE is unset.

       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.

              Within  [  and  ],  character classes can be specified using the
              syntax [:class:], where class is one of  the  following  classes
              defined in the POSIX standard:
              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.

       Note that the exec builtin command can make redirections take effect in
       the current shell.

   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

       No  parameter expansion, command substitution, arithmetic expansion, or
       pathname expansion is performed on word.  If any characters in word are
       quoted,  the  delimiter is the result of quote removal on word, and the
       lines in the here-document are not expanded.  If word is unquoted,  all
       lines  of  the  here-document  are  subjected  to  parameter expansion,
       command substitution, and arithmetic expansion.  In  the  latter  case,
       the  character  sequence  \<newline>  is ignored, and \ must be used to
       quote the characters \, $, and ‘.

       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

       Aliases allow a string to be substituted for a word when it is used  as
       the  first  word  of  a  simple command.  The shell maintains a list of
       aliases that may be set and unset with the alias  and  unalias  builtin
       commands  (see  SHELL  BUILTIN COMMANDS below).  The first word of each
       simple command, if unquoted, is checked to see if it has an alias.   If
       so,  that word is replaced by the text of the alias.  The characters /,
       $, ‘, and = and any of the shell metacharacters or  quoting  characters
       listed above may not appear in an alias name.  The replacement text may
       contain any valid shell input,  including  shell  metacharacters.   The
       first  word  of  the replacement text is tested for aliases, but a word
       that is identical to an alias being expanded is not expanded  a  second
       time.   This  means  that  one may alias ls to ls -F, for instance, and
       bash does not try to recursively expand the replacement text.   If  the
       last  character  of  the  alias value is a blank, then the next command
       word following the alias is also checked for alias expansion.

       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.

       Function  names and definitions may be listed with the -f option to the
       declare or typeset builtin commands.   The  -F  option  to  declare  or
       typeset  will  list  the function names only (and optionally the source
       file and line  number,  if  the  extdebug  shell  option  is  enabled).
       Functions  may  be  exported  so that subshells automatically have them
       defined  with  the  -f  option  to  the  export  builtin.   A  function
       definition  may  be  deleted  using the -f option to the unset builtin.
       Note that shell functions and variables with the same name  may  result
       in  multiple identically-named entries in the environment passed to the
       shell’s children.  Care should be taken in cases where this may cause a
       problem.

       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
              True if file exists and its “sticky” bit is set.
       -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.

       Simply  naming a job can be used to bring it into the foreground: %1 is
       a synonym for “fg %1”, bringing job 1  from  the  background  into  the
       foreground.   Similarly,  “%1  &”  resumes  job  1  in  the background,
       equivalent to “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^
              Quick substitution.  Repeat the last command, replacing  string1
              with   string2.    Equivalent  to  “!!:s/string1/string2/”  (see
              Modifiers below).
       !#     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
              Display current readline key and function bindings, bind  a  key
              sequence  to  a  readline  function  or macro, or set a readline
              variable.  Each non-option argument is a  command  as  it  would
              appear  in  .inputrc, but each binding or command must be passed
              as a separate argument; e.g.,  ’"\C-x\C-r":  re-read-init-file’.
              Options, if supplied, have the following meanings:
              -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]
              Change the current directory to dir.  The variable HOME  is  the
              default  dir.   The  variable CDPATH defines the search path for
              the directory containing dir.  Alternative  directory  names  in
              CDPATH  are  separated by a colon (:).  A null directory name in
              CDPATH is the same as the current directory, i.e., “.”.  If  dir
              begins  with a slash (/), then CDPATH is not used. The -P option
              says  to  use  the  physical  directory  structure  instead   of
              following  symbolic  links  (see  also  the -P option to the set
              builtin command); the -L option  forces  symbolic  links  to  be
              followed.   An  argument  of  -  is equivalent to $OLDPWD.  If a
              non-empty directory name from CDPATH is used, or  if  -  is  the
              first  argument,  and  the  directory  change is successful, the
              absolute pathname of the new working directory is written to the
              standard  output.  The return value is true if the directory was
              successfully changed; false otherwise.

       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]
              Resume the next iteration of the enclosing for, while, until, or
              select  loop.   If  n  is specified, resume at the nth enclosing
              loop.  n must be ≥ 1.  If  n  is  greater  than  the  number  of
              enclosing  loops, the last enclosing loop (the “top-level” loop)
              is resumed.  The return value is  0  unless  the  shell  is  not
              executing a loop when continue is executed.

       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     Append the “new” history  lines  (history  lines  entered
                     since  the  beginning of the current bash session) to the
                     history file.
              -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   Change  the  behavior  of bash where the default
                              operation differs from  the  POSIX  standard  to
                              match the standard (posix mode).
                      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
                      If  set,  and  a file that bash is checking for mail has
                      been accessed since the last time it  was  checked,  the
                      message   “The  mail  in  mailfile  has  been  read”  is
                      displayed.
              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 ...]
              The command arg is to  be  read  and  executed  when  the  shell
              receives  signal(s)   sigspec.  If arg is absent (and there is a
              single sigspec) or -, each specified  signal  is  reset  to  its
              original  disposition  (the  value  it  had upon entrance to the
              shell).  If arg is the null string the signal specified by  each
              sigspec  is ignored by the shell and by the commands it invokes.
              If arg is not present and -p has been supplied,  then  the  trap
              commands  associated  with  each  sigspec  are displayed.  If no
              arguments are supplied or if only -p is given, trap  prints  the
              list  of  commands  associated  with each signal.  The -l option
              causes the shell to print a  list  of  signal  names  and  their
              corresponding  numbers.   Each  sigspec  is either a signal name
              defined in <signal.h>, or a signal  number.   Signal  names  are
              case  insensitive  and the SIG prefix is optional.  If a sigspec
              is EXIT (0) the command arg is executed on exit from the  shell.
              If  a sigspec is DEBUG, the command arg is executed before every
              simple command, for command, case command, select command, every
              arithmetic for command, and before the first command executes in
              a shell function  (see  SHELL  GRAMMAR  above).   Refer  to  the
              description  of  the  extdebug  option  to the shopt builtin for
              details of its effect on the DEBUG trap.  If a sigspec  is  ERR,
              the  command  arg  is  executed  whenever a simple command has a
              non-zero exit status, subject to the following conditions.   The
              ERR  trap  is  not executed if the failed command is part of the
              command list immediately following a  while  or  until  keyword,
              part of the test in an if statement, part of a && or ││ list, or
              if the command’s return value is being inverted  via  !.   These
              are  the  same  conditions  obeyed  by the errexit option.  If a
              sigspec is RETURN, the command arg is executed each time a shell
              function  or  a  script  executed  with the . or source builtins
              finishes executing.  Signals ignored upon  entry  to  the  shell
              cannot  be trapped or reset.  Trapped signals that are not being
              ignored are reset to their original values in  a  child  process
              when  it  is created.  The return status is false if any sigspec
              is invalid; otherwise trap returns true.

       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     The maximum scheduling priority ("nice")
              -f     The  maximum  size  of files written by the shell and its
                     children
              -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     The maximum real-time scheduling priority
              -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.