Traitement de la liste d'arguments¶

Si le premier argument (argument 0) du shell est « - », alors c'est un shell de connexion. Un shell de connexion peut également être spécifié en invoquant le shell avec l'option -l pour seul argument.

Les autres arguments options sont interprétés comme suit :

-b

Forcer une « cassure » lors du traitement des options, en faisant en sorte que tout argument ultérieur soit traité comme un argument non option. Les arguments restants ne seront pas interprétés comme des options du shell. Cela peut être utile pour passer des options à un script shell en évitant une confusion ou un éventuel subterfuge. Le shell n'exécutera pas de script SUID sans cette option.

-c

Les commandes sont lues à partir de l'argument suivant (qui doit être présent, et qui doit être seul), stockées dans la variable shell command pour pouvoir être référencées, et exécutées. Tous les arguments restants sont placés dans la variable shell argv.

-d

Le shell charge la pile de répertoires à partir de ~/.cshdirs comme décrit dans Démarrage et arrêt, que ce soit un shell de connexion ou non. (+)

-Dnom[=valeur]

Fournit une valeur à la variable d'environnement nom. (Domain/OS uniquement) (+)

-e

Le shell se termine si une des commandes invoquées se termine anormalement ou produit une valeur de retour non nulle.

-f

Le shell ignore ~/.tcshrc, et démarre ainsi plus rapidement.

-F

Le shell utilise fork(2) au lieu de vfork(2) pour créer des processus. (Convex/OS uniquement) (+)

-i

Le shell est interactif et demande une entrée de haut niveau, même si elle ne semble pas provenir d'un terminal. Les shells sont interactifs sans cette option si leurs entrées et sorties sont des terminaux.

-l

Le shell est un shell de connexion. Applicable uniquement si -l est la seule option spécifiée.

-m

Le shell charge ~/.tcshrc même s'il n'appartient pas à l'utilisateur effectif. Des versions plus récentes de su(1) peuvent passer -m au shell. (+)

-n

Le shell analyse les commandes mais ne les exécute pas. Cela aide au débogage des scripts shell.

-q

Le shell accepte SIGQUIT (voyez Traitement des signaux) et agit quand il est utilisé sous un débogueur. Le contrôle des travaux est désactivé. (u)

-s

Les commandes d'entrée sont lues à partir de l'entrée standard.

-t

Le shell lit et exécute une ligne d'entrée. Un « \ » peut être utilisé pour protéger le saut de ligne (« \n ») et continuer sur une autre ligne.

-v

Définit la variable shell verbose, afin que l'entrée de la commande soit renvoyée en écho après la substitution d'historique.

-x

Définit la variable shell echo, afin que les commandes soient renvoyées en écho juste avant leur exécution.

-V

Définit la variable shell verbose avant même d'exécuter ~/.tcshrc.

-X

Est à -x ce que -V est à -v.

Après le traitement des arguments options, s'il reste des arguments mais qu'aucune des options -c, -i, -s ou -t n'est fournie, le premier argument est supposé être le nom d'un fichier de commandes, c.-à-d. le « script » à exécuter. Le shell ouvre ce fichier et sauvegarde son nom pour une éventuelle re-substitution pour « $0 ». Puisque de nombreux systèmes utilisent les shells standard version 6 ou 7 dont les scripts ne sont pas compatibles avec ce shell, celui-ci utilise un tel shell « standard» pour exécuter un script dont le premier caractère n'est pas un « #», c.-à-d. qui ne commence pas par un commentaire.

Les arguments restants sont placés dans la variable shell argv.

Démarrage et arrêt¶

Un shell de connexion démarre en exécutant les commandes des fichiers système /etc/csh.cshrc et /etc/csh.login. Il exécute ensuite les commandes des fichiers situés dans le répertoire personnel (home) de l'utilisateur : d'abord ~/.tcshrc (+) ou, s'il n'est pas trouvé, ~/.cshrc ; ensuite ~/.history (ou la valeur de la variable shell histfile) ; puis ~/.login ; et finalement ~/.cshdirs (ou la valeur de la variable shell dirsfile) (+). Le shell peut lire /etc/csh.login avant plutôt qu'après /etc/csh.cshrc, et ~/.login avant plutôt qu'après ~/.tcshrc ou ~/.cshrc et ~/.history, s'il est compilé ainsi ; voyez la variable shell version. (+)

Les shells non de connexion ne lisent que /etc/csh.cshrc et ~/.tcshrc ou ~/.cshrc au démarrage.

Pour des exemples de fichiers de démarrage, veuillez consulter http://tcshrc.sourceforge.net.

Les commandes comme stty(1) et tset(1), qui ne doivent être exécutées qu'une fois par connexion, sont habituellement situées dans un des fichiers ~/.login. Les utilisateurs qui doivent utiliser le même jeu de fichiers pour csh(1) et tcsh peuvent n'avoir qu'un seul ~/.cshrc qui vérifie l'existence de la variable shell tcsh avant d'utiliser des commandes spécifiques à tcsh, ou peuvent avoir à la fois un ~/.cshrc et un ~/.tcshrc qui emploient comme source (voyez la commande intégrée) le fichier ~/.cshrc. Le reste de ce manuel utilisera « ~/.tcshrc » pour vouloir dire « ~/.tcshrc » ou, si ~/.tcshrc n'est pas trouvé, « ~/.cshrc ».

Normalement, le shell commence à lire des commandes à partir du terminal, en affichant l'invite « > ». (Le traitement des arguments et l'utilisation du shell pour traiter les fichiers contenant des scripts de commandes seront décrits plus tard.) Le shell effectue à plusieurs reprises la boucle suivante : il lit une ligne d'entrée de commande, la découpe en mots, la place dans la liste d'historique de commandes, l'analyse et exécute chaque commande de la ligne.

On peut se déconnecter en tapant « ^D » sur une ligne vide, en tapant « logout » ou « login », ou encore via le mécanisme de déconnexion automatique du shell (voyez la variable shell autologout). Quand un shell de connexion se termine, il donne la valeur appropriée (« normal » ou « automatic ») à la variable shell logout, et exécute ensuite les commandes des fichiers /etc/csh.logout et ~/.logout. Le shell peut ignorer le DTR à la déconnexion si cela est compilé ; voyez la variable shell version.

Les noms des fichiers de connexion et de déconnexion varient selon les systèmes pour assurer la compatibilité avec les différentes variantes de csh(1) ; voyez FICHIERS.

Édition¶

Nous décrivons d'abord L'éditeur de ligne de commandes. Les sections Complètement et listage et Correction orthographique décrivent deux ensembles de fonctionnalités qui sont implémentées sous forme de commandes d'éditeur, mais qui méritent un traitement spécifique. Finalement, la section Commandes de l'éditeur liste et décrit les commandes d'éditeur spécifiques au shell et leurs liaisons par défaut.

L'éditeur de ligne de commandes (+)¶

L'entrée de la ligne de commandes peut être éditée en utilisant des séquences de touches semblables à celles employées dans GNU Emacs ou vi(1). L'éditeur n'est actif que lorsque la variable shell edit est définie, ce qui est le cas par défaut dans les shells interactifs. La commande intégrée bindkey peut afficher et modifier les liaisons de touches. Des liaisons de touches de style Emacs sont utilisées par défaut (à moins que le shell n'ait été compilé différemment ; voyez la variable shell version), mais bindkey peut modifier les liaisons de touches pour utiliser un style vi.

Le shell associe toujours les touches fléchées (comme définies dans la variable d'environnement TERMCAP) à

à moins que procéder ainsi n'altère une autre liaison de caractère. On peut donner aux séquences d'échappement de touches fléchées la valeur « chaîne vide » ("") en utilisant settc pour empêcher ces liaisons. Les séquences ANSI/VT100 pour les touches fléchées sont toujours liées.

Les autres liaisons de touches sont, pour la plupart, celles auxquelles les utilisateurs d'emacs(1) et de vi(1) s'attendent et peuvent facilement être affichées par bindkey, de sorte qu'il n'est pas nécessaire de les lister ici. De même, bindkey peut lister les commandes d'éditeur accompagnées d'une courte description de chacune d'entre elles.

Notez que les commandes d'éditeur n'ont pas la même notion de « mot » que celle qu'a le shell. L'éditeur délimite les mots par n'importe quel caractère non alphanumérique ne faisant pas partie de la variable shell wordchars, alors que le shell ne reconnaît que les caractères d'espacement et certains des caractères ayant une signification spéciale pour lui, qui sont listés dans Structure Lexicale.

Complètement et listage (+)¶

Le shell est souvent capable de compléter des mots quand on lui fournit une abréviation unique. Tapez une partie d'un mot (par exemple « ls /usr/lost ») et appuyez sur la touche tab pour lancer la commande d'éditeur complete-word (compléter-mot). Le shell complète le nom de fichier « /usr/lost » en « /usr/lost+found/ », en remplaçant le mot incomplet par le mot complet dans le tampon d'entrée. (Note sur le « / » terminal : le complètement ajoute un « / » à la fin des répertoires complétés, et une espace à la fin des autres mots complétés, pour accélérer la frappe et fournir un indicateur visuel d'un complètement réussi. La variable shell addsuffix peut être indéfinie pour éviter cela.) Si aucune correspondance n'est trouvée (« /usr/lost+found » n'existe peut-être pas), la sonnerie du terminal retentit. Si le mot est déjà complet (il y a peut-être un « /usr/lost » sur votre système, ou vous avez peut-être pensé trop loin et avez déjà tapé le mot en entier), un « / » ou une espace est ajouté(e) à la fin si il/elle n'y était pas déjà.

Le complètement fonctionne partout sur la ligne, et pas uniquement à la fin ; le texte complété pousse le reste de la ligne sur la droite. Le complètement au milieu d'un mot résulte souvent en des caractères excédentaires à la droite du curseur qui devront être effacés.

Les commandes et les variables peuvent être complétées d'une façon fort similaire. Par exemple, taper « em[tab] » complète « em » en « emacs » si emacs est la seule commande sur votre système débutant par « em ». Le complètement peut trouver une commande si elle est située dans n'importe quel répertoire du path, ou bien si on lui fournit un nom de chemin complet. Taper « echo $ar[tab] » complète « $ar » en « $argv » si aucune autre variable ne commence par « ar ».

Le shell examine le tampon d'entrée pour déterminer si le mot que vous voulez compléter doit être complété en tant que nom de fichier, commande ou variable. Le premier mot du tampon et le premier mot suivant « ; », « | », « |& », « && » ou « || » sont considérés être des commandes. Un mot débutant par « $ » est considéré être une variable. Tout le reste est considéré être un nom de fichier. Une ligne vide est « complétée » en tant que nom de fichier.

Vous pouvez lister les complètements possibles d'un mot à tout moment en tapant « ^D » pour lancer la commande d'éditeur delete-char-or-list-or-eof. Le shell liste les complètements possibles en utilisant la commande intégrée ls-F et réaffiche l'invite et la ligne de commandes non terminée, par exemple :

> ls /usr/l[^D]
lbin/ lib/ local/ lost+found/
> ls /usr/l

Si la variable shell autolist est définie, le shell liste les choix restants (s'il y en a) à chaque fois que le complètement échoue :

> set autolist
> nm /usr/lib/libt[tab]
libtermcap.a@ libtermlib.a@
> nm /usr/lib/libterm

Si autolist vaut « ambiguous », les choix ne sont listés que lorsque le complètement échoue et n'ajoute aucun nouveau caractère au mot en cours de complètement.

Un nom de fichier à compléter peut contenir des variables, votre répertoire personnel ou celui d'autres personnes abrégé en « ~ » (voyez Substitution des noms de fichiers), et des entrées de la pile de répertoires abrégées avec « = » (voyez Substitution de pile de répertoires). Par exemple,

> ls ~k[^D]
kahn kas kellogg
> ls ~ke[tab]
> ls ~kellogg/

ou

> set local = /usr/local
> ls $lo[tab]
> ls $local/[^D]
bin/ etc/ lib/ man/ src/
> ls $local/

Notez que les variables peuvent également être développées explicitement via la commande d'éditeur expand-variables.

delete-char-or-list-or-eof liste uniquement à la fin de la ligne ; au milieu d'une ligne, elle efface le caractère situé sous le curseur et, sur une ligne vide, provoque la déconnexion ou, si ignoreeof est définie, ne fait rien. « M-^D », lié à la commande d'éditeur list-choices, liste les complètements possibles n'importe où sur une ligne, et list-choices (ou n'importe laquelle des commandes d'éditeur apparentées qui effacent ou non, listent et/ou déconnectent, qui sont listées sous delete-char-or-list-or-eof), peut être liée à « ^D » avec la commande intégrée bindkey si vous le souhaitez.

Les commandes d'éditeur complete-word-fwd et complete-word-back (qui ne sont liées à aucune touche par défaut) peuvent être utilisées pour cycler entre les différents complètements possibles, en remplaçant le mot courant par le mot suivant ou précédent dans la liste.

La variable shell fignore peut être définie en tant que liste de suffixes à ignorer lors du complètement. Considérez le cas suivant :

> ls
Makefile condiments.h~ main.o side.c
README main.c meal side.o
condiments.h main.c~
> set fignore = (.o \~)
> emacs ma[^D]
main.c main.c~ main.o
> emacs ma[tab]
> emacs main.c

« main.c~ » et « main.o » sont ignorés lors du complètement (mais pas par le listage), car ils se terminent par un des suffixes de fignore. Notez qu'un « \ » est nécessaire devant « ~ » pour éviter qu'il ne soit développé en home comme décrit dans Substitution des noms de fichiers. fignore est ignoré si un seul complètement est possible.

Si la variable shell complete vaut « enhance », le complètement 1) ignore la casse et 2) considère les points, tirets et caractères de soulignement (« . », « - » et « _ ») comme étant des séparateurs de mots, et que les tirets et les caractères de soulignement sont équivalents. Si vous aviez les fichiers

comp.lang.c comp.lang.perl comp.std.c++
comp.lang.c++ comp.std.c

et que vous aviez tapé « mail -f c.l.c[tab] », cela serait complété en « mail -f comp.lang.c », et ^D listerait « comp.lang.c » et « comp.lang.c++ ». « mail -f c..c++[^D] » listerait « comp.lang.c++ » et « comp.std.c++ ». Taper « rm a--file[^D] » dans le répertoire suivant

A_silly_file a-hyphenated-file another_silly_file

listerait tous les trois fichiers, car la casse est ignorée et les tirets et caractères de soulignement sont équivalents. Les points ne sont néanmoins pas équivalents aux tirets et aux caractères de soulignement.

Le complètement et le listage sont affectés par beaucoup d'autres variables shell : recexact peut être définie pour ne compléter que vers la correspondance unique la plus courte possible, même si taper plus de caractères peut résulter en une correspondance plus longue :

> ls
fodder foo food foonly
> set recexact
> rm fo[tab]

émet juste un bip, car « fo » peut être développé en « fod » ou « foo », mais si nous tapons un autre « o »,

> rm foo[tab]
> rm foo,

le complètement se fait vers « foo », même si « food » et « foonly » correspondent également. autoexpand peut être définie pour lancer la commande d'éditeur expand-history avant chaque tentative de complètement, autocorrect peut être définie pour corriger l'orthographe du mot à compléter (voyez Correction orthographique) avant chaque tentative de complètement et correct peut être définie pour compléter les commandes automatiquement après que l'on ait tapé sur « entrée ». matchbeep peut être définie pour faire en sorte que le complètement bippe ou pas dans un certain nombre de situations, et nobeep peut être définie pour ne jamais bipper. nostat peut être définie pour fournir une liste de répertoires et/ou de motifs qui leur correspondent afin d'éviter que le mécanisme de complètement n'effectue un stat(2) sur ces répertoires. listmax et listmaxrows peuvent être définies pour limiter le nombres d'éléments et de lignes (respectivement) qui sont listés sans le demander au préalable. recognize_only_executables peut être définie pour que le shell ne liste que les exécutables lors d'un listage de commandes, mais c'est assez lent.

Finalement, la commande intégrée complete peut être utilisée pour indiquer au shell la façon de compléter les mots différents des noms de fichiers, de commandes ou de variables. Le complètement et le listage ne fonctionnent pas sur les motifs génériques (glob-pattern, voyez Substitution des noms de fichiers), mais les commandes d'éditeur list-glob et expand-glob accomplissent des fonctions équivalentes pour les motifs génériques.

Correction orthographique (+)¶

Le shell peut parfois corriger l'orthographe des noms de fichiers, de commandes et de variables en plus de les compléter et de les lister.

Les mots individuels peuvent être corrigés avec la commande d'éditeur spell-word (habituellement liée à M-s et M-S) et le tampon d'entrée entier avec spell-line (liée habituellement à M-$). La variable shell correct peut être fixée à « cmd » pour corriger le nom de commande, ou « all » pour corriger la ligne entière à chaque fois que la touche entrée est enfoncée, et autocorrect peut être fixée de sorte à corriger le mot à compléter avant chaque tentative de complètement.

