Perl/Pack

pack, unpack

1. Pack / Unpack Tutorial - 문서 번역

1.1. 왜 pack과 unpack이 필요한가

1.2. 정수 포맷

1.3. 캐릭터 포맷

1.4. Perl의 pack 함수

1.5. Perl의 unpack 함수

1.6. 정수 포맷

1.7. 스트링 포맷

1.7.1. 'a', 'A', 그리고 'Z' 포맷

1.7.2. 'b'와 'B' 포맷

1.7.3. 'h'와 'H' 포맷

1.8. 추가 정보

1.9. 참고

1.10. 예제 코드

2. perlpacktut - Tutorial on pack and unpack - 문서 정리

2.1. 설명 Description

2.2. 기본 원리 The Basic Prinicple

2.3. 텍스트 팩킹 Packing Text

2.4. 수 팩킹 Packing Numbers

2.4.1. 정수 Integers

2.4.2. 스택 프레임 unpack하기 Unpacking a Stack Frame

2.4.3. 네트워크 위에서는 달걀을 어느 쪽으로 깨어 먹는가13

2.4.4. 바이트 순서 변경자 Byte-order modifiers

2.4.5. 부동소수 Floating point Numbers

2.5. Exotic Templates

2.5.1. 비트 스트링 Bit Strings

2.5.2. Uuencoding

2.5.3. 합 구하기 Doing Sums

2.5.4. Unicode

2.5.5. Another Portable Binary Encoding

2.6. Template Grouping

2.7. 길이와 폭 Lenghts and Widths

2.7.1. 스트링의 길이 String Lenghts

2.7.2. 동적 템플릿 Dynamic Templates

2.7.3. 반복 횟수를 세기 Counting Repetitions

2.8. C 구조체 Packing and Unpacking C Structures

2.8.1. 열맞추기 The Alignment Pit

2.8.2. 엔디안 다루기 Dealing with Endian-ness

2.8.3. 열맞추기, 장면2 Alignment, Take 2

2.8.4. 열맞추기, 장면3 Alignment, Take 3

2.8.5. 포인터를 어떻게 사용하는가 Pointers for How to Use Them

2.9. Pack 비책들 Pack Recipes

2.10. 재미있죠? Funnies Section

2.11. 저자

3. perldoc -f pack - 문서 번역

4. 관련 문서

5. 기타, comments

1. Pack / Unpack Tutorial - 문서 번역

• 원문: [Pack/Unpack Tutorial (aka How the System Stores Data)]
• (이 섹션의 이하의 내용은 다 번역한 것이고 주인장의 보충 설명이나 의견은 각주로 달았습니다)

1.1. 왜 pack과 unpack이 필요한가

1.2. 정수 포맷

1.3. 캐릭터 포맷

1.4. Perl의 pack 함수

주인장 보충:

말이 좀 애매하긴 한데, 관련 문서에 있는 aero님의 문서를 참조하면 좀 쉽다.

숫자를 나타내는 c 등에 *가 붙으면, 인자로 주어진 값 리스트의 나머지 원소들을 다 가져와서 pack하게 된다.

$a = pack "c*", "65", "66", "67"; # $a = "ABC", 즉 "66","67"을 다 가져왔다

반면에 스트링을 나타내는 a 같은 경우에는 그 문자에 해당하는 원소의 나머지 문자들 전부를 가져온다.

$a = pack "a*", "abc", "def", "ghi"; # $a = "abc", 즉 첫번째 값 "abc"의 나머지 문자인 b와 c를 가져왔다

    struct SupplyRequest {
        time_t request_time;    // time request was entered
        int employee_id;        // employee making request
        char item[32];          // item requested
        short quantity;         // quantity needed
        short urgent;           // request is urgent
    };

   $rec = pack( "l i Z32 s2", time, $emp_id, $item, $quan, $urgent);

     오프셋   내용 (주소는 좌측에서 우측으로 커짐)
         0   160  44  19  62| 41  82   3   0| 98 111 120 101 115  32 111 102
              A0  2C  13  3E| 29  52  03  00| 62  6f  78  65  73  20  6f  66
                                            |  b   o   x   e   s       o   f

        16    32 112  97 112 101 114  99 108 105 112 115   0   0   0   0   0
              20  70  61  70  65  72  63  6c  69  70  73  00  00  00  00  00
                   p   a   p   e   r   c   l   i   p   s

        32     0   0   0   0   0   0   0   0|  2   0|  1   0
              00  00  00  00  00  00  00  00| 02  00| 01  00

1.5. Perl의 unpack 함수

    ($order_time, $monk, $itemname, $quantity, $ignore) =
        unpack( "l i Z32 s2", $rec );

1.6. 정수 포맷

1.7. 스트링 포맷

1.7.1. 'a', 'A', 그리고 'Z' 포맷

    pack('a8',"hello") produces "hello\0\0\0"
    pack('Z8',"hello") produces "hello\0\0\0"
    pack('A8',"hello") produces "hello   "
    unpack('a8',"hello\0\0\0") produces "hello\0\0\0"
    unpack('Z8',"hello\0\0\0") produces "hello"
    unpack('A8',"hello   ") produces "hello"
    unpack('A8',"hello\0\0\0") produces "hello"

1.7.2. 'b'와 'B' 포맷

    ord(pack('b8','00100110')) produces 100 (4 + 32 + 64)
    ord(pack('B8','00100110')) produces 38 (32 + 4 + 2)

1.7.3. 'h'와 'H' 포맷

    pack('h4','1234') produces 0x21,0x43
    pack('H4','1234') produces 0x12,0x34

1.8. 추가 정보

1.9. 참고

1.10. 예제 코드

#!/usr/bin/perl -w
use strict;

