Any hints on why that happens?

Because that is how array assignment works in Perl. The array expands to accommodate as many items as you assign to it. This is usually seen as a good thing as you'll discover as your experience of Perl grows.

But also, think about how could perl know you only want two values to be assigned to the first array and four to the second? Perl doesn't understand the English in your variable names :)

have over 50 variables of varying size in that header. Am I on a valid approach by appending them in the above statement? That will end up being one looong statement...

Simply put, No. That would not be convenient for you at all. Even if you used the array slice assignment trick: it would be very messy to read & write; difficult to maintain; and very easy to get wrong.

The simplest thing is to assign all fields to a single array and define constant names to access them:

use constant {
    NAME => 0,
    ONBYTE => 1,
    TWOBYTE => 2,
    FOURBYTE => 3,
    TWOBYTE2 => 4,
    TRAILING => 5,
};

my @fields = unpack( "Z16 C1 C2 C4 C1 x400 C*", $data ); 

print $fields[ NAME ];
print $fields[ FOURBYTE ];
print for @fields[ TRAILING .. $#fields ];
[download]

Hopefully with better names :)

But realise, that if you want to unpack two bytes as a single entity, the format C2 will not work. It will return 2 single bytes. You probably want something more like:

my @fields = unpack( "Z16 C S L C x400 C*", $data );
[download]

That is:1 unsigned byte, 1 unsigned short, 1 unsigned long, another unsigned byte; skip 400 bytes and the unpack what's left as bytes.

The @twobytes array swallows all remaining bytes of the file, not just the 2 is am seeking.

You can use array slices to prevent the array from swallowing up more than you want:

my $data = "ABCDEFG";

my ($one, @two, @four);

(@two[0..1], @four[0..3], $one) = unpack "C2 C4 C", $data;

print "@two | @four | $one";    # 65 66 | 67 68 69 70 | 71
[download]

But note that assigning to a slice does not clear any other elements that might have been in the array.

Wonderful!

I guess my misunderstanding was to expected the digit in C2 to limit the assignment to 2 bytes, which it clearly does not.

Actually replacing C2 by C1 in your code like so:

(@two[0..1], @four[0..3], $one) = unpack "C1 C4 C", $data;

print "@two | @four | $one";    # 65 66 | 67 68 69 70 |
[download]

And warns for uninitialized likely undef. I am really missing the purpose of what the digit does!?

I am really missing the purpose of what the digit does!?

Essentially, the unpack just returns a list of values that you have to assign in some meaningful way.

The digits in the template are just telling unpack how to parse the input data. No provisions are made to assign "sub-lists" to separate arrays, or some such.  In other words, in the example "C2 C4 C" has the same effect as saying "C7".  But note that in other cases, such as "A2 A4 A", where A2 etc. would return a single element, there would a difference to saying "A7".

There's only one thing a function can return: a list of scalars, so as far as the assignment is concerned,

my ($name, $onebyte, @twobytes, @fourbytes, $back2onebyte, @trailing)
    = unpack( "Z16 C1 C2 C4 C1 x400 C*", $data);
[download]

is the same thing as

my ($name, $onebyte, @twobytes, @fourbytes, $back2onebyte, @trailing)
    = ($z, $c1, $c2_0, $c2_1, $c4_0, $c4_1, $c4_2, $c4_3, ...);
[download]

How can it possibly know it should assign two (no more, no less) of those elements to @twobytes? It can't.

So what should Perl do when there's an array on the LHS of an assignment? Well, it could throw an error, but instead, it simply assigns everything else to the array. At least that makes (..., @trailing) = useful.

BrowserUK's suggested use of constant works really nicely!

You (and I!) should also look at the enum pragma to simplify declaring such incremental constants:

use enum qw[ NAME ONEBYTE TWOBYTE FOURBYTE TWOBYTE2 TRAILING ];
[download]

Makes such things much cleaner.