Provided by: manpages-fr-extra_20090906_all bug

NOM

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

SYNOPSIS

       bash [options] [fichier]

COPYRIGHT

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

DESCRIPTION

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

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

OPTIONS

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

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

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

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

       --login
              Équivalent à -l.

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

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

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

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

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

       --verbose
              Équivalent à -v.

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

ARGUMENTS

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

APPEL

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

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

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

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

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

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

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

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

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

       Bash attempts to determine when it is being run with its standard input
       connected  to a a network connection, as if by the remote shell daemon,
       usually rshd, or the secure shell daemon sshd.  If bash  determines  it
       is  being  run  in  this  fashion,  it reads and executes commands from
       ~/.bashrc and ~/.bashrc, if these files exist  and  are  readable.   It
       will  not  do  this if invoked as sh.  The --norc option may be used to
       inhibit this behavior, and the --rcfile option may  be  used  to  force
       another  file  to be read, but rshd does not generally invoke the shell
       with those options or allow them to be specified.

       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
       A pipeline is a sequence of one or more commands separated  by  one  of
       the control operators | or |&.  The format for a pipeline is:

              [time [-p]] [ ! ] command [ [||&] command2 ... ]

       The  standard output of command is connected via a pipe to the standard
       input  of  command2.   This  connection   is   performed   before   any
       redirections  specified  by the command (see REDIRECTION below).  If |&
       is used, the standard error  of  command  is  connected  to  command2’s
       standard  input  through  the  pipe;  it is shorthand for 2>&1 |.  This
       implicit redirection of the  standard  error  is  performed  after  any
       redirections specified by the command.

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

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

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

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

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

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

       Si  une  commande  se  termine   par   l’opérateur   de   contrôle   &,
       l’interpréteur  l’exécute  en  arrire-plan, dans un sous-interpréteur.
       L’interpréteur n’attend pas  que  la  commande  se  termine  et  l’état
       renvoyé  est  0.  Les  commandes  séparées  par  un  ;  sont  exécutées
       successivement, l’interpréteur attend que chaque  commande  se  termine
       tour  à  tour.  L’état renvoyé est l’état final de la dernière commande
       exécutée.

       AND and OR lists are sequences of one of more  pipelines  separated  by
       the  &&  and  ││ control operators, respectively.  AND and OR lists are
       executed with left associativity.  An AND list has the form

              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; }
              list is simply executed in the current shell environment.   list
              must  be  terminated with a newline or semicolon.  This is known
              as a group command.  The return status is  the  exit  status  of
              list.   Note that unlike the metacharacters ( and ), { and } are
              reserved words and must occur where a reserved word is permitted
              to  be  recognized.   Since they do not cause a word break, they
              must be separated from  list  by  whitespace  or  another  shell
              metacharacter.

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

              An  additional  binary operator, =~, is available, with the same
              precedence as == and !=.  When it is used,  the  string  to  the
              right   of  the  operator  is  considered  an  extended  regular
              expression and matched accordingly (as in regex(3)).  The return
              value  is  0 if the string matches the pattern, and 1 otherwise.
              If  the  regular  expression  is  syntactically  incorrect,  the
              conditional expression’s return value is 2.  If the shell option
              nocasematch is enabled, the match is performed without regard to
              the  case of alphabetic characters.  Any part of the pattern may
              be quoted to force it to be matched  as  a  string.   Substrings
              matched  by  parenthesized  subexpressions  within  the  regular
              expression are saved in the array  variable  BASH_REMATCH.   The
              element  of  BASH_REMATCH  with  index  0  is the portion of the
              string matching the entire regular expression.  The  element  of
              BASH_REMATCH  with index n is the portion of the string matching
              the nth parenthesized subexpression.

              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
              A case command first expands word, and tries to match it against
              each  pattern  in  turn,  using  the  same matching rules as for
              pathname expansion (see Pathname Expansion below).  The word  is
              expanded   using   tilde   expansion,   parameter  and  variable
              expansion,  arithmetic   substitution,   command   substitution,
              process  substitution  and quote removal.  Each pattern examined
              is  expanded  using  tilde  expansion,  parameter  and  variable
              expansion,  arithmetic  substitution,  command substitution, and
              process  substitution.   If  the  shell  option  nocasematch  is
              enabled,  the  match  is performed without regard to the case of
              alphabetic characters.  When a match is found, the corresponding
              list  is  executed.   If  the ;; operator is used, no subsequent
              matches are attempted after the first pattern match.   Using  ;&
              in  place  of  ;;  causes  execution  to  continue with the list
              associated with the next set of patterns.  Using ;;& in place of
              ;;  causes  the  shell  to  test  the  next  pattern list in the
              statement,  if  any,  and  execute  any  associated  list  on  a
              successful  match.   The  exit  status  is  zero  if  no pattern
              matches.  Otherwise, it is the exit status of the  last  command
              executed in list.

       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.

   Coprocesses
       A coprocess is a shell command preceded by the coproc reserved word.  A
       coprocess  is  executed asynchronously in a subshell, as if the command
       had been terminated with the & control operator, with  a  two-way  pipe
       established between the executing shell and the coprocess.

       The format for a coprocess is:

              coproc [NAME] command [redirections]

       This  creates  a  coprocess  named  NAME.  If NAME is not supplied, the
       default name is COPROC.  NAME must not be  supplied  if  command  is  a
       simple  command  (see above); otherwise, it is interpreted as the first
       word of the simple command.  When the coproc  is  executed,  the  shell
       creates  an array variable (see Arrays below) named NAME in the context
       of the executing shell.  The standard output of  command  is  connected
       via  a  pipe to a file descriptor in the executing shell, and that file
       descriptor is assigned to NAME[0].  The standard input  of  command  is
       connected  via  a pipe to a file descriptor in the executing shell, and
       that file descriptor is assigned to NAME[1].  This pipe is  established
       before  any  redirections  specified  by  the  command (see REDIRECTION
       below).  The file descriptors can be utilized  as  arguments  to  shell
       commands  and redirections using standard word expansions.  The process
       id of the shell spawned to execute the coprocess is  available  as  the
       value  of  the variable NAME_PID.  The wait builtin command may be used
       to wait for the coprocess to terminate.

       The return status of a coprocess is the exit status of command.

   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.

       In the context where an assignment statement is assigning a value to  a
       shell variable or array index, the += operator can be used to append to
       or add to the variable’s previous value.   When  +=  is  applied  to  a
       variable  for  which  the  integer  attribute  has  been  set, value is
       evaluated as an arithmetic  expression  and  added  to  the  variable’s
       current value, which is also evaluated.  When += is applied to an array
       variable using compound assignment (see Arrays below),  the  variable’s
       value is not unset (as it is when using =), and new values are appended
       to the array beginning at one greater than the  array’s  maximum  index
       (for  indexed  arrays)  or  added  as  additional key-value pairs in an
       associative array.  When applied to a string-valued variable, value  is
       expanded and appended to the variable’s value.

   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.
       ?      Expands  to  the  exit  status  of  the  most  recently executed
              foreground pipeline.
       -      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.
       BASHPID
              Expands to the process id of the  current  bash  process.   This
              differs  from  $$ under certain circumstances, such as subshells
              that do not require bash to be re-initialized.
       BASH_ALIASES
              An associative array variable whose members  correspond  to  the
              internal  list  of  aliases  as  maintained by the alias builtin
              Elements added to this array appear in the alias list; unsetting
              array  elements cause aliases to be removed from the alias list.
       BASH_ARGC
              An array variable whose values are the number of  parameters  in
              each frame of the current bash execution call stack.  The number
              of parameters to  the  current  subroutine  (shell  function  or
              script  executed  with  . or source) is at the top of the stack.
              When a subroutine is executed, the number of  parameters  passed
              is pushed onto BASH_ARGC.  The shell sets BASH_ARGC only when in
              extended debugging mode (see the  description  of  the  extdebug
              option to the shopt builtin below)
       BASH_ARGV
              An  array  variable  containing  all  of  the  parameters in the
              current bash execution call stack.  The final parameter  of  the
              last  subroutine  call  is  at  the  top of the stack; the first
              parameter of  the  initial  call  is  at  the  bottom.   When  a
              subroutine  is executed, the parameters supplied are pushed onto
              BASH_ARGV.  The shell  sets  BASH_ARGV  only  when  in  extended
              debugging  mode  (see  the description of the extdebug option to
              the shopt builtin below)
       BASH_CMDS
              An associative array variable whose members  correspond  to  the
              internal  hash  table  of  commands  as  maintained  by the hash
              builtin.  Elements added to this array appear in the hash table;
              unsetting  array  elements cause commands to be removed from the
              hash table.
       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
              An  array  variable whose members are the line numbers in source
              files   corresponding    to    each    member    of    FUNCNAME.
              ${BASH_LINENO[$i]}  is  the line number in the source file where
              ${FUNCNAME[$i]}   was   called   (or   ${BASH_LINENO[$i-1]}   if
              referenced  within  another  shell function).  The corresponding
              source file name is ${BASH_SOURCE[$i]}.  Use  LINENO  to  obtain
              the current line number.
       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_KEY
              The key (or final key of a key  sequence)  used  to  invoke  the
              current completion function.

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

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

       COMP_TYPE
              Set to an integer value corresponding to the type of  completion
              attempted  that  caused a completion function to be called: TAB,
              for  normal  completion,  ?,  for  listing   completions   after
              successive  tabs,  !,  for  listing alternatives on partial word
              completion,  @,  to  list  completions  if  the  word   is   not
              unmodified,  or  %,  for  menu  completion.   This  variable  is
              available only in shell functions and external commands  invoked
              by  the  programmable  completion  facilities  (see Programmable
              Completion below).

       COMP_WORDBREAKS
              The set of characters that the readline library treats  as  word
              separators  when performing word completion.  If COMP_WORDBREAKS
              is unset, it  loses  its  special  properties,  even  if  it  is
              subsequently reset.

       COMP_WORDS
              An   array   variable  (see  Arrays  below)  consisting  of  the
              individual words in the current command line.  The line is split
              into  words as readline would split it, using COMP_WORDBREAKS as
              described above.  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
              An array variable containing the names of  all  shell  functions
              currently in the execution call stack.  The element with index 0
              is the name of  any  currently-executing  shell  function.   The
              bottom-most element is "main".  This variable exists only when a
              shell function is executing.  Assignments to  FUNCNAME  have  no
              effect  and  return  an  error status.  If FUNCNAME is unset, it
              loses its special properties, even if it is subsequently  reset.

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

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

       HOSTNAME
              Automatiquement mis au nom de la machine courante.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              Le p facultatif est un chiffre indiquant la prcision, le nombre
              de chiffres  après  la  virgule.  Une  valeur  de  0  conduit  à
              affichage de nombre entiers. Trois chiffres au plus peuvent être
              affichés après la virgule ; tout  chiffre  supérieur  à  3  sera
              changé  en 3. Si p n’est pas spécifié, la valeur 3 est utilisée.

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

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

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

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

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

       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 provides one-dimensional indexed and associative array  variables.
       Any  variable may be used as an indexed array; the declare builtin will
       explicitly declare an array.  There is no maximum limit on the size  of
       an  array,  nor  any  requirement  that  members be indexed or assigned
       contiguously.  Indexed arrays are referenced using integers  (including
       arithmetic  expressions)   and  are  zero-based; associative arrays are
       referenced using arbitrary strings.

       An indexed array is created automatically if any variable  is  assigned
       to using the syntax name[subscript]=value.  The subscript is treated as
       an arithmetic expression that must evaluate to a number greater than or
       equal  to zero.  To explicitly declare an indexed array, use declare -a
       name (see SHELL BUILTIN COMMANDS below).  declare -a name[subscript] is
       also accepted; the subscript is ignored.

       Associative arrays are created using declare -A name.

       Attributes may be specified for an array variable using the declare and
       readonly builtins.  Each attribute applies to all members of an  array.

       Arrays   are  assigned  to  using  compound  assignments  of  the  form
       name=(value1  ...  valuen),  where  each   value   is   of   the   form
       [subscript]=string.   Indexed  array  assignments  do  not  require the
       bracket and subscript.   When  assigning  to  indexed  arrays,  if  the
       optional  brackets  and  subscript are supplied, that index is assigned
       to; otherwise the index of the  element  assigned  is  the  last  index
       assigned to by the statement plus one.  Indexing starts at zero.

       When assigning to an associative array, the subscript is required.

       This  syntax is also accepted by the declare builtin.  Individual array
       elements may be assigned  to  using  the  name[subscript]=value  syntax
       introduced above.

       Any  element  of  an  array may be referenced using ${name[subscript]}.
       The braces are required to avoid conflicts with pathname expansion.  If
       subscript  is  @  or *, the word expands to all members of name.  These
       subscripts differ only when the word appears within double quotes.   If
       the word is double-quoted, ${name[*]} expands to a single word with the
       value of each array member separated by the first character of the  IFS
       special  variable,  and  ${name[@]}  expands  each element of name to a
       separate word.  When there are no array members, ${name[@]} expands  to
       nothing.   If  the  double-quoted  expansion  occurs within a word, the
       expansion of the first parameter is joined with the beginning  part  of
       the  original  word,  and the expansion of the last parameter is joined
       with the last part of the original word.   This  is  analogous  to  the
       expansion  of  the  special  parameters * and @ (see Special Parameters
       above).     ${#name[subscript]}    expands    to    the    length    of
       ${name[subscript]}.   If  subscript  is  *  or  @, the expansion is the
       number of elements in the array.  Referencing an array variable without
       a  subscript is equivalent to referencing the array with a subscript of
       0.

       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.

       The  declare,  local,  and readonly builtins each accept a -a option to
       specify an indexed array and a -A  option  to  specify  an  associative
       array.   The read builtin accepts a -a option to assign a list of words
       read from the standard input to an array.  The set and declare builtins
       display  array  values  in  a  way  that  allows  them  to be reused as
       assignments.

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

       A  sequence expression takes the form {x..y[..incr]}, where x and y are
       either integers or single characters, and incr, an optional  increment,
       is  an  integer.  When integers are supplied, the expression expands to
       each number between x and  y,  inclusive.   Supplied  integers  may  be
       prefixed with 0 to force each term to have the same width.  When either
       x or y begins with a zero, the shell attempts to  force  all  generated
       terms  to  contain  the  same  number  of  digits,  zero-padding  where
       necessary.  When characters are supplied,  the  expression  expands  to
       each character lexicographically between x and y, inclusive.  Note that
       both x and y must be of the same type.  When the increment is supplied,
       it  is used as the difference between each term.  The default increment
       is 1 or -1 as appropriate.

       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.

       In  each  of  the  cases  below,  word  is  subject to tilde expansion,
       parameter expansion, command substitution, and arithmetic expansion.

       When not performing substring expansion,  using  the  forms  documented
       below,  bash tests for a parameter that is unset or null.  Omitting the
       colon results in a test only for a parameter that is unset.

       ${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}
              Substring Expansion. Expands  to  up  to  length  characters  of
              parameter  starting  at  the  character specified by offset.  If
              length  is  omitted,  expands  to  the  substring  of  parameter
              starting  at  the  character  specified  by  offset.  length and
              offset are arithmetic  expressions  (see  ARITHMETIC  EVALUATION
              below).   length must evaluate to a number greater than or equal
              to zero.  If offset evaluates to a number less  than  zero,  the
              value  is  used  as  an  offset  from  the  end  of the value of
              parameter.  Arithmetic expressions starting with  a  -  must  be
              separated by whitespace from the preceding : to be distinguished
              from the Use Default Values expansion.  If parameter is  @,  the
              result  is length positional parameters beginning at offset.  If
              parameter is an indexed array name subscripted by @  or  *,  the
              result  is  the  length  members  of  the  array  beginning with
              ${parameter[offset]}.  A negative offset is  taken  relative  to
              one  greater  than  the  maximum  index  of the specified array.
              Substring expansion applied to  an  associative  array  produces
              undefined   results.   Note  that  a  negative  offset  must  be
              separated from the colon by at least one space  to  avoid  being
              confused   with   the   :-  expansion.   Substring  indexing  is
              zero-based unless the positional parameters are used,  in  which
              case  the  indexing starts at 1 by default.  If offset is 0, and
              the positional parameters are used, $0 is prefixed to the  list.

       ${!prfixe*}
       ${!prfixe@}
              Names  matching  prefix. Expands to the names of variables whose
              names begin with prefix, separated by the first character of the
              IFS  special variable.  When @ is used and the expansion appears
              within double quotes, each variable name expands to  a  separate
              word.

       ${!nom[@]}
       ${!nom[*]}
              List of array keys. If name is an array variable, expands to the
              list of array indices (keys) assigned in name.  If name  is  not
              an  array, expands to 0 if name is set and null otherwise.  When
              @ is used and the expansion appears within double  quotes,  each
              key expands to a separate word.

       ${#paramtre}
              Parameter  length.  The  length  in  characters  of the value of
              parameter is substituted.  If parameter is *  or  @,  the  value
              substituted   is   the  number  of  positional  parameters.   If
              parameter is an array name subscripted by  *  or  @,  the  value
              substituted is the number of elements in the array.

       ${paramtre#mot}
       ${paramtre##mot}
              Remove  matching prefix pattern. 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}
              Remove  matching suffix pattern. 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}
              Pattern  substitution.  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 pattern 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.

       ${parameter^pattern}
       ${parameter^^pattern}
       ${parameter,pattern}
       ${parameter,,pattern}
              Case   modification.   This   expansion  modifies  the  case  of
              alphabetic characters in parameter.  The pattern is expanded  to
              produce a pattern just as in pathname expansion.  The ^ operator
              converts lowercase letters matching pattern to uppercase; the  ,
              operator  converts matching uppercase letters to lowercase.  The
              ^^ and ,, expansions  convert  each  matched  character  in  the
              expanded  value;  the  ^ and , expansions match and convert only
              the first character in  the  expanded  value..   If  pattern  is
              omitted,  it is treated like a ?, which matches every character.
              If parameter is @ or  *,  the  case  modification  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 case modification 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
              `command`

       Bash effectue la  substitution  en  exécutant  la  commande  et  en  la
       remplaçant  par  sa sortie standard, dont les éventuels sauts de lignes
       finaux sont supprimés.  Les  sauts  de  lignes  internes  ne  sont  pas
       supprimés  mais  peuvent  disparaître  lors  du  découpage  en mots. La
       substitution  de  commande  $(cat  fichier)  peut  être  remplacée  par
       l’équivalent plus rapide $(< fichier).

       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.

       The  shell  treats each character of IFS as a delimiter, and splits the
       results of the other expansions into words on these characters.  If IFS
       is  unset,  or its value is exactly <space><tab><newline>, the default,
       then sequences of <space>, <tab>, and <newline> at  the  beginning  and
       end  of  the  results  of  the previous expansions are ignored, and any
       sequence of IFS characters not  at  the  beginning  or  end  serves  to
       delimit  words.   If  IFS  has  a  value  other  than the default, then
       sequences of the whitespace characters space and tab are ignored at the
       beginning  and  end of the word, as long as the whitespace character is
       in the value of IFS (an IFS whitespace character).   Any  character  in
       IFS  that is not IFS whitespace, along with any adjacent IFS whitespace
       characters, delimits a field.  A sequence of IFS whitespace  characters
       is  also  treated as a delimiter.  If the value of IFS is null, no word
       splitting occurs.

       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 not
       enabled, 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.

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

       Motifs génériques

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

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

       *      Matches  any  string,  including  the  null  string.   When  the
              globstar  shell  option  is enabled, and * is used in a filename
              expansion context, two adjacent *s used as a single pattern will
              match all files and zero or more directories and subdirectories.
              If followed by a /, two adjacent *s will match only  directories
              and subdirectories.
       ?      Correspond à n’importe quel caractère.
       [...]  Correspond  à  tout  caractère  entre les crochets. Un couple de
              caractères séparés par un trait d’union indique  une  expression
              de  plage ;  tout  caractère  qui  correspond  à  n’importe quel
              caractère situé entre les deux bornes incluses, en utilisant les
              suites  de  collations  des  paramètres  linguistiques régionaux
              courants et le  jeu  de  caractères.  Si  le  premier  caractère
              suivant  le  [  est un ! ou un ^ alors la correspondance se fait
              sur  tous  les  caractères  hors  plage.  L’ordre  de  tri   des
              caractères  dans  les expressions de plage est déterminé par les
              paramètres linguistiques régionaux courants et par la valeur  de
              la variable de l’interpréteur LC_COLLATE si existante. Un - peut
              être mis en correspondance en l’incluant en premier  ou  dernier
              caractère de l’ensemble. Un ] peut être mis en correspondance en
              l’incluant en premier caractère de l’ensemble.

              Entre [ et ], on  peut  indiquer  une  classe  de  caractre  en
              utilisant la syntaxe [:classe:], où classe est l’une des classes
              suivantes, définies dans le standard POSIX :
              alnum alpha ascii blank cntrl  digit  graph  lower  print  punct
              space upper word xdigit
              Une  classe correspond à un caractère quelconque qui s’y trouve.
              La  classe  de  caractères  word  correspond  aux  lettres,  aux
              chiffres et au caractère souligné « _ ».

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

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

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

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

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

REDIRECTIONS

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

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

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

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

              ls > liste_répertoires 2>&1

       redirige à la fois la sortie standard et la  sortie  d’erreur  standard
       vers le fichier liste_rpertoires, alors que la commande

              ls 2>&1 > liste_répertoires

       directs  only the standard output to file dirlist, because the standard
       error was duplicated from  the  standard  output  before  the  standard
       output was redirected to dirlist.

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

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

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

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

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

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

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

              [n]<mot

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

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

              [n]>mot

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

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

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

              [n]>>mot

   Redirection de la sortie standard et de la sortie derreur standard
       This construct allows both the standard output (file descriptor 1)  and
       the  standard error output (file descriptor 2)  to be redirected to the
       file whose name is the expansion of word.

       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

   Appending Standard Output and Standard Error
       This construct allows both the standard output (file descriptor 1)  and
       the  standard  error  output (file descriptor 2)  to be appended to the
       file whose name is the expansion of word.

       The format for appending standard output and standard error is:

              &>>word

       This is semantically equivalent to

              >>word 2>&1

   Document en ligne
       This type of redirection instructs the shell to  read  input  from  the
       current source until a line containing only delimiter (with no trailing
       blanks) is seen.  All of the lines read up to that point are then  used
       as the standard input for a command.

       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.

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

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

ÉVALUATION ARITHMÉTIQUE

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

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

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

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

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

CONDITIONS

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

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

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

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

       chane_1 == chane_2
              Vrai si les deux chaînes sont égales. Le symbole = peut servir à
              remplacer == pour une stricte conformité POSIX.

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

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

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

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

DÉVELOPPEMENT DES COMMANDES SIMPLES

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

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

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

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

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

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

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

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

EXÉCUTION DES COMMANDES

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

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

       If the name is neither a shell function nor a builtin, and contains  no
       slashes,  bash  searches  each  element  of  the  PATH  for a directory
       containing an executable file by that name.  Bash uses a hash table  to
       remember  the  full pathnames of executable files (see hash under SHELL
       BUILTIN COMMANDS below).  A full search of the directories in  PATH  is
       performed  only  if the command is not found in the hash table.  If the
       search is unsuccessful, the shell searches for a defined shell function
       named command_not_found_handle.  If that function exists, it is invoked
       with the original command and the original command’s arguments  as  its
       arguments,  and  the  function’s exit status becomes the exit status of
       the shell.  If that function is not defined, the shell prints an  error
       message and returns an exit status of 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.

       Subshells spawned to execute command substitutions inherit the value of
       the -e option from the parent shell.  When  not  in  posix  mode,  Bash
       clears the -e option in such subshells.

       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

       The  exit  status  of  an executed command is the value returned by the
       waitpid system call or equivalent function.  Exit statuses fall between
       0  and  255, though, as explained below, the shell may use values above
       125 specially.  Exit statuses from shell builtins and compound commands
       are  also limited to this range. Under certain circumstances, the shell
       will use special values to indicate specific failure modes.

       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.

       There are a number of ways to  refer  to  a  job  in  the  shell.   The
       character % introduces a job specification (jobspec).  Job number n may
       be referred to as %n.  A job may also be referred to using a prefix  of
       the  name  used  to  start it, or using a substring that appears in its
       command line.  For example, %ce refers to  a  stopped  ce  job.   If  a
       prefix  matches  more than one job, bash reports an error.  Using %?ce,
       on the other hand, refers to any job containing the string  ce  in  its
       command line.  If the substring matches more than one job, bash reports
       an error.  The symbols %% and %+ refer to the  shell’s  notion  of  the
       current  job,  which  is  the  last  job  stopped  while  it was in the
       foreground or started in the  background.   The  previous  job  may  be
       referenced using %-.  If there is only a single job, %+ and %- can both
       be used to refer to that job.  In output pertaining to jobs (e.g.,  the
       output  of  the jobs command), the current job is always flagged with a
       +, and the previous job with a -.  A single % (with no accompanying job
       specification) also refers to the current job.

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

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

       If an attempt to exit bash is made while jobs are stopped (or,  if  the
       checkjobs  shell  option  has  been  enabled  using  the shopt builtin,
       running), the shell prints a warning message,  and,  if  the  checkjobs
       option is enabled, lists the jobs and their statuses.  The jobs command
       may then be used to inspect their status.  If a second attempt to  exit
       is  made  without  an  intervening  command,  the  shell does not print
       another warning, and any stopped jobs are terminated.

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     the current working  directory,  with  $HOME  abbreviated
                     with a tilde (uses the $PROMPT_DIRTRIM variable)
              \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

       This   is  the  library  that  handles  reading  input  when  using  an
       interactive shell, unless the --noediting  option  is  given  at  shell
       invocation.   Line editing is also used when using the -e option to the
       read builtin.  By default, the line editing  commands  are  similar  to
       those  of  emacs.  A vi-style line editing interface is also available.
       Line editing can be enabled at any time using the -o  emacs  or  -o  vi
       options to the set builtin (see SHELL BUILTIN COMMANDS below).  To turn
       off line editing after the shell is running, use the +o emacs or +o  vi
       options to the set builtin.

   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-prefix-display-length (0)
              The  length  in  characters  of  the  common prefix of a list of
              possible completions that  is  displayed  without  modification.
              When  set  to  a value greater than zero, common prefixes longer
              than this value are replaced with an  ellipsis  when  displaying
              possible completions.
       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.
       history-size (0)
              Set the maximum number of history entries saved in  the  history
              list.  If set to zero, the number of entries in the history list
              is not limited.
       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.
       revert-all-at-newline (Off)
              If  set  to  on, readline will undo all changes to history lines
              before returning when  accept-line  is  executed.   By  default,
              history  lines  may be modified and retain individual undo lists
              across calls to readline.
       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).
       shell-forward-word
              Move  forward  to the end of the next word.  Words are delimited
              by non-quoted shell metacharacters.
       shell-backward-word
              Move back to the start of the current or previous  word.   Words
              are delimited by non-quoted shell metacharacters.
       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)
              Invoke an editor on the current command line,  and  execute  the
              result  as  shell  commands.   Bash  attempts to invoke $VISUAL,
              $EDITOR, and emacs as the editor, in that order.

   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.
       shell-kill-word (M-d)
              Kill from point to the end of the current word,  or  if  between
              words,  to  the  end  of the next word.  Word boundaries are the
              same as those used by shell-forward-word.
       shell-backward-kill-word (M-Rubout)
              Kill the word behind point.  Word boundaries  are  the  same  as
              those used by shell-backward-word.
       unix-word-rubout (C-w)
              Effacer  le mot sous le curseur, en utilisant une espace blanche
              comme limite de mot. Le texte  effacé  est  sauvegardé  dans  le
              tampon circulaire.
       unix-filename-rubout
              Effacer le mot sous le curseur, en utilisant l’espace blanche et
              la barre oblique comme limites de mot.  Le  texte  supprimé  est
              sauvegardé dans le tampon circulaire.
       delete-horizontal-space (M-\)
              Effacer toutes les espaces blanches et les tabulations autour du
              curseur.
       kill-region
              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.
       dabbrev-expand
              Attempt menu completion on the text before point, comparing  the
              text against lines from the history list for possible completion
              matches.
       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.

       After  these matches have been generated, any shell function or command
       specified with the -F and -C options is invoked.  When the  command  or
       function is invoked, the COMP_LINE, COMP_POINT, COMP_KEY, and COMP_TYPE
       variables are assigned values as described above under Shell Variables.
       If  a  shell  function  is being invoked, the COMP_WORDS and COMP_CWORD
       variables are also set.  When the function or command is  invoked,  the
       first  argument  is  the  name of the command whose arguments are being
       completed, the second argument is the word  being  completed,  and  the
       third  argument  is  the word preceding the word being completed on the
       current command  line.   No  filtering  of  the  generated  completions
       against  the word being completed is performed; the function or command
       has complete freedom in generating the matches.

       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.

       On  startup,  the  history  is  initialized  from the file named by the
       variable HISTFILE (default ~/.bash_history).  The  file  named  by  the
       value  of  HISTFILE is truncated, if necessary, to contain no more than
       the number of lines specified by the value of HISTFILESIZE.   When  the
       history  file  is  read,  lines  beginning  with  the  history  comment
       character followed immediately by a digit are interpreted as timestamps
       for  the  preceding  history  line.   These  timestamps  are optionally
       displayed depending on the value of the HISTTIMEFORMAT variable.   When
       an  interactive  shell  exits, the last $HISTSIZE lines are copied from
       the history list to $HISTFILE.   If  the  histappend  shell  option  is
       enabled  (see  the  description  of  shopt under SHELL BUILTIN COMMANDS
       below), the lines are appended  to  the  history  file,  otherwise  the
       history  file  is overwritten.  If HISTFILE is unset, or if the history
       file is unwritable, the history is not saved.   If  the  HISTTIMEFORMAT
       variable  is  set,  time stamps are written to the history file, marked
       with the history comment character, so they  may  be  preserved  across
       shell sessions.  This uses the history comment character to distinguish
       timestamps from other history lines.  After  saving  the  history,  the
       history  file  is truncated to contain no more than HISTFILESIZE lines.
       If HISTFILESIZE is not set, no truncation is performed.

       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.

       The  shell allows control of the various characters used by the history
       expansion mechanism (see the description of histchars above under Shell
       Variables).   The  shell  uses  the  history  comment character to mark
       history timestamps when writing the history file.

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

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

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

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

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

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

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

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

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

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

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

       bind [-m jeu_de_raccourcis] [-lpsvPSV]
       bind   [-m   jeu_de_raccourcis]   [-q   fonction]   [-u  fonction]  [-r
       suite_de_touches]
       bind [-m jeu_de_raccourcis] -f fichier
       bind               [-m               jeu_de_raccourcis]              -x
       suite_de_touches:commande_de_linterprteur
       bind [-m jeu_de_raccourcis] suite_de_touches:nom_de_fonction
       bind commande_readline
              Affiche  les  associations  de touches readline courantes et les
              raccourcis de fonctions, associe une  suite  de  touches  à  une
              fonction  ou  une  macro readline ou crée une variable readline.
              Chaque argument qui n’est pas une option est une commande  comme
              elle  devrait apparaître dans .inputrc, mais chaque raccourci ou
              commande doit être fourni comme un  argument  indépendant ;  par
              exemple   « "\C-x\C-r":  re-read-init-file ».  Les  options,  si
              fournies, ont les significations suivantes :
              -m jeu_de_raccourcis
                     Utiliser le jeu_de_raccourcis  comme  jeu  de  raccourcis
                     devant  être  concerné par les raccourcis ultérieurs. Les
                     noms  de   jeux_de_raccourcis   possibles   sont   emacs,
                     emacs-standard,   emacs-meta,  emacs-ctlx,  vi,  vi-move,
                     vi-command et vi-insert. vi est équivalent à vi-command ;
                     emacs est équivalent à emacs-standard.
              -l     Afficher  la  liste  des  noms  de  toutes  les fonctions
                     readline.
              -p     Affiche  les  noms  des  fonctions  readline   et   leurs
                     raccourcis de façon à pouvoir les relire.
              -P     Affiche   les   noms  des  fonctions  readline  et  leurs
                     raccourcis.
              -s     Afficher les suites de  touches  readline  associées  aux
                     macros et les chaînes correspondantes, de façon à pouvoir
                     les relire.
              -S     Afficher les suites de  touches  readline  associées  aux
                     macros et les chaînes correspondantes.
              -v     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.
              -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
                     Cause  shell-command  to  be  executed whenever keyseq is
                     entered.  When shell-command is executed, the shell  sets
                     the   READLINE_LINE  variable  to  the  contents  of  the
                     readline line buffer and the READLINE_POINT  variable  to
                     the  current  location  of  the  insertion point.  If the
                     executed command changes the value  of  READLINE_LINE  or
                     READLINE_POINT, those new values will be reflected in the
                     editing state.

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

       break [n]
              Exit  from  within a for, while, until, or select loop.  If n is
              specified, break n levels.  n must be ≥ 1.  If n is greater than
              the  number  of enclosing loops, all enclosing loops are exited.
              The return value is 0 unless n is not greater than or  equal  to
              1.

       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.

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

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

       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 comp-option] [-E] [-A action] [-G globpat]
       [-W wordlist] [-F function] [-C command]
              [-X filterpat] [-P prefix] [-S suffix] name [name ...]
       complete -pr [-E] [name ...]
              Specify  how arguments to each name should be completed.  If the
              -p option is supplied, or if no options are  supplied,  existing
              completion  specifications are printed in a way that allows them
              to be reused as input.   The  -r  option  removes  a  completion
              specification  for  each name, or, if no names are supplied, all
              completion specifications.  The -E  option  indicates  that  the
              remaining  options  and  actions should apply to “empty” command
              completion; that is, completion attempted on a blank line.

              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
                              Tell   readline   that  the  compspec  generates
                              filenames,    so    it    can    perform     any
                              filename-specific   processing  (like  adding  a
                              slash  to  directory  names,   quoting   special
                              characters,  or  suppressing  trailing  spaces).
                              Intended to be used with shell functions.
                      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.

       compopt [-o option] [+o option] [name]
              Modify  completion  options  for  each  name  according  to  the
              options,  or  for the currently-execution completion if no names
              are supplied.  If no options are given, display  the  completion
              options  for  each name or the current completion.  The possible
              values of option  are  those  valid  for  the  complete  builtin
              described above.

       The  return  value  is  true  unless  an invalid option is supplied, an
       attempt is made  to  modify  the  options  for  a  name  for  which  no
       completion specification exists, or an output error occurs.

       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 n is not greater than
              or equal to 1.

       declare [-aAfFilrtux] [-p] [name[=value] ...]
       typeset [-aAfFilrtux] [-p] [name[=value] ...]
              Declare variables and/or give them attributes.  If no names  are
              given  then display the values of variables.  The -p option will
              display the attributes and values of each name.  When -p is used
              with name arguments, additional options are ignored.  When -p is
              supplied without name arguments, it will display the  attributes
              and  values  of all variables having the attributes specified by
              the additional options.  If no other options are  supplied  with
              -p,  declare will display the attributes and values of all shell
              variables.  The -f option will restrict  the  display  to  shell
              functions.   The  -F  option  inhibits  the  display of function
              definitions; only the function name and attributes are  printed.
              If  the extdebug shell option is enabled using shopt, the source
              file name and line number where  the  function  is  defined  are
              displayed  as  well.   The  -F option implies -f.  The following
              options can be used to restrict output  to  variables  with  the
              specified attribute or to give variables attributes:
              -a     Each  name  is  an  indexed  array  variable  (see Arrays
                     above).
              -A     Each name is an associative array  variable  (see  Arrays
                     above).
              -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.
              -l     When  the  variable  is  assigned a value, all upper-case
                     characters are converted to lower-case.   The  upper-case
                     attribute is disabled.
              -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.
              -u     When  the  variable  is  assigned a value, all lower-case
                     characters are converted to upper-case.   The  lower-case
                     attribute is disabled.
              -x     Marque   les   noms   pour   qu’ils  soit  exportés  dans
                     l’environnement des commandes ultérieures.

              Using ‘+’ instead of ‘-’ turns off the attribute  instead,  with
              the  exceptions  that  +a  may  not  be used to destroy an array
              variable and +r will not remove the  readonly  attribute.   When
              used  in  a  function,  makes each name local, as with the local
              command.  If a variable name is followed by =value, the value of
              the  variable  is set to value.  The return value is 0 unless an
              invalid option is encountered, an attempt is made  to  define  a
              function  using  ‘‘-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 [+n] [-n] [-cplv]
              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 ...]
              Without options, each jobspec  is  removed  from  the  table  of
              active  jobs.   If jobspec is not present, and neither -a nor -r
              is supplied, the shells notion of the current job is used.   If
              the  -h  option  is  given, each jobspec is not removed from the
              table, but is marked so that SIGHUP is not sent to  the  job  if
              the  shell  receives  a  SIGHUP.   If no jobspec is present, and
              neither the -a nor the -r option is supplied, the current job is
              used.   If no jobspec is supplied, the -a option means to remove
              or mark all jobs; the  -r  option  without  a  jobspec  argument
              restricts  operation  to  running  jobs.   The return value is 0
              unless a jobspec does not specify a valid job.

       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     suppress further output
              \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 [-a] [-dnps] [-f filename] [name ...]
              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]]
              If command is specified, it replaces the shell.  No new  process
              is  created.  The arguments become the arguments to command.  If
              the -l option is supplied,  the  shell  places  a  dash  at  the
              beginning  of  the  zeroth  argument passed to command.  This is
              what login(1)   does.   The  -c  option  causes  command  to  be
              executed  with  an  empty  environment.   If -a is supplied, the
              shell passes  name  as  the  zeroth  argument  to  the  executed
              command.   If  command  cannot  be  executed  for some reason, a
              non-interactive shell exits, unless the shell option execfail is
              enabled, in which case it returns failure.  An interactive shell
              returns failure if the file cannot be executed.  If  command  is
              not  specified,  any  redirections  take  effect  in the current
              shell, and the return status is 0.  If there  is  a  redirection
              error, the return status is 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 ename] [-lnr] [first] [last]
       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 [-dms] [pattern]
              Display  helpful information about builtin commands.  If pattern
              is specified, help gives detailed help on all commands  matching
              pattern;  otherwise  help for all the builtins and shell control
              structures is printed.
              -d     Display a short description of each pattern
               -m    Display the description of each pattern in a manpage-like
                     format
              -s     Display only a short usage synopsis for each pattern
       The return status is 0 unless no command matches pattern.

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

              If  the  HISTTIMEFORMAT  is  set,  the  time  stamp  information
              associated  with  each  history  entry is written to the history
              file, marked with  the  history  comment  character.   When  the
              history  file  is read, lines beginning with the history comment
              character followed immediately by a  digit  are  interpreted  as
              timestamps for the previous history line.  The return value is 0
              unless an invalid option is encountered, an error  occurs  while
              reading  or  writing  the  history  file,  an  invalid offset is
              supplied as an argument to -d, or the history expansion supplied
              as an argument to -p fails.

       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.

       mapfile [-n count] [-O origin] [-s count] [-t] [-u  fd]  [-C  callback]
       [-c quantum] [array]
       readarray [-n count] [-O origin] [-s count] [-t] [-u fd] [-C  callback]
       [-c quantum] [array]
              Read lines from the standard input into array variable array, or
              from  file  descriptor  fd  if  the  -u option is supplied.  The
              variable MAPFILE is the default array.   Options,  if  supplied,
              have the following meanings:
              -n     Copy  at  most count lines.  If count is 0, all lines are
                     copied.
              -O     Begin assigning to array at index  origin.   The  default
                     index is 0.
              -s     Discard the first count lines read.
              -t     Remove a trailing line from each line read.
              -u     Read  lines  from  file  descriptor  fd  instead  of  the
                     standard input.
              -C     Evaluate callback each time quantum lines are read.   The
                     -c option specifies quantum.
              -c     Specify  the  number  of  lines read between each call to
                     callback.

              If -C is specified without -c,  the  default  quantum  is  5000.
              When callback is evaluated, it is supplied the index of the next
              array  element  to  be  assigned  as  an  additional   argument.
              callback  is  evaluated  after  the  line is read but before the
              array element is assigned.

              If not supplied with an  explicit  origin,  mapfile  will  clear
              array before assigning to it.

              mapfile  returns successfully unless an invalid option or option
              argument is supplied, or array is invalid or unassignable.

       popd [-n] [+n] [-n]
              Enlève des éléments de la pile des répertoires. Sans  arguments,
              seul le répertoire du sommet de la pile est éliminé et un cd est
              effectué en direction  du  nouveau  répertoire  au  sommet.  Les
              argument, si fournis, ont les significations suivantes :
              -n     Empê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.
              +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.

              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] [+n] [-n]
       pushd [-n] [rp]
              Ajoute  un  répertoire  au  sommet de la pile des répertoires ou
              effectue une rotation dans la pile, en  ramenant  le  répertoire
              courant  au  sommet.  Sans  argument, cette commande échange les
              deux répertoires au sommet et renvoie 0, à  moins  que  la  pile
              soit  vide.  Les  arguments,  si fournis, ont les significations
              suivantes :
              -n     Empêche le changement  normal  de  répertoire  lors  d’un
                     ajout dans la pile. Seule la pile est manipulée.
              +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).
              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] [-a aname] [-d delim] [-i text] [-n nchars] [-p prompt] [-t
       timeout] [-u fd] [name ...]
              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     If the standard input is coming from a terminal, readline
                     (see  READLINE  above)  is  used  to  obtain  the   line.
                     Readline  uses  the  current (or default, if line editing
                     was not previously active) editing settings.
              -i text
                     If readline is being used  to  read  the  line,  text  is
                     placed into the editing buffer before editing begins.
              -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
                     Cause read to time out and return failure if  a  complete
                     line  of  input  is  not  read  within  timeout  seconds.
                     timeout may be a decimal number with a fractional portion
                     following   the  decimal  point.   This  option  is  only
                     effective if read is reading input from a terminal, pipe,
                     or other special file; it has no effect when reading from
                     regular files.  If timeout is 0, read returns success  if
                     input  is  available  on  the  specified file descriptor,
                     failure otherwise.  The exit status is greater  than  128
                     if the timeout is exceeded.
              -u fd  Lire l’entrée à partir du descripteur de fichier fd.

              If  no  names  are  supplied,  the  line read is assigned to the
              variable REPLY.  The return code is zero, unless end-of-file  is
              encountered,  read  times  out (in which case the return code is
              greater than 128), or an invalid file descriptor is supplied  as
              the argument to -u.

       readonly [-aApf] [name[=word] ...]
              The  given  names are marked readonly; the values of these names
              may not be changed by subsequent assignment.  If the  -f  option
              is  supplied,  the  functions  corresponding to the names are so
              marked.  The  -a  option  restricts  the  variables  to  indexed
              arrays;  the  -A  option  restricts the variables to associative
              arrays.  If no name arguments are given, or if the -p option  is
              supplied,  a  list  of  all  readonly  names is printed.  The -p
              option causes output to be displayed in a  format  that  may  be
              reused  as  input.  If a variable name is followed by =word, the
              value of the variable is set to word.  The return  status  is  0
              unless an invalid option is encountered, one of the names is not
              a valid shell variable name, or -f is supplied with a name  that
              is not a function.

       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 [--abefhkmnptuvxBCEHPT] [-o option] [arg ...]
       set [+abefhkmnptuvxBCEHPT] [+o option] [arg ...]
              Without options, the name and value of each shell  variable  are
              displayed in a format that can be reused as input for setting or
              resetting  the  currently-set  variables.   Read-only  variables
              cannot  be  reset.   In  posix  mode,  only  shell variables are
              listed.  The output is sorted according to the  current  locale.
              When  options are specified, they set or unset shell attributes.
              Any arguments remaining after option processing are  treated  as
              values for the positional parameters and are assigned, in order,
              to $1, $2, ... $n.  Options, if specified,  have  the  following
              meanings:
              -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      Exit  immediately  if a pipeline (which may consist of a
                      single simple command), a subshell command  enclosed  in
                      parentheses,  or one of the commands executed as part of
                      a command list enclosed by  braces  (see  SHELL  GRAMMAR
                      above) exits with a non-zero status.  The shell does not
                      exit if the command that fails is part  of  the  command
                      list  immediately  following  a  while or until keyword,
                      part of the test  following  the  if  or  elif  reserved
                      words,  part  of any command executed in a && or ││ list
                      except the command following the final  &&  or  ││,  any
                      command  in a pipeline but the last, or if the command’s
                      return value is being inverted with !.  A trap  on  ERR,
                      if set, is executed before the shell exits.  This option
                      applies to  the  shell  environment  and  each  subshell
                      environment    separately    (see    COMMAND   EXECUTION
                      ENVIRONMENT above), and  may  cause  subshells  to  exit
                      before executing all the commands in the subshell.
              -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   Use   an   emacs-style   command   line  editing
                              interface.  This is enabled by default when  the
                              shell   is  interactive,  unless  the  shell  is
                              started with the --noediting option.  This  also
                              affects  the editing interface used for read -e.
                      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  Same as -f.
                      nolog   Currently ignored.
                      notify  Identique à -b.
                      nounset Identique à -u.
                      onecmd  Identique à -t.
                      physical
                              Identique à -P.
                      pipefail
                              Si  existante,  la  valeur  renvoyée   par   une
                              conduite  est  la valeur de la dernière commande
                              (la plus à droite) à terminer avec un état final
                              différent   de   zéro  ou  zéro  si  toutes  les
                              commandes de la conduite terminent avec  succès.
                              Cette option est désactivée par défaut.
                      posix   Aligner  le comportement de bash sur le standard
                              POSIX, en  ce  qui  concerne  les  options  dont
                              l’action par défaut diffère de ce standard (mode
                              posix).
                      privileged
                              Identique à -p.
                      verbose Identique à -v.
                      vi      Use a vi-style command line  editing  interface.
                              This also affects the editing interface used for
                              read -e.
                      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      Turn on privileged mode.  In this  mode,  the  $ENV  and
                      $BASH_ENV  files  are not processed, shell functions are
                      not inherited from the environment, and  the  SHELLOPTS,
                      CDPATH,  and GLOBIGNORE variables, if they appear in the
                      environment, are ignored.  If the shell is started  with
                      the effective user (group) id not equal to the real user
                      (group) id, and the -p option  is  not  supplied,  these
                      actions  are  taken  and the effective user id is set to
                      the real user id.  If  the  -p  option  is  supplied  at
                      startup,  the  effective  user id is not reset.  Turning
                      this option off causes the effective user and group  ids
                      to be set to the real user and group ids.
              -t      Terminer après lecture et exécution d’une commande.
              -u      Treat  unset  variables  and  parameters  other than the
                      special  parameters  "@"  and  "*"  as  an  error   when
                      performing   parameter   expansion.    If  expansion  is
                      attempted on an unset variable or parameter,  the  shell
                      prints  an error message, and, if not interactive, exits
                      with a non-zero status.
              -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 :

              autocd  If  set,  a command name that is the name of a directory
                      is executed as  if  it  were  the  argument  to  the  cd
                      command.   This  option  is  only  used  by  interactive
                      shells.
              cdable_vars
                      Si existante, un argument de la commande interne cd  qui
                      n’est  pas  un  répertoire  est  supposé  être un nom de
                      variable dont la valeur est le répertoire visé.
              cdspell Si existante, les erreurs  minimes  de  frappe  dans  un
                      composant  du  répertoire  en argument de la commande cd
                      seront  corrigées.  Les  erreurs  corrigées   sont   les
                      inversions  d’un  caractère, un caractère manquant et un
                      caractère en trop. Si une correction  est  possible,  le
                      nom de répertoire corrigé est affiché et la commande est
                      exécuté.  Cette  option  n’est  utilisée  que  par   les
                      interpréteurs interactifs.
              checkhash
                      Si  existante, bash vérifie si une commande trouvée dans
                      la  table  de  hachage   existe   avant   d’essayer   de
                      l’exécuter.  Si  une  commande hachée n’existe plus, une
                      recherche normale de chemin est effectuée.
              checkjobs
                      If set, bash lists the status of any stopped and running
                      jobs  before  exiting an interactive shell.  If any jobs
                      are running, this causes the exit to be deferred until a
                      second  exit is attempted without an intervening command
                      (see JOB CONTROL above).   The  shell  always  postpones
                      exiting if any jobs are stopped.
              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.
              dirspell
                      If set, bash attempts spelling correction  on  directory
                      names  during  word  completion  if  the  directory name
                      initially supplied does not exist.
              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.
              globstar
                      If set, the pattern **  used  in  a  filename  expansion
                      context  will match a files and zero or more directories
                      and subdirectories.  If the pattern is followed by a  /,
                      only directories and subdirectories match.
              gnu_errfmt
                      Si  existante,  les  messages d’erreur de l’interpréteur
                      seront écrits dans le format standard GNU  des  messages
                      d’erreurs.
              histappend
                      Si  existante,  la  file  d’historique  est  ajoutée  au
                      fichier désigné par la valeur de  la  variable  HISTFILE
                      lorsque  l’interpréteur termine, plutôt que d’écraser ce
                      fichier.
              histreedit
                      Si existante et si readline est utilisée, un utilisateur
                      peut   rééditer  une  substitution  d’historique  qui  a
                      échoué.
              histverify
                      Si existante et si readline est utilisée, le résultat de
                      la   substitution   d’historique   n’est  pas  transmise
                      immédiatement à  l’analyseur  de  l’interpréteur.  À  la
                      place,  la  ligne  résultant  est chargée dans le tampon
                      d’édition  de  readline  permettant  des   modifications
                      ultérieures.
              hostcomplete
                      Si  existante et si readline est utilisée, bash essayera
                      d’effectuer  le  complètement  des  noms   de   machines
                      lorsqu’un  mot  contient  un  @  (voir Complètement dans
                      READLINE  plus  haut).  Cette  option  est  activée  par
                      défaut.
              huponexit
                      Si existante, bash enverra un signal SIGHUP à toutes les
                      tâches lorsqu’un interpréteur  de  connexion  interactif
                      termine.
              interactive_comments
                      Si existante, un mot commençant par un # conduira ce mot
                      et tous les autres caractères restants  de  la  ligne  à
                      être  ignorés  dans  un  interpréteur  interactif  (voir
                      COMMENTAIRES plus haut). Cette option  est  activée  par
                      défaut.
              lithist Si  existante  et  si  l’option cmdhist est activée, les
                      commandes    multilignes    sont    sauvegardées    dans
                      l’historique  avec  des  sauts de ligne incorporés comme
                      séparateurs plutôt que des points-virgules là  où  c’est
                      possible.
              login_shell
                      L’interpréteur  crée  cette  option  s’il est démarré en
                      tant  qu’interpréteur  de  connexion  (voir  APPEL  plus
                      haut). La valeur ne peut être modifiée.
              mailwarn
                      Si  existante et s’il a été accédé à un fichier que bash
                      surveille  pour  les  courriels   depuis   sa   dernière
                      vérification,     le     message     « The    mail    in
                      fichier_de_courriel has been read » est affiché.
              no_empty_cmd_completion
                      Si  existante  et  si  readline   est   utilisée,   bash
                      n’essaiera  pas  d’utiliser  le  PATH  pour de possibles
                      complètements quand le complètement est  tenté  sur  une
                      ligne vide.
              nocaseglob
                      Si   existante,  bash  fait  correspondre  les  noms  de
                      fichiers d’une façon  insensible  à  la  casse  lors  du
                      développement   des   chemins  (voir  Développement  des
                      chemins plus haut).
              nocasematch
                      Si existante, bash fait correspondre  les  motifs  d’une
                      façon   insensible  à  la  casse  lors  de  la  mise  en
                      correspondance   pendant   l’exécution   des   commandes
                      conditionnelles case ou [[.
              nullglob
                      Si  existante, bash autorise les motifs ne correspondant
                      à aucun fichier (voir  Développement  des  chemins  plus
                      haut)  à  se  développer en une chaîne vide plutôt qu’en
                      une valeur littérale.
              progcomp
                      Si existante, les outils de  complètement  programmables
                      (voir Complètement programmable plus haut) sont activés.
                      Cette option est activée par défaut.
              promptvars
                      Si existante, les  chaînes  d’invite  sont  sujettes  au
                      développement  des  paramètres,  à  la  substitution  de
                      commande,  au  développement  arithmétique   et   à   la
                      suppression  des  protections après avoir été développée
                      comme décrit plus haut dans INVITES.  Cette  option  est
                      activée par défaut.
              restricted_shell
                      L’interpréteur  crée  cette  option  s’il est démarré en
                      mode restreint (voir plus bas INTERPRÉTEUR RESTREINT  ).
                      Cette  valeur  ne  peut pas être changée. Elle n’est pas
                      réinitialisée lorsque les  fichiers  de  démarrage  sont
                      exécutés,  ce  qui permet à ces fichiers de découvrir si
                      un interpréteur est restreint ou non.
              shift_verbose
                      Si existante,  la  commande  interne  shift  affiche  un
                      message  d’erreur lorsque le nombre de décalages dépasse
                      le nombre de paramètres positionnels.
              sourcepath
                      Si existante, la commande interne source (.) utilise  la
                      valeur  de  la  variable PATH pour trouver le répertoire
                      contenant le fichier fourni en  argument.  Cette  option
                      est activée par défaut.
              xpg_echo
                      Si  existante,  la  commande  interne echo développe par
                      défaut  les  suites  de  caractères  d’échappement   par
                      contre-oblique.
       suspend [-f]
              Suspend  the execution of this shell until it receives a SIGCONT
              signal.  A login shell cannot be suspended; the -f option can be
              used  to  override  this  and  force the suspension.  The return
              status is 0 unless the shell is a login  shell  and  -f  is  not
              supplied, or if job control is not enabled.
       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.

              Expressions may  be  combined  using  the  following  operators,
              listed  in  decreasing  order  of  precedence.   The  evaluation
              depends on the number of arguments; see below.
              ! 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
                     If  the  second argument is one of the binary conditional
                     operators listed above under CONDITIONAL EXPRESSIONS, the
                     result of the expression is the result of the binary test
                     using the first and third arguments as operands.  The  -a
                     and  -o  operators  are  considered binary operators when
                     there are three arguments.  If the first argument  is  !,
                     the  value is the negation of the two-argument test using
                     the second and third arguments.  If the first argument is
                     exactly ( and the third argument is exactly ), the result
                     is  the  one-argument  test  of  the   second   argument.
                     Otherwise, the expression is false.
              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 command  executed
              in  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’’  would  not
              return file.  If a command is hashed, -p and -P print the hashed
              value, not necessarily the file that appears first in PATH.   If
              the  -a  option  is  used,  type  prints  all of the places that
              contain an executable named name.   This  includes  aliases  and
              functions,  if  and only if the -p option is not also used.  The
              table of hashed commands is not consulted when using -a.  The -f
              option  suppresses  shell  function  lookup, as with the command
              builtin.  type returns true if all of the arguments  are  found,
              false if any are not found.

       ulimit [-HSTabcdefilmnpqrstuvx [limit]]
              Provides  control  over the resources available to the shell and
              to processes started by it, on systems that allow such  control.
              The -H and -S options specify that the hard or soft limit is set
              for the given resource.  A hard limit cannot be increased  by  a
              non-root  user  once it is set; a soft limit may be increased up
              to the value of the  hard  limit.   If  neither  -H  nor  -S  is
              specified,  both the soft and hard limits are set.  The value of
              limit can be a number in the unit specified for the resource  or
              one  of the special values hard, soft, or unlimited, which stand
              for the current hard limit,  the  current  soft  limit,  and  no
              limit,  respectively.  If limit is omitted, the current value of
              the soft limit of the resource is printed, unless the -H  option
              is  given.   When more than one resource is specified, the limit
              name and unit are printed before the value.  Other  options  are
              interpreted as follows:
              -a     Toutes les limitations courantes sont signalées
              -b     The maximum socket buffer size
              -c     La taille maximum des fichiers core créés
              -d     La taille maximum du segment de données d’un processus
              -e     La priorité d’ordonnancement maximum (« nice »)
              -f     La  taille  maximum d’un fichier écrit par l’interpréteur
                     et ses fils
              -i     Le nombre maximum de signaux en attente
              -l     La taille maximum qui peut être verrouillée en mémoire
              -m     The maximum resident set size (many systems do not  honor
                     this limit)
              -n     Le nombre maximum de descripteurs de fichiers ouverts (la
                     plupart des systèmes ne permettent pas de modifier  cette
                     valeur)
              -p     La  taille  d’un  tube  en  blocs  de 512 octets (parfois
                     inexistante)
              -q     Le nombre maximum d’octets dans  les  files  de  messages
                     POSIX
              -r     La priorité d’ordonnancement temps-réel maximale
              -s     La taille maximum de la pile
              -t     La  durée  maximum, en seconde, de temps CPU accordé à un
                     processus
              -u     Le nombre maximum de processus  autorisés  pour  un  seul
                     utilisateur
              -v     La   quantité   de   mémoire  virtuelle  disponible  pour
                     l’interpréteur
              -x     Le nombre maximum de verrous de fichiers
              -T     The maximum number of threads

              If limit is given, it is the new value of the specified resource
              (the -a option is display only).  If no option is given, then -f
              is assumed.  Values are in 1024-byte increments, except for  -t,
              which  is  in seconds, -p, which is in units of 512-byte blocks,
              and -T, -b, -n, and -u, which are unscaled values.   The  return
              status is 0 unless an invalid option or argument is supplied, or
              an error occurs while setting a new limit.

       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.ramey@case.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 variables de type tableau ne peuvent pas (encore) être exportées.

       There may be only one active coprocess at a time.

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.