vi

viis an interactive text editor that is display-oriented: the screen of yourterminalacts as a window into the file you are editing. Changes you make to the file are reflected in what you see.

vi [ -| -s ] [-l] [-L] [-R] [ -r [ filename ] ] [-S] [-t tag] [-v] [-V]
   [-x] [-w] [-n ] [-C] [+command | -c command ] filename

viis an interactive text editor that is display-oriented: the screen of yourterminalacts as a window into the file you are editing. Changes you make to the file are reflected in what you see.

Usingviyou can insert text anywhere in the file very easily. Most of thevicommands move thecursoraround in the file. You can move the cursor forward and backward in units of characters, words, sentences, and paragraphs. Some of the operators, likedfor delete andcfor change, can be combined with the motion commands to make them operate on entire words, paragraphs, etc., in a natural way.

The most common way to start avisession is to tell it which file to edit. To edit a file namedfilename, use the command:

vi filename

The screen will clear and the text of your file will appear on the screen. Iffilenamedoesn't exist yet,viwill start you in a new file, and when you tell it to save your work, it will use thefilenamethat you specified.

The editor does not directly modify the file you are editing. Instead, it makes a copy of this file in memory called the buffer. You do not actually affect the contents of the file until you write the changes you've made back into the original file.

On most terminals, you can use the arrow keys to move the cursor around. Left and right moves the cursor left or right one character, and up and down move the cursor up or down one line. The other way to move the cursor is with theh,j,k, andlkeys:

A bit of historical trivia: thehjklkeys are used because the original computer system Bill Joy developed with did not have separate arrow keys. Instead, the keyboard usedhjklkeys as the arrow keys.

Hardcoreviusers will tell you that thehjklkeys are the only true" way to move the cursor because you can keep your hands in the typing position, but you should use whatever works best for you.

The Escape key is important invi: it is used to cancel any command you've started typing, and to return to command-mode after you've been inserting or adding text. Escape is a safe key to hit if you've lost track of what mode you're in or what you're doing. You can hit it several times to return to command mode and cancel anything that you've been doing.

