








           AAnn IInnttrroodduuccttiioonn ttoo DDiissppllaayy EEddiittiinngg wwiitthh VVii


                           _W_i_l_l_i_a_m _J_o_y
                           _M_a_r_k _H_o_r_t_o_n
                    Computer Science Division
    Department of Electrical Engineering and Computer Science
               University of California, Berkeley
                      Berkeley, Ca.  94720


                            _A_B_S_T_R_A_C_T

          _V_i (visual) is a display oriented interactive text
     editor.  When using _v_i 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  _v_i you can insert new text any place in the
     file quite easily.  Most of the commands to _v_i 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 dd for delete and cc for change, are  combined
     with  the  motion  commands  to form operations such as
     delete word or change paragraph, in a simple and  natu-
     ral  way.   This regularity and the mnemonic assignment
     of commands to keys makes the editor command  set  easy
     to remember and to use.

          _V_i  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 dis-
     play, the editor will function quite well on dumb  ter-
     minals   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
     available.

          It  is  also possible to use the command set of _v_i
     on  hardcopy  terminals,  storage  tubes  and   ``glass
     tty's'' using a one line editing window; thus _v_i_'_s com-
     mand set is available on all terminals.  The full  com-
     mand  set of the more traditional, line oriented editor
     _e_x is available within _v_i_; it is quite simple to switch
     between the two modes of editing.










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


11..  GGeettttiinngg ssttaarrtteedd

     This  document  provides  a quick introduction to _v_i_.  (Pro-
nounced _v_e_e_-_e_y_e.)  You should be running _v_i on  a  file  you  are
familiar with while you are reading this.  The first part of this
document (sections 1 through 5) describes the basics of using _v_i_.
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  _v_i.
Attached to this document should be a quick reference card.  This
card summarizes the commands of _v_i in a very compact format.  You
should have the card handy while you are learning _v_i_.

11..11..  SSppeecciiffyyiinngg tteerrmmiinnaall ttyyppee

     Before  you  can start _v_i you must 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 terminal can be created.


       CCooddee       FFuullll nnaammee                    TTyyppee
      ------------------------------------------------------
       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
       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
-----------
The  financial  support  of  an  IBM  Graduate Fellowship and the
National Science  Foundation  under  grants  MCS74-07644-A03  and
MCS78-07291 is gratefully acknowledged.









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


`2621'.   In  this case you can use one of the following commands
to tell the system the type of your terminal:

     % sseetteennvv TTEERRMM 2621

This command works with the _c_s_h shell.   If  you  are  using  the
standard Bourne shell _s_h then you should give the commands

     $ TTEERRMM==2621
     $ eexxppoorrtt TTEERRMM


     If  you  want  to  arrange to have your terminal type set up
automatically when you log in, you can use the _t_s_e_t program.   If
you  dial  in on a _m_i_m_e, but often use hardwired ports, a typical
line for your _._l_o_g_i_n file (if you use csh) would be

     sseetteennvv TTEERRMM ``ttsseett - -d mime`

or for your _._p_r_o_f_i_l_e file (if you use sh)

     TTEERRMM==``ttsseet - -d mime`

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

11..22..  EEddiittiinngg aa ffiillee

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

     % vvii _n_a_m_e

replacing  _n_a_m_e  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-
note.++
-----------
++ 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 ::qq (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
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
correctly.
     If the editor doesn't seem to respond to the commands  which









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


11..33..  TThhee eeddiittoorr''ss ccooppyy:: tthhee bbuuffffeerr

     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 _b_u_f_f_e_r_, 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.

11..44..  NNoottaattiioonnaall ccoonnvveennttiioonnss

     In  our  examples,  input  which must be typed as is will be
presented in bboolldd ffaaccee. Text which should be replaced with appro-
priate input will be given in _i_t_a_l_i_c_s.  We will represent special
characters in SMALL CAPITALS.

11..55..  AArrrrooww kkeeyyss

     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 hh jj kk and ll
keys as cursor positioning keys (these are labelled  with  arrows
on an _a_d_m_3_a_)_._*

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

11..66..  SSppeecciiaall cchhaarraacctteerrss:: EESSCC,, CCRR aanndd DDEELL

     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.++
Partially formed commands are cancelled  by  ESC,  and  when  you
insert  text  in  the  file  you end the text insertion with ESC.
This key 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
-----------
you  type here, try sending an interrupt to it by hitting the DEL
or RUB key on your terminal, and  then  hitting  the  ::qq  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  qui-
etly flash the screen rather than ringing the bell.









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


keyboard, and is the same command used at the end of  each  shell
command.

     Another  very useful key is the DEL or RUB key, which gener-
ates 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
computing 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.

11..77..  GGeettttiinngg oouutt ooff tthhee eeddiittoorr

     After you have worked with this introduction  for  a  while,
and you wish to do something else, you can give the command ZZZZ 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 ::qq!!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.

22..  MMoovviinngg aarroouunndd iinn tthhee ffiillee

22..11..  SSccrroolllliinngg aanndd ppaaggiinngg

     The editor has a number of commands for moving around in the
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.  You may have a key labelled `^' on your termi-
nal.  This key will be represented as `^' in this  document;  `^'
is  exclusively  used  as  part  of the `^x' notation for control
-----------
* 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.









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


characters.++

     As you know now  if  you  tried  hitting  ^^DD,  this  command
scrolls down in the file.  The DD 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 ^^UU.  Many
dumb terminals can't scroll up at all, in which case  hitting  ^^UU
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  ^^EE to expose one more line at the bottom of the screen,
leaving the cursor where it is.  The command ^^YY (which  is  hope-
lessly  non-mnemonic, but next to ^^UU 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 ^^FF
and  ^^BB  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 ^^DD and ^^UU if you
wish.

     Notice the difference between scrolling and paging.  If  you
are trying to read the text in a file, hitting ^^FF 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.

22..22..  SSeeaarrcchhiinngg,, ggoottoo,, aanndd pprreevviioouuss ccoonntteexxtt

     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  nn 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-
tion.


-----------
++ If you don't have a `^' key on your  terminal  then  there  is
probably a key labelled `^'; in any case these characters are one
and the same.
+  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
::ssee nnoowwrraappssccaannCR, or more briefly ::ssee nnoowwssCR.









An Introduction to Display Editing with Vi               USD:11-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  //^^sseeaarrcchhCR
will search for the word `search' at the beginning of a line, and
//llaasstt$$CR searches for the word `last' at the end of a line.*

     The  command  GG, when preceded by a number will position the
