sed - Provides a stream line editor

       sed [-n] [-e script ...]  [-f source-file] [file ...]


              sed [-n] [script] [file ...]

              The  sed  command modifies lines from the specified
              file or from standard input according to edit  com-
              mands and writes them to standard output.

       The sed command includes many features for selecting lines
       to be modified and making changes  only  to  the  selected
       lines.

       The  sed command uses two work spaces for holding the line
       being modified:  the pattern  space,  where  the  selected
       line  is  held,  and  the  hold space, where a line can be
       stored temporarily.

       An edit script consists of  individual  subcommands,  each
       one  on  a separate line.  The general form of sed subcom-
       mands is as follows:

            [address_range] function [modifier ...]


       The sed command processes each input file  by  reading  an
       input line into a pattern space, sequentially applying all
       sed subcommands in sequence whose  addresses  select  that
       line,  and  writing  the pattern space to standard output.
       It then clears the pattern space and repeats this  process
       for  each line in the input file.  Some of the subcommands
       use a hold space to save all or part of the pattern  space
       for subsequent retrieval.

       When  a  command includes an address, either a line number
       or a search pattern, only the addressed line or lines  are
       affected  by  the  command.   Otherwise,  the  command  is
       applied to all lines.

   sed Addresses
              An address is either a decimal line  number,  a  $,
              which  addresses  the last line of input, or a con-
              text address.   A  context  address  is  a  regular
              expression  (R.E.)  as  described  for grep, except
              that you can select  the  character  delimiter  for
              patterns.  The general form of the expression is as
              follows:

            \?pattern\?

       The ? represents a character delimiter you  select.   This
       delimiter  cannot be a 2-byte international character sup-
       port extended character.

       The default form for the pattern is as follows:

            /pattern/




         o  In a context address, the construction \cexpressionc,
            where  c  is any character other than a \ (backslash)
            or the newline character, is  identical  to  /expres-
            sion/.  If the character designated by c appears fol-
            lowing a \ (backslash), then it is considered  to  be
            that  literal character, which does not terminate the
            RE.  For example, in the context address \xabc\xdefx,
            the  second  x stands for itself, so that the regular
            expression is abcxdef.

         o  The sequence \n matches a newline  character  in  the
            pattern space, except the terminating new line.

         o  A  . (dot) matches any character except a terminating
            newline character.  That is, unlike grep, which  can-
            not  match  a  newline  character  in the middle of a
            line, sed can match a newline character in  the  pat-
            tern space.


