🚀 go-pugleaf

G. Ioannou (gi101@cus.cam.ac.uk) wrote:
: In article <DGtuuq.AJ@rci.ripco.com>, Eric Pement <epement@ripco.com> wrote:
: [...]
: >I want to remove a block of 4 contiguous lines which recur at repeated
: >intervals throughout several files.  The first line of each block is
: >always a blank line.  However, the input files also contain groups of 1
: >or more blank lines which should not be deleted.  My problem arises when
: >the block to be deleted is preceded by 1 or more blank lines.  E.g.,
: >
: >  1: aaa aaaa        # (Line numbers added for clarity)
: >  2: bbb bbbb
: >  3:
: >  4:                 # Lines #4-7, inclusive,
: >  5: xxxx            # should be deleted from
: >  6: yyyy            # the input stream.
: >  7: zzzz            #
: >  8: ccc cccc
: >  9: ddd dddd
: >
: [...]
: >Since blank lines can appear anywhere in the input file, there may be
: >two or even 3 blank lines before the deletion block.  I have tried
: >writing other tests for the next two lines after a blank line, but the
: >problem is that SED program logic jumps to the NEXT line read after the
: >last "N" command rather than iterating on each line.

: I think the following sed script should do the trick:

:     :loop
:     $b
:     /^$/{
:         N
:         /\nxxxx$/b success
:         P
:         D
:     }
:     n
:     b loop
:     :success
:     N
:     N
:     d

: This script uses a technique I learned from Dale Dougherty's book,
: `sed & awk', published by O'Reilly and Associates.  He calls this the
: input/output loop, and explains it in the chapter on `Advanced Sed
: Commands'.  The logic behind this is as follows:

: The script is composed of two parts, the i/o loop and the success
: routine.  As long as the current line is not blank, sed simply reaches
: the n command, followed by an unconditional branch to the top of the
: script, and therefore outputs the current line and starts from the
: beginning with the next line.  As soon as a blank line is encountered,
: the i/o loop is entered: the next line is appended to the pattern
: space; if this line does not match xxxx, then the blank line is output
: and then deleted (P then D).  The D command causes sed to start from
: the beginning, USING THE LINE ALREADY IN THE PATTERN SPACE, NOT THE
: NEXT LINE.  This is really the essence of the technique.

: Now if the appended line matches xxxx, a branch is made to the success
: label.  This appends the following two lines (yyyy and zzzz) and then
: deletes the lot, from the blank line to zzzz inclusive.  The next line
: is read in and sed starts from the beginning.

: I have assumed that a blank line followed by xxxx is always a success,
: in other words, that lines yyyy and zzzz always follow xxxx after a
: blank.  If this is not true, then additional checking is needed in the
: success routine.

: I have put a `$b' command right after the :loop label, because
: otherwise the script will not output the last line of input if it is
: blank, presumably because the N command fails?  Anyway, this trick
: seems to correct the problem.

: Hope this helps.
: -George.

It does indeed.  I quoted your ENTIRE message, since I am so impressed with 
your worthwhile and perceptive response.  Actually, I have Dougherty's book, 
"SED & AWK", and had worked my way through pp. 117-119 (the section you 
referred to), but seeing your explanation above in light of my particular 
problem put things in a different, and better, perspective.

Thanks so much.  I suspected that sed should be able to handle a problem of 
this nature, and am glad that my intuitions here were on target.  Now I 
wonder about getting something like minimal range matching...<grin>.  Thanx 
again for your assistance.

Kind regards,

Eric Pement <epement@ripco.com>