MirBSD manpage: 12.vi(USD)

           An Introduction to Display Editing with Vi

                           William Joy

                           Mark Horton

                    Computer Science Division
    Department of Electrical Engineering and Computer Science
               University of California, Berkeley
                      Berkeley, Ca.  94720


          Vi (visual) is a display oriented interactive text
     editor.  When using vi the screen of your terminal acts
     as a window  into  the  file  which  you  are  editing.
     Changes  which  you  make  to the file are reflected in
     what you see.

          Using vi you can insert new text any place in  the
     file  quite easily. Most of the commands to vi move the
     cursor around in the file. There are commands  to  move
     the cursor forward and backward in units of characters,
     words, sentences and paragraphs. A small set of  opera-
     tors,  like d for delete and c for change, are combined
     with the motion commands to  form  operations  such  as
     delete  word  or  change  paragraph,  in  a  simple and
     natural way. This regularity and the  mnemonic  assign-
     ment  of  commands to keys makes the editor command set
     easy to remember and to use.

          Vi will work on a large number of  display  termi-
     nals, and new terminals are easily driven after editing
     a terminal description file. While it  is  advantageous
     to  have  an  intelligent  terminal  which  can locally
     insert  and  delete  lines  and  characters  from   the
     display,  the  editor  will function quite well on dumb
     terminals over  slow  phone  lines.  The  editor  makes
     allowance for the low bandwidth in these situations and
     uses smaller window sizes and different display  updat-
     ing  algorithms  to  make best use of the limited speed

          It is also possible to use the command set  of  vi
     on   hardcopy  terminals,  storage  tubes  and  ``glass
     tty's'' using a one-line editing window; thus vi's com-
     mand  set  is available on all terminals. The full com-
     mand set of the more traditional, line oriented  editor

                        December 24, 2022

USD:12-2               An Introduction to Display Editing with Vi

     ex is available within vi; it is quite simple to switch
     between the two modes of editing.

1. Getting started

     This document provides a quick  introduction  to  vi.  (Pro-
nounced vee-eye.) You should be running vi on a file you are fam-
iliar with while you are reading this. The  first  part  of  this
document (sections 1 through 5) describes the basics of using vi.
Some topics of special interest are presented in section  6,  and
some  nitty-gritty  details of how the editor functions are saved
for section 7 to avoid cluttering the presentation here.

     There is also a short appendix here, which  gives  for  each
character  the  special  meanings which this character has in vi.
Attached to this document should be a quick reference card.  This
card summarizes the commands of vi in a very compact format.  You
should have the card handy while you are learning vi.

1.1. Specifying terminal type

     Before you start vi you can tell the  system  what  kind  of
terminal  you  are using. Here is a (necessarily incomplete) list
of terminal type codes. If your terminal does  not  appear  here,
you  should  consult with one of the staff members on your system
to find out the code for your terminal. If your terminal does not
have a code, one can be assigned and a description for the termi-
nal can be created.

       Code       Full name                    Type
       2621       Hewlett-Packard 2621A/P      Intelligent
       2645       Hewlett-Packard 264x         Intelligent
       act4       Microterm ACT-IV             Dumb
       act5       Microterm ACT-V              Dumb
       adm3a      Lear Siegler ADM-3a          Dumb
       adm31      Lear Siegler ADM-31          Intelligent
       c100       Human Design Concept 100     Intelligent
       dm1520     Datamedia 1520               Dumb
       dm2500     Datamedia 2500               Intelligent
       dm3025     Datamedia 3025               Intelligent
       fox        Perkin-Elmer Fox             Dumb
       h1500      Hazeltine 1500               Intelligent
       h19        Heathkit h19                 Intelligent
       i100       Infoton 100                  Intelligent
       mime       Imitating a smart act4       Intelligent
The financial support of  an  IBM  Graduate  Fellowship  and  the
National  Science  Foundation  under  grants  MCS74-07644-A03 and
MCS78-07291 is gratefully acknowledged.

                        December 24, 2022

An Introduction to Display Editing with Vi               USD:12-3

       t1061      Teleray       1061                 Intelligent
       vt52       Dec VT-52                    Dumb

     Suppose for example that you have a Hewlett-Packard  HP2621A
terminal.   The  code  used  by  the  system for this terminal is
`2621'. In this case you can use one of the following commands to
tell the system the type of your terminal:

        % setenv TERM 2621

This command works with the csh shell. If you are using the stan-
dard Bourne shell sh then you should give the command:

        $ export TERM=2621

     If you want to arrange to have your  terminal  type  set  up
automatically  when  you log in, you can use the tset(1) program.
If you dial in on a mime, but often use hardwired ports, a  typi-
cal line for your .login file (if you use csh) would be

        % setenv TERM `tset - -d mime`

or for your .profile file (if you use sh)

        $ export TERM=`tset - -d mime`

Tset knows which terminals are hardwired to each port  and  needs
only to be told that when you dial in you are probably on a mime.
Tset is usually used to change the  erase  and  kill  characters,

1.2. Editing a file

     After telling the system which kind of  terminal  you  have,
you  should  make a copy of a file you are familiar with, and run
vi on this file, giving the command

        % vi name

replacing name with the name of the copy file you  just  created.
The  screen  should clear and the text of your file should appear
on the screen.  If something else  happens  refer  to  the  foot-
++ If you gave the system an incorrect terminal  type  code  then
the  editor  may  have just made a mess out of your screen.  This
happens when it sends control codes for one kind of  terminal  to
some other kind of terminal.  In this case hit the keys :q (colon
and the q key) and then hit the RETURN key. This should  get  you
back  to  the  command level interpreter. Figure out what you did
wrong (ask someone else if necessary) and try again.
     Another thing which can go wrong is that you typed the wrong

                        December 24, 2022

USD:12-4               An Introduction to Display Editing with Vi

1.3. The editor's copy: the buffer

     The editor does not directly modify the file which  you  are
editing. Rather, the editor makes a copy of this file, in a place
called the buffer, and remembers the file's  name.   You  do  not
affect  the  contents  of the file unless and until you write the
changes you make back into the original file.

1.4. Notational conventions

     In our examples, input which must be typed  as  is  will  be
presented  in  bold  face.  Text  which  should  be replaced with
appropriate input will be given in italics.   We  will  represent
special characters in SMALL CAPITALS.

1.5. Arrow keys

     The editor command set is independent of  the  terminal  you
are using.  On most terminals with cursor positioning keys, these
keys will also work within the editor. If you don't  have  cursor
positioning  keys, or even if you do, you can use the h j k and l
keys as cursor positioning keys (these are labelled  with  arrows
on an adm3a).*

     (Particular note for the HP2621: on this terminal the  func-
tion keys must be shifted (ick) to send to the machine, otherwise
they only act locally.  Unshifted use will leave the cursor posi-
tioned incorrectly.)

1.6. Special characters: ESC, CR and DEL

     Several of these special characters are very  important,  so
be  sure to find them right now.  Look on your keyboard for a key
labelled ESC or ALT.  It should be near the upper left corner  of
your terminal. Try hitting this key a few times.  The editor will
ring the bell to indicate that it is in a quiescent state.++ Par-
tially  formed commands are cancelled by ESC, and when you insert
text in the file you end the text insertion with ESC.   This  key
file  name  and  the editor just printed an error diagnostic.  In
this case you should follow the above procedure for  getting  out
of  the  editor  and  try again, this time spelling the file name
     If the editor doesn't seem to respond to the commands  which
you  type here, try sending an interrupt to it by hitting the DEL
or RUB key on your terminal, and  then  hitting  the  :q  command
again followed by a carriage return.

*  As we will see later, h moves back to the left (like control-h
which is a backspace), j moves down (in the same column), k moves
up (in the same column), and l moves to the right.
++ On smart terminals where  it  is  possible,  the  editor  will
quietly flash the screen rather than ringing the bell.

                        December 24, 2022

An Introduction to Display Editing with Vi               USD:12-5

is a fairly harmless one to hit, so you can just hit  it  if  you
don't know what is going on until the editor rings the bell.

     The CR or RETURN key is important because it is used to ter-
minate  certain  commands. It is usually at the right side of the
keyboard, and is the same command used at the end of  each  shell

     Another very useful key is the DEL or RUB  key,  which  gen-
erates an interrupt, telling the editor to stop what it is doing.
It is a forceful way of making the editor listen to  you,  or  to
return  it to the quiescent state if you don't know or don't like
what is going on.  Try hitting the  `/'  key  on  your  terminal.
This key is used when you want to specify a string to be searched
for.  The cursor should now be positioned at the bottom  line  of
the  terminal  after  a `/' printed as a prompt.  You can get the
cursor back to the current position by hitting  the  DEL  or  RUB
key; try this now.* From now on we will simply refer  to  hitting
the DEL or RUB key as ``sending an interrupt.''**

     The editor often echoes your commands on the  last  line  of
the terminal. If the cursor is on the first position of this last
line, then the editor is performing a computation, such  as  com-
puting  a  new  position  in the file after a search or running a
command to reformat part of the buffer. When  this  is  happening
you can stop the editor by sending an interrupt.

1.7. Getting out of the editor

     After you have worked with this introduction  for  a  while,
and you wish to do something else, you can give the command ZZ to
the editor. This will write the contents of the  editor's  buffer
back  into the file you are editing, if you made any changes, and
then quit from the editor.  You can also end an editor session by
giving the command :q!CR;+ this is a dangerous  but  occasionally
essential  command which ends the editor session and discards all
your changes. You need to know about this  command  in  case  you
change  the editor's copy of a file you wish only to look at.  Be
very careful not to give this command when  you  really  want  to
save the changes you have made.

2. Moving around in the file

2.1. Scrolling and paging

     The editor has a number of commands for moving around in the
* Backspacing over the `/' will also cancel the search.
**  On  some systems, this interruptibility comes at a price: you
cannot type ahead when the editor is computing with the cursor on
the bottom line.
+  All commands which read from the last display line can also be
terminated with a ESC as well as an CR.

                        December 24, 2022