cursor at that line in the file.  Thus 11GG will move the cursor to
the  first  line  of  the  file.  If you give GG 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  ^^GG.  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 GG command to get to the end and then
another GG 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
GG because it requires no advance preparation.  Try giving a GG  or
a search with // or ?? and then a ```` to get back to where you were.
If you accidentally hit nn or any command which moves you far away
from  a  context of interest, you can quickly get back by hitting
````.

22..33..  MMoovviinngg aarroouunndd oonn tthhee ssccrreeeenn

     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 hh, jj, kk,
and ll.  Experienced users of _v_i 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
way.

-----------
*Actually, the string you give to search for here can be a  _r_e_g_u_-
_l_a_r  _e_x_p_r_e_s_s_i_o_n  in the sense of the editors _e_x(1) and _e_d(1).  If
you don't wish to learn about this yet, you can disable this more
general  facility by doing ::ssee nnoommaaggiiccCR; by putting this command
in EXINIT in your environment, you can have  this  always  be  in
effect (more about _E_X_I_N_I_T later.)









USD:11-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.

     _V_i also has commands to take you to the top, middle and bot-
tom of the screen.  HH will take you to the top (home) line on the
screen.  Try preceding it with a number as in 33HH.  This will take
you  to the third line on the screen.  Many _v_i commands take pre-
ceding numbers and do interesting things with them.  Try MM, which
takes  you  to  the middle line on the screen, and LL, which takes
you to the last line on the screen.  LL also takes counts, thus 55LL
will take you to the fifth line from the bottom.

22..44..  MMoovviinngg wwiitthhiinn aa lliinnee

     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 ww key.  This will
advance the cursor to the next word on the line.  Try hitting the
bb  key  to  back  up words in the line.  Also try the ee 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 ^^HH) key  which
moves left one character.  The key hh works as ^^HH does and is use-
ful if you don't have a BS key.  (Also, as noted  just  above,  ll
will move to the right.)

     If  the line had punctuation in it you may have noticed that
that the ww and bb keys stopped at each group of punctuation.   You
can  also go back and forwards words without stopping at punctua-
tion by using WW and BB 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 ww and bb.

     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 ww.

22..55..  SSuummmmaarryy


     SPACE    advance the cursor one position
     ^^BB       backwards to previous page
     ^^DD       scrolls down in the file
     ^^EE       exposes another line at the bottom
     ^^FF       forward to next page
     ^^GG       tell what is going on
     ^^HH       backspace the cursor
     ^^NN       next line, same column
     ^^PP       previous line, same column
     ^^UU       scrolls up in the file










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


     ^^YY       exposes another line at the top
     ++        next line, at the beginning
     --        previous line, at the beginning
     //        scan for a following string forwards
     ??        scan backwards
     BB        back a word, ignoring punctuation
     GG        go to specified line, last default
     HH        home screen line
     MM        middle screen line
     LL        last screen line
     WW        forward a word, ignoring punctuation
     bb        back a word
     ee        end of current word
     nn        scan for next instance of // or ?? pattern
     ww        word after this word


22..66..  VViieeww

     If you want to use the editor to look at a file, rather than
to  make changes, invoke it as _v_i_e_w instead of _v_i.  This will set
the _r_e_a_d_o_n_l_y option which will prevent you from accidently  over-
writing the file.


33..  MMaakkiinngg ssiimmppllee cchhaannggeess

33..11..  IInnsseerrttiinngg

     One  of  the most useful commands is the ii (insert) command.