The Return (or Enter") key is used to complete certain commands and execute them.

The Delete key is another safe" key to press. It interrupts anything that the editor has been doing and brings you back to the default state of the editor, sometimes also called the quiescent" state.

The commandZZwill write the contents of the buffer into the file you are editing, and quitvi.

If there are no changes to be saved, you can also quit the editor with the command:q. If you have made changes that haven't been saved yet, the editor won't let you exit this way.

If you want to quit and discard the changes you've made, you can tell the editor you're sure you know what you're doing by quitting with the command:q!. This will exitviimmediately, and any unsaved changes will be lost.

The editor has several commands for moving around within your file. One of the most useful of these isControl-D(also represented as^D). This command "scrolls" down in the file (theDstands for "down").^U("up") is similar: it scrolls up one page in the file. Both of these commands will also move the cursor to the new location.

If you just want to see more of the file, but leave the cursor where it is, you can use^Eto "expose" one more line at the bottom of the screen.^Y(which doesn't stand for anything, but it's next to theUon the keyboard) exposes one line at the top of the screen.

There are other ways to move around in the file. The keys^Fand^Bmove forward and backward one page (this is called "paging"), keeping a couple of lines of continuity between screens so that it is possible to read through a file using these rather than^Dand^Uif you wish.

Notice the difference between "scrolling" (^U,^D) and "paging" (^B,^F). Scrolling leaves more context, but paging only leaves you a couple of lines. It's up to you which one is easier for moving around and reading your file.

Another way to position yourself in the file is by giving the editor astringto search for. If you type "/" followed by a string of characters and press Enter, the editor will search for the next occurrence of this string in your file, and place the cursor there. Pressingnwill go to the next occurrence after that.

If instead of forward, you want to search backward for a string, use?instead of/. In a?string search, pressingnwill take you to successive occurrences in the same (backward) direction.

If the search string you give the editor is not present in the file, the editor will print a message letting you know it couldn't find it, and your cursor will not be moved.

If you want your search string only to match if it's at the beginning of a line, you should begin the search string with acaret("^"). To match only at the end of a line, end the search string with a dollar sign ("$"). So using the command

/^mystring

will only find a match if "mystring" is at the very begining of a line. Similarly, the command

/mystring$

will only match any occurrences of "mystring" that are at the very end of a line.

The commandG, when preceded by a number, will "goto" a line: it will go to that line number and position the cursor there. If you useGwith no number, it moves the cursor to the last line of the file.

So, using the command

1G

Moves your cursor to the first line in the file;

30G

Moves your cursor to line 30, and

G

Moves your cursor to the last line, whatever number that may be.

You can find out where you're at in the file by pressing^G. This sill show you the name of the file you are editing, the number of the current line, the number of lines in the buffer, and the percentage of the way through the buffer your cursor is currently at.

Any time you move the cursor in any of these ways, you can move the cursor back to where it just was by typing``(twoback quotes). So, if you type

G

to move to the end of the file, but then you realize you need to get back to where you were (whether you remember where that is or not), you can type

``

To get back to your original location. This also works after performing a search. Remember this command, because it's very useful!

If you're near the end of your file, and the last line is not at the bottom of the screen,viwill print atilde("~") on any lines after the end of your actual file. This indicates that the last line of your file is on the screen; that is, any lines showing "~" are past the end of your file. You'll notice this, for instance, when you start editing a new file: every line will begin with a tilde.

As we've already mentioned, you can use the arrow keys orh,j,k, andlto move the cursor left and right one cursor, or up and down one line.

You can also use+to move to the next line or-to move to the previous line. This is similar to usingupanddown(orjandk), except that your cursor will automatically be placed at the first non-whitespacecharacter on the line.

Any of these keys, if they would take you before the first line on the screen or after the last line, will scroll the display one line in the correct direction. Pressing theReturnkey is the same as pressing+. You can also position the cursor at the top, middle, or bottom of the currently-displayed screen of text:

Hwill take you to the top ("home") line on the screen. PrecedingHwith a number will take you to the home line plus that number of lines. For instance,3Hmoves your cursor to the third line of text displayed on the screen.

Mis a similar command: it moves your cursor to the middle of the screen.

Lmoves your cursor to the last line of the screen. If you precede it with a number, it moves your cursor to that number of lines before the last line displayed. So5Lmoves your cursor to the fifth-to-last line currently displayed.

wwill advance the cursor to the next word on the line, andbwill back up the cursor to the previous word.

eadvances you to the end of the current word rather than the beginning of the next word.

If words are punctuated, for instance with an apostrophe or a comma,wandbwill stop at the punctuation. If you useWandBinstead, they move the cursor while ignoring punctuation.

These commands all wrap at the end (or beginning) of a line, moving to the previous or next line if their search for the next or previous word goes that far.

Here's a recap of the movement keys we just discussed, and a few extras.

The most basic command for making changes to your file is the i (insert) command. After you type i, everything you type until you hit Esc is inserted at your cursor position into the buffer.

The companion to the i command is the a ("append") command. This works exactly like i, except it starts inserting the text after the cursor location, not at the cursor location.

Sometimes, you want to start editing on a new line right after the line your cursor is at. To do this, use the o command. To start a new line before the line your cursor is at, use the O command. Just like with i and a, any text you type will be inserted into the buffer until you press Esc.

While you are inserting text with any of these commands, you can use ^W to erase a whole word and leave your cursor one space after the previous word

One thing to note is that when you backspace, you will not erase any characters that you haven't inserted. Also, you can't backspace to the previous line; backspacing will stop when you get to the beginning of the current line.

It's easy to make small corrections in vi. If you need to remove a character that shouldn't be there, move the cursor over it and press x to delete it. You can also supply a number before pressing x, and it will delete that many characters. So if you have the word "discovery", and you move the cursor over the v and type

4x

...you will be left with the word "disco".

If you want to replace a single character with another character, move the cursor over it and press r and then the character that should replace it. So, if you type "mistoke", and move the cursor over the "o" and type

ra

...the o will be replaced with an a, leaving you with the word "mistake."

The R command is similar, but you can use it to replace more than one character; if you press R and start typing, every character you type will replace every character that was already there. So, if you have the word "mistake", and you move the cursor over the letter t and type

Rsile

...you will see that the word "mistake" has turned into the word "missile". You might also notice that if you backspace in this mode, your original text will be restored, letter by letter. When you're done, press Esc to stop replacing characters.

The command d acts as a delete operator: pressing d and then a movement key will delete wherever the cursor would have moved. For instance, typing dw will delete the next word, and typing db will delete backwards to the previous word. Typing dSPACE will delete one character; this is the same as typing x.

Another useful operator is c, which stands for change. The command cwwill change a single word: it will delete everything to the end of a word, and place you into insert mode to type the text that should replace it.

Any time you make a change with a command, you can type "." to repeat the change. So if you delete a word with dw, typing . will delete the next word as well. You can repeat this over and over by typing .several times, like an ellipsis ("...").

Typing dd will delete an entire line.

Typing cc will change an entire line, deleting it and placing you in insert mode.

You can delete or change more than one line at a time by preceding ddor cc with a number. For instance, 5dd will delete 5 lines. You can also give a command like dL which will delete every line from the cursor up to and including the last line on the screen, or d3L which will delete every line from the cursor to the third-to-last line. When you make big changes like this, especially if you make changes that go beyond what you can see in one screen, the editor gives you a message telling you what's been done.

To undo the last change, type u. To re-do (to undo an undo), type uagain.

Unlike vim, vi only offers one level of undo. However, you can use U(capital U) to undo any changes that were made to the current line; pressing U restores the current line to the way it was before you started changing it.

fx moves the cursor finds the next x character on the current line. After that, if you press ; your cursor moves to the next occurrence of the same character. F is a similar command, but searches backwards in the same line, rather than forwards.

The f and F commands can be combined, for example, with the dcommand. Typing dfx will delete everything from the cursor through the next occurrence of x in the line. Sometimes you want to delete up to, but not including, the next occurrence of character x. In this case, use the command dtx. t stands for "to".

The beginning of the line is represented by zero ("0"), the caret ("^") represents the first non-whitespace character on the line, and the end of the line is represented by the dollar sign ("$"). If you press ^, the cursor will be placed at the first non-whitespace character of the line; if you press 0, the cursor will be placed at the beginning of the line; and if you press $, the cursor will be placed at the end of the line.

To delete everything from the cursor to the end of the line, type d$. To delete everything from the cursor to the beginning of the line, type d0... and so on.

Sometimes it's helpful to move around in units of entire sentences. The ( and ) commands move to the beginning of the previous and next sentences, respectively. So the command d) deletes everything through the end of the current sentence; and d( deletes everything through the beginning of the current sentence, or the entire previous sentence if you're already at the beginning of a sentence.

A sentence is defined as ending at a period ("."), exclamation point ("!"), or question mark ("?") which is followed either by the end of the line or a space. Any number of closing ), ], ", and ' characters may appear after the ., ?, or ! before the space or the end of the line.