Quand la correction orthographique est invoquée d'une de ces façons, et que le shell pense qu'une partie quelconque de la ligne de commandes est mal orthographiée, il affiche l'invite avec la ligne corrigée :

> set correct = cmd
> lz /usr/bin
CORRECT>ls /usr/bin (y|n|e|a)?

On peut répondre « y » ou espace pour exécuter la ligne corrigée, « e » pour laisser la commande non corrigée dans le tampon d'entrée, « a » pour annuler la commande comme si « ^C » avait été tapé, et n'importe quoi d'autre pour exécuter la ligne originale non modifiée.

La correction orthographique reconnaît les complètements définis par l'utilisateur (voyez la commande intégrée complete). Si un mot d'entrée situé à une position pour laquelle un complètement est défini ressemble à un mot de la liste des complètements, la correction orthographique enregistrera une faute de frappe et suggérera ce dernier mot pour effectuer la correction. Néanmoins, si le mot d'entrée ne correspond à aucun des complètements possibles pour cette position, la correction orthographique n'enregistrera pas de faute de frappe.

Comme pour le complètement, la correction orthographique fonctionne partout sur la ligne, et repousse le reste de la ligne sur la droite en laissant éventuellement des caractères excédentaires à la droite du curseur.

Attention : la correction orthographique peut ne pas fonctionner comme vous le souhaitez, et n'est principalement fournie qu'en tant que fonctionnalité expérimentale. Les suggestions et les améliorations sont les bienvenues.

Commandes de l'éditeur (+)¶

« bindkey » liste les liaisons de touches et « bindkey -l » liste et décrit brièvement les commandes d'édition. Seules les commandes nouvelles ou particulièrement intéressantes seront décrites ici. Voyez emacs(1) et vi(1) pour obtenir les descriptions des liaisons de touches de chacun de ces éditeurs.

Le(s) caractère(s) au(x)quel(s) chaque commande est liée par défaut est (sont) fourni(s) entre parenthèses. « ^caractère » signifie un caractère de contrôle et « M-caractère » un méta-caractère, tapé en faisant escape-caractère sur les terminaux ne possédant pas de touche méta. La casse compte, mais les commandes qui sont liées à des lettres par défaut sont liées à la fois à des lettres minuscules et majuscules par commodité.

complete-word (tab)

Compléter un mot comme cela est décrit dans Complètement et listage.

complete-word-back (non lié)

Comme complete-word-fwd, mais descend à partir de la fin de la liste.

complete-word-fwd (non lié)

Remplace le mot courant par le premier mot de la liste des complètements possibles. Peut être répété pour monter dans la liste. À la fin de la liste, bippe et revient au mot incomplet.

complete-word-raw (^X-tab)

Comme complete-word, mais ignore les complètements définis par l'utilisateur.

copy-prev-word (M-^_)

Copie le mot précédent de la ligne courante dans le tampon d'entrée. Voyez également insert-last-word.

dabbrev-expand (M-/)

Développe le mot courant vers le mot précédent le plus récent ayant le mot courant comme préfixe, en examinant toute la liste d'historique (une seule fois) si c'est nécessaire. La répétition de dabbrev-expand sans aucune frappe entre-temps passe au mot précédent suivant etc., en ignorant les correspondances identiques, un peu comme le fait history-search-backward.

delete-char (non lié)

Efface le caractère situé sous le curseur. Voyez également delete-char-or-list-or-eof.

delete-char-or-eof (non lié)

Effectue un delete-char s'il y a un caractère sous le curseur, ou end-of-file sur une ligne vide. Voyez également delete-char-or-list-or-eof.

delete-char-or-list (non lié)

Effectue un delete-char s'il y a un caractère sous le curseur, ou list-choices à la fin de la ligne. Voyez également delete-char-or-list-or-eof.

delete-char-or-list-or-eof (^D)

Effectue un delete-char s'il y a un caractère sous le curseur, list-choices à la fin de la ligne, ou end-of-file sur une ligne vide. Voyez également ces trois commandes, chacune d'entre elles n'effectuant qu'une seule action, et delete-char-or-eof, delete-char-or-list ainsi que list-or-eof, chacune d'entre elles effectuant une combinaison de deux des trois commandes précitées.

down-history (flèche-bas, ^N)

Comme up-history, mais descend, en s'arrêtant à la ligne d'entrée originale.

end-of-file (non lié)

Signale une fin de fichier, forçant le shell à se terminer à moins que la variable shell ignoreeof ne soit définie pour empêcher cela. Voyez également delete-char-or-list-or-eof.

expand-history (M-espace)

Développe les substitutions d'historique dans le mot courant. Voyez Substitution d'historique. Voyez également magic-space, toggle-literal-history et la variable shell autoexpand.

expand-glob (^X-*)

Développe le motif générique situé à la gauche du curseur. Voyez Substitution des noms de fichiers.

expand-line (non lié)

Comme expand-history, mais développe les substitutions d'historique dans chaque mot du tampon d'entrée.

expand-variables (^X-$)

Développe la variable située à gauche du curseur. Voyez Substitution de variables.

history-search-backward (M-p, M-P)

Effectue une recherche en arrière dans la liste d'historique pour trouver une commande débutant par le contenu courant du tampon d'entrée jusqu'au curseur et la copier dans le tampon d'entrée. La chaîne de caractères de recherche peut être un motif générique (voyez Substitution des noms de fichiers) contenant « * », « ? », « [] » or « {} ». up-history et down-history procéderont à partir de l'emplacement approprié dans la liste d'historique. Mode Emacs uniquement. Voyez également history-search-forward et i-search-back.

history-search-forward (M-n, M-N)

Comme history-search-backward, mais la recherche se fait en avant.

i-search-back (non lié)

Effectue une recherche en arrière comme history-search-backward, copie la première correspondance dans le tampon d'entrée avec le curseur positionné à la fin du motif, et affiche l'invite « bck: » et la première correspondance. Des caractères supplémentaires peuvent être tapés pour étendre la recherche, i-search-back peut être tapé pour continuer la recherche avec le même motif, cyclant dans la liste d'historique si nécessaire (i-search-back doit être lié à un unique caractère pour que cela fonctionne) ou bien l'un des caractères spéciaux suivants peut être tapé :

i-search-fwd (non lié)

Comme i-search-back, mais la recherche s'effectue en avant.

insert-last-word (M-_)

Insérer le dernier mot de la ligne d'entrée précédente (« !$ ») dans le tampon d'entrée. Voyez également copy-prev-word.

list-choices (M-^D)

Lister les possibilités de complètement comme décrit dans Complètement et listage. Voyez également delete-char-or-list-or-eof et list-choices-raw.

list-choices-raw (^X-^D)

Comme list-choices, mais ignore les complètements définis par l'utilisateur.

list-glob (^X-g, ^X-G)

Liste (via la commande intégrée ls-F) les correspondances du motif générique (voyez Substitution des noms de fichiers) situées à gauche du curseur.

list-or-eof (non lié)

Effectue un list-choices ou un end-of-file sur une ligne vide. Voyez également delete-char-or-list-or-eof.

magic-space (non lié)

Développe les substitutions d'historique sur la ligne courante, comme expand-history, et y concatène une espace. magic-space est conçu pour être lié à la barre d'espacement, mais il n'est pas lié par défaut.

normalize-command (^X-?)

Recherche le mot courant dans le PATH et, s'il est trouvé, le remplace par le chemin complet menant à l'exécutable. Les caractères spéciaux sont protégés. Les alias sont développés et protégés mais les commandes à l'intérieur des alias ne le sont pas. Cette commande est utile avec les commandes qui prennent des commandes en tant qu'arguments, comme p.ex. « dbx » et « sh -x ».

normalize-path (^X-n, ^X-N)

Développe le mot courant comme décrit dans le réglage « expand » de la variable shell symlinks.

overwrite-mode (non lié)

Passer du mode d'entrée au mode d'écrasement et inversement.

run-fg-editor (M-^Z)

Sauvegarde la ligne d'entrée courante et recherche un travail stoppé de nom identique au dernier composant de la partie nom de fichier des variables d'environnement EDITOR ou VISUAL ou, si aucune d'entre elles n'est définie, « ed » ou « vi ». Si un tel travail est trouvé, il est redémarré comme si « fg %job » avait été tapé. C'est utile pour passer facilement d'un éditeur au shell et inversement. Certaines personnes lient cette commande à « ^Z » afin de faire cela plus facilement.

run-help (M-h, M-H)

Recherche de la documentation sur la commande courante, en utilisant la même notion de « commande courante » que celle des routines de complètement, et l'affiche. Il n'est pas possible d'utiliser un paginateur ; run-help est conçu pour les fichiers d'aide courts. Si l'alias spécial helpcommand est défini, il est exécuté avec le nom de la commande pour unique argument. Sinon, la documentation doit se situer dans un fichier nommé commande.help, commande.1, commande.6, commande.8 ou commande, qui devrait se situer dans l'un des répertoires listés dans la variable d'environnement HPATH. S'il y a plus d'un fichier d'aide, seul le premier est affiché.

self-insert-command (caractères texte)

Dans le mode d'insertion (le mode par défaut), insère le caractère tapé dans la ligne d'entrée après le caractère situé sous le curseur. Dans le mode d'écrasement, remplace le caractère situé sous le curseur par le caractère tapé. Le mode d'entrée est normalement préservé entre les lignes, mais la variable shell inputmode peut être définie en « insert » (insertion) ou « overwrite » (écrasement) pour placer l'éditeur dans ce mode au début de chaque ligne. Voyez également overwrite-mode.

sequence-lead-in (préfixe flèche, préfixe méta, ^X)

Indique que les caractères suivants font partie d'une séquence de plusieurs touches. Lier une commande à une séquence de plusieurs touches crée en fait deux liaisons : le premier caractère à sequence-lead-in, et la séquence entière à la commande. Toutes les séquences débutant par un caractère lié à sequence-lead-in sont en fait liées à undefined-key à moins d'être liées à une autre commande.

spell-line (M-$)

Essaie de corriger l'orthographe de chaque mot du tampon d'entrée, comme spell-word, mais ignore les mots dont le premier caractère est « - », « ! », « ^ » ou encore « % », ou qui contient « \ », « * » ou « ? », pour éviter les problèmes avec les options, les substitutions et d'autres choses du même genre. Voyez Correction orthographique.

spell-word (M-s, M-S)

Essaie de corriger l'orthographe du mot courant comme décrit dans Correction orthographique. Vérifie tous les composants d'un mot qui semblent être des noms de chemins.

toggle-literal-history (M-r, M-R)

Développe ou « anti-développe » les substitutions d'historique dans le tampon d'entrée. Voyez également expand-history et la variable shell autoexpand.

undefined-key (n'importe quelle touche non liée)

Bippe.

up-history (flèche-haut, ^P)

Copie l'entrée précédente de la liste d'historique dans le tampon d'entrée. Si histlit est définie, utilise la forme littérale de l'entrée. Peut être répété pour parcourir la liste d'historique, en s'arrêtant au sommet.

vi-search-back (?)

Affiche l'invite « ? » et demande à l'utilisateur une chaîne de caractères de recherche (qui peut être un motif générique, comme pour history-search-backward), la recherche et la copie dans le tampon d'entrée. Le haut-parleur bippe si aucune correspondance n'est trouvée. L'appui sur Entrée termine la recherche et laisse la dernière correspondance dans le tampon d'entrée. L'appui sur Escape termine la recherche et exécute la correspondance. Mode vi uniquement.

vi-search-fwd (/)

Comme vi-search-back, mais recherche en avant.

which-command (M-?)

Effectue un which (voyez la description de la commande intégrée) sur le premier mot du tampon d'entrée.

Structure lexicale¶

Le shell découpe les lignes d'entrée en mots aux emplacements des blancs et des tabulations. Les caractères spéciaux « & », « | », « ; », « < », « > », « ( » et « ) » et les caractères dupliqués « && », « || », « << » et « >> » constituent toujours des mots séparés, qu'ils soient ou non entourés de caractères d'espacement.

Quand l'entrée du shell n'est pas un terminal, le caractère « # » est utilisé pour débuter un commentaire. Chaque « # » et le reste de la ligne d'entrée sur laquelle il apparaît est éliminé avant tout examen ultérieur.

On peut éviter la signification spéciale d'un caractère spécial (y compris un blanc ou une tabulation) pouvant faire partie d'un autre mot, en le faisant précéder par un backslash (« \ »), ou en l'enfermant dans des apostrophes (« ' »), des guillemets (« " ») ou des apostrophes inversées (« ` »). Quand il n'est pas protégé, un saut de ligne précédé par un « \ » est équivalent à un blanc mais, à l'intérieur de caractères de protection, cette séquence produit un saut de ligne.

De plus, toutes les Substitutions (voir en dessous) à l'exception de la Substitution d'historique peuvent être évitées en enfermant les chaînes de caractères (ou des parties de chaînes) dans lesquelles elles apparaissent à l'intérieur d'apostrophes ou en protégeant le(s) caractère(s) crucial(aux) (c.-à-d. « $ » ou « ` » pour la Substitution de variables ou la Substitution de commandes respectivement) avec « \ ». (La Substitution d'alias ne fait pas exception : protéger de quelque manière que ce soit un caractère quelconque d'un mot pour lequel un alias a été défini empêche la substitution de l'alias. La manière habituelle de protéger un alias est de le faire précéder par un backslash.) La Substitution d'historique est évitée par l'utilisation de backslashs, mais pas par celle de caractères de protection. Les chaînes de caractères protégées par des guillemets ou des apostrophes inversées (`) subissent la Substitution de variables et la Substitution de commandes, mais pas les autres substitutions.

Le texte présent entre apostrophes ou guillemets devient un mot unique (ou en fait partie). Les métacaractères présents dans ces chaînes, y compris les blancs et les tabulations, ne forment pas des mots séparés. Une chaîne de caractères protégée par des guillemets ne peut que dans un seul cas (voir Substitution de commandes ci-dessous) produire des parties de plus d'un mot ; les chaînes de caractères protégée par des apostrophes ne le font jamais. Les apostrophes inversées sont spéciales : elles signalent la Substitution de commandes, qui peut résulter en plus d'un mot.

La protection de chaînes de caractères complexes, en particulier celles qui contiennent elles-mêmes des caractères de protection, peut engendrer une certaine confusion. Souvenez-vous que les caractères de protection ne doivent pas être utilisés comme ils le sont dans l'écriture humaine ! Il peut être plus facile de ne pas protéger une chaîne de caractères entière, mais uniquement les parties de la chaîne qui en ont besoin, en utilisant différents types de protections si nécessaire.

La variable shell backslash_quote peut être utilisée pour que les backslashs protègent toujours « \ », « ' », et « " ». (+) Cela peut simplifier les tâches de protections complexes, mais peut engendrer des erreurs de syntaxe dans les scripts csh(1).

Substitutions¶

Nous décrivons maintenant les diverses transformations que le shell effectue sur l'entrée dans l'ordre dans lequel elles se produisent. Nous notons au passage les structures de données impliquées, et les commandes et variables qui les affectent. Souvenez-vous que les substitutions peuvent être évitées en protégeant comme décrit dans Structure lexicale.

Substitution d'historique¶

Chaque commande, ou « événement », entrée à partir du terminal, est sauvegardée dans la liste d'historique. La commande précédente est toujours sauvegardée, et la variable shell history peut être réglée pour indiquer le nombre de commandes à sauvegarder. La variable shell histdup peut être définie pour faire en sorte de ne pas sauvegarder d'événements dupliqués ou d'événements dupliqués consécutifs.

Les commandes sauvegardées sont numérotées séquentiellement à partir de 1 et sont estampillées avec l'heure courante. Il n'est habituellement pas nécessaire d'utiliser les numéros d'événements, mais le numéro d'événement courant peut faire partie de l'invite en plaçant un « ! » dans la variable shell prompt.

Le shell sauvegarde en fait l'historique dans les formes développées et littérales (non développées). Si la variable shell histlit est définie, les commandes qui affichent et stockent l'historique utilisent la forme littérale.

La commande intégrée history peut afficher, sauvegarder dans un fichier, restaurer et effacer la liste d'historique à n'importe quel moment, et les variables shell savehist et histfile peuvent être définies pour que la liste d'historique soit automatiquement sauvegardée à la déconnexion, et restaurée à la connexion.

Les substitutions d'historique introduisent des mots de la liste d'historique dans le flux d'entrée, facilitant ainsi la répétition de commandes, la répétition d'arguments d'une commande précédente dans la commande courante, ou encore la correction orthographique d'erreurs dans la commande précédente avec un nombre limité de frappes et un grand degré de sécurité.

Les substitutions d'historique commencent par le caractère « ! ». Elles peuvent commencer n'importe où dans le flux d'entrée, mais ne peuvent être imbriquées. Le « ! » peut être précédé d'un « \ » pour éviter sa signification spéciale ; par commodité, un « ! » est laissé inchangé quand il est suivi d'un blanc, d'une tabulation, d'un saut de ligne, d'un « = » ou d'un « ( ». Les substitutions d'historique se produisent également quand une ligne d'entrée débute par « ^ ». Cette abréviation spéciale sera décrite plus loin. Les caractères utilisés pour signaler la substitution d'historique (« ! » et « ^ ») peuvent être modifiés en définissant la variable shell histchars. Toute ligne d'entrée contenant une substitution d'historique est affichée avant d'être exécutée.

Une substitution d'historique peut comprendre une « spécification d'événement », qui indique l'événement à partir duquel les mots doivent être pris, un « désigneur de mot », qui sélectionne des mots particuliers de l'événement choisi, et/ou un « modificateur », qui manipule les mots sélectionnés.

Une spécification d'événement peut être

Par exemple, considérez ce morceau d'historique :

 9 8:30 nroff -man wumpus.man
10 8:31 cp wumpus.man wumpus.man.old
11 8:36 vi wumpus.man
12 8:37 diff wumpus.man.old wumpus.man

Les commandes sont affichées avec leurs numéro d'événement et horodate. L'événement courant, que nous n'avons pas encore tapé, est l'événement numéro 13. « !11 » et « !-2 » se réfèrent à l'événement 11. « !! » se réfère à l'événement précédent, c.-à-d. 12. « !! » peut être abrégé en « ! » s'il est suivi d'un « : » (« : » est décrit plus bas). « !n » se réfère à l'événement 9, qui commence par « n ». « !?old? » se réfère également à l'événement 12, qui contient « old ». Sans les désigneurs ou les modificateurs de mots, les références d'historique se développent simplement en l'événement entier, de sorte que l'on peut taper « !cp » pour ré-exécuter la commande de copie, ou « !!|more » si la sortie de « diff » déborde de l'écran.

Les références d'historique peuvent être isolées à partir du texte environnant par des accolades si nécessaire. Par exemple, « !vdoc » rechercherait une commande débutant par « vdoc » et, dans cet exemple, n'en trouverait pas, mais « !{v}doc » se développerait de façon non ambiguë en « vi wumpus.mandoc ». Les substitutions d'historique ne s'imbriquent pas, même à l'intérieur d'accolades.

(+) Alors que csh(1) développe, par exemple, « !3d » en l'événement 3 avec la lettre « d » ajoutée à la fin, tcsh le développe en le dernier événement débutant par « 3d » ; seuls les arguments entièrement numériques sont traités comme des numéros d'événements. Cela permet de rappeler des événements commençant par des nombres. Pour développer « !3d » comme dans csh(1), tapez « !\3d ».

Pour sélectionner des mots à partir d'un événement, nous pouvons faire suivre la spécification d'événement par un « : » et un désigneur pour les mots désirés. Les mots d'une ligne d'entrée sont numérotés à partir de 0, le premier mot (habituellement une commande) étant 0, le deuxième mot (le premier argument) étant 1, etc. Les désigneurs de mots de base sont :

Les mots sélectionnés sont insérés dans la ligne de commandes et sont séparés par des simples blancs. Par exemple, la commande « diff » de l'exemple précédent pourrait avoir été tapée comme ceci : « diff !!:1.old !!:1 » (en utilisant « :1 » pour sélectionner le premier argument de l'événement précédent), ou encore « diff !-2:2 !-2:1 » pour sélectionner et intervertir les arguments de la commande « cp ». Si nous ne nous préoccupons pas de l'ordre du « diff », nous pouvons faire « diff !-2:1-2 », ou simplement « diff !-2:* ». La commande « cp » pourrait avoir été tapée comme « cp wumpus.man !#:1.old », en utilisant « # » pour se référer à l'événement courant. « !n:- hurkle.man » réutiliserait les deux premiers mots de la commande « nroff » pour dire « nroff -man hurkle.man ».

