C<pack> and C<unpack> are two functions for transforming data according
to a user-defined template, between the guarded way Perl stores values
-and some well-defined representation as might be required in the
+and some well-defined representation as might be required in the
environment of a Perl program. Unfortunately, they're also two of
the most misunderstood and most often overlooked functions that Perl
provides. This tutorial will demystify them for you.
To see how (un)packing works, we'll start with a simple template
code where the conversion is in low gear: between the contents of a byte
sequence and a string of hexadecimal digits. Let's use C<unpack>, since
-this is likely to remind you of a dump program, or some desparate last
+this is likely to remind you of a dump program, or some desperate last
message unfortunate programs are wont to throw at you before they expire
into the wild blue yonder. Assuming that the variable C<$mem> holds a
sequence of bytes that we'd like to inspect without assuming anything
41204d414e204120504c414e20412043414e414c2050414e414d41
-What was in this chunk of memory? Numbers, charactes, or a mixture of
+What was in this chunk of memory? Numbers, characters, or a mixture of
both? Assuming that we're on a computer where ASCII (or some similar)
encoding is used: hexadecimal values in the range C<0x40> - C<0x5A>
indicate an uppercase letter, and <0x20> encodes a space. So we might
01/28/2001 Flea spray 24.99
01/29/2001 Camel rides to tourists 235.00
->From this, we can see that the date column stretches from column 1 to
+From this, we can see that the date column stretches from column 1 to
column 10 - ten characters wide. The C<pack>-ese for "character" is
C<A>, and ten of them are C<A10>. So if we just wanted to extract the
dates, we could say this:
my( $s ) = unpack( 's', $ps );
This is true for all numeric template codes. But don't expect miracles:
-if the packed value exceeds the alotted byte capacity, high order bits
+if the packed value exceeds the allotted byte capacity, high order bits
are silently discarded, and unpack certainly won't be able to pull them
back out of some magic hat. And, when you pack using a signed template
code such as C<s>, an excess value may result in the sign bit
characters are assigned to the numbers 0 - 127. The Latin-1 Supplement with
characters that are used in several European languages is in the next
range, up to 255. After some more Latin extensions we find the character
-sets from languages using non-roman alphabets, interspersed with a
+sets from languages using non-Roman alphabets, interspersed with a
variety of symbol sets such as currency symbols, Zapf Dingbats or Braille.
(You might want to visit L<www.unicode.org> for a look at some of
them - my personal favourites are Telugu and Kannada.)
The Unicode character sets associates characters with integers. Encoding
these numbers in an equal number of bytes would more than double the
-requirements for storing texts written in latin alphabets.
+requirements for storing texts written in Latin alphabets.
The UTF-8 encoding avoids this by storing the most common (from a western
point of view) characters in a single byte while encoding the rarer
ones in three or more bytes.
by prefixing the binary message length to the actual message. You'll find
that packing a length followed by so many bytes of data is a
frequently used recipe since appending a null byte won't work
-if a null byte may be part of the data. - Here is an example where both
+if a null byte may be part of the data. Here is an example where both
techniques are used: after two null terminated strings with source and
destination address, a Short Message (to a mobile phone) is sent after
a length byte:
( $src, $dst, $len, $sm ) = unpack( 'Z*Z*CA*', $msg );
-There's a subtle trap lurking in the offings: Adding another field after
+There's a subtle trap lurking in the offing: Adding another field after
the Short Message (in variable C<$sm>) is all right when packing, but this
cannot be unpacked naively:
# unpack $buf: '13 Humpty-Dumpty'
my $txt = unpack( 'A4/A*', $buf );
+C</> is not implemented in Perls before 5.6, so if your code is required to
+work on older Perls you'll need to C<unpack( 'Z* Z* C')> to get the length,
+then use it to make a new unpack string. For example
+
+ # pack a message: ASCIIZ, ASCIIZ, length, string, byte (5.005 compatible)
+ my $msg = pack( 'Z* Z* C A* C', $src, $dst, length $sm, $sm, $prio );
+
+ # unpack
+ ( undef, undef, $len) = unpack( 'Z* Z* C', $msg );
+ ($src, $dst, $sm, $prio) = unpack ( "Z* Z* x A$len C", $msg );
+
+But that second C<unpack> is rushing ahead. It isn't using a simple literal
+string for the template. So maybe we should introduce...
=head2 Dynamic Templates
For the reverse operation, we'll have to determine the number of items
in the buffer before we can let C<unpack> rip it apart:
- my $n = ( $env =~ s/\0/\0/g - 1 );
+ my $n = $env =~ tr/\0// - 1;
my %env = map { split( '=', $_ ) } unpack( 'Z*' x $n, $env );
-The substitution counts the null bytes. The C<unpack> call returns a
-list of name-value pairs each of which is taken apart in the C<map>
-block.
+The C<tr> counts the null bytes. The C<unpack> call returns a list of
+name-value pairs each of which is taken apart in the C<map> block.
=head2 Another Portable Binary Encoding
multiple-of-four or even at a multiple-of eight address, a C compiler
will give you this speed benefit by stuffing extra bytes into structures.
If you don't cross the C shoreline this is not likely to cause you any
-grief (although you should care when you design large data structures).
+grief (although you should care when you design large data structures,
+or you want your code to be portable between architectures (you do want
+that, don't you?)).
To see how this affects C<pack> and C<unpack>, we'll compare these two
C structures:
my $gappy = pack( 'cxs cxxx l!', $c1, $s, $c2, $l );
Note the C<!> after C<l>: We want to make sure that we pack a long
-integer as it is compiled by our C compiler.
+integer as it is compiled by our C compiler. And even now, it will only
+work for the platforms where the compiler aligns things as above.
+And somebody somewhere has a platform where it doesn't.
+[Probably a Cray, where C<short>s, C<int>s and C<long>s are all 8 bytes. :-)]
Counting bytes and watching alignments in lengthy structures is bound to
be a drag. Isn't there a way we can create the template with a simple
pack( 's!ax' x @buffer,
map{ ( $_->{count}, $_->{glyph} ) } @buffer );
+=head2 Alignment, Take 3
+
+And even if you take all the above into account, ANSI still lets this:
+
+ typedef struct {
+ char foo[2];
+ } foo_t;
+vary in size. The alignment constraint of the structure can be greater than
+any of its elements. [And if you think that this doesn't affect anything
+common, dismember the next cellphone that you see. Many have ARM cores, and
+the ARM structure rules make C<sizeof (foo_t)> == 4]
=head2 Pointers for How to Use Them
projects / p5sagit/p5-mst-13.2.git / commitdiff