The { and } commands move over paragraphs, and the operations [[and ]] move over sections. A "section" can be defined by a special macro, or by a formfeed at the beginning of a line.

The editor has a special unnamed buffer where the last deleted or changed-away text is saved, and a set of named buffers a through zwhich you can use to save copies of text and to move text around in your file (or files).

The y command "yanks" a copy of an object into the unnamed buffer. If preceded by a buffer name, it places this object into the named buffer. The way to specify the buffer is double quotes ("), then a letter a-z, then the y command. So "ay will yank an object into the buffer named a.

Text in a buffer (either the unnamed buffer or one of your named buffers) can be pasted into your document with the commands p or P. pwill paste the buffer contents after the cursor location (much like an append), and P will paste the buffer contents at the cursor location (much like an insert).

If the text which you yank forms part of a line, or is an object such as a sentence which partially spans more than one line, then when you put the text back, it will be placed after the cursor (or before it if you used P). If the yanked text forms whole lines, they will be put back as whole lines, without changing the current line. In this case, the paste acts much more like an o or O command. So, the command YP will make a copy of the current line and place you at the location of the copy, which is placed before the current line. Y is a convenient abbreviation for yy.

The command Yp will also make a copy of the current line, and place it after the current line. You can give Y a number of lines to yank, and thus duplicate several lines; for instance, 3YP will duplicate three lines, and place them before the current line.

To move text within the buffer, you need to delete it in one place, and put it back in another. You can precede a delete operation by the name of a buffer in which the text is to be stored, as in "a5dd, which deletes 5 lines into the named buffer a. You can then move the cursor to the eventual resting place of these lines and do a "ap or "aP to put them back. In fact, you can switch and edit another file before you put the lines back, by giving a command of the form :e name, where name is the name of the other file you want to edit. You will have to write the contents of the current editor buffer (or discard them) if you have made changes, before the editor will allow you to edit a new file.

An ordinary delete command saves the text in the unnamed buffer, so that an ordinary paste will place it back in the file. However, the unnamed buffer is lost when you change files, so to move text from one file to another you should use a named buffer.

So far we have seen how to write our file to disk and quit (ZZ), or simply write our file and continue editing(:w).

If you have changed your file but you want to quit without saving, use the command:q!. The command:qquits the editor, but it will only let you do this if you haven't made any changes since your last write (your last save). The exclamation point, however, tells the editor "yes, I really want to do this."

Similarly, you can edit another file with the:enamecommand, wherenameis the name of the file you want to edit. But the editor won't let you do this if you have unsaved changes. However, if you use the exclamation mark again (:e!name), the editor will do as you ask: it will discard your changes and open filenamefor editing.

If you don't specify a file name, and just use the command:e!, the editor will re-load your saved version of the file you're working on. This is like the "revert" command in other file editors. It will discard your changes, and revert to the last-saved version of the file.

If you want run a shell command without exiting the editor, you can use the command:!command. The system will run the commandcommand, and when the command finishes, the editor will ask you to press Enter before returning you to the editing screen. You can also give another:command when it asks you to press Enter; this will run the next command without redrawing the screen.

If you want to drop entirely to your shell's command prompt, use the command:sh. This will drop you into your shell, where you can use it as you normally would; when you're done, type Control-D (^D), and you will be returned tovi.

On many systems, you can also simply type^Zfrom within the editor at any time to drop into your shell. This technically putsviin the background. To return tovi, typefg("foreground") at your shell command prompt, andviwill become your foreground process again.

As already mentioned, the command``(two back quotes) returns you to the previous place after a motion of the cursor by a command such as/,/, orG. You can also mark your position in the file with single-letter tags and return to these marks later. The marking is done with the commandmx, wherexis the letter you want to assign to the mark. To return to the place that you marked, you can use the command`x

For example, if you typema, you will mark the current cursor position with the lettera. Then, if you move the cursor anywhere else in the file, you can always return to that line with the command`a. Marks last until you start editing another file, or until you overwrite the mark by setting it somewhere else.

When using operators such asdand referring to marked lines, sometimes you'll want to refer to the line that you marked, and not the actual cursor position within the line. At any time, you can use'x(as opposed to`x) to refer to the line itself. So, the commandd`awill delete everything from the current cursor position up to the exact position at marka, whereas the commandd'awill delete everything up to (and including) the entire line where markaresides.

Used without an operator,'xmoves you to the first non-whitespace character in the line where markxresides.

If the screen image is messed up for any reason, you can refresh the screen with Control-L (^L).

If you want to center the screen on your cursor at any time, typez-. To adjust the screen so that the line with your cursor is at the top of the screen, typezand press Enter. To adjust the screen so that the line with your cursor is at the bottom of the screen, typez..

zzis the same asz-, and will center the screen so that the line with your cursor is at the center of the screen.

The editor has a set of options, which you can set with the:setcommand. To set optionoptto valueval, use the command:setopt=val.

Toggle options can be set with the commandssetopt, and unset with the commandset noopt.

Here are some of the most useful options you can set:

These statements can be placed in theenvironment variableEXINIT, or can be given while you are runningviby preceding them with a:, as described above.

You can view a list of all options and their settings by typing:setwithinviat any time. To view the current setting of a particular option, use the command:setopt?.

setcan be abbreviated asse. Multiple options can be set on one line, for instance:se ai aw nu.

Options set with:setonly last for your current editor session.

If you want to place your default settings into the environment variableEXINITso that they are loaded every time you runvi, you can specify multiple commands on a single line by separating them with the vertical bar ("|"). For instance, if your shell iscsh, you could setEXINITwith the following shell command:

setenv EXINIT 'set ai aw terse|map @ dd|map # x'

You might have a problem if you delete several lines and then want them back. However, the editor saves the last 9 deleted blocks of text in a set of registers numbered1through9. You can get thenth previous deleted text back in your file by the command"np. These are similar to your named buffers, except they refer to the number of the previous block of text that was deleted.

Usually, when you type a single period ("."), it repeats the last change you've made. As a special case, when this period repeats a change that refers to a numbered buffer, the number is incremented before the command is repeated. Let's see how this works, and why it's useful:

Let's say you deleted something important, and you know it's in one of your nine previous block-deletes, but you're not sure which one. If you want to go back and look at all nine previously deleted blocks, here's how you could do it: you could use the command

"1p

To paste the contents of the most recently-deleted text (buffer number1). If that's not the text you wanted, you could then undo (u) and repeat the command with., pasting the command of buffer2. In other words, typing the command

"1pu.u.u.u.

is the same as typing

"1pu"2pu"3pu"4pu"5p

and you can go back in the numbered buffers easily until you find the text you want to have back.

The commandPcan, of course, be used instead ofpin the above example, to place the text before the cursor instead of after it.

If the system crashes, you can recover the work you were doing to within a few changes. When you get back into your system, use this command to startvi:

vi -r name

Wherenameis the name of the file you were editing. This will recover your work to a point as close as possible to where you left off.

If you don't specify a file withnameand instead just type

vi -r

then you will receive a list of files which can be recovered.

When you are typing in large amounts of text it is convenient to have lines broken near the right margin automatically. You can cause this to happen by giving the command:se wm=10. This causes all lines to be broken at a space at least 10 columns from the right hand edge of the screen.

If the editor breaks an input line and you wish to put it back together you can tell it to join the lines withJ. You can giveJa count of the number of lines to be joined as in3Jto join 3 lines. The editor supplies white space, if appropriate, at the juncture of the joined lines, and leaves the cursor at this white space. You can kill the white space withxif you don't want it.

The editor has a number of commands for editing programs. The thing that most distinguishes editing of programs from editing of text is the indented structure to the body of the program. The editor has anautoindentfacility for helping you generate correctly indented programs.

To enable this facility you can give the command:se ai. Now try opening a new line withoand type some characters on the line after a few tabs. If you now start another line, notice that the editor supplies white space at the beginning of the line to line it up with the previous line. You cannot backspace over this indentation, but you can use^Dkey to backtab over the supplied indentation.

Each time you type^Dyou back up one position, normally to an 8 column boundary. This amount is settable; the editor has an option calledshiftwidthwhich you can set to change this value. Try giving the command:se sw=4and then experimenting withautoindentagain.

For shifting lines in the program left and right, there are operators. These shift the lines you specify right or left by one shiftwidth. Try<>which shift one line left or right, andLshifting the rest of the display left and right.

If you have a complicated expression and wish to see how the parentheses match, put the cursor at a left or right parenthesis and hit%. This will show you the matching parenthesis. This works also for braces{and}, and brackets[and].

If you are editingCprograms, you can use the`and`keys to advance or retreat to a line starting with a{, i.e. a function declaration at a time. When]]is used with an operator it stops after a line which starts with}; this is sometimes useful withy]].