Le « : » séparant la spécification d'événement du désigneur de mot peut être omis si le sélecteur d'événement commence par « ^ », « $ », « * », « % » ou « - ». Par exemple, notre commande « diff » aurait pu être « diff !!^.old !!^ » ou, de façon équivalente, « diff !!$.old !!$ ». Néanmoins, si « !! » est abrégé en « ! », un sélecteur d'argument débutant par « - » sera interprété comme une spécification d'événement.

Une référence d'historique peut posséder un désigneur de mot, mais pas de spécification d'événement. Elle référence ensuite la commande précédente. Pour continuer avec notre exemple « diff », nous pourrions pu faire simplement « diff !^.old !^ » ou « diff !* » pour avoir les arguments dans l'ordre inverse.

Le ou les mots d'une référence d'historique peuvent être édités, ou « modifiés », en les faisant suivre par un ou plusieurs modificateurs, chacun d'entre eux étant précédé par un « : »:

Les modificateurs ne sont appliqués qu'au premier mot modifiable (à moins que « g » ne soit utilisé). Le fait qu'aucun mot ne soit modifiable constitue une erreur.

Par exemple, la commande « diff » pourrait avoir été écrite comme « diff wumpus.man.old !#^:r », en utilisant « :r » pour supprimer « .old » du premier argument situé sur la même ligne (« !#^ »). Nous pourrions faire « echo hello out there », ensuite « echo !*:u » pour mettre « hello » en majuscule, « echo !*:au » pour le dire bruyamment, ou « echo !*:agu » pour réellement crier. Nous pourrions faire suivre « mail -s "J'ai oublié mon mot de passe" rot » par « !:s/rot/root » pour corriger l'orthographe de « root » (voyez Correction orthographique pour une approche différente).

Il y a une abréviation spéciale pour les substitutions. Quand « ^ » est le premier caractère d'une ligne d'entrée, il est équivalent à « !:s^ ». Donc, on aurait pu dire « ^rot^root » pour effectuer une correction orthographique sur l'exemple précédent. C'est la seule substitution d'historique qui ne commence pas explicitement par « ! ».

(+) Dans csh, un seul modificateur peut être appliqué à chaque développement d'historique ou de variable. Dans tcsh, on peut en utiliser plusieurs, comme par exemple

% mv wumpus.man /usr/man/man1/wumpus.1
% man !$:t:r
man wumpus

Dans csh, le résultat sera « wumpus.1:r ». Une substitution suivie d'un « : » pourrait devoir en être isolée avec des accolades :

> mv a.out /usr/games/wumpus
> setenv PATH !$:h:$PATH
Mauvais modificateur ! : $.
> setenv PATH !{-2$:h}:$PATH
setenv PATH /usr/games:/bin:/usr/bin:.

La première tentative fonctionnera avec csh mais échouera avec tcsh, car tcsh s'attend à un modificateur différent de « $ » après le deuxième « : ».

Finalement, l'historique peut être accédé via l'éditeur ainsi qu'avec les substitutions que l'on vient de décrire. Les commandes d'éditeur up- et down-history, history-search-backward et -forward, i-search-back et -fwd, vi-search-back et -fwd, copy-prev-word et insert-last-word recherchent des événements dans la liste d'historique et les copient dans le tampon d'entrée. La commande d'éditeur toggle-literal-history bascule entre les formes développées et littérales des lignes d'historique dans le tampon d'entrée. expand-history et expand-line développent les substitutions d'historique dans le mot courant et dans le tampon d'entrée entier respectivement.

Substitution d'alias¶

Le shell maintient une liste d'alias qui peuvent être définis, in-définis et affichés par les commandes alias et unalias. Après qu'une ligne de commandes ait été découpée en commandes uniques (voyez Commandes), le premier mot de chaque commande est examiné de gauche à droite pour voir s'il comprend un alias. Si c'est le cas, le premier mot est remplacé par l'alias. Si l'alias contient une référence d'historique, il subit la Substitution d'historique comme si la commande originale était la ligne d'entrée précédente. Si l'alias ne contient pas de référence d'historique, la liste des arguments n'est pas modifiée.

Par conséquent, si l'alias pour « ls » est « ls -l », la commande « ls /usr » devient « ls -l /usr », la liste des arguments n'étant pas modifiée. Si l'alias pour « lookup » est « grep !^ /etc/passwd », alors « lookup bill » devient « grep bill /etc/passwd ». Les alias peuvent être utilisés pour introduire une métasyntaxe d'analyseur syntaxique. Par exemple, « alias print 'pr \!* | lpr » définit une « commande » (« print ») qui envoie ses arguments à l'imprimante via pr(1).

La substitution d'alias est répétée jusqu'à ce que le premier mot de la commande ne possède plus d'alias. Si une substitution d'alias ne modifie pas le premier mot (comme dans l'exemple précédent), elle est marquée pour éviter un bouclage. Les autres boucles sont détectées et causent une erreur.

Certains alias sont référencés par le shell ; voyez Alias spéciaux.

Substitution de variables¶

Le shell maintient une liste de variables, chacune d'entre elles ayant pour valeur une liste de mots (éventuellement vide). La valeur des variables shell peut être affichée et modifiée en utilisant les commandes set et unset. Le système maintient sa propre liste de variables d'« environnement ». Celles-ci peuvent être affichées et modifiées en utilisant printenv, setenv et unsetenv.

(+) Les variables peuvent être rendues accessibles en lecture uniquement en utilisant « set -r ». Les variables accessibles en lecture seule ne peuvent être ni modifiées, ni in-définies ; si on essaie de le faire, cela causera une erreur. Une fois accessible en lecture seule, une variable ne peut plus être rendue accessible en écriture, et « set -r » ne devrait donc être utilisé qu'avec prudence. Les variables d'environnement ne peuvent pas être rendues accessibles en lecture seule.

Certaines variables sont définies par le shell ou sont référencées par lui. Par exemple, la variable argv est une image de la liste des arguments du shell, et les mots de cette valeur de variable sont référencés d'une façon spéciale. Certaines des variables référencées par le shell sont des interrupteurs ; le shell ne se soucie pas de leur valeur, mais uniquement du fait de savoir s'ils sont sélectionnés ou non. Par exemple, la variable verbose est un interrupteur qui renvoie les commandes d'entrée en écho. L'option de ligne de commandes -v définit cette variable. Variables shell spéciales liste toutes les variables qui sont référencées par le shell.

Les autres opérations traitent les variables de façon numérique. La commande « @ » permet d'effectuer des calculs numériques, et d'affecter leur résultat à une variable. Les valeurs de variables sont néanmoins toujours représentées par zéro ou plusieurs chaînes de caractères. Lors des opérations numériques, la chaîne de caractères vide est considérée valoir zéro, et les n-ièmes mots (n>=2) des valeurs à plusieurs mots sont ignorés.

Après que la ligne d'entrée ait subi la substitution des alias et ait été analysée, et avant que chaque commande ne soit exécutée, la substitution des variables est effectuée en entrant des caractères « $ ». Ce développement peut être évité en faisant précéder le « $ » par un « \ », sauf dans des « " » où elle se produit toujours, et dans des « ' » où elle ne se produit jamais. Les chaînes de caractères protégées par des « ` » sont interprétées ultérieurement (voyez Substitution de commandes plus bas) de sorte que la substitution de « $ » ne s'y produit pas encore, si jamais elle se produit. Un « $ » est passé sans être modifié s'il est suivi par un blanc, une tabulation, ou un fin-de-ligne (eol).

Les redirections d'entrée/sortie sont reconnues avant le développement des variables, et subissent le développement des variables séparément. Autrement, le nom de la commande et la liste d'arguments entière sont développés ensemble. Il est ainsi possible que le premier mot (la commande) (à cet instant) génère plus d'un mot, le premier d'entre eux devenant le nom de la commande, et les autres devenant des arguments.

À moins d'être encadré dans des « " », ou d'avoir fourni le modificateur « :q », les résultats d'une substitution de variables peuvent éventuellement subir la substitution de commandes et de noms de fichier. À l'intérieur de « " », une variable dont la valeur est constituée de plusieurs mots se développe en un (une partie d'un) mot unique, les mots faisant partie de la valeur de la variable étant séparés par des blancs. Quand le modificateur « :q » est appliqué à une substitution, la variable sera développée en plusieurs mots séparés par des blancs et protégés pour éviter des substitutions ultérieures de commandes ou de noms de fichiers.

Les méta-séquences suivantes sont fournies pour introduire des valeurs de variables dans l'entrée du shell. À moins que cela ne soit précisé, référencer une variable non définie constitue une erreur.

$nom

${nom}

Substitue les mots de la valeur de la variable nom, ceux-ci étant séparés par un blanc. Des accolades isolent nom des caractères suivants qui en feraient autrement partie. Le nom des variables shell peut contenir jusqu'à 20 lettres ou chiffres, et doit débuter par une lettre. Le caractère de soulignement (« _ ») est considéré être une lettre. Si nom n'est pas une variable shell, mais est défini dans l'environnement, alors cette valeur est renvoyée (mais les modificateurs « : » et les autres formes fournies en dessous ne sont pas disponibles dans ce cas).

$nom[sélecteur]

${nom[sélecteur]}

Ne substitue que les mots sélectionnés à partir de la valeur de nom. Le sélecteur subit la substitution du « $ » et peut être composé d'un ou de deux nombres séparés par un « - ». Le premier mot d'une valeur de variable est numéroté « 1 ». Si le premier nombre d'un intervalle est omis, sa valeur par défaut est « 1 ». Si le dernier membre d'un intervalle est omis, sa valeur par défaut est « $#nom ». Le sélecteur « * » sélectionne tous les mots. La vacuité d'un intervalle ne constitue pas une erreur si le second argument est omis ou fait partie de l'intervalle.

$0

Substitue le nom du fichier à partir duquel l'entrée de commande est lue. Une erreur se produit si le nom n'est pas connu.

$nombre

${nombre}

Équivalent à « $argv[nombre] ».

$*

Équivalent à « $argv », qui est équivalent à « $argv[*] ».

Les modificateurs « : » décrits dans Substitution d'historique, sauf « :p », peuvent être appliqués aux substitutions ci-dessus. Plusieurs d'entre eux peuvent être utilisés. (+) Des accolades peuvent être nécessaires pour isoler une substitution de variables à partir d'un deux-points littéral, comme dans la Substitution d'historique ; tout modificateur doit apparaître à l'intérieur des accolades)

Les substitutions suivantes ne peuvent être modifiées par les modificateurs « : » :

$?nom

${?nom}

Remplacé par la chaîne de caractère « 1 » si nom est défini, ou « 0 » sinon.

$?0

Remplacé par « 1 » si le nom du fichier d'entrée courant est connu, ou « 0 » sinon. Vaut toujours « 0 » dans les shells interactifs.

$#nom

${#nom}

Remplacé par le nombre de mots de nom.

$#

Équivalent à « $#argv ». (+)

$%nom

${%nom}

Remplacé par le nombre de caractères de nom. (+)

$%nombre

${%nombre}

Remplacé par le nombre de caractères de $argv[nombre]. (+)

$?

Équivalent à « $status ». (+)

$$

Remplacé par le numéro de processus (décimal) du shell (parent).

$!

Remplacé par le numéro (décimal) du processus du dernier processus tournant en tâche de fond lancé par ce shell. (+)

$_

Remplacé par la ligne de commandes de la dernière commande exécutée. (+)

$<

Remplacé par une ligne de l'entrée standard, sans interprétation ultérieure. Cela peut être utilisé pour lire à partir du clavier dans un script shell. (+) Alors que csh protège toujours $< comme s'il était équivalent à « $<:q », tcsh ne le fait pas. De plus, quand tcsh attend que l'utilisateur tape une ligne, celui-ci peut taper un caractère d'interruption pour interrompre la séquence dans laquelle la ligne doit être substituée, mais csh ne permet pas cela.

La commande d'éditeur expand-variables, normalement liée à « ^X-$ », peut être utilisée pour développer interactivement des variables individuelles.

Substitution de commandes, de noms de fichiers et de pile de répertoires¶

Les substitutions restantes sont appliquées sélectivement aux arguments des commandes intégrées. Cela signifie que les parties des expressions qui ne sont pas évaluées ne sont pas sujettes à ces développements. Pour les commandes qui ne font pas partie du shell, le nom de la commande est substitué séparément de la liste d'arguments. Cela se produit très tard, après que les redirections d'entrée-sortie aient été effectuées, et dans un fils du shell principal.

Substitution de commandes¶

La substitution de commandes est indiquée par une commande entourée de « ` ». La sortie d'une telle commande est découpée en mots séparés aux emplacements des blancs, tabulations et sauts de ligne, et les mots vides sont éliminés. La sortie subit la substitution des variables et des commandes et remplace la chaîne de caractères originale.

La substitution de commandes à l'intérieur de guillemets (« " ») retient les blancs et les tabulations ; seuls les sauts de lignes entraînent de nouveaux mots. Le saut de ligne final n'entraîne jamais de nouveau mot. Il est ainsi possible qu'une substitution de commande ne produise qu'une partie d'un mot, même si la commande produit une ligne complète en sortie.

Substitution des noms de fichiers¶

Si un mot contient l'un des caractères « * », « ? », « [ » ou « { », ou commence par le caractère « ~ », alors il est candidat à la substitution des noms de fichier, également connue sous le nom de de « développement » (globbing). Ce mot est ensuite considéré être un motif (dit « générique »), et est remplacé par une liste triée alphabétiquement de noms de fichiers correspondant au motif.

Dans les noms de fichiers correspondant, le caractère « . » présent au début d'un nom de fichier ou suivant immédiatement un « / » doit être reconnu explicitement. Le caractère « * » convient pour n'importe quelle chaîne de caractères, y compris la chaîne vide. Le caractère « ? » correspond à n'importe quel caractère. La séquence « [...] » reconnaît n'importe quel caractère enfermé dans les crochets. À l'intérieur de « [...] », une paire de caractères séparés par un « - » correspond à n'importe quel caractère présent lexicalement entre les deux.

(+) Certains motifs génériques peuvent être niés : la séquence « [^...] » correspond à n'importe quel caractère non spécifié par les caractères et/ou intervalles de caractères présents entre les crochets.

Un motif générique entier peut également être nié avec « ^ » :

> echo *
bang crash crunch ouch
> echo ^cr*
bang ouch

Les motifs génériques qui n'utilisent pas « ? », « * » ou « [] », ou qui utilisent « {} » ou « ~ » (voir ci-dessous) ne sont pas niés correctement.

La méta-notation « a{b,c,d}e » est un raccourci pour « abe ace ade ». L'ordre de gauche à droite est préservé : « /usr/source/s1/{oldls,ls}.c » se développe en « /usr/source/s1/oldls.c /usr/source/s1/ls.c ». Les résultats des correspondances sont triés séparément à un bas niveau pour préserver cet ordre : « ../{memo,*box} » pourrait se développer en « ../memo ../box ../mbox ». (Notez que « memo » n'a pas été trié avec les résultats des « *box » correspondant) Cette construction peut se développer en des fichiers qui n'existent pas, mais une erreur peut se produire au niveau d'une commande à laquelle on a passé la liste développée. Ces constructions peuvent être imbriquées. Exception : les mots « { », « } » et « {} » sont passés sans subir la moindre modification.

