three cases:



1) To edit files too large for comfortable interactive editing;

2) To edit any size file when the sequence of editing commands is

     too complicated to be comfortably typed in interactive mode.

3) To perform multiple  `global' editing functions efficiently in

     one pass through the input.



     This memorandum constitutes a manual for users of sed.



Introduction



     Sed  is  a non-interactive  context  editor  designed to  be

     especially useful in three cases:



1) To edit files too large for comfortable interactive editing;

2) To edit any size file when the sequence of editing commands is

     too complicated to be comfortably typed in interactive mode;

3) To perform multiple  `global' editing functions efficiently in

     one pass through the input.



     Since only  a few lines of  the input reside in  core at one

     time, and no temporary files are used, the effective size of

     file that can  be edited is limited only  by the requirement

     that the input and  output fit simultaneously into available

     secondary storage.



     Complicated  editing scripts can  be created  separately and

     given to  sed as  a command file.   For complex  edits, this

     saves  considerable typing, and  its attendant  errors.  Sed

     running from a command file  is much more efficient than any

     interactive editor known to  the author, even if that editor

     can be driven by a pre-written script.



     The principal  loss of functions compared  to an interactive

     editor  are  lack of  relative  addressing  (because of  the

     line-at-a-time    operation),   and   lack    of   immediate

     verification that a command has done what was intended.



     Sed is a lineal descendant  of the UNIX editor, ed.  Because

     of the  differences between interactive  and non-interactive

     operation,  considerable changes have  been made  between ed

     and  sed; even  confirmed  users of  ed  will frequently  be

     surprised (and  probably chagrined), if they  rashly use sed

     without reading Sections 2 and 3 of this document.  The most

     striking family  resemblance between  the two editors  is in

     the   class  of   patterns   (`regular  expressions')   they

     recognize; the  code for matching patterns  is copied almost

     verbatim  from  the code  for  ed,  and  the description  of

     regular expressions  in Section 2 is  copied almost verbatim

     from  the  UNIX   Programmer's  Manual[1].  (Both  code  and

     description were written by Dennis M. Ritchie.)



1. Overall Operation



     Sed  by default copies  the standard  input to  the standard

     output, perhaps  performing one or more  editing commands on

     each line  before writing it  to the output.   This behavior

     may be  modified by flags  on the command line;  see Section

     1.1 below.



     The general format of an editing command is:



               [address1,address2][function][arguments]



One or both addresses may  be omitted; the format of addresses is

given in  Section 2.  Any number  of blanks or  tabs may separate

the addresses  from the function.  The function  must be present;

the available commands are discussed in Section 3.  The arguments

may  be required  or  optional, according  to  which function  is

given;  again,  they  are  discussed  in  Section  3  under  each

individual function.



     Tab  characters and  spaces at  the beginning  of  lines are

     ignored.



1.1. Command-line Flags



     Three flags are recognized on the command line:

          -n:

               tells sed  not to copy  all lines, but  only those

               specified  by  p  functions  or p  flags  after  s

               functions (see Section 3.3);

          -e:

               tells sed to take  the next argument as an editing

               command;

          -f:

               tells  sed to  take the  next argument  as  a file

               name;  the file  should contain  editing commands,

               one to a line.



1.2. Order of Application of Editing Commands



     Before any editing  is done (in fact, before  any input file

     is even opened), all  the editing commands are compiled into

     a  form  which  will  be  moderately  efficient  during  the

     execution phase  (when the commands are  actually applied to

     lines of the input file).   The commands are compiled in the

     order in  which they are encountered; this  is generally the

     order  in which they  will be  attempted at  execution time.

     The commands  are applied one at  a time; the  input to each

     command is the output of all preceding commands.



     The default linear order  of application of editing commands

     can be changed by the flow-of-control commands, t and b (see

     Section 3).   Even when the order of  application is changed

     by these commands,  it is still true that  the input line to

     any command is the output of any previously applied command.



1.3.  Pattern-space



     The range  of pattern matches  is called the  pattern space.

     Ordinarily, the pattern space is one line of the input text,

     but more than one line can be read into the pattern space by

     using the N command (Section 3.6.).



1.4. Examples



     Examples  are scattered throughout  the text.   Except where

     otherwise noted, the examples all assume the following input

     text:



          In Xanadu did Kubla Khan

          A stately pleasure dome decree:

          Where Alph, the sacred river, ran

          Through caverns measureless to man

          Down to a sunless sea.



     (In  no  case  is the  output  of  the  sed commands  to  be

     considered an improvement on Coleridge.)



Example:



     The command



     2q



     will quit  after copying the  first two lines of  the input.

     The output will be:



          In Xanadu did Kubla Khan

          A stately pleasure dome decree:



2. ADDRESSES: Selecting lines for editing



     Lines in the input file(s)  to which editing commands are to

     be applied  can be selected by addresses.   Addresses may be

     either line numbers or context addresses.



     The application of a group  of commands can be controlled by

     one address (or address-pair)  by grouping the commands with

     curly braces (`{ }')(Sec. 3.6.).



2.1. Line-number Addresses



     A line  number is a decimal  integer.  As each  line is read

     from  the input,  a  line-number counter  is incremented;  a

     line-number address  matches (selects) the  input line which

     causes   the   internal  counter   to   equal  the   address

     line-number.  The counter runs cumulatively through multiple

     input  files; it  is  not reset  when  a new  input file  is

     opened.



     As a special case, the  character $ matches the last line of

     the last input file.



2.2. Context Addresses



     A  context  address  is  a  pattern  (`regular  expression')

     enclosed   in  slashes   (`/').   The   regular  expressions

     recognized by sed are constructed as follows:



1) An ordinary character (not one  of those discussed below) is a

     regular expression, and matches that character.



2) A  circumflex `^'  at the  beginning of  a  regular expression

     matches the null character at the beginning of a line.

3) A dollar-sign `$'  at the end of a  regular expression matches

     the null character at the end of a line.

