2.4.1. Simple Control Mode Commands

Table 2-7. Basic vi control mode commands

Time for a few examples. Let's say you type in this line and, before you hit ENTER, decide you want to change it:

$ fgrep -l Bob < ~pete/wk/names

As shown, your cursor is beyond the last character of the line. First, type ESC to enter control mode; your cursor moves back one space so that it is on the s. Then if you type h, your cursor moves back to the e. If you type 3h from the e, you end up at the n.

Now we look at the difference between the two "word" concepts. Go back to the end of the line by typing $. If you type b, the word in question is "names", and the cursor ends up on the n:

$ fgrep -l Bob < ~pete/wk/names

If you type b again, the next word is the slash (it's a "sequence" of non-alphanumeric characters), so the cursor ends up over it:

$ fgrep -l Bob < ~pete/wk/names

However, if you typed B instead of b, the nonblank word would be the entire pathname, and the cursor ends up at the beginning of it -- that is, over the tilde:

$ fgrep -l Bob < ~pete/wk/names

You would have had to type b four times -- or just 4b -- to get the same effect, since there are four "words" in the part of the pathname to the left of /names: wk, slash, pete, and the leading tilde.

At this point, w and W do the opposite: typing w gets you over the p, since the tilde is a "word," while typing W brings you to the end of the line. But whereas w and W take you to the beginning of the next word, e and E take you to the end of the current word. Thus, if you type w with the cursor on the tilde, you get to:

$ fgrep -l Bob < ~pete/wk/names

Then typing e gets you to:

$ fgrep -l Bob < ~pete/wk/names

And typing an additional w gets you to:

$ fgrep -l Bob < ~pete/wk/names

2.4.2. Entering and Changing Text

Table 2-8. Commands for entering vi input mode

Most likely, you will use either i or a consistently, and you may use R occasionally. I and A are abbreviations for 0i and $a respectively. To illustrate the difference between i, a, and R, say we start out with our example line:

$ fgrep -l Bob < ~pete/wk/names

If you type i followed by end, you get:

$ fgrep -l Bob < ~pete/wkend/names

That is, the cursor always appears to be over the / before names. But if you type a instead of i, you will notice the cursor move one space to the right. Then if you type nick, you get:

$ fgrep -l Bob < ~pete/wk/nicknames

$ fgrep -l Bob < ~pete/wk/tasks

In other words, you will be replacing (hence R) instead of inserting text.

Why capital R instead of lowercase r? The latter is a slightly different command, which replaces only one character and does not enter input mode. With r, the next single character overwrites the character under the cursor. So if we start with the original command line and type r followed by a semicolon, we get:

$ fgrep -l Bob < ~pete/wk;names

2.4.3. Deletion Commands

Table 2-9. Some vi-mode deletion commands

Table 2-10. Abbreviations for vi-mode delete commands

Table 2-11. Vi-mode cut and paste commands

The d and p commands are quite useful together for rearranging the order of options or arguments on a command line. As an example, most Unix C compilers accept a -l option that indicates the name of a library to use when linking a compiled program. The -L option specifies a directory in which the compiler should look for libraries, besides looking in the standard places for system libraries.

cc -o myprog myprog.c -Lmylibdir -lmylib

This command looks for the library file libmylib.a in the directory mylibdir when compiling and linking myprog.c. So far so good. The catch is that typically the -L option must appear on the command line before the -l option. Let's suppose you accidentally typed them the other way around, and therefore that the compilation failed. You can use the d and p commands to rearrange things. Start by recalling the line:

$ cc -o myprog myprog.c -lmylib -Lmylibdir

Next, move to the last option with 5w. Then back up to the preceding space with h. Your command line now looks like this:

$ cc -o myprog myprog.c -lmylib-Lmylibdir

Type D to delete the rest of the line:

$ cc -o myprog myprog.c -lmylib

Now move back to the preceding c character with Bhh:

$ cc -o myprog myprog.c -lmylib

Finally, use p to insert the moved option:

$ cc -o myprog myprog.c -Lmylibdir -lmylib

2.4.4. Moving Around in the History File

Table 2-12. Vi control mode commands for searching the history file

If you aren't familiar with vi and its cultural history, you may be wondering at the wisdom of choosing such seemingly poor mnemonics as h, j, k, and l for backward character, forward line, backward line, and forward character, respectively. Well, there actually is a rationale for the choices -- other than that they are all together on the standard keyboard.

Another (partial) rationale for the command choices is that CTRL-H is the traditional backspace key, and CTRL-J denotes linefeed. The primary rationale for these choices, however, is that with these keys, it's never necessary to move your hands off the "home row" of the keyboard.

Perhaps + and - are better mnemonics than j and k, but the latter have the advantage of being more easily accessible to touch typists. In either case, these commands are the most basic ones for moving around the history file. To see how they work, let's take the same examples we used when discussing emacs-mode earlier.

You enter the example command (ENTER works in both input and control modes, as does newline or CTRL-J):

$ fgrep -l Bob < ~pete/wk/names

But you get an error message saying that your option letter was wrong. You want to change it to -s without having to retype the entire command. Assuming you are in control mode (you may have to type ESC to put yourself in control mode), you type k or - to get the command back. Your cursor will be at the beginning of the line:

$ fgrep -l Bob < ~pete/wk/names

Type w to get to the -, then l or space to get to the l. Now you can replace it by typing rs; press ENTER to run the command.

But typing /^ma doesn't give you what you want; instead, the shell gives you:

$ make myprogram

2.4.5. Character-Finding Commands

Table 2-13. Vi-mode character-finding commands

$ fgrep -l Bob < ~pete/wk/names

At this point, you could type rR to replace the B with R. But let's say you wanted to change Bob to Blob. You would need to move one space to the right of the B. Of course, you could just type l. But, given that you're somewhere to the right of Bob, the fastest way to move to the o would be to type TB instead of FB followed by l.

As an example of how the repeat count can be used with character-finding commands, let's say you want to change the filename from names to namfile. In this case, assuming your cursor is still on the B, you need to get to the third e to the right, so you can type 3te, followed by l to put the cursor back on the e in names.

The character-finding commands also have associated delete commands. Read the command definitions in the previous table and mentally substitute "delete" for "move." You'll get what happens when you precede the given character-finding command with a d. The deletion includes the character given as argument. For example, assume that your cursor is under the n in names:

$ fgrep -l Bob < ~pete/wk/names

If you want to change names to aides, one possibility is to type dfm. This means "delete right to next occurrence of m," i.e., delete "nam." Then you can type i (to enter input mode) and then "aid" to complete the change.

A better way, though, is to use cfm. This means "change everything from under the cursor up to and including the next occurrence of m." This deletes "nam" and enters input mode for you.

The % command is very useful for finding the matching "pair" character when used with parentheses, square brackets, and curly braces. All of these occur frequently in matched pairs on shell command lines.

2.4.6. Filename and Variable Completion and Expansion

1. If there is no file whose name begins with the word, the shell beeps and nothing further happens.

2. If there is exactly one way to complete the filename, and the file is a regular file, the shell types the rest of the filename, followed by a space in case you want to type in more command arguments.

3. If there is exactly one way to complete the filename, and the file is a directory, the shell completes the filename, followed by a slash.

4. If there is more than one way to complete the filename, the shell completes out to the longest common prefix among the available choices.

As in emacs-mode, starting with ksh93h, you may use TAB instead of ESC \. However, this only works if you use set -o viraw in addition to set -o vi. (The viraw option is a bit more CPU-intensive -- although probably not noticeably -- and is required on some older Unix systems for vi-mode to work at all.) Fortunately, beginning with ksh93n, the viraw option is automatically enabled when you use vi-mode.

$ cc pro            ESC = typed at this point
1) problem.c
2) program.c
$ cc pro

Beginning with ksh93m, prefixing the = command with a count indicates selection of a particular option. Returning to the previous example: after listing both problem.c and program.c, the command line looks like this:

$ cc pro

If you want program.c, it's enough to type 2 =, and the shell picks expansion number 2. The command line changes to:

$ cc program.c 

As in emacs-mode, you can also do command completion from vi-mode. The *, \, and = commands, when used on the first word of the command line, expand aliases, functions, and commands. Also as in emacs-mode, starting with ksh93l, these expansions work when you've opened a quoted string but haven't closed it yet, and for variable expansions with $ and "$.

2.4.7. Miscellaneous Commands

Table 2-14. Miscellaneous vi-mode commands

A repeat count preceding _ causes the nth word in the previous command to be inserted in the current line; without the count, the last word is used. Omitting the repeat count is useful because a filename is usually the last thing on a Unix command line, and because users often run several commands in a row on the same file. With this feature, you can type all of the commands (except the first) followed by ESC _, and the shell inserts the filename.

2.4.8. Macro Expansion with Aliases

As before, suppose that you want a command to capitalize the first letter of the current word. You could define an alias as follows:

alias _C='B~'

$ print here is a word     Type ESC @ C
$ print here is a Word