Le caractère « ~ » présent au début d'un nom de fichier référence les répertoires personnels. Présent seul, c.-à-d. « ~ », il est remplacé par le répertoire personnel de l'appelant comme reflété par la variable shell home. Quand il est suivi par un nom constitué de lettres, de chiffres, et de caractères « - », le shell recherche un utilisateur portant ce nom et substitue son répertoire personnel ; ainsi, « ~ken » pourrait être développé en « /usr/ken » et « ~ken/chmach » en « /usr/ken/chmach ». Si le caractère « ~ » est suivi par un caractère autre qu'une lettre ou « / », ou qu'il apparaît ailleurs qu'au début d'un mot, il n'est pas modifié. Une commande comme « setenv MANPATH /usr/man:/usr/local/man:~/lib/man » n'effectue donc pas la substitution de répertoires, comme on est en droit de l'espérer.

Un motif générique contenant « * », « ? », « [ » ou « ~ », avec ou sans « ^ », ne peut pas ne correspondre à aucun fichier. Néanmoins, un seul motif d'une liste de motifs génériques doit correspondre à un fichier (de sorte que, p.ex., « rm *.a *.c *.o » n'échouera que s'il n'y a aucun fichier dans le répertoire courant se terminant en « .a », « .c », ou « .o ») et, si la variable shell nonomatch est définie, un motif (ou une liste de motifs) qui ne reconnaît rien n'est pas modifié(e) plutôt que de causer une erreur.

La variable shell noglob peut être définie pour empêcher la substitution des noms de fichiers, et la commande d'éditeur expand-glob, liée normalement à « ^X-* », peut être utilisée pour développer interactivement des substitutions de noms de fichiers individuels.

Substitution de pile de répertoires (+)¶

La pile des répertoires est une liste de répertoires, numérotés à partir de zéro, qui est utilisée par les commandes intégrées pushd, popd et dirs. dirs peut afficher, sauvegarder dans un fichier, restaurer et effacer la pile de répertoires à tout moment, et les variables shell savedirs et dirsfile peuvent être définies pour sauvegarder automatiquement la pile de répertoires à la déconnexion et la restaurer à la connexion. La variable shell dirstack peut être examinée pour visualiser la pile de répertoires, et définie pour placer des répertoires arbitraires dans la pile de répertoires.

Le caractère « = » suivi d'un ou de plusieurs chiffres se développe en une entrée dans la pile de répertoires. Le cas spécial « =- » se développe vers le dernier répertoire de la pile. Par exemple,

> dirs -v
0 /usr/bin
1 /usr/spool/uucp
2 /usr/accts/sys
> echo =1
/usr/spool/uucp
> echo =0/calendar
/usr/bin/calendar
> echo =-
/usr/accts/sys

Les variables shell noglob et nonomatch et la commande d'éditeur expand-glob s'appliquent à la pile de répertoires autant qu'aux substitutions de noms de fichiers.

Autres substitutions (+)¶

Il existe beaucoup d'autres transformations impliquant des noms de fichiers, et qui ne sont pas strictement apparentées à celles présentées ci-dessus, mais qui sont mentionnées ici dans un but de complétude. Tout nom de fichier peut être développé en un chemin complet quand la variable symlinks vaut « expand ». La protection empêche cette expansion, et la commande d'éditeur normalize-path le fait à la demande. La commande d'éditeur normalize-command développe les commandes présentes dans le PATH en des chemins complets à la demande. Finalement, cd et pushd interprètent « - » comme l'ancien répertoire de travail (équivalent à la variable shell owd). Cela ne constitue pas du tout une substitution, mais une abréviation qui n'est reconnue que par ces commandes. Néanmoins, cela peut également être empêché en utilisant les protections.

Commandes¶

Les trois sections suivantes décrivent la façon dont le shell exécute des commandes et traite ses entrées et sorties.

Commandes simples, tubes et séquences¶

Une commande simple est une séquence de mots, le premier d'entre eux spécifiant la commande à exécuter. Une série de commandes simples reliées par des caractères « | » forme un tube. La sortie de chaque commande d'un tube est connectée à l'entrée de la commande suivante.

Les commandes simples et les tubes peuvent être réunis dans des séquences avec « ; », et seront exécutées séquentiellement. Les commandes simples et les tubes peuvent être également être réunis dans des séquences avec « || » ou « && », indiquant, comme dans le langage C, que la seconde commande ne doit être exécutée que si la première échoue ou réussit respectivement.

Une commande simple, un tube ou une séquence peut être placé(e) entre parenthèses, « () », pour former une commande simple, qui peut à son tour être un composant d'un tube ou d'une séquence. Une commande, un tube ou une séquence peut être exécuté(e) sans attendre qu'il (elle) se termine en le (la) faisant suivre par un « & ».

Exécution de commandes intégrées ou pas¶

Les commandes intégrées sont exécutées à l'intérieur même du shell. Si tous les composants d'un tube (sauf le dernier) sont des commandes intégrées, le tube sera exécuté dans un sous-shell.

Les commandes parenthésées sont toujours exécutées dans un sous-shell.

(cd; pwd); pwd

affiche par conséquent le répertoire home (répertoire personnel), en vous laissant là où vous étiez (en affichant ceci après le répertoire personnel), alors que

cd; pwd

vous laisse dans le répertoire home. Les commandes parenthésées sont le plus souvent utilisées pour éviter que cd n'affecte le shell courant.

Quand une commande à exécuter ne se trouve pas être une commande intégrée, le shell essaie d'exécuter la commande en utilisant execve(2). Chaque mot de la variable path nomme un répertoire dans lequel le shell recherchera la commande. S'il ne reçoit ni l'option -c, ni l'option -t, le shell hache les noms de ces répertoires dans une table interne de sorte qu'il n'essaiera un execve(2) dans un répertoire que s'il y a une possibilité que la commande y réside. Cela accélère considérablement la localisation des commandes quand un grand nombre de répertoires sont présents dans le chemin de recherche. Si ce mécanisme a été désactivé (via unhash), si on a fourni l'argument -c ou -t au shell, ou dans tous les cas pour chaque répertoire faisant partie de path qui ne commence pas par un « / », le shell concatène le répertoire de travail courant au nom de commande fourni pour former le nom de chemin d'un fichier qu'il essaie ensuite d'exécuter.

Si le fichier possède des permissions d'exécution mais n'est pas exécutable dans le système (p.ex. s'il n'est ni un binaire exécutable, ni un script qui spécifie son interpréteur), alors il est supposé être un fichier contenant des commandes shell et un nouveau shell est engendré pour le lire. L'alias spécial shell peut être défini pour spécifier un interpréteur différent du shell lui-même.

Sur les systèmes qui ne comprennent pas la convention d'interpréteur de script « #! », le shell peut être compilé pour l'émuler ; voyez la variable shell version. Si c'est le cas, le shell examine la première ligne du fichier pour voir si elle est de la forme « #!interpréteur arg ... ». Si c'est le cas, le shell lancera l'interpréteur avec les arguments fournis, et lui fournira le fichier sur la sortie standard.

Entrée/Sortie¶

L'entrée et la sortie standard d'une commande peuvent être redirigées en utilisant la syntaxe suivante :

< nom

Ouvrir le fichier nom (qui subit d'abord le développement des variables, des commandes et des noms de fichiers) pour l'utiliser comme entrée standard.

<< mot

Lire l'entrée shell jusqu'à une ligne identique à mot. mot ne subit pas les substitutions de variables, de commandes et de noms de fichiers, et chaque ligne d'entrée est comparée à mot avant qu'une quelconque substitution ne soit effectuée sur cette ligne d'entrée, à moins qu'un « \ », « " », « ' » ou « ` » de protection apparaisse dans la variable mot et que la substitution de commandes soit effectuée sur les lignes interposées, permettant à « \ » de protéger « $ », « \ » et « ` ». Les commandes qui sont substituées voient tous leurs blancs, tabulations et sauts de lignes préservés, à l'exception du saut de ligne final qui est perdu. Le texte résultant est placé dans un fichier temporaire anonyme qui est fourni à la commande en tant qu'entrée standard.

> nom
>! nom
>& nom

>&! nom

Le fichier nom est utilisé comme sortie standard. Si le fichier n'existe pas, il est créé. Si le fichier existe, il est tronqué, son contenu précédent étant perdu.

>> nom
>>& nom
>>! nom

>>&! nom

Comme « > », mais concatène la sortie à la fin de nom. Si la variable shell noclobber est définie, alors le fichier doit exister, à moins que l'une des formes « ! » ne soit fournie.

Une commande reçoit l'environnement dans lequel le shell a été invoqué, comme modifié par les paramètres d'entrée-sortie et par la présence de la commande dans un tube. Par conséquent, à la différence de certains shells antérieurs, les commandes lancées à partir d'un fichier de commandes shell n'ont pas accès par défaut au texte des commandes ; elles reçoivent plutôt l'entrée standard originelle du shell. Le mécanisme « << » devrait être utilisé pour présenter des données en ligne. Cela permet aux scripts de commandes shell de fonctionner comme des composants de tube, et au shell de lire son entrée par blocs. Notez que l'entrée standard par défaut d'une commande détachée n'est pas le fichier vide /dev/null, mais l'entrée standard originelle du shell. Si c'est un terminal et que le processus essaie de lire à partir du terminal, alors le processus bloquera et l'utilisateur sera averti (voir Travaux).

La sortie de diagnostic peut être dirigée dans un tube avec la sortie standard. Utilisez simplement la forme « |& » plutôt que seulement « | ».

Le shell ne peut actuellement rediriger la sortie de diagnostic sans rediriger également la sortie standard, mais « (commande > fichier-sortie) >& fichier-erreur » est souvent un détour acceptable. Soit fichier-sortie, soit fichier-erreur peut être « /dev/tty » pour envoyer la sortie sur le terminal.

Fonctionnalités¶

Ayant décrit la façon dont le shell accepte, analyse et exécute des lignes de commandes, nous allons maintenant traiter quelques unes de ses fonctionnalités utiles.

Flux de contrôle¶

Le shell contient quelques commandes qui peuvent être utilisées pour réguler le flux de contrôle dans les fichiers de commandes (scripts shell) et (dans des formes limitées mais néanmoins utiles) dans l'entrée provenant d'un terminal. Ces commandes opèrent toutes en forçant le shell à relire ou à passer son entrée et, à cause de l'implémentation, restreignent l'emplacement de certaines de ces commandes.

Les instructions foreach, switch et while, comme la forme if-then-else de l'instruction if, requièrent que les mots-clés principaux apparaissent dans une commande unique d'une ligne d'entrée comme montré plus bas.

Si on ne peut pas parcourir l'entrée du shell, le shell place l'entrée dans une mémoire tampon à chaque fois qu'il remarque une boucle, et effectue des recherches dans ce tampon interne pour effectuer la relecture impliquée par la boucle. (Dans la mesure du possible, les goto en arrière fonctionneront dans de telles entrées.)

Expressions¶

Les commandes intégrées if, while et exit utilisent des expressions possédant une syntaxe commune. Les expressions peuvent inclure n'importe lequel des opérateurs décrits dans les trois prochaines sections. Notez que la commande intégrée @ dispose de sa propre syntaxe.

Opérateurs logiques, arithmétiques et de comparaison¶

Ces opérateurs sont similaires à ceux du C et ont la même priorité. Ils incluent :

|| && | ^ & == != =~ !~ <= >=
< > << >> + - * / % ! ~ ( )

Ici, la priorité augmente en allant vers la droite, « == », « != », « =~ » et « !~ », « <= », « >= », « < » et « > », « << » et « >> », « + » et « - », « * », « / » et « % » ayant, dans leurs groupes respectifs, la même priorité. Les opérateurs « == », « != », « =~ » et « !~ » comparent leurs arguments comme des chaînes de caractères ; tous les autres travaillent sur des nombres. Les opérateurs « =~ » et « !~ » sont similaires à « != » et « == » mis à part que le membre de droite est un motif générique (voyez Substitution des noms de fichiers) auquel on essaie de faire correspondre l'opérande de gauche. Cela amoindrit le besoin de la commande intégrée switch dans des scripts shell où tout ce qui est réellement nécessaire est la reconnaissance de motifs.

Les chaînes de caractères commençant par « 0 » sont considérées être des nombres octaux. Les arguments vides ou manquants sont considérés valoir « 0 ». Les résultats de toutes les expressions sont des chaînes de caractères représentant des nombres décimaux. Il est important de noter que deux composants d'une expression ne peuvent apparaître dans le même mot ; à moins qu'ils ne soient adjacents à des composants d'expressions qui sont ont une signification syntaxique pour l'analyseur syntaxique (« & », « | », « < », « > », « ( » ou « ) »), ils devraient être entourés par des espaces.

Valeur de retour des commandes¶

Les commandes peuvent être exécutées dans des expressions, et leur valeur de retour peut être renvoyée en les entourant d'accolades (« {} »). Souvenez-vous que les accolades doivent être séparées des mots des commandes par des espaces. L'exécution d'une commande réussit en renvoyant la valeur vrai, c.-à-d. « 1 », si la commande se termine avec la valeur de retour 0 ; sinon, elle échoue en renvoyant la valeur faux, c.-à-d. « 0 ». Si des informations de statut plus détaillées sont requises, alors la commande devrait être exécutée à l'extérieur d'une expression et la variable shell status devrait être examinée.

Opérateurs de tests de fichiers¶

Certains de ces opérateurs effectuent des tests vrai/faux sur des fichiers et objets apparentés. Ils sont de la forme -op fichier, où op peut être :

fichier subit le développement des noms de commandes et de fichiers, et est ensuite testé pour voir s'il a la relation spécifiée avec l'utilisateur réel. Si fichier n'existe pas ou est inaccessible ou, pour les opérateurs indiqués par « * », si le type de fichier spécifié n'existe pas sur le système, alors toutes les requêtes renvoient faux, c.-à-d. « 0 ».

Ces opérateurs peuvent être combinés pour la concision : « -xyfichier » est équivalent à « -x fichier && -y fichier ». (+) Par exemple, « -fx » est vrai (renvoie « 1 ») pour les fichiers texte exécutables, mais pas pour les répertoires.

L peut être utilisé dans un test multi-opérateurs pour appliquer les opérateurs ultérieurs à un lien symbolique plutôt qu'au fichier vers lequel il pointe. Par exemple, « -lLo » est vrai pour les liens possédés par l'utilisateur appelant. Lr, Lw et Lx sont toujours vrais pour les liens et faux pour les non-liens. L a une signification différente quand il est le dernier opérateur d'un test multi-opérateurs ; voyez ci-dessous.

Il est possible mais pas utile, et cela induit parfois en erreur, de combiner des opérateurs qui s'attendent à ce que fichier soit un fichier avec des opérateurs qui ne s'y attendent pas, (p.ex. X et t). Faire suivre L par un opérateur non-fichier peut générer des résultats particulièrement étranges.

D'autres opérateurs revoient d'autres informations, c.-à-d. pas uniquement « 0 » ou « 1 ». (+) Ils ont le même format qu'auparavant ; op peut être :

Un seul de ces opérateurs peut apparaître dans un test multi-opérateurs, et doit être le dernier. Notez que L a une signification différente s'il est placé ou pas à la fin d'un test multi-opérateurs. Puisque « 0 » est une valeur de retour valide pour beaucoup de ces opérateurs, ils ne renvoient pas « 0 » quand ils échouent : la plupart renvoient « -1 », et F renvoie « : ».

Si le shell est compilé avec POSIX défini (voyez la variable shell version), le résultat d'un test de fichier est basé sur les bits de permission du fichier, et pas sur le résultat de l'appel système access(2). Par exemple, si l'on teste un fichier avec -w dont les permissions permettraient d'habitude l'écriture mais qui est situé dans un système de fichiers qui est monté en lecture seule, le test réussira dans un shell POSIX, mais échouera dans un shell non POSIX.

Les opérateurs de tests de fichiers peuvent également être évalués avec la commande intégrée filetest (+).

Travaux¶

Le shell associe un travail (job) à chaque tube. Il conserve une table des travaux courants, ceux qui sont affichés par la commande jobs, et leur affecte des numéros entiers courts. Quand un travail est démarré de façon asynchrone avec « & », le shell affiche une ligne qui ressemble à

[1] 1234

qui indique que le travail qui a été démarré de façon asynchrone était le travail numéro 1 qui est constitué d'un processus (de haut niveau), dont l'identifiant de processus est 1234.

Si un de vos travaux s'exécute et que vous souhaitez faire autre chose, vous pouvez taper la touche de suspension (en général « ^Z ») qui envoie un signal STOP au travail courant. Le shell indiquera alors normalement que le travail a été suspendu (« Suspended ») et affichera une autre invite. Si la variable shell listjobs est définie, tous les travaux seront listés à la manière de la commande intégrée jobs ; si elle vaut « long », le listage sera effectué dans un format long, comme avec « jobs -l ». Vous pouvez ensuite manipuler l'état du travail suspendu. Vous pouvez le placer en arrière-plan (« background ») avec la commande bg ou lancer d'autres commandes et replacer le travail en avant-plan (« foreground ») avec fg. (Voyez également la commande d'éditeur run-fg-editor.) Un « ^Z » prend effet immédiatement et est semblable à une interruption dans le sens où la sortie restante et l'entrée non lue sont éliminées quand ce caractère est tapé. La commande intégrée wait indique au shell d'attendre la fin de tous les travaux tournant en tâche de fond.