USD:12-6               An Introduction to Display Editing with Vi

file. The most useful of these is generated by hitting  the  con-
trol  and  D keys at the same time, a control-D or `^D'.  We will
use this two character notation for referring  to  these  control
keys from now on.

     As you know now  if  you  tried  hitting  ^D,  this  command
scrolls down in the file.  The D thus stands for down.  Many edi-
tor commands are mnemonic and this  makes  them  much  easier  to
remember.   For  instance  the  command to scroll up is ^U.  Many
dumb terminals can't scroll up at all, in which case  hitting  ^U
clears  the  screen and refreshes it with a line which is farther
back in the file at the top.

     If you want to see more of the file below where you are, you
can  hit  ^E to expose one more line at the bottom of the screen,
leaving the cursor where it is. The command ^Y  (which  is  hope-
lessly  non-mnemonic, but next to ^U on the keyboard) exposes one
more line at the top of the screen.

     There are other ways to move around in the file; the keys ^F
and  ^B  move  forward  and  backward a page, keeping a couple of
lines of continuity between screens so that  it  is  possible  to
read  through  a  file  using  these rather than ^D and ^U if you

     Notice the difference between scrolling and paging.  If  you
are trying to read the text in a file, hitting ^F to move forward
a page will leave you only a little  context  to  look  back  at.
Scrolling on the other hand leaves more context, and happens more
smoothly.  You can continue to read the text as scrolling is tak-
ing place.

2.2. Searching, goto, and previous context

     Another way to position yourself in the file  is  by  giving
the editor a string to search for.  Type the character / followed
by a string of characters terminated  by  CR.   The  editor  will
position  the  cursor  at the next occurrence of this string. Try
hitting n to then go to the next occurrence of this  string.  The
character ? will search backwards from where you are, and is oth-
erwise like /.+

     If the search string you give the editor is not  present  in
the  file, the editor will print a diagnostic on the last line of
the screen, and the cursor will be returned to its initial  posi-

+ These searches will normally wrap around the end of  the  file,
and  thus  find  the  string  even  if it is not on a line in the
direction you search provided it is anywhere else  in  the  file.
You  can  disable  this wraparound in scans by giving the command
:se nowrapscanCR, or more briefly :se nowsCR.

                        December 24, 2022

An Introduction to Display Editing with Vi               USD:12-7

     If you wish the search to match only at the beginning  of  a
line,  begin  the  search string with an ^.  To match only at the
end of a line, end the search string with a  $.  Thus  /^searchCR
will search for the word `search' at the beginning of a line, and
/last$CR searches for the word `last' at the end of a line.*

     The command G, when preceded by a number will  position  the
cursor  at that line in the file. Thus 1G will move the cursor to
the first line of the file.  If you give  G  no  count,  then  it
moves to the end of the file.

     If you are near the end of the file, and the  last  line  is
not  at  the bottom of the screen, the editor will place only the
character `~' on each remaining line.  This  indicates  that  the
last  line  in  the file is on the screen; that is, the `~' lines
are past the end of the file.

     You can find out the state of the file you  are  editing  by
typing  a  ^G.  The editor will 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
which you are. Try doing this now, and remember the number of the
line  you  are  on.  Give  a G command to get to the end and then
another G command to get back where you were.

     You can also get back to a previous position  by  using  the
command  `` (two back quotes). This is often more convenient than
G because it requires no advance preparation. Try giving a G or a
search  with  / or ? and then a `` to get back to where you were.
If you accidentally hit n or any command which moves you far away
from  a  context of interest, you can quickly get back by hitting

2.3. Moving around on the screen

     Now try just moving the cursor around on the screen. If your
terminal  has  arrow  keys (4 or 5 keys with arrows going in each
direction) try them and convince yourself that they work. If  you
don't have working arrow keys, you can always use h, j, k, and l.
Experienced users of vi prefer these keys to arrow keys,  because
they are usually right underneath their fingers.

     Hit the + key.  Each time you do,  notice  that  the  cursor
advances  to  the  next  line in the file, at the first non-white
position on the line.  The - key is like +  but  goes  the  other
*Actually, the string you give to search for here can be a  regu-
lar  expression  in  the sense of the editors ex(1) and ed(1). If
you don't wish to learn about this yet, you can disable this more
general  facility by doing :se nomagicCR; by putting this command
in EXINIT in your environment, you can have  this  always  be  in
effect (more about EXINIT later.)

                        December 24, 2022

USD:12-8               An Introduction to Display Editing with Vi

     These are very common keys for moving up and down  lines  in
the  file. Notice that if you go off the bottom or top with these
keys then the screen will scroll down (and  up  if  possible)  to
bring  a  line  at a time into view.  The RETURN key has the same
effect as the + key.

     Vi also has commands to take you to the top, middle and bot-
tom  of the screen. H will take you to the top (home) line on the
screen. Try preceding it with a number as in 3H. This  will  take
you  to  the  third  line  on  the  screen. Many vi commands take
preceding numbers and do interesting things  with  them.  Try  M,
which  takes  you  to the middle line on the screen, and L, which
takes you to the last line on the screen. L  also  takes  counts,
thus 5L will take you to the fifth line from the bottom.

2.4. Moving within a line

     Now try picking a word on some line on the screen,  not  the
first  word on the line. move the cursor using RETURN and - to be
on the line where the word is. Try hitting the w key.  This  will
advance  the cursor to the next word on the line. Try hitting the
b key to back up words in the line. Also  try  the  e  key  which
advances  you  to  the end of the current word rather than to the
beginning of the next word. Also try SPACE (the space bar)  which
moves  right one character and the BS (backspace or ^H) key which
moves left one character. The key h works as ^H does and is  use-
ful  if  you  don't  have a BS key. (Also, as noted just above, l
will move to the right.)

     If the line had punctuation in it you may have noticed  that
that  the w and b keys stopped at each group of punctuation.  You
can also go back and forwards words without stopping at  punctua-
tion  by  using  W  and B rather than the lower case equivalents.
Think of these as bigger words. Try these on  a  few  lines  with
punctuation to see how they differ from the lower case w and b.

     The word keys wrap around the end of line, rather than stop-
ping  at the end.  Try moving to a word on a line below where you
are by repeatedly hitting w.

2.5. Summary

     SPACE    advance the cursor one position
     ^B       backwards to previous page
     ^D       scrolls down in the file
     ^E       exposes another line at the bottom
     ^F       forward to next page
     ^G       tell what is going on
     ^H       backspace the cursor
     ^N       next line, same column
     ^P       previous line, same column
     ^U       scrolls up in the file
     ^Y       exposes another line at the top

                        December 24, 2022

An Introduction to Display Editing with Vi               USD:12-9

     +        next   line,   at    the    beginning
     -        previous    line,    at   the   beginning
     /        scan   for   a   following   string   forwards
     ?        scan           backwards
     B        back   a   word,    ignoring    punctuation
     G        go   to   specified   line,   last   default
     H        home      screen      line
     M        middle      screen      line
     L        last      screen      line
     W        forward    a    word,   ignoring   punctuation
     b        back      a      word
     e        end     of    current    word
     n        scan  for  next  instance  of  /  or   ?   pattern
     w        word after this word

2.6. View

     If you want to use the editor to look at a file, rather than
to  make  changes, invoke it as view instead of vi. This will set
the readonly  option  which  will  prevent  you  from  accidently
overwriting the file.

3. Making simple changes

3.1. Inserting

     One of the most useful commands is the i  (insert)  command.
After  you  type  i,  everything  you  type  until you hit ESC is
inserted into the file. Try this now; position yourself  to  some
word  in the file and try inserting text before this word. If you
are on an dumb terminal it will seem, for a minute, that some  of
the  characters in your line have been overwritten, but they will
reappear when you hit ESC.

     Now try finding a word which can, but does not,  end  in  an
`s'.  Position  yourself  at this word and type e (move to end of
word), then a for append and then `sESC' to terminate the textual
insert. This sequence of commands can be used to easily pluralize
a word.

     Try inserting and appending a few times  to  make  sure  you
understand how this works; i placing text to the left of the cur-
sor, a to the right.

     It is often the case that you want to add new lines  to  the
file  you  are editing, before or after some specific line in the
file.  Find a line where this makes sense and then give the  com-
mand  o  to  create  a new line after the line you are on, or the
command O to create a new line before the line you are on.  After
you  create a new line in this way, text you type up to an ESC is
inserted on the new line.

                        December 24, 2022

USD:12-10              An Introduction to Display Editing with Vi

     Many related editor commands are invoked by the same  letter
key  and differ only in that one is given by a lower case key and
the other is given by an upper case key.   In  these  cases,  the
upper case key often differs from the lower case key in its sense
of direction, with the upper case key working backward and/or up,
while the lower case key moves forward and/or down.

     Whenever you are typing in text, you can give many lines  of
input  or just a few characters. To type in more than one line of
text, hit a RETURN at the middle of your input.  A new line  will
be created for text, and you can continue to type.  If you are on
a slow and dumb terminal the editor may choose to wait to  redraw
the  tail  of the screen, and will let you type over the existing
screen lines. This avoids the lengthy delay which would occur  if
the  editor attempted to keep the tail of the screen always up to
date.  The tail of the screen will be fixed up, and  the  missing
lines will reappear, when you hit ESC.

     While you are inserting new text, you can use the characters
you normally use at the system command level (usually ^H or #) to
backspace over the last character which you typed, and the  char-
acter which you use to kill input lines (usually @, ^X, or ^U) to
erase the input you have typed on the current line.+ The  charac-
ter  ^W  will  erase  a  whole word and leave you after the space
after the previous word; it is useful for quickly backing  up  in
an insert.

     Notice that when you backspace during an insertion the char-
acters  you backspace over are not erased; the cursor moves back-
wards, and the characters remain on the display.  This  is  often
useful  if you are planning to type in something similar.  In any
case the characters disappear when when you hit ESC; if you  want
to get rid of them immediately, hit an ESC and then a again.

     Notice also that you can't erase characters which you didn't
insert,  and  that  you can't backspace around the end of a line.
If you need to back up to the previous line to make a correction,
just  hit  ESC  and  move  the  cursor back to the previous line.
After making the correction you can return to where you were  and
use the insert or append command again.

3.2. Making small corrections

     You can  make  small  corrections  in  existing  text  quite
easily.  Find  a single character which is wrong or just pick any
character. Use the arrow keys to find the character, or get  near
the character with the word motion keys and then either backspace
(hit the BS key or ^H or even just h) or SPACE (using  the  space
bar)  until the cursor is on the character which is wrong. If the
+ In fact, the character ^H (backspace) always works to erase the
last  input character here, regardless of what your erase charac-
ter is.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-11

character is not needed then hit the  x  key;  this  deletes  the
character  from  the  file.  It is analogous to the way you x out
characters when you make mistakes on a  typewriter  (except  it's
not as messy).

     If the character is incorrect, you can replace it  with  the
correct  character  by giving the command rc, where c is replaced
by the correct character.  Finally  if  the  character  which  is
incorrect should be replaced by more than one character, give the
command s which substitutes a string of characters,  ending  with
ESC,  for it. If there are a small number of characters which are
wrong you can precede s with a count of the number of  characters
to  be  replaced.   Counts  are also useful with x to specify the
number of characters to be deleted.

3.3. More corrections: operators

     You already know almost enough to make changes at  a  higher
level.  All  you  need  to  know  now is that the d key acts as a
delete operator.  Try the command dw to delete a word.  Try  hit-
ting  .  a few times.  Notice that this repeats the effect of the
dw.  The command . repeats the last command which made a  change.
You can remember it by analogy with an ellipsis `...'.

     Now try db.  This  deletes  a  word  backwards,  namely  the