After you type ii, 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 ee (move to  end  of
word), then aa for append and then `sESC' to terminate the textual
insert.  This sequence of commands can be used to easily  plural-
ize a word.

     Try  inserting  and  appending  a few times to make sure you
understand how this works; ii placing text to the left of the cur-
sor, aa 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 oo to create a new line after the line you  are  on,  or  the
command OO 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.









USD:11-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 ^^HH or ##) to
backspace  over the last character which you typed, and the char-
acter which you use to kill input lines (usually @@, ^^XX, or ^^UU) to
erase  the input you have typed on the current line.+ The charac-
ter ^^WW 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 aa 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.

33..22..  MMaakkiinngg ssmmaallll ccoorrrreeccttiioonnss

     You can make small corrections in existing text  quite  eas-
ily.   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 ^^HH or even just hh) or SPACE (using  the  space
bar) until the cursor is on the character which is wrong.  If the
character is not needed then hit the  xx  key;  this  deletes  the
-----------
+ In fact, the character ^^HH (backspace) always works to erase the
last input character here, regardless of what your erase  charac-
ter is.









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


character  from  the  file.  It is analogous to the way you xx 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 rr_c, 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  ss  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 ss with a count of the number of characters
to be replaced.  Counts are also useful with  xx  to  specify  the
number of characters to be deleted.

33..33..  MMoorree ccoorrrreeccttiioonnss:: ooppeerraattoorrss

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

     Now try ddbb.  This deletes a word backwards, namely the  pre-
ceding  word.   Try ddSPACE.  This deletes a single character, and
is equivalent to the xx command.

     Another very useful operator is cc or change.  The command ccww
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.

33..44..  OOppeerraattiinngg oonn lliinneess

     It  is  often  the  case  that you want to operate on lines.
Find a line which you want to delete, and type dddd, the dd operator
twice.   This  will delete the line.  If you are on a dumb termi-
nal, the editor may just erase the line on the screen,  replacing
it  with  a line with only an @ on it.  This line does not corre-
spond 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 cc 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  SS is a convenient synonym for for cccc, by analogy
with ss.  Think of SS as a substitute on lines, while ss is  a  sub-
stitute on characters.









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


     You can delete or change more than one line by preceding the
dddd or cccc with a count, i.e. 55dddd deletes 5 lines.   You  can  also
give  a command like ddLL to delete all the lines up to and includ-
ing the last line on the screen, or dd33LL  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 num-
ber  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.

33..55..  UUnnddooiinngg

     Now  suppose  that the last change which you made was incor-
rect; 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 uu (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 an uu also undoes a uu..

     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 UU
command restores the current line to the state before you started
changing it.

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

33..66..  SSuummmmaarryy


     SPACE    advance the cursor one position
     ^^HH       backspace the cursor
     ^^WW       erase a word during an insert
     erase    your erase (usually ^H or #), erases a character during an insert
     kill     your kill (usually @, ^X, or ^U), kills the insert on this line
     ..        repeats the changing command
     OO        opens and inputs new lines, above the current
     UU        undoes the changes you made to the current line
     aa        appends text after the cursor
     cc        changes the object you specify to the following text
     dd        deletes the object you specify
     ii        inserts text before the cursor
     oo        opens and inputs new lines, below the current
     uu        undoes the last change


-----------
*  One  subtle  point here involves using the // search after a dd.
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  //ppaatt//++00,  a
line address.









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


44..  MMoovviinngg aabboouutt;; rreeaarrrraannggiinngg aanndd dduupplliiccaattiinngg tteexxtt

44..11..  LLooww lleevveell cchhaarraacctteerr mmoottiioonnss

     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 ff_x where _x is this character.  This com-
mand 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 ff 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 a FF command, which is like ff,  but  searches  back-
ward.  The ;; command repeats FF 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 ddff_x for some _x now and
notice that the _x character is deleted.  Undo  this  with  uu  and
then  try  ddtt_x;  the tt here stands for to, i.e.  delete up to the
next _x, but not the _x.  The command TT is the reverse of tt.

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

     Your file may have tab (^^II) 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  repre-
sent 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
on the character and the setting of the _b_e_a_u_t_i_f_y 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  ^^VV
before  the control character.  The ^^VV quotes the following char-
acter, causing it to be inserted directly into the file.

-----------
*  This  is settable by a command of the form ::ssee ttss==_xCR, where _x
is 4 to set tabstops every four columns.  This has effect on  the
screen representation within the editor.









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


44..22..  HHiigghheerr lleevveell tteexxtt oobbjjeeccttss

     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 dd)) will delete the rest of the
current sentence; likewise dd(( will delete the  previous  sentence
if  you are at the beginning of the current sentence, or the cur-
rent sentence up to where you are if you are not at the beginning
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 num-
ber  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 _p_a_r_a_g_r_a_p_h_s.
The default setting for this option defines the paragraph  macros
of  the  _-_m_s and _-_m_m 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-
graphs.

     Sections in the editor begin after each macro  in  the  _s_e_c_-
_t_i_o_n_s  option,  normally  `.NH',  `.SH', `.H' and `.HU', and each
line with a formfeed ^^LL 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,
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.
-----------
+  The [[[[ and ]]]] operations require the operation character to be
doubled because they can move the cursor far from where  it  cur-
rently  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 _p_a_r_a_g_r_a_p_h_s option in your EXINIT.
See section 6.2 for details.  The `.bp' directive is also consid-
ered to start a paragraph.









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


44..33..  RReeaarrrraannggiinngg aanndd dduupplliiccaattiinngg tteexxtt

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

     The operator yy yanks a copy of the object which follows into
the unnamed buffer.  If preceded by a buffer name, ""_xyy,  where  _x
here is replaced by a letter aa--zz, it places the text in the named
buffer.  The text can then be put back in the file with the  com-
mands pp and PP;; pp puts the text after or below the cursor, while PP
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 PP).  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 a oo
or OO command.

     Try the command YYPP.  This makes a copy of the  current  line
and  leaves  you on this copy, which is placed before the current
line.  The command YY is a convenient abbreviation  for  yyyy.   The
command  YYpp  will also make a copy of the current line, and place
it after the current line.  You can give YY a count  of  lines  to
yank, and thus duplicate several lines; try 33YYPP.

     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 ""aa55dddd deleting 5 lines into the named buffer _a.  You
can  then  move  the  cursor to the eventual resting place of the
these lines and do a ""aapp or ""aaPP 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 ::ee _n_a_m_eCR where _n_a_m_e 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.

44..44..  SSuummmmaarryy..


     ^^        first non-white on line
     $$        end of line
     ))        forward sentence
     }}        forward paragraph
     ]]]]       forward section










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


     ((        backward sentence
     {{        backward paragraph
     [[[[       backward section
     ff_x       find _x forward in line
     pp        put text back, after cursor or below current line
     yy        yank operator, for copies and moves
     tt_x       up to _x forward, for operators
     FF_x       f backward in line
     PP        put text back, before cursor or above current line
     TT_x       t backward in line


55..  HHiigghh lleevveell ccoommmmaannddss

55..11..  WWrriittiinngg,, qquuiittttiinngg,, eeddiittiinngg nneeww ffiilleess

     So far we have seen how to enter _v_i and  to  write  out  our
file  using  either  ZZZZ or ::wwCR. 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 ::qq!!CR to quit from the editor with-
out  writing  the  changes.   You  can  also reedit the same file
(starting over) by giving  the  command  ::ee!!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 ::ee _n_a_m_eCR.  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  ::wwCR  to  save  your work and then the ::ee _n_a_m_eCR command
again, or carefully give the command ::ee!! _n_a_m_eCR, which edits  the
other  file  discarding  the changes you have made to the current
file.  To have the editor automatically save changes, include _s_e_t
_a_u_t_o_w_r_i_t_e in your EXINIT, and use ::nn instead of ::ee.

55..22..  EEssccaappiinngg ttoo aa sshheellll

     You can get to a shell to execute a single command by giving
a _v_i command of the form ::!!_c_m_dCR.  The system will run the single
command  _c_m_d  and  when the command finishes, the editor will ask
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 ::sshhCR.  This will give you a new









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


shell, and when you finish with the shell, ending it by typing  a
^^DD, the editor will clear the screen and continue.

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

55..33..  MMaarrkkiinngg aanndd rreettuurrnniinngg

     The command ```` returned to the previous place after a motion
of the cursor by a command such as //, ?? or GG.  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 mm_x, where you should pick some letter for _x, say
`a'.  Then move the cursor to a different line (any way you like)
and  hit  ``aa.   The  cursor  will  return  to the place which you
marked.  Marks last only until you edit another file.

     When using operators such  as  dd  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 mm.  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 ````.

