Extract lines between two patterns and include line above first and second

As you asked for a solution sed

/ awk

(and everyone is scared ed

;-), here's one way to do it in awk:

awk '/FIRST/{print p; f=1} {p=$0} /SECOND/{c=1} f; c--==0{f=0}' file

      

        
        
        
      

    

If the first pattern matches, print the previous line p

and set the print flag f

. When the second pattern matches, set c

to 1. If f

equal to 1 (true), the current line will be printed. c--==0

matches only the string after matching the second pattern.

Another way you can do this is by double clicking the file:

awk 'NR==FNR{if(/FIRST/)s=NR;else if(/SECOND/)e=NR;next}FNR>=s-1&&FNR<=e+1' file file

      

        
        
        
      

    

The first pass through the file goes through the file and records the line numbers. The second one prints lines in a range.

The advantage of the second approach is that it is trilinearly easy to print M lines before and N lines after the range by simply changing the numbers in the script.

To use shell variables instead of hard-coded patterns, you can pass variables like this:

awk -v first="$first" -v second="$second" '...' file

      

        
        
        
      

    

Then use $0 ~ first

instead /FIRST/

.

sed '#n
   H;$!d
   x;s/\n/²/g
   /FIRST.*SECOND/!b
   s/.*²\([^²]*²[^²]*FIRST\)/\1/
:a
   s/\(FIRST.*SECOND[^²]*²[^²]*\)².\{1,\}/\1/
   ta
   s/²/\
/g
   p' YourFile

      

        
        
        
      

    

• POSIX sed version (using GNU sed --posix
  
  )
• take the following SECOND pattern, also if on the same line it is easy to adapt to take at least one new line in between
  • #n
    
    : do not print if request is expres (for example p
    
    )
  • H;$!d
    
    : add each line to the buffer, if not the last line, remove the current line and loop
  • x;s/\n/²/g
    
    : load a buffer and replace any newline with another character (I'm using here ²
    
    ) because posix sed doesn't allow[^\n]
    
    
  • /FIRST.*SECOND/!b
    
    : if no template is present, exit without output
  • s/.*²\([^²]*²[^²]*FIRST\)/\1/
    
    : remove everything before the line before the first pattern
  • :a
    
    : label for goto (used later)
  • s/\(FIRST.*SECOND[^²]*²[^²]*\)².\{1,\}/\1/
    
    : remove everything after the line after the second pattern. It accepts the largest string, so the last occurrence of the template is a link
  • ta
    
    : if the latter s///
    
    happens, you get a label a
    
    . This is cyle until the first SECOND pattern appears in the file (after FIRST)
  • s/²/\ /g
    
    : return new lines
  • p
    
    : print the result

based on Tom's comment: if the file is small, we can just store it in an array and then loop over it:

awk '{a[++i]=$0} /FIRST/{s=NR} /SECOND/{e=NR} END {for(i=s-1;i<e+1;i++) print a[i]}'

      

        
        
        
      

    

I would do it with Perl personally. We have a "range operator" that we can use to detect if we are between two patterns:

if ( m/FIRST/ .. /SECOND/ ) 

      

        
        
        
      

    

This is the easy part. What's a little less simple is to "catch" the previous and next lines. So I am setting the value $prev_line

, so when I first got into this test, I know what to print. And I clear this $prev_line

because then it is empty when I type it again, but also because then I can detect a transition at the end of the range.

So something like this:

#!/usr/bin/perl

use strict;
use warnings;

my $prev_line = " ";
while (<DATA>) {
    if ( m/FIRST/ .. /SECOND/ ) {
        print $prev_line;
        $prev_line = '';
        print;
    }
    else {
        if ( not $prev_line ) {
            print;
        }
        $prev_line = $_;
    }
}

__DATA__ 
asdgs sdagasdg sdagdsag
asdfgsdagg gsfagsaf 
asdfsdaf dsafsdfdsfas
asdfdasfadf
nnnn nnnnn aaaaa
line before first pattern
***** FIRST *****
dddd ffff cccc
wwww rrrrrrrr xxxx
***** SECOND *****
line after second pattern
asdfgsdagg gsfagsaf 
asdfsdaf dsafsdfdsfas
asdfdasfadf
nnnn nnnnn aaaaa