aero님의 노트

Unicode in Perl

Fri, 14 Nov 2008 15:37:37 +0900

Unicode in Perl

Unicode란?

세계의 각문자를 코드포인트(code point)에 배정시킨 것.
코드(code)는 코드테이블의 코드값 자체를 말함
인코딩(encoding)은 자료교환을 위해 코드를 특정한 형태로 표현하는 것 - [ USC-2, USC-4 ], UTF-8, UTF-16, UTF-32
상세사항 참고

유니코드의 기본구조

UCS코드 체계는 그림과 같이 그룹, 평면, 행, 셀 4개의 octet으로 구성되며 각 octet은 16진수 00~FF의 값을 가진다. UCS코드 체계의 부호화 공간은 128(0x00~0x7F)개의 그룹으로 구성되어 있으며 각 그룹은 256(0x00~0xFF)개의 평면을 가지고 각 평면은 256x256개의 cell을 가진다. 4개의 octet을 모두 사용하는 것을 UCS-4 라고 하며 평면하나만 사용해서 행 octet과 열 octet의 2개의 octets로 표현하는것을 UCS-2 라고 한다. 여기서 UCS-4는 4바이트 코드체계 이지만 최상위 bit는 늘 0으로 두고 나머지 31bit만을 사용하므로 그룹갯수는(0x00~0x7F)개가 된다. ( UCS-2, UCS-4 는 코드포인트이자 그 자체로 인코딩이다. )

unicode 3.0 (ISO/IEC 10646-1:2000)
- 16bit = 2 octets (ISO 용어) = 2 bytes (유니코드 컨소시엄 용어)
- 0x0000 ~ 0xFFFD
- 1개의 기본영역다중언어판(BMP, Basic Multilingual Plane) - 256x256 cells, |행octet|열octet| -> 코드포인트
- 256*256 = 2^16 = 65,536개의 코드포인트, 실제사용 코드포인트는 49,194개, UCS-2(코드포인트이자 인코딩자체)
unicode 3.1
- 65,536개의 코드포인트로도 모자라자 보충언어판(supplementary planes - 0~16 총17개 모두 평면00에 속함, BMP는 0에 해당 )를 정의
- 0x0000 ~ 0x10FFFD
- BMP의 2,048자를 대행코드(surrogates)로 할당하고 각 1,024자씩을 상위대행(high surrogates - 0xD800~0xDBFF),하위대행(low surrogates - 0xDC00~0xDFFF)로 정의하여 이 둘의 조합으로 다시 1024*1024=1048576 문자를 추가로 정의할 수 있도록 하였음 -> UTF-16
- ensurrogate: $hi = ($uni - 0x10000) / 0x400 + 0xD800; , $lo = ($uni - 0x10000) % 0x400 + 0xDC00;
- desurrogate: $uni = 0x10000 + ($hi - 0xD800) * 0x400 + ($lo -0xDC00);
- UTF-16 인코딩 -> 16bit에서는 UCS-2와 거의 동일, 보충언어판을 인코딩할때는 high/low surrogate의 조합(32bit)로 1048576개의 문자 추가 인코딩 가능
- 0x10300 코드포인트를 UTF-16으로 인코딩 한다면 UCS-2영역을 벗어나므로 32bit로 인코딩해야함
  - ensurrogate식에 $uni=0x10300을 대입하면 0xD800_DF00 으로 인코딩됨.(UTF-16에서는 상위대행코드가 나오면 반드시 하위대행코드가 따라옴)

현재는 Unicode 5.1 까지 나와있다.

Perl에서의 코드포인트 처리

Perl에서는 특별히 surrogates(\x{D800}~\x{DFFF})에 대해서 사용을 금지하지 않으며(검사로 인한 속도저하 때문?) \x{0000_0000} ~ \x{ffff_ffff}영역은 모두 일단 문자로 취급한다.

Unicode의 인코딩

UTF-8(문자에 따라 보통 1~4 또는 UCS-4 전 영역까지 포함할 경우 6바이트로 표현)
UTF-16(2바이트혹은 보충언어판영역에 대해 high/low surrogate를 사용 4바이트로 표현) - UCS-2와 흡사하지만 Surrogate 영역을 이용하여 보충언어판을 표현할 수 있으므로 UCS-2는 UTF-16의 부분집합으로 볼 수 있음
UTF-32(4바이트로 표현) - USC-4와 동일하지만 17개의 보충언어판만 지원하므로 UCS-4의 부분집합으로 볼 수 있음.
Big Endian, Little Endian 머신에 따라 Byte order를 지정해주기 위해 인코딩 문자열 선두에 BOM을 붙임, UTF-8은 Byte order와 상관없는 인코딩이지만 Windows에서는 UTF-8에 대해서도 붙인다.(이것 때문에 Windows<->UNIX간 자료교환시 문제가 발생할 수 있으므로 주의)
참고: http://en.wikipedia.org/wiki/Byte-order_mark

UTF-8이 널리 사용되는 이유

UTF-8를 제외한 인코딩 방식은 C등에서 전통적인 char형으로 문자열을 취급하게 되면 인코딩된 다중 byte의 일부분에 널(null,0)이 들어갈 수 있어 지금까지 개발된 프로그램들에서 문자열의 끝을 잘 못 인식하는 문제발생의 소지가 있으므로 ASCII 영역에서는 1바이트 UTF-8 인코딩과 완전히 일치되며 중간에 null바이트가 나타나지 않도록 고안되어 이런 문제가 발생하지 않는 UTF-8 인코딩이 널리 사용됨.

UTF-8 의 인코딩 규칙

UCS-4    UTF-8
0x00000000 - 0x0000007F    0xxxxxxx (ASCII 영역에서는 일치 - ASCII코드만 사용하는 경우 기존의 프로그램 수정이 필요없다는 의미)
0x00000080 - 0x000007FF    110xxxxx 10xxxxxx
0x00000800 - 0x0000FFFF    1110xxxx 10xxxxxx 10xxxxxx
0x00010000 - 0x001FFFFF    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx ( 17개의 보충언어판을 포함한 범위는 0x10FFFD 까지이므로 4byte까지로 표현됨)
0x00200000 - 0x03FFFFFF    111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
0x04000000 - 0x7FFFFFFF    1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

