HtorneDK:

I'd suggest something like this:

Keep two sets of fields: the temporary set and the full set you're building.

• Read a line and parse it into the temporary fields (unpack, substr)
• If the first column exists (e.g. A00004) then it looks like you're on a new item, so:
• If you have anything in the "full" set:
• process it
• write the processed data
• Copy the temporary data into your "full" set
• Otherwise
• Append the existing temporary fields into your full set
• then go back and process the next line

Finally, when you're done, if you have anything in your full set, process it.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

What have you tried so far? It seems to me the logic would work something like this:

read a line into an array, store it
read the next line into an array
if it only has one field preceded by whitespace
  append that field to the second field of the previous array
else
  print out the stored array
  put this array into storage
at the end, print the stored array
[download]

Coding that should be fairly simple. I don't know if the third line with only the first field is significant, so you may need to add some code to handle that too.

This looks similar to what I see in sqlplus when data is wider than a format allows for. Is there any way to change the width of your formats when generating the data to make your parsing easier?

Then next question I would ask is if the gaps between columns are tabs or spaces. I would use split, a regular expression or substr to pull out the data for each column.

After I had the columnized data for each row, I would feed the data into a state machine. If @current_line[0] == @last_line[0], then you have a multi-line parsing situation (although, having nothing in the first column seems to indicate the same thing). Build up your data for each record, and print out the processed information once the record is complete.

If you show some code, you will be led along the path to enlightenment.

How are you parsing it? This is important step, which will determine how you reassemble/join the string back together

Once you have an array of arrays, its as simple as checking for trailing "-" on a field, iterating/appending until the trailing "-" is missing

Parse::Report - parse Perl format-ed reports. might help, its like the opposite of Perl6::Form

This brings back nice memories, because it closely resembles the problem I solved as part of my first paying Perl gig, and that led to a contract that lasted about three years, back in about 1998.

As has already been explained, just collect the lines, putting each line into an array (I would use an array of arrays, or AoA). You could merge the continuation lines as you go, or you could do it at the end -- if a line has a '-' in the second column, replace that with whatever's in the next line's second column.

I also had to deal with headers and footers, but they were easier.

use Modern::Perl;

while (<DATA>) {
    my @record = split;
    if ($record[1]=~s/-$//) {
        while (<DATA>) {
            my ($continuation) = split;
            $record[1] .= $continuation;
            last unless $record[1]=~s/-$//;
        }
    }
    say join ' ', @record;
}

__DATA__
A00002   \\a00002\c$    2   WinNT   NTFS  Yes 73,626MB  42.5
A00003   /            1     Linux86 EXT3  No  38,289MB  29.8
A00004
A00004   \Sys-       1     WinNT    VSS  Yes  0 KB     0.0
         temState\-
         NULL\Syst-
         em
A00005   /xyz           4     Linux86 EXT2  No  12,345MB  30
[download]