preceding word. Try dSPACE.  This deletes a single character, and
is equivalent to the x command.

     Another very useful operator is c or change.  The command cw
thus  changes  the  text  of  a single word. You follow it by the
replacement text ending with an ESC. Find a word  which  you  can
change  to  another, and try this now. Notice that the end of the
text to be changed was marked with the character `$' so that  you
can see this as you are typing in the new material.

3.4. Operating on lines

     It is often the case that you want to operate on lines. Find
a  line  which  you  want  to delete, and type dd, the d operator
twice.  This will delete the line. If you are on a dumb terminal,
the  editor  may  just erase the line on the screen, replacing it
with a line with only an @ on it.  This line does not  correspond
to  any  line  in your file, but only acts as a place holder.  It
helps to avoid a lengthy redraw of the rest of the  screen  which
would  be  necessary to close up the hole created by the deletion
on a terminal without a delete line capability.

     Try repeating the c operator twice; this will change a whole
line,  erasing its previous contents and replacing them with text
you type up to an ESC.+
+ The command S is a convenient synonym for for  cc,  by  analogy
with  s.   Think of S as a substitute on lines, while s is a sub-
stitute on characters.

                        December 24, 2022

USD:12-12              An Introduction to Display Editing with Vi

     You can delete or change more than one line by preceding the
dd  or  cc  with  a count, i.e. 5dd deletes 5 lines. You can also
give a command like dL to delete all the lines up to and  includ-
ing  the  last  line  on the screen, or d3L to delete through the
third from the bottom line.  Try some commands  like  this  now.*
Notice  that  the  editor  lets  you know when you change a large
number of lines so that you can see the extent of the change. The
editor  will  also always tell you when a change you make affects
text which you cannot see.

3.5. Undoing

     Now  suppose  that  the  last  change  which  you  made  was
incorrect;  you  could use the insert, delete and append commands
to put the correct material back.  However, since it is often the
case  that  we  regret a change or make a change incorrectly, the
editor provides a u (undo) command to  reverse  the  last  change
which  you made. Try this a few times, and give it twice in a row
to notice that a u also undoes a u.

     The undo command lets you  reverse  only  a  single  change.
After you make a number of changes to a line, you may decide that
you would rather have the original state of the line back.  The U
command restores the current line to the state before you started
changing it. Additionally, an unlimited number of changes may  be
reversed  by  following a u with a .. Each subsequent . will undo
one more change.

     You can recover text which you delete, even if undo will not
bring it back; see the section on recovering lost text below.

3.6. Summary

     SPACE     advance the cursor one position
     ^H        backspace the cursor
     werase    (usually ^W), erase a word during an insert
     erase     (usually DEL or ^H), erases a character during an insert
     kill      (usually ^U), kills the insert on this line
     .         repeats the changing command
     O         opens and inputs new lines, above the current
     U         undoes the changes you made to the current line
     a         appends text after the cursor
     c         changes the object you specify to the following text
     d         deletes the object you specify
     i         inserts text before the cursor
     o         opens and inputs new lines, below the current
* One subtle point here involves using the / search  after  a  d.
This will normally delete characters from the current position to
the point of the match.  If what is desired is  to  delete  whole
lines  including  the  two points, give the pattern as /pat/+0, a
line address.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-13

     u         undoes                  the                   last

4. Moving about; rearranging and duplicating text

4.1. Low level character motions

     Now move the cursor to a line where there is  a  punctuation
or  a  bracketing  character  such as a parenthesis or a comma or
period.  Try the command fx, where x  is  this  character.   This
command  finds the next x character to the right of the cursor in
the current line.  Try then hitting a ;,  which  finds  the  next
instance  of the same character.  By using the f command and then
a sequence of ;'s you can often get to a particular  place  in  a
line  much faster than with a sequence of word motions or SPACEs.
There is also an F command, which is like f, but  searches  back-
ward.  The ; command repeats F also.

     When you are operating on the text in a  line  it  is  often
desirable  to  deal with the characters up to, but not including,
the first instance of a character.  Try dfx for some  x  now  and
notice  that  the  text  up to (and including) the x character is
deleted. Undo this with u and then try dtx; the t here stands for
to,  i.e.  delete up to the next x, but not the x.  The command T
is the reverse of t.

     When working with the text of a single line, a ^  moves  the
cursor to the first non-white position on the line, and a $ moves
it to the end of the line.  Thus $a will append new text  at  the
end of the current line.

     Your file may have tab (^I) characters in it.  These charac-
ters  are  represented  as  a number of spaces expanding to a tab
stop, where tab stops are every 8 positions.* When the cursor  is
at  a  tab,  it  sits  on  the  last  of the several spaces which
represent that tab.  Try moving the cursor back  and  forth  over
tabs so you understand how this works.

     On rare occasions, your file may have nonprinting characters
in  it.  These  characters are displayed in the same way they are
represented in this document, that is with a two character  code,
the  first character of which is `^'.  On the screen non-printing
characters resemble a `^'  character  adjacent  to  another,  but
spacing  or  backspacing  over the character will reveal that the
two characters are, like the spaces representing a tab character,
a single character.

     The editor sometimes discards control characters,  depending
* This is settable by a command of the form :se ts=xCR,  where  x
is  4  to set tabstops every four columns.  This has an effect on
the screen representation within the editor.

                        December 24, 2022

USD:12-14              An Introduction to Display Editing with Vi

on the character and the setting of the beautify option,  if  you
attempt  to insert them in your file. You can get a control char-
acter in the file by beginning an insert and  then  typing  a  ^V
before  the control character.  The ^V quotes the following char-
acter, causing it to be inserted directly into the file.

4.2. Higher level text objects

     In working with a document it is often advantageous to  work
in  terms of sentences, paragraphs, and sections.  The operations
( and ) move to the beginning of the previous and next  sentences
respectively.  Thus  the  command  d) will delete the rest of the
current sentence; likewise d( will delete the  previous  sentence
if  you  are  at  the  beginning  of the current sentence, or the
current sentence up to where you are if you are not at the begin-
ning of the current sentence.

     A sentence is defined to end at a `.', `!' or `?'  which  is
followed  by  either  the  end  of a line, or by two spaces.  Any
number of closing `)', `]', `"' and  `''  characters  may  appear
after the `.', `!' or `?' before the spaces or end of line.

     The operations { and } move over paragraphs and  the  opera-
tions [[ and ]] move over sections.+

     A paragraph begins after each empty line, and also  at  each
of  a  set of paragraph macros, specified by the pairs of charac-
ters in the definition of the string  valued  option  paragraphs.
The  default setting for this option defines the paragraph macros
of the -ms and -mm macro packages, i.e. the `.IP',  `.LP',  `.PP'
and `.QP', `.P' and `.LI' macros.++ Each  paragraph  boundary  is
also  a  sentence  boundary.  The sentence and paragraph commands
can be given counts to operate over groups of sentences and para-

     Sections in the editor begin after each macro  in  the  sec-