utf-16 같이 surrogate pair에 의한 삽질(?)이 필요 없으며 코드포인트 자체를 규칙에 따라 그대로 인코딩 하면된다.

Perl의 유니코드

Perl에서 유니코드처리는 5.6.0 ~ 5.8.x 버젼을 거치면서 발달해왔다. 유니코드를 자체적으로 지원할 수 있는 기능추가는 5.6.0 버젼부터 시작되었다. 하지만 아주 엄밀하게 유니코드를 지원할 수 있다고 추천되는 버젼은 5.8.0 버젼부터 이며. 5.6.1 버젼에서 초기 유니코드 구현의 버그가 많이 수정되었지만 정규표현식 같은것은 여전히 5.6.1 버젼에서는 동작하지 않는다. 그 이전 버젼에서 유니코드 처리는 Perl의 자체적인 지원이 부족하여 Text::Iconv 같은 모듈 등등을 사용했지만 최근버젼들에서는 use utf8; pragma와 Encode모듈 등으로 Perl native한 지원이 거의 완벽해져서 따로 그 같은 모듈을 사용하지 않아도 된다.

문자열(Text string, Character string) - 사람이 읽을수 있는 문자들의 연속체

바이너리열(Binary string, Bytes string ) - Byte의 연속체, Perl process 외부와 소통하는 모든것들

인코딩(encoding) - 문자열을 바이너리열으로 변환하는 것 ( 내부적 인코딩 iso-8859-1, utf-8 -> 플래그로 구별)

디코딩(decoding) - 바이너리열을 문자열로 변환하는 것

내부포멧(internal format) - 문자열을 내부포멧으로 인코딩(Perl은 utf-8을 사용)해서 메모리에 저장한다.

iso-8859-1(latin1) 인코딩

Perl은 기본으로는 문자열을 iso-8859-1(latin1)인코딩으로 저장한다.

( iso-8859-1(latin1)은 서유럽 언어의 표기에 필요한 ASCII의 영역을 넘어 ASCII에 없는 94개의 글자의 순차적 나열임 U+0000~U+00FF (을)를 0x00~0xff 의1 바이트에 매핑하는 인코딩 )

보통 euc-kr 같은 로컬인코딩의 경우 Byte 하나하나씩 봤을 때 iso-8859-1의 코드영역이 모두 커버하므로 그대로 입출력 가능하다. 하지만 euc-kr의 한글같은 경우 2바이트가 한글자이나 Perl은 이것을 한 문자라고 인식하지 못한다. 입출력시 그냥 건드리지 않고 처리.

codepoint( \x{16진수} )를 지정했을 경우 \x{ff}를 초과한 것들은 Perl이 유니코드로 인식하여 자동으로 내부포멧이 utf-8인코딩으로 변환되며 utf-8 flag가 켜진다. (이때 문자열 내에 ASCII영역(\x{00}~\x{7f}) 영역을 넘는 문자들은 모두 같이 인코딩이 utf-8으로 변경된다.) 문자열의 utf-8플래그가 켜지면 각종 문자열 처리함수 및 정규식등에서 바이트단위가 아닌 문자단위처리를 한다.

"eé가" 문자열에서 "é가"를 유니코드 codepoint로 지정하여 테스트

문자 codepoint UTF-8

é U+00E9 c3-a9

가 U+AC00 ea-b0-80

<코드>

#!/usr/bin/perl

use Devel::Peek;

my $s1="e\x{e9}\x{ac00}";
print length $s1,"\n";
Dump($s1);

<결과>

3 <- 내부적으로 UTF-8인코딩 6바이트이나 문자단위 처리를 하므로 문자열의 길이는 3으로 찍혔음
SV = PVMG(0x12c21f4) at 0x3d6f90
REFCNT = 1
FLAGS = (PADBUSY,PADMY,SMG,POK,pPOK,UTF8) <- UTF-8 flag가 켜졌음
IV = 0
NV = 0
PV = 0x12c34f4 "e\303\251\352\260\200"\0 [UTF8 "e\x{e9}\x{ac00}"] <- 내부적 UTF-8 인코딩 ( e, \xc3,\xa9, \xea,\xb0,\x80 )
CUR = 6
LEN = 8
MAGIC = 0x12c32fc
    MG_VIRTUAL = &PL_vtbl_utf8
    MG_TYPE = PERL_MAGIC_utf8(w)
    MG_LEN = 3

use utf8;

Perl에서 소스코드에 utf-8 인코딩 문자열을 사용하려면 use utf8; pragma를 사용한다. 선언후 wellformed utf8 인코딩 문자열이 나오면 Perl이 자동으로 Perl 내부 문자열 포멧으로 변경하면서 utf-8 flag를 넣어준다. 이 동작은 utf8 인코딩이 아니면서 0-127 범위를 벗어난 코드를 가지는 iso-8859-1(latin1)이나 기타 로컬코드문자가 들어오면 (utf-8인코딩 입장에서는 malformed utf-8으로 인식됨)억지로 utf8으로 변환하고자 하면서 깨지는 문제가 발생. codepoint( \x{16진수} )를 지정할 경우 \x{ff}를 초과한 것들은 Perl이 유니코드로 인식하여 자동으로 내부포멧이 utf-8인코딩으로 변환되는건 마찬가지.

이 pragma는 소스코드가 utf-8인코딩을 사용하고 소스코드 안에서 눈으로 읽을 수 있는 utf-8문자열을 사용할 때 이외는 사용할 필요가 없다.

utf-8인코딩으로 코드를 작성하여 테스트

<코드>

#!/usr/bin/perl
use Devel::Peek;
use utf8;

my $s = "가";
print length $s,"\n";
Dump($s);

my $s1="\x{ac00}";
print length $s1,"\n";
Dump($s1);

my $s2="\x{ea}\x{b0}\x{80}";
print length $s2,"\n";
Dump($s2);