# 스트링의 각 바이트를 10진수, 16진수, 캐릭터로 덤프한다
sub DumpString {
    my @a = unpack('C*',$_[0]);
    my $o = 0;
    while (@a) {
        my @b = splice @a,0,16;
        my @d = map sprintf("%03d",$_), @b;
        my @x = map sprintf("%02x",$_), @b;
        my $c = substr($_[0],$o,16);
        $c =~ s/[[:^print:]]/ /g;
        printf "%6d %s\n",$o,join(' ',@d);
        print " "x8,join('  ',@x),"\n";
        print " "x9,join('   ',split(//,$c)),"\n";
        $o += 16;
    }
}

# 웹으로 주문을 내린다
my $t = time;
my $emp_id = 217641;
my $item = "boxes of paperclips";
my $quan = 2;
my $urgent = 1;
my $rec = pack( "l i a32 s2", $t, $emp_id, $item, $quan, $urgent);
DumpString($rec);

# 웹으로 들어온 주문을 처리한다
my ($order_time, $monk, $itemname, $quantity, $ignore) =
       unpack( "l i a32 s2", $rec );
print "Order time: ",scalar localtime($order_time),"\n";
print "Placed by monk #$monk for $quantity $itemname\n";

# 스트링 포맷들
$rec = pack('a8',"hello");               # should produce 'hello\0\0\0'
DumpString($rec);
$rec = pack('Z8',"hello");               # should produce 'hello\0\0\0'
DumpString($rec);
$rec = pack('A8',"hello");               # should produce 'hello   '
DumpString($rec);
($rec) = unpack('a8',"hello\0\0\0");     # should produce 'hello\0\0\0'
DumpString($rec);
($rec) = unpack('Z8',"hello\0\0\0");     # should produce 'hello'
DumpString($rec);
($rec) = unpack('A8',"hello   ");        # should produce 'hello'
DumpString($rec);
($rec) = unpack('A8',"hello\0\0\0");     # should produce 'hello'
DumpString($rec);

# 비트 포맷
$rec = pack('b8',"00100110");            # should produce 0x64 (100)
DumpString($rec);
$rec = pack('B8',"00100110");            # should produce 0x26 (38)
DumpString($rec);

# 16진수 포맷
$rec = pack('h4',"1234");                # should produce 0x21,0x43
DumpString($rec);
$rec = pack('H4',"1234");                # should produce 0x12,0x34
DumpString($rec);

2. perlpacktut - Tutorial on pack and unpack - 문서 정리

• 원문: perlpacktut
• (이 섹션의 이하의 내용은 원문을 정리한 것이고 주인장의 보충 설명이나 의견은 각주로 달았습니다)

2.1. 설명 Description

2.2. 기본 원리 The Basic Prinicple

• pack : 값들을 바이트 시퀀스로 변환. 이 변환은 템플릿이라 불리는 명세에 의해 이뤄진다.
• unpack : pack의 반대 역할. 바이트 스트링의 내용으로부터 값들을 얻어 낸다.

• 파일, 장치, 네트워크 입출력 시에 이런 형태가 요구되거나, 이런 형태를 사용해야 처리가 더 편해지는 경우가 있다.
• Perl 함수로 제공되지 않는 시스템 콜 : syscall 함수는 C 프로그램의 방식으로 저장된 파라메터가 필요하다.
• 텍스트 처리를 매우 간단하게 할 수 있다.

# $mem에 어떤 바이트 시퀀스 - 내용이 뭐가 됐든 - 가 들어있는 상태에서
my ( $hex ) = unpack( 'H*', $mem );
print "$hex\n";
# 출력예
41204d414e204120504c414e20412043414e414c2050414e414d41

• 바이트 시퀀스의 내용을 16진수 표기로 변환한다.
• 'H(50)'는 16진수 한 자리를 변환
• '*(51)'는 남은 것 전부를 사용

my $s = pack( 'H2' x 10, map { "3$_" } ( 0..9 ) );
print "$s\n";

# 출력
0123456789

2.3. 텍스트 팩킹 Packing Text

    Date      |Description                | Income|Expenditure
    01/24/2001 Ahmed's Camel Emporium                  1147.99
    01/28/2001 Flea spray                                24.99
    01/29/2001 Camel rides to tourists      235.00

• split 은 비어 있는 필드를 잡아내지 못하기 때문에 Income과 Expenditure필드를 구분할 수 없다.
• substr:

    while (<>) {
        my $date   = substr($_,  0, 11);
        my $desc   = substr($_, 12, 27);
        my $income = substr($_, 40,  7);
        my $expend = substr($_, 52,  7);
        ...
    }

• 필드의 시작위치와 길이를 일일이 손으로 세어가며 계산해 주어야 함. 에러가 나기 쉽다.
• /정규표현식:

    while (<>) {
        my($date, $desc, $income, $expend) =
            m|(\d\d/\d\d/\d{4}) (.{27}) (.{7})(.*)|;
        ...
    }

• 조금 나아졌지만 여전히 유지 보수하기 힘들다.
• pack과 unpack: 폭이 고정된 데이타를 다룰 때 유용하다8

    while (<>) {
        my($date, $desc, $income, $expend) = unpack("A10xA27xA7xA*", $_);
        ...
    }

• 1열부터 10열까지가 date 필드. "캐릭터"를 의미하는 템플릿은 "A(52)", 캐릭터 10개는 "A10"를 의미
  • date 필드만 뽑아내는 경우:

    my($date) = unpack("A10", $_);

• "x(53)" 는 "앞으로 건너뜀"을 의미.
• "*(54)" 는 "남아 있는 모든 것을 사용하라"는 의미.
  • 정규표현식과 비슷해 보이지만, 들어오는 데이타와 매치가 안 되면 프로그램이 에러를 낸다. 주의.

    while (<>) {
        my($date, $desc, $income, $expend) = unpack("A10xA27xA7xA*", $_);
        $tot_income += $income;
        $tot_expend += $expend;
    }

    $tot_income = sprintf("%.2f", $tot_income); # Get them into 
    $tot_expend = sprintf("%.2f", $tot_expend); # "financial" format

    $date = POSIX::strftime("%m/%d/%Y", localtime);

    # OK, let's go:
    print pack("A10xA27xA7xA*", $date, "Totals", $tot_income, $tot_expend);

• 출력을 해 보면 마지막 줄의 필드 사이에 띄어쓰기가 되지 않는다.
• x(55)는 "null byte", 즉 '\0'을 의미9
• 각 필드의 폭을 늘려서 공백으로 채워넣자:

    print pack("A11 A28 A8 A*", $date, "Totals", $tot_income, $tot_expend);
# 템플릿 스트링 안에 있는 공백은 단지 가독성을 위해 추가한 것이고, 실제 변환시 공백으로 변환되는 것이 아님

• "A(56)" 형식은 캐릭터가 없는 곳은 스페이스로 채운다.
• pack에서는 필드를 오른쪽 정렬로 맞출 수는 없다. 마지막 필드는 sprintf를 사용하여 열을 맞춰준다10:

    $tot_income = sprintf("%.2f", $tot_income);
    $tot_expend = sprintf("%12.2f", $tot_expend);
    $date = POSIX::strftime("%m/%d/%Y", localtime);
    print pack("A11 A28 A8 A*", $date, "Totals", $tot_income, $tot_expend);

• 출력:

01/24/2001 Ahmed's Camel Emporium                  1147.99
01/28/2001 Flea spray                                24.99
01/29/2001 Camel rides to tourists     1235.00
11/07/2008 Totals                      1235.00     1172.98

• pack 을 사용하여 여러 데이타 조각을 하나의 고정폭 형태로 변환한다. unpack 을 사용하여 하나의 고정폭 형태의 스트링을 여러 데이타 조각들로 변환한다.
• "A(57)"는 "any character"를 의미한다. pack 도중에 더 이상 압축할 대상이 없다면 남은 부분을 공백으로 채운다.
• "x(58)"는 unpack하는 동안에는 "한 바이트 스킵"을 의미한다. pack하는 경우에는 "널 바이트를 추가"한다 - 텍스트를 처리하는 경우라면, 이것은 사용자가 원하는 동작은 아닐 것이다.
• 템플릿 포맷 뒤에 숫자를 덧붙여서 얼마나 많은 캐릭터에 적용할지를 명시한다. "A12"는 "12개의 캐릭터를 취함"을 의미. "x6"은 "6바이트 스킵" 또는 "널 캐릭터, 여섯 번"을 의미.
• 숫자 대신에 "*(59)"을 사용하여 "남은 것들 전부를 소모"하도록 할 수 있다.

• 복수개의 데이타 조각들을 pack하는 경우, "*"는 단지 "현재 데이타 조각의 모든 것을 소모"하라는 의미이다.

pack("A*A*", $one, $two);

• $one에 담겨있는 모든 내용을 첫번째 "A*"에 압축하고, $two에 담겨있는 모든 내용을 두번째 "A*"에 압축한다.
• 일반적인 원칙: pack하는 경우 각각의 포맷 문자는 하나의 데이타 조각에 대응된다.

2.4. 수 팩킹 Packing Numbers

2.4.1. 정수 Integers

• 정수를 보관하는데 사용되는 바이트의 수
• 부호의 유무
• 바이트의 순서: 첫 바이트가 가장 상위 바이트인지(big endian(61)) 가장 하위 바이트인지(little endian(62))

   my $ps = pack( 's', 20302 );

• 결과는 2바이트짜리 스트링
• 출력할 경우 시스템의 바이트 순서에 따라서 "ON"또는 "NO"가 출력될 것임. (ASCII를 사용하지 않는다면 다른 것이 출력될 수도 있음)

   my( $s ) = unpack( 's', $ps );

• pack된 값이 할당단 바이트 용량을 초과할 경우 상위 비트는 버려짐
• "s(64)"와 같이 부호를 적용하는 템플릿을 사용하여 pack한 경우에 초과된 값11이 부호 비트를 세팅하여, unpack했을 때 음수값이 반환될 수 있음

   signed unsigned  byte length in C   byte length in Perl
     s!     S!      sizeof(short)      $Config{shortsize}
     i!     I!      sizeof(int)        $Config{intsize}
     l!     L!      sizeof(long)       $Config{longsize}
     q!     Q!      sizeof(long long)  $Config{longlongsize}

• %Config 해쉬를 사용하고 싶으면 "use Config"를 써서 import할 것
• i!와 L!은 i,L과 동일하며 단지 일관성을 맞추기 위해서 존재한다

2.4.2. 스택 프레임 unpack하기 Unpacking a Stack Frame

      +---------+        +----+----+               +---------+
 TOS: |   IP    |  TOS+4:| FL | FH | FLAGS  TOS+14:|   SI    |
      +---------+        +----+----+               +---------+
      |   CS    |        | AL | AH | AX            |   DI    |
      +---------+        +----+----+               +---------+
                         | BL | BH | BX            |   BP    |
                         +----+----+               +---------+
                         | CL | CH | CX            |   DS    |
                         +----+----+               +---------+
                         | DL | DH | DX            |   ES    |
                         +----+----+               +---------+

• little endian(71) 순서
• unsigned short값을 얻기 위해 "v(72)"를 사용:

   my( $ip, $cs, $flags, $ax, $bx, $cd, $dx, $si, $di, $bp, $ds, $es ) =
     unpack( 'v12', $frame );

• 또는 "C(73)"를 사용하여 FL, FH 등 개별적으로 접근할 수 있는 바이트 레지스터를 unpack :

   my( $fl, $fh, $al, $ah, $bl, $bh, $cl, $ch, $dl, $dh ) =
     unpack( 'C10', substr( $frame, 4, 10 ) );

• 위 두가지를 동시에 수행하고 싶다면?
  • short를 unpack하고, 되돌아와서 다시 두 개의 byte를 unpack
  • X(74) - 한 바이트를 되돌림(back up)

   my( $ip, $cs,
       $flags,$fl,$fh,
       $ax,$al,$ah, $bx,$bl,$bh, $cx,$cl,$ch, $dx,$dl,$dh,
       $si, $di, $bp, $ds, $es ) =
   unpack( 'v2' . ('vXXCC' x 5) . 'v5', $frame );

2.4.3. 네트워크 위에서는 달걀을 어느 쪽으로 깨어 먹는가13

• n(76) - 16비트
• N(77) - 32비트

   my $buf = pack( 'N', length( $msg ) ) . $msg;
# 또는 아예 묶어서
   my $buf = pack( 'NA*', length( $msg ), $msg );
# 이제 $buf를 송신 루틴에 전달

2.4.4. 바이트 순서 변경자 Byte-order modifiers

   my @data = unpack 's*', pack 'S*', unpack 'n*', $buf;

• >(84) : big endian(85)
• <(86) : little endian(87)
• 위의 코드를 변경자를 사용하여 바꾼 예:

   my @data = unpack 's>*', $buf;

2.4.5. 부동소수 Floating point Numbers

• f(89) - 단정도형. 시스템 고유 포맷.
• d(90) - 배정도형. 시스템 고유 포맷.

• D(91) - long double. 시스템이 지원하는 경우에만14
• F(92) - Perl 내부에서 사용하는 부동소수형태(NV).

2.5. Exotic Templates

2.5.1. 비트 스트링 Bit Strings

• 한 바이트가 다음과 같이 구성되었을 때,

     7 6 5 4 3 2 1 0
   +-----------------+
   | 1 0 0 0 1 1 0 0 |
   +-----------------+
    MSB           LSB

• 두 가지 비트 스트링 표기가 가능B(93),b(94):

   $byte = pack( 'B8', '10001100' ); # start with MSB
   $byte = pack( 'b8', '00110001' ); # start with LSB

   +-----------------+-----------------+
   | S Z - A - P - C | - - - - O D I T |
   +-----------------+-----------------+
    MSB           LSB MSB           LSB

• "-"로 표기된 미사용 비트는 undef에 할당해서 버려버림

   ($carry, undef, $parity, undef, $auxcarry, undef, $zero, $sign,
    $trace, $interrupt, $direction, $overflow) =
      split( //, unpack( 'b16', $status ) );

2.5.2. Uuencoding

• 3바이트(24비트)를 취함
• 이것을 4개의 6비트 덩어리로 나누고 각 덩어리에 스페이스에 해당하는 값(0x20)을 더함. (단 원래 바이트가 0x00인 경우는 0x20이 아니라 0x60으로 만듦)
• 4바이트로 이뤄진 그룹들을 60바이트 이하의 라인에 접어 넣음 (Fold groups of 4 bytes into lines no longer than 60 - 이 60이 60바이트인지 60그룹인지 잘 모르겠음)
• 제일 앞에는 원래의 바이트 갯수에 0x20을 더하여 붙이고, 제일 뒤에는 "\n"을 덧붙임

   my $uubuf = pack( 'u', $bindat );

2.5.3. 합 구하기 Doing Sums

• 다른 템플릿 코드의 prefix로 사용된다.
• pack 함수에서는 전혀 쓰이지 않는다.
• unpack 에서, 데이타 값들의 합을 구해서 number비트의 정수를 만든다.15

    my $buf = pack( 'iii', 100, 20, 3 );
    print unpack( '%32i3', $buf ), "\n";  # prints 123

• 스트링 값에서는 바이트 값들의 합을 반환한다. substr과 ord를 써서 합을 구해야 하는 불편을 덜어준다.

    print unpack( '%32A*', "\x01\x10" ), "\n";  # prints 17

• b(98)나 B(99)와 함께 사용할 경우, %는 단순히 비트들을 더한다. 1로 세팅된 비트의 갯수를 셀 때 효과적이다.

    my $bitcount = unpack( '%32b*', $mask );

• 패리티 비트를 결정하는 데 쓸 수도 있다.

    my $evenparity = unpack( '%1b*', $mask );

2.5.4. Unicode

• 유로화 심볼(코드 번호 0x20AC)을 만드는 예:

   $UTF8{Euro} = pack( 'U', 0x20AC );
   # Equivalent to: $UTF8{Euro} = "\x{20ac}";

• $UTF8{Euro}는 3바이트를 차지하며 그 내용은 "\xe2\x82\xac"이다.
• 역으로 유니코드 번호를 얻어내는 예:

   $Unicode{Euro} = unpack( 'U', $UTF8{Euro} );

• UTF-8 스트링을 pack 또는 unpack:

   # pack and unpack the Hebrew alphabet
   my $alefbet = pack( 'U*', 0x05d0..0x05ea );
   my @hebrew = unpack( 'U*', $utf );

2.5.5. Another Portable Binary Encoding

• 이식성 있는 바이너리 데이타 인코딩 제공
• BER(Binary Encoded Representation)로 압축된 무부호 정수
• 128진수 형식으로 저장
  • 최상위 비트가 먼저
  • 자릿수를 최소한으로 사용
  • 마지막 바이트를 제외하고 모든 바이트의 최상위 비트를 1로 세팅

   my $berbuf = pack( 'w*', 1, 128, 128+1, 128*128+127 );

• 위 코드의 $berbuf 를 덤프해보면 "01 8100 8101 81807F"16가 나옴. 마지막 바이트는 항상 128보다 작으므로 unpack 함수는 어디서 멈춰야 할 지 알 수 있음.

2.6. Template Grouping

   unpack( 'v2 (vXXCC)5 v5', $frame )

• @str 배열의 원소 스트링들의 첫 글자들로 이뤄진 스트링 만들기

   join( '', map( substr( $_, 0, 1 ), @str ) )

• pack 을 사용하여17

   pack( '(A)'.@str, @str )

• "필요한 만큼 반복"을 의미하는 "*"를 써서 더 간단히

   pack( '(A)*', @str )

• "A*"라고 쓰면 단지 $str[0]에 담긴 스트링 전체를 pack하는 거에 유의

   $pd = pack( '(CCS)*', map( @$_, @dates ) );

• x(108)와 X(109)를 사용하여 앞뒤로 스킵하는 방법

   $s = pack( '(A)*', unpack( '(xAXXAx)*', $s ) );

• '@(110)'를 사용하여 어떤 오프셋만큼 건너뛸 수 있다. 오프셋 0은 마지막 "("를 만났을 때 있던 지점이다.

   $s = pack( '(A)*', unpack( '(@1A @0A @2)*', $s ) );

• 전혀 다른 방향에서 해결: 스트링을 2바이트씩 나누어서 big endian short 형태로 취급하여 unpack한 후 반대 순서로 pack

   $s = pack( '(v)*', unpack( '(n)*', $s );

2.7. 길이와 폭 Lenghts and Widths

2.7.1. 스트링의 길이 String Lenghts

• 발신자/수신자 주소는 널로 끝나는 스트링을 사용, 메시지는 그 길이를 앞에 명시

   my $msg = pack( 'Z*Z*CA*', $src, $dst, length( $sm ), $sm );

• 동일한 템플릿을 가지고 unpack

   ( $src, $dst, $len, $sm ) = unpack( 'Z*Z*CA*', $msg );

   # pack a message
   my $msg = pack( 'Z*Z*CA*C', $src, $dst, length( $sm ), $sm, $prio );

   # unpack fails - $prio remains undefined!
   ( $src, $dst, $len, $sm, $prio ) = unpack( 'Z*Z*CA*C', $msg );

• 'A*'가 나머지 바이트를 전부 사용해 버리기 때문에, $prio는 정의되지 않은 상태로 남게 된다.

   # pack a message: ASCIIZ, ASCIIZ, length/string, byte
   my $msg = pack( 'Z* Z* C/A* C', $src, $dst, $sm, $prio );

   # unpack
   ( $src, $dst, $sm, $prio ) = unpack( 'Z* Z* C/A* C', $msg );

• pack에서는, 인자의 길이를 계산하여 첫번째 코드에 맞춰 pack하고, 인자 자체는 슬래쉬 뒤에 있는 코드에 맞춰서 변환한 후 추가한다.
  • length 함수를 호출을 따로 할 필요 없다.
• unpack 시에는, 길이를 나타내는 바이트의 값을 사용하여 버퍼에서 읽을 스트링의 끝을 표시한다.
• 이 조합은 두번째 코드가 'a*', 'A*', 'Z*'일 때만 의미가 있기 때문에 그 외의 경우에는 허용되지 않는다.

   # pack/unpack a string preceded by its length in ASCII
   my $buf = pack( 'A4/A*', "Humpty-Dumpty" );
   # unpack $buf: '13  Humpty-Dumpty'
   my $txt = unpack( 'A4/A*', $buf );

   # 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 );

2.7.2. 동적 템플릿 Dynamic Templates

   my $env = pack( '(A*A*Z*)' . keys( %Env ) . 'C',
                   map( { ( $_, '=', $Env{$_} ) } keys( %Env ) ), 0 );

• map을 호출하여 $env 버퍼에 넣을 항목들을 생성
  • 키($_)에 "=" 구분자와 해시 값을 덧붙임
  • 이렇게 구성된 한 벌의 데이타가 "A*A*Z" 코드에 맞춰 pack됨
  • 키의 갯수(keys 함수가 스칼라 컨텍스트에서 반환한 값)만큼 반복됨
  • 제일 마지막에 0을 "C"코드에 맞춰 pack함

   my $n = $env =~ tr/\0// - 1;
   my %env = map( split( /=/, $_ ), unpack( "(Z*)$n", $env ) );

• tr은 널바이트의 숫자를 센다.
• unpack은 이름-값 쌍의 리스트를 반환한다.
• map은 리스트의 각 원소에서 이름과 값을 분리한다.

2.7.3. 반복 횟수를 세기 Counting Repetitions

   my $env = pack( 'S(S/A* S/A*)*', scalar keys( %Env ), %Env );

   my %env = unpack( 'S/(S/A* S/A*)', $env );

2.8. C 구조체 Packing and Unpacking C Structures

2.8.1. 열맞추기 The Alignment Pit

typedef struct {
    char c1;
    short s;
    char c2;
    long l;
} gappy_t;

typedef struct {
    long l;
    short s;
    char c1;
    char c2;
} dense_t;

• C 컴파일러는 gappy_t 타입의 변수에는 12바이트를 할당하지만 dense_t의 경우는 8바이트만 할당한다.

   0           +4          +8          +12
   +--+--+--+--+--+--+--+--+--+--+--+--+
   |c1|xx|  s  |c2|xx|xx|xx|     l     |    xx = fill byte
   +--+--+--+--+--+--+--+--+--+--+--+--+
   gappy_t

   0           +4          +8
   +--+--+--+--+--+--+--+--+
   |     l     |  h  |c1|c2|
   +--+--+--+--+--+--+--+--+
   dense_t

• pack과 unpack 템플릿은 'x(121)' 코드를 써서 이런 여분의 fill byte를 처리해야 한다.

  my $gappy = pack( 'cxs cxxx l!', $c1, $s, $c2, $l );

• 'l(122)'뒤에 '!(123)'를 붙여서, long 정수를 C 컴파일러가 컴파일했을 때와 동일하게 pack 되게 하였다. 그러나 이런 방법도 컴파일러가 위에처럼 정렬을 해 주는 플랫폼에서나 유효하고, 세상 어딘가에는 안 그런 플랫폼도 있다. (Cray의 경우는 short, int, long이 다 8바이트이다)

• 템플릿을 만들어 주는 C 프로그램의 예:

   #include <stdio.h>
   #include <stddef.h>

   typedef struct {
     char     fc1;
     short    fs;
     char     fc2;
     long     fl;
   } gappy_t;

   #define Pt(struct,field,tchar) \
     printf( "@%d%s ", offsetof(struct,field), # tchar );

   int main() {
     Pt( gappy_t, fc1, c  );
     Pt( gappy_t, fs,  s! );
     Pt( gappy_t, fc2, c  );
     Pt( gappy_t, fl,  l! );
     printf( "\n" );
   }

• 위 프로그램의 출력을 템플릿으로 쓸 수 있다:

  my $gappy = pack( '@0c @2s! @4c @8l!', $c1, $s, $c2, $l );

• @(124)를 사용하여 pack 버퍼의 첫 부분으로부터의 오프셋을 명시할 수 있다.

• x!N(125) - "다음 N의 배수 주소에 도달하기 위해 필요한 바이트 수만큼을 건너뛰어라"

  my $gappy = pack( 'c x!2 s c x!4 l!', $c1, $s, $c2, $l );

• 위 방법에서는 각 정수들의 길이를 알아야 한다.
• 숫자 대신에 "short 의 길이만큼"이라 명시
  • pack 코드를 대괄호로 둘러싸서 표현, [(126)s](127)

  my $gappy = pack( 'c x![s] s c x![l!] l!', $c1, $s, $c2, $l );

• 이것이 최선의 방법

2.8.2. 엔디안 다루기 Dealing with Endian-ness

• 먼저 대상 머신에서 데이타 타입들의 크기를 알아야 한다. long이 32비트, short가 16비트인 경우라 하자. 위에서 작성한 템플릿을 다시 쓰면:

  my $gappy = pack( 'c x![s] s c x![l] l', $c1, $s, $c2, $l );

• 대상 머신이 little endian(128)을 사용한다면, short와 long멤버가 little endian 으로 저장되게 강제:

  my $gappy = pack( 'c x![s] s< c x![l] l<', $c1, $s, $c2, $l );

• 바이트 순서 수정자를 그룹에 대해 지정할 수도 있다:
  • 의도를 좀 더 명확히 드러내 주고, 읽거나 보수하기도 쉽다.

  my $gappy = pack( '( c x![s] s c x![l] l )<', $c1, $s, $c2, $l );

2.8.3. 열맞추기, 장면2 Alignment, Take 2

   typedef struct {
     short    count;
     char     glyph;
   } cell_t;

   typedef cell_t buffer_t[BUFLEN];

# 뭔가 잘못 되고 있음:
   pack( 's!a' x @buffer,
         map{ ( $_->{count}, $_->{glyph} ) } @buffer );

• 이것은 3*@buffer개의 바이트를 pack한다. 그러나 buffer_t의 크기는 BUFLEN의 4배인 것으로 밖혀진다.

   pack( 's!ax' x @buffer,
         map{ ( $_->{count}, $_->{glyph} ) } @buffer );

2.8.4. 열맞추기, 장면3 Alignment, Take 3

   typedef struct {
     char     foo[2];
   } foo_t;

• ANSI 표준에서 위의 구조체의 크기는 변할 수 있다.
• 구조체의 원소들 뿐 아니라 구조체 전체의 정렬도 제약을 받는다.
• 일반적인 경우가 아니라고 생각한다면, 눈에 띄는 휴대폰을 분해해 보라. 많은 휴대폰에는 ARM 코어가 사용되고 있고, ARM에서 sizeof(foo_t)==4 이다.

2.8.5. 포인터를 어떻게 사용하는가 Pointers for How to Use Them

    # allocate some storage and pack a pointer to it
    my $memory = "\x00" x $size;
    my $memptr = pack( 'P', $memory );

    my $ptr = unpack( 'L!', $memptr );

• 이 경우는 포인터를 unsigned long으로 타입변환할 수 있고 그 역도 가능하다고 가정했다. 이 가정이 언제나 옳지는 않다.

• read(2) 시스템 콜:

    ssize_t read(int fd, void *buf, size_t count);

• 파일을 표준 출력으로 복사하는 Perl 함수. perlfunc에서 syscall 사용법을 참조할 것:19

    require 'syscall.ph';
    sub cat($){
        my $path = shift();
        my $size = -s $path;
        my $memory = "\x00" x $size;  # allocate some memory
        my $ptr = unpack( 'L', pack( 'P', $memory ) );
        open( F, $path ) || die( "$path: cannot open ($!)\n" );
        my $fd = fileno(F);
        my $res = syscall( &SYS_read, fileno(F), $ptr, $size );
        print $memory;
        close( F );
    }

• 이 예제의 핵심은, 장막 뒤로 기어들어가서 Perl이 잘 보호하고 있는 메모리에 접근할 수 있다는 것이다.
• 주의(중요함): Perl의 syscall 함수는 굳이 이런 번거로운 방법으로 포인터를 만들어서 넘기지 않아도 된다. 그냥 스트링 변수를 넘겨주면 Perl이 변수의 주소를 전달한다.20

• 버퍼에 어떤 포인터가 담겨 있는 것을 unpack한다고 생각해보자. 이게 널 포인터(이 경우는 undef이 반환된다)가 아니라면, 시작 주소를 얻을 수 있다. 그러나 Perl은 그 포인터가 가리키는 "고정 길이 스트링"의 길이를 알 수 없기 때문에, 사용자가 실제 사이즈를 P뒤에 적어 주어야 한다:

   my $mem = "abcdefghijklmn";
   print unpack( 'P5', pack( 'P', $mem ) ); # prints "abcde"

• 결과적으로, pack은 'P'뒤에 오는 숫자나 '*(131)'를 무시한다.

   my $buf = pack( 'p', "abc\x00efhijklmn" );
   print unpack( 'p', $buf );    # prints "abc"

• 좀 혼동의 여지가 있는데, 'P(133)'코드 뒤에 오는 숫자는 길이를 의미하지만, 'p(134)' 코드의 경우는 스트링의 길이를 가지고 길이를 알 수 있기 때문에21 코드 뒤에 오는 숫자는 길이가 아니라 repeat count(135)를 의미하게 된다.

주인장의 보충:

"Pack / Unpack Tutorial"의 마지막 예제 코드에 있는 DumpString를 사용하여 덤프를 출력하며 비교해보자.

• 스트링 데이타를 3개 준비하고

my $str1 = "ABC\x{41}DEFGHI";    # 널 캐릭터 포함해서 10글자짜리
my $str2 = "abc\x{00}defghi";
my $str3 = "123\x{00}567890";

• P코드 뒤에 길이를 붙이며 pack

my $pack1 = pack( 'P' , $str1, $str2, $str3 );
my $pack2 = pack( 'P2', $str1, $str2, $str3 );
my $pack3 = pack( 'P*', $str1, $str2, $str3 );
my $pack4 = pack( 'PP', $str1, $str2, $str3 );
my $pack5 = pack( 'P2P3', $str1, $str2, $str3 );

• 덤프를 뜬다

DumpString( $pack1 );
DumpString( $pack2 );
DumpString( $pack3 );
DumpString( $pack4 );
DumpString( $pack5 );

• 출력은

     0 048 130 084 009
        30  82  54  09
         0       T
     0 048 130 084 009
        30  82  54  09
         0       T
     0 048 130 084 009
        30  82  54  09
         0       T
     0 048 130 084 009 136 081 084 009
        30  82  54  09  88  51  54  09
         0       T           Q   T
     0 048 130 084 009 136 081 084 009
        30  82  54  09  88  51  54  09
         0       T           Q   T

• 처음 셋은 다 동일하다, 'P'는 해당 변수의 주소를 pack하는 것이라서, "길이"란 게 의미가 없다.
• "PP"로 템플릿을 주었을 때는 $str1과 $str2의 주소가 각각 pack된다.
• "PP"와 "P2P3"도 서로 동일하다.

• 이걸 unpack하자. 리스트의 원소들을 구분하기 위해 "|" 기호로 join하고, 좌우에도 대괄호를 붙여서 공백을 확인할 수 있게 한다.

print "[", join( '|', unpack( 'P'  , $pack1 ) ), "]\n";   # "A"
print "[", join( '|', unpack( 'P2' , $pack2 ) ), "]\n";   # "AB"
print "[", join( '|', unpack( 'P10', $pack2 ) ), "]\n";   # "ABC\0DEFGHI"
print "[", join( '|', unpack( 'P*' , $pack3 ) ), "]\n";   # 런타임에 에러가 난다.
print "[", join( '|', unpack( 'PP' , $pack4 ) ), "]\n";   # ( "A", "a" )
print "[", join( '|', unpack( 'P2P3' , $pack4 ) ), "]\n"; # ( "AB", "abc" )

• 출력은

[A]
[AB]
[ABCDEFGHI]
'P' must have an explicit size in unpack at ./t07.pl line 25.
      <- 실제로는 이 시점에서 에러가 나며 프로그램이 종료되므로, 'P*' 라인을 지워야 이하의 출력이 나온다.
[A|a]
[AB|abc]

• "P"는 "P1"로 간주되는 걸 알 수있다.
• "P*"는 시작 주소를 주면서 "길이는 최대"라고 주는 셈이라서 의미가 없다. 런타임 에러가 나면서 프로그램이 종료된다.
• "PP"는 pack되어 있던 두 개의 포인터에서 각각 한 바이트씩을 끄집어낸다.
• "P2P3"는 두 개의 포인터에서 2바이트, 3바이트씩 가져온다.

• 이번에는 "p"를 사용하여 동일하게 pack

my $pack1 = pack( 'p' , $str1, $str2, $str3 );
my $pack2 = pack( 'p2', $str1, $str2, $str3 );
my $pack3 = pack( 'p*', $str1, $str2, $str3 );
my $pack4 = pack( 'pp', $str1, $str2, $str3 );
my $pack5 = pack( 'p2p3', $str1, $str2, $str3 );

• 덤프를 뜬다.

DumpString( $pack1 );
DumpString( $pack2 );
DumpString( $pack3 );
DumpString( $pack4 );
DumpString( $pack5 );

• 출력

     0 048 130 084 009
        30  82  54  09
         0       T
     0 048 130 084 009 136 081 084 009
        30  82  54  09  88  51  54  09
         0       T           Q   T
     0 048 130 084 009 136 081 084 009 176 223 084 009
        30  82  54  09  88  51  54  09  b0  df  54  09
         0       T           Q   T               T
     0 048 130 084 009 136 081 084 009
        30  82  54  09  88  51  54  09
         0       T           Q   T
     0 048 130 084 009 136 081 084 009 176 223 084 009 232 074 083 009
        30  82  54  09  88  51  54  09  b0  df  54  09  e8  4a  53  09
         0       T           Q   T               T           J   S
    16 232 074 083 009
        e8  4a  53  09
             J   S

• 'p'는 $str1의 포인터를 pack
• 'p2'는 'p'와 다르다. $str1, $str2의 포인터를 pack한다
• 'p*'는 뒤에 오는 리스트 전부를 받아들이니 총 3개의 포인터
• 'pp'는 'p2'와 같다
• 'p2p3'는 좀 묘하다. 'ppppp'와 같은 상황이니 변수 3개의 포인터가 앞에 pack되는 데, 그 뒤에 8바이트가 더 있다. 포인터 두개가 더 들어가 있는 듯 한데, 둘은 같은 값이다.

• unpack해보자.

print "[", join( '|', unpack( 'p'  , $pack1 ) ), "]\n";
print "[", join( '|', unpack( 'p2' , $pack2 ) ), "]\n";
print "[", join( '|', unpack( 'p10', $pack2 ) ), "]\n";
print "[", join( '|', unpack( 'p*' , $pack3 ) ), "]\n";
print "[", join( '|', unpack( 'pp' , $pack4 ) ), "]\n";
print "[", join( '|', unpack( 'p2p3' , $pack5 ) ), "]\n";

• 출력

[ABC]
[ABC|abc]
[ABC|abc]
[ABC|abc|123]
[ABC|abc]
[ABC|abc|123||]

• 'p'는 길이가 명시되지 않아서 널 캐릭터가 있는 곳까지 세 글자를 가져온다.
• 'p2'는 포인터 두개에서 세 글자를 가져온다.
• 'p10'을 해봤자 실제 pack되어 있는 포인터는 두개뿐이니 'p2'와 같은 출력
• 'p*'는 pack되어 있는 모든 포인터에서 스트링을 가져온다.
• 'pp'는 'p2'와 같다
• 'p2p3'는 'ppppp'와 같고, 처음 세 포인터에서 세 글자씩 가져오고, 나머지 두 포인터를 가지고도 unpack하여 원소가 두 개 더 반환되었다. 실제로 뭐를 가리키는지 몰라도, 아무것도 출력되지 않았다.

• 해당 주소의 메모리 사용을 마치기 전에 스코프를 벗어날 (그래서 메모리를 반납할) 변수의 주소를 얻으려 하지 말라.
• 변수의 값을 변경할 Perl 동작을 수행할 때 매우 조심하라. 예를 들어, 변수의 뒤에 뭔가를 덧붙일 경우 저장 공간을 새로 할당해야만 될 때가 있고, 이 경우 사용자가 얻었던 포인터는 무의미한 곳을 가리키게 된다.
• 어떤 Perl 변수가 integer나 double 타입의 수를 저장한 상태에서 그 변수의 주소를 얻을 수 있다고 생각하지 말라! pack('P',$x)는, 마치 사용자가 $x .= '' 같은 코드를 작성한 것처럼, 그 변수의 내부 표현을 스트링 형태로 강제로 바꾼다.

2.9. Pack 비책들 Pack Recipes

    # IP 주소를 소켓 함수에 인자로 줄 수 있는 형태로 변환
    pack( "C4", split /\./, "123.4.5.6" );

    # 어떤 메모리 영역 내에서 1인 비트의 수 합산
    unpack( '%32b*', $mask );

    # 시스템이 어떤 엔디안을 사용하고 있는지 검사
    $is_little_endian = unpack( 'c', pack( 's', 1 ) );
    $is_big_endian = unpack( 'xc', pack( 's', 1 ) );

    # 시스템 고유의 integer 타입이 몇 비트를 차지하는지 검사
    $bits = unpack( '%32I!', ~0 );

    # nanosleep 시스템 호출의 인자를 준비
    my $timespec = pack( 'L!L!', $secs, $nanosecs );

주인장 보충:

위 예 중에

    # 시스템 고유의 integer 타입이 몇 비트를 차지하는지 검사
    $bits = unpack( '%32I!', ~0 );

이것은 제대로 동작하지 않는다(적어도 주인장이 테스트한 Perl 5.8.8에서는 그랬다). 아래처럼 바꿔야 한다.

    $bits = unpack( '%32B*', pack( 'I!', ~0 ) );

2.10. 재미있죠? Funnies Section

    # 어디에서 숫자를 끌어왔을까...
    print unpack( 'C', pack( 'x' ) ),
          unpack( '%B*', pack( 'A' ) ),
          unpack( 'H', pack( 'A' ) ),
          unpack( 'A', unpack( 'C', pack( 'A' ) ) ), "\n";

    # 이별을 하며 건배를 ;-)
    my $advice = pack( 'all u can in a van' );

2.11. 저자

3. perldoc -f pack - 문서 번역

• 원문: pack (Perl 5.10(136) 기준)

• a(137) - 임의의 바이너리 데이타로 이뤄진 스트링. 널로 채워짐
• A(138) - 텍스트(ASCII) 스트링, 스페이스로 채워짐
• Z(139) - 널로 끝나는 (ASCIZ) 스트링, 널로 채워짐

• b(140) - 비트 스트링 (vec과 같이, 각 바이트 내의 비트 순서는 오름차순.)
• B(141) - 비트 스트링 (각 바이트 내의 비트 순서는 내림차순.)
• h(142) - 16진수 스트링 (낮은 니블이 먼저)
• H(143) - 16진수 스트링 (높은 니블이 먼저)

• c(144) - 부호형 char (8-비트) 값.
• C(145) - 무부호형 char (octet) 값.
• W(146) - 무부호형 char 값. (255보다 큰 값 가능).

• s(147) - 부호형 short (16-비트) 값.
• S(148) - 무부호형 short 값.

• l(149) - 부호형 long (32-비트) 값.
• L(150) - 무부호형 long 값.

• q(151) - 부호형 quad (64-비트) 값.
• Q(152) - 무부호형 quad 값.
  • (시스템에서 64-비트 정수를 지원하고, 또한 Perl도 64-비트 정수를 지원하도록 컴파일되어 있어야 한다. 그렇지 않을 경우는 파탈 에러 발생)

• i(153) - 부호형 정수 값
• I(154) - 무부호형 정수 값
  • (여기서 말하는 '정수'는 최소 32비트이다. 정확한 사이즈는 C 컴파일러가 'int'타입을 어떻게 취급하느냐에 달려 있다.)

• n(155) - "network" (big endian(156)) 순서로 된 무부호형 short (16-비트)
• N(157) - "network" (big endian(158)) 순서로 된 무부호형 long (32-비트)
• v(159) - "VAX" (little endian(160)) 순서로 된 무부호형 short (16-비트)
• V(161) - "VAX" (little endian(162)) 순서로 된 무부호형 long (32-비트)

• j(163) - Perl 내부에서 사용하는 부호형 정수 값 (IV).
• J(164) - Perl 내부에서 사용하는 무부호형 정수 값 (UV).

• f(165) - 시스템 고유 포맷으로 된 단정도 부동소수
• d(166) - 시스템 고유 포맷으로 된 배정도 부동소수

• F(167) - 시스템 고유 포맷으로 된, Perl 내부에서 사용하는 부동소수 (NV)
• D(168) - 시스템 고유 포맷으로 된, long double-precision 부동소수
  • (long double은 시스템이 지원해야 하고 또한 Perl도 지원하도록 컴파일되어 있어야 한다. 그렇지 않은 경우 파탈 에러 발생)

• p(169) - 널로 끝나는 스트링을 가리키는 포인터
• P(170) - 구조체(고정길이 스트링)를 가리키는 포인터

• u(171) - uuencode(172) 된 스트링
• U(173) - Unicode(174) 캐릭터 번호. Encodes to a character in character mode and UTF-8 (or UTF-EBCDIC in EBCDIC platforms) in byte mode.

• w(175) - BER 압축된 정수 (ASN.1 BER은 아님, 자세한 것은 perlpacktut 문서를 볼 것). 이 바이트 시퀀스는 128진수로 된 무부호형 정수를 표현한다. 이 때 제일 높은 자릿수가 먼저 나오며, 최소한의 자릿수만 사용한다. 마지막 자릿수인 경우만 제외하고 각 자릿수의 8번째 비트(가장 높은 비트)는 1로 세팅된다.

• x(176) - 널 바이트.
• X(177) - 한 바이트 백업
• @(178) - 절대값으로 주어진 위치만큼 널로 채우거나 잘라냄. 위치는 가장 안쪽의 ()-그룹의 시작지점부터 센다.
• .(179) - 값에 명시된 절대적인 위치만큼 널로 채우거나 잘라냄.
• ((180) - ()-그룹의 시작 표시.

• !(181)
  • s S l L i I - 고정된(16-/32-비트) 크기 대신에 머신 고유의 (short, long, int) 크기를 사용하도록 강제함
  • x X - x와 X를 열맞춤 명령으로 동작하도록 함
  • n N v V - 무부호형 대신 부호형 정수로 취급하도록 함
  • @. - pack된 스트링의 내부적인 표현법에서의 바이트 오프셋으로 위치를 명세할 수 있게 함. 효율적이지만 위험하다.

• >(182)
  • s S i I l L q Q
  • j J f F d D p P
  • 해당 타입에 대해 big endian(183)을 사용하도록 강제함. (부등호의 "커다란 끝"이 생성자를 닿아 있음23)

• <(184)
  • s S i I l L q Q
  • j J f F d D p P
  • 해당 타입에 대해 little endian(185)을 사용하도록 강제함. (부등호의 "작은 끝"이 생성자에 닿아 있음)

• 각 (템플릿)문자는 추가로 반복 카운트(repeat count(186))를 나타내는 숫자가 뒤에 올 수 있다. 'a','A','Z','b','B','h','H','@','.','x','X','P'를 제외하고 나머지 타입들에서는 반복 카운트 숫자에 있는 갯수 만큼의 값들을 LIST에서 가져다 쓴다.24 반복 카운트 대신 '*(187)'를 사용하면 남아 있는 아이템 전부를 사용하라는 의미인데, 다음의 경우는 예외이다: '@','x','X'의 경우는 "0"과 같다; '<','>'의 경우에는 스트링이 어떻게 시작하느냐에 따라 다르다; 'u'의 경우에는 1(또는 45, 결과적으로 동일하다)과 같다. 숫자로 이뤄진 반복횟수는 "pack 'C[80]', @arr"과 같이 대괄호 안에 적어줄 수도 있다.

숫자로 이뤄진 반복횟수 대신에 대괄호로 둘러싼 템플릿을 적어 줄 수 있다; 이 경우 그 템플릿을 pack한 결과의 길이(바이트 단위)가 카운트 값으로 사용된다. 예를 들어서, "x[L]"은 long만큼 스킵한다(즉 long타입이 차지하는 바이트의 수만큼 스킵); "$t X[$t] $t"는 $t가 unpack하는 대상을 두 번 unpack하게 된다. If the template in brackets contains alignment commands (such as "x![d]" ), its packed length is calculated as if the start of the template has the maximal possible alignment.25

'*'가 'z'와 함께 사용될 경우, 끝에 널 바이트를 추가하게 된다 (따라서 pack된 결과의 길이는 pack하는 대상 항목에 대해 length 함수를 수행한 결과보다 1이 더 클 것이다)

반복 카운트가 '@'와 함께 쓰일 경우, 가장 안쪽의 ()그룹의 시작 지점으로부터의 오프셋을 의미한다.

When used with ., the repeat count is used to determine the starting position from where the value offset is calculated. If the repeat count is 0, it's relative to the current position. If the repeat count is * , the offset is relative to the start of the packed string. And if its an integer n the offset is relative to the start of the n-th innermost () group (or the start of the string if n is bigger then the group level).

The repeat count for u is interpreted as the maximal number of bytes to encode per line of output, with 0, 1 and 2 replaced by 45. The repeat count should not be more than 65.

• The a , A , and Z 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 whitespace and nulls, Z strips everything after the first null, and a returns data verbatim.

If the value-to-pack is too long, it is truncated. If too long and an explicit count is provided, Z packs only $count-1 bytes, followed by a null byte. Thus Z always packs a trailing null (except when the count is 0).

• Likewise, the b and B fields pack a string that many bits long. Each character of the input field of pack() generates 1 bit of the result. Each result bit is based on the least-significant bit of the corresponding input character, i.e., on ord($char)%2. In particular, characters "0" and "1" generate bits 0 and 1, as do characters "\0" and "\1" .

Starting from the beginning of the input string of pack(), each 8-tuple of characters is converted to 1 character of output. With format b the first character of the 8-tuple determines the least-significant bit of a character, and with format B it determines the most-significant bit of a character.

If the length of the input string is not exactly divisible by 8, the remainder is packed as if the input string were padded by null characters at the end. Similarly, during unpack()ing the "extra" bits are ignored.

If the input string of pack() is longer than needed, extra characters are ignored. A * for the repeat count of pack() means to use all the characters of the input field. On unpack()ing the bits are converted to a string of "0" s and "1" s.

• The h and H fields pack a string that many nybbles (4-bit groups, representable as hexadecimal digits, 0-9a-f) long.

Each character of the input field of pack() generates 4 bits of the result. For non-alphabetical characters the result is based on the 4 least-significant bits of the input character, i.e., on ord($char)%16. In particular, characters "0" and "1" generate nybbles 0 and 1, as do bytes "\0" and "\1" . For characters "a".."f" and "A".."F" the result is compatible with the usual hexadecimal digits, so that "a" and "A" both generate the nybble 0xa==10 . The result for characters "g".."z" and "G".."Z" is not well-defined.

Starting from the beginning of the input string of pack(), each pair of characters is converted to 1 character of output. With format h the first character of the pair determines the least-significant nybble of the output character, and with format H it determines the most-significant nybble.

If the length of the input string is not even, it behaves as if padded by a null character at the end. Similarly, during unpack()ing the "extra" nybbles are ignored.

If the input string of pack() is longer than needed, extra characters are ignored. A * for the repeat count of pack() means to use all the characters of the input field. On unpack()ing the nybbles are converted to a string of hexadecimal digits.

• 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 type packs a pointer to a structure of the size indicated by the length. A NULL pointer is created if the corresponding value for p or P is undef, similarly for unpack().

If your system has a strange pointer size (i.e. a pointer is neither as big as an int nor as big as a long), it may not be possible to pack or unpack pointers in big- or little-endian byte order. Attempting to do so will result in a fatal error.

• The / template character allows packing and unpacking of a sequence of items where the packed structure contains a packed item count followed by the packed items themselves.

For pack you write length-item/sequence-item and the length-item describes how the length value is packed. The ones likely to be of most use are integer-packing ones like n (for Java strings), w (for ASN.1 or SNMP) and N (for Sun XDR).

For pack, the sequence-item may have a repeat count, in which case the minimum of that and the number of available items is used as argument for the length-item. If it has no repeat count or uses a '*', the number of available items is used.

For unpack an internal stack of integer arguments unpacked so far is used. You write /sequence-item and the repeat count is obtained by popping off the last element from the stack. The sequence-item must not have a repeat count.

If the sequence-item refers to a string type ("A" , "a" or "Z" ), the length-item is a string length, not a number of strings. If there is an explicit repeat count for pack, the packed string will be adjusted to that given length.

    unpack 'W/a', "\04Gurusamy";            gives ('Guru')
    unpack 'a3/A A*', '007 Bond  J ';       gives (' Bond', 'J')
    unpack 'a3 x2 /A A*', '007: Bond, J.';  gives ('Bond, J', '.')
    pack 'n/a* w/a','hello,','world';       gives "\000\006hello,\005world"
    pack 'a/W2', ord('a') .. ord('z');      gives '2ab'

The length-item is not returned explicitly from unpack.

Adding a count to the length-item letter is unlikely to do anything useful, unless that letter is A , a or Z . Packing with a length-item of a or Z may introduce "\000" characters, which Perl does not regard as legal in numeric strings.

• The integer types s, S , l , and L may be followed by a ! modifier to signify native shorts or longs--as you can see from above for example a bare l does mean exactly 32 bits, the native long (as seen by the local C compiler) may be larger. This is an issue mainly in 64-bit platforms. You can see whether using ! makes any difference by

        print length(pack("s")), " ", length(pack("s!")), "\n";
        print length(pack("l")), " ", length(pack("l!")), "\n";

i! and I! also work but only because of completeness; they are identical to i and I .

The actual sizes (in bytes) of native shorts, ints, longs, and long longs on the platform where Perl was built are also available via Config:

       use Config;
       print $Config{shortsize},    "\n";
       print $Config{intsize},      "\n";
       print $Config{longsize},     "\n";
       print $Config{longlongsize}, "\n";

(The $Config{longlongsize} will be undefined if your system does not support long longs.)

• The integer formats s, S , i , I , l , L , j , and J are inherently non-portable between processors and operating systems because they obey the native byteorder and endianness. For example a 4-byte integer 0x12345678 (305419896 decimal) would be ordered natively (arranged in and handled by the CPU registers) into bytes as

        0x12 0x34 0x56 0x78     # big-endian
        0x78 0x56 0x34 0x12     # little-endian

Basically, the Intel and VAX CPUs are little-endian, while everybody else, for example Motorola m68k/88k, PPC, Sparc, HP PA, Power, and Cray are big-endian. Alpha and MIPS can be either: Digital/Compaq used/uses them in little-endian mode; SGI/Cray uses them in big-endian mode.

The names `big-endian' and `little-endian' are comic references to the classic "Gulliver's Travels" (via the paper "On Holy Wars and a Plea for Peace" by Danny Cohen, USC/ISI IEN 137, April 1, 1980) and the egg-eating habits of the Lilliputians.

Some systems may have even weirder byte orders such as

        0x56 0x78 0x12 0x34
        0x34 0x12 0x78 0x56

You can see your system's preference with

        print join(" ", map { sprintf "%#02x", $_ }
                            unpack("W*",pack("L",0x12345678))), "\n";

The byteorder on the platform where Perl was built is also available via Config:

        use Config;
        print $Config{byteorder}, "\n";

Byteorders '1234' and '12345678' are little-endian, '4321' and '87654321' are big-endian.

If you want portable packed integers you can either use the formats n , N , v , and V , or you can use the > and < modifiers. These modifiers are only available as of perl 5.9.2. See also perlport.

• All integer and floating point formats as well as p and P and () -groups may be followed by the > or < modifiers to force big- or little- endian byte-order, respectively. This is especially useful, since n , N , v and V don't cover signed integers, 64-bit integers and floating point values. However, there are some things to keep in mind.

Exchanging signed integers between different platforms only works if all platforms store them in the same format. Most platforms store signed integers in two's complement, so usually this is not an issue.

The > or < modifiers can only be used on floating point formats on big- or little-endian machines. Otherwise, attempting to do so will result in a fatal error.

Forcing big- or little-endian byte-order on floating point values for data exchange can only work if all platforms are using the same binary representation (e.g. IEEE floating point format). Even if all platforms are using IEEE, there may be subtle differences. Being able to use > or < on floating point values can be very useful, but also very dangerous if you don't know exactly what you're doing. It is definitely not a general way to portably store floating point values.

When using > or < on an () -group, this will affect all types inside the group that accept the byte-order modifiers, including all subgroups. It will silently be ignored for all other types. You are not allowed to override the byte-order within a group that already has a byte-order modifier suffix.

• 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). See also perlport.

If you know exactly what you're doing, you can use the > or < modifiers to force big- or little-endian byte-order on floating point values.

Note that Perl uses doubles (or long doubles, if configured) 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).

• Pack and unpack can operate in two modes, character mode (C0 mode) where the packed string is processed per character and UTF-8 mode (U0 mode) where the packed string is processed in its UTF-8-encoded Unicode form on a byte by byte basis. Character mode is the default unless the format string starts with an U . You can switch mode at any moment with an explicit C0 or U0 in the format. A mode is in effect until the next mode switch or until the end of the ()-group in which it was entered.

• You must yourself do any alignment or padding by inserting for example enough 'x' es while packing. There is no way to pack() and unpack() could know where the characters are going to or coming from. Therefore pack (and unpack) handle their output and input as flat sequences of characters.

• A ()-group is a sub-TEMPLATE enclosed in parentheses. A group may take a repeat count, both as postfix, and for unpack() also via the / template character. Within each repetition of a group, positioning with @ starts again at 0. Therefore, the result of

    pack( '@1A((@2A)@3A)', 'a', 'b', 'c' )

• x and X accept ! modifier. In this case they act as alignment commands: they jump forward/back to the closest position aligned at a multiple of count characters. For example, to pack() or unpack() C's struct {char c; double d; char cc[2]} one may need to use the template W x![d] d W[2] ; this assumes that doubles must be aligned on the double's size.

For alignment commands count of 0 is equivalent to count of 1; both result in no-ops.

• n , N , v and V accept the ! modifier. In this case they will represent signed 16-/32-bit integers in big-/little-endian order. This is only portable if all platforms sharing the packed data use the same binary representation for signed integers (e.g. all platforms are using two's complement representation).

• A comment in a TEMPLATE starts with # and goes to the end of line. White space may be used to separate pack codes from each other, but modifiers and a repeat count must follow immediately.

• If TEMPLATE requires more arguments to pack() than actually given, pack() assumes additional "" arguments. If TEMPLATE requires fewer arguments to pack() than actually given, extra arguments are ignored.

    $foo = pack("WWWW",65,66,67,68);
    # foo eq "ABCD"
    $foo = pack("W4",65,66,67,68);
    # same thing
    $foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9);
    # same thing with Unicode circled letters.
    $foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
    # same thing with Unicode circled letters. You don't get the UTF-8
    # bytes because the U at the start of the format caused a switch to
    # U0-mode, so the UTF-8 bytes get joined into characters
    $foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9);
    # foo eq "\xe2\x92\xb6\xe2\x92\xb7\xe2\x92\xb8\xe2\x92\xb9"
    # This is the UTF-8 encoding of the string in the previous example

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

    # note: the above examples featuring "W" and "c" are true
    # only on ASCII and ASCII-derived systems such as ISO Latin 1
    # and UTF-8.  In EBCDIC the first example would be
    # $foo = pack("WWWW",193,194,195,196);

    $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)

    $utmp_template = "Z8 Z8 Z16 L";
    $utmp = pack($utmp_template, @utmp1);
    # a struct utmp (BSDish)

    @utmp2 = unpack($utmp_template, $utmp);
    # "@utmp1" eq "@utmp2"

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

    $foo = pack('sx2l', 12, 34);
    # short 12, two zero bytes padding, long 34
    $bar = pack('s@4l', 12, 34);
    # short 12, zero fill to position 4, long 34
    # $foo eq $bar
    $baz = pack('s.l', 12, 4, 34);
    # short 12, zero fill to position 4, long 34

    $foo = pack('nN', 42, 4711);
    # pack big-endian 16- and 32-bit unsigned integers
    $foo = pack('S>L>', 42, 4711);
    # exactly the same
    $foo = pack('s<l<', -42, 4711);
    # pack little-endian 16- and 32-bit signed integers
    $foo = pack('(sl)<', -42, 4711);
    # exactly the same

4. 관련 문서

• pack
• unpack

• [pack,unpack,vec - aero님의 노트]
• [Pack/Unpack Tutorial (aka How the System Stores Data)]
• [h0ney의 이야기들.. :: perl pack/unpack]

5. 기타, comments