tions  option,  normally  `.NH',  `.SH', `.H' and `.HU', and each
line with a formfeed ^L in the first column.  Section  boundaries
are always line and paragraph boundaries also.

     Try experimenting with the sentence and  paragraph  commands
until  you are sure how they work.  If you have a large document,
+ The [[ and ]] operations require the operation character to  be
doubled  because  they  can  move  the  cursor  far from where it
currently is.  While it is easy to get back with the command  ``,
these  commands  would  still be frustrating if they were easy to
hit accidentally.
++  You can easily change or extend this set of macros by assign-
ing a different string to the paragraphs option in  your  EXINIT.
See  section  6.2  for  details. The `.bp' directive is also con-
sidered to start a paragraph.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-15

try looking through it using the section  commands.  The  section
commands  interpret  a preceding count as a different window size
in which to redraw the screen at the new location, and this  win-
dow  size  is the base size for newly drawn windows until another
size is specified. This is very useful if you are on a slow  ter-
minal  and are looking for a particular section. You can give the
first section command a small count to then see  each  successive
section heading in a small window.

4.3. Rearranging and duplicating text

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

     The operator y yanks a copy of the object which follows into
the  unnamed  buffer.  If preceded by a buffer name, "xy, where x
here is replaced by a letter a-z, it places the text in the named
buffer.   The text can then be put back in the file with the com-
mands p and P; p puts the text after or below the cursor, while P
puts the text before or above the cursor.

     If the text which you yank forms a 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 if you use P).  If the yanked text forms
whole lines, they will be put back as whole lines, without chang-
ing  the current line.  In this case, the put acts much like an o
or O command.

     Try the command YP.  This makes a copy of the  current  line
and  leaves  you on this copy, which is placed before the current
line. The command Y is a convenient abbreviation for yy. The com-
mand  Yp  will also make a copy of the current line, and place it
after the current line.  You can give Y a count of lines to yank,
and thus duplicate several lines; try 3YP.

     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 deleting 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 nameCR where name is the name of
the other file you want to edit.  You will have to write back the
contents  of  the  current editor buffer (or discard them) if you
have made changes before the editor will let you  switch  to  the
other  file.  An  ordinary  delete  command saves the text in the
unnamed buffer, so that an ordinary put can  move  it  elsewhere.
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.

                        December 24, 2022

USD:12-16              An Introduction to Display Editing with Vi

4.4. Summary.

     ^        first non-white on line
     $        end of line
     )        forward sentence
     }        forward paragraph
     ]]       forward section
     (        backward sentence
     {        backward paragraph
     [[       backward section
     fx       find x forward in line
     p        put text back, after cursor or below current line
     y        yank operator, for copies and moves
     tx       up to x forward, for operators
     Fx       f backward in line
     P        put text back, before cursor or above current line
     Tx       t backward in line

5. High level commands

5.1. Writing, quitting, editing new files

     So far we have seen how to enter vi and  to  write  out  our
file  using  either  ZZ or :wCR. The first exits from the editor,
(writing if changes were made), the second writes  and  stays  in
the editor.

     If you have changed the editor's copy of the file but do not
wish  to save your changes, either because you messed up the file
or decided that the changes are not an improvement to  the  file,
then  you  can  give  the  command  :q!CR to quit from the editor
without writing the changes. You can also reedit  the  same  file
(starting  over)  by  giving  the  command :e!CR.  These commands
should be used only rarely, and with caution, as it is not possi-
ble  to  recover the changes you have made after you discard them
in this manner.

     You can edit a different file without leaving the editor  by
giving  the  command :e nameCR.  If you have not written out your
file before you try to do this, then the  editor  will  tell  you
this,  and  delay  editing the other file.  You can then give the
command :wCR to save your work and  then  the  :e nameCR  command
again,  or carefully give the command :e! nameCR, which edits the
other file discarding the changes you have made  to  the  current
file.  To have the editor automatically save changes, include set
autowrite in your EXINIT, and use :n instead of :e.

5.2. Escaping to a shell

     You can get to a shell to execute a single command by giving
a  vi command of the form :!cmdCR. The system will run the single
command cmd and when the command finishes, the  editor  will  ask

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-17

you  to hit a RETURN to continue.  When you have finished looking
at the output on the screen, you should hit RETURN and the editor
will clear the screen and redraw it.  You can then continue edit-
ing. You can also give another : command when it asks you  for  a
RETURN; in this case the screen will not be redrawn.

     If you wish to execute more than one command in  the  shell,
then  you  can  give  the command :shCR. This will give you a new
shell, and when you finish with the shell, ending it by typing  a
^D, the editor will clear the screen and continue.

     On systems which support it, ^Z will suspend the editor  and
return  to the (top level) shell. When the editor is resumed, the
screen will be redrawn.

5.3. Marking and returning

     The command `` returned to the previous place after a motion
of  the cursor by a command such as /, ? or G.  You can also mark
lines in the file with single letter tags  and  return  to  these
marks  later  by  naming  the tags.  Try marking the current line
with the command mx, where you should pick some letter for x, say
`a'.  Then move the cursor to a different line (any way you like)
and hit `a.  The cursor  will  return  to  the  place  which  you
marked. Marks last only until you edit another file.

     When using operators such  as  d  and  referring  to  marked
lines,  it  is  often desirable to delete whole lines rather than
deleting to the exact position in the line marked by m.  In  this
case  you  can  use  the form 'x rather than `x.  Used without an
operator, 'x will move to the first non-white  character  of  the
marked  line; similarly '' moves to the first non-white character
of the line containing the previous context mark ``.

5.4. Adjusting the screen

     If the screen image is messed up because of  a  transmission
error  to  your  terminal, or because some program other than the
editor wrote output to your terminal, you can hit a ^L, the ASCII
form-feed character, to cause the screen to be refreshed.

     On a dumb terminal, if there are @ lines in  the  middle  of
the screen as a result of line deletion, you may get rid of these
lines by typing ^R to cause the  editor  to  retype  the  screen,
closing up these holes.

     Finally, if you wish to place a certain line on  the  screen
at the top, middle, or bottom of the screen, you can position the
cursor to that line, and then give a z command. You should follow
the z command with a RETURN if you want the line to appear at the
top of the window, a . if you want it at the center, or  a  -  if
you want it at the bottom.

                        December 24, 2022

USD:12-18              An Introduction to Display Editing with Vi

6. Special topics

6.1. Editing on slow terminals

     When you are on a slow terminal, it is  important  to  limit
the  amount  of  output which is generated to your screen so that
you will not suffer long delays, waiting for  the  screen  to  be
refreshed.   We have already pointed out how the editor optimizes
the updating of the screen during insertions on dumb terminals to
limit  the delays, and how the editor erases lines to @ when they
are deleted on dumb terminals.

     The editor also makes editing more pleasant at low speed  by
starting editing in a small window, and letting the window expand
as you edit. This works particularly well on  intelligent  termi-
nals.  The editor can expand the window easily when you insert in
the middle of the screen on these terminals.   If  possible,  try
the editor on an intelligent terminal to see how this works.

     You can control the size of the window which is redrawn each
time  the screen is cleared by giving window sizes as argument to
the commands which cause large screen motions:

        :  /  ?  [[  ]]  `  '

Thus if you are searching for a particular instance of  a  common
string  in  a file, you can precede the first search command by a
small number, say 3, and the editor will draw three line  windows
around each instance of the string which it locates.

     You can easily expand or contract the  window,  placing  the
current  line  as  you choose, by giving a number on a z command,
after the z and before the following RETURN, . or  -.   Thus  the
command  z5.  redraws  the  screen  with  the current line in the
center of a five line window.+

     If the editor is redrawing or otherwise updating large  por-
tions  of the display, you can interrupt this updating by hitting
a DEL or RUB as usual.  If you do this you may partially  confuse
the  editor about what is displayed on the screen.  You can still
edit the text on the screen if you wish; clear up  the  confusion
by  hitting  a  ^L; or move or search again, ignoring the current
state of the display.

6.2. Options, set, and editor startup files

     The editor has a set of options, some  of  which  have  been
mentioned above. The most useful options are given in the follow-
ing table.

+ Note that the command 5z. has  an  entirely  different  effect,
placing line 5 in the center of a new window.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-19

     The options are of three  kinds:   numeric  options,  string
options,  and  toggle  options.   You  can set numeric and string
options by a statement of the form

        set opt=val

and toggle options can be set or unset by statements  of  one  of
the forms

        set opt
        set noopt

Name         Default                     Description
autoindent   noai                        Supply indentation automatically
autowrite    noaw                        Auto write before :n, :ta, ^^, !
ignorecase   noic                        Ignore case in searching
list         nolist                      Tabs print as ^I; end of lines $
magic        magic                       . [ and * are special in scans
number       nonu                        Lines prefixed with line numbers
paragraphs   para=IPLPPPQPP LIpplpipbp   Macros which start paragraphs
ruler        noruler                     Display a row/column ruler.
sections     sect=NHSHH HUnhsh           Macros which start new sections
shiftwidth   sw=8                        Shift distance for <, >, ^D and ^T
showmatch    nosm                        Show matching ( or {
term         $TERM                       The kind of terminal being used

These statements can be placed in your EXINIT  in  your  environ-
ment,  or given while you are running vi by preceding them with a
: and following them with a CR.

     You can get a list of all options which you have changed  by
the  command  :setCR, or the value of a single option by the com-
mand :set opt?CR. A list of all possible options and their values
is  generated  by :set allCR. Set can be abbreviated se. Multiple
options can be placed on one line, e.g. :se ai aw nuCR.

     Options set by the set command only last while you  stay  in
the  editor.  It  is  common  to want to have certain options set
whenever you use the editor. This can be accomplished by creating
a list of ex commands+ which are to be run every time  you  start
up  ex or vi. A typical list includes a set command, and possibly
a few map commands. Since it is advisable to get  these  commands
on  one  line,  they  can  be separated with the | character, for

        set ai aw terse|map @ dd|map # x

which sets the options autoindent, autowrite, terse (the set com-
mand),  makes @ delete a line (the first map), and makes # delete
+ All commands which start with : are ex commands.

                        December 24, 2022

USD:12-20              An Introduction to Display Editing with Vi

a character (the second map). (See section 6.9 for a  description
of the map command.) This string should be placed in the variable
EXINIT in your environment. If you use the shell  csh,  put  this
line in the file .login in your home directory:

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

If you use the standard shell sh, put these  lines  in  the  file
.profile in your home directory:

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

Of course, the particulars of the  line  would  depend  on  which
options you wanted to set.

6.3. Recovering lost lines

     You might have a serious problem if you delete a  number  of
lines  and  then regret that they were deleted.  Despair not, the
editor saves the last 9 deleted blocks of text in a set  of  num-
bered  registers  1-9. You can get the n'th previous deleted text
back in your file by the command "np. The  "  here  says  that  a
buffer  name is to follow, n is the number of the buffer you wish
to try (use the number 1 for now), and  p  is  the  put  command,
which  puts  text in the buffer after the cursor. If this doesn't
bring back the text you wanted, hit u to undo  this  and  then  .
(period) to repeat the put command. In general the . command will
repeat the last change you made. As a special case, when the last
command  refers  to  a numbered text buffer, the . command incre-
ments the number of the  buffer  before  repeating  the  command.
Thus a sequence of the form


will, if repeated long enough, show  you  all  the  deleted  text
which has been saved for you. You can omit the u commands here to
gather up all this text in the buffer, or stop after any  .  com-
mand to keep just the then recovered text. The command P can also
be used rather than p to put the  recovered  text  before  rather
than after the cursor.

6.4. Recovering lost files

     If the system crashes, you can recover  the  work  you  were
doing  to  within  a few changes.  You will normally receive mail
when you next login giving you the name of  the  file  which  has
been saved for you. You should then change to the directory where
you were when the system crashed and give a command of the form:

        % vi -r name

replacing name with the name of the file which you were  editing.
This will recover your work to a point near where you left off.+

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-21

     You can get a listing of the files which are saved  for  you
by giving the command:

        % vi -r

If there is more than one instance of a  particular  file  saved,
the  editor  gives  you the newest instance each time you recover
it.  You can thus get an older saved copy back by first  recover-
ing the newer copies.

     For this feature to work, vi must be correctly installed  by
a  super  user on your system, and the mail program must exist to
receive mail. The invocation ``vi -r'' will not always  list  all
saved  files,  but  they  can  be  recovered even if they are not

6.5. Continuous text input

     When you are typing in large amounts  of  text  it  is  con-
venient to have lines broken near the right margin automatically.
You can cause this to happen by giving the command  :se  wm=10CR.
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 with J.  You can
give J a count of the number of lines to be joined as  in  3J  to
join 3 lines.  The editor supplies whitespace, if appropriate, at
the juncture of the joined lines, and leaves the cursor  at  this
whitespace.  You can kill the whitespace with x if you don't want

6.6. Features for editing programs

     The editor has a number of commands  for  editing  programs.
The  thing that most distinguishes editing of programs from edit-
ing of text is the desirability of maintaining an indented struc-
ture  to  the  body of the program.  The editor has an autoindent
facility for helping you generate correctly indented programs.

     To enable this facility you can give the command  :se  aiCR.
Now try opening a new line with o and type some characters on the
line after a few tabs.  If you now  start  another  line,  notice
that  the editor supplies whitespace at the beginning of the line
to line it up with the previous line.  You cannot backspace  over
this  indentation,  but  you  can  use ^D key to backtab over the
+ In rare cases, some of the lines of the file may be lost.   The
editor  will  give you the numbers of these lines and the text of
the lines will be replaced by the  string  `LOST'.   These  lines
will  almost always be among the last few which you changed.  You
can either choose to discard the changes which you made (if  they
are easy to remake) or to replace the few lost lines by hand.

                        December 24, 2022

USD:12-22              An Introduction to Display Editing with Vi

supplied indentation.

     Each time you type ^D you back up one position, normally  to
an 8 column boundary.  This amount is settable; the editor has an
option called shiftwidth which you can set to change this  value.
Try  giving  the  command  :se sw=4CR and then experimenting with
autoindent again.

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

     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 editing C programs, 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 use-
ful with y]].

6.7. Filtering portions of the buffer

     You can run system commands  over  portions  of  the  buffer
using  the  operator  !.  You  can  use this to sort lines in the
buffer, or to reformat portions of  the  buffer  with  a  pretty-
printer.  Try typing in a list of random words, one per line, and
ending them with a blank line.  Back up to the beginning  of  the
list,  and then give the command !}sortCR.  This says to sort the
next paragraph of material, and the blank line ends a paragraph.

6.8. Macros

     Vi has a parameterless macro facility, 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

     Briefly, there are two flavors of macros:

a)   Ones where you put the macro body in a buffer register,  say
     x.  You  can then type @x to invoke the macro.  The @ may be
     followed by another @ to repeat the last macro.