La touche « ^] » envoie un signal de suspension retardé au travail courant, et ne génère pas de signal STOP avant qu'un programme n'essaie de le lire (via read(2)). Cela peut être utilement tapé quand vous avez préparé quelques commandes pour un travail que vous voulez arrêter avant qu'il ne les ait lues. La touche « ^Y » effectue cette fonction dans csh(1) ; dans tcsh, « ^Y » est une commande d'édition. (+)

Un travail lancé en arrière-plan s'arrête s'il essaie de lire quelque chose à partir du terminal. Les travaux en arrière-plan peuvent normalement produire une sortie, mais cela peut être désactivé en fournissant la commande « stty tostop ». Si vous définissez cette option de terminal, alors les travaux en arrière-plan s'arrêteront s'ils essaient de produire une sortie comme ils le font lorsqu'ils essaient de lire une entrée.

Il y a plusieurs façons de référencer les travaux du shell. Le caractère « % » introduit un nom de travail. Si vous voulez désigner le travail numéro 1, vous pouvez utiliser « %1 ». Le simple fait de nommer un travail le ramène à l'avant-plan ; ainsi, « %1 » est un synonyme de « fg %1 », ramenant le travail 1 à l'avant-plan. D'une manière similaire, « %1 & » envoie le travail 1 à l'arrière-plan, tout comme « bg %1 ». Un travail peut également être nommé en utilisant un préfixe non ambigu de la chaîne de caractères tapée pour le démarrer : « %ex » redémarrerait normalement un travail ex(1) suspendu, s'il n'y avait qu'un seul travail suspendu dont le nom commence par la chaîne de caractères « ex ». Il est également possible de taper « %?chaîne-caractères » pour spécifier un travail dont le texte contient chaîne-caractères, s'il n'y a qu'un seul travail de ce type.

Le shell entretient une notion de travaux actuels et précédents. Dans une sortie rattachée à des travaux, le travail courant est marqué par un « + » et le travail précédent par un « - ». Les abréviations « %+ », « % » et (par analogie avec la syntaxe du mécanisme history) « %% » se réfèrent toutes au travail courant, alors que « %- » se réfère au travail précédent.

Le mécanisme de contrôle des travaux requiert que l'option « new » de stty(1) soit définie sur certains systèmes. C'est un artefact d'une « nouvelle » implémentation du pilote de tty qui permet la génération de caractères d'interruption à partir du clavier pour indiquer aux travaux de s'arrêter. Voyez stty(1) et la commande intégrée setty pour des détails sur l'utilisation des options du nouveau pilote tty.

Rapport de statut¶

Le shell apprend immédiatement le changement d'état d'un processus. Il vous informe normalement à chaque fois qu'un travail devient bloqué au point qu'aucune progression future n'est possible, mais juste avant il affiche une invite. Cela est effectué de sorte que cela ne perturbe en aucune façon votre travail. Si vous définissez néanmoins la variable shell notify, le shell vous informera immédiatement des changements d'état des travaux en tâche de fond. Il existe également une commande shell notify qui marque un processus pour que ses changements de statut soient immédiatement rapportés. Par défaut, notify marque le processus courant ; tapez simplement « notify » après le lancement d'un travail en tâche de fond pour le marquer.

Quand vous essayez de quitter le shell alors que des travaux sont stoppés, vous serez averti du fait que « You have stopped jobs. » (Il y a des travaux arrêtés). Vous pouvez utiliser la commande jobs pour les visualiser. Si vous faites cela ou que vous essayez immédiatement de sortir à nouveau, le shell ne vous avertira pas une seconde fois, et les travaux suspendus seront terminés.

Événements automatiques, périodiques et minutés (+)¶

Il y a différentes façons de lancer des commandes et d'entreprendre d'autres actions automatiquement à différents moments du « cycle de vie » du shell. Elles sont résumées ici, et sont décrites en détail dans les sections Commandes intégrées, Variables shell spéciales et Alias spéciaux appropriées.

La commande intégrée sched place les commandes dans une liste d'événements programmés, pour qu'elle soit exécutée par le shell à un moment donné.

Les Alias spéciaux beepcmd, cwdwmd, periodic, precmd, postcmd et jobcmd peuvent être définis, respectivement, pour exécuter des commandes lorsque le shell veut faire retentir la sonnette, quand le répertoire de travail change, toutes les tperiod minutes, avant chaque invite, avant que chaque commande soit exécutée, après chaque exécution de commande, et quand un travail est démarré ou est amené à l'avant-plan.

La variable shell autologout peut être définie pour déconnecter ou verrouiller le shell après un certain nombre de minutes d'inactivité.

La variable shell mail peut être définie pour vérifier périodiquement si l'on a reçu des courriels.

La variable shell printexitvalue peut être définie pour afficher la valeur de retour des commandes qui se terminent avec un statut différent de zéro.

La variable shell rmstar peut être définie pour demander à l'utilisateur s'il veut réellement exécuter « rm * ».

La variable shell time peut être définie pour exécuter la commande intégrée time après la terminaison de tous les processus prenant plus d'un nombre donné de secondes CPU.

Les variables shell watch et who peuvent être définies pour que l'on soit informé des connexions et déconnexions des utilisateurs sélectionnés, et la commande intégrée log le fait n'importe quand.

Support Système de la Langue Native (+)¶

(Native Language System Support, NLS)

Le shell supporte les caractères 8 bits (si cela est intégré lors de la compilation ; voyez la variable shell version), et supporte donc les jeux de caractères nécessitant cette capacité. La prise en charge du NLS diffère selon que le shell a été compilé pour utiliser le NLS du système ou pas (voyez à nouveau version). Dans tous les cas, l'ASCII 7 bits est la valeur de classification (par exemple l'identité des caractères imprimables) et de tri de caractères par défaut, et la modification des variables d'environnement LANG ou LC_CTYPE entraîne une vérification des changements possibles à cet égard.

Lors de l'utilisation du NLS du système, la fonction setlocale(3) est appelée pour déterminer la classification et le tri de caractères appropriés. Cette fonction examine typiquement les variables d'environnement LANG et LC_CTYPE ; référez-vous à la documentation système pour plus de détails. Quand il n'utilise pas le NLS du système, le shell le simule en supposant que le jeu de caractères ISO 8859-1 est utilisé à chaque fois que l'une des variables LANG et LC_CTYPE est définie, quelle que soit sa valeur. Le tri n'est pas affecté par le NLS simulé.

De plus, que ce soit pour le NLS réel ou pour le NLS simulé, tous les caractères imprimables situés dans l'intervalle \200-\377, c.-à-d. ceux qui possèdent des liaisons M-caractère, sont automatiquement re-liés à self-insert-command. La liaison correspondante de la séquence escape-caractère, s'il y en a une, est laissée seule. Ces caractères ne sont pas re-liés si la variable d'environnement NOREBIND est définie. Cela peut être utile pour le NLS simulé, ou pour un NLS natif réel qui suppose un jeu de caractères ISO 8859-1 complet. Sinon, toutes les liaisons M-car de l'intervalle \240-\377 sont effectivement annulées. Une reliaison explicite des touches pertinentes avec bindkey est bien entendu toujours possible.

Les caractères inconnus (c.-à-d. ceux qui ne sont ni imprimables, ni des caractères de contrôle) sont affichés dans le format \nnn. Si le tty n'est pas dans le mode 8 bits, les autres caractères 8 bits sont affichés en les convertissant en ASCII et en utilisant le mode saillant (standout). Le shell ne modifie jamais le mode 7/8 bits du tty, et traque les modifications de mode 7/8 bits initiés par l'utilisateur. Les utilisateurs du NLS (ou ceux qui veulent utiliser une touche méta à cet effet) peuvent devoir régler explicitement le tty dans le mode 8 bits en utilisant la commande stty(1) appropriée dans, p.ex., le fichier ~/.login.

Support des variantes de Systèmes d'Exploitation (+)¶

De nouvelles commandes intégrées sont fournies pour supporter les fonctionnalités de systèmes d'exploitation particuliers. Elles sont décrites en détail dans la section Commandes intégrées.

Sur les systèmes supportant le TCF (aix-ibm370, aix-ps2), getspath et setspath obtiennent et règlent le chemin d'exécution du système, getxvers et setxvers obtiennent et règlent le préfixe de version expérimentale et migrate migre des processus entre des sites. La commande intégrée jobs affiche le site sur lequel chaque travail est en cours d'exécution.

Sous Domain/OS, inlib ajoute les bibliothèques partagées à l'environnement courant, rootnode modifie le nœud racine et ver modifie le type de système.

Sous Mach, setpath est équivalent au setpath(1) de Mach.

Sous Masscomp/RTU et Harris CX/UX, universe définit l'univers.

Sous Harris CX/UX, ucb ou att exécute une commande dans l'univers spécifié.

Sous Convex/OS, warp affiche ou définit l'univers.

Les variables d'environnement VENDOR, OSTYPE et MACHTYPE indiquent respectivement le vendeur, le système d'exploitation et le type de machine (la classe du microprocesseur ou le modèle de machine) du système sur lequel le shell pense tourner. Elles sont particulièrement utiles lors du partage d'un répertoire personnel entre différents types de machines ; on peut faire, par exemple, un

set path = (~/bin.$MACHTYPE /usr/ucb /bin /usr/bin .)

dans son ~/.login et placer les exécutables compilés pour chaque machine dans le répertoire approprié.

La variable shell version indique quelles options ont été choisies quand le shell a été compilé.

Remarquez également la commande intégrée newgrp, les variables shell afsuser et echo_style, et les emplacements dépendants du système des fichiers d'entrée du shell (voyez FICHIERS).

Traitement des signaux¶

Les shells de connexion ignorent les interruptions lors de la lecture du fichier ~/.logout. Le shell ignore les signaux quit à moins qu'il n'ait été démarré avec l'option -q. Les shells de connexion captent le signal de terminaison, mais les autres shells héritent du comportement de terminaison de leurs parents. Les autres signaux ont les valeurs que le shell a héritées de son parent.

Dans les scripts shell, le traitement des signaux d'interruption et de terminaison par le shell peut être contrôlé par onintr, et son traitement des déconnexions peut être contrôlé avec hup et nohup.

Le shell se termine lors d'une déconnexion (voyez également la variable shell logout). Les enfants du shell le font également, mais le shell ne leur envoie pas de signal de déconnexion (hangup) quand il se termine. hup fait en sorte que le shell envoie un signal HANGUP à un enfant quand il se termine, et nohup indique à un enfant d'ignorer les signaux de déconnexion.

Gestion des terminaux (+)¶

Le shell utilise 3 ensembles différents de modes de terminaux (« tty ») : « edit », utilisé pour l'édition ; « quote », utilisé pour la protection de caractères littéraux, et « execute », utilisé lors de l'exécution de commandes. Le shell maintient certains réglages dans chaque constante de mode, de sorte que les commandes quittant le tty dans un état de confusion n'interfèrent pas avec le shell. Le shell détecte également les modifications dans la vitesse et le remplissage (padding) du tty. La liste des modes de tty qui sont maintenus constants peut être examinée et modifiée avec la commande setty. Notez que bien que l'éditeur utilise le mode CBREAK (ou son équivalent), il utilise de toute façon les caractères tapés à l'avance.

Les commandes echotc, settc et telltc peuvent être utilisées pour manipuler et déboguer les capacités du terminal à partir de la ligne de commandes.

Sur les systèmes supportant SIGWINCH ou SIGWINDOW, le shell s'adapte automatiquement au redimensionnement des fenêtres et ajuste les variables d'environnement LINES et COLUMNS en conséquence si elles sont définies. Si la variable d'environnement TERMCAP contient les champs li# et co#, le shell les ajuste pour refléter la nouvelle taille de fenêtre.

Commandes intégrées¶

%job

Un synonyme de la commande intégrée fg.

%job &

Un synonyme de la commande intégrée bg.

:

Ne fait rien, avec succès.

@
@ nom = expr
@ nom[indice] = expr
@ nom++|--

@ nom[indice]++|--

La première forme affiche la valeur de toutes les variables shell.

alias [nom [liste_mots]]

Sans arguments, affiche tous les alias. Avec nom, affiche l'alias de ce nom. Avec nom et liste_mots, affecte liste_mots comme alias pour nom. liste_mots subit la substitution des commandes et des noms de fichiers. nom ne peut pas être « alias » ou « unalias ». Voyez également la commande intégrée unalias.

alloc

Affiche la quantité de mémoire dynamique acquise, découpée entre mémoire utilisée et mémoire libre. Avec un argument, affiche le nombre de blocs libres et utilisés dans chaque catégorie de taille. Les catégories débutent à la taille 8 et doublent à chaque pas. La sortie de cette commande peut varier selon les types de systèmes, puisque les systèmes autres que VAX peuvent utiliser un allocateur de mémoire différent.

bg [%travail ...]

Place les travaux spécifiés (ou, sans argument, le travail courant) en tâche de fond (arrière-plan), continuant tous ceux d'entre eux qui sont arrêtés. travail peut être un nombre, une chaîne de caractères, la chaîne vide, « % », « + » ou « - » comme décrit dans Travaux.

bindkey [-l|-d|-e|-v|-u] (+)
bindkey [-a] [-b] [-k] [-r] [--] touche (+)

bindkey [-a] [-b] [-k] [-c|-s] [--] touche commande (+)

Sans option, la première forme liste toutes les touches liées et les commandes d'éditeur correspondantes, la deuxième forme liste la commande d'éditeur à laquelle touche est liée, et la troisième forme lie la commande d'éditeur commande à touche. Les options incluent :

break

Reprendre l'exécution après le end du foreach ou while englobant le plus proche. Les commandes restant sur la ligne courante sont exécutées. Des breaks sur plusieurs niveaux sont donc possibles en les écrivant tous sur une seule ligne.

breaksw