55..44..  AAddjjuussttiinngg tthhee ssccrreeeenn

     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 ^^LL, 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  ^^RR  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 zz command.  You should  fol-
low the zz 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.

66..  SSppeecciiaall ttooppiiccss

66..11..  EEddiittiinngg oonn ssllooww tteerrmmiinnaallss

     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









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


limit the delays, and how the editor erases lines to @ when  they
are deleted on dumb terminals.

     The use of the slow terminal insertion mode is controlled by
the _s_l_o_w_o_p_e_n option.  You can force the editor to use  this  mode
even  on  faster  terminals by giving the command ::ssee sslloowwCR.  If
your system is sluggish this helps lessen the  amount  of  output
coming  to  your  terminal.   You  can disable this option by ::ssee
nnoosslloowwCR.

     The editor can simulate an intelligent terminal  on  a  dumb
one.   Try giving the command ::ssee rreeddrraawwCR.  This simulation gen-
erates a great deal of output and is generally tolerable only  on
lightly  loaded systems and fast terminals.  You can disable this
by giving the command
 ::ssee nnoorreeddrraawwCR.

     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 zz command,
after the zz and before the following RETURN, .. or  --.   Thus  the
command  zz55.. redraws the screen with the current line in the cen-
ter 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 ^^LL; or move or search again,  ignoring  the  current
state of the display.

     See  section  7.8 on _o_p_e_n mode for another way to use the _v_i
command set on slow terminals.
-----------
+ Note that the command 55zz.. has  an  entirely  different  effect,
placing line 5 in the center of a new window.









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


66..22..  OOppttiioonnss,, sseett,, aanndd eeddiittoorr ssttaarrttuupp ffiilleess

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

     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

     sseett _o_p_t==_v_a_l

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

     sseett _o_p_t
     sseett nnoo_o_p_t


NNaammee         DDeeffaauulltt               DDeessccrriippttiioonn
--------------------------------------------------------------------------------------
autoindent   noai                  Supply indentation automatically
autowrite    noaw                  Automatic write before ::nn, ::ttaa, ^^^^, !!
ignorecase   noic                  Ignore case in searching
lisp         nolisp                (( {{ )) }} commands deal with S-expressions
list         nolist                Tabs print as ^I; end of lines marked with $
magic        nomagic               The characters . [ and * are special in scans
number       nonu                  Lines are displayed prefixed with line numbers
paragraphs   para=IPLPPPQPbpP LI   Macro names which start paragraphs
redraw       nore                  Simulate a smart terminal on a dumb one
sections     sect=NHSHH HU         Macro names which start new sections
shiftwidth   sw=8                  Shift distance for <, > and input ^^DD and ^^TT
showmatch    nosm                  Show matching (( or {{ as )) or }} is typed
slowopen     slow                  Postpone display updates during inserts
term         dumb                  The kind of terminal you are using.

These  statements  can  be placed in your EXINIT in your environ-
ment, or given while you are running _v_i 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 ::sseettCR, or the value of a single option by  the  com-
mand  ::sseett _o_p_t??CR.  A list of all possible options and their val-
ues is generated by ::sseett aallllCR.  Set can be abbreviated ssee.  Mul-
tiple options can be placed on one line, e.g.  ::ssee aaii aaww nnuuCR.

     Options  set  by the sseett 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 creat-
ing a list of _e_x commands+ which are to be  run  every  time  you
start up _e_x, _e_d_i_t, or _v_i.  A typical list includes a sseett command,
and possibly a few mmaapp commands.  Since it is  advisable  to  get
-----------
+ All commands which start with :: are _e_x commands.









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


these  commands  on  one  line,  they can be separated with the |
character, for example:

     sseett ai aw terse|mmaapp @ dd|mmaapp # x

which sets the options _a_u_t_o_i_n_d_e_n_t,  _a_u_t_o_w_r_i_t_e,  _t_e_r_s_e,  (the  sseett
command),  makes  @  delete  a line, (the first mmaapp), and makes #
delete a character, (the second mmaapp).  (See  section  6.9  for  a
description  of  the mmaapp command) This string should be placed in
the variable EXINIT in your environment.  If you  use  the  shell
_c_s_h, put this line in the file _._l_o_g_i_n in your home directory:

     setenv EXINIT 'sseett ai aw terse|mmaapp @ dd|mmaapp # x'

If  you  use  the  standard shell _s_h, put these lines in the file
_._p_r_o_f_i_l_e in your home directory:

     EXINIT='sseett ai aw terse|mmaapp @ dd|mmaapp # x'
     export EXINIT

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

66..33..  RReeccoovveerriinngg lloosstt lliinneess

     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 "_npp.  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 pp is the put command,
which puts text in the buffer after the cursor.  If this  doesn't
bring  back  the  text  you wanted, hit uu 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
increments the number of the buffer before repeating the command.
Thus a sequence of the form

     ""11ppuu..uu..uu..

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

66..44..  RReeccoovveerriinngg lloosstt ffiilleess

     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









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


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:

     % vvii --rr _n_a_m_e

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

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

     % vvii --rr

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, _v_i must be correctly installed  by
a  super  user on your system, and the _m_a_i_l program must exist to
receive mail.  The invocation ``_v_i _-_r'' will not always list  all
saved  files,  but  they  can  be  recovered even if they are not
listed.

66..55..  CCoonnttiinnuuoouuss tteexxtt iinnppuutt

     When you are typing in large amounts of text  it  is  conve-
nient  to  have lines broken near the right margin automatically.
You can cause this to happen by giving the command  ::ssee  wwmm==1100CR.
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 JJ.  You can
give JJ a count of the number of lines to be joined as  in  33JJ  to
join  3  lines.  The editor supplies white space, if appropriate,
at the juncture of the joined lines, and  leaves  the  cursor  at
this  white  space.   You  can kill the white space with xx if you
don't want it.

66..66..  FFeeaattuurreess ffoorr eeddiittiinngg pprrooggrraammss

     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 a _a_u_t_o_i_n_d_e_n_t
-----------
+  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.









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


facility for helping you generate correctly indented programs.

     To enable this facility you can give the command  ::ssee  aaiiCR.
Now try opening a new line with oo and type some characters on the
line after a few tabs.  If you now  start  another  line,  notice
that the editor supplies white space at the beginning of the line
to line it up with the previous line.  You cannot backspace  over
this indentation, but you can use ^^DD key to backtab over the sup-
plied indentation.

     Each time you type ^^DD you back up one position, normally  to
an 8 column boundary.  This amount is settable; the editor has an
option called _s_h_i_f_t_w_i_d_t_h which you can set to change this  value.
Try  giving  the  command  ::ssee ssww==44CR 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 _s_h_i_f_t_w_i_d_t_h_.  Try <<<< and >>>> which shift one line  left
or right, and <<LL and >>LL shifting the rest of the display left and
right.

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

     If  you  are  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 yy]]]].