<결과>

1
SV = PVMG(0xa8191c) at 0x3d6044
REFCNT = 1
FLAGS = (PADBUSY,PADMY,SMG,POK,pPOK,UTF8)
IV = 0
NV = 0
PV = 0x3dd9ec "\352\260\200"\0 [UTF8 "\x{ac00}"]
CUR = 3
LEN = 4
MAGIC = 0xa823ac
    MG_VIRTUAL = &PL_vtbl_utf8
    MG_TYPE = PERL_MAGIC_utf8(w)
    MG_LEN = 1
1
SV = PVMG(0xa8193c) at 0x3d602c
REFCNT = 1
FLAGS = (PADBUSY,PADMY,SMG,POK,pPOK,UTF8)
IV = 0
NV = 0
PV = 0x3df43c "\352\260\200"\0 [UTF8 "\x{ac00}"]
CUR = 3
LEN = 4
MAGIC = 0xa82484
    MG_VIRTUAL = &PL_vtbl_utf8
    MG_TYPE = PERL_MAGIC_utf8(w)
    MG_LEN = 1
3 <--- utf-8 플래그가 켜져있지 않으므로 Byte기반으로 처리해서 3글자로 인식
SV = PV(0x3d617c) at 0xa9378c
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK)
PV = 0xa8398c "\352\260\200"\0 <--- 2번째와 바이너리열은 같지만 utf-8 flag가 켜져 있지 않다.(내부적 인코딩은 utf-8이지만 utf-8 flag가 켜져 있지 않으므로 Perl은 이것이 utf-8 인코딩이라고 인식하지 못한다.)
CUR = 3
LEN = 4

use encoding ...; pragma

http://search.cpan.org/perldoc?encoding

Dan Kogai씨가 만든 Encode 모듈에 포함되어 있는 기능이며 입출력/파일 I/O에 대한 인코딩을 지정하여 프로그램 내부로 읽어들이면 프로그램 내부적으로 모두 유니코드로 다루는 구조이나 use utf8; pragma와는 달리 ASCII영역(\x{00}~\x{7f})을 넘는 문자열 뿐만 아니라 바이너리열에 대해서도 무조건 utf-8인코딩으로 변환시켜 버리므로 기존 iso-8859-1을 사용하는 legacy코드들과 호환성에 문제가 있다. Perl 유니코드 관련 문서들에 소개가 되고 있으나 최근 설계가 잘못되었다는 지적이 제기되며 Dan Kogai씨도 이를 인정하고 deprecate 시키고 싶다고 했으므로 사용하지 않을 것을 추천

Perl에서 왜 유니코드처리시 문자가 깨지는가?

Perl은 내부적으로 wellformed utf8 인코딩이며 utf-8 flag가 켜져있을때 제대로된 유니코드 처리를 할 수 있다. Perl에서 문자열/데이터 처리시 깨지는 경우는 wellformed utf8/utf-8 flag on 데이터와 iso-8859-1인코딩 데이터, wellformed utf8이나 utf-8 flag가 켜져있지 않는 문자열이 합쳐질때 발생한다. 이경우 wellformed utf8/utf-8 flag on 데이터와 합쳐지는 데이터들은 byte하나하나가 codepoint로 인식되어 utf-8으로 인코딩 되므로 깨지게 되는것이다.

이런과정을 테스트해보면.

<코드>

#!/usr/bin/perl
use strict;
use warnings;
use Devel::Peek;

my $s1="\x{ea}\x{b0}\x{80}"; #wellformed utf-8/utf-8 flag off "가"
Dump($s1);
my $s2="\x{ac00}"; #wellformed utf-8/utf-8 flag on "가"
Dump($s2);
my $s3 = $s2.$s1;
Dump($s3);

<결과>

SV = PV(0x3d708c) at 0x3d6f48
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK)
PV = 0x3de8fc "\352\260\200"\0
CUR = 3
LEN = 4
SV = PV(0x3d70e0) at 0x3d6f30
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK,UTF8)
PV = 0x3dfb74 "\352\260\200"\0 [UTF8 "\x{ac00}"]
CUR = 3
LEN = 4
SV = PV(0x3d7110) at 0x3d6f6c
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK,UTF8)
PV = 0x12cf74c "\352\260\200\303\252\302\260\302\200"\0 [UTF8 "\x{ac00}\x{ea}\x{b0}\x{80}"]
CUR = 9
LEN = 12

처음과 두번째의 내부적 바이너리열은 같지만 첫번째는 utf-8 flag off 두번째는 on이다. 이 두개를 합쳤을때 첫번째 \x{ea}\x{b0}\x{80}가 각각 codepoint로 인식되어 \303\252\302\260\302\200 utf-8인코딩으로 잘 못 변환되었음을 볼 수 있다.

Perl에서 유니코드들을 깨지지 않게 하려면?

앞에서도 말했다시피 Perl에서 유니코드가 깨지지 않게 하려면 문자열을 조작하기전 모두 wellformed utf-8/ utf-8 flag on 상태(Perl 내부 유니코드 저장 포멧)로 만들 필요가 있으며 I/O(STDIN,file,socket등)를 통해 외부에서 받아들인 데이터는 명시적으로 wellformed utf-8/ utf-8 flag on 상태로 만들어야 한다.

(실제로는 Perl내부에서 어떠한 형태로 유니코드가 저장되는지는 사용자 입장에서 알 필요가 없으며 넣고 꺼낼때 명시적인 규칙을 따라서 해주면 내부 동작은 알 필요가 없는 블랙박스처럼 동작한다고 생각하면 된다.)

이런 상태로 만드는 방법에는 읽어들이는 I/O Layer에 encoding을 명시적으로 지정하거나 일단 읽어들인 다음 Encode모듈의 decode 함수에 입력 인코딩을 명시적으로 지정하여 Perl 내부 문자열 포멧으로 변환 시키는 두가지 방법이 있다.

<euc-kr.txt> -> euc-kr 포멧

가나다

<코드>

#!/usr/bin/perl
use strict;
use warnings;
use Devel::Peek;
use Encode;

