vi man page on Archlinux

Man page or keyword search:  
man Server   11224 pages
apropos Keyword Search (all sections)
Output format
Archlinux logo
[printable version]

VI(1)				 User Commands				 VI(1)

NAME
       vi, view, vedit - screen oriented (visual) display editor based on ex

SYNOPSIS
       vi [-c command|+command] [-r [filename]] [-s|-] [-t tagstring]
	      [-w size] [-lLRV] [file ...]

       view [-c command|+command] [-r [filename]] [-s|-] [-t tagstring]
	      [-w size] [-lLRV] [file ...]

       vedit [-c command|+command] [-r [filename]] [-s|-] [-t tagstring]
	      [-w size] [-lLRV] [file ...]

DESCRIPTION
       Vi (visual) is a display oriented text editor based on ex(1).   Ex  and
       vi  run	the same code; it is possible to get to the command mode of ex
       from within vi and vice-versa.

       The view command is identical to vi except that files are opened	 read-
       only.   The  vedit  command is also identical, but sets some options to
       values more useful for novices.

       The following options are accepted:

       -c command or +command
	      Execute command when editing begins.

       -l     Start in a special mode useful for  the  Lisp  programming  lan‐
	      guage.

       -r [filename] or -L
	      When  no	argument is supplied with this option, all files to be
	      recovered are listed and the editor  exits  immediately.	 If  a
	      filename	is  specified,	the  corresponding  temporary  file is
	      opened in recovery mode.

       -R     Files are opened read-only when this option is given.

       -s or -
	      Script mode; all feedback for interactive editing	 is  disabled.
	      EXINIT and .exrc files are not processed.

       -t tagstring
	      Read  the tags file, then choose the file and position specified
	      by tagstring for editing.

       -V     Echo command input to standard error, unless it originates  from
	      a terminal.

       -w size
	      Specify the size of the editing window for visual mode.

       The  Introduction  to  Display Editing with Vi provides full details on
       using vi.

       Most of the ex commands are available in visual mode when prefixed by a
       : character. See ex(1) for a description of them.

       The  following  gives the uses the editor makes of each character.  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 characters.

       For each character we tell a meaning it has as a command and any	 mean‐
       ing it has during an insert.  If it has only meaning as a command, then
       only this is discussed.	Section numbers in parentheses indicate	 where
       the  character is discussed in “An Introduction to Display Editing with
       Vi”; a `f' after the section number means that the  character  is  men‐
       tioned in a footnote.

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

       ^A     Unused.

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

       ^C     Unused.

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

       ^E     Exposes  one  more  line	below  the current screen in the file,
	      leaving the cursor where it is if possible.

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

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

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

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

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

       ^K     Unused.

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

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

       ^N     Same as down arrow (see j).

       ^O     Unused.

       ^P     Same as up arrow (see k).

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

       ^R     Redraws the current screen, eliminating logical lines not corre‐
	      sponding to physical lines (lines with only a single @ character
	      on them).	 On hardcopy terminals in open mode, retypes the  cur‐
	      rent line (5.4, 7.2, 7.8).

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

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

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

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

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

       ^X     Unused.

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

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

       ^[ (ESC)
	      Cancels a partially formed command, such as a z when no  follow‐
	      ing  character has yet been given; terminates inputs on the last
	      line (read by commands 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.
	      The  user	 can thus hit ESC if he doesn't know what is happening
	      till the editor rings  the  bell.	  If  the  user	 doesn't  know
	      whether he is in insert mode he can type ESCa, and then material
	      to be input; the material will be inserted correctly whether  or
	      not he was in insert mode when he started (1.6, 3.1, 7.5).

       ^\     Unused.

       ^]     Searches	for  the  word	which  is  after  the cursor as a tag.
	      Equivalent to typing :ta, this word, and then  a	CR.   Mnemoni‐
	      cally, this command is “ right to” (7.3).

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

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

       SPACE  Same as right arrow (see l).

       !      An  operator,  which processes lines from the buffer with refor‐
	      matting commands.	 Follow ! with the object to be processed, and
	      then  the command name terminated by CR.	Doubling ! and preced‐
	      ing it by a count causes count lines to be  filtered;  otherwise
	      the count is passed on to the object after the !.	 Thus 2!}fmtCR
	      reformats the next two paragraphs by running  them  through  the
	      program  fmt.   If working on LISP, the command !%grindCR, given
	      at the beginning of a function, will run the text of  the	 func‐
	      tion through the LISP grinder (6.7, 7.3).	 To read a file or the
	      output of a command into the buffer :r (7.3) can	be  used.   To
	      simply  execute  a  command,  :! (7.3).  Precedes a named buffer
	      specification.  There are named  buffers	1-9  used  for	saving
	      deleted text and named buffers a-z into which the user can place
	      text (4.3, 6.3)

       #      The macro character which, when followed by a number, will  sub‐
	      stitute  for  a  function key on terminals without function keys
	      (6.9).  In input mode, if this is the erase character,  it  will
	      delete  the last character typed in input mode, and must be pre‐
	      ceded with a \ to insert it, since it normally  backs  over  the
	      last input character.

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

       %      Moves  to the parenthesis or brace { } which balances the paren‐
	      thesis or brace at the current cursor position.

       &      A synonym for :&CR, by analogy with the ex & command.

       ´      When followed by a ´ returns to  the  previous  context  at  the
	      beginning	 of  a line.  The previous context is set whenever the
	      current line is moved in a non-relative way.  When followed by a
	      letter  a-z, returns to the line which was marked with this let‐
	      ter with a m command, at the first non-white  character  in  the
	      line.  (2.2,  5.3).   When  used with an operator such as d, the
	      operation takes place over complete lines; if  `	is  used,  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 lisp 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 sentences (4.2, 6.8).

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

       *      Unused.

       +      Same as CR when used as a command.

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

       -      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; the user  can  delete  some
	      words/lines  and then hit . to delete more and more words/lines.
	      Given a count, it passes it on to the  command  being  repeated.
	      Thus after a 2dw, 3. deletes three words (3.3, 6.3, 7.2, 7.4).

       /      Reads  a string from the last line on the screen, and scans for‐
	      ward 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  the user hits 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 termi‐
	      nated with a DEL or RUB, or by backspacing when at the beginning
	      of  the  bottom  line, returning the cursor to its initial posi‐
	      tion.  Searches normally wrap end-around to find a  string  any‐
	      where 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  the  user  can force whole lines to be affected.	 To do
	      this a pattern with a closing a closing / and then an offset  +n
	      or -n must be given.

	      To  include  the	character  /  in the search string, it must be
	      escaped 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 section 7.4; unless nomagic  ist  set
	      in the .exrc file the user will have to preceed the characters .
	      [ * and ~ in the search pattern with a \ to get them to work  as
	      one would naively expect (1.6, 2.2, 6.1, 7.2, 7.4).

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

       1-9    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.   The
	      user  can return to where he was by hitting DEL or RUB if he hit
	      : accidentally (see ex(1) and primarily 6.2 and 7.3).

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

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

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

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

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

       @      A macro character (6.9).	If this is the kill character, it must
	      be  escaped with a \ to type it in during input mode, as it nor‐
	      mally backs over the input given on the current line (3.1,  3.4,
	      7.5).

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

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

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

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

       E      Moves  forward  to the end of a word, defined as blanks and non-
	      blanks, like B and W.  A count repeats the effect.

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

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

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

       I      Inserts at the beginning of a line; a synonym for ^i.

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

       K      Unused.

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

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

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

       O      Opens a new line above the current line and inputs text there up
	      to an ESC.  A count can be used on dumb terminals to  specify  a
	      number of lines to be opened; this is generally obsolete, as the
	      slowopen option works better (3.1).

       P      Puts the last deleted text back before/above  the	 cursor.   The
	      text goes back as whole lines above the cursor if it was deleted
	      as whole lines.  Otherwise the  text  is	inserted  between  the
	      characters before and at the cursor.  May be preceded by a named
	      buffer specification "x to retrieve the contents of the  buffer;
	      buffers  1-9 contain deleted material, buffers a-z are available
	      for general use (6.3).

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

       R      Replaces characters on the screen with characters typed (overlay
	      fashion).	 Terminates with an ESC.

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

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

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

       V      Unused.

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

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

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

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

       [[     Backs  up to the previous section boundary.  A section begins at
	      each macro in the sections option, normally a `.NH' or `.SH' and
	      also  at	lines  which  which  start  with a formfeed ^L.	 Lines
	      beginning with { also stop [[; this makes it useful for  looking
	      backwards,  a  function at a time, in C programs.	 If the option
	      lisp 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  definition	 (4.2,
	      6.1, 6.6, 7.2).

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

       _      Unused.

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

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

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

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

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

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

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

       g      Unused.

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

       h      Left arrow .  Moves the cursor one character to the left.	  Like
	      the  other  arrow	 keys, either h, the left arrow key, or one of
	      the synonyms (^H) has the same  effect.	A  count  repeats  the
	      effect (3.1, 7.5).

       i      Inserts text before the cursor, otherwise like a (7.2).

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

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

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

       m      Marks the current position of the cursor in  the	mark  register
	      which  is	 specified  by	the  next character a-z.  The user can
	      return to this position or use it with an operator using ` or  ´
	      (5.3).

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

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

       p      Puts text after/below the cursor; otherwise like P (6.3).

       q      Unused.

       r      Replaces	the single character at the cursor with a single char‐
	      acter typed.  The new character may be a	RETURN;	 this  is  the
	      easiest  way  to split lines.  A count replaces each of the fol‐
	      lowing count characters with the single character given;	see  R
	      above which is the more usually useful iteration of r (3.2).

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

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

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

       v      Unused.

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

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

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

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

       {      Retreats	to  the	 beginning  of	the beginning of the preceding
	      paragraph.  A paragraph begins at each macro in  the  paragraphs
	      option,  normally `.IP', `.LP', `.PP', `.QP' and `.bp'.  A para‐
	      graph 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).

       ~      Switches the case of the given count of characters starting from
	      the current cursor position to the  end  of  the	current	 line.
	      Non-alphabetic characters remain unchanged.

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

ENVIRONMENT VARIABLES
       The following environment variables affect the behaviour of vi:

       COLUMNS
	      Overrides the system-supplied number of terminal columns.

       EXINIT Contains commands to execute at editor startup.  If  this	 vari‐
	      able  is present, the .exrc file in the user's home directory is
	      ignored.

       HOME   Used to locate the editor startup file.

       LANG, LC_ALL
	      See locale(7).

       LC_CTYPE
	      Determines the mapping of bytes to characters, types of  charac‐
	      ters,  case  conversion  and composition of character classes in
	      regular expressions.

       LC_MESSAGES
	      Sets the language used for diagnostic and informal messages.

       LINES  Overrides the system-supplied number of terminal lines.

       NLSPATH
	      See catopen(3).

       SHELL  The program file used to execute external commands.

       TERM   Determines the terminal type.

FILES
       /usr/lib/ex/expreserve
	      preserve command

       /usr/lib/ex/exrecover
	      recover command

       /etc/termcap
	      describes capabilities of terminals

       $HOME/.exrc
	      editor startup file

       /var/tmp/Exnnnnnnnnnn
	      editor temporary

       /var/tmp/Rxnnnnnnnnnn
	      named buffer temporary

       /var/lib/ex
	      preservation directory

SEE ALSO
       ex(1), edit(1), “Vi Quick Reference” card, “An Introduction to  Display
       Editing with Vi”.

AUTHOR
       William Joy.

       Mark Horton added macros to visual mode and was maintaining version 3.

       This version incorporates changes by Gunnar Ritter.

NOTES
       Software tabs using ^T work only immediately after the autoindent.

       Left and right shifts on intelligent terminals don't make use of insert
       and delete character operations in the terminal.

       The wrapmargin option can be fooled since it looks  at  output  columns
       when  blanks  are  typed.  If a long word passes through the margin and
       onto the next line without a break, then the line won't be broken.

       Insert/delete within a line can be slow if tabs are present on intelli‐
       gent terminals, since the terminals need help in doing this correctly.

       The  source command does not work when executed as :source; there is no
       way to use the :append, :change, and :insert commands, since it is  not
       possible	 to  give  more	 than one line of input to a : escape.	To use
       these on a :global one must Q to ex command  mode,  execute  them,  and
       then reenter the screen editor with vi or open.

Ancient Unix Ports		    3/12/03				 VI(1)
[top]

List of man pages available for Archlinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net