I've used the practice you outline to process human-list-reports into nice, machine-treatable reports to great success, except without the slurping part:

package Parser::ReportFoo;
use strict;

sub new {
    ...
    $self->columns = [qw(date customer amount)];
};

my @handlers = [
    # Line containing uninteresting information
    [qr/^Line containing uninteresting information/ => \&discard],
    [qr/^------------/ => \&discard],
    [qr/^(\d\d-[A-Z]{3}-\d\d)     (..........) (\d+\.\d+)/ => \&captur
+e_transaction],
    [qr/^\s*$/ => \&flush ],
    [qr/^         )     (..........)\s+$/ => \&capture_name2],
];

sub discard {};

sub flush {
    my ($self) = @_;
    my @row = map { $self->$_ } (@{ $self->columns });
    print join "\t", @row;
};

sub capture_transaction {
    my ($self,$date,$customer,$amount) = @_;
    $self->date($date);
    $self->customer($customer);
    $self->amount($amount);
};

sub capture_name2 {
    my ($self,$customer) = @_;
    $self->customer($self->customer . " " . $customer);
    $self->flush();
};

sub parse {
    my ($self,$file) = @_;
    my $fh = open "<", $file or die "$file: $!";
    while (defined my $line = <$fh>) {
        # First, check which regex 
        my $handled;
        for (@handlers) {
            my ($re,$code) = @$_;
            if (my @match = ($line =~ /$re/)) {
                $code->($self, @match);
                $handled = 1;
                last;
            };
        };
        warn "Unhandled line >>$line<<";
    };
};
[download]

The separation of flush() and capture_foo is because I have sometimes reports where one logical row spans several lines or where the transaction date is noted at the top of the "page", so some information has to persist before a whole line can be printed to the results.

I use tab separated files with a file extension of .xls which is the most Excel friendly thing you can get without involving Win32::OLE or SpreadSheet::WriteExcel.

Update: monarch spotted a typo/error in sub parse, I was using @_ where it should have been @$_.

My excel here recognizes files with extention of .tab by default as text with tab seperated values (it's also my fav delimited format) :)

I wondered whether there is there something like format for reading files?

Template::Extract is along those lines. That said, I think the solutions that Corion and jZed have already given will work better for this particular case.

$LINEFORMAT = "A10 A20 A15 A12"; # adjust to your field widths

my @fields;

# presuming the input is stdin. otherwise, chop it into lines however 
+you like
while (<>) {
    my @line = unpack $LINEFORMAT, $_;
    if ($line[0]) { # new record
        if ($fields[0]) {       # already have a record read in, print
+ it
            print join ("|", @fields), "\n";
            @fields = ();
        }
        @fields = @line;
        $fields[0] =~ s/^\r//; # strip linefeeds.
    } else {
        $fields[$_] .= " $line[$_]" for 0..$#line;
    }

}

# print the last record
print join ("|", @fields), "\n";
[download]

Forgot to add at the top of the while loop:

next if /$uninteresting/;
# or
next unless /$interesting_line/;
[download]

1. When I see /Transaction\s+Employee\s+-{3}\s/ I know the next two lines will complete the display of column headings.

2. Having reached the end of the headings, the next line contains your "Code1/.../Code2" string; that's easy enough.

3. After that, lines matching /^\s*\d{1,2}-[A-Z]{3}-\d{2}\s+.*?\s\d+\.\d{2}\s*$/ contain column data, and lines matching /^\s{10,}(.*)/ (if any) contain continuation data for the middle column;¹ these latter need to be contiguous with (directly after) the former, and the continuation is terminated by a blank line.

4. Once a blank line is followed by something that doesn't match the 3-column data pattern, that's the end of the table.

So it's just a fairly well-constrained state machine: watch for start of headings, then get "code" fields, then iterate through sets of row data (3-column line, 0-or-more continuation lines, blank line); when that iteration is done, go back to watching for start of headings.

¹ update: Counting initial whitespace characters on the continuation lines might be tricky, if the input uses tabs and spaces in funny or inconsistent ways.