.if \n(zZ=1 .ig zZ .\" .\" MAN PAGE COMMENTS to .\" .\" Chet Ramey .\" Case Western Reserve University .\" chet@po.cwru.edu .\" .\" Last Change: Tue Dec 28 13:41:43 EST 2010 .\" .\" bash_builtins, strip all but Built-Ins section .if \n(zY=1 .ig zY .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH BASH 1 "28 décembre 2010" "GNU Bash\-4.2" .de }1 .ds ]X \&\\*(]B\\ .nr )E 0 .if !"\\$1"" .nr )I \\$1n .}f .ll \\n(LLu .in \\n()Ru+\\n(INu+\\n()Iu .ti \\n(INu .ie !\\n()Iu+\\n()Ru-\w\\*(]Xu-3p \{\\*(]X .br\} .el \\*(]X\h|\\n()Iu+\\n()Ru\c .}f .. .\" .\" There's some problem with having a `@' .\" in a tagged paragraph with the BSD man macros. .\" It has to do with `@' appearing in the }1 macro. .\" This is a problem on 4.3 BSD and Ultrix, but Sun .\" appears to have fixed it. .\" If you're seeing the characters .\" `@u-3p' appearing before the lines reading .\" `possible-hostname-completions .\" and `complete-hostname' down in READLINE, .\" then uncomment this redefinition. .\" .de FN \fI\|\\$1\|\fP .. .\" .\" File Name macro. This used to be `.PN', for Path Name, .\" but Sun doesn't seem to like that very much. .\" .SH NOM bash \- Interpréteur de commandes GNU Bourne\-Again SHell .SH SYNOPSIS \fBbash\fP [options] [fichier] .SH COPYRIGHT .if n Bash est Copyright (C) 1989-2011 par la Free Software Foundation, Inc. .if t Bash est Copyright \(co 1989-2011 par la Free Software Foundation, Inc. .SH DESCRIPTION \fBBash\fP est un interpréteur de commandes (\fIshell\fP) compatible \fBsh\fP qui exécute les commandes lues depuis l'entrée standard ou depuis un fichier. \fBBash\fP inclut aussi des fonctionnalités utiles des interpréteurs de commandes \fIKorn\fP et \fIC\fP (\fBksh\fP et \fBcsh\fP). .PP \fBBash\fP 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). \fBBash\fP peut être configuré pour être conforme aux spécifications POSIX par défaut. .SH OPTIONS Toutes les options d'interpréteur monocaractères documentées dans la description de la commande interne \fBset\fP peuvent être utilisées comme options si l'interpréteur est invoqué. De plus, \fBbash\fP accepte les options suivantes lors de son appel\ : .PP .PD 0 .TP 10 \fB\-c\fP\fI\| chaîne\^\fP Si l'option \fB\-c\fP est présente, les commandes sont lues depuis la \fIchaîne\fP fournie. S'il y a des arguments après la \fIchaîne\fP, ils sont affectés aux paramètres positionnels, en commençant par \fB$0\fP. .TP \fB\-i\fP Si l'option \fB\-i\fP est présente, l'interpréteur est \fIinteractif\fP. .TP \fB\-l\fP Faire que \fBbash\fP se comporte comme s'il avait été appelé comme interpréteur de commandes de connexion (consultez .SM \fBAPPEL\fP ci\-dessous). .TP \fB\-r\fP Si l'option \fB\-r\fP est présente, l'interpréteur devient \fIrestreint\fP (consultez .SM \fBINTERPRÉTEUR RESTREINT\fP ci\-dessous). .TP \fB\-s\fP Si l'option \fB\-s\fP 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. .TP \fB\-D\fP Une liste de toutes les chaînes entre guillemets doubles précédées de \fB$\fP 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 \fBC\fP ni \fBPOSIX\fP. Cela implique l'option \fB\-n\fP\ ; aucune commande ne sera exécutée. .TP [\fB\-+\fP]\fBO\fP [\fIoption_shopt\fP] \fIoption_shopt\fP est une des options de l'interpréteur acceptées par la commande interne \fBshopt\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). Si \fIoption_shopt\fP est présente, \fB\-O\fP crée cette option\ ; \fB+O\fP la détruit. Si \fIoption_shopt\fP n'est pas fournie, les noms et valeurs des options de l'interpréteur acceptées par \fBshopt\fP sont affichés sur la sortie standard. Si l'option d'appel est \fB+O\fP, la sortie est affichée dans un format réutilisable en entrée. .TP \fB\-\-\fP Deux caractères \fB\-\-\fP indiquent la fin des options et désactivent le traitement des arguments. Tous les arguments après le \fB\-\-\fP sont traités comme des noms de fichiers et paramètres. \fB\-\fP est équivalent à \fB\-\-\fP. .PD .PP \fBBash\fP 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. .PP .PD 0 .TP \fB\-\-debugger\fP 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 (consultez ci\-dessous la description de l'option \fBextdebug\fP de la commande interne \fBshopt\fP). .TP \fB\-\-dump\-po\-strings\fP Équivalent à \fB\-D\fP, mais la sortie est dans le format des fichiers \fBpo\fP (objets portables) de l'outil GNU \fIgettext\fP. .TP \fB\-\-dump\-strings\fP Équivalent à \fB\-D\fP. .TP \fB\-\-help\fP Affiche un message d'aide sur la sortie standard et termine avec succès. .TP \fB\-\-init\-file\fP \fIfichier\fP .PD 0 .TP \fB\-\-rcfile\fP \fIfichier\fP .PD Exécuter les commandes contenues dans \fIfichier\fP plutôt que celles du fichier d'initialisation commun à tout le système \fI/etc/bash.bashrc\fP et que le fichier d'initialisation personnel standard \fI~/.bashrc\fP si l'interpréteur est interactif (consultez .SM \fBAPPEL\fP ci\-dessous). .TP \fB\-\-login\fP Équivalent à \fB\-l\fP. .TP \fB\-\-noediting\fP Ne pas utiliser la bibliothèque GNU \fBreadline\fP pour lire les lignes de commande, lorsque l'interpréteur est interactif. .TP \fB\-\-noprofile\fP Ne lire ni le fichier de configuration générale .FN /etc/profile , ni les fichiers d'initialisation personnels \fI~/.bash_profile\fP, \fI~/.bash_login\fP ou \fI~/.profile\fP. Par défaut, \fBbash\fP lit ces fichiers lorsqu'il est appelé comme interpréteur de commandes de connexion (consultez .SM \fBAPPEL\fP ci\-dessous). .TP \fB\-\-norc\fP Ne pas lire ou exécuter le fichier de configuration commun à tout le système \fI/etc/bash.bashrc\fP, ni le fichier personnel d'initialisation \fI~/.bashrc\fP lorsque l'interpréteur est interactif. Cette option est activée par défaut si l'interpréteur est appelé sous le nom \fBsh\fP. .TP \fB\-\-posix\fP Aligner le comportement de \fBbash\fP sur le standard POSIX, en ce qui concerne les options dont l'action par défaut diffère de ce standard (\fImode posix\fP). .TP \fB\-\-restricted\fP L'interpréteur devient restreint (consultez .SM \fBINTERPRÉTEUR RESTREINT\fP ci\-dessous). .TP \fB\-\-verbose\fP Équivalent à \fB\-v\fP. .TP \fB\-\-version\fP Affiche le numéro de version de \fBbash\fP sur la sortie standard et termine avec succès. .PD .SH ARGUMENTS S'il reste des arguments sur la ligne de commande après traitement des options et que ni l'option \fB\-c\fP, ni l'option \fB\-s\fP n'ont été fournies, le premier argument est supposé être le nom du fichier dans lequel lire les commandes d'interpréteur. Si \fBbash\fP est appelé de cette façon, le nom du ficher est affecté à \fB$0\fP et les arguments restants aux autres paramètres positionnels. \fBBash\fP lit et exécute les commandes depuis ce fichier, puis termine. L'état final de \fBbash\fP 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 actuel et, si aucun fichier n'est trouvé, l'interpréteur cherche le script dans les répertoires contenus dans .SM \fBPATH\fP. .SH APPEL Un interpréteur de commandes est dit \fIde connexion\fP (\fIlogin shell\fP) si le premier caractère de son argument numéro zéro est un \fB\-\fP ou s'il est appelé avec l'option \fB\-\-login\fP. .PP Un interpréteur est \fIinteractif\fP s'il est appelé sans argument autre que des options et sans l'option \fB\-c\fP, dont l'entrée standard et sa sortie d'erreur sont toutes deux connectées à des terminaux (comme déterminé par la fonction \fBisatty\fP(3)) ou s'il est appelé avec l'option \fB\-i\fP. .SM \fBPS1\fP est créée et \fB$\-\fP contient la lettre \fBi\fP si \fBbash\fP est interactif, ce qui permet à un script ou à un fichier de démarrage de tester cet état. .PP Le paragraphe suivant décrit comment \fBbash\fP exécute ses fichiers d'initialisation. Si un de ces fichiers existe mais n'est pas accessible en lecture, \fBbash\fP signale une erreur. Les tildes sont remplacés par des noms de fichiers comme décrit ci\-dessous dans \fBDéveloppement du tilde\fP dans le paragraphe .SM \fBDÉVELOPPEMENTS\fP. .PP Lorsque \fBbash\fP est lancé comme interpréteur de commandes de connexion interactif ou comme interpréteur non interactif avec l'option \fB\-\-login\fP, il lit et exécute tout d'abord les commandes se trouvant dans le fichier \fI/etc/profile\fP si ce fichier existe. Après lecture de ce fichier, il recherche \fI~/.bash_profile\fP, \fI~/.bash_login\fP et \fI~/.profile\fP, dans cet ordre, puis lit et exécute les commandes se trouvant dans le premier fichier existant et accessible en lecture. L'option \fB\-\-noprofile\fP peut être utilisée à l'appel de l'interpréteur pour empêcher ce comportement. .PP Lorsqu'un interpréteur de commandes de connexion termine, \fBbash\fP lit et exécute les commandes du fichier \fI~/.bash_logout\fP, s'il existe. .PP Quand un interpréteur interactif démarre sans être un interpréteur de commandes de connexion, \fBbash\fP lit et exécute les commandes se trouvant dans \fI/etc/bash.bashrc\fP et \fI~/.bashrc\fP s'ils existent. Ce comportement peut être empêché à l'aide de l'option \fB\-\-norc\fP. L'option \fB\-\-rcfile\fP \fIfichier\fP forcera \fBbash\fP à lire et exécuter les commandes dans \fIfichier\fP plutôt que dans \fI/etc/bash.bashrc\fP et \fI~/.bashrc\fP. .PP Quand \fBbash\fP est démarré de façon non interactive, par exemple pour lancer un script, il consulte la variable .SM \fBBASH_ENV\fP 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. \fBBash\fP se comporte comme si la commande suivante était exécutée\ : .sp .5 .RS .if t \f(CWif [ \-n "$BASH_ENV" ]; then . "$BASH_ENV"; fi\fP .if n if [ \-n "$BASH_ENV" ]; then . "$BASH_ENV"; fi .RE .sp .5 mais la valeur de la variable .SM \fBPATH\fP n'est pas utilisée pour rechercher le fichier. .PP Si \fBbash\fP est appelé sous le nom \fBsh\fP, il essaye d'imiter le comportement de démarrage des versions historiques de \fBsh\fP 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 \fB\-\-login\fP, il essaye d'abord de lire et exécuter, dans cet ordre, les commandes de \fI/etc/profile\fP puis de \fI~/.profile\fP. L'option \fB\-\-noprofile\fP peut être utilisée pour empêcher ce comportement. Quand il est appelé en tant qu'interpréteur interactif sous le nom \fBsh\fP, \fBbash\fP consulte la variable .SM \fBENV\fP, 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 \fBsh\fP n'essaye ni de lire, ni d'exécuter des commandes d'un autre fichier de démarrage, l'option \fB\-\-rcfile\fP n'a aucun effet. Un interpréteur non interactif appelé sous le nom \fBsh\fP n'essaie de lire aucun autre fichier d'initialisation. Quand il est appelé sous le nom \fBsh\fP, \fBbash\fP entre en mode \fIposix\fP après avoir lu les fichiers d'initialisation. .PP Quand \fBbash\fP est appelé en mode \fIposix\fP comme avec l'option \fB\-\-posix\fP 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 .SM \fBENV\fP 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. .PP \fBBash\fP tente de déterminer s'il est exécuté avec son entrée standard reliée à une connexion réseau, comme quand il est exécuté par le démon lançant les interpréteurs de commandes à distance, généralement \fIrshd\fP, ou le démon d'interpréteur sécurisé \fIsshd\fP. Si \fBbash\fP conclut qu'il est exécuté de cette façon, il lit et exécute les commandes de \fI/etc/bash.bashrc\fP et \fI~/.bashrc\fP si ces fichiers existent et sont accessibles en lecture. Il n'a pas ce comportement lorsqu'il est appelé sous le nom \fBsh\fP. L'option \fB\-\-norc\fP peut être utilisée pour empêcher ce comportement et l'option \fB\-\-rcfile\fP peut être utilisée pour forcer la lecture d'un autre fichier, mais \fIrshd\fP n'appelle généralement pas l'interpréteur avec ces options ni ne permet de les indiquer. .PP 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 \fB\-p\fP n'est pas fournie, aucun fichier d'initialisation n'est lu, les fonctions de l'interpréteur ne sont pas importées depuis l'environnement, les variables .SM \fBSHELLOPTS\fP, .SM \fBBASHOPTS\fP, .SM \fBCDPATH\fP, et .SM \fBGLOBIGNORE\fP, si présentes dans l'environnement, sont ignorées, et l'identifiant de l'utilisateur effectif est configuré à celui de l'utilisateur réel. Si l'option \fB\-p\fP est fournie à l'appel, le comportement au démarrage est le même mais l'identifiant d'utilisateur effectif n'est pas modifié. .SH DÉFINITIONS .PP Les définitions suivantes sont utilisées dans toute la suite ce document. .PD 0 .TP \fBblanc\fP Une espace ou une tabulation. .TP \fBmot\fP Une suite de caractères considérée comme une unité élémentaire par l'interpréteur. On parle également de \fBlexème\fP («\ token\ »). .TP \fBnom\fP Un \fImot\fP ne contenant que des caractères alphanumériques ou tirets bas («\ underscore\ »), commençant par une lettre ou un tiret bas. On s'y réfère également sous le terme \fBidentificateur\fP. .TP \fBmétacaractère\fP Un caractère qui, non protégé, sépare les mots. Un de ceux\-ci\ : .br .RS .PP .if t \fB| & ; ( ) < > espace tab\fP .if n \fB| & ; ( ) < > espace tab\fP .RE .PP .TP \fBopérateur de contrôle\fP Un \fIlexème\fP ayant une fonction de contrôle. C'est l'un des symboles suivants\ : .RS .PP .if t \fB|| & && ; ;; ( ) | |& \fP .if n \fB|| & && ; ;; ( ) | |& \fP .RE .PD .SH "MOTS RÉSERVÉS" Les \fImots réservés\fP 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 (consultez .SM \fBGRAMMAIRE DE L'INTERPRÉTEUR\fP ci\-dessous) soit le troisième mot d'une commande \fBcase\fP ou \fBfor\fP\ : .if t .RS .PP .B .if n ! case do done elif else esac fi for function if in select then until while { } time [[ ]] .if t ! case do done elif else esac fi for function if in select then until while { } time [[ ]] .if t .RE .SH "GRAMMAIRE DE L'INTERPRÉTEUR" .SS "Commandes simples" .PP Une \fIcommande simple\fP est une suite d'affectations facultatives de variables, suivie de mots séparés par des \fIblancs\fP et de redirections, et terminée par un \fIopérateur de contrôle\fP. Le premier mot indique la commande à exécuter et est passé comme argument zéro. Les mots restants sont transmis comme arguments à la commande appelée. .PP La valeur renvoyée par une \fIcommande simple\fP est son état final ou 128+\fIn\^\fP si la commande a été terminée par le signal \fIn\fP. .SS Conduites .PP Une \fIconduite\fP («\ pipeline\ ») est une suite d'une ou plusieurs commandes séparées par un des opérateurs de contrôle \fB|\fP ou \fB|&\fP. Le format d'une conduite est\ : .RS .PP [\fBtime\fP [\fB\-p\fP]] [\fB!\fP] \fIcommande_1\fP [ [\fB|\fP\(bv\fB|&\fP] \fIcommande_2\fP ... ] .RE .PP La sortie standard de la \fIcommande_1\fP est connectée par un tube à l'entrée standard de la \fIcommande_2\fP. Cette connexion est effectuée avant toute redirection indiquée par la commande elle\-même (consultez .SM \fBREDIRECTIONS\fP ci\-dessous). Si \fB|&\fP est utilisé, la sortie d'erreur standard de la \fIcommande_1\fP est connectée à l'entrée standard de la \fIcommande_2\fP dans le tube\ ; c'est un raccourci pour \fB2>&1 |\fP. Cette redirection implicite de la sortie d'erreur standard est réalisée après toute redirection précisée par la commande. .PP L'état renvoyé par une conduite est l'état final de la dernière commande, à moins que l'option \fBpipefail\fP soit activée. Si \fBpipefail\fP 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é \fB!\fP précède une conduite, l'état final de cette conduite sera la négation logique de l'état final tel que décrit ci\-dessus. L'interpréteur attend que toutes les commandes de la conduite soient terminées avant de renvoyer une valeur. .PP Si le mot réservé \fBtime\fP 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 \fB\-p\fP modifie le format de sortie pour celui indiqué par POSIX. Quand l'interpréteur est en \fImode posix\fP, il ne reconnaît pas \fBtime\fP comme un mot réservé si le jeton suivant commence par un «\ \-\ ». La variable .SM \fBTIMEFORMAT\fP peut contenir une chaîne de format indiquant comment les informations de chronométrage doivent être affichées\ ; consultez ci\-dessous la description de .SM \fBTIMEFORMAT\fP dans \fBVariables de l'interpréteur\fP. .PP Quand l'interpréteur est en \fImode posix\fP, \fBtime\fP peut être suivi d'un changement de ligne. Dans ce cas, l'interpréteur affiche le temps utilisateur et système total consommé par l'interpréteur et ses enfants. La variable .SM \fBTIMEFORMAT\fP peut être utilisée pour indiquer le format des informations de temps. .PP Chaque commande dans une conduite est exécutée comme un processus indépendant (c'est\-à\-dire dans un sous\-interpréteur). .SS Listes .PP Une \fIliste\fP est une suite d'une ou plusieurs conduites séparées par l'un des opérateurs \fB;\fP, \fB&\fP, \fB&&\fP ou \fB||\fP et facultativement terminée par \fB;\fP, \fB&\fP ou \fB\fP. .PP Dans cette liste d'opérateurs, \fB&&\fP et \fB||\fP ont une priorité identique, suivis par \fB;\fP et \fB&\fP, qui ont également une priorité identique. .PP Une suite d'un ou plusieurs changements de ligne peut apparaître dans une \fIliste\fP à la place d'un point\-virgule pour délimiter les commandes. .PP Si une commande se termine par l'opérateur de contrôle \fB&\fP, l'interpréteur l'exécute en \fIarrière\-plan\fP, 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 \fB;\fP 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. .PP Les listes ET et OU sont des suites d'une ou plusieurs conduites séparées respectivement par les opérateurs de contrôle \fB&&\fP et \fB||\fP. Les listes ET et OU sont exécutées avec associativité à gauche. Une liste ET est de la forme .RS .PP \fIcommande_1\fP \fB&&\fP \fIcommande_2\fP .RE .PP \fIcommande_2\fP est exécutée si, et seulement si, \fIcommande_1\fP renvoie un état final de zéro. .PP Une liste OU a la forme .RS .PP \fIcommande_1\fP \fB||\fP \fIcommande_2\fP .PP .RE .PP \fIcommande_2\fP est exécutée si et seulement si \fIcommande_1\fP 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. .SS "Commandes composées" .PP Une \fIcommande composée\fP est l'une des constructions suivantes\ : .TP \fB(\fP\fIliste\fP\fB)\fP \fIliste\fP est exécutée dans un sous\-interpréteur (consultez .SM \fBENVIRONNEMENT D'EXÉCUTION DES COMMANDES\fP ci\-dessous). 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 \fIliste\fP. .TP \fB{\fP \fIliste\fP\fB; }\fP \fIliste\fP est simplement exécutée avec l'environnement de l'interpréteur en cours. \fIliste\fP doit se terminer par un changement de ligne ou un point\-virgule. Cette construction est connue sous le nom de \fIcommandes groupées\fP. L'état renvoyé est l'état final de la \fIliste\fP. Remarquez que contrairement aux métacaractères \fB(\fP et \fB)\fP, \fB{\fP et \fB}\fP sont des \fImots réservés\fP qui ne doivent apparaître que là où un mot réservé peut être reconnu. Puisqu'ils ne conduiront pas un découpage en mots, ils doivent être séparés de la \fIliste\fP par un blanc ou un autre métacaractère de l'interpréteur. .TP \fB((\fP\fIexpression\fP\fB))\fP L'\fIexpression\fP est évaluée selon les règles décrites ci\-dessous dans .SM \fBÉVALUATION ARITHMÉTIQUE\fP. 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. C'est exactement équivalent à \fBlet "\fP\fIexpression\fP\fB"\fP. .TP \fB[[\fP \fIexpression\fP \fB]]\fP Renvoie un état de 0 ou 1 selon l'évaluation de la condition \fIexpression\fP. Les conditions sont composées de primitives décrites ci\-dessous dans .SM \fBCONDITIONS\fP. Le découpage en mots et le développement des chemins ne sont pas effectués sur les mots entre \fB[[\fP et \fB]]\fP\ ; 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 \fB\-f\fP ne doivent pas être protégés afin d'être reconnus comme primitives. .if t .sp 0.5 .if n .sp 1 Lorsqu'ils sont utilisés avec \fB[[\fP, les opérateurs \fB<\fP et \fB>\fP ordonnent d'un point de vue lexicographique en utilisant les paramètres linguistiques régionaux actuels. .PP Consultez la description de la commande interne \fItest\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous) pour la gestion des paramètres (c'est\-à\-dire des paramètres manquants). .if t .sp 0.5 .if n .sp 1 Quand les opérateurs \fB==\fP et \fB!=\fP 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 ci\-dessous dans \fBMotifs génériques\fP. Si l'option d'interpréteur \fBnocasematch\fP 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 (\fB==\fP), ou respectivement ne correspondent pas (\fB!=\fP), au motif et 1 sinon. Toute partie du motif peut être protégée pour la forcer à correspondre en tant que chaîne. .if t .sp 0.5 .if n .sp 1 Un opérateur binaire supplémentaire, \fB=~\fP, est disponible, avec la même priorité que \fB==\fP et \fB!=\fP. Lorsqu'il est utilisé, la chaîne à droite de l'opérateur est considérée comme une expression rationnelle étendue et est mise en correspondance en conséquence (comme avec \fBregex\fP(3)). La valeur renvoyée est 0 si la chaîne correspond au motif et 1 si elle ne correspond pas. Si l'expression rationnelle n'est pas syntaxiquement correcte, la valeur renvoyée de l'expression conditionnelle est 2. Si l'option d'interpréteur \fBnocasematch\fP est activée, la mise en correspondance est effectuée sans tenir compte de la casse. Toute partie du motif peut être protégée pour la forcer à correspondre en tant que chaîne. Les sous\-chaînes mises en correspondance avec des sous\-expressions entre parenthèses dans l'expression rationnelle sont sauvegardées dans la variable tableau .SM \fBBASH_REMATCH\fP. L'élément d'indice 0 de .SM \fBBASH_REMATCH\fP est la partie de la chaîne correspondant à l'expression rationnelle complète. L'élément d'indice \fIn\fP de .SM \fBBASH_REMATCH\fP est la partie de la chaîne correspondant à la \fIn\fP\-ième sous\-expression entre parenthèses. .if t .sp 0.5 .if n .sp 1 Les expressions peuvent être combinées en utilisant les opérateurs suivants, décrits par ordre de priorité décroissante\ : .if t .sp 0.5 .if n .sp 1 .RS .PD 0 .TP \fB( \fP\fIexpression\fP\fB )\fP Renvoie la valeur de l'\fIexpression\fP. Cela peut être utilisé pour surpasser la priorité normale des opérateurs. .TP \fB! \fP\fIexpression\fP Vrai si \fIexpression\fP est fausse. .TP \fIexpression1\fP \fB&&\fP \fIexpression2\fP Vrai si \fIexpression1\fP et \fIexpression2\fP sont toutes les deux vraies. .TP \fIexpression1\fP \fB||\fP \fIexpression2\fP Vrai si \fIexpression1\fP ou \fIexpression2\fP est vraie. .PD .LP Les opérateurs \fB&&\fP et \fB||\fP n'évaluent pas \fIexpression2\fP si la valeur de \fIexpression1\fP suffit à déterminer la valeur renvoyée par la condition tout entière. .RE .TP \fBfor\fP \fInom\fP [ [ \fBin\fP [ \fImot ...\fP ] ] ; ] \fBdo\fP \fIliste\fP ; \fBdone\fP La liste de mots suivant \fBin\fP est développée, produisant une liste d'éléments. La variable \fInom\fP prend tour à tour la valeur de chacun des éléments et \fIliste\fP est exécutée à chaque fois. Si \fBin\fP \fImot\fP est omis, la commande \fBfor\fP exécute la \fIliste\fP une fois pour chacun des paramètres positionnels existants (consultez .SM \fBPARAMÈTRES\fP ci\-dessous). L'état renvoyé est l'état final de la dernière commande exécutée. Si le développement des éléments suivant \fBin\fP conduit à une liste vide, aucune commande n'est exécutée et l'état renvoyé est 0. .TP \fBfor\fP (( \fIexpr1\fP ; \fIexpr2\fP ; \fIexpr3\fP )) ; \fBdo\fP \fIliste\fP ; \fBdone\fP L'expression arithmétique \fIexpr1\fP est d'abord évaluée selon les règles décrites ci\-dessous sous .SM \fBÉVALUATION ARITHMÉTIQUE\fP. L'expression arithmétique \fIexpr2\fP est ensuite évaluée répétitivement jusqu'à valoir zéro. Chaque fois que \fIexpr2\fP est évaluée en une valeur différente de zéro, \fIliste\fP est exécutée et l'expression arithmétique \fIexpr3\fP est évaluée. Si l'une des expressions est omise, elle est considérée comme s'évaluant à 1. La valeur renvoyée est l'état final de la dernière commande dans \fIliste\fP qui est exécutée ou faux si l'une des expressions est incorrecte. .TP \fBselect\fP \fInom\fP [ \fBin\fP \fImot\fP ] ; \fBdo\fP \fIliste\fP ; \fBdone\fP La liste de mots à la suite de \fBin\fP 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 \fBin\fP \fImot\fP est omis, les paramètres positionnels sont imprimés (consultez .SM \fBPARAMÈTRES\fP ci\-dessous). L'invite .SM \fBPS3\fP 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 \fInom\fP. 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 \fInom\fP. La ligne lue est conservée dans la variable .SM \fBREPLY\fP. La \fIliste\fP est exécutée après chaque sélection, jusqu'à ce qu'une commande \fBbreak\fP soit atteinte. L'état final de \fBselect\fP est l'état final de la dernière commande exécutée dans la \fIliste\fP ou zéro si aucune commande n'a été exécutée. .TP \fBcase\fP \fImot\fP \fBin\fP [ [(] \fImotif\fP [ \fB|\fP \fImotif\fP ] ... ) \fIliste\fP ;; ] ... \fBesac\fP Une commande \fBcase\fP commence d'abord par développer le \fImot\fP, puis essaye de le mettre en correspondance tour à tour avec chacun des \fImotifs\fP en utilisant les mêmes règles que pour le développement des chemins (consultez ci\-dessous \fBDéveloppement des chemins\fP). Le \fImot\fP est développé en utilisant le développement du tilde, le développement des paramètres et des variables, la substitution arithmétique, la substitution de commande, la substitution de processus et la suppression des protections. Chaque \fImotif\fP examiné est développé en utilisant le développement du tilde, le développement des paramètres et des variables, la substitution arithmétique, la substitution de commande et la substitution de processus. Si l'option d'interpréteur \fBnocasematch\fP est activée, la mise en correspondance est effectuée sans tenir compte de la casse des caractères alphabétiques. Quand une correspondance est trouvée, la \fIliste\fP associée est exécutée. Dès qu'un motif correct a été trouvé, il n'y a plus d'autre essai si l'opérateur \fB;;\fP est utilisé. Si \fB;&\fP est utilisé au lieu de \fB;;\fP, l'exécution continue avec la \fIliste\fP associée au jeu de motifs suivant. Si \fB;;&\fP est utilisé au lieu de \fB;;\fP, l'interpréteur essaye la liste de motifs suivant, si elle existe, et exécute toute \fIliste\fP associée à un motif correspondant. L'état final est zéro si aucun motif ne correspond. Sinon il est l'état final de la dernière commande exécutée dans la \fIliste\fP. .TP \fBif\fP \fIliste\fP; \fBthen\fP \fIliste\fP; [ \fBelif\fP \fIliste\fP; \fBthen\fP \fIliste\fP; ] ... [ \fBelse\fP \fIliste\fP; ] \fBfi\fP La \fIliste\fP du \fBif\fP est exécutée. Si son état final est zéro, la \fIliste\fP du \fBthen\fP est exécutée. Sinon, chacune des \fIlistes\fP des \fBelif\fP est exécutée tour à tour et si son état final est zéro, la \fIliste\fP du \fBthen\fP associé est exécutée et la commande termine. Sinon, la \fIliste\fP du \fBelse\fP, 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. .TP \fBwhile\fP \fIliste\-1\fP; \fBdo\fP \fIliste\-2\fP; \fBdone\fP .PD 0 .TP \fBuntil\fP \fIliste\-1\fP; \fBdo\fP \fIliste\-2\fP; \fBdone\fP .PD La commande \fBwhile\fP répète la \fIliste\-2\fP tant que la dernière commande de la \fIliste\-1\fP renvoie un état final de zéro. La commande \fBuntil\fP est identique à la commande \fBwhile\fP, sauf que le test est inversé\ ; la \fIliste\-2\fP est exécutée tant que la dernière commande de la \fIliste\-1\fP renvoie un état final différent de zéro. L'état final des commandes \fBwhile\fP et \fBuntil\fP est l'état final de la dernière commande exécutée dans la \fIliste\-2\fP ou zéro si aucune commande n'a été exécutée. .SS Coprocessus .PP Un \fIcoprocessus\fP est une commande d'interpréteur précédée par le mot réservé \fBcoproc\fP. Un coprocessus est exécuté de façon asynchrone dans un sous\-interpréteur, comme si la commande se terminait par l'opérateur de contrôle \fB&\fP, avec un tube bidirectionnel établi entre l'interpréteur d'exécution et le coprocessus. .PP Le format d'un coprocessus est\ : .RS .PP \fBcoproc\fP [\fINOM\fP] \fIcommande\fP [\fIredirections\fP] .RE .PP Un coprocessus appelé \fINOM\fP est créé. Si \fINOM\fP n'est pas fourni, le nom par défaut est \fICOPROC\fP. \fINOM\fP ne doit pas être fourni si \fIcommande\fP est une \fIcommande simple\fP (voir ci\-dessus)\ ; sinon, il est interprété comme le premier mot d'une commande simple. Quand le coprocessus est exécuté, l'interpréteur crée une variable tableau (consultez \fBTableaux\fP ci\-dessous) appelée \fINOM\fP dans le contexte de l'interpréteur d'exécution. La sortie standard de \fIcommande\fP est connecté par un tube à un descripteur de fichier dans l'interpréteur d'exécution, et ce descripteur de fichier est affecté à \fINOM\fP[0]. L'entrée standard de \fIcommande\fP est connecté par un tube à un descripteur de fichier dans l'interpréteur d'exécution, et ce descripteur de fichier est affecté à \fINOM\fP[1]. Ce tube est établi avant toute redirection indiquée par la commande (consultez .SM \fBREDIRECTIONS\fP ci\-dessous). Les descripteurs de fichier peuvent être utilisés comme arguments aux commandes d'interpréteur et redirections utilisant les développements standards de mot. L'identifiant du processus (PID) de l'interpréteur engendré pour exécuter le coprocessus est disponible comme valeur de la variable \fINAME\fP_PID. La commande interne \fBwait\fP peut être utilisée pour attendre que le coprocessus soit terminé. .PP L'état renvoyé d'un coprocessus est l'état final de \fIcommande\fP. .SS "Définitions des fonctions de l'interpréteur" .PP 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\ : .TP \fInom\fP () \fIcommande\-composée\fP [\fIredirection\fP] .PD 0 .TP \fBfunction\fP \fInom\fP [()] \fIcommande\-composée\fP [\fIredirection\fP] .PD Cela définit une fonction possédant le \fInom\fP mentionné. Le mot réservé \fBfunction\fP est facultatif. S'il est fourni, les parenthèses sont facultatives. Le \fIcorps\fP de la fonction est la commande composée \fIcommande\-composée\fP (consultez \fBCommandes composées\fP ci\-dessus). Cette commande est généralement une \fIliste\fP de commandes entre { et }, mais peut être n'importe quelle commande décrite dans \fBCommandes composées\fP ci\-dessus. La \fIcommande\-composée\fP est exécutée chaque fois que \fInom\fP est indiqué comme le nom d'une commande normale. Toutes les redirections (consultez .SM \fBREDIRECTIONS\fP ci\-dessous) indiquées lorsqu'une fonction est définie sont effectuées lorsque la fonction est exécutée. L'état final d'une définition de fonction est zéro, à moins qu'une erreur de syntaxe ne se produise ou qu'une fonction en lecture seule n'existe déjà avec le même nom. Lorsque la fonction est exécutée, l'état final est celui de la dernière commande exécutée dans le corps de la fonction (consultez .SM \fBFONCTIONS\fP ci\-dessous). .SH COMMENTAIRES Dans un interpréteur non interactif ou dans un interpréteur interactif avec l'option \fBinteractive_comments\fP activée par la commande interne \fBshopt\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous), un mot commençant par \fB#\fP conduit à ignorer ce mot et tous les caractères restants sur la ligne. Un interpréteur interactif sans l'option \fBinteractive_comments\fP n'autorise pas les commentaires. L'option \fBinteractive_comments\fP est activée par défaut dans les interpréteurs interactifs. .SH PROTECTIONS Les \fIprotections\fP («\ 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. .PP Tous les \fImétacaractères\fP décrits ci\-dessus dans .SM \fBDÉFINITIONS\fP ont des significations spéciales pour l'interpréteur et doivent être protégés pour ne représenter que leur propre caractère. .PP Lorsque les outils de développement de l'historique des commandes sont utilisés (consultez .SM \fBDÉVELOPPEMENT DE L'HISTORIQUE\fP ci\-dessous), le caractère de \fIdéveloppement de l'historique\fP, généralement \fB!\fP, doit être protégé pour éviter le développement de l'historique. .PP Il y a trois mécanismes de protection\ : le caractère d'échappement, les guillemets simples («\ single quotes\ ») et les guillemets doubles («\ double quotes\ »). .PP Le \fIcaractère d'échappement\fP est une contre\-oblique (\fB\e\fP) non protégée. Il préserve la valeur littérale du caractère qui le suit, à l'exception du . Si un couple \fB\e\fP apparaît et si la contre\-oblique n'est pas elle\-même protégée, l'ensemble \fB\e\fP est considéré comme une continuation de ligne (c'est\-à\-dire qu'il est supprimé du flux d'entrée et ignoré en pratique). .PP 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. .PP Encadrer des caractères entre des guillemets doubles préserve la valeur littérale de chacun des caractères sauf \fB$\fP, \fB\`\fP, \fB\e\fP et, lorsque le développement de l'historique est activé, \fB!\fP. Les caractères \fB$\fP et \fB\`\fP conservent leurs significations spéciales entre guillemets doubles. La contre\-oblique ne conserve sa signification spéciale que lorsqu'elle est suivie par l'un des caractères suivants\ : \fB$\fP, \fB\`\fP, \^\fB"\fP\^, \fB\e\fP ou \fB\fP. Un guillemet double peut être protégé entre deux guillemets doubles en étant précédé d'une contre\-oblique. S'il est activé, le développement de l'historique sera effectué, à moins qu'un \fB!\fP apparaissant entre guillemets doubles ne soit protégé par une contre\-oblique. La contre\-oblique précédant le \fB!\fP n'est pas supprimée. .PP Les caractères spéciaux \fB*\fP et \fB@\fP ont des significations spéciales lorsqu'ils se trouvent entre des guillemets doubles (consultez .SM \fBPARAMÈTRES\fP ci\-dessous). .PP Les mots de la forme \fB$\fP\(aq\fIchaîne\fP\(aq sont traités spécialement. Le mot est développé en \fIchaîne\fP avec les caractères protégés par contre\-oblique remplacés comme indiqué par le standard ANSI C. Les suites d'échappement par contre\-oblique, si présentes, sont décodées comme suit\ : .RS .PD 0 .TP \fB\ea\fP alerte (alarme)\ ; .TP \fB\eb\fP effacement arrière («\ backspace\ »)\ ; .TP \fB\ee\fP .TP \fB\eE\fP caractère d'échappement\ ; .TP \fB\ef\fP saut de page («\ form feed\ »)\ ; .TP \fB\en\fP saut de ligne («\ new line\ »)\ ; .TP \fB\er\fP retour chariot («\ carriage return\ »)\ ; .TP \fB\et\fP tabulation horizontale\ ; .TP \fB\ev\fP tabulation verticale\ ; .TP \fB\e\e\fP contre\-oblique\ ; .TP \fB\e\(aq\fP guillemet simple\ ; .TP \fB\e"\fP guillemet double\ ; .TP \fB\e\fP\fInnn\fP le caractère 8\ bits dont la valeur octale est \fInnn\fP (un à trois chiffres)\ ; .TP \fB\ex\fP\fIHH\fP le caractère 8\ bits dont la valeur hexadécimale est \fIHH\fP (un ou deux chiffres hexadécimaux)\ ; .TP \fB\eu\fP\fIHHHH\fP le caractère Unicode (ISO/IEC 10646) dont la valeur hexadécimale est \fIHHHH\fP (un à quatre chiffres hexadécimaux)\ ; .TP \fB\eU\fP\fIHHHHHHHH\fP le caractère Unicode (ISO/IEC 10646) dont la valeur hexadécimale est \fIHHHHHHHH\fP (un à huit chiffres hexadécimaux)\ ; .TP \fB\ec\fP\fIx\fP un caractère contrôle\-\fIx\fP. .PD .RE .LP Le résultat développé est protégé par des guillemets simples comme si le symbole dollar n'avait pas été présent. .PP Une chaîne entre guillemets doubles précédée d'un symbole dollar (\fB$\fP"\fIchaîne\fP") conduira à la traduction de la chaîne selon les paramètres linguistiques régionaux en vigueur. Si les paramètres linguistiques régionaux actuels est \fBC\fP ou \fBPOSIX\fP, le symbole dollar est ignoré. Si la chaîne est traduite et remplacée, le résultat est protégé par des guillemets doubles. .SH PARAMÈTRES Un \fIparamètre\fP est une entité permettant de stocker des valeurs. Il peut être un \fInom\fP, un nombre ou un des caractères spéciaux décrits ci\-dessous, dans \fBParamètres spéciaux\fP. Une \fIvariable\fP est un paramètre noté par un \fInom\fP. Une variable possède une \fIvaleur\fP et zéro ou plusieurs \fIattributs\fP. Les attributs sont affectés en utilisant la commande interne \fBdeclare\fP (consultez \fBdeclare\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .PP 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 \fBunset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .PP Une \fIvariable\fP peut recevoir une valeur par une affectation de la forme .RS .PP \fInom\fP=[\fIvaleur\fP] .RE .PP Si aucune \fIvaleur\fP n'est indiquée, une chaîne vide est affectée à la variable. Toutes les \fIvaleurs\fP 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 (consultez .SM \fBDÉVELOPPEMENTS\fP ci\-dessous). Si une variable a son attribut \fIinteger\fP configuré, alors la \fIvaleur\fP est soumise à l'évaluation arithmétique, même si la syntaxe $((...)) n'est pas utilisée (consultez \fBDéveloppement arithmétique\fP ci\-dessous). Le découpage en mots n'est pas effectué, à l'exception de \fB"$@"\fP comme expliqué ci\-dessous dans \fBParamètres spéciaux\fP. Le développement des chemins n'est pas effectué. Les affectations peuvent également apparaître comme argument des commandes internes suivantes\ : \fBalias\fP, \fBdeclare\fP, \fBtypeset\fP, \fBexport\fP, \fBreadonly\fP et \fBlocal\fP. .PP Dans le contexte où une affectation affecte une valeur à une variable de l'interpréteur ou à un indice de tableau, l'opérateur += peut être utilisé pour ajouter ou additionner à la précédente valeur de la variable. Lorsque l'opérateur += est appliqué à une variable dont l'attribut \fIinteger\fP (entier) a été positionné, la \fIvaleur\fP est évaluée comme une expression arithmétique et additionnée à la valeur actuelle de la variable qui est également évaluée. Lorsque += est appliqué à une variable tableau en utilisant l'affectation composée (consultez \fBTableaux\fP ci\-dessous), la valeur de la variable n'est pas détruite (comme elle l'est lorsque = est utilisé) et les nouvelles valeurs sont ajoutées au tableau, en commençant à l'indice maximum du tableau plus un (pour les tableaux indicés) ou ajoutées comme un couple clé\-valeur pour un tableau associatif. Lorsque l'opérateur est appliqué à une variable de type chaîne, la \fIvaleur\fP est développée et concaténée en valeur de la variable. .SS "Paramètres positionnels" .PP Un \fIparamètre positionnel\fP 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 \fBset\fP. 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 (consultez .SM \fBFONCTIONS\fP ci\-dessous). .PP Un paramètre positionnel constitué de plusieurs chiffres doit être encadré par des accolades lors de son développement (consultez .SM \fBDÉVELOPPEMENTS\fP ci\-dessous). .SS "Paramètres spéciaux" .PP 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. .PD 0 .TP \fB*\fP Se développe en ensemble des paramètres positionnels, commençant par le premier. Quand le développement se produit entre des guillemets doubles, \fB*\fP 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 .SM \fBIFS\fP. C'est\-à\-dire que "\fB$*\fP" est équivalent à "\fB$1\fP\fIc\fP\fB$2\fP\fIc\fP\fB...\fP", où \fIc\fP est le premier caractère de la valeur de la variable .SM \fBIFS\fP. Si .SM \fBIFS\fP est inexistante, les paramètres sont séparés par des espaces. Si .SM \fBIFS\fP est vide, les paramètres sont accolés sans séparateurs. .TP \fB@\fP Se développe en ensemble des paramètres positionnels, commençant par le premier. Quand le développement a lieu entre guillemets doubles, chaque paramètre se développe en un mot distinct. C'est\-à\-dire que "\fB$@\fP" est équivalent à "\fB$1\fP" "\fB$2\fP" .... 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, "\fB$@\fP" et \fB$@\fP ne se développent en rien (c'est\-à\-dire qu'ils sont simplement éliminés). .TP \fB#\fP Correspond au nombre de paramètres positionnels, en base décimale. .TP \fB?\fP Se développe en état final de la dernière conduite exécutée au premier plan. .TP \fB\-\fP Est remplacé par la liste des options de l'interpréteur indiquées durant l'appel, configurées avec la commande interne \fBset\fP ou celles créées par l'interpréteur lui\-même (comme avec l'option \fB\-i\fP). .TP \fB$\fP 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. .TP \fB!\fP Se transforme en PID de la commande (asynchrone) exécutée en arrière\-plan le plus récemment. .TP \fB0\fP Se développe en nom de l'interpréteur ou du script. Ce paramètre est créé lors de l'initialisation de l'interpréteur. Si \fBbash\fP est appelé avec un fichier de commandes, \fB$0\fP correspond au nom de ce fichier. Si \fBbash\fP est lancé avec l'option \fB\-c\fP, alors \fB$0\fP 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 \fBbash\fP, comme indiqué par l'argument zéro. .TP \fB_\fP Au lancement de l'interpréteur, contient le chemin d'accès absolu utilisé pour appeler l'interpréteur, ou le script en cours d'exécution tel qu'il est passé dans l'environnement ou dans la liste des arguments. Devient le dernier argument de la commande précédente, après développement. Contient également le chemin d'accès complet de chaque commande exécutée et se retrouve dans l'environnement exporté à cette commande. Lors de la vérification de l'arrivée de courrier, contient le nom du fichier de courrier en cours de consultation. .PD .SS "Variables de l'interpréteur" .PP Les variables suivantes sont créées par l'interpréteur\ : .PP .PD 0 .TP \fBBASH\fP Se développe en chemin d'accès complet à l'instance actuelle de \fBbash\fP. .TP \fBBASHOPTS\fP Liste des options activées de l'interpréteur, séparées par des deux\-points «\ :\ ». Chaque mot de la liste est un argument correct pour l'option \fB\-s\fP de la commande interne \fBshopt\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). Les options apparaissant dans .SM \fBBASHOPTS\fP sont celles indiquées comme \fIactives\fP par \fBshopt\fP. Si cette variable est dans l'environnement au lancement de \fBbash\fP, chaque option de la liste est activée avant de lire n'importe quel fichier d'initialisation. Cette variable est en lecture seule. .TP \fBBASHPID\fP Se transforme en PID de l'interpréteur \fBbash\fP actuel. Diffère de \fB$$\fP sous certaines conditions, comme dans les sous\-interpréteurs ne nécessitant pas que \fBbash\fP soit réinitialisé. .TP \fBBASH_ALIASES\fP Une variable de type tableau associatif dont les éléments correspondent à une liste interne d'alias comme celle gérée par la commande interne \fBalias\fP. Les éléments ajoutés à ce tableau apparaissent dans la liste d'alias\ ; la destruction d'éléments du tableau implique le retrait des alias de la liste. .TP \fBBASH_ARGC\fP Une variable de type tableau contenant le nombre de paramètres de chaque trame de la pile d'appel d'exécution de l'interpréteur \fBbash\fP actuel. Le nombre de paramètres du sous\-programme actuel (fonction de l'interpréteur ou script exécuté par \fB.\fP ou \fBsource\fP) est au sommet de la pile. Lorsqu'un sous\-programme est exécuté, le nombre de paramètres passés est placé dans .SM \fBBASH_ARGC\fP. L'interpréteur crée .SM \fBBASH_ARGC\fP seulement dans le mode de traçage étendu (consultez ci\-dessous la description de l'option \fBextdebug\fP de la commande interne \fBshopt\fP). .TP \fBBASH_ARGV\fP Une variable de type tableau contenant tous les paramètres de la pile d'appel d'exécution de l'interpréteur \fBbash\fP actuel. Le dernier paramètre du dernier sous\-programme est au sommet de la pile\ ; le premier paramètre de l'appel initial est en bas. Lorsqu'un sous\-programme est exécuté, les paramètres fournis sont placés dans .SM \fBBASH_ARGV\fP. .SM \fBBASH_ARGV\fP est créé uniquement dans le mode de traçage étendu (consultez ci\-dessous la description de l'option \fBextdebug\fP de la commande interne \fBshopt\fP). .TP \fBBASH_CMDS\fP Une variable de type tableau associatif dont les éléments correspondent à une table de hachage interne de commandes comme celle gérée par la commande interne \fBhash\fP. Les éléments ajoutés à ce tableau apparaissent dans la liste table de hachage\ ; la destruction d'éléments du tableau implique le retrait des commandes de la table de hachage. .TP \fBBASH_COMMAND\fP 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. .TP \fBBASH_EXECUTION_STRING\fP L'argument commande de l'option d'appel \fB\-c\fP. .TP \fBBASH_LINENO\fP Une variable de type tableau dont les éléments sont les numéros de ligne des fichiers sources où chaque élément correspondant de .SM \fBFUNCNAME\fP a été invoqué. \fB${BASH_LINENO[\fP\fI$i\fP\fB]}\fP est le numéro de la ligne dans le fichier source (\fB${BASH_SOURCE[\fP\fI$i+1\fP\fB]}\fP) où \fB${FUNCNAME[\fP\fI$i\fP\fB]}\fP a été appelé (ou \fB${BASH_LINENO[\fP\fI$i\-1\fP\fB]}\fP si consulté depuis une autre fonction de l'interpréteur). Utilisez .SM \fBLINENO\fP pour obtenir le numéro de ligne actuel. .TP \fBBASH_REMATCH\fP Une variable de type tableau dont les éléments sont affectés avec l'opérateur binaire \fB=~\fP dans la commande conditionnelle \fB[[\fP. L'élément d'indice 0 est la partie de la chaîne correspondant à l'expression rationnelle complète. L'élément d'indice \fIn\fP est la partie de la chaîne correspondant à la \fIn\fP\-ième sous\-expression entre parenthèses. Cette variable est en lecture seule. .TP \fBBASH_SOURCE\fP Une variable de type tableau dont les éléments sont les noms des fichiers source où les noms des fonctions d'interpréteur correspondants à la variable de type tableau .SM \fBFUNCNAME\fP sont définis. La fonction d'interpréteur \fB${FUNCNAME[\fP\fI$i\fP\fB]}\fP est définie dans le fichier \fB${BASH_SOURCE[\fP\fI$i\fP\fB]}\fP et appelée depuis \fB${BASH_SOURCE[\fP\fI$i+1\fP\fB]}\fP. .TP \fBBASH_SUBSHELL\fP Incrémentée chaque fois qu'un sous\-interpréteur ou qu'un environnement de sous\-interpréteur est engendré. La valeur initiale est 0. .TP \fBBASH_VERSINFO\fP Une variable de type tableau protégée en écriture dont les éléments représentent la version de cette instance de \fBbash\fP. Cette valeur est affectée aux éléments du tableau comme suit\ : .sp .5 .RS .TP 24 \fBBASH_VERSINFO[\fP0\fB]\fP Le numéro majeur de la version (\fIrelease\fP). .TP \fBBASH_VERSINFO[\fP1\fB]\fP Le numéro mineur de la version (\fIversion\fP). .TP \fBBASH_VERSINFO[\fP2\fB]\fP Le niveau de correctif. .TP \fBBASH_VERSINFO[\fP3\fB]\fP Le numéro de compilation. .TP \fBBASH_VERSINFO[\fP4\fB]\fP Le statut de cette version (par exemple \fIbeta1\fP). .TP \fBBASH_VERSINFO[\fP5\fB]\fP La valeur de .SM \fBMACHTYPE\fP. .RE .TP \fBBASH_VERSION\fP Se développe en une chaîne décrivant le numéro de version de cette instance de \fBbash\fP. .TP \fBCOMP_CWORD\fP Un indice dans \fB${COMP_WORDS}\fP du mot contenant la position actuelle du curseur. Cette variable n'est disponible que dans les fonctions de l'interpréteur appelées par les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBCOMP_KEY\fP La touche (ou dernière touche d'une suite de touches) utilisée pour appeler la fonction de complètement actuelle. .TP \fBCOMP_LINE\fP La ligne de commande actuelle. Cette variable n'est disponible que dans les fonctions de l'interpréteur appelées par les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBCOMP_POINT\fP L'indice de la position actuelle du curseur relatif au début de la commande actuelle. Si la position actuelle du curseur est à la fin de la commande actuelle, la valeur de cette variable est égale à \fB${#COMP_LINE}\fP. 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 (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBCOMP_TYPE\fP Configurée à une valeur entière correspondant au type de complètement essayé qui a provoqué l'appel d'une fonction de complètement\ : \fITAB\fP pour un complètement normal, \fI?\fP pour l'affichage des complètements après tabulations successives, \fI!\fP pour l'affichage des alternatives de complètement de mot partiel, \fI@\fP pour afficher les complètements si le mot n'est pas modifié, ou \fI%\fP pour le menu de complètement. Cette variable n'est disponible que dans les fonctions de l'interpréteur et les commandes externes appelées par les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBCOMP_WORDBREAKS\fP Le jeu de caractères que la bibliothèque \fBreadline\fP considère comme séparateurs de mots lors du complètement de mot. Si .SM \fBCOMP_WORDBREAKS\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBCOMP_WORDS\fP Une variable de type tableau (consultez \fBTableaux\fP ci\-dessous) consistant en mots individuels de la ligne de commande actuelle. La ligne est découpée en mots comme \fBreadline\fP la découperait, en utilisant .SM \fBCOMP_WORDBREAKS\fP tel que décrit ci\-dessus. Cette variable n'est disponible que dans les fonctions de l'interpréteur appelées par les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBCOPROC\fP Une variable de type tableau (consultez \fBTableaux\fP ci\-dessous) créée pour représenter les descripteurs de fichier pour les sorties depuis et les entrées vers un coprocessus non nommé (consultez \fBCoprocessus\fP ci\-dessus). .TP \fBDIRSTACK\fP Une variable de type tableau (consultez \fBTableaux\fP ci\-dessous) représentant le contenu actuel de la pile de répertoires. Les répertoires apparaissent dans la pile dans l'ordre dans lequel la commande interne \fBdirs\fP 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 \fBpushd\fP et \fBpopd\fP doivent être utilisées pour ajouter et enlever des répertoires. L'affectation de cette variable ne modifiera pas le répertoire actuel. Si .SM \fBDIRSTACK\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBEUID\fP Contient l'UID effectif de l'utilisateur, initialisé au démarrage de l'interpréteur. Cette variable est en lecture seule. .TP \fBFUNCNAME\fP Une variable de type tableau contenant le nom de toutes les fonctions de l'interpréteur actuellement dans la pile d'appel d'exécution. L'élément d'indice 0 est le nom de l'une des fonctions en cours d'exécution dans l'interpréteur. L'élément le plus bas (celui avec l'indice le plus grand) est .if t \f(CW« main »\fP. .if n « main ». Cette variable n'existe que si une fonction de l'interpréteur est en cours d'exécution. Les affectations de \fBFUNCNAME\fP n'ont aucun effet et renvoient un état d'erreur. Si .SM \fBFUNCNAME\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .if t .sp 0.5 .if n .sp 1 Cette variable peut être utilisée avec \fBBASH_LINENO\fP et \fBBASH_SOURCE\fP. Chaque élément de \fBFUNCNAME\fP a des éléments correspondant dans \fBBASH_LINENO\fP et \fBBASH_SOURCE\fP pour décrire la pile d'appel. Par exemple, \fB${FUNCNAME[\fP\fI$i\fP\fB]}\fP a été appelé depuis le fichier \fB${BASH_SOURCE[\fP\fI$i+1\fP\fB]}\fP à la ligne numéro \fB${BASH_LINENO[\fP\fI$i\fP\fB]}\fP. La commande interne \fBcaller\fP affiche la pile d'appel actuelle utilisant ces renseignements. .TP \fBGROUPS\fP Une variable de type tableau contenant la liste des groupes dont l'utilisateur est membre. Les affectations de .SM \fBGROUPS\fP n'ont aucun effet et renvoient un état d'erreur. Si .SM \fBGROUPS\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBHISTCMD\fP Le numéro d'historique, ou l'indice dans la file d'historique, de la commande en cours. Si .SM \fBHISTCMD\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBHOSTNAME\fP Automatiquement configurée au nom de la machine actuelle. .TP \fBHOSTTYPE\fP Automatiquement configurée en chaîne décrivant de façon unique le type de machine sur laquelle \fBbash\fP s'exécute. La valeur par défaut dépend du système. .TP \fBLINENO\fP 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 .SM \fBLINENO\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBMACHTYPE\fP Automatiquement configurée en chaîne décrivant le type du système sur lequel \fBbash\fP s'exécute, dans le format standard de GNU \fIprocesseur\-compagnie\-système\fP. La valeur par défaut dépend du système. .TP \fBMAPFILE\fP Une variable de type tableau (consultez \fBTableaux\fP ci\-dessous) créée pour représenter le texte lu par la commande interne \fBmapfile\fP si aucun nom de variable n'a été fourni. .TP \fBOLDPWD\fP Le répertoire de travail précédent tel que configuré par la commande \fBcd\fP. .TP \fBOPTARG\fP La valeur du dernier argument d'option traité par la commande interne \fBgetopts\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .TP \fBOPTIND\fP L'indice du prochain argument à traiter par la commande interne \fBgetopts\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .TP \fBOSTYPE\fP Automatiquement configurée en chaîne décrivant le système d'exploitation sur lequel \fBbash\fP s'exécute. La valeur par défaut dépend du système. .TP \fBPIPESTATUS\fP Une variable de type tableau (consultez \fBTableaux\fP ci\-dessous) 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). .TP \fBPPID\fP L'identifiant du processus parent de l'interpréteur. Cette variable est en lecture seule. .TP \fBPWD\fP Le répertoire de travail actuel tel que configuré par la commande \fBcd\fP. .TP \fBRANDOM\fP À 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 à .SM \fBRANDOM\fP. Si .SM \fBRANDOM\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBREADLINE_LINE\fP Le contenu du tampon de ligne \fBreadline\fP, pour utiliser avec .if t \f(CWbind -x\fP .if n « bind -x » (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .TP \fBREADLINE_POINT\fP La position du point d'insertion dans le tampon de ligne \fBreadline\fP, pour utiliser avec .if t \f(CWbind -x\fP .if n « bind -x » (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .TP \fBREPLY\fP Configurée en ligne de saisie lue par la commande interne \fBread\fP lorsqu'aucun argument n'a été fourni. .TP \fBSECONDS\fP À 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 à .SM \fBSECONDS\fP, 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 .SM \fBSECONDS\fP est détruite, elle perd ses propriétés spéciales, même si elle est recréée par la suite. .TP \fBSHELLOPTS\fP Liste des options activées de l'interpréteur, séparées par des deux\-points «\ :\ ». Chaque mot de la liste est un argument correct pour l'option \fB\-o\fP de la commande interne \fBset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). Les options apparaissant dans .SM \fBSHELLOPTS\fP sont celles indiquées comme \fIactives\fP par \fBset \-o\fP. Si cette variable est dans l'environnement au lancement de \fBbash\fP, chaque option de la liste est activée avant de lire n'importe quel fichier d'initialisation. Cette variable est en lecture seule. .TP \fBSHLVL\fP Incrémenté de 1 à chaque appel d'une instance de \fBbash\fP. .TP \fBUID\fP Contient l'UID de l'utilisateur actuel, initialisé au démarrage de l'interpréteur. Cette variable est en lecture seule. .PD .PP Les variables suivantes sont utilisées par l'interpréteur. Dans certains cas, \fBbash\fP affecte des valeurs par défaut aux variables\ ; ces cas sont décrits ci\-dessous. .PP .PD 0 .TP \fBBASH_ENV\fP Si ce paramètre existe lorsque \fBbash\fP 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 \fI~/.bashrc\fP. La valeur de .SM \fBBASH_ENV\fP 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. .SM \fBPATH\fP n'est pas utilisée pour rechercher le fichier obtenu. .TP \fBBASH_XTRACEFD\fP Si configurée à une valeur entière correspondant à un descripteur de fichier correct, \fBbash\fP écrira la trace de sortie si .if t \f(CWset -x\fP .if n \fIset -x\fP est activé vers ce descripteur de fichier. Le descripteur de fichier est fermé quand .SM \fBBASH_XTRACEFD\fP est détruite ou qu'une nouvelle valeur lui est affectée. Détruire .SM \fBBASH_XTRACEFD\fP ou lui affecter la chaîne vide conduit la trace de sortie à être envoyé vers la sortie d'erreur standard. Remarquez que configurer .SM \fBBASH_XTRACEFD\fP à 2 (le descripteur de fichier de la sortie d'erreur standard) puis la détruite revient à fermer la sortie d'erreur standard. .TP \fBCDPATH\fP Le chemin de recherche de la commande interne \fBcd\fP. 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 \fBcd\fP. Un exemple de valeur est .if t \f(CW« .:~:/usr »\fP. .if n « .:~:/usr ». .TP \fBCOLUMNS\fP Utilisée par la commande composée \fBselect\fP pour déterminer la taille du terminal lors de l'affichage des listes de sélection. Automatiquement configurée à la réception d'un signal .SM \fBSIGWINCH\fP . .TP \fBCOMPREPLY\fP Une variable de type tableau dans lequel \fBbash\fP lit les complètements possibles produits par une fonction de l'interpréteur appelée par les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessous). .TP \fBEMACS\fP Si \fBbash\fP trouve cette variable dans l'environnement lorsque l'interpréteur démarre avec la valeur .if t \f(CWt\fP, .if n « t », il considère que l'interpréteur est lancé dans un tampon d'interpréteur d'Emacs et désactive l'édition en ligne. .TP \fBENV\fP Similaire à .SM \fBBASH_ENV\fP. Utilisé quand l'interpréteur est invoqué en mode POSIX. .TP \fBFCEDIT\fP L'éditeur par défaut utilisé par la commande interne \fBfc\fP. .TP \fBFIGNORE\fP Une liste de suffixes, séparés par des deux\-points «\ :\ », que \fBbash\fP ignorera lors du complètement des noms de fichiers (consultez .SM \fBREADLINE\fP ci\-dessous). Un nom de fichier dont le suffixe correspond à l'un de ceux mentionnés dans .SM \fBFIGNORE\fP est exclu de la liste des noms de fichiers correspondant pour le complètement. Par exemple, cette variable peut prendre la valeur .if t \f(CW« .o:~ »\fP. .if n « .o:~ » (des protections sont nécessaires pour l'affectation d'une valeur à cette variable, qui contient des tildes). .TP \fBFUNCNEST\fP Si configurée à une valeur numérique strictement positive, cela définit le niveau maximal d'imbrication de fonctions. Les invocations de fonctions qui dépassent ce niveau d'imbrication forceront la commande actuelle à abandonner. .TP \fBGLOBIGNORE\fP 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 .SM \fBGLOBIGNORE\fP, il est supprimé de la liste des correspondances. .TP \fBHISTCONTROL\fP 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 \fIignorespace\fP, les lignes commençant par une \fBespace\fP ne sont pas sauvegardées dans la file d'historique. La valeur \fIignoredups\fP conduit à ne pas sauvegarder une ligne correspondant exactement à la ligne de commande précédente. La présence de \fIignoreboth\fP est un condensé pour \fIignorespace\fP et \fIignoredups\fP. La valeur \fIerasedups\fP conduit à retirer de la file d'historique toutes les lignes précédant la ligne actuelle 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 .SM \fBHISTCONTROL\fP 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 .SM \fBHISTIGNORE\fP. 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 .SM \fBHISTCONTROL\fP. .TP \fBHISTFILE\fP Le nom du fichier dans lequel l'historique des commandes est sauvegardé (consultez .SM \fBHISTORIQUE\fP ci\-dessous). Par défaut, il s'agit de \fI~/.bash_history\fP. Si inexistante, l'historique des commandes n'est pas sauvegardé lorsqu'un interpréteur interactif termine. .TP \fBHISTFILESIZE\fP 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. .TP \fBHISTIGNORE\fP 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 «\ \fB*\fP\ » implicite). Chaque motif est comparé à chaque ligne après application des vérifications de .SM \fBHISTCONTROL\fP. En plus des motifs génériques usuels de l'interpréteur, «\ \fB&\fP\ » correspond à la ligne précédente de l'historique. «\ \fB&\fP\ » peut être protégée par une contre\-oblique\ ; la contre\-oblique est supprimée avant de tenter une comparaison. La seconde ligne et les suivantes d'une commande multiligne ne sont pas testées et sont ajoutées dans l'historique quelque soit la valeur de .SM \fBHISTIGNORE\fP. .TP \fBHISTSIZE\fP Le nombre de commandes à mémoriser dans l'historique (consultez .SM \fBHISTORIQUE\fP ci\-dessous). La valeur par défaut est 500. .TP \fBHISTTIMEFORMAT\fP Si cette variable existe et n'est pas vide, sa valeur est utilisée comme une chaîne de caractères par \fBstrftime\fP(3) afin d'imprimer l'horodatage associé à chaque élément de l'historique affiché par la commande interne \fBhistory\fP. Si cette variable existe, les horodatages sont écrits dans le fichier d'historique afin d'être conservés au fur et à mesure des sessions de l'interpréteur. Cela utilise le caractère de commentaire d'historique pour distinguer l'horodatage des autres lignes de l'historique. .TP \fBHOME\fP Le répertoire d'accueil de l'utilisateur actuel\ ; l'argument par défaut de la commande interne \fBcd\fP. La valeur de cette variable est aussi utilisée lors du développement du tilde. .TP \fBHOSTFILE\fP Contient le nom d'un fichier ayant le même format que .FN /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, \fBbash\fP ajoute le contenu du nouveau fichier à la liste existante. Si .SM \fBHOSTFILE\fP existe mais est vide, ou désigne un fichier non accessible en lecture, \fBbash\fP essaie de lire .FN /etc/hosts pour obtenir la liste des complètements de noms de machines possibles. Lorsque .SM \fBHOSTFILE\fP est détruite, la liste des noms de machines est effacée. .TP \fBIFS\fP Le \fIséparateur de champs interne\fP («\ \fIInternal Field Separator\fP\ ») 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 \fBread\fP. La valeur par défaut est «\ \ ». .TP \fBIGNOREEOF\fP Commande le comportement d'un interpréteur interactif à réception d'un caractère .SM \fBEOF\fP (fin de fichier) comme unique saisie. Si elle existe, la valeur est le nombre de caractères .SM \fBEOF\fP consécutifs qui doivent être tapés comme premiers caractères sur une ligne de saisie avant que \fBbash\fP ne termine. Si la variable existe mais que sa valeur n'est pas numérique ou si elle n'a pas de valeur, la valeur par défaut est 10. Si elle n'existe pas, .SM \fBEOF\fP signifie la fin de la saisie pour l'interpréteur. .TP \fBINPUTRC\fP Le nom du fichier de configuration de \fBreadline\fP prioritaire sur le fichier par défaut .FN ~/.inputrc (consultez .SM \fBREADLINE\fP ci\-dessous). .TP \fBLANG\fP 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 \fBLC_\fP. .TP \fBLC_ALL\fP Cette variable surpasse .SM \fBLANG\fP et toute autre variable \fBLC_\fP indiquant une catégorie de paramètres linguistiques régionaux. .TP \fBLC_COLLATE\fP 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. .TP \fBLC_CTYPE\fP 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. .TP \fBLC_MESSAGES\fP 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 \fB$\fP. .TP \fBLC_NUMERIC\fP Cette variable détermine le paramètre linguistique régional utilisé pour formater les nombres. .TP \fBLINES\fP Utilisée par la commande composée \fBselect\fP pour déterminer la longueur de colonne lors de l'affichage des listes de sélection. Automatiquement configurée à la réception d'un signal .SM \fBSIGWINCH\fP. .TP \fBMAIL\fP Si ce paramètre correspond à un nom de fichier ou de répertoire et si la variable .SM \fBMAILPATH\fP est inexistante, \fBbash\fP informe l'utilisateur de l'arrivée de messages dans le fichier indiqué ou le répertoire au format Maildir. .TP \fBMAILCHECK\fP Indique l'intervalle (en secondes) avec lequel \fBbash\fP vérifie si un nouveau message est arrivé. La valeur par défaut est 60 secondes. Lorsque le délai est écoulé, l'interpréteur vérifiera la présence d'un courrier électronique avant d'afficher son invite de base. Si cette variable est inexistante, ou contient une valeur strictement négative, l'interpréteur désactive la vérification du courrier. .TP \fBMAILPATH\fP Une liste de noms de fichiers séparés par des deux\-points «\ :\ », dans lesquels on vérifiera l'arrivée de courrier. Le nom d'un fichier peut être suivi d'un point d'interrogation «\ ?\ », puis d'une chaîne de caractères indiquant le message à afficher en cas de courrier. Dans cette chaîne, le paramètre \fB$_\fP correspond au nom du fichier de courrier actuel. Exemple\ : .RS .PP \fBMAILPATH\fP=\(aq/usr/spool/mail/bfox?"Vous avez du courrier":~/shell\-mail?"$_ a du courrier\ !"\(aq .PP \fBBash\fP 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/\fB$USER\fP). .RE .TP \fBOPTERR\fP Si configurée à la valeur 1, \fBbash\fP affiche les messages d'erreurs engendrés par la commande interne \fBgetopts\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .SM \fBOPTERR\fP est initialisée avec la valeur 1 à chaque appel de l'interpréteur ou au lancement d'un script. .TP \fBPATH\fP 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 (consultez .SM \fBEXÉCUTION DES COMMANDES\fP ci\-dessous). Un nom de répertoire de taille nulle (vide) dans la valeur de .SM \fBPATH\fP désigne le répertoire actuel. 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 \fBbash\fP. Une valeur commune est .if t \f(CW/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin\fP. .if n « /usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin ». .TP \fBPOSIXLY_CORRECT\fP Si cette variable existe dans l'environnement lorsque \fBbash\fP démarre, l'interpréteur passe en \fImode posix\fP avant de lire les fichiers de configuration comme si l'option \fB\-\-posix\fP avait été fournie. Si elle est créée pendant que l'interpréteur est en cours d'exécution, \fBbash\fP active le \fImode posix\fP comme si la commande .if t \f(CWset -o posix\fP .if n \fIset -o posix\fP avait été exécutée. .TP \fBPROMPT_COMMAND\fP Si existante, sa valeur est exécutée comme commande préalablement à l'affichage de chaque invite de base. .TP \fBPROMPT_DIRTRIM\fP Si elle contient un nombre supérieur à zéro, cette valeur est utilisée comme nombre de répertoires finaux à conserver lors du développement des protections de chaîne d'invite \fB\ew\fP et \fB\eW\fP (consultez .SM \fBINVITES\fP ci\-dessous). Les caractères supprimés sont remplacés par une ellipse. .TP \fBPS1\fP La valeur de ce paramètre est développée puis utilisée comme chaîne d'invite de base (consultez .SM \fBINVITES\fP ci\-dessous). La valeur par défaut est «\ \fB\es\-\ev\e$ \fP\ ». .TP \fBPS2\fP La valeur de ce paramètre est développée comme .SM \fBPS1\fP puis utilisée comme chaîne d'invite secondaire. La valeur par défaut est «\ \fB>\ \fP\ ». .TP \fBPS3\fP La valeur de ce paramètre est utilisée comme invite de la commande \fIselect\fP (consultez .SM \fBGRAMMAIRE DE L'INTERPRÉTEUR\fP ci\-dessus). .TP \fBPS4\fP La valeur de ce paramètre est développée comme .SM \fBPS1\fP puis affichée entre chaque commande lors d'un suivi d'exécution. Le premier caractère de .SM \fBPS4\fP est répété autant de fois que nécessaire pour indiquer le niveau d'imbrication. La valeur par défaut est «\ \fB+\ \fP\ ». .TP \fBSHELL\fP 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, \fBbash\fP lui affecte le chemin d'accès complet à l'interpréteur de commandes de connexion de l'utilisateur actuel. .TP \fBTIMEFORMAT\fP La valeur de ce paramètre est utilisée en tant que chaîne de format indiquant comment les informations de paramétrage doivent être affichées pour les conduites précédées du mot réservé \fBtime\fP. Le caractère \fB%\fP introduit une suite de caractères d'échappement qui est développée en valeur de temps ou autre information. Les suites de caractères d'échappement et leurs significations sont les suivantes\ ; les crochets marquent les parties facultatives. .sp .5 .RS .PD 0 .TP 10 \fB%%\fP Un \fB%\fP seul (non interprété). .TP \fB%[\fP\fIp\fP\fB][l]R\fP Le temps écoulé en secondes. .TP \fB%[\fP\fIp\fP\fB][l]U\fP Le temps processeur écoulé en mode utilisateur en secondes. .TP \fB%[\fP\fIp\fP\fB][l]S\fP Le temps processeur écoulé en mode système en secondes. .TP \fB%P\fP Le pourcentage de temps processeur utilisé calculé avec (%U + %S) / %R. .PD .RE .IP Le \fIp\fP facultatif est un chiffre indiquant la \fIprécision\fP, le nombre de chiffres après la virgule. Une valeur de 0 conduit à affichage de nombre entiers. Trois chiffres au plus peuvent être affichés après la virgule\ ; tout valeur supérieure à 3 sera modifiée en 3. Si \fIp\fP n'est pas précisé, la valeur 3 est utilisée. .IP Le \fBl\fP facultatif indique un format plus long, incluant les minutes, de la forme \fIMM\fPm\fISS\fP.\fIDD\fPs. La valeur de \fIp\fP détermine si la partie décimale est affichée ou non. .IP Si cette variable n'existe pas, \fBbash\fP agit comme si elle avait la valeur \fB$\(aq\enreal\et%3lR\enuser\et%3lU\ensys\t%3lS\(aq\fP. Si la valeur est vide, aucune information de chronométrage n'est affichée. Un caractère final de changement de ligne est ajouté quand la chaîne de format est affichée. .PD 0 .TP \fBTMOUT\fP Si configurée en valeur strictement positive, .SM \fBTMOUT\fP est traitée comme le délai par défaut pour la commande interne \fBread\fP. La commande \fBselect\fP se termine s'il n'y a pas de saisie au bout de .SM \fBTMOUT\fP secondes lorsque l'entrée vient d'un terminal. Dans un interpréteur interactif, la valeur est interprétée comme le nombre de secondes à attendre une saisie après avoir affiché l'invite de base. \fBBash\fP se termine après avoir attendu pendant ce nombre de secondes si aucune saisie n'est arrivée. .TP \fBTMPDIR\fP Si existante, \fBbash\fP utilise sa valeur comme nom de répertoire dans lequel \fBbash\fP crée les fichiers temporaires nécessaires au fonctionnement de l'interpréteur. .TP \fBauto_resume\fP 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 \fInom\fP d'une tâche suspendue, dans ce contexte, est la ligne de commande utilisée pour la lancer. Si configurée à la valeur \fIexact\fP, la chaîne fournie doit correspondre exactement au nom d'une tâche suspendue\ ; si configurée à \fIsubstring\fP, la chaîne fournie doit correspondre à une sous\-chaîne du nom de la tâche suspendue. La valeur \fIsubstring\fP donne une fonctionnalité analogue à l'identificateur de tâche \fB%?\fP (consultez .SM \fBCONTRÔLE DES TÂCHES\fP ci\-dessous). Si configurée à toute autre valeur, la chaîne fournie doit être le préfixe du nom d'une tâche suspendue\ ; cela fournit une fonctionnalité analogue à l'identificateur de tâche \fB%\fP\fIstring\fP. .TP \fBhistchars\fP Les deux ou trois caractères commandant le développement de l'historique et le découpage en lexèmes (consultez .SM \fBDÉVELOPPEMENT DE L'HISTORIQUE\fP ci\-dessous). Le premier caractère est le \fIcaractère de développement de l'historique\fP, celui qui indique le début d'un développement d'historique (normalement «\ \fB!\fP\ »). Le second caractère est celui de \fIsubstitution rapide\fP, utilisé comme raccourci pour relancer la commande précédente, en modifiant une partie de la chaîne (par défaut «\ \fB^\fP\ »). 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 «\ \fB#\fP\ »). 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. .PD .SS Tableaux \fBBash\fP fournit des variables de type tableau indicé ou associatif, à une dimension. Toute variable peut être utilisée comme tableau indicé\ ; la commande interne \fBdeclare\fP peut servir à déclarer explicitement un tableau. Il n'y a pas de limitation maximum à la taille d'un tableau, ni d'obligation à indicer les éléments ou les affecter de façon contiguë. Les tableaux indicés sont consultés avec des entiers (évaluations arithmétiques comprises) commençant à zéro\ ; les tableaux associatifs sont consultés avec des chaînes arbitraires. .PP Un tableau indicé est créé automatiquement si une variable quelconque est affectée en utilisant la syntaxe \fInom\fP[\fIindice\fP]=\fIvaleur\fP. L'\fIindice\fP est traité comme une expression arithmétique et doit s'évaluer en un nombre. Si l'\fIindice\fP s'évalue en un nombre négatif, il est utilisé comme indice commençant à l'indice maximal du tableau plus un (ainsi un indice \-1 fait référence au dernier élément du tableau). \fBdeclare \-a \fP\fInom\fP permet de déclarer explicitement un tableau indicé (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). \fBdeclare \-a \fP\fInom\fP\fB[\fP\fIindice\fP\fB]\fP est aussi accepté\ ; l'\fIindice\fP est ignoré. .PP Les tableaux associatifs sont créés en utilisant \fBdeclare \-A \fP\fInom\fP. .PP Des attributs peuvent être indiqués pour une variable tableau en utilisant les commandes internes \fBdeclare\fP et \fBreadonly\fP. Les attributs s'appliquent à tous les éléments d'un tableau. .PP Les tableaux sont affectés en utilisant l'affectation composée de la forme \fInom\fP=\fB(\fPvaleur_\fI1\fP ... valeur_\fIn\fP\fB)\fP, où chaque \fIvaleur\fP est de la forme [\fIindice\fP]=\fIchaîne\fP. Les affectations de tableau indicé ne nécessitent ni crochets ni indices. Lors de l'affectation de tableaux indicés, si les crochets et les indices facultatifs sont fournis, les affectations ont lieu en conséquence\ ; sinon l'indice de l'élément affecté est le dernier indice affecté plus un. L'indexation commence à zéro. .PP Lors de l'affectation d'un tableau associatif, l'indice est obligatoire. .PP Cette syntaxe est aussi acceptée par la commande interne \fBdeclare\fP. Les éléments individuels du tableau sont affectés en utilisant la syntaxe \fInom\fP[\fIindice\fP]=\fIvaleur\fP présentée ci\-dessus. .PP Tout élément d'un tableau est accessible avec la notation ${\fInom\fP[\fIindice\fP]}. Les accolades sont nécessaires pour éviter les conflits avec le développement des chemins. Si \fIindice\fP est \fB@\fP ou \fB*\fP, le mot se développe en tous les éléments de \fInom\fP. Ces deux indices ne diffèrent que lorsque le mot apparaît entre guillemets doubles. Si le mot est entre guillemets doubles, ${\fInom\fP[*]} se développe en un seul mot contenant les valeurs de chaque élément du tableau séparées par le premier caractère de la variable spéciale .SM \fBIFS\fP et ${\fInom\fP[@]} développe chaque élément de \fInom\fP en un mot distinct. Quand il n'y a pas d'élément dans le tableau, ${\fInom\fP[@]} ne se développe en rien. Si le développement entre guillemets doubles survient à l'intérieur d'un mot, le développement du premier paramètre est accolé à la première partie du mot original et le développement du dernier paramètre est accolé à la dernière partie du mot original. Le comportement est analogue à celui des paramètres spéciaux \fB*\fP et \fB@\fP (consultez \fBParamètres spéciaux\fP ci\-dessus). ${#\fInom\fP[\fIindice\fP]} s'évalue en longueur de l'élément ${\fInom\fP[\fIindice\fP]}. Si l'\fIindice\fP est \fB*\fP ou \fB@\fP, s'évalue en nombre d'éléments dans le tableau. Accéder à une variable tableau sans indice est équivalent à accéder à l'élément de tableau d'indice 0. .PP Une variable tableau est considérée configurée si une valeur a été affectée à un indice. La chaîne vide est une valeur correcte. .PP La commande interne \fBunset\fP sert à détruire les tableaux. \fBunset\fP \fInom\fP[\fIindice\fP] détruit l'élément de tableau d'indice \fIindice\fP. Un soin particulier doit être apporté afin d'éviter des effets de bords non désirés provoqués par le développement des chemins. \fBunset\fP \fInom\fP, où \fInom\fP est un tableau, ou \fBunset\fP \fInom\fP[\fIindice\fP], avec \fIindice\fP valant \fB*\fP ou \fB@\fP supprime le tableau entier. .PP Les commandes internes \fBdeclare\fP, \fBlocal\fP et \fBreadonly\fP acceptent toutes une option \fB\-a\fP pour préciser un tableau indicé et une option \fB\-A\fP pour préciser un tableau associatif. Si les deux options sont fournies, \fB\-A\fP est prioritaire. La commande interne \fBread\fP accepte une option \fB\-a\fP pour affecter une liste de mots lus depuis l'entrée standard dans un tableau. Les commandes internes \fBset\fP et \fBdeclare\fP affichent les valeurs d'un tableau d'une façon qui permet de les réutiliser pour des affectations. .SH DÉVELOPPEMENTS Les développements sont appliqués à la ligne de commande après avoir été découpée en mots. Sept types de développements sont effectués\ : le \fIdéveloppement des accolades\fP, le \fIdéveloppement du tilde\fP, le \fIdéveloppement des paramètres et des variables\fP, la \fIsubstitution de commande\fP, le \fIdéveloppement arithmétique\fP, le \fIdécoupage en mots\fP et le \fIdéveloppement des chemins\fP. .PP 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. .PP Sur les systèmes qui le permettent, un développement supplémentaire a lieu\ : la \fIsubstitution de processus\fP. .PP 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 «\ \fB$@\fP\ » et «\ \fB${\fP\fInom\fP\fB[@]}\fP\ » comme expliqué ci\-dessus (consultez .SM \fBPARAMÈTRES\fP). .SS "Développement des accolades" .PP Le \fIdéveloppement des accolades\fP est un mécanisme permettant de produire des chaînes quelconques. Il est similaire au \fIdéveloppement des chemins\fP, mais les noms de fichiers produits n'existent pas nécessairement. Les motifs qui seront développés prennent la forme d'un \fIpréambule\fP facultatif, suivi soit par une série de chaînes séparées par des virgules, soit par l'expression d'une série entre accolades, et suivi par un \fIpost\-scriptum\fP 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. .PP 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\fB{\fPd,c,b\fB}\fPe se développe en «\ ade ace abe\ ». .PP Une expression de série est de la forme \fB{\fP\fIx\fP\fB..\fP\fIy\fP\fB[..\fP\fIincr\fP\fB]}\fP, où \fIx\fP et \fIy\fP sont soit des entiers, soit des caractères uniques, et \fIincr\fP, un incrément facultatif, est un entier. Lorsqu'il s'agit d'entiers, l'expression est remplacée par la liste des nombres entre \fIx\fP et \fIy\fP inclus. Les entiers fournis peuvent être préfixés par \fI0\fP pour forcer chaque terme à avoir la même longueur. Si \fIx\fP ou \fIy\fP commencent par un zéro, l'interpréteur essaiera de forcer tous les termes créés à la même longueur, en ajoutant des zéros au besoin. S'il s'agit de caractères, l'expression se développe en ensemble des caractères situés entre \fIx\fP et \fIy\fP d'un point de vue lexicographique. Remarquez que \fIx\fP et \fIy\fP doivent être du même type. Si l'incrément est fourni, il est utilisé comme différence entre chaque terme. L'incrément par défaut est 1 ou \-1 suivant les valeurs de \fIx\fP et \fIy\fP. .PP 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. \fBBash\fP n'effectue aucune interprétation syntaxique du texte entre les accolades. .PP Un développement d'accolades correctement formé doit contenir des accolades ouvrante et fermante non protégées et au moins une virgule non protégée ou une expression de série correcte. Tout développement d'accolades incorrectement formé est laissé inchangé. Un \fB{\fP ou un \fB,\fP 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 \fB${\fP n'est pas considérée comme éligible au développement des accolades. .PP 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\ : .RS .PP mkdir /usr/local/src/bash/{old,new,dist,bugs} .RE ou .RS chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}} .RE .PP Le développement des accolades induit une légère incompatibilité avec les versions historiques de \fBsh\fP. \fBsh\fP n'effectue aucun traitement sur les accolades ouvrantes et fermantes lorsqu'elles apparaissent dans un mot et les laisse inchangées. \fBBash\fP supprime les accolades dans les mots, après développement. Par exemple, si le mot \fIfile{1,2}\fP est fourni à \fBsh\fP, il reste inchangé en sortie. En revanche, il est transformé en \fIfile1 file2\fP par \fBbash\fP. Si une compatibilité stricte avec \fBsh\fP est nécessaire, lancez \fBbash\fP avec l'option \fB+B\fP ou désactivez le développement des accolades avec l'option \fB+B\fP de la commande \fBset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .SS "Développement du tilde" .PP Si un mot commence par un caractère tilde («\ \fB~\fP\ ») 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 \fIpréfixe tilde\fP. Si aucun caractère du préfixe tilde n'est protégé, les caractères suivant le tilde sont traités comme un \fIidentifiant de connexion\fP possible. Si cet identifiant de connexion est une chaîne vide, le tilde est remplacé par la valeur du paramètre d'interpréteur .SM \fBHOME\fP. Si .SM \fBHOME\fP n'existe pas, le répertoire d'accueil de l'utilisateur exécutant l'interpréteur est utilisé à la place. Sinon le préfixe tilde est remplacé par le répertoire d'accueil associé à l'identifiant de connexion indiqué. .PP Si le préfixe tilde est «\ ~+\ », la valeur de la variable de l'interpréteur .SM \fBPWD\fP le remplace. Si le préfixe tilde est «\ ~\-\ », la valeur de la variable de l'interpréteur .SM \fBOLDPWD\fP, si existante, lui est substituée. Si les caractères à la suite du tilde dans le préfixe tilde représentent un nombre \fIN\fP 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 \fBdirs\fP 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 «\ +\ ». .PP Si l'identifiant de connexion est incorrect ou si le développement du tilde échoue, le mot est inchangé. .PP Chaque affectation de variable vérifie immédiatement la présence de préfixes tilde non protégés suivant un \fB:\fP ou le premier \fB=\fP. 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 .SM \fBPATH\fP, .SM \fBMAILPATH\fP et .SM \fBCDPATH\fP et l'interpréteur affectera la valeur développée. .SS "Remplacement des paramètres" .PP Le caractère «\ \fB$\fP\ » permet d'introduire le développement des paramètres, la substitution de commande ou le développement arithmétique. Le nom du paramètre ou du symbole à développer peut être encadré par des accolades facultatives mais permettant d'éviter le développement de la variable à partir de caractères la suivant immédiatement et qui pourraient être considérés comme appartenant à son nom. .PP Lorsque les accolades sont utilisées, l'accolade de fin correspondante est le premier caractère «\ \fB}\fP\ » ni protégé par une contre\-oblique, ni inclus dans une chaîne protégée, un développement arithmétique, une substitution de commande ou un développement des paramètres. .PP .PD 0 .TP ${\fIparamètre\fP} est remplacé par la valeur du \fIparamètre\fP. Les accolades sont nécessaires quand le \fIparamètre\fP est un paramètre positionnel ayant plusieurs chiffres, ou si le \fIparamètre\fP est suivi de caractères n'appartenant pas à son nom. .PD .PP Si le premier caractère du \fIparamètre\fP est un point d'exclamation (\fB!\fP), un niveau d'imbrication de variable est introduit. \fBBash\fP utilise la valeur de la variable formée par le reste du \fIparamètre\fP 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 \fIparamètre\fP lui\-même. On appelle ce mécanisme \fIle développement imbriqué\fP. Les exceptions à celui\-ci sont les développements de ${\fB!\fP\fIpréfixe\fP\fB*\fP} et de ${\fB!\fP\fInom\fP[\fI@\fP]} décrits ci\-dessous. Le point d'exclamation doit immédiatement suivre l'accolade ouvrante afin d'introduire l'imbrication. .PP Dans chacun des cas ci\-dessous, le \fImot\fP est soumis au développement du tilde, au développement des paramètres, à la substitution de commande et au développement arithmétique. .PP Quand il n'effectue pas de développement de sous\-chaîne, en utilisant les formes documentées ci\-dessous, \fBbash\fP teste si le paramètre est inexistant ou vide. L'absence de deux\-points induit un test sur la seule inexistence du paramètre.uand il n'effectue pas de développem .PP .PD 0 .TP ${\fIparamètre\fP\fB:\-\fP\fImot\fP} \fBUtilisation de valeur par défaut\fP. Si le \fIparamètre\fP est inexistant ou vide, le développement du \fImot\fP est substitué. Sinon, c'est la valeur du \fIparamètre\fP qui est substituée. .TP ${\fIparamètre\fP\fB:=\fP\fImot\fP} \fBAffectation de valeur par défaut\fP. Si le \fIparamètre\fP est inexistant ou vide, le développement du \fImot\fP lui est affecté. La valeur du \fIparamètre\fP est alors substitué. Les paramètres positionnels et spéciaux ne peuvent pas être affectés de cette façon. .TP ${\fIparamètre\fP\fB:?\fP\fImot\fP} \fBAffichage d'erreur si vide ou inexistant\fP. Si le \fIparamètre\fP est inexistant ou vide, le développement du \fImot\fP (ou un message approprié si aucun \fImot\fP 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 \fIparamètre\fP est substituée. .TP ${\fIparamètre\fP\fB:+\fP\fImot\fP} \fBUtilisation de valeur alternative\fP. Si le \fIparamètre\fP est vide ou inexistant, rien n'est substitué. Sinon le développement du \fImot\fP est substitué. .TP ${\fIparamètre\fP\fB:\fP\fIdébut\fP} .PD 0 .TP ${\fIparamètre\fP\fB:\fP\fIdébut\fP\fB:\fP\fIlongueur\fP} .PD \fBDéveloppement des sous\-chaînes\fP. Se développe pour fournir la sous\-chaîne de \fIlongueur\fP indiquée (en caractères) commençant au \fIdébut\fP. Si la \fIlongueur\fP est omise, fournit la sous\-chaîne commençant au caractère indiqué par \fIdébut\fP et s'étendant jusqu'à la fin du \fIparamètre\fP. La \fIlongueur\fP et le \fIdébut\fP sont des expressions arithmétiques (consultez .SM \fBÉVALUATION ARITHMÉTIQUE\fP ci\-dessous). Si le \fIdébut\fP est négatif, sa valeur est considérée à partir de la fin du contenu du \fIparamètre\fP. Les expressions arithmétiques commençant par un «\ \-\ » doivent être séparées par une espace des «\ :\ » (deux\-points) les précédant pour être distinguées du développement \fBUtilisation de valeur par défaut\fP. Si \fIlongueur\fP s'évalue en nombre négatif, et que \fIparamètre\fP n'est ni \fB@\fP ni un tableau indicé ou associatif, il est interprété comme un indice à partir de la fin de la valeur de \fIparamètre\fP plutôt que comme un nombre de caractères, et l'expansion est constituée des caractères entre les deux indices. Si le \fIparamètre\fP est \fB@\fP, le résultat correspond aux \fIlongueur\fP paramètres positionnels commençant au \fIdébut\fP. Si le \fIparamètre\fP est un nom de tableau indicé par @ ou *, le résultat est les \fIlongueur\fP éléments du tableau commençant à ${\fIparamètre\fP[\fIdébut\fP]}. Une valeur négative de \fIdébut\fP est prise relativement à la valeur maximum de l'indice du tableau considéré, augmentée de un. Le développement de sous\-chaîne s'applique aux tableaux associatifs. Remarquez qu'une valeur négative de \fIdébut\fP doit être séparée du deux\-points par au moins une espace pour éviter toute confusion avec le développement de «\ :\-\ ». L'indexation des sous\-chaînes débute à zéro, sauf pour les paramètres positionnels pour lesquels l'indexation commence à 1 par défaut. Si \fIdébut\fP est 0, et que les paramètres positionnels sont utilisés, la liste sera préfixée par \fB$0\fP. .TP ${\fB!\fP\fIpréfixe\fP\fB*\fP} .PD 0 .TP ${\fB!\fP\fIpréfixe\fP\fB@\fP} .PD \fBNoms correspondant au préfixe\fP. Se développe en noms des variables dont les noms commencent par \fIpréfixe\fP, séparés par le premier caractère de la variable spéciale .SM \fBIFS\fP. Si \fI@\fP est utilisé et que le développement apparaît entre guillemets doubles, chaque nom de variable se développe séparément. .TP ${\fB!\fP\fInom\fP[\fI@\fP]} .PD 0 .TP ${\fB!\fP\fInom\fP[\fI*\fP]} .PD \fBListe des clefs du tableau\fP. Si \fInom\fP est une variable de type tableau, elle se développe en liste des indices (clefs) du tableau affecté à \fInom\fP. Si \fInom\fP n'est pas un tableau, se développe en 0 si \fInom\fP existe et en vide sinon. Quand \fI@\fP est utilisé et que le développement apparaît entre guillemets doubles, chaque clef se développe en un mot séparé. .TP ${\fB#\fP\fIparamètre\fP} \fBLongueur du paramètre\fP. Est remplacé par la longueur, en caractères, de la valeur du \fIparamètre\fP. Si le \fIparamètre\fP est \fB*\fP ou \fB@\fP, la valeur est le nombre de paramètres positionnels. Si le \fIparamètre\fP est un nom de tableau indicé par \fB*\fP ou \fB@\fP, la valeur donnée est le nombre d'éléments du tableau. .TP ${\fIparamètre\fP\fB#\fP\fImot\fP} .PD 0 .TP ${\fIparamètre\fP\fB##\fP\fImot\fP} .PD \fBRetrait du motif correspondant au préfixe\fP. Le \fImot\fP est développé pour fournir un motif, comme dans le développement des chemins. Si le motif correspond au début de la valeur du \fIparamètre\fP, alors le développement prend la valeur développée du \fIparamètre\fP après suppression du plus court (cas «\ \fB#\fP\ ») ou du plus long (cas «\ \fB##\fP\ ») motif correspondant. Si le \fIparamètre\fP est \fB@\fP ou \fB*\fP, l'opération de suppression de motif est appliquée à chaque paramètre positionnel tour à tour et le développement est la liste résultante. Si le \fIparamètre\fP est une variable tableau indicée par \fB@\fP ou \fB*\fP, l'opération de suppression de motif est appliquée à chaque élément du tableau tour à tour et le développement est la liste résultante. .TP ${\fIparamètre\fP\fB%\fP\fImot\fP} .PD 0 .TP ${\fIparamètre\fP\fB%%\fP\fImot\fP} .PD \fBRetrait du motif correspondant au suffixe\fP. Le \fImot\fP est développé pour fournir un motif, comme dans le développement des chemins. Si le motif correspond à une portion finale de la valeur développée du \fIparamètre\fP, alors le développement prend la valeur développée du \fIparamètre\fP après suppression du plus court (cas «\ \fB%\fP\ ») ou du plus long (cas «\ \fB%%\fP\ ») motif correspondant. Si le \fIparamètre\fP est \fB@\fP ou \fB*\fP, l'opération de suppression de motif est appliquée à chaque paramètre positionnel tour à tour et le développement est la liste résultante. Si le \fIparamètre\fP est une variable tableau indicée par \fB@\fP ou \fB*\fP, l'opération de suppression de motif est appliquée à chaque élément du tableau tour à tour et le développement est la liste résultante. .TP ${\fIparamètre\fP\fB/\fP\fImotif\fP\fB/\fP\fIchaîne\fP} \fBSubstitution de motif\fP. Le \fImotif\fP est développé comme dans le traitement des chemins. Le \fIparamètre\fP est développé et la plus longue portion correspondant au \fImotif\fP est remplacée par la \fIchaîne\fP. Si le \fImotif\fP commence par \fB/\fP, toutes les correspondances au \fImotif\fP sont remplacées par la \fIchaîne\fP. Normalement, seule la première correspondance est remplacée. Si le \fImotif\fP commence par \fB#\fP, il doit correspondre au début de la valeur développée du \fIparamètre\fP. Si le \fImotif\fP commence par \fB%\fP, il doit correspondre à la fin du développement du \fIparamètre\fP. Si la \fIchaîne\fP est vide, les portions correspondant au \fImotif\fP sont supprimées et le \fB/\fP suivant le \fImotif\fP peut être omis. Si le \fIparamètre\fP est \fB@\fP ou \fB*\fP, l'opération de substitution est appliquée à chacun des paramètres positionnels tour à tour et le développement est la liste résultante. Si le \fIparamètre\fP est une variable tableau indicée par \fB@\fP ou \fB*\fP, l'opération de substitution s'applique à chaque élément du tableau tour à tour et le développement est la liste résultante. .TP ${\fIparamètre\fP\fB^\fP\fImotif\fP} .PD 0 .TP ${\fIparamètre\fP\fB^^\fP\fImotif\fP} .TP ${\fIparamètre\fP\fB,\fP\fImotif\fP} .TP ${\fIparamètre\fP\fB,,\fP\fImotif\fP} .PD \fBModification de la casse\fP. Ce développement modifie la casse des caractères alphabétiques du \fIparamètre\fP. Le \fImottif\fP est développé pour fournir un motif, comme dans le développement des chemins. L'opérateur \fB^\fP convertit les lettre minuscules correspondant à ce \fImotif\fP en majuscule\ ; l'opérateur \fB,\fP convertit les lettre majuscules correspondant à ce \fImotif\fP en minuscule. Les développements \fB^^\fP et \fB,,\fP convertissent tous les caractères correspondant à leur valeur développée\ ; les développements \fB^\fP et \fB,\fP convertissent seulement le premier caractère de la valeur développée correspondant. Si \fImotif\fP est omis, il est traité comme un \fB?\fP, ce qui correspond à n'importe quel caractère. Si le \fIparamètre\fP est \fB@\fP ou \fB*\fP, la modification de casse s'applique à chaque paramètre positionnel tour à tour et le développement est la liste résultante. Si le \fIparamètre\fP est une variable tableau indicée par \fB@\fP ou \fB*\fP, la modification de casse s'applique à chaque élément du tableau tour à tour et le développement est la liste résultante. .SS "Substitution de commande" .PP La \fIsubstitution de commande\fP permet de remplacer le nom d'une commande par son résultat. Il en existe deux formes\ : .RS .PP \fB$(\fP\fIcommande\fP\|\fB)\fP .RE ou .RS \fB\`\fP\fIcommande\fP\fB\`\fP .RE .PP \fBBash\fP effectue la substitution en exécutant la \fIcommande\fP et en la remplaçant par sa sortie standard, dont les éventuels sauts de lignes finaux sont supprimés. Les changements de ligne internes ne sont pas supprimés mais peuvent disparaître lors du découpage en mots. La substitution de commande \fB$(cat \fP\fIfichier\fP\fB)\fP peut être remplacée par l'équivalent plus rapide \fB$(< \fP\fIfichier\fP\fB)\fP. .PP Quand l'ancienne forme de substitution avec les accents graves «\ \`\ » est utilisée, le caractère contre\-oblique garde sa signification propre sauf lorsqu'il est suivi de \fB$\fP, \fB\`\fP ou \fB\e\fP. Le premier accent grave non protégé par une contre\-oblique termine la substitution de commande. Quand on utilise la forme $(\^\fIcommande\fP\|), tous les caractères entre parenthèses constituent la commande\ ; aucun n'est traité spécifiquement. .PP 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. .PP 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. .SS "Développement arithmétique" .PP 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\ : .RS .PP \fB$((\fP\fIexpression\fP\fB))\fP .RE .PP L'ancien format \fB$[\fP\fIexpression\fP\fB]\fP est obsolète et sera supprimé dans les prochaines versions de bash. .PP L'\fIexpression\fP 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. .PP L'évaluation est effectuée en suivant les règles décrites ci\-dessous dans .SM \fBÉVALUATION ARITHMÉTIQUE\fP. Si l'\fIexpression\fP est incorrecte, \fBbash\fP affiche un message indiquant l'échec et aucune substitution n'a lieu. .SS "Substitution de processus" .PP La \fIsubstitution de processus\fP n'est disponible que sur les systèmes acceptant le mécanisme des tubes nommés (\fIFIFO\fP) ou la méthode \fB/dev/fd\fP de noms de fichiers. Elle prend la forme \fB<(\fP\fIliste\^\fP\fB)\fP ou \fB>(\fP\fIliste\^\fP\fB)\fP. La \fIliste\fP de processus est exécutée avec son entrée ou sa sortie connectée à une \fIFIFO\fP ou à un fichier dans \fB/dev/fd\fP. 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 \fB>(\fP\fIliste\^\fP\fB)\fP, l'écriture dans le fichier fournira des entrées pour la \fIliste\fP. Si la forme \fB<(\fP\fIliste\^\fP\fB)\fP est utilisée, le fichier passe en argument devra être lu pour obtenir la sortie de la \fIliste\fP. .PP 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. .SS "Découpage en mots" .PP 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 \fIdécoupage en mots\fP. .PP L'interpréteur considère chaque caractère du paramètre .SM \fBIFS\fP comme un délimiteur et découpe le résultat des transformations précédentes en fonction de ceux\-ci. Si .SM \fBIFS\fP est inexistante ou si sa valeur est exactement \fB\fP, la valeur par défaut, alors les suites de caractères \fB\fP, \fB\fP et \fB\fP au début ou à la fin du résultat des développements précédents sont ignorés, et toute suite de caractères de .SM \fBIFS\fP ni au début ni à la fin sert à délimiter les mots. Si .SM \fBIFS\fP a une valeur autre que celle par défaut, alors les suites de caractères blancs \fBespace\fP et \fBtabulation\fP sont ignorées en début et fin de mot, à condition que ces caractères blancs se trouvent dans la valeur de .SM \fBIFS\fP (un caractère blanc de .SM \fBIFS\fP). Tout caractère de .SM \fBIFS\fP qui n'est pas un caractère blanc, se trouvant à côté d'un caractère blanc de .SM \fBIFS\fP, délimite un champ. Une suite de caractères blancs de .SM \fBIFS\fP est également traitée comme un délimiteur. Si la valeur de .SM \fBIFS\fP est vide, aucun découpage en mots n'a lieu. .PP Les arguments vides explicites (\^\fB"\^"\fP ou \^\fB\(aq\^\(aq\fP\^) 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é. .PP Remarquez que si aucun développement n'a lieu, le découpage en mots n'est pas effectué. .SS "Développement des chemins" .PP Après le découpage en mots, à moins que l'option \fB\-f\fP soit présente, \fBbash\fP recherche dans chaque mot les caractères \fB*\fP, \fB?\fP et \fB[\fP. Si l'un d'eux apparaît, le mot est considéré comme un \fImotif\fP et remplacé par une liste, classée par ordre alphabétique, des noms de fichiers correspondant à ce motif. Si aucun nom de fichier ne correspond et si l'option d'interpréteur \fBnullglob\fP n'est pas activée, le mot reste inchangé. Si l'option \fBnullglob\fP existe et si aucune correspondance n'est trouvée, le mot est supprimé. Si l'option d'interpréteur \fBfailglob\fP existe et si aucune correspondance n'est trouvée, un message d'erreur est affiché et la commande n'est pas exécutée. Si l'option d'interpréteur \fBnocaseglob\fP est activée, la correspondance est effectuée sans tenir compte de la casse des caractères alphabétiques. Remarquez que lorsque des expressions de plage comme [a\-z] (voir ci\-dessous) sont utilisées les lettres de l'autre casse peuvent être incluses, selon le paramétrage de \fBLC_COLLATE\fP. Quand un motif est utilisé pour le développement des chemins, le caractère \fB«\ .\ »\fP au début d'un nom ou immédiatement à la suite d'une barre oblique doit être explicitement mis en correspondance, à moins que l'option d'interpréteur \fBdotglob\fP n'existe. Lors de la correspondance avec un chemin, le caractère barre oblique doit toujours être mis en correspondance explicitement. Dans les autres cas, le caractère \fB«\ .\ »\fP n'est pas traité spécifiquement. Voyez la description de la commande \fBshopt\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP pour une description des options d'interpréteur \fBnocaseglob\fP, \fBnullglob\fP, \fBfailglob\fP et \fBdotglob\fP. .PP La variable de l'interpréteur .SM \fBGLOBIGNORE\fP peut servir à restreindre l'ensemble des noms de fichiers correspondant à un \fImotif\fP. Si .SM \fBGLOBIGNORE\fP existe, chaque nom de fichier qui correspond aussi à un motif de .SM \fBGLOBIGNORE\fP est supprimé de la liste des correspondances. Les noms de fichiers \fB«\ .\ »\fP et \fB«\ ..\ »\fP sont toujours ignorés quand .SM \fBGLOBIGNORE\fP existe et n'est pas vide. Toutefois, configurer .SM \fBGLOBIGNORE\fP avec une valeur non vide a pour effet d'activer l'option d'interpréteur \fBdotglob\fP, ainsi tous les autres noms de fichiers commençant par \fB«\ .\ »\fP correspondront. Pour obtenir l'ancien comportement ignorant les noms commençant par \fB«\ .\ »\fP, placez \fB«\ .*\ »\fP dans l'un des motifs de .SM \fBGLOBIGNORE\fP. L'option \fBdotglob\fP est désactivée si la variable .SM \fBGLOBIGNORE\fP est inexistante. .PP \fBMotifs génériques\fP .PP Tout caractère apparaissant dans un motif, hormis les caractères spéciaux décrits ci\-dessous 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. .PP Les caractères spéciaux ont les significations suivantes\ : .PP .PD 0 .RS .TP \fB*\fP Correspond à n'importe quel chaîne, chaîne vide comprise. Si l'option \fBglobstar\fP de l'interpréteur est activée, et que \fB*\fP est utilisé dans un contexte de développement des chemins, deux \fB*\fP adjacents sont utilisés pour un seul motif correspondant à tous les fichier et zéro ou plus de répertoires et sous\-répertoires. Lorsqu'il sont suivis de \fB/\fP, deux \fB*\fP adjacents correspondront seulement aux répertoires et sous\-répertoires. .TP \fB?\fP Correspond à n'importe quel caractère. .TP \fB[...]\fP Correspond à tout caractère entre les crochets. Un couple de caractères séparés par un trait d'union indique une \fIexpression de plage\fP\ ; 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 actuels et le jeu de caractères. Si le premier caractère suivant le \fB[\fP est un \fB!\fP ou un \fB^\fP 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 actuels et par la valeur de la variable de l'interpréteur .SM \fBLC_COLLATE\fP si existante. Un \fB\-\fP peut être mis en correspondance en l'incluant en premier ou dernier caractère de l'ensemble. Un \fB]\fP peut être mis en correspondance en l'incluant en premier caractère de l'ensemble. .br .if t .sp 0.5 .if n .sp 1 Entre \fB[\fP et \fB]\fP, on peut indiquer une \fIclasse de caractère\fP en utilisant la syntaxe \fB[:\fP\fIclasse\fP\fB:]\fP, où \fIclasse\fP est l'une des classes suivantes, définies dans le standard POSIX\ : .PP .RS .B .if n alnum alpha ascii blank cntrl digit graph lower print punct space upper word xdigit .if t alnum alpha ascii blank cntrl digit graph lower print punct space upper word xdigit .br Une classe correspond à n'importe quel caractère qui s'y trouve. La classe de caractères \fBword\fP correspond aux lettres, aux chiffres et au caractère souligné «\ _\ ». .br .if t .sp 0.5 .if n .sp 1 Entre \fB[\fP et \fB]\fP, on peut indiquer une \fIclasse d'équivalence\fP en utilisant la syntaxe \fB[=\fP\fIc\fP\fB=]\fP, qui correspond à n'importe quel caractère ayant le même poids de collation (comme indiqué par les paramètres linguistiques régionaux actuels) que le caractère \fIc\fP. .br .if t .sp 0.5 .if n .sp 1 Entre \fB[\fP et \fB]\fP, la syntaxe \fB[.\fP\fIsymbole\fP\fB.]\fP correspond au symbole de collation \fIsymbole\fP. .RE .RE .PD .PP Si l'option \fBextglob\fP d'interpréteur est activée par la commande interne \fBshopt\fP plusieurs opérateurs de correspondance étendue sont reconnus. Dans la description suivante, une \fIliste\-motif\fP est une liste d'un ou plusieurs motifs séparés par des \fB|\fP. Les motifs composés sont formés en utilisant un ou plusieurs sous\-motifs comme suit\ : .sp 1 .PD 0 .RS .TP \fB?(\fP\^\fIliste\-motif\^\fP\fB)\fP Correspond à zéro ou une occurrence des motifs indiqués. .TP \fB*(\fP\^\fIliste\-motif\^\fP\fB)\fP Correspond à zéro ou plusieurs occurrences des motifs indiqués. .TP \fB+(\fP\^\fIliste\-motif\^\fP\fB)\fP Correspond à une ou plusieurs occurrences des motifs indiqués. .TP \fB@(\fP\^\fIliste\-motif\^\fP\fB)\fP Correspond à une occurrence exactement des motifs indiqués. .TP \fB!(\fP\^\fIliste\-motif\^\fP\fB)\fP Correspond à tout sauf l'un des motifs indiqués. .RE .PD .SS "Suppression des protections" .PP Après les développements précédents, toutes les occurrences non protégées des caractères \fB\e\fP, \fB\(aq\fP et \^\fB"\fP\^ qui ne résultent pas d'un des développements ci\-dessus sont supprimées. .SH REDIRECTIONS Avant qu'une commande ne soit exécutée, il est possible de \fIrediriger\fP 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 actuel de l'interpréteur. Les opérateurs de redirection suivants peuvent précéder ou apparaître n'importe où dans une \fIcommande simple\fP ou suivre une \fIcommande\fP. Les redirections sont traitées dans leur ordre d'apparition, de gauche à droite. .PP Toutes les redirections pouvant être précédées par un numéro de descripteur de fichier peuvent aussi être précédées par un mot de la forme {\fInom_de_variable\fP}. Dans ce cas, pour chaque opérateur de redirection à part >&\- et <&\-, l'interpréteur de commande allouera un descripteur de fichier supérieur à 10 et l'affectera à \fInom_de_variable\fP. Si >&\- ou <&\- est précédé de {\fInom_de_variable\fP}, la valeur de \fInom_de_variable\fP définit le descripteur de fichier à fermer. .PP 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 \fB<\fP, la redirection se rapporte à l'entrée standard (descripteur de fichier 0). Si le premier caractère de l'opérateur de redirection est \fB>\fP, la redirection se rapporte à la sortie standard (descripteur de fichier 1). .PP 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, \fBbash\fP signale une erreur. .PP Remarquez que l'ordre des redirections est important. Par exemple, la commande .RS .PP ls \fB>\fP liste_répertoires 2\fB>&\fP1 .RE .PP redirige à la fois la sortie standard et la sortie d'erreur standard vers le fichier \fIliste_répertoires\fP, alors que la commande .RS .PP ls 2\fB>&\fP1 \fB>\fP liste_répertoires .RE .PP ne redirige que la sortie standard vers le fichier \fIliste_répertoires\fP, car la sortie d'erreur standard a été dupliquée de la sortie standard avant que celle\-ci ne soit redirigée vers \fIliste_répertoires\fP. .PP \fBBash\fP 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\ : .RS .PP .PD 0 .TP \fB/dev/fd/\fP\fIfd\fP Si \fIfd\fP est un entier correct, le descripteur de fichier \fIfd\fP est dupliqué. .TP \fB/dev/stdin\fP Le descripteur de fichier 0 est dupliqué. .TP \fB/dev/stdout\fP Le descripteur de fichier 1 est dupliqué. .TP \fB/dev/stderr\fP Le descripteur de fichier 2 est dupliqué. .TP \fB/dev/tcp/\fP\fIhost\fP\fB/\fP\fIport\fP Si \fIhost\fP est une adresse Internet ou un nom de machine correct et si \fIport\fP est un numéro de port entier ou un nom de service, \fBbash\fP tentera d'ouvrir une connexion TCP sur la «\ socket\ » correspondante. .TP \fB/dev/udp/\fP\fIhost\fP\fB/\fP\fIport\fP Si \fIhost\fP est un nom de machine correct ou une adresse Internet et si \fIport\fP est un numéro de port entier ou un nom de service, \fBbash\fP tentera d'ouvrir une connexion UDP sur la «\ socket\ » correspondante. .PD .RE .PP Un échec à l'ouverture ou à la création de fichier conduit à l'échec de la redirection. .PP Les redirections utilisant des descripteurs de fichiers supérieurs à 9 doivent être utilisées avec précaution car des conflits peuvent survenir avec les descripteurs de fichiers utilisés en interne par l'interpréteur. .PP Notez que la commande interne \fBexec\fP peut faire appliquer les redirections à l'interpréteur de commande en cours. .SS "Redirection d'entrée" .PP Une redirection d'entrée conduit à l'ouverture en lecture avec le descripteur de fichier numéro \fIn\fP du fichier dont le nom résulte du développement du \fImot\fP ou en tant qu'entrée standard (descripteur de fichier 0) si \fIn\fP n'est pas indiqué. .PP Le format général des redirections d'entrée est\ : .RS .PP [\fIn\fP]\fB<\fP\fImot\fP .RE .SS "Redirection de sortie" .PP Une redirection de sortie conduit à l'ouverture en écriture du fichier dont le nom résulte du développement du \fImot\fP avec comme descripteur de fichier \fIn\fP ou en tant que sortie standard (descripteur de fichier 1) si \fIn\fP n'est pas indiqué. Si le fichier n'existe pas, il est créé. S'il existait déjà, sa taille est réduite à zéro. .PP Le format général des redirections de sortie est le suivant\ : .RS .PP [\fIn\fP]\fB>\fP\fImot\fP .RE .PP Si l'opérateur de redirection est \fB>\fP et si l'option \fBnoclobber\fP de la commande interne \fBset\fP est activée, la redirection échouera si le fichier dont le nom résulte du développement du \fImot\fP existe et est un fichier normal. Si l'opérateur de redirection est \fB>|\fP ou l'opérateur \fB>\fP avec l'option \fBnoclobber\fP de la commande interne \fBset\fP n'est pas activée, la redirection sera tentée même si le fichier dont le nom résulte du développement du \fImot\fP existe. .SS "Ajout d'une sortie redirigée" .PP La redirection de la sortie de cette façon conduit à l'ouverture du fichier dont le nom résulte du développement du \fImot\fP pour ajouter au descripteur de fichier \fIn\fP ou à la sortie standard (descripteur de fichier 1) si \fIn\fP n'est pas indiqué. Si le fichier n'existe pas, il est créé. .PP Le format général pour les sorties avec ajout est\ : .RS .PP [\fIn\fP]\fB>>\fP\fImot\fP .RE .PP .SS "Redirection de la sortie standard et de la sortie d'erreur standard" .PP Cette construction permet la redirection simultanée de la sortie standard (descripteur 1) et de la sortie d'erreur standard (descripteur 2), dans un fichier dont le nom est le résultat du développement du \fImot\fP. .PP Il y a deux formes pour rediriger les sortie standard et sortie d'erreur standard\ : .RS .PP \fB&>\fP\fImot\fP .RE et .RS \fB>&\fP\fImot\fP .RE .PP La première des deux formes est préférée. C'est sémantiquement équivalent à .RS .PP \fB>\fP\fImot\fP 2\fB>&\fP1 .RE .PP .SS "Ajout de la sortie standard et de la sortie d'erreur standard" .PP Cette construction permet l'ajout simultané de la sortie standard (descripteur 1) et de la sortie d'erreur standard (descripteur 2), dans un fichier dont le nom est le résultat du développement du \fImot\fP. .PP La forme pour ajouter les sortie standard et sortie d'erreur standard est\ : .RS .PP \fB&>>\fP\fImot\fP .RE .PP C'est sémantiquement équivalent à .RS .PP \fB>>\fP\fImot\fP 2\fB>&\fP1 .RE .SS "Document en ligne" .PP Ce type de redirection commande à l'interpréteur de lire son entrée de la source actuelle jusqu'à ce qu'il voie une ligne contenant seulement le \fIdélimiteur\fP prévu (sans blancs finaux). Toutes les lignes lues jusqu'à ce point sont ensuite utilisées comme l'entrée standard pour une commande. .PP Le format des documents en ligne est le suivant\ : .RS .PP .nf \fB<<\fP[\fB\-\fP]\fImot\fP \fIdocument_en_ligne\fP \fIdélimiteur\fP .fi .RE .PP Il n'y a ni développement des paramètres, ni substitution de commande, ni développement arithmétique, ni développement des chemins d'effectué sur le \fImot\fP. Si un n'importe quel caractère du \fImot\fP est protégé, \fIdélimiteur\fP est le résultat de la suppression des protections sur \fImot\fP et les lignes du document en ligne ne sont pas développées. Si le \fImot\fP n'est pas protégé, toutes les lignes du document en ligne sont soumises au développement des paramètres, à la substitution de commande et au développement arithmétique. Dans ce dernier cas, la suite de caractères \fB\e\fP est ignorée et \fB\e\fP doit être utilisée pour protéger les caractères \fB\e\fP, \fB$\fP et \fB\`\fP. .PP Si l'opérateur de redirection est \fB<<\-,\fP alors les tabulations en tête de chaque ligne sont supprimées de l'entrée, y compris dans la ligne contenant \fIdélimiteur\fP. Cela permet d'indenter de façon naturelle les documents en ligne au sein des scripts. .SS "Chaînes en ligne" Une variante aux documents en ligne, le format est\ : .RS .PP .nf \fB<<<\fP\fImot\fP .fi .RE .PP Le \fImot\fP est développé et fourni à la commande sur son entrée standard. .SS "Dédoublement de descripteur de fichier" .PP L'opérateur de redirection .RS .PP [\fIn\fP]\fB<&\fP\fImot\fP .RE .PP permet de dupliquer les descripteurs de fichiers en entrée. Si le \fImot\fP se transforme en un ou plusieurs chiffres, le descripteur de fichier noté par \fIn\fP devient une copie de ce descripteur. Si les chiffres du \fImot\fP ne correspondent pas à un descripteur ouvert en lecture, une erreur de redirection se produit. Si le \fImot\fP prend la forme \fB\-\fP, le descripteur \fIn\fP est fermé. Si \fIn\fP n'est pas mentionné, l'entrée standard (descripteur 0) est utilisée. .PP L'opérateur .RS .PP [\fIn\fP]\fB>&\fP\fImot\fP .RE .PP est utilisé de façon similaire pour dupliquer les descripteurs de sortie. Si \fIn\fP n'est pas explicité, la sortie standard (descripteur 1) est utilisée. Si les chiffres du \fImot\fP ne correspondent pas à un descripteur en écriture, une erreur de redirection se produit. Dans le cas particulier où \fIn\fP est omis et où \fImot\fP 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. .SS "Déplacement de descripteurs de fichiers" .PP L'opérateur de redirection .RS .PP [\fIn\fP]\fB<&\fP\fIchiffre\fP\fB\-\fP .RE .PP déplace le descripteur de fichier \fIchiffre\fP vers le descripteur de fichier \fIn\fP ou sur l'entrée standard (descripteur de fichier 0) si \fIn\fP n'est pas indiqué. \fIchiffre\fP est fermé après avoir été dupliqué en \fIn\fP. .PP De la même façon, l'opérateur de redirection .RS .PP [\fIn\fP]\fB>&\fP\fIchiffre\fP\fB\-\fP .RE .PP déplace le descripteur de fichier \fIchiffre\fP vers le descripteur de fichier \fIn\fP ou sur la sortie standard (descripteur de fichier 1) si \fIn\fP n'est pas indiqué. .SS "Ouverture en Lecture/Écriture d'un descripteur de fichier" .PP L'opérateur de redirection .RS .PP [\fIn\fP]\fB<>\fP\fImot\fP .RE .PP conduit à l'ouverture du fichier dont le nom résulte du développement du \fImot\fP, à la fois en lecture et en écriture et lui affecte le descripteur de fichier \fIn\fP ou bien le descripteur 0 si \fIn\fP n'est pas mentionné. Si le fichier n'existe pas, il est créé. .SH ALIAS Les \fIalias\fP permettent de substituer une chaîne à un mot lorsqu'il est utilisé comme premier mot d'une commande simple. L'interpréteur gère une liste d'alias qui peuvent être créés et détruits avec les commandes internes \fBalias\fP et \fBunalias\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). L'interpréteur vérifie si le premier mot de chaque commande simple, si non protégé, est un alias. Si c'est le cas, ce mot est remplacé par le texte de l'alias. Les caractères \fB/\fP, \fB$\fP, \fB\`\fP et \fB=\fP et tout \fImétacaractère\fP de l'interpréteur ou caractère de protection décrits ci\-dessus ne peuvent pas apparaître dans un nom d'alias. Le texte de remplacement peut contenir toute entrée correcte pour l'interpréteur, y compris les métacaractères de l'interpréteur. L'interpréteur vérifie si le premier mot du texte de remplacement est à son tour un alias, mais un mot identique à un alias en cours de développement n'est pas développé une seconde fois. Cela signifie qu'on peut, par exemple, créer un alias \fBls\fP valant \fBls \-F\fP et \fBbash\fP n'essaiera pas de développer récursivement le texte de substitution. Si le dernier caractère de la valeur de l'alias est un \fIblanc\fP, alors le prochain mot de commande suivant l'alias connaîtra aussi le développement d'alias. .PP Les alias sont créés et affichés avec la commande \fBalias\fP et supprimés avec la commande \fBunalias\fP. .PP 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 (consultez .SM \fBFONCTIONS\fP ci\-dessous). .PP Les alias ne sont pas développés quand l'interpréteur n'est pas interactif sauf si l'option \fBexpand_aliases\fP de l'interpréteur est créée par la commande \fBshopt\fP (consultez la description de \fBshopt\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .PP Les règles concernant la définition et l'utilisation des alias sont un peu confuses. \fBBash\fP lit toujours au moins une ligne d'entrée complètement avant d'exécuter une des commandes de cette ligne. Les alias sont traités lorsque la commande est lue et non pas lorsqu'elle est exécutée. Ainsi, une définition d'alias apparaissant sur la même ligne qu'une autre commande ne prend pas effet avant la lecture de la prochaine ligne d'entrée. Autrement dit, une commande placée à la suite d'une définition d'alias, sur la même ligne ne sera pas affectée par cet alias. Ce comportement est également important lors de l'exécution des fonctions. Les alias sont traités lorsque la définition de la fonction est lue et non pas lors de l'exécution de cette fonction. Ainsi des alias définis dans une fonction ne sont pas disponibles avant la fin de l'exécution de la fonction. Pour plus de tranquillité, placez toujours les définitions d'alias sur des lignes isolées et n'utilisez jamais la commande \fBalias\fP dans les commandes composées. .PP Les alias sont surpassés par les fonctions de l'interpréteur dans la plupart des situations. .SH FONCTIONS Une fonction de l'interpréteur, définie comme décrit ci\-dessus, dans .SM \fBGRAMMAIRE DE L'INTERPRÉTEUR\fP, 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 actuel\ ; 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 \fB#\fP est mis à jour en conséquence. Le paramètre spécial \fB0\fP reste inchangé. Le premier élément de la variable .SM \fBFUNCNAME\fP contient le nom de la fonction pendant son exécution. .PP Tous les autres aspects de l'environnement d'exécution de l'interpréteur sont identiques entre la fonction et le contexte d'appel, aux exceptions suivantes\ : les captures de .SM \fBDEBUG\fP et \fBRETURN\fP (consultez la description de la commande interne \fBtrap\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous) ne sont pas héritées, à moins que l'attribut \fBtrace\fP ne soit positionné pour la fonction (consultez la description de la commande interne .SM \fBdeclare\fP ci\-dessous) ou que l'option d'interpréteur \fB\-o functrace\fP n'ait été activée avec la commande interne \fBset\fP (auquel cas toutes les fonctions hériteront des captures de \fBDEBUG\fP et \fBRETURN\fP), et la capture .SM \fBERR\fP n'est pas héritée à moins que l'option d'interpréteur \fB\-o errtrace\fP n'ait été activée. .PP Les variables locales d'une fonction peuvent être déclarées avec la commande interne \fBlocal\fP. Dans le cas général, les variables et leurs valeurs sont partagées entre la fonction et le contexte d'appel. .PP La variable \fBFUNCNEST\fP, si configurée à une valeur numérique strictement positive, définit le niveau maximal d'imbrication de fonctions. Les invocations de fonctions qui dépassent la limite forceront toute la commande à abandonner. .PP Si la commande interne \fBreturn\fP 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 \fBRETURN\fP 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 \fB#\fP reprennent les valeurs qu'ils avaient avant l'appel de la fonction. .PP Les noms de fonctions et leurs définitions peuvent être affichés avec l'option \fB\-f\fP des commandes internes \fBdeclare\fP ou \fBtypeset\fP. Les options \fB\-F\fP de \fBdeclare\fP ou \fBtypeset\fP n'afficheront que les noms de fonctions (et facultativement le fichier source et le numéro de ligne, si l'option d'interpréteur \fBextdebug\fP est activée). Les fonctions peuvent être exportées avec l'option \fB\-f\fP de la commande interne \fBexport\fP, afin d'être automatiquement définies dans les sous\-interpréteurs. Une définition de fonction peut être supprimée avec l'option \fB\-f\fP de la commande interne \fBunset\fP. 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. .PP Les fonctions peuvent être récursives. La variable \fBFUNCNEST\fP peut être utilisée pour limiter la profondeur de la pile d'appel de la fonction et restreindre le nombre d'invocations de fonctions. Par défaut, aucune limite n'est imposée quant au nombre d'appels récursifs. .SH "ÉVALUATION ARITHMÉTIQUE" L'interpréteur permet, dans certaines circonstances, l'évaluation d'expressions arithmétiques (consultez les commandes internes \fBlet\fP et \fBdeclare\fP ainsi que \fBDéveloppement arithmétique\fP). 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. .PP .PD 0 .TP \fIid\fP\fB++ \fP\fIid\fP\fB\-\-\fP post\-incrément et post\-décrément de variables .TP \fB++\fP\fIid\fP\fB \-\-\fP\fIid\fP pré\-incrément et pré\-décrément de variables .TP \fB\- +\fP moins et plus unaires .TP \fB! ~\fP négations logique et binaire .TP \fB**\fP exponentiation .TP \fB* / %\fP multiplication, division, reste .TP \fB+ \-\fP addition, soustraction .TP \fB<< >>\fP décalage arithmétique à gauche et à droite .TP \fB<= >= < >\fP comparaisons .TP \fB== !=\fP égalité et différence .TP \fB&\fP ET binaire .TP \fB^\fP OU exclusif binaire .TP \fB|\fP OU binaire .TP \fB&&\fP ET logique .TP \fB||\fP OU logique .TP \fIexpr\fP\fB?\fP\fIexpr\fP\fB:\fP\fIexpr\fP opérateur conditionnel .TP \fB= *= /= %= += \-= <<= >>= &= ^= |=\fP affectations .TP \fIexpr1\fP\fB , \fP\fIexpr2\fP virgule .PD .PP Les variables de l'interpréteur sont utilisables comme opérandes, le développement des paramètres étant effectué avant l'évaluation arithmétique. Dans une expression, les variables de l'interpréteur peuvent également être référencées par leur nom, sans utiliser la syntaxe de développement des paramètres. Une variable d'interpréteur vide ou inexistante est évaluée à 0 lorsqu'elle est consultée par son nom sans utiliser la syntaxe de développement des paramètres. La valeur d'une variable est évaluée comme une expression arithmétique lorsqu'elle est consultée, ou lorsqu'une valeur lui est affecté alors que son attribut \fIinteger\fP (entier) a été positionné en utilisant \fBdeclare \-i\fP. Une valeur vide est évaluée à 0. Une variable d'interpréteur n'a donc pas besoin d'avoir son attribut \fIinteger\fP positionné pour être utilisable dans un calcul. .PP Les constantes commençant par 0 sont interprétées comme des nombres octaux. Un en\-tête 0x ou 0X indique une valeur hexadécimale. Sinon, les nombres ont la forme [\fIbase#\fP]n où la \fIbase\fP facultative est un nombre décimal entre 2 et 64 représentant la base arithmétique et \fIn\fP est un nombre exprimé dans cette base. Si la \fIbase#\fP 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 \fIbase\fP est inférieure ou égale à 36 les minuscules et les majuscules sont interchangeables pour représenter les nombres entre 10 et 35. .PP 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. .SH CONDITIONS Les conditions sont utilisées par la commande composée \fB[[\fP et les commandes internes \fBtest\fP et \fB[\fP pour vérifier l'état d'un fichier et effectuer des comparaisons arithmétiques ou sur des chaînes. Les conditions se forment à partir des primitives unaires ou binaires suivantes. Si n'importe quel argument \fIfichier\fP de l'une des primitives est de la forme \fI/dev/fd/n\fP, alors le descripteur de fichier \fIn\fP est examiné. Si l'argument \fIfichier\fP de l'une des primitives est parmi \fI/dev/stdin\fP, \fI/dev/stdout\fP ou \fI/dev/stderr\fP, le descripteur de fichier 0, 1 ou 2, respectivement, est examiné. .PP 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. .if t .sp 0.5 .if n .sp 1 Lorsqu'ils sont utilisés avec \fB[[\fP, les opérateurs \fB<\fP et \fB>\fP ordonnent d'un point de vue lexicographique en utilisant les paramètres linguistiques régionaux actuels. La commande \fBtest\fP trie en utilisant l'ordre ASCII. .sp 1 .PD 0 .TP \fB\-a \fP\fIfichier\fP Vrai si le \fIfichier\fP existe. .TP \fB\-b \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un fichier spécial bloc. .TP \fB\-c \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un fichier spécial caractère. .TP \fB\-d \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un répertoire. .TP \fB\-e \fP\fIfichier\fP Vrai si le \fIfichier\fP existe. .TP \fB\-f \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un fichier normal. .TP \fB\-g \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et a son bit Set\-GID positionné. .TP \fB\-h \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un lien symbolique. .TP \fB\-k \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et a son bit «\ sticky\ » positionné. .TP \fB\-p \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un tube nommé (FIFO). .TP \fB\-r \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est accessible en lecture. .TP \fB\-s \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et a une taille strictement positive. .TP \fB\-t \fP\fIfd\fP Vrai si le descripteur de fichier \fIfd\fP est ouvert et se rapporte à un terminal. .TP \fB\-u \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et a son bit Set\-UID positionné. .TP \fB\-w \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est accessible en écriture. .TP \fB\-x \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est exécutable. .TP \fB\-G \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et appartient au GID effectif du groupe. .TP \fB\-L \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est un lien symbolique. .TP \fB\-N \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et a été modifié depuis sa dernière lecture. .TP \fB\-O \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et appartient à l'UID effectif de l'utilisateur. .TP \fB\-S \fP\fIfichier\fP Vrai si le \fIfichier\fP existe et est une «\ socket\ ». .TP \fIfichier_1\fP \fB\-ef\fP \fIfichier_2\fP Vrai si le \fIfichier_1\fP et le \fIfichier_2\fP se rapportent au même périphérique et ont les mêmes numéros d'inœuds. .TP \fIfichier_1\fP \-\fBnt\fP \fIfichier_2\fP Vrai si le \fIfichier_1\fP est plus récent que le \fIfichier_2\fP (selon les dates de dernière modification) ou si \fIfichier_1\fP existe et non \fIfichier_2\fP. .TP \fIfichier_1\fP \-\fBot\fP \fIfichier_2\fP Vrai si le \fIfichier_1\fP est plus ancien que le \fIfichier_2\fP ou si \fIfichier_2\fP existe et non \fIfichier_1\fP. .TP \fB\-o \fP\fInom_opt\fP Vrai si l'option d'interpréteur \fInom_opt\fP est activée. Consulter la liste des options ci\-dessous dans la description de l'option \fB\-o\fP de la commande interne \fBset\fP. .TP \fB\-v\fP \fInom_de_variable\fP Vrai si la variable \fInom_de_variable\fP de l'interpréteur est configurée (si une valeur lui a été assignée). .TP \fB\-z \fP\fIchaîne\fP Vrai si la longueur de la \fIchaîne\fP est nulle. .TP \fIchaîne\fP .PD 0 .TP \fB\-n \fP\fIchaîne\fP .PD Vrai si la longueur de la \fIchaîne\fP est non nulle. .TP \fIchaîne_1\fP \fB==\fP \fIchaîne_2\fP .PD 0 .TP \fIchaîne_1\fP \fB=\fP \fIchaîne_2\fP .PD Vrai si les deux chaînes sont égales. Le symbole \fB=\fP devrait être utilisé avec la commande \fBtest\fP pour être en conformité POSIX. .TP \fIchaîne_1\fP \fB!=\fP \fIchaîne_2\fP Vrai si les deux chaînes sont différentes. .TP \fIchaîne_1\fP \fB<\fP \fIchaîne_2\fP Vrai si \fIchaîne_1\fP se trouve avant \fIchaîne_2\fP dans l'ordre lexicographique. .TP \fIchaîne_1\fP \fB>\fP \fIchaîne_2\fP Vrai si \fIchaîne_1\fP se trouve après \fIchaîne_2\fP dans l'ordre lexicographique. .TP \fIarg1 \fP\fBOP\fP\fI arg2\fP .SM \fBOP\fP est l'un des opérateurs suivants \fB\-eq\fP, \fB\-ne\fP, \fB\-lt\fP, \fB\-le\fP, \fB\-gt\fP ou \fB\-ge\fP. Ces opérateurs arithmétiques binaires renvoient vrai si \fIarg1\fP est respectivement égal, différent, inférieur, inférieur ou égal, supérieur, supérieur ou égal à \fIarg2\fP. \fIarg1\fP et \fIarg2\fP peuvent être des entiers positifs ou négatifs. .PD .SH "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. .IP 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. .IP 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. .IP 3. Les redirections sont effectuées comme décrit ci\-dessus dans .SM \fBREDIRECTIONS\fP. .IP 4. Le texte suivant le signe \fB=\fP de chaque affectation de variable est sujet au développement du tilde, des paramètres, à la substitution de commande, au développement arithmétique et à la suppression des protections avant d'être affecté à la variable. .PP Si aucun nom de commande ne résulte des précédentes opérations, les affectations de variables modifient l'environnement actuel 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 actuel. Si l'une des tentatives d'affectation concerne une variable en lecture seule, une erreur se produit et la commande termine avec un état différent de zéro. .PP Si aucun nom de commande n'est obtenu, les redirections sont effectuées mais ne modifient pas l'environnement de l'interpréteur actuel. Une erreur de redirection conduit à la terminaison de la commande avec un état différent de zéro. .PP S'il reste un nom de commande après le développement, l'exécution a lieu comme décrit ci\-dessous. 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. .SH "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. .PP 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 ci\-dessus dans .SM \fBFONCTIONS\fP. 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. .PP Si le nom n'est ni celui d'une fonction de l'interpréteur, ni celui d'une commande interne et s'il ne contient pas de barre oblique, \fBbash\fP va chercher dans chacun des éléments de .SM \fBPATH\fP un répertoire contenant un fichier exécutable du nom désiré. \fBBash\fP utilise une table de hachage pour mémoriser les chemins d'accès complets aux fichiers exécutables (consultez la commande \fBhash\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). Une recherche complète dans les répertoires du .SM \fBPATH\fP n'est effectuée que si la commande ne se trouve pas dans la table de hachage. Si la recherche est infructueuse, l'interpréteur recherche une fonction de l'interpréteur appelée \fBcommand_not_found_handle\fP. Si cette fonction existe, elle est appelée avec pour arguments la commande d'origine et ses arguments, et l'état final de la fonction devient l'état final de l'interpréteur. Si cette fonction n'est pas définie, l'interpréteur affiche un message d'erreur et renvoie un état final de 127. .PP Si la recherche réussit ou si le nom de la commande contient une ou plusieurs barres obliques, l'interpréteur exécute le programme demandé dans un environnement d'exécution distinct. L'argument 0 est configuré au nom indiqué et les éventuels arguments restants de la commande sont configurés aux arguments indiqués. .PP 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 \fIscript\fP, 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 (consultez \fBhash\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .PP Si le programme est un fichier commençant par \fB#!\fP, le reste de la première ligne indique un interprète pour ce programme. L'interpréteur se chargera d'exécuter l'interprète indiqué sur les systèmes d'exploitation qui ne gèrent pas eux\-mêmes ce format d'exécutable. Les arguments de l'interprète consistent en un seul argument facultatif fourni sur la première ligne du fichier à la suite du nom de l'interprète, suivi du nom du programme, suivi des arguments de la commande s'il y en a. .SH "ENVIRONNEMENT D'EXÉCUTION DES COMMANDES" L'interpréteur fournit un \fIenvironnement d'exécution\fP consistant en l'ensemble des éléments suivants\ : .IP \(bu les fichiers ouverts hérités par l'interpréteur à son appel et modifiés par les redirections fournies à la commande interne \fBexec\fP\ ; .IP \(bu le répertoire de travail actuel comme configuré par \fBcd\fP, \fBpushd\fP ou \fBpopd\fP ou hérité par l'interpréteur à son appel\ ; .IP \(bu le masque de création de fichier comme configuré par \fBumask\fP ou hérité du parent de l'interpréteur\ ; .IP \(bu les captures actuelles configurées par \fBtrap\fP\ ; .IP \(bu les paramètres de l'interpréteur configurés par des affectations de variables, avec la commande interne \fBset\fP, ou hérités de l'environnement du parent de l'interpréteur\ ; .IP \(bu 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\ ; .IP \(bu les options activées à l'appel (par défaut ou avec les arguments de ligne de commande) ou par \fBset\fP\ ; .IP \(bu les options activées par \fBshopt\fP\ ; .IP \(bu les alias de l'interpréteur définies par la commande \fBalias\fP\ ; .IP \(bu les ID des divers processus, y compris ceux des tâches en arrière\-plan, la valeur de \fB$$\fP et la valeur de .SM \fBPPID\fP. .PP Lorsqu'une commande différente d'une commande interne ou d'une fonction de l'interpréteur doit être exécutée, elle est appelée dans un environnement d'exécution séparé constitué de ce qui suit. Sauf indication contraire, les valeurs sont héritées de l'environnement de l'interpréteur\ : .if n .sp 1 .IP \(bu les fichiers ouverts de l'interpréteur, ainsi que toutes modifications et ajouts précisés par les redirections de la commande\ ; .IP \(bu le répertoire de travail actuel\ ; .IP \(bu le masque de création de fichiers\ ; .IP \(bu 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\ ; .IP \(bu 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. .PP Une commande appelée dans un environnement distinct ne peut pas affecter l'environnement d'exécution de l'interpréteur. .PP Les substitutions de commande, les commandes groupées entre parenthèses et les commandes asynchrones sont appelées dans un environnement de sous\-interpréteur qui est une copie de celui de l'interpréteur, mais les captures interceptées par l'interpréteur sont réinitialisées aux valeurs que l'interpréteur avait héritées de son parent à son appel. Les commandes internes appelées dans une conduite sont aussi exécutées dans un environnement de sous\-interpréteur. Les modifications apportées à l'environnement d'un sous\-interpréteur n'affectent aucunement l'environnement d'exécution de l'interpréteur. .PP Les sous\-interpréteurs engendrés pour exécuter les substitutions de commande héritent des valeurs de l'option \fB\-e\fP de l'interpréteur parent. En dehors du mode \fIposix\fP, \fBbash\fP efface l'option \fB\-e\fP de tels sous\-interpréteurs. .PP Si une commande est suivie par un \fB&\fP 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 \fI/dev/null\fP. Sinon, la commande appelée hérite des descripteurs de fichiers de l'interpréteur appelant comme modifiés par les redirections. .SH ENVIRONNEMENT Quand un programme est appelé, il reçoit un tableau de chaînes que l'on appelle \fIenvironnement\fP. Il s'agit d'une liste de couples \fInom\fP\-\fIvaleur\fP, de la forme \fInom\fP=\fIvaleur\fP. .PP 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 \fIexportable\fP vers les processus enfants. Les commandes exécutées héritent de cet environnement. Les commandes \fBexport\fP et \fBdeclare \-x\fP permettent d'ajouter ou de supprimer des paramètres ou des fonctions de l'environnement. Si la valeur d'un paramètre de l'environnement est modifiée, la nouvelle valeur devient une partie de l'environnement et elle remplace l'ancienne. L'environnement hérité par toute commande exécutée est l'environnement initial de l'interpréteur, dont les valeurs peuvent être modifiées dans l'interpréteur, sans les éléments supprimés par la commande \fBunset\fP, et avec les éléments ajoutés par les commandes \fBexport\fP et \fBdeclare \-x\fP. .PP L'environnement d'une \fIcommande simple\fP ou d'une fonction peut être augmenté temporairement, en la faisant précéder des affectations de paramètres, comme nous l'avons vu ci\-dessus dans .SM \fBPARAMÈTRES\fP. Ces affectations ne concernent que l'environnement vu par cette commande. .PP Si l'option \fB\-k\fP est configurée (consultez ci\-dessous la commande interne \fBset\fP), alors \fItoutes\fP 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. .PP Quand \fBbash\fP appelle une commande externe, la variable \fB_\fP est configurée en chemin d'accès complet à cette commande et elle est transmise dans l'environnement. .SH "ÉTAT FINAL" .PP L'état final d'une commande exécutée est la valeur renvoyée par l'appel système \fIwaitpid\fP ou fonction équivalente. Les états finaux prennent leurs valeurs entre 0 et 255, néanmoins, comme expliqué ci\-dessous, l'interpréteur peut utiliser les valeurs supérieures à 125 de façon particulière. Les états finaux des commandes internes et composées sont également limitées à cette plage. Sous certaines conditions, l'interpréteur utilisera des valeurs particulières pour indiquer des modes d'échec particuliers. .PP Du point de vue de l'interpréteur, une commande qui termine avec état final valant zéro a réussi. Un état final de zéro indique le succès. Un état final différent de zéro indique un échec. Quand une commande se termine par un signal mortel \fIN\fP, \fBbash\fP utilise la valeur 128+\fIN\fP comme état final. .PP 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. .PP 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. .PP Les commandes internes renvoient un état de 0 (\fIvrai\fP) si réussies et une valeur différente de zéro (\fIfaux\fP) si une erreur se produit pendant leur exécution. Toutes les commandes internes renvoient un état final de 2 pour indiquer un usage incorrect. .PP \fBBash\fP lui\-même renvoie l'état final de la dernière commande exécutée, à moins qu'une erreur de syntaxe ne se produise, auquel cas il termine avec une valeur différente de zéro. Consultez aussi ci\-dessous la commande interne \fBexit\fP. .SH SIGNAUX Quand \fBbash\fP fonctionne de façon interactive, en absence de toute capture, il ignore .SM \fBSIGTERM\fP (c'est ainsi que \fBkill 0\fP ne tue pas un interpréteur interactif) et .SM \fBSIGINT\fP est intercepté et géré (c'est ainsi que la commande interne \fBwait\fP est interruptible). Dans tous les cas, \fBbash\fP ignore .SM \fBSIGQUIT\fP. Si le contrôle des tâches est actif, \fBbash\fP ignore .SM \fBSIGTTIN\fP, .SM \fBSIGTTOU\fP et .SM \fBSIGTSTP\fP. .PP Les commandes externes lancées par \fBbash\fP ont les gestionnaires de signaux configurés aux valeurs héritées par l'interpréteur de son parent. Quand le contrôle des tâches n'est pas actif, les tâches en arrière\-plan ignorent les signaux .SM \fBSIGINT\fP et .SM \fBSIGQUIT\fP 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 .SM \fBSIGTTIN\fP, .SM \fBSIGTTOU\fP et .SM \fBSIGTSTP\fP. .PP Par défaut, l'interpréteur termine à la réception de .SM \fBSIGHUP\fP. Avant de terminer, un interpréteur interactif renvoie le .SM \fBSIGHUP\fP à toutes les tâches en cours ou suspendues. Les tâches suspendues reçoivent aussi .SM \fBSIGCONT\fP pour s'assurer qu'elles reçoivent bien le .SM \fBSIGHUP\fP. 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 \fBdisown\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous) ou marquée comme exemptée de .SM \fBSIGHUP\fP en utilisant \fBdisown \-h\fP. .PP Si l'option d'interpréteur \fBhuponexit\fP a été configurée avec la fonction \fBshopt\fP, \fBbash\fP envoie un signal .SM \fBSIGHUP\fP à toutes les tâches lorsqu'un interpréteur de commandes de connexion interactif termine. .PP Lorsque \fBbash\fP attend qu'une commande se termine et qu'il reçoit un signal pour lequel une capture a été configurée, la capture ne sera pas exécutée tant que la commande n'est pas terminée. Lorsque \fBbash\fP attend la fin d'une commande asynchrone par la commande interne \fBwait\fP, la réception d'un signal pour lequel une capture a été configurée conduira à un retour immédiat de la commande interne \fBwait\fP avec un état final supérieur à 128, à la suite de quoi la capture est immédiatement exécutée. .SH "CONTRÔLE DES TÂCHES" Le \fIcontrôle des tâches\fP se réfère à la capacité de suspendre (\fIsuspend\fP) sélectivement l'exécution d'un processus et de la reprendre (\fIresume\fP) ultérieurement. L'utilisateur bénéficie généralement de cette possibilité grâce à l'action conjointe du pilote de terminal du noyau de système d'exploitation et de \fBbash\fP. .PP L'interpréteur associe une \fItâche\fP à chaque conduite. Il maintient une table des tâches en cours d'exécution, cette table pouvant être affichée avec la commande \fBjobs\fP. Quand \fBbash\fP lance une tâche de façon asynchrone (en \fIarrière\-plan\fP), il affiche une ligne qui ressemble à\ : .RS .PP [1] 25647 .RE .PP 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. \fBBash\fP utilise la notion de \fItâche\fP comme base du contrôle des tâches. .PP Pour faciliter l'implémentation d'une interface utilisateur pour le contrôle de tâches, le système introduit la notion d'\fIID de groupe de processus associés à un terminal\fP. Les membres de ce groupe de processus (processus dont le GID est égal au \fIProcess Group ID\fP du terminal actuel) reçoivent les signaux émis par le clavier comme .SM \fBSIGINT\fP. Ces processus sont dits au \fIpremier plan\fP. Les processus en \fIarrière\-plan\fP sont ceux dont le \fIProcess\-GID\fP diffère de celui du terminal\ ; ils sont indifférents aux signaux émis par le clavier. Seuls les processus au premier plan peuvent lire depuis le terminal ou, si l'utilisateur l'indique avec \f(CWstty tostop\fP, y écrire. Les processus en arrière\-plan qui tentent une lecture (ou une écriture si \f(CWstty tostop\fP est actif) dans le terminal reçoivent un signal .SM \fBSIGTTIN (SIGTTOU)\fP émis par le pilote du terminal du noyau, qui, sauf interception, suspend le processus. .PP Si le système d'exploitation sur lequel \fBbash\fP fonctionne permet le contrôle des tâches, \fBbash\fP fournit des outils pour l'utiliser. La frappe d'un caractère de \fIsuspension\fP (généralement \fB^Z\fP, Contrôle\-Z) pendant l'exécution d'un processus conduit à la suspension de celui\-ci et redonne la main à \fBbash\fP. La frappe d'un caractère de \fIsuspension différée\fP (généralement \fB^Y\fP, Contrôle\-Y) conduira à la suspension du processus au moment où il tentera de lire des saisies depuis le terminal et la main reviendra à \fBbash\fP. L'utilisateur peut alors manipuler l'état de cette tâche en utilisant la commande \fBbg\fP (background = arrière\-plan) pour en continuer l'exécution en arrière\-plan, la commande \fBfg\fP (foreground = premier plan) pour la continuer au premier plan ou encore la commande \fBkill\fP pour la tuer. Un \fB^Z\fP s'applique immédiatement et a pour effet de bord d'éliminer les sorties et saisies en attente. .PP Plusieurs façons permettent de se rapporter à une tâche. Le caractère \fB%\fP introduit une spécification de tâche (\fIjobspec\fP). Il est possible de se rapporter à la tâche numéro \fIn\fP avec \fB%n\fP. Il est également possible de se rapporter à une tâche en utilisant un préfixe du nom utilisé pour le lancer ou une sous\-chaîne qui apparaît dans sa ligne de commande. Par exemple, \fB%ce\fP se rapporte à une tâche suspendue nommée \fBce\fP. Si ce préfixe correspond à plusieurs tâches, \fBbash\fP signale une erreur. Utiliser \fB%?ce\fP, d'un autre côté, se rapporte à toute tâche contenant la chaîne \fBce\fP dans sa ligne de commande. Si la sous\-chaîne correspond à plusieurs tâches, \fBbash\fP signale une erreur. Les symboles \fB%%\fP et \fB%+\fP se rapportent à la notion de \fItâche actuelle\fP de l'interpréteur, c'est\-à\-dire la dernière tâche suspendue alors qu'elle était au premier plan ou démarrée en arrière\-plan. La \fItâche précédente\fP peut être désignée en utilisant \fB%\-\fP. Si une seule tâche existe, \fB%+\fP et \fB%\-\fP peuvent tous deux être utilisés pour se rapporter à cette tâche. Dans les affichages se rapportant aux tâches (par exemple la sortie de la commande \fBjobs\fP), la tâche actuelle est toujours annotée d'un \fB+\fP et la tâche précédente d'un \fB\-\fP. Un simple \fB%\fP (non accompagné de spécification de tâche) se rapporte également à la tâche actuelle. .PP Il suffit de nommer une tâche pour la ramener au premier plan\ : \fB%1\fP est synonyme de \fB«\ fg %1\ »\fP et ramène la tâche 1 de l'arrière\-plan vers le premier plan. De même, \fB«\ %1 &\ »\fP reprend la tâche 1 en arrière\-plan, de façon équivalente à \fB«\ bg %1\ »\fP. .PP L'interpréteur est immédiatement prévenu lorsqu'une tâche change d'état. Normalement \fBbash\fP 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 \fB\-b\fP de la commande interne \fBset\fP est activée, \fBbash\fP signalera de telles modifications immédiatement. Toute capture sur .SM \fBSIGCHLD\fP est exécutée pour chaque enfant qui termine. .PP Si une tentative visant à terminer \fBbash\fP est réalisée alors que des tâches sont suspendues (ou, si l'option d'interpréteur \fBcheckjobs\fP a été activée par la commande interne \fBshopt\fP, en cours d'exécution), l'interpréteur affiche un message d'avertissement, et, si l'option d'interpréteur \fBcheckjobs\fP est activée, affiche la liste les tâches et leurs états. La commande \fBjobs\fP peut alors être utilisée pour examiner leur état. Si une deuxième tentative est faite pour terminer sans commande intercalaire, l'interpréteur n'affiche aucun autre avertissement et les tâches suspendues sont terminées. .SH INVITES Quand il est exécuté de façon interactive, \fBbash\fP affiche l'invite de base .SM \fBPS1\fP dès qu'il est prêt à lire une commande et l'invite secondaire .SM \fBPS2\fP quand il a besoin de plus de saisies pour exécuter une commande. \fBBash\fP permet de personnaliser ces chaînes d'invite, en insérant un certain nombre de caractères spéciaux protégés par des contre\-obliques qui sont décodés comme suit\ : .RS .PD 0 .TP \fB\ea\fP un caractère ASCII d'alarme (07)\ ; .TP \fB\ed\fP la date au format «\ Jour_de_la_semaine Mois Quantième\ » (par exemple\ : «\ Tue May 26\ »)\ ; .TP \fB\eD{\fP\fIformat\fP\fB}\fP le \fIformat\fP est passé à \fBstrftime\fP(3) et le résultat est inséré dans la chaîne de l'invite\ ; un \fIformat\fP vide implique une représentation du temps spécifique aux paramètres linguistiques régionaux. Les accolades sont nécessaires\ ; .TP \fB\ee\fP un caractère d'échappement ASCII (033)\ ; .TP \fB\eh\fP le nom de la machine, jusqu'au premier point «\ .\ »\ ; .TP \fB\eH\fP le nom de la machine\ ; .TP \fB\ej\fP le nombre de tâches actuellement gérées par l'interpréteur\ ; .TP \fB\el\fP le nom de base du nom de périphérique de terminal de l'interpréteur\ ; .TP \fB\en\fP changement de ligne\ ; .TP \fB\er\fP retour chariot («\ carriage return\ »)\ ; .TP \fB\es\fP le nom de l'interpréteur, c'est\-à\-dire le nom de base de \fB$0\fP (la portion suivant la dernière barre oblique)\ ; .TP \fB\et\fP l'heure actuelle au format HH:MM:SS sur 24 heures\ ; .TP \fB\eT\fP l'heure actuelle au format HH:MM:SS sur 12 heures\ ; .TP \fB\e@\fP l'heure actuelle au format HH:MM sur 12 heures\ ; .TP \fB\eA\fP l'heure actuelle au format HH:MM sur 24 heures\ ; .TP \fB\eu\fP le nom de l'utilisateur\ ; .TP \fB\ev\fP la version de \fBbash\fP (par exemple, 2.00)\ ; .TP \fB\eV\fP le numéro de version complet (avec niveau de correctifs) de \fBbash\fP, (par exemple, 2.00.0)\ ; .TP \fB\ew\fP le répertoire de travail actuel, avec .SM \fB$HOME\fP abrégé en tilde «\ ~\ » (utilise la valeur de la variable .SM \fBPROMPT_DIRTRIM\fP)\ ; .TP \fB\eW\fP le nom de base du répertoire de travail actuel, avec .SM \fB$HOME\fP abrégé en tilde («\ ~\ »)\ ; .TP \fB\e!\fP le numéro d'historique de la commande\ ; .TP \fB\e#\fP le numéro de la commande\ ; .TP \fB\e$\fP \fB#\fP si l'UID effectif est 0, \fB$\fP sinon\ ; .TP \fB\e\fP\fInnn\fP le caractère de code octal \fInnn\fP\ ; .TP \fB\e\e\fP une contre\-oblique\ ; .TP \fB\e[\fP 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\ ; .TP \fB\e]\fP finit une suite de caractères non imprimables. .PD .RE .PP 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 (consultez .SM \fBHISTORIQUE\fP ci\-dessous), 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 actuelle. Après que la chaîne ait été décodée, elle est soumise au développement des paramètres, à la substitution de commande, au développement arithmétique, au découpage des mots et à la suppression des protections, selon la valeur de l'option d'interpréteur \fBpromptvars\fP (consultez la description de \fBshopt\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .SH READLINE C'est la bibliothèque qui gère la lecture des saisies lors des sessions interactives de l'interpréteur, à moins que l'option \fB\-\-noediting\fP ne soit indiquée à l'appel de l'interpréteur. Par défaut les commandes d'édition de ligne sont similaires à celles d'Emacs. Une interface d'édition de ligne dans le style vi est aussi disponible. Pour arrêter l'édition de ligne après le démarrage de l'interpréteur, utiliser l'option \fB+o emacs\fP ou \fB+o vi\fP de la commande interne \fBset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .SS "Notation readline" .PP Dans ce paragraphe on utilisera la notation «\ à la Emacs\ » pour indiquer les frappes de touches. Les touches Contrôle sont notées C\-\fItouche\fP, par exemple C\-n signifie Contrôle\-N. De même, les touches \fIMéta\fP sont notées par M\-\fItouche\fP, ainsi M\-x signifie Méta\-X. (Sur les claviers sans touches \fIMéta\fP, M\-\fIx\fP signifie ESC \fIx\fP, c'est\-à\-dire presser la touche d'Échappement puis la touche \fIx\fP. Cela fait de ESC le \fIpréfixe méta\fP. La combinaison M\-C\-\fIx\fP signifie ESC\-Contrôle\-\fIx\fP ou encore presser la touche d'Échappement puis maintenez la touche Contrôle enfoncée tout en pressant la touche \fIx\fP.) .PP Les commandes readline peuvent recevoir des \fIarguments\fP numériques, qui fonctionnent en règle générale comme compteurs de répétitions. Parfois, cependant, c'est le signe de l'argument qui est significatif. L'utilisation d'un argument négatif pour une commande agissant dans un sens donné (par exemple \fBkill\-line\fP) conduit cette commande à agir dans la direction opposée. Les commandes dont le comportement avec les arguments diffère de cela sont indiquées ci\-dessous. .PP Lorsqu'une commande est indiquée comme \fIdétruisant\fP du texte, le texte effacé est en fait sauvegardé pour une éventuelle récupération ultérieure («\ \fIyanking\fP\ »). Il est conservé dans un tampon circulaire («\ \fIkill ring\fP\ »). Les suppressions successives conduisent à l'accumulation du texte en un seul bloc qui peut être récupéré en une fois. Les commandes non destructives séparent les blocs de textes dans le tampon circulaire. .SS "Initialisation de readline" .PP Readline est personnalisé en plaçant des commandes dans un fichier d'initialisation (le fichier \fIinputrc\fP). Le nom de ce fichier est pris dans la variable de l'interpréteur .SM \fBINPUTRC\fP. Si cette variable est inexistante, le nom par défaut est \fI~/.inputrc\fP. Lorsqu'un programme utilisant la bibliothèque readline démarre, le fichier d'initialisation est lu et les raccourcis clavier et les variables sont mis en place. Il n'y a que quelques constructions élémentaires possibles dans le fichier d'initialisation de readline. Les lignes blanches sont ignorées. Les lignes commençant par \fB#\fP sont des commentaires. Les lignes commençant par \fB$\fP indiquent des constructions conditionnelles. Les autres lignes indiquent des raccourcis clavier et des paramétrages de variables. .PP Les raccourcis clavier par défaut peuvent être modifiés par un fichier \fIinputrc\fP. D'autres programmes qui utilisent cette bibliothèque peuvent ajouter leurs propres commandes et raccourcis. .PP Par exemple, en plaçant .RS .PP M\-Control\-u: universal\-argument .RE ou .RS C\-Meta\-u: universal\-argument .RE dans le fichier \fIinputrc\fP, on associera la suite de touches M\-C\-u à la commande readline \fIuniversal\-argument\fP. .PP Les caractères symboliques suivants sont acceptés\ : \fIRUBOUT\fP, \fIDEL\fP, \fIESC\fP, \fILFD\fP, \fINEWLINE\fP, \fIRET\fP, \fIRETURN\fP, \fISPC\fP, \fISPACE\fP et \fITAB\fP. .PP 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 \fImacro\fP). .SS "Raccourcis clavier readline" .PP La syntaxe de définition des raccourcis clavier dans le fichier \fIinputrc\fP est simple. Tout ce qui est nécessaire est le nom de la commande ou le texte d'une macro et la suite de touches à laquelle il faut l'associer. Les noms de touches peuvent être indiqués de l'une des deux façons\ : comme un nom de touche symbolique, éventuellement précédé des préfixes \fIMeta\-\fP ou \fIControl\-\fP ou sous forme d'une suite de touches. .PP En utilisant la forme \fBtouche\fP:\^\fInom_de_fonction\fP ou \fImacro\fP, \fItouche\fP est le nom de la touche en anglais. Par exemple\ : .sp .RS Control\-u: universal\-argument .br Meta\-Rubout: backward\-kill\-word .br Control\-o: "> sortie" .RE .LP Dans l'exemple ci\-dessus, \fIC\-u\fP est associé à la fonction \fBuniversal\-argument\fP, \fIM\-DEL\fP à la fonction \fBbackward\-kill\-word\fP et \fIC\-o\fP à l'exécution de la macro exprimée dans la partie gauche (c'est\-à\-dire, insérer le texte .if t \f(CW> sortie\fP .if n « > sortie » sur la ligne). .PP Avec la seconde forme, \fB"touches"\fP:\^\fInom_de_fonction\fP ou \fImacro\fP, \fBtouches\fP diffère de \fBtouche\fP ci\-dessus en ce que les chaînes notant une suite complète de touches peut être indiquée en plaçant la suite entre guillemets doubles. Certaines suites de touches d'échappement dans le style GNU Emacs peuvent être utilisées, comme dans l'exemple suivant, mais les noms de caractères symboliques ne sont pas reconnus. .sp .RS "\eC\-u": universal\-argument .br "\eC\-x\eC\-r": re\-read\-init\-file .br "\ee[11~": "Function Key 1" .RE .PP Dans cet exemple, \fIC\-u\fP est à nouveau associé à la fonction \fBuniversal\-argument\fP, \fIC\-x C\-r\fP à la fonction \fBre\-read\-init\-file\fP et \fIESC [ 1 1 ~\fP à l'insertion du texte .if t \f(CWFunction Key 1\fP. .if n « Function Key 1 ». .PP Le jeu complet des suites de caractères d'échappements du style GNU Emacs est\ : .RS .PD 0 .TP \fB\eC\-\fP préfixe Contrôle\ ; .TP \fB\eM\-\fP préfixe Méta\ ; .TP \fB\ee\fP caractère d'échappement\ ; .TP \fB\e\e\fP contre\-oblique\ ; .TP \fB\e"\fP un guillemet " littéral\ ; .TP \fB\e\(aq\fP un guillemet \(aq littéral. .RE .PD .PP 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\ : .RS .PD 0 .TP \fB\ea\fP alerte (alarme)\ ; .TP \fB\eb\fP effacement arrière («\ backspace\ »)\ ; .TP \fB\ed\fP effacement\ ; .TP \fB\ef\fP saut de page («\ form feed\ »)\ ; .TP \fB\en\fP changement de ligne\ ; .TP \fB\er\fP retour chariot («\ carriage return\ »)\ ; .TP \fB\et\fP tabulation horizontale\ ; .TP \fB\ev\fP tabulation verticale\ ; .TP \fB\e\fP\fInnn\fP le caractère 8\ bits dont la valeur octale est \fInnn\fP (un à trois chiffres)\ ; .TP \fB\ex\fP\fIHH\fP le caractère 8\ bits dont la valeur hexadécimale est \fIHH\fP (un ou deux chiffres hexadécimaux)\ ; .RE .PD .PP Lorsqu'on saisit le texte d'une macro, il faut utiliser des guillemets simples ou doubles pour indiquer la définition de la macro. Les textes non protégés sont considérés comme des noms de fonctions. Dans le corps de la macro, les protections par contre\-oblique décrites ci\-dessus sont développées. La contre\-oblique protégera tout autre caractère dans le texte de la macro, y compris " et \(aq. .PP \fBBash\fP permet d'afficher ou de modifier les raccourcis clavier readline avec la commande interne \fBbind\fP. On peut basculer d'un mode d'édition à l'autre en mode interactif en utilisant l'option \fB\-o\fP de la commande interne \fBset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). .SS "Variables de readline" .PP Readline dispose de variables permettant de personnaliser encore plus son comportement. Une variable peut être configurée dans le fichier \fIinputrc\fP avec une affectation de la forme .RS .PP \fBset\fP \fInom_de_variable\fP \fIvaleur\fP .RE .PP Sauf indication contraire, les variables de readline prennent les valeurs \fBOn\fP ou \fBOff\fP (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 à \fBOn\fP. Toutes les autres valeurs sont équivalentes à \fBOff\fP. Les variables et leurs valeurs par défaut, sont\ : .PP .PD 0 .TP \fBbell\-style (audible)\fP Cette variable commande readline lorsqu'il faut déclencher l'alarme du terminal. Si configurée à \fBnone\fP, readline n'émet jamais d'alarme. Si configurée à \fBvisible\fP, readline utilise une alarme visuelle s'il y en a une disponible. Si configurée à \fBaudible\fP, readline essaie de faire sonner l'alarme du terminal. .TP \fBbind\-tty\-special\-chars (On)\fP Si configurée à \fBOn\fP, readline tente d'associer les caractères de contrôle traités spécialement par le pilote de terminal du noyau à leurs équivalents readline. .TP \fBcomment\-begin («\ #\ »)\fP Cette chaîne est insérée quand la commande readline \fBinsert\-comment\fP est exécutée. Cette commande est associée à \fBM\-#\fP en mode Emacs et à \fB#\fP en mode de commande vi. .TP \fBcompletion\-ignore\-case (Off)\fP Si configurée à \fBOn\fP, readline effectue les correspondances et complètements de noms de fichiers sans tenir compte de la casse. .TP \fBcompletion\-prefix\-display\-length (0)\fP La longueur, en caractères, du préfixe commun d'une liste de complètements possibles affiché sans modification. Si configurée en valeur positive, les préfixes communs plus longs que cette valeur sont remplacés par une ellipse lors de l'affichage des complètements possibles. .TP \fBcompletion\-query\-items (100)\fP Cela détermine quand l'utilisateur est interrogé pour voir le nombre de complètements possibles produits par la commande \fBpossible\-completions\fP. Elle peut être configurée à toute valeur entière positive. Si le nombre de complètements possibles est supérieur ou égal à la valeur de cette variable, il est demandé à l'utilisateur s'il veut ou non les voir\ ; sinon, ils sont simplement affichés sur le terminal. .TP \fBconvert\-meta (On)\fP Si configurée à \fBOn\fP, 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 \fIpréfixe méta\fP). .TP \fBdisable\-completion (Off)\fP Si configurée à \fBOn\fP, 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 à \fBself\-insert\fP. .TP \fBediting\-mode (emacs)\fP Commande si readline doit démarrer avec des raccourcis clavier similaires à \fIEmacs\fP ou à \fIvi\fP. \fBediting\-mode\fP peut être positionné soit à \fBemacs\fP, soit à \fBvi\fP. .TP \fBecho\-control\-characters (On)\fP Si configurée à \fBOn\fP, sur les systèmes d'exploitation le permettant, readline affiche un caractère correspondant à un signal provenant du clavier. .TP \fBenable\-keypad (Off)\fP Quand configurée à \fBOn\fP, readline essayera d'activer le pavé numérique de l'application une fois appelée. Sur certains systèmes, c'est nécessaire pour utiliser les flèches. .TP \fBenable\-meta\-key (On)\fP Quand configurée à \fBOn\fP, readline essayera d'activer toutes les touches de modificateur \fIMéta\fP que le terminal peut prendre en charge une fois appelé. Sur de nombreux terminaux, la touche \fIMéta\fP est utilisée pour saisir des caractères sur huit bits. .TP \fBexpand\-tilde (Off)\fP Si configurée à \fBOn\fP, le développement du tilde est effectué lorsque readline tente un complètement de commandes. .TP \fBhistory\-preserve\-point (Off)\fP Si configurée à \fBOn\fP, le programme d'historique tente de placer le curseur au même endroit sur chaque ligne d'historique récupérée avec \fBprevious\-history\fP ou \fBnext\-history\fP. .TP \fBhistory\-size (0)\fP Configure le nombre d'éléments sauvegardés dans la file de l'historique. Si configurée à zéro, le nombre d'éléments de la file de l'historique n'est pas limité. .TP \fBhorizontal\-scroll\-mode (Off)\fP Quand configurée à \fBOn\fP, 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. .TP \fBinput\-meta (Off)\fP Si configurée à \fBOn\fP, 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 \fBmeta\-flag\fP est un synonyme pour cette variable. .TP \fBisearch\-terminators («\ C\-[C\-J\ »)\fP La chaîne de caractères qui doit terminer une recherche incrémentale sans que le caractère ne soit exécuté comme une commande. Si cette variable n'a pas reçu de valeur, les caractères \fIESC\fP et \fIC\-J\fP termineront une recherche incrémentale. .TP \fBkeymap (emacs)\fP Configure le jeu de raccourcis readline actuel. L'ensemble des noms corrects de jeux de raccourcis est \fIemacs\fP, \fIemacs\-standard\fP, \fIemacs\-meta\fP, \fIemacs\-ctlx\fP, \fIvi\fP, \fIvi\-command\fP et \fIvi\-insert\fP. \fIvi\fP est équivalent à \fIvi\-command\fP\ ; \fIemacs\fP est équivalent à \fIemacs\-standard\fP. La valeur par défaut est \fIemacs\fP\ ; la valeur de \fBediting\-mode\fP modifie aussi le jeu de raccourcis par défaut. .TP \fBmark\-directories (On)\fP Si configurée à \fBOn\fP, une barre oblique est ajoutée aux noms de répertoires. .TP \fBmark\-modified\-lines (Off)\fP Si configurée à \fBOn\fP, les lignes d'historique qui ont été modifiées seront précédées à l'affichage d'un astérisque (\fB*\fP). .TP \fBmark\-symlinked\-directories (Off)\fP Si configurée à \fBOn\fP, une barre oblique est ajoutée aux noms complétés si ce sont des liens symboliques vers des répertoires (selon la valeur de \fBmark\-directories\fP). .TP \fBmatch\-hidden\-files (On)\fP Cette variable, quand elle est configurée à \fBOn\fP, conduit readline à faire correspondre des fichiers dont le nom commence par un «\ .\ » (fichiers cachés) lors du complètement de noms de fichiers. Si configurée à \fBOff\fP, le «\ .\ » du début doit être fourni par l'utilisateur dans le nom de fichier à compléter. .TP \fBmenu\-complete\-display\-prefix (Off)\fP Si configurée à \fBOn\fP, le complètement de menu affiche le préfixe commun à la liste de complétements possibles (qui peut être vide) avant de tourner dans la liste. .TP \fBoutput\-meta (Off)\fP Si configurée à \fBOn\fP, 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. .TP \fBpage\-completions (On)\fP Si configurée à \fBOn\fP, readline utilise un afficheur de texte interne du type \fImore\fP pour afficher les complètements possibles sur un seul plein écran. .TP \fBprint\-completions\-horizontally (Off)\fP Si configurée à \fBOn\fP, readline affichera les complètements correspondants triés horizontalement dans l'ordre alphabétique plutôt que verticalement. .TP \fBrevert\-all\-at\-newline (Off)\fP Si configurée à \fBOn\fP, readline annulera toutes les modifications des lignes d'historique avant de s'arrêter quand \fBaccept\-line\fP est exécuté. Par défaut les lignes d'historique peuvent être modifiées et conservent les listes d'annulation individuelles au fur et à mesure des appels à \fBreadline\fP. .TP \fBshow\-all\-if\-ambiguous (Off)\fP Cela modifie le comportement par défaut des fonctions de complètement. Si configurée à \fBOn\fP, 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. .TP \fBshow\-all\-if\-unmodified (Off)\fP Cela modifie le comportement par défaut des fonctions de complètement de façon similaire à \fBshow\-all\-if\-ambiguous\fP. Si configurée à \fBOn\fP, 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. .TP \fBskip\-completed\-text (Off)\fP Si configurée à \fBOn\fP, modifie le comportement par défaut du complètement lors de l'insertion d'une unique correspondance dans la ligne. Elle n'est utilisée que lors d'un complètement effectué au milieu d'un mot. Si elle est activée, readline n'insère pas de caractères de complètement correspondant à des caractères situés après le curseur dans le mot en train d'être complété, ainsi les parties du mots situées après le curseur ne sont pas dupliquées. .TP \fBvisible\-stats (Off)\fP Si configurée à \fBOn\fP, un caractère indiquant le type de fichier, comme signalé par \fBstat\fP(2) est ajouté aux noms de fichiers en affichant les complètements possibles. .PD .SS "Constructions conditionnelles de readline" .PP 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. .IP \fB$if\fP La structure \fB$if\fP 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. .RS .IP \fBmode\fP La forme \fBmode=\fP de la directive \fB$if\fP est utilisée pour vérifier si readline est en mode emacs ou vi. Cela peut être utilisé conjointement à la commande \fBset keymap\fP, par exemple pour ne configurer les raccourcis des jeux de raccourcis \fIemacs\-standard\fP et \fIemacs\-ctlx\fP que si readline démarre en mode emacs. .IP \fBterm\fP La forme \fBterm=\fP 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 \fB=\fP est comparé à la fois au nom complet du terminal et à la portion de nom du terminal qui précède le premier signe \fB\-\fP. Cela permet, par exemple, de faire correspondre \fIsun\fP avec à la fois \fIsun\fP et \fIsun\-cmd\fP. .IP \fBapplication\fP La structure \fBapplication\fP est utilisée pour inclure des paramétrages spécifiques à chaque application. Chaque programme utilisant la bibliothèque readline configure un \fInom d'application\fP et un fichier d'initialisation peut tester une valeur particulière. Ce peut être utilisé pour associer des suites de touches à des fonctions utiles pour un certain programme. Par exemple, les commandes suivantes ajoutent une suite de touches qui protège le mot actuel ou précédant dans \fBbash\fP\ : .sp 1 .RS .nf \fB$if\fP Bash # Protéger le mot actuel ou le précédant "\eC\-xq": "\eeb\e"\eef\e"" \fB$endif\fP .fi .RE .RE .IP \fB$endif\fP Cette commande, comme on l'a vu dans l'exemple ci\-dessus, termine une commande \fB$if\fP. .IP \fB$else\fP Permet d'ajouter des commandes qui seront exécutées si un \fB$if\fP échoue. .IP \fB$include\fP 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 \fI/etc/inputrc\fP\ : .sp 1 .RS .nf \fB$include\fP \^ \fI/etc/inputrc\fP .fi .RE .SS Recherche .PP Readline fournit des commandes de recherche au sein de l'historique de commandes (consultez .SM \fBHISTORIQUE\fP ci\-dessous) des lignes contenant une chaîne donnée. Il y a deux modes de recherche\ : \fIincrémental\fP et \fInon incrémental\fP. .PP Les recherches incrémentales commencent avant même que l'utilisateur n'ait terminé de saisir la chaîne recherchée. À chaque caractère saisi, readline affiche l'élément suivant de l'historique qui correspond à la chaîne déjà entrée. Une recherche incrémentale nécessite seulement le nombre de caractères indispensable pour retrouver l'élément d'historique désiré. Les caractères se trouvant dans la variable \fBisearch\-terminators\fP 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 actuelle. .PP Pour trouver les autres éléments correspondant dans la file d'historique, saisissez selon Contrôle\-S ou Contrôle\-R. Cela 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 \fIchangement de ligne\fP interrompra la recherche et acceptera la ligne, exécutant ainsi la commande de la file d'historique. .PP 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. .PP 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 actuelle. .SS "Noms des commandes readline" .PP 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 \fIcurseur\fP («\ point\ ») se rapporte à la position actuelle du curseur et la \fImarque\fP se rapporte à une position de curseur sauvegardée par la commande \fBset\-mark\fP. Le texte entre le curseur et la marque est désigné comme la \fIzone\fP. .SS "Commandes de déplacement" .PP .PD 0 .TP \fBbeginning\-of\-line (C\-a)\fP Saut au début de la ligne actuelle. .TP \fBend\-of\-line (C\-e)\fP Saut à la fin de la ligne. .TP \fBforward\-char (C\-f)\fP Avancer d'un caractère. .TP \fBbackward\-char (C\-b)\fP Reculer d'un caractère. .TP \fBforward\-word (M\-f)\fP Avancer jusqu'à la fin du mot suivant. Les mots sont composés de caractères alphanumériques (lettres et chiffres). .TP \fBbackward\-word (M\-b)\fP Reculer jusqu'au début du mot actuel ou du précédent. Les mots sont composés de caractères alphanumériques (lettres et chiffres). .TP \fBshell\-forward\-word\fP Avancer jusqu'à la fin du mot suivant. Les mots sont séparés par des métacaractères non protégés de l'interpréteur. .TP \fBshell\-backward\-word\fP Reculer jusqu'au début du mot actuel ou du précédent. Les mots sont séparés par des métacaractères non protégés de l'interpréteur. .TP \fBclear\-screen (C\-l)\fP Effacer l'écran, en laissant la ligne actuelle au sommet de l'écran. S'il y a un argument, rafraîchir la ligne actuelle sans effacer l'écran. .TP \fBredraw\-current\-line\fP Rafraîchir la ligne actuelle. .PD .SS "Commandes de manipulation de l'historique" .PP .PD 0 .TP \fBaccept\-line (changement de ligne, retour chariot)\fP 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 .SM \fBHISTCONTROL\fP. Si cette ligne est une ligne d'historique modifiée, restaurer cette dernière. .TP \fBprevious\-history (C\-p)\fP Récupérer la commande précédente de la file d'historique, en remontant dans la file. .TP \fBnext\-history (C\-n)\fP Récupérer la commande suivante dans la file d'historique, en descendant dans la file. .TP \fBbeginning\-of\-history (M\-<)\fP Récupérer la première ligne de l'historique. .TP \fBend\-of\-history (M\->)\fP Retourner à la fin de l'historique de saisie, c'est\-à\-dire à la ligne en cours de saisie. .TP \fBreverse\-search\-history (C\-r)\fP Rechercher en arrière dans l'historique, en remontant. C'est une recherche incrémentale. .TP \fBforward\-search\-history (C\-s)\fP Rechercher en avant dans l'historique, en descendant. C'est une recherche incrémentale. .TP \fBnon\-incremental\-reverse\-search\-history (M\-p)\fP 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. .TP \fBnon\-incremental\-forward\-search\-history (M\-n)\fP Rechercher une chaîne en avant dans l'historique, utiliser une recherche non incrémentale pour une chaîne fournie par l'utilisateur. .TP \fBhistory\-search\-forward\fP 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. .TP \fBhistory\-search\-backward\fP 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. .TP \fByank\-nth\-arg (M\-C\-y)\fP 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 \fIn\fP, insérer le \fIn\fP\-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 \fIn\fP\-ième mot en partant de la fin de la commande précédente. Une fois que l'argument \fIn\fP est traité, l'argument est extrait comme si le développement d'historique «\ !\fIn\fP\ » avait été indiqué. .TP \fByank\-last\-arg (M\-.\^, M\-_\^)\fP Insérer le dernier argument de la commande précédente (le dernier mot de l'élément précédent de la file d'historique). Avec un argument numérique, se comporte exactement comme \fByank\-nth\-arg\fP. Les appels successifs à \fByank\-last\-arg\fP remontent dans la file d'historique en insérant le dernier mot (ou le mot indiqué par l'argument du premier appel) de chaque ligne tour à tour. Tous les arguments numériques fournis à ces appels successifs déterminent la direction de déplacement dans l'historique. Un argument négatif modifie la direction dans l'historique (en avant ou en arrière). Les outils de développement d'historique sont utilisés pour extraire le dernier argument, comme si le développement d'historique «\ !$\ » avait été indiqué. .TP \fBshell\-expand\-line (M\-C\-e)\fP Développer, comme le fait l'interpréteur, la ligne actuelle. Cela effectue le développement des alias et d'historique, ainsi que tous les développements de mot de l'interpréteur. Consultez ci\-dessous .SM \fBDÉVELOPPEMENT DE L'HISTORIQUE\fP, pour une description détaillée du développement de l'historique. .TP \fBhistory\-expand\-line (M\-^)\fP Effectuer le développement d'historique sur la ligne actuelle. Consultez ci\-dessous .SM \fBDÉVELOPPEMENT DE L'HISTORIQUE\fP, pour une description détaillée. .TP \fBmagic\-space\fP Effectuer le développement de l'historique sur la ligne actuelle et insérer une espace. Consultez ci\-dessous .SM \fBDÉVELOPPEMENT DE L'HISTORIQUE\fP, pour une description détaillée. .TP \fBalias\-expand\-line\fP Effectuer le développement des alias sur la ligne actuelle. Consultez .SM \fBALIAS\fP ci\-dessus pour une description des développements d'alias. .TP \fBhistory\-and\-alias\-expand\-line\fP Effectuer le développement de l'historique et des alias sur la ligne actuelle. .TP \fBinsert\-last\-argument (M\-.\^, M\-_\^)\fP Un synonyme de \fByank\-last\-arg\fP. .TP \fBoperate\-and\-get\-next (C\-o)\fP Valider la ligne actuelle et récupérer la ligne suivante de l'historique pour édition. Tout argument est ignoré. .TP \fBedit\-and\-execute\-command (C\-xC\-e)\fP Appelle un éditeur sur la ligne de commande actuelle et exécute le résultat comme une commande d'interpréteur. \fBBash\fP tente d'appeler, dans cet ordre, .SM \fB$VISUAL\fP, .SM \fB$EDITOR\fP et \fIemacs\fP comme éditeur. .PD .SS "Commande d'édition de texte" .PP .PD 0 .TP \fBdelete\-char (C\-d)\fP Effacer le caractère sous le curseur. Si la ligne est vide et que le dernier caractère saisi n'était pas associé à \fBdelete\-char\fP, alors renvoyer .SM \fBEOF\fP. .TP \fBbackward\-delete\-char (Effacement ou «\ Rubout\ »)\fP Effacer le caractère avant le curseur. Lorsque un argument numérique est indiqué, le texte effacé est sauvegardé dans le tampon circulaire. .TP \fBforward\-backward\-delete\-char\fP 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é. .TP \fBquoted\-insert (C\-q, C\-v)\fP Ajouter littéralement sur la ligne le caractère saisi suivant. Cela permet d'insérer des caractères comme \fBC\-q\fP, par exemple. .TP \fBtab\-insert (C\-v TAB)\fP Insérer un caractère de tabulation. .TP \fBself\-insert (a,\ b,\ A,\ 1,\ !,\ ...)\fP Insérer le caractère mentionné. .TP \fBtranspose\-chars (C\-t)\fP É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. .TP \fBtranspose\-words (M\-t)\fP 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. .TP \fBupcase\-word (M\-u)\fP Transformer le mot actuel (ou le suivant) en majuscules. Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur. .TP \fBdowncase\-word (M\-l)\fP Transformer le mot actuel (ou le suivant) en minuscules. Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur. .TP \fBcapitalize\-word (M\-c)\fP Passer en majuscule l'initiale du mot actuel (ou du suivant). Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur. .TP \fBoverwrite\-mode\fP 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 \fBemacs\fP\ ; le mode \fBvi\fP écrase de façon différente. Chaque appel à \fIreadline()\fP démarre en mode d'insertion. En mode d'écrasement, les caractères associés à \fBself\-insert\fP remplacent le texte sous le curseur plutôt que de déplacer le texte vers la droite. Les caractères associés à \fBbackward\-delete\-char\fP remplacent le caractère avant le curseur par une espace. Par défaut, cette commande n'est pas associée. .PD .SS "Effacement et récupération" .PP .PD 0 .TP \fBkill\-line (C\-k)\fP Effacer le texte depuis la position du curseur jusqu'à la fin de la ligne. .TP \fBbackward\-kill\-line (C\-x Effacement)\fP Effacer en arrière jusqu'au début de ligne. .TP \fBunix\-line\-discard (C\-u)\fP .\" There is no real difference between this and backward-kill-line Effacer le texte entre le début de la ligne et la position du curseur. Le texte est sauvegardé dans le tampon circulaire. .TP \fBkill\-whole\-line\fP Effacer toute la ligne sans tenir compte de la position du curseur. .TP \fBkill\-word (M\-d)\fP Effacer le texte entre le curseur et la fin du mot actuel ou, si entre des mots, jusqu'à la fin du mot suivant. Les limites des mots sont identiques à celles utilisées par \fBforward\-word\fP. .TP \fBbackward\-kill\-word (M\-Effacement)\fP Effacer le mot sous le curseur. Les limites de mots sont identiques à celles utilisées par \fBbackward\-word\fP. .TP \fBshell\-kill\-word (M\-d)\fP Effacer le texte entre le curseur et la fin du mot actuel ou, si entre des mots, jusqu'à la fin du mot suivant. Les limites des mots sont identiques à celles utilisées par \fBshell\-forward\-word\fP. .TP \fBshell\-backward\-kill\-word (M\-Effacement)\fP Effacer le mot sous le curseur. Les limites de mots sont identiques à celles utilisées par \fBshell\-backward\-word\fP. .TP \fBunix\-word\-rubout (C\-w)\fP Effacer le mot sous le curseur, en utilisant une espace blanche comme limite de mot. Le texte effacé est sauvegardé dans le tampon circulaire. .TP \fBunix\-filename\-rubout\fP 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. .TP \fBdelete\-horizontal\-space (M\-\e)\fP Effacer toutes les espaces blanches et les tabulations autour du curseur. .TP \fBkill\-region\fP Effacer le texte de la zone actuelle. .TP \fBcopy\-region\-as\-kill\fP Copier le texte de la zone vers le tampon circulaire. .TP \fBcopy\-backward\-word\fP Copier le mot précédant le curseur dans le tampon circulaire. Les limites de mots sont identiques à celles de \fBbackward\-word\fP. .TP \fBcopy\-forward\-word\fP Copier le mot suivant le curseur dans le tampon circulaire. Les limites de mots sont identiques à celles de \fBforward\-word\fP. .TP \fByank (C\-y)\fP Récupérer le texte au sommet du tampon circulaire à la position du curseur dans le tampon. .TP \fByank\-pop (M\-y)\fP Exécuter une rotation du tampon circulaire et récupérer le texte situé à son nouveau sommet. Cela ne fonctionne qu'après \fByank\fP ou \fByank\-pop\fP. .PD .SS "Arguments numériques" .PP .PD 0 .TP \fBdigit\-argument (M\-0, M\-1, ..., M\-\-)\fP Ajouter ce chiffre à l'argument en cours de rédaction ou créer un nouvel argument. M\-\- crée un argument négatif. .TP \fBuniversal\-argument\fP Il s'agit d'une autre façon d'indiquer un argument. Si cette commande est suivie d'un ou plusieurs chiffres facultativement précédés d'un signe moins, ces chiffres définissent l'argument. Si la commande est suivie de chiffres, une nouvelle exécution de \fBuniversal\-argument\fP 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. .PD .SS Complètement .PP .PD 0 .TP \fBcomplete (TAB)\fP Essayer d'effectuer un complètement du texte situé avant le curseur. \fBBash\fP effectue le complètement en considérant tour à tour le texte comme une variable (s'il commence par \fB$\fP), un nom d'utilisateur (s'il commence par \fB~\fP), un nom de machine (s'il commence par \fB@\fP) ou une commande (y compris les alias et les fonctions). Si aucun ne correspond, un complètement de nom de fichier est essayé. .TP \fBpossible\-completions (M\-?)\fP Affiche les complètements possibles pour le texte situé avant le curseur. .TP \fBinsert\-completions (M\-*)\fP Insérer avant le curseur l'ensemble des complètements qui auraient été produits par \fBpossible\-completions\fP. .TP \fBmenu\-complete\fP Analogue à \fBcomplete\fP, 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 \fBmenu\-complete\fP 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 \fBbell\-style\fP) et le texte original est restauré. Un argument de \fIn\fP déplace de \fIn\fP 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 \fBTAB\fP, mais ne l'est pas par défaut. .TP \fBmenu\-complete\-backward\fP Identique à \fBmenu\-complete\fP, mais se déplace en arrière dans la liste des complètements possibles, comme si un argument négatif avait été passé à \fBmenu\-complete\fP. Cette commande n'est associée à aucune touche par défaut. .TP \fBdelete\-char\-or\-list\fP Effacer le caractère sous le curseur sauf au début ou en fin de ligne (comme \fBdelete\-char\fP). En fin de ligne, se comporte comme \fBpossible\-completions\fP. Cette commande n'est associée à aucune touche par défaut. .TP \fBcomplete\-filename (M\-/)\fP Essayer le complètement des noms de fichiers sur le texte situé avant le curseur. .TP \fBpossible\-filename\-completions (C\-x /)\fP Afficher les complètements possibles du texte situé avant le curseur, traité comme un nom de fichier. .TP \fBcomplete\-username (M\-~)\fP Essayer le complètement sur le texte situé avant le curseur, en le traitant comme un nom d'utilisateur. .TP \fBpossible\-username\-completions (C\-x ~)\fP Afficher les complètements possibles du texte situé avant le curseur, en le traitant comme un nom d'utilisateur. .TP \fBcomplete\-variable (M\-$)\fP Essayer le complètement sur le texte situé avant le curseur, en le traitant comme une variable de l'interpréteur. .TP \fBpossible\-variable\-completions (C\-x $)\fP Afficher les complètements possibles du texte situé avant le curseur, en le traitant comme une variable de l'interpréteur. .TP \fBcomplete\-hostname (M\-@)\fP Essayer le complètement sur le texte situé avant le curseur, en le traitant comme un nom de machine. .TP \fBpossible\-hostname\-completions (C\-x @)\fP Afficher les complètements possibles du texte situé avant le curseur, en le traitant comme un nom de machine. .TP \fBcomplete\-command (M\-!)\fP 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. .TP \fBpossible\-command\-completions (C\-x\ !)\fP Afficher les complètements possibles du texte situé avant le curseur, en le traitant comme un nom de commande. .TP \fBdynamic\-complete\-history (M\-TAB)\fP 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. .TP \fBdabbrev\-expand\fP Essayer le menu de complètement du texte situé avant le curseur, en le comparant aux lignes de la file d'historique lui correspondant pour les complètements possibles. .TP \fBcomplete\-into\-braces (M\-{)\fP 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 (consultez \fBDéveloppement des accolades\fP ci\-dessus). .PD .SS "Macros clavier" .PP .PD 0 .TP \fBstart\-kbd\-macro (C\-x (\^)\fP Démarre la mémorisation dans la macro en cours des caractères tapés. .TP \fBend\-kbd\-macro (C\-x )\^)\fP Arrête la mémorisation dans la macro en cours des caractères saisis et conserve la définition. .TP \fBcall\-last\-kbd\-macro (C\-x e)\fP Ré\-exécute la dernière macro définie, en agissant comme si les caractères contenus dans cette macro étaient saisis au clavier. .PD .SS Divers .PP .PD 0 .TP \fBre\-read\-init\-file (C\-x C\-r)\fP Lire le contenu du fichier \fIinputrc\fP et prendre en compte tous raccourcis ou affectations de variables qui s'y trouvent. .TP \fBabort (C\-g)\fP Abandonner l'édition en cours et émettre une alarme de terminal (selon la configuration de la variable \fBbell\-style\fP). .TP \fBdo\-uppercase\-version (M\-a, M\-b, M\-\fP\fIx\fP\fB, ...)\fP Si le caractère \fIx\fP précédé de Méta est en minuscule, exécuter la commande qui est associée aux caractères majuscules correspondants. .TP \fBprefix\-meta (ESC)\fP Considérer le prochain caractère saisi comme un Méta. .SM \fBESC\fP \fBf\fP est équivalent à \fBMeta\-f\fP. .TP \fBundo (C\-_, C\-x C\-u)\fP Fonction d'annulation incrémentale, chaque ligne étant mémorisée séparément. .TP \fBrevert\-line (M\-r)\fP Annuler toutes les modifications sur cette ligne. Cela est équivalent à répéter \fBundo\fP en nombre suffisant pour ramener la ligne à son état initial. .TP \fBtilde\-expand (M\-&)\fP Effectuer le développement du tilde sur le mot actuel. .TP \fBset\-mark (C\-@, M\-)\fP Placer la marque à la position actuelle du curseur. Si un argument numérique est fourni, la marque est posée à la position correspondante. .TP \fBexchange\-point\-and\-mark (C\-x C\-x)\fP Échanger le curseur et la marque. La position actuelle du curseur est configurée à la position sauvegardée précédemment et l'ancienne position du curseur est mémorisée comme la marque. .TP \fBcharacter\-search (C\-])\fP 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. .TP \fBcharacter\-search\-backward (M\-C\-])\fP 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. .TP \fBskip\-csi\-sequence\fP Lit suffisamment de caractères pour consommer une suite multitouche comme celles définies pour des touches comme Début et Fin. De telles suites commencent par un indicateur de suite de contrôle («\ control sequence indicator\ » ou CSI), habituellement ESC\-[. Si cette suite est associée à "\e[", les touches qui produisent de telles suites n'auront pas d'effet à moins d'être explicitement associées à une commande readline, au lieu d'insérer des caractères égarés dans le tampon d'édition. N'est associée à aucune touche par défaut, mais est souvent associé à ESC\-[. .TP \fBinsert\-comment (M\-#)\fP Sans argument numérique, la valeur de la variable \fBcomment\-begin\fP de readline est insérée au début de la ligne actuelle. 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 \fBcomment\-begin\fP, la valeur est insérée, sinon, les caractères de \fBcomment\-begin\fP sont effacés du début de la ligne. Dans les deux cas, la ligne est acceptée comme si un changement de ligne avait été saisi. La valeur par défaut de \fBcomment\-begin\fP conduit cette commande à transformer la ligne actuelle 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. .TP \fBglob\-complete\-word (M\-g)\fP 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. .TP \fBglob\-expand\-word (C\-x *)\fP 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. .TP \fBglob\-list\-expansions (C\-x g)\fP La liste des développements qui aurait été produite par \fBglob\-expand\-word\fP 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. .TP \fBdump\-functions\fP Afficher toutes les fonctions et leurs raccourcis clavier sur le flux de sortie de readline. Si un argument numérique est fourni, la sortie est mise en forme de façon à être incorporée dans un fichier \fIinputrc\fP. .TP \fBdump\-variables\fP Afficher toutes les variables readline modifiables et leurs valeurs sur le flux de sortie de readline. Si un argument numérique est fourni, la sortie est mise en forme de façon à être incorporée dans un fichier \fIinputrc\fP. .TP \fBdump\-macros\fP Afficher toutes les suites de touches readline associées à des macros et les chaînes auxquelles elles correspondent. Si un argument numérique est fourni, la sortie est mise en forme de façon à être incorporée dans un fichier \fIinputrc\fP. .TP \fBdisplay\-shell\-version (C\-x C\-v)\fP Afficher des informations sur la version actuelle de \fBbash\fP. .PD .SS "Complètement programmable" .PP 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 \fBcomplete\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous), les outils de complètement programmables sont appelés. .PP En premier lieu, le nom de la commande est identifié. Si le mot de commande est vide (complètement essayé en début de ligne vide), toutes les spécifications de complètement définies par l'option \fB\-E\fP de \fBcomplete\fP sont utilisées. Si une spécification de complètement a été définie pour cette commande, elle est utilisée pour produire la liste des complètements possibles pour le mot. Si le mot de commande est un chemin d'accès complet, on cherche en premier lieu une spécification de complètement pour le chemin d'accès complet. Si aucune spécification de complètement n'est trouvée pour le chemin d'accès complet, une tentative est effectuée pour trouver une spécification de complètement pour la partie située après la barre oblique finale. Si ces recherches ne donnent aucun résultat sous forme de spécification de complètement, toutes les spécifications de complètement définies par l'option \fB\-D\fP de \fBcomplete\fP sont utilisées par défaut. .PP 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 \fBbash\fP, tel que décrit ci\-dessus dans \fBComplètement\fP est effectué. .PP Tout d'abord, les actions définies par la spécification de complètement sont utilisées. Seules les correspondances préfixées par le mot à compléter sont renvoyées. Lorsque l'option \fB\-f\fP ou \fB\-d\fP est utilisée pour le complètement des noms de fichiers ou de répertoire, la variable de l'interpréteur .SM \fBFIGNORE\fP est utilisée pour filtrer les correspondances. .PP Tous les complètements indiqués par le motif de développement de chemin de l'option \fB\-G\fP 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 .SM \fBGLOBIGNORE\fP n'est pas utilisée pour filtrer les correspondances, mais la variable .SM \fBFIGNORE\fP est utilisée. .PP Ensuite, la chaîne indiquée comme argument à l'option \fB\-W\fP est prise en compte. Cette chaîne est tout d'abord découpée en utilisant les caractères de la variable spéciale .SM \fBIFS\fP comme délimiteurs. Les protections de l'interpréteur sont prises en compte. Chaque mot est ensuite développé en utilisant les développements d'accolades, du tilde, des paramètres et des variables, de même que la substitution de commande et le développement arithmétique comme décrit ci\-dessus dans .SM \fBDÉVELOPPEMENTS\fP. Les résultats sont découpés en utilisant les règles décrites ci\-dessus dans \fBDécoupage en mots\fP. 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. .PP Après la création de ces correspondances, toute fonction de l'interpréteur ou commande indiquée avec les options \fB\-F\fP et \fB\-C\fP est appelée. Lorsque la commande ou la fonction est appelée, les variables .SM \fBCOMP_LINE\fP, .SM \fBCOMP_POINT\fP, .SM \fBCOMP_LINKEY\fP, et .SM \fBCOMP_POINTYPE\fP se voient affectées de valeurs comme décrit ci\-dessus dans \fBVariables de l'interpréteur\fP. Si une fonction de l'interpréteur est appelée, les variables .SM \fBCOMP_WORDS\fP et .SM \fBCOMP_CWORD\fP sont également créées. Lorsqu'une fonction ou une commande est appelée, le premier argument est le nom de la commande dont les arguments doivent être complétés, le second argument est le mot à compléter et le troisième argument est le mot précédent celui devant être complété sur la ligne de commande. Aucun filtrage des complètements produits pour le mot à compléter n'est effectué\ ; la fonction ou la commande a toute liberté dans la production des correspondances. .PP Toute fonction indiquée avec \fB\-F\fP est appelée en premier. La fonction peut utiliser tous les outils de l'interpréteur, incluant la commande interne \fBcompgen\fP décrite ci\-dessous, pour produire les correspondances. Elle doit mettre les complètements possibles dans la variable tableau .SM \fBCOMPREPLY\fP. .PP Ensuite, toute commande indiquée avec l'option \fB\-C\fP 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 changement de ligne. .PP Après la création de tous les complètements possibles, tout filtre, indiqué avec l'option \fB\-X\fP, est appliqué à la liste. Ce filtre est un motif comme dans le développement des chemins\ ; un \fB&\fP dans le motif est remplacé par le texte du mot en cours de complètement. Un \fB&\fP 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 \fB!\fP 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. .PP Finalement, tous préfixe et suffixe indiqués avec les options \fB\-P\fP et \fB\-S\fP 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. .PP Si les opérations précédemment appliquées ne produisent aucune correspondance et si l'option \fB\-o dirnames\fP a été fournie à \fBcomplete\fP lorsque la spécification de complètement a été définie, le complètement des noms de répertoire est tenté. .PP Si l'option \fB\-o plusdirs\fP a été fournie à \fBcomplete\fP 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. .PP 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 \fBbash\fP ne sont pas tentés et le complètement de fichiers par défaut de readline est désactivé. Si l'option \fB\-o bashdefault\fP a été fournie à \fBcomplete\fP lors de la définition de la spécification de complètement, les complètements par défaut de \fBbash\fP sont tentés si la spécification de complètement ne produit aucune correspondance. Si l'option \fB\-o default\fP a été fournie à \fBcomplete\fP 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 \fBbash\fP) ne produit aucune correspondance. .PP 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 \fBmark\-directories\fP de readline, indépendamment du paramétrage de la variable \fBmark\-symlinked\-directories\fP de readline. .PP La modification dynamique des complètements est également possible. C'est particulièrement utile combiné avec un complètement par défaut indiqué à l'aide de \fBcomplete \-D\fP. Les fonctions de l'interpréteur exécutés comme gestionnaires de complètement permettent d'annoncer que le complètement devrait être réessayé en renvoyant un état final de 124. Si une fonction de l'interpréteur renvoie 124, et modifie la spécification de complètement associée à la commande sur laquelle le complètement est essayé (fournie comme premier argument quand la fonction est exécutée), le complètement programmable recommence depuis le début, en essayant de trouver une nouvelle spécification de complètement pour cette commande. Un jeu de complètements peut ainsi être construit dynamiquement lorsque le complètement est essayé, plutôt que d'être chargé entièrement au début. .PP Par exemple, en supposant l'existence d'une bibliothèque de spécifications de complètement, chacune conservée dans un fichier correspondant au nom de la commande, la fonction de complètement par défaut suivante chargerait les complètements de façon dynamique\ : .PP \f(CW_completion_loader()\fP .br \f(CW{\fP .br \f(CW . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124\fP .br \f(CW}\fP .br \f(CWcomplete \-D \-F _completion_loader\fP .br \fP .SH HISTORIQUE Quand l'option \fB\-o history\fP de la commande interne \fBset\fP est activée, l'interpréteur donne accès à un \fIhistorique des commandes\fP, c'est\-à\-dire la liste des commandes précédemment utilisées. La valeur de la variable .SM \fBHISTSIZE\fP est utilisée comme nombre de commandes à sauvegarder dans la file d'historique. Le texte des .SM \fBHISTSIZE\fP 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 (consultez .SM \fBDÉVELOPPEMENTS\fP ci\-dessus) mais après avoir effectué le développement de l'historique, selon les valeurs des variables de l'interpréteur .SM \fBHISTIGNORE\fP et .SM \fBHISTCONTROL\fP. .PP Au démarrage, l'historique est initialisé avec le fichier dont le nom est contenu dans la variable .SM \fBHISTFILE\fP (par défaut \fI~/.bash_history\fP). Le fichier désigné par la valeur de .SM \fBHISTFILE\fP est tronqué si nécessaire, pour ne pas contenir plus de lignes que le nombre précisé par .SM \fBHISTFILESIZE\fP. Quand le fichier d'historique est lu, les lignes commençant par le caractère de commentaire d'historique suivi immédiatement par un chiffre sont considérées comme des horodatages de la ligne d'historique précédente. Ces horodatages sont facultativement affichés en fonction de la valeur de la variable .SM \fBHISTTIMEFORMAT\fP. Lorsqu'un interpréteur interactif termine, les .SM \fBHISTSIZE\fP dernières lignes de la file d'historique sont copiées dans le fichier .SM \fBHISTFILE\fP. Si l'option d'interpréteur \fBhistappend\fP est activée (consultez la description de \fBshopt\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous), les lignes sont ajoutées au fichier d'historique, sinon le fichier est écrasé. Si .SM \fBHISTFILE\fP est inexistante ou si le fichier d'historique n'est pas accessible en écriture, l'historique n'est pas sauvegardé. Si la variable .SM \fBHISTTIMEFORMAT\fP est configurée, les horodatages sont écrits dans le fichier d'historique, repérés par le caractère de commentaire d'historique, afin d'être conservés au fur et à mesure des sessions de l'interpréteur. Le caractère de commentaire d'historique est utilisé pour distinguer l'horodatage des autres lignes de l'historique. Après la sauvegarde de l'historique, le fichier d'historique est tronqué pour ne pas contenir plus de .SM \fBHISTFILESIZE\fP lignes. Si .SM \fBHISTFILESIZE\fP n'existe pas, aucune troncature n'est effectuée. .PP La commande interne \fBfc\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous) permet d'afficher, d'éditer ou de ré\-exécuter une partie de la file d'historique. La commande interne \fBhistory\fP 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. .PP L'interpréteur permet de configurer quelles commandes seront sauvegardées dans la file d'historique. Les variables .SM \fBHISTCONTROL\fP et .SM \fBHISTIGNORE\fP peuvent être configurées pour conduire l'interpréteur à ne sauvegarder qu'un sous\-ensemble des commandes saisies. L'option d'interpréteur \fBcmdhist\fP, 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 \fBlithist\fP conduit l'interpréteur à sauvegarder les commandes avec des changements de ligne incorporés plutôt que des points\-virgules. Consultez ci\-dessous la description de la commande interne \fBshopt\fP dans .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP pour des détails sur la création et la destruction des options d'interpréteur. .SH "DÉVELOPPEMENT DE L'HISTORIQUE" .PP L'interpréteur propose des possibilités de développement de l'historique qui sont semblables à celles de \fBcsh\fP. 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 \fB\+H\fP de la commande interne \fBset\fP (consultez .SM \fBCOMMANDES INTERNES DE L'INTERPRÉTEUR\fP ci\-dessous). Les interpréteurs non interactifs n'effectuent pas de développement d'historique par défaut. .PP Le développement de l'historique permet d'insérer des mots de la file d'historique dans le flux de saisie, facilitant la répétition de commandes, l'insertion des arguments d'une ligne antérieure dans la saisie en cours ou la correction rapide d'erreurs dans les commandes précédentes. .PP 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'\fIévénement\fP et les parties de cette ligne à réutiliser sont des \fImots\fP. Plusieurs \fImodificateurs\fP 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 \fImétacaractères\fP 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 \^\fB!\fP\^ par défaut. Seule la contre\-oblique (\^\fB\e\fP\^) et les guillemets simples permettent de protéger le caractère de développement de l'historique. .PP 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, changement de ligne, retour chariot et \fB=\fP. Si l'option d'interpréteur \fBextglob\fP est activée, \fB(\fP empêchera aussi le développement. .PP Plusieurs options d'interpréteur, configurables avec la commande interne \fBshopt\fP, permettent d'ajuster le comportement du développement de l'historique. Si l'option d'interpréteur \fBhistverify\fP est activée (consultez la description de la commande interne \fBshopt\fP ci\-dessous) et si \fBreadline\fP est utilisée, les substitutions d'historique ne sont pas transmises tout de suite à l'analyseur de l'interpréteur. À la place, la ligne développée est rechargée dans le tampon d'édition de \fBreadline\fP pour permettre des modifications ultérieures. Si \fBreadline\fP est utilisée et si l'option \fBhistreedit\fP est activée, une substitution d'historique qui échoue est rechargée dans la mémoire tampon de \fBreadline\fP pour correction. L'option \fB\-p\fP de la commande interne \fBhistory\fP peut servir à examiner ce qu'une substitution donnera avant de l'employer réellement. L'option \fB\-s\fP de la commande interne \fBhistory\fP 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. .PP L'interpréteur offre le contrôle des divers caractères utilisés par le mécanisme de développement de l'historique (consultez la description de \fBhistchars\fP ci\-dessus dans \fBVariables de l'interpréteur\fP). L'interpréteur utilise le caractère de commentaire d'historique pour repérer l'horodatage lors de l'écriture du fichier d'historique. .SS "Indicateur d'événement" .PP Un indicateur d'événement est une référence à un élément ligne de commande dans la file d'historique. Sauf s'il s'agit d'une référence absolue, les événements sont relatifs à la position actuelle dans la file d'historique. .PP .PD 0 .TP \fB!\fP Débute une substitution d'historique, sauf s'il est suivi par un \fBblanc\fP, changement de ligne, retour chariot, = ou ( (lorsque l'option d'interpréteur \fBextglob\fP est activée en utilisant la commande interne \fBshopt\fP). .TP \fB!\fP\fIn\fP Se rapporte à la ligne de commande \fIn\fP. .TP \fB!\-\fP\fIn\fP Se rapporte à la commande actuelle moins \fIn\fP. .TP \fB!!\fP Se rapporte à la commande précédente. C'est un synonyme de «\ !\-1\ ». .TP \fB!\fP\fIchaîne\fP Se rapporte à la commande la plus récente précédent la position actuelle dans la liste d'historique commençant par \fIchaîne\fP. .TP \fB!?\fP\fIchaîne\fP[\fB?\fP] Se rapporte à la commande la plus récente précédent la position actuelle dans la liste d'historique contenant \fIchaîne\fP. Le \fB?\fP final peut être omis si \fIchaîne\fP est immédiatement suivie d'un changement de ligne. .TP \fB\d\s+2^\s-2\u\fP\fIchaîne_1\fP\fB\d\s+2^\s-2\u\fP\fIchaîne_2\fP\fB\d\s+2^\s-2\u\fP Substitution rapide. Répéter la commande précédente en remplaçant \fIchaîne_1\fP par \fIchaîne_2\fP. Équivalent à «\ \fB!!:s/\fP\fIchaîne_1\fP\fB/\fP\fIchaîne_2\fP\fB/\fP\ » (consultez \fBModificateurs\fP ci\-dessous). .TP \fB!#\fP La ligne entière tapée jusqu'à présent. .PD .SS "Indicateurs de mots" .PP Ces indicateurs servent à sélectionner les mots désirés dans un événement. Un \fB:\fP sépare l'indicateur d'événements de l'indicateur de mot. On peut l'omettre si l'indicateur de mot commence par \fB^\fP, \fB$\fP, \fB*\fP, \fB\-\fP ou \fB%\fP. Les mots sont numérotés depuis le début de la ligne, le premier étant noté \fB0\fP (zéro). Les mots sont insérés dans la ligne actuelle, séparés par des espaces. .PP .PD 0 .TP \fB0\fP (zéro) Le zéro\-ième mot. Pour l'interpréteur, c'est le nom de la commande. .TP \fIn\fP Le \fIn\fP\-ième mot. .TP \fB^\fP Le premier argument, c'est\-à\-dire le mot 1. .TP \fB$\fP Le dernier argument. .TP \fB%\fP Le mot correspondant à la recherche «\ ?\fIchaîne\fP?\ » la plus récente. .TP \fIx\fP\fB\-\fP\fIy\fP Une plage de mots, «\ \fB\-\fP\fIy\fP\ » permet d'abréger «\ \fB0\-\fP\fIy\fP\ ». .TP \fB*\fP Tous les mots sauf le zéro\-ième. C'est un synonyme pour «\ \fB1\-$\fP\ ». Il n'est pas erroné d'utiliser \fB*\fP s'il n'y a qu'un mot dans l'événement\ ; la chaîne vide est renvoyée dans ce cas. .TP \fIx\fP\fB*\fP Abréviation de \fIx\fP\fB\-$\fP. .TP \fIx\fP\fB\-\fP Abréviation de \fIx\fP\fB\-$\fP comme \fIx\fP\fB*\fP, mais sans le dernier mot. .PD .PP Si un indicateur de mot est fourni sans indication d'événement, la dernière commande est utilisée. .SS Modificateurs .PP 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 «\ :\ ». .PP .PD 0 .PP .TP \fBh\fP Élimine la fin du chemin d'accès, ne laissant que son début. .TP \fBt\fP Supprime tout le début d'un chemin d'accès, en ne laissant que la fin. .TP \fBr\fP Supprime un suffixe final de la forme \fI.xxx\fP, en ne laissant que le nom de base. .TP \fBe\fP Supprime tout sauf le suffixe final. .TP \fBp\fP Affiche la nouvelle commande sans l'exécuter. .TP \fBq\fP Protège les mots substitués, pour éviter des substitutions futures. .TP \fBx\fP Protège les mots substitués comme avec \fBq\fP, mais avec séparation des mots aux \fBblancs\fP et changements de ligne. .TP \fBs/\fP\fIancien\fP\fB/\fP\fInouveau\fP\fB/\fP Remplace par \fInouveau\fP la première occurrence de \fIancien\fP 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 \fIancien\fP et \fInouveau\fP avec une seule contre\-oblique. Si & apparaît dans \fInouveau\fP, il est remplacé par \fIancien\fP. Une seule contre\-oblique protégera le &. Si \fIancien\fP est vide, il est configuré au dernier \fIancien\fP substitué ou si aucune substitution n'a eu lieu précédemment, la dernière \fIchaîne\fP dans une recherche \fB!?\fP\fIchaîne\fP\fB[?]\fP. .TP \fB&\fP Répète la substitution précédente. .TP \fBg\fP Conduit à l'application des changements sur la ligne d'événement entière. C'est utilisé conjointement à «\ \fB:s\fP\ » (par exemple «\ \fB:gs/\fP\fIancien\fP\fB/\fP\fInouveau\fP\fB/\fP\ ») ou «\ \fB:&\fP\ ». Si utilisé avec «\ \fB:s\fP\ », 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 \fBa\fP peut être utilisé en tant que synonyme de \fBg\fP. .TP \fBG\fP Applique le modificateur «\ \fBs\fP\ » suivant une fois à chacun des mots de la ligne d'événements. .PD .SH "COMMANDES INTERNES DE L'INTERPRÉTEUR" .\" start of bash_builtins .zZ .PP Sauf indication contraire, chaque commande interne décrite dans ce paragraphe comme acceptant des options précédées par \fB\-\fP accepte également la notation \fB\-\-\fP pour signaler la fin des options. Les commandes internes \fB:\fP, \fBtrue\fP, \fBfalse\fP et \fBtest\fP n'acceptent aucune option et \fB\-\-\fP est ignoré. Les commandes internes \fBexit\fP, \fBlogout\fP, \fBbreak\fP, \fBcontinue\fP, \fBlet\fP et \fBshift\fP acceptent et traitent les arguments commençant par \fB\-\fP sans avoir besoin de \fB\-\-\fP. Les autres commandes internes qui acceptent les arguments mais qui ne sont pas déclarés explicitement comme acceptant des options considèrent les arguments commençant par \fB\-\fP comme des options non valides, donc \fB\-\-\fP est obligatoire pour éviter cette interprétation. .sp .5 .PD 0 .TP \fB:\fP [\fIarguments\fP] .PD Sans effet\ ; cette commande ne fait rien d'autre que développer les \fIarguments\fP et effectuer toute redirection indiquée. Un code final de zéro est renvoyé. .TP \fB.\| \fP \fIfichier\fP [\fIarguments\fP] .PD 0 .TP \fBsource\fP \fIfichier\fP [\fIarguments\fP] .PD Lit et exécute les commandes contenues dans \fIfichier\fP avec l'environnement de l'interpréteur actuel, puis renvoie l'état final de la dernière commande exécutée dans \fIfichier\fP. Si le nom du \fIfichier\fP ne contient pas de barre oblique, les chemins d'accès contenus dans .SM \fBPATH\fP sont parcourus pour rechercher le répertoire contenant le \fIfichier\fP. Lorsqu'il est recherché dans .SM \fBPATH\fP le fichier n'a pas besoin d'être exécutable. Lorsque \fBbash\fP n'est pas en \fImode posix\fP, le répertoire de travail actuel est finalement examiné si aucun fichier n'est trouvé dans .SM \fBPATH\fP. Si l'option \fBsourcepath\fP de la commande interne \fBshopt\fP est désactivée, le .SM \fBPATH\fP n'est pas parcouru. Si des \fIarguments\fP sont fournis, ils sont transmis dans les paramètres positionnels lorsque le \fIfichier\fP 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 \fIfichier\fP n'est pas trouvé ou ne peut être lu. .TP \fBalias\fP [\fB\-p\fP] [\fInom\fP[=\fIvaleur\fP] ...] La commande \fBalias\fP sans argument ou avec l'option \fB\-p\fP affiche sur la sortie standard la liste des alias actuellement définis, sous la forme \fInom\fP=\fIvaleur\fP. Lorsque des arguments sont fournis, un alias est créé pour chaque \fInom\fP auquel on a donné une \fIvaleur\fP. Une espace finale dans une \fIvaleur\fP conduira à la recherche d'alias dans le mot suivant lors du développement de l'alias. Pour chacun des \fInoms\fP pour lesquels aucune \fIvaleur\fP n'est fournie dans la liste d'arguments, le nom et la valeur de l'alias sont affichés. La commande \fBalias\fP renvoie vrai, à moins qu'un \fInom\fP n'ait été indiqué pour lequel aucun alias n'a été défini. .TP \fBbg\fP [\fItâche\fP ...] Reprend en arrière\-plan chaque \fItâche\fP suspendue, comme si elle avait été lancée avec \fB&\fP. Si aucune \fItâche\fP n'est précisée, la notion d'interpréteur de \fItâche actuelle\fP est utilisée. \fBbg\fP \fItâche\fP renvoie 0 sauf si le contrôle des tâches est désactivé, ou, quand le contrôle des tâches est activé, si une \fItâche\fP précisée n'a pas été trouvée ou a été lancée sans contrôle de tâches. .TP \fBbind\fP [\fB\-m\fP \fIjeu_de_raccourcis\fP] [\fB\-lpsvPSV\fP] .PD 0 .TP \fBbind\fP [\fB\-m\fP \fIjeu_de_raccourcis\fP] [\fB\-q\fP \fIfonction\fP] [\fB\-u\fP \fIfonction\fP] [\fB\-r\fP \fIsuite_de_touches\fP] .TP \fBbind\fP [\fB\-m\fP \fIjeu_de_raccourcis\fP] \fB\-f\fP \fIfichier\fP .TP \fBbind\fP [\fB\-m\fP \fIjeu_de_raccourcis\fP] \fB\-x\fP \fIsuite_de_touches\fP:\fIcommande_de_l'interpréteur\fP .TP \fBbind\fP [\fB\-m\fP \fIjeu_de_raccourcis\fP] \fIsuite_de_touches\fP:\fInom_de_fonction\fP .TP \fBbind\fP \fIcommande_readline\fP .PD Affiche les associations de touches \fBreadline\fP actuelles et les raccourcis de fonctions, associe une suite de touches à une fonction ou une macro \fBreadline\fP ou crée une variable \fBreadline\fP. Chaque argument qui n'est pas une option est une commande comme elle devrait apparaître dans \fI.inputrc\fP, mais chaque raccourci ou commande doit être fourni comme un argument indépendant\ ; par exemple «\ "\eC\-x\eC\-r": re\-read\-init\-file\ ». Les options, si fournies, ont les significations suivantes\ : .RS .PD 0 .TP \fB\-m \fP\fIjeu_de_raccourcis\fP Utiliser le \fIjeu_de_raccourcis\fP comme jeu de raccourcis devant être concerné par les raccourcis ultérieurs. Les noms de \fIjeux_de_raccourcis\fP possibles sont \fIemacs, emacs\-standard, emacs\-meta, emacs\-ctlx, vi, vi\-move, vi\-command\fP et \fIvi\-insert\fP. \fIvi\fP est équivalent à \fIvi\-command\fP\ ; \fIemacs\fP est équivalent à \fIemacs\-standard\fP. .TP \fB\-l\fP Afficher la liste des noms de toutes les fonctions \fBreadline\fP. .TP \fB\-p\fP Afficher les noms des fonctions \fBreadline\fP et leurs raccourcis de façon à pouvoir les relire. .TP \fB\-P\fP Afficher les noms des fonctions \fBreadline\fP et leurs raccourcis. .TP \fB\-s\fP Afficher les suites de touches \fBreadline\fP associées aux macros et les chaînes correspondantes, de façon à pouvoir les relire. .TP \fB\-S\fP Afficher les suites de touches \fBreadline\fP associées aux macros et les chaînes correspondantes. .TP \fB\-v\fP Afficher les noms des variables \fBreadline\fP et leurs valeurs de façon à pouvoir les relire. .TP \fB\-V\fP Afficher les noms des variables \fBreadline\fP et leurs valeurs. .TP \fB\-f \fP\fIfichier\fP Lire les raccourcis clavier dans \fIfichier\fP. .TP \fB\-q \fP\fIfonction\fP Rechercher les touches permettant d'appeler la \fIfonction\fP indiquée. .TP \fB\-u \fP\fIfonction\fP Dissocier toutes les touches associées à \fIfonction\fP. .TP \fB\-r \fP\fIsuite_de_touches\fP Supprimer tout raccourci actuel pour la \fIsuite_de_touches\fP. .TP \fB\-x \fP\fIsuite_de_touches\fP\fB:\fP\fIcommande_de_l'interpréteur\fP Conduire la \fIcommande_de_l'interpréteur\fP à être exécutée chaque fois que la \fIsuite_de_touches\fP est saisie. Quand la \fIcommande_de_l'interpréteur\fP est exécutée, l'interpréteur configure la variable .SM \fBREADLINE_LINE\fP au contenu du tampon de ligne de \fBreadline\fP et la variable .SM \fBREADLINE_POINT\fP à la position actuelle du curseur d'insertion. Si la commande exécutée modifie les valeurs de .SM \fBREADLINE_LINE\fP ou .SM \fBREADLINE_POINT\fP, ces nouvelles valeurs seront prises en considération dans l'état d'édition. .PD .PP La valeur renvoyée est 0, à moins qu'une option inconnue ne soit indiquée ou qu'une erreur ne se soit produite. .RE .TP \fBbreak\fP [\fIn\fP] Sort d'une boucle \fBfor\fP, \fBwhile\fP, \fBuntil\fP ou \fBselect\fP. Si \fIn\fP est indiqué, sort de \fIn\fP niveaux de boucles. \fIn\fP doit être \(>= 1. Si \fIn\fP est supérieur au nombre de boucles imbriquées, on sort de l'ensemble d'entre elles. La valeur renvoyée est 0, à moins que \fIn\fP ne soit pas plus grand ou égal à 1. .TP \fBbuiltin\fP \fIcommande_interne\fP [\fIarguments\fP] Exécute la \fIcommande interne\fP de l'interpréteur indiquée, en lui passant les \fIarguments\fP, puis renvoie son état final. C'est utile lorsqu'une fonction est définie avec le même nom qu'une commande interne, et que cette commande est appelée depuis l'intérieur de la fonction. La commande interne \fBcd\fP est souvent redéfinie de cette façon. L'état renvoyé est faux si la \fIcommande_interne\fP n'est pas une commande interne de l'interpréteur. .TP \fBcaller\fP [\fIexpr\fP] Renvoie le contexte de tout appel de sous\-programme actif (une fonction de l'interpréteur ou un script lancé avec les commandes internes \fB.\fP ou \fBsource\fP). Sans \fIexpr\fP, \fBcaller\fP affiche le numéro de ligne et le nom de fichier du sous\-programme actuel. Si un entier positif est fourni comme \fIexpr\fP, \fBcaller\fP 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 actuelle. Cette information supplémentaire peut être utilisée, par exemple, pour afficher une trace de la pile. La trame actuelle 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 \fIexpr\fP ne corresponde pas à une position correcte dans la pile d'appels. .TP \fBcd\fP [\fB\-L\fP|\fB\-P\fP [\fB\-e\fP]] [\fIrép\fP] Remplace le répertoire de travail actuel par \fIrép\fP. La variable .SM \fBHOME\fP est la valeur par défaut de \fIrép\fP. La variable .SM \fBCDPATH\fP définit des chemins de recherche pour trouver le répertoire contenant \fIrép\fP. Les répertoires possibles y sont fournis dans une liste séparées par des deux\-points «\ \fB:\fP\ ». Un nom de répertoire vide dans .SM \fBCDPATH\fP est équivalent au répertoire actuel, c'est\-à\-dire «\ \fB.\fP\ ». Si \fIrép\fP commence par une barre oblique (\fB/\fP), alors .SM \fBCDPATH\fP n'est pas utilisé. L'option \fB\-P\fP indique de n'employer que la structure de répertoires physiques au lieu de suivre les liens symboliques (consultez aussi l'option \fB\-P\fP de la commande interne \fBset\fP) l'option \fB\-L\fP force à suivre les liens symboliques. Si l'option \fB\-e\fP est fournie avec \fB\-P\fP, et que le répertoire de travail actuel ne peut pas être déterminé avec succès après un changement de répertoire avec succès, \fBcd\fP reverra un état d'échec. Un argument \fB\-\fP est équivalent à .SM \fB$OLDPWD\fP. Si un nom de répertoire non vide de .SM \fBCDPATH\fP est utilisé ou si \fB\-\fP 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. .TP \fBcommand\fP [\fB\-pVv\fP] \fIcommande\fP [\fIarguments\fP ...] Lance la \fIcommande\fP avec les \fIarguments\fP indiqués, mais en simplifiant le processus habituel de recherche des commandes. Seules les commandes internes et les commandes trouvées dans .SM \fBPATH\fP seront exécutées. Si l'option \fB\-p\fP est indiquée, la recherche de la \fIcommande\fP est effectuée en utilisant une valeur par défaut pour .SM \fBPATH\fP garantissant de trouver tous les utilitaires standards. Si l'option \fB\-V\fP ou \fB\-v\fP est fournie, une description de la \fIcommande\fP est affichée. L'option \fB\-v\fP conduit à n'afficher qu'un seul mot indiquant la commande ou le nom de fichier utilisé pour appeler la \fIcommande\fP. L'option \fB\-V\fP fournit une description plus prolixe. Si l'option \fB\-V\fP ou \fB\-v\fP est fournie, l'état final est 0 si la \fIcommande\fP a été trouvée et 1 sinon. Si aucune option n'est fournie et si une erreur s'est produite ou si la \fIcommande\fP ne peut être trouvée, l'état final est 127. Sinon, l'état final de la commande interne est l'état final de \fIcommande\fP. .TP \fBcompgen\fP [\fIoption\fP] [\fImot\fP] Produit les correspondances des complètements possibles pour \fImot\fP selon les \fIoption\fPs, qui peuvent être toute option acceptée par la commande interne \fBcomplete\fP à l'exception de \fB\-p\fP et \fB\-r\fP et écrit le résultat sur la sortie standard. Lorsqu'on utilise les options \fB\-F\fP ou \fB\-C\fP, les diverses variables de l'interpréteur créées par les outils de complètement programmables, lorsque disponibles, n'auront pas de valeurs utilisables. .sp 1 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 \fImot\fP est indiqué, seuls les complètements qui correspondent à \fImot\fP sont affichés. .sp 1 La valeur renvoyée est vrai, sauf si une option incorrecte a été fournie ou si aucune correspondance n'a été produite. .TP \fBcomplete\fP [\fB\-abcdefgjksuv\fP] [\fB\-o\fP \fIoption\-complètement\fP] [\fB\-DE\fP] [\fB\-A\fP \fIaction\fP] [\fB\-G\fP \fIglobpat\fP] [\fB\-W\fP \fIliste_de_mots\fP] [\fB\-F\fP \fIfonction\fP] [\fB\-C\fP \fIcommande\fP] .br [\fB\-X\fP \fImotif_filtre\fP] [\fB\-P\fP \fIpréfixe\fP] [\fB\-S\fP \fIsuffixe\fP] \fInom\fP [\fInom\fP \&...] .PD 0 .TP \fBcomplete\fP \fB\-pr\fP [\fB\-DE\fP] [\fInom\fP ...] .PD Indique comment les arguments de chaque \fInom\fP doivent être complétés. Si l'option \fB\-p\fP est fournie ou si aucune option n'est fournie, les spécifications de complètement existantes sont affichées de telle façon qu'elles puissent être réutilisées comme entrée. L'option \fB\-r\fP retire une spécification de complètement à chaque \fInom\fP fourni ou, si aucun \fInom\fP n'est fourni, toutes les spécifications de complètement. L'option \fB\-D\fP indique que les options restantes et les actions devraient s'appliquer à la commande de complètement par «\ défaut\ », c'est\-à\-dire le complètement essayé sur une commande pour laquelle aucun complètement n'a été préalablement défini. L'option \fB\-E\fP indique que les options restantes et les actions devraient s'appliquer à la commande de complètement «\ vide\ », c'est\-à\-dire le complètement essayé sur une ligne vide. .sp 1 Le processus d'application de ces spécifications de complètement, lorsqu'un complètement de mot est tenté, est décrit ci\-dessus dans \fBComplètement programmable\fP. .sp 1 Les autres options, si indiquées, ont les significations suivantes. Les arguments des options \fB\-G\fP, \fB\-W\fP et \fB\-X\fP (et, si nécessaire, les options \fB\-P\fP et \fB\-S\fP) devraient être protégées pour éviter leur développement avant que la commande interne \fBcomplete\fP ne soit appelée. .RS .PD 0 .TP 8 \fB\-o\fP \fIoption\-complètement\fP L'\fIoption\-complètement\fP commande plusieurs aspects du comportement des spécifications de complètement au\-delà de la simple production de complètement. \fIoption\-complètement\fP peut être l'une des suivantes\ : .RS .TP 8 \fBbashdefault\fP Effectuer le reste des complètements par défaut de \fBbash\fP si la spécification de complètement ne produit aucune correspondance. .TP 8 \fBdefault\fP Utiliser le complètement de nom de fichier par défaut de readline si la spécification de complètement ne produit aucune correspondance. .TP 8 \fBdirnames\fP Effectuer le complètement de nom de répertoire si la spécification de complètement ne produit aucune correspondance. .TP 8 \fBfilenames\fP Indiquer à readline que la spécification de complètement produit des noms de fichiers, ainsi il peut effectuer tout traitement spécifique aux noms de fichiers (comme ajouter une barre oblique aux noms de répertoires, protéger les caractères spéciaux ou supprimer les espaces de fin de ligne). Destinée à être utilisée avec les fonctions de l'interpréteur. .TP 8 \fBnospace\fP Indiquer à readline de ne pas ajouter une espace (comportement par défaut) aux mots complétés en fin de ligne. .TP 8 \fBplusdirs\fP Après création de toutes les correspondances définies par la spécification de complètement, une tentative de complètement de nom de répertoire est effectuée et toutes les correspondances sont ajoutées aux résultats des autres actions. .RE .TP 8 \fB\-A\fP \fIaction\fP L'\fIaction\fP peut être l'une des suivantes pour produire une liste des complètements possibles\ : .RS .TP 8 \fBalias\fP Noms d'alias. Peut également être indiquée avec \fB\-a\fP. .TP 8 \fBarrayvar\fP Noms de variable de type tableau. .TP 8 \fBbinding\fP Noms de raccourci clavier \fBreadline\fP. .TP 8 \fBbuiltin\fP Noms de commandes internes de l'interpréteur. Peut également être indiquée avec \fB\-b\fP. .TP 8 \fBcommand\fP Noms de commande. Peut également être indiquée avec \fB\-c\fP. .TP 8 \fBdirectory\fP Noms de répertoire. Peut également être indiquée avec \fB\-d\fP. .TP 8 \fBdisabled\fP Noms de commandes internes de l'interpréteur désactivées. .TP 8 \fBenabled\fP Noms de commandes internes de l'interpréteur activées. .TP 8 \fBexport\fP Noms de variables de l'interpréteur exportées. Peut également être indiquée avec \fB\-e\fP. .TP 8 \fBfile\fP Noms de fichier. Peut également être indiquée avec \fB\-f\fP. .TP 8 \fBfunction\fP Noms de fonctions de l'interpréteur. .TP 8 \fBgroup\fP Noms de groupe. Peut également être indiquée avec \fB\-g\fP. .TP 8 \fBhelptopic\fP Sujets de l'aide acceptés par la commande interne \fBhelp\fP. .TP 8 \fBhostname\fP Noms de machine tels qu'ils sont extraits du fichier indiqué par la variable de l'interpréteur .SM \fBHOSTFILE\fP. .TP 8 \fBjob\fP Noms de tâche si le contrôle des tâches est actif. Peut également être indiquée avec \fB\-j\fP. .TP 8 \fBkeyword\fP Mots réservés de l'interpréteur. Peut également être indiquée avec \fB\-k\fP. .TP 8 \fBrunning\fP Noms de tâches en cours d'exécution si le contrôle des tâches est actif. .TP 8 \fBservice\fP Noms de service. Peut également être indiquée avec \fB\-s\fP. .TP 8 \fBsetopt\fP Arguments corrects de l'option \fB\-o\fP de la commande interne \fBset\fP. .TP 8 \fBshopt\fP Noms des options d'interpréteur acceptées par la commande interne \fBshopt\fP. .TP 8 \fBsignal\fP Noms de signaux. .TP 8 \fBstopped\fP Noms de tâches suspendues si le contrôle des tâches est actif. .TP 8 \fBuser\fP Noms d'utilisateur. Peut également être indiquée avec \fB\-u\fP. .TP 8 \fBvariable\fP Noms de toutes les variables de l'interpréteur. Peut également être indiquée avec \fB\-v\fP. .RE .TP 8 \fB\-C\fP \fIcommande\fP La \fIcommande\fP est exécutée dans un environnement de sous\-interpréteur et sa sortie est utilisée comme complètements possibles. .TP 8 \fB\-F\fP \fIfonction\fP La \fIfonction\fP de l'interpréteur est exécutée dans l'interpréteur actuel. Lorsqu'elle finit, les complètements possibles sont récupérés à partir de la valeur de la variable de type tableau .SM \fBCOMPREPLY\fP. .TP 8 \fB\-G\fP \fIglobpat\fP Le motif de développement des chemins \fIglobpat\fP est développé pour produire les complètements possibles. .TP 8 \fB\-P\fP \fIpréfixe\fP \fIpréfixe\fP est ajouté au début de chaque complètement possible après application de toutes les autres options. .TP 8 \fB\-S\fP \fIsuffixe\fP \fIsuffixe\fP est ajouté à chaque complètement possible après application de toutes les autres options. .TP 8 \fB\-W\fP \fIliste_de_mots\fP La \fIliste_de_mots\fP est découpée en utilisant les caractères de la variable spéciale .SM \fBIFS\fP 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. .TP 8 \fB\-X\fP \fImotif_filtre\fP \fImotif_filtre\fP est un motif utilisé pour le développement des chemins. Il est appliqué à la liste des complètements possibles produite par les options et arguments précédents et chaque complètement correspondant à \fImotif_filtre\fP est supprimé de la liste. Un \fB!\fP au début du \fImotif_filtre\fP inverse le motif\ ; dans ce cas, tout complètement qui ne correspond pas à \fImotif_filtre\fP est supprimé. .PD .PP La valeur renvoyée est vrai, sauf si une option incorrecte a été fournie, si une option comme \fB\-p\fP ou \fB\-r\fP a été fournie sans un \fInom\fP d'argument, si une tentative a été faite pour supprimer une spécification de complètement pour un \fInom\fP pour lequel il n'existe pas de spécification, ou si une erreur est survenue lors de l'ajout d'une spécification de complètement. .RE .TP \fBcompopt\fP [\fB\-o\fP \fIoption\fP] [\fB\-DE\fP] [\fB+o\fP \fIoption\fP] [\fInom\fP] Modifie les options de complétion pour chaque \fInom\fP en fonction des \fIoption\fPs, ou pour le complètement en cours d'exécution si aucun \fInom\fP n'est fourni. Si aucune \fIoption\fP n'est donnée, affiche les options de complétion pour chaque \fInom\fP ou pour le complètement actuel. Les valeurs possible d'option sont les options valables décrites ci\-dessus pour la commande interne \fBcomplete\fP. L'option \fB\-D\fP indique que les options restantes et les actions devraient s'appliquer à la commande de complètement par «\ défaut\ »\ ; c'est\-à\-dire le complètement essayé sur une commande pour laquelle aucun complètement n'a été préalablement défini. L'option \fB\-E\fP indique que les options restantes et les actions devraient s'appliquer à la commande de complètement par «\ vide\ »\ ; c'est\-à\-dire le complètement essayé sur une ligne vide. .sp 1 La valeur renvoyée est vrai, à moins qu'une option incorrecte ait été fournie, qu'une tentative ait été faite pour modifier les options pour un \fInom\fP pour lequel il n'existe pas de spécification de complètement, ou bien qu'une erreur de sortie soit survenue. .TP \fBcontinue\fP [\fIn\fP] Reprend l'exécution à l'itération suivante d'une boucle \fBfor\fP, \fBwhile\fP, \fBuntil\fP ou encore \fBselect\fP. Si \fIn\fP est indiqué, reprend l'exécution à la \fIn\fP\-ième boucle imbriquée. \fIn\fP doit être \(>= 1. Si \fIn\fP est supérieur au nombre de boucles imbriquées, l'exécution reprend à la boucle la plus externe (la boucle «\ au sommet\ »). La valeur renvoyée est 0, à moins que \fIn\fP ne soit plus grand ou égal à 1. .TP \fBdeclare\fP [\fB\-aAfFgilrtux\fP] [\fB\-p\fP] [\fInom\fP[\fB=\fP\fIvaleur\fP] ...] .PD 0 .TP \fBtypeset\fP [\fB\-aAfFgilrtux\fP] [\fB\-p\fP] [\fInom\fP[\fB=\fP\fIvaleur\fP] ...] .PD Déclare des variables ou leur fournit des attributs. Si aucun \fInom\fP n'est indiqué, affiche les valeurs des variables. L'option \fB\-p\fP affichera les attributs et les valeurs de chaque \fInom\fP. Quand \fB\-p\fP est utilisée avec des arguments \fInom\fP, les options supplémentaires sont ignorées. Quand \fB\-p\fP est fourni sans argument \fInom\fP, les attributs et valeurs de toutes les variables ayant des attributs indiqués par les options additionnelles seront affichés. Si aucune autre option n'est fournie avec \fB\-p\fP, \fBdeclare\fP affichera les attributs et valeurs de toutes les variables de l'interpréteur. L'option \fB\-f\fP limite l'affichage aux fonctions de l'interpréteur. L'option \fB\-F\fP empêche l'affichage des définitions de fonctions\ : seuls le nom de la fonction et ses attributs sont affichés. Si l'option d'interpréteur \fBextdebug\fP est activée en utilisant \fBshopt\fP, le nom du fichier source et le numéro de ligne où la fonction est définie sont aussi affichés. L'option \fB\-F\fP implique \fB\-f\fP. L'option \fB\-g\fP force la création ou la modification de variables avec une portée globale, même si \fBdeclare\fP est exécutée dans une fonction de l'interpréteur. Elle est ignorée dans tous les autres cas. Les options suivantes permettent de restreindre l'affichage aux variables dotées de certains attributs ou de configurer les attributs des variables\ : .RS .PD 0 .TP \fB\-a\fP Chaque \fInom\fP est une variable de type tableau indicé (consultez \fBTableaux\fP ci\-dessus). .TP \fB\-A\fP Chaque \fInom\fP est une variable de type tableau associatif (consultez \fBTableaux\fP ci\-dessus). .TP \fB\-f\fP Utiliser seulement les noms de fonctions. .TP \fB\-i\fP La variable est traitée comme un entier\ ; l'évaluation arithmétique (consultez .SM \fBÉVALUATION ARITHMÉTIQUE\fP ci\-dessus) est effectuée lorsqu'une valeur est affectée à la variable. .TP \fB\-l\fP Quand cette variable contient une valeur, toutes les majuscules seront converties en minuscules. L'attribut majuscule est désactivé. .TP \fB\-r\fP Rendre les \fInom\fPs accessibles en lecture seule. Plus aucune valeur ne pourra leur être affectée et ils ne pourront plus être détruits. .TP \fB\-t\fP Donner à chaque \fInom\fP l'attribut \fItrace\fP. Les fonctions tracées héritent des captures de \fBDEBUG\fP et \fBRETURN\fP de l'interpréteur appelant. L'attribut \fItrace\fP n'a pas de signification spéciale pour les variables. .TP \fB\-u\fP Quand cette variable contient une valeur, toutes les minuscules seront converties en majuscules. L'attribut minuscule est désactivé. .TP \fB\-x\fP Marquer les \fInom\fPs pour qu'ils soit exportés dans l'environnement des commandes ultérieures. .PD .PP En utilisant «\ +\ » à la place de «\ \-\ », l'attribut correspondant est désactivé, aux exceptions que \fB+a\fP ne peut pas être utilisé pour détruire une variable tableau et que \fB+r\fP n'enlèvera pas l'attribut lecture seule. Quand utilisé dans une fonction, chaque \fInom\fP devient local, comme avec la commande \fBlocal\fP sauf si l'option \fB\-g\fP est fournie. Si un nom de variable est suivi par \fB=\fP\fIvaleur\fP, la valeur de cette variable est configurée à \fIvaleur\fP. La valeur renvoyée est 0, sauf si une option incorrecte est rencontrée, si une tentative est faite de définir une fonction en utilisant .if n « \-f truc=bidule », .if t \f(CW\-f truc=bidule\fP, si une tentative est faite d'affecter une valeur à une variable en lecture seule, si une tentative est faite d'affecter une valeur à une variable tableau sans employer la syntaxe d'affectation composée (consultez \fBTableaux\fP ci\-dessus), si un des \fInom\fPs n'est pas un nom correct pour une variable de l'interpréteur, si une tentative est faite de supprimer l'attribut lecture\-seule d'une variable en lecture seule, si une tentative est faite de supprimer l'attribut tableau d'une variable tableau, ou si une tentative est faite avec \fB\-f\fP d'afficher une fonction inexistante. .RE .TP \fBdirs\fP [\fB+\fP\fIn\fP] [\fB\-\fP\fIn\fP] [\fB\-clpv\fP] Sans option, affiche la liste des répertoires actuellement mémorisés. L'affichage par défaut est réalisé sur une seule ligne, les noms de répertoires étant séparés par des espaces. Les répertoires sont ajoutés à la liste avec la commande \fBpushd\fP et supprimés avec la commande \fBpopd\fP. .RS .PD 0 .TP \fB+\fP\fIn\fP Afficher le \fIn\fP\-ième élément de la liste fournie par \fBdirs\fP, lorsqu'appelé sans options, en comptant à partir de la gauche en commençant à zéro. .TP \fB\-\fP\fIn\fP Afficher le \fIn\fP\-ième élément de la liste fournie par \fBdirs\fP, lorsqu'appelé sans options, en comptant à partir de la droite en commençant à zéro. .TP \fB\-c\fP Effacer la liste des répertoires en les supprimant tous. .TP \fB\-l\fP Produire une liste plus longue\ ; le format d'affichage par défaut utilise le tilde pour représenter le répertoire d'accueil. .TP \fB\-p\fP Afficher la pile des répertoires avec un élément par ligne. .TP \fB\-v\fP 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. .PD .PP La valeur renvoyée est 0, sauf si une option incorrecte a été fournie ou si l'indice \fIn\fP dépasse la longueur de la pile des répertoires. .RE .TP \fBdisown\fP [\fB\-ar\fP] [\fB\-h\fP] [\fItâche\fP ...] Sans options, chaque \fItâche\fP est supprimée de la table des tâches actives. Si aucune \fItâche\fP n'est précisée, et que ni \fB\-a\fP ni \fB\-r\fP n'est fournie, la notion d'interpréteur de \fItâche actuelle\fP est utilisée. Si l'option \fB\-h\fP est indiquée, aucune \fItâche\fP n'est supprimée de la table, mais chaque \fItâche\fP est marquée pour que le signal .SM \fBSIGHUP\fP ne lui soit pas envoyé si l'interpréteur reçoit un signal .SM \fBSIGHUP\fP. Si aucune \fItâche\fP n'est indiquée et que ni l'option \fB\-a\fP ni l'option \fB\-r\fP n'est fournie, la \fItâche actuelle\fP est concernée. Si aucune \fItâche\fP n'est fournie, l'option \fB\-a\fP signifie la suppression ou le marquage de toutes les tâches\ ; l'option \fB\-r\fP sans l'argument \fItâche\fP restreint les opérations aux tâches en cours d'exécution. La valeur renvoyée est 0, sauf si \fItâche\fP n'indique pas une tâche correcte. .TP \fBecho\fP [\fB\-neE\fP] [\fIarguments\fP ...] Affiche les \fIarguments\fP, séparés par des espaces, suivis par un saut de ligne. La valeur renvoyée est toujours 0. Si \fB\-n\fP est indiqué, le changement de ligne final est supprimé. Si l'option \fB\-e\fP est indiquée, l'interprétation des caractères suivants d'échappement par une contre\-oblique est activée. L'option \fB\-E\fP 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 \fBxpg_echo\fP peut être utilisée dynamiquement pour déterminer si \fBecho\fP développe ou non par défaut ces caractères d'échappement. \fBecho\fP n'interprète pas \fB\-\-\fP comme signifiant la fin des options. \fBecho\fP reconnaît les suites de caractères d'échappement suivantes\ : .RS .PD 0 .TP \fB\ea\fP alerte (alarme)\ ; .TP \fB\eb\fP effacement arrière («\ backspace\ »)\ ; .TP \fB\ec\fP supprime tout affichage suivant\ ; .TP \fB\ee\fP .TP \fB\eE\fP caractère d'échappement\ ; .TP \fB\ef\fP saut de page («\ form feed\ »)\ ; .TP \fB\en\fP saut de ligne («\ new line\ »)\ ; .TP \fB\er\fP retour chariot («\ carriage return\ »)\ ; .TP \fB\et\fP tabulation horizontale\ ; .TP \fB\ev\fP tabulation verticale\ ; .TP \fB\e\e\fP contre\-oblique\ ; .TP \fB\e0\fP\fInnn\fP le caractère 8\ bits dont la valeur en octal est \fInnn\fP (zéro à trois chiffres octaux)\ ; .TP \fB\ex\fP\fIHH\fP le caractère 8\ bits dont la valeur hexadécimale est \fIHH\fP (un ou deux chiffres hexadécimaux)\ ; .TP \fB\eu\fP\fIHHHH\fP le caractère Unicode (ISO/IEC 10646) dont la valeur hexadécimale est \fIHHHH\fP (un à quatre chiffres hexadécimaux)\ ; .TP \fB\eU\fP\fIHHHHHHHH\fP le caractère Unicode (ISO/IEC 10646) dont la valeur hexadécimale est \fIHHHHHHHH\fP (un à huit chiffres hexadécimaux)\ ; .PD .RE .TP \fBenable\fP [\fB\-a\fP] [\fB\-dnps\fP] [\fB\-f\fP \fIfichier\fP] [\fInom\fP ...] Active ou désactive les commandes internes de l'interpréteur. Désactiver une commande interne permet d'exécuter une commande disque ayant le même nom qu'une commande interne de l'interpréteur, sans avoir à indiquer un chemin d'accès complet, même quand l'interpréteur recherche normalement les commandes internes avant les commandes du disque. Si \fB\-n\fP est utilisé, chaque \fInom\fP indiqué est désactivé, sinon ils sont activés. Par exemple, pour utiliser le programme binaire \fBtest\fP qui se trouve dans .SM \fBPATH\fP plutôt que la commande interne, utilisez .if t \f(CWenable -n test\fP. .if n « enable -n test ». L'option \fB\-f\fP demande de charger la nouvelle commande interne avec le \fInom\fP indiqué depuis le \fIfichier\fP objet partagé sur les systèmes qui le permettent. L'option \fB\-d\fP permet de supprimer une commande interne chargée précédemment avec \fB\-f\fP. Si aucun argument \fInom\fP n'est indiqué ou si l'option \fB\-p\fP 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 \fB\-n\fP est fournie, seules les commandes désactivées sont affichées. Si \fB\-a\fP est fournie, la liste de toutes les commandes est affichée, avec une indication des activations et désactivations. Si \fB\-s\fP est fournie, la sortie est limitée aux commandes internes \fIspéciales\fP POSIX. La valeur renvoyée est 0, sauf si \fInom\fP n'est pas une commande interne ou qu'il y a une erreur au chargement d'une nouvelle commande interne d'un objet partagé. .TP \fBeval\fP [\fIarguments\fP ...] Les \fIarguments\fP 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 \fBeval\fP. S'il n'y a pas d'\fIarguments\fP ou uniquement des arguments vides, \fBeval\fP renvoie 0. .TP \fBexec\fP [\fB\-cl\fP] [\fB\-a\fP \fInom\fP] [\fIcommande\fP [\fIarguments\fP]] Si une \fIcommande\fP est indiquée, elle remplace l'interpréteur. Aucun nouveau processus n'est créé. Les \fIarguments\fP deviennent ceux de la \fIcommande\fP. Si l'option \fB\-l\fP est fournie, l'interpréteur place un tiret en guise de zéro\-ième argument fourni a la \fIcommande\fP. C'est ce que fait \fBlogin\fP(1). L'option \fB\-c\fP conduit à l'exécution de la \fIcommande\fP avec un environnement vide. Si l'option \fB\-a\fP est fournie, l'interpréteur transmet le \fInom\fP comme zéro\-ième argument. Si la \fIcommande\fP ne peut être exécutée pour une raison quelconque, un interpréteur non interactif termine, sauf si l'option de l'interpréteur \fBexecfail\fP est activée, auquel cas une erreur est renvoyée. Un interpréteur interactif renvoie une erreur si le fichier ne peut pas être exécuté. Si aucune \fIcommande\fP n'est indiquée, les éventuelles redirections sont mises en place dans l'interpréteur actuel et l'état renvoyé est 0. S'il y a une erreur de redirection, l'état renvoyé est 1. .TP \fBexit\fP [\fIn\fP] Termine l'interpréteur avec un état de \fIn\fP. Si \fIn\fP est omis, l'état final est celui de la dernière commande exécutée. Une capture sur .SM \fBEXIT\fP est exécutée avant que l'interpréteur ne se termine. .TP \fBexport\fP [\fB\-fn\fP\^] [\fInom\fP[=\fImot\fP]] ... .PD 0 .TP \fBexport \-p\fP .PD Les \fInom\fPs fournis sont marqués pour être exportés automatiquement dans l'environnement des commandes exécutées par la suite. Si l'option \fB\-f\fP est indiquée, les \fInom\fPs se rapportent à des fonctions. Si aucun \fInom\fP n'est donné ou si l'option \fB\-p\fP est fournie, une liste est affichée indiquant l'ensemble des noms exportés dans cet interpréteur. L'option \fB\-n\fP conduit à supprimer l'attribut d'exportation de chacune des variables \fInom\fPmées. Si un nom de variable est suivi par =\fImot\fP, la valeur de la variable est configurée à \fImot\fP. \fBexport\fP renvoie un état final de 0, sauf si une option incorrecte est rencontrée, si un des \fInom\fPs n'est pas un nom correct de variable de l'interpréteur, ou si l'option \fB\-f\fP est fournie avec un \fInom\fP qui n'est pas une fonction. .TP \fBfc\fP [\fB\-e\fP \fIéditeur\fP] [\fB\-lnr\fP] [\fIpremière\fP] [\fIdernière\fP] .PD 0 .TP \fBfc\fP \fB\-s\fP [\fImotif\fP=\fInouveau\fP] [\fIcommande\fP] .PD Commande épinglée («\ fix command\ »). Dans la première forme, une plage de commandes, entre la \fIpremière\fP et la \fIdernière\fP, est sélectionné dans la file d'historique. La \fIpremière\fP et la \fIdernière\fP peuvent être indiquées sous forme de chaînes (pour trouver la dernière commande commençant par cette chaîne) ou sous forme numérique (un indice dans la file d'historique où un nombre négatif est utilisé comme décalage par rapport au numéro de la commande actuelle). Si la \fIdernière\fP n'est pas indiquée, elle est configurée à la commande actuelle si l'on veut afficher la liste (ainsi .if n « fc \-l \-10 » .if t \f(CWfc \-l \-10\fP affiche les 10 dernières commandes) et à l'identique de la \fIpremière\fP sinon. Si la \fIpremière\fP n'est pas indiquée, elle est configurée à la commande précédente pour une édition et à \-16 pour l'affichage de liste. .sp 1 L'option \fB\-n\fP supprime l'affichage des numéros dans la liste. L'option \fB\-r\fP inverse l'ordre des commandes. Si l'option \fB\-l\fP est indiquée, les commandes sont affichées sur la sortie standard. Sinon, l'\fIéditeur\fP indiqué est appelé avec un fichier contenant les commandes sélectionnées. Si aucun \fIéditeur\fP n'est indiqué, on utilise la valeur de la variable .SM \fBFCEDIT\fP ou la valeur de .SM \fBEDITOR\fP si .SM \fBFCEDIT\fP n'existe pas. Si aucune variable n'existe, .FN vi est utilisé. Lorsque l'édition se termine, les commandes sont affichées puis exécutées. .sp 1 Dans la seconde forme, la \fIcommande\fP est ré\-exécutée après avoir remplacé chaque instance du \fImotif\fP par \fInouveau\fP. Un alias utile pour cela est .if n « r="fc -s" », .if t \f(CWr='fc \-s'\fP, ainsi en tapant .if n « r cc » .if t \f(CWr cc\fP on relance la dernière commande commençant par .if n « cc » .if t \f(CWcc\fP et en tapant .if n « r » .if t \f(CWr\fP on ré\-exécute la commande précédente. .sp 1 Lorsque la première forme est utilisée, la valeur renvoyée est 0, sauf si une option incorrecte est trouvée ou si \fIpremière\fP ou \fIdernière\fP indiquent des lignes d'historique hors d'atteinte. Si l'option \fB\-e\fP est fournie, la valeur renvoyée est celle de la dernière commande exécutée ou un échec si une erreur s'est produite avec le fichier temporaire des commandes. Avec la seconde forme, l'état renvoyé est celui de la commande ré\-exécutée, sauf si \fIcommande\fP n'indique pas une ligne correcte de l'historique, auquel cas \fBfc\fP renvoie un échec. .TP \fBfg\fP [\fItâche\fP] Reprend la \fItâche\fP au premier plan qui devient la tâche actuelle. Si aucune \fItâche\fP n'est précisée, l'interpréteur utilise la notion de \fItâche actuelle\fP. La valeur renvoyée est celle de la commande placée au premier plan ou un échec si le contrôle des tâches est désactivé ou, lorsque le contrôle des tâches est activé, si la \fItâche\fP n'indique pas une tâche correcte ou si la \fItâche\fP indique une tâche lancée sans contrôle des tâches. .TP \fBgetopts\fP \fIchaîne_d_options\fP \fInom\fP [\fIarguments\fP] \fBgetopts\fP est utilisé par les scripts d'interpréteur pour analyser les paramètres positionnels. La \fIchaîne_d_options\fP contient l'ensemble des caractères d'options à reconnaître\ ; si un caractère est suivi par un deux\-points, l'option est censée avoir un argument, qui devrait en être séparé par une espace. Les caractères deux\-points et le point d'interrogation ne peuvent pas être utilisés comme caractères d'option. À chaque appel, \fBgetopts\fP place l'option suivante dans la variable de l'interpréteur dont le \fInom\fP est fourni, en la créant si elle n'existe pas et l'indice de l'argument suivant à traiter dans la variable .SM \fBOPTIND\fP. .SM \fBOPTIND\fP est initialisée à 1 à chaque appel d'un interpréteur ou d'un script. Quand une option nécessite un argument, \fBgetopts\fP place cet argument dans la variable .SM \fBOPTARG\fP. L'interpréteur ne réinitialise pas .SM \fBOPTIND\fP automatiquement, il faut le faire manuellement entre des appels multiples à \fBgetopts\fP au sein du même appel d'interpréteur si un nouveau jeu de paramètres doit être utilisé. .sp 1 Lorsque la fin des options est atteinte, \fBgetopts\fP termine avec une valeur renvoyée strictement supérieure à zéro. .SM \fBOPTIND\fP est positionné à l'indice du premier argument obligatoire et un point d'interrogation (\^\fB?\fP\^) est placé dans la variable \fInom\fP. .sp 1 \fBgetopts\fP analyse en principe les paramètres positionnels, mais si plus d'\fIarguments\fP sont indiqués, \fBgetopts\fP analysera ces derniers à la place. .sp 1 \fBgetopts\fP peut signaler des erreurs de deux façons. Si le premier caractère de la \fIchaîne_d_options\fP est un deux\-points, les erreurs sont signalées de façon \fIsilencieuse\fP. 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 .SM \fBOPTERR\fP est configurée à 0, aucun message d'erreur ne sera affiché, même si le premier caractère de la \fIchaîne_d_options\fP n'est pas un deux\-points. .sp 1 Si une option incorrecte est rencontrée, \fBgetopts\fP place un point d'interrogation (\^\fB?\fP\^) dans la variable \fInom\fP, affiche un message d'erreur (s'il n'est pas en mode silencieux) et détruit la variable .SM \fBOPTARG\fP. Si \fBgetopts\fP fonctionne en mode silencieux, le caractère d'option est placé dans .SM \fBOPTARG\fP et aucun message de diagnostic n'est affiché. .sp 1 Lorsqu'un argument d'option nécessaire est absent et si \fBgetopts\fP n'est pas silencieux, un point d'interrogation (\^\fB?\fP\^) est placé dans la variable \fInom\fP, .SM \fBOPTARG\fP est détruite et un message de diagnostic est affiché. Si \fBgetopts\fP est silencieux, un deux\-points (\^\fB:\fP\^) est placé dans la variable \fInom\fP et .SM \fBOPTARG\fP est positionné à l'option monocaractère trouvée. .sp 1 \fBgetopts\fP renvoie vrai si une option, indiquée ou non, est trouvée. Il renvoie faux si la fin des options est atteinte ou si une erreur se produit. .TP \fBhash\fP [\fB\-lr\fP] [\fB\-p\fP \fIfichier\fP] [\fB\-dt\fP] [\fInom\fP] Chaque fois que \fBhash\fP est invoquée, le chemin d'accès complet de la commande \fInom\fP est déterminé en examinant les répertoires de \fB$PATH\fP, et mémorisé. Tous les chemins précédemment mémorisés sont supprimés. Si l'option \fB\-p\fP est fournie, aucune recherche de chemin d'accès n'est effectuée et le \fIfichier\fP est utilisé comme chemin d'accès complet pour la commande. L'option \fB\-r\fP conduit l'interpréteur à oublier tous les emplacements mémorisés. L'option \fB\-d\fP conduit l'interpréteur à oublier tous les emplacements mémorisés de chaque \fInom\fP. Si l'option \fB\-t\fP est fournie, le chemin d'accès complet de chaque \fInom\fP correspondant est affiché. Si plusieurs arguments \fInom\fP sont fournis avec \fB\-t\fP, le \fInom\fP est affiché avant chaque chemin d'accès complet associé. L'option \fB\-l\fP conduit à afficher la sortie dans un format réutilisable en entrée. Si aucun argument n'est indiqué ou si seulement \fB\-l\fP est fournie, des informations sur les commandes mémorisées sont affichées. La valeur renvoyée est vrai, sauf si \fInom\fP n'est pas trouvé ou si une option incorrecte est fournie. .TP \fBhelp\fP [\fB\-dms\fP] [\fImotif\fP] Affiche des informations d'aide au sujet des commandes internes. Si un \fImotif\fP est indiqué, \fBhelp\fP fournit de l'aide sur toutes les commandes internes correspondant à ce \fImotif\fP, sinon, une liste des commandes internes et des structures de contrôle de l'interpréteur est affichée. .RS .PD 0 .TP \fB\-d\fP Afficher une courte description de chaque \fImotif\fP. .TP \fB\-m\fP Afficher la description de chaque \fImotif\fP dans un format du type pages de manuel. .TP \fB\-s\fP Afficher seulement un court synopsis d'utilisation de chaque \fImotif\fP. .PD .PP L'état renvoyé est 0, sauf si aucune commande ne correspond au \fImotif\fP. .RE .TP \fBhistory\fP [\fIn\fP] .PD 0 .TP \fBhistory\fP \fB\-c\fP .TP \fBhistory \-d\fP \fInombre\fP .TP \fBhistory\fP \fB\-anrw\fP [\fIfichier\fP] .TP \fBhistory\fP \fB\-p\fP \fIargument\fP [\fIargument ...\fP] .TP \fBhistory\fP \fB\-s\fP \fIargument\fP [\fIargument ...\fP] .PD Sans options, affiche la liste des commandes de la file d'historique, avec les numéros de ligne. Les lignes marquées avec un \fB*\fP ont été modifiées. Un argument \fIn\fP permet de n'afficher que les \fIn\fP dernières lignes. Si la variable de l'interpréteur .SM \fBHISTTIMEFORMAT\fP existe et n'est pas vide, elle est utilisée comme chaîne de format pour \fBstrftime\fP(3) afin d'afficher l'horodatage associé à chaque élément de l'historique. Aucun blanc ne sépare l'horodatage ainsi mis en forme de la ligne d'historique. Si un argument \fIfichier\fP est fourni, il est utilisé comme nom de fichier d'historique\ ; sinon la valeur de .SM \fBHISTFILE\fP est utilisée. Les options, si fournies, ont les significations suivantes\ : .RS .PD 0 .TP \fB\-c\fP Effacer la file de l'historique en supprimant tous les éléments. .TP \fB\-d\fP \fInombre\fP Détruire l'élément de l'historique à la position \fInombre\fP. .TP \fB\-a\fP Ajouter les «\ nouvelles\ » lignes d'historiques (celles créées depuis le début de la session actuelle de \fBbash\fP) dans le fichier d'historique. .TP \fB\-n\fP Lire dans le fichier d'historique les lignes non encore lues et les ajouter à la file d'historique actuelle. Il s'agit des lignes qui ont été ajoutées dans le fichier d'historique depuis le début de la session \fBbash\fP. .TP \fB\-r\fP Lire le contenu du fichier et l'utiliser comme historique actuel. .TP \fB\-w\fP Écrire dans le fichier l'historique actuel, en écrasant le contenu précédent. .TP \fB\-p\fP Effectuer la substitution d'historique sur les \fIargument\fPs suivants et afficher le résultat sur la sortie standard. Ne pas mémoriser les résultats dans la file d'historique. Chaque \fIargument\fP doit être protégé pour désactiver le développement normal de l'historique. .TP \fB\-s\fP Conserver les \fIargument\fPs 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 \fIargument\fPs ne soient ajoutés. .PD .PP Si la variable .SM \fBHISTTIMEFORMAT\fP existe, les informations d'horodatage associées à chaque élément de l'historique sont écrites dans le fichier d'historique, repérés par le caractère de commentaire d'historique. Quand le fichier d'historique est lu, les lignes commençant par le caractère de commentaire d'historique suivi immédiatement par un chiffre sont considérés comme des horodatages de la ligne d'historique précédente. La valeur renvoyée est 0, sauf si une option incorrecte est fournie, si une erreur se produit durant la lecture ou l'écriture du fichier, si un \fInombre\fP incorrect est fourni comme argument à \fB\-d\fP ou si le développement de l'historique fourni en argument à \fB\-p\fP échoue. .RE .TP \fBjobs\fP [\fB\-lnprs\fP] [ \fItâche\fP ... ] .PD 0 .TP \fBjobs\fP \fB\-x\fP \fIcommande\fP [ \fIarguments\fP ... ] .PD La première forme affiche la liste des tâches actives. Les options ont les significations suivantes\ : .RS .PD 0 .TP \fB\-l\fP Afficher les PID, en plus des informations normales. .TP \fB\-n\fP Afficher uniquement des informations sur les tâches dont l'état a changé depuis la dernière notification de leur état à l'utilisateur. .TP \fB\-p\fP Afficher uniquement le PID du meneur du groupe de processus de la tâche. .TP \fB\-r\fP Restreindre l'affichage aux tâches en cours d'exécution. .TP \fB\-s\fP Restreindre l'affichage aux tâches suspendues. .PD .PP Si une \fItâche\fP est indiquée, l'affichage est restreint aux informations relatives à cette tâche. L'état renvoyé est 0, sauf si une option incorrecte est rencontrée ou si une \fItâche\fP incorrecte est fournie. .PP Si l'option \fB\-x\fP est fournie, \fBjobs\fP remplace toute \fItâche\fP trouvée dans la \fIcommande\fP ou dans ses \fIarguments\fP avec les Process Group ID correspondant, puis il exécute la \fIcommande\fP en lui transmettant les \fIarguments\fP et en renvoyant son état final. .RE .TP \fBkill\fP [\fB\-s\fP \fIsignal\fP | \fB\-n\fP \fInum\-signal\fP | \fB\-\fP\fIsignal\fP] [\fIpid\fP | \fItâche\fP] ... .PD 0 .TP \fBkill\fP \fB\-l\fP [\fIsignal\fP | \fIétat_final\fP] .PD Envoie le signal indiqué par \fIsignal\fP ou \fInum\-signal\fP aux processus indiqués par \fIpid\fP ou par \fItâche\fP. \fIsignal\fP est soit sous la forme de nom de signal (indifférent à la casse), comme .SM \fBSIGKILL\fP (avec ou sans le préfixe .SM \fBSIG\fP), soit sous forme numérique\ ; \fInum\-signal\fP est un numéro de signal. Si \fIsignal\fP est absent, .SM \fBSIGTERM\fP est supposé par défaut. Un argument \fB\-l\fP provoque l'affichage de la liste des noms de signaux. Si des arguments sont fournis quand \fB\-l\fP est indiqué, les noms des signaux correspondant aux arguments sont affichés et l'état renvoyé est 0. L'argument \fIétat_final\fP de l'option \fB\-l\fP est un nombre indiquant soit un numéro de signal, soit l'état final d'un processus terminé par un signal. \fBkill\fP 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. .TP \fBlet\fP \fIargument\fP [\fIargument\fP ...] Chaque \fIargument\fP est une expression arithmétique à évaluer (consultez .SM \fBÉVALUATION ARITHMÉTIQUE\fP ci\-dessus). Si l'évaluation du dernier \fIargument\fP donne 0, \fBlet\fP renvoie 1\ ; sinon 0 est renvoyé. .TP \fBlocal\fP [\fIoption\fP] [\fInom\fP[=\fIvaleur\fP] ...] Pour chaque argument, une variable locale \fInom\fP est créée et la \fIvaleur\fP lui est affectée. L'\fIoption\fP peut être n'importe quelle option acceptée par \fBdeclare\fP. Quand \fBlocal\fP est utilisé dans une fonction, la variable \fInom\fP possède une portée visible restreinte à cette fonction et ses enfants. Sans opérandes, \fBlocal\fP affiche la liste des variables locales sur la sortie standard. Une utilisation de \fBlocal\fP hors des fonctions est erronée. La valeur renvoyée est 0, sauf si \fBlocal\fP est utilisé hors d'une fonction, si un \fInom\fP incorrect est fourni ou si \fInom\fP est une variable en lecture seule. .TP \fBlogout\fP Termine un interpréteur de connexion. .TP \fBmapfile\fP [\fB\-n\fP \fInombre\fP] [\fB\-O\fP \fIorigine\fP] [\fB\-s\fP \fInombre\fP] [\fB\-t\fP] [\fB\-u\fP \fIfd\fP] [\fB\-C\fP \fIrappel\fP] [\fB\-c\fP \fIquantum\fP] [\fItableau\fP] .PD 0 .TP \fBreadarray\fP [\fB\-n\fP \fInombre\fP] [\fB\-O\fP \fIorigine\fP] [\fB\-s\fP \fInombre\fP] [\fB\-t\fP] [\fB\-u\fP \fIfd\fP] [\fB\-C\fP \fIrappel\fP] [\fB\-c\fP \fIquantum\fP] [\fItableau\fP] .PD Lit les lignes depuis l'entrée standard vers la variable de type tableau indicé \fItableau\fP, ou depuis le descripteur de fichier \fIfd\fP si l'option \fB\-u\fP est fournie. La variable .SM \fBMAPFILE\fP est le \fItableau\fP par défaut. Les options, si fournies, ont les significations suivantes\ : .RS .PD 0 .TP \fB\-n\fP Copier au plus \fInombre\fP lignes. Si \fInombre\fP est 0, toutes les lignes sont copiées. .TP \fB\-O\fP Commencer l'affectation de \fItableau\fP à l'indice \fIorigine\fP. L'indice par défaut est 0. .TP \fB\-s\fP Supprimer les \fInombre\fP premières lignes lues. .TP \fB\-t\fP Éliminer le changement de ligne de chaque ligne lue. .TP \fB\-u\fP Lire les lignes à partir du descripteur de fichier \fIfd\fP plutôt que depuis l'entrée standard. .TP \fB\-C\fP Évaluer \fIrappel\fP à chaque fois que \fIquantum\fP lignes sont lues. L'option \fB\-c\fP précise le \fIquantum\fP. .TP \fB\-c\fP Préciser le nombre de lignes entre chaque appel à \fIrappel\fP. .PD .PP Si \fB\-C\fP est précisé sans \fB\-c\fP, le quantum par défaut est 5000. Quand \fIrappel\fP est évalué, l'indice du prochain élément de tableau à affecter et la ligne à affecter à cet élément sont fournis en arguments supplémentaires. \fIrappel\fP est évalué après la lecture de la ligne, mais avant l'affectation de l'élément de tableau. .PP Si aucune origine explicite n'est fournie, \fBmapfile\fP effacera \fItableau\fP avant de lui affecter des valeurs. .PP \fBmapfile\fP termine avec succès sauf si une option ou un de ses arguments n'est pas valable, ou si \fItableau\fP n'est pas valable, n'est pas un tableau indicé ou si son affectation est impossible. .RE .TP \fBpopd\fP [\fB\-n\fP] [\fB+\fP\fIn\fP] [\fB\-\fP\fIn\fP] 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 \fBcd\fP est effectué en direction du nouveau répertoire au sommet. Les argument, si fournis, ont les significations suivantes\ : .RS .PD 0 .TP \fB\-n\fP Empêcher le changement normal de répertoire lors de la suppression d'un répertoire de la pile. Seule la pile est manipulée. .TP \fB+\fP\fIn\fP Supprimer le \fIn\fP\-ième élément de la liste affichée par \fBdirs\fP, en comptant depuis la gauche à partir de zéro. Par exemple\ : .if n « popd +0 » .if t \f(CWpopd +0\fP enlève le premier répertoire, .if n « popd +1 » .if t \f(CWpopd +1\fP le second. .TP \fB\-\fP\fIn\fP Supprimer le \fIn\fP\-ième élément de la liste affichée par \fBdirs\fP, en comptant depuis la droite à partir de zéro. Par exemple\ : .if n « popd -0 » .if t \f(CWpopd -0\fP supprime le dernier répertoire et .if n « popd -1 » .if t \f(CWpopd -1\fP l'avant\-dernier. .PD .PP Si la commande \fBpopd\fP réussit, un \fBdirs\fP est effectué et l'état renvoyé est 0. \fBpopd\fP renvoie faux si une option incorrecte est trouvée, si la pile de répertoires est vide, si le répertoire indiqué est absent de la pile ou si le changement de répertoire a échoué. .RE .TP \fBprintf\fP [\fB\-v\fP \fIvar\fP] \fIformat\fP [\fIarguments\fP] Écrit les \fIarguments\fP mis en forme sur la sortie standard sous le contrôle du \fIformat\fP. L'option \fB\-v\fP conduit à affecter la sortie à la variable \fIvar\fP plutôt que de l'afficher sur la sortie standard. .sp 1 Ce \fIformat\fP 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 \fIarguments\fP successifs. En plus des spécifications de format standard de \fBprintf\fP(1), \fBprintf\fP interprète les extensions suivantes\ : .RS .PD 0 .TP \fB%b\fP conduit \fBprintf\fP à développer les suites de caractères d'échappement par contre\-oblique se trouvant dans l'\fIargument\fP correspondant (à l'exception de \fB\ec\fP qui termine la sortie, des contre\-obliques dans \fB\e\(aq\fP, \fB\e"\fP et \fB\e?\fP qui ne sont pas supprimées et des suites de caractères d'échappement pour les nombres en octal commençant par \fB\e0\fP qui peuvent contenir jusqu'à quatre chiffres)\ ; .TP \fB%q\fP conduit \fBprintf\fP à afficher l'\fIargument\fP correspondant dans un format réutilisable en entrée de l'interpréteur\ ; .TP \fB%(\fP\fIformatdate\fP\fB)T\fP conduit \fBprintf\fP à afficher la chaîne date\-heure résultant de l'utilisation de \fIformatdate\fP en tant que chaîne de format pour \fBstrftime\fP(3). L'\fIargument\fP correspondant est un entier représentant le temps en seconde écoulé depuis epoch. Deux valeur particulières d'argument peuvent être utilisées\ : \fB\-1\fP représente l'heure actuelle et \fB\-2\fP l'heure à laquelle l'interpréteur a été invoqué. .PD .PP Les arguments des spécificateurs de format qui ne sont pas des chaînes sont traités comme des constantes C, sauf qu'un signe plus ou moins est permis au début, et que si le premier caractère est un guillemet simple ou double, la valeur est la valeur ASCII du caractère suivant. .PP Le \fIformat\fP est réutilisé jusqu'à consommer tous les \fIarguments\fP. Si le \fIformat\fP demande plus d'\fIarguments\fP que fournis, les spécifications supplémentaires se comportent comme si des valeurs zéro ou des chaînes vides, suivant le besoin, avaient été fournies. La valeur renvoyée est zéro en cas de succès, différente de zéro en cas d'échec. .RE .TP \fBpushd\fP [\fB\-n\fP] [\fB+\fP\fIn\fP] [\fB\-\fP\fIn\fP] .PD 0 .TP \fBpushd\fP [\fB\-n\fP] [\fIrép\fP] .PD Ajoute un répertoire au sommet de la pile des répertoires ou effectue une rotation dans la pile, en ramenant le répertoire actuel au sommet. Sans argument, cette commande échange les deux répertoires au sommet et renvoie 0, sauf si la pile est vide. Les arguments, si fournis, ont les significations suivantes\ : .RS .PD 0 .TP \fB\-n\fP Empêcher le changement normal de répertoire lors d'un ajout dans la pile. Seule la pile est manipulée. .TP \fB+\fP\fIn\fP Effectuer une rotation dans la pile, de façon à amener au sommet le \fIn\fP\-ième répertoire (de la liste affichée par \fBdirs\fP, en comptant depuis la gauche à partir de zéro). .TP \fB\-\fP\fIn\fP Effectuer une rotation dans la pile, de façon à amener au sommet le \fIn\fP\-ième répertoire (de la liste affichée par \fBdirs\fP, en comptant depuis la gauche à partir de zéro). .TP \fBrép\fP Ajouter le répertoire \fIrép\fP au sommet de la pile de répertoires en faisant le nouveau répertoire de travail actuel. .PD .PP Si la commande \fBpushd\fP réussit, un \fBdirs\fP est aussi effectué. Avec la première forme, \fBpushd\fP renvoie 0 sauf si le déplacement vers \fIrép\fP échoue. Avec la seconde forme, \fBpushd\fP renvoie 0, sauf si la pile est vide, si un élément inexistant dans la pile est indiqué ou si le changement de répertoire vers le nouveau répertoire indiqué échoue. .RE .TP \fBpwd\fP [\fB\-LP\fP] Affiche le chemin d'accès absolu au répertoire de travail actuel. Le chemin ne contiendra pas de liens symboliques si l'option \fB\-P\fP est fournie, ou si l'option \fB\-o physical\fP de la commande interne \fBset\fP est activée. Si l'option \fB\-L\fP est utilisée, le chemin affiché peut contenir des liens symboliques. L'état renvoyé est 0, sauf si une erreur s'est produite lors de la lecture du nom du répertoire actuel ou si une option incorrecte est fournie. .TP \fBread\fP [\fB\-ers\fP] [\fB\-a\fP \fItableau\fP] [\fB\-d\fP \fIdélimiteur\fP] [\fB\-i\fP \fItexte\fP] [\fB\-n\fP \fInb_car\fP] [\fB\-N\fP \fInb_car\fP] [\fB\-p\fP \fIinvite\fP] [\fB\-t\fP \fIdélai\fP] [\fB\-u\fP \fIfd\fP] [\fInom\fP ...] Une ligne est lue depuis l'entrée standard ou à partir du descripteur de fichier \fIfd\fP fourni en argument à l'option \fB\-u\fP, puis le premier mot de cette ligne est affecté au premier \fInom\fP, le second mot au second \fInom\fP, et ainsi de suite avec les mots restants et leurs séparateurs affectés au dernier \fInom\fP. S'il y a moins de mots lus dans le flux d'entrée que de variables, des valeurs vides sont affectées à celles restantes. Les caractères contenus dans la variable .SM \fBIFS\fP sont utilisés pour découper la ligne en mots. Le caractère contre\-oblique (\fB\e\fP) 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\ : .RS .PD 0 .TP \fB\-a \fP\fItableau\fP Les mots sont affectés aux indices successifs d'une variable tableau de nom \fItableau\fP, en commençant à 0. \fItableau\fP est détruit avant que de nouvelles valeurs ne soient affectées. Les autres arguments \fInom\fP sont ignorés. .TP \fB\-d \fP\fIdélimiteur\fP Le premier caractère de \fIdélimiteur\fP est utilisé pour terminer la ligne de saisie, plutôt qu'un changement de ligne. .TP \fB\-e\fP Si l'entrée standard provient d'un terminal, la bibliothèque \fBreadline\fP (consultez .SM \fBREADLINE\fP ci\-dessus) est utilisée pour obtenir la ligne. Readline utilise les configurations d'édition en cours (ou par défaut, si l'édition de ligne n'était pas préalablement active). .TP \fB\-i \fP\fItexte\fP Si \fBreadline\fP est utilisée pour lire la ligne, \fItexte\fP est placé dans le tampon d'édition avant le début de l'édition. .TP \fB\-n \fP\fInb_car\fP \fBread\fP s'arrête après avoir lu \fInb_car\fP caractères plutôt que d'attendre une ligne complète en entrée, mais un délimiteur est respecté si moins de \fInb_car\fP caractères ont été lus avant le délimiteur. .TP \fB\-N \fP\fInb_car\fP \fBread\fP s'arrête après avoir lu exactement \fInb_car\fP caractères plutôt que d'attendre une ligne complète en entrée, sauf si une fin de fichier (EOF) est rencontrée ou si \fBread\fP dépasse son délai de réponse. Les délimiteurs rencontrés en entrée ne sont pas pris en compte et n'entraînent pas la fin de \fBread\fP avant que \fInb_car\fP caractères n'aient été lus. .TP \fB\-p \fP\fIinvite\fP Afficher \fIinvite\fP sur la sortie d'erreur standard, sans caractère final de changement de ligne, avant d'essayer de lire toute nouvelle saisie. L'invite est affichée seulement si l'entrée vient d'un terminal. .TP \fB\-r\fP La contre\-oblique n'agit pas comme un caractère d'échappement. La contre\-oblique est considérée comme faisant partie de la ligne. En particulier une contre\-oblique suivie d'un changement de ligne n'est pas considérée comme une continuation de ligne. .TP \fB\-s\fP Mode silencieux. Si une entrée arrive à partir d'un terminal, les caractères ne sont pas affichés. .TP \fB\-t \fP\fIdélai\fP Conduire \fBread\fP à expirer et renvoyer un échec si une ligne complète en entrée n'a pas été lue dans le \fIdélai\fP en secondes. \fIdélai\fP est un nombre décimal avec éventuellement des chiffres après la virgule (NdT\ : point en l'occurrence). Cette option n'est effective que si \fBread\fP lit l'entrée à partir d'un terminal, d'un tube, ou depuis un autre fichier spécial\ ; elle n'a aucun effet lors de la lecture d'un fichier normal. Si \fIdélai\fP est nul, \fBread\fP termine avec succès si une entrée est disponible pour le descripteur de fichier indiqué, en échec sinon. L'état final est supérieur à 128 si le délai est dépassé. .TP \fB\-u \fP\fIfd\fP Lire l'entrée à partir du descripteur de fichier \fIfd\fP. .PD .PP Si aucun \fInom\fP n'est fourni, la ligne lue est affectée entièrement à la variable .SM \fBREPLY\fP. Le code renvoyé est zéro, sauf si une fin de fichier (EOF) est rencontrée, si \fBread\fP dépasse son délai de réponse (auquel cas le code renvoyé est plus grand que 128) ou si un descripteur de fichier incorrect est fourni en argument de \fB\-u\fP. .RE .TP \fBreadonly\fP [\fB\-aAf\fP] [\fB\-p\fP] [\fInom\fP[\fB=\fP\fImot\fP] ...] .PD Les \fInom\fPs indiqués reçoivent un attribut lecture seule\ ; les valeurs de ces \fInom\fPs ne pourront plus être modifiées par des affectations ultérieures. Si l'option \fB\-f\fP est fournie, les fonctions correspondant à ces \fInom\fPs sont marquées en conséquence. L'option \fB\-a\fP restreint l'action aux variables tableaux indicés\ ; l'option \fB\-A\fP restreint l'action aux variables tableaux associatifs. Si les deux options sont fournies, \fB\-A\fP est prioritaire. Si aucun argument \fInom\fP n'est indiqué ou si l'option \fB\-p\fP est fournie, une liste de tous les noms en lecture seule est affichée. Les autres options peuvent être utilisées pour restreindre l'affichage à un sous\-ensemble de l'ensemble des noms en lecture seule. L'option \fB\-p\fP conduit à afficher la sortie dans un format susceptible d'être réutilisé en entrée. Si le nom d'une variable est suivi par \fB=\fP\fImot\fP, la variable est configurée à \fImot\fP. L'état renvoyé est 0, sauf si une option incorrecte a été rencontrée, si l'un des \fInom\fPs n'est pas un nom correct de variable de l'interpréteur ou si l'option \fB\-f\fP est fournie avec un \fInom\fP qui n'est pas une fonction. .TP \fBreturn\fP [\fIn\fP] Termine une fonction en renvoyant la valeur indiquée par \fIn\fP. Si \fIn\fP est omis, la valeur renvoyée est celle de la dernière commande exécutée dans le corps de la fonction. Si utilisée hors d'une fonction, mais durant l'exécution d'un script par la commande \fB.\fP (\fBsource\fP) elle conduit à l'arrêt de l'exécution du script par l'interpréteur et renvoie comme état final du script\ : soit \fIn\fP soit l'état final de la dernière commande exécutée dans le script. Si utilisée hors d'une fonction ou d'un script exécuté par \fB.\fP\^, l'état renvoyé est faux. Toute commande associée à la capture de \fBRETURN\fP est exécutée avant la reprise de l'exécution après la fonction ou le script. .TP \fBset\fP [\fB\-\-abefhkmnptuvxBCEHPT\fP] [\fB\-o\fP \fInom_d_option\fP] [\fIargument\fP ...] .PD 0 .TP \fBset\fP [\fB+abefhkmnptuvxBCEHPT\fP] [\fB+o\fP \fInom_d_option\fP] [\fIargument\fP ...] .PD Sans options, le nom et la valeur de chacune des variables de l'interpréteur sont affichés dans un format susceptible d'être réutilisé en entrée pour créer ou réinitialiser les variables actuelles. Les variables en lecture seule ne peuvent pas être réinitialisées. Dans le \fImode posix\fP, seules les variables de l'interpréteur sont affichées. La sortie est triée en fonction des paramètres linguistiques régionaux actuels. Lorsque des options sont indiquées, elles créent ou détruisent des attributs de l'interpréteur. Tous les \fIargument\fPs restant après traitement des options sont considérés comme des valeurs pour les paramètres positionnels et sont affectés, dans l'ordre, à\ : \fB$1\fP, \fB$2\fP, \fB...\fP \fB$\fP\fIn\fP. Les options, si indiquées, ont les significations suivantes\ : .RS .PD 0 .TP 8 \fB\-a\fP Marquer automatiquement des variables et fonctions modifiées ou créées pour qu'elles soient exportées dans l'environnement des commandes exécutées ultérieurement. .TP 8 \fB\-b\fP 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é. .TP 8 \fB\-e\fP Terminer immédiatement si une \fIconduite\fP (qui peut être réduite à une unique \fIcommande simple\fP), une commande de \fIsous\-interpréteur\fP entre parenthèses, ou une liste de commandes entre accolades (consultez .SM \fBGRAMMAIRE DE L'INTERPRÉTEUR\fP ci\-dessus) termine avec un état différent de zéro. L'interpréteur ne termine pas si la commande qui échoue fait partie d'une liste de commandes immédiatement suivie par un mot\-clef \fBwhile\fP ou \fBuntil\fP, d'un test suivant les mots réservés \fBif\fP ou \fBelif\fP, d'une commande exécuté dans une liste \fB&&\fP ou \fB||\fP sauf si la commande est située après le dernier \fB&&\fP ou \fB||\fP, d'une commande de conduite à l'exception de la dernière, ou si la valeur renvoyée par la commande est inversée par \fB!\fP. Une capture sur \fBERR\fP, si existante, est exécutée avant que l'interpréteur ne se termine. Cette option s'applique à l'environnement de l'interpréteur ainsi qu'à l'environnement de chaque sous\-interpréteur individuellement (consultez .SM \fBENVIRONNEMENT D'EXÉCUTION DES COMMANDES\fP ci\-dessus), et peut conduire des sous\-interpréteurs à se terminer avant d'y avoir exécuté toutes les commandes. .TP 8 \fB\-f\fP Désactiver le développement des chemins. .TP 8 \fB\-h\fP Mémoriser l'emplacement des commandes lors de leur exécution. Activée par défaut. .TP 8 \fB\-k\fP 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. .TP 8 \fB\-m\fP Mode supervision. Le contrôle des tâches est activé. Cette option est activée par défaut pour les interpréteurs interactifs sur les systèmes qui le permettent (consultez .SM \fBCONTRÔLE DES TÂCHES\fP ci\-dessus). 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. .TP 8 \fB\-n\fP Lecture de commandes sans exécution. Cela peut être utilisé pour rechercher les erreurs de syntaxe dans un script. Cette option est ignorée par les interpréteurs interactifs. .TP 8 \fB\-o \fP\fInom_d_option\fP Le \fInom_d_option\fP est l'un des suivants\ : .RS .TP 8 \fBallexport\fP Identique à \fB\-a\fP. .TP 8 \fBbraceexpand\fP Identique à \fB\-B\fP. .TP 8 \fBemacs\fP Utiliser une interface d'édition des lignes de commande «\ à la Emacs\ ». C'est le comportement activé par défaut quand l'interpréteur est interactif, sauf si l'interpréteur est démarré avec l'option \fB\-\-noediting\fP. L'interface d'édition utilisée par \fBread \-e\fP est modifiée également. .TP 8 \fBerrexit\fP Identique à \fB\-e\fP. .TP 8 \fBerrtrace\fP Identique à \fB\-E\fP. .TP 8 \fBfunctrace\fP Identique à \fB\-T\fP. .TP 8 \fBhashall\fP Identique à \fB\-h\fP. .TP 8 \fBhistexpand\fP Identique à \fB\-H\fP. .TP 8 \fBhistory\fP Activer l'historique des commandes, comme décrit ci\-dessus dans .SM \fBHISTORY\fP. Cette option est activée par défaut dans les interpréteurs interactifs. .TP 8 \fBignoreeof\fP Identique à l'exécution de la commande d'interpréteur .if t \f(CWIGNOREEOF=10\fP .if n « IGNOREEOF=10 » (consultez \fBVariables de l'interpréteur\fP ci\-dessus). .TP 8 \fBkeyword\fP Identique à \fB\-k\fP. .TP 8 \fBmonitor\fP Identique à \fB\-m\fP. .TP 8 \fBnoclobber\fP Identique à \fB\-C\fP. .TP 8 \fBnoexec\fP Identique à \fB\-n\fP. .TP 8 \fBnoglob\fP Identique à \fB\-f\fP. .TP 8 \fBnolog\fP Actuellement ignorée. .TP 8 \fBnotify\fP Identique à \fB\-b\fP. .TP 8 \fBnounset\fP Identique à \fB\-u\fP. .TP 8 \fBonecmd\fP Identique à \fB\-t\fP. .TP 8 \fBphysical\fP Identique à \fB\-P\fP. .TP 8 \fBpipefail\fP Si existante, la valeur renvoyée par une conduite est la valeur de la dernière commande (la plus à droite) à terminer avec un état final différent de zéro ou zéro si toutes les commandes de la conduite terminent avec succès. Désactivée par défaut. .TP 8 \fBposix\fP Aligner le comportement de \fBbash\fP sur le standard POSIX, en ce qui concerne les options dont l'action par défaut diffère de ce standard (\fImode posix\fP). .TP 8 \fBprivileged\fP Identique à \fB\-p\fP. .TP 8 \fBverbose\fP Identique à \fB\-v\fP. .TP 8 \fBvi\fP Utiliser une interface d'édition des lignes de commande «\ à la vi\ ». L'interface d'édition utilisée par \fBread \-e\fP est modifiée également. .TP 8 \fBxtrace\fP Identique à \fB\-x\fP. .sp .5 .PP Si \fB\-o\fP est fournie sans \fInom_d_option\fP, les valeurs actuelles des options sont affichées. Si \fB+o\fP est fournie sans \fInom_d_option\fP, la série de commandes \fBset\fP permettant de recréer la configuration actuelle d'options est affichée sur la sortie standard. .RE .TP 8 \fB\-p\fP Basculer en mode \fIprivilégié\fP. Dans ce mode, les fichiers \fB$ENV\fP et \fB$BASH_ENV\fP ne sont pas traités, les fonctions de l'interpréteur ne sont pas héritées de l'environnement, et les variables .SM \fBSHELLOPTS\fP, .SM \fBBASHOPTS\fP, .SM \fBCDPATH\fP, et .SM \fBGLOBIGNORE\fP, si présentes dans l'environnement, sont ignorées. Si l'interpréteur démarre avec un UID (ou respectivement un GID) effectif différent de son UID (GID) réel et si l'option \fB\-p\fP n'est pas fournie, ce comportement est appliqué et l'UID (GID) effectif est positionné à l'UID (GID) réel. Si l'option \fB\-p\fP est fournie au démarrage, l'UID (GID) effectif n'est pas modifié. Désactiver cette option conduit à la configuration des UID et GID effectifs à la valeur des UID et GID réels. .TP 8 \fB\-t\fP Terminer après lecture et exécution d'une commande. .TP 8 \fB\-u\fP Considérer les variables inexistantes et les paramètres différents des paramètres spéciaux «\ @\ » et «\ *\ » comme des erreurs lors du développement des paramètres. Si un développement de variable inexistante ou de paramètre est tenté, l'interpréteur affiche un message d'erreur et, s'il n'est pas interactif, termine avec un état différent de zéro. .TP 8 \fB\-v\fP Afficher les lignes en entrée de l'interpréteur lorsqu'elles sont lues. .TP 8 \fB\-x\fP Après le développement de chaque \fIcommande simple\fP, commande \fBfor\fP, commande \fBcase\fP, commande \fBselect\fP ou commande \fBfor\fP arithmétique, afficher la valeur développée de .SM \fBPS4\fP, suivie de la commande et ses arguments développés ou la liste de mots associés. .TP 8 \fB\-B\fP L'interpréteur effectue le développement des accolades (consultez \fBDéveloppement des accolades\fP ci\-dessus). Activée par défaut. .TP 8 \fB\-C\fP Si configurée, \fBbash\fP n'écrasera pas un fichier existant avec les opérateurs \fB>\fP, \fB>&\fP et \fB<>\fP. Ce comportement peut être surpassé lors de la création d'un fichier de sortie en utilisant l'opérateur de redirection \fB>|\fP à la place de \fB>\fP. .TP 8 \fB\-E\fP Si configurée, toute capture sur \fBERR\fP 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 \fBERR\fP n'est normalement pas héritée dans de tels cas. .TP 8 \fB\-H\fP Activer le style \fB!\fP de substitution d'historique. C'est le comportement par défaut lorsque l'interpréteur est interactif. .TP 8 \fB\-P\fP Si configurée, l'interpréteur ne doit pas suivre les liens symboliques en exécutant des commandes comme \fBcd\fP qui modifient le répertoire de travail. Il utilise à la place le répertoire physique. Par défaut \fBbash\fP suit la chaîne logique des répertoires lors des commandes qui modifient le répertoire actuel. .TP 8 \fB\-T\fP Si configurée, toutes les captures de \fBDEBUG\fP et \fBRETURN\fP 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 \fBDEBUG\fP et \fBRETURN\fP ne sont normalement pas héritées dans de tels cas. .TP 8 \fB\-\-\fP Si aucun argument ne suit cet option, alors les paramètres positionnels sont détruits. Sinon, les paramètres positionnels sont configurés aux \fIarguments\fP, même si certains d'entre eux commencent par un \fB\-\fP. .TP 8 \fB\-\fP Marquer la fin des options, tous les \fIarguments\fP restants sont alors affectés aux paramètres positionnels. Les options \fB\-x\fP et \fB\-v\fP sont désactivées. S'il n'y a pas d'\fIarguments\fP, les paramètres positionnels ne sont pas modifiés. .PD .PP Par défaut les attributs sont désactivés, sauf indication contraire. En utilisant «\ +\ » à la place de «\ \-\ », les options sont désactivées. Les options peuvent également être fournies en argument lors de l'appel de l'interpréteur. Le jeu actuel des options peut être trouvé dans \fB$\-\fP. La valeur renvoyée est toujours vrai, sauf si une option incorrecte est rencontrée. .RE .TP \fBshift\fP [\fIn\fP] Les paramètres positionnels à partir de \fIn\fP+1 ... sont renommés en \fB$1\fP \&\fB....\fP Les paramètres représentés par les nombres \fB$#\fP jusqu'à \fB$#\fP\-\fIn\fP+1 sont détruits. \fIn\fP doit être un entier positif inférieur ou égal à \fB$#\fP. Si \fIn\fP vaut 0, aucun paramètres n'est modifié. Si \fIn\fP est omis, on suppose qu'il vaut 1. Si \fIn\fP est supérieur à \fB$#\fP, les paramètres positionnels ne sont pas modifiés. L'état renvoyé est strictement positif si \fIn\fP est supérieur à \fB$#\fP ou strictement négatif, sinon 0 est renvoyé. .TP \fBshopt\fP [\fB\-pqsu\fP] [\fB\-o\fP] [\fInom_opt\fP ...] Bascule la valeur des variables contrôlant le comportement facultatif de l'interpréteur. Sans option ou avec l'option \fB\-p\fP, une liste de toutes les options configurables est affichée, avec l'indication de l'état de chacune d'entre elles. L'option \fB\-p\fP 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\ : .RS .PD 0 .TP \fB\-s\fP Activer (créer) chaque \fInom_opt\fP. .TP \fB\-u\fP Désactiver (détruire) chaque \fInom_opt\fP. .TP \fB\-q\fP Supprimer la sortie normale (mode silencieux)\ ; l'état renvoyé indique si \fInom_opt\fP est existante ou non. Si plusieurs arguments \fInom_opt\fP sont indiqués avec \fB\-q\fP, l'état renvoyé est zéro si tous les \fInom_opt\fP sont activés\ ; différent de zéro sinon. .TP \fB\-o\fP Restreindre les valeurs de \fInom_opt\fP à celles définies pour l'option \fB\-o\fP de la commande interne \fBset\fP. .PD .PP Si l'option \fB\-s\fP ou \fB\-u\fP est utilisée sans argument \fInom_opt\fP, l'affichage est limité aux options qui sont respectivement existantes ou non. Sauf indication contraire, les options \fBshopt\fP sont désactivées (détruites) par défaut. .PP L'état renvoyé lors d'un affichage des options est zéro si tous les \fInom_opt\fP 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 \fInom_opt\fP ne soit pas une option correcte de l'interpréteur. .PP La liste des options \fBshopt\fP est\ : .if t .sp .5v .if n .sp 1v .PD 0 .TP 8 \fBautocd\fP Si existante, un nom de commande qui est le nom d'un répertoire est exécuté comme s'il était l'argument de la commande interne \fBcd\fP. Cette option n'est utilisée que par les interpréteurs interactifs. .TP 8 \fBcdable_vars\fP Si existante, un argument de la commande interne \fBcd\fP qui n'est pas un répertoire est supposé être un nom de variable dont la valeur est le répertoire visé. .TP 8 \fBcdspell\fP Si existante, les erreurs minimes de frappe dans un composant du répertoire en argument de la commande \fBcd\fP 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. .TP 8 \fBcheckhash\fP Si existante, \fBbash\fP 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. .TP 8 \fBcheckjobs\fP Si existante, \fBbash\fP affiche la liste des états de toutes les tâches en cours et arrêtées avant de terminer un interpréteur interactif. Si des tâches sont en cours, la sortie est différée jusqu'à ce qu'une nouvelle sortie soit tentée sans commande intermédiaire (consultez .SM \fBCONTRÔLE DES TÂCHES\fP ci\-dessus). L'interpréteur repousse toujours la sortie si des tâches sont arrêtées. .TP 8 \fBcheckwinsize\fP Si existante, \fBbash\fP vérifie la taille de la fenêtre après chaque commande et, au besoin, met à jour les valeurs des variables .SM \fBLINES\fP et .SM \fBCOLUMNS\fP. .TP 8 \fBcmdhist\fP Si existante, \fBbash\fP essaie de sauvegarder les commandes s'étendant sur plusieurs lignes en un seul élément d'historique. Cela facilite l'édition ultérieure de commandes multilignes. .TP 8 \fBcompat31\fP Si existante, \fBbash\fP modifie son comportement de manière compatible à la version\ 3.1 en respectant les arguments protégés de l'opérateur \fB=~\fP de commande conditionnelle \fB[[\fP. .TP 8 \fBcompat32\fP Si existante, \fBbash\fP modifie son comportement de manière compatible à la version\ 3.2 en respectant les comparaisons de chaînes spécifiques aux paramètres linguistiques régionaux lors de l'utilisation des opérateurs \fB<\fP et \fB>\fP de commande conditionnelle \fB[[\fP. Les versions de \fBbash\fP antérieure à 4.1 utilisent la collation ASCII et \fBstrcmp\fP(3). \fBbash\fP à partir de la version\ 4.1 la suite de collation de des paramètres linguistiques régionaux et \fBstrcoll\fP(3). .TP 8 \fBcompat40\fP Si existante, \fBbash\fP modifie son comportement de manière compatible à la version\ 4.0 en respectant les comparaisons de chaînes spécifiques aux paramètres linguistiques régionaux lors de l'utilisation des opérateurs \fB<\fP et \fB>\fP de commande conditionnelle \fB[[\fP (consultez l'entrée précédente) et l'effet d'interruption de liste de commandes. .TP 8 \fBcompat41\fP Si existante, \fBbash\fP, lorsqu'il est en \fImode posix\fP, traite le guillemet simple dans l'expansion de paramètre entre guillemets doubles comme un caractère spécial. Les guillemets simples doivent correspondre (et même s'appairer) et les caractères entre guillemets simples sont considérés protégés. C'est le comportement du \fImode posix\fP de la version\ 4.1. le comportement par défaut de \fBbash\fP reste le même que dans les versions précédentes. .TP 8 \fBdirexpand\fP Si existante, \fBbash\fP remplace les noms de répertoire par les résultats de développement de mots lors du complètement des noms de fichier. Cela modifie le contenu du tampon d'édition de \fBreadline\fP. Sinon, \fBbash\fP essaye de conserver ce que l'utilisateur a tapé. .TP 8 \fBdirspell\fP Si existante, \fBbash\fP essaie de corriger les erreurs de frappe sur les noms de répertoire lors du complètement de mot si le nom de répertoire initialement fourni n'existe pas. .TP 8 \fBdotglob\fP Si existante, \fBbash\fP inclut les noms de fichiers commençant par un «\ .\ » dans les résultats des développements de chemins. .TP 8 \fBexecfail\fP Si existante, un interpréteur non interactif ne terminera pas s'il ne peut exécuter un fichier indiqué en argument de la commande interne \fBexec\fP. Un interpréteur interactif ne termine pas si \fBexec\fP échoue. .TP 8 \fBexpand_aliases\fP Si existante, les alias sont développés comme décrit ci\-dessus, dans .SM \fBALIAS\fP. Cette option est activée par défaut pour les interpréteurs interactifs. .TP 8 \fBextdebug\fP Si existante, le comportement attendu par les traceurs est activé\ : .RS .TP \fB1.\fP L'option \fB\-F\fP de la commande interne \fBdeclare\fP affiche le nom du fichier source et le numéro de ligne correspondant à chaque nom de fonction fourni comme argument. .TP \fB2.\fP Si la commande lancée par la capture de \fBDEBUG\fP renvoie une valeur différente de zéro, la commande suivante est sautée et n'est pas exécutée. .TP \fB3.\fP Si la commande lancée par la capture de \fBDEBUG\fP 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 \fB.\fP ou \fBsource\fP), un appel à \fBreturn\fP est simulé. .TP \fB4.\fP .SM \fBBASH_ARGC\fP et .SM \fBBASH_ARGV\fP sont mises à jour comme expliqué dans leurs descriptions ci\-dessus. .TP \fB5.\fP 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 \fB(\fP \fIcommand\fP \fB)\fP héritent des captures de \fBDEBUG\fP et \fBRETURN\fP. .TP \fB6.\fP 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 \fB(\fP \fIcommand\fP \fB)\fP héritent de la capture de \fBERR\fP. .RE .TP 8 \fBextglob\fP Si existante, les fonctionnalités étendues de mise en correspondance décrites ci\-dessus dans \fBDéveloppement des chemins\fP sont activées. .TP 8 \fBextquote\fP Si existante, la protection par \fB$\fP\(aq\fIchaîne\fP\(aq et \fB$\fP"\fIchaîne\fP" est effectuée à l'intérieur des développements de \fB${\fP\fIparamètres\fP\fB}\fP entre guillemets doubles. Cette option est activée par défaut. .TP 8 \fBfailglob\fP 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. .TP 8 \fBforce_fignore\fP Si existante, les suffixes indiqués par la variable de l'interpréteur .SM \fBFIGNORE\fP conduiront des mots à être ignorés lors du complètement de mot, même si les mots ignorés sont les seuls complètements possibles. Consultez .SM \fBVARIABLES DE L'INTERPRÉTEUR\fP ci\-dessus pour une description de .SM \fBFIGNORE\fP. Cette option est activée par défaut. .TP 8 \fBglobstar\fP Si existante, le motif \fB**\fP utilisé dans un contexte de développement des chemins correspondra à tous les fichiers et zéro ou plusieurs répertoires et sous\-répertoires. Si le motif est suivi de \fB/\fP, seuls les répertoires et sous\-répertoires correspondent. .TP 8 \fBgnu_errfmt\fP Si existante, les messages d'erreur de l'interpréteur seront écrits dans le format standard GNU des messages d'erreurs. .TP 8 \fBhistappend\fP Si existante, la file d'historique est ajoutée au fichier désigné par la valeur de la variable .SM \fBHISTFILE\fP lorsque l'interpréteur termine, plutôt que d'écraser ce fichier. .TP 8 \fBhistreedit\fP Si existante et si \fBreadline\fP est utilisée, un utilisateur peut rééditer une substitution d'historique qui a échoué. .TP 8 \fBhistverify\fP Si existante et si \fBreadline\fP est utilisée, le résultat de la substitution d'historique n'est pas transmise immédiatement à l'analyseur de l'interpréteur. À la place, la ligne résultante est chargée dans le tampon d'édition de \fBreadline\fP, permettant des modifications ultérieures. .TP 8 \fBhostcomplete\fP Si existante et si \fBreadline\fP est utilisée, \fBbash\fP essayera d'effectuer le complètement des noms de machines lorsqu'un mot contient un \fB@\fP (consultez \fBComplètement\fP dans .SM \fBREADLINE\fP ci\-dessus). Cette option est activée par défaut. .TP 8 \fBhuponexit\fP Si existante, \fBbash\fP enverra un signal .SM \fBSIGHUP\fP à toutes les tâches lorsqu'un interpréteur de connexion interactif termine. .TP 8 \fBinteractive_comments\fP Si existante, un mot commençant par un \fB#\fP conduira ce mot et tous les autres caractères restants de la ligne à être ignorés dans un interpréteur interactif (consultez .SM \fBCOMMENTAIRES\fP ci\-dessus). Cette option est activée par défaut. .TP 8 \fBlastpipe\fP Si existante, et que le contrôle des tâches n'est pas activé, l'interpréteur exécute la dernière commande d'une conduite non exécutée en arrière\-plan dans l'environnement d'interpréteur actuel. .TP 8 \fBlithist\fP Si existante et si l'option \fBcmdhist\fP est activée, les commandes multilignes sont sauvegardées dans l'historique avec des changements de ligne incorporés comme séparateurs plutôt que des points\-virgules là où c'est possible. .TP 8 \fBlogin_shell\fP L'interpréteur crée cette option s'il est démarré en tant qu'interpréteur de connexion (consultez .SM \fBAPPEL\fP ci\-dessus). La valeur ne peut être modifiée. .TP 8 \fBmailwarn\fP Si existante et s'il a été accédé à un fichier que \fBbash\fP surveille pour les courriers depuis sa dernière vérification, le message «\ Le courrier dans \fIfichier_de_courrier\fP a été lu.\ » est affiché. .TP 8 \fBno_empty_cmd_completion\fP Si existante et si \fBreadline\fP est utilisée, \fBbash\fP n'essaiera pas d'utiliser le .SM \fBPATH\fP pour de possibles complètements quand le complètement est tenté sur une ligne vide. .TP 8 \fBnocaseglob\fP Si existante, \fBbash\fP fait correspondre les noms de fichiers d'une façon insensible à la casse lors du développement des chemins (consultez \fBDéveloppement des chemins\fP ci\-dessus). .TP 8 \fBnocasematch\fP Si existante, \fBbash\fP fait correspondre les motifs d'une façon insensible à la casse lors de la mise en correspondance pendant l'exécution des commandes conditionnelles \fBcase\fP ou \fB[[\fP. .TP 8 \fBnullglob\fP Si existante, \fBbash\fP autorise les motifs ne correspondant à aucun fichier (consultez \fBDéveloppement des chemins\fP ci\-dessus) à se développer en une chaîne vide plutôt qu'en une valeur littérale. .TP 8 \fBprogcomp\fP Si existante, les outils de complètement programmables (consultez \fBComplètement programmable\fP ci\-dessus) sont activés. Cette option est activée par défaut. .TP 8 \fBpromptvars\fP Si existante, les chaînes d'invite sont sujettes au développement des paramètres, à la substitution de commande, au développement arithmétique et à la suppression des protections après avoir été développées comme décrit ci\-dessus dans .SM \fBINVITES\fP. Cette option est activée par défaut. .TP 8 \fBrestricted_shell\fP L'interpréteur crée cette option s'il est démarré en mode restreint (consultez .SM \fBINTERPRÉTEUR RESTREINT\fP ci\-dessous). 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. .TP 8 \fBshift_verbose\fP Si existante, la commande interne \fBshift\fP affiche un message d'erreur lorsque le nombre de décalages dépasse le nombre de paramètres positionnels. .TP 8 \fBsourcepath\fP Si existante, la commande interne \fBsource\fP (\fB.\fP) utilise la valeur de la variable .SM \fBPATH\fP pour trouver le répertoire contenant le fichier fourni en argument. Cette option est activée par défaut. .TP 8 \fBxpg_echo\fP Si existante, la commande interne \fBecho\fP développe par défaut les suites de caractères d'échappement par contre\-oblique. .RE .PD .TP \fBsuspend\fP [\fB\-f\fP] Suspend l'exécution de l'interpréteur jusqu'à la réception d'un signal .SM \fBSIGCONT\fP. Un interpréteur de connexion ne peut pas être suspendu\ ; l'option \fB\-f\fP permet de surpasser ce comportement et force sa suspension. L'état renvoyé est 0, sauf si l'interpréteur est un interpréteur de connexion et que l'option \fB\-f\fP est absente, ou si le contrôle des tâches n'est pas activé. .TP \fBtest\fP \fIexpr\fP .PD 0 .TP \fB[\fP \fIexpr\fP \fB]\fP Renvoie un état de 0 ou 1 selon l'évaluation de la condition \fIexpr\fP. Chaque opérateur et opérande doit être représenté par un argument distinct. Les conditions sont composées des primitives décrites ci\-dessus dans .SM \fBCONDITIONS\fP. \fBtest\fP n'accepte aucune option, n'accepte pas non plus et ignore l'argument \fB\-\-\fP signifiant la fin des options. .if t .sp 0.5 .if n .sp 1 Les conditions peuvent être combinées avec les opérateurs suivant, décrits par ordre de priorité décroissante. L'évaluation dépend du nombre d'arguments, voir ci\-dessous. La priorité des opérateurs est utilisée quand il y a au moins cinq arguments. .RS .PD 0 .TP \fB! \fP\fIexpr\fP Vrai si \fIexpr\fP est fausse. .TP \fB( \fP\fIexpr\fP\fB )\fP Renvoie la valeur de \fIexpr\fP. Peut servir à surpasser la priorité normale des opérateurs. .TP \fIexpr1\fP \fB\-a\fP \fIexpr2\fP Vrai si \fIexpr1\fP et \fIexpr2\fP sont toutes deux vraies. .TP \fIexpr1\fP \fB\-o\fP \fIexpr2\fP Vrai si \fIexpr1\fP ou \fIexpr2\fP est vraie. .PD .PP \fBtest\fP et \fB[\fP évaluent les conditions en fonction d'un jeu de règles dépendant du nombre d'arguments. .if t .sp 0.5 .if n .sp 1 .PD 0 .TP 0 argument La condition est fausse. .TP 1 argument La condition est vraie si et seulement si l'argument n'est pas vide. .TP 2 arguments Si le premier argument est \fB!\fP, 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 ci\-dessus dans .SM \fBCONDITIONS\fP 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. .TP 3 arguments Les conditions suivantes sont appliquées dans l'ordre de la liste. Si le second argument est l'un des opérateurs conditionnels binaires décrits ci\-dessus dans .SM \fBCONDITIONS\fP, le résultat de la condition est le résultat du test binaire utilisant le premier et le troisième argument en tant qu'opérandes. Les opérateurs \fB\-a\fP et \fB\-o\fP sont considérés comme des opérateurs binaires quand ils sont avec trois arguments. Si le premier argument est \fB!\fP, la valeur est la négation du test binaire utilisant les deuxième et troisième arguments. Si le premier argument est exactement \fB(\fP et le troisième argument est exactement \fB)\fP, le résultat est le test unaire du second argument. Sinon la condition est fausse. .TP 4 arguments Si le premier argument est \fB!\fP, 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. .TP 5 arguments ou plus La condition est analysée et évaluée selon les règles de priorité décrites ci\-dessus. .if t .sp 0.5 .if n .sp 1 .LP Lorsqu'ils sont utilisés avec \fBtest\fP ou \fB[\fP, les opérateurs \fB<\fP et \fB>\fP ordonnent d'un point de vue lexicographique en utilisant l'ordre ASCII. .RE .PD .TP \fBtimes\fP 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. .TP \fBtrap\fP [\fB\-lp\fP] [[\fIargument\fP] \fIsignal\fP ...] La commande \fIargument\fP doit être lue et exécutée quand l'interpréteur reçoit au moins un \fIsignal\fP. Si \fIargument\fP est absent (et qu'un seul \fIsignal\fP est fourni) ou \fB\-\fP, chaque signal indiqué est réinitialisé à sa position d'origine (la valeur qu'il avait lors de l'entrée dans l'interpréteur). Si \fIargument\fP est la chaîne vide, chaque \fIsignal\fP indiqué est ignoré par l'interpréteur et par les commandes qu'il appelle. Si \fIargument\fP n'est pas présent et que \fB\-p\fP est fourni, les commandes capturées associées à chaque \fIsignal\fP sont affichées. Si aucun argument n'est fourni, ou si seul \fB\-p\fP est donné, \fBtrap\fP affiche la liste des commandes associées à chaque signal. L'option \fB\-l\fP conduit l'interpréteur a afficher une liste des noms de signal et leur numéro correspondant. Chaque \fIsignal\fP est soit un nom de signal défini dans <\fIsignal.h\fP>, soit un numéro de signal. Les noms de signal sont insensibles la casse et le préfixe .SM \fBSIG\fP est optionnel. .if t .sp 0.5 .if n .sp 1 Si un \fIsignal\fP est .SM \fBEXIT\fP (0), la commande \fIargument\fP est exécutée lors de la sortie de l'interpréteur. Si un \fIsignal\fP est .SM \fBDEBUG\fP, la commande \fIargument\fP est exécutée avant toute \fIcommande simple\fP, commande \fBfor\fP, commande \fBcase\fP, commande \fBselect\fP, toute commande \fBfor\fP arithmétique, et avant que la première commande n'exécute une fonction de l'interpréteur (consultez .SM \fBGRAMMAIRE DE L'INTERPRÉTEUR\fP ci\-dessus). Reportez\-vous à la description de l'option \fBextdebug\fP de la commande interne \fBshopt\fP pour obtenir des renseignements sur les effets de la capture \fBDEBUG\fP. Si un \fIsignal\fP est .SM \fBRETURN\fP, la commande \fIargument\fP est exécutée à chaque fois qu'une fonction de l'interpréteur, ou un script exécuté avec les commandes internes \fB.\fP ou \fBsource\fP, termine son exécution. .if t .sp 0.5 .if n .sp 1 Si un \fIsignal\fP est .SM \fBERR\fP, la commande \fIargument\fP est exécutée chaque fois qu'une commande simple renvoie un état final différent de zéro, sujet aux conditions suivantes. La capture .SM \fBERR\fP n'est pas exécutée si la commande échouée fait partie d'une liste de commandes immédiatement suivie par un mot\-clef \fBwhile\fP ou \fBuntil\fP, d'un test \fIif\fP, d'une commande exécutée au sein d'une liste de \fB&&\fP ou de \fB||\fP, ou si la valeur renvoyée par la commande est inversée par \fB!\fP. Se sont les mêmes conditions que celles observées par l'option \fBerrexit\fP. .if t .sp 0.5 .if n .sp 1 Les signaux ignorés en entrant dans l'interpréteur ne peuvent être capturés ou réinitialisés. Les signaux capturés qui ne sont pas ignorés sont réinitialisés à leur valeur d'origine dans un sous\-interpréteur ou un environnement de sous\-interpréteur quand il est créé. L'état renvoyé est faux si un \fIsignal\fP n'est pas valable, sinon \fBtrap\fP renvoie vrai. .TP \fBtype\fP [\fB\-aftpP\fP] \fInom\fP [\fInom\fP ...] Sans option, indique comment chaque \fInom\fP doit être interprété si on l'utilise en nom de commande. Si l'attribut \fB\-t\fP est utilisé, \fBtype\fP affiche une des phrases suivantes \fIalias\fP, \fIkeyword\fP, \fIfunction\fP, \fIbuiltin\fP ou \fIfile\fP selon que le \fInom\fP 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 \fInom\fP n'est pas trouvé, rien n'est affiché et un état final à faux est renvoyé. Si l'option \fB\-p\fP est utilisée, \fBtype\fP renvoie le nom du fichier qui sera exécuté si l'on tape le \fInom\fP en guise de commande ou rien si .if t \f(CWtype -t name\fP .if n « type -t name » ne renvoyait pas \fIfile\fP. L'option \fB\-P\fP force une recherche dans .SM \fBPATH\fP pour chaque \fInom\fP, même si .if t \f(CWtype -t name\fP .if n « type -t name » ne renvoyait pas \fIfile\fP. Si une commande est disponible dans la table de hachage, \fB\-p\fP et \fB\-P\fP affichent la valeur de cette table, qui n'est pas nécessairement le fichier apparaissant en premier dans .SM \fBPATH\fP. Si l'option \fB\-a\fP est appelée, \fBtype\fP affiche tous les emplacements contenant un exécutable du \fInom\fP indiqué. Cela inclut les alias et les fonctions, sauf si l'option \fB\-p\fP est également présente. La table de hachage des commandes n'est pas consultée avec l'option \fB\-a\fP. L'option \fB\-f\fP supprime la fonction de l'interpréteur de consultation de table, comme avec la commande interne \fBcommand\fP. \fBtype\fP renvoie vrai si tous les arguments sont trouvés et faux si aucun n'a pas été trouvé. .TP \fBulimit\fP [\fB\-HSTabcdefilmnpqrstuvx\fP [\fIlimitation\fP]] Fournit, sur les systèmes qui le permettent, un mécanisme de contrôle des ressources disponibles pour l'interpréteur et pour les processus qu'il lance. Les options \fB\-H\fP et \fB\-S\fP indiquent si la limitation est stricte («\ hard\ ») ou flexible («\ soft\ ») pour la ressource indiquée. Une limitation stricte ne peut pas être augmentée par un utilisateur non privilégié une fois qu'elle a été configurée\ ; une limitation flexible peut être augmentée jusqu'à la valeur de la limitation stricte correspondante. Si ni \fB\-H\fP ni \fB\-S\fP n'est indiqué, les limitations strictes et flexibles sont toutes deux configurées. La valeur de la \fIlimitation\fP peut être un nombre (utilisant les unités particulières de la ressource) ou l'une des valeurs spéciales \fBhard\fP, \fBsoft\fP ou \fBunlimited\fP, qui signifient, respectivement, la limitation stricte actuelle, la limitation flexible actuelle et l'absence de limitation. Si la \fIlimitation\fP est omise, la valeur actuelle de la limitation flexible pour la ressource est affichée, à moins que l'option \fB\-H\fP soit indiquée. Quand plusieurs ressources sont indiquées, les noms des limitations et leurs unités sont affichés avant les valeurs. Les autres options sont interprétées comme suit\ : .RS .PD 0 .TP \fB\-a\fP Toutes les limitations actuelles sont signalées .TP \fB\-b\fP La taille maximum du tampon de «\ socket\ » .TP \fB\-c\fP La taille maximum des fichiers core créés .TP \fB\-d\fP La taille maximum du segment de données d'un processus .TP \fB\-e\fP La priorité d'ordonnancement maximum («\ nice\ ») .TP \fB\-f\fP La taille maximum d'un fichier écrit par l'interpréteur et ses enfants .TP \fB\-i\fP Le nombre maximum de signaux en attente .TP \fB\-l\fP La taille maximum qui peut être verrouillée en mémoire .TP \fB\-m\fP La taille maximum de la partie résidente d'un processus («\ resident set size\ » ou RSS, la plupart des systèmes ne respectent pas cette limite) .TP \fB\-n\fP Le nombre maximum de descripteurs de fichiers ouverts (la plupart des systèmes ne permettent pas de modifier cette valeur) .TP \fB\-p\fP La taille d'un tube en blocs de 512 octets (parfois inexistante) .TP \fB\-q\fP Le nombre maximum d'octets dans les files de messages POSIX .TP \fB\-r\fP La priorité d'ordonnancement temps\-réel maximale .TP \fB\-s\fP La taille maximum de la pile .TP \fB\-t\fP La durée maximum, en seconde, de temps CPU accordé à un processus .TP \fB\-u\fP Le nombre maximum de processus autorisés pour un seul utilisateur .TP \fB\-v\fP La quantité de mémoire virtuelle disponible pour l'interpréteur et, sur certains systèmes, pour ses enfants .TP \fB\-x\fP Le nombre maximum de verrous de fichiers .TP \fB\-T\fP Le nombre maximum de processus légers («\ threads\ ») .PD .PP Si une \fIlimitation\fP est indiquée, elle sera la nouvelle valeur pour la ressource indiquée (l'option \fB\-a\fP correspond à l'affichage seul). Si aucune option n'est indiquée alors \fB\-f\fP est supposée. Les valeurs s'expriment par pas de 1024 octets, sauf pour \fB\-t\fP qui est en secondes, \fB\-p\fP, qui utilise des unités de blocs de 512 octets, ainsi que \fB\-T\fP, \fB\-b\fP, \fB\-n\fP et \fB\-u\fP, qui n'ont pas d'unités. L'état renvoyé est 0, sauf si une option ou un argument incorrect a été fourni ou si une erreur se produit en configurant la nouvelle limitation. .RE .TP \fBumask\fP [\fB\-p\fP] [\fB\-S\fP] [\fImode\fP] Le masque de création de fichier de l'utilisateur est configuré à \fImode\fP. Si \fImode\fP 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 \fBchmod\fP(1). Si \fImode\fP est omis ou si l'option \fB\-S\fP est fournie, la valeur actuelle du masque est affichée. L'option \fB\-S\fP conduit à l'affichage du masque sous forme symbolique, l'affichage par défaut étant en octal. Si l'option \fB\-p\fP est fournie et si le \fImode\fP 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 \fImode\fP n'a été fourni, et faux sinon. .TP \fBunalias\fP [\-\fBa\fP] [\fInom\fP ...] Supprime le \fInom\fP de la liste des alias définis. Si l'option \fB\-a\fP est fournie, toutes les définitions d'alias sont supprimées. La valeur renvoyée est vrai, sauf si un \fInom\fP fourni n'est pas un alias défini. .TP \fBunset\fP [\-\fBfv\fP] [\fInom\fP ...] Pour chaque \fInom\fP indiqué, supprime la variable ou la fonction correspondante. Si aucune option n'est fournie ou si l'option \fB\-v\fP est indiquée, chaque \fInom\fP se rapporte à une variable de l'interpréteur. Les variables en lecture seule ne peuvent pas être détruites. Si l'option \fB\-f\fP est indiquée, chaque \fInom\fP se rapporte à une fonction de l'interpréteur et la définition de la fonction est supprimée. Chaque variable ou fonction détruite est supprimée de l'environnement transmis aux commandes ultérieures. Si l'une des variables .SM \fBCOMP_WORDBREAKS\fP, .SM \fBRANDOM\fP, .SM \fBSECONDS\fP, .SM \fBLINENO\fP, .SM \fBHISTCMD\fP, .SM \fBFUNCNAME\fP, .SM \fBGROUPS\fP ou .SM \fBDIRSTACK\fP est détruite, elle perd ses propriétés spécifiques, même s'il elle est recréée ultérieurement. L'état final est vrai sauf si un des \fInom\fPs est en lecture seule. .TP \fBwait\fP [\fIn ...\fP] Attend que chaque processus indiqué termine et renvoie son état final. Chaque \fIn\fP 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 \fIn\fP est omis, la fin de tous les processus enfants actuellement actifs sera attendue et l'état renvoyé est zéro. Si \fIn\fP indique un processus ou une tâche inexistants, l'état renvoyé est 127. Sinon, l'état renvoyé est l'état final du dernier processus ou tâche attendu. .if \n(zZ=1 .ig zZ .\" bash_builtins .SH "INTERPRÉTEUR RESTREINT" .\" rbash.1 .zY .PP Si \fBbash\fP démarre sous le nom \fBrbash\fP ou si l'option \fB\-r\fP 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 \fBbash\fP à la différence des actions suivantes qui sont interdites ou non effectuées\ : .IP \(bu changer de répertoire avec \fBcd\fP\ ; .IP \(bu créer ou détruire les valeurs de .SM \fBSHELL\fP, .SM \fBPATH\fP, .SM \fBENV\fP ou .SM \fBBASH_ENV\fP\ ; .IP \(bu indiquer des noms de commandes contenant un \fB/\fP\ ; .IP \(bu indiquer un nom de fichier contenant un \fB/\fP comme argument de la commande interne \fB.\fP\ ; .IP \(bu indiquer un nom de fichier contenant une barre oblique comme argument de l'option \fB\-p\fP de la commande interne \fBhash\fP\ ; .IP \(bu importer une définition de fonction dans l'environnement au démarrage\ ; .IP \(bu analyser les valeurs de .SM \fBSHELLOPTS\fP au démarrage\ ; .IP \(bu rediriger la sortie en utilisant les opérateurs de redirection >, >|, <>, >&, &> et >>\ ; .IP \(bu utiliser la commande interne \fBexec\fP pour remplacer l'interpréteur par une autre commande\ ; .IP \(bu ajouter ou supprimer des commandes internes avec les options \fB\-f\fP et \fB\-d\fP de la commande interne \fBenable\fP\ ; .IP \(bu utiliser la commande interne \fBenable\fP pour activer les commandes internes de l'interpréteur désactivées\ ; .IP \(bu indiquer l'option \fB\-p\fP à la commande interne \fBcommande\fP\ ; .IP \(bu supprimer le mode restreint avec \fBset +r\fP ou \fBset +o restricted\fP. .PP Ces restrictions sont mises en place après la lecture de n'importe quel fichier de démarrage. .PP .ie \n(zY=1 Quand une commande exécutée se trouve être un script shell, .el \{ Quand une commande exécutée se trouve être un script shell (consultez .SM .B "EXÉCUTION DES COMMANDES" ci-dessus), \} \fBrbash\fP supprime toute restriction dans l'interpréteur créé pour exécuter le script. .if \n(zY=1 .ig zY .\" end of rbash.1 .SH "VOIR AUSSI" .PD 0 .TP \fIManuel de référence de Bash\fP, Brian Fox et Chet Ramey .TP \fIThe GNU Readline Library\fP, Brian Fox et Chet Ramey .TP \fIThe GNU History Library\fP, Brian Fox et Chet Ramey .TP \fIPortable Operating System Interface (POSIX) Part 2: Shell and Utilities\fP, IEEE .TP \fBsh\fP(1), \fBksh\fP(1), \fBcsh\fP(1) .TP \fBemacs\fP(1), \fBvi\fP(1) .TP \fBreadline\fP(3) .PD .SH FICHIERS .PD 0 .TP .FN /bin/bash L'exécutable \fBbash\fP .TP .FN /etc/profile Le fichier d'initialisation commun à tout le système, exécuté pour les interpréteurs de commandes de connexion .TP .FN /etc/bash.bashrc Le fichier de démarrage commun à tout le système pour chacun des interpréteurs interactifs .TP .FN /etc/bash.bash.logout Le fichier de nettoyage des interpréteurs de connexion commun à tout le système, exécuté lorsqu'un interpréteur de connexion termine .TP .FN ~/.bash_profile Le fichier d'initialisation personnel exécuté pour les interpréteurs de commandes de connexion .TP .FN ~/.bashrc Le fichier de démarrage personnel, pour chacun des interpréteurs interactifs .TP .FN ~/.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 .TP .FN ~/.inputrc Le fichier d'initialisation personnalisée de \fIreadline\fP .PD .SH AUTEURS Brian Fox, Free Software Foundation .br bfox@gnu.org .PP Chet Ramey, Case Western Reserve University .br chet.ramey@case.edu .SH "SIGNALEMENTS D'ANOMALIES" Si vous trouvez une anomalie dans \fBbash,\fP 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 \fBbash\fP disponible. La dernière version est toujours disponible à partir de \fIftp://ftp.gnu.org/pub/gnu/bash/\fP. .PP Une fois que vous avez déterminé qu'une anomalie existe effectivement, utilisez la commande \fIbashbug\fP 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) à \fIbug\-bash@gnu.org\fP ou postés dans le groupe Usenet \fBgnu.bash.bug\fP. .PP TOUS les signalements d'anomalie doivent contenir\ : .PP .PD 0 .TP 20 Le numéro de version de \fBbash\fP .TP Le matériel et le système d'exploitation utilisés .TP Le compilateur utilisé pour compiler .TP Une description (en anglais) de l'anomalie .TP Un petit script ou une «\ recette\ » qui démontre l'anomalie .PD .PP \fIbashbug\fP insère automatiquement les trois premiers éléments de cette liste dans le formulaire qu'il fournit pour remplir un signalement d'anomalie. .PP Les commentaires et signalement d'anomalies concernant la version originale de cette page de manuel (en anglais) doivent être transmis à \fIchet.ramey@case.edu\fP. Ceux concernant cette version française peuvent être envoyés à \fIdebian\-l10n\-french@lists.debian.org\fP. .SH ANOMALIES .PP Cet interpréteur de commandes est trop gros et trop lent. .PP Il y a quelques différences subtiles de comportement entre \fBbash\fP et les versions traditionnelles de \fBsh\fP, principalement à cause des spécifications .SM \fBPOSIX\fP. .PP L'utilisation des alias peut avoir des conséquences inattendues. .PP Les commandes internes et les fonctions de l'interpréteur ne peuvent pas être suspendues/relancées. .PP 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. .PP Les variables de type tableau ne peuvent pas (encore) être exportées. .PP Il ne peut exister qu'un seul coprocessus actif à la fois. .zZ .zY .SH TRADUCTION Ce document est une traduction réalisée par Christophe Blaess et Thierry Vignaud en 1997, et mise à jour par Alain Portal en 2006. La version présente dans Debian a été entièrement retravaillée par Frédéric Lehobey et est dorénavant maintenue par David Prévot \fIdavid@tilapin.org\fP et les membres de la liste \fIdebian\-l10n\-french@lists.debian.org\fP. Veuillez signaler toute erreur de traduction par un rapport de bogue sur le paquet manpages\-fr\-extra.