b)   You can use the map  command  from  vi  (typically  in  your
     EXINIT) with a command of the form:

             :map lhs rhsCR

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-23

     mapping lhs into rhs. There are restrictions: lhs should  be
     one keystroke (either 1 character or one function key) since
     it must be entered within one second  (unless  notimeout  is
     set,  in  which  case you can type it as slowly as you wish,
     and vi will wait for you to finish it before it echoes  any-
     thing). The lhs can be no longer than 10 characters, the rhs
     no longer than 100. To get a space, tab or newline into  lhs
     or  rhs  you should escape them with a ^V. (It may be neces-
     sary to double the ^V if the map command is given inside vi,
     rather  than in ex.) Spaces and tabs inside the rhs need not
     be escaped.

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

        :map q :wq^V^VCR CR

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

     Macros can be deleted with

        unmap lhs

     If the lhs of 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 key x on all
terminals (and need not be typed within one second). The  charac-
ter ``#'' can be changed by using a macro in the usual way:

        :map ^V^V^I #

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

     The undo command 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 ^T
to be the same as 4 spaces in input mode, you can type:

        :map ^T ^V////

where b/ is a blank. The ^V is necessary  to  prevent  the  blanks
from being taken as whitespace between the lhs and rhs.

                        December 24, 2022

USD:12-24              An Introduction to Display Editing with Vi

7. Word Abbreviations

     A feature similar to macros in input mode is word  abbrevia-
tion.  This  allows you to type a short word and have it expanded
into a longer word or words. The  commands  are  :abbreviate  and
:unabbreviate  (:ab  and  :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.

7.1. Abbreviations

     The editor has a number of short commands  which  abbreviate
longer  commands  which  we  have  introduced here.  You can find
these commands easily on the quick  reference  card.  They  often
save a bit of typing and you can learn them as convenient.

8. Nitty-gritty details

8.1. Line representation in the display

     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.   Try  80|  on a line which is more than 80 columns

     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 ^R command.

     If you wish, you can have  the  editor  place  line  numbers
before  each  line  on the display.  Give the command :se nuCR to
enable this, and the command :se nonuCR to turn it off.  You  can
have  tabs represented as ^I and the ends of lines indicated with
`$' by giving the command :se listCR;  :se  nolistCR  turns  this
+ You can make long lines very easily by using J to join together
short lines.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-25


     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 which are past the  logi-
cal end of file.

8.2. Counts

     Most vi commands will use a preceding count to affect  their
behavior  in  some way. The following table gives the common ways
in which the counts are used:

        new window size      :  /  ?  [[  ]]  `  '
        scroll amount        ^D  ^U
        line/column number   z  G  |
        repeat effect        most of the rest

     The editor maintains a notion of the current default  window
size. On terminals which run at speeds greater than 1200 baud the
editor uses the full terminal  screen.  On  terminals  which  are
slower  than  1200 baud (most dialup lines are in this group) the
editor uses 8 lines as the default window size. At 1200 baud  the
default is 16 lines.

     This size is the  size  used  when  the  editor  clears  and
refills  the screen after a search or other motion moves far from
the edge of the current window. The commands  which  take  a  new
window  size  as  count all often cause the screen to be redrawn.
If you anticipate this, but do not need as large a window as  you
are  currently  using,  you may wish to change the screen size by
specifying the new size before these commands. In any  case,  the
number  of  lines  used on the screen will expand if you move off
the top with a - or similar command or off the bottom with a com-
mand  such  as  RETURN  or ^D. The window will revert to the last
specified size the next time it is cleared and refilled.+

     The scroll commands ^D and ^U likewise remember  the  amount
of  scroll  last specified, using half the basic window size ini-
tially. The simple insert commands  use  a  count  to  specify  a
repetition  of the inserted text.  Thus 10a+----ESC will insert a
grid-like string of text. A few commands  also  use  a  preceding
count as a line or column number.

     Except for a few commands which ignore any counts  (such  as
^R),  the  rest  of the editor commands use a count to indicate a
simple repetition of their effect.  Thus 5w advances  five  words
on  the  current line, while 5RETURN advances five lines.  A very
+ But not by a ^L which just redraws the screen as it is.

                        December 24, 2022

USD:12-26              An Introduction to Display Editing with Vi

useful instance of a count as a repetition is a  count  given  to
the  .  command, which repeats the last changing command.  If you
do dw and then 3., you will  delete  first  one  and  then  three
words.  You can then delete two more words with 2..

8.3. More file manipulation commands

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

        :w           write back changes
        :wq          write and quit
        :x           write (if necessary) and quit (same as ZZ)
        :e name      edit file name
        :e!          reedit, discarding changes
        :e + name    edit, starting at end
        :e +n        edit, starting at line n
        :e #         edit alternate file
        :w name      write file name
        :w! name     overwrite file name
        :x,yw name   write lines x through y to name
        :r name      read file name into buffer
        :r !cmd      read output of cmd into buffer
        :n           edit next file in argument list
        :n!          edit next file, discarding changes to current
        :n args      specify new argument list
        :ta tag      edit file containing tag tag, at tag

All of these commands are followed by a CR or ESC. The most basic
commands are :w and :e. A normal editing session on a single file
will end with a ZZ command. If you are editing for a long  period
of time you can give :w commands occasionally after major amounts
of editing, and then finish with a ZZ.   When you edit more  than
one  file,  you can finish with one with a :w and start editing a
new file by giving a :e command, or  set  autowrite  and  use  :n

     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  dis-
card any changes you have made.  Use this carefully.

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

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-27


     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 the w, separated by ,'s. You
can  also  mark these lines with m and then use an address of the
form 'x,'y on the w command here.

     You can read another file into the buffer after the  current
line  by using the :r command. You can similarly read in the out-
put from a command, just use !cmd instead 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 :n command a list of
file names, or a pattern to be expanded as you would  have  given
it on the initial vi command.

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

8.4. More about searching for strings

     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 as d, c  or  y,
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/-n to refer to the n'th line before the next line containing
pat, or you can use + instead of - to refer to  the  lines  after
the one containing pat. 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 icCR. The command :se
noicCR turns this off.

     Strings given to searches may actually  be  regular  expres-
sions. If you do not want or need this facility, you should

        set nomagic

in your EXINIT. 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,

                        December 24, 2022

USD:12-28              An Introduction to Display Editing with Vi

in  any  case.  The following table gives the extended forms when
magic is set.

        ^        at beginning of pattern, matches beginning of line
        $        at end of pattern, matches end of line
        .        matches any character
        \<       matches the beginning of a word
        \>       matches the end of a word
        [str]    matches any single character in str
        [^str]   matches any single character not in str
        [x-y]    matches any character between x and y
        *        matches any number of the preceding pattern

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

8.5. More about input mode

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

        ^H      deletes the last input character
        ^W      deletes the last input word, defined as by b
        erase   your erase character, same as ^H
        kill    your kill character, deletes the input on this line
        \       escapes a following ^H and your erase and kill
        ESC     ends an insertion
        DEL     interrupts an insertion, terminating it abnormally
        CR      starts a new line
        ^D      backtabs over autoindent
        0^D     kills all the autoindent
        ^^D     same as 0^D, but restores indent next line
        ^V      quotes the next non-printing character into the file

     The most usual way of making corrections to input is by typ-
ing  ^H  to  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 @, ^X or ^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  command  A  which  appends at the end of the
current line is often useful for continuing.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-29

     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 ^V echoes 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 using autoindent you can backtab over the  indent
which  it supplies by typing a ^D.  This backs up to a shiftwidth
boundary. This only works immediately after the supplied  autoin-

     When you are using autoindent you 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 will move the cursor to the  left
margin for one line, and restore the previous indent on the next.
You can also type a 0 followed immediately by a ^D if you wish to
kill all the indent and not have it come back on the next line.

8.6. Upper case only terminals

     If your terminal has only upper case, you can still  use  vi
by using the normal system convention for typing on such a termi-
nal. 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  termi-
nals, but you can escape them as \( \^ \) \! \'. These characters
are represented on the display in the same way they are typed.++

8.7. Vi and ex

     Vi is actually one mode of editing  within  the  editor  ex.
When  you are running vi you can escape to the line oriented edi-
tor of ex by giving the command Q. All of the  :  commands  which
were introduced above are available in ex. Likewise, most ex com-
mands can be invoked from vi using :. Just give them without  the
: and follow them with a CR.

* This is not quite true.  The implementation of the editor  does
not  allow  the NULL (^@) character to appear in files.  Also the
LF (linefeed or ^J) character is used by the editor  to  separate
lines  in  the file, so it cannot appear in the middle of a line.
You can insert any other character, however, if you wait for  the
editor to echo the ^ before you type the character.  In fact, the
editor will treat  a  following  letter  as  a  request  for  the
corresponding control character.  This is the only way to type ^S
or ^Q, since the system normally uses them to suspend and  resume
output and never gives them to the editor to process.
++ The \ character you give will not echo until you type  another

                        December 24, 2022

USD:12-30              An Introduction to Display Editing with Vi

     In rare instances, an internal error may  occur  in  vi.  In
this  case  you  will get a diagnostic and be left in the command
mode of ex. You can then save your work and quit if you  wish  by
giving  a command x after the : which ex prompts you with, or you
can reenter vi by giving ex a vi command.

     There are a number of things which you can do more easily in
ex  than  in vi. Systematic changes in line oriented material are
particularly easy. You can read the  advanced  editing  documents
for  the  editor  ed  to  find out a lot more about this style of
editing. Experienced users often mix their use of ex command mode
and vi command mode to speed the work they are doing.


     Bruce  Englar  encouraged  the  early  development  of  this
display  editor. Peter Kessler helped bring sanity to version 2's
command layout. Bill Joy wrote versions 1 and  2.0  through  2.7,
and  created  the framework that users see in the present editor.
Mark Horton added macros and other features and made  the  editor
work on a large number of terminals and Unix systems.

Appendix: character functions

     This appendix gives the uses the editor makes of each  char-
acter.   The characters are presented in their order in the ASCII
character set:  Control characters come first, then most  special
characters,  then  the  digits, upper and then lower case charac-

     For each character we tell a meaning it has as a command and
any  meaning it has during an insert. If it has only meaning as a
command,  then  only  this  is  discussed.  Section  numbers   in
parentheses  indicate  where  the  character  is discussed; a `f'
after the section number means that the character is mentioned in
a footnote.

^@             Not a command character. If  typed  as  the  first
               character  of an insertion it is replaced with the
               last text inserted,  and  the  insert  terminates.
               Only  128  characters  are  saved  from  the  last
               insert;  if  more  characters  were  inserted  the
               mechanism is not available. A ^@ cannot be part of
               the file due to the editor implementation (7.5f).

^A             Search forward for the current word.

^B             Backward window. A count specifies repetition. Two
               lines  of  continuity  are  kept if possible (2.1,
               6.1, 7.2).

^C             Unused.

^D             As a command, scrolls down a half-window of  text.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-21

               A  count  gives  the  number of (logical) lines to
               scroll, and is remembered for  future  ^D  and  ^U
               commands  (2.1,  7.2).  During an insert, backtabs
               over autoindent whitespace at the beginning  of  a
               line  (6.6,  7.5); this whitespace cannot be back-
               spaced over.

^E             Exposes one more line below the current screen  in
               the file, leaving the cursor where it is if possi-
               ble. (Version 3 only.)

^F             Forward window.  A count specifies repetition. Two
               lines  of  continuity  are  kept if possible (2.1,
               6.1, 7.2).

^G             Equivalent to :fCR,  printing  the  current  file,
               whether  it  has  been  modified, the current line
               number and the number of lines in  the  file,  and
               the  percentage  of  the way through the file that
               you are.

^H (BS)        Same as left arrow. (See  h).  During  an  insert,
               eliminates  the last input character, backing over
               it but not erasing it; it remains so you  can  see
               what  you typed if you wish to type something only
               slightly different (3.1, 7.5).

^I (TAB)       Not a command character. When inserted  it  prints
               as  some number of spaces. When the cursor is at a
               tab character it rests at the last of  the  spaces
               which  represent  the tab. The spacing of tabstops
               is controlled by the tabstop option (4.1, 6.6).

^J (LF)        Same as down arrow (see j).

^K             Unused.

^L             The ASCII  formfeed  character,  this  causes  the
               screen  to be cleared and redrawn.  This is useful
               after a transmission error, if characters typed by
               a  program  other  than  the  editor  scramble the
               screen, or after output is stopped by an interrupt
               (5.4, 7.2f).

^M (CR)        A carriage return advances to the  next  line,  at
               the first non-white position in the line.  Given a
               count, it advances that many lines  (2.3).  During
               an insert, a CR causes the insert to continue onto
               another line (3.1).

^N             Same as down arrow (see j).

^O             Unused.

                        December 24, 2022

USD:12-22              An Introduction to Display Editing with Vi

^P             Same as up arrow (see k).

^Q             Not a command character. In input mode, ^Q  quotes
               the  next  character,  the same as ^V, except that
               some teletype drivers will eat the ^Q so that  the
               editor never sees it.

^R             Redraws the current  screen,  eliminating  logical
               lines  not  corresponding to physical lines (lines
               with only a single @ character on them) (5.4, 7.2,

^S             Unused.  Some teletype drivers use ^S  to  suspend
               output until ^Q is pressed.

^T             Not a command character. During  an  insert,  with
               autoindent  set  and at the beginning of the line,
               inserts shiftwidth whitespace.

^U             Scrolls the screen up, inverting ^D which  scrolls
               down.  Counts work as they do for ^D, and the pre-
               vious scroll amount is common to both. On  a  dumb
               terminal,  ^U  will often necessitate clearing and
               redrawing the screen  further  back  in  the  file
               (2.1, 7.2).

^V             Not a command character. In input mode, quotes the
               next  character  so  that it is possible to insert
               non-printing and special characters into the  file
               (4.2, 7.5).

^W             Not a command character. During an  insert,  backs
               up as b would in command mode; the deleted charac-
               ters remain on the display (see ^H) (7.5).

^X             Unused.

^Y             Exposes one more line above  the  current  screen,
               leaving  the  cursor where it is if possible.  (No
               mnemonic value for this key; however, it  is  next
               to ^U which scrolls up a bunch.) (Version 3 only.)

^Z             If supported by the Unix system, stops the editor,
               exiting  to  the top level shell. Same as :stopCR.
               Otherwise, unused.

^[ (ESC)       Cancels a partially formed command, such  as  a  z
               when  no  following  character has yet been given;
               terminates inputs on the last line (read  by  com-
               mands  such  as : / and ?); ends insertions of new
               text into the buffer. If  an  ESC  is  given  when
               quiescent  in  command state, the editor rings the
               bell or flashes the screen.  You can thus hit  ESC
               if  you  don't  know  what  is  happening till the

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-23

               editor rings the bell. If you don't  know  if  you
               are  in  insert  mode  you can type ESCa, and then
               material  to  be  input;  the  material  will   be
               inserted  correctly  whether  or  not  you were in
               insert mode when you started (1.5, 3.1, 7.5).

^\             Unused.

^]             Searches for the word which is after the cursor as
               a  tag.   Equivalent to typing :ta, this word, and
               then a CR.  Mnemonically,  this  command  is  ``go
               right to'' (7.3).

^^             Equivalent to :e #CR, returning  to  the  previous
               position  in  the  last  edited file, or editing a
               file which you specified if you got  a  `No  write
               since  last  change diagnostic' and do not want to
               have to type the file name again (7.3). (You  have
               to  do  a :w before ^^ will work in this case.  If
               you do not wish to write the file  you  should  do
               :e! #CR instead.)

^_             Unused. Reserved as the command character for  the
               Tektronix 4025 and 4027 terminal.

SPACE          Same as right arrow (see l).

!              An operator, which processes lines from the buffer
               with  reformatting  commands.  Follow  !  with the
               object to be processed, and then the command  name
               terminated  by CR.  Doubling ! and preceding it by
               a count causes count lines to be filtered;  other-
               wise  the  count  is passed on to the object after
               the !.  Thus 2!}fmtCR reformats the next two para-
               graphs  by  running  them through the program fmt.
               If  you  are  working   on   LISP,   the   command
               !%grindCR,* given at the beginning of a  function,
               will run the text of the function through the LISP
               grinder (6.7, 7.3). To read a file or  the  output
               of a command into the buffer use :r (7.3). To sim-
               ply execute a command use :! (7.3).

"              Precedes a named buffer specification.  There  are
               named buffers 1-9 used for saving deleted text and
               named buffers a-z into which you  can  place  text
               (4.3, 6.3)

#              The macro character  which,  when  followed  by  a
               number, will substitute for a function key on ter-
               minals without function keys (6.9). In input mode,
*Both fmt and grind are Berkeley programs and may not be  present
at all installations.

                        December 24, 2022

USD:12-24              An Introduction to Display Editing with Vi

               if this is your erase character,  it  will  delete
               the  last  character  you typed in input mode, and
               must be preceded with a \ to insert it,  since  it
               normally  backs  over the last input character you

$              Moves to the end of the current line.  If you  :se
               listCR, then the end of each line will be shown by
               printing a $ after the end of the  displayed  text
               in  the  line.   Given  a  count,  advances to the
               count'th following end of line; thus  2$  advances
               to the end of the following line.

%              Moves to the parenthesis or brace { }  which  bal-
               ances the parenthesis or brace at the current cur-
               sor position.

&              A synonym for :&CR, by analogy with the ex &  com-

'              When followed by a ' returns to the previous  con-
               text  at  the  beginning  of a line.  The previous
               context is set whenever the current line is  moved
               in  a  non-relative way. When followed by a letter
               a-z, returns to the line  which  was  marked  with
               this  letter  with  a m command, at the first non-
               white character in the line. (2.2, 5.3). When used
               with  an  operator  such as d, the operation takes
               place over complete  lines;  if  you  use  `,  the
               operation  takes place from the exact marked place
               to the current cursor position within the line.

(              Retreats to the beginning of a  sentence.  A  sen-
               tence  ends  at  a  .  ! or ? which is followed by
               either the end of a line or by  two  spaces.   Any
               number  of  closing  )  ]  "  and ' characters may
               appear after the . ! or ?, and before  the  spaces
               or end of line.  Sentences also begin at paragraph
               and section boundaries (see {  and  [[  below).  A
               count advances that many sentences (4.2, 6.8).

)              Advances to the beginning of a sentence.  A  count
               repeats the effect. See ( above for the definition
               of a sentence (4.2, 6.8).

*              Unused.

+              Same as CR when used as a command.

,              Reverse of the last f F t or  T  command,  looking
               the  other  way  in  the current line.  Especially
               useful after hitting too  many  ;  characters.   A
               count repeats the search.

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-25

-              Retreats to the previous line at  the  first  non-
               white  character.  This  is  the  inverse of + and
               RETURN. If the line moved to is not on the screen,
               the  screen is scrolled, or cleared and redrawn if
               this is not possible. If a large amount of  scrol-
               ling  would be required the screen is also cleared
               and redrawn, with the current line at  the  center

.              Repeats the last command which changed the buffer.
               Especially  useful  when  deleting words or lines;
               you can delete some words/lines and then hit .  to
               delete  more  and more words/lines. Given a count,
               it passes it on to  the  command  being  repeated.
               Thus  after  a  2dw,  3. deletes three words (3.3,
               6.3, 7.2, 7.4).

/              Reads a string from the last line on  the  screen,
               and  scans forward for the next occurrence of this
               string.  The normal input editing sequences may be
               used  during  the  input  on  the bottom line. The
               search begins when you hit  CR  to  terminate  the
               pattern;  the cursor moves to the beginning of the
               last line to indicate that the search is  in  pro-
               gress;  the  search  may then be terminated with a
               DEL or RUB, or by backspacing when at  the  begin-
               ning  of  the bottom line, returning the cursor to
               its initial position. Searches normally wrap  end-
               around to find a string anywhere in the buffer.

               When used with an operator the enclosed region  is
               normally  affected.  By  mentioning an offset from
               the line matched by  the  pattern  you  can  force
               whole  lines  to  be  affected.  To do this give a
               pattern with a closing a closing  /  and  then  an
               offset +n or -n.

               To include the character / in the  search  string,
               you  must escape it with a preceding \. A ^ at the
               beginning of the pattern forces the match to occur
               at  the  beginning of a line only; this speeds the
               search.  A $ at the end of the pattern forces  the
               match  to  occur  at  the end of a line only. More
               extended pattern matching is available,  see  sec-
               tion  7.4;  unless  you  set nomagic in your .exrc
               file you will have to precede the characters . [ *
               and  ~  in the search pattern with a \ to get them
               to work as you would  naively  expect  (1.5,  2,2,
               6.1, 7.2, 7.4).

0              Moves to the first character on the current  line.
               Also  used,  in  forming numbers, after an initial

                        December 24, 2022

USD:12-26              An Introduction to Display Editing with Vi

1-9            Used to form numeric arguments to  commands  (2.3,

:              A prefix to a set of commands for file and  option
               manipulation  and escapes to the system.  Input is
               given on the bottom line and  terminated  with  an
               CR, and the command then executed.  You can return
               to where you were by hitting DEL or RUB if you hit
               : accidentally (see primarily 6.2 and 7.3).

;              Repeats the last single character find which  used
               f F t or T. A count iterates the basic scan (4.1).

<              An  operator   which   shifts   lines   left   one
               shiftwidth,  normally  8  spaces.  Like all opera-
               tors, affects  lines  when  repeated,  as  in  <<.
               Counts  are  passed  through  to the basic object,
               thus 3<< shifts three lines (6.6, 7.2).

=              Display the line number. If a numerical prefix  is
               specified,  display  its  line  number;  otherwise
               display the line number of the last  line  in  the

>              An  operator  which   shifts   lines   right   one
               shiftwidth, normally 8 spaces.  Affects lines when
               repeated as in >>.  Counts repeat the basic object
               (6.6, 7.2).

?              Scans backwards, the opposite of  /.   See  the  /
               description  above  for  details on scanning (2.2,
               6.1, 7.4).

@              A macro character (6.9).  If  this  is  your  kill
               character,  you must escape it with a \ to type it
               in during input mode, as it  normally  backs  over
               the input you have given on the current line (3.1,
               3.4, 7.5).

A              Appends at the end  of  line,  a  synonym  for  $a

B              Backs up a word, where words are composed of  non-
               blank  sequences, placing the cursor at the begin-
               ning of the word.   A  count  repeats  the  effect

C              Changes the rest of the text on the current  line;
               a synonym for c$.

D              Deletes the rest of the text on the current  line;
               a synonym for d$.

E              Moves forward to the end of  a  word,  defined  as

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-27

               blanks  and  non-blanks,  like  B  and W.  A count
               repeats the effect.

F              Finds a single following character,  backwards  in
               the current line. A count repeats this search that
               many times (4.1).

G              Goes to the line number given as  preceding  argu-
               ment, or the end of the file if no preceding count
               is given.  The screen  is  redrawn  with  the  new
               current line in the center if necessary (7.2).

H              Home arrow. Homes the cursor to the  top  line  on
               the  screen.  If a count is given, then the cursor
               is moved to the count'th line on  the  screen.  In
               any  case  the  cursor  is moved to the first non-
               white character on the line.  If used as the  tar-
               get  of an operator, full lines are affected (2.3,

I              Inserts at the beginning of a line; a synonym  for

J              Joins together lines, supplying  appropriate  whi-
               tespace: one space between words, two spaces after
               a ., and no spaces at all if the  first  character
               of  the  joined on line is ).  A count causes that
               many lines to be joined rather  than  the  default
               two (6.5, 7.1f).

K              Unused.

L              Moves the cursor to the first non-white  character
               of  the last line on the screen.  With a count, to
               the first non-white of the count'th line from  the
               bottom.   Operators  affect  whole lines when used
               with L (2.3).

M              Moves the cursor to the middle line on the screen,
               at the first non-white position on the line (2.3).

N              Scans for the next match of the last pattern given
               to  /  or ?, but in the reverse direction; this is
               the reverse of n.

O              Opens a new line above the current line and inputs
               text  there  up to an ESC.  A count can be used on
               dumb terminals to specify a number of lines to  be

P              Puts the last deleted text back  before/above  the
               cursor.   The  text goes back as whole lines above
               the cursor if it was deleted as whole lines.  Oth-
               erwise the text is inserted between the characters

                        December 24, 2022

USD:12-28              An Introduction to Display Editing with Vi

               before and at the cursor.  May be  preceded  by  a
               named buffer specification "x to retrieve the con-
               tents of the buffer; buffers 1-9  contain  deleted
               material,  buffers  a-z  are available for general
               use (6.3).

Q              Quits from vi to ex command mode.  In  this  mode,
               whole  lines  form commands, ending with a RETURN.
               You can give all the : commands; the  editor  sup-
               plies the : as a prompt (7.7).

R              Replaces characters on the screen with  characters
               you  type  (overlay  fashion).  Terminates with an

S              Changes whole lines, a synonym for  cc.   A  count
               substitutes  for  that  many lines.  The lines are
               saved in the numeric buffers, and  erased  on  the
               screen before the substitution begins.

T              Takes a single following  character,  locates  the
               character  before  the cursor in the current line,
               and places the cursor just after that character. A
               count repeats the effect.  Most useful with opera-
               tors such as d (4.1).

U              Restores the current line to its state before  you
               started changing it (3.5).

V              Unused.

W              Moves forward to the beginning of a  word  in  the
               current line, where words are defined as sequences
               of blank/non-blank characters. A count repeats the
               effect (2.4).

X              Deletes the character before the cursor.  A  count
               repeats  the  effect,  but  only characters on the
               current line are deleted.

Y              Yanks a copy of the current line into the  unnamed
               buffer,  to  be put back by a later p or P; a very
               useful synonym for yy. A  count  yanks  that  many
               lines.   May  be  preceded by a buffer name to put
               lines in that buffer (7.4).

ZZ             Exits the editor. (Same as :xCR.) If  any  changes
               have  been  made, the buffer is written out to the
               current file. Then the editor quits.

[[             Backs up to the previous section boundary.  A sec-
               tion  begins at each macro in the sections option,
               normally a `.NH' or `.SH' and also at lines  which
               which  start  with a formfeed ^L.  Lines beginning

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-29

               with { also stop [[;  this  makes  it  useful  for
               looking backwards, a function at a time, in C pro-
               grams (4.2, 6.1, 6.6, 7.2).

\              Unused.

]]             Forward to a section boundary; see [[ for a defin-
               ition (4.2, 6.1, 6.6, 7.2).

^              Moves to  the  first  non-white  position  on  the
               current line (4.4).

_              Unused.

`              When followed by a `, returns to the previous con-
               text.  The  previous  context  is set whenever the
               current line is moved in a non-relative way.  When
               followed  by a letter a-z, returns to the position
               which was marked with this letter with  a  m  com-
               mand.  When  used  with an operator such as d, the
               operation takes place from the exact marked  place
               to  the  current  position within the line; if you
               use ', the operation  takes  place  over  complete
               lines (2.2, 5.3).

a              Appends arbitrary text after  the  current  cursor
               position;  the  insert  can continue onto multiple
               lines by using RETURN within the insert.  A  count
               causes  the  inserted  text  to be replicated, but
               only if the inserted text is all on one line.  The
               insertion terminates with an ESC (3.1, 7.2).

b              Backs up to the beginning of a word in the current
               line.  A word is a sequence of alphanumerics, or a
               sequence of special characters.  A  count  repeats
               the effect (2.4).

c              An operator which changes  the  following  object,
               replacing  it  with the following input text up to
               an ESC.  If more than part of  a  single  line  is
               affected,  the text which is changed away is saved
               in the numeric named buffers.  If only part of the
               current  line is affected, then the last character
               to be changed away is marked with  a  $.  A  count
               causes that many objects to be affected, thus both
               3c) and c3) change the following  three  sentences

d              An operator which deletes  the  following  object.
               If  more than part of a line is affected, the text
               is saved in the numeric buffers.  A  count  causes
               that  many objects to be affected; thus 3dw is the
               same as d3w (3.3, 3.4, 4.1, 7.4).

                        December 24, 2022

USD:12-30              An Introduction to Display Editing with Vi

e              Advances to the end of the next word,  defined  as
               for  b  and  w.  A  count repeats the effect (2.4,

f              Finds the first instance  of  the  next  character
               following the cursor on the current line.  A count
               repeats the find (4.1).

g              Unused.

               Arrow keys h, j, k, l, and H.

h              Left arrow. Moves the cursor one character to  the
               left.  Like  the  other  arrow keys, either h, the
               left arrow key, or one of the  synonyms  (^H)  has
               the same effect. On v2 editors, arrow keys on cer-
               tain kinds of terminals (those which  send  escape
               sequences,  such  as  vt52, c100, or hp) cannot be
               used. A count repeats the effect (3.1, 7.5).

i              Inserts text before the cursor, otherwise  like  a

j              Down arrow. Moves the cursor one line down in  the
               same  column.  If  the position does not exist, vi
               comes as close as possible  to  the  same  column.
               Synonyms include ^J (linefeed) and ^N.

k              Up arrow. Moves the cursor one line up.  ^P  is  a

l              Right arrow. Moves the cursor one character to the
               right. SPACE is a synonym.

m              Marks the current position of the  cursor  in  the
               mark register which is specified by the next char-
               acter a-z.  Return to this position or use with an
               operator using ` or ' (5.3).

n              Repeats the last / or ? scanning commands (2.2).

o              Opens new lines below the current line;  otherwise
               like O (3.1).

p              Puts text after/below the cursor; otherwise like P

q              Unused.

r              Replaces the single character at the cursor with a
               single  character you type.  The new character may
               be a RETURN; this is  the  easiest  way  to  split
               lines.   A  count  replaces  each of the following
               count characters with the single character  given;

                        December 24, 2022

An Introduction to Display Editing with Vi              USD:12-31

               see  R  above  which  is  the  more usually useful
               iteration of r (3.2).

s              Changes the single character under the  cursor  to
               the  text  which  follows  up  to  an ESC; given a
               count, that many characters from the current  line
               are  changed.  The last character to be changed is
               marked with $ as in c (3.2).

t              Advances the cursor upto the character before  the
               next  character  typed. Most useful with operators
               such as d and c to delete the characters up  to  a
               following character.  You can use . to delete more
               if this  doesn't  delete  enough  the  first  time

u              Undoes the last change made to the current buffer.
               If  repeated,  will  alternate  between  these two
               states, thus is its own inverse. When  used  after
               an  insert  which  inserted  text on more than one
               line, the lines are saved  in  the  numeric  named
               buffers (3.5).

v              Unused.

w              Advances to the beginning of  the  next  word,  as
               defined by b (2.4).

x              Deletes the single  character  under  the  cursor.
               With  a count deletes deletes that many characters
               forward from the cursor position, but only on  the
               current line (6.5).

y              An operator, yanks the following object  into  the
               unnamed  temporary  buffer. If preceded by a named
               buffer specification, "x, the text  is  placed  in
               that  buffer  also.   Text  can  be recovered by a
               later p or P (7.4).

z              Redraws the screen with the current line placed as
               specified   by  the  following  character:  RETURN
               specifies the top of the screen, . the  center  of
               the  screen,  and - at the bottom of the screen. A
               count may be given after the z and before the fol-
               lowing  character  to  specify the new screen size
               for the redraw. A count before  the  z  gives  the
               number  of  the line to place in the center of the
               screen instead of the default current line. (5.4)

{              Retreats to the beginning of the beginning of  the
               preceding  paragraph.  A  paragraph begins at each
               macro in the paragraphs  option,  normally  `.IP',
               `.LP',  `.PP',  `.QP'  and `.bp'. A paragraph also
               begins after a completely empty line, and at  each

                        December 24, 2022

USD:12-32              An Introduction to Display Editing with Vi

               section boundary (see [[ above) (4.2, 6.8, 7.6).

|              Places the cursor on the character in  the  column
               specified by the count (7.1, 7.2).

}              Advances to the beginning of the  next  paragraph.
               See  {  for the definition of paragraph (4.2, 6.8,

~              Unused.

^? (DEL)       Interrupts the editor,  returning  it  to  command
               accepting state (1.5, 7.5).

                        December 24, 2022

Generated on 2022-12-24 01:00:14 by $MirOS: src/scripts/roff2htm,v 1.113 2022/12/21 23:14:31 tg Exp $ — This product includes material provided by mirabilos.

These manual pages and other documentation are copyrighted by their respective writers; their sources are available at the project’s CVSweb, AnonCVS and other mirrors. The rest is Copyright © 2002–2022 MirBSD.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report — diffs preferred.

Kontakt / Impressum & Datenschutzerklärung