4) The characters  `\n' match an imbedded  newline character, but

     not the newline at the end of the pattern space.

5) A period `.' matches any character except the terminal newline

     of the pattern space.

6) A regular  expression followed by an asterisk  `*' matches any

     number   (including  0)  of  adjacent   occurrences   of the

     regular expression it follows.

7) A string  of characters in  square brackets `[ ]'  matches any

     character in the  string,  and no others.  If,  however, the

     first character of the string is circumflex `^', the regular

     expression  matches any character  except the  characters in

     the string and the terminal newline of the pattern space.

8) A concatenation of regular expressions is a regular expression

     which  matches  the  concatenation  of  strings  matched  by

     the components of the regular expression.

9) A regular  expression between the  sequences `\(' and  `\)' is

     identical  in effect to   the unadorned  regular expression,

     but  has  side-effects which   are  described  under  the  s

     command  below and specification 10) immediately below.

10) The  expression  `\d' means  the  same  string of  characters

     matched by  an expression enclosed in `\('  and `\)' earlier

     in the same pattern.  Here  d is  a single digit; the string

     specified is that beginning with the dth  occurrence of `\('

     counting  from  the  left.    For example,   the  expression

     `^\(.*\)\1'  matches   a line  beginning  with two  repeated

     occurrences of the same string.

11) The null  regular expression  standing alone (e.g.,  `//') is

     equivalent to the  last regular expression compiled.



     To use one of the special characters (^  $ . * [ ] \ /) as a

     literal  (to match an  occurrence of  itself in  the input),

     precede the special character by a backslash `\'.



     For a context address to `match' the input requires that the

     whole pattern  within the address match some  portion of the

     pattern space.



2.3. Number of Addresses



     The  commands  in the  next  section can  have  0,  1, or  2

     addresses.  Under each command the maximum number of allowed

     addresses is  given.  For a  command to have  more addresses

     than the maximum allowed is considered an error.



     If a command  has no addresses, it is  applied to every line