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 cre-
       ate,  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  com-
       mands.

       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
       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' com-
       mand  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
       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 inter-
               preted 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  typi-
       cally  supplied  to commands as the default address when
       none is specified.  When a file is first read,  the cur-
       rent  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, opera-
       tors (i.e.  + and -) and whitespace.  Addresses are read
       from  left to right, and their values are computed rela-
       tive 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-delim-
       ited 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 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  corre-
       sponding  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  inter-
               preted  according  to  locale(5)  (not currently
               supported).  See regex(3) for an explanation  of
               these constructs.

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

       ^       If  `^'  is  the  first  character  of a regular
               expression, then it anchors the regular  expres-
               sion  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  subsequent
               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  delim-
               iter.

       *       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 expression or subexpression, then it  is
               interpreted literally (i.e., the regular expres-
               sion `\{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 char-
               acters, including the underscore (_).


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

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

       \?      Optionally matches the single character  regular
               expression  or subexpression immediately preced-
               ing it.  For  example,  the  regular  expression
               `a[bd]\?c'  matches the strings `abc', `adc' and
               `ac'.  If \? occurs at the beginning of a  regu-
               lar   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
               shorthand for `aa*'.  If \+ occurs at the begin-
               ning 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 additional parameters.  If a  command's  parame-
       ters  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.  Other-
               wise  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 file-
               name is used.   Any  lines  in  the  buffer  are
               deleted  before  the new file is read.  The cur-
               rent 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 cur-
               rent 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  file-
               name 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  sepa-
               rate  line,  and  every line except for the last
               must be terminated by a backslash (\).  Any com-
               mands are allowed, except for `g', `G', `v', and
               `V'.  A newline alone in command-list is equiva-
               lent 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 com-
               mand-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 com-
               mand 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  cur-
               rent 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 sin-
               gle quote followed by lc )  in  subsequent  com-
               mands.   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  cur-
               rent 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
               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' suf-
               fix, 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 current address is set the
               last line affected.

               re and replacement may be delimited by any char-
               acter  other than space and newline (see the `s'
               command 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 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 regular expression of the last search to  be
               used  instead  of the that of the last substitu-
               tion.  The `g' suffix toggles the global  suffix
               of  the  last substitution.  The `p' suffix tog-
               gles 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
               matching a regular expression re.  This is simi-
               lar to the `G' command.

       (1,$)w file
               Writes  the addressed lines to file.  Any previ-
               ous 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' 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  char-
               acter  of command is `!', then it is replaced by
               text of the previous `!command'.   ed  does  not
               process command for backslash (\) escapes.  How-
               ever,  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
       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 characters preceded by a backslash
       (\) are interpreted literally.

       If a text (non-binary) file is not terminated by a  new-
       line  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 explana-
       tion of the last error  can  be  printed  with  the  `h'
       (help) command.

       Attempting  to quit ed or edit another file before writ-
       ing a modified buffer results in an error.  If the  com-
       mand  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.



                         5 October 2006                   ED(1)
