Loading

NOM

       tcsh  -  shell C  avec complètement des noms de fichiers  et édition de 
       lignes de commandes  

SYNOPSIS

       tcsh [-bcdefFimnqstvVxX] [-Dnom[=valeur]] [arg ...]
       tcsh -l

       tcsh est une version améliorée mais complètement compatible du  shell C
       du UNIX de  Berkeley,  csh(1).  C'est un  interpréteur  de  langage  de 
       commandes utilisable à la fois  comme shell de connexion interactif  et
       comme processeur de commandes de scripts shell. Il inclut un éditeur de
       ligne de commandes complet (voyez L'éditeur de ligne de commandes),  un
       complètement des mots programmable (voyez Complètement et listage), une
       correction  orthographique   (voyez   Correction  orthographique),   un 
       mécanisme d'historique  (voyez Substitution d'historique),  un contrôle
       des travaux (voyez Travaux)  et une syntaxe semblable à celle du C.  La
       section NOUVELLES FONCTIONNALITÉS décrit  les améliorations majeures de
       tcsh   par  rapport  à  csh(1).   Tout  au  long  de  ce  manuel,   les 
       fonctionnalités  de  tcsh  qu'on ne  trouve  pas  dans  la plupart  des
       implémentations de csh (spécifiquement le csh de BSD4.4)  sont marquées
       par un « (+) », et les fonctionnalités  qui sont présentes  dans csh(1)
       mais qui ne sont  généralement  pas documentées  sont marquées  par  un 
       « (u) ».

       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) à

          bas           down-history
          haut          up-history 
          gauche        backward-char
          droite        forward-char

       à 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é : 

        ^W
            Concatène le reste du mot sous le curseur au motif de recherche. 
        delete
            (ou n'importe quel caractère lié à backward-delete-char) Annule l'effet du dernier caractère tapé et efface un caractère du motif de recherche si cela est approprié. 
        ^G
            Si la recherche précédente a été couronnée de succès, abandonner la recherche. Sinon, revenir à la dernière recherche réussie. 
        escape
            Termine la recherche, en laissant la ligne courante dans le tampon d'entrée. 

    Tout autre caractère non lié à self-insert-command termine la recherche, en laissant la ligne courante dans le tampon d'entrée, et est ensuite interprété comme une entrée normale. En particulier, un retour chariot entraînera l'exécution de la ligne courante. Mode Emacs uniquement. Voyez également i-search-fwd et history-search-backward. 

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

    n
        Un nombre se référant à un événement particulier. 
    -n
        Un décalage se référant au n-ième événement précédant l'événement courant 
    #
        L'événement courant. Cela devrait être utilisé avec précaution dans csh(1), car il n'y a pas de vérification de récursion. tcsh admet 10 niveaux de récursion. (+) 
    !
        L'événement précédent (équivalent à « -1 ») 
    s
        L'événement le plus récent dont le premier mot débute par la chaîne de caractères s 
    ?s?
        L'événement le plus récent contenant la chaîne s. Le second « ? » peut être omis s'il est immédiatement suivi d'un saut de ligne. 

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 :

    0
        Le premier mot (la commande) 
    n
        Le n-ième argument 
    ^
        Le premier argument, équivalent à « 1 » 
    $
        Le dernier argument 
    %
        Le mot correspondant à une recherche ?s? 
    x-y
        Un intervalle de mots 
    -y
        Équivalent à « 0-y » 
    *
        Équivalent à « ^-$ », mais ne renvoie rien si l'événement ne contient qu'un seul mot 
    x*
        Équivalent à « x-$ » 
    x-
        Équivalent à « x* », mais omet le dernier mot (« $ ») 

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 « : »:

    h
        Supprimer un composant de nom de chemin de queue, en conservant la tête. 
    t
        Supprimer tous les composants de tête du nom de chemin, en conservant la queue. 
    r
        Supprimer l'extension du nom de fichier « .xxx », en conservant le nom racine. 
    e
        Supprimer tout sauf l'extension. 
    u
        Mettre en majuscule la première lettre minuscule. 
    l
        Mettre en minuscule la première lettre majuscule. 
    s/l/r/
        Substituer r à l. l est simplement une chaîne de caractères comme r, et pas une expression rationnelle du type de celles de la commande éponyme ed(1). N'importe quel caractère peut être utilisé comme délimiteur au lieu de « / » ; un « \ » peut être utilisé pour protéger le délimiteur à l'intérieur de l et r. Un caractère « & » dans r est remplacé par l ; « \ » protège également « & ». Si l est vide (""), le l d'une substitution précédente ou le s d'une spécification d'événement précédente « ?s? » sera utilisé. Le délimiteur de queue peut être omis s'il est immédiatement suivi d'un saut de ligne. 
    &
        Répéter la substitution précédente. 
    g
        Appliquer le modificateur suivant une fois sur chaque mot. 
    a (+)
        Appliquer le modificateur suivant autant de fois que possible sur un simple mot. « a » et « g » peuvent être utilisés simultanément pour appliquer un modificateur de façon globale. Dans l'implémentation actuelle, l'utilisation simultanée des modificateurs « a » et « s » peut mener à une boucle infinie. Par exemple, « :as/f/ff/ » ne se terminera jamais. Ce comportement pourrait changer dans le futur. 
    p
        Afficher la nouvelle ligne de commandes mais ne pas l'exécuter. 
    q
        Protéger les mots substitués, en empêchant ainsi de nouvelles substitutions. 
    x
        Comme q, mais couper en mots aux emplacement des blancs, tabulations et sauts de ligne. 

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.

        Si la variable shell noclobber est définie, alors le fichier ne peut pas exister ou doit être un fichier spécial (p.ex. un terminal ou « /dev/null »), ou sinon une erreur surviendra. Cela aide à prévenir des destructions accidentelles de fichiers. Dans ce cas, les formes « ! » peuvent être utilisées pour supprimer cette vérification.

        Les formes invoquant « & » dirigent la sortie de diagnostic (d'erreur) dans le fichier spécifié en plus de la sortie standard. nom est développé de la même façon que les noms de fichiers d'entrée « < » le sont. 

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

    r
        Accès en lecture 
    w
        Accès en écriture 
    x
        Exécutable 
    X
        Exécutable dans le « path » ou commande intégrée, p.ex. « -X ls » et « -X ls-F » sont vrais en général, mais « -X /bin/ls » ne l'est pas (+) 
    e
        Existence 
    o
        Propriété 
    z
        Taille nulle 
    s
        Taille non nulle (+) 
    f
        Fichier texte 
    d
        Répertoire 
    l
        Lien symbolique (+) * 
    b
        Fichier spécial en mode bloc (+)       
    c
        Fichier spécial en mode caractère (+) 
    p
        Tube nommé (fifo) (+) * 
    S
        Fichier spécial de socket (+) * 
    u
        Le bit SUID est positionné (+) 
    g
        Le bit SGID est positionné (+) 
    k
        Le bit collant (sticky bit) est positionné (+) 
    t
        fichier (qui doit être un nombre) est un descripteur de fichier ouvert pour un périphérique de terminal (+) 
    R
        A été migré (convex uniquement) (+) 
    L
        Applique les opérateurs ultérieurs dans un test multi-opérateurs à un lien symbolique plutôt qu'au fichier vers lequel le lien pointe (+) * 

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 :

    A
        Date de dernier accès au fichier, mesuré en nombre de secondes depuis l'Epoch 
    A:
        Comme A, mais dans un format d'horodate, p.ex. « Fri May 14 16:36:10 1993 » 
    M
        Date de dernière modification du fichier 
    M:
        Comme M, mais dans le format d'horodate 
    C
        Date de dernière modification d'i-n½ud 
    C:
        Comme C, mais dans le format d'horodate 
    D
        Numéro de périphérique 
    I
        Numéro d'i-n½ud 
    F
        Identifiant de fichier composé, de la forme périphérique:i-n½ud 
    L
        Le nom du fichier qui est pointé par un lien symbolique 
    N
        Nombre de liens (matériels) 
    P
        Permissions, en octal, sans le zéro de tête 
    P:
        Comme P, avec le zéro de tête 
    Pmode
        Équivalent à « -P fichier & mode », p.ex. « -P22 fichier » renvoie « 22 » si fichier est accessible en écriture pour le groupe et les autres utilisateurs, « 20 » s'il ne l'est que pour le groupe, et « 0 » s'il ne l'est pour aucun d'entre eux 
    Pmode:
        Comme Pmode:, sans le zéro de tête 
    U
        Identifiant numérique de l'utilisateur 
    U:
        Nom d'utilisateur, ou ID d'utilisateur numérique si le nom d'utilisateur est inconnu 
    G
        Identifiant numérique de groupe 
    G:
        Nom de groupe, ou ID de groupe numérique si le nom du groupe est inconnu 
    Z
        Taille en octets 

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 FBLANGFR ou FBLC_CTYPEFR 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.

 
RÉFÉRENCES
Les sections suivantes de ce manuel décrivent les Commandes intégrées, Alias spéciaux et Variables shell spéciales.  
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.

        La deuxième forme affecte la valeur de expr à nom. La troisième forme affecte la valeur de expr au indice-ième composant de nom ; le nom et son indice-ième composant doivent tous deux exister au préalable.

        expr peut contenir les opérateurs « * », « + », etc., comme en C. Si expr contient « < », « > », « & » ou "" (la chaîne vide), alors au moins cette partie de expr doit être placée entre parenthèses. Notez que la syntaxe de expr n'a rien à voir avec celle décrite dans Expressions.

        Les quatrième et cinquième formes incrémentent (« ++ ») ou décrémentent (« -- ») nom de son indice-ième composant.

        L'espace entre « @ » et nom est obligatoire. Les espaces entre nom et « = », et entre « = » et expr sont optionnelles. Les composants de expr doivent être séparés par des espaces. 

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 : 

    -l
        Liste toutes les commandes d'éditeur et une courte description pour chacune d'entre elles. 
    -d
        Liste toutes les touches des liaisons standard de l'éditeur par défaut. 
    -e
        Liste toutes les touches des liaisons standard de type GNU Emacs. 
    -v
        Liste toutes les touches des liaisons standard de type vi(1). 
    -a
        Affiche ou modifie les liaisons de touches dans la cartographie clavier alternative. C'est la cartographie clavier utilisée dans le mode commande de vi. 
    -b
        touche est interprétée comme un caractère de contrôle écrit ^caractère (p.ex. « ^A ») ou C-caractère (p.ex. « C-A »), un métacaractère écrit M-caractère (p.ex. « M-A »), une touche de fonction écrite F-chaîne_caractères (p.ex. « F-chaîne_caractères »), ou une touche préfixe étendue écrite X-caractère (p.ex. « X-A »). 
    -k
        touche est interprétée en tant que nom de touche fléchée symbolique, qui peut être « down » (bas), « up » (haut), « left » (gauche) ou « right » (droite). 
    -r
        Supprime la liaison de touche. Faites attention : « bindkey -r » ne lie pas key à self-insert-command, elle « délie » touche complètement. 
    -c
        commande est interprétée en tant que commande intégrée ou commande externe au lieu d'une commande d'éditeur. 
    -s
        commande est interprétée en tant que chaîne de caractères littérale et est traitée comme entrée pour le terminal quand la touche est pressée. Les touches liées à commande sont elles-mêmes réinterprétées, et cela se poursuit jusqu'à 10 niveaux d'interprétation. 
    -- 
        Force une cassure dans le traitement des options, afin que le mot suivant soit interprété comme une touche même s'il commence par « - ». 
    -u (ou toute option invalide)
        Affiche un message d'utilisation. 

    touche peut être un unique caractère ou une chaîne de caractères. Si une commande est liée à une chaîne de caractères, le premier caractère de la chaîne est lié à sequence-lead-in et la chaîne de caractères entière est liée à la commande.

    Les caractères de contrôle dans touche peuvent être littéraux (ils peuvent être tapés en les faisant précéder par la commande d'éditeur quoted-insert, liée normalement à « ^V ») ou écrits dans le style accent_circonflexe-caractère, p.ex. « ^A ». Delete est écrit « ^? » (accent_circonflexe-point_d_interrogation). touche et commande peuvent contenir des séquences d'échappement backslashées (dans le style du echo(1) de System V) comme suit :

            \a Sonnerie 
        \b
            Effacement arrière (backspace) 
        \e
            Échappement (escape) 
        \f
            Saut de page 
        \n
            Saut de ligne 
        \r
            Retour chariot 
        \t
            Tabulation horizontale 
        \v
            Tabulation verticale 
        \nnn
            Le caractère ASCII correspondant au nombre octal nnn 

    « \ » annule la signification spéciale du caractère suivant, s'il y en a un, notamment « \ » et « ^ ». 

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.

        Avec -p, affiche la pile de répertoires finale, tout comme dirs. Les drapeaux -l, -n et -v ont le même effet sur cd que sur dirs, et impliquent -p. (+)

        Voyez également la variable shell implicitcd. 

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.

        commande peut être un nom de commande complet ou un motif générique (voyez Substitution des noms de fichiers). Elle peut commencer par « - » pour indiquer que le complètement ne devrait être utilisé que si la commande est ambiguë.

        mot spécifie quel mot relatif au mot courant doit être complété, et peut être :

            c
                Complètement du mot courant. motif est un motif générique qui doit correspondre au commencement du mot courant sur la ligne courante. motif est ignoré lors du complètement du mot courant. 
            C
                Comme c, mais inclut motif lors du complètement du mot courant. 
            n
                Complètement du mot suivant. motif est un motif générique qui doit correspondre au commencement du mot précédent sur la ligne de commandes. 
            N
                Comme n, mais doit correspondre au commencement du mot situé à deux positions avant le mot courant. 
            p
                Complètement dépendant de la position. motif est un intervalle numérique, avec la même syntaxe que celle utilisée pour indexer les variables shell, et qui doit inclure le mot courant. 

        liste, la liste des complètements possibles, peut être :

            a
                Alias 
            b
                Liaisons (commandes d'éditeur) 
            c
                Commandes (intégrées ou externes) 
            C
                Commandes externes débutant par le préfixe de chemin fourni 
            d
                Répertoires 
            D
                Répertoires commençant par le préfixe de chemin fourni 
            e
                Variables d'environnement 
            f
                Noms de fichiers 
            F
                Noms de fichiers commençant par le préfixe de chemin fourni 
            g
                Noms de groupes 
            j
                Travaux 
            l
                Limites 
            n
                Rien 
            s
                Variables shell 
            S
                Signaux 
            t
                fichiers plats (« texte ») 
            T
                fichiers plats (« texte ») commençant par le préfixe de chemin fourni 
            v
                N'importe quelle variable 
            u
                Noms d'utilisateurs 
            x
                Comme n, mais affiche select quand list-choices est utilisé. 
            X
                Complètements 
            $var
                Mots provenant de la variable var 
            (...)
                Mots provenant de la liste donnée 
            `...`
                Mots provenant de la sortie de la commande 

        select est un motif générique optionnel. S'il est fourni, seuls les mots de liste qui correspondent au select sont pris en considération et la variable shell fignore est ignorée. Les trois derniers types de complètements peuvent ne pas contenir de motif select, et x utilise select comme message d'explication quand la commande d'éditeur list-choices est utilisée.

        suffixe est un caractère à concaténer lors d'un complètement réussi. S'il est nul, aucun caractère n'est concaténé. S'il est omis (auquel cas le quatrième délimiteur peut également être omis), un / est concaténé aux répertoires et une espace aux autres mots.

        Maintenant voici quelques exemples. Certaines commandes ne prennent que des répertoires comme arguments, de sorte que cela n'a aucun sens de compléter des fichiers normaux.

            > complete cd 'p/1/d/' 

        ne complète que le premier mot suivant « cd » (« p/1 ») par un répertoire. Le complètement de type p peut également être utilisé pour limiter le complètement des commandes :

            > co[^D]
            complete compress
            > complete -co* 'p/0/(compress)/'
            > co[^D]
            > compress 

        Ce complètement complète des commandes (mots en position 0, « p/0 ») qui commencent par « co » (correspondant donc à « co* ») en « compress » (le seul mot de la liste). Le « - » de tête indique que ce complètement ne doit être utilisé que pour les commandes ambiguës.

            > complete find 'n/-user/u/' 

        est un exemple du complètement de type n. Tous les mots suivant « find » et suivant immédiatement « -user » est complété à partir de la liste des utilisateurs.

            > complete cc 'c/-I/d/' 

        montre le complètement de type c. Tous les mots suivant « cc » et commençant par « -I » sont complétés en un répertoire. « -I » n'est pas considéré faisant partie du répertoire car nous avons utilisé un c minuscule.

        Des différentes listes sont utiles avec des commandes différents.

            > complete alias 'p/1/a/'
            > complete man 'p/*/c/'
            > complete set 'p/1/s/'
            > complete true 'p/1/x:Truth has no options./' 

        Celles-ci complètent les mots suivant « alias » par des alias, « man » par des commandes, et « set » par des variables shell. « true » n'a aucune option, et x ne fait donc rien quand le complètement est tenté, et affiche « Truth has no options. » quand les choix de complètement sont listés.

        Notez que l'exemple man, et plusieurs autres exemples plus bas, aurait tout aussi bien pu utiliser « c/* » ou « n/* » plutôt que « p/* ».

        Les mots peuvent être complétés à partir d'une variable évaluée au moment du complètement :

            > complete ftp 'p/1/$hostnames/'
            > set hostnames = (rtfm.mit.edu tesla.ee.cornell.edu)
            > ftp [^D]
            rtfm.mit.edu tesla.ee.cornell.edu
            > ftp [^C]
            > set hostnames = (rtfm.mit.edu tesla.ee.cornell.edu uunet.uu.net)
            > ftp [^D]
            rtfm.mit.edu tesla.ee.cornell.edu uunet.uu.net 

        ou à partir d'une commande en cours d'exécution au moment du complètement :

            > complete kill 'p/*/`ps | awk \{print\ \$1\}`/'
            > kill -9 [^D]
            23113 23377 23380 23406 23429 23529 23530 PID 

        Notez que la commande complete ne protège pas elle-même ses arguments, de sorte que les accolades, l'espace et le « $ » dans « {print $1} » doivent être protégés explicitement.

        Une commande peut posséder plusieurs complètements :

            > complete dbx 'p/2/(core)/ » 'p/*/c/' 

        complète le deuxième argument en « dbx » par le mot « core » et tous les autres arguments par des commandes. Notez que le complètement positionnel est spécifié avant le complètement du mot suivant. Puisque les complètements sont évalués de gauche à droite, si le complètement du mot suivant avait été spécifié en premier lieu, il conviendrait toujours et le complètement positionnel ne serait jamais exécuté. C'est une erreur courante lors de la définition d'un complètement.

        Le motif select est utile quand une commande ne prend que des fichiers de formes particulières comme arguments. Par exemple,

            > complete cc 'p/*/f:*.[cao]/' 

        ne complète les arguments de « cc » que pour les fichiers se terminant en « .c », « .a » ou « .o ». select peut également exclure des fichiers, en utilisant la négation d'un motif générique comme décrit dans Substitution des noms de fichiers. On pourrait utiliser

            > complete rm 'p/*/f:^*.{c,h,cc,C,tex,1,man,l,y}/' 

        pour exclure un code source précieux d'un complètement « rm ». Bien sûr, on peut toujours taper les noms exclus manuellement ou surcharger le mécanisme de complètement en utilisant les commandes d'éditeur complete-word-raw ou list-choices-raw.

        Les listes « C », « D », « F » et « T » sont identiques à « c », « d », « f » et « t » respectivement, à l'exception près qu'elles utilisent l'argument select d'une manière différente, pour restreindre le complètement aux fichiers commençant par un préfixe de chemin particulier. Par exemple, le programme mail Elm utilise « = » comme abréviation pour son répertoire de mail. On pourrait utiliser

            > complete elm c@=@F:$HOME/Mail/@ 

        pour compléter « elm -f = » comme s'il s'agissait de « elm -f ~/Mail/ ». Notez que nous avons utilisé « @ » au lieu de « / » pour éviter la confusion avec l'argument select, et « $HOME » au lieu de « ~ » car la substitution de répertoire personnel ne fonctionne qu'au commencement d'un mot.

        suffixe est utilisé pour ajouter un suffixe non standard (pas d'espace ou de « / » pour les répertoires) aux mots complétés.

            > complete finger 'c/*@/$hostnames/' 'p/1/u/@' 

        complète les arguments de « finger » à partir de la liste des utilisateurs, concatène un « @ », et ensuite complète après le « @ » à partir de la variable « hostnames ». Notez à nouveau l'ordre dans lequel les complètements sont spécifiés.

        Finalement, voici un exemple complexe pour l'inspiration :

            > complete find \
            'n/-name/f/' 'n/-newer/f/' 'n/-{,n}cpio/f/' \
            'n/-exec/c/' 'n/-ok/c/' 'n/-user/u/' \
            'n/-group/g/' 'n/-fstype/(nfs 4.2)/' \
            'n/-type/(b c d f l p s)/' \
            'c/-/(name newer cpio ncpio exec ok user \
            group fstype type atime ctime depth inum \
            ls mtime nogroup nouser perm print prune \
            size xdev)/' \
            'p/*/d/' 

        Cela complète les mots suivant « -name », « -newer », « -cpio » ou « ncpio » (notez le motif qui correspond aux deux) en des fichiers, les mots suivant « -exec » ou « -ok » en des commandes, les mots suivant « user » et « group » en des utilisateurs et des groupes respectivement, et les mots suivant « -fstype » ou « -type » en des membres des listes données. Le complètement des options est également effectué à partir de la liste fournie (notez l'emploi du complètement de type c), et complète tout ce qui ne serait pas complété en un répertoire. Whaw !

        Souvenez-vous que les complètements programmés sont ignorés si le mot en cours de complètement est une substitution de tilde (débutant par « ~ ») ou une variable (débutant par « $ »). complete est une fonctionnalité expérimentale, et sa syntaxe pourrait changer dans de futures versions du shell. Voyez également la commande intégrée uncomplete. 

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.

        Avec -S, la deuxième forme sauvegarde la pile de répertoires dans nom_fichier sous forme d'une série de commandes cd et pushd. Avec -L, le shell utilise comme source nom_fichier, supposé être un fichier de pile de répertoires sauvegardé via l'option -S ou le mécanisme savedirs. Dans tous les cas, dirsfile est utilisé si nom_fichier n'est pas fourni et si ~/.cshdirs est utilisé alors que dirsfile n'est pas définie.

        Notez que les shells de connexion font l'équivalent de « dirs -L » au démarrage et, si savedirs est définie, « dirs -S » avant de se terminer. Puisque seul ~/.tcshrc est normalement utilisé comme source avant ~/.cshdirs, dirsfile devrait être définie dans ~/.tcshrc plutôt que dans ~/.login.

        La dernière forme efface la pile de répertoires. 

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.

        Si arg est « baud », « cols », « lines », « meta » ou « tabs », affiche la valeur de cette capacité (« yes » (oui) ou « no » (non) indiquant que le terminal possède ou non cette capacité). On pourrait utiliser ceci pour rendre la sortie d'un script shell moins bavarde sur les terminaux lents, ou pour limiter la sortie d'une commande au nombre de lignes de l'écran :

            > set history=`echotc lines`
            > @ history-- 

        Les chaînes de caractères termcap peuvent contenir des jokers qui ne seront pas transmis correctement. On devrait utiliser des guillemets quand on on affecte une chaîne de caractères de capacité de terminal à une variable shell, comme dans l'exemple suivant qui place la date dans la ligne de statut :

            > set tosl="`echotc ts 0`"
            > set frsl="`echotc fs`"
            > echo -n "$tosl";date; echo -n "$frsl" 

        Avec -s, les capacités non existantes renvoient la chaîne vide plutôt que de causer une erreur. Avec -v, les messages sont verbeux. 

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.

        Avec -S, la deuxième forme sauvegarde la liste d'historique dans nom_fichier. Si le premier mot de la variable shell savehist est un nombre, au plus ce nombre de lignes seront sauvegardées. Si le second mot de savehist est « merge », la liste d'historique est fusionnée avec le fichier d'historique existant (s'il y en a un) au lieu de le remplacer et est triée par horodate. (+) La fusion est destinée à un environnement comme le système X Window où plusieurs shells sont utilisés simultanément. Actuellement, elle ne fonctionne que lorsque les shells se terminent proprement les uns après les autres.

        Avec -L, le shell concatène nom_fichier, qui est supposé être une liste d'historique sauvegardée par l'option -S ou par le mécanisme savehist, à la liste d'historique. -M est similaire à -L, mais le contenu de nom_fichier est fusionné dans la liste d'historique et est trié par horodate. Dans tous les cas, histfile est utilisé si nom_fichier n'est pas fourni et si ~/.history est utilisé alors que histfile n'est pas définie. « history -L » agit exactement comme « source -h » à part qu'il ne requiert pas de nom de fichier.

        Notez que les shells de connexion font l'équivalent de « history -L » au démarrage et, si savehist est définie, « history -S » avant la terminaison. Puisque seul ~/.tcshrc est normalement utilisé comme source avant ~/.history, histfile devrait être définie dans ~/.tcshrc plutôt que dans ~/.login.

        Si histlit est définie, la première et la deuxième formes affichent et sauvent la forme littérale (non développée) de la liste d'historique.

        La dernière forme efface la liste d'historique. 

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.

        Les ressources contrôlables incluent actuellement (si c'est supporté par le système d'exploitation :

        cputime
            le nombre maximum de secondes-cpu que chaque processus peut utiliser 
        filesize
            taille de fichier : le plus grand fichier pouvant être créé 
        datasize
            taille des données : la croissance maximale de la région données+pile via sbrk(2) au-delà de la fin du texte du programme 
        stacksize
            taille de la pile : la taille maximale de la région de la pile étendue automatiquement 
        coredumpsize
            la taille de la grande image mémoire (core dump) pouvant être créée 
        memoryuse
            utilisation mémoire : la quantité maximale de mémoire physique qu'un processus peut avoir alloué à un moment donné 
        descriptors ou openfiles
            le nombre maximum de fichiers ouverts pour ce processus 
        concurrency
            le nombre maximum de threads pour ce processus 
        memorylocked
            la quantité de mémoire maximale qu'un processus peut verrouiller en mémoire en utilisant mlock(2) 
        maxproc
            le nombre maximum de processus simultanés pour cet id d'utilisateur 
        sbsize
            le niveau maximal d'utilisation du tampon de socket pour cet utilisateur 

        utilisation-maximale peut être fournie comme un nombre (réel flottant ou entier) suivi d'un facteur d'échelle. Pour toutes les limites autres que cputime, l'échelle (l'unité) par défaut est « k » ou « kilobytes » (kilo-octets, c.-à-d. 1024 octets) ; un facteur d'échelle de « m » ou « megabytes » (mégaoctets) peut également être utilisé. Pour cputime, l'unité par défaut est la seconde (« seconds »), alors qu'on a « m » pour les minutes et « h » pour les heures, ou une heure de la forme « mm:ss » qui donne le nombre de minutes et de secondes qui peuvent être employées.

        Pour les noms de ressources et de facteurs d'échelle, des préfixes nom ambigus suffisent. 

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 : 

    /
        Répertoire 
    *
        Exécutable 
    #
        Périphérique en mode bloc 
    %
        Périphérique en mode caractère 
    |
        Tube nommé (uniquement pour les systèmes supportant les tubes nommés) 
    =
        Socket (uniquement pour les systèmes supportant les sockets) 
    @
        Lien symbolique (uniquement pour les systèmes supportant les liens symboliques) 
    +
        Répertoire caché (AIX uniquement) ou dépendant du contexte (HP/UX uniquement) 
    :
        Périphérique réseau spécial (HP/UX uniquement) 

    Si la variable shell listlinks est définie, les liens symboliques sont identifiés avec plus de détails (uniquement, bien sûr, sur les systèmes les supportant) :

    @
        Lien symbolique vers un non-répertoire 
    >
        Lien symbolique vers un répertoire 
    &
        Lien symbolique vers nulle part (lien défaillant) 

    listlinks ralentit également ls-F et entraîne le montage des partitions contenant des fichiers vers lesquels pointent des liens symboliques.

    Si la variable shell listflags 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 »). Sur les machines où « ls -C » n'est pas le comportement par défaut, ls-F agit comme « ls -CF », à moins que listflags ne contienne un « x », auquel cas il agit comme « ls -xF ». ls-F passe ses arguments à ls(1) si on lui fournit des options, de sorte que « alias ls ls-F » effectue généralement ce qu'on attend de lui.

    La commande intégrée ls-F peut lister les fichiers en utilisant différentes couleurs en fonction du type de fichier ou d'extension. Voyez la variable tcsh color et la variable d'environnement LS_COLORS. 

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,

            > sched 11:00 echo Il est onze heures. 

        indique au shell de produire en écho « Il est onze heures. » à 11h00. L'heure peut être dans le format 12 heures AM/PM

            > sched 5pm set prompt='[%h] Il est 5 heures passées ; retourne à la maison: >' 

        ou peut être relative à l'heure courante :

            > sched +2:15 /usr/lib/uucp/uucico -r1 -sother 

        Une spécification d'heure relative ne peut pas utiliser le format AM/PM. La troisième forme supprime l'élément n de la liste d'événements :

            > sched

                 1  Wed Apr  4 15:42  /usr/lib/uucp/uucico -r1 -sother

                 2  Wed Apr  4 17:00  set prompt=[%h] Il est 5 heures passées ; retourne à la maison: >
            > sched -2
            > sched

                 1  Wed Apr  4 15:42  /usr/lib/uucp/uucico -r1 -sother 

        Une commande de la liste d'événements programmés est exécutée juste avant que la première invite ne soit affichée, et après le moment où la commande a été programmée. Il est possible de rater l'heure exacte quand la commande doit être lancée, mais une commande en retard s'exécutera à la prochaine invite. Une commande qui vient à échéance pendant que le shell attend une entrée de l'utilisateur est exécutée immédiatement. Néanmoins, l'exécution normale d'une commande en cours d'exécution ne sera pas interrompue afin qu'un élément de la liste d'événements programmés puisse être exécuté.

        Ce mécanisme est similaire, mais pas identique à la commande at(1) sur certains systèmes Unix. Son désavantage majeur est qu'il ne peut pas lancer une commande au moment exactement spécifié. Son avantage principal est que, puisque sched est exécuté directement à partir du shell, il a accès aux variables shell et aux autres structures. Cela fournit un mécanisme de modification de son environnement de travail en fonction de l'heure de la journée. 

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

            > alias cwdcmd 'echo -n "^[]2;${HOST}:$cwd ^G"' 

        alors le shell modifiera le titre de la xterm(1) en cours d'exécution pour qu'il soit celui du nom de l'hôte, un signe deux-points, et le répertoire de travail courant complet. Une manière plus imaginative de faire cela est

            > alias cwdcmd 'echo -n "^[]2;${HOST}:$cwd^G^[]1;${HOST}^G"' 

        Cela placera le nom de l'hôte et le répertoire de travail sur la barre de titre, mais uniquement le nom de l'hôte dans le menu du gestionnaire d'icônes.

        Notez que le placement d'un cd, pushd ou popd dans cwdcmd peut provoquer une boucle infinie. L'auteur pense que celui qui fait cela n'aura que ce qu'il mérite. 

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

            > alias jobcmd 'echo -n "^[]2\;\!#^G"' 

        l'exécution de vi foo.c placera la chaîne de commande dans la barre de titre de la xterm. 

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

            > alias helpcommand '\!:1 --help' 

        alors l'affichage d'aide de la commande elle-même sera invoqué, en utilisant la convention d'appel d'aide GNU. Actuellement, il n'y a pas de manière facile de traiter les différentes conventions d'appel (p.ex. le « -h » coutumier de Unix), sauf en utilisant une table comportant beaucoup de commandes. 

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

            > set tperiod = 30
            > alias periodic checknews 

        alors le programme checknews(1) se lancera toutes les 30 minutes. Si periodic est définie mais que tperiod ne l'est pas ou vaut 0, periodic se comporte comme precmd. 

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

            > alias precmd date 

        alors date(1) s'exécutera juste avant que le shell ne fournisse l'invite de commandes. Il n'y a pas de limites sur ce que peut valoir precmd, mais il faudrait agir avec discernement. 

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

            > alias postcmd 'echo -n "^[]2\;\!#^G"' 

        Ensuite, l'exécution de vi foo.c placera la chaîne de commande dans la barre de titre de la xterm. 

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 :

            echo `pwd` $argv > ~/._pause; % 

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 :

            > set dspmbyte = 0000....(256 bytes)....0000 

        La table requiert seulement 256 octets. Chacun des 256 caractères correspond (de gauche à droite) aux codes ASCII 0x00, 0x01 ... 0xff. Chaque caractère est fixé au nombre 0, 1, 2 ou 3. Les nombres possèdent les significations suivantes :

          0 ... pas utilisé pour les caractères multi-octets.

          1 ... utilisé pour le premier octet d'un caractère multi-octets.

          2 ... utilisé pour le deuxième octet d'un caractère multi-octets.

          3 ... utilisé à la fois pour le premier et le second octet d'un caractère multi-octets.


          Exemple:
        Si elle vaut « 001322 », le premier caractère (c.-à-d. le 0x00 du code ASCII) et le deuxième caractère (c.-à-d. le 0x01 du code ASCII) sont fixés à « 0 ». Ensuite, elle n'est pas utilisée par les caractères multi-octets. Le 3ème caractère (0x02) est fixé à « 2 », pour indiquer qu'il est utilisé comme premier octet d'un caractère multi-octets. Le 4ème caractère (0x03) est fixé à « 3 ». Il est utilisé à la fois pour le premier et le deuxième octet d'un caractère multi-octets. Les 5ème et 6ème caractères (0x04, 0x05) sont fixés à « 2 », pour indiquer qu'ils sont utilisés pour le deuxième octet d'un caractère multi-octets.

        La version GNU fileutils de ls ne peut pas afficher des noms de fichiers multi-octets sans l'option -N ( --literal ). Si vous utilisez cette version, fixez le second mot de dspmbyte à « ls ». Sinon, par exemple, « ls-F -l » ne pourra pas afficher les noms de fichiers multi-octets.


          Note:
        Cette variable ne peut être utilisée que si KANJI ou DSPMBYTE a été définie au moment de la compilation. 

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 

    bsd
        Ne pas produire en écho un saut de ligne si le premier argument est « -n ». 
    sysv
        Reconnaître les séquences d'échappement backslashées dans les chaînes de caractères d'écho. 
    both
        Reconnaître à la fois le drapeau « -n » et les séquences d'échappement backslashées ; comportement par défaut. 
    none
        Ne reconnaître aucun des deux. 

    Fixée par défaut au style par défaut du système local. Les options BSD et System V sont décrites dans les pages de manuel de echo(1) sur les systèmes concernés. 

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 « / » (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. 

    Si vous êtes dans un shell de connexion, alors aucun fichier de mail n'est rapporté à moins qu'il n'ait été modifié après le moment du démarrage du shell, afin d'éviter des notifications redondantes. La plupart des programmes de connexion vous disent si vous avez reçu ou pas de nouveaux emails quand vous vous connectez.

    Si un fichier spécifié dans mail est un répertoire, le shell comptera chaque fichier de ce répertoire comme un message séparé, et rapportera « You have n mails. » ou « You have n mails in nom. » (vous avez n emails (dans)) adéquatement. Cette fonctionnalité est fournie pour les systèmes qui stockent les mails de cette manière, comme le Andrew Mail System.

    Si le premier mot de mail est numérique, il est employé comme intervalle de vérification des mails, en secondes.

    Dans de très rares circonstances, le shell peut rapporter « You have mail. » au lieu de « You have new mail.' 

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 : 

    %/
        Le répertoire de travail courant. 
    %~
        Le répertoire de travail courant, mais où le répertoire personnel de l'utilisateur est représenté par « ~ » et les répertoires personnels des autres utilisateurs sont représentés par « ~utilisateur » comme dans la Substitution des noms de fichiers. La substitution « ~utilisateur » ne se produit que si le shell a déjà utilisé « ~utilisateur » dans un nom de chemin dans la session courante. 
    %c[[0]n], %.[[0]n]
        Le composant de queue du répertoire de travail courant, ou n composants de queue si un chiffre n est donné. Si n commence par « 0 », le nombre de composants passés précède le ou les composants de queue dans le format « /en-queue ». Si la variable shell ellipsis est définie, les composants passés sont représentés par une ellipse afin que le tout devienne « ...en-queue ». La substitution « ~ » est effectuée comme dans « %~ » au-dessus, mais le composant « ~ » est ignoré lors du comptage de composants d'en-queue. 
    %C
        Comme %c, mais sans la substitution du « ~ ». 
    %h, %!, !
        Le numéro d'événement de l'historique courant. 
    %M
        Le nom d'hôte complet. 
    %m
        Le nom d'hôte jusqu'au premier « . ». 
    %S (%s)
        Démarrer (stopper) le mode saillant (standout). 
    %B (%b)
        Démarrer (stopper) le mode gras. 
    %U (%u)
        Démarrer(arrêter) le mode de soulignement. 
    %t, %@
        L'heure du jour dans le format 12-heures AM/PM. 
    %T
        Comme « %t », mais dans le format 24-heures (mais voyez la variable shell ampm). 
    %p
        L'heure « précise » dans le format 12-heures AM/PM, avec les secondes. 
    %P
        Comme « %p », mais dans le format 24-heures (mais voyez la variable shell ampm). 
    \c
        c est analysé comme pour bindkey. 
    ^c
        c est analysé comme pour bindkey. 
    %%
        Un unique « % ». 
    %n
        Le nom d'utilisateur. 
    %j
        Le nombre de travaux. 
    %d
        Le jour de la semaine dans le format « Jou ». 
    %D
        Le jour dans le format « dd ». 
    %w
        Le mois dans le format « Moi ». 
    %W
        Le mois dans le format « mm ». 
    %y
        L'année dans le format « aa ». 
    %Y
        L'année dans le format « aaaa ». 
    %l
        Le tty du shell. 
    %L
        Efface à partir de la fin de l'invite jusqu'à la fin de l'écran, ou la fin de la ligne. 
    %$
        Développe le nom de la variable shell ou d'environnement présente immédiatement après le « $ ». 
    %#
        « > » (ou le premier caractère de la variable shell promptchars) pour les utilisateurs normaux, « # » (ou le second caractère de promptchars) pour le super-utilisateur. 
    %{chaîne_caractères%}
        Inclut chaîne_caractères en tant que séquence d'échappement littérale. Cela devrait n'être utilisé que pour modifier les attributs du terminal et ne devrait pas changer l'emplacement du curseur. Cela ne peut être la dernière séquence de prompt. 
    %?
        Le code de retour de la commande exécutée juste avant l'invite. 
    %R
        Dans prompt2, le statut de l'analyseur syntaxique. Dans prompt3, la chaîne de caractères corrigée. Dans history, la chaîne de caractères d'historique. 

    « %B », « %S », « %U » et « %{chaîne_caractères%} » ne sont disponibles que dans les shells supportant les caractères 8 bits ; voyez la variable shell version.

    Les séquences de gras, saillant et de soulignement sont souvent utilisées pour différencier un shell de super-utilisateur. Par exemple,

        > set prompt = "%m [%h] %B[%@]%b [%/] you rang? "
        tut [37] [2:54pm] [/usr/accts/sys] you rang? _ 

    Si « %t », « %@ », « %T », « %p » ou « %P » est utilisé, et que noding n'est pas définie, alors afficher « DING! » au moment du changement d'heure (c.-à-d. les minutes « :00 ») au lieu de l'heure courante.

    Fixée par défaut à « %#  » dans les shells interactifs. 

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 ») :

        Si elle vaut « chase », à chaque fois que l'on se déplace dans un répertoire contenant un lien symbolique, celui-ci est développé pour former le nom réel du répertoire pointé. Cela ne fonctionne pas pour le répertoire personnel de l'utilisateur ; c'est un bogue.

        Si elle vaut « ignore », le shell essaie de construire un répertoire courant relatif au répertoire courant avant que le lien n'ait été suivi. Cela signifie qu'effectuer un cd à travers un lien symbolique et ensuite un « cd .. » revient au répertoire original. Cela n'affecte que les commandes intégrées et le complètement des noms de fichiers.

        Si elle vaut « expand », le shell essaie d'arranger les liens symboliques en développant en réalité les arguments qui ressemblent à des noms de chemins. Cela affecte toutes les commandes, et pas uniquement celles qui sont intégrées. Malheureusement, cela ne fonctionne pas pour les noms de fichiers difficiles à reconnaître, comme ceux qui sont encastrés dans les options de commande. Le développement peut être évité avec le mécanisme de protection. Bien que ce réglage soit habituellement le plus pratique, il induit parfois en erreur et est déroutant quand il n'arrive pas à reconnaître un argument qui devrait être développé. Un compromis est d'utiliser « ignore » et de n'utiliser la commande d'éditeur normalize-path (liée par défaut à ^X-n) que lorsque c'est nécessaire.

        Quelques exemples dans l'ordre. En premier lieu, créons quelques répertoires pour jouer :

            > cd /tmp
            > mkdir from from/src to
            > ln -s from/src to/dest 

        Voici le comportement avec symlinks non définie,

            > cd /tmp/to/dest; echo $cwd
            /tmp/to/dest
            > cd ..; echo $cwd
            /tmp/from 

        voici le comportement avec symlinks fixée à « chase »,

            > cd /tmp/to/dest; echo $cwd
            /tmp/from/src
            > cd ..; echo $cwd
            /tmp/from 

        voici le comportement avec symlinks fixée à « ignore »,

            > cd /tmp/to/dest; echo $cwd
            /tmp/to/dest
            > cd ..; echo $cwd
            /tmp/to 

        et voici le comportement avec symlinks fixée à « expand ».

            > cd /tmp/to/dest; echo $cwd
            /tmp/to/dest
            > cd ..; echo $cwd
            /tmp/to
            > cd /tmp/to/dest; echo $cwd
            /tmp/to/dest
            > cd ".."; echo $cwd
            /tmp/from
            > /bin/echo ..
            /tmp/to
            > /bin/echo ".."
            .. 

        Notez que le développement « expand » 1) fonctionne exactement comme « ignore » pour les commandes intégrées comme cd, 2) est évité par la protection, et 3) se produit avant que les noms de fichiers ne soient passés à des commandes non intégrées. 

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 : 

    %U
        Le temps que le processus a passé dans le mode utilisateur en secondes cpu. 
    %S
        Le temps que le processus a passé dans le mode kernel (noyau) en secondes cpu. 
    %E
        Le temps (total) écoulé en secondes. 
    %P
        Le pourcentage d'utilisation CPU calculé par (%U + %S) / %E. 
    %W
        Le nombre de fois que le processus a été swappé (placé en mémoire d'échange). 
    %X
        La quantité moyenne d'espace texte (partagé) utilisée en Ko. 
    %D
        La quantité moyenne d'espace de données/pile (non partagé) utilisée en Ko. 
    %K
        L'espace total utilisé (%X + %D) en Ko. 
    %M
        La mémoire maximum dont le processus ait jamais disposé en Ko. 
    %F
        Le nombre de défauts de page majeurs (page devant être rechargée depuis le disque). 
    %R
        Le nombre de défauts de page mineurs. 
    %I
        Le nombre d'opérations d'entrée. 
    %O
        Le nombre d'opérations de sortie. 
    %r
        Le nombre de messages reçus sur une socket. 
    %s
        Le nombre de messages envoyés sur une socket. 
    %k
        Le nombre de signaux reçus. 
    %w
        Le nombre de commutations de contexte volontaires (attentes). 
    %c
        Le nombre de commutations de contexte involontaires. 

    Seules les quatre premières séquences sont supportées sur les systèmes ne disposant pas des fonctions de limitation de ressources BSD. Le format d'heure par défaut est « %Uu %Ss %E %P %X+%Dk %I+%Oio %Fpf+%Ww » pour les systèmes qui supportent les rapports d'utilisation des ressources et « %Uu %Ss %E %P » pour les systèmes qui n'en disposent pas.

    Sous Sequent DYNIX/ptx, %X, %D, %K, %r et %s ne sont pas disponibles, mais les séquences additionnelles suivantes le sont :

    %Y
        Le nombre d'appels système effectués. 
    %Z
        Le nombre de pages qui sont remplies de zéros à la demande. 
    %i
        Le nombre de fois que la quantité de mémoire résidente (resident set size) utilisée par un processus a été augmentée par le noyau. 
    %d
        Le nombre de fois que la quantité de mémoire résidente utilisée par un processus a été diminuée par le noyau. 
    %l
        Le nombre d'appels système de lecture effectués. 
    %m
        Le nombre d'appels système d'écriture effectués. 
    %p
        Le nombre de lectures à partir de périphériques disques bruts. 
    %q
        Le nombre d'écritures sur des périphériques disques bruts. 

    et le format d'heure par défaut est « %Uu %Ss $E %P %I+%Oio %Fpf+%Ww ». Notez que le pourcentage d'occupation CPU peut être plus haut que 100% sur les systèmes multi-processeurs. 

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. 

    8b
        Le shell supporte les caractères 8 bits ; par défaut 
    7b
        Le shell ne supporte pas les caractères 8 bits 
    nls
        Le NLS du système est utilisé ; défaut pour les systèmes comportant le NLS 
    lf
        Les shells de connexion exécutent /etc/csh.login avant plutôt qu'après /etc/csh.cshrc et ~/.login avant plutôt qu'après ~/.tcshrc et ~/.history. 
    dl
        « . » est placé en dernier lieu dans le path par sécurité ; par défaut 
    nd
        « . » est omis du path par sécurité 
    vi
        l'édition de style vi est le comportement par défaut plutôt que le style d'emacs 
    dtr
        Les shells de connexion ignorent le DTR quand ils se terminent 
    bye
        bye est un synonyme de logout et log est un nom alternatif pour watchlog 
    al
        autologout est activé ; par défaut 
    kan
        Kanji est utilisé si c'est approprié en fonction des réglages de localisation, à moins que la variable shell nokanji ne soit définie 
    sm
        Le malloc(3) du système est utilisé 
    hb
        La convention « #!  » est émulée lors de l'exécution de scripts shell 
    ng
        La commande intégrée newgrp est disponible 
    rh
        Le shell essaie de définir la variable d'environnement REMOTEHOST 
    afs
        Le shell vérifie votre mot de passe via le serveur kerberos si l'authentification locale échoue. La variable shell afsuser ou la variable d'environnement AFSUSER surcharge votre nom d'utilisateur local si elle est définie. 

    Un administrateur peut insérer des chaînes de caractères additionnelles pour indiquer les différences dans la version locale. 

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,

            set watch = (george ttyd1 any console $user any) 

        rapporte l'activité de l'utilisateur « george » sur ttyd1, n'importe quel utilisateur sur la console, et soi-même (ou un intrus) sur n'importe quel terminal.

        Les connexions et déconnexions sont vérifiées toutes les 10 minutes par défaut, mais le premier mot de watch peut être un nombre qui indique le nombre de minutes entre chaque vérification. Par exemple,

            set watch = (1 any any) 

        rapporte chaque connexion/déconnexion une fois par minute. Pour les impatients, la commande intégrée log déclenche un rapport watch à n'importe quel moment. Toutes les connexions actuelles sont rapportées (comme pour la commande intégrée log) quand watch est définie pour la première fois.

        La variable shell who contrôle le format des rapports watch. 

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

    %n
        Le nom de l'utilisateur qui s'est connecté/déconnecté. 
    %a
        L'action observée, p.ex. « logged on » (connecté), « logged off » (déconnecté) ou « replaced ancien-utilisateur on » (remplacé ancien-utilisateur). 
    %l
        Le terminal (tty) sur lequel l'utilisateur s'est connecté/déconnecté. 
    %M
        Le nom d'hôte complet de l'hôte distant, ou « local » si la connexion/déconnexion s'est faite sur l'hôte local. 
    %m
        Le nom d'hôte de l'hôte distant jusqu'au premier « . ». Le nom complet est affiché si c'est une adresse IP ou un affichage du système X Window System. 

    %M et %m ne sont disponibles que sur les systèmes qui stockent le nom d'hôte distant dans /etc/utmp. Si elle n'est pas définie, « %n has %a %l from %m. » est utilisé, ou « %n has %a %l. » sur les systèmes qui ne stockent pas le nom d'hôte distant. 

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

 
ENVIRONNEMENT

AFSUSER (+)
    Équivalent à la variable shell afsuser. 
COLUMNS
    Le nombre de colonnes du terminal. Voyez Gestion des terminaux. 
DISPLAY
    Utilisé par le Système X Window (voyez X(1)). Si elle est définie, le shell ne définit pas autologout. 
EDITOR
    Le nom du chemin vers un éditeur par défaut. Voyez également la variable d'environnement VISUAL et la commande d'éditeur run-fg-editor. 
GROUP (+)
    Équivalent à la variable shell group. 
HOME
    Équivalent à la variable shell home. 
HOST (+)
    Initialisé au nom de la machine sur laquelle le shell est lancé, déterminé par l'appel système gethostname(2). 
HOSTTYPE (+)
    Initialisé au type de machine sur laquelle le shell est lancé, déterminé au moment de la compilation. Cette variable est obsolète est sera supprimée dans une version future. 
HPATH (+)
    Une liste de répertoires séparés par des « : » dans laquelle la commande d'éditeur run-help recherche la documentation sur les commandes. 
LANG
    Fournit l'environnement de caractères préféré. Voyez Support Système de la Langue Native. 
LC_CTYPE
    Si définie, seul le traitement des caractères ctype est modifié. Voyez Support Système de la Langue Native. 
LINES
    Le nombre de lignes du terminal. Voyez Gestion des terminaux. 
LS_COLORS
    Le format de cette variable fait penser au format du fichier termcap(5) ; une liste d'expressions séparées par des deux-points de la forme « xx=chaîne_car », où « xx » est un nom de variable de deux caractères. Les variables avec leurs valeurs par défaut associées sont : 

        no 0
            Texte normal (non nom de fichier) 
        fi 0
            Fichier régulier 
        di 01;34
            Répertoire 
        ln 01;36
            Lien symbolique 
        pi 33
            Tube nommé (FIFO) 
        so 01;35
            Socket 
        do      01;35
            Door (NdT : ?)
        bd 01;33
            Périphérique en mode bloc 
        cd 01;32
            Périphérique en mode caractère 
        ex 01;32
            Fichier exécutable 
        mi (aucune)
            Fichier manquant (vaut fi par défaut) 
        or (aucune)
            Lien symbolique orphelin (vaut ln par défaut) 
        lc ^[[
            Code gauche 
        rc m
            Code droit 
        ec (aucune)
            Code de fin (remplace lc+no+rc) 

    Vous ne devez inclure que les variables dont vous voulez modifier la valeur par rapport à celle donnée par défaut.

    Les noms de fichiers peuvent également être colorés en fonction de l'extension du nom de fichier. Cela est spécifié dans la variable LS_COLORS en utilisant la syntaxe « *ext=chaîne_car ». Par exemple, en utilisant les codes ISO 6429, pour colorer tous les fichiers sources C en bleu, vous devriez spécifier « *.c=34 ». Cela mettra en couleur tous les fichiers se terminant par .c dans la couleur bleue (34).

    Les caractères de contrôle peuvent être écrits soit dans la notation d'échappement de style C, soit dans la notation ^ du style de stty. La notation du style C ajoute ^[ pour Escape, _ pour un caractère espace blanche normal, et ? pour Delete. De plus, le caractère d'échappement ^[ peut être utilisé pour surcharger l'interprétation par défaut de ^[, ^, : et =.

    Chaque fichier sera écrit sous la forme     . Si le code  n'est pas défini, la séquence    sera utilisée à la place. C'est généralement plus commode à utiliser, mais moins général. Les codes gauche, droite et fin sont fournis afin que vous n'ayez pas à taper à maintes reprises les parties communes et pour supporter les terminaux exotiques ; vous n'avez généralement pas besoin de les changer à moins que votre terminal n'utilise pas les séquences de couleur ISO 6429 mais un système différent.

    Si votre terminal n'utilise pas les codes de couleur ISO 6429, vous pouvez composer les codes de caractères (c.-à-d. tous sauf les codes lc, rc et ec) à partir des commandes numériques séparées par des points-virgules. Les commandes les plus courantes sont :

        0
            pour restaurer la couleur par défaut 
        1
            pour des couleurs plus claires 
        4
            pour du texte souligné 
        5
            pour du texte clignotant 
        30
            pour un avant-plan noir 
        31
            pour un avant-plan rouge 
        32
            pour un avant-plan vert 
        33
            pour un avant-plan jaune (ou brun) 
        34
            pour un avant-plan bleu 
        35
            pour un avant-plan violet 
        36
            pour un avant-plan cyan 
        37
            pour un avant-plan blanc (ou gris) 
        40
            pour un arrière-plan blanc 
        41
            pour un arrière-plan rouge 
        42
            pour un arrière-plan vert 
        43
            pour un arrière-plan jaune (ou brun) 
        44
            pour un arrière-plan bleu 
        45
            pour un arrière-plan violet 
        46
            pour un arrière-plan cyan 
        47
            pour un arrière-plan blanc (ou gris) 

    Les commandes ne fonctionneront pas toutes sur tous les systèmes et périphériques d'affichage.

    Quelques programmes de terminaux ne reconnaissent pas correctement le code de fin par défaut. Si tout le texte est coloré après que vous ayez fait un listage de répertoire, essayez de remplacer les codes de no et fi de 0 par les codes numériques de vos couleurs standard d'avant- ou d'arrière-plan. 

MACHTYPE (+)
    Le type de machine (classe de microprocesseurs ou modèle de machine), comme déterminé au moment de la compilation. 
NOREBIND (+)
    Si définie, les caractères imprimables ne sont pas re-liés à self-insert-command. Voyez Support Système de la Langue Native. 
OSTYPE (+)
    Le système d'exploitation, déterminé au moment de la compilation. 
PATH
    Une liste de répertoires séparés par des deux-points dans lesquels rechercher les exécutables. Équivalent à la variable shell path, mais dans un format différent. 
PWD (+)
    Équivalent à la variable shell cwd, mais pas synchronisé avec elle ; mis à jour uniquement après un changement de répertoire réel. 
REMOTEHOST (+)
    L'hôte à partir duquel l'utilisateur s'est connecté à distance, si c'est le cas et si le shell a été capable de le déterminer. Définie uniquement si le shell a été compilé de cette façon ; voyez la variable shell version. 
SHLVL (+)
    Équivalent à la variable shell shlvl. 
SYSTYPE (+)
    Le type de système courant. (Domain/OS uniquement) 
TERM
    Équivalent à la variable shell term. 
TERMCAP
    La chaîne de caractères de capacité du terminal. Voyez Gestion des terminaux. 
USER
    Équivalent à la variable shell user. 
VENDOR (+)
    Le vendeur, déterminé au moment de la compilation. 
VISUAL
    Le nom du chemin de l'éditeur plein écran par défaut. Voyez également la variable d'environnement EDITOR et la commande d'éditeur run-fg-editor. 

 
FICHIERS

/etc/csh.cshrc
    Lu en premier lieu par chaque shell. ConvexOS, Stellix et Intel utilisent /etc/cshrc et les NeXT utilisent /etc/cshrc.std. A/UX, AMIX, Cray et IRIX n'ont pas d'équivalent dans csh(1), mais lisent ce fichier de toute façon dans tcsh. Solaris 2.x ne l'a pas non plus, mais tcsh lit /etc/.logout. (+) 
/etc/csh.login
    Lu par les shells de connexion après /etc/csh.cshrc. ConvexOS, Stellix et Intel utilisent /etc/login, les NeXT utilisent /etc/login.std, Solaris 2.x utilise /etc/.login et A/UX, AMIX, Cray et IRIX utilisent /etc/cshrc. 
~/.tcshrc (+)
    Lu par chaque shell après /etc/csh.cshrc ou son équivalent. 
~/.cshrc
    Lu par chaque shell, si ~/.tcshrc n'existe pas, après /etc/csh.cshrc ou son équivalent. Ce manuel utilise « ~/.tcshrc » pour « ~/.tcshrc » ou, si ~/.tcshrc n'a pas été trouvé, « /.cshrc ». 
~/.history
    Lu par les shells de connexion après ~/.tcshrc si savehist est définie, mais voyez également histfile. 
~/.login
    Lu par les shells de connexion après ~/.tcshrc ou ~/.history. Le shell peut être compilé afin de lire ~/.login avant plutôt qu'après ~/.tcshrc et ~/.history ; voyez la variable shell version. 
~/.cshdirs (+)
    Lu par les shells de connexion après ~/.login si savedirs est définie, mais voyez également dirsfile. 
/etc/csh.logout
    Lu par les shells de connexion lors de la déconnexion. ConvexOS, Stellix et Intel utilisent /etc/logout, et les NeXTs utilisent /etc/logout.std. A/UX, AMIX, Cray et IRIX n'ont pas d'équivalent dans csh(1), mais lisent de toute façon ce fichier dans tcsh. Solaris 2.x ne l'a pas non plus, mais tcsh lit /etc/.logout. (+) 
~/.logout
    Lu par les shells de connexion à la déconnexion après /etc/csh.logout ou son équivalent. 
/bin/sh
    Utilisé pour interpréter les scripts shell ne débutant pas par un « # ». 
/tmp/sh*
    Fichier temporaire pour « << ». 
/etc/passwd
    Source des répertoires personnels pour les substitutions « ~nom ». 

L'ordre dans lequel les fichiers de démarrage sont lus peut être différent si le shell a été compilé de cette façon ; voyez Démarrage et arrêt et la variable shell version.  
NOUVELLES FONCTIONNALITÉS (+)
Ce manuel décrit tcsh comme une entité unique, mais les utilisateurs expérimentés de csh(1) devraient porter une attention spéciale aux nouvelles fonctionnalités de tcsh.

Un éditeur de ligne de commandes, qui supporte les liaisons de touche de style GNU Emacs ou vi(1). Voyez L'éditeur de ligne de commandes et Commandes d'éditeur.

Un complètement et un listage des mots programmables et interactifs. Voyez Complètement et listage et les commandes intégrées complete et uncomplete.

La Correction orthographique des noms de fichiers, commandes et variables.

Les Commandes d'éditeur qui effectuent d'autres fonctions utiles au sein des commandes tapées, incluant une recherche de documentation (run-help), un redémarrage rapide de l'éditeur (run-fg-editor) et une résolution de commandes (which-command).

Un mécanisme d'historique amélioré. Les événements présents dans la liste d'historique sont horodatés. Voyez également la commande history et ses variables shell associées, le spécificateur d'événement auparavant non documenté « # » et les nouveaux modificateurs dans Substitution d'historique, les commandes d'éditeur *-history, history-search-*, i-search-*, vi-search-* et toggle-literal-history et la variable shell histlit.

Une analyse des répertoires et une gestion des piles de répertoires améliorées. Voyez les commandes cd, pushd, popd et dirs et leurs variables shell associées, la description de Substitution de pile de répertoires, les variables shell dirstack, owd et symlinks et les commandes d'éditeur normalize-command et normalize-path.

La négation dans les motifs génériques. Voyez Substitution des noms de fichiers.

De nouveaux Opérateurs de tests de fichiers et une commande intégrée filetest qui les utilise.

Certains Événements automatiques, périodiques et minutés incluant les événements programmés, les alias spéciaux, la déconnexion automatique et le verrouillage du terminal, la minuterie des commandes et la surveillance des connexions et déconnexions.

La prise en charge du NLS (voyez Support Système de la Langue Native), des fonctionnalités dépendantes du SE (voyez Support des variantes de Systèmes d'Exploitation et la variable shell echo_style), et les emplacements des fichiers dépendants du système (voyez FICHIERS).

Des capacités étendues de gestion des terminaux. Voyez Gestion des terminaux.

De nouvelles commandes intégrées incluant builtins, hup, ls-F, newgrp, printenv, which et where.

De nouvelles variables qui facilitent l'accès aux informations utiles depuis le shell. Voyez les variables shell gid, loginsh, oid, shlvl, tcsh, tty, uid et version et les variables d'environnement HOST, REMOTEHOST, VENDOR, OSTYPE et MACHTYPE.

Une nouvelle syntaxe pour l'inclusion d'informations utiles dans la chaîne de caractères d'invite (voyez prompt), et des invites spéciales pour les boucles et la correction orthographique (voyez prompt2 et prompt3).

Des variables accessibles en lecture seule. Voyez Substitution de variables.

 
BOGUES
Quand une commande suspendue est redémarrée, le shell affiche le répertoire dans lequel il l'a démarrée s'il est différent du répertoire courant. Cela peut induire en erreur (c.-à-d. être faux) puisque le travail peut avoir changé de répertoires en interne.

Les fonctions intégrées du shell ne sont pas arrêtables/redémarrables. Les séquences de commandes de la forme « a ; b ; c » ne sont pas non plus traitées gracieusement quand on essaie de les stopper. Si vous suspendez « b », le shell exécutera alors immédiatement « c ». Ceci est particulièrement perceptible si ce développement résulte d'un alias. Il suffit de placer la séquence de commandes dans des () pour les forcer à s'exécuter dans un sous-shell, p.ex. « ( a ; b ; c ) ».

Le contrôle sur la sortie du tty après que les processus aient été démarrés est primitif ; peut-être cela inspirera-t-il quelqu'un à écrire une bonne interface de terminal virtuel. Dans une interface de terminal virtuel, des choses nettement plus intéressantes pourraient être effectuées avec le contrôle de sortie.

La substitution d'alias est la plupart du temps utilisée pour simuler maladroitement des procédures shell ; des procédures shell devraient être fournies plutôt que des alias.

Les commandes présentes à l'intérieur de boucles ne sont pas placées dans la liste d'historique. Les structures de contrôle devraient être analysées plutôt que d'être reconnues comme des commandes intégrées. Cela permettrait aux commandes de contrôle d'être placées n'importe où, d'être combinées avec « | », et d'être utilisées avec la métasyntaxe « & » et « ; ».

foreach n'ignore pas les documents en ligne (here documents) quand elle recherche son end.

Il devrait être possible d'utiliser les modificateurs « : » sur la sortie des substitutions de commandes.

La mise à jour de l'écran pour des lignes plus grandes que la largeur de l'écran est très médiocre si le terminal ne peut déplacer le curseur vers le haut (c.-à-d. le type de terminal « dumb » (stupide)).

HPATH et NOREBIND ne doivent pas nécessairement être des variables d'environnement.

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

La forme en une seule commande de if effectue la redirection de sortie même si l'expression est fausse et que la commande n'est pas exécutée.

ls-F inclut les caractères d'identifications de fichiers lors du tri des noms de fichiers et ne traite pas bien les caractères de contrôle dans les noms de fichiers. Il ne peut être interrompu.

Rapportez les bogues à tcsh-bugs@mx.gw.com, de préférence avec des corrections. Si vous voulez aider à maintenir et à tester tcsh, envoyez un mail à listserv@mx.gw.com avec le texte « subscribe tcsh  » sur une ligne contenue dans le corps du mail. Vous pouvez également faire un « subscribe tcsh-bugs  » pour obtenir tous les rapports de bogues, ou un « subscribe tcsh-diffs  » pour obtenir la liste de développement plus des diffs pour chaque niveau de patch.  
LE T DANS TCSH
En 1964, DEC produisait le PDP-6. Le PDP-10 était une réimplémentation postérieure. Il a été rebaptisé en DECsystem-10 en 1970 (à peu près) quand DEC mit sur le marché le second modèle, le KI10.

TENEX a été créé à Bolt, Beranek & Newman (un réservoir à idées de Cambridge, Massachussets) en 1972 comme une expérience sur les systèmes d'exploitation avec mémoire virtuelle paginée. Ils construisirent un nouveau paginateur pour le DEC PDP-10 et ont créé le SE pour aller avec. Il a eu beaucoup de succès dans le monde académique.

DEC sortit un nouveau modèle de PDP-10, le KL10 ; ils souhaitaient n'avoir qu'une version de TENEX pour la nouvelle machine, dont ils avaient acquis la licence auprès de BBN. Ils appelèrent leur version TOPS-20 (la mise en majuscule est une marque de fabrique). Un tas d'utilisateurs du TOPS-10 (« The OPerating System for PDP-10 ») se sont plaints ; ainsi, DEC dut supporter deux systèmes incompatibles sur le même matériel, mais ensuite il y en eut 6 sur le PDP-11 !

TENEX, et TOPS-20 jusqu'à la version 3, possédait le complètement de commandes via une sous-routine de bibliothèque de code de niveau utilisateur appelée ULTCMD. Avec la version 3, DEC déplaça cette capacité et plus encore dans le moniteur (« noyau » pour vous, les Unixiens), accessible via l'instruction COMND% JSYS (instruction « Jump to SYStem », le mécanisme d'appel au superviseur [sont-ce mes racines IBM qui se dévoilent ? ]).

Le créateur de tcsh a été impressionné par cette fonctionnalité et par beaucoup d'autres du TENEX et du TOPS-20, et a créé une version du csh qui les imitait.

 
LIMITATIONS
Les mots ne peuvent être plus longs que 1024 caractère.

Le système limite les liste d'arguments à 10240 caractères.

Le nombre d'arguments d'une commande qui implique un développement de noms de fichier est limité à 1/6-ème du nombre de caractères permis dans la liste d'arguments.

Les substitutions de commandes ne peuvent substituer plus de caractères que ce qui est permis dans la liste d'arguments.

Pour détecter les bouclages, le shell restreint le nombre de substitutions d'alias sur une seule ligne à 20.  
VOYEZ AUSSI
csh(1), emacs(1), ls(1), newgrp(1), sh(1), setpath(1), stty(1), su(1), tset(1), vi(1), x(1), access(2), execve(2), fork(2), killpg(2), pipe(2), setrlimit(2), sigvec(2), stat(2), umask(2), vfork(2), wait(2), malloc(3), setlocale(3), tty(4), a.out(5), termcap(5), environ(7), termio(7), Introduction to the C Shell  
VERSION
Ce manuel documente tcsh version 6.12.00 (Astron) du 23/07/2002.  
AUTEURS

William Joy
    Auteur original de csh(1) 
J.E. Kulp, IIASA, Laxenburg, Austria
    Contrôle des travaux et fonctionnalités de piles de répertoires 
Ken Greer, HP Labs, 1981
    Complètement des noms de fichiers 
Mike Ellis, Fairchild, 1983
    Reconnaissance/complètement des noms de commandes 
Paul Placeway, Ohio State CIS Dept., 1983-1993
    Éditeur de ligne de commandes, routines d'invite, une nouvelle syntaxe pour les motifs génériques et de nombreuses corrections et accélérations 
Karl Kleinpaste, CCI 1983-4
    Alias spéciaux, matériaux d'extraction de pile de répertoires, surveillance des connexions/déconnexions, événements programmés, et l'idée d'un nouveau format d'invite 
Rayan Zachariassen, Université de Toronto, 1984
    Les commandes intégrées ls-F et which et de nombreuses corrections de bogues, modifications et accélérations 
Chris Kingsley, Caltech
    Routines d'allocateur de mémoire rapide 
Chris Grevstad, TRW, 1987
    A incorporé le csh BSD 4.3 dans tcsh 
Christos S. Zoulas, Cornell U. EE Dept., 1987-94
    Des portages sur HPUX, SVR2 et SVR3, une version SysV de getwd.c, support de SHORT_STRINGS et une nouvelle version de sh.glob.c 
James J Dempsey, BBN, and Paul Placeway, OSU, 1988
    Portage sur A/UX 
Daniel Long, NNSC, 1988
    wordchars 
Patrick Wolfe, Kuck and Associates, Inc., 1988
    Nettoyage du mode vi 
David C Lawrence, Rensselaer Polytechnic Institute, 1989
    autolist et listage des complètements ambigus 
Alec Wolman, DEC, 1989
    Les sauts de ligne dans l'invite 
Matt Landau, BBN, 1989
    ~/.tcshrc 
Ray Moody, Purdue Physics, 1989
    Développement de l'historique magique via la barre d'espacement 
Mordechai ????, Intel, 1989
    Corrections à printprompt() et ajouts 
Kazuhiro Honda, Dept. of Computer Science, Keio University, 1989
    Correction orthographique automatique et prompt3 
Per Hedeland, Ellemtel, Sweden, 1990
    De nombreuses corrections de bogues, améliorations et mises à jour du manuel 
Hans J. Albertsson (Sun Sweden)
    ampm, settc et telltc 
Michael Bloom
    Corrections dans le traitement des interruptions 
Michael Fine, Digital Equipment Corp
    Support des touches étendues 
Eric Schnoebelen, Convex, 1990
    Support de Convex, de nombreuses corrections de bogues présents dans csh, sauvegarde et restauration de la pile de répertoires 
Ron Flax, Apple, 1990
    (re)portage sur A/UX 2.0 
Dan Oscarsson, LTH Sweden, 1990
    Support du NLS et support du NLS simulé pour les sites ne prenant pas en charge le NLS, corrections 
Johan Widen, SICS Sweden, 1990
    shlvl, support Mach, correct-line, affichage 8 bits 
Matt Day, Sanyo Icon, 1990
    Support du termio POSIX, corrections de limites SysV 
Jaap Vermeulen, Sequent, 1990-91
    Corrections du mode vi, expand-line, correction de changements de fenêtre, portage sur Symmetry 
Martin Boyer, Institut de recherche d'Hydro-Québec, 1991
    Options de sonnerie autolist, a modifié la recherche d'historique pour rechercher la chaîne de caractères entière du début de la ligne jusqu'au curseur. 
Scott Krotz, Motorola, 1991
    Portage Minix 
David Dawes, Sydney U. Australia, Physics Dept., 1991
    Corrections de contrôle des travaux SVR4 
Jose Sousa, Interactive Systems Corp., 1991
    Corrections étendues à vi et commande d'effacement dans vi 
Marc Horowitz, MIT, 1991
    Corrections d'ANSIfication, un nouveau code de hachage pour les exécutables, corrections à imake, where 
Bruce Sterling Woodcock, sterling@netcom.com, 1991-1995
    Portage ETA et Pyramid, corrections au Makefile et à lint, ajout de ignoreeof=n, et diverses autres modifications pour la portabilité et corrections de bogues. 
Jeff Fink, 1992
    complete-word-fwd et complete-word-back 
Harry C. Pulley, 1992
    Portage sur Coherent 
Andy Phillips, Mullard Space Science Lab U.K., 1992
    Portage sur VMS-POSIX 
Beto Appleton, IBM Corp., 1992
    Corrections pour les groupes de processus, correction de bogues de csh, tests de fichiers POSIX, SIGHUP POSIX 
Scott Bolte, Cray Computer Corp., 1992
    Portage sur CSOS 
Kaveh R. Ghazi, Rutgers University, 1992
    Portage et corrections sur Tek, m88k, Titan et Masscomp. Ajouta le support pour autoconf. 
Mark Linderman, Cornell University, 1992
    Portage OS/2 
Mika Liljeberg, liljeber@kruuna.Helsinki.FI, 1992
    Portage Linux 
Tim P. Starrin, NASA Langley Research Center Operations, 1993
    Variables accessibles en lecture seule 
Dave Schweisguth, Yale University, 1993-4
    Nouvelle page de manuel et tcsh.man2html 
Larry Schwimmer, Stanford University, 1993
    Patchs AFS et HESIOD 
Luke Mewburn, RMIT University, 1994-6
    Affichage des répertoires amélioré dans l'invite. Ajouta ellipsis et rprompt. 
Edward Hutchins, Silicon Graphics Inc., 1996
    Ajouta le cd implicite. 
Martin Kraemer, 1997
    Portage sur la machine Siemens Nixdorf EBCDIC 
Amol Deshpande, Microsoft, 1997
    Portage sur WIN32 (Windows/95 et Windows/NT) ; a écrit toutes les bibliothèques manquantes et le code de catalogue de messages pour l'interface avec Windows. 
Taga Nayuta, 1998
    Ajout de couleurs pour ls. 

 
REMERCIEMENTS À
Bryan Dunlap, Clayton Elwell, Karl Kleinpaste, Bob Manson, Steve Romig, Diana Smetters, Bob Sutterfield, Mark Verber, Elizabeth Zwicky et à toutes les autres personnes de l'État de l'Ohio pour leurs suggestions et leurs encouragements.

Tous les personnes sur le Net qui ont utilisé ce programme, rapporté des bogues et suggéré des améliorations à chaque nouvelle version.

Richard M. Alderson III, pour avoir écrit la section « T dans tcsh ».

TRADUCTION
Frédéric Delanoy <delanoy_f at yahoo.com>, 2003.

http://www.delafond.org/traducmanfr/man/man1/tcsh.1.html
http://manpages.ubuntu.com/manpages/maverick/en/man1/tcsh.1.html