ED(1)                                                       ED(1)

NAME
       ed, red - text editor

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

       red [-] [-Gs] [-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 occurences 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 buffer.  Lines consist of
       text up to and including a newline character.  Input  mode
       is  terminated 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' command is  applied  to
       whole lines at a time.

       In  general,  ed  commands  consist  of  zero or more line
       addresses, followed by a single character command and pos-
       sibly  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  sup-
       plied.

   OPTIONS
       -G      Forces  backwards compatibility.  Affects the com-
               mands `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, pre-
               fix  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 computed 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 legal 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 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

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

       +n

       whitespace n
               The  nth next line, where n is a non-negative num-
               ber.  Whitespace followed by a number n is  inter-
               preted 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  expres-
               sion  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) com-
               mand, where lc is a lower case letter.

   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 correspond-
       ing 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  char-
               acters.   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 inter-
               preted according to locale(5) (not currently  sup-
               ported).  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 expres-
               sion,  then  it  anchors the regular expression to
               the beginning of a line.   Otherwise,  it  matches
               itself.

       $       If  `$' is the last character of a regular expres-
               sion, 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 subsequent  back-
               reference 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'.  Subexpressions are
               ordered relative to their left delimiter.

       *       Matches the single character regular expression or
               subexpression  immediately  preceding  it  zero or
               more times.  If '*' is the first  character  of  a
               regular   expression  or  subexpression,  then  it
               matches itself.  The `*' operator sometimes yields
               unexpected  results.   For  example,  the  regular
               expression  `b*'  matches  the  beginning  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 preceding 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 expres-
               sion or subexpression, then it is interpreted lit-
               erally   (i.e.,  the  regular  expression  `\{2\}'
               matches the string `{2}', and so on).

       \<
       \>      Anchors the single character regular expression or
               subexpression  immediately  following  it  to  the
               beginning (\<) or ending (\>) of a word, i.e.,  in
               ASCII,  a  maximal  string of alphanumeric charac-
               ters, including the underscore (_).

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

       \`
       \'      Unconditionally matches the beginning (\`) or end-
               ing (\') of a line.

       \?      Optionally  matches  the  single character regular
               expression or subexpression immediately  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
               expressions or subexpression, then  it  matches  a
               literal `?'.

       \+      Matches the single character regular expression or
               subexpression immediately preceding it one or more
               times.   So  the regular expression `a+' is short-
               hand 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 expression `\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
       additonal 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.  How-
       ever, 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   filename   is
               unchanged.   Any  lines  in the buffer are deleted
               before the output of command 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 unwritten  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 cur-
               rent 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 rec-
               ommended  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 sin-
               gle line containing their joined text.   The  cur-
               rent 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 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 command-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  dis-
               carded 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 postive number, causes only the nth
               match to be replaced.  It is an error if  no  sub-
               stitutions  are  performed on any of the addressed
               lines.  The current address is set the  last  line
               affected.

               re and replacement may be delimited by any charac-
               ter other than space and newline (see the `s' com-
               mand 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 substi-
               tution  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  suffix  `n',  or  any
               combination  of  the characters `r', `g', and `p'.
               If a count suffix `n' is given, then only the  nth
               match is replaced.  The `r' suffix causes the reg-
               ular 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 expression re.  This
               is similar to the `g' command.

       (1,$)V/re/
               Interactively edits the addressed lines not match-
               ing  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  exe-
               cutes 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' command, 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 overwritten  by  subse-
               quent  `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 charac-
               ter 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 filename.
               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
       /tmp/ed.*           Buffer file
       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 Pas-
       cal , Addison-Wesley, 1981.

LIMITATIONS
       ed processes file arguments for backslash  escapes,  i.e.,
       in  a filename, any characters preceded by a backslash (\)
       are 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: 4 ints

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
       buffer are lost.

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

                         10 November 1994                       1