Provided by: ed_1.5-3_amd64 bug

NAME

       ed, red - text editor

SYNOPSIS

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

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

DESCRIPTION

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

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

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

              ,s/old/new/g

       which replaces all occurrences of the string old with new.

       When  an  input  command, such as `a' (append), `i' (insert) or `c' (change), is given, ed
       enters input mode.  This is the primary means of adding text to a file.  In this mode,  no
       commands  are  available;  instead,  the  standard input is written directly to the editor
       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 possibly additional parameters; i.e., commands have the structure:

              [address [,address]]command[parameters]

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

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

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

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

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

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

       A line address is constructed from one of the bases in the list below, optionally followed
       by a numeric offset.  The offset may include any combination of digits, operators (i.e.  +
       and  -)  and  whitespace.   Addresses  are  read  from left to right, and their values are
       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 valid wherever it makes sense.

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

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

       The following address symbols are recognized.

       .       The current line (address) in the buffer.

       $       The last line in the buffer.

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

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

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

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

       whitespace n

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

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

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

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

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

       'lc     The  line  previously  marked  by  a  `k' (mark) command, where lc is a lower case
               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  corresponding  regular
       expression.   If  it  is  possible  for a regular expression to match several strings in a
       line, then the left-most longest match is the one selected.

       The following symbols are used in constructing regular expressions:

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

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

       .       Matches any single character.

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

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

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

               Patterns in char-class of the form:

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

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

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

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

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

       \(re\)  Defines  a  (possibly  null)  subexpression  re.  Subexpressions may be nested.  A
               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'.
               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 expression or subexpression, then it
               is interpreted literally (i.e., the regular expression `\{2\}' matches the  string
               `{2}', and so on).

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

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

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

       \?      Optionally matches  the  single  character  regular  expression  or  subexpression
               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 shorthand  for
               `aa*'.   If  \+  occurs at the beginning of a regular expression or subexpression,
               then it matches a literal `+'.

       \b      Matches the beginning or ending  (null  string)  of  a  word.   Thus  the  regular
               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 parameters extend over several lines, then each line except for the last must be
       terminated with a backslash (\).

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

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

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

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

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

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

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

       e !command
               Edits the standard output  of  `!command',  (see  !command  below).   The  default
               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 current address is set to the line currently matched before  command-list
               is  executed.   At  the  end of the `g' command, the current address is set to the
               last line affected by command-list.

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

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

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

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

       h       Prints an explanation of the last error.

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

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

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

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

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

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

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

       P       Toggles the command prompt on and off.  Unless a  prompt  was  specified  by  with
               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' suffix,
               where n is a positive number, causes only the nth match to be replaced.  It is  an
               error  if  no  substitutions  are  performed  on  any of the addressed lines.  The
               current address is set to the last line affected.

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

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

       (.,.)s  Repeats  the  last  substitution.   This  form  of the `s' command accepts a count
               suffix `n', and 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  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 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  subsequent  `y',  `s',  `j',  `d',  or `c' commands.  The current
               address is unchanged.

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

       !command
               Executes command via sh(1).  If the first character of command is `!', then it  is
               replaced  by  text  of  the  previous `!command'.  ed does not process command for
               backslash (\) escapes.  However, an unescaped  `%'  is  replaced  by  the  default
               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  character
       preceded by a backslash (\) is interpreted literally.

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

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

DIAGNOSTICS

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

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

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

                                           3 July 2010                                      ED(1)