You can run system commands over portions of the buffer using the operator!(the exclamation point). Essentially, it sends a section of your file asstandard inputto a shell command, then replaces that portion of your text with the standard output of the command.

All together, the way to specify what text to send and what command to send it to, is!(movement-specifier) command-name. Themovement-specifiercould bewfor operating on the next word, for instance, or}for the next paragraph, etc. Thecommand-nameis the shell command, and any arguments it may take.

This is especially useful for sorting using thesortcommand. You can use this to sort lines in your file. For instance, if you were to type in a list of random words, one per line, and end them with a blank line, then you backed up to the beginning of the list and gave the command!}sort, this would sort the data you just typed in, right before your eyes. This is a very powerful function! Try it for yourself.

If you are editing aLISPprogram you should set the optionlispby doing:se lisp. This changes the(and)commands to move backward and forward over s-expressions. The{and}commands are like(and)but don't stop at atoms. These can be used to skip to the next list, or through acommentquickly.

Theautoindentoption works differently for LISP, supplying indent to align at the firstargumentto the last open list. If there is no such argument then the indent is two spaces more than the last level.

There is another option that is useful for typing in LISP, theshowmatchoption. Try setting it with:se smand then try typing a "(", some words, and then a ")". Notice that the cursor shows the position of the "(" which matches the ")" briefly. This happens only if the matching "(" is on the screen, and the cursor stays there for at most one second.

