icon Top 9 categories map      RocketAware > Perl >


Tips: Browse or Search all pages for efficient awareness of Perl functions, operators, and FAQs.


Search Perl pages


By activity
Professions, Sciences, Humanities, Business, ...

User Interface
Text-based, GUI, Audio, Video, Keyboards, Mouse, Images,...

Text Strings
Conversions, tests, processing, manipulation,...

Integer, Floating point, Matrix, Statistics, Boolean, ...

Algorithms, Memory, Process control, Debugging, ...

Stored Data
Data storage, Integrity, Encryption, Compression, ...

Networks, protocols, Interprocess, Remote, Client Server, ...

Hard World
Timing, Calendar and Clock, Audio, Video, Printer, Controls...

File System
Management, Filtering, File & Directory access, Viewers, ...

Takes an array or list of values and packs it into a binary structure, returning the string containing the structure. The TEMPLATE is a sequence of characters that give the order and type of values, as follows:

    A   An ascii string, will be space padded.
    a   An ascii string, will be null padded.
    b   A bit string (ascending bit order, like vec()).
    B   A bit string (descending bit order).
    h   A hex string (low nybble first).
    H   A hex string (high nybble first).

    c   A signed char value.
    C   An unsigned char value.

    s   A signed short value.
    S   An unsigned short value.
          (This 'short' is _exactly_ 16 bits, which may differ from
           what a local C compiler calls 'short'.)

    i   A signed integer value.
    I   An unsigned integer value.
          (This 'integer' is _at_least_ 32 bits wide.  Its exact size
           depends on what a local C compiler calls 'int', and may
           even be larger than the 'long' described in the next item.)

    l   A signed long value.
    L   An unsigned long value.
          (This 'long' is _exactly_ 32 bits, which may differ from
           what a local C compiler calls 'long'.)

    n   A short in "network" (big-endian) order.
    N   A long in "network" (big-endian) order.
    v   A short in "VAX" (little-endian) order.
    V   A long in "VAX" (little-endian) order.
          (These 'shorts' and 'longs' are _exactly_ 16 bits and
           _exactly_ 32 bits, respectively.)

    f   A single-precision float in the native format.
    d   A double-precision float in the native format.

    p   A pointer to a null-terminated string.
    P   A pointer to a structure (fixed-length string).

    u   A uuencoded string.

    w   A BER compressed integer.  Its bytes represent an unsigned
        integer in base 128, most significant digit first, with as few
        digits as possible.  Bit eight (the high bit) is set on each
        byte except the last.

    x   A null byte.
    X   Back up a byte.
    @   Null fill to absolute position.

Each letter may optionally be followed by a number which gives a repeat count. With all types except ``a'', ``A'', ``b'', ``B'', ``h'', ``H'', and ``P'' the pack function will gobble up that many values from the LIST. A * for the repeat count means to use however many items are left. The ``a'' and ``A'' types gobble just one value, but pack it as a string of length count, padding with nulls or spaces as necessary. (When unpacking, ``A'' strips trailing spaces and nulls, but ``a'' does not.) Likewise, the ``b'' and ``B'' fields pack a string that many bits long. The ``h'' and ``H'' fields pack a string that many nybbles long. The ``p'' type packs a pointer to a null- terminated string. You are responsible for ensuring the string is not a temporary value (which can potentially get deallocated before you get around to using the packed result). The ``P'' packs a pointer to a structure of the size indicated by the length. Real numbers (floats and doubles) are in the native machine format only; due to the multiplicity of floating formats around, and the lack of a standard ``network'' representation, no facility for interchange has been made. This means that packed floating point data written on one machine may not be readable on another - even if both use IEEE floating point arithmetic (as the endian-ness of the memory representation is not part of the IEEE spec). Note that Perl uses doubles internally for all numeric calculation, and converting from double into float and thence back to double again will lose precision (i.e., unpack("f", pack("f", $foo)) will not in general equal $foo).


    $foo = pack("cccc",65,66,67,68);
    # foo eq "ABCD"
    $foo = pack("c4",65,66,67,68);
    # same thing

    $foo = pack("ccxxcc",65,66,67,68);
    # foo eq "AB\0\0CD"

    $foo = pack("s2",1,2);
    # "\1\0\2\0" on little-endian
    # "\0\1\0\2" on big-endian

    $foo = pack("a4","abcd","x","y","z");
    # "abcd"

    $foo = pack("aaaa","abcd","x","y","z");
    # "axyz"

    $foo = pack("a14","abcdefg");
    # "abcdefg\0\0\0\0\0\0\0"

    $foo = pack("i9pl", gmtime);
    # a real struct tm (on my system anyway)

    sub bintodec {
        unpack("N", pack("B32", substr("0" x 32 . shift, -32)));

The same template may generally also be used in the unpack function.

Source: Perl builtin functions
Copyright: Larry Wall, et al.
Next: package NAMESPACE

Previous: ord EXPR

(Corrections, notes, and links courtesy of RocketAware.com)

[Overview Topics]

Up to: String-Integer-String conversions

Rapid-Links: Search | About | Comments | Submit Path: RocketAware > Perl > perlfunc/pack.htm
RocketAware.com is a service of Mib Software
Copyright 2000, Forrest J. Cavalier III. All Rights Reserved.
We welcome submissions and comments