Unix/Linux Go Back    


Linux 2.6 - man page for ed (linux section 1)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


ED(1)											    ED(1)

NAME
       ed, red - text editor

SYNOPSIS
       ed [-GVhs] [-p string] [file]

       red [-GVhs] [-p string] [file]

DESCRIPTION
       ed  is  a  line-oriented text editor.  It is used to create, display, modify and otherwise
       manipulate text files.  red is a restricted ed: it can only  edit  files  in  the  current
       directory and cannot execute shell commands.

       If  invoked  with  a  file argument, then a copy of file is read into the editor's buffer.
       Changes are made to this copy and not directly to file  itself.	 Upon  quitting  ed,  any
       changes not explicitly saved  with a `w' command are lost.

       Editing	is  done  in two distinct modes: command and input.  When first invoked, ed is in
       command mode.  In this mode commands are read from the  standard  input	and  executed  to
       manipulate the contents of the editor buffer.  A typical command might look like:

	      ,s/old/new/g

       which replaces all occurrences of the string old with new.

       When  an  input	command, such as `a' (append), `i' (insert) or `c' (change), is given, ed
       enters input mode.  This is the primary means of adding text to a file.	In this mode,  no
       commands are available; instead, the standard input is written directly to the editor buf-
       fer.  Lines consist of text up to and including a newline character.  Input mode is termi-
       nated by entering a single period  (.) on a line.

       All  ed	commands operate on whole lines or ranges of lines; e.g., the `d' command deletes
       lines; the `m' command moves lines, and so on.  It is possible to modify only a portion of
       a  line by means of replacement, as in the example above.  However even here, the `s' com-
       mand is applied to whole lines at a time.

       In general, ed commands consist of zero or more line addresses, followed by a single char-
       acter command and possibly additional parameters; i.e., commands have the structure:

	      [address [,address]]command[parameters]

       The  address(es)  indicate  the	line or range of lines to be affected by the command.  If
       fewer addresses are given than the command accepts, then default addresses are supplied.

   OPTIONS
       -G      Forces backwards compatibility.	Affects the commands `G',  `V',  `f',  `l',  `m',
	       `t', and `!!'.

       -s      Suppresses  diagnostics.  This  should  be  used  if ed's standard input is from a
	       script.

       -p string
	       Specifies a command prompt.  This may be toggled on and off with the `P' command.

       file    Specifies the name of a file to read.  If file is prefixed with a bang  (!),  then
	       it  is interpreted as a shell command.  In this case, what is read is the standard
	       output of file executed via sh(1).  To read a file whose name begins with a  bang,
	       prefix the name with a backslash (\).  The default filename is set to file only if
	       it is not prefixed with a bang.

   LINE ADDRESSING
       An address represents the number of a line in the buffer.  ed maintains a current  address
       which  is  typically  supplied  to commands as the default address when none is specified.
       When a file is first read,  the current address is set to the last line of the  file.   In
       general, the current address is set to the last line affected by a command.

       A line address is constructed from one of the bases in the list below, optionally followed
       by a numeric offset.  The offset may include any combination of digits, operators (i.e.	+
       and  -)	and whitespace.  Addresses are read from left to right, and their values are com-
       puted relative to the current address.

       One exception to the rule that addresses represent line numbers is the address  0  (zero).
       This means "before the first line", and is valid wherever it makes sense.

       An  address  range is two addresses separated either by a comma or semicolon. The value of
       the first address in a range cannot exceed the value of the second.  If only  one  address
       is  given  in a range, then the second address is set to the given address.  If an n-tuple
       of addresses is given where n > 2, then the corresponding range is determined by the  last
       two  addresses  in the n-tuple.	If only one address is expected, then the last address is
       used.

       Each address in a comma-delimited range is interpreted relative to  the	current  address.
       In  a semicolon-delimited range, the first address is used to set the current address, and
       the second address is interpreted relative to the first.

       The following address symbols are recognized.

       .       The current line (address) in the buffer.

       $       The last line in the buffer.

       n       The nth, line in the buffer where n is a number in the range [0,$].

       -       The previous line.  This is equivalent to -1 and may be repeated  with  cumulative
	       effect.

       ^n      The nth previous line, where n is a non-negative number.

       +       The  next  line.   This	is  equivalent	to +1 and may be repeated with cumulative
	       effect.

       whitespace n

       +n      The nth next line, where n is a non-negative number.   Whitespace  followed  by	a
	       number n is interpreted as +n.

       ,       The  first  through  last  lines in the buffer.	This is equivalent to the address
	       range 1,$.

       ;       The current through last lines in the buffer.  This is equivalent to  the  address
	       range .,$.

       /re/    The  next  line	containing  the  regular  expression re.  The search wraps to the
	       beginning of the buffer and continues down to the current line, if necessary.   //
	       repeats the last search.

       ?re?    The  previous  line containing the regular expression re.  The search wraps to the
	       end of the buffer and continues up to the current line, if necessary.  ??  repeats
	       the last search.

       'lc     The  line previously marked by a `k' (mark) command, where lc is a lower case let-
	       ter.

   REGULAR EXPRESSIONS
       Regular expressions are patterns used in selecting text.  For example, the ed command

	      g/string/

       prints all lines containing string.  Regular expressions are also used by the `s'  command
       for selecting old text to be replaced with new.

       In  addition to a specifying string literals, regular expressions can represent classes of
       strings.  Strings thus represented are said to be matched  by  the  corresponding  regular
       expression.   If  it  is  possible  for a regular expression to match several strings in a
       line, then the left-most longest match is the one selected.

       The following symbols are used in constructing regular expressions:

       c       Any character c not listed below, including `{',  '}',  `(',  `)',  `<'	and  `>',
	       matches itself.

       \c      A backslash-escaped character c other than `{', '}', `(', `)', `<', `>', `b', 'B',
	       `w', `W', `+', and `?'  matches itself.

       .       Matches any single character.

       [char-class]
	       Matches any single character in char-class.  To include a  `]' in  char-class,  it
	       must be the first character.  A range of characters may be specified by separating
	       the end characters of the range with a `-', e.g., `a-z' specifies the  lower  case
	       characters.   The  following literal expressions can also be used in char-class to
	       specify sets of characters:

		 [:alnum:]  [:cntrl:]  [:lower:]  [:space:]
		 [:alpha:]  [:digit:]  [:print:]  [:upper:]
		 [:blank:]  [:graph:]  [:punct:]  [:xdigit:]

	       If `-' appears as the first or last  character  of  char-class,	then  it  matches
	       itself.	All other characters in char-class match themselves.

	       Patterns in char-class of the form:

		 [.col-elm.] or,   [=col-elm=]

	       where  col-elm  is a collating element are interpreted according to locale(5) (not
	       currently supported).  See regex(3) for an explanation of these constructs.

       [^char-class]
	       Matches any single character, other than newline, not in  char-class.   char-class
	       is defined as above.

       ^       If `^' is the first character of a regular expression, then it anchors the regular
	       expression to the beginning of a line.  Otherwise, it matches itself.

       $       If `$' is the last character of a  regular  expression,	it  anchors  the  regular
	       expression to the end of a line.  Otherwise, it matches itself.

       \(re\)  Defines a (possibly null) subexpression re.  Subexpressions may be nested.  A sub-
	       sequent backreference of the form `\n', where n is a number in  the  range  [1,9],
	       expands	to  the  text matched by the nth subexpression.  For example, the regular
	       expression `\(a.c\)\1' matches the string `abcabc', but not `abcadc'.   Subexpres-
	       sions are ordered relative to their left delimiter.

       *       Matches	the single character regular expression or subexpression immediately pre-
	       ceding it zero or more times.  If '*' is the first character of a regular  expres-
	       sion  or subexpression, then it matches itself.	The `*' operator sometimes yields
	       unexpected results.  For example, the regular expression `b*' matches  the  begin-
	       ning  of  the string `abbb', as opposed to the substring `bbb', since a null match
	       is the only left-most match.

       \{n,m\}
       \{n,\}
       \{n\}   Matches the single character regular expression or subexpression immediately  pre-
	       ceding  it  at  least  n and at most m times.  If m is omitted, then it matches at
	       least n times.  If the comma is also omitted, then it matches exactly n times.  If
	       any  of these forms occurs first in a regular expression or subexpression, then it
	       is interpreted literally (i.e., the regular expression `\{2\}' matches the  string
	       `{2}', and so on).

       \<
       \>      Anchors	the single character regular expression or subexpression immediately fol-
	       lowing it to the beginning (\<) or ending (\>) of a word, i.e., in ASCII, a  maxi-
	       mal string of alphanumeric characters, including the underscore (_).

       The  following extended operators are preceded by a backslash (\) to distinguish them from
       traditional ed syntax.

       \`
       \'      Unconditionally matches the beginning (\`) or ending (\') of a line.

       \?      Optionally matches the single character regular expression or subexpression  imme-
	       diately	preceding it.  For example, the regular expression `a[bd]\?c' matches the
	       strings `abc', `adc' and `ac'.  If \? occurs at the beginning of a regular expres-
	       sions or subexpression, then it matches a literal `?'.

       \+      Matches	the single character regular expression or subexpression immediately pre-
	       ceding it one or more times.  So the regular expression	`a\+'  is  shorthand  for
	       `aa*'.	If  \+	occurs at the beginning of a regular expression or subexpression,
	       then it matches a literal `+'.

       \b      Matches the beginning or ending (null string) of a word.  Thus the regular expres-
	       sion `\bhello\b' is equivalent to `\<hello\>'.  However, `\b\b' is a valid regular
	       expression whereas `\<\>' is not.

       \B      Matches (a null string) inside a word.

       \w      Matches any character in a word.

       \W      Matches any character not in a word.

   COMMANDS
       All ed commands are single characters, though some require additional  parameters.   If	a
       command's parameters extend over several lines, then each line except for the last must be
       terminated with a backslash (\).

       In general, at most one command is allowed per line.   However,	most  commands	accept	a
       print  suffix,  which is any of `p' (print), `l' (list) , or `n' (enumerate), to print the
       last line affected by the command.

       An interrupt (typically ^C) has the effect of aborting the current command  and	returning
       the editor to command mode.

       ed  recognizes  the  following commands.  The commands are shown together with the default
       address or address range supplied if none is specified (in parenthesis).

       (.)a    Appends text to the buffer after the addressed line, which may be  the  address	0
	       (zero).	 Text  is entered in input mode.  The current address is set to last line
	       entered.

       (.,.)c  Changes lines in the buffer.  The addressed lines are deleted from the buffer, and
	       text  is  appended  in  their  place.  Text is entered in input mode.  The current
	       address is set to last line entered.

       (.,.)d  Deletes the addressed lines from the buffer.  If there is a line after the deleted
	       range, then the current address is set to this line. Otherwise the current address
	       is set to the line before the deleted range.

       e file  Edits file, and sets the default filename.  If file is  not  specified,	then  the
	       default filename is used.  Any lines in the buffer are deleted before the new file
	       is read.  The current address is set to the last line read.

       e !command
	       Edits the standard output of `!command', (see !command below).  The default  file-
	       name  is unchanged.  Any lines in the buffer are deleted before the output of com-
	       mand is read.  The current address is set to the last line read.

       E file  Edits file unconditionally.  This is similar to the e command, except that unwrit-
	       ten changes are discarded without warning.  The current address is set to the last
	       line read.

       f file  Sets the default filename to file.  If file is not  specified,  then  the  default
	       unescaped filename is printed.

       (1,$)g/re/command-list
	       Applies	command-list to each of the addressed lines matching a regular expression
	       re.  The current address is set to the line currently matched before  command-list
	       is  executed.   At  the	end of the `g' command, the current address is set to the
	       last line affected by command-list.

	       Each command in command-list must be on a separate line, and every line except for
	       the  last must be terminated by a backslash (\).  Any commands are allowed, except
	       for `g', `G', `v', and `V'.  A newline alone in command-list is	equivalent  to	a
	       `p' command.

       (1,$)G/re/
	       Interactively  edits  the  addressed  lines matching a regular expression re.  For
	       each matching line, the line is printed, the current address is set, and the  user
	       is  prompted  to enter a command-list.  At the end of the `G' command, the current
	       address is set to the last line affected by (the last) command-list.

	       The format of command-list is the same as that of  the  `g'  command.   A  newline
	       alone acts as a null command list.  A single `&' repeats the last non-null command
	       list.

       H       Toggles the printing of error explanations.   By  default,  explanations  are  not
	       printed.   It  is  recommended  that  ed scripts begin with this command to aid in
	       debugging.

       h       Prints an explanation of the last error.

       (.)i    Inserts text in the buffer before the current line.   Text  is  entered	in  input
	       mode.  The current address is set to the last line entered.

       (.,.+1)j
	       Joins  the  addressed  lines.  The addressed lines are deleted from the buffer and
	       replaced by a single line containing their joined text.	The  current  address  is
	       set to the resultant line.

       (.)klc  Marks  a line with a lower case letter lc.  The	line can then be addressed as 'lc
	       (i.e., a single quote followed by lc ) in subsequent commands.  The  mark  is  not
	       cleared until the line is deleted or otherwise modified.

       (.,.)l  Prints  the  addressed lines unambiguously.  If invoked from a terminal, ed pauses
	       at the end of each page until a newline is entered.  The current address is set to
	       the last line printed.

       (.,.)m(.)
	       Moves  lines in the buffer.  The addressed lines are moved to after the right-hand
	       destination address, which may be the address 0 (zero).	The  current  address  is
	       set to the new address of the last line moved.

       (.,.)n  Prints  the addressed lines along with their line numbers.  The current address is
	       set to the last line printed.

       (.,.)p  Prints the addressed lines.    If invoked from a terminal, ed pauses at the end of
	       each page until a newline is entered.  The current address is set to the last line
	       printed.

       P       Toggles the command prompt on and off.  Unless a prompt was specified by with com-
	       mand-line option -p string, the command prompt is by default turned off.

       q       Quits ed.

       Q       Quits ed unconditionally.  This is similar to the q command, except that unwritten
	       changes are discarded without warning.

       ($)r file
	       Reads file to after the addressed line.	 If  file  is  not  specified,	then  the
	       default	filename is used.  If there was no default filename prior to the command,
	       then the default filename is set to file.   Otherwise,  the  default  filename  is
	       unchanged.  The current address is set to the last line read.

       ($)r !command
	       Reads  to  after  the  addressed  line the standard output of `!command', (see the
	       !command below).  The default filename is unchanged.  The current address  is  set
	       to the last line read.

       (.,.)s/re/replacement/
       (.,.)s/re/replacement/g
       (.,.)s/re/replacement/n
	       Replaces  text  in  the	addressed  lines  matching  a  regular expression re with
	       replacement.  By default, only the first match in each line is replaced.   If  the
	       `g'  (global)  suffix  is given, then every match to be replaced.  The `n' suffix,
	       where n is a positive number, causes only the nth match to be replaced.	It is  an
	       error  if  no substitutions are performed on any of the addressed lines.  The cur-
	       rent address is set to the last line affected.

	       re and replacement may be delimited by any character other than space, newline and
	       the  characters used by the form of the `s' command shown below.  If one or two of
	       the last delimiters is omitted, then the last line affected is printed  as  though
	       the print suffix `p' were specified.

	       An  unescaped  `&'  in replacement is replaced by the currently matched text.  The
	       character sequence `\m', where m is a number in the range [1,9],  is  replaced  by
	       the  mth backreference expression of the matched text.  If replacement consists of
	       a single `%', then replacement from the last substitution is used.   Newlines  may
	       be embedded in replacement if they are escaped with a backslash (\).

       (.,.)s  Repeats	the last substitution.	This form of the `s' command accepts a count suf-
	       fix `n', and any combination of the characters `r', `g', and `p'.  If a count suf-
	       fix  `n' is given, then only the nth match is replaced.	The `r' suffix causes the
	       regular expression of the last search to be used instead of the that of	the  last
	       substitution.   The `g' suffix toggles the global suffix of the last substitution.
	       The `p' suffix toggles the print suffix of the  last  substitution.   The  current
	       address is set to the last line affected.

       (.,.)t(.)
	       Copies  (i.e.,  transfers) the addressed lines to after the right-hand destination
	       address, which may be the address 0 (zero).  The current address  is  set  to  the
	       last line copied.

       u       Undoes the last command and restores the current address to what it was before the
	       command.  The global commands `g', `G', `v', and `V'.  are  treated  as	a  single
	       command by undo.  `u' is its own inverse.

       (1,$)v/re/command-list
	       Applies command-list to each of the addressed lines not matching a regular expres-
	       sion re.  This is similar to the `g' command.

       (1,$)V/re/
	       Interactively edits the addressed lines not  matching  a  regular  expression  re.
	       This is similar to the `G' command.

       (1,$)w file
	       Writes the addressed lines to file.  Any previous contents of file is lost without
	       warning.  If there is no default filename, then the default  filename  is  set  to
	       file,  otherwise  it  is unchanged.  If no filename is specified, then the default
	       filename is used.  The current address is unchanged.

       (1,$)wq file
	       Writes the addressed lines to file, and then executes a `q' command.

       (1,$)w !command
	       Writes the addressed lines to the standard input of `!command', (see the  !command
	       below).	The default filename and current address are unchanged.

       (1,$)W file
	       Appends	the  addressed lines to the end of file.  This is similar to the `w' com-
	       mand, expect that the previous contents of file is  not	clobbered.   The  current
	       address is unchanged.

       (.)x    Copies  (puts)  the  contents  of the cut buffer to after the addressed line.  The
	       current address is set to the last line copied.

       (.,.)y  Copies (yanks) the addressed lines to the cut buffer.  The cut buffer is overwrit-
	       ten  by	subsequent  `y',  `s', `j', `d', or `c' commands.  The current address is
	       unchanged.

       (.+1)zn Scrolls n lines at a time starting at addressed line.  If n is not specified, then
	       the  current  window  size  is  used.  The current address is set to the last line
	       printed.

       !command
	       Executes command via sh(1).  If the first character of command is `!', then it  is
	       replaced  by  text  of  the  previous `!command'.  ed does not process command for
	       backslash (\) escapes.  However, an unescaped `%' is replaced by the default file-
	       name.   When  the  shell returns from execution, a `!'  is printed to the standard
	       output.	The current line is unchanged.

       (.,.)#  Begins a comment;  the rest of the line, up to a newline, is ignored.  If  a  line
	       address	followed by a semicolon is given, then the current address is set to that
	       address.  Otherwise, the current address is unchanged.

       ($)=    Prints the line number of the addressed line.

       (.+1)newline
	       Prints the addressed line, and sets the current address to that line.

FILES
       ed.hup  The file to which ed attempts to write the  buffer if the terminal hangs up.

SEE ALSO
       vi(1), sed(1), regex(3), sh(1).

       USD:12-13

       B. W. Kernighan and P. J. Plauger, Software Tools in Pascal , Addison-Wesley, 1981.

LIMITATIONS
       ed processes file arguments for backslash escapes, i.e.,  in  a	filename,  any	character
       preceded by a backslash (\) is interpreted literally.

       If  a text (non-binary) file is not terminated by a newline character, then ed appends one
       on reading/writing it.  In the case of a binary file, ed does  not  append  a  newline  on
       reading/writing.

       Per line overhead: 2 pointers, 1 long int, and 1 int.

DIAGNOSTICS
       When  an  error	occurs,  if  ed's  input is from a regular file or here document, then it
       exits, otherwise it prints a `?' and returns to command mode.  An explanation of the  last
       error can be printed with the `h' (help) command.

       Attempting  to quit ed or edit another file before writing a modified buffer results in an
       error.  If the command is entered a second time, it succeeds, but any changes to the  buf-
       fer are lost.

       ed exits with 0 if no errors occurred; otherwise >0.

					   3 July 2010					    ED(1)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 06:03 AM.