Why does this have to be done in a single pass? Reading a file backwards is sufficiently awkward that it pays to use a module such as File::ReadBackwards to handle the ugly work for you. I would probably do it something like this:

use strict;
use warnings;
use File::ReadBackwards;

open my $forward, '<', 'filename.txt' or die $!;
while( my $line = <$forward> ) {
    last if $line eq "\n";
}
my $blank_position = tell( $forward );
close $forward;
my $bw = File::ReadBackwards->new( 'filename.txt' ) 
    or die "can't read 'filename.txt' $!" ;

while( defined( my $bw_line = $bw->readline ) ) {
    last if $bw->tell() <= $blank_position;
    print $bw_line;
}
[download]

This is untested, but should give you the general framework.

The thing about File::ReadBackwards is that it kinda assumes you are reading a log file or other text-oriented data, sorted into records by line, and that you want to read them in backwards order but not actually reverse the lines themselves (not an unreasonable assumption, but I didn't assume it myself.)

My interpretation of the question was that the data itself should be reversed from the blank line on.. so my code below gives that, while Dave's contribution above gives.. the first thing I said.

-d

A file handle only remembers one current position. If you want to deal with two then you'll need to store that information yourself. I suggest two variables to store the current forward and backward positions. tell will get you the data to store in those variables and seek will let you move between the two positions.

open FILE, "path/to/file";
local $/ = "\n\n";
my $first_part = <FILE>;
[download]

open FILE, "path/to/file";
local $/ = undef;
my $whole_file = <FILE>;

my $first_blank_pos = index($whole_file,"\n\n")
die "no blank lines" 
  unless ($first_blank >= 0)

my $first_part = 
  substr $whole_file, 0, $first_blank_pos;

my $second_part = 
  reverse substr $whole_file, $first_blank_pos;
[download]

This was originally a correction note, then I realized that I could just edit the original post to be correct, so I did. I don't see a way to delete this post entirely (short of marking it for consideration, which would be making my mistake into more people's problems), so here's what it was.

---- original content ---

oops,

die "no blank lines" 
  unless ($first_blank > 0)
[download]

should have been:

die "no blank lines" 
  unless ($first_blank >= 0)
[download]

This is a great example of "incomplete specifications."

1. Is the file only "text" file?
2. Are there more blank lines after the "first" blank line?
3. Is the file small enough that available memory is not going to be an issue?

Assuming "yes" to all three #1 and #3, and "no" to #2 of the above questions, reading the entire file in an array and then reversing the array, and reading it till one reaches the blank line would accomplish the job in a "single pass."

# from the venerable cookbook, recipe 8.4
@lines = reverse <FILE>;
foreach $line (@lines) {
    # do something with $line
    # until blank line, which happens to be 
    # the first blank line from top
}
[download]

Sorry, that was with record oriented files. Now days most file systems are continuous streams of characters, and the record boundaries are defined by context. The normal operation to read from a file does so in the forward direction and advances the pointer by that same amount. This is the problem. if you desire to read a file in the reverse direction, you must do so with forward semanticts[sp?]. This means you must "backup" a record, read the record just backed over, then "backup" again. It isn't easy, but it can be done. Others have indicated there is a Perl module to help you in this, and if done correctly ("tie" to a file handle comes to mind) it might even seem like a normal operation.

That being said, reading in the reverse direction isn't commonly done, as there are usually better ways to do the same thing. Reading the records into a hash, and operating on them that way is probably a "better idea". Also consider the original dataset. It might be better formatted at the source to eliminate the need to do the fancy dance with the data. A good look at "why" you need to access the data in this manner might pay off better in the long run.

Good luck!

Reading the records into a hash, and operating on them that way is probably a "better idea".

Don't you mean "Reading the records into an array..."? I assume the questioner needs to preserve the order of the records (if only so they can be accurately reversed) and hashes generally destroy that order.

A good look at "why" you need to access the data in this manner might pay off better in the long run.

Indeed!

open($handle, 'test.dat');
while (<$handle>) {
    chomp; last if !$_;
}
chomp(@data = <$handle>);
close($handle);

for (reverse @data) {
    print $_, "\n";
}
[download]

open($handle, 'test.dat');
while (<$handle>) {
    chomp; last if !$_;
}
while (<$handle>) {
    chomp; push @data, $_;
}
close($handle);
for ($i = $#data; $i > -1; $i--) {
    print $data[$i], "\n";
}
[download]