Rats, forgot to attach the man pages.

On Wed, 25 Dec 2002, Tim Rice wrote:

> On Wed, 25 Dec 2002, Richard Levitte - VMS Whacker wrote:
> 
> > In message <[EMAIL PROTECTED]> on 
>Tue, 24 Dec 2002 16:21:32 -0800 (PST), Tim Rice <[EMAIL PROTECTED]> said:
> > 
> > tim> > sed -e 's/ \?\([\.,@]\)  */\1/g' -e 's/  *:/:/g' -e 's/#.*//'
> > tim> 
> > tim> It doesn't work with the sed on UnixWare or sed on SCO OpenServer.
> > tim> The 's/#.*//' rule works.
> > tim> It seems to do the right thing with GNU sed.
> > 
> > Do you have the possibility to either figure out a sed expression that
> > works with the SCO and UnixWare seds, or send me the man pages for sed
> > on each of those systems?
> 
> I'll try and work on it between getting a server ready to install on monday.
> I've attached a couple of sed man pages. (in case you figure it out first)
> 
> > 
> > As far as I understand, we need the filtering I picture above.  Do you
> > understand what it does?
> 
> I'll need some words explaining what the first section should do.
> 
> 
> 

-- 
Tim Rice                                Multitalents    (707) 887-1469
[EMAIL PROTECTED]


 sed(C)                        06 January 1993                         sed(C)

 Name

    sed - invoke the stream editor

 Syntax

    sed [ -n ] [ -e script ] [ -f sfile ] [ files ]

 Description

    The sed command copies the named files (standard input default) to the
    standard output, edited according to a script of commands.  The -e option
    causes the script to be read literally from the next argument, which is
    usually quoted to protect it from the shell.  The -f option causes the
    script to be taken from file sfile; these options accumulate. If there is
    just one -e option and no -f options, the flag -e may be omitted. The -n
    option suppresses the default output.  A script consists of editing com-
    mands, one per line, of the following form:

       [ address [ , address ] ] function [ arguments ]

    In normal operation, sed cyclically copies a line of input into a pattern
    space (unless there is something left after a D command), applies in
    sequence all commands whose addresses select that pattern space, and at
    the end of the script copies the pattern space to the standard output
    (except under -n) and deletes the pattern space.

    A semicolon (;) can be used as a command delimiter.

    Some of the commands use a hold space to save all or part of the pattern
    space for subsequent retrieval.

    An address is either a decimal number that counts input lines cumula-
    tively across files, a ``$'' that addresses the last line of input, or a
    context address, that is, a /regular expression/ in the style of ed(C)
    modified as follows:

    +  In a context address, the construction \?regular expression?, where
       ``?'' is any character, is identical to /regular expression/.  Note
       that in the context address \xabc\xdefx, the second x stands for
       itself, so that the standard expression is abcxdef.

    +  The escape sequence \n matches a newline embedded in the pattern
       space.

    +  A dot (.) matches any character except the terminal newline of the
       pattern space.

    +  A command line with no addresses selects every pattern space.

    +  A command line with one address selects each pattern space that
       matches the address.

    +  A command line with two addresses separated by a comma selects the
       inclusive range from the first pattern space that matches the first
       address through the next pattern space 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.

    Editing commands can be applied only to nonselected pattern spaces by use
    of the negation function ``!'' (below).

    In the following list of functions, the maximum number of permissible
    addresses for each function is indicated in parentheses.

    The text argument consists of one or more lines, all but the last of
    which end with backslashes to hide the newlines.  Backslashes in text are
    treated like backslashes in the replacement string of an s command, and
    may be used to protect initial blanks and tabs against the stripping that
    is done on every script line.  The rfile or wfile argument must terminate
    the command line and must be preceded by one blank. Each wfile is created
    before processing begins. There can be at most 10 distinct wfile argu-
    ments.

    (1) a\ text
              Appends text, placing it on the output before reading the next
              input line.

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

    (2) c\ text
              Changes text by deleting the pattern space and then appending
              text.  With 0 or 1 address or at the end of a 2-address range,
              places text on the output and starts the next cycle.

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

    (2) D     Deletes the initial segment of the pattern space through the
              first newline and 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 contents of
              the pattern space.

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

    (1) i\ text
              Insert.  Places text on the standard output.

    (2) l     Lists the pattern space on the standard output with nonprinting
              characters spelled in two-digit ASCII and long lines folded.

    (2) n     Copies the pattern space to the standard output.  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.  (The current line number changes.)

    (2) p     Prints (copies) the pattern space on the standard output.

    (2) P     Prints (copies) the initial segment of the pattern space
              through the first newline to the standard output.

    (1) q     Quits sed by branching to the end of the script.  No new cycle
              is started.

    (2) r rfile
              Reads the contents of rfile and places them on the output
              before reading the next input line.

    (2) s /regular expression/replacement/flags
              Substitutes the replacement string for instances of the regular
              expression in the pattern space.  Any character may be used
              instead of ``/''.  For a more detailed description, see ed(C).
              Flags is zero or more of:

              n    n=1-512.  Substitute for just the nth occurrence of the
                   regular expression.

              g    Globally substitutes for all non-overlapping instances of
                   the regular expression rather than just the first one.

              p    Prints the pattern space if a replacement was made.

              w wfile
                   Writes the pattern space to wfile if a replacement was
                   made.

    (2) t label
              Branches to the colon (:) command bearing label if any substi-
              tutions have been made since the most recent reading of an
              input line or execution of a t command.  If label is empty, t
              branches to the end of the script.

    (2) w wfile
              Writes the pattern space to wfile.

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

    (2) y /string1/string2/
              Replaces all occurrences of characters in string1 with the cor-
              responding characters in string2.  The lengths of string1 and
              string2 must be equal.

    (2) ! function
              Applies the function (or group, if function is ``{'') only to
              lines NOT selected by the address(es).

    (0) : label
              This command does nothing; it bears a label for b and t com-
              mands to branch to.

    (1) =     Places the current line number on the standard output as a
              line.

    (2) {     Executes the following commands through a matching ``}'' only
              when the pattern space is selected.
    (0)       An empty command is ignored.

 Examples

    The following examples assume the use of sh or ksh.

    The most common use of sed is to edit a file from within a shell script.
    In this example, every occurrence of the string ``sysman'' in the file
    infile is replaced by ``System Manager''. A temporary file TMP is used to
    hold the intermediate result of the edit:

       TMP=/usr/tmp/tmpfile_$$
       sed  -e  's/sysman/System Manager/g'  <  infile  >  $TMP
       mv  $TMP  infile

    sed can be used to strip all lines from a file which do not contain a
    certain string. In this example, all lines in the file infile which start
    with a hash ``#'' are echoed to the screen:

       sed -e '/^#/!d' < infile

    If several editing commands must be carried out on a file, but the param-
    eters for the edit are to be supplied by the user, then a document can be
    used to build a temporary edit script for sed to use. The following exam-
    ple removes all occurrences of the strings given as arguments to the
    script from the file infile. The name of the temporary script is held by
    the variable SCRIPT:

       SCRIPT=/usr/tmp/script_$$
       for name in $*
       do
               cat >> $SCRIPT <<!
                       s/${name}//g
               !
       done
       TMPFILE=/usr/tmp/tmpfile_$$
       sed  -f  $SCRIPT  <  infile  >  $TMPFILE
       mv  $TMPFILE  infile
       rm  $SCRIPT

    Another use of sed is to process the output from other commands. Here the
    ps command is filtered using sed to report the status of all processes
    other than those owned by the super user:

       ps -ef | sed -e '/^[<Space><Tab>]*root/d'

 See also

    awk(C), ed(C) and grep(C).

 Notes

    This command is explained in detail in the User's Guide.

 Standards conformance

    sed is conformant with:

    AT&T SVID Issue 2;
    and X/Open Portability Guide, Issue 3, 1989.

See also regexp(S)





       sed(1)                                                        sed(1)


       NAME
             sed - stream editor

       SYNOPSIS
             sed [-n] [-e script] [-f sfile] [file . . .]

       DESCRIPTION
             sed copies the named file (standard input default) to the
             standard output, edited according to a script of commands.
             The -f option causes the script to be taken from file sfile;
             these options accumulate.  If there is just one -e option and
             no -f options, the flag -e may be omitted.  The -n option
             suppresses the default output.

             sed processes supplementary code set characters, and
             recognizes supplementary code set characters in script file
             comments (see below) according to the locale specified in the
             LC_CTYPE environment variable [see LANG on environ(5)], except
             as noted under the y command below.  In regular expressions,
             pattern searches are performed on characters, not bytes, as
             described on ed(1).

             A script consists of editing commands, one per line, of the
             following form:

                   [address [, address]] function [arguments]

             In normal operation, sed cyclically copies a line of input
             into a pattern space (unless there is something left after a D
             command), applies in sequence all commands whose addresses
             select that pattern space, and at the end of the script copies
             the pattern space to the standard output (except under -n) and
             deletes the pattern space.

             Some of the commands use a hold space to save all or part of
             the pattern space for subsequent retrieval.

             An address is either a decimal number that counts input lines
             cumulatively across files, a $ that addresses the last line of
             input, or a context address, that is, a /regular expression/
             in the style of ed(1) modified thus:

                   In a context address, the construction \?regular
                   expression?, where ?  is any character, is identical to
                   /regular expression/.  Note that in the context address
                   \xabc\xdefx, the second x stands for itself, so that the


                           Copyright 1996 Novell, Inc.               Page 1














      sed(1)                                                        sed(1)


                  regular expression is abcxdef.

                  The escape sequence \n matches a new-line embedded in
                  the pattern space.

                  A period (.)  matches any character except the terminal
                  new-line of the pattern space.

                  A command line with no addresses selects every pattern
                  space.

                  A command line with one address selects each pattern
                  space that matches the address.

                  A command line with two addresses selects the inclusive
                  range from the first pattern space that matches the
                  first address through the next pattern space that
                  matches the second address.  (If the second address is a
                  number less than or equal to the line number selected by
                  the first address, only the line corresponding to the
                  first address is selected.)  Thereafter the process is
                  repeated, looking again for the first address.

            Editing commands can be applied only to non-selected pattern
            spaces by use of the negation function !  (below).

            In the following list of functions the maximum number of
            permissible addresses for each function is indicated in
            parentheses.

            The text argument consists of one or more lines, all but the
            last of which end with \ to hide the new-line.  Backslashes in
            text are treated like backslashes in the replacement string of
            an s command.  The rfile or wfile argument must terminate the
            command line and must be preceded by exactly one blank.  Each
            wfile is created before processing begins.  There can be at
            most 10 distinct wfile arguments.

            (1)a\
            text      Append.  Place text on the output before reading the
                      next input line.

            (2)b label
                      Branch to the : command bearing the label.  If label
                      is empty, branch to the end of the script.



                          Copyright 1996 Novell, Inc.               Page 2














       sed(1)                                                        sed(1)


             (2)c\
             text      Change.  Delete the pattern space.  Place text on
                       the output.  Start the next cycle.

             (2)d      Delete the pattern space.  Start the next cycle.

             (2)D      Delete the initial segment of the pattern space
                       through the first new-line.  Start the next cycle.

             (0)E      Delete the contents of the hold space.

             (2)g      Replace the contents of the pattern space by the
                       contents of the hold space.

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

             (2)h      Replace the contents of the hold space by the
                       contents of the pattern space.

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

             (1)i\
             text      Insert.  Place text on the standard output.

             (2)l      List the pattern space on the standard output in an
                       unambiguous form.  Non-printable characters are
                       displayed in octal notation and long lines are
                       folded.

             (2)n      Copy the pattern space to the standard output.
                       Replace the pattern space with the next line of
                       input.

             (2)N      Append the next line of input to the pattern space
                       with an embedded new-line.  (The current line number
                       changes.)

             (2)p      Print.  Copy the pattern space to the standard
                       output.

             (2)P      Copy the initial segment of the pattern space
                       through the first new-line to the standard output.




                           Copyright 1996 Novell, Inc.               Page 3














      sed(1)                                                        sed(1)


            (1)q      Quit.  Branch to the end of the script.  Do not
                      start a new cycle.

            (2)r rfile
                      Read the contents of rfile.  Place them on the
                      output before reading the next input line.

            (2)s/regular expression/replacement/flags
                      Substitute the replacement string for instances of
                      the regular expression in the pattern space.  Any
                      character may be used instead of /.  For a fuller
                      description see ed(1).  flags is zero or more of:

                      n       n= 1 - 512.  Substitute for just the nth
                              occurrence of the regular expression.

                      g       Global.  Substitute for all nonoverlapping
                              instances of the regular expression rather
                              than just the first one.

                      p       Print the pattern space if a replacement was
                              made.

                      w wfile Write.  Append the pattern space to wfile if
                              a replacement was made.

            (2)t label
                      Test.  Branch to the : command bearing the label if
                      any substitutions have been made since the most
                      recent reading of an input line or execution of a t.
                      If label is empty, branch to the end of the script.

            (2)w wfile
                      Write.  Append the pattern space to wfile.  The
                      first occurrence of w will cause wfile to be
                      cleared.  Subsequent invocations of w will append.
                      Each time the sed command is used, wfile is
                      overwritten.

            (2)x      Exchange the contents of the pattern and hold
                      spaces.

            (2)y/string1/string2/
                      Transform.  Replace all occurrences of characters in
                      string1 with the corresponding characters in
                      string2.  string1 and string2 must have the same


                          Copyright 1996 Novell, Inc.               Page 4














       sed(1)                                                        sed(1)


                       number of characters.  The result is not guaranteed
                       when supplementary code set characters are specified
                       in the strings.

             (2)! function
                       Don't.  Apply the function (or group, if function is
                       {) only to lines not selected by the address(es).

             (0): label
                       This command does nothing; it bears a label for b
                       and t commands to branch to.

             (1)=      Place the current line number on the standard output
                       as a line.

             (2){      Execute the following commands through a matching }
                       only when the pattern space is selected.

             (0)       An empty command is ignored.

             (0)#      If a # appears as the first character on a line of a
                       script file, then that entire line is treated as a
                       comment, with one exception: if a # appears on the
                       first line and the character after the # is an n,
                       then the default output will be suppressed.  The
                       rest of the line after #n is also ignored.  A script
                       file must contain at least one non-comment line.
                       Comments may contain supplementary code set
                       characters.

       FILES
             /usr/lib/locale/locale/LC_MESSAGES/uxcore.abi
                   language-specific message file [See LANG on environ(5).]

       REFERENCES
             awk(1), ed(1), grep(1)












                           Copyright 1996 Novell, Inc.               Page 5








Reply via email to