open my $fh1, '<', 'euc-kr.txt';
my $euc_kr = <$fh1>; # 일단 euc-kr 인코딩 자체로 읽어들임
print $euc_kr,"\n";
Dump($euc_kr);
my $utf_8 = decode('euc-kr',$euc_kr); # decode 함수로 Perl 내부 유니코드 저장 포멧으로 변경
print $utf_8,"\n"; # STDOUT(표준출력)의 인코딩이 utf-8으로 지정되어 있지 않으므로 Wide character in print 에러가 발생.
Dump($utf_8);

open my $fh2, '<:encoding(euc-kr)', 'euc-kr.txt'; # 파일 I/O에 대해 명시적으로 인코딩을 지정하여 읽어들임
# 이미 열린 파일핸들에 대해 인코딩을 지정하려면
# binmode $fh2, ':encoding(euc-kr)';
$utf_8 = <$fh2>;
binmode STDOUT, ':utf8'; # STDOUT의 인코딩을 명시적으로 utf-8인코딩으로 변경.
print $utf_8,"\n"; # Wide character in print 에러가 발생하지 않음
Dump($utf_8);

<결과>

가나다
SV = PV(0x3d708c) at 0x3d6f00
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK)
PV = 0x138d65c "\260\241\263\252\264\331"\0
CUR = 6
LEN = 80
Wide character in print at e.pl line 12, <$fh1> line 1.
媛€?섎떎
SV = PV(0x3d7530) at 0x1325e1c
REFCNT = 1
FLAGS = (PADBUSY,PADMY,POK,pPOK,UTF8)
PV = 0x138a23c "\352\260\200\353\202\230\353\213\244"\0 [UTF8 "\x{ac00}\x{b098}\x{b2e4}"]
CUR = 9
LEN = 12
媛€?섎떎
SV = PVMG(0x1371b04) at 0x1325e1c
REFCNT = 1
FLAGS = (PADBUSY,PADMY,SMG,POK,pPOK,UTF8)
IV = 0
NV = 0
PV = 0x138a23c "\352\260\200\353\202\230\353\213\244"\0 [UTF8 "\x{ac00}\x{b098}\x{b2e4}"]
CUR = 9
LEN = 12
MAGIC = 0x13bca7c
    MG_VIRTUAL = &PL_vtbl_utf8
    MG_TYPE = PERL_MAGIC_utf8(w)
    MG_LEN = 3

결과를 보면 첫번째는 euc-kr 인코딩 그대로이며 두번째 세번째는 모두 Perl내부 유니코드 포멧으로 변환되었음을 볼 수 있다. 그리고 여기서 눈여겨 볼 것은 두번째의 Wide character in print 에러인데 이것은 Perl 내부 유니코드 포멧을 명시적으로 인코딩이 지정되지 않은 I/O 인터페이스로 출력하려고 할때 발생한다. 반면 3번째에서는 STDOUT에 대해 utf-8으로 인코딩을 명시적으로 지정했으므로 그런 에러가 발생하지 않았다. 만약 코드의 마지막에서 3째줄의 binmode STDOUT, ':utf8'; 를 binmode STDOUT, ':encoding(euc-kr)'; 로 바꾸고 실행하면 Perl내부 유니코드 포맷이 euc-kr 인코딩으로 잘 변환되어 원래의 euc-kr "가나다" 문자열이 출력될 것이다.

Perl Unicode 조언

Perl 유니코드에 관해서 perlunitut, perlunifaq 문서를 작성하는 등 깊은 지식을 가지고 있는 Juerd Waalboer씨의 Perl Unicode조언을 참고하면 많은 문제점을 사전에 회피할 수 있다.

참고: http://juerd.nl/site.plp/perluniadvice

기타참고 문서

perluniintro - Perl Unicode introduction
perlunicode - Unicode support in Perl
Encode - character encodings
Encode::Unicode - Various Unicode Transformation Formats
Unicode-processing issues in Perl and how to cope with it
- http://ahinea.com/en/tech/perl-unicode-struggle.html
Unicode support in Perl