66..77..  FFiilltteerriinngg ppoorrttiioonnss ooff tthhee bbuuffffeerr

     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 !!}}ssoorrttCR.  This says to sort  the
next  paragraph of material, and the blank line ends a paragraph.

66..88..  CCoommmmaannddss ffoorr eeddiittiinngg LLIISSPP

     If you are editing a LISP program you should set the  option
_l_i_s_p  by  doing ::ssee lliissppCR.  This changes the (( and )) commands to
move backward and forward over s-expressions.  The {{ and  }}  com-
mands  are  like  ((  and )) but don't stop at atoms.  These can be
used to skip to the next list, or through a comment quickly.

     The _a_u_t_o_i_n_d_e_n_t option works differently for LISP,  supplying
indent  to align at the first argument to the last open list.  If
there is no such argument then the indent is two spaces more than









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


the last level.

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

     The editor also has an operator to realign existing lines as
though they had been typed in with _l_i_s_p and _a_u_t_o_i_n_d_e_n_t set.  This
is the == operator.  Try the command ==%%  at  the  beginning  of  a
function.  This will realign all the lines of the function decla-
ration.

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

66..99..  MMaaccrrooss

     _V_i 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
repeatedly.

     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 @@xx to invoke the macro.  The @@ may be
     followed by another @@ to repeat the last macro.

b)   You can use the _m_a_p  command  from  _v_i  (typically  in  your
     _E_X_I_N_I_T) with a command of the form:

          :map _l_h_s _r_h_sCR

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

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











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


     :map q :wq^^VV^^VVCR CR

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

     Macros can be deleted with

     unmap lhs


     If  the  _l_h_s  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 ^^VV^^VV^^II #

to use tab, for example.  (This won't  affect  the  _m_a_p  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 mmaapp causes the mapping to apply
to input mode, rather than command mode.  Thus, to arrange for ^^TT
to be the same as 4 spaces in input mode, you can type:

     :map ^^TT ^^VVb/b/b/b/

where bb// is a blank.  The ^^VV is necessary to  prevent  the  blanks
from being taken as white space between the _l_h_s and _r_h_s.

77..  WWoorrdd AAbbbbrreevviiaattiioonnss

     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 ::aabbbbrreevviiaattee and
::uunnaabbbbrreevviiaattee (::aabb and ::uunnaa) and have the same  syntax  as  ::mmaapp.
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  abbrevia-
tion  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









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


keystroke, as it should be with a macro.

77..11..  AAbbbbrreevviiaattiioonnss

     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.

88..  NNiittttyy--ggrriittttyy ddeettaaiillss

88..11..  LLiinnee rreepprreesseennttaattiioonn iinn tthhee ddiissppllaayy

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

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

     If  you  wish,  you  can  have the editor place line numbers
before each line on the display.  Give the command  ::ssee  nnuuCR  to
enable  this, and the command ::ssee nnoonnuuCR to turn it off.  You can
have tabs represented as ^^II and the ends of lines indicated  with
`$'  by  giving  the  command ::ssee lliissttCR; ::ssee nnoolliissttCR turns this
off.

     Finally, lines consisting of only the character `~' are dis-
played  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.

88..22..  CCoouunnttss

     Most  _v_i 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:





-----------
+ You can make long lines very easily by using JJ to join together
short lines.









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


     new window size      ::  //  ??  [[[[  ]]]]  ``  ''
     scroll amount        ^^DD  ^^UU
     line/column number   zz  GG  ||
     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 ^^DD.  The window will revert to the last
specified size the next time it is cleared and refilled.+

     The scroll commands ^^DD and ^^UU 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 rep-
etition  of  the  inserted  text.  Thus 1100aa++--------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
^^RR), the rest of the editor commands use a count  to  indicate  a
simple  repetition  of their effect.  Thus 55ww advances five words
on the current line, while 55RETURN advances five lines.   A  very
useful  instance  of  a count as a repetition is a count given to
the .. command, which repeats the last changing command.   If  you
do  ddww  and  then  33..,  you  will delete first one and then three
words.  You can then delete two more words with 22...

88..33..  MMoorree ffiillee mmaanniippuullaattiioonn ccoommmmaannddss

     The following table lists  the  file  manipulation  commands
