while (<DATA>) {
  print if /red line/..././;
}
__DATA__
A red line is found 
at location 2.5 4.5 
A Blue line is found 
at location 2.6 4.5 
A red line is found 
at location 2.67 4.56 
The red arc is found 
at location 2.5 4.5
[download]

  print if (/red line/..././) =~ /E/;
[download]

In these situations, I come up with a way to read one "record" at a time. You can do several things to get back all of the information for one record with one operation.

For instance, write a function to read two lines at once (adding appropriate checks I don't cover here).

while( defined( my $record = get_record( $fh ) )
    {
    # ...
    }

sub get_record
    {
    my $fh = shift;

    join '', scalar <$fh>, scalar <$fh>;
    }
[download]

Sometimes preprocessing the data works better. You take your data file and join the appropriate lines. It's even better if you can track down the guy who can change the output at the source. :) Once it's all on one line, life is easy.

A red line is found at location 2.5 4.5
[download]

I've also found alternate delimiters useful. If you have to have a newline between the two interesting lines, maybe you can have a form feed (or something else) as the separator between records. Then you can set $/ to the record separator and read records instead of lines.

A little database is a little more fancy than that, and more useful if you have to use the same data file over and over. Process the file once and store it in something such as a DBM::Deep file. Now lookups are as easy as using a hash, and you only have to process the file once.

my ($x,$y,$redline);
while (<FILE>) {
   if ($redline) {
      ($x,$y) = /at location (\S+) (\S+)/;
      print "$x $y\n";
   }
   $redline = /red line/;
}
[download]

Vary the details as needed. $redline is set to a true value when ever the pattern matches (and a false value when it doesn't match) so that on the next iteration of the loop, you'll be able to capture the location information.

open(FH,"file");

while( <FH> ) {
    if (/red line/) {
       process(<FH>);
    }
}
[download]

Not the most elegant or efficient but it does work.

while( <FH> ) {
    if (/red line/) {
       process(<FH>);
    }
}
[download]

This doesn't work as required. Replace

    process(<FH>);

with

    process(scalar <FH>);

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper::Simple;

read DATA, my $text, 163; #<- manually grabbed size of DATA just for t
+his example

my @matches = ($text =~ /red line.*?location\s+(\d+\.\d+\s+\d+\.\d+)/s
+g);
print Dumper(@matches);

__DATA__
A red line is found
at location 2.5 4.5
A Blue line is found
at location 2.6 4.5
A red line is found
at location 2.67 4.56
The red arc is found
at location 2.5 4.5
[download]

Replace 163 with -s DATA.

If I'm working with a regular filehandle, I always use -s to get the length to read, but unfortunately that doesn't work here. -s DATA will give you the length of the entire file, Perl code included, not just the part after __DATA__.

Update: With that stated, I do realize it wouldn't hurt anything to supply a bigger number than required as the third argument to read.

while(<FILE>){
  next unless /^(?:A|The) (.*) is found$/;
  my $item = $1;
  my $next_line = <FILE>;
  next unless $next_line =~ /^at location (.*)/;
  my $location = $1;   # needs chomp'ing??
  printf "'%s' is as [%s]\n", $item, $location;   # or shove into some
+ data structure
}
[download]

my $i = 0;
while (<FILE>) {
  next if ++$i % 2;
  print;
}
[download]

while (<FILE>) {
  next if $. % 2;
  print;
}
[download]

my $toggle = 0;
while (<FILE>) {
   next if $toggle ^= 1;
   print;
}
[download]

By the way,
 #!usr/bin/perl
is wrong. You must remove the leading space, and you must make the path absolute (or else it will only work form the root):
#!/usr/bin/perl

Update: I didn't read your post close enough. The above didn't answer your question. A solution would be:

for (;;) {
   last if not defined (my $line1 = <FILE>);
   last if not defined (my $line2 = <FILE>);

   next if not $line1 =~ /red line/;

   print($line1, $line2);
}
[download]

There is more than one way to determine what constitutes a line:

use strict;
use warnings;

local $/ = "A red line is found\n";

while (<DATA>) {
  print "Red line $1" if /(at location[^\n]*\n)/;
}

__DATA__
A red line is found
at location 2.5 4.5
A Blue line is found
at location 2.6 4.5
A red line is found
at location 2.67 4.56
The red arc is found
at location 2.5 4.5
[download]

Prints:

Red line at location 2.5 4.5
Red line at location 2.67 4.56
[download]

Read two lines at a time and concatenate them. Use /s on the regex to allow '.' to match the newline.

#! perl -slw
use strict;

m[red line.*location (\S+) (\S+)\n]s and print "($1, $2)" 
    while $_ = <DATA> . <DATA>;

__DATA__
A red line is found
at location 2.5 4.5
A Blue line is found
at location 2.6 4.5
A red line is found
at location 2.67 4.56
The red arc is found
at location 2.5 4.5
[download]

Thanks to ALL of those that replied, these insights were exactly what I needed to get the information I wanted. RCP