Perlmania( http://www.perlmania.or.kr ) 에 올라온 질문에 대한 답변 정리.

>과거에 use strict 를 사용하기 전에는, 한글 (UTF-8) 문자열을 폼으로 입력받아서
>화면상에 찍었을 때, 아무 문제 없이 화면상에 깨지지 않고 출력되었습니다만,
>새로 코드를 짜면서 테스트를 진행하니, 화면상에 출력되는 모든 UTF-8 한글 코드들은
>decode("utf8") 를 통해서 UTF-8 문자열임을 명시적으로 찍어주지 않으면 글자가 다 깨지는군요.
>덕분에 전에는 전혀 신경쓸 필요가 없던 출력단 부분에 일일이 decode 를 찍어주고 있습니다.
>(재미있는게, 정상적으로 출력되도록 decode를 찍어준 문자열이나, decode를 찍어주기 전 문자열이나 16진수 비교를 해보면 똑같습니다. -_-;;;)
>

일단 "decode를 찍어준 문자열이나, decode를 찍어주기 전 문자열이나 16진수 비교를 해보면 똑같습니다. " 에 대한 답은
두 문자열이 옥텟열(바이트 스트림)은 같은데 다르게 동작하는 것은 utf8 플래그기 있냐 없느냐의 차이일 겁니다. Perl은 내부적으로 UTF8인코딩으로 유니코드 문자열을 저장하는데 use utf8; 프래그마를 사용하고 utf8인코딩으로 코드를 작성하면 문자열에서 ASCII영역을 벗어난 문자가 있으면 utf8 플래그를 켭니다.
이것은 use Devel::Peek; 한다음 Dump(문자열)로 확인해보시면 utf8플래그를 볼 수 있을 겁니다.

Perl에서 unicode를 다룰 때 다음과 같은 기본 개념을 잡고 있으면 전혀 헷갈리지 않습니다.

                                     --인코딩지정-->
옥텟열(바이트스트림)           decode함수           Perl 내부유니코드 포멧
                                    <--인코딩지정 --        (utf8인코딩,utf8플래그on)
                                       encode함수

Perl 내부유니코드 포멧은 사용자 입장에서는 사실 내부적으로 어떤 인코딩을 쓰고 어떤 방식으로 동작하는지 알 필요가 없습니다. 그냥 넣고 뺄 때 일관성있는 규칙과 방법을 적용하면 내부 동작을 신경 쓸 필요가 없기 때문에 일종의 블랙박스로 보면되죠..

1. Perl 프로세스 외부에서 파일,표준입력,소켓등의 I/O 통해 받아들이는 문자열은 단순히 옥텟열이다.

2. 옥텟열이 어떤 인코딩을 사용하고 있느냐를 알려줘서 그것을 Perl 내부유니코드포멧으로 변환하는 것이 Encode모듈의 decode 함수다.

( decode함수를 쓰지 않더라도 open my $fh, '<:utf8', 'file.txt'; 또는 binmode STDIN,':utf8'; 같이 I/O인터페이스에 대해 인코딩을 지정해주면 읽어들이면서 자동으로 Perl 내부 유니코드 포멧으로 바꿈 - 일종의 decode함수 같은 동작이 발생함 )
a. $str이 utf8 인코딩 옥텟열이면 decode('utf8',$str); ( 이 경우는 단순히 utf8플래그를 켜주는 역할)
* ':utf8'은 단순히 플래그만 on하며 ':encoding(UTF-8)' 인코딩의 정합성 까지 채크한다.
b. $str이 euc-kr 인코딩 옥텟열이면 decode('euc-kr',$str);
( 파일로부터 읽어들일 때는 open my $fh, '<:encoding(euc-kr), 'file.txt';
표준입력으로 부터는 binmode STDIN, ':encoding(euc-kr)'; 처럼 쓸 수 있음 )

3. a.의 경우 $str과 decode된 $str의 옥텟열은 같지만 다른 것은 decode 후의 문자열은 Perl 내부 유니코드포멧(utf-8)으로 변환된 상태이며 utf8플래그가 켜져 있는 상태이다. 이런 상태이면 Perl의 각종 문자열 처리함수들은 옥텟(바이트)단위가 아닌 문자 단위의 처리를 하므로 한 문자가 몇 바이트를 사용하는지 신경써서 경계를 수동으로 잘라주고 할 필요가 없다.

4. Encode 모듈의 encode 함수는 Perl내부 유니코드 포멧 문자열을 특정 인코딩의 옥텟열로 변환 하는 것이다.
a. $str이 Perl내부 유니코드 포멧 문자열이면 encode('euc-kr',$str); 하면 euc-kr 옥텟열이 나온다.

5. Perl 내부 유니코드 포멧의 문자열을 외부로 출력할 때는 해당 I/O 인터페이스에 대해 명시적으로 인코딩을 지정해야 한다. 그렇지 않으면 Wide character 어쩌고 저쩌고 하는 경고가 발생한다.
* $str이 Perl 내부 유니코드 문자열이면
binmode STDOUT, ':encoding(euc-kr)';
print $str;
하면 euc-kr로 출력되고
binmode STDOUT, ':encoding(UTF-8)';
print $str;
하면 utf-8으로 출력된다.
(일종의 encode 함수 같은 동작이 발생함)

Parrot

Fri, 14 Nov 2008 11:46:12 +0900

Parrot 이란?

Parrot은 Perl6를 위해 개발된 register기반의 Virtual Machine(가상머신)이다. 하지만 Parrot bytecode를 생성하는 컴파일러만 만들면 Python,Ruby등 dynamic typed language(동적언어)를 모두 지원할 수 있다. 기존의 Java JVM,.NET CLR같은 VM이 있으나 이것들은 stack기반이고 동적언어의 기능을 100% 지원하지 못하며 본래 static typed language(정적언어)를 위해 개발된것이다.

Virtual Machine Showdown: Stack Versus Registers 에 의하면 register기반은 stack기반 VM보다 명령을 수행하는데 소요되는 인스트럭션을 47% 줄일 수 있고 실행시간도 25.6%정도 빠르다는 연구결과가 나와있다.

참고:

On the Architecture of the Parrot Virtual Machine OnTheArchOfParrotVM.pdf

Software Patterns in the Parrot System SoftwarePatternsInParrot.pdf

.NET and Java to get better dynamic language support

현재 Parrot위에서 돌아가도록 구현되고 있는 언어들로는 bc,Befunge,Lua,Javascript,Perl6,Plumhead(PHP),Pynie(Python),Ruby, Scheme,Tcl등이 있다. 이것은 궁극적으로 Parrot 기반으로 다양한 언어를 동시에 제한 없이 같이 사용할 수 있게됨을 뜻한다.

공식홈페이지: http://www.parrotcode.org/
Parrot 디자인문서: http://www.parrotcode.org/docs/pdd/
Perl 6 and the Parrot Virtual Machine http://www.cs.helsinki.fi/u/pohjalai/k05/okk/seminar/Fagerholm-Parrot.pdf
Parrot Compiler Tools http://www.lohutok.net/talks/compiler_tools.pdf
관련정보싸이트: http://www.perlfoundation.org/parrot/, http://en.wikipedia.org/wiki/Parrot_virtual_machine
Inside Parrot's Compiler Tools http://www.oreillynet.com/onlamp/blog/2006/03/inside_parrots_compiler_tools.html

Parrot의 구조

내부 데이터 타입

Parrot은 다음과 같은 네종류의 register(또는 데이터 타입)을 가진다.

I : native 정수형을 저장
N: native 실수형을 저장
S: 문자열을 저장
- buffer : 실제 문자열을 저장
- length : 문자열의 길이를 저장
- encoding : 문자열의 인코딩을 저장
- character set : 문자열의 문자셋을 저장
P: Perl Magic Cookie(PMC)를 저장

Parrot은 앞에서도 말했다시피 Dynamic typed language를 위해 설계되었다. Java같은 언어에서는 정수형변수에 실수를 저장하려고 하면 에러가 나지만 Perl같은 Dynamic typed language에서는 이것이 문제가 안된다. 그러면 Parrot은 무엇이든 변수에 저장할 수 있는데 왜 명시적인 타입을 가지는 저장소가 필요한가라는 질문이 있을 수 있다. 이것은 경우에 따라 편리하게 더 나은 성능을 얻을 수 있게 하는 장치이며 이것은 Just-in-time(JIT)과 관련이있다. 또 Perl에서는 변수가 어떤때는 숫자 어떤때는 문자를 포함할 수 도 있는데 왜 navtive정수,실수를 내부 타입으로 지원하는가 하는 질문이 있을 수 있는데 이것은 필요할때 Perl6는 효율성을 위해 변수의 타입을 지정할 수 있게 하기 때문이다.

PMC(Parrot Magic Cookie)

PMC는 추상화된 데이터구조로 연산,논리연산,문자열처리 method를 자체적으로 가지는 특별한 내부객체로 생각할 수 도 있으며 이것은 정수,실수,문자열같은 기본 데이터 타입,Hash,Array,객체같은 기능을 포함 할 수 있으며 더 나아가 subroutine,coroutine,closure,continuation 같은것도 PMC로 구현된다.

Vtable

PMC가 객체라면 Vtable은 어떤 호출에 대해서 어떻게 처리해야 할 지를 결정하는 PMC안에 있는 함수 포인터라고 생각하면 된다. 이것은 언어별로 적절하게 구현해서 다양한 언어에서 호출할 수 있도록 한다.

Object System

Parrot의 Object System은 두개의 PMC로 이루어지는데 ParrotObject PMC와 ParrotClass PMC로 구현된다.

Parrot의 PMC는 실제로는 Object Sytem이기 때문에 Parrot을 타켓으로하는 각각의 언어는 자신만의 PMC들을 가질 수 있다.

예를들면 Parrot을 위한 Tcl 컴파일러(ParTcl)는 Tcl의 List를 구현한 TclList라는 PMC를 가진다.

프로그래머는 PMC를 Parrot assembly(PASM)언어로 정의할 수 있다. 또 PIR(Parrot Intermediate Representation)이라는것이 있는데 이것은 PASM보다 한단계 높은 언어로 더 쉽게 작성할 수 있고 세부적인 기능을 가진다.

Continuation Passing Style(CPS) - 계산과정 전달

일반적으로 고전적인 시스템에서는 서브루틴이 호출되면 리턴 주소를 stack에 넣고 인자들을 stack이나 register에 넣고 호출하며 리턴될때 리턴값은 인자를 넣었던 방식으로 다시넣고 리턴되면 다시 그 정보를 이용하여 프로그램 수행을 계속한다. 이런 절차를 간단히 하기위해 만들어진것이 CPS이며. Continuation이란 현재 실행되는 서브루틴의 lexical영역과 control stack등을 snapshot하듯이 저장하고 있는 일종의 객체라고 볼 수 있으며 호출되면 그 상태 그대로 완전히 복구된다.

Exceptions

Parrot은 현대적인 프로그램밍 언어가 가지는 특징인 예외처리를 지원한다.

Native Callling Interface(NCI)

Parrot은 C등으로 작성된 Native한 외부 라이브러리,함수를 쉽게 호출할 수 있게 해주는 인터페이스를 가진다.

Garbage Collection

Parrot은 Garbage Collection을 지원한다. 이것은 사용자가 수동으로 메모리를 확보/해지 할 필요가 없다는 뜻이다.

Parrot이 실행할 수 있는 4가지 format

PIR (Parrot Intermediate Representation) - 사용자 혹은 컴파일러에 의해 생성되고 사람이 읽고 쓸 수 있게 설계되었으며 예를 들면 함수에 파라메터들이 어떻게 전달되는지 등 저수준의 세부사항을 알 필요가 없이 작성할 수 있게되어있다.
PASM (Parrot Assembly) - PIR보다 더 로우레벨이나 여전히 사람이 읽고 쓰는것이 가능하다. 하지만 작성자는 호출규약이나 레지스터 할당등을 신경써야 한다.
PAST (Parrot Abstract Syntax Tree) - Parrot이 Abstract Syntax Tree 스타일의 인풋을 받을 수 있게 해주며 이것은 Compiler를 제작하는데 유용하다.
PBC (Parrot Bytecode) - 위의 3가지 코드는 자동으로 Parrot 내부에서 PBC로 변환 되며 이것은 Parrot에 있어 machine code와 유사한 것이다.

PCT(Parrot Compiler Toos)

PGE(Parrot Grammar Engine)
TGE(Tree Grammar Engine)

pack,unpack,vec

Wed, 12 Nov 2008 12:27:05 +0900

pack,unpack,vec은 Perl에서도 비교적 잘 알려져 있지 않고 어려운 쪽에 속하는 고급 주제이다. perldoc에 자세히 설명된 문서들이 있긴 하지만 너무 장황하거나 보면 알듯하면서도 또 모르겠고 헷갈릴 경우가 많은데 Perldoc의 문서 중에는 이런 문서들이 많다. 하지만 그 문서들이 안 좋다는 것이 아니고 처음 접하는 사람에게 친절하지는 않다는 것이다. 그럴때는 나름대로의 이해방식으로 정리해서 기본을 익힌다음 perldoc을 읽어보는게 좋다. 그래서 나름대로의 이해방식으로 pack,unpack,vec에 대해서 정리해봤다. 이 문서는 pack,unpack,vec의 전부가 아니고 perldoc문서 보고 감을잡고 이해하며 살을 붙여갈 수 있도록 기초를 다져주는 것임을 명심하길.. (보다가 틀린 것 있으면 태클 환영)

pack TEMPLATE, LIST

리스트를 TEMPLATE를 적용해서 하나의 연속적인 바이트 데이터로 만드는 함수

(Perldoc에서는 문자열로 만든다고 하나 실제는 연속적인 바이트(옥텟) 데이터로 보는 것이 적절하다. 각 바이트들의 범위는 0x00~0xff까지이기 때문에 ASCII영역을 벗어나기도 하기 때문이다.)

여기서 TEMPLATE는 LIST가 무엇을 뜻하는가를 의미함

연속적인 바이트데이터 형태 <- TEMPLATE <- TEMPLATE가 지정한 형태의 자료들의 리스트

unpack TEMPLATE, EXPR

EXPR의 연속적인 바이트데이터를 원하는 데이터들의 리스트로 만드는 함수

여기서 TEMPLATE는 EXPR의 연속 바이트데이터의 특정부분이 어떤 데이터가 될 것인가를 의미함

TEMPLATE가 지정한 형태의 데이터 리스트 <- TEMPLATE <- 연속적인 바이트 데이터 형태

TEMPLATE

* 자세한 템플릿 정의문자는 http://perldoc.perl.org/functions/pack.html 를 참고

pack,unpack은 TEMPLATE에서 특정 속성을 나타내는 템플릿정의 문자가 나올때 마다 각각의 단위가 된다.

"C" # unsigned char값 하나

"C2" 또는 "C*"의 형태 # unsigned char값의 숫자만큼 연속과 계속적인 연속

"C2C" # unsigned char값2개 묶음하나, unsigned char값 하나

"CC" # unsigned char값 2개

pack,unpack 예제

* 기초

<65를 unsigned char 값으로 생각하고 바이트데이터화 한다.>

print pack "C",65; # C An unsigned char (octet) value, ascii code 65 -> "A"

A <- 위 명령의 결과로 바이트데이터 \x41 이 되고 이것을 찍으면 해당 아스키코드 문자 A가 찍힘

<메모리상에 저장된 "A"에 대한 바이트데이터(\x41)를 C가 나타내는 크기(1바이트)만큼 가져와서 unsinged char화 한다.>

print unpack "C","A"; # 메모리상에는 "A"가 \x41 바이트데이터로 들어가 있음

print pack "CC",65,66;

print join ' ', unpack "CC","AB";

65 66

print pack "C*",65,66,67;

ABC

print join ' ', unpack "C*", "ABC";

65 66 67

* a,A,Z,b,B,h,H,@,.,x,X와 P 를 제외한 템플릿 정의 문자는 pack함수에서 숫자나 *로 복수개를 지정하면 LIST의 값들을 계속적으로 끌어들인다(globbing).

H -> A hex string (high nybble first). nybble은 4bit를 말함 16진수 0xAE에서 A와E가 nybble.

print pack "H*", "41","42"; # H에 *을 써도 "41"에만 적용
A

print pack "H4", "41","42"; # 마찬가지로 H4는 "41"에만 적용된다. 남는다고 뒷쪽 것을 가져오지 않는다.

print pack "H*", "4142";
AB

"4142"를 nybble의 연속(H*)으로 보고 4비트씩 차례대로 pack하면 \x41\x42 가 되기 때문에 찍으면 AB가 나옴.

이경우는 H*가 "4142"에 대해서 동작한 것이므로 LIST의 요소가 여러개인 위 예제들과는 다르다.

만약에 H* 대신 h*를 써서

print pack "h*", "4142";

라고 하면 h는 A hex string (low nybble first)을 뜻하므로 \x14\x24 로 pack된다.

print pack "a4","abcde","X","Y","Z"; # a A string with arbitrary binary data, will be null padded. "a4"가 리스트 첫번째 요소에 적용되어버린다.
abcd

print pack "a4","abc","X","Y","Z"; # 남는다고 뒷쪽 것을 가져오지 않는다.

abc

print pack "A4","abc","X","Y","Z"; # a는 null로 padding 하고 A는 공백으로 패딩한다.

abc <- 여기서는 c뒤에 공백하나가 있다.

print pack "aaaa","abcde","X","Y","Z";
aXYZ

print pack "C*", 65,66,67; # C에*을 쓰면 LIST를 계속적으로 끌어들임
ABC

print pack "C3", 65,66,67; # C에숫자를 쓰면 LIST를 계속적으로 끌어들임

ABC

* a,A,Z,b,B,h,H,@,.,x,X와 P 를 제외한 템플릿 정의 문자는 unpack에서 숫자나 *를 사용하면 LIST를 반환한다.

print join " ",unpack("H*", "ABC"); # 한 묶음으로 넘어간다.(공백으로 join했으나 공백이 안들어갔으므로)
414243

print join " ",unpack "B*", pack "C",255; # B A bit string (descending bit order inside each byte)., 한 묶음으로 넘어옴
11111111

print join " ",unpack("H4","AB"); #역시 한 묶음으로 넘어감

4142
$hex=unpack("C*","ABC");print $hex; # $hex가 스칼라 변수라서 넘겨준 LIST의 첫 번째 값만 들어갔다.(리스트가 넘어옴을 알 수 있다.)
65

@hex=unpack("C*","ABC");print "@hex"; # 배열로 하면 넘겨준 리스트를 다 받는다.
65 66 67

print join " ",unpack("C3","ABC"); # 리스트를 넘겨준다.

65 66 67

* 기타

print pack "H2","41";

print unpack "H2","A";

print pack "HH", "41";

왜 A가 아닐까? 첫H가 뒤 따르는 "41"과 매칭하여 동작하고 두번째 H는 매칭 대상이 없으므로 빈문자가 된다.

pack에서 템플릿정의문자로 이루어지는 각 단위는 최소 리스트 요소들에 최소 1:1 혹은 이상으로 대응되어 동작한다.

따라서 41에서 상위 nybble 4만가져와서 \x40에 대한 ASCII 문자 @를 찍었다.

print unpack "HH", "A";
4

unpack에서 템플릿정의문자로 이루어지는 각 단위는 최소 1바이트단위에 대해 동작한다.

"A"가 메모리상에 저장된 1바이트 \x41에서 상위 nybble 4만 가져와서 찍혔다. 두번째H는 적용대상이 없으므로 빈 문자가 된다.

print unpack "B2", pack "C",255; # pack된 255(0b11111111)의 상위 2비트를 가져온다.
11

print unpack "BB", pack "C",255;
1

이건 왜 11이 아닐까? 바로 위"HH"경우를 떠올리면 답이나옴

print pack "H6","414243";

ABC

print join ' ', unpack "H6", "ABC";

414243 <- H6으로 ABC가 저장된 바이트데이터연속을 한덩어리로 unpack 됐다.(공백으로 join했는데 숫자중간에 공백이 없으므로)

print join ' ', unpack "H2H2H2", "ABC";

41 42 43 <- 한 바이트씩 리스트로 unpack

print join '|', unpack "HHHHHH", "ABC";

4|4|4|||

왜 4|1|4|2|4|3 이 아닐까? 위에서 unpack에서 템플릿정의문자로 이루어지는 각 단위는 최소 1바이트단위에 대해 동작한다. 라고

한 것을 떠올리면 처음 3개의 H가 각각 A,B,C에 대해 동작해서 상위 nybble 4만 가져오고 나머지는 적용대상이 없으므로

빈문자가 되었음을 알 수 있다.

my $var = pack "S",65535; # S An unsigned short value, 65535 는 0xFFFF

$var 는 unsigned 16bit 값으로 메모리상의 연속적인 바이트데이터 "\xff\xff" 로 저장됨

메모리상의 연속적인바이트데이터 \xff\xff (16bit)를 16진수 형태로 unpack하려면

print unpack("H4",$var);

ffff

255(0xff)를 16bit 정수로 pack하고 16진수 형태로 unpack, 255는 8bit으로 나타낼 수 있지만 템플릿이 그 이상의 크기를 지정하면 나머지는 0로 패딩된다.

print unpack("H4", pack "S",255);

ff00 <- intel 머신이 little-endian 이므로 하위 바이트가 상위로 갔다.

(endian에 대해서는 http://ko.wikipedia.org/wiki/%EC%97%94%EB%94%94%EC%96%B8 를 참고 )

이것을 network byte order(big-endian)으로 해서 찍으려면

print unpack("H4", pack "n",255); # n An unsigned short (16-bit) in "network" (big-endian) order.

00ff

print unpack 'C',pack 'B*','10001000'; # B A bit string (descending bit order inside each byte).

136

여기서 H와h가 달랐던 것처럼 B와b도 다르게 동작한다. 만약

print unpack 'C',pack 'b*','10001000'; # b A bit string (ascending bit order inside each byte, like vec()).

처럼 "b*"로 pack하면 0b00010001이 되고 이것을 "C"로 unpack하면 17이 되는 것이다.

따라서 pack,unpack을 사용할 때는 템플릿정의 문자에 따라 bit,nybble,byte를 어떤 순서로 처리하는지와

big-endian, little-endian을 고려해야 한다.

vec EXPR,OFFSET,BITS

EXPR을 비트의 연속인 비트스트링으로 간주하고 BITS단위로 OFFSET만큼 이동시키며
$var = vec(...) 형식이면 거기서부터 데이터를 읽을 수 있고 lvalue로 사용하여 vec(...)=1처럼 거기에 값을 대입시키면 그 위치부터 데이터를 바꾼다.

읽는 값이나 대입시키는 값은 BITS에 지정한 bit수로 표현되거나 표현할 수 있는 데이터이다.

단 바이트의 비트순서는 little endian 형식을 따르며(최하위 비트가 제일 먼저 나온다는 말)

BITS는 1~32까지(64bit perl은 64까지)의 2의승수(1,2,4,8,16,32)이어야 된다.

<1bit단위로 0만큼 이동해서 그 값(1bit)을 0으로>

>perl -e '$var = pack "C",255;vec($var,0,1)=0;print unpack "b*",$var;' # 255 = 0xff = 0b11111111
01111111 <- little-endian형식, vec이 little-endian형식으로 비트를 다룸을 알 수 있다.

>perl -e '$var = pack "C",255;vec($var,0,1)=0;print unpack "C",$var;'

254 <- 이진수로는 0b11111110 인 이 값은 십진수로 254이다 이것을 보면 실제 최하위 비트가 0이 됐음을 알 수 있다.

>perl -e '$var = pack "C",255;vec($var,0,1)=0;print unpack "B*",$var;'
11111110 <- big-endian형식으로 출력해서 그것을 확인

<1bit단위로 1만큼 이동해서 그 값을 0으로>

perl -e '$var = pack "C",255;vec($var,1,1)=0;print unpack "b*",$var;'
10111111

<2bit단위로 0만큼이동해서 그 값(2bit)을 0으로>

>perl -e '$var = pack "C",255;vec($var,0,2)=0;print unpack "b*",$var;'
00111111

<BITS가 2의 승수가 아니면 에러>
>perl -e '$var = pack "C",255;vec($var,0,3)=0;print unpack "b*",$var;'
Illegal number of bits in vec at -e line 1.

<2bit단위로 1만큼이동하여 그 값을 0으로>

>perl -e '$var = pack "C",255;vec($var,1,2)=0;print unpack "b*",$var;'
11001111

<8bit 단위로 n만큼 이동해서 해당 위치의 값(8bit)을 가져와서 해당 아스키코드 문자를 찍어보자>

>perl -e '$str="Perl"; print chr(vec($str,0,8));'
P
>perl -e "$str="Perl"; print chr(vec($str,1,8));"
e
>perl -e "$str="Perl"; print chr(vec($str,2,8));"
r
>perl -e "$str="Perl"; print chr(vec($str,3,8));"
l

<예제코드>

#!/usr/bin/perl
use strict;
use warnings;
use Devel::Peek;

print "\x50\x65\x72\x6C\n";
my $foo = '';
vec($foo, 0, 32) = 0x5065726C; # $foo는 32bit |50|65|72|6C|

print "$foo\n";
print unpack("H8", $foo),"\n";

my $foo2 = '';
vec($foo2, 0, 32) = unpack "N",pack "H8","5065726C"; # N An unsigned long (32-bit) in "network" (big-endian) order.
print "$foo2\n";

<결과>

Perl

5065726c

Perl