Command:   elvis  clone of the Berkeley vi editor
     Syntax:    elvis [Rerv] [t tag] [file] ...
     Flags:     R   Set the read-only option
     Flags:     e   Start up emulating ex
     Flags:     r   Tell the user to use elvrec instead
     Flags:     t   Start editing at the given tag
     Flags:     v   Start up emulating vi
     Examples:  elvis                    # Call the editor
     Examples:  elvis prog.c             # edit prog.c

     Elvis is a full-screen editor closely modeled on the  famous
     Berkeley vi editor.  It provides essentially the same inter-
     face to the user as vi, but  the  code  is  completely  new,
     written from scratch.  This document provides a brief intro-
     duction to vi.   It  is  not  intended  as  a  tutorial  for
     beginners.  Most books on UNIX cover vi.

     Like vi, elvis can operate as a screen editor (vi  mode)  or
     as a line editor (ex) mode. It can be called either as elvis
     vi,or as ex, depending on which is desired.   They  are  all
     links to the same file.

     Vi Commands

     Below is a list of the vi commands supported.  The following
     symbols are used in the table:
       count     Integer parameter telling how many or how much
       key       One character parameter to the command
       inp       Interactive input expected
       mv        Indicates how much for commands like delete  and
                 change:
                      (  Previous sentence
                      )  Next sentence
                      {  Previous paragraph
                      }  Next paragraph (delimited by blank line,
                         .PP, .LP, .IP etc.)
                      [  Previous section (delimited  by  .SH  or
                         .NH)
                         A repeated command character  means  the
                         scope is this line
       MOVE      Indicates commands that may also be  used  where
                 mv is specified
       EDIT      These commands affect text and may  be  repeated
                 by the . command
    In addition to the above notation, the caret (^) is  used  as
    an abbreviation for CTRL.  For example, ^A means CTRL-A.
    Count     Command   Description                      Type
              ^A        (Not defined)
              ^B        Move toward the top  of  the  file  by  1
                        screenful
              ^C        (Not defined)
    count     ^D        Scroll  down  count  lines  (default  1/2
                        screen)
    count     ^E        Scroll up count lines
              ^F        Move toward the bottom of the file  by  1
                        screenful
              ^G        Show file status, and the current line
    count     ^H        Move left, like h                MOVE
              ^I        (Not defined)
    count     ^J        Move down                        MOVE
              ^K        (Not defined)
              ^l        Redraw the screen
    count     ^M        Move to the front of the next lineMOVE
    count     ^N        Move down                        MOVE
              ^O        (Not defined)
    count     ^P        Move up                          MOVE
              ^Q        (Not defined)
              ^R        Redraw the screen
              ^S        (Not defined)
              ^T        (Not defined)
    count     ^U        Scroll  up  count  lines   (default   1/2
                        screen)
              ^V        (Not defined)
              ^W        (Not defined)
              ^X        (Not defined)
    count     ^Y        Scroll down count lines
              ^Z        (Not defined)
              ESC       (Not defined)
              ^\        (Not defined)
              ^]        If the cursor is on a  tag  name,  go  to
                        that tag
              ^^        Save this file and edit the previous file
              ^_        (Not defined)
    count     SPACE     Move right,like l                MOVE
              ! mv      Run the selected lines thru  an  external
                        filter program
              " key     Select which cut buffer to use next
              #         (Not defined)
              $         Move to the rear of the current lineMOVE
              %         move to the matching (){}[] characterMOVE
              &         (Not defined)
              ' key     Move to a marked line            MOVE
    count     (         Move backward count sentences    MOVE
    count     )         Move forward count sentences     MOVE
              *         (Not defined)
    count     +         Move to the front of the next lineMOVE
    count     ,         Repeat the previous [fFtT] but the  other
                        wayMOVE
    count               Move  to  the  front  of  the   preceding
                        lineMOVE
              .         Repeat the previous 'edit' command
               /        Text search forward for a  given  regular
                        exprMOVE
              0         If not part of count, move to 1st char of
                        this line      MOVE
              1         Part of count
              2         Part of count
              3         Part of count
              4         Part of count
              5         Part of count
              6         Part of count
              7         Part of count
              8         Part of count
              9         Part of count
              :         Text. Run single ex cmd
    count     ;         Repeat the previous [fFtT] cmd   MOVE
    count     < mv      Shift text left                  EDIT
              =         (Not defined)
    count     > mv      Shift text right                 EDIT
              ?  text    Search  backward  for  a  given  regular
                        expressionMOVE
              @         (Not defined)
    count     A inp     Append at end of the line        EDIT
    count     B         Move back Word                   MOVE
              C inp     Change text from cursor  through  end  of
                        lineEDIT
              D         Delete text from  cursor through  end  of
                        lineEDIT
    count     E         Move end of Word                 MOVE
    count     F key     Move leftward to a given characterMOVE
    count     G         Move to line #count (default is the  bot-
                        tom line)MOVE
    count     H         Move to home row (the line at the top  of
                        the screen)
    count     I inp     Insert at the front of  the  line  (after
                        indents)EDIT
    count     J         Join lines, to form one big line EDIT
              K         Look up keyword
    count     L         Move to last row (the line at the  bottom
                        of the screen)
              M         Move to middle row (the line in the  mid-
                        dle)
              N         Repeat previous search, but the  opposite
                        wayMOVE
    count     O inp     Open up a  new  line  above  the  current
                        lineEDIT
              P         Paste text before the cursor
              Q         Quit to EX mode
              R inp     Overtype                         EDIT
    count     S inp     Change lines, like countcc
    count     T key     Move leftward almost to a  given  charac-
                        terMOVE
              U         Undo all recent changes  to  the  current
                        line
              V         (Not defined)
    count     W         Move forward count Words         MOVE
    count     X         Delete the character(s) to  the  left  of
                        the cursorEDIT
    count     Y         Yank text line(s) (copy them into  a  cut
                        buffer)
              Z Z       Save the file & exit
              [ [       Move back 1 section              MOVE
              \         (Not defined)
              ] ]       Move forward 1 section           MOVE
              ^         Move to the front  of  the  current  line
                        (after indent)MOVE
              _         (Not defined)
              ` key     Move to a marked character       MOVE
    count     a inp     Insert text after the cursor     EDIT
    count     b         Move back count words            MOVE
              c mv      Change text                      EDIT
              d mv      Delete text                      EDIT
    count     e         Move forward to the end  of  the  current
                        wordMOVE
    count     f key     Move rightward to a given characterMOVE
              g         (Not defined)
    count     h         Move left                        MOVE
    count     i inp     Insert text at the cursor        EDIT
    count     j         Move down                        MOVE
    count     k         Move up                          MOVE
    count     l         Move right                       MOVE
              m key     Mark a line or character
              n         Repeat the previous search       MOVE
    count     o  inp     Open  a  new  line  below  the   current
                        lineEDIT
              p         Paste text after the cursor
              q         (Not defined)
    count     r key     Replace count chars by  a  given  charac-
                        terEDIT
    count     s inp     Replace count chars with  text  from  the
                        userEDIT
    count     t key     Move rightward almost to a given  charac-
                        terMOVE
              u         Undo the previous edit command
              v         (Not defined)
    count     w         Move forward count words         MOVE
    count     x         Delete the character  that  the  cursor's
                        onEDIT
              y mv      Yank text (copy it into a cut buffer)
              z key     Scroll current line to the screen's +=top
                        -=bottom .=middle
    count     {         Move back count paragraphs       MOVE
    count     |         Move to column count (the leftmost column
                        is 1)
    count     }         Move forward count paragraphs    MOVE
    count     ~         Switch a character between upper &  lower
                        caseEDIT
              DEL       (Not defined)

    Ex Commands

     Below is a list of the ex commands supported.   All  can  be
     abbreviated.


     General


     [line]      append
                 args        [files]
                 cd          [directory]
                 chdir       [directory]
     [line][,line]           change
     [line][,line]           copyline
     [line][,line]           debug[!]
     [line][,line]           Delete['x]
                 edit[!]     [file]
                 ex[!]       [file]
                 file
     [line][,line]           global/regexp/ command
     [line]      Insert
     [line][,line]           join
     [line][,line]           list
                 map[!]      key mapped_to
     [line]      mark        x
                 mkexrc
     [line][,line]           Moveline
                 next[!]     [files]
                 Next[!]
                 previous[!]
     [line][,line]           print
     [line]      put         ['x]
                 quit[!]
     [line]      read        file
                 rewind[!]
                 set         [options]
     [line][,line]           substitute/regexp/replacement/[p][g]
                 tag[!]      tagname
     [line][,line]           toline
                 Undo
                 unmap[!]    key
                 validate[!]
                 version
     [line][,line]           vglobal/regexp/ command
                 visual
                 wq
     [line][,line]           write[!][[>>]file]
                 xit[!]
     [line][,line]           yank['x]
     [line][,line]           !command
     [line][,line]           <
     [line][,line]           =
     [line][,line]           >



     Text Entry



     [line]      append
     [line][,line]           change ['x]
     [line]      Insert

     The (a)ppend command inserts text after the specified line.

     The (i)nsert command inserts text before the specified line.

     The (c)hange command copies the range of lines  into  a  cut
     buffer,  deletes  them,  and  inserts new text where the old
     text used to be.

     For all of these commands, you indicate the end of the  text
     you're  inserting  by hitting ^D or by entering a line which
     contains only a period.



     Cut & Paste



     [line][,line]           Delete ['x]
     [line][,line]           yank ['x]
     [line]      put[!] ['x]
     [line][,line]           copy line
     [line][,line]           to line
     [line][,line]           Move line

     The (d)elete command copies the  specified  range  of  lines
     into a cut buffer, and then deletes them.

     The (y)ank command copies the specified range of lines  into
     a cut buffer, but does not delete them.

     The (pu)t command inserts text from a cut buffer  after  the
     specified line-or before it if the ! is present.

     The (co)py and (t)o commands yank  the  specified  range  of
     lines and then immediately paste them after some other line.

     The (m)ove command deletes the specified range of lines  and
     then  immediately pastes them after some other line.  If the
     destination line comes after the deleted text, then it  will
     be adjusted automatically to account for the deleted lines.


     Displaying Text


     [line][,line]           print
     [line][,line]           list

     The (p)rint command displays the specified range of lines.

     The (l)ist command also displays them, but it is careful  to
     make control characters visible.


     Global Operations


     [line][,line]           global /regexp/ command
     [line][,line]           vglobal /regexp/ command

     The (g)lobal command  searches  through  the  lines  of  the
     specified  range  (or  through the whole file if no range is
     specified) for lines that contain a  given  regular  expres-
     sion.   It  then moves the cursor to each of these lines and
     runs some other command on them.

     The (v)global command is similar, but it searches for  lines
     that do not contain the regular expression.


     Line Editing


     [line][,line]           join
     [line][,line]           ! program
     [line][,line]           <
     [line][,line]           >
     [line][,line]           substitute /regexp/replacement/[p][g]

     The (j)oin command concatenates all lines in  the  specified
     range  together to form one big line.  If only a single line
     is specified, then the following line is catenated onto it.

     The ! command runs an external filter program, and feeds the
     specified  range of lines to it's stdin.  The lines are then
     replaced by the output of the  filter.   A  typical  example
     would  be ':'a,'z!sort -n' to sort the lines 'a,'z according
     to their numeric values.

     The < and > commands shift the specified range of lines left
     or  right,  normally  by  the width of 1 tab character.  The
     'shiftwidth' option determines the shifting amount.

     The (s)ubstitute command finds  the  regular  expression  in
     each  line,  and replaces it with the replacement text.  The
     'p' option causes the altered lines to be printed,  and  the
     'g'  option  permits all instances of the regular expression
     to be found  &  replaced.   (Without  'g',  only  the  first
     occurrence is replaced.)



     Undo



                 undo

     The (u)ndo command restores the file to the state it was  in
     before your most recent command which changed text.



     Configuration & Status



                 map[!] [key mapped_to]
                 unmap[!] key
                 set [options]
                 mkexrc
     [line]      mark x
                 visual
                 version
     [line][,line]           =
                 file

     The (ma)p command allows you to configure elvis to recognize
     your  function keys, and treat them as though they transmit-
     ted some other sequence of characters.  Normally  this  map-
     ping  is done only when in the visual command mode, but with
     the [!]present it will map keys under  all  contexts.   When
     this  command  is given with no arguments, it prints a table
     showing all mappings currently in effect.  When called  with
     two  arguments, the first is the sequence that your function
     key really sends, and the second is the  sequence  that  you
     want elvis to treat it as having sent.

     The (unm)ap command removes key definitions that  were  made
     via the map command.

     The (se)t command allows you examine or set various options.
     With  no  arguments,  it displays the values of options that
     have been  changed.   With  the  single  argument  'all'  it
     displays  the  values  of all options, regardless of whether
     they've been explicitly set or not.   Otherwise,  the  argu-
     ments are treated as options to be set.

     The (mk)exrc command saves the current  configuration  to  a
     file called .exrc in the current directory.

     The mar(k) command defines  a  named  mark  to  refer  to  a
     specific  place in the file.  This mark may be used later to
     specify lines for other commands.

     The (vi)sual command  puts  the  editor  into  visual  mode.
     Instead of emulating ex, elvis will start emulating vi.

     The (ve)rsion command tells you that what version  of  elvis
     this is.

     The = command tells you what line you specified, or, if  you
     specified  a range of lines, it will tell you both endpoints
     and the number of lines included in the range.

     The file command tells you the name of the file, whether  it
     has  been modified, the number of lines in the file, and the
     current line number.


     Multiple Files


                 args [files]
                 next[!] [files]
                 Next[!]
                 previous[!]
                 rewind[!]

     When you invoke elvis from your shell's  command  line,  any
     filenames  that you give to elvis as arguments are stored in
     the args list.  The (ar)gs command will display  this  list,
     or define a new one.

     The (n)ext command switches from the  current  file  to  the
     next  one in the args list.  You may specify a new args list
     here, too.

     The (N)ext and (pre)vious commands (they're  really  aliases
     for  the  same  command) switch from the current file to the
     preceding file in the args list.

     The (rew)ind command switches from the current file  to  the
     first file in the args list.

     Switching Files



                 edit[!] [file]
                 tag[!] tagname

     The (e)dit command allows to switch from the current file to
     some other file.  This has nothing to do with the args list,
     by the way.

     The (ta)g command looks up a given tagname in a file  called
     'tags".   This tells it which file the tag is in, and how to
     find it in that file.  Elvis then switches to the tag's file
     and finds the tag.



     Exiting



                 quit[!]
                 wq
                 xit

     The (q)uit command exits from the editor without saving your
     file.

     The (wq) and (x)it commands (really two names for  the  same
     command) both write the file before exiting.


     File I/O


     [line]      read file
     [line][,line]           write[!][[>>]file]

     The (r)ead command gets text from another file  and  inserts
     it after the specified line.

     The (w)rite command writes the whole file, or just  part  of
     it,  to some other file.  The !, if present, will permit the
     lines to be written even if you've set the readonly  option.
     If  you  precede  the  filename  by >> then the lies will be
     appended to the file.


     Directory

                 cd [directory]
                 chdir [directory]
                 shell

     The (cd) and (chd)ir commands (really two names for one com-
     mand) switch the current working directory.

     The (sh)ell command starts an interactive shell.



     Debugging



     [line][,line]           debug[!]
                 validate[!]

     These commands are only available if you compile elvis  with
     the -DDEBUG flag.

     The de(b)ug command lists stats for the blocks which contain
     the specified range of lines.  If the ! is present, then the
     contents of those blocks is displayed, too.

     The (va)lidate command checks certain variables for internal
     consistency.  Normally it does not output anything unless it
     detects a problem.  With the !, though, it will always  pro-
     duce *some* output.


     Extensions


       In addition to the standard commands, a variety  of  extra
       features  are present in elvis that are not present in vi.
       They are described below.

    .exrc
       Elvis first runs a .exrc file (if there is one) from  your
       $HOME  directory. After that, it runs a .exrc (if there is
       one) from the current directory.  The one in  the  current
       directory  may  override  settings  made by the one in the
       $HOME directory.

    :mkexrc
    :mk
       This EX command saves the current :set and :map configura-
       tions in the '.exrc' file in your current directory.

    :args
    :ar
       You can use the :args command to define a new  args  list,
       as in:

                 :args *.h

       After you have defined a new args list, the next time  you
       issue  a :next command elvis will switch to the first file
       of the new list.

    :Next
    :previous
    :N
    :pre
       These commands move backwards through the args list.

    zz
       In VI,  the  (lowercase)  'zz'  command  will  center  the
       current line on the screen, like 'z="

    .
       The default count value for . is the same as the  previous
       command which . is meant to repeat.  However, you can sup-
       ply a new count if you wish. For example, after '3dw', '.'
       will delete 3 words, but '5.' will delete 5 words.

    "
       The text which was most recently input (via  a  'cw'  com-
       mand,  or  something  similar)  is  saved  in a cut buffer
       called ". (which is a pretty hard  name  to  write  in  an
       English  sentence).   You can use this with the 'p' or 'P'
       commands thusly:
                 ".p
    K
       You can move the cursor onto a word and press  shift-K  to
       have  elvis  run a reference program to look that word up.
       This command alone is worth the price of  admission!   See
       the ctags and ref programs.

    input
       You can backspace back past the beginning of the line.  If
       you type CTRL-A, then the text that you input last time is
       inserted.  You will remain in input mode, so you can back-
       space  over  part of it, or add more to it.  (This is sort
       of like CTRL-@ on the real vi, except that  CTRL-A  really
       works.)

       Real vi can only remember up to 128 characters  of  input,
       but elvis can remember any amount.

    :set charattr
    :se ca
       Elvis can display 'backslash-f' style character attributes
       on  the  screen  as you edit.  The following example shows
       the recognized attributes:

                 normal boldface italics

       NOTE: you must compile elvis without  the  DSET_NOCHARATTR
       flag for this to work.

    Omissions

     A few vi features are missing.  The replace mode is a  hack.
     It does not save the text that it overwrites.

     Long lines are displayed differently-where the real vi would
     wrap a long line onto several rows of the screen, elvis sim-
     ply displays part of the line, and allows you to scroll  the
     screen sideways to see the rest of it.

     The ':preserve' and ':recover' commands are missing,  as  is
     the r flag.  ':Preserve" is practically never used and since
     use of ':recover\*(CQ is so rare, it was decided  to  imple-
     ment  it as a separate program.  There's no need to load the
     recovery code into memory every time you edit a file.

     LISP support is missing.  The  '@'  and  ':@'  commands  are
     missing.  You cannot APPEND to a cut buffer.

     Options

     A variety of options can be set as described below:
       Name     Abbr        Type     DefaultDescription
       autoindent   as      Bool     FALSEautoindent during input?
       autowrite    aw      Bool     FALSEwrite file for :n command?
       charattr ca  Bool    FALSE    display bold & underline chars?
       columns  co  Number  80       width of screen, in characters
       directory    dir     String   /usr/tmpwhere tmp files are kept
       errorbells   eb      Bool     TRUEring bell on error?
       exrefresh    er      Bool     TRUEEX mode calls write() often?
       ignorecase   ic      Bool     FALSEsearches: upper/lowercase OK?
       keytime  kt  Number  1        allow slow receipt of ESC seq?
       keywordprg   kp      String   /usr/bin/refprogram to run for shift-K
       lines    ln  Number  25       height of screen, in lines
       list     li  Bool    FALSE    show tabs as '^I'?
       magic    ma  Bool    TRUE     searches: allow metacharacters?
       paragraphs   pa      String   PPppPApaparagraphs start with .PP, etc.
       readonly ro  Bool    FALSE    no file should be written back?
       report   re  Number  5        report changes to X lines?
       scroll   sc  Number  12       default #lines for ^U and ^D
       sections se  String  SEseSHsh sections start with .SE, etc.
       shell    sh  String  /bin/sh  shell program, from environment
       shiftwidth   sw      Number   8width of < or > commands
       sidescroll   ss      Number   8#chars to scroll sideways by
       sync     sy  Bool    FALSE    call sync() after each change?
       tabstop  ts  Number  8        width of a tab character
       term     te  String  "?"      terminal type, from environment
       vbell    vb  Bool    TRUE     use visible bell if possible?
       warn     wa  Bool    TRUE     warn if file not saved for :!cmd
       wrapmargin   wm      Number   0Insert newline after which col?
       wrapscan ws  Bool    TRUE     searches: wrap at EOF?

    autoindent
       During input mode, the autoindent option will  cause  each
       added  line  to begin with the same amount of leading whi-
       tespace as the line above it.  Without  autoindent,  added
       lines are initially empty.

    autowrite
       When you're editing one  file  and  decide  to  switch  to
       another-via the :tag command, or :next command, perhaps-if
       your current file has been modified, then elvis will  nor-
       mally print an error message and refuse to switch.

       However, if the autowrite option is on,  then  elvis  will
       write  the  modified  version of the current file and suc-
       cessfully switch to the new file.

    charattr
       Many text formatting programs allow you to designate  por-
       tions  of your text to be underlined, italicized, or bold-
       face by embedding the special strings \fU, \fI, and \fB in
       your text.  The special string \fR marks the end of under-
       lined or boldface text.

       Elvis normally treats those special strings just like  any
       other  text.   However, if the charattr option is on, then
       elvis will interpret those special strings  correctly,  to
       display  underlined or boldface text on the screen.  (This
       only works, of course, if your terminal can display under-
       lined  and  boldface, and if the TERMCAP entry says how to
       do it.)

    columns
       This is a 'read  only'  option.   You  cannot  change  its
       value, but you can have elvis print it.  It shows how wide
       your screen is.

    directory
       Elvis uses temporary files to store  changed  text.   This
       option  allows  you to control where those temporary files
       will be.  Ideally, you should store them on in  fast  non-
       volatile memory, such as a hard disk.

       This option can only be set in the ".exrc" file.

    errorbells
       Normally, elvis will ring your terminal's bell if you make
       an  error.   However,  in noerrorbells mode, your terminal
       will remain silent.

    exrefresh
       The EX mode of elvis writes many lines to the screen.  You
       can  make  elvis  either  write  each  line  to the screen
       separately, or save up many lines and write  them  all  at
       once.

       The exrefresh option is normally on, so each line is writ-
       ten to the screen separately.

       You may wish to turn the exrefresh option off  (:se  noer)
       if  the  'write' system call is costly on your machine, or
       if  you're  using  a  windowing  environment.   (Windowing
       environments  scroll text a lot faster when you write many
       lines at once.)

       This option has no effect in vi mode.

    ignorecase
       Normally, when elvis searches for text, it  treats  upper-
       case letters as being different for lowercase letters.

       When the ignorecase option is on, uppercase and  lowercase
       are treated as equal.

    keytime
       The arrow keys of most terminals  send  a  multi-character
       sequence.   It takes a measurable amount of time for these
       sequences to be transmitted.  The  keytime  option  allows
       you  to control the maximum amount of time to allow for an
       arrow key (or other mapped key) to be received in full.

       The default keytime value is 2.  Because of the  way  UNIX
       timekeeping  works, the actual amount of time allowed will
       vary slightly, but it will  always  be  between  1  and  2
       seconds.

       If you set keytime to 1, then the actual  amount  of  time
       allowed  will  be  between 0 and 1 second.  This will gen-
       erally make the keyboard's response  be  a  little  faster
       (mostly for the ESC key), but on those occasions where the
       time allowed happens to be closer  to  0  than  1  second,
       elvis  may  fail  to  allow enough time for an arrow key's
       sequence to be received fully.  Ugh.

       As a special case, you can set keytime  to  0  to  disable
       this  time  limit  stuff altogether.  The big problem here
       is:  If your arrow keys' sequences start with an ESC, then
       every  time  you  hit  your ESC key elvis will wait... and
       wait... to see if maybe that ESC  was  part  of  an  arrow
       key's sequence.

       NOTE: this option  is  a  generalization  of  the  timeout
       option of the real vi.

    keywordprg
       Elvis has a special keyword lookup feature.  You move  the
       cursor  onto  a  word,  and  hit  shift-K,  and elvis uses
       another program to look up the word and  display  informa-
       tion about it.

       This option says which program gets run.  It  should  con-
       tain  the  full pathname of the program; your whole execu-
       tion path is not checked.

       The default value of this option is /usr/bin/ref, which is
       a program that looks up the definition of a function in C.
       It looks up the function name  in  a  file  called  'refs'
       which is created by ctags.

       You can substitute other programs, such as an English dic-
       tionary program or the online manual.  elvis runs the pro-
       gram, using the keyword as its only argument.  The program
       should  write  information  to stdout.  The program's exit
       status should be 0, unless you want elvis  to  print  '<<<
       failed >>>".

    lines
       This 'read only' option shows how many  lines  you  screen
       has.

    list
       Normally (in 'nolist" mode) elvis will expand tabs to  the
       proper  number  of  spaces on the screen, so that the file
       appears the same would it would be if you  printed  it  or
       looked at it with more.

       Sometimes, though, it  can  be  handy  to  have  the  tabs
       displayed  as  '^I".  In 'list" mode, elvis does this, and
       also displays a '$" after the end of the line.

    magic
       The  search  mechanism  in  elvis  can   accept   'regular
       expressions'-strings in which certain characters have spe-
       cial meaning.  The magic  option  is  normally  on,  which
       causes  these  characters to be treated specially.  If you
       turn the magic option off (:se noma), then all  characters
       except  ^  and  $  are treated literally.   ^ and $ retain
       their special meanings regardless of the setting of magic.

    paragraphs
       The { and } commands move the cursor forward  or  backward
       in   increments  of  one  paragraph.   Paragraphs  may  be
       separated by blank lines, or by a 'dot' command of a  text
       formatter.   Different text formatters use different 'dot'
       commands.  This option allows you to  configure  elvis  to
       work with your text formatter.

       It is assumed that your formatter uses commands that start
       with a ".' character at the front of a line, and then have
       a one- or two-character command name.

       The value of the paragraphs option is a  string  in  which
       each  pair of characters is one possible form of your text
       formatter's paragraph command.

    readonly
       Normally, elvis will let you write back any file to  which
       you  have write permission.  If you do not have write per-
       mission, then you can only write the  changed  version  of
       the file to a different file.

       If you set the readonly option, then  elvis  will  pretend
       you do not have write permission to any file you edit.  It
       is useful when you really only mean to use elvis  to  look
       at  a  file, not to change it.  This way you cannot change
       it accidentally.

       This option is normally off, unless  you  use  the  'view'
       alias  of  elvis.   'View'  is  like  vi  except  that the
       readonly option is on.

    report
       Commands in elvis may affect  many  lines.   For  commands
       that  affect  a  lot of lines, elvis will output a message
       saying what was done and how  many  lines  were  affected.
       This  option  allows  you  to define what 'a lot of lines'
       means.  The default is 5, so any command which  affects  5
       or more lines will cause a message to be shown.

    scroll
       The CTRL-U and CTRL-D keys  normally  scroll  backward  or
       forward  by half a screenful, but this is adjustable.  The
       value of this option says how many lines those keys should
       scroll by.

    sections
       The [[ and ]] commands move the cursor backward or forward
       in increment of 1 section.  Sections may be delimited by a
       { character in column 1 (which  is  useful  for  C  source
       code) or by means of a text formatter's 'dot' commands.

       This option allows you to configure  elvis  to  work  with
       your  text  formatter's  'section' command, in exactly the
       same way that the paragraphs option makes it work with the
       formatter's 'paragraphs" command.

    shell
       When elvis forks a shell (perhaps for  the  :!  or  :shell
       commands)  this  is  the  program that is uses as a shell.
       This is /bin/sh by default, unless you have set the  SHELL
       environment  variable,  it which case the default value is
       copied from the environment.

    shiftwidth
       The < and > commands shift text left or right by some uni-
       form  number  of  columns.   The shiftwidth option defines
       that uniform number.  The default is 8.

    sidescroll
       For long lines, elvis scrolls  sideways.   (This  is  dif-
       ferent  from  the  real vi, which wraps a single long line
       onto several rows of the screen.)  To minimize the  number
       of  scrolls  needed,  elvis  moves  the screen sideways by
       several characters at a time.  The value  of  this  option
       says  how  many  characters'  widths  to scroll at a time.
       Generally, the faster your  screen  can  be  redrawn,  the
       lower the value you will want in this option.

    sync
       If the system crashes during an edit session, then most of
       your  work  can  be recovered from the temporary file that
       elvis uses to store  changes.   However,  sometimes  MINIX
       will  not  copy  changes  to the hard disk immediately, so
       recovery might not be possible.  The [no]sync option  lets
       you  control this.  In nosync mode (which is the default),
       elvis lets the operating system control when data is writ-
       ten to the disk.  This is generally faster.  In sync mode,
       elvis forces all changes out to disk every time you make a
       change.  This is generally safer, but slower.

    tabstop
       Tab characters are normally 8 characters wide, but you can
       change their widths by means of this option.

    term
       This 'read only' option shows  the  name  of  the  termcap
       entry that elvis is using for your terminal.

    vbell
       If your termcap entry describes a visible  alternative  to
       ringing  your  terminal's  bell, then this option will say
       whether the visible version gets used or not.  Normally it
       will be.
       If your termcap does NOT include a visible  bell  capabil-
       ity,  then  the  vbell  option will be off, and you cannot
       turn it on.

    warn
       Elvis will normally warn you if you run  a  shell  command
       without  saving  your  changed  version  of  a  file.  The
       'nowarn" option prevents this warning.

    wrapmargin
       Normally (with wrapmargin=0) elvis will let  you  type  in
       extremely long lines, if you wish.  However, with wrapmar-
       gin set to something other that 0 (wrapmargin=65 is nice),
       elvis  will automatically cause long lines to be 'wrapped"
       on a word break for lines longer  than  wrapmargin's  set-
       ting.

    wrapscan
       Normally, when you search for something, elvis  will  find
       it no matter where it is in the file.  elvis starts at the
       cursor position, and searches forward.  If elvis hits  EOF
       without  finding  what  you're  looking for, then it wraps
       around to continue searching from line 1.

       If you turn off the wrapscan option (:se nows), then  when
       elvis hits EOF during a search, it will stop and say so.

    Cflags

     Elvis uses many preprocessor symbols to control compilation.
     Most  of  these  flags  allow  you  to disable small sets of
     features.  MINIX-ST users will probably  want  all  features
     enabled,  but MINIX-PC users will have to disable one or two
     feature sets because otherwise elvis would be too  large  to
     compile and run.

     These symbols can be defined via flags passed  to  the  com-
     piler.  The best way to do this is to edit the Makefile, and
     append the flag to the 'CFLAGS=' line.  After you  do  that,
     you must recompile elvis completely by saying
             make  clean
             make
    DM_SYSV
       This flag causes elvis to use System-V ioctl()  calls  for
       controlling  your  terminal; normally it uses v7/BSD/MINIX
       ioctl() calls.

    DDATE
       The symbol DATE should be defined to look  like  a  string
       constant,  giving  the date when elvis was compiled.  This
       date is reported by the ':version' command.

       You can also leave DATE undefined, in  which  case  ':ver-
       sion' will not report the compilation date.

    DCRUNCH
       This flag causes several large  often-used  macros  to  be
       replaced  by equivalent functions.  This saves about 4K of
       space in the '.text' segment, and it does not cost you any
       features.

    DDEBUG
       This  adds  many  internal  consistency  checks  and   the
       ':debug'  and ':validate' commands.  It increases the size
       of 'text' by about 5K bytes.

    DNO_CHARATTR
       This permanenently disables  the  'charattr'  option.   It
       reduces the size of '.text' by about 850 bytes.

    DNO_RECYCLE
       Normally, elvis will recycle space in the  temporary  file
       which  contains  totally  obsolete  text.  The DNO_RECYCLE
       option disables this, making your '.text'  segment smaller
       by about 1K but also permitting the temporary file to grow
       very quickly.  If you have less than two megabytes of free
       space  on  your disk, then do not even consider using this
       flag.

    DNO_SENTENCE
       This leaves out the  '('  and  ')'  visual  commands,  and
       removes  the code that allows the '[[', ']]', '{', and '}'
       commands to recognize nroff macros.   The  '[['  and  ']]'
       commands will still move to the start of the previous/next
       C function source code, though, and '{' and '}' will  move
       to  the  previous/next  blank  line.  This saves about 650
       bytes from the '.text' segment.

    DNO_CHARSEARCH
       This leaves out the visual commands which locate  a  given
       character  in  the  current line: 'f', 't', 'F', 'T', ';',
       and ','.  This saves about 900 bytes.

    DNO_EXTENSIONS
       This leaves out the ':mkexrc' command, and the 'K' and '#'
       visual  commands.  Other extensions are either inherent in
       the design of elvis, or are too tiny to be worth removing.
       This saves about 500 bytes.

    DNO_MAGIC
       This permanently disables the 'magic' option, so that most
       meta-characters  in  a  regular  expression are not recog-
       nized. This saves about 3K bytes from the '.text' segment.

    Termcap Elvis can use standard termcap entries, but  it  also
    recognizes  and  uses several extra capabilities, if you give
    them.  All of these are optional.
      Capability     Description
      :PU=:          sequence received from the <PgUp> key
      :PD=:          sequence received from the <PgDn> key
      :HM=:          sequence received from the <Home> key
      :EN=:          sequence received from the <End> key
      :VB=:          sequence sent to start bold printing
      :Vb=:          sequence sent to end bold printing

   Author

     Elvis was written by Steve Kirkendall.
     He can be reached by email at: kirkenda@cs.pdx.edu
     for comments regarding elvis.