SiteMap / AllPages / Out

ManEd

                       ed(1) - 10 November 1994
    Overview:
      * DESCRIPTION
           + OPTIONS
           + LINE ADDRESSING
           + REGULAR EXPRESSIONS
           + COMMANDS
      * FILES
      * SEE ALSO
      * LIMITATIONS
      * DIAGNOSTICS
 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
         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  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.

SiteMap / AllPages / Out / kensanata@gmail.com / Last change: 2001-02-15