Provoque une cassure dans un switch, en reprenant après le endsw.

builtins (+)

Affiche le nom de toutes les commandes intégrées.

bye (+)

Un synonyme de la commande intégrée logout. Disponible uniquement si le shell a été compilé de cette façon ; voyez la variable shell version.

case étiquette:

Une étiquette dans une instruction switch (voir plus bas).

cd [-p] [-l] [-n|-v] [nom]

Si un répertoire nom est fourni, remplace le répertoire de travail courant du shell par nom. Sinon, le remplacer par home. Si nom est « - », il est interprété en tant que répertoire de travail précédent (voyez Autres substitutions). (+) Si nom n'est pas un sous-répertoire du répertoire courant (et ne commence pas par « / », « ./ » ou « ../ »), chaque composant de la variable cdpath est analysé pour voir s'il comporte un sous-répertoire nom. Finalement, si tout échoue mais que nom est une variable shell dont la valeur débute par « / », alors on essaie de voir si c'est un répertoire.

chdir

Un synonyme de la commande intégrée cd.

complete [commande [mot/motif/liste[:select]/[[suffixe]/] ...]] (+)

Sans argument, liste tous les complètements. Avec commande, liste les complètements pour commande. Avec commande et mot etc., définit les complètements.

continue

Passer à l'itération suivante du while ou foreach englobant le plus proche. Les commandes restant sur la ligne courante sont exécutées.

default:

Étiquette le cas par défaut dans une instruction switch. Devrait venir après toutes les étiquettes case.

dirs [-l] [-n|-v]
dirs -S|-L [nom_fichier] (+)

dirs -c (+)

La première forme affiche la pile de répertoires. Le sommet de la pile est à gauche et le premier répertoire sur la pile est le répertoire courant. Avec -l, un « ~ » ou un « ~nom » présent dans la sortie, est développé explicitement en home ou dans le nom du chemin du répertoire personnel de l'utilisateur nom. (+) Avec -n, les entrées sont enveloppées (wrapped) avant qu'elles atteignent le bord de l'écran. (+) Avec -v, les entrées sont affichées ligne par ligne, précédées par leur position dans la pile. (+) Si plus d'un -n ou -v est donné, -v a priorité. -p est accepté mais ne fait rien.

echo [-n] mot ...

Écrit tous les mots sur la sortie standard du shell, en les séparant par des espaces et en terminant par un saut de ligne. La variable shell echo_style peut être définie pour émuler (ou non) les drapeaux et les séquences d'échappement des versions BSD et/ou System V de echo ; voyez echo(1).

echotc [-sv] arg ... (+)

Exerce les capacités du terminal (voyez termcap(5)) dans args. Par exemple, « echotc home » envoie le curseur à la position home (NdT : origine), « echotc cm 3 10 » l'envoie à la colonne 3 et à la ligne 10, et « echotc ts 0 ; echo "Ceci est un test." ; echotc fs » affiche « Ceci est un test. » dans la ligne de statut.

else
end
endif

endsw

Voyez la description des instructions foreach, if, switch et while en dessous.

eval arg ...

Traite les arguments en tant qu'entrée pour le shell et exécute la ou les commandes résultantes dans le contexte du shell courant. Cela est habituellement utilisé pour exécuter des commandes générées comme résultat d'une substitution de commandes ou de variables, étant donné que l'analyse syntaxique se produit avant ces substitutions. Voyez tset(1) pour un exemple d'utilisation d'eval.

exec commande

Exécute la commande spécifiée au lieu du shell courant.

exit [expr]

Le shell se termine soit avec la valeur de l'expr spécifiée (une expression, comme cela est décrit dans Expressions) soit, sans expr, avec la valeur de la variable status.

fg [%travail ...]

Amène les travaux spécifiés (ou, sans argument, le travail courant) à l'avant-plan, continuant ceux qui étaient arrêtés. travail peut être un numéro, une chaîne de caractères, la chaîne vide, « % », « + » ou « - » comme cela est décrit dans Travaux. Voyez également la commande d'éditeur run-fg-editor.

filetest -op fichier ... (+)

Applique op (qui est un opérateur de test de fichier comme décrit dans Opérateurs de tests de fichiers) à chaque fichier, et renvoie les résultats dans une liste dont les éléments sont séparés par des espaces.

foreach nom (liste_mots)
...

end

Affecte successivement chaque membre de liste_mots à la variable nom, et exécute la séquence de commandes présente entre cette commande et le end correspondant. (foreach et end doivent tous deux apparaître seuls sur des lignes séparées.) La commande intégrée continue peut être utilisée pour passer à l'itération suivante de la boucle, et la commande intégrée break pour la terminer prématurément. Quand cette commande est lue à partir du terminal, la boucle est lue une seule fois, en affichant l'invite « foreach?  » (ou prompt2) avant que la moindre instruction de la boucle ne soit exécutée. Si vous avez commis une erreur de frappe dans une boucle sur le terminal, vous pouvez l'effacer.

getspath (+)

Affiche le chemin d'exécution du système. (TCF uniquement)

getxvers (+)

Affiche le préfixe de version expérimentale. (TCF uniquement)

glob liste_mots

Comme echo, mais aucun échappement « \ » n'est reconnu, et les mots sont délimités par des caractères nuls dans la sortie. Utile pour les programmes qui veulent utiliser le shell pour faire subir le développement des noms de fichiers à une liste de mots.

goto mot

mot subit la substitution des noms de fichiers et celle des commandes pour produire une chaîne de caractères de la forme « étiquette » (label). Le shell revient en arrière dans son entrée autant que faire se peut, recherche une ligne de la forme « étiquette: », éventuellement précédée de blancs et/ou de tabulations, et continue l'exécution après cette ligne.

hashstat

Affiche une ligne de statistiques indiquant une mesure de l'efficacité de la table de hachage interne à localiser les commandes (et à éviter des execs). Un exec est tenté pour chaque composant de path où la fonction de hachage indique un succès possible, et dans chaque composant qui ne commence pas par un « / ».

Sur les machines sans vfork(2), n'affiche que le numéro et la taille des seaux de hachage.

history [-hTr] [n]
history -S|-L|-M [nom_fichier] (+)

history -c (+)

La première forme affiche la liste d'événements d'historique. Si n est fourni, seuls les n événements les plus récents seront affichés ou sauvegardés. Avec -h, la liste d'historique est affichée sans les nombres de tête. Si -T est spécifié, les horodates sont également affichées sous forme de commentaires. (Cela peut être utilisé pour produire des fichiers convenant au chargement avec « history -L » ou « source -h ».) Avec -r, l'ordre d'affichage va du plus récent au plus ancien.

hup [commande] (+)

Avec commande, lance commande de sorte qu'elle se termine à la réception d'un signal de déconnexion (HANGUP), et s'arrange pour que le shell envoie un signal HANGUP à la commande quand il se termine. Notez que les commandes peuvent définir leur propre réponse aux déconnexions, en surchargeant hup. Sans argument (permis uniquement dans un script shell), pousse le shell à se terminer en cas de réception d'un signal HANGUP dans le reste du script. Voyez également Traitement des signaux et la commande intégrée nohup.

if (expr) commande

Si expr (une expression, comme décrit dans Expressions) s'évalue à vrai, alors commande est exécutée. La substitution de variables sur commande se produit tôt, au même moment que pour le reste de la commande if. commande doit être une commande simple, et pas un alias, un tube, une liste de commandes ou une liste de commandes parenthésée, mais elle peut avoir des arguments. La redirection d'entrée/sortie se produit même si expr est fausse et que commande n'est donc pas exécutée ; c'est un bogue.

if (expr) then
...
else if (expr2) then
...
else
...

endif

Si l'expr spécifiée est vraie, alors les commandes du premier else sont exécutées ; sinon, si expr2 est vraie, alors les commandes du deuxième else sont exécutées, etc. Le nombre de paires else-if n'est pas limité ; un seul endif est nécessaire. La partie else est également optionnelle. (Les mots else et endif doivent apparaître au début des lignes d'entrée ; le if doit apparaître seul sur sa ligne d'entrée ou après un else.)

inlib bibliothèque-partagée ... (+)

Ajoute chaque bibliothèque-partagée à l'environnement courant. Il n'y a aucun moyen de supprimer une bibliothèque partagée. (Domain/OS uniquement)

jobs [-l]

Liste les travaux actifs. Avec -l, liste les identifiants de processus (PIDs) en plus des informations normales. Sur les systèmes TCF, affiche le site sur lequel chaque travail est en cours d'exécution.

kill [-s signal] %travail|pid ...

kill -l

