Linux and UNIX Man Pages

Linux & Unix Commands - Search Man Pages

elvis(9) [minix man page]

Elvis  is  a  full-screen  editor  closely  modeled on the famous
Berkeley vi editor.  It provides essentially the  same	interface
to  the  user as vi, but the code is completely new, written from
scratch.  This document provides a brief introduction to vi.   It
is not intended as a tutorial for beginners.  Most books on 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.  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
		 (  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
  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 lineMOVE
	  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 bottom 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 middle)
	  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 characterMOVE
	  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 characterEDIT
count	  s inp     Replace count chars with text from the userEDIT
count	  t key     Move rightward almost to a given characterMOVE
	  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)
Below is a list of the ex commands supported.  All can be  abbre-
[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]
[line][,line]		global/regexp/ command
[line]	    Insert
[line][,line]		join
[line][,line]		list
	    map[!]	key mapped_to
[line]	    mark	x
[line][,line]		Moveline
	    next[!]	[files]
[line][,line]		print
[line]	    put 	[x]
[line]	    read	file
	    set 	[options]
[line][,line]		substitute/regexp/replacement/[p][g]
	    tag[!]	tagname
[line][,line]		toline
	    unmap[!]	key
[line][,line]		vglobal/regexp/ command
[line][,line]		write[!][[>>]file]
[line][,line]		yank[x]
[line][,line]		!command
[line][,line]		<
[line][,line]		=
[line][,line]		>
[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 con-
tains only a period.
[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 speci-
fied 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 destina-
tion line comes after the deleted text, then it will be  adjusted
automatically to account for the deleted lines.
[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.
[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 expression.	It then moves the
cursor	to  each  of  these  lines and runs some other command on

The (v)global command is similar, but it searches for lines  that
do not contain the regular expression.
[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  speci-
fied, 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  re-
placed	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

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

The  (u)ndo  command restores the file to the state it was in be-
fore your most recent command which changed text.
	    map[!] [key mapped_to]
	    unmap[!] key
	    set [options]
[line]	    mark x
[line][,line]		=

The (ma)p command allows you to configure elvis to recognize your
function  keys,  and  treat  them as though they transmitted some
other sequence of characters.  Normally this mapping 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  se-
quence 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 val-
ues of all options, regardless of whether they've been explicitly
set  or  not.  Otherwise, the arguments 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

The = command tells you what line you specified, or, if you spec-
ified 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.
	    args [files]
	    next[!] [files]

When  you  invoke elvis from your shell's command line, any file-
names 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

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

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.

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

The (wq) and (x)it commands (really two names for the  same  com-
mand) both write the file before exiting.
[line]	    read file
[line][,line]		write[!][[>>]file]

The (r)ead command gets text from another file and inserts it af-
ter 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.
	    cd [directory]
	    chdir [directory]

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

The (sh)ell command starts an interactive shell.
[line][,line]		debug[!]

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 con-
sistency.  Normally it does not output anything unless it detects
a  problem.   With  the  !, though, it will always produce *some*
  In addition to the standard commands, a variety of  extra  fea-
  tures  are  present  in elvis that are not present in vi.  They
  are described below.

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.

This EX command saves the current :set and :map configurations in
  the .exrc file in your current directory.

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

These commands move backwards through the args list.

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  supply  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  command,  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
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  com-
  mand	alone is worth the price of admission!	See the ctags and
  ref programs.

You can backspace back past the beginning of the  line.   If  you
  type	CTRL-A, then the text that you input last time is insert-
  ed.  You will remain in input mode, so you can  backspace  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.

  Elvis can display backslash-f style character attributes on the
  screen as you edit.  The following example shows the recognized

	    normal boldface italics

  NOTE:  you must compile elvis without the -DSET_NOCHARATTR flag
  for this to work.
A few vi features are missing.	The replace mode is a  hack.   It
does  not  save the text that it overwrites.  Long lines are dis-
played differently--where the real vi would wrap a long line onto
several  rows  of  the	screen, elvis simply 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 implement 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.  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?

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

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 normally 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  successfully
  switch to the new file.

Many  text formatting programs allow you to designate portions of
  your text to be underlined, italicized, or boldface  by  embed-
  ding	the  special strings fU, fI, and fB in your text.  The
  special string fR marks the	end  of  underlined  or  boldface

  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 under-
  lined or boldface text on the screen.   (This  only  works,  of
  course,  if  your terminal can display underlined and boldface,
  and if the TERMCAP entry says how to do it.)

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.

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.

Normally, elvis will ring your terminal's bell if you make an er-
  ror.	 However, in noerrorbells mode, your terminal will remain

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

Normally, when elvis searches for text, it treats uppercase  let-
  ters as being different for lowercase letters.

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

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 max-
  imum	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 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 generally 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.

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 information about it.

  This option says which program gets run.  It should contain the
  full	pathname of the program; your whole execution path is not

  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  cre-
  ated by ctags.

  You  can  substitute other programs, such as an English dictio-
  nary program or the online manual.  elvis runs the program, us-
  ing 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 >>>".

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

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

  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.

The search mechanism in elvis can  accept  regular  expressions--
  strings  in which certain characters have special 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  literal-
  ly.	 ^  and $ retain their special meanings regardless of the
  setting of magic.

The { and } commands move the cursor forward or backward  in  in-
  crements  of	one  paragraph.   Paragraphs  may be separated by
  blank lines, or by a dot command of a text formatter.   Differ-
  ent  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 format-
  ter's paragraph command.

Normally, elvis will let you write back any  file  to  which  you
  have	write  permission.   If you do not have write permission,
  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.

Commands  in  elvis may affect many lines.  For commands that af-
  fect 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.

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.

The [[ and ]] commands move the cursor backward or forward in in-
  crement of 1 section.  Sections may be delimited by a { charac-
  ter 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 para-
  graphs" command.

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.

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

For  long lines, elvis scrolls sideways.  (This is different 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 op-

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

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

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

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  capability,
  then the vbell option will be off, and you cannot turn it on.

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

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

Normally,  when  you  search for something, elvis will find it no
  matter where it is in the file.  elvis starts at the cursor po-
  sition,  and searches forward.  If elvis hits EOF without find-
  ing 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.
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 be-
cause otherwise elvis would be too large to compile and run.

These symbols can be defined via flags passed  to  the	compiler.
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
This flag causes elvis to use System-V ioctl() calls for control-
  ling your  terminal;	normally  it  uses  v7/BSD/MINIX  ioctl()

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 :version will
  not report the compilation date.

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.

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

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

Normally,  elvis  will	recycle space in the temporary file which
  contains totally obsolete text.  The -DNO_RECYCLE  option  dis-
  ables  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.

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.

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

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

This permanently disables the magic option, so	that  most  meta-
  characters  in  a  regular expression are not recognized.  This
  saves about 3K bytes from the .text segment.
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
Elvis was written by Steve Kirkendall.
He can be reached by email at:
for comments regarding elvis.
Man Page