edit man page on Archlinux

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

EX(1)				 User Commands				 EX(1)

       ex, edit - text editor

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

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

       Ex is the root of a family of editors: edit, ex and vi.	Ex is a super‐
       set of ed, with the most notable	 extension  being  a  display  editing
       facility.  Display based editing on CRT terminals is the focus of vi.

       For  those  who	have not used ed, or for casual users, the editor edit
       may be convenient.  It avoids some  of  the  complexities  of  ex  used
       mostly by systems programmers and persons very familiar with ed.

       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‐

       -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     Start in visual mode even if called as ex.

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

   File manipulation
       Ex is normally editing the contents of a single	file,  whose  name  is
       recorded	 in the current file name.  Ex performs all editing actions in
       a buffer (actually a temporary file) into which the text of the file is
       initially  read.	 Changes made to the buffer have no effect on the file
       being edited unless and until the buffer contents are  written  out  to
       the  file with a write command.	After the buffer contents are written,
       the previous contents of the written file  are  no  longer  accessible.
       When  a file is edited, its name becomes the current file name, and its
       contents are read into the buffer.

       The current file is almost always considered to be edited.  This	 means
       that  the  contents of the buffer are logically connected with the cur‐
       rent file name, so that writing the current buffer contents  onto  that
       file,  even  if it exists, is a reasonable action.  If the current file
       is not edited then ex will not normally	write  on  it  if  it  already

       For  saving  blocks  of text while editing, and especially when editing
       more than one file, ex has a group of named buffers.  These are similar
       to  the	normal buffer, except that only a limited number of operations
       are available on them.  The buffers have names a through z.

   Exceptional Conditions
       When errors occur ex (optionally) rings the terminal bell and,  in  any
       case, prints an error diagnostic.  If the primary input is from a file,
       editor processing will terminate.  If an interrupt signal is  received,
       ex prints “Interrupt” and returns to its command level.	If the primary
       input is a file, then ex will exit when this occurs.

       If a hangup signal is received and the buffer has been  modified	 since
       it  was	last  written out, or if the system crashes, either the editor
       (in the first case) or the system (after it reboots in the second) will
       attempt	to  preserve  the  buffer.   The next time the user logs in he
       should be able to recover the work he was doing, losing at most	a  few
       lines of changes from the last point before the hangup or editor crash.
       To recover a file one can use the -r option.  If one  was  editing  the
       file  resume, then he should change to the directory where he were when
       the crash occurred, giving the command

	      ex -r resume

       After checking that the retrieved file is indeed ok, he	can  write  it
       over the previous contents of that file.

       The user will normally get mail from the system telling him when a file
       has been saved after a crash.  The command

	      ex -r

       will print a list of the files which have been saved for the user.

   Editing modes
       Ex has five distinct modes.  The primary mode is	 command  mode.	  Com‐
       mands are entered in command mode when a `:' prompt is present, and are
       executed each time a complete line is sent.   In	 text  input  mode  ex
       gathers	input  lines and places them in the file.  The append, insert,
       and change commands use text input mode.	 No prompt is printed when  in
       text input mode.	 This mode is left by typing a `.' alone at the begin‐
       ning of a line, and command mode resumes.

       The last three modes are open and visual modes, entered by the commands
       of  the	same  name,  and,  within open and visual modes text insertion
       mode.  Open and visual modes allow local editing operations to be  per‐
       formed  on the text in the file.	 The open command displays one line at
       a time on any terminal while visual works on CRT terminals with	random
       positioning  cursors,  using  the  screen as a (single) window for file
       editing changes.	 These modes are described (only) in  An  Introduction
       to Display Editing with Vi.

   Command structure
       Most command names are English words, and initial prefixes of the words
       are  acceptable	abbreviations.	 The  ambiguity	 of  abbreviations  is
       resolved in favor of the more commonly used commands.

       Most  commands accept prefix addresses specifying the lines in the file
       upon which they are to have effect.  The forms of these addresses  will
       be  discussed  below.   A  number  of commands also may take a trailing
       count specifying the number of lines to be  involved  in	 the  command.
       Thus  the  command  “10p” will print the tenth line in the buffer while
       “delete 5” will delete five lines from the buffer,  starting  with  the
       current line.

       Some  commands  take  other information or parameters, this information
       always being given after the command name.

       A number of commands have two distinct variants.	 The variant  form  of
       the  command is invoked by placing an `!' immediately after the command
       name.  Some of the default variants may be controlled  by  options;  in
       this case, the `!' serves to toggle the default.

       The  characters	`#',  `p' and `l' may be placed after many commands (A
       `p' or `l' must be preceded by a blank or tab except in the single spe‐
       cial  case `dp').  In this case, the command abbreviated by these char‐
       acters is executed after the  command  completes.   Since  ex  normally
       prints the new current line after each change, `p' is rarely necessary.
       Any number of `+' or `-' characters may also be given with these flags.
       If  they	 appear,  the  specified offset is applied to the current line
       value before the printing command is executed.

       It is possible to give editor commands which are ignored.  This is use‐
       ful  when making complex editor scripts for which comments are desired.
       The comment character is the double quote: ".  Any command line	begin‐
       ning  with  " is ignored.  Comments beginning with " may also be placed
       at the ends of commands, except in cases where they could  be  confused
       as part of text (shell escapes and the substitute and map commands).

       More  than  one command may be placed on a line by separating each pair
       of commands by a `|' character.	However the global commands, comments,
       and  the	 shell escape `!'  must be the last command on a line, as they
       are not terminated by a `|'.

   Command addressing
       .		   The current line.  Most commands leave the  current
			   line	 as  the  last	line  which  they affect.  The
			   default address for most commands  is  the  current
			   line, thus `.' is rarely used alone as an address.

       n		   The	nth  line  in the editor's buffer, lines being
			   numbered sequentially from 1.

       $		   The last line in the buffer.

       %		   An abbreviation for “1,$”, the entire buffer.

       +n -n		   An offset relative to the current buffer line.  The
			   forms  `.+3'	 `+3' and `+++' are all equivalent; if
			   the current line is line 100 they all address  line

       /pat/ ?pat?	   Scan	 forward  and backward respectively for a line
			   containing pat, a regular  expression  (as  defined
			   below).   The scans normally wrap around the end of
			   the buffer.	If all that is desired is to print the
			   next	 line containing pat, then the trailing / or ?
			   may be omitted.  If pat is  omitted	or  explicitly
			   empty,  then	 the last regular expression specified
			   is located.	The forms \/ and  \?  scan  using  the
			   last	 regular  expression  used  in a scan; after a
			   substitute // and ?? would scan using  the  substi‐
			   tute's regular expression.

       ´´ ´x		   Before each non-relative motion of the current line
			   `.', the previous current line  is  marked  with  a
			   tag,	 subsequently referred to as `´´'.  This makes
			   it easy to refer or return to  this	previous  con‐
			   text.   Marks  may  also be established by the mark
			   command, using single lower case letters x and  the
			   marked lines referred to as `´x'.

       Addresses  to  commands	consist	 of a series of addressing primitives,
       separated by `,' or `;'.	 Such address  lists  are  evaluated  left-to-
       right.	When  addresses	 are separated by `;' the current line `.'  is
       set to the value of the previous addressing expression before the  next
       address	is  interpreted.  If more addresses are given than the command
       requires, then all but the last one or two are ignored.	If the command
       takes  two  addresses, the first addressed line must precede the second
       in the buffer.

       Null address specifications are permitted in a list of  addresses,  the
       default in this case is the current line `.'; thus `,100' is equivalent
       to `.,100'.  It is an error to give a prefix address to a command which
       expects none.

   Command descriptions
       The following form is a prototype for all ex commands:

	      address command ! parameters count flags

       All  parts are optional; the degenerate case is the empty command which
       prints the next line in the file.  For sanity with use from within vis‐
       ual mode, ex ignores a “:” preceding any command.

       In  the following command descriptions, the default addresses are shown
       in parentheses, which are not, however, part of the command.

       abbreviate word rhs abbr: ab
	      Add the named abbreviation to the current list.  When  in	 input
	      mode  in visual, if word is typed as a complete word, it will be
	      changed to rhs .

       ( . ) append   abbr: a
	      Reads the input text and places it  after	 the  specified	 line.
	      After  the  command,  `.'	  addresses the last line input or the
	      specified line if no lines were input.  If address `0' is given,
	      text is placed at the beginning of the buffer.

	      The  variant  flag to append toggles the setting for the autoin‐
	      dent option during the input of text.

       args   The members of the argument list are printed, with  the  current
	      argument delimited by `[' and `]'.

       cd directory
	      The cd command is a synonym for chdir.

       ( . , . ) change count	abbr: c
	      Replaces	the  specified lines with the input text.  The current
	      line becomes the last line input; if no lines were input	it  is
	      left as for a delete.

	      The variant toggles autoindent during the change.

       chdir directory
	      The  specified  directory	 becomes the current directory.	 If no
	      directory is specified, the current value of the home option  is
	      used as the target directory.  After a chdir the current file is
	      not considered to have been edited so that write restrictions on
	      pre-existing files apply.

       ( . , . )copy addr flags abbr: co
	      A copy of the specified lines is placed after addr, which may be
	      `0'.  The current line `.'  addresses the last line of the copy.
	      The command t is a synonym for copy.

       ( . , . )delete buffer count flags abbr: d
	      Removes the specified lines from the buffer.  The line after the
	      last line deleted becomes the current line; if the lines deleted
	      were  originally	at the end, the new last line becomes the cur‐
	      rent line.  If a named buffer is specified by giving  a  letter,
	      then  the	 specified lines are saved in that buffer, or appended
	      to it if an upper case letter is used.

       edit file abbr: e
       ex file
	      Used to begin an editing session on  a  new  file.   The	editor
	      first  checks  to	 see if the buffer has been modified since the
	      last write command was issued.  If it has	 been,	a  warning  is
	      issued  and  the	command	 is  aborted.	The  command otherwise
	      deletes the entire contents of  the  editor  buffer,  makes  the
	      named  file the current file and prints the new filename.	 After
	      insuring that this file is sensible (i.e.,  that	it  is	not  a
	      binary  file  such  as a directory, a block or character special
	      file other than /dev/tty, a terminal, or a binary or  executable
	      file), the editor reads the file into its buffer.

	      If  the  read of the file completes without error, the number of
	      lines and characters read is typed.  Any null characters in  the
	      file  are discarded.  If none of these errors occurred, the file
	      is considered edited.  If the last line of  the  input  file  is
	      missing  the trailing newline character, it will be supplied and
	      a complaint will be issued.  This	 command  leaves  the  current
	      line `.' at the last line read.  If executed from within open or
	      visual, the current line is initially  the  first	 line  of  the

       e! file
	      The  variant  form  suppresses the complaint about modifications
	      having been made and not written from the	 editor	 buffer,  thus
	      discarding  all  changes which have been made before editing the
	      new file.

       e +n file
	      Causes the editor to begin at line n rather  than	 at  the  last
	      line;  n	may  also  be  an editor command containing no spaces,
	      e.g.: “+/pat”.

       file abbr: f
	      Prints the current file name, whether it has  been  `[Modified]'
	      since the last write command, whether it is read only , the cur‐
	      rent line, the number of lines in the buffer, and the percentage
	      of  the way through the buffer of the current line.  In the rare
	      case that the current file is `[Not edited]' this is noted also;
	      in  this	case  one has to use the form w! to write to the file,
	      since the editor is not sure that a write	 will  not  destroy  a
	      file unrelated to the current contents of the buffer.

       file file
	      The  current  file  name	is changed to file which is considered
	      `[Not edited]'.

       ( 1 , $ ) global /pat/ cmds   abbr: g
	      First marks each line among those specified  which  matches  the
	      given  regular  expression.  Then the given command list is exe‐
	      cuted with `.' initially set to each marked line.

	      The command list consists of the remaining commands on the  cur‐
	      rent input line and may continue to multiple lines by ending all
	      but the last such line with a `\'.  If cmds  (and	 possibly  the
	      trailing	/  delimiter)  is  omitted,  each line matching pat is
	      printed.	Append, insert, and  change  commands  and  associated
	      input are permitted; the `.' terminating input may be omitted if
	      it would be on the last line of the command list.	 Open and vis‐
	      ual  commands  are  permitted in the command list and take input
	      from the terminal.

	      The global command itself may not appear in cmds.	 The undo com‐
	      mand is also not permitted there, as undo instead can be used to
	      reverse the entire global command.  The  options	autoprint  and
	      autoindent  are  inhibited  during  a  global, (and possibly the
	      trailing / delimiter) and the value of the report option is tem‐
	      porarily	infinite,  in  deference  to  a	 report for the entire
	      global.  Finally, the context mark `´´' is set to the  value  of
	      `.' before the global command begins and is not changed during a
	      global command, except perhaps by an open or visual  within  the

       g! /pat/ cmds  abbr: v
	      The  variant  form of global runs cmds at each line not matching

       ( . )insert    abbr: i
	      Places the given text before the specified  line.	  The  current
	      line is left at the last line input; if there were none input it
	      is left at the line before the  addressed	 line.	 This  command
	      differs from append only in the placement of text.

	      The variant toggles autoindent during the insert.

       ( . , .+1 ) join count flags  abbr: j
	      Places  the text from a specified range of lines together on one
	      line.  White space is adjusted at each junction  to  provide  at
	      least  one blank character, two if there was a `.' at the end of
	      the line, or none if the first following character is a `)'.  If
	      there  is	 already  white space at the end of the line, then the
	      white space at the start of the next line will be discarded.

       j!     The variant causes a simpler join with no white  space  process‐
	      ing; the characters in the lines are simply concatenated.

       ( . ) k x
	      The  k  command  is  a  synonym for mark.	 It does not require a
	      blank or tab before the following letter.

       ( . , . ) list count flags
	      Prints the specified lines in a more unambiguous way:  tabs  are
	      printed as `^I' and the end of each line is marked with a trail‐
	      ing `$'.	The current line is left at the last line printed.

       map[!] lhs rhs
	      The map command is used to define macros for use in visual  com‐
	      mand  mode.   Lhs	 should be a single character, or the sequence
	      “#n”, for n a digit, referring to function  key  n.   When  this
	      character or function key is typed in visual mode, it will be as
	      though the corresponding rhs had been typed.  On terminals with‐
	      out function keys, the user can type “#n”.  If the `!' character
	      follows the command name, the mapping is	interpreted  in	 input
	      mode.   See  section 6.9 of the “Introduction to Display Editing
	      with Vi” for more details.

       ( . ) mark x
	      Gives the specified line mark x, a  single  lower	 case  letter.
	      The x must be preceded by a blank or a tab.  The addressing form
	      `´x' then addresses this line.  The current line is not affected
	      by this command.

       ( . , . ) move addr abbr: m
	      The  move	 command  repositions  the specified lines to be after
	      addr .  The first of the moved lines becomes the current line.

       next abbr: n
	      The next file from the command line argument list is edited.

       n!     The variant suppresses warnings about the modifications  to  the
	      buffer  not  having been written out, discarding (irretrievably)
	      any changes which may have been made.

       n filelist
       n +command filelist
	      The specified  filelist  is  expanded  and  the  resulting  list
	      replaces	the  current  argument list; the first file in the new
	      list is then edited.  If command is given (it  must  contain  no
	      spaces), then it is executed after editing the first such file.

       ( . , . ) number count flags  abbr: # or nu
	      Prints  each  specified line preceded by its buffer line number.
	      The current line is left at the last line printed.

       ( . ) open flags	   abbr: o
       ( . ) open /pat/ flags
	      Enters intraline editing open mode at each addressed  line.   If
	      pat  is  given,  then the cursor will be placed initially at the
	      beginning of the string matched by the pattern.	To  exit  this
	      mode  use Q.  See An Introduction to Display Editing with Vi for
	      more details.

	      The current editor buffer is saved as though the system had just
	      crashed.	 This  command	is  for use only in emergencies when a
	      write command has resulted in an error.

       ( . , . )print count	abbr: p or P
	      Prints the specified lines with non-printing characters  printed
	      as control characters `^x'; delete (octal 177) is represented as
	      `^?'.  The current line is left at the last line printed.

       ( . )put buffer	   abbr: pu
	      Puts back previously deleted or  yanked  lines.	Normally  used
	      with  delete to effect movement of lines, or with yank to effect
	      duplication of lines.  If no buffer is specified, then the  last
	      deleted  or  yanked text is restored.  But no modifying commands
	      may intervene between the delete or yank and the	put,  nor  may
	      lines  be	 moved between files without using a named buffer.  By
	      using a named buffer, text may be restored that was saved	 there
	      at any previous time.

       quit abbr: q
	      Causes ex to terminate.  No automatic write of the editor buffer
	      to a file is performed.  However, ex issues a warning message if
	      the  file	 has  changed since the last write command was issued,
	      and does not quit.  Ex will also issue a diagnostic if there are
	      more  files  in the argument list.  Normally, the user will wish
	      to save his changes, and he should give a write command;	if  he
	      wishes to discard them, he should the q! command variant.

       q!     Quits  from the editor, discarding changes to the buffer without

       ( . ) read file	   abbr: r
	      Places a copy of the text of the given file in the editing  buf‐
	      fer  after  the specified line.  If no file is given the current
	      file name is used.  The current file name is not changed	unless
	      there  is none in which case file becomes the current name.  The
	      sensibility restrictions for the edit command apply  here	 also.
	      If the file buffer is empty and there is no current name then ex
	      treats this as an edit command.

	      Address `0' is legal for this command and causes the file to  be
	      read  at	the  beginning of the buffer.  Statistics are given as
	      for the edit command  when  the  read  successfully  terminates.
	      After  a	read  the  current line is the last line read.	Within
	      open and visual the current line is set to the first  line  read
	      rather than the last.

       ( . ) read  !command
	      Reads  the  output  of the command command into the buffer after
	      the specified line.  This is not a variant form of the  command,
	      rather  a	 read  specifying  a command rather than a filename; a
	      blank or tab before the ! is mandatory.

       recover file
	      Recovers file from the system save area.	Used after a  acciden‐
	      tal  hangup  of the phone or a system crash or preserve command.
	      Except when preserve is used, the user will be notified by  mail
	      when a file is saved.

       rewind	 abbr: rew
	      The  argument list is rewound, and the first file in the list is

       rew!   Rewinds the argument list discarding any	changes	 made  to  the
	      current buffer.

       set parameter
	      With  no	arguments, prints those options whose values have been
	      changed from their defaults; with parameter all it prints all of
	      the option values.

	      Giving  an  option  name	followed  by a `?'  causes the current
	      value of that option to be  printed.   The  `?'  is  unnecessary
	      unless  the option is Boolean valued.  Boolean options are given
	      values either by the form `set option' to turn them on  or  `set
	      nooption'	 to  turn  them	 off;  string  and numeric options are
	      assigned via the form `set option=value'.

	      More than one parameter may be given to set ;  they  are	inter‐
	      preted left-to-right.

	      A list of options can be found below.

       shell	 abbr: sh
	      A new shell is created.  When it terminates, editing resumes.

       source file    abbr: so
	      Reads  and  executes  commands  from the specified file.	Source
	      commands may be nested.

       ( . , . ) substitute /pat/repl/ options count flags
	      abbr: s
	      On each specified line, the first instance  of  pattern  pat  is
	      replaced	by  replacement pattern repl.  If the global indicator
	      option character `g' appears, then  all  instances  are  substi‐
	      tuted;  if  the  confirm	indication character `c' appears, then
	      before each substitution the line to  be	substituted  is	 typed
	      with  the	 string	 to be substituted marked with `^' characters.
	      By typing an `y' one can cause the substitution to be performed,
	      any other input causes no change to take place.  After a substi‐
	      tute the current line is the last line substituted.

	      Lines may be split  by  substituting  new-line  characters  into
	      them.   The newline in repl must be escaped by preceding it with
	      a `\'.  Other metacharacters  available  in  pat	and  repl  are
	      described below.

       stop   Suspends	the  editor, returning control to the top level shell.
	      If autowrite is set and there are unsaved changes,  a  write  is
	      done  first  unless  the form stop !  is used.  This commands is
	      only available where supported by the teletype driver, shell and
	      operating system.

       ( . , . ) substitute options count flags	    abbr: s
	      If  pat  and  repl  are  omitted,	 then the last substitution is
	      repeated.	 This is a synonym for the & command.

       ( . , . ) t addr flags
	      The t command is a synonym for copy .

       ta tag The focus of editing switches to the location of tag,  switching
	      to  a different line in the current file where it is defined, or
	      if necessary to another file.

	      The tags file is normally created by a program  such  as	ctags,
	      and consists of a number of lines with three fields separated by
	      blanks or tabs.  The first field gives the name of the tag,  the
	      second the name of the file where the tag resides, and the third
	      gives an addressing form which can be used by the editor to find
	      the  tag;	 this field is usually a contextual scan using `/pat/'
	      to be immune to minor changes  in	 the  file.   Such  scans  are
	      always performed as if nomagic was set.

	      The tag names in the tags file must be sorted alphabetically.

       unabbreviate word   abbr: una
	      Delete word from the list of abbreviations.

       undo abbr: u
	      Reverses the changes made in the buffer by the last buffer edit‐
	      ing command.  Note that global commands are considered a	single
	      command for the purpose of undo (as are open and visual.)	 Also,
	      the commands write and edit which interact with the file	system
	      cannot be undone.	 Undo is its own inverse.

	      Undo always marks the previous value of the current line `.'  as
	      `´´'.  After an undo the current line is the first line restored
	      or  the  line  before  the  first	 line deleted if no lines were
	      restored.	 For commands with more global effect such  as	global
	      and visual the current line regains it's pre-command value after
	      an undo.

       unmap[!] lhs
	      The macro expansion associated by map for lhs is removed.

       ( 1 , $ ) v /pat/ cmds
	      A synonym for the global command variant g!, running the	speci‐
	      fied cmds on each line which does not match pat.

       version	 abbr: ve
	      Prints  the  current version number of the editor as well as the
	      date the editor was last changed.

       ( . ) visual type count flags abbr: vi
	      Enters visual mode at the specified line.	 Type is optional  and
	      may  be  `-'  ,  `^'  or `.'  as in the z command to specify the
	      placement of the specified line on the screen.  By  default,  if
	      type  is	omitted,  the specified line is placed as the first on
	      the screen.  A count  specifies  an  initial  window  size;  the
	      default  is the value of the option window.  See the document An
	      Introduction to Display Editing with Vi for  more	 details.   To
	      exit this mode, type Q.

       visual file
       visual +n file
	      From visual mode, this command is the same as edit.

       ( 1 , $ ) write file	abbr: w
	      Writes  changes  made back to file, printing the number of lines
	      and characters written.  Normally file is omitted and  the  text
	      goes back where it came from.  If a file is specified, then text
	      will be written to that file.  If the file does not exist it  is
	      created.	 The  current file name is changed only if there is no
	      current file name; the current line is never changed.

	      If an error occurs while writing the current  and	 edited	 file,
	      the  editor  considers  that there has been “No write since last
	      change” even if the buffer had not previously been modified.

       ( 1 , $ ) write>> file	abbr: w>>
	      Writes the buffer contents at the end of an existing file.

       w! name
	      Overrides the checking of the normal  write  command,  and  will
	      write to any file which the system permits.

       ( 1 , $ ) w  !command
	      Writes  the  specified  lines into command.  Note the difference
	      between w! which overrides checks and w  !  which	 writes	 to  a

       wq name
	      Like a write and then a quit command.

       wq! name
	      The  variant  overrides checking on the sensibility of the write
	      command, as w! does.

       xit name
	      If any changes have been made  and  not  written	to  any	 file,
	      writes the buffer out.  Then, in any case, quits.

       ( . , . )yank buffer count    abbr: ya
	      Places  the  specified  lines  in	 the  named  buffer, for later
	      retrieval via put.  If no buffer name is specified, the lines go
	      to a more volatile place; see the put command description.

       ( .+1 ) z count
	      Print the next count lines, default window.

       ( . ) z type count
	      Prints  a window of text with the specified line at the top.  If
	      type is `-' the line is placed at the bottom; a `.'  causes  the
	      line  to	be  placed in the center.  A count gives the number of
	      lines to be displayed rather than double the number specified by
	      the  scroll  option.  On a CRT the screen is cleared before dis‐
	      play begins unless a count which is less than the screen size is
	      given.   The  current  line  is  left  at the last line printed.
	      Forms `z=' and `z^' also exist; `z=' places the current line  in
	      the center, surrounds it with lines of `-' characters and leaves
	      the current line at this line.  The form `z^' prints the	window
	      before  `z-'  would.   The  characters  `+',  `^' and `-' may be
	      repeated for cumulative effect.

       ! command
	      The remainder of the line after the `!' character is sent	 to  a
	      shell to be executed.  Within the text of command the characters
	      `%' and `#' are expanded as in filenames and the	character  `!'
	      is  replaced  with  the  text of the previous command.  Thus, in
	      particular, `!!' repeats the last such  shell  escape.   If  any
	      such  expansion  is performed, the expanded line will be echoed.
	      The current line is unchanged by this command.

	      If there has been “[No write]” of the buffer contents since  the
	      last  change  to	the  editing buffer, then a diagnostic will be
	      printed before the command is executed as a warning.   A	single
	      `!' is printed when the command completes.

       ( addr , addr ) ! command
	      Takes  the  specified  address range and supplies it as standard
	      input to command; the resulting output then replaces  the	 input

       ( $ ) =
	      Prints  the line number of the addressed line.  The current line
	      is unchanged.

       ( . , . ) > count flags
       ( . , . ) < count flags
	      Perform intelligent shifting on the specified  lines;  <	shifts
	      left  and > shift right.	The quantity of shift is determined by
	      the shiftwidth option and the repetition	of  the	 specification
	      character.   Only	 white	space (blanks and tabs) is shifted; no
	      non-white characters are discarded in a left-shift.  The current
	      line becomes the last line which changed due to the shifting.

       ^D     An  end-of-file  from a terminal input scrolls through the file.
	      The scroll option specifies the size of the scroll,  normally  a
	      half screen of text.

       ( .+1 , .+1 )
       ( .+1 , .+1 ) |
	      An  address  alone  causes the addressed lines to be printed.  A
	      blank line prints the next line in the file.

       ( . , . ) & options count flags
	      Repeats the previous substitute command.

       ( . , . ) ~ options count flags
	      Replaces the  previous  regular  expression  with	 the  previous
	      replacement pattern from a substitution.

   Regular expressions
       A  regular expression specifies a set of strings of characters.	A mem‐
       ber of this set of strings is said to be matched by the regular expres‐
       sion.  Ex remembers two previous regular expressions: the previous reg‐
       ular expression used in a substitute command and the  previous  regular
       expression used elsewhere (referred to as the previous scanning regular
       expression.)  The previous regular expression can always be referred to
       by a null re, e.g. `//' or `??'.

       The following basic constructs are used to construct magic mode regular

       char	      An ordinary character matches  itself.   The  characters
		      `^'  at the beginning of a line, `$' at the end of line,
		      `*' as any character other than  the  first,  `.',  `\',
		      `[',  and	 `~'  are  not ordinary characters and must be
		      escaped (preceded) by `\' to be treated as such.

       ^	      At the beginning of a pattern forces the match  to  suc‐
		      ceed only at the beginning of a line.

       $	      At  the  end of a regular expression forces the match to
		      succeed only at the end of the line.

       .	      Matches any single character except the new-line charac‐

       \<	      Forces  the  match  to  occur only at the beginning of a
		      “variable” or “word”; that is, either at	the  beginning
		      of  a line, or just before a letter, digit, or underline
		      and after a character not one of these.

       \>	      Similar to `\<', but matching the end of a “variable” or
		      “word”,  i.e. either the end of the line or before char‐
		      acter which is neither a letter, nor a  digit,  nor  the
		      underline character.

       [string]	      Matches  any  (single) character in the class defined by
		      string.  Most characters in string define themselves.
			A pair	of  characters	separated  by  `-'  in	string
		      defines  the  set	 of  characters	 collating between the
		      specified lower and upper bounds, thus `[a-z]' as a reg‐
		      ular  expression	matches	 any (single) ASCII lower-case
			If the sequence `[:class:]' appears in	string,	 where
		      class  is	 one  of  `alnum',  `alpha', `blank', `cntrl',
		      `digit', `graph', `lower',  `print',  `punct',  `space',
		      `upper', `xdigit', or a locale-specific character class,
		      all characters  that  belong  to	the  given  class  are
		      matched.	Thus `[[:lower:]]' matches any lower-case let‐
		      ter, possibly including characters beyond the  scope  of
			If  the	 first	character of string is an `^' then the
		      construct matches those characters  which	 it  otherwise
		      would  not;  thus `[^a-z]' matches anything but an ASCII
		      lower-case letter (and of course a newline).
			Backslash `\' is interpreted as an  escape  character.
		      To  place	 a  `\'	 character  in string, write it twice:
		      `\\'; to place any of the characters `^', `[', or `-' in
		      string, you escape them with a preceding `\'.
			Characters  also  lose	their special meaning by posi‐
		      tion: `^' is an ordinary	character  unless  immediately
		      following	 the initial `[', `]' is an ordinary character
		      if immediately following the initial  `['	 (or  `^',  if
		      present),	 and  `-'  is  an ordinary character if placed
		      immediately behind `[' or `^', or before ']'.

       The concatenation of two regular expressions matches the	 leftmost  and
       then  longest string which can be divided with the first piece matching
       the first regular expression and the second piece matching the second.

       A regular expression may be enclosed between  the  sequences  `\('  and
       `\)', which matches whatever the enclosed expression matches.

       Any  of	the  (single character matching) regular expressions mentioned
       above or a regular expression surrounded by `\(' and '\)' may  be  fol‐
       lowed  by  the character `*' to form a regular expression which matches
       any number of adjacent occurrences (including 0) of characters  matched
       by the regular expression it follows.

       A  single  character  regular  expression  or a regular expression sur‐
       rounded by `\(' and '\)' followed by `\{m,n\}' matches a sequence of  m
       through	n  occurences,	inclusive, of the single character expression.
       The values of m and n must be non-negative and smaller than  255.   The
       form  `\{m\}' matches exactly m occurences, `\{m,\}' matches at least m

       The character `~' may be used in a regular expression, and matches  the
       text which defined the replacement part of the last substitute command.

       The sequence `\n' matches the text that was matched by the n-th regular
       subexpression enclosed between `\(' and `\)' earlier in the expression.

   Substitute replacement patterns
       The basic metacharacters for the replacement pattern are `&', `~',  and
       `#';  the  first two of them are given as `\&' and `\~' when nomagic is
       set.  Each instance of `&' is replaced by the characters which the reg‐
       ular expression matched.	 The metacharacter `~' stands, in the replace‐
       ment pattern, for the defining text of the  previous  replacement  pat‐
       tern.   If  the entire replacement pattern is `#', the defining text of
       the previous replacement pattern is used.

       Other metasequences possible in	the  replacement  pattern  are	always
       introduced  by  the  escaping  character	 `\'.	The  sequence  `\n' is
       replaced by the text matched by the n-th regular subexpression enclosed
       between	`\('  and `\)'.	 When nested, parenthesized subexpressions are
       present, n is determined by counting occurrences of `\(' starting  from
       the  left.  The sequences `\u' and `\l' cause the immediately following
       character in the replacement to be converted to	upper-	or  lower-case
       respectively  if	 this  character  is a letter.	The sequences `\U' and
       `\L' turn such conversion on, either until `\E' or `\e' is encountered,
       or until the end of the replacement pattern.

   Option descriptions
       autoindent, ai default: noai
	      Can  be used to ease the preparation of structured program text.
	      At the beginning of each append , change or  insert  command  or
	      when  a  new  line  is opened or created by an append , change ,
	      insert , or substitute operation within open or visual mode,  ex
	      looks  at	 the line being appended after, the first line changed
	      or the line inserted before and calculates the amount  of	 white
	      space  at	 the  start of the line.  It then aligns the cursor at
	      the level of indentation so determined.

	      If the user then types lines of text in, they will  continue  to
	      be  justified  at	 the displayed indenting level.	 If more white
	      space is typed at the beginning of a line,  the  following  line
	      will  start  aligned  with  the first non-white character of the
	      previous line.  To back the cursor up to the preceding tab  stop
	      one  can	hit  ^D.  The tab stops going backwards are defined at
	      multiples of the shiftwidth option.  The user  cannot  backspace
	      over the indent, except by sending an end-of-file with a ^D.

	      Specially	 processed  in	this mode is a line with no characters
	      added to it, which turns into a completely blank line (the white
	      space provided for the autoindent is discarded.)	Also specially
	      processed in this mode are lines beginning with an `^' and imme‐
	      diately  followed	 by a ^D.  This causes the input to be reposi‐
	      tioned at the beginning of the line, but retaining the  previous
	      indent for the next line.	 Similarly, a `0' followed by a ^D re‐
	      positions at the beginning but without  retaining	 the  previous

	      Autoindent  doesn't  happen in global commands or when the input
	      is not a terminal.

       autoprint, ap  default: ap
	      Causes the current line to be printed after each delete , copy ,
	      join  , move , substitute , t , undo or shift command.  This has
	      the same effect as supplying a trailing `p' to  each  such  com‐
	      mand.   Autoprint	 is suppressed in globals, and only applies to
	      the last of many commands on a line.

       autowrite, aw  default: noaw
	      Causes the contents of the buffer to be written to  the  current
	      file if the user has modified it and gives a next, rewind, stop,
	      tag, or !	 command, or a ^^ (switch files) or ^] (tag goto) com‐
	      mand  in	visual.	  Note,	 that  the edit and ex commands do not
	      autowrite.  In each case, there is an equivalent way of  switch‐
	      ing  when autowrite is set to avoid the autowrite (edit for next
	      , rewind!	 for .I rewind , stop!	for stop ,  tag!   for	tag  ,
	      shell for ! , and :e # and a :ta! command from within visual).

       beautify, bf   default: nobeautify
	      Causes  all control characters except tab, newline and form-feed
	      to be discarded from the input.  A complaint is  registered  the
	      first  time  a  backspace character is discarded.	 Beautify does
	      not apply to command input.

       directory, dir default: dir=/tmp
	      Specifies the directory in which ex places its buffer file.   If
	      this  directory  in  not	writable,  then	 the  editor will exit
	      abruptly when it fails to be able to create its buffer there.

       edcompatible   default: noedcompatible
	      Causes the presence of absence of g and c suffixes on substitute
	      commands	to  be	remembered, and to be toggled by repeating the
	      suffices.	 The suffix r makes the substitution be as  in	the  ~
	      command, instead of like &.

       errorbells, eb default: noeb
	      Error messages are preceded by a bell.  Bell ringing in open and
	      visual on errors is not suppressed by setting noeb.  If possible
	      the editor always places the error message in a standout mode of
	      the terminal (such as inverse  video)  instead  of  ringing  the

       exrc	      default: noexrc
	      If  set,	the  current directory is searched for a .exrc file on
	      startup.	If this file is found, its content is  treated	as  ex
	      commands	 and   executed	 immediately  after  the  contents  of
	      $HOME/.exrc on startup.

       flash, fl default: flash
	      If the terminal provides the “visual bell” capability,  ex  will
	      use it instead of the audible bell if flash is set.

       hardtabs, ht   default: ht=8
	      Gives the boundaries on which terminal hardware tabs are set (or
	      on which the system expands tabs).

       ignorecase, ic default: noic
	      All upper case characters in the text are mapped to  lower  case
	      in  regular  expression  matching.   In addition, all upper case
	      characters in regular  expressions  are  mapped  to  lower  case
	      except in character class specifications.

       lisp default: nolisp
	      Autoindent  indents appropriately for lisp code, and the ( ) { }
	      [[ and ]] commands in open and visual are modified to have mean‐
	      ing for lisp.

       list default: nolist
	      All  printed lines will be displayed (more) unambiguously, show‐
	      ing tabs and end-of-lines as in the list command.

       magic	 default: magic for ex and vi, Nomagic for edit.
	      If nomagic is set, the number of regular expression  metacharac‐
	      ters  is	greatly	 reduced, with only `^' and `$' having special
	      effects.	In addition the metacharacters	`~'  and  `&'  of  the
	      replacement  pattern  are treated as normal characters.  All the
	      normal metacharacters may be made magic when nomagic is  set  by
	      preceding them with a `\'.

       mesg default: mesg
	      Causes  write  permission to be turned off to the terminal while
	      the user is in visual mode, if nomesg is set.

       modelines, ml  default: nomodelines
	      If modelines is set, then the first 5 lines and  the  last  five
	      lines  of	 the file will be checked for ex command lines and the
	      comands issued.  To be recognized as a command  line,  the  line
	      must  have the string ex: or vi: in it.  This string may be any‐
	      where in the line and anything after the : is interpeted as edi‐
	      tor commands.  This option defaults to off because of unexpected
	      behavior when editting files such as /etc/passwd.

       number, nu     default: nonumber
	      Causes all output lines to be printed with their	line  numbers.
	      In  addition  each  input line will be prompted for by supplying
	      the line number it will have.

       open default: open
	      If noopen, the commands open and visual are not permitted.

       optimize, opt  default: optimize
	      Throughput of text is expedited by setting the terminal  to  not
	      do automatic carriage returns when printing more than one (logi‐
	      cal) line of output, greatly speeding output on terminals	 with‐
	      out  addressable	cursors	 when text with leading white space is

       paragraphs, para	   default: para=IPLPPPQPP LIbp
	      Specifies the paragraphs for the { and } operations in open  and
	      visual.	The  pairs of characters in the option's value are the
	      names of the macros which start paragraphs.

       prompt	 default: prompt
	      Command mode input is prompted for with a `:'.

       redraw	 default: noredraw
	      The editor simulates (using great amounts of output), an	intel‐
	      ligent  terminal	on  a dumb terminal (e.g. during insertions in
	      visual the characters to the right of the	 cursor	 position  are
	      refreshed	 as  each  input  character is typed.)	Useful only at
	      very high speed.

       remap	 default: remap
	      If on, macros are repeatedly tried  until	 they  are  unchanged.
	      For  example,  if o is mapped to O , and O is mapped to I , then
	      if remap is set, o will map to I , but if	 noremap  is  set,  it
	      will map to O .

       report	 default: report=5, 2 for edit.
	      Specifies	 a  threshold for feedback from commands.  Any command
	      which modifies more than the specified number of lines will pro‐
	      vide feedback as to the scope of its changes.  For commands such
	      as global , open , undo , and visual which have potentially more
	      far reaching scope, the net change in the number of lines in the
	      buffer is presented at the end of the command, subject  to  this
	      same threshold.  Thus notification is suppressed during a global
	      command on the individual commands performed.

       scroll	 default: scroll=½ window
	      Determines the number of logical lines scrolled when an  end-of-
	      file  is received from a terminal input in command mode, and the
	      number of lines printed by a command mode z command (double  the
	      value of scroll ).

       sections	 default: sections=SHNHH HU
	      Specifies	 the  section  macros  for the [[ and ]] operations in
	      open and visual.	The pairs of characters in the options's value
	      are the names of the macros which start paragraphs.

       shell, sh default: sh=/bin/sh
	      Gives  the  path	name  of the shell forked for the shell escape
	      command `!', and by the shell command.   The  default  is	 taken
	      from SHELL in the environment, if present.

       shiftwidth, sw default: sw=8
	      Gives  the  width	 a  software tab stop, used in reverse tabbing
	      with ^D when using autoindent to append text, and by  the	 shift

       showmatch, sm  default: nosm
	      In open and visual mode, when a ) or } is typed, move the cursor
	      to the matching ( or { for one second if this matching character
	      is on the screen.	 Extremely useful with lisp.

       showmode, smd  default: nosmd
	      In  visual  mode, show a description of the current editing mode
	      in the window's lower right corner.

       slowopen, slow terminal dependent
	      Affects the display algorithm used in visual mode,  holding  off
	      display  updating during input of new text to improve throughput
	      when the terminal in use is both slow and unintelligent.	See An
	      Introduction to Display Editing with Vi for more details.

       tabstop, ts    default: ts=8
	      The  editor  expands  tabs  in  the  input file to be on tabstop
	      boundaries for the purposes of display.

       taglength, tl  default: tl=0
	      Tags are not significant beyond this many characters.   A	 value
	      of zero (the default) means that all characters are significant.

       tags default: tags=tags /usr/lib/tags
	      A	 path of files to be used as tag files for the tag command.  A
	      requested tag is searched for in the  specified  files,  sequen‐
	      tially.	By  default, files called tags are searched for in the
	      current directory and in /usr/lib (a master file for the	entire

       term from environment TERM
	      The terminal type of the output device.

       terse	 default: noterse
	      Shorter error diagnostics are produced for the experienced user.

       warn default: warn
	      Warn  if	there has been `[No write since last change]' before a
	      `!'  command escape.

       window	 default: window=speed dependent
	      The number of lines in a text window in the visual command.  The
	      default  is  8  at  slow speeds (600 baud or less), 16 at medium
	      speed (1200 baud), and the  full	screen	(minus	one  line)  at
	      higher speeds.

       w300, w1200, w9600
	      These  are  not true options but set window only if the speed is
	      slow (300), medium (1200), or high (9600),  respectively.	  They
	      are  suitable  for  an  EXINIT  and  make	 it easy to change the
	      8/16/full screen rule.

       wrapscan, ws   default: ws
	      Searches using the regular expressions in addressing  will  wrap
	      around past the end of the file.

       wrapmargin, wm default: wm=0
	      Defines  a margin for automatic wrapover of text during input in
	      open and visual modes.  See An Introduction to Text Editing with
	      Vi for details.

       writeany, wa   default: nowa

	      Inhibit the checks normally made before write commands, allowing
	      a write to any file which the system protection  mechanism  will

       The following environment variables affect the behaviour of ex:

	      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

       HOME   Used to locate the editor startup file.

       LANG, LC_ALL
	      See locale(7).

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

	      Sets the language used for diagnostic and informal messages.

       LINES  Overrides the system-supplied number of terminal lines.

	      See catopen(3).

       SHELL  The program file used to execute external commands.

       TERM   Determines the terminal type.

	      preserve command

	      recover command

	      describes capabilities of terminals

	      editor startup file

	      editor temporary

	      named buffer temporary

	      preservation directory

       The  document Edit: A tutorial (USD:14) provides a comprehensive intro‐
       duction to edit assuming no previous knowledge of computers or the UNIX

       The  Ex	Reference Manual – Version 3.7 (USD:16) is a comprehensive and
       complete manual for the command mode features of ex.  The USAGE section
       of  this	 page  is  taken from the manual.  For an introduction to more
       advanced forms of editing using the command mode of ex see the  editing
       documents written by Brian Kernighan for the editor ed; the material in
       the introductory and advanced documents works also with ex.

       An Introduction to Display Editing with Vi (USD:15) introduces the dis‐
       play  editor vi and provides reference material on vi.  (This reference
       now forms the vi(1) manual page).  In addition, the Vi Quick  Reference
       card  summarizes the commands of vi in a useful, functional way, and is
       useful with the Introduction.

       awk(1), ed(1), grep(1), sed(1), grep(1), vi(1), catopen(3), termcap(5),
       environ(7), locale(7), regex(7)

       Originally written by William Joy.

       Mark Horton has maintained the editor since version 2.7, adding macros,
       support for many unusual terminals, and other  features	such  as  word
       abbreviation mode.

       This version incorporates changes by Gunnar Ritter.

       Undo never clears the buffer modified condition.

       The  z  command	prints a number of logical rather than physical lines.
       More than a screen full of output may result if long lines are present.

       File input/output errors don't print a name if  the  command  line  `-'
       option is used.

       The  editor  does  not  warn if text is placed in named buffers and not
       used before exiting the editor.

       Null (00) characters are converted  to  0200  characters	 when  reading
       input files, and cannot appear in resultant files.

       LC_COLLATE  locales are ignored; collating symbols `[.c.]'  and equiva‐
       lence classes `[=c=]' in bracket expressions are recognized but useless
       since `c' is restricted to a single character and is the only character
       matched; range expressions `[a-m]' are always evaluated in byte order.

Ancient Unix Ports		    12/1/04				 EX(1)

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