First analyze the structure of your input, name the parts of it. This input consist of lines, each line consists three fields: a prefix, a separator and a text field. Consecutive prefixes form a block and consecutive blocks form a prefix alphabet.

Second, answer this question: is the input parsable line-by-line or you have to look around (at a certain point) to decide what-is-what? The former answer is typically resulting more efficient programs (but it is not possible for all types of input) and the latter is generally easier to code, but requires to hold more of your input in memory. (I decided to choose the line-by-line approach by storing the previous prefix only beyond the current line.)

Then constrain yourself to go through your input line-by-line and ask yourself: what are the states (or state transitions) determining what should I do?

1. at the start of a new (consecutive) prefix-block
2. in the middle of a prefix-block
3. prefix alphabet starting over

How to map these states to relations between lines? By comparing the prefix of the current and the previous line.

What is the tool to express these relations between the lines? Alphabetical comparison. The mapping is (cf. with the previous listing):

1. $prefix gt $prev_prefix
2. $prefix eq $prev_prefix
3. $prefix lt $prev_prefix

What should I do at each state transition?

1. add $prefix => $text to the current hash
2. append $text to the current $hash{$prefix}
3. push a new hash ref to your array: { $prefix => $text }

Now try to write it again and if you're stuck, come back and look at this:

Of course this is only one approach, but the clearing of concepts, methodical thinking of the mechanical way to solve a problem always helped me.

And in general: practice and practice more. Read books, read the code of others (not just glance over, but change them, understand them), read the problems of others and try to solve them without looking at the solution posted by others.

Thanks for the response, but you misunderstood my task. The 'a>', 'b>', 'c>' are not really present in the text file. I included them as "line numbers" to illustrate where I wanted the text split up. In the specific case I presented, the text is split up at the line *before* the line that starts with '======'.

In any case, I am curious about a general approach to such problems, and at first glance, it seems that a state machine approach would help me. However, I got stuck with that as well, especially since my splitting markers are not *in* the line where I want to split the text, but *after* the line on which I want to split.

--

when small people start casting long shadows, it is time to go to bed

but you misunderstood my task

Indeed. In the last days I'm doing really stupid things, sorry.

my $hdr = <>;
<>;
my @part1;
my @part2;
my $part = \@part1;

while (<>) {
    if ($_ eq "----------------\n") {
        my $next_hdr = pop(@$part);

        process_rec($hdr, \@part1, \@part2);

        $hdr = $next_hdr;
        @part1 = ();
        @part2 = ();
        $part = \@part1;
    }
    elsif ($_ eq "****************\n") {
        $part = \@part2;
    }
    else {
        push @$part, $_;
    }
}

process_rec($hdr, \@part1, \@part2);
[download]

my @foo;

my $next_a = <DATA>;
scalar(<DATA>);

until (eof(DATA))
{
    my $a = $next_a;

    my @b;
    while (my $line = <DATA>)
    {
        last if $line =~ /^[*]{16}$/;
        push @b, $line;
    }

    my $found_next;
    my @c;
    while (my $line = <DATA>)
    {
        last if $found_next = ($line =~ /^-{16}$/);
        push @c, $line;
    }
    $next_a = pop(@c) if $found_next;

    push @foo, {
        a => $a,
        b => join("" => @b),
        c => join("" => @c),
    };
}

use Data::Dumper;
print Dumper \@foo;

__END__
title 1
----------------

a few random lines
of more random text

****************
some more
random text

title 2
----------------

cow jumped

over the moon
****************
corn on the cob

lobster
thermidor
[download]