With either set of bindings, you’ll sometimes need to review the functions of certain keys as you learn the command editor. The following command is useful:

% bindkey

bindkey, with no arguments, displays your current key bindings by showing the associations between keystrokes and editing command names. Keystrokes are displayed using ^X for CTRL-X, ^[ for ESC, ^? for DEL, and nnn for the ASCII character with octal code nnn. The nnn notation is obscure; typically these are keystrokes you type by holding down the META key. It’s usually easier to figure out what META-c does by looking for the command associated with ESC c (displayed as ^[c), because META-c and ESC c execute the same command.

If you don’t know what an editing command name means, use the following command to get a list of short descriptions:

% bindkey -l

If you’re familiar with emacs or vi, the corresponding set of command editor bindings is generally similar to what you’re already used to, so you may simply want to use the bindings that most resemble whichever editor you prefer. Otherwise, you can try both sets and see which you like best. The following comparison describes some general differences between the emacs and vi bindings:

Before making a change (e.g., adding or deleting text), you position the cursor. The emacs cursor motion commands are shown in Table 7-1.

Try these commands by entering the following line, leaving the cursor at the end:

% echo this is a command

Then, enter the editing commands below; you should see the cursor move, as shown:

% echo this is a comman       Type CTRL-B
% echo this is a ommand       Type ESC b
% cho this is a command       Type CTRL-A
% eho this is a command       Type CTRL-F
% echothis is a command       Type ESC f
% echo this is a command      Type CTRL-E

To add new characters to the current command, just type them. To delete characters, words, or even the entire line, use the commands shown in Table 7-2. Modifications take place at the cursor position.

Try the modification commands by typing the following line, leaving the cursor at the end:

% echo My typing skilks are not amazing.

Then, use the following editing commands to make the changes shown below:

% echo My typing skilks are not mazing.     Type ESC b
% echo My typing skilks are mazing.         Type ESC CTRL-H
% echo My typing skilk are amazing.         Type CTRL-B several times
% echo My typing skil are amazing.          Type CTRL-H
% ech My typing skill are amazing.         Type l

Deletion commands, other than those that clobber single characters, place the deleted text into a cut buffer. To yank the text back into the command line, use CTRL-Y. You can easily rearrange sections of the command line this way, because the text need not be returned to its original location. You can yank the text into the command line more than once. (Character deletions are not placed in the cut buffer, since you can retype a character to restore it.)

If you want to repeat a command several times, it’s often easier to specify a repeat count than to type the command multiple times. To repeat a command n times, precede it with ESC n, where n is some number. For example, ESC 10 CTRL-B moves the cursor back ten characters, and ESC 3 ESC d deletes three words. If a command cannot be repeated as many times as you specify, tcsh repeats it as many times as possible.

Another way to repeat a command, if it consists of a single keystroke, is simply to hold down the key.

emacs mode allows you to search your history list for a command you want to edit. This is often faster than backing up a line at a time with CTRL-P or up arrow. You can specify a command line either by a prefix of the line, or by a string that appears in the line.

To use prefix searching, enter the first part of the command line, then type ESC p. The prefix can contain filename pattern characters. tcsh searches backward through your history for a command that begins with the prefix and retrieves it into the edit buffer. If the command isn’t the one you want, type ESC p again to find the next match. ESC n is similar but searches forward. You can use ESC p and ESC n together to bounce back and forth among the matching commands.

String searching is done using two commands that allow emacs-style incremental searches. These commands are not bound to any keys by default, so you must bind them to some key or key sequence before you can use them. For example, to bind them to CTRL-X p and CTRL-X n, put the following commands in your ˜/.cshrc file:

bindkey "^xp" i-search-back
bindkey "^xn" i-search-fwd

These two commands allow you to search backward or forward, so that as you type a string, the command line containing that string is retrieved into the edit buffer. For example, suppose your history looks like this:

unexpand note.txt > note2.txt
man cal
cal 1066

When you type CTRL-X p, the command editor prints bck: as a prompt, and prepares to search backward for commands. If you then type a, n, and d in succession, tcsh retrieves commands into the edit buffer in the following order:

cal 1066                          Command matches a
man cal                           Command matches an
unexpand note.txt > note2.txt     Command matches and

With incremental searching, you type no more than necessary to find the desired command, and the text you type can be anywhere in the command line. If you enter an extra character, delete it and the search will return to the previous command found.

Hit ESC to terminate an incremental search, so that you can edit the currently displayed command. Or, just hit RETURN to execute the command.

You can use the arrow keys for emacs mode editing. Up arrow and down arrow move up and down through your history list, like CTRL-P and CTRL-N. Left arrow and right arrow move the cursor left and right one character, like CTRL-B and CTRL-F.

When you begin to edit a command using the vi bindings, you’re in insert mode and most characters simply go into the edit buffer at the cursor position. You can do some limited cursor movement and text deletion using the commands listed in Table 7-3.

To make changes that cannot easily be made in insert mode, hit ESC to enter command mode. The commands for moving the cursor, changing text, or deleting text in command mode are more flexible than those available in insert mode. (There is also a u command that is supposed to undo the last change made in command mode; unfortunately, I have not found it to work reliably.)

% echo this is a command

% echo this is a comman        Type h
% echo this is a ommand        Type b
% cho this is a command        Type ^ or CTRL-A
% eho this is a command        Type SPACE or 1
% echo his is a command        Type w
% echo this is a command       Type $ or CTRL-E

% echo My typing skilks are not amazing. Type a simple command line
% echo My typing skilks are notmazing.  Hit ESC to enter command mode, then type b
% echo My typing skilks aremazing.     Type db
% echo My typing skils are amazing.     Type h several times
% echo My typing skils are amazing.     Type rl

In vi command mode, you can use ? and / to search backward and forward through your history list. For instance, when you type ?, tcsh prints ? as a prompt to solicit the string you want to search for. Type a string and hit RETURN. The string can contain filename pattern characters. The editor searches backward for a line that matches the string and retrieves it into the edit buffer, with the cursor at the end of the line. If the command isn’t the one you want, type n (next match) to repeat the search in the same direction. N repeats the search in the opposite direction. You can use n and N together to bounce back and forth among the matching commands.

When you find the command you want, just start editing it as usual (note that you’ll still be in command mode after a search). Or, you can hit RETURN to execute it.

vi command mode provides a set of commands that search for characters in the current command line (see Table 7-8). You can use these as motion commands to move the cursor to a particular character, or combine them with the d or c commands to delete or change text from the cursor position to that character.

fc moves the cursor forward to the next instance of character c in the command. Fc moves the cursor backward:

% echo abcdefghi     Type a command, leaving cursor at end
% ech abcdefghi      Type ESC to enter command mode, then Fo to move back to o
% echo abcdefhi      Type fg to move forward to g

The ; command repeats the last f or F command. The , command is similar but moves the cursor in the opposite direction. That is, the , command repeats f as F and F as f. This feature is useful if you use multiple ; commands to search for successive instances of a character, and go too far:

% echo three games of tic tac toe    Type a command, leaving cursor at end
% echo three games of tic tac oe     Hit ESC to enter command mode, then type Ft
% echo three games of tic ac toe     Type ; to repeat search
% echo three games of ic tac toe     Type ; to repeat search
% echo hree games of tic tac toe     Type ; to repeat search
% echo three games of ic tac toe     Oops, too far; type, to reverse search

tc and Tc are similar to fc and Fc, but the former move the cursor up to or back to the c, i.e., just to the left of c for t and just to the right of c for T.

You can precede the character-seeking commands with d or c to delete or change text. For example, dt/ deletes up to the next slash (handy for clobbering parts of pathnames) and 3c SPACE changes text up through the third space after the cursor.

Up arrow and down arrow are like CTRL-P and CTRL-N, just as in emacs mode. Left arrow and right arrow move the cursor left and right one character. However, there is a quirk you should look out for if you’re in insert mode. On many terminals, arrow keys actually send out strings of characters that begin with ESC. Although the arrow keys move the cursor, they’ll also switch you into command mode. If you find this distracting, avoid left arrow and right arrow in insert mode, and stick with CTRL-B and CTRL-F.

To select a set of bindings en masse, use the -e or -v option:

% bindkey -e                     Select emacs bindings
% bindkey -v                     Select vi bindings

Selecting either set rebinds every key to the default for that set, undoing any prior bindings you may have established. To bind any individual keys specially (as discussed under Changing Key Bindings, below), you should do so only after executing bindkey -e or bindkey -v.

bindkey -d restores all bindings to whatever the default set is at your site. This isn’t really useful, unless you’re using whatever set that happens to be. You might as well use bindkey -e or bindkey -v to explicitly select a particular set.

To see the full list of editing command names and their meanings, use the following command:

% bindkey -l
backward-char
    Move back a character
backward-delete-char
    Delete the character behind cursor
backward-delete-word
    Cut from beginning of current word to cursor - saved in cut buffer
    .
    .
    .

bindkey -l is useful for determining which editing commands can be bound to keys, or what a given command does. The descriptions displayed are quite concise, however. Appendix C, Other Sources of Information, lists a document that provides more detailed explanations of the editing commands.

bindkey can display all key bindings currently in effect, or the bindings for individual keys.

% bindkey
Standard key bindings
"^@"           ->  set-mark-command
"^A"           ->  beginning-of-line
"^B"           ->  backward-char
"^C"           ->  tty-sigintr
"^D"           ->  delete-char-or-list-or-eof
.
.
.

% bindkey | grep history

% bindkey ^A                    Show binding for CTRL-A
"^A"   ->    beginning-of-line
% bindkey ^L                    Show binding for CTRL-L
"^L"   ->    clear-screen

% bindkey !                      Show binding from standard key map
"!"     ->      self-insert-char
% bindkey -a !                Show binding from alternative key map
"!"     ->      expand-history

The key argument to bindkey can represent a single character or a string of characters. key can include special characters, and some of bindkey’s options modify the key argument’s interpretation.

The following methods allow you to include special characters in key:

For example, to check the binding for CTRL-C, you can type any of these commands:

% bindkey ^C
% bindkey CTRL-VCTRL-C
% bindkey "03"
% bindkey \003

In general, it’s a good idea to put quotes around a key argument that contains backslash sequences or characters that the shell interprets specially, like | or ; or (. Note that you type a backslash only once if it’s used within quotes, but twice if it’s not in quotes.

% bindkey -k left                Display binding for left arrow key

% bindkey -b C-A                Show binding for CTRL-A
% bindkey -b M-A                Show binding for META-A

% bindkey left
Unbound extended key "left"
% bindkey C-A
Unbound extended key "C-A"

You can customize your bindings by modifying bindings for individual keys. bindkey allows you to do the following:

You can experiment with your bindings by changing them at the command line, using the bindkey commands described below. If you decide to make a given binding part of your environment, put the appropriate command in ˜/.cshrc.

% bindkey key command

% bindkey -a ^B backward-char
% bindkey -a ^F forward-char

% bindkey key self-insert-command

% bindkey -r key

% bindkey -c ^Xl   'ls -l|more'

% bindkey -s key string

% ps ax |  grep string

% bindkey -s ^Xp 'ps ax |  grep '

% CTRL-Xpemacs

If a key doesn’t do what you expect, you may have a conflict between the way the terminal driver and the command editor are interpreting keystrokes. For example, CTRL-W is normally interpreted as the werase (word erase) character by the terminal driver. But CTRL-W doesn’t perform the word erase function if you use the emacs bindings, because CTRL-W is bound to the editor’s kill-region command. If you suspect a conflict, you can change the terminal driver setting using stty (see Chapter 5, Setting Up Your Terminal), or change the command editor key binding using bindkey.

If you specify two multicharacter bindings that begin with the same prefix, you will not be able to use both bindings. Instead, the second binding replaces the first:

% bindkey -s ^Xl ls
% bindkey -s ^Xlm 'ls | more'