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

           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.

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

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

           ($)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
                   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
                   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                   ED(1)