which  you can use when you are in _v_i_.  All of these commands are
followed by a CR or ESC.  The most basic commands are ::ww and  ::ee.
A normal editing session on a single file will end with a ZZZZ com-
mand.  If you are editing for a long period of time you can  give
::ww commands occasionally after major amounts of editing, and then
finish with a ZZZZ.   When you edit more than  one  file,  you  can
finish  with one with a ::ww and start editing a new file by giving
-----------
+ But not by a ^^LL which just redraws the screen as it is.









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




     ::ww           write back changes
     ::wwqq          write and quit
     ::xx           write (if necessary) and quit (same as ZZ).
     ::ee _n_a_m_e      edit file _n_a_m_e
     ::ee!!          reedit, discarding changes
     ::ee ++ _n_a_m_e    edit, starting at end
     ::ee ++_n        edit, starting at line _n
     ::ee ##         edit alternate file
     ::ww _n_a_m_e      write file _n_a_m_e
     ::ww!! _n_a_m_e     overwrite file _n_a_m_e
     ::_x_,_yww _n_a_m_e   write lines _x through _y to _n_a_m_e
     ::rr _n_a_m_e      read file _n_a_m_e into buffer
     ::rr !!_c_m_d      read output of _c_m_d into buffer
     ::nn           edit next file in argument list
     ::nn!!          edit next file, discarding changes to current
     ::nn _a_r_g_s      specify new argument list
     ::ttaa _t_a_g      edit file containing tag _t_a_g, at _t_a_g


a ::ee command, or set _a_u_t_o_w_r_i_t_e and use ::nn <file>.

     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 ::ee 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 ++//_p_a_t or ++??_p_a_t.  In forming new names to the ee 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  ::ee
and  get  a diagnostic that you haven't written the file, you can
give a ::ww command and then a ::ee ## command to  redo  the  previous
::ee.

     You  can  write  part of the buffer to a file by finding out
the lines that bound the range to be written using ^^GG, and giving
these  numbers  after  the  :: and before the ww, separated by ,,'s.
You can also mark these lines with mm and then use an  address  of
the form ''_x,,''_y on the ww command here.

     You  can read another file into the buffer after the current
line by using the ::rr command.  You can similarly read in the out-
put from a command, just use !!_c_m_d 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 ::nn.  It is also possible to respecify the
list of files to be edited by giving the ::nn  command  a  list  of









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


file  names,  or a pattern to be expanded as you would have given
it on the initial _v_i command.

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

88..44..  MMoorree aabboouutt sseeaarrcchhiinngg ffoorr ssttrriinnggss

     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 dd, cc or yy,
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
//_p_a_t//--_n to refer to the _n'th line before the next line containing
_p_a_t,  or  you  can use ++ instead of -- to refer to the lines after
the one containing _p_a_t.  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 ::ssee iiccCR.  The command ::ssee
nnooiiccCR 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,
in  any  case.  The following table gives the extended forms when
mmaaggiicc is set.





















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


     ^^        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
     [[_s_t_r]]    matches any single character in _s_t_r
     [[^^_s_t_r]]   matches any single character not in _s_t_r
     [[_x--_y]]    matches any character between _x and _y
     **        matches any number of the preceding pattern


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

88..55..  MMoorree aabboouutt iinnppuutt mmooddee

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


     ^^HH      deletes the last input character
     ^^WW      deletes the last input word, defined as by bb
     eerraassee   your erase character, same as ^^HH
     kkiillll    your kill character, deletes the input on this line
     \\       escapes a following ^^HH and your erase and kill
     EESSCC     ends an insertion
     DDEELL     interrupts an insertion, terminating it abnormally
     CCRR      starts a new line
     ^^DD      backtabs over _a_u_t_o_i_n_d_e_n_t
     00^^DD     kills all the _a_u_t_o_i_n_d_e_n_t
     ^^^^DD     same as 00^^DD, but restores indent next line
     ^^VV      quotes the next non-printing character into the file



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

     Your system kill character, normally @@, ^^XX or ^^UU, 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 AA which appends at the end of the cur-
rent line is often useful for continuing.

     If you wish to type in your erase or kill character  (say  #
or  @) then you must precede it with a \\, just as you would do at
the normal system command level.  A more general  way  of  typing









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


non-printing  characters  into the file is to precede them with a
^^VV.  The ^^VV 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 _a_u_t_o_i_n_d_e_n_t you can backtab over the  indent
which  it supplies by typing a ^^DD.  This backs up to a _s_h_i_f_t_w_i_d_t_h
boundary.  This only works immediately after the supplied _a_u_t_o_i_n_-
_d_e_n_t.

     When  you are using _a_u_t_o_i_n_d_e_n_t 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 ^^DD.  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 00 followed immediately by a ^^DD if you wish to
kill all the indent and not have it come back on the next line.

88..66..  UUppppeerr ccaassee oonnllyy tteerrmmiinnaallss

     If your terminal has only upper case, you can still  use  _v_i
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 charac-
ters are represented on the display in  the  same  way  they  are
typed.++

88..77..  VVii aanndd eexx

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

     In  rare  instances,  an internal error may occur in _v_i_.  In
this case you will get a diagnostic and be left  in  the  command
mode  of _e_x_.  You can then save your work and quit if you wish by
-----------
*  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 ^^JJ) 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 corre-
sponding control character.  This is the only way to type  ^^SS  or
^^QQ,  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
key.









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


giving a command xx after the :: which _e_x prompts you with, or  you
can reenter _v_i by giving _e_x a _v_i command.

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