La première et la deuxième formes envoient le signal spécifié (ou, si aucun n'a été fourni, le signal TERM (terminaison)) aux travaux ou processus spécifiés. travail peut être un numéro, une chaîne de caractères, la chaîne vide, « % », « + » ou « - » comme décrit dans Travaux. Les signaux sont fournis soit par leur numéro, soit par leur nom (ceux trouvés dans /usr/include/signal.h, desquels on retire le préfixe « SIG »). Il n'y a pas de travail par défaut ; juste taper « kill » n'envoie pas de signal au travail courant. Si le signal envoyé est TERM (terminaison) ou HUP (déconnection), alors le travail ou processus se voit également envoyer un signal CONT (continuer). La seconde forme liste le nom des signaux.

limit [-h] [ressource [utilisation-maximale]]

Limite la consommation de la ressource spécifiée à utilisation-maximale pour le processus courant et chacun des processus qu'il a créés. Si aucune utilisation-maximale n'est donnée, alors la limite courante est affichée ; si aucune ressource n'est fournie, alors toutes les limitations actuelles sont affichées. Si le drapeau -h est donné, des limites impératives sont utilisées au lieu des limites actuelles. Les limites impératives imposent un plafond aux valeurs des limites actuelles. Seul le super-utilisateur peut relever les limites impératives, mais un utilisateur peut baisser ou augmenter les limites actuelles à l'intérieur de l'intervalle légal.

log (+)

Affiche la valeur de la variable shell watch et rapporte des informations sur tous les utilisateurs indiqués par watch qui sont actuellement connectés, quel que soit le moment de leur dernière connection. Voyez également watchlog.

login

Termine un shell de connexion, en le remplaçant par une instance de /bin/login. C'est une façon de se déconnecter qui est incluse pour assurer la compatibilité avec sh(1).

logout

Termine un shell de connexion. Particulièrement utile si ignoreeof est définie.

ls-F [-option ...] [fichier ...] (+)

Liste les fichiers comme « ls -F », mais beaucoup plus rapidement. Identifie chaque type de fichier spécial de la liste par un caractère spécial :

migrate [-site] pid|%id_trav ... (+)

migrate -site (+)

La première forme migre le processus ou travail sur le site spécifié ou sur le site par défaut déterminé par le chemin du système. La seconde forme équivaut à « migrate -site $$ » : elle migre le processus courant sur le site spécifié. La migration du shell lui-même peut causer un comportement inattendu, puisque le shell n'aime pas perdre son tty (terminal). (TCF uniquement)

newgrp [-] groupe (+)

Équivalent à « exec newgrp » ; voyez newgrp(1). Disponible uniquement si le shell a été compilé de cette façon ; voyez la variable shell version.

nice [+nombre] [commande]

Fixe la priorité d'ordonnancement du shell à nombre ou, sans nombre, à 4. Avec commande, lance commande avec la priorité appropriée. Au plus le nombre est grand, au moins le processus reçoit de temps cpu. Le super-utilisateur peut spécifier des priorités négatives en utilisant « nice -nombre ... ». La commande est toujours exécutée dans un sous-shell, et les restrictions placées sur les commandes dans les simples instructions if s'appliquent ici.

nohup [commande]

Avec commande, lance commande de sorte qu'elle ignorera les signaux de déconnexion. Notez que les commandes peuvent définir leur propre réponse aux déconnexions, en surchargeant nohup. Sans argument (permis uniquement dans un script shell), indique au shell d'ignorer les signaux HANGUP pour le restant du script. Voyez également Traitement des signaux et la commande intégrée hup.

notify [%travail ...]

Indique au shell d'avertir l'utilisateur de façon asynchrone quand le statut de l'un des travaux spécifiés (ou, sans %travail, de celui du travail courant) change, au lieu d'attendre jusqu'à l'invite suivante comme c'est le cas habituellement. travail peut être un numéro, une chaîne de caractères, la chaîne vide, « + » ou « - » comme décrit dans Travaux. Voyez également la variable shell notify.

onintr [-|étiquette]

Contrôle l'action du shell lors des interruptions. Sans argument, restaure l'action par défaut du shell lors des interruptions, c.-à-d. de terminer les scripts shell ou de retourner au niveau de l'entrée de commande du terminal. Avec « - », ignore toutes les interruptions. Avec étiquette, indique au shell d'exécuter un « goto étiquette » quand une interruption est reçue, ou qu'un processus fils se termine parce qu'il a été interrompu.

onintr est ignoré si le shell a été lancé détaché ou depuis un des fichiers de démarrage du système (voyez FICHIERS), où les interruptions sont désactivées de toute façon.

popd [-p] [-l] [-n|-v] [+n]

Sans argument, dépile la pile de répertoires et revient au nouveau répertoire du sommet. Avec un nombre, « +n », élimine la n-ième entrée de la pile.

Finalement, toutes les formes de popd affichent la pile de répertoires finale, tout comme dirs. La variable shell pushdsilent peut être définie pour éviter cela, et le drapeau -p peut être donné pour surcharger pushdsilent. Les drapeaux -l, -n et -v ont le même effet sur popd que sur dirs. (+)

printenv [nom] (+)

Affiche le nom et la valeur de toutes les variables d'environnement ou, avec nom, la valeur de la variable d'environnement nom.

pushd [-p] [-l] [-n|-v] [nom|+n]

Sans argument, intervertit les deux éléments situés au sommet de la pile de répertoires. Si pushdtohome est définie, pushd sans argument effectue « pushd ~ », comme cd. (+) Avec nom, empile le répertoire de travail courant sur la pile de répertoires et va en nom. Si nom est « - », il est interprété comme étant le répertoire de travail courant précédent (voyez Substitution des noms de fichiers). (+) Si dunique est définie, pushd supprime toutes les instances de nom de la pile avant de l'empiler. (+) Avec un nombre « +n », pivote le n-ième élément de la pile de répertoires pour qu'il soit l'élément du sommet, et y aller. Néanmoins, si dextract est définie, « pushd +n » extraira le n-ième répertoire, l'empilera sur le sommet de la pile et s'y rendra. (+)

Finalement, toutes les formes de pushd affichent la pile de répertoires finale, tout comme dirs. La variable shell pushdsilent peut être définie pour empêcher cela et le drapeau -p peut être fourni pour surcharger pushdsilent. Les drapeaux -l, -n et -v ont le même effet sur pushd que sur dirs. (+)

rehash

Force la régénération de la table de hachage interne du contenu des répertoires. Ceci est nécessaire si de nouvelles commandes sont ajoutées aux répertoires de path pendant que vous êtes connecté. Cela ne devrait être nécessaire que si vous ajoutez des commandes à l'un de vos propres répertoires, ou si un programmeur système modifie le contenu de l'un des répertoires du système. Vide également le cache des répertoires personnels construit par le développement du tilde.

repeat nombre commande

La commande spécifiée, qui est soumise aux mêmes restrictions que la commande dans l'instruction if à une ligne au-dessus, est exécutée nombre fois. Les redirections d'E/S se produisent exactement une fois, même si nombre vaut 0.

rootnode //nœud-racine (+)

Fixe le nœud racine à //nœud-racine de sorte que « / » sera interprété comme « //nœud-racine ». (Domain/OS uniquement)

sched (+)
sched [+]hh:mm commande (+)

sched -n (+)

La première forme affiche la liste d'événements programmés. La variable shell sched peut être définie pour fournir le format dans lequel la liste d'événements programmés est affichée. La deuxième forme ajoute commande à la liste d'événements programmés. Par exemple,

set
set nom ...
set nom=mot ...
set [-r] [-f|-l] nom=(liste-mots) ... (+)
set nom[indice]=mot ...
set -r (+)
set -r nom ... (+)

set -r nom=mot ... (+)

La première forme de la commande affiche la valeur de toutes les variables shell. Les variables contenant plus d'un mot sont affichées en tant que liste de mots parenthésée. La deuxième forme affecte la chaîne de caractères vide à nom. La troisième forme affecte le mot à nom. La quatrième forme affecte la liste de mots de liste-mots à nom. Dans tous les cas, la valeur subit le développement des commandes et des noms de fichiers. Si -r est spécifié, la valeur est en lecture seule. Si -f ou -l sont spécifiés, ne définit que des mots uniques conservant leur ordre. -f préfère la première occurrence d'un mot, et -l la dernière. La cinquième forme affecte le indice-ième composant de nom à mot ; ce composant doit déjà exister. La sixième forme liste les noms (uniquement) de toutes les variables shell qui sont accessibles en lecture seule. La septième forme rend nom accessible en lecture seule, qu'il ait ou non une valeur. La huitième forme est identique à la troisième forme, mais rend nom accessible en lecture seule en même temps.

Ces arguments peuvent être répétés pour définir et/ou placer en lecture seule plusieurs variables dans une unique commande set. Notez néanmoins que le développement des variables se produit pour tous les arguments avant que le moindre réglage ne se produise. Remarquez également que « = » peut être adjacent à la fois à nom et à mot, ou bien être séparé des deux par des caractères d'espacement, mais ne peut être adjacent qu'à un seul des deux. Voyez également la commande intégrée unset.

setenv [nom [valeur]]

Sans argument, affiche le nom et la valeur de toutes les variables d'environnement. Étant donné nom, donner cette valeur à la variable d'environnement nom, ou la chaîne vide si aucune valeur n'est mentionnée.

setpath chemin (+)

Équivalent à setpath(1). (Mach uniquement)

setspath LOCAL|site|cpu ... (+)

Fixe le chemin d'exécution du système. (TCF uniquement)

settc cap valeur (+)

Dire au shell de croire que la capacité de terminal cap (comme définie dans termcap(5)) possède la valeur valeur. Aucun contrôle n'est effectué. Les utilisateurs de terminaux Concept pourraient devoir effectuer un « settc xn no » pour obtenir une disposition (NdT : wrapping) adéquate de la colonne la plus à droite.

setty [-d|-q|-x] [-a] [[+|-]mode] (+)

Contrôle quels modes de tty (voyez Gestion des terminaux) le shell ne permet pas de modifier. -d, -q ou -x indiquent à setty d'agir sur les ensembles de modes tty « edit », « quote » ou « execute » respectivement ; sans -d, -q ou -x, « execute » est utilisé.

Sans autre argument, setty liste les modes de l'ensemble choisi qui sont utilisés (« +mode ») ou pas (« -mode »). Les modes disponibles, et donc l'affichage, varient d'un système à l'autre. Avec -a, liste tous les modes tty de l'ensemble choisi qu'ils soient utilisés ou non. Avec +mode, -mode ou mode, utilise mode ou pas ou supprime le contrôle de mode dans l'ensemble choisi. Par exemple, « setty +echok echoe » active le mode « echok » et permet aux commandes d'activer ou de désactiver le mode « echoe » quand le shell exécute des commandes.

setxvers [chaîne_caractères] (+)

Fixe le préfixe de version expérimentale à chaîne_caractères, ou le supprime si la chaîne_caractères est omise. (TCF uniquement)

shift [variable]

Sans argument, élimine argv[1] et décale les membres de argv vers la gauche. C'est une erreur pour argv de ne pas être définie ou d'avoir moins d'un mot pour valeur. Avec variable, effectue la même chose sur variable.

source [-h] nom [arguments ...]

Le shell lit et exécute les commandes provenant de nom. Les commandes ne sont pas placées dans la liste d'historique. Si des arguments sont fournis, ils sont placés dans argv. (+) Les commandes source peuvent être imbriquées ; si elles sont imbriquées trop profondément, le shell peut tomber à court de descripteurs de fichiers. Une erreur dans un source à n'importe quel niveau termine toutes les commandes source imbriquées. Avec -h, les commandes sont placées dans la liste d'historique au lieu d'être exécutées, un peu comme avec « history -L ».

stop %travail|pid ...

Stoppe les travaux ou processus spécifiés qui sont en cours d'exécution en arrière-plan. travail peut être un nombre, une chaîne de caractères, la chaîne vide, « + » ou « - » comme décrit dans Travaux. Il n'y a aucun travail par défaut ; le simple fait de taper « stop » ne stoppe pas le travail courant.

suspend

Suspend le shell, comme s'il avait reçu un signal d'arrêt avec ^Z. C'est utilisé la plupart du temps pour stopper les shells démarrés avec su(1).

switch (chaîne_caractères)
case str1:

...
breaksw

...

default:

...
breaksw

endsw

Chaque étiquette case est successivement comparée à la chaîne_caractères spécifiée, qui subit d'abord le développement des commandes et des noms de fichiers. Les métacaractères de fichiers « * », « ? » et « [...] » peuvent être utilisés dans les étiquettes case, qui subissent le développement des variables. Si aucune des étiquettes ne convient avant qu'une étiquette « default » soit trouvée, alors l'exécution commence après l'étiquette default. Chaque étiquette case et l'étiquette default doivent apparaître au début d'une ligne. La commande breaksw provoque la reprise de l'exécution après le endsw. Sinon, le contrôle passe au travers des étiquettes case et de l'étiquette default, comme en C. Si aucune étiquette ne convient et qu'il n'y a pas d'étiquette default, l'exécution continue après le endsw.

telltc (+)

Liste les valeurs de toutes les capacités de terminaux (voyez termcap(5)).

time [commande]

Exécute commande (qui doit être une commande simple, c.-à-d. pas un alias, un tube, une liste de commandes ou une liste de commandes parenthésée) et affiche un résumé temporel comme décrit dans la variable time. Si nécessaire, un shell supplémentaire est créé pour afficher les statistiques de temps quand la commande se termine. Sans commande, affiche un résumé temporel pour le shell courant et ses enfants.

umask [valeur]

Fixe le masque de création de fichier à valeur, qui est fourni en octal. Les valeurs habituelles pour le masque sont 002, donnant tous les droits d'accès au groupe et les droits de lecture et d'exécution pour les autres utilisateurs, et 022, donnant l'accès en lecture et en exécution au groupe et aux autres utilisateurs. Sans valeur, affiche le masque actuel de création de fichier.

unalias motif

Supprime tous les alias dont le nom correspond au motif. « unalias * » supprime donc tous les alias. Il n'est pas erroné de ne rien unaliaser.

uncomplete motif (+)

Supprime toutes les complètements dont le nom correspond à motif. « uncomplete * » supprime donc tous les complètements. Il n'est pas erroné de ne rien uncompleter.

unhash

Désactiver l'utilisation de la table de hachage interne servant à accélérer la localisation des programmes à exécuter.

universe univers (+)

Fixer l'univers à univers. (Masscomp/RTU uniquement)

unlimit [-h] [ressource]

Supprime la limitation sur la ressource ou, si aucune ressource n'est spécifiée, sur toutes les limitations de ressources. Avec -h, les limites impératives correspondantes sont supprimées. Seul le super-utilisateur peut faire cela.

unset motif

Supprime toutes les variables dont le nom correspond à motif, sauf si elles sont accessibles en lecture seule. « unset * » supprime donc toutes les variables à moins qu'elles ne soient accessibles en lecture seule ; c'est une mauvaise idée. Il n'est pas erroné de ne rien unseter.

unsetenv motif

Supprime toutes les variables d'environnement dont le nom correspond à motif. « unsetenv * » supprime donc toutes les variables d'environnement ; c'est une mauvaise idée. Il n'est pas erroné de ne rien unsetenver.

ver [type-système [commande]] (+)

Sans argument, affiche la valeur de SYSTYPE. Avec type-système, fixe SYSTYPE à type-système. Avec type-système et commande, exécute commande sous type-système. type-système peut être « bsd4.3 » ou « sys5.3 ». (Domain/OS uniquement)

wait

Le shell attend la terminaison de tous les travaux tournant en arrière-plan. Si le shell est interactif, une interruption suspendra l'attente et forcera le shell à afficher les nom et numéro de travail de tous les travaux en suspens.

warp univers (+)

Fixer l'univers à univers. (Convex/OS uniquement)

watchlog (+)

Un nom alternatif pour la commande intégrée log. Disponible uniquement si le shell a été compilé de cette façon ; voyez la variable shell version.

where commande (+)

Rapporte toutes les instances connues de commande, incluant les alias, les commandes intégrées et les exécutables situés dans le path.

which commande (+)

Affiche la commande qui sera exécutée par le shell après les substitutions, la recherche dans le path, etc. La commande intégrée est identique à which(1), mais elle rapporte correctement les alias tcsh et les commandes intégrées, et est de 10 à 100 fois plus rapide. Voyez également la commande d'éditeur which-command.

while (expr)
...

end

Exécute les commandes situées entre le while et le end correspondant. while expr (une expression, comme décrit dans Expressions) est évaluée à une valeur non nulle. while et end doivent apparaître seuls sur leur ligne d'entrée. break et continue peuvent être utilisés pour terminer l'itération courante ou passer à l'itération suivante respectivement. Si l'entrée est un terminal, l'utilisateur verra une invite la première fois qu'il rentre dans la boucle comme pour foreach.

Alias spéciaux (+)¶

S'ils sont définis, chacun de ces alias s'exécute automatiquement au moment indiqué. Initialement, ils sont ne sont pas définis.

beepcmd

S'exécute quand le shell essaie de faire retentir la sonnette du terminal.

cwdcmd

S'exécute après chaque changement de répertoire de travail. Par exemple, si l'utilisateur travaille dans un système X Window utilisant xterm(1) et un gestionnaire de fenêtres qui supporte les barres de titre comme twm(1), et tape

jobcmd

S'exécute après l'exécution de chaque commande, ou quand la commande change d'état. C'est similaire à postcmd, mais cela n'affiche pas les commandes intégrées. Avec

helpcommand

Invoqué par la commande d'éditeur run-help. Le nom de la commande pour laquelle on recherche de l'aide est passé comme seul argument. Par exemple, si l'on fait

periodic

S'exécuter toutes les tperiod minutes. Cela fournit un moyen pratique pour vérifier l'apparition de changements communs mais non fréquents comme un nouvel email. Par exemple, si l'on fait

precmd

S'exécute juste avant l'affichage de l'invite. Par exemple, si l'on fait

postcmd

S'exécute avant que chaque commande ne soit exécutée.

shell

Spécifie l'interpréteur pour les scripts qui ne spécifient pas eux-mêmes d'interpréteur. Le premier mot devrait être un nom de chemin complet menant à l'interpréteur désiré (p.ex. « /bin/csh » ou « /usr/local/bin/tcsh »).

Variables shell spéciales¶

Les variables décrites dans cette section ont une signification spéciale pour le shell.

Le shell règle addsuffix, argv, autologout, command, echo_style, edit, gid, group, home, loginsh, oid, path, prompt, prompt2, prompt3, shell, shlvl, tcsh, term, tty, uid, user et version au démarrage ; elles ne sont pas modifiées par après à moins de l'être par l'utilisateur. Le shell met à jour cwd, dirstack, owd et status quand cela est nécessaire, et règle logout à la déconnexion.

Le shell synchronise afsuser, group, home, path, shlvl, term et user avec les variables d'environnement du même nom : chaque fois que la variable d'environnement change, le shell modifie la valeur de la variable shell équivalente pour qu'elle corresponde (à moins que la variable shell soit accessible en lecture seule) et inversement. Notez que bien que cwd et PWD aient une signification identique, elles ne sont pas synchronisées de cette manière, et que le shell interconvertit automatiquement les différents formats de path et PATH.

addsuffix (+)

Si elle est définie, le complètement des noms de fichiers ajoute un « / » à la fin des répertoires et une espace à la fin des fichiers normaux quand ils correspondent exactement. Définie par défaut.

afsuser (+)

Si elle est définie, la fonctionnalité de verrouillage automatique de autologout utilise sa valeur au lieu du nom d'utilisateur local pour l'authentification kerberos.

ampm (+)

Si elle est définie, toutes les heures sont affichées dans le format 12 heures AM/PM.

argv

Les arguments passés au shell. Les paramètres positionnels sont extraits à partir d'argv, p.ex. « $1 » est remplacé par « $argv[1] », etc. Définie par défaut, mais habituellement vide dans les shells interactifs.

autocorrect (+)

Si elle est définie, la commande d'éditeur spell-word est invoquée automatiquement avant chaque tentative de complètement.

autoexpand (+)

Si elle est définie, la commande d'éditeur expand-history est invoquée automatiquement avant chaque tentative de complètement.

autolist (+)

Si elle est définie, les possibilités sont listées après un complètement ambigu. Si elle vaut « ambiguous », les possibilités ne sont listées que lorsqu'aucun caractère n'a été ajouté par le complètement.

autologout (+)

Le premier mot est le nombre de minutes d'inactivité avant la déconnexion automatique. Le second mot optionnel est le nombre de minutes d'inactivité avant le verrouillage automatique. Quand le shell se déconnecte automatiquement, il affiche « auto-logout », fixe la variable logout à « automatic » et se termine. Quand le shell se verrouille automatiquement, l'utilisateur est requis pour entrer son mot de passe afin de pouvoir continuer à travailler. Cinq tentatives incorrectes résultent en une déconnexion automatique. Fixée à « 60 » (déconnexion automatique après 60 minutes, et aucun verrouillage) par défaut dans les shells de connexion et super-utilisateurs, mais pas si le shell pense tourner dans un système de fenêtrage (c.-à-d. si la variable d'environnement DISPLAY est définie), si le tty est un pseudo-tty (pty) ou si le shell n'a pas été compilé pour que cela soit le cas (voyez la variable shell version). Voyez également les variables shell afsuser et logout.

backslash_quote (+)

Si elle est définie, les backslashs (« \ ») protègent toujours « \ », « ' », et « " ». Cela peut simplifier les tâches de protection complexes, mais engendrer des erreurs de syntaxe dans les scripts csh(1).

catalog

Le nom de fichier du catalogue de messages. S'il est défini, tcsh utilise le catalogue de messages « tcsh.${catalog} » au lieu du celui employé par défaut (« tcsh »).

cdpath

Une liste de répertoires dans laquelle cd devrait rechercher les sous-répertoires s'ils ne sont pas trouvés dans le répertoire courant.

color

Si elle est définie, active l'affichage de la couleur pour la commande intégrée ls-F et passe --color=auto à ls. Alternativement, elle peut être définie uniquement pour ls-F ou pour ls afin de n'activer la couleur que pour une seule commande. La fixer à rien équivaut à la fixer à (ls-F ls).

colorcat

Si elle est définie, active les séquences d'échappement de couleur pour les fichiers de messages du NLS, et affiche des messages NLS très colorés.

command (+)

Si elle est définie, la commande qui a été passée au shell avec le drapeau -c.

complete (+)

Si elle vaut « enhance », le complètement 1) ignore la casse et 2) considère les points, tirets et caractères de soulignement (« . », « - » et « _ ») comme étant des séparateurs de mots, et les tirets et caractères de soulignement comme étant équivalents.

continue (+)

Si elle est définie en une liste de commandes, le shell continuera les commandes listées, au lieu d'en démarrer une nouvelle.

continue_args (+)

Comme continue, mais le shell exécutera :

correct (+)

Si elle vaut « cmd », les commandes subiront automatiquement la correction orthographique. Si elle vaut « complete », les commandes seront automatiquement complétées. Si elle vaut « all », la ligne de commandes entière est corrigée.

cwd

Le nom de chemin complet du répertoire courant. Voyez également les variables shell dirstack et owd.

dextract (+)

Si elle est définie, « pushd +n » extrait le n-ème répertoire de la pile de répertoires plutôt que de le faire pivoter jusqu'au sommet.

dirsfile (+)

L'emplacement par défaut dans lequel « dirs -S » et « dirs -L » recherchent un fichier d'historique. Si elle n'est pas définie, ~/.cshdirs est utilisé. Puisque seul ~/.tcshrc est normalement utilisé comme source avant ~/.cshdirs, dirsfile devrait être définie dans ~/.tcshrc plutôt que dans ~/.login.

dirstack (+)

Un tableau de tous les répertoires de la pile de répertoires. « $dirstack[1] » est le répertoire de travail courant, « $dirstack[2] » le premier répertoire sur la pile, etc. Notez que le répertoire de travail courant est « $dirstack[1] » mais « =0 » dans les substitution de pile de répertoires, etc. On peut modifier la pile arbitrairement en réglant dirstack, mais le premier élément (le répertoire de travail courant) est toujours correct. Voyez également les variables shell cwd et owd.

dspmbyte (+)

Si elle vaut « euc », active l'affichage et l'édition du code EUC-kanji (japonais). Si elle vaut « sjis », active l'affichage et l'édition du code Shift-JIS (japonais). Si elle vaut « big5 », active l'affichage et l'édition du code Shift-JIS (chinois). Si elle vaut « utf8 », active l'affichage et l'édition du code Shift-JIS (Unicode). Si elle vaut le format suivant, active l'affichage et l'édition du format de code original multi-octets :

dunique (+)

Si elle est définie, pushd supprime toutes les instances de nom de la pile avant de l'empiler.

echo

Si elle est définie, chaque commande avec ses arguments est renvoyée en écho juste avant d'être exécutée. Pour les commandes non intégrées, tous les développements se produisent avant la mise en écho. Les commandes intégrées sont envoyées en écho avant la substitution des commandes et des noms de fichiers puisque ces substitutions sont ensuite faites sélectivement. Définie par l'option -x de la ligne de commandes.