Certain  commands  allow  you  to  specify one line or a range of
lines to which the command applies.  These  commands  are  called
addressed  commands.  The following rules apply to addressed com-
mands:


  o  A command line with no address selects every line.

  o  A command line with one address, expressed in context  form,
     selects each line that matches the address.

  o  A  command  line with two addresses separated by a , (comma)
     or ; (semicolon) selects the entire  range  from  the  first
     line  that  matches  the first address through the next line
     that matches the second.  (If the second address is a number
     less  than  or equal to the line number first selected, only
     one line is selected.)  Thereafter, the process is repeated,
     looking again for the first address.

       -e script
           Uses  the  string script as an editing script.  If you
           are using just one -e flag and no  -f  flag,  you  can
           omit  the -e flag and include the single script on the
           command line as an argument to sed.

       -f source_file
           Uses source_file as the source  of  the  edit  script.
           The  source_file  is  a  set of editing commands to be
           applied to file.

       -n  Suppresses all information normally written  to  stan-
           dard output.


   Subcommands
       Backslashes  in  text  are treated like backslashes in the
       replacement string of an s command and can be used to pro-
       tect initial spaces and tabs against the stripping that is
       done on every script line.

       The text argument accompanying the a\, c\, and i\ commands
       can  continue  onto more than one line, provided all lines
       but the last end with a \ (backslash) to quote the newline
       character.

       The  read_file  and write_file arguments must end the com-
       mand line and must be preceded by exactly one space.  Each
       write_file is created before processing begins.

       The sed command can process up to 99 commands in a file.

       In  the  following list of subcommands, the maximum number
       of permissible addresses for each subcommand is  indicated
       in  parentheses.   The  sed script subcommands are as fol-
       lows:


       (2){subcommand ...

       }   Groups subcommands enclosed in { }  (braces).   The  {
           (left brace) can be preceded by spaces and can be fol-
           lowed by spaces or tabs.  The list of subcommands must
           be  separated  by newline characters.  The subcommands
           can also be preceded by spaces or tabs.  The terminat-
           ing  }  (right  brace)  must  be preceded by a newline
           character and then zero or more spaces.

       (1) a\

       text
           Places text on the  output  before  reading  the  next
           input line.

       (2)b[label]
           Branches to the : command bearing the label.  If label
           is empty, it branches to the end of the script.

       (2)c\

       text
           Deletes the pattern space.  With a 0 or 1  address  or
           at  the  end  of a 2-address range, places text on the
           output.  Then it starts the next cycle.

       (2)d
           Deletes the pattern space.  Then it  starts  the  next
           cycle.

       (2)D
           Deletes  the  initial  segment  of  the  pattern space
           through the first newline character.  Then  it  starts
           the next cycle.

       (2)g
           Replaces  the  contents  of the pattern space with the
           contents of the hold space.

       (2)G
           Appends the contents of the hold space to the  pattern
           space.

       (2)h
           Replaces  the contents of the hold space with the con-
           tents of the pattern space.

       (2)H
           Appends the contents of the pattern space to the  hold
           space.

       (1)i\

       text
           Writes text to standard output before reading the next
           line into the pattern space.

       (2)l
           Writes the pattern space to standard  output,  showing
           nonprinting  characters as 3-digit octal values.  Long
           lines are folded, with the point of folding  indicated
           by  <Backslash><Return>.   The  end  of  each  line is
           marked with a $.

           Certain characters are shown as  escape  sequences  as
           follows:


           \\  Backslash

           \a  Alert
           \b  Backspace

           \f  Formfeed

           \n  Newline

           \r  Carriage-return

           \t  Tab

           \v  Vertical tab


       (2)n
           Writes  the  pattern  space  to  standard  output.  It
           replaces the pattern  space  with  the  next  line  of
           input.

       (2)N
           Appends  the  next  line of input to the pattern space
           with an embedded newline character.  (The current line
           number  changes.)  You can use this to search for pat-
           terns that are split onto two lines.

       (2)p
           Writes the pattern space to standard output.

       (2)P
           Writes  the  initial  segment  of  the  pattern  space
           through  the  first newline character to standard out-
           put.

       (1)q
           Branches to the end of the script.  It does not  start
           a new cycle.

       (1)r read_file
           Reads  the  contents of read_file.  It places contents
           on the output before reading the next input line.

       (2)s/pattern/replacement/flags
           Substitutes  the  replacement  string  for  the  first
           occurrence  of  the pattern in the pattern space.  Any
           character that is entered after the s command can sub-
           stitute  for  the / (slash) separator, except \ (back-
           slash) and the newline character.  Within the  regular
           expression  and  replacement string, the delimiter can
           appear as a literal if it is preceded by  a  \  (back-
           slash).

           An  &  (ampersand) appearing in the replacement string
           is replaced by the string matching the RE.   The  spe-
           cial meaning of & in this context can be suppressed by
           preceding it with a \ (backslash).  The characters \n,
           where  n  is a digit, are replaced by the text matched
           by the corresponding backreference expression.

           A line can be split by substituting a newline  charac-
           ter into it.  You must escape the newline character in
           the replacement string by preceding it with a \  back-
           slash.  A substitution is considered to have been per-
           formed even if the replacement string is identical  to
           the string that it replaces.

           You can add zero or more of the following flags:


           n   Where  n is 1-512, substitutes replacement for the
               nth occurrence of pattern on each addressed  line,
               rather than for the first occurrence.

           g   Substitutes  replacement  for  all  nonoverlapping
               instances  of  pattern  on  each  addressed  line,
               rather than for just the first one (or for the one
               specified by n).

           p   Writes the pattern space to standard output  if  a
               replacement was made.

           w write_file
               Writes  the  pattern  space  to  write_file  if  a
               replacement was made.  Appends the  pattern  space
               to write_file.  If write_file was not already cre-
               ated by a previous write by this sed  script,  sed
               creates  it.   Each  write_file  is created before
               processing begins.


       (2)t[label]
           Branches to :label in the script file if any substitu-
           tions  were  made  since the most recent reading of an
           input line execution of a t subcommand.  If you do not
           specify  label,  control  transfers  to the end of the
           script.

       (2)w write_file
           Appends the pattern space to write_file.

       (2)x
           Exchanges the contents of the pattern  space  and  the
           hold space.

       (2)y/pattern1/pattern2/
           Replaces  all  occurrences  of  characters in pattern1
           with the corresponding characters from pattern2.   The
           byte lengths of pattern1 and pattern2 must be equal.


       (2)!sed_command
           Applies the specified sed subcommand only to lines not
           selected by the address or addresses.

       (0):label
           This script entry simply marks a branch  point  to  be
           referenced by the b and t commands.  This label can be
           any sequence of eight or fewer bytes.

       (1)=
           Writes the current line number to standard output as a
           line.

       (2){subcommand ...

       }   Groups subcommands enclosed in { } (braces).

       (0) Ignores an empty command.

       (0)#
           If a # (number sign) appears as the first character on
           the first line of a script file, that entire  line  is
           treated  as  a  comment,  with  one exception.  If the
           character after the # is an n, the default  output  is
           suppressed.   The  rest  of  the  line after the #n is
           ignored.  A script must contain at least  one  noncom-
           ment line.

       The h subcommand for sed does not work properly.  When you
       use the h subcommand to place text  into  the  hold  area,
       only  the  last  line of the specified text is saved.  You
       can use the H subcommand to append text to the hold  area.
       The H subcommand and all others dealing with the hold area
       work correctly.

        1.  To perform a global change, enter:

            sed  "s/happy/enchanted/g"  chap1  >chap1.new



              This replaces each occurrence of happy found in the
              file chap1 with enchanted, and puts the edited ver-
              sion in a separate file named chap1.new.  The g  at
              the  end  of  the s subcommand tells sed to make as
              many substitutions as possible on each line.  With-
              out  the  g, sed replaces only the first happy on a
              line.

              The sed stream editor operates  as  a  filter.   It
              reads  text  from  standard input or from the files
              named on the command line (chap1 in this  example),
              modifies  this text, and writes it to standard out-
              put.  Unlike most editors, it does not replace  the
              original  file.   This makes sed a powerful command
              when used in pipelines.

        2.  To use sed as a  filter  in  a  pipeline  (sh  only),
            enter:

            pr  chap2 | sed  "s/Page  *[0-9]*$/(&)/" | print



              This  encloses  the  page  numbers  in  parentheses
              before printing chap2.  The pr command puts a head-
              ing  and  page number at the top of each page, then
              sed puts the page numbers in parentheses,  and  the
              print command prints the edited listing.

              The  sed  pattern /Page *[0-9]*$/ matches page num-
              bers that appear at the end of a line.  The s  sub-
              command changes this to (&), where the & stands for
              the pattern that was  matched  (for  example,  Page
              5).

        3.  To display selected lines of a file, enter:

            sed  -n  "/food/p" chap3



              This  displays each line in chap3 that contains the
              word food.  Normally,  sed  copies  every  line  to
              standard  output  after  it is edited.  The -n flag
              stops sed from doing this.  You  then  use  subcom-
              mands  like  p to write specific parts of the text.
              Without the -n, this example displays all the lines
              in  chap3,  and  it shows each line containing food
              twice.

        4.  To perform complex editing, enter:

            sed  -f  script.sed  chap4  >chap4.new



              It is always a good idea to  create  a  sed  script
              file when you want to do anything complex.  You can
              then test and modify your script before  using  it.
              You can also reuse your script to edit other files.
              Create the script file  with  an  interactive  text
              editor.

        5.  A sample sed script follows:
            :join
            /\\$/{N
            s/\\\n//
            b join
            }



              This  sed script joins each line that ends with a \
              (backslash) to the line that  follows  it.   First,
              the pattern /\\$/ selects a line that ends with a \
              for the group of commands enclosed in { }.   The  N
              subcommand  then appends the next line, embedding a
              newline character.   The  s/\\\n//  deletes  the  \
              (backslash)   and   embedded   newline   character.
              Finally, b join branches back to the label :join to
              check  for  a \ (backslash) at the end of the newly
              joined line.  Without the branch,  sed  writes  the
              joined  line and reads the next one before checking
              for a second \ character.

              The N subcommand causes sed to stop immediately  if
              there  are  no  more  lines of input (that is, if N
              reads the End-of-File character).  It does not copy
              the  pattern  space to standard output before stop-
              ping.  This means that if  the  last  line  of  the
              input  ends with a \ (backslash) character, then it
              is not copied to the output.

       Commands:        awk(1),        grep(1)/egrep(1)/fgrep(1),
       vi(1)/vedit(1)/view(1).

       Programming Support Tools delim off