88..88..  OOppeenn mmooddee:: vvii oonn hhaarrddccooppyy  tteerrmmiinnaallss  aanndd  ````ggllaassss  ttttyy''ss''''
[[++++]]

     If  you  are on a hardcopy terminal or a terminal which does
not have a cursor which can move off the  bottom  line,  you  can
still  use  the command set of _v_i_, but in a different mode.  When
you give a _v_i command, the editor will tell you that it is  using
_o_p_e_n mode.  This name comes from the _o_p_e_n command in _e_x_, which is
used to get into the same mode.

     The only difference between _v_i_s_u_a_l mode and _o_p_e_n mode is the
way in which the text is displayed.

     In  _o_p_e_n  mode the editor uses a single line window into the
file, and moving backward and forward  in  the  file  causes  new
lines  to  be displayed, always below the current line.  Two com-
mands of _v_i work differently in _o_p_e_n_: zz and ^^RR.   The  zz  command
does  not  take  parameters, but rather draws a window of context
around the current line and then returns you to the current line.

     If  you  are  on  a  hardcopy  terminal, the ^^RR command will
retype the current line.  On such terminals, the editor  normally
uses  two lines to represent the current line.  The first line is
a copy of the line as you started to edit it, and you work on the
line  below  this  line.   When you delete characters, the editor
types a number of \'s  to  show  you  the  characters  which  are
deleted.   The  editor  also reprints the current line soon after
such changes so that you can see what the line looks like  again.

     It  is sometimes useful to use this mode on very slow termi-
nals which can support _v_i in the full screen mode.   You  can  do
this by entering _e_x and using an _o_p_e_n command.


AAcckknnoowwlleeddggeemmeennttss

     Bruce  Englar  encouraged the early development of this dis-
play 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.











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


AAppppeennddiixx:: cchhaarraacctteerr ffuunnccttiioonnss

     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-
ters.

     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  paren-
theses indicate where the character is discussed; a `f' after the
section number means that the character is mentioned in  a  foot-
note.

^^@@             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 mech-
               anism is not available.  A ^^@@ cannot  be  part  of
               the  file due to the editor implementation (7.5f).

^^AA             Unused.

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

^^CC             Unused.

^^DD             As a command, scrolls down a half-window of  text.
               A  count  gives  the  number of (logical) lines to
               scroll, and is remembered for  future  ^^DD  and  ^^UU
               commands  (2.1,  7.2).  During an insert, backtabs
               over _a_u_t_o_i_n_d_e_n_t white space at the beginning of  a
               line  (6.6,  7.5);  this  white  space  cannot  be
               backspaced over.

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

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

^^GG             Equivalent to ::ffCR,  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.











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


^^HH ((BS))        Same as lleefftt aarrrrooww.  (See hh).  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).

^^II ((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 _t_a_b_s_t_o_p option (4.1, 6.6).

^^JJ ((LF))        Same as ddoowwnn aarrrrooww (see jj).

^^KK             Unused.

^^LL             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).

^^MM ((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).

^^NN             Same as ddoowwnn aarrrrooww (see jj).

^^OO             Unused.

^^PP             Same as uupp aarrrrooww (see kk).

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

^^RR             Redraws the current  screen,  eliminating  logical
               lines  not  corresponding to physical lines (lines
               with only a single @ character on them).  On hard-
               copy  terminals  in _o_p_e_n mode, retypes the current
               line (5.4, 7.2, 7.8).

^^SS             Unused.  Some teletype drivers use ^^SS  to  suspend
               output until pressed.^^QQis

^^TT             Not  a  command character.  During an insert, with
               _a_u_t_o_i_n_d_e_n_t set and at the beginning of  the  line,
               inserts _s_h_i_f_t_w_i_d_t_h white space.











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


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

^^VV             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).

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

^^XX             Unused.

^^YY             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 ^^UU which  scrolls  up  a  bunch.)   (Version  3
               only.)

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

^^[[ ((ESC))       Cancels  a  partially  formed command, such as a zz
               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  edi-
               tor  rings the bell.  If you don't know if you are
               in insert mode you can type ESCaa, and  then  mate-
               rial  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 ::ttaa, this  word,  and
               then  a  CR.   Mnemonically,  this command is ``go
               right to'' (7.3).

^^^^             Equivalent to ::ee ##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









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


               to  do  a ::ww before ^^^^ will work in this case.  If
               you do not wish to write the file  you  should  do
               ::ee!! ##CR instead.)

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

SPACE          Same as rriigghhtt aarrrrooww (see ll).

!!              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 22!!}}_f_m_tCR reformats the next two para-
               graphs  by  running  them through the program _f_m_t.
               If  you  are  working   on   LISP,   the   command
               !!%%_g_r_i_n_dCR,* 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 ::rr (7.3).  To
               simply execute a command use ::!! (7.3).

""              Precedes a named buffer specification.  There  are
               named buffers 11--99 used for saving deleted text and
               named buffers aa--zz into which you  can  place  text
               (4.3, 6.3)

##              The macro character which, when followed by a num-
               ber, will substitute for a function key on  termi-
               nals  without function keys (6.9).  In input mode,
               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
               gave.

$$              Moves to the end of the current line.  If you  ::ssee
               lliissttCR, 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  22$$  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 _e_x && com-
               mand.
-----------
*Both  _f_m_t and _g_r_i_n_d are Berkeley programs and may not be present
at all installations.









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


''              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
               aa-zz, returns to the line  which  was  marked  with
               this  letter  with  a mm command, at the first non-
               white character in the  line.  (2.2,  5.3).   When
               used  with  an  operator  such as dd, 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, or to the
               beginning  of  a  LISP  s-expression  if  the _l_i_s_p
               option is set.  A sentence 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  sen-
               tences (4.2, 6.8).

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

**              Unused.

++              Same as CR when used as a command.

,,              Reverse  of  the  last ff FF tt or TT command, looking
               the other way in  the  current  line.   Especially
               useful  after  hitting  too  many ;; characters.  A
               count repeats the search.

--              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  scrolling would be required the screen
               is also cleared and redrawn, with the current line
               at the center (2.3).

..              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 22ddww, 33..  deletes  three  words  (3.3,
               6.3, 7.2, 7.4).











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


//              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;  an
               returns  to  command state without ever searching.
               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
               progress; 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 nnoommaaggiicc in your _._e_x_r_c
               file you will have to preceed 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).

00              Moves  to the first character on the current line.
               Also used, in forming numbers,  after  an  initial
               11-99.

11--99            Used  to  form numeric arguments to commands (2.3,
               7.2).

::              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
               ff FF tt or TT.   A  count  iterates  the  basic  scan
               (4.1).

<<              An   operator   which   shifts   lines   left  one
               _s_h_i_f_t_w_i_d_t_h,   normally   8   spaces.    Like   all









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


               operators,  affects lines when repeated, as in <<<<.
               Counts are passed through  to  the  basic  object,
               thus 33<<<< shifts three lines (6.6, 7.2).

==              Reindents line for LISP, as though they were typed
               in with _l_i_s_p and _a_u_t_o_i_n_d_e_n_t set (6.8).

>>              An  operator  which   shifts   lines   right   one
               _s_h_i_f_t_w_i_d_t_h, 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).

AA              Appends  at  the  end  of  line,  a synonym for $$aa
               (7.2).

BB              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
               (2.4).

CC              Changes  the rest of the text on the current line;
               a synonym for cc$$.

DD              Deletes the rest of the text on the current  line;
               a synonym for dd$$.

EE              Moves  forward  to  the  end of a word, defined as
               blanks and non-blanks, like  BB  and  WW.   A  count
               repeats the effect.

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

GG              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 cur-
               rent line in the center if necessary (7.2).

HH              HHoommee aarrrrooww.  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









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


               target  of  an  operator,  full lines are affected
               (2.3, 3.2).

II              Inserts at the beginning of a line; a synonym  for
               ^^ii.

JJ              Joins  together lines, supplying appropriate white
               space: 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).

KK              Unused.

LL              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 LL (2.3).

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

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

OO              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
               opened;   this   is  generally  obsolete,  as  the
               _s_l_o_w_o_p_e_n option works better (3.1).

PP              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
               before and at the cursor.  May be  preceded  by  a
               named buffer specification ""_x to retrieve the con-
               tents of the buffer; buffers 11-99  contain  deleted
               material,  buffers  aa-zz  are available for general
               use (6.3).

QQ              Quits from _v_i to _e_x 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).

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











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


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

TT              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
               operators such as dd (4.1).

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

VV              Unused.

WW              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).

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

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

ZZZZ             Exits the editor.  (Same as ::xxCR.)  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 _s_e_c_t_i_o_n_s option,
               normally a `.NH' or `.SH' and also at lines  which
               which  start  with a formfeed ^^LL.  Lines beginning
               with {{ also stop [[[[;  this  makes  it  useful  for
               looking backwards, a function at a time, in C pro-
               grams.  If the option _l_i_s_p is set, stops at each ((
               at the beginning of a line, and is thus useful for
               moving backwards at the top  level  LISP  objects.
               (4.2, 6.1, 6.6, 7.2).

\\              Unused.

]]]]             Forward  to a section boundary, see [[[[ for a defi-
               nition (4.2, 6.1, 6.6, 7.2).

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










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


__              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 aa-zz, returns to the  position
               which  was  marked  with this letter with a mm com-
               mand.  When used with an operator such as  dd,  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).

aa              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).

bb              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).

cc              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
               33cc)) and cc33)) change the following  three  sentences
               (7.4).

dd              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 33ddww is  the
               same as dd33ww (3.3, 3.4, 4.1, 7.4).

ee              Advances  to  the end of the next word, defined as
               for bb and ww.  A count  repeats  the  effect  (2.4,
               3.1).

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

gg              Unused.

               Arrow keys hh, jj, kk, ll, and HH.










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


hh              LLeefftt aarrrrooww.  Moves the cursor one character to the
               left.  Like the other arrow keys,  either  hh,  the
               lleefftt  aarrrrooww  key,  or one of the synonyms (^^HH) has
               the same effect.  On v2  editors,  arrow  keys  on
               certain  kinds  of  terminals  (those  which  send
               escape sequences, such as vt52, c100, or hp)  can-
               not  be  used.   A  count repeats the effect (3.1,
               7.5).

ii              Inserts text before the cursor, otherwise  like  aa
               (7.2).

jj              DDoowwnn aarrrrooww.  Moves the cursor one line down in the
               same column.  If the position does not  exist,  _v_i
               comes  as  close  as  possible to the same column.
               Synonyms include ^^JJ (linefeed) and ^^NN.

kk              UUpp aarrrrooww.  Moves the cursor one line up.  ^^PP is  a
               synonym.

ll              RRiigghhtt  aarrrrooww.   Moves  the cursor one character to
               the right.  SPACE is a synonym.

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

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

oo              Opens  new lines below the current line; otherwise
               like OO (3.1).

pp              Puts text after/below the cursor; otherwise like PP
               (6.3).

qq              Unused.

rr              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;
               see RR above which is the more usually useful iter-
               ation of rr (3.2).

ss              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 cc (3.2).

tt              Advances  the cursor upto the character before the
               next character typed.  Most useful with  operators









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


               such  as  dd and cc to delete the characters up to a
               following character.  You can use .. to delete more
               if  this  doesn't  delete  enough  the  first time
               (4.1).

uu              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).

vv              Unused.

ww              Advances  to  the  beginning  of the next word, as
               defined by bb (2.4).

xx              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).

yy              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 pp or PP (7.4).

zz              Redraws the screen with the current line placed as
               specified by the following character: RETURN spec-
               ifies  the  top of the screen, .. the center of the
               screen, and -- at the  bottom  of  the  screen.   A
               count may be given after the zz and before the fol-
               lowing character to specify the  new  screen  size
               for  the  redraw.   A count before the zz 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  _p_a_r_a_g_r_a_p_h_s option, normally `.IP',
               `.LP', `.PP', `.QP' and `.bp'.  A  paragraph  also
               begins  after a completely empty line, and at each
               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,
               7.6).

~~              Unused.










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


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





























































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


               .



























