echo_style (+)

Le style de la commande intégrée echo. Peut valoir

edit (+)

Si elle est définie, l'éditeur de ligne de commandes est utilisé. Définie par défaut dans les shells interactifs.

ellipsis (+)

Si elle est définie, les séquences d'invite « %c », « %. » et « %C » (voyez la variable shell prompt) indiquent les répertoires passés avec une ellipse (« ... ») au lieu de « /<skipped> » (passé).

fignore (+)

Liste les suffixes de noms de fichiers à ignorer lors du complètement.

filec

Dans tcsh, le complètement est toujours utilisé et cette variable est ignorée. Si edit n'est pas définie, alors le complètement csh traditionnel est utilisé. Si elle est définie dans csh, le complètement des noms de fichiers est utilisé.

gid (+)

L'ID de groupe réel de l'utilisateur.

group (+)

Le nom de groupe de l'utilisateur.

histchars

Une valeur de type chaîne de caractères déterminant les caractères utilisés dans la Substitution d'historique. Le premier caractère de sa valeur est utilisé comme caractère de substitution d'historique, remplaçant le caractère par défaut « ! ». Le second caractère de sa valeur remplace le caractère « ^ » dans les substitutions rapides.

histdup (+)

Contrôle le traitement des entrées dupliquées dans la liste d'historique. Si elle vaut « all », seuls les événements d'historique uniques sont insérés dans la liste d'historique. Si elle vaut « prev » et que le dernier événement d'historique est identique à la commande courante, alors la commande courante n'est pas insérée dans l'historique. Si elle vaut « erase » et que le même événement est trouvé dans la liste d'historique, cet ancien événement est effacé et l'événement courant est inséré. Notez que les options « prev » et « all » renumérotent les événements d'historique afin qu'il n'y ait pas de trous.

histfile (+)

L'emplacement par défaut dans lequel « history -S » et « history -L » recherchent un fichier d'historique. S'il n'est pas défini, ~/.history est utilisé. histfile est utile quand on partage le même répertoire personnel entre différentes machines, ou quand on sauvegarde des historiques séparés sur des terminaux différents. Puisque seul ~/.tcshrc est normalement utilisé comme source avant ~/.history, histfile devrait être définie dans ~/.tcshrc plutôt que dans ~/.login.

histlit (+)

Si elle est définie, les commandes intégrées et d'éditeur et le mécanisme savehist utilisent la forme littérale (non développée) des lignes dans la liste d'historique. Voyez également la commande d'éditeur toggle-literal-history.

history

Le premier mot indique le nombre d'événements d'historique à sauvegarder. Le second mot optionnel (+) indique le format dans lequel l'historique est affiché ; s'il n'est pas fourni, « %h\t%T\t%R\n » est utilisé. Les séquences de format sont décrites dans prompt ; notez la signification variable de « %R ». Fixée à « 100 » par défaut.

home

Initialisé au répertoire personnel de l'appelant. Le développement de nom de fichier « ~ » se réfère à cette variable.

ignoreeof

Si elle vaut la chaîne de caractères vide ou « 0 » et que le périphérique d'entrée est un terminal, la commande end-of-file (habituellement générée par l'utilisateur en tapant « ^D » sur une ligne vide) indique au shell d'afficher « Use "exit" to leave tcsh. » (Utilisez exit pour quitter tcsh) au lieu de se terminer. Cela empêche que le shell soit tué accidentellement. Si elle vaut un nombre n, le shell ignorera n - 1 end-of-files consécutifs et se terminera au n-ième. (+) Si elle n'est pas définie, « 1 » est utilisé, c.-à-d que le shell se termine sur un simple « ^D ».

implicitcd (+)

Si elle est définie, le shell traite un nom de répertoire tapé comme une commande comme si cela avait été une requête de déplacement dans ce répertoire. Si elle vaut verbose, le changement de répertoire est produit en écho sur la sortie standard. Ce comportement est inhibé dans les scripts shell non interactifs, ou pour les chaînes de caractères de commande de plus d'un mot. Le changement de répertoire a priorité sur l'exécution d'une commande nommée d'une façon similaire, mais cela est effectué après la substitution des alias. Le développement du tilde et des variables fonctionnent comme prévu.

inputmode (+)

Si elle vaut « insert » ou « overwrite », place l'éditeur dans ce mode d'entrée au début de chaque ligne.

killdup (+)

Contrôle le traitement des entrées dupliquées dans l'anneau des parties supprimées (kill ring). Si elle vaut « all », seules les chaînes uniques sont entrées dans l'anneau. Si elle vaut « prev » et que la dernière chaîne supprimée est identique à la chaîne actuellement supprimée, alors la chaîne courante n'est pas entrée dans l'anneau. Si elle vaut « erase » et que la même chaîne est trouvée dans l'anneau, l'ancienne chaîne est effacée et la chaîne courante est insérée.

killring (+)

Indique le nombre de chaînes supprimées à garder en mémoire. Vaut « 30 » par défaut. Si elle n'est pas définie ou vaut moins de « 2 », le shell ne conservera que la chaîne la plus récemment supprimée.

listflags (+)

Si elle vaut « x », « a » ou « A », ou n'importe quelle combinaison d'entre eux (p.ex. « xA »), ils sont utilisés comme options pour ls-F, le faisant agir comme « ls -xF », « ls -Fa », « ls -FA » ou une combinaison (p.ex. « ls -FxA ») : « a » affiche tous les fichiers (même s'ils débutent par un « . »), « A » montre tous les fichiers sauf « . » et « .. », et « x » trie en lignes plutôt qu'en colonnes. Si le second mot de listflags est défini, il est utilisé comme chemin pour « ls(1) ».

listjobs (+)

Si elle est définie, tous les travaux sont listés quand un travail est suspendu. Si elle vaut « long », le listage est dans le format long.

listlinks (+)

Si elle est définie, la commande intégrée ls-F affiche le type du fichier vers lequel chaque lien symbolique pointe.

listmax (+)

Le nombre maximal d'éléments que la commande d'éditeur list-choices listera sans rien demander au préalable.

listmaxrows (+)

Le nombre maximal de rangées d'éléments que la commande d'éditeur list-choices listera sans rien demander au préalable.

loginsh (+)

Définie par le shell s'il n'est pas un shell de connexion. Sa définition ou la suppression de sa définition à l'intérieur d'un shell n'a aucun effet. Voyez également shlvl.

logout (+)

Fixée par le shell à « normal » avant une déconnexion normale, « automatic » avant une déconnexion automatique, et « hangup » si le shell a été tué par un signal de déconnexion (HANGUP, voyez Traitement des signaux). Voyez également la variable shell autologout.

mail

Le nom des fichiers ou répertoires à vérifier pour un email entrant, séparés par des espaces, et éventuellement précédés d'un mot numérique. Avant chaque invite, si 10 minutes se sont écoulées depuis la dernière vérification, le shell vérifie chaque fichier et dit « You have new mail. » (Vous avez du courrier) ou, si mail contient plusieurs fichiers, « You have new mail in nom. », si la taille du fichier est plus grande que zéro et possède une date de modification plus récente que sa date de dernier accès.

matchbeep (+)

Si elle vaut « never », le complètement ne bippe jamais. Si elle vaut « nomatch », tcsh bippe uniquement quand il n'y a pas de correspondance. Si elle vaut « ambiguous », il bippe quand il y a de multiples correspondances. Si elle vaut « notunique », il bippe quand il y a a une correspondance exacte et d'autres plus longues. Si elle n'est pas définie, « ambiguous » est utilisé.

nobeep (+)

Si elle est définie, la sonnerie est totalement désactivée. Voyez également visiblebell.

noclobber

Si elle est définie, des restrictions sont placées sur la redirection de sortie pour s'assurer que des fichiers ne seront pas accidentellement détruits et que les redirections « >> » se réfèrent à des fichiers existants, comme décrit dans la section Entrée/sortie.

noding

Si elle est définie, désactive l'affichage de « DING! » dans les spécificateurs temporels de prompt au moment du changement d'heure.

noglob

Si elle est définie, les Substitution des noms de fichiers et les Substitutions de pile de répertoires sont inhibés. C'est le plus utile dans les scripts shell qui ne s'occupent pas des noms de fichiers, ou après qu'une liste de noms de fichiers ait été obtenue, et que des développements supplémentaires ne sont pas désirables.

nokanji (+)

Si elle est définie et que le shell supporte le Kanji (voyez la variable shell version), elle est désactivée afin que la touche méta puisse être utilisée.

nonomatch

Si elle est définie, une Substitution de noms de fichiers ou une Substitutions de pile de répertoires qui ne correspond à aucun fichier existant n'est pas transformée plutôt que de causer une erreur. Il est toujours erroné pour la substitution d'être mal formée ; p.ex. « echo [ » donne toujours une erreur.

nostat (+)

Une liste de répertoires (ou des motifs génériques correspondant à des répertoires, voyez Substitution des noms de fichiers) qui ne devrait pas être stat(2)ée lors d'une opération de complètement. Cela est habituellement nécessaire pour exclure des répertoires pour lesquels stat(2) prendrait trop de temps, comme par exemple /afs.

notify

Si elle est définie, le shell annonce l'achèvement des travaux de façon asynchrone. Le comportement par défaut est de présenter les achèvements des travaux juste avant d'afficher une invite.

oid (+)

L'ID d'organisation réel de l'utilisateur. (Domain/OS uniquement)

owd (+)

L'ancien répertoire de travail, équivalent au « - » utilisé par cd et pushd. Voyez également les variables shell cwd dirstack.

path

Une liste de répertoire dans lesquels rechercher les commandes exécutables. Un mot vide spécifie le répertoire courant. S'il n'y a pas de variable path, alors seuls les noms de chemin complet s'exécuteront. path est définie par le shell au démarrage à partir de la variable d'environnement PATH ou, si PATH n'existe pas, vaudra un chemin par défaut dépendant du système comme p.ex. "(/usr/local/bin /usr/bsd /bin /usr/bin .)". Le shell peut placer « . » en premier ou en dernier lieu dans path ou l'omettre entièrement en fonction de la façon dont il a été compilé ; voyez la variable shell version. Un shell qui n'a reçu ni l'option -c ni l'option -t hache le contenu des répertoires de path après avoir lu ~/.tcshrc et à chaque fois que path est réinitialisé. Si l'on ajoute une nouvelle commande dans un répertoire présent dans path alors que le shell est actif, on pourrait devoir faire un rehash pour que le shell la trouve.

printexitvalue (+)

Si elle est définie et qu'un programme interactif se termine avec une valeur de retour non nulle, le shell affiche « Exit status ».

prompt

La chaîne de caractères (l'invite) qui est affichée avant de lire chaque commande du terminal. prompt peut inclure n'importe laquelle des séquences de formatage suivantes (+), qui sont remplacées par les informations fournies :

prompt2 (+)

La chaîne de caractères formant l'invite des boucles while et foreach, et affichée après les lignes se terminant par « \ ». Les mêmes séquences de format que celles de prompt peuvent être utilisées ; notez la signification variable de « %R ». Fixée par défaut à « %R?  » dans les shells interactifs.

prompt3 (+)

La chaîne de caractères formant l'invite lors de la confirmation d'une correction orthographique automatique. Les mêmes séquences de format que celles de prompt peuvent être utilisées ; notez la signification variable de « %R ». Fixée par défaut à « CORRECT>%R (y|n|e|a)?  » dans les shells interactifs.

promptchars (+)

Si elle est définie (en une chaîne de deux caractères), la séquence de formatage « %# » de la variable shell prompt est remplacée par le premier caractère pour les utilisateurs normaux et par le second caractère pour le super-utilisateur.

pushdtohome (+)

Si elle est définie, pushd sans argument effectue un « pushd ~ », comme cd.

pushdsilent (+)

Si elle est définie, pushd et popd n'affichent pas la pile de répertoires.

recexact (+)

Si elle est définie, le complètement complète en une correspondance exacte même si une correspondance plus longue est possible.

recognize_only_executables (+)

Si elle est définie, le listage des commandes affiche uniquement les fichiers situés dans le path qui sont exécutables. Lent.

rmstar (+)

Si elle est définie, on demande confirmation à l'utilisateur avant que « rm * » ne soit exécuté.

rprompt (+)

La chaîne de caractères à afficher du côté droit de l'écran (après l'entrée de commande) quand l'invite est affichée sur la gauche. Elle reconnaît les mêmes caractères de formatage que prompt. Elle disparaîtra et réapparaîtra automatiquement si nécessaire, pour s'assurer que l'entrée de commandes n'est pas obscurcie, et apparaîtra uniquement si l'invite, l'entrée de commande et elle-même combinées tiennent ensemble sur la première ligne. Si edit n'est pas définie, alors rprompt sera affiché après l'invite et avant l'entrée de commande.

savedirs (+)

Si elle est définie, le shell effectue un « dirs -S » avant de se terminer. Si le premier mot est un nombre, il représentera le nombre maximum d'entrées de la pile de répertoires à sauvegarder.

savehist

Si elle est définie, le shell effectue un « history -S » avant de se terminer. Si le premier mot est un nombre, au plus ce nombre de lignes seront sauvegardées. (Le nombre doit être plus petit ou égal à history.) Si le second mot est « merge », la liste d'historique est fusionnée avec le fichier d'historique existant (s'il y en a un) plutôt que de le remplacer et est triée par horodate, et les événements les plus récents sont retenus. (+)

sched (+)

Le format dans lequel la commande intégrée sched affiche les événements programmés ; s'il n'est pas fourni, « %h\t%T\t%R\n » est utilisé. Les séquences de format sont décrites plus haut sous prompt ; notez la signification variable de « %R ».

shell

Le fichier dans lequel le shell réside. C'est utilisé pour forker (générer) des shells afin d'interpréter les fichiers dont les bits d'exécution sont positionnés, mais qui ne sont pas exécutables par le système. (Voyez la description dans Exécution des commandes intégrées ou pas.) Initialisé au répertoire de démarrage (dépendant du système) du shell.

shlvl (+)

Le nombre de shells imbriqués. Réinitialisé à 1 dans les shells de connexion. Voyez également loginsh.

status

Le statut (valeur de retour) renvoyé par la dernière commande. Si elle s'est terminée anormalement, alors 0200 est ajouté au statut. Les commandes intégrées qui échouent retournent une valeur de sortie de « 1 », toutes les autres commandes intégrées renvoient une valeur de retour de « 0 ».

symlinks (+)

Peut prendre plusieurs valeurs différentes pour contrôler la résolution des liens symboliques (« symlink ») :

tcsh (+)

Le numéro de version du shell dans le format « R.VV.PP », où « R » est le numéro de publication majeur (release), « VV » la version actuelle et « PP » le niveau de patchs.

term

Le type de terminal. Habituellement défini dans ~/.login comme décrit dans Démarrage et arrêt.

time

Si elle vaut un nombre, alors la commande intégrée time s'exécute automatiquement après chaque commande qui utilise plus que ce nombre de secondes CPU. S'il y a un second mot, il est utilisé comme chaîne de caractères de format pour la sortie de la commande intégrée time. (u) Les séquences suivantes peuvent être utilisées dans la chaîne de format :

tperiod (+)

La durée, en minutes, entre les exécutions de l'alias spécial periodic.

tty (+)

Le nom du tty, ou vide si le shell n'est attaché à aucun terminal.

uid (+)

L'ID d'utilisateur réel de l'utilisateur.

user

Le nom de connexion de l'utilisateur.

verbose

Si elle est définie, provoque l'affichage des mots de chaque commande, après la substitution d'historique (s'il y en a une). Définie par l'option de ligne de commandes -v.

version (+)

L'identifiant de version. Il contient le numéro de version du shell (voyez tcsh), l'origine, la date de publication, le vendeur, le système d'exploitation et la machine (voyez VENDOR, OSTYPE et MACHTYPE) et une liste d'options séparées par des virgules qui sont fixées au moment de la compilation. Les options qui sont spécifiées par défaut dans la distribution sont également citées.

visiblebell (+)

Si elle est définie, un clignotement d'écran est utilisé plutôt que la sonnerie audible. Voyez aussi nobeep.

watch (+)

Une liste de paires utilisateur/terminal pour surveiller les connexions et déconnexions. Si l'utilisateur est « any », tous les terminaux sont surveillés pour l'utilisateur fourni et vice-versa. Définir watch à « (any any) » surveille tous les utilisateurs et terminaux. Par exemple,

who (+)

La chaîne de format pour les messages watch. Les séquences suivantes sont remplacées par les informations fournies :

wordchars (+)

Une liste de caractères non alphanumériques qui doivent être considérés comme faisant partie d'un mot par les commandes d'éditeur forward-word, backward-word etc. Si elle n'est pas définie, « *?_-.[]~= » est utilisé.