The editor also has an operator to realign existing lines as though they had been typed in withlispandautoindentset. This is the=operator. Try the command=%at the beginning of afunction. This will realign all the lines of the function declaration.

When you are editing LISP, the`and`advance and retreat to lines beginning with a(, and are useful for dealing with entire function definitions.

vihas a parameterlessmacrofacility, which lets you set it up so that when you hit a single keystroke, the editor will act as though you had hit some longer sequence of keys. You can set this up if you find yourself typing the same sequence of commands repeatedly.

There are two general kinds of macros:

1. Ones where you put the macro body in a named macro bufferx. You can then type@xto invoke the macro. The@may be followed by another@to repeat the last macro.
2. You can use the map command fromvi(typically in yourEXINITenvironment variable) with a command of the form:
   
   

   :map lhs rhsCR

   mappinglhsintorhs. There are restrictions:lhsshould be one keystroke (either 1 character or one function key) since it must be entered within one second (unlessnotimeoutis set, in which case you can type it as slowly as you wish, andviwill wait for you to finish it before it echoes anything). The lhs can be no longer than 10 characters, therhsno longer than 100. To get a space, tab ornewlineintolhsorrhsyou should escape them with a^V. It may be necessary to double the^Vif the map command is given insidevi, rather than inex. Spaces and tabs inside therhsneed not be escaped.

Thus to make theqkey write and exit the editor, you can give the command

:map q :wq^V^VCR CR

which means that whenever you typeq, it will be as though you had typed the four characters:wqCR. A^V's is needed because without it the carriage return would end the:command, rather than becoming part of the map definition. There are two^V's because from withinvi, two^V's must be typed to get one. The first CR is part of therhs, the second terminates the:command.

Macros can be deleted with

unmap lhs

If thelhsof a macro is "#0" through "#9", this maps the particular function key instead of the 2 character "#" sequence. So that terminals without function keys can access such definitions, the form "#x" will mean function keyxon all terminals (and need not be typed within one second). The character "#" can be changed by using a macro in the usual way:

:map ^V^V^I #

to use tab, for example. This won't affect themapcommand, which still uses#, but just the invocation from visual mode.

Theundocommand reverses an entire macro call as a unit, if it made any changes.

Placing a "!" after the word map causes the mapping to apply to input mode, rather than command mode. Thus, to arrange for^Tto be the same as 4 spaces in input mode, you can type:

:map! ^T ^Vb/b/b/b/

whereb/is a blank. The^Vis necessary to prevent the blanks from being taken as white space between thelhsandrhs.

A feature similar to macros in input mode is word abbreviation. This allows you to type a short word and have it expanded into a longer word or words. The commands are:abbreviateand:unabbreviate(:aband:una) and have the same syntax as:map. For example:

:ab eecs Electrical Engineering and Computer Sciences

causes the word "eecs" to always be changed into the phrase "Electrical Engineering and Computer Sciences". Word abbreviation is different from macros in that only whole words are affected. If "eecs" were typed as part of a larger word, it would be left alone. Also, the partial word is echoed as it is typed. There is no need for an abbreviation to be a single keystroke, as it should be with a macro.

The editor folds long logical lines onto many physical lines in the display. Commands which advance lines advance logical lines and will skip over all the segments of a line in one motion. The command|moves the cursor to a specific column, and may be useful for getting near the middle of a long line to split it in half.

The editor only puts full lines on the display; if there is not enough room on the display to fit a logical line, the editor leaves the physical line empty, placing only an@on the line as a place holder. When you delete lines on a dumb terminal, the editor will often just clear the lines to@to save time (rather than rewriting the rest of the screen). You can always maximize the information on the screen by giving the^Rcommand.

If you wish, you can have the editor place line numbers before each line on the display. Give the command:se nuto enable this, and the command:se nonuto turn it off. You can have tabs represented as^Iand the ends of lines indicated with "$" by giving the command:se list;:se nolistturns this off.

Finally, lines consisting of only the character "~" are displayed when the last line in the file is in the middle of the screen. These represent physical lines that are past the logical end of file.

The following table lists the file manipulation commands which you can use when you are invi.

All of these commands are followed by a CR or Esc. The most basic commands are:wand:e. A normal editing session on a single file will end with aZZcommand. If you are editing for a long period of time you can give:wcommands occasionally after major amounts of editing, and then finish with aZZ. When you edit more than one file, you can finish with one with a:wand start editing a new file by giving a:ecommand, or setautowriteand use:nfile.

If you make changes to the editor's copy of a file, but do not wish to write them back, then you must give an!after the command you would otherwise use; this forces the editor to discard any changes you have made. Use this carefully.

The:ecommand can be given a+argument to start at the end of the file, or a+nargument to start at linen. In actuality,nmay be any editor command not containing a space, usefully a scan like+/pator+?pat. In forming new names to theecommand, you can use the character%which is replaced by the current file name, or the character#which is replaced by the alternate filename. The alternate filenameis generally the last name you typed other than the current file. Thus if you try to do a:eand get a diagnostic that you haven't written the file, you can give a:wcommand and then a:e #command to redo the previous:e.

You can write part of the buffer to a file by finding out the lines that bound the range to be written using^G, and giving these numbers after the:and before thew, separated by,'s. You can also mark these lines withmand then use an address of the form'x,'yon thewcommand here.

You can read another file into the buffer after the current line by using the:rcommand. You can similarly read in the output from a command, just use!cmdinstead of a file name.

If you wish to edit a set of files in succession, you can give all the names on the command line, and then edit each one in turn using the command:n. It is also possible to respecify the list of files to be edited by giving the:ncommand a list of file names, or a pattern to be expanded as you would have given it on the initialvicommand.

If you are editing large programs, you will find the:tacommand very useful. It utilizes a data base of function names and their locations, which can be created by programs such asctags, to quickly find a function whose name you give. If the:tacommand will require the editor to switch files, then you must:wor abandon any changes before switching. You can repeat the:tacommand without any arguments to look for the same tag again.

When you are searching for strings in the file with/and?, the editor normally places you at the next or previous occurrence of the string. If you are using an operator such asd,cory, then you may well wish to affect lines up to the line before the line containing the pattern. You can give a search of the form/pat/-nto refer to then'th line before the next line containingpat, or you can use+instead of-to refer to the lines after the one containingpat. If you don't give a line offset, then the editor will affect characters up to the match place, rather than whole lines; thus use "+0" to affect to the line which matches.

You can have the editor ignore the case of words in the searches it does by giving the command:se ic. The command:se noicturns this off.

Strings given to searches may actually beregular expressions. If you do not want or need this facility, you should

set nomagic

in yourEXINIT. In this case, only the characters^and$are special in patterns. The character\is also then special (as it is most everywhere in the system), and may be used to get at the an extended pattern matching facility. It is also necessary to use a\before a/in a forward scan or a?in a backward scan, in any case. The following table gives the extended forms when magic is set.

If you usenomagicmode, then the. [and*primitives are given with a preceding\.

There are a number of characters which you can use to make corrections during input mode. These are summarized in the following table.

The most usual way of making corrections to input is by typing^Hto correct a single character, or by typing one or more^W's to back over incorrect words. If you use#as your erase character in the normal system, it will work like^H.

Your system kill character, normally@,^Xor^U, will erase all the input you have given on the current line. In general, you can neither erase input back around a line boundary nor can you erase characters which you did not insert with this insertion command. To make corrections on the previous line after a new line has been started you can hit Esc to end the insertion, move over and make the correction, and then return to where you were to continue. The commandAwhich appends at the end of the current line is often useful for continuing.

If you wish to type in your erase or kill character (say#or@) then you must precede it with a\, just as you would do at the normal system command level. A more general way of typing non-printing characters into the file is to precede them with a^V. The^Vechoes as a^character on which the cursor rests. This indicates that the editor expects you to type a control character. In fact you may type any character and it will be inserted into the file at that point.

If you are usingautoindentyou can backtab over the indent which it supplies by typing a^D. This backs up to ashiftwidthboundary. This only works immediately after the suppliedautoindent.

When you are usingautoindentyou may wish to place a label at the left margin of a line. The way to do this easily is to type^and then^D. The editor moves the cursor to the left margin for one line, and restore the previous indent on the next. You can also type a0followed immediately by a^Dif you wish to kill all the indent and not have it come back on the next line.

If your terminal has only upper case, you can still useviby using the normal system convention for typing on such a terminal. Characters which you normally type are converted to lower case, and you can type upper case letters by preceding them with a\. The characters{~}|`are not available on such terminals, but you can escape them as\(\^\)\!\'. These characters are represented on the display in the same way they are typed.

viis actually one mode of editing within the editorex. When you are runningviyou can escape to the line oriented editor ofexby giving the commandQ. All of the:commands which were introduced above are available inex. Likewise, mostexcommands can be invoked fromviusing:. Just give them without the:and follow them with a CR.

In rare instances, an internal error may occur invi. In this case you will get a diagnostic and be left in the command mode ofex. You can then save your work and quit if you wish by giving a commandxafter the:whichexprompts you with, or you can reenterviby givingexavicommand.

There are a number of things which you can do more easily inexthan invi. Systematic changes in line-oriented material are particularly easy. You can read the advanced editing documents for the editoredto find out a lot more about this style of editing. Experienced users often mix their use ofexcommand mode andvicommand mode to speed the work they are doing.

This is a summary of all the most usefulvicommands. Refer to it any time you need to remember any ofvi's functions quickly, and at a glance.

From the command line:

From withinvi:

TheEsckey exits each of the following text-entry modes, except forr, which is only used to enter a single character.

(Each of these commands can be used twice to affect entire lines):

vi myfile.txt

Edits the filemyfile.txt.