Se connecter
Inscription
Mot de passe perdu
zion - tcshNom
tcsh - shell C avec complètement des noms de fichiers et édition de lignes de commandes
Résumé
tcsh [-bcdefFimnqstvVxX] [-Dnom[=valeur]] [arg ...] tcsh -l
Description
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 darguments
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 (« ») et continuer sur une autre ligne. |
-v
| Définit la variable shell verbose, afin que l'entrée de la commande soit renvoyée en écho après la substitution d'historique. |
-x
| Définit la variable shell echo, afin que les commandes soient renvoyées en écho juste avant leur exécution. |
-V
| Définit la variable shell verbose avant même d'exécuter ~/.tcshrc. |
-X
| Est à -x ce que -V est à -v. |
Après le traitement des arguments options, s'il reste des arguments mais qu'aucune des options -c, -i, -s ou -t n'est fournie, le premier argument est supposé être le nom d'un fichier de commandes, c.-à-d. le « script » à exécuter. Le shell ouvre ce fichier et sauvegarde son nom pour une éventuelle re-substitution pour « $0 ». Puisque de nombreux systèmes utilisent les shells standard version 6 ou 7 dont les scripts ne sont pas compatibles avec ce shell, celui-ci utilise un tel shell « standard » pour exécuter un script dont le premier caractère n'est pas un « # », c.-à-d. qui ne commence pas par un commentaire.
Les arguments restants sont placés dans la variable shell argv.
Démarrage et arrêt
Un shell de connexion démarre en exécutant les commandes des fichiers système /etc/csh.cshrc et /etc/csh.login. Il exécute ensuite les commandes des fichiers situés dans le répertoire personnel (home) de l'utilisateur : d'abord ~/.tcshrc (+) ou, s'il n'est pas trouvé, ~/.cshrc ; ensuite ~/.history (ou la valeur de la variable shell histfile) ; puis ~/.login ; et finalement ~/.cshdirs (ou la valeur de la variable shell dirsfile) (+). Le shell peut lire /etc/csh.login avant plutôt qu'après /etc/csh.cshrc, et ~/.login avant plutôt qu'après ~/.tcshrc ou ~/.cshrc et ~/.history, s'il est compilé ainsi ; voyez la variable shell version. (+)
Les shells non de connexion ne lisent que /etc/csh.cshrc et ~/.tcshrc ou ~/.cshrc au démarrage.
Pour des exemples de fichiers de démarrage, veuillez consulter http://tcshrc.sourceforge.net.
Les commandes comme stty(1) et tset(1), qui ne doivent être exécutées qu'une fois par connexion, sont habituellement situées dans un des fichiers ~/.login. Les utilisateurs qui doivent utiliser le même jeu de fichiers pour csh(1) et tcsh peuvent n'avoir qu'un seul ~/.cshrc qui vérifie l'existence de la variable shell tcsh avant d'utiliser des commandes spécifiques à tcsh, ou peuvent avoir à la fois un ~/.cshrc et un ~/.tcshrc qui emploient comme source (voyez la commande intégrée) le fichier ~/.cshrc. Le reste de ce manuel utilisera « ~/.tcshrc » pour vouloir dire « ~/.tcshrc » ou, si ~/.tcshrc n'est pas trouvé, « ~/.cshrc ».
Normalement, le shell commence à lire des commandes à partir du terminal, en affichant l'invite « > ». (Le traitement des arguments et l'utilisation du shell pour traiter les fichiers contenant des scripts de commandes seront décrits plus tard.) Le shell effectue à plusieurs reprises la boucle suivante : il lit une ligne d'entrée de commande, la découpe en mots, la place dans la liste d'historique de commandes, l'analyse et exécute chaque commande de la ligne.
On peut se déconnecter en tapant « ^D » sur une ligne vide, en tapant « logout » ou « login », ou encore via le mécanisme de déconnexion automatique du shell (voyez la variable shell autologout). Quand un shell de connexion se termine, il donne la valeur appropriée (« normal » ou « automatic ») à la variable shell logout, et exécute ensuite les commandes des fichiers /etc/csh.logout et ~/.logout. Le shell peut ignorer le DTR à la déconnexion si cela est compilé ; voyez la variable shell version.
Les noms des fichiers de connexion et de déconnexion varient selon les systèmes pour assurer la compatibilité avec les différentes variantes de csh(1) ; voyez FICHIERS.
Édition
Nous décrivons d'abord L'éditeur de ligne de commandes. Les sections Complètement et listage et Correction orthographique décrivent deux ensembles de fonctionnalités qui sont implémentées sous forme de commandes d'éditeur, mais qui méritent un traitement spécifique. Finalement, la section Commandes de l'éditeur liste et décrit les commandes d'éditeur spécifiques au shell et leurs liaisons par défaut.
Léditeur de ligne de commandes (+)
L'entrée de la ligne de commandes peut être éditée en utilisant des séquences de touches semblables à celles employées dans GNU Emacs ou vi(1). L'éditeur n'est actif que lorsque la variable shell edit est définie, ce qui est le cas par défaut dans les shells interactifs. La commande intégrée bindkey peut afficher et modifier les liaisons de touches. Des liaisons de touches de style Emacs sont utilisées par défaut (à moins que le shell n'ait été compilé différemment ; voyez la variable shell version), mais bindkey peut modifier les liaisons de touches pour utiliser un style vi.
Le shell associe toujours les touches fléchées (comme définies dans la variable d'environnement TERMCAP) à
|
à moins que procéder ainsi n'altère une autre liaison de caractère. On peut donner aux séquences d'échappement de touches fléchées la valeur « chaîne vide » ("") en utilisant settc pour empêcher ces liaisons. Les séquences ANSI/VT100 pour les touches fléchées sont toujours liées.
Les autres liaisons de touches sont, pour la plupart, celles auxquelles les utilisateurs d'emacs(1) et de vi(1) s'attendent et peuvent facilement être affichées par bindkey, de sorte qu'il n'est pas nécessaire de les lister ici. De même, bindkey peut lister les commandes d'éditeur accompagnées d'une courte description de chacune d'entre elles.
Notez que les commandes d'éditeur n'ont pas la même notion de « mot » que celle qu'a le shell. L'éditeur délimite les mots par n'importe quel caractère non alphanumérique ne faisant pas partie de la variable shell wordchars, alors que le shell ne reconnaît que les caractères d'espacement et certains des caractères ayant une signification spéciale pour lui, qui sont listés dans Structure Lexicale.
Complètement et listage (+)
Le shell est souvent capable de compléter des mots quand on lui fournit une abréviation unique. Tapez une partie d'un mot (par exemple « ls /usr/lost ») et appuyez sur la touche tab pour lancer la commande d'éditeur complete-word (compléter-mot). Le shell complète le nom de fichier « /usr/lost » en « /usr/lost+found/ », en remplaçant le mot incomplet par le mot complet dans le tampon d'entrée. (Note sur le « / » terminal : le complètement ajoute un « / » à la fin des répertoires complétés, et une espace à la fin des autres mots complétés, pour accélérer la frappe et fournir un indicateur visuel d'un complètement réussi. La variable shell addsuffix peut être indéfinie pour éviter cela.) Si aucune correspondance n'est trouvée (« /usr/lost+found » n'existe peut-être pas), la sonnerie du terminal retentit. Si le mot est déjà complet (il y a peut-être un « /usr/lost » sur votre système, ou vous avez peut-être pensé trop loin et avez déjà tapé le mot en entier), un « / » ou une espace est ajouté(e) à la fin si il/elle n'y était pas déjà.
Le complètement fonctionne partout sur la ligne, et pas uniquement à la fin ; le texte complété pousse le reste de la ligne sur la droite. Le complètement au milieu d'un mot résulte souvent en des caractères excédentaires à la droite du curseur qui devront être effacés.
Les commandes et les variables peuvent être complétées d'une façon fort similaire. Par exemple, taper « em[tab] » complète « em » en « emacs » si emacs est la seule commande sur votre système débutant par « em ». Le complètement peut trouver une commande si elle est située dans n'importe quel répertoire du path, ou bien si on lui fournit un nom de chemin complet. Taper « echo $ar[tab] » complète « $ar » en « $argv » si aucune autre variable ne commence par « ar ».
Le shell examine le tampon d'entrée pour déterminer si le mot que vous voulez compléter doit être complété en tant que nom de fichier, commande ou variable. Le premier mot du tampon et le premier mot suivant « ; », « | », « |& », « && » ou « || » sont considérés être des commandes. Un mot débutant par « $ » est considéré être une variable. Tout le reste est considéré être un nom de fichier. Une ligne vide est « complétée » en tant que nom de fichier.
Vous pouvez lister les complètements possibles d'un mot à tout moment en tapant « ^D » pour lancer la commande d'éditeur delete-char-or-list-or-eof. Le shell liste les complètements possibles en utilisant la commande intégrée ls-F et réaffiche l'invite et la ligne de commandes non terminée, par exemple :
"" 4
| > 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 :
"" 4
| > 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,
"" 4
| > ls ~k[^D] kahn kas kellogg > ls ~ke[tab] > ls ~kellogg/ |
ou
"" 4
| > 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 :
"" 4
| > 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
"" 4
| 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
"" 4
| 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 :
"" 4
| > 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 »,
"" 4
| > 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 :
"" 4
| > 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é : |
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 dhistorique
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
s
|
Par exemple, considérez ce morceau d'historique :
"" 4
| 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 :
n
x-y
-y
x*
x-
|
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. .ig " Pas vrai, mais on pensait que ça l'était pendant un long moment . " ..., à moins qu'une référence d'historique précédente ne se soit . " produite sur la même ligne, auquel cas cette forme répète la . " référence précédente. Donc « !?foo?^ !$ » fournit les premier . " et dernier arguments de la commande correspondant à « ?foo? ». .. Pour continuer avec notre exemple « diff », nous pourrions pu faire simplement « diff !^.old !^ » ou « diff !* » pour avoir les arguments dans l'ordre inverse.
Le ou les mots d'une référence d'historique peuvent être édités, ou « modifiés », en les faisant suivre par un ou plusieurs modificateurs, chacun d'entre eux étant précédé par un « : »:
|
Les modificateurs ne sont appliqués qu'au premier mot modifiable (à moins que « g » ne soit utilisé). Le fait qu'aucun mot ne soit modifiable constitue une erreur.
Par exemple, la commande « diff » pourrait avoir été écrite comme « diff wumpus.man.old !#^:r », en utilisant « :r » pour supprimer « .old » du premier argument situé sur la même ligne (« !#^ »). Nous pourrions faire « echo hello out there », ensuite « echo !*:u » pour mettre « hello » en majuscule, « echo !*:au » pour le dire bruyamment, ou « echo !*:agu » pour réellement crier. Nous pourrions faire suivre « mail -s "J'ai oublié mon mot de passe" rot » par « !:s/rot/root » pour corriger l'orthographe de « root » (voyez Correction orthographique pour une approche différente).
Il y a une abréviation spéciale pour les substitutions. Quand « ^ » est le premier caractère d'une ligne d'entrée, il est équivalent à « !:s^ ». Donc, on aurait pu dire « ^rot^root » pour effectuer une correction orthographique sur l'exemple précédent. C'est la seule substitution d'historique qui ne commence pas explicitement par « ! ».
(+) Dans csh, un seul modificateur peut être appliqué à chaque développement d'historique ou de variable. Dans tcsh, on peut en utiliser plusieurs, comme par exemple
"" 4
| % 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 :
"" 4
| > 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 dalias
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 e!* | 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 « e », 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é
Poster un commentaire
Matériel
Les Technos
Jeux Vidéos
Tablettes
