Perl 메모

Codeordie

목차

탑에

처음에

  • 이 페이지는 Perl5 (을)를 대상으로 하고 있습니다. 또,perl 를 대상으로 하고 있기 때문에, jperl 로 움직인다고 하는 보증은 없습니다.
  • perl 스크립트는 EUC-JP 그리고 쓰여지는 것을 상정하고 있습니다.
  • 이 페이지는 CGI 메일링리스트 등으로의 질의응답·FAQ를 참고에, 내가 독자적으로 메모로 해 집계한 것입니다. 다만, CGI 에 특화한 것이 아닙니다.
  • 주로 참조한 페이지는 나의 페이지 (잡다한 링크)의 문자 / Perl / WWW 에 링크해 있습니다.
  • 이 페이지에 쓰여져 있는 스크립트는, 개인의 책임에 대해 실행해 주세요. 또, 수시 불편의 수정을 하고 있기 때문에, 이용 되는 (분)편은 주의해 주십시오.
  • 이 페이지에 쓰여져 있는 스크립트의 이용·개조는 자유 입니다. 그 때는 어디엔가 이 페이지의 URI( http://www.din.or.jp/~ohzaki/perl.htm )(을)를 참고로서 기술해 주시면 다행입니다(임의).
  • 이 페이지는 Internet Explorer 5 및 Netscape Communicator 4.75 그리고 표시의 확인을 실시하고 있습니다. 이것들 이외의 브라우저를 사용하시는 경우는, 정상적으로 표시되지 않을지도 모릅니다.
  • 의견· 감상· 요망 등은 ohzaki@din.or.jp 에 부탁합니다. 이렇게 쓰는 것이 좋은, 움직이지 않아, 몰라요, 버그비치는, 이것서, 등 등 기다리고 있습니다.
  • 이 페이지로의 링크는 자유 에 쳐 주셔 좋습니다. URI 는 http://www.din.or.jp/~ohzaki/perl.htm 입니다.
  • 인용 또는 전재하는 경우는, 출전으로서 이 페이지의 URI( http://www.din.or.jp/~ohzaki/perl.htm )(을)를 명기해 주세요. URI 를 명기하는 경우에 한정해 허가는 필요 없습니다만, 사후에 상관없기 때문에 통지해 주시면 기쁩니다. URI 를 명기하지 않는 경우에는 사전의 허가없이 인용 또는 전재하는 것을 금지합니다.
탑에

배타 제어(파일 락)를 한다

sub my_flock {
  my %lfh = (dir => '. /lockdir/', basename => 'lockfile',
	     timeout => 60, trytime => 10, @_);
  $lfh{path} = $lfh{dir} .  $lfh{basename};

  for (my $i = 0; $i < $lfh{trytime}; $i++, sleep 1) {
    return \%lfh if (rename($lfh{path}, $lfh{current} = $lfh{path} .  time));
  }
  opendir(LOCKDIR, $lfh{dir});
  my @filelist = readdir(LOCKDIR);
  closedir(LOCKDIR);
  foreach (@filelist) {
    if (/^$lfh{basename}(\d+)/) {
      return \%lfh if (time - $1 > $lfh{timeout} and
	  rename($lfh{dir} .  $_, $lfh{current} = $lfh{path} .  time));
      last;
    }
  }
  undef;
}

sub my_funlock {
  rename($_[0]->{current}, $_[0]->{path});
}

# 잠근다(타임 아웃 있어)
$lfh = my_flock() or die 'Busy! ';

# 언로크 한다
my_funlock($lfh);

복수의 프로세스가 동시에 있는 1개의 파일을 읽고 쓰기할 가능성 (이)가 있는 경우,배타 제어를 하지 않으면 안됩니다. 배타제 어를 하는 방법은 몇개인가 있습니다만, 이 스크립트는 다음의 방침에 근거하고 있습니다.

  1. 어떤 플랫폼이라도 사용할 수 있는 것
  2. 이상한 락 상태를 회피할 수 있는 것

배타 제어를 하는 방법으로서 flock 함수 나 symlink 함수를 사용하는 방법이 있습니다만, 이러한 함수는 플랫폼에 따라서는 서포트되고 있지 않습니다. 따라서, 1 을 채우기 (위해)때문에 에는 이러한 방법을 사용할 수 없습니다. 그 이외의 방법으로서는, mkdir 함수를 사용하는 방법과 rename 함수를 사용할 방법이 생각됩니다. 다음에 2 에 무심코 (이)라고입니다만, 이상한 락 상태란, 어느 프로세스가 잠근 상태인 채 어떠한 원 인으로 죽었을 경우에, 락이 해제되지 않고 남아 버린 상태입니다. flock 를 사용하고 있는 경우는, 락 상태로 프로세스가 죽었을 때자동적으로 락이 해제되기 때문에, 이상한 락 상태는 오코시 와 선. 그러나, symlink 나 mkdir, rename 등을 사용하는 경우에는 스크립트측에서의 대처가 필요하게 됩니다.

구체적으로 어떻게 대처할까입니다만, 락 상태가 있는 일정한 시간을 경과해 있었을 경우에는 이상이라고 판단해, 다른 프로세스가 락 상태를 해제해도 괜찮은 것에 섬 . 실은 여기에 함정이 존재합니다. 배타 제어를 하는 방법으로서 왜 symlink 나 mkdir, rename 를 사용하는지? 그것은 이러한 함수가,잠글 수 있을지 어떨지의 테스트와 실제로 잠그는 조작을 동시에 행할 수가 있는 atomic 인 함수이기 때문입니다. 이야기를 되돌려, 이상한 락 상태를 해제할 때를 생각합니다. 예를 들어, mkdir 를 사용한 락의 방법에 대해, 이상한 락 상태 때에 록 쿠를 해제하는데는, 다음과 같은 스크립트가 됩니다. 

rmdir($lockdir) if (time - (stat($lockdir))[9] > 60);

락 상태가 60초이상 경과하고 있었을 경우에는 락을 해제하면(자) 말하는 스크립트입니다만, 이것이 symlink (이)나 mkdir, rename 때와 달리, 락을 해제할지 어떨지의 판단과 실제로 록 쿠를 해제하는 조작을 동시에 행하고 있는 것은 아니다고 하는 것이 문제가 됩니다. 구체적으로 무엇이 맛이 없는 것인지라고 하면(자),정상적인 락 상태도 해제해 끝내는 일이 있다라고 하는 것입니다. 그것은 다음과 같은 경우입니다.

프로세스 A프로세스 B프로세스 C
이상과 판단이상과 판단
↓
↓
↓
↓
락 해제
↓
↓
↓
↓
락
↓
락 해제
↓

복수의 프로세스로 락 상태가 이상하다라고 판단해, 그 중의 1개가 락을 해제한 것에 의해, 다른 프로세스가 잠그었음에도인가 변하지 않고, 방금전 락 상태가 이상하다라고 판단한 프로세스에 의해 이 정상적인 록 쿠가 해제되어 버릴 가능성이 있습니다.

이 방법의 문제점은, 이상한 락 상태를 해제하는 조작이 정상적인 락 상태도 해제 가능하게 되는 것에 있습니다. 반대로 말하면, 이상한 락 상태를 해제하는 조작에 따라서 정상적인 락 상태를 해제할 수 없으면 문제 없는 것입니다. 그 때문에는 어떻게 좋은 것인지? 대답은락 상태가 항상 변화해 나가면 좋다그렇다고 하는 것입니다. 그리고, 이것을 실현하는데 형편이 좋은 것이 rename 에 의한 방법이 됩니다.

최초의 스크립트로 설명하면, 락 파일이 lockfile 라고 한다 이름 때가 락이 해제되고 있는 상태로,lockfile987654321 에 뒤로 작성 시각이 붙은 상태가 락 상태가 됩니다. 이렇게 하는 것으로 방금전의 예로,프로세스 B에 의해프로세스 C의 락 하지만 해제되어 버렸다고 하는 상황을 회피할 수가 있습니다. 왜냐하면,프로세스 C에 의해 rename 된 록크파 일의 이름은 벌써프로세스 B가 알고 있는 이름과는 차이가 나기 때문에 입니다. 최초의 스크립트에서는 일단 락을 해제하는 것이 아니라, 이상한 락 상태를 해제하면서, 새로운 락 상태로 이행 시키고 있습니다.

스크립트의 주의점으로서는, 미리 락용의 디렉토리와 파일을 준비해 두는 것, 디렉토리에 기입해 속성을 붙여 두는 것, dir 의 값에는 마지막에 / 등의 딜리미터를 붙여 두는 와 (와)과입니다. $lfh = my_flock(basename => 'lockfileA'); (와)과 같이 호출하는 것으로 파라미터를 변경할 수 있습니다. 또,my_flock() (은)는 락에 실패(타임 아웃)하면(자) undef 를 돌려줍니다. 잠글 때까지 블록 하고 싶은 경우에는 다음과 같이 씁니다. 

# 잠근다(타임 아웃 없음)
1 while (not defined($lfh = my_flock()));

마지막으로, 파일을 읽어들여, 그것을 가공한 다음 기입하는 경우의 안전한 배타제 어의 순서를 써 둡니다.

  1. 잠근다
  2. 파일을 읽어들인다
  3. 일시파일에 기입한다
  4. 일시파일을 원파일에 rename 한다
  5. 언로크 한다
탑에

파일의 내용을 역순서에 표시한다

# 파일 $file 의 내용을 역순서에 표시한다

$bufsize = 1024;
open(FILE, "< $file");
binmode(FILE);
$size = (-s FILE) / $bufsize;
$pos += $size <=> ($pos = int($size));
while ($pos--) {
  seek(FILE, $bufsize * $pos, 0);  
  read(FILE, $buf, $bufsize);
  $buf . = $buf_tmp;
  ($buf_tmp, @lines) = $buf =~ /[^\x0D\x0A]*\x0D? \x0A? /g;
  pop(@lines);
  foreach (reverse @lines) {
    print $_;
    print "\n" if $_ ! ~ /[\x0D\x0A]$/;
  }
}
close(FILE);
print $buf_tmp;

이 스크립트는 파일을 $bufsize 바이트두개 읽어들여 역순서에 표시하므로, 파일 전체를 한 번에 읽어들이는 방법으로 비교해적은 메모리로 실행시킬 수가 있습니다.

$size 에의 대입문에 있다 -s (은)는파일 테스트 연산자의 1개로 파일 사이즈를 돌려줍니다. $pos 에는 파일 사이즈를 $bufsize 그리고 나누어 끝맺은 값이 대입됩니다. 절상에 관해서는 「숫자를 끝맺는다」를 참조해 주세요. while 블록은 $pos 회로 나누어 파일을 읽어들여 처리한다고 하는 것을 하고 있습니다.

$buf 에는 $bufsize 바이트두개 읽어들인 파일의 일부가 대입됩니다. 파일의 내용을 역순서에 표시한다 위해(때문에)는, 우선은 $buf 의 내용을 행 마다 나눌 필요가 있습니다. 그것을 행하고 있는 것이 $buf =~ /[^\x0D\x0A]*\x0D? \x0A? /g; 의 부분이 됩니다. 이 정규 표현은, 개행 코드 이외의 문자가 0 문자이상 계속되어, 그 후의 개행 코드까지를 나타내고 있습니다. 즉, 이것으로 1행분을 꺼내고 있는 것입니다. 개행 코드 이외의 문자가 0 문자이상으로 어느 공행에도 성냥 합니다. 또, 개행 코드의 부분의 정규 표현 \x0D? \x0A? (은)는 개행 코드가 \x0D\x0A 에서도 \x0D 에서도 \x0A 이라도 좋은 것은 응, 파일의 최후가 개행으로 끝나지 않은 행이었던 경우에도 성냥 합니다. 여기까지의 이야기로 벌써 기분 다음 사람도 있을지도 모릅니다만, 이 1행분에 성냥 하는 정규 표현은, 실은공문자열에도 성냥합니다. 그리고, 그것은 반드시 $buf 의 최후로 성냥 시키는 문자가 아무것도 없는 상태로 한 번만 일어납니다. 따라서, 이 무의미한 공문자열을 삭제하기 위해서, 다음의 행으로 pop(@lines); 하고 있습니다.

$buf 의 내용을 행 마다 나누려면 split 함수를 사용해, split(/\x0D\x0A|\x0D|\x0A/, $buf); 그렇다면 좋은 것은 아닌지 없을까 생각할지도 모릅니다만, 이 방법에서는 $buf 의 마지막에 공행이 있었을 경우에 맛이 없게 됩니다. split 함수의제 3 인수를 생략 하면(자), split 한 결과의최후가 공문자열이었다 경우에는 자동적으로 삭제됩니다. 즉, 마지막에 공행이 연속하는 캐릭터 라인 "foo\nbar\n\n\n" 와 같은 것을 split 하면(자) ('foo', 'bar') 밖에 남지 않기 때문에, 본래 ('foo', 'bar', '', '') 되기를 원했다 마지막 공행이 없어져 버립니다.

거기서 마지막 공문자열을 자동적으로 삭제시키지 않기 위해(때문에),제 3 인수에 split(/\x0D\x0A|\x0D|\x0A/, $buf, -1); (와)과 같이음수를 지정하면 좋은 것이 아닐까 생각할지도 알려지지 않습니다만, 이것이라도 아직 잘되지 않습니다. 예를 들면, "foo\nbar\n" (을)를 split 하면(자), 이번은 ('foo', 'bar', '') (와)과 같이 마지막 개행 코드의 뒤의 공문자열이 삭제되지 않고 남아 버립니다. 거기서, 이것에 대처하기 위해서 최후가 공문자열이었을 경우에는 삭제하도록(듯이), pop(@lines) if $lines[-1] eq ''; 로 하는 손이 있습니다. 그러나, 이것을 행하는 것에 의해, 정확히 $bufsize 두개 단락지은 전후가 개행 코드였을 경우에는 필요한 공행까지 삭제해 버립니다. 그 때문에 게다가 read 의 뒤에 $buf_tmp = "\n" if $buf_tmp eq ''; (을)를 넣을 필요가 있습니다. 이것으로 정규 표현을 사용한 방법과 거의 같은 동작을 하게 됩니다. 다만, 내가 벤치마크를 취해 조사했는데, 정규 표현을 사용한 방법의 (분)편이빨랐던유익 그 쪽을 채용했습니다.

탑에

파일의 마지막 몇 줄기만 표시한다

# 파일 $file 의 마지막 최대 $n행만 표시한다

$bufsize = 1024;
open(FILE, "< $file");
binmode(FILE);
$size = (-s FILE) / $bufsize;
$pos += $size <=> ($pos = int($size));
while ($pos--) {
  seek(FILE, $bufsize * $pos, 0);  
  read(FILE, $buf, $bufsize);
  $buf . = $buf_tmp;
  ($buf_tmp, @lines) = $buf =~ /[^\x0D\x0A]*\x0D? \x0A? /g;
  pop(@lines);
  unshift(@tail, @lines);
  last if @tail >= $n;
}
close(FILE);
unshift(@tail, $buf_tmp);
@tail = @tail[-$n .. -1] if @tail > $n;
foreach (@tail) {
  print $_;
}

이 스크립트의 기본은 「파일의 내용을 역순서에 표시한다」의 스크립트와 같습니다. 스크립트의 상세한 것에 대하여는 그 쪽을 참조해 주세요. 차이로서는 $n 행을 꺼낼 수가 있던 시점에서 곧바로 while 블록을 빠지도록(듯이) 하고 있는 곳(중)입니다.

실제로 표시하기 직전으로는 @tail 의 크기를 조사해 만약 $n 보다 크면 마지막 $n 개만을 배열 슬라이스로 꺼내 다시 대입하고 있습니다. .. (은)는범위 연산자라고 말해, 리스트 문맥으로 실행했을 경우는 범위 연산자의 전의 값으로부터 뒤의 값까지의 리스트를 돌려줍니다. 즉, 이 경우는 (-$n, -$n+1,..., -2, -1) 라고 하는 리스트가 됩니다. 배열의 첨자가 음수였던 경우에는 뒤로부터 센 장소가 되므로, 이 경우는 배열의 마지막 $n 개분이라는 것이 됩니다.

탑에

파일로부터 1행랜덤에 선택한다

# 파일 $file 로부터 1행 랜덤에 선택한다

srand;
open(FILE, "< $file");
rand($. ) < 1 and $line = $_ while <FILE>;
close(FILE);
print $line;

이 스크립트에서는 파일 전체를 메모리에 읽어들이지 않는다 의로적은 메모리로 실행시킬 수가 있습니다. 또, 파일의 행수를 미리 알고 있을 필요도 없습니다.

파일 전체에 대해서 while 문을 돌리는 것입니다만, 1행두개 읽어들여 실행되는 부분이 while 보다 좌측의 부분입니다. 이 부분은 2개의 식의 and (을)를 취하고 있습니다. 논리 연산자 and (은)는 좌측이 진정한 경우에 한정해 우측이 평가됩니다. 즉, 이 부분은 if 문장을 사용해 다음과 같이 쓴 것과 같은 의미가 됩니다. 

if (rand($. ) < 1) {
  $line = $_;
}

특수 변수 $. (은)는 마지막에 읽어들인 파일의 행 번호를 돌려줍니다. 따라서, 이 조건이 성립하는 확률은 1/$. (이)가 됩니다. 예를 들어, 1행째때는 1/1, 2행째때는 1/2, 3행째때는 1/3 의 확률과 같이 됩니다. 이것으로 왜 랜덤에 1행선택할 수 있는가 하는 문제는 수학의 문제입니다. 간단하게 쓰면, 전부 3행의 파일이었던 경우에, 1행째가 선택되는 것은,1행째에 조건이 진이 되어, 2행째와3행째로는 조건이 가짜가 될 필요가 있습니다. 따라서, 확률은 1/1 * (1 - 1/2) * (1 - 1/3) = 1/3 되어, 분명하게 행수로 나눈 확률이 됩니다. 2행째가 선택되는 것은, 조건이 2행째에 진으로 3행째에 가짜의 경우입니다. 2행째에 실로 되면 그 이전의 조건은 무관계하다고 하는 것은 좋다 (이)군요? 그 결과, 확률은 역시 1/2 * (1 - 1/3) = 1/3 되어, 행수로 나눈 확률이 됩니다.

탑에

디렉토리(폴더) 사이즈를 요구한다

# 디렉토리 $dir 의 사이즈 $size 를 요구한다

use File::Find;

find(sub {$size += -s if -f}, $dir);
print $size, "bytes\n";

이 스크립트는디렉토리 $dir 이하의 모든 파일의 파일 사이즈의 합계를 요구하고 있습니다. 어느 디렉토리 이하의 모든 파일 또는 디렉토리에 대해서 무엇인가 처리하고 싶다 경우에는표준 모듈 File::Find 의 find 함수를 사용하는 것이 간단합니다. 이 함수는제 2 인수로 준 디렉토리에 대해서, 파일 또는 디렉토리를폭우선으로 탐색해, 발견되었다 파일 또는 디렉토리를 $_ 에 1개대입해제 1 인수로 준 함수를 실행합니다. 정확하게는제 1 인수에 (은)는함수에의 레퍼런스를 줍니다. 이 스크립트에서는무명 함수에의 레퍼런스를 주고 있습니다. 이것은 다음과 같이 써도 같습니다. 

# 디렉토리 $dir 의 사이즈 $size 를 요구한다(알기 쉽고)

use File::Find;

find(\&wanted, $dir);
print $size, "bytes\n";

sub wanted {
  $size += -s $_ if -f $_;
}

-s (은)는파일 테스트 연산자의 하나로 파일 사이즈를 돌려줍니다. -f (은)는 디렉토리나 기호 연결등으로는 없고 보통 파일 때에 진이 됩니다. 폭우선은 아니고깊이 우선으로 처리하고 싶은 경우에는 finddepth 함수를 사용합니다.

탑에

태그를 삭제한다

$str 는 EUC-JP 그렇다고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 안의 태그를 삭제한 $result 를 만든다
# $tag_regex 와 $tag_regex_ 는 별도 참조

$text_regex = q{[^<]*};

$result = '';
while ($str =~ /($text_regex)($tag_regex)? /gso) {
  last if $1 eq '' and $2 eq '';
  $result . = $1;
  $tag_tmp = $2;
  if ($tag_tmp =~ /^<(XMP|PLAINTEXT|SCRIPT)(?![0-9A-Za-z]) /i) {
    $str =~ /(. *? )(? :<\/$1(?![0-9A-Za-z]) $tag_regex_|$) /gsi;
    ($text_tmp = $1) =~ s/</&lt;/g;
    $text_tmp =~ s/>/&gt;/g;
    $result . = $text_tmp;
  }
}

이 스크립트의 기본은 「자동으로 URI(URL)의 링크한다」의 스크립트와 같습니다. 자세하게는 그 쪽을 참조해 주세요. $tag_regex 및 $tag_regex_ 에 대해서는 「HTML 태그의 정규 표현」의 스크립트를 정규 표현으로서 사용합니다. 또, $str 에는 HTML 문서전체를 넣어 둡니다. 주의가 필요한 점으로서는, XMP 태그나 PLAINTEXT 태그를 삭제했을 경우에는, 그것까지 그 중에 무효였던 태그가 유효하게 되어 버릴 가능성이 있는 것입니다. 그 때문에,XMP 태그나 PLAINTEXT 태그를 삭제할 경우에는, 그 중의 < 를 &lt; 에, > 를 &gt; (으)로 변환하고 있습니다. SCRIPT 태그에 대해서도 같습니다.

다음과 같이 해 태그의 개시 < 와 종료 > 에만 주목해 태그를 삭제하는 방법에서는 잘 되지 않는경우가 있습니다. 

# $str 안의 태그를 삭제한 $result 를 만든다(불완전)

($result = $str) =~ s/<[^>]*>//g;

구체적으로는 다음과 같은 불편이 있습니다.

최초의 스크립트에서는 이러한 경우에도 잘되게 되어 있습니다. 다만,HTML 문서로서 올바르게 쓰여져 있는 경우를 상정해 있기 때문에, < 에 대응하는 > 가 없을 때 등은 예기치 못한 동작을 하는 것에 됩니다.

만약 BR태그나 A태그등 특정의 태그만은 삭제하고 싶지 않은 경우에는, $tag_tmp = $2; 의 뒤에, 다음과 같이 해 $tag_tmp 를 $result 에 가세하도록 하면 할 수 있습니다. 

  $result . = $tag_tmp if $tag_tmp =~ /^<\/? (BR|A)(?![0-9A-Za-z]) /i;

반대로 FONT 태그나 IMG 태그등 특정의 태그만 삭제하고 싶은 경우에는, $tag_tmp = $2; 의 뒤에, 다음과 같이 해 $tag_tmp 를 $result 에 가세하도록 하면 할 수 있습니다. 

  $result . = $tag_tmp if $tag_tmp ! ~ /^<\/? (FONT|IMG)(?![0-9A-Za-z]) /i;

모듈 HTML::TokeParser 의 get_text 메소드, 또는 get_trimmed_text 메소드나, striphtml (을)를 사용해도 같은 일이 생깁니다.

탑에

자동으로 URI(URL)의 링크한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP (으)로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 안의 URI(URL)에 링크한 $result 를 만든다
# $tag_regex 와 $tag_regex_ 는 별도 참조
# $http_URL_regex 와 $ftp_URL_regex 및 $mail_regex 는 별도 참조

$text_regex = q{[^<]*};

$result = '';  $skip = 0;
while ($str =~ /($text_regex)($tag_regex)? /gso) {
  last if $1 eq '' and $2 eq '';
  $text_tmp = $1;
  $tag_tmp = $2;
  if ($skip) {
    $result . = $text_tmp .  $tag_tmp;
    $skip = 0 if $tag_tmp =~ /^<\/[aA](?![0-9A-Za-z])/;
  } else {
    $text_tmp =~ s{($http_URL_regex|$ftp_URL_regex|($mail_regex))}
      {my($org, $mail) = ($1, $2);
       (my $tmp = $org) =~ s/"/&quot;/g;
       '<A HREF="' .  ($mail ne '' ?  'mailto:' : '') .  "$tmp\">$org</A>"}ego;
    $result . = $text_tmp .  $tag_tmp;
    $skip = 1 if $tag_tmp =~ /^<[aA](?![0-9A-Za-z])/;
    if ($tag_tmp =~ /^<(XMP|PLAINTEXT|SCRIPT)(?![0-9A-Za-z]) /i) {
      $str =~ /(. *? (? :<\/$1(?![0-9A-Za-z]) $tag_regex_|$)) /gsi;
      $result . = $1;
    }
  }
}

$http_URL_regex 에 대해서는 「http URL 의 정규 표현」, $ftp_URL_regex 에 대해서는 「ftp URL 의 정규 표현」, $mail_regex 에 대해서는 「메일 주소의 정규 표현」의 마지막에 써 있다 스크립트를 정규 표현으로서 사용합니다. 또, $tag_regex 및 $tag_regex_ 에 대해서는 「HTML 태그의 정규 표현」의 스크립트를 정규 표현으로서 사용합니다. 또, $str 에는 HTML 문서전체를 넣어 둡니다. 이 스크립트는 이하의 항목에 들어맞지 않는 http URL 와 ftp URL 및 메일 주소에 대해 링크합니다.

이 스크립트의 설명을 간단하게 합니다. $str 에 대해서, 텍스트 부분과 태그 부분을 각각 1개두개 찾아 while 문 을 돌립니다. 태그 부분은 특히 처리할 필요는 없기 때문에 그대로입니다. $skip (은)는 A태그로 링크하기 시작했을 때에 1 이 됩니다. 이 때는 텍스트 부분을 특히 처리하는 일 없이 그대로 합니다. A태그가 닫았을 때에 $skip 를 0 에 되돌립니다. A태그로 링크하지 않을 때, 텍스트 부분에 http URL 나 ftp URL 또는 메일 주소를 찾아냈다 경우에는 링크합니다.

만약, 태그 부분이 XMP 태그, 또는, PLAINTEXT 태그였던 경우에는, 다음에 대응하는 닫고 태그까지 무조건 스킵 합니다. 무조건이라고 하는 것은,while 문장에 있는 조건으로 텍스트 부분과 태그 부분을 꺼낼 수가 없게 되기 (위해)때문에, 닫고 태그인 만큼 주목한다고 하는 것입니다. 왜냐하면, 이러한 태그의 유효 범위내에서는 다른태그가 무효(이)가 되어, 그대로 표시되기 때문입니다. 반대로 말하면, 이러한 태그의 유효 범위내에서는 태그로 보여도 태그는 아니고, 보통 텍스트와 같이 취급하지 않으면 안 되면 말하는 것입니다. 다만, 이 부분에 http URL 나 ftp URL, 메일 주소가 있는 경우에서도 링크는 치지 않습니다. 만약 쳤다고 해도, 그것은 그대로 표시되어 끝의미가 없기 때문입니다. SCRIPT 태그에 대해서도 같습니다.

$str 에 대한 패턴 매치가 행해지고 있다 2개소모두 에수식자 g 하지만 붙여져 있는 것에 주목해 주세요. 수식자 g (을)를 붙인 패턴 매치를스칼라 문맥으로 행하면(자), 전회 어디까지 패턴 매치를 행했는지를 보존해 두어, 다음번 그 계속으로부터 검색을 시작해 줍니다. 이 스크립트에서는 기본적으로 텍스트 부분과 태그 부분을 1개두개 찾아 while 문장을 돌리고 있습니다만,XMP 태그, PLAINTEXT 태그,SCRIPT 태그때 만일 수 있는은 별처리를 할 필요가 있습니다. 그 처리 종료후 while 문장에 돌아왔을 때에는, 그 계속으로부터 패턴 매치를 받는다 필요가 있습니다. 이러한 때에, $str 에 대한 어느 쪽의 패턴 매치에 두어도수식자 g 가 붙여져 있기 때문에, 어느 쪽의 경우도 때마침 계속으로부터 패턴 매치를 시작할 수가 있는 것입니다.

치환에 의해 링크하는 처리입니다만, 단순하게 다음과 같이 행한 것은 2개의 이유로부터 맛이 없게 됩니다. 

    $text_tmp =~ s/($http_URL_regex) /<A HREF="$1">$1<\/A>/go;
    $text_tmp =~ s/($ftp_URL_regex) /<A HREF="$1">$1<\/A>/go;
    $text_tmp =~ s/($mail_regex) /<A HREF="mailto:$1">$1<\/A>/go;

1개째의 이유는, 태그 중(안)에서는 다브르크트로 둘러싸는 형편상, 성냥 한 것이 다브르크트를 포함하고 있으면(자) 맛이 없게 된다고 하는 것입니다. 거기서, 다브르크트로 둘러싸는 부분에 대해서는, 성냥 한 것에 포함된다 다브르크트를 &quot; (으)로 변환한다고 하는 처리가 필요하게 됩니다.

2개(살)째의 이유입니다만, 치환의 처리가 http URL, ftp URL, 메일 주소의 각각 붙어 독립해 행해지고 있다고 하는 것입니다. 이것들은 서로 다른 정규 표현에 성냥 하는 부분을 포함할 수가 있습니다. 구체적인 예로 말하면, 다음과 같은 것을 들 수 있습니다. 

http://www.din.or.jp/~ohzaki/? ftp://ftp.din.or.jp/+ohzaki@din.or.jp
ftp://ftp.din.or.jp/ohzaki@din.or.jp
"http://www.din.or.jp/~ohzaki/? ftp://ftp.din.or.jp/"@din.or.jp

위로부터 순서에 http URL,ftp URL, 메일 주소 되고 있습니다. 이것들을 독립해 치환 처리했을 경우, 메일 주소의 일부를 http URL 로서 치환해 버리거나http URL 의 일부를 ftp URL 로서 치환해 버린다라고 하는 일이 일어나 버립니다. 어느 쪽이 어느 쪽으로 포함되는지 모르기 때문에, 치환 처리의 차례로 동공 할 수 있는 문제가 아닙니다. 다행스럽게도, 선두 부분이 다른 정규 표현에 성냥 할 것은 없기 때문에, 이러한 치환 처리를 1개의 정규 표현으로 해 정리해,1회의 치환 처리로 행하는 것으로, 잘 링크할 수가 있습니다.

탑에

문자의 정규 표현

# 반각 스페이스
$space = '\x20';

# 전각 스페이스
$Zspace = '(? :\xA1\xA1)'; # EUC-JP
$Zspace_sjis = '(? :\x81\x40)'; # SJIS

# 전각 숫자 [0-9]
$Zdigit = '(? :\xA3[\xB0-\xB9])'; # EUC-JP
$Zdigit_sjis = '(? :\x82[\x4F-\x58])'; # SJIS

# 전각 대문자 [A-Z]
$Zuletter = '(? :\xA3[\xC1-\xDA])'; # EUC-JP
$Zuletter_sjis = '(? :\x82[\x60-\x79])'; # SJIS

# 전각 소문자 [a-z]
$Zlletter = '(? :\xA3[\xE1-\xFA])'; # EUC-JP
$Zlletter_sjis = '(? :\x82[\x81-\x9A])'; # SJIS

# 전각 알파벳 [A-Za-z]
$Zalphabet = '(? :\xA3[\xC1-\xDA\xE1-\xFA])'; # EUC-JP
$Zalphabet_sjis = '(? :\x82[\x60-\x79\x81-\x9A])'; # SJIS

# 전각 히라가나 [-응]
$Zhiragana = '(? :\xA4[\xA1-\xF3])'; # EUC-JP
$Zhiragana_sjis = '(? :\x82[\x9F-\xF1])'; # SJIS

# 전각 히라가나(확장) [-응″˚□□]
$ZhiraganaExt = '(? :\xA4[\xA1-\xF3]|\xA1[\xAB\xAC\xB5\xB6])'; # EUC-JP
$ZhiraganaExt_sjis = '(? :\x82[\x9F-\xF1]|\x81[\x4A\x4B\x54\x55])'; # SJIS

# 전각 카타카나 []
$Zkatakana = '(? :\xA5[\xA1-\xF6])'; # EUC-JP
$Zkatakana_sjis = '(? :\x83[\x40-\x96])'; # SJIS

# 전각 카타카나(확장) [·-□□]
$ZkatakanaExt = '(? :\xA5[\xA1-\xF6]|\xA1[\xA6\xBC\xB3\xB4])'; # EUC-JP
$ZkatakanaExt_sjis = '(? :\x83[\x40-\x96]|\x81[\x45\x5B\x52\x53])'; # SJIS

# 반각 카타카나 [˚]
$Hkatakana = '(? :\x8E[\xA6-\xDF])'; # EUC-JP
$Hkatakana_sjis = '[\xA6-\xDF]'; # SJIS

# EUC-JP문자
$ascii = '[\x00-\x7F]'; # 1바이트 EUC-JP문자
$twoBytes = '(? :[\x8E\xA1-\xFE][\xA1-\xFE])'; # 2바이트 EUC-JP문자
$threeBytes = '(? :\x8F[\xA1-\xFE][\xA1-\xFE])'; # 3바이트 EUC-JP문자
$character = "(? :$ascii|$twoBytes|$threeBytes) "; # EUC-JP문자

# EUC-JP문자(기종 의존 문자·미정도리 영역·3바이트 문자를 포함하지 않는다)
$character_strict = '(? :[\x00-\x7F]|' # ASCII
  .  '\x8E[\xA1-\xDF]|' # 반각 카타카나
  .  '[\xA1\xB0-\xCE\xD0-\xF3][\xA1-\xFE]|' # 1,16-46,48-83구
  .  '\xA2[\xA1-\xAE\xBA-\xC1\xCA-\xD0\xDC-\xEA\xF2-\xF9\xFE]|' # 2구
  .  '\xA3[\xB0-\xB9\xC1-\xDA\xE1-\xFA]|' # 3구
  .  '\xA4[\xA1-\xF3]|' # 4구
  .  '\xA5[\xA1-\xF6]|' # 5구
  .  '\xA6[\xA1-\xB8\xC1-\xD8]|' # 6구
  .  '\xA7[\xA1-\xC1\xD1-\xF1]|' # 7구
  .  '\xA8[\xA1-\xC0]|' # 8구
  .  '\xCF[\xA1-\xD3]|' # 47구
  .  '\xF4[\xA1-\xA6])'; # 84구

# EUC-JP미정 요시후미자(기종 의존 문자·3바이트 문자를 포함한다)
$character_undef = '(? :[\xA9-\xAF\xF5-\xFE][\xA1-\xFE]|' # 9-15,85-94구
  .  '\x8E[\xE0-\xFE]|' # 반각 카타카나
  .  '\xA2[\xAF-\xB9\xC2-\xC9\xD1-\xDB\xEB-\xF1\xFA-\xFD]|' # 2구
  .  '\xA3[\XA1-\xAF\xBA-\xC0\xDB-\xE0\xFB-\xFE]|' # 3구
  .  '\xA4[\xF4-\xFE]|' # 4구
  .  '\xA5[\xF7-\xFE]|' # 5구
  .  '\xA6[\xB9-\xC0\xD9-\xFE]|' # 6구
  .  '\xA7[\xC2-\xD0\xF2-\xFE]|' # 7구
  .  '\xA8[\xC1-\xFE]|' # 8구
  .  '\xCF[\xD4-\xFE]|' # 47구
  .  '\xF4[\xA7-\xFE]|' # 84구
  .  '\x8F[\xA1-\xFE][\xA1-\xFE])'; # 3바이트 문자

# SJIS 문자
$oneByte_sjis = '[\x00-\x7F\xA1-\xDF]'; # 1바이트 SJIS 문자
$twoBytes_sjis =
  '(? :[\x81-\x9F\xE0-\xFC][\x40-\x7E\x80-\xFC])'; # 2바이트 SJIS 문자
$character_sjis = "(? :$oneByte_sjis|$twoBytes_sjis) "; # SJIS 문자

# SJIS 문자(기종 의존 문자·미정도리 영역을 포함하지 않는다)
$character_sjis_strict = '(? :[\x00-\x7F\xA1-\xDF]|' # ASCII, 반각 카타카나
  .  '[\x89-\x97\x99-\x9F\xE0-\xE9][\x40-\x7E\x80-\xFC]|' # 17-46,49-82구
  .  '\x81[\x40-\x7E\x80-\xAC\xB8-\xBF\xC8-\xCE\xDA-\xE8\xF0-\xF7\xFC]|' # 1,2구
  .  '\x82[\x4F-\x58\x60-\x79\x81-\x9A\x9F-\xF1]|' # 3,4구
  .  '\x83[\x40-\x7E\x80-\x96\x9F-\xB6\xBF-\xD6]|' # 5,6구
  .  '\x84[\x40-\x60\x70-\x7E\x80-\x91\x9F-\xBE]|' # 7,8구
  .  '\x88[\x9F-\xFC]|' # 15,16구
  .  '\x98[\x40-\x72\x9F-\xFC]|' # 47,48구
  .  '\xEA[\x40-\x7E\x80-\xA4])'; # 83,84구

# SJIS 미정 요시후미자(기종 의존 문자를 포함한다)
$character_sjis_undef =
  '(? :[\x85-\x87\xEB-\xFC][\x40-\x7E\x80-\xFC]|' # 9-14,85-120구
  .  '\x81[\xAD-\xB7\xC0-\xC7\xCF-\xD9\xE9-\xEF\xF8-\xFB]|' # 1,2구
  .  '\x82[\x40-\x4E\x59-\x5F\x7A-\x7E\x80\x9B-\x9E\xF2-\xFC]|' # 3,4구
  .  '\x83[\x97-\x9E\xB7-\xBE\xD7-\xFC]|' # 5,6구
  .  '\x84[\x61-\x6F\x92-\x9E\xBF-\xFC]|' # 7,8구
  .  '\x88[\x40-\x7E\x80-\x9E]|' # 15,16구
  .  '\x98[\x73-\x7E\x80-\x9E]|' # 47,48구
  .  '\xEA[\xA5-\xFC])'; # 83,84구

# i모드 대응 그림 문자 
$iPictograph_base = '(? :\xF8[\x9F-\xFC]|' # 기본 그림 문자(SJIS)
  .  '\xF9[\x40-\x49\x50-\x52\x55-\x57\x5B-\x5E\x72-\x7E\x80-\xB0])';
$iPictograph_ext = '(? :\xF9[\xB1-\xFC])'; # 확장 그림 문자(SJIS)
$iPictograph =
  '(? :$iPictograph_base|$iPictograph_ext)'; # i모드 대응 그림 문자(SJIS)

일본어의 취급에 대해서는 「일본어를 취급한다」를 참조.

개개의 기종 의존 문자에 대해서는 여기에서는 취급하지 않는 것으로 한다. 왜냐하면, 기종 의존 문자는 각 vender·문자 코드 마다 매우 많은 종류가 존재해, 그 모든 것을 파악하는 것은 불가능하기 때문에이다. 이하의 링크처의 문서의 외자(유저 정의와 vender 정의)의 란이 기종 의존 문자에 해당한다.

탑에

HTML 태그의 정규 표현

# HTML 태그의 정규 표현 $tag_regex

$tag_regex_ = q{[^"'<>]*(? :"[^"]*"[^"'<>]*|'[^']*'[^"'<>]*)*(? :>|(? =<)|$(?!\n))}; #'}}}}
$comment_tag_regex =
    '<! (? :--[^-]*-(? :[^-]+-)*? -(? :[^>-]*(? :-[^>-]+)*? )??)*(? :>|$(?!\n)|--. *$)';
$tag_regex = qq{$comment_tag_regex|<$tag_regex_};

이 스크립트의 $comment_tag_regex 하지만 코멘트 태그의 정규 표현으로, $tag_regex_ 가 코멘트 태그 이외의 보통 태그의 < 이후의 정규 표현이 됩니다.

최초로 보통 태그의 정규 표현에 대해 설명합니다. 보통 태그의 내용의 정규 표현으로서 최초로 생각나는 것은 [^>]* 입니다. 그러나, 이것으로는 다브르크트나 싱르크트로 둘러싸인 안에 > 가 있었을 경우에 맛이 없게 됩니다. 거기서, 다브르크트나 싱르크트에 대해 생각합니다.

다브르크트로 둘러싸여 있는 부분의 정규 표현은 "[^"]*" 라고 쓸 수가 있습니다. 싱르크트로 둘러싸여 있는 부분에 대해서도 같습니다. 이것으로 다브르크트나 싱르크트로 둘러싸여 있는 안쪽에는 > (을)를 포함할 수가 있습니다. 그 이외의 다브르크트에서도 싱르크트에서도 둘러싸이지 않은 부분은 이번이야말로 [^>] 이니까, 결국 (? :[^>]|"[^"]*"|'[^']')* 그리고 좋은가, 라고 하면(자) 그렇게 잘 네 오지 않습니다. [^>] 에서는 다브르크트나 싱르크트까지 포함해 버리기 (위해)때문에, 모처럼 준비한 다브르크트나 싱르크트로 둘러싸여 있는 부분의 정규 표현이 사용되는 일 없이 그대로 매칭이 진행되어, 다브르크트나 싱르크트의 안의 > 를 태그의 마지막으로 잘못알아 성냥이 성공해 버립니다.

이것을 회피하려면 , (? :"[^"]*"|'[^']*'|[^>])* (와)과 같이 최초로 다브르크트나 싱르크트로 둘러싸여 있는지 어떤지를 조사하는 방법이 있습니다. 그러나, 이것은 분명하게늦은입니다. 왜냐하면, 다브르크트나 싱르크트로 둘러싸이지 않은 부분의 경우, 1 문자마다 다브르크트와 싱르크트의 매칭이 실패하지 않으면 [^>] 에 성냥 하지 않기 때문입니다. 거기서 다음과 같이 [^"'>] 로 하면(자) 모든 것이 잘됩니다. 

$tag_regex_ = q{(? :[^"'>]|"[^"]*"|'[^']*')*}; #'}}}

다음에 닫지 않는 태그를 생각합니다. 닫지 않는 태그란 <P<B> 와 같이 > (을)를 생략 되어 있는 것입니다. 이 때 <P (을)를 올바르게 태그로서 인식하기 위해서는, 태그의 내용은 [^>]* 는 아니고 [^<>]* 로 해야 하게 됩니다. 또, 태그의 최후는 반드시 > 로 끝난다고는 할 수 없기 때문에, (? :>|(? =<)|$(?!\n)) 로 할 필요가 있습니다. 이것은 > 로 끝나는 보통 태그인가, 또는, 그 다음의 문자가 태그의 개시 문자인 < 인지, 또는, 캐릭터 라인의 최후인 경우를 나타내고 있습니다. $(?!\n) 에 대해서는 다음에 자세하게 설명합니다. 결국, 이것을 정리하면(자) 다음과 같이 됩니다. 

$tag_regex_ = q{(? :[^"'<>]|"[^"]*"|'[^']*')*(? :>|(? =<)|$(?!\n))}; #'}}}

이것을 Jeffrey E. F. Friedl씨 원저에 의한다 「상세 해설 정규 표현 ( Mastering Regular Expressions )」로 「루프 전개」로서 쓰여져 있다 수법으로실행 속도를 빠르게한 것이 최초의 스크립트의 정규 표현입니다. 간단한 벤치마크를 취해 보았는데약 1.5배정도 빨랐습니다.

다음에 코멘트 태그의 정규 표현의 설명을 합니다. 코멘트 태그에 대해서는, 우선은 6월변하고들씨에 의한다 「 SGML의 주석 선언」을 일독하는 것을 추천합니다.

코멘트 태그, 즉, 주석 선언은 --코멘트의 내용-- 그렇다고 하는 코멘트만으로부터 구성되어 있습니다. 코멘트 태그는복수의 코멘트를 가지는일이 생겨 코멘트의 뒤에는공백 문자만있어도 괜찮습니다. 또, 코멘트의 내용이나 코멘트의 수가 0개여도 괜찮습니다. 다만,<! (와)과 코멘트동안에 공백 문자가 있는 것은 용서되지 않기 때문에,<! 의 직후에는 코멘트인가 닫고 괄호의 > 밖에 와선 안 되게 됩니다. 이상로부터, 정상적인 코멘트 태그의 정규 표현은 다음과 같이 됩니다. 

# 정상적인 코멘트 태그의 정규 표현 $comment_tag_regex

$comment_tag_regex = q{<! (? :--(? :(?!--). ) *--\s*) *>};

이 정상적인 코멘트 태그의 정규 표현을 기초로, 닫지 않는 코멘트 태그였던 경우와 코멘트의 뒤로 공백 문자 이외의 문자가 있어 부정한 코멘트 태그였던 경우에도 대응한 정규 표현이 최초의 스크립트가 됩니다.

마지막 (? :>|$(?!\n)|--. *$) 의 선택은 각각, 코멘트 태그가 닫고 있었을 경우, 코멘트의 뒤에 > 가 없게 닫아 없었던 경우, 코멘트의 마지막의 -- 하지만 없게 코멘트의 내용이 끝까지 계속되고 있는 경우를 나타내고 있습니다. $(?!\n) 그렇지만, 단순한 $ 이라도 좋은 것이 아닐까 의문에 생각되는 사람도 있을까하고 생각합니다만,$(?!\n) 와 $ 에서는 조금의미가 다릅니다. 예를 들어, $str = "test\n"; 때, m/^test$/ (은)는 성냥 합니다만,m/^test$(?!\n)/ 는 성냥 하지 않습니다. 왜냐하면,$ 은 캐릭터 라인의 마지막에 개행이 있었을 경우에는, 개행의 직전이라도 성냥 하는으로부터입니다. 만약, 'test' 에는 성냥 해 주었으면 하지만, "test\n" 에는 성냥 하기를 바라지 않다고 할 때, 단순한 $ 그럼 곤란한 것입니다. 코멘트 태그의 정규 표현에서는 "<! \n" (와)과 같은 경우에 성냥 받아서는 곤란하므로 이러한 정규 표현이 되어 있습니다. perl5. 005 이후라면 $(?!\n) 를 \z (으)로 할 수가 있습니다. \z 는 $ 이나 \Z (와)과 달리 진정한 의미로 캐릭터 라인의 마지막에 성냥 합니다.

실은 다음과 같이 코멘트 태그의 정규 표현을 써도 같은 것이 생깁니다. 이해하려면 우선 이쪽의 정규 표현을 기초로 생각하는 것이 좋을지도 모릅니다. 

# 코멘트 태그의 정규 표현(늦다)

$comment_tag_regex = '<! (? :--(? :(?!--). )*--(? :(?!--)[^>])*)*(? :>|$(?!\n)|--. *$)';

이 정규 표현에서는, 코멘트의 내용을 나타내는 정규 표현으로서 (? :(?!--). )* (으)로 하고 있습니다. 이것의 의미는, 다음에 -- 하지만 오지 않는 것 같은 무엇인가 1 문자의 반복이라고 하는 것입니다. 즉, - 하지만 단독으로 나타났을 경우에는 문제 없는 것으로, -- (와)과 계속해 나타난다 - (은)는 안된다고 하는 것이 됩니다. 이것으로 코멘트의 내용에는 -- 이 절대로 나타나지 않는 것이 보증됩니다. 코멘트의 내용을 나타내는 정규 표현으로서는 이것으로 올바릅니다만, 1 문자마다 -- 가 아닌 것을 체크하고 있으므로 이대로는실행 속도가 늦은입니다.

거기서 보통 태그 때와 같게 「루프 전개」의 수법을 이용하는 것으로 합니다. 우선,-- 이 오지 않는 무엇인가 1 문자의 반복을 나타낸다 (? :(?!--). )* (을)를 조금 다른 생각으로 다시 표현합니다. 이 정규 표현은 -- 하지만 포함되지 않는 부분이라고 하는 것이므로, 우선,-이외의 문자라면 문제 없는 것은 곧바로 안다고 생각합니다. 만일 - 하지만 왔다고 해도 그 다음의 문자가 -이외의 문자이면 그 경우도 또 괜찮습니다. 그 말은,(? :(?!--). )* (은)는 (? :[^-]|-[^-])* (와)과 변형할 수가 있습니다. 이것에 대해서 「루프 전개」의 수법을 이용하면(자), [^-]*(? :-[^-][^-]*)* 되어, 결국 [^-]*(? :-[^-]+)* 됩니다.

이것으로 코멘트 부분의 정규 표현은 --[^-]*(? :-[^-]+)*-- 되었습니다. 간단한 벤치마크를 취했는데 약 2배정도 빨라졌습니다. 그러나, 아직 최초의 스크립트와는 조금 차이가 납니다. 이 코멘트 부분의 정규 표현에는비결정성인 곳이 있습니다. 그것은 - 이 왔을 때에, 그 시점에서는 그것이 코멘트의 내용인가, 코멘트의 종료를 나타낸다 -- 의 최초의 1 문자인가 모릅니다만, 정규 표현에서도 역시 성냥 할 가능성이 있는 장소가 2개소에 되어 있다고 하는 것입니다. 즉,(? :-[^-]+)* 의 (? : 직후의 - 에 성냥 할지도 모르고, (? :-[^-]+)* 직후의 - 에 성냥 할지도 모릅니다. 이러한 비결정성은 백 트럭 발생시에 많은 부담을 강요하게 됩니다. 거기서, [^-]*(? :-[^-]+)*-- (을)를 변형해, 비결정성을 배제하면(자) [^-]*-(? :[^-]+-)*- 됩니다. 이것으로 - 하지만 왔을 때에 성냥 하는 정규 표현의 부분은 [^-]* 직후의 것 - 의 1개소 됩니다.

여기까지의 변형으로 꽤 최초의 스크립트에 가까워졌습니다만, 아직 1개소차이가 납니다. 그것은 (? :[^-]+-)* (와)과 (? :[^-]+-)*? , 즉, * (와)과 *? 의 차이입니다. 일반적으로 * (와)과 *? (을)를 바꾸니 성냥 하는 것도 바뀌어 버립니다. 그러나, 이번 경우는 * 그렇지만 *? 그렇지만 반드시 같은 결과가 됩니다. 반드시 같은 결과가 되는 것을 알 수 있고 있으므로, 실행 속도가 빠른 (분)편을 생각합니다. 일반적으로 코멘트 태그라는 것은 <-- 이것은 코멘트 태그입니다 --> 라고 하는 것 같은 것이 대부분이지요. 즉, 코멘트 태그의 내용으로서 - (을)를 포함하고 있는 것의 출현 빈도는, 포함하지 않은 출현 빈도보다 낮다고 하는 것입니다. 만약, 코멘트 태그의 내용에 - 를 포함하고 있었다 경우는 (? :[^-]+-) 의 부분을 통과하게 됩니다. 그러나, 실제로는 포함하지 않은 것이 많은 것이기 때문에, (? :[^-]+-) 의 부분을 체크하는 것은 쓸데없는 됩니다. 거기서,* 를 *? (와)과 하는 것으로 이 헛됨을 가능한 한 배제할 수가 있습니다.

다음에 (? :(?!--)[^>])* 의 부분에 도착해 생각합니다. 여기도 코멘트 태그의 내용의 부분과 같게 우선은 「루프 전개」의 수법을 이용해 (? :[^>-]*(? :-[^>-]+)* (와)과 변형합니다. 더욱, * (을)를 *? (으)로 할 수가 있기 때문에, (? :[^>-]*(? :-[^>-]+)*? (와)과 변형하는 곳(중)까지는 같습니다.

최초의 스크립트에서는 더욱 전체를 (? : regex)?? (와)과 같이 ?? (을)를 붙인 형태로 하고 있습니다. 이것은, 코멘트 태그의 내용과 달리, 일반적으로 코멘트의 종료를 나타낸다 -- 의 뒤에는 무엇인가 문자가 들어가는 일 없이 직후에 > 로 닫혀지고 있는 것의 출현 빈도가 높다고 생각되기 (위해)때문에입니다. 바꾸어 말하면(자), (? :[^>-]*(? :-[^>-]+)*? 하지만 성냥 하는 것은 거의 없는, 즉, 성냥 시키려고 하면(자) 쓸데없게 끝난다 일이 많다고 생각되기 (위해)때문에, 이 부분의 정규 표현 전체에 ?? (을)를 붙여, 가능한 한 체크시키지 않게 하고 있습니다.

탑에

URI(URL)의 정규 표현

# $uri 가 올바른 URI 나 판정한다

$digit = q{[0-9]};
$upalpha = q{[A-Z]};
$lowalpha = q{[a-z]};
$alpha = qq{(? :$lowalpha|$upalpha)};
$alphanum = qq{(? :$alpha|$digit)};
$hex = qq{(? :$digit|[A-Fa-f])};
$escaped = qq{%$hex$hex};
$mark = q{[-_.!~*'()]};
$unreserved = qq{(? :$alphanum|$mark)};
$reserved = q{[;/? :@&=+$,]};
$uric = qq{(? :$reserved|$unreserved|$escaped)};
$fragment = qq{$uric*};
$query = qq{$uric*};
$pchar = qq{(? :$unreserved|$escaped|} .  q{[:@&=+$,])};
$param = qq{$pchar*};
$segment = qq{$pchar*(? :;$param)*};
$path_segments = qq{$segment(? :/$segment)*};
$abs_path = qq{/$path_segments};
$uric_no_slash = qq{(? :$unreserved|$escaped|} .  q{[;? :@&=+$,])};
$opaque_part = qq{$uric_no_slash$uric*};
$path = qq{(? :$abs_path|$opaque_part)? };
$port = qq{$digit*};
$IPv4address = qq{$digit+\\. $digit+\\. $digit+\\. $digit+};
$toplabel = qq{(? :$alpha|$alpha(? :$alphanum|-) *$alphanum)};
$domainlabel = qq{(? :$alphanum|$alphanum(? :$alphanum|-) *$alphanum)};
$hostname = qq{(? :$domainlabel\\. ) *$toplabel\\.?};
$host = qq{(? :$hostname|$IPv4address)};
$hostport = qq{$host(? ::$port)? };
$userinfo = qq{(? :$unreserved|$escaped|} .  q{[;:&=+$,])*};
$server = qq{(? :(? :$userinfo\@)? $hostport)? };
$reg_name = qq{(? :$unreserved|$escaped|} .  q{[$, ;:@&=+])+};
$authority = qq{(? :$server|$reg_name)};
$scheme = qq{$alpha(? :$alpha|$digit|[-+. ])*};
$rel_segment = qq{(? :$unreserved|$escaped|} .  q{[;@&=+$,])+};
$rel_path = qq{$rel_segment(? :$abs_path)? };
$net_path = qq{//$authority(? :$abs_path)? };
$hier_part = qq{(? :$net_path|$abs_path)(? :\\? $query)? };
$relativeURI = qq{(? :$net_path|$abs_path|$rel_path)(? :\\? $query)? };
$absoluteURI = qq{$scheme:(? :$hier_part|$opaque_part)};
$URI_reference = qq{(? :$absoluteURI|$relativeURI)? (? :#$fragment)? };

$pattern = $URI_reference;

print "ok\n" if $uri =~ /^$pattern$/o;

URI 에 대해서는 RFC 2396 ( 일본어 번역 )에 쓰여져 있습니다. 그것을 기계적으로 솔직하게 정규 표현으로 했다 물건이 위의 스크립트입니다. 지금부터 요구한 URI References 의 정규 표현은 다음과 같이 되었습니다. 

(? :(? :[a-z]|[A-Z])(? :(? :[a-z]|[A-Z])|[0-9]|[-+. ])*:(? :(? ://(? :(? :(
? :(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])
(? :[0-9]|[A-Fa-f])|[;:&=+$,])*@)? (? :(? :(? :(? :(? :[a-z]|[A-Z])|[0-9]
)|(? :(? :[a-z]|[A-Z])|[0-9])(? :(? :(? :[a-z]|[A-Z])|[0-9])|-)*(? :(? :[
a-z]|[A-Z])|[0-9]))\. )*(? :(? :[a-z]|[A-Z])|(? :[a-z]|[A-Z])(? :(? :(? :
[a-z]|[A-Z])|[0-9])|-)*(? :(? :[a-z]|[A-Z])|[0-9]))\.?|[0-9]+\. [0-9]
+\. [0-9]+\. [0-9]+)(? ::[0-9]*)? )? |(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[
-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[$, ;:@&=+])+)(? :
/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(
? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[
-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*(? :
/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(
? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[
-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*)*)
? |/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f]
)(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])
|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*(
? :/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f]
)(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])
|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*)
*)(? :\? (? :[;/? :@&=+$,]|(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%
(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]))*)? |(? :(? :(? :(? :[a-z]|[A-Z])|
[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[;? :@&=+
$,])(? :[;/? :@&=+$,]|(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :
[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]))*)|(? ://(? :(? :(? :(? :(? :(? :(? :[a-
z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]
)|[;:&=+$,])*@)? (? :(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|(? :(? :[a-z]|[A-
Z])|[0-9])(? :(? :(? :[a-z]|[A-Z])|[0-9])|-)*(? :(? :[a-z]|[A-Z])|[0-9]
))\. )*(? :(? :[a-z]|[A-Z])|(? :[a-z]|[A-Z])(? :(? :(? :[a-z]|[A-Z])|[0-9
])|-)*(? :(? :[a-z]|[A-Z])|[0-9]))\.?|[0-9]+\. [0-9]+\. [0-9]+\. [0-9]+
)(? ::[0-9]*)? )? |(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[
0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[$, ;:@&=+])+)(? :/(? :(? :(? :(? :[a-z
]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])
|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[
0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*(? :/(? :(? :(? :(? :[a-z
]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])
|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[
0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*)*)? |/(? :(? :(? :(? :[a
-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f
])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(?
:[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*(? :/(? :(? :(? :(? :[a
-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f
])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(?
:[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*)*)*|(? :(? :(? :(? :[a-
z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]
)|[;@&=+$,])+(? :/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :
[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]
|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|
[:@&=+$,])*)*(? :/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :
[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]
|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|
[:@&=+$,])*)*)*)? )(? :\? (? :[;/? :@&=+$,]|(? :(? :(? :[a-z]|[A-Z])|[0-9]
)|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]))*)? )? (? :#(? :[
;/? :@&=+$,]|(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A
-Fa-f])(? :[0-9]|[A-Fa-f]))*)?

이 정규 표현은 너무 너무 일반적이어, 대부분의 입력에 대해서 성냥 해 끝냅니다. RFC 2396 은 원래 URI 의 일반형을 정의했다 물건이므로, 이 정규 표현을 사용하는 것은 거의 없다고 말해도 좋을 것입니다.

탑에

http URL 의 정규 표현

# $http 가 올바른 http URL 나 판정한다

$digit = q{[0-9]};
$upalpha = q{[A-Z]};
$lowalpha = q{[a-z]};
$alpha = qq{(? :$lowalpha|$upalpha)};
$alphanum = qq{(? :$alpha|$digit)};
$hex = qq{(? :$digit|[A-Fa-f])};
$escaped = qq{%$hex$hex};
$mark = q{[-_.!~*'()]};
$unreserved = qq{(? :$alphanum|$mark)};
$reserved = q{[;/? :@&=+$,]};
$uric = qq{(? :$reserved|$unreserved|$escaped)};
$query = qq{$uric*};
$pchar = qq{(? :$unreserved|$escaped|} .  q{[:@&=+$,])};
$param = qq{$pchar*};
$segment = qq{$pchar*(? :;$param)*};
$path_segments = qq{$segment(? :/$segment)*};
$abs_path = qq{/$path_segments};
$port = qq{$digit*};
$IPv4address = qq{$digit+\\. $digit+\\. $digit+\\. $digit+};
$toplabel = qq{(? :$alpha|$alpha(? :$alphanum|-) *$alphanum)};
$domainlabel = qq{(? :$alphanum|$alphanum(? :$alphanum|-) *$alphanum)};
$hostname = qq{(? :$domainlabel\\. ) *$toplabel\\.?};
$host = qq{(? :$hostname|$IPv4address)};
$http_URL = qq{http://$host(? ::$port)? (? :$abs_path(? :\\? $query)? )? };

$pattern = $http_URL;

print "ok\n" if $http =~ /^$pattern$/;

http URL 에 대해서는 RFC 2616 의 3.2. 2 http URL 에 쓰여져 있습니다. 이 스크립트는, 「URI(URL)의 정규 표현」으로 쓴 URI(URL)의 정규 표현의 스크립트를 수정해, http URL 의 정규 표현으로 한 것입니다. 이 스크립트로부터 요구한 http URL 의 정규 표현은 다음과 같이 되었습니다. 

http://(? :(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|(? :(? :[a-z]|[A-Z])|[0-9]
)(? :(? :(? :[a-z]|[A-Z])|[0-9])|-)*(? :(? :[a-z]|[A-Z])|[0-9]))\. )*(? :
(? :[a-z]|[A-Z])|(? :[a-z]|[A-Z])(? :(? :(? :[a-z]|[A-Z])|[0-9])|-)*(? :
(? :[a-z]|[A-Z])|[0-9]))\.?|[0-9]+\. [0-9]+\. [0-9]+\. [0-9]+)(? ::[0-9
]*)? (? :/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-
Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[
0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,]
)*)*(? :/(? :(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()])|%(? :[0-9]|[A-
Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,])*(? :;(? :(? :(? :(? :[a-z]|[A-Z])|[
0-9])|[-_.!~*'()])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f])|[:@&=+$,]
)*)*)*(? :\? (? :[;/? :@&=+$,]|(? :(? :(? :[a-z]|[A-Z])|[0-9])|[-_.!~*'()
])|%(? :[0-9]|[A-Fa-f])(? :[0-9]|[A-Fa-f]))*)? )?

이 http URL 의 정규 표현은, 문자 클래스끼리의 선택이 정리하지 않기 때문에 헛됨이 많은 것을 압니다. 거기서, 문자 클래스를 가능한 한 정리하도록(듯이) 이하와 같이 일부 개량합니다. 

# $http 가 올바른 http URL 나 판정한다(문자 클래스 개량판)

$alpha = q{[a-zA-Z]};
$alphanum = q{[a-zA-Z0-9]};
$hex = q{[0-9A-Fa-f]};
$uric = q{(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]} .  qq{|$escaped)};
$pchar = q{(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]} .  qq{|$escaped)};
$toplabel = qq{(? :$alpha|$alpha} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)};
$domainlabel = qq{(? :$alphanum|$alphanum} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)};

이 스크립트로부터 요구한 http URL 의 정규 표현은 다음과 같이 되었습니다. 

http://(? :(? :(? :[a-zA-Z0-9]|[a-zA-Z0-9][-a-zA-Z0-9]*[a-zA-Z0-9])\.
)*(? :[a-zA-Z]|[a-zA-Z][-a-zA-Z0-9]*[a-zA-Z0-9])\.?|[0-9]+\. [0-9]+\
. [0-9]+\. [0-9]+)(? ::[0-9]*)? (? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0
-9A-Fa-f][0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa
-f][0-9A-Fa-f])*)*(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][
0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-F
a-f])*)*)*(? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A
-Fa-f])*)? )?

이 정규 표현은 전술했습니다만,RFC 2616 의 3.2. 2 http URL 에 쓰여져 있습니다. RFC 2616 에는 HTTP 프로토콜에 관한 일이 쓰여져 있어3.2. 2 http URL 에 쓰여져 있는 http URL 도, HTTP 프로토콜 중(안)에서의 이야기가 됩니다. 일반적으로, HTML 의 링크에 사용되는 것은, 순수하게 HTTP 프로토콜 중(안)에서 사용되는 http URL 는 아니고, scheme 가 http 인URI References 입니다.

예를 들어 http://user:passwd@www.din.or.jp/~ohzaki/perl.htm#URI (은)는 URI References 입니다만,user:passwd@ 의 부분, 즉, userinfo 나,#URI 의 부분, 즉, Fragment Identifier 는 HTTP 프로토콜 중(안)에서 사용된다 http URL 로서는 부정한 것이 됩니다. 그러나, HTML 의 링크로서는 문제 없습니다. 왜냐하면, 클라이언트(브라우저)가 HTTP 프로토콜로 통신하려면 그것들을 삭제하고 있기 때문입니다. 여담입니다만, RFC 2396 ( 일본어 번역 )의제 4장에는 Fragment Identifier 는 URI 의 일부에서는 없는이라고 쓰여지고 있습니다. Fragment Identifier 는 user agent 에 의해 해석되는 부가적 참조 정보라고 합니다.

다음에, scheme 가 http 인 URI References 를 생각합니다. 거기서 다시 「URI(URL)의 정규 표현」으로 쓴 URI(URL)의 정규 표현의 스크립트를 수정해 만듭니다. 그 때, HTTP 프로토콜 중(안)에서 사용되는 http URL (을)를 구축하는데 필요한 정보를 반드시 포함하고 있으면, 그 이외에 장황한 정보를 포함하고 있어도 괜찮다고 합니다. 필요한 정보란, host, port, abs_path, query 입니다. 또, scheme 는 당연히 http 입니다만, 이 때, Secure Hyper Text Tranasfer Protocol(S-HTTP)로 불린다 프로토콜을 사용하는 shttp: 나 Secure Sockets Layer(SSL) 그렇다고 하는 프로토콜을 사용하는 https: 에도 대응하도록(듯이) 해 둡니다. 수정한 결과는, 이하와 같이 일부를 수정하게 되었습니다. 

$server = qq{(? :$userinfo\@)? $hostport};
$authority = qq{$server};
$scheme = q{(? :https? |shttp)};
$hier_part = qq{$net_path(? :\\? $query)? };
$absoluteURI = qq{$scheme:$hier_part};
$URI_reference = qq{$absoluteURI(? :#$fragment)? };

이것에 방금전과 같이 문자 클래스를 정리하는 개량으로서 이하와 같이 일부 (을)를 수정했습니다. 

$alpha = q{[a-zA-Z]};
$alphanum = q{[a-zA-Z0-9]};
$hex = q{[0-9A-Fa-f]};
$unreserved = q{[-_.!~*'() a-zA-Z0-9]};
$uric = q{(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]} .  qq{|$escaped)};
$pchar = q{(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]} .  qq{|$escaped)};
$toplabel = qq{(? :$alpha|$alpha} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)};
$domainlabel = qq{(? :$alphanum|$alphanum} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)};
$userinfo = q{(? :[-_.!~*'() a-zA-Z0-9;:&=+$,]|} .  qq{$escaped)*};

이와 같이 해 요구한 정규 표현은 다음과 같이 되었습니다. 

(? :https? |shttp)://(? :(? :[-_.!~*'() a-zA-Z0-9;:&=+$,]|%[0-9A-Fa-f][
0-9A-Fa-f])*@)? (? :(? :(? :[a-zA-Z0-9]|[a-zA-Z0-9][-a-zA-Z0-9]*[a-zA-
Z0-9])\. )*(? :[a-zA-Z]|[a-zA-Z][-a-zA-Z0-9]*[a-zA-Z0-9])\.?|[0-9]+\
. [0-9]+\. [0-9]+\. [0-9]+)(? ::[0-9]*)? (? :/(? :[-_.!~*'() a-zA-Z0-9:@&=
+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%
[0-9A-Fa-f][0-9A-Fa-f])*)*(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9
A-Fa-f][0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f
][0-9A-Fa-f])*)*)*)? (? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-
Fa-f][0-9A-Fa-f])*)? (? :#(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-F
a-f][0-9A-Fa-f])*)?

이 정규 표현을 사용하면, $http 가, scheme 가 http 인 URI References 화도나 판정할 수 있습니다. 그런데 ,어느 캐릭터 라인의 안으로부터 http URL 를 추출하는 목적으로 이 정규 표현을 사용해도 잘되지 않습니다. 예를 들어, 다음과 같은 스크립트를 실행하면(자) 잘 되지 않는 것을 압니다. 

# $str 로부터 http URI References 를 추출한다

$str = "이 페이지의 URI 는 http://www.din.or.jp/~ohzaki/perl.htm 입니다 ";

$pattern = $URI_reference;

while ($str =~ /($pattern) /g) {
  print $1, "\n";
}

실행 결과(실패예)
http://www.din.or.j

왜 이러한 결과가 되어 버렸는지요. 그것은 Perl 의 패턴 매치 엔진이비결정성 유한 자동 장치 NFAs(Nondeterministic Finite Automata) 이기 때문입니다. 다음과 같은 스크립트를 생각해 보세요. 

print "숫자 1 문자 or 숫자로 시작되어 숫자나 소문자가 계속되는 것 \n";
$str = '123abc';
@patterns = ('(? :\d|\d[0-9a-z]+)', '(? :\d[0-9a-z]*)');
foreach $pattern (@patterns) {
  print "  캐릭터 라인 $str  패턴 $pattern  ";
  print '결과 ' .  join('/', $str =~ /$pattern/g) .  "\n";
}
print "\n숫자 1 문자 or 최초가 숫자나 소문자로, 다음이 소문자의 것 \n";
$str = '1a';
@patterns = ('(? :\d|[\da-z][a-z])', '(? :[\da-z][a-z]|\d)');
foreach $pattern (@patterns) {
  print "  캐릭터 라인 $str  패턴 $pattern  ";
  print '결과 ' .  join('/', $str =~ /$pattern/g) .  "\n";
}

실행 결과
숫자 1 문자 or 최초가 숫자로, 그 후 숫자나 소문자가 계속되는 것
  캐릭터 라인 123abc  패턴 (? :\d|\d[0-9a-z]+) 결과 1/2/3
  캐릭터 라인 123abc  패턴 (? :\d[0-9a-z]*) 결과 123abc

숫자 1 문자 or 최초가 숫자나 소문자로, 다음이 소문자의 것
  캐릭터 라인 1a  패턴 (? :\d|[\da-z][a-z]) 결과 1
  캐릭터 라인 1a  패턴 (? :[\da-z][a-z]|\d) 결과 1a

2개(살)의 예의 쳐, 어느쪽이나 최초의 정규 표현에서는 캐릭터 라인의 일부 밖에 성냥 하고 있지 않는 것을 안다고 생각합니다. 이와 같이 Perl 의 패턴 매치 엔진은 잘 성냥 시켜 가면 좀 더 긴 캐릭터 라인에 성냥 시킬 수가 있는 경우에서도, 최초로 발견된 방법으로 패턴 매치를 진행시켜 버립니다. 그러면 왜 이제(벌써) 한편의 정규 표현에서는 잘 캐릭터 라인 전체에 성냥 시킬 수가 있었는지요.

1개째의 예에서는, (? :regex1|regex1regex2+) 그렇다고 하는 선택을 regex1regex2* 라고 하는 형태에 변형해, 선택이 나타나지 않게 하고 있습니다. 이와 같이 하는 것으로, 보다 길게 성냥 시킬 수가 있어 또, 대부분의 경우에백 트럭을 줄일 수가 있으므로 효율적이 됩니다. 이것과 같은 것 행해, 이하와 같이 일부 개량합니다. 

$toplabel = qq{$alpha(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };
$domainlabel = qq{$alphanum(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };

2개째의 예에서는, (? :regex1|regex2) 그렇다고 하는 선택으로,regex1 가 regex2 의 일부와 성냥 해 버리는 경우에, 보다 길게 성냥 할 수 있을 가능성이다. regex2 (을)를 시험하는 일 없이 regex1 가 선택되어 버렸다 위해(때문에) 캐릭터 라인의 일부에 성냥 해 버렸습니다. 선택을 반대로 한, (? :regex2|regex1) 의 형태에 수정하는 것으로, 이러한 사태를 피할 수가 있습니다. 실제로 그 가능성이 있는 선택을 가지는 부분이라고 하면(자), host 의 정규 표현의 hostname 와 IPv4address 의 선택의 부분이 됩니다. 왜냐하면, IPv4address 의 정규 표현은 hostname 의 일부와 성냥 해 버릴 가능성이 있기 때문입니다. 예를 들면, 127.0. 0.1.www.din.or.jp 라고 하는 host 가 있었을 경우, 먼저 IPv4address 를 성냥 시켜 버리면(자) 127.0. 0.1 의 부분에 성냥 해 버립니다. 다행히, 최초부터 host 의 정규 표현은 먼저 hostname (을)를 성냥 시키게 되어 있기 때문에, 특히 수정할 필요는 없게 됩니다.

마지막으로,pseudohttp://foo/bar.htm (와)과 같이 HTTP 가 아닌 scheme 의 도중부터 성냥 해 버리는 것이 없게, 이하와 같이 개량합니다. 

$http_URL_regex = q{\b} .  $URI_reference;

이상의 개량을 모두 정리한 최종적인 스크립트는 이하와 같이 되었습니다. 

# http URL 의 정규 표현 $http_URL_regex

$digit = q{[0-9]};
$alpha = q{[a-zA-Z]};
$alphanum = q{[a-zA-Z0-9]};
$hex = q{[0-9A-Fa-f]};
$escaped = qq{%$hex$hex};
$uric = q{(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]} .  qq{|$escaped)};
$fragment = qq{$uric*};
$query = qq{$uric*};
$pchar = q{(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]} .  qq{|$escaped)};
$param = qq{$pchar*};
$segment = qq{$pchar*(? :;$param)*};
$path_segments = qq{$segment(? :/$segment)*};
$abs_path = qq{/$path_segments};
$port = qq{$digit*};
$IPv4address = qq{$digit+\\. $digit+\\. $digit+\\. $digit+};
$toplabel = qq{$alpha(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };
$domainlabel = qq{$alphanum(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };
$hostname = qq{(? :$domainlabel\\. ) *$toplabel\\.?};
$host = qq{(? :$hostname|$IPv4address)};
$hostport = qq{$host(? ::$port)? };
$userinfo = q{(? :[-_.!~*'() a-zA-Z0-9;:&=+$,]|} .  qq{$escaped)*};
$server = qq{(? :$userinfo\@)? $hostport};
$authority = qq{$server};
$scheme = q{(? :https? |shttp)};
$net_path = qq{//$authority(? :$abs_path)? };
$hier_part = qq{$net_path(? :\\? $query)? };
$absoluteURI = qq{$scheme:$hier_part};
$URI_reference = qq{$absoluteURI(? :#$fragment)? };
$http_URL_regex = q{\b} .  $URI_reference;

이 스크립트로부터 요구한 http URL 의 정규 표현은 다음과 같이 되었습니다. 

\b(? :https? |shttp)://(? :(? :[-_.!~*'() a-zA-Z0-9;:&=+$,]|%[0-9A-Fa-f
][0-9A-Fa-f])*@)? (? :(? :[a-zA-Z0-9](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \. )
*[a-zA-Z](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \.?|[0-9]+\. [0-9]+\. [0-9]+\.
[0-9]+)(? ::[0-9]*)? (? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f]
[0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-
Fa-f])*)*(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f
])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)*)
*)? (? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])
*)? (? :#(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*
)?

이 정규 표현을 사용하면,http URL 의 추출이 잘되도록(듯이) 됩니다. 이하가 이것을 직접 대입해 사용하는 스크립트가 됩니다. 

$http_URL_regex =
q{\b(? :https? |shttp)://(? :(? :[-_.!~*'() a-zA-Z0-9;:&=+$,]|%[0-9A-Fa-f} .
q{][0-9A-Fa-f])*@)? (? :(? :[a-zA-Z0-9](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \. )} .
q{*[a-zA-Z](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \.?|[0-9]+\. [0-9]+\. [0-9]+\. } .
q{[0-9]+)(? ::[0-9]*)? (? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f]} .
q{[0-9A-Fa-f])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-} .
q{Fa-f])*)*(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f} .
q{])*(? :;(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)*)} .
q{*)? (? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])} .
q{*)? (? :#(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*} .
q{)? };

그런데, 여기까지 길게 써 왔습니다만, 정확하게 정규 표현을 쓰는 것을 포기해, 좀 더 간단하고 좋아라고 하는 사람을 위한 http URL 의 정규 표현이 이하가 됩니다. 

s? https? ://[-_.!~*'() a-zA-Z0-9;/? :@&=+$,%#]+

이 정규 표현을 일단 변수에 대입해 사용하는 경우는 문제 없습니다만, 직접 정규 표현으로서 이용하는 경우는 다음과 같이 쓸 필요가 있습니다. 

# 문서 $text 로부터 http URL 를 추출해 @http 에 격납한다

@http = $text =~ /s? https? :\/\/[-_.!~*'() a-zA-Z0-9;\/? :\@&=+\$,%#]+/g;

/ 하지만 \/ (이)가 되어 있는 것은 문제 없다고 생각합니다. 특별히 주의하지 않으면 안 되는 것은,$ 이라고 @ 의 부분입니다. 이것들은 그대로는 각각 스칼라 변수·배열 변수로서 다루어져 변수 전개의 대상이 되어 버립니다. 거기서 이 2개(살)에 대해서도 \$ \@ (와)과 같이 할 필요가 있습니다. 만약, 이 2개(살)에 \ 를 붙이고 잊고 있었을 경우는 어떻게 되는지? 그 때는,$ 에 대해서는특수 변수 $, (으)로서 통상은 공문자열에 전개되어 버립니다. @ 에 대해서는 @& 그리고 시작되는 것 같은 배열 변수는 존재하지 않기 때문에, 배열 변수로서는 다루어지지 않고 그대로 됩니다.

탑에

ftp URL 의 정규 표현

# ftp URL 의 정규 표현 $ftp_URL_regex

$digit = q{[0-9]};
$alpha = q{[a-zA-Z]};
$alphanum = q{[a-zA-Z0-9]};
$hex = q{[0-9A-Fa-f]};
$escaped = qq{%$hex$hex};
$uric = q{(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]} .  qq{|$escaped)};
$fragment = qq{$uric*};
$query = qq{$uric*};
$pchar = q{(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]} .  qq{|$escaped)};
$segment = qq{$pchar*};
$ftptype = q{[AIDaid]};
$path_segments = qq{$segment(? :/$segment)*(? :;type=$ftptype)? };
$abs_path = qq{/$path_segments};
$port = qq{$digit*};
$IPv4address = qq{$digit+\\. $digit+\\. $digit+\\. $digit+};
$toplabel = qq{$alpha(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };
$domainlabel = qq{$alphanum(? :} .  q{[-a-zA-Z0-9]*} .  qq{$alphanum)? };
$hostname = qq{(? :$domainlabel\\. ) *$toplabel\\.?};
$host = qq{(? :$hostname|$IPv4address)};
$hostport = qq{$host(? ::$port)? };
$user = q{(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|} .  qq{$escaped)*};
$password = $user;
$userinfo = qq{$user(? ::$password)? };
$server = qq{(? :$userinfo\@)? $hostport};
$authority = qq{$server};
$scheme = q{ftp};
$net_path = qq{//$authority(? :$abs_path)? };
$hier_part = qq{$net_path(? :\\? $query)? };
$absoluteURI = qq{$scheme:$hier_part};
$URI_reference = qq{$absoluteURI(? :#$fragment)? };
$ftp_URL_regex = q{\b} .  $URI_reference;

ftp URL 에 대해서는 RFC 1738 에 쓰여져 있습니다. 다만, 현재는 RFC 1738 은 RFC 2396 ( 일본어 번역 )에 의해 갱신되고 있습니다. 갱신궢고 있다고 해도 RFC 2396 은 URI 의 일반형을 정의뙰 것이 XX 있으므로, ftp URL 의 정의에 대궠 직접 쓰여궋 있는 부분은 없습니다. 거기서,ftp URL의 정규 표현으로서RFC 2396 의 URI 의 일반형의 정의를 기초로, 「http URL 의 정규 표현」으로 스킴이 http 인 URI References 로서 요구한 방법과 같은 방법으로, 스킴이 ftp 인 URI References 를 생각XX니다.

RFC 1738 에 쓰여XX 있는 ftp URL 의 정의를 고려해 고쳐 궫 부분은 이하와 같이 궔니다. 

$segment = qq{$pchar*};
$ftptype = q{[AIDaid]};
$path_segments = qq{$segment(? :/$segment)*(? :;type=$ftptype)? };
$user = q{(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|} .  qq{$escaped)*};
$password = $user;
$userinfo = qq{$user(? ::$password)? };
$server = qq{(? :$userinfo\@)? $hostport};
$authority = qq{$server};
$scheme = q{ftp};
$net_path = qq{//$authority(? :$abs_path)? };
$hier_part = qq{$net_path(? :\\? $query)? };
$absoluteURI = qq{$scheme:$hier_part};
$URI_reference = qq{$absoluteURI(? :#$fragment)? };
$ftp_URL_regex = q{\b} .  $URI_reference;

ftp URL 는 RFC 1738 으로 ftpurl = "ftp://" login [ "/" fpath [ ";type=" ftptype ]] (이)라고 정의되고 있습니다. login 보다 뒤의 부분은 path_segments 에 해당되는 것입니다만, ; (은)는 fpath 와 그 뒤의 부분을 단락궖 목적으로 사용됩니다. 거기서, segment 로부터 ; (와)과 param 를 삭제해, path_segments 를 ftp URL 의 정의에 적합하도록(듯이) 수정XX습니다. (와)과 같이 login 부분은 login = [ user [ ":" password ] "@" ] hostport 라고 정의되고 있어 userinfo 는 user [ ":" password ] 가 되고 있습니다. 즉,: 하지만 user 와 password 를 단락짓는 목적으로 사용XX기 (위해)때문에, userinfo 로부터 : (을)를 없앤 것을 새롭게 user, password 로서 정의해 userinfo 를 수정했습니다. scheme 는 당연히 ftp 됗며, 스킴이 ftp 인 URI References (으)로서는 있을 수 궕궬 선택 부분을 삭제궶궵 등 해 URI_reference 나 absoluteURI 등을 수정했습니다.

이 스크립트로부터 요구한 ftp URL 의 정규 표현은 다음과 같이 되었습니다. 

\bftp://(? :(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*
(? ::(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)? @)? (?
:(? :[a-zA-Z0-9](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \. )*[a-zA-Z](? :[-a-zA-
Z0-9]*[a-zA-Z0-9])? \.?|[0-9]+\. [0-9]+\. [0-9]+\. [0-9]+)(? ::[0-9]*)?
(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*(? :/(?
:[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)*(? :;type=[
AIDaid])? )? (? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9
A-Fa-f])*)? (? :#(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A
-Fa-f])*)?

이하가 이것을 직접 대입벞 사용하는 스크립트가 솤니다. 

$ftp_URL_regex =
q{\bftp://(? :(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*} .
q{(? ::(? :[-_.!~*'() a-zA-Z0-9;&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)? @)? (? } .
q{:(? :[a-zA-Z0-9](? :[-a-zA-Z0-9]*[a-zA-Z0-9])? \. )*[a-zA-Z](? :[-a-zA-} .
q{Z0-9]*[a-zA-Z0-9])? \.?|[0-9]+\. [0-9]+\. [0-9]+\. [0-9]+)(? ::[0-9]*)? } .
q{(? :/(? :[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*(? :/(? } .
q{:[-_.!~*'() a-zA-Z0-9:@&=+$,]|%[0-9A-Fa-f][0-9A-Fa-f])*)*(? :;type=[} .
q{AIDaid])? )? (? :\? (? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9} .
q{A-Fa-f])*)? (? :#(? :[-_.!~*'() a-zA-Z0-9;/? :@&=+$,]|%[0-9A-Fa-f][0-9A} .
q{-Fa-f])*)? };
탑에

메일 주소의 정규 표현

RFC 821 으로 RFC 822 는 RFC 2821 (일본어 번역 1~3장 4,5장 6장~ )(와)과 RFC 2822 ( 일본어 번역 )에 의해 obsolete 가 되었습니다.

메일 주소에 대해서는 RFC 821 ( 일본어 번역 )과 RFC 822 ( 일본어 번역 )에 쓰여빁 있습니다. perl5. 6.0이전의 perl 그럼메일 주소의 정규 표현을 정확하게 기술하는 것은 할 수 없었습니다. Jeffrey E. F. Friedl씨 원저에 의궘다 「상세 해설 정규 표현 ( Mastering Regular Expressions )」에는 메일 주소는 네스트 했다 코멘트를 가귣 수가 궴궔므로 정규 표현으로 나타궲; 불가능묆다라고 써 있습니다. 거기서,Jeffrey E. F. Friedl씨는 네스트 Pe다 코멘트를 포기해, 다음과 같은 6,598바이트에 달룊다 정규 표현을 만들고 XX. http://public.yahoo.com/~jfriedl/regex/email-opt.pl 에 원시 코드가 있습니다. 

[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x
80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\
\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :(? :[^(\040) <>@, ;:". \\\[\]\000
-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]) |"[^\
\\x80-\xff\n\015"]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015"]*) *")[\04
0\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\
xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80
-\xff\n\015()]*)*\)[\040\t]*)*(? :\. [\040\t]*(? :\([^\\\x80-\xff\n\0
15()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]
*)*(? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:"
. \\\[\]\000-\037\x80-\xff]) |"[^\\\x80-\xff\n\015"]*(? :\\[^\x80-\xf
f][^\\\x80-\xff\n\015"]*) *")[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(
? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\
\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*)*@[
\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x8
0-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\
x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:". \\\[\]\000-\03
7\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff])|\[(? :[^\
\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(? :\([^\\\x80-\x
ff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\
x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\
040\t]*)*(? :\. [\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-
\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\01
5()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:"
. \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-
\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(
? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\
015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\
n\015()]*)*\)[\040\t]*)*)*|(? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-
\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]) |"[^\\\x80-\xff
\n\015"]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015"]*) *")[^() <>@, ;:". \\
\[\]\x80-\xff\000-\010\012-\037]*(? :(? :\([^\\\x80-\xff\n\015()]*(?
:(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\
x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\) |"[^\\\x80-\xff\
n\015"]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015"]*) *")[^() <>@, ;:". \\\
[\]\x80-\xff\000-\010\012-\037]*) *<[\040\t]*(? :\([^\\\x80-\xff\n\0
15()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]
*)*(? :@[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\
([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*
\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:". \\\[\]
\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff])|
\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(? :\([^\
\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*
(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()
]*)*\)[\040\t]*)*(? :\. [\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\
\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\
xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040
) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\
037\x80-\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\
040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80
-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*(? :,[\040\t]*(? :\([^\\\x80-\xff\
n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80
-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040
\t]*)*@[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\
([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*
\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:". \\\[\]
\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff])|
\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\040\t]*(? :\([^\
\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*
(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()
]*)*\)[\040\t]*)*(? :\. [\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\
\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\
xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040
) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\
037\x80-\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])[\
040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80
-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*)*:[\040\t]*(? :\([^\\\x80-\xff\n
\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-
\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\
t]*)*)? (? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@
, ;:". \\\[\]\000-\037\x80-\xff]) |"[^\\\x80-\xff\n\015"]*(? :\\[^\x80
-\xff][^\\\x80-\xff\n\015"]*) *")[\040\t]*(? :\([^\\\x80-\xff\n\015(
)]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff]
[^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*
(? :\. [\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([
^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\)
)[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:". \\\[\]\0
00-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]) |"[
^\\\x80-\xff\n\015"]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015"]*) *")[\
040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80
-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x
80-\xff\n\015()]*)*\)[\040\t]*)*)*@[\040\t]*(? :\([^\\\x80-\xff\n\0
15()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\x
ff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]
*)*(? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:"
. \\\[\]\000-\037\x80-\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80
-\xff])*\])[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xf
f]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()
]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*(? :\. [\040\t]*(? :\([^
\\\x80-\xff\n\015()]*(? :(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]
*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015(
)]*)*\)[\040\t]*)*(? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?!
[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff])|\[(? :[^\\\x80-\xff\n\01
5\[\]]|\\[^\x80-\xff])*\])[\040\t]*(? :\([^\\\x80-\xff\n\015()]*(? :
(? :\\[^\x80-\xff]|\([^\\\x80-\xff\n\015()]*(? :\\[^\x80-\xff][^\\\x
80-\xff\n\015()]*)*\))[^\\\x80-\xff\n\015()]*)*\)[\040\t]*)*) *>)

email-opt.pl 를 바탕으로 장황 부분을 깎아 떨어뜨렸던 것이 이하의 스크립트입니다. 장황 부분을 깎아 떨어뜨려도 상당한 양입니다. 

# $email 가 올바른 메일 주소나 판정한다

$esc         = '\\\\';               $Period      = '\. ';
$space       = '\040';               $tab         = '\t';
$OpenBR      = '\[';                 $CloseBR     = '\]';
$OpenParen   = '\(';                 $CloseParen  = '\)';
$NonASCII    = '\x80-\xff';          $ctrl        = '\000-\037';
$CRlist      = '\n\015';
$qtext       = qq/[^$esc$NonASCII$CRlist\"]/;
$dtext       = qq/[^$esc$NonASCII$CRlist$OpenBR$CloseBR]/;
$quoted_pair = qq<${esc}[^$NonASCII]>;
$ctext       = qq<[^$esc$NonASCII$CRlist()]>;
$Cnested     = qq<$OpenParen$ctext*(? :$quoted_pair$ctext*) *$CloseParen>;
$comment     =
    qq<$OpenParen$ctext*(? :(? :$quoted_pair|$Cnested) $ctext*) *$CloseParen>;
$X           = qq<[$space$tab]*(? :${comment}[$space$tab]*) *>;
$atom_char   = qq/[^($space) <>\@, ;:\". $esc$OpenBR$CloseBR$ctrl$NonASCII]/;
$atom        = qq<$atom_char+(?!$atom_char) >;
$quoted_str  = qq<\"$qtext*(? :$quoted_pair$qtext*) *\">;
$word        = qq<(? :$atom|$quoted_str) >;
$domain_ref  = $atom;
$domain_lit  = qq<$OpenBR(? :$dtext|$quoted_pair) *$CloseBR>;
$sub_domain  = qq<(? :$domain_ref|$domain_lit) $X>;
$domain      = qq<$sub_domain(? :$Period$X$sub_domain) *>;
$route       = qq<\@$X$domain(? :, $X\@$X$domain) *:$X>;
$local_part  = qq<$word$X(? :$Period$X$word$X) *>;
$addr_spec   = qq<$local_part\@$X$domain>;
$route_addr  = qq[<$X(? :$route)? $addr_spec>];
$phrase_ctrl = '\000-\010\012-\037';
$phrase_char =
   qq/[^() <>\@, ;:\". $esc$OpenBR$CloseBR$NonASCII$phrase_ctrl]/;
$phrase      =
    qq<$word$phrase_char*(? :(? :$comment|$quoted_str) $phrase_char*) *>;
$mailbox     = qq<$X(? :$addr_spec|$phrase$route_addr) >;

print "ok\n" if $email =~ /^$mailbox$/o;

perl5. 6.0이전의 perl 에서는 표현할 수 없었던 네스트 한 코멘트 부분은, 이 스크립트에서는 $Cnested 와 $comment 의 대입문으로 정의되고 있어 1회만 네스트를 허락한 정규 표현이 되고 있습니다. 이 2개의 대입문을 이하와 같이 변경하는 것으로메일 주소의 정규 표현을 정확하게 기술할 수가 있는 것같게 됩니다. 

use re 'eval';
$comment     =
  qr<$OpenParen$ctext*(? :(? :$quoted_pair|(??{$comment})) $ctext*) *$CloseParen>;

다만, 여기서 사용하고 있는 정규 표현 (??{ code }) 는 실험적인 것이므로 향후 변경되거나 삭제될지도 모르므로 주의가 필요합니다. 또, use re 'eval'; 하고 있으므로, 이 점에도 충분히 주의할 필요가 있습니다. 무엇을 어떻게 주의할 필요가 있는지는 메뉴얼을 읽어 주세요. 메일 주소의 패턴 매치가 끝난 시점에서 no re 'eval'; 해 두는 것을 추천합니다.

메일 주소가 올바른지 어떤지를 조사하려면 모듈 Email::Valid 또는 모듈 Mail::CheckUser 를 사용하는 것이 좋다고 생각합니다. 이 모듈을 사용하면, 메일 주소가 RFC 822 에 쓰여져 있는 문법적으로 올바른지 어떤지 만이 아니고, 그 메일 주소가 실제로 유효한가 어떤가도 어느 정도 조사할 수가 있습니다. 다만, 그 경우는 물론 인터넷에 접속되고 있을 필요가 있습니다. 자세한 사용법은 메뉴얼을 읽어 주세요.

그런데, 여기까지로 써 온 메일 주소라고 하는 것은 From행등으로 지정할 수 있는 것의 일로 하고,RFC 822 냄새나 mailbox 로서 정의되고 있습니다. 이 mailbox 를 있는 캐릭터 라인으로부터 메일 주소를 추출하는 목적으로 사용하는 것은 도리에 맞지 않음이라는 것입니다. 그러한 목적 때에 필요하게 되는 것은 mailbox 는 아니고, addr-spec 의 (분)편이지요. mailbox 나 addr-spec 가 어떠한 것일까하고 말하면, 예를 들어, OHZAKI Hiroki <ohzaki@din.or.jp> 라고 하는 것은 mailbox 입니다만 addr-spec 가 아닙니다. ohzaki@din.or.jp 라고 하는 것은 addr-spec 만일 수 있는으로부터 완성되는 mailbox 가 됩니다.

거기서 방금전의 스크립트를 수정해, 어느 캐릭터 라인으로부터 메일 주소를 추출한다 목적으로 사용하기 위한 addr-spec 의 정규 표현을 이하와 같이 만들었습니다. 

# 메일 주소의 정규 표현 $mail_regex

$esc         = '\\\\';               $Period      = '\. ';
$space       = '\040';
$OpenBR      = '\[';                 $CloseBR     = '\]';
$NonASCII    = '\x80-\xff';          $ctrl        = '\000-\037';
$CRlist      = '\n\015';
$qtext       = qq/[^$esc$NonASCII$CRlist\"]/;
$dtext       = qq/[^$esc$NonASCII$CRlist$OpenBR$CloseBR]/;
$quoted_pair = qq<${esc}[^$NonASCII]>;
$atom_char   = qq/[^($space) <>\@, ;:\". $esc$OpenBR$CloseBR$ctrl$NonASCII]/;
$atom        = qq<$atom_char+(?!$atom_char) >;
$quoted_str  = qq<\"$qtext*(? :$quoted_pair$qtext*) *\">;
$word        = qq<(? :$atom|$quoted_str) >;
$domain_ref  = $atom;
$domain_lit  = qq<$OpenBR(? :$dtext|$quoted_pair) *$CloseBR>;
$sub_domain  = qq<(? :$domain_ref|$domain_lit) >;
$domain      = qq<$sub_domain(? :$Period$sub_domain) *>;
$local_part  = qq<$word(? :$Period$word) *>;
$addr_spec   = qq<$local_part\@$domain>;
$mail_regex  = $addr_spec;

이 스크립트는, 방금전의 스크립트로부터, 도중에 코멘트와 스페이스나 탭이 없게 변경해, 장황 부분을 삭제한 것입니다. 이 스크립트로부터 요구한 addr-spec 는 이하와 같이 되었습니다. 

(? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\
\[\]\000-\037\x80-\xff]) |"[^\\\x80-\xff\n\015"]*(? :\\[^\x80-\xff][
^\\\x80-\xff\n\015"]*) *")(? :\. (? :[^(\040) <>@, ;:". \\\[\]\000-\037\x
80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]) |"[^\\\x80-\
xff\n\015"]*(? :\\[^\x80-\xff][^\\\x80-\xff\n\015"]*) *"))*@(? :[^(\0
40) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\[\]\000
-\037\x80-\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x80-\xff])*\])
(? :\. (? :[^(\040) <>@, ;:". \\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@,;
:". \\\[\]\000-\037\x80-\xff])|\[(? :[^\\\x80-\xff\n\015\[\]]|\\[^\x
80-\xff])*\]))*

이하가 이것을 직접 대입해 사용하는 스크립트가 됩니다. 

$mail_regex =
q{(? :[^(\040) <>@, ;:". \\\\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\\} .
q{\[\]\000-\037\x80-\xff]) |"[^\\\\\x80-\xff\n\015"]*(? :\\\\[^\x80-\xff][} .
q{^\\\\\x80-\xff\n\015"]*) *")(? :\. (? :[^(\040) <>@, ;:". \\\\\[\]\000-\037\x} .
q{80-\xff]+(?![^(\040) <>@, ;:". \\\\\[\]\000-\037\x80-\xff]) |"[^\\\\\x80-} .
q{\xff\n\015"]*(? :\\\\[^\x80-\xff][^\\\\\x80-\xff\n\015"]*) *"))*@(? :[^(} .
q{\040) <>@, ;:". \\\\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@, ;:". \\\\\[\]\0} .
q{00-\037\x80-\xff])|\[(? :[^\\\\\x80-\xff\n\015\[\]]|\\\\[^\x80-\xff])*} .
q{\])(? :\. (? :[^(\040) <>@, ;:". \\\\\[\]\000-\037\x80-\xff]+(?![^(\040) <>@,} .
q{;:". \\\\\[\]\000-\037\x80-\xff])|\[(? :[^\\\\\x80-\xff\n\015\[\]]|\\\\[} .
q{^\x80-\xff])*\]))*};

이 메일 주소의 정규 표현 $mail_regex (을)를 사용해,$email 하지만 올바른 메일 주소나 판정하려면 다음과 같이 씁니다. 

# $email 가 올바른 메일 주소(addr_spec)나 판정한다

if ($email ! ~ /^$mail_regex$/o) {
  print "부정한 메일 주소입니다 \n";
}

여담입니다만, DoCoMo(i-mode)와 J-Phone(J-Sky)에서는 메일 주소로서 irregular. @docomo.ne.jp (와)과 같이 @ 의 직전이 . (피리어드) 인 것도 사용할 수 있습니다. 그러나, 이것은 RFC 822 에 적합하지 않는 부정한 메일 주소입니다. @ 의 전의 local-part 의 부분에서는 . (피리어드) (은)는 반드시 다른 문자에 끼워지지 않으면 안 됩니다. 따라서, . (피리어드) (이)가 선두에 있는 경우와@ 의 직전에 있는 경우는 부정한 메일 주소라는 것이 됩니다. DoCoMo(i-mode)끼리나 J-Phone(J-Sky)끼리에서의 메일교환이면 문제 없습니다만, 그렇지 않으면 사용해야 하는 것이 아닙니다.

탑에

일본어를 취급한다

perl 스크립트는 EUC-JP 로 쓴다

perl 로 일본어를 취급하려면 여러가지 주의하지 않으면 안 되는 것이 있습니다. 왜냐하면, 일본어의 문자 코드에는 perl 가 특별한 의미로서 해석해 버린다 문자가 포함되어 있기 때문입니다. 예를 들어, perl 스크립트를 JIS 그리고 다음과 같이 썼다고 합니다. 

$str = "이 TEST로 충분히 ";
$str =~ s/이 TEST로 충분히/이 테스트로 충분히/;  # JIS 에서도 SJIS 에서도 타목
print $str, "\n";
이것을 정상적으로 실행할 수 없습니다. unmatched () in regexp 가 되어 버릴 것입니다. 왜냐하면, escape sequence의 ESC ( B 하지만 포함되어 있기 위해서(때문에),( 를 그룹화를 위한 열어 괄호로서 해석해 버리기 때문입니다. 물론, 이 에러는 닫고 괄호의 ) 하지만 없기 위해(때문에) 괄호가 대응하고 있지 않다고 하는 에러입니다. 그러면 이 스크립트를 SJIS 로 썼을 경우는 어떻습니까. 이번은 unmatched [] in regexp (이)가 되어 버릴 것입니다. 왜냐하면 SJIS 의 「충」의 문자 코드는 0x8F 0x5B 이며,0x5B 라고 하는 것은 ASCII 의 [ 의 문자 코드이기 때문입니다.

거기서 SJIS 의 경우에는 정규 표현으로 에러가 되지 않게, 다음과 같이 패턴의 부분을 \Q 와 \E 로 사이에 두어 이스케이프 한다고 하는 회피 방법이 있습니다. 

$str = "이 TEST로 충분히 ";
$str =~ s/\Q 이 TEST로 충분히\E/이 테스트로 충분히/;  # 이것으로 SJIS 에서도 괜찮아?
print $str, "\n";
그런데 , 이것을 실제로 실행해 보면글자 깨짐해 끝냅니다. 왜냐하면, SJIS 의 「10」의 문자 코드는 0x8F 0x5C (이어)여,0x5C 라고 하는 것은 ASCII 의 \ 의 문자 코드이기 (위해)때문에, 「분 」의 1바이트째와 합해 특별한 의미로서 해석하려고 하기 (위해)때문에입니다. \ (와)과 「분 」의 1바이트째를 맞춘 escape sequence라는 것은 없기 때문에, 결과적으로 「10」의 2바이트째의 \ (은)는 무시되게 됩니다.

이와 같이 SJIS 에는 2바이트째가 \ 인 문자가 있기 위해서(때문에) 글자가 깨져 버립니다. 같이2바이트째가 @ 인 문자에서는 배열이라고 해석되어 버리는 일이 있습니다. 2바이트째가 \ 인 문자에 대해서는, 그 뒤로 \ (을)를 쓰면 회피할 수가 있습니다만,2바이트째가 @ 인 문자에 대해서는 한층 더 다른 회피 수단을 취하지 않을 수 없게 됩니다. 덧붙여서, SJIS 로 2바이트째가 \ 인 문자는 「―소Ы준리기규구잠10신증단첩능표폭예녹면객구미나회삽준분병채 좌석애촉체심만번」 입니다. 또,2바이트째가 @ 인 문자는 전각 스페이스와 「А원괴기굴후찰종식섬고저여비법유련첨지간료알엽벽양호적주수담유건치노아」 입니다. 이러한 문자 이외에도 SJIS 에서는 문제가 되는 문자가 아직도 있습니다.

덧붙여 조금 전 SJIS 의 경우에 \Q 와 \E 로 사이에 두어 이스케이프 한다고 하는 회피 방법에 대해 접했습니다만, 실은이 방법은 완전하지는 않습니다. 예를 들어, 다음의 스크립트를 봐 주세요. 

if ($str =~ /\Q$keyword\E/) {
  print "성냥 한 \n";
}

이 스크립트와 같이, 어느키워드 $keyword (을)를 \Q 와 \E 그리고 사이에 두면 에러가 되지 않고 잘 패턴 매치할 수 있다고 하는 이야기가 있습니다. 분명히 에러로는 되지 않습니다만, 예를 들어 SJIS 로 $str = '테스트'; 때에 $keyword = 'X'; 로 패턴 매치를 행하면(자) 성냥 해 버립니다. 이것은 SJIS 의 「스」의 문자 코드가 0x83 0x58 이며, 0x58 라고 하는 것이 ASCII 의 X 의 문자 코드로 있기 때문에입니다. 또, $str = 'ca＜b'; 때에 $keyword = '모=모'; 때도 성냥 해 버립니다. 이것은 「ca＜b」라고 하는 캐릭터 라인의 문자 코드 0x82 0x83 0x82 0x81 0x81 0x83 0x82 0x82 에 대해서, 1바이트두개 어긋난 위치에서 「모=모」라고 하는 캐릭터 라인의 문자 코드 0x83 0x82 0x81 0x81 0x83 0x82 하지만 성냥 해 버리기 때문입니다.

perl 로 일본어를 취급하기 위한 수단의 하나가 jperl 를 사용한다고 하는 것입니다. jperl 는 오리지날의 perl 에 패치를 대어, 일본어를 취급할 수 있도록(듯이) 한 것입니다. Windows용의 jperl 는 이하의 장소(스즈키 유키오씨제공)로부터 입수할 수가 있습니다.

http://www.shonanblue.ne.jp/~kipp/perl/jperl/index.html

그러면 최초의 스크립트를 EUC-JP 그리고 썼을 경우는 어떨까요. EUC-JP 그리고 썼을 경우에는 정상적으로 실행할 수 있을 것입니다. 왜냐하면,EUC-JP 에는 JIS 나 SJIS 와 같이 perl 가 특별한 의미로서 해석해 버리는 것 같은 문자가 포함되지 않기 때문입니다. perl 로 일본어를 취급하려면 perl 스크립트를 EUC-JP 그리고 쓰는것이 제일 간단한 방법입니다. 이하에서는,EUC-JP 그리고 스크립트를 쓰는 것을 전제로 하고 있습니다.

실은 EUC-JP 의 패턴 매치에 대해도 SJIS 와 같이 잘못해 성냥 해 버리는 경우가 있습니다. 이것에 대해서는 「올바르고 패턴 매치시킨다 」(을)를 참조해 주세요.

탑에

한자 코드를 EUC-JP 로 변환해 처리한다

perl 스크립트는 EUC-JP 로 썼다고 해도, 입력한 일본어의 한자 코드가 SJIS 나 JIS 에서는 정상적인 동작을 기대할 수 없습니다. 거기서 어떠한 처리를 행할 때는 한 번 EUC-JP 로 변환하고 나서 행합니다. perl 스크립트를 EUC-JP 로 써, 한자 코드가 EUC-JP 인 일본어를 처리한다라고 하는 것이, perl 로 일본어를 취급할 때 제일 문제가 일어나기 어려운 방법입니다.

입력한 일본어의 한자 코드가 EUC-JP 가 아닌 경우, 또는, 한자 코드를 모르는 경우에는, 한자 코드를 jcode.pl (가대 카즈마사씨작)(을)를 사용해 EUC-JP 로 변환해 줍니다. $str 를 EUC-JP (으)로 변환하려면 다음과 같이 씁니다. 

# $str 를 EUC-JP 로 변환한다

require 'jcode.pl';

jcode::convert(\$str, 'euc');

'euc' 의 부분을 'sjis' 나 'jis' 로 하면, SJIS 나 JIS 로 변환할 수 있습니다. 만약, 입력한 일본어의 한자 코드가 $code 이다고 알고 있는 경우에는, 다음과 같이 명시적으로 지정하는 것으로 내부에서 자동 판별하지 않게 할 수가 있습니다. 

# 한자 코드가 $code 인 $str 를 EUC-JP 로 변환한다

require 'jcode.pl';

jcode::convert(\$str, 'euc', $code);

「한자 코드를 조사한다」로 자동 판별의 판정 정밀도를 올려 요구한 $code 를 사용하고 싶을 때에도 이 서식을 사용합니다.

여담입니다만, 다음과 같이 my 선언된 변수에 대해서, 형태 그로브를 사용해 변환하려고 하는 것은실수입니다. 

# my 선언된 변수를 변환할 때의 사이 다른 예

require 'jcode.pl';

my $str = 'my 선언된 변수의 형태 그로브는 없는';

jcode::convert(*str, 'euc');
my 선언된 변수의 형태 그로브는 없기 때문에, 이것으로는 변환할 수 없습니다. my 선언된 변수의 하드 레퍼런스는 요구할 수가 있으므로, 최초의 스크립트와 같이 항상 \$str 와 같이 쓰는 것이 제일 문제의 일어나기 어렵다 쓰는 법입니다.

jcode.pl (은)는 이하의 장소에 최신 버젼이 놓여져 있습니다.

http://www.srekcah.org/jcode/
현재의 최신 버젼은 jcode.pl-2. 13 입니다. 이것을 취해 와 jcode.pl 로 이름을 변경해 사용합니다. jcode.pl 의 사용법은 jcode.pl 안에 쓰여져 있습니다. 잘 모르면, 코즈카 아츠시씨에 의한다 「jcode.pl 의 사적인 해설서」를 읽으면 좋을지도 모릅니다.

Jcode.pm - jcode.pl 의 후계 (코가이탄씨작) (이)라는 것도 공개되고 있습니다. Jcode.pm 는 UNICODE 에 대응하고 있습니다만, 사용하려면 jcode.pl 와 같이 카피하는 것 만으로는 안되어, 분명하게 인스톨 할 필요가 있습니다. 덧붙여Windows용의 perl 이다 ActivePerl 5.6용으로, 컴파일 끝난 패키지가 이하의 장소(스즈키 유키오씨 제공)으로 배포되고 있습니다.

http://www.shonanblue.ne.jp/~kipp/perl/packages/5. 6/index.html

버젼 2.10이전의 jcode.pl (은)는 thread가 유효하게 되어 있는 perl에서는사용하는 것이 할 수 없습니다. thread가 유효하게 되어 있는 perl 에서는특수 변수 $_ (이)나 @_ (은)는레키시칼 변수가 됩니다. 레키시칼 변수란 my 선언된 변수입니다. 이 레키시칼 변수라고 하는 것은 local 선언하는 것이 할 수 없습니다만,버젼 2.10이전의 jcode.pl 에서는 함수의 인수를 local 선언한형태 그로브 *_ 에 대입하려고 하고 있기 위해서(때문에) 정상적으로 동작하지 않습니다. 최신 버젼의 jcode.pl 및 Jcode.pm (은)는 thread가 유효하게 되어 있는 perl 에서도 정상적으로 동작합니다.

수중의 perl 의 thread가 유효하게 되어 있는지 어떤지를 조사하려면 perl -V 라고 입력해 실행합니다. 이 때 usethreads=undef 가 되고 있으면 무효가 되어 있으므로 jcode.pl 를 안심하고 사용할 수 있습니다. perl5. 005보다 전의 perl 도 thread 기능이 없기 때문에 문제 없습니다. 만약, thread가 유효하게 되어 있었을 경우에는버젼 2.10이전의 jcode.pl 를 사용할 수 없는 것은 물론의 일,특수 변수 $_ 나 @_ 하지만 레키시칼 변수가 되어 있게도 주의해 스크립트를 쓸 필요가 있습니다.

탑에

한자 코드를 조사한다

# $str 의 한자 코드를 조사한다

require 'jcode.pl';

($match, $code) = jcode::getcode(\$str);
$code = 'euc' if $code eq undef and $match > 0;
jcode.pl 의 getcode 함수를 사용합니다. $code 에는 'euc' 나 'sjis','jis' 그렇다고 하는 캐릭터 라인이 들어가 있습니다. 자세하게는 jcode.pl 안의 설명을 읽어 주세요.

여기서 주의가 필요한 것은,한자 코드를 정확하게 조사하는 것에는 한계가 있다라고 하는 것입니다. SJIS 의 한자(제2 수준)의 일부나 SJIS 의 반각 카타카나 2 문자는 EUC-JP 의 한자 1 문자와 구별이 되지 않습니다. 만약, 한자 코드가 EUC-JP 인가 SJIS 의 양쪽 모두의 가능성이 있어, 어느 쪽인지 판단할 수 없을 때에는 jcode::getcode() 는 undef (을)를 돌려줍니다. 다만, 엄밀하게는 어느 쪽인지 판단할 수 없다고는 말할 수 있어 반각 카타카나가 포함되지 않은 경우 (와)과 어느 경우 EUC-JP 이므로, 위의 스크립트에서는 최종적으로 undef 는 아니고 EUC-JP 로 하고 있습니다.

jcode::getcode() 는 SJIS 의 반각 카타카나를 고려하지 않고 판정하고 있습니다. 이 때문에, SJIS 라고 판단할 수 있는 반각 카타카나가 포함되어 있는 문자 열에서도 EUC-JP 와 잘못해 버리는 일이 있습니다. 거기서, 다음 에 쓰는 것으로 판정 정밀도를 올릴 수가 있습니다. 

# $str 의 한자 코드를 조사한다

require 'jcode.pl';

($match, $code) = jcode::getcode(\$str);
$code = 'euc' if $code eq undef and $match > 0;

$ascii = '[\x00-\x7F]';
if ($code eq 'euc') {
  if ($str ! ~ /^(? :$jcode::re_euc_c|$jcode::re_euc_kana|
                   $jcode::re_euc_0212|$ascii) *$/ox) {
    if ($str =~ /^(? :$jcode::re_sjis_c|$jcode::re_sjis_kana|$ascii) *$/o) {
      $code = 'sjis';
    }
  }
}
이것으로 SJIS 를 EUC-JP 와 잘못해 판정할 가능성을 줄일 수가 있습니다만, 그 만큼 처리에 시간이 걸려 버리는 것을 잊어서는 안됩니다. 이와 같이 해 자동 판정의 판정 정밀도를 올려 요구한 $code (은)는 한자 코드를 변환할 경우에도 이용할 수가 있습니다. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조.
탑에

전각 문자가 포함되어 있는지 판정한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 에 전각 문자(반각 카타카나를 포함하지 않는다)가 포함되어 있는지 판정한다

if ($str =~ /[\xA1-\xFE][\xA1-\xFE]/) {
  print "포함되어 있는 \n";
}
전각 문자는 JIS X 0208 으로 JIS X 0212 이므로, 반각 카타카나인 JIS X 0201 가타카나 는 포함하지 않습니다. 전각 문자가 포함되어 있는지 어떤지를 판정하려면 ,JIS X 0208 으로 JIS X 0212 의 공통 부분이며, ASCII 나 JIS X 0201 가타카나 에서는 나타나지 않는 패턴 /[\xA1-\xFE][\xA1-\xFE]/ 를 사용해 판정합니다. 
# $str 에 반각 카타카나가 포함되어 있는지 판정한다

if ($str =~ /\x8E/) {
  print "포함되어 있는 \n";
}

반각 카타카나가 포함되어 있는지 어떤지를 판정하려면 ,EUC-JP 에서는 /\x8E/ 를 조사하는 것만으로 할 수 있습니다. 

# $str 에 ASCII 이외가 포함되어 있는지 판정한다

if ($str =~ /[\x8E\xA1-\xFE]/) {
  print "포함되어 있는 \n";
}

ASCII 이외의 문자가 포함되어 있는지를 판정하려면 , /[\x8E\xA1-\xFE]/ 를 조사하는 것으로 할 수 있습니다. \x8E (이)가 있으면 JIS X 0201 가타카나 의 1바이트째에 성냥 해, [\xA1-\xFE] 가 있으면 JIS X 0208 의 1바이트째인가, JIS X 0212 의 2바이트째에 성냥 하기 때문에, ASCII 이외의 문자가 포함되어 있는 것을 알 수 있습니다.

$str 가 EUC-JP 화도일지도 모를 때는 jcode.pl (을)를 사용해 조사할 수도 있습니다. jcode.pl 를 사용해 「한자 코드를 조사한다」로 쓴 스크립트로 $str 의 한자 코드를 조사한 결과가 undef 의 경우는 ASCII 이외의 문자는 포함되지 않다고 할 수가 있습니다. 반대로 말하면,undef 가 아닌 경우는 ASCII 이외의 문자가 포함되어 있다고 할 수가 있습니다. 이 때, 다음과 같이 당황해 $match 를 사용하지 않고 , 갑자기 undef 화도인지를 조사하는 방법은잘못되어 있습니다. 

# $str 에 ASCII 이외가 포함되어 있는지 판정할 때의 사이 다른 예

require 'jcode.pl';
$code = jcode::getcode(\$str);

if ($code eq undef) {
  print "ASCII 이외는 포함되지 않은 \n";
  print "이 판단은 잘못해 \n";
}
jcode::getcode() 는 EUC-JP 나 SJIS 의 양쪽 모두의 가능성이 있어, 어느 쪽인지 판단할 수 없을 때에도 undef (을)를 돌려줍니다. 「한자 코드를 조사한다」로 써 어느 $match 를 사용해 undef 의 경우를 처리할 필요가 있습니다.
탑에

문자가 중단되고 있는지 판정한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 의 마지막 문자가 중단되고 있는지 판정한다

if ($str =~ /\x8F$/ or $str =~ tr/\x8E\xA1-\xFE// % 2) {
  print "마지막 문자가 중단되고 있는 \n";
}

EUC-JP 로 문자가 중단될 가능성이 있는 것은,JIS X 0201 가타카나(반각 카타카나)(와)과JIS X 0208(전각 문자)으로 JIS X 0212(보조 한자)입니다. JIS X 0212 는 3바이트로 표현되어 최초가 \x8F 로 시작됩니다. 최초의 조건은 $str 가 \x8F 그리고 끝나 있었을 경우, 즉,JIS X 0212 가 1바이트째에 중단되고 있었을 경우를 나타내고 있습니다. 다음의 조건이 JIS X 0201 가타카나 와 JIS X 0208 이 1바이트째에 중단되고 있었을 경우와JIS X 0212 가 2바이트째에 중단되고 있었을 경우입니다. tr/\x8E\xA1-\xFE// 는 $str 안의,JIS X 0201 가타카나 와 JIS X 0208 의 1바이트째와 2바이트째, JIS X 0212 의 2바이트째와 3바이트째의 수를 세고 있습니다. 이 수가 만약 홀수라면 문자가 중단되고 있는 것을 알 수 있습니다.

탑에

전각영숫자를 반각영숫자로 변환한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 의 전각영숫자를 반각영숫자로 변환한다

require 'jcode.pl';

jcode::tr(\$str, '0-9A-Za-z', '0-9A-Za-z');

jcode.pl 의 tr 함수를 사용합니다. 이 함수는 전각 문자에 대응했다 tr 입니다. 자세하게는 jcode.pl 안의 설명을 읽어 주세요. 기본적으로 tr 그래서, 전각영숫자 이외에도 전각 스페이스를 반각 스페이스로 하는 등의 변환도 다음과 같이 쓰는 것으로 간단하게 할 수 있습니다. 

# $str 의 전각 스페이스등을 반각 스페이스 등에 변환한다

require 'jcode.pl';

jcode::tr(\$str, '　()＿＠－', ' ()_@-');

반대로,제 1 인수와제 2 인수를 반대로 하면, 반각 문자를 전각 문자로 할 수도 있습니다. 반각 카타카나와 전각 카타카나의 상호 변환에 관해서는 「반각 카타카나를 전각 카타카나로 변환한다」를 참조.

탑에

반각 카타카나를 전각 카타카나로 변환한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 의 반각 카타카나를 전각 카타카나로 변환한다

require 'jcode.pl';

jcode::h2z_euc(\$str);

jcode.pl 의 h2z_euc 함수를 사용합니다.

탑에

올바르고 패턴 매치시킨다

$str 및 $pattern 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조.

perl 로 일본어를 취급하는 경우에는 스크립트를 EUC-JP 로 써, 한자 코드가 EUC-JP 인 일본어를 처리한다는 것이 제일 문제가 일어나기 어려운 방법이다고 하는 것을 「perl 스크립트는 EUC-JP 로 쓴다」라고 「한자 코드를 EUC-JP (으)로 변환해 처리한다」로 말했습니다. 그러나, 그것만으로는 조금 곤란한 일이 일어나는 일이 있습니다. 예를 들어, 다음과 같은 스크립트를 실행하면(자) 잘못해 성냥 해 버립니다. 

# 잘못해 성냥 해 버리는 예

$str = '이것은 테스트입니다';
$pattern = '호';

if ($str =~ /$pattern/) {
  print "성냥 한 \n";
}

왜 이러한 일이 일어나 버리는가 하면(자),EUC-JP 의 「스」의 문자 코드는 0xA5 0xB9 , 「트」는 0xA5 0xC8, 「호」는 0xB9 0xA5 (이어)여, 정확히 「파업」의 한가운데의 부분이 「호」와 같게 되므로 성냥 해 끝냅니다. 이와 같이어긋난 장소에서 성냥해 끝내서는 곤란한 경우에는 다음과 같이 씁니다. 

# $str 에 $pattern 를 올바르게 성냥 시킨다

$ascii = '[\x00-\x7F]';
$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

if ($str =~ /^(? :$ascii|$twoBytes|$threeBytes)*? (? :$pattern)/) {
  print "성냥 한 \n";
}

왜 이러한 쓰는 법이 되는지 설명합니다. 최초가 잘못해 성냥 해 버린다 스크립트에서는 /$pattern/ 와 같이 간단하게 성냥 시키려고 했기 때문에 어긋난 장소에서 성냥 해 버렸습니다. 거기서, 어긋난 장소에서 성냥 하지 않게 하려면 ,$pattern 의 전에는 일본어의 문자가 무엇 문자인가 있어, 그 후에 $pattern 가 오면(자) 말하는 것을 명시적으로 써 줄 필요가 있습니다. EUC-JP 에서의 1 문자라고 하는 것은 1바이트 문자인 ASCII, 2바이트 문자인 JIS X 0201 가타카나(반각 카타카나)와 JIS X 0208(전각 문자),3바이트 문자로 어느 JIS X 0212(보조 한자)입니다. 이것을 정규 표현으로 나타냈던 것이 (? :$ascii|$twoBytes|$threeBytes) 의 부분입니다. 이 문자가 캐릭터 라인의 선두로부터 무엇 문자인가 계속된 후에 $pattern 가 온다고 하는 것을 정규 표현으로 썼던 것이 위의 스크립트입니다.

정규 표현으로 임의의 한 글자를 나타내려면 보통 . (피리어드)(을)를 사용합니다만, 일본어의 캐릭터 라인에 대한 매칭에서는, . (피리어드) (으)로 쓰고 싶어지는 장소를 (? :$ascii|$twoBytes|$threeBytes) 그렇다면 좋은 것에 됩니다. 최초의 스크립트의 /$pattern/ 도 /^. *? (? :$pattern)/ (이)라고 생각하면 위의 스크립트와 같이 되는 것도 납득해 주실 수 있는 것은 아닐까요.

일본어의 캐릭터 라인에 대해서 올바르게 성냥 시키는 방법으로서 지금까지 써 온 것처럼 EUC-JP 에서의 1 문자라는 것을 분명하게 의식해 정규 표현을 쓴다고 하는 방법 이외에, 미리 성냥 시킨다 전에 2바이트 문자와 3바이트 문자의 뒤로 문자의 단락을 알 수 있도록(듯이)단락 문자를 적어 속과 말하는 방법이 있습니다. 구체적으로는 다음과 같이, 성냥의 대상이 되고 있는 일본어의 캐릭터 라인 $str 와 성냥 시키려고 하고 있는 패턴 $pattern 의 양쪽 모두에 단락지어 문자를 적는 처리를 하고 나서 매칭을 행합니다. 이 스크립트에서는 단락지어 문자로서 \000 (을)를 사용하고 있습니다. 

# 단락 문자를 적어 올바르게 성냥 시킨다(매우 늦다)

$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

$pattern =~ s/($twoBytes|$threeBytes) /$1\000/og;
$str =~ s/($twoBytes|$threeBytes) /$1\000/og;

if ($str =~ /$pattern/) {
  print "성냥 한 \n";
}

이 방법에서는 성냥 시키기 전에 단락지어 문자를 적는 처리를 행하는 것으로, 정규 표현 그 자체는 보통으로 쓸 수가 있습니다. 이 방법은 알기 쉬운 곳은 좋습니다만, 아마 대부분의 경우 단락 문자를 사용하지 않는 최초의 스크립트 보다실행 속도가 늦은이지요.

이 2개(살)방법의 특징을 생각해 보겠습니다. 단락 문자를 사용하지 않는 방법은, 사전 처리없이 곧바로 패턴 매치를 시작할 수가 있다. 그러나, 패턴 매치 그것은 정규 표현이 복잡하기 때문에 조금 늦다. 단락 문자를 사용한 방법은, 미리 캐릭터 라인 전체에 대해 단락 몬지를 들어갈 수 있는 사전 처리를 행할 필요가 있다. 다만, 패턴 매치 그 자체는 정규 표현이 복잡하게 안 되기 위해(때문에) 빠르다.

그러면 실제로 비교하면 어떻게 될까 조사해 보았습니다. 패턴 매치가 성공하지 않았던 경우, 캐릭터 라인 전체에 대해 검색을 행하는 것에 됩니다만, 내가 벤치마크를 취해 보았는데, 단락 문자를 사용하지 않는다 방법이압도적으로 빨랐다 (약 15배)입니다. 패턴 성냥이 성공하는 경우에는, 캐릭터 라인의 도중에 검색을 멈출 수가 있으므로, 캐릭터 라인 전체에 대해서 반드시 사전 처리를 행하지 않으면 안 되는 단락 문자를 사용했다 방법이 늦은 것은 말할 것도 없습니다. 결국, 단락 문자를 사용하지 않는 방법은 정규 표현이 복잡하게 된 만큼 패턴 매치 그 자체는 조금 늦어집니다만, 단락 문자를 사용하는 방법은, 안돼 선단락 몬지를 들어갈 수 있는 처리가 너무 늦어 패턴 매치 그 자체의 속도가 전혀 살지 않았던 것 같습니다.

이 결과로부터 하면(자), 데이터안 (으)로부터 성냥 하는 것만 꺼내는 것 같은 처리에는 분명하게 단락 문자를 사용하지 않는다 최초의 스크립트가 좋다고 말할 수 있습니다. 단락 문자를 사용한 방법이 좋다 경우로서는, 사전 처리의 늦음을 패턴 매치의 속도로 보충할 수 있는 만큼 몇번이나 같은 캐릭터 라인에 대해서 패턴 매치를 행하는 경우입니다. 물론, 이것들 실행 속도에 관해서는 환경에 의존하는 이야기이므로, 실제로 자신의 환경에서 시험해 보는 것이 좋을 것입니다.

다음에, 일본어의 캐릭터 라인을 올바르게 치환하는 방법에 대해 설명합니다. 다음과 같은 스크립트가 잘못해 치환해 버린다고 하는 것은 벌써 설명했던 대로입니다. 

# 잘못해 치환해 버리는 예

$str = '이것은 테스트입니다';
$pattern = '호';
$replace = '혐';

$str =~ s/$pattern/$replace/g;

다음과 같이 쓰는 것으로 올바르게 치환할 수가 있습니다. 

# $str 의 $pattern 를 $replace 에 올바르게 치환한다

$ascii = '[\x00-\x7F]';
$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

$str =~ s/\G((? :$ascii|$twoBytes|$threeBytes)*? )(? :$pattern) /$1$replace/g;

이 스크립트의 기본적인 생각은,EUC-JP 에서의 1 문자라는 것을 분명하게 의식해 정규 표현을 쓰는 성냥의 방법과 같습니다. 다만, 성냥 시킬 뿐(만큼)의 경우와 다른 것은 $1 (와)과 \G 를 사용하고 있는 곳(중)입니다. $1 (을)를 사용하는 것은, 치환하는 부분을 성냥 시킬 때 $pattern 의 전에 있는 문자도 함께 성냥 시킨다 되기 (위해)때문에, 이 부분을 치환하지 않고 그대로 남겨 줄 필요가 있기 때문입니다. 거기서 $pattern 의 전의 부분에 해당되는 정규 표현 (? :$ascii|$twoBytes|$threeBytes)*? (을)를 괄호로 둘러싸 $1 그리고 참조할 수 있도록(듯이) 하고 있습니다.

다음에 \G 의 설명을 합니다. \G (을)를 사용하는 것은수식자 g 하지만 붙여져 있기 (위해)때문에입니다. 수식자 g 는, 성냥 할지 어떨지 판정할 뿐(만큼)이라면 필요없으며, 또,1회밖에 치환하지 않는 경우도 필요 없습니다. 그 때는수식자 g 를 붙이는 것을 그만두어, \G 를 캐릭터 라인의 선두에 성냥 한다 ^ 에 바꿀 수가 있습니다. 반대로 말하면,수식자 g 를 붙여 $str 안의 $pattern (을)를 모두 치환하고 싶을 때에, 캐릭터 라인의 선두에만 성냥 한다 ^ (을)를 사용할 수 없다고 하는 것입니다. \G (은)는수식자 g 가 붙여져 있다 풀어에,패턴 매치의 개시 위치에 성냥합니다. 즉,\G 하 제일 처음은 ^ 과 같아, 다음으로부터는 $pattern 의 곧 뒤로 성냥 합니다. 알기 쉽고 간단하게 말하면(자),\G 는 성냥 할지 어떨지 지금부터 조사하려고 하고 있는 나머지의 부분의 선두에 성냥 한다고 말할 수 있습니다. \G (을)를 사용하는 것으로, 어긋난 위치에서 $pattern 하지만 성냥 하는 것이 없게 됩니다.

치환의 경우에도 다음과 같이 단락지어 문자를 적어 올바르게 치환하는 방법이 있습니다. 

# 단락 문자를 적어 올바르게 치환시킨다(매우 늦다)

$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

$pattern =~ s/($twoBytes|$threeBytes) /$1\000/og;
$str =~ s/($twoBytes|$threeBytes) /$1\000/og;

$str =~ s/$pattern/$replace/g;
$str =~ tr/\000//d;
# $str =~ s/($twoBytes|$threeBytes) \000/$1/og;

기본적으로 단락지어 문자를 적어 올바르게 성냥 시키는 방법과 같습니다. 다만, 성냥 시킬 뿐(만큼)의 경우와 달리, 치환 후에 단락지어 문자를 삭제할 필요가 있습니다. 이 스크립트에서는 단락지어 문자에 \000 (을)를 사용하고 있어, 치환 후에 이 단락 문자를 tr 를 사용해 삭제하고 있습니다. 그런데 , $str 안에 처음부터 포함되어 있었다 \000 도 함께 삭제해 버립니다. tr 를 사용해 삭제할 수 있는 것은 $str 안에 단락지어 문자와 같다 \000 하지만 포함되지 않다고 하는 전제가 필요합니다. 만약, $str 안에 \000 가 포함되어 있을지도 모르는 경우에는 tr (을)를 사용해 단락 문자를 삭제하는 것을 멈추어, $str =~ tr/\000//d; 를 $str =~ s/($twoBytes|$threeBytes) \000/$1/og; (으)로 변경합니다.

실행 속도에 대해 2개(살)방법을 비교해 보았습니다. 준 캐릭터 라인에 대해서 전혀 치환하는 곳(중)이 없었던 경우에는, 단락 문자를 사용하지 않는다 방법이압도적으로 빨랐다 (약 35배)입니다. 전부의 문자를 치환할 필요가 있는 캐릭터 라인을 주었다 경우에서도, 단락 문자를 사용하지 않는 방법이 4할 정도 빨랐다입니다. 만약, 단락 문자를 사용하는 경우의 방법으로 후 처리에 tr 를 사용하지 않았던 경우에는 더욱 스피드 차이가 나겠지요. 결국, 치환의 경우에서도 단락지어 문자를 사용하는 경우는, 사전 처리와 후 처리에 시간이 걸려 지난다고 하는 것을 말할 수 있습니다. 실행 속도에 관해서는 환경에 의존하는 이야기이므로, 어느 쪽이 빠른가 자신의 환경에서 시험해 본다 의가 제일이라고 하는 것은 말할 것도 없습니다.

그런데, 여기까지의 이야기에서는 $pattern 는 Perl 의 문법적으로 올바른 정규 표현이라고 하는 전제였습니다. 그러니까, 예를 들어열어 괄호 ( 에 성냥 시키고 싶은 경우에는 \( 와 같이 이스케이프 할 필요가 있습니다. CGI 등에 있어, 유저 입력의 캐릭터 라인으로 성냥 하는 것을 검색하고 싶은 경우등에는, 입력된 캐릭터 라인을 정규 표현으로서 해석하는 것이 아니라, 그 캐릭터 라인 그 자체로 검색하고 싶은 경우가 대부분이지요. 그러한 때에, $pattern 로서 패턴 매치를 행하면(자), 방금전의 예로 든열림 괄호 ( 등이 입력되었을 때에 정규 표현으로서 올바르지 않으면 에러가 되어 버립니다. 거기서 정규 표현으로 특별한 의미로서 해석되는 열림 괄호등의메타 캐릭터(은)는 이스케이프 해 패턴 매치시킬 필요가 있습니다.

그 때문에(위해)는, 유저 입력 $keyword 에 대해서, 지금까지 쓴 스크립트의 $pattern 의 부분을 \Q$keyword\E 로 변경해, 패턴 매치의 경우는, 

if ($str =~ /^(? :$ascii|$twoBytes|$threeBytes)*? \Q$keyword\E/) {
  print "성냥 한 \n";
}
치환의 경우는, 
$str =~ s/\G((? :$ascii|$twoBytes|$threeBytes)*? ) \Q$keyword\E/$1$replace/g;
(와)과 같이 합니다. \Q 로부터 \E 까지 메타 캐릭터가 무시되게 됩니다.

다음에 실행 속도를 올리기 위한 방법을 1개써 둡니다. 지금까지 써 온 것처럼, 일본어의 캐릭터 라인에 대해서 올바르게 성냥 시키거나 치환한다 위해(때문에)는 조금 복잡한 정규 표현을 사용할 필요가 있습니다. 그 때문에, 그 복잡하게 된 만큼 만여라실행 속도가 늦어져 버립니다. 이것은, 대량의 데이터중에서 검색하거나 치환하거나 하는 경우에는 매우 시간이 걸리게 되어 버리는 것을 의미합니다.

여기서 조금 생각해 보세요. 대량의 데이터중에서 검색할 때, 그대부분의 경우는 성냥 하지 않는다의입니다. 즉, 성냥 하지 않기 때문에 올바르게 성냥 시킬 필요는 없습니다. 거기서 $pattern 를 검색하고 싶을 때에는, 다음과 같이 하는 것으로 대부분의 경우실행 속도를 올리는일이 생깁니다. 

if ($str =~ /$pattern/) {
  if ($str =~ /^(? :$ascii|$twoBytes|$threeBytes)*? (? :$pattern)/) {
    print "성냥 한 \n";
  }
}

$keyword 의 경우는, /\Q$keyword\E/ 라고 하는 정규 표현은 사용하지 않고 다음과 같이 index 함수를 사용합니다. 

if (index($str, $keyword) > -1) {
  if ($str =~ /^(? :$ascii|$twoBytes|$threeBytes)*? \Q$keyword\E/) {
    print "성냥 한 \n";
  }
}

index 함수는 정규 표현 에 비해실행 속도가 압도적으로 빠른것으로, 뭐든지 정규 표현은 아니고,index 함수를 사용할 수 없는가 항상 생각하고 싶은 것입니다.

지금까지 써 온 방법은 EUC-JP 만이 아니고, SJIS 의 경우에 도 응용할 수가 있습니다. SJIS 의 경우에도 SJIS 에서의 1 문자라고 한다 물건을 의식해 정규 표현을 쓰게 됩니다. SJIS 에서의 1 문자에 대해서, 「문자의 정규 표현」을 참조.

실은,EUC-JP 로 perl5. 005 이후라고 하는 조건 냄새 (이)라고는, 대부분의 경우에 지금까지 써 온 방법보다실행 속도 하지만 빠르고, 보다취급하기 쉬운방법이 있습니다. 이하에 정리해 열거합니다. 

# EUC-JP 로 perl5. 005 이후 한정의 방법

$eucpre = qr{(? <! \x8F)};
$eucpost = qr{
    (? =                         
     (? :[\xA1-\xFE][\xA1-\xFE])* # JIS X 0208 이 0 문자 이상 계속되어
     (? :[\x00-\x7F\x8E\x8F]|\z)  # ASCII, SS2, SS3 또는 종단
    )
 }x;

if ($str =~ /$eucpre(? :$pattern) $eucpost/) {          # 패턴 매치
  print "성냥 한 \n";
}

if ($str =~ /$eucpre\Q$keyword\E$eucpost/) {      # 키워드 매치
  print "성냥 한 \n";
}

$str =~ s/$eucpre(? :$pattern) $eucpost/$replace/g;     # 패턴 치환

$str =~ s/$eucpre\Q$keyword\E$eucpost/$replace/g; # 키워드 치환

어느 경우에 대해도,$eucpre 와 $eucpost 로 사이에 두는 만큼 됩니다. 이 방법은 정규 표현의뒤읽기(lookbehind) (와)과예측(lookahead)을 사용하고 있습니다. 후 읽기는 (? <regex), 예측은 (? =regex) 그렇다고 하는 정규 표현이 됩니다. 이 스크립트에서는 후 읽기는 부정 후 읽기의 (? <! regex) 의 (분)편을 사용하고 있습니다.

이 방법은 성냥 시키고 싶은 정규 표현에 성냥 한 것이 어긋난 위치가 아닌 것 (을)를 후 읽기와 예측에 의해 보증하고 있습니다. 구체적으로는, 후 읽기의 부분에서 JIS X 0212 의 2바이트째부터 어긋나 성냥 하고 있고 없는가 체크하고 있습니다. JIS X 0212 의 2바이트째부터 성냥 하고 있었을 경우는, 성냥 한 부분의 직전에 JIS X 0212 의 1바이트째, 즉, \x8F 가 있게 됩니다. 그러나, 후 읽기에 의해 \x8F 가 아닌 것이 보증되고 있으므로, JIS X 0212 의 2바이트째부터 어긋나 성냥 하는 것은 없어집니다.

또,JIS X 0208 의 2바이트째부터 어긋나 성냥 해 (이)라고 끝내는 경우와 JIS X 0212 의 3바이트째부터 어긋나 막 치 해 버리는 경우에 대한 체크는 예측 부분에서 행하고 있습니다. 만약, 이 인 위치로부터 어긋나 성냥 해 버렸을 경우, 예측 부분에 성냥 하지 않게 됩니다. 예측 부분은 성냥 한 부분의 뒤로 올바르게 EUC-JP 의 캐릭터 라인이 속 있고 (이)라고 있을지 어떨지를 체크하고 있습니다. 구체적으로는, 성냥 한 부분의 뒤로부터, JIS X 0208이외의 것이 올 때까지, 올바르고 JIS X 0208 문자가 계속되고 있는지 어떤지를 체크하고 있습니다.

이 방법에서는 예측과 후 읽기만으로 올바르게 성냥 시킬 수가 있습니다. 예측 (와)과 후 읽기는 어느쪽이나 그 자체에는 성냥 한 캐릭터 라인을 포함하지 않는다 0 문자폭의 정규 표현입니다. 따라서, 치 환 하는 경우에 치환 후의 캐릭터 라인안에 $eucpre 나 $eucpost 에 성냥 한 부분을 생각한 $1 (와)과 같은 것을 필요로 하지 않게 됩니다.

탑에

전후의 공백 문자(전각 스페이스함)를 삭제한다

# $str 의 선두의 공백 문자(전각 스페이스함)를 삭제한다
$str =~ s/^(? :\s|$Zspace) +//o; # $str 가 EUC-JP 의 경우
$str =~ s/^(? :\s|$Zspace_sjis) +//o; # $str 가 SJIS 의 경우

# $str 의 말미의 공백 문자(전각 스페이스함)를 삭제한다
$str =~ s/^($character*? )(? :\s|$Zspace) +$/$1/o; # $str 가 EUC-JP 의 경우
$str =~ s/$eucpre(? :\s|$Zspace) +$//o; # $str 가 EUC-JP 의 경우(perl5. 005이후)

$str =~ s/^($character_sjis*? )(? :\s|$Zspace_sjis) +$/$1/o; # $str 가 SJIS 의 경우

상기 스크립트로 사용하고 있는 변수에 대해서는 「문자의 정규 표현」 및 「올바르고 패턴 매치시킨다」 (을)를 참조해 주세요.

전후의 전각 스페이스를 포함한 공백 문자를 삭제할 때, 다음과 같이 쓰면(자) 잘못해 삭제해 버릴 가능성이 있습니다. 

# $str 의 말미의 공백 문자(전각 스페이스함)를 삭제한다(실수)
$str =~ s/(? :\s|$Zspace) +$//o; # $str 가 EUC-JP 의 경우
$str =~ s/(? :\s|$Zspace_sjis) +$//o; # $str 가 SJIS 의 경우

선두의 공백 문자를 삭제하는 경우에 대해서는 특히 문제 없습니다만, 말미의 공백 문자를 삭제할 경우에는 전각 스페이스가 멀티 바이트 문자의 일부 등에 잘못해 성냥 해 버릴 가능성이 있습니다. 예를 들면, SJIS 로 $str = '＠=@'; 의 경우, 잘못해 말미를 삭제해 버립니다. 자세하게는, 「perl 스크립트는 EUC-JP 로 쓴다」 및 「올바르고 패턴 매치시킨다」 (을)를 참조해 주세요.

탑에

문자 단위로 분할한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 를 문자 단위로 분할해 배열 @chars 에 대입한다

$ascii = '[\x00-\x7F]';
$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

@chars = $str =~ /$ascii|$twoBytes|$threeBytes/og;

마지막 대입문을 알기 쉽고, @chars = ($str =~ /($ascii|$twoBytes|$threeBytes) /og; (이)라고 써도 거의 동등의 동작을 합니다. 먼저 그처럼 썼을 경우의 설명을 합니다. EUC-JP 에서의 1 문자가 $ascii|$twoBytes|$threeBytes (와)과 정규 표현으로 나타낼 수가 있는 것을 「올바르고 패턴 매치시킨다」로 말했습니다. 이것을 괄호로 둘러싸 그룹으로 하고 있습니다. 한편, 이 대입문은 배열 @chars 에의 대입이므로, 우변은리스트 문맥으로 실행됩니다. 패턴 매치를 리스트 문맥으로 실행하면(자), 그룹으로 된 정규 표현에 성냥 하는 캐릭터 라인의 리스트가 돌려주어집니다. 즉, ($1, $2, $3,…) (이)라고 하는 리스트가 돌려주어집니다. 한층 더수식자 g 가 붙여져 있기 때문에, ($1, $2, $3,…, $1, $2, $3,…) (이)라고 하는 리스트가 돌려주어지게 됩니다. 이 경우는 그룹으로 되고 있는 정규 표현이 1개이므로, 정확히 EUC-JP 에서의 1 문자에 분할된 리스트가 돌려주어지게 됩니다.

최초의 스크립트에서는 @chars 에의 대입문의 우변 전체를 괄호로 둘러싸고 있지 않습니다만, 이것은 = 보다 =~ (분)편이연산자의 우선 순위가 높은것으로, @char = $str (을)를 먼저 실행해 버린다고 하는 것은 없습니다.

또, 정규 표현의 전체를 괄호로 둘러싸고 있지 않습니다만,수식자 g 하지만 붙여져 있는 패턴 매치를 리스트 문맥으로 실행했을 때, 정규 표현안에 괄호가 1개도 없었다 경우는 자동적으로정규 표현 전체를 괄호로 둘러싸 있는것과 해 동작합니다. 이 때, 정규 표현 전체를 괄호로 둘러쌌다 경우보다실행 속도가 빠른입니다. 나중에 $1 (으)로서 사용하는 것도 아니고 정규 표현 전체를 괄호로 둘러싼다 같은 경우에는 괄호를 붙이지 않는 것이 좋을 것입니다.

탑에

특정의 길이로 되풀이한다

# $str 를 $bytes 바이트로 되풀이한다

require 'fold.pl';

while (length($str)) {
  (my $folded, $str) = fold($str, $bytes);
  print $folded, "\n";
}

fold.pl (가대 카즈마사씨작)(을)를 사용하는 것이 간단합니다. fold.pl 를 사용하지 않고, 「문자가 중단되고 있는지 판정한다」로 쓴 것처럼 문자가 중단되지 않은가 판정하면서 substr 함수를 사용해 되풀이한다고 하는 방법도 있습니다만, 일부러 쓸 필요는 없을 것입니다. fold 함수 의제 3 인수에 1 을 지정하면, 되풀이한 결과 $bytes바이트에 못 미친 경우에는 스페이스를 보충해 $bytes바이트가 되도록(듯이) 하는 것이 할 수 있습니다. 또, 제 4 인수에 1 을 지정하면 단어 경계에서 되풀이하게 됩니다. 자세하게는 fold.pl 안의 설명을 읽어 주세요. 덧붙여 fold.pl 는 보조 한자와 SJIS 의 반각 카타카나에는 대응해 없습니다. 또,EUC-JP 의 반각 카타카나는 2바이트 문자로서 취급하기 때문에, 반각 카타카나가 섞이고 있으면(자) 표시폭에 차이가 발생합니다. 표시폭을 갖추고 싶은 경우에는, 반각 카타카나를 미리 전각 카타카나로 변환해 두는지, 되풀이하는 바이트수를 적당하게 처리해 줄 필요가 있습니다.

Jcode.pm 의 jfold 함수 (을)를 사용해도 같은 것이 생깁니다만, 단어 경계에서 되풀이하거나는 할 수 없습니다.

덤으로서 반각 카타카나에 대응한 금칙 처리 하면서 되풀이하는 스크립트를 실어 둡니다. 이 스크립트는 EUC-JP 로 쓰여져 $str 도 EUC-JP 그렇다고 하는 전제이므로, 필요하면 미리 EUC-JP (으)로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $str 를 금칙 처리 하면서 되풀이한다

require 'fold.pl';
require 'jcode.pl';

$no_begin = "! %),. :;? ]}￠о＇”‰´˝℃,. 들〉》」」】〕" .
    "″˚□□" .
    "·-□□! %),. ：；? ］｝";              # 줄머리 금칙 문자
$no_begin_jisx0201 = ".」, ·″˚";
jcode::z2h_euc(\$no_begin_jisx0201);
$no_begin . = $no_begin_jisx0201;                 # 줄머리 금칙 문자(반각 카타카나)
$no_end = "\$([{￡\‘“〈《「 「【〔＄(［｛￥";  # 줄 끝 금칙 문자
$no_end_jisx0201 = " 「";
jcode::z2h_euc(\$no_end_jisx0201);
$no_end . = $no_end_jisx0201;                     # 줄 끝 금칙 문자(반각 카타카나)
$allow_end = $no_begin;                          # 매달고 줄머리 금칙 문자
$del_space = '(? :\s|\xA1\xA1)';                  # 삭제하는 줄머리 줄 끝 공백
$basebytes = 74;                                 # 기본장
$maxbytes = 76;                                  # 최대장
$ascii = '[\x00-\x7F]';
$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

map {$no_begin{$_} = 1;} ($no_begin =~ /$ascii|$twoBytes|$threeBytes/og);
map {$no_end{$_} = 1;} ($no_end =~ /$ascii|$twoBytes|$threeBytes/og);
map {$allow_end{$_} = 1 + /[\xA1-\xFE]/ - /\x8E/;}
    ($allow_end =~ /$ascii|$twoBytes|$threeBytes/og);

sub fold_properly {
  my $str = shift;
  my($folded, $strtmp, $bytestmp, $begin_char, $end_char, $flag);
  $flag = 1; # 줄머리 금칙 처리 상태(1:매달아 0:추방)
  $bytestmp = $basebytes;
  $str =~ tr/\t\n\r\f/ /; # 공백 문자를 스페이스에 변환
  $str =~ s/^$del_space+//o; # 줄머리 공백 삭제
  ($begin_char) = %no_begin; # 줄머리 금칙 문자를 1 문자 대입
  while ($no_begin{$begin_char} or $no_end{$end_char}) {
    ($folded, $strtmp) = fold($str, $bytestmp, 0, 1);
    while (length($folded) - ($folded =~ tr/\x8E//) <= $basebytes and
   $strtmp ne '' and $flag) { # 반각 카타카나를 위한 표시폭처리
      ($folded, $strtmp) = fold($str, $bytestmp, 0, 1);
      my ($folded_tmp, $strtmp_tmp) = fold($str, $bytestmp + 1, 0, 1);
      if (length($folded_tmp) - ($folded_tmp =~ tr/\x8E//) <= $basebytes) {
        ($folded, $strtmp) = ($folded_tmp, $strtmp_tmp);
        $bytestmp++;
      } else {
        last;
      }
    }
    ($begin_char) = $strtmp =~ /^$del_space*($ascii|$twoBytes|$threeBytes) /o;
    ($end_char) = $folded =~ /($threeBytes|$twoBytes|$ascii) $/o;
    if ($flag) { # 매달고 금칙 처리
      if ($no_begin{$begin_char} and $allow_end{$begin_char}) { # 매달고 가능
        if (length($folded) - ($folded =~ tr/\x8E//)
            + $allow_end{$begin_char} <= $maxbytes) {
          $bytestmp++;
        } else {
          $flag = 0;
          $bytestmp = $basebytes - 1 + ($folded =~ tr/\x8E//);
        }
      } else {
        $flag = 0;
        $bytestmp--;
      }
    } else {
      $bytestmp--;
    }
    if ($bytestmp == 0) { # 금칙 처리 불가능
      ($folded, $strtmp) = fold($str, $basebytes, 0, 1);
      last;
    }
  }
  $folded =~ s/^((? :$ascii|$twoBytes|$threeBytes)*? (? =$del_space))
      $del_space+$/$1/ox; # 줄 끝 공백 삭제
  ($folded, $strtmp);
}

while (length($str)) {
  (my $folded, $str) = fold_properly($str);
  print $folded, "\n";
}
탑에

Base64encode·디코드한다

$str 는 EUC-JP 라고 하는 전제이므로, 필요하면 미리 EUC-JP 로 변환해 둬 주세요. 한자 코드의 변환에 관해서는 「한자 코드를 EUC-JP (으)로 변환해 처리한다」를 참조. 

# $data 를 Base64 encode 해 $encoded_data 를 요구한다

use MIME::Base64;

$encoded_data = encode_base64($data);

Base64encode 하려면 , 모듈 MIME::Base64 의 encode_base64 함수를 사용합니다. Base64encode·디코드에 대해서는 RFC 2045 ( 일본어 번역 )에 쓰여져 있습니다. 여기에 따른 Base64encode 한 출력 시냇물의 각 행은 76 문자이내가 아니면 안되면 쓰여져 있습니다. encode_base64 함수는제 2 인수를 지정하지 않고 불렀을 경우에는 자동적으로 76 문자마다 개행 코드를 넣어 되풀이해 줍니다. 

# $encoded_data 를 Base64 디코드해 원의 데이터 $data 에 되돌린다

use MIME::Base64;

$data = decode_base64($encoded_data);

Base64디코드하려면 , 모듈 MIME::Base64 의 decode_base64 함수를 사용합니다. $encoded_data 에는 76 문자마다 되풀이하기 위해서(때문에) 삽입되고 있는 개행 코드가 들어간 채로도 괜찮습니다.

다음에 encoded-word 에 대해 설명합니다. encoded-word 에 대해서는 RFC 2047 ( 일본어 번역 )에 쓰여져 있습니다. encoded-word 라고 하는 것은 =? charset? encoding? encoded-text? = 그렇다고 하는 형태를 한 것입니다. 예를 들어 =? ISO-2022-JP? B? GyRCTmMbKEI=? = 하 "예" 라고 하는 캐릭터 라인을 encoded-word (으)로 한 것입니다. 여기에서는 encoding 에 B 를 지정했다 encoded-word 에 대해 설명합니다.

encoding 가 B 라고 하는 것은 encoded-text 의 부분이 Bencode된 것인 것을 나타내고 있습니다. Bencode라고 하는 것은 Base64encode와 같은 encode 방법입니다만, encoded-word 의 경우는 Base64encode라고는 부르지 못하고 Bencode라고 부릅니다. 

# $str 를 Bencode 해 encoded-word 로 변환한다(불완전)

require 'jcode.pl';
use MIME::Base64;

jcode::convert(\$str, 'jis', 'euc', 'z');
$str = '=? ISO-2022-JP? B? ' .  encode_base64($str, '') .  '? =';

Bencode하려면 encode_base64 함수를 사용하면 좋겠습니다만,제 2 인수를 지정하지 않는 경우는 encode 한 결과에 개행 코드가 붙어 버리므로, 공문자열을 지정해 개행 코드가 붙지 않게 하고 있습니다. 또,charset 에 ISO-2022-JP 를 지정하는 형편상, 미리 $str 를 JIS 에 변환할 필요가 있습니다. 정확하게는 ISO-2022-JP 로 변환할 필요가 있습니다. ISO-2022-JP (으)로 변환하려면 기본적으로 JIS 로 변환해 주면 좋겠습니다만, ISO-2022-JP 에서는 반각 카타카나를 사용할 수 있지 않습니다. 거기서 반각 카타카나가 포함되어 있었을 경우에는 전각 카타카나로 변환할 필요가 있습니다. 이것을 하려면 jcode::convert 함수의제 4 인수에 'z' 를 지정 해 줍니다.

encoded-word 로 변환하는 기초는 이만큼입니다만, 이것은 어디까지나 기초이며 RFC 2047 (을)를 채울 수가 없다 불완전한 것입니다. RFC 2047 에는 encoded-word 로 변환하는데 있어서 지키지 않으면 안 되는 결정에 대해. 대체로 다음과 같은 일이 쓰여져 있습니다.

  1. encoded-word 는 75바이트이내가 아니면 안된다.
  2. encoded-word 를 포함한 행은 76바이트이내가 아니면 안된다.
  3. encoded-word (은)는 각각 독립해 디코드 가능하지 않으면 안 된다.
  4. encoded-text 를 디코드한 캐릭터 라인의 문자 코드는, 마지막에 ASCII 가 지정된 상태가 아니면 안된다.
  5. encoded-word 가 나타나는 출현 위치에 관한 결정.
    • Subject 나 Comment 의 헤더 필드등의, 'text' 안에 출현.
    • "(" 와 ") " 로 단락지어졌다 'comment' 안에 출현.
    • From 나 To, CC 헤더등으로,'phrase' 안에 출현.
    • 'addr-spec' 안에서 출현해서는 안 된다.
    • 'quoted-string' 안에서 출현해서는 안 된다. 등 등.
  6. 서로 이웃이 되는 encoded-word 의 사이의 'linear-white-space' 는 무시한다.

1 에서 4 까지가 encoded-word 로 변환할 때 관계해 옵니다. 조금 전의 스크립트에서는 3 으로 4 에 대해서는 클리어 하고 있습니다만, 1 으로 2 에 대해서는 전혀 신경쓰고 있지 않습니다. 1 으로 2 에 대해서도 대응하기 위해서는 조금 곤란했다 문제가 일어납니다.

우선, 1 에 대해입니다만,encoded-word 의 길이가 75바이트를 넘는 것 같은 경우에는,Bencode한다 대상을 짧게 해,2개(살)이상의 encoded-word 로 나누어 변환하지 않으면 안됩니다. 2개(살)이상의 encoded-word (으)로 나누기 위해서(때문에),Bencode한 후의 encoded-text (을)를 3 이 채워지도록(듯이) 잘 분할할 수도 있습니다만, 그러면 4 (을)를 채울 수가 없게 되어 버립니다. 4 를 채우면서 대상을 짧게 하려면 , 적당한 곳에서 대상의 캐릭터 라인을 분할해 안되어, 분명하게일본어의 문자 단위로 짧고하지 않으면 되지 않습니다. 즉, 한자등의 2바이트 문자나 3바이트 문자의 도중에 분할해 안된다고 하는 것입니다. 일본어의 문자 단위로 짧게 할 수가 있으면(자), 후는 jcode.pl 를 사용해 JIS 에 변환하면, 자동적으로 마지막 문자 코드가 ASCII 상태가 되도록(듯이) 해 줍니다.

다음에, 2 에 대한 곤란한 문제라고 하는 것을 설명합니다. encoded-word (을)를 포함한 행이 76바이트이내가 아니면 안된다고 하는 것은, encoded-word 로 변환할 때, 변환한 후의 행이 76바이트이내가 되어 있도록(듯이) encoded-word 의 길이를 조정해야 한다고 하는 것이 됩니다. 만약, encoded-word 로 변환하면(자) 그 행이 76바이트를 넘어 끝내는 경우에는,개행해 되풀이할필요가 있습니다.

이상이 encoded-word 에의 변환 그 자체에 대한 조금 곤란한 문제 (이)라는 것이 됩니다만, 실은 그 이전에 제일 곤란한 문제라고 하는 것이 있어서, 그것이 5 입니다. 즉, 어느 부분을 encoded-word (으)로 변환하면 좋은 것인지, 라고 하는 것이 제일 문제인 것입니다. 같이 어느 부분을 디코드하면(자) 좋은 것인지라고 하는 것도 문제가 됩니다. 캐릭터 라인이 주어져 잘 처리하라고 말해지면(자) 어휘분석이나 구문 분석이 필요하게 되어 버립니다. 여기에서는 매우 거기까지는 할 수 없기 때문에,encoded-word 로 변환하고 싶은 부분, 역변환 하고 싶은 부분이 주어졌을 경우의 스크립트를 씁니다. 

# $str 를 encoded-word 로 변환해 $line 에 추가한다

require 'jcode.pl';
use MIME::Base64;

$ascii = '[\x00-\x7F]';
$twoBytes = '[\x8E\xA1-\xFE][\xA1-\xFE]';
$threeBytes = '\x8F[\xA1-\xFE][\xA1-\xFE]';

sub add_encoded_word {
  my($str, $line) = @_;
  my $result;

  while (length($str)) {
    my $target = $str;
    $str = '';
    if (length($line) + 22 +
	($target =~ /^(? :$twoBytes|$threeBytes) /o) * 8 > 76) {
      $line =~ s/[ \t\n\r]*$/\n/;
      $result . = $line;
      $line = ' ';
    }
    while (1) {
      my $encoded = '=? ISO-2022-JP? B? ' .
      encode_base64(jcode::jis($target, 'euc', 'z'), '') .  '? =';
      if (length($encoded) + length($line) > 76) {
	$target =~ s/($threeBytes|$twoBytes|$ascii) $//o;
	$str = $1 .  $str;
      } else {
	$line . = $encoded;
	last;
      }
    }
  }
  $result .  $line;
}

$line = add_encoded_word($str, $line);

실행예
$line = 'Subject: ';
$str = '이것은 테스트입니다. This is test. ';
$line = add_encoded_word($str, $line);
print $line, "\n";

실행 결과
Subject: =? ISO-2022-JP? B? GyRCJDMkbCRPJUYlOSVIJEckOSElGyhCVGhpcyBpcyB0ZXN0? =
 =? ISO-2022-JP? B? Lg==? =

이 스크립트는 $line 에 $str 를 encoded-word (으)로 변환하고 나서 추가합니다. $str 가 꽤 긴 경우는,encoded-word 하지만 빠르고 75바이트이내가 되도록(듯이) 당을 붙이고 나서 준 (분)편이 좋습니다만 이 스크립트에서는 행하고 있지 않습니다. 또, 어느 부분을 encoded-word 로 할까입니다만,RFC 2047 에는 본래 encoded-word 로 변환할 필요가 없는 것, 즉, ASCII 만일 수 있는으로부터 완성되는 단어까지 변환하는 것은추천 할 수 없다와 쓰여져 있습니다. 그러니까, 실행 예의 같게 is 나 test. 까지 함께 encoded-word 에 변환 하는 것은 너무 좋은 예라고는 말할 수 없습니다. 이것에 대해서는, Subject 등의 unstructured header 의 경우에 대응한 스크립트를 다음에 씁니다. 

# unstructured header $header 를 MIME encode 한다
# add_encoded_word()에 대해서는 위의 스크립트를 참조

sub mime_unstructured_header {
  my $oldheader = shift;
  my($header, @words, @wordstmp, $i) = ('');
  my $crlf = $oldheader =~ /\n$/;
  $oldheader =~ s/\s+$//;
  @wordstmp = split /\s+/, $oldheader;
  for ($i = 0; $i < $#wordstmp; $i++) {
    if ($wordstmp[$i] ! ~ /^[\x21-\x7E]+$/ and
	$wordstmp[$i + 1] ! ~ /^[\x21-\x7E]+$/) {
      $wordstmp[$i + 1] = "$wordstmp[$i] $wordstmp[$i + 1]";
    } else {
      push(@words, $wordstmp[$i]);
    }
  }
  push(@words, $wordstmp[-1]);
  foreach $word (@words) {
    if ($word =~ /^[\x21-\x7E]+$/) {
      $header =~ /(? :. *\n)*(. *)/;
      if (length($1) + length($word) > 76) {
	$header . = "\n $word";
      } else {
	$header . = $word;
      }
    } else {
      $header = add_encoded_word($word, $header);
    }
    $header =~ /(? :. *\n)*(. *)/;
    if (length($1) == 76) {
      $header . = "\n ";
    } else {
      $header . = ' ';
    }
  }
  $header =~ s/\n?  $//mg;
  $crlf ?  "$header\n" : $header;
}

$header = mime_unstructured_header($header);

실행예
$header = "Subject: ASCII 일본어 ASCII와 일본어 ASCII ASCII\n";
$header = mime_unstructured_header($header);
print $header;

실행 결과
Subject: ASCII =? ISO-2022-JP? B? GyRCRnxLXDhsGyhCIEFTQ0lJGyRCJEhGfEtcGyhC? =
 =? ISO-2022-JP? B? GyRCOGwbKEI=? = ASCII ASCII

이 스크립트는 전술의 스크립트의 함수 add_encoded_word() 를 이용하고 있습니다. 전술의 스크립트의 마지막 $line = add_encoded_word($str, $line); (을)를 삭제해, 이 스크립트로 변경해 사용합니다.

이 스크립트의 전반 부분에서 단어 마다 분할하고 있습니다. 여기서 분할되었다 단어 마다, ASCII 만일 수 있는으로부터 완성되는 단어인가 어떤가를 판정해 encoded-word 로 변환할지 어떨지를 결정해 갑니다. 이 때 6 에 주의할 필요가 있습니다. 디코드 때에 encoded-word 의 사이의 'linear-white-space' 는 무시됩니다만, 이것은 1행의 길이가 길어져 버리는 경우에,encoded-word (을)를 분할하기 위해서 삽입된 본래 불필요한 'linear-white-space' (을)를 삭제하기 위한의 것입니다. 그러나,원으로부터 존재한다 'linear-white-space' 의 양측을 encoded-word (으)로 변환해 버리면(자), 디코드 때에 잘못해 삭제되어 버리는일 (이)가 됩니다. 거기서,'linear-white-space' 의 양측을 encoded-word (으)로 변환할 필요가 있는 경우에는,'linear-white-space' 를 포함한 양측의 단어를 1개의 encoded-word 로서 변환합니다. 

# $str 를 B디코드해 encoded-word 를 바탕으로 되돌린다

require 'jcode.pl';
use MIME::Base64;

$lws = '(? :(? :\x0D\x0A|\x0D|\x0A)? [ \t])+';
$ew_regex = '=\? ISO-2022-JP\? B\? ([A-Za-z0-9+/]+=*)\? =';
$str =~ s/($ew_regex) $lws(? =$ew_regex) /$1/gio;
$str =~ s/$lws/ /go;
$str =~ s/$ew_regex/decode_base64($1) /egio;
jcode::convert(\$str, 'euc', 'jis');

이 스크립트는 주어진 캐릭터 라인 $str 안의 encoded-word 를 바탕으로 되돌립니다. 서로 이웃이 된다 encoded-word 의 사이의 'linear-white-space' (은)는 무시합니다. encoded-word 는 "(" 의 직후이다든가,'linear-white-space' 의 직후인 것 같은 경우에 encoded-word 이며, 그렇지 않은 경우는 일견 encoded-word 로 보여도,우연히 그러한 캐릭터 라인인이라고 해석해, 마음대로 바탕으로 되돌리려고 해야 하지는 않습니다. 그러나, 이 스크립트에서는 encoded-word 로 보인 것은 모두 바탕으로 되돌려 버리기 때문에, 캐릭터 라인 $str (을)를 주는 (분)편으로 그 판정을 행해, 바탕으로 되돌려도 문제 없는 것만을 줄 필요가 있습니다. 예를 들어, $str = q{"=? ISO-2022-JP? B? GyRCTmMbKEI=? ="}; 때는 quoted-string 이므로, 이 안에 encoded-word 하지만 나타날 것이 없습니다. 이것을 마음대로 바탕으로 되돌리려고는 안됩니다.

낡은 Outlook Express 등은 encoded-word 로 변환한 것을 다브르크트로 둘러싸 quoted-string 로 하므로,RFC 2047 (을)를 채울 수가 없습니다. Outlook Express 5 에서는 이 점은 수정된 것 같습니다. 그러나,Outlook Express 5 를 포함한다 대부분의 메일러는 encoded-word (을)를 포함한 행이 76바이트이내가 아니면 안된다고 하는 제약을 채우고 있지 않습니다.

encoded-word 에의 변환을 행하는 스크립트로서 mime_pls (이쿠타 노보루씨작) (이)라는 것도 공개되고 있습니다. 그러나, 이것도 RFC 2047 을 완전하게 채우고 있는 것은 아닙니다. encoded-word 에의 변환에 관해서는, Subject 행이나 From 행의 차이를 고려하지 않고 같은 코멘트 처리를 해 버립니다. 또, word 단위로 행하지 않기 때문에, 예를 들어 $str = "test 테스트 "; (와)과 같은 캐릭터 라인을 변환, 역변환을 행하면(자) "test 테스트 " (와)과 같이 여분의 스페이스가 들어가 버립니다. 특수 변수 $`, $&, $' 를 사용하고 있으므로, 모든 패턴 매치의 속도가 조금 늦어져 버리는 점은 개량의 여지가 있습니다. encoded-word 로부터의 역변환에 관해서는, 조금 전 말한 것처럼 일견 encoded-word 로 보이는 것까지 바탕으로 되돌려 버립니다. 이것을 올바르게 행하기 위해서(때문에)는 아무래도 구문 분석이 필요하게 됩니다.

Jcode.pm 의 MIME encode 함수 mime_encode 와 MIME 디코드 함수 mime_decode 는 버젼 0.63이후에 상기의 스크리프 트가 채용되고 있습니다.

RFC 2047 을 완전하게 채우고 있는 encoded-word 에의 변환을 행하는 스크립트로서는 IM(Internet Message) 의 IM::Iso2022jp 모듈이 있습니다. 표준 모듈은 아니기 때문에, 사용하기 위해서(때문에)는 IM 를 인스톨 할 필요가 있습니다. 사용법은 Iso2022jp.pm 의 내용을 봐 주세요.

탑에

URI 이스케이프·안 이스케이프 한다

'이스케이프' 라고 하는 캐릭터 라인을 '%a5%a8%a5%b9%a5%b1%a1%bc%a5%d7' 와 같이 URI 이스케이프하려면 다음과 같이 씁니다. 

# $str 를 URI 이스케이프 한다

$str =~ s/(\W)/'%' .  unpack('H2', $1) /eg;

반대로 '%a5%a8%a5%b9%a5%b1%a1%bc%a5%d7' 그렇다고 하는 캐릭터 라인을 URI 안 이스케이프해 '이스케이프' 그렇다고 하는 캐릭터 라인에 되돌리려면 다음과 같이 씁니다. 

# $str 를 URI 안 이스케이프 한다

$str =~ s/%([0-9A-Fa-f][0-9A-Fa-f]) /pack('H2', $1) /eg;

내가 벤치마크를 취해 조사한 마지막으로는, 상기와 같이 URI 이스케이프·안 이스케이프 한다 방법이제일 실행 속도가 빠른이지요. 이외의 방법으로서는 unpack 함수를 사용하지 않고 sprintf 함수와 ord 함수(을)를 사용한다든가, pack 함수를 포맷 'H2' 로 사용하지 않고 hex 함수와 chr 함수, 혹은, hex 함수와 pack 함수를 포맷 'C' 로 사용한다든가, 수식자 i 를 사용한다든가, {2} 를 사용한다든가 여러 가지 있습니다만, 특별히 쓸 필요는 없을 것입니다. 또,'%A5%A8%A5%B9%A5%B1%A1%BC%A5%D7' (와)과 같이 알파벳을 대문자로 변환해도 괜찮습니다만, 그 경우는 sprintf 함수와 ord 함수를 사용한 방법이 되어, 처리가 늦어집니다.

또, 해시와연산자 ||= (을)를 사용해, 다음과 같이 계산 결과를 재이용하는 방법이 있습니다만, CGI 등으로 사용한다 정도에서는 대부분의 경우 상기의 스크립트 보다늦은이지요. 

# $str 를 URI 이스케이프 한다(재이용판)

$str =~ s/(\W) /$escape{$1} ||= '%' .  unpack('H2', $1) /eg;

# $str 를 URI 안 이스케이프 한다(재이용판)

$str =~ s/%([0-9A-Fa-f][0-9A-Fa-f]) /$unescape{$1} ||= pack('H2', $1) /eg;

재이용판이 늦은 이유는, 재이용하려고 하는 계산 부분, 즉, '%' . unpack('H2', $1) 나 pack('H2', $1) 하지만 그만큼 늦은 처리는 아니기 때문입니다. 이 부분이 늦은 처리인 경우에는, 한 번 계산한 결과를 몇차례 재이용하는 것으로 충분히 효과가 나옵니다만, 이번 경우와 같이 그만큼 늦은 처리가 아닌 경우에는, 해시를 사용하거나 ||= 에 의한 연산의 오버 헤드를 위해서(때문에) 반대로 늦어져 버립니다. 내가 벤치마크를 취해 조사했는데, URI 안 이스케이프의 재이용판에서는재이용율700%정도로, 즉, 한 번 계산한 모든 결과를 7회재이용했을 무렵으로부터 간신히 효과가 나오기 시작한다고 하는 정도였습니다.

반대로 말하면, 대량의 문장을 처리하려고 했을 경우에는 효과가 있다고 하는 것 입니다만, 그러한 경우는 다음과 같이 미리 변환 테이블을 준비해 둔다 (분)편이실행 속도가 빠르다입니다. 

# $str 를 URI 이스케이프 한다(변환 테이블판)

foreach $i (0x00 .. 0xFF) {
  $escape{chr($i)} = sprintf('%%%02x', $i);
}

$str =~ s/(\W) /$escape{$1}/g;

# $str 를 URI 안 이스케이프 한다(변환 테이블판)

foreach $i (0x00 .. 0xFF) {
  $unescape{sprintf('%02x', $i)} = chr($i);
  $unescape{sprintf('%02X', $i)} = chr($i);
}

$str =~ s/%([0-9A-Fa-f][0-9A-Fa-f]) /$unescape{$1}/g;

변환 테이블판에서는 최초로 변환 테이블을 준비한다고 하는 사전 처리가 필요하게 됩니다만, 변환 그 자체는 수식자 e 하지만 없어져, 캐릭터 라인 전개에만 되므로 가장 실행 속도가 빠릅니다.

URI 이스케이프의 대상이 되는 문자입니다만, 상기의 스크립트에서는 단순궎게 \W 로 하고 궶;궫윱求? 그러나, 이것은 엄밀하게는URI 이스케이프의 필요가 궞귉 문자까지도 URI 이스케이프해 버립니다. 반드시URI 이스케이프해야 XX는 문자는 RFC 2396 ( 일본어 번역 )으로 unreserved 로서 정의XX고 XX 문자 이외에 XX니다. unreserved 이외의 문자만을URI 이스케이프귞궴 스크립트는 이하와 같이 뎹니다. 

# $str 를 URI 이스케이프 뛩다(필요 최소한판)

$str =~ s/([^a-zA-Z0-9_.!~*'()-])/'%' .  unpack('H2', $1) /eg;

여기에서 앞은 CGI 나 URI 특유의 이야기가 됩니다.

URI 이스케이프하려면 , 「RFC 2396으로 URI 문자로서 사용할 수 있는 문자 uric 로서 정의되고 있는 것 이외를 이스케이프 궴면 궞기 때문에, 모듈 URI::Escape 의 uri_escape 함수를 사용해, 정규 표현 [;\/? :@&=+\$, A-Za-z0-9\-_.!~*'()] 그리고 표현되는 문자 이외를 이스케이프 하면 된다」라고 하는 이야기가 있습니다만, 이것은실수입니다. 정확하게는, 어떤 의미로는 그것으로 좋습니다만, 아마 CGI 를 쓰는 사람에게 있어서는 대부분의 경우 실수지요. uri_escape 함수가 궋려 하고 XX, URI 를 입력으로 했을 때에 URI 문자이외의 문자를 이스케이프 렅다 것궢귗;궣, CGI 를 뿀 사람이 하등의 값을 이스케이프 하려고 궘궠 것으로는 의미가 궣;. 예를 들어, $value = 'A&B=C'; 때, print "http://foo.bar/cgi-bin/hoge.cgi? value=$value"; (으)로 깚을 생각딖면 어떻게 된다고 생각합니까? uri_escape 함수를 사용해 $value 를 이스케이프 해도 & 나 = (은)는 URI 문자이므로 이스케이프는 되지 않습니다. 이 결과, value=A 와 B=C 라고 한다 2개(살)을 & 로 연결하고 있다고 해석되어 버립니다. 실은 uri_escape 함수는제 2 인수로 변환 대상으로 하는 문자를 줄 수가 있습니다. 다만, 하고 있는 내용은 위에 썼다 스크립트와 같은 것이므로, 일부러 표준이 아닌모듈 URI::Escape 를 인스톨 해 사용할 것도 없을 것입니다.

다음에, 스페이스와 + 의 상호 변환의 이야기를 합니다. CGI 에 어떠한 데이터를 건네주는 방법으로서는, FORM 의 GET 또는 POST 를 사용하는 방법과 커멘드 라인 인수로서 건네주는 방법의 2개가 있습니다. 이 2개(살)방법에서는 각각 스페이스와 + 의 상호 변환이 얘기가 다르고 있습니다. FORM 의 GET 또는 POST 를 사용하는 방법에 대해서는 HTML 4.0 ( 일본어 번역 )의 17.13. 4 Form content types 에 content types 가 디폴트의 application/x-www-form-urlencoded 때의 encode 방법으로서 쓰여져 있습니다. 커멘드 라인 인수로서 건네주는 방법으로 붙어 CGI/1. 1 의 5. The CGI Script Command Line 에 쓰여져 있습니다.

application/x-www-form-urlencoded 에서의 encode에서는 control names 와 values 의 스페이스는 + 으로 변환해, 그 이외의 reserved character를 %HH 의 형식에 URI 이스케이프섬 . 그리고, controle names 와 values 를 = 로 단락지은 조로 해, 그 조 (을)를 & 로 단락지어 늘어놓습니다. 즉, 스페이스는 + (으)로 변환해, 그 이외의 reserved character를 URI 이스케이프한 다음, name1=value1&name2=value2 그렇다고 하는 것 같은 형식으로 하는 것입니다. control names 나 values 에 대해서 행하는 문자 처리 부분은 다음과 같이 됩니다. 

# $str 에 대해 encode의 문자 처리 부분을 행한다

$str =~ s/([^\w ])/'%' .  unpack('H2', $1) /eg;
$str =~ tr/ /+/;

스페이스는 + 으로 변환하지 않으면 안 되기 때문에, URI 이스케이프한 다음에 s/%20/+/g; 과 재차 변환 다시 하는 방법도 있습니다만, 이 스크립트와 같이 스페이스에 대해서 불필요한 처리를 행하지 않게 한 (분)편이실행 속도가 빠른입니다. 

# $str 에 대해 디코드의 문자 처리 부분을 행한다

$str =~ tr/+/ /;
$str =~ s/%([0-9A-Fa-f][0-9A-Fa-f]) /pack('H2', $1) /eg;

먼저 URI 안 이스케이프해 버리면(자),+ 에 변환되고 있는 스페이스와 구별이 가지 않게 되므로, 그 전에 + (을)를 스페이스에 되돌려 둡니다. 이 때 $str =~ s/\+/ /g; 라고 해도 가능합니다만, 문자 단위의 변환이므로실행 속도가 빠르다 tr 함수를 사용합니다.

세상 일반으로 사용되고 있는 URL encode라고 하는 것이 무엇을 가리키고 있는지 나에게는 잘 모릅니다만, application/x-www-form-urlencoded 에서의 encode를 URL encode라고 말한다면, reserved character를 %HH 의 형식으로 변환하는 URI 이스케이프의 처리 만을 가리켜 URL encode라고 말하는 것은실수에 . 만약,URI 이스케이프 를 URL encode와 말한다면, 스페이스를 + (으)로 변환하지 않으면 안 된다고 하는 것은실수이 됩니다.

한편, 커멘드 라인 인수로서 건네주는 방법입니다만, 이 방법의 서식은 search-string = search-word *( "+" search-word ) 되고 있습니다. 구체적인 예로 말하면, http://foo.bar/cgi-bin/hoge.cgi? arg1+arg2+arg3 와 같이 됩니다. 이 때스페이스를 + 로 변환한다고 한다 이야기는 어디에도 없습니다. search-string 끼리를 단락짓고 있는 + 은 최초부터 + 에서 만나며, 스페이스를 변환한 것 (은)는 아닙니다. 만약,search-string 에 스페이스가 포함되어 있었을 경우에는, 그 외의 reserved character와 같이 URI 이스케이프되게 되므로 %20 에 변환되게 됩니다. 스페이스를 틀려 + 로 변환해 버리면(자), 예를 들어 $value = 'A B C'; 때, 이것을 CGI 의 인수로서 건네주려고 print "http://foo.bar/cgi-bin/hoge.cgi? $value"; (으)로 하는 것을 생각하면(자), http://foo.bar/cgi-bin/hoge.cgi? A+B+C 되어, 이 때 hoge.cgi 는 3개의 인수 'A','B', 'C' 를 받게 되어 버립니다. 이것은 http://foo.bar/cgi-bin/hoge.cgi? A%20B%20C (으)로 하는 것이 정답이 됩니다.

커멘드 라인 인수로서 건네주는 방법에서는 스페이스가 + 에 변환되고 있다 것은 아니기 때문에, 받은 옆에서 + 를 스페이스에 되돌리는 것 같은 일을 해선 안 된다고 하는 것이 됩니다. 커멘드 라인 인수로서 건네주는 방법에서도 QUERY_STRING 로부터 query 부분, 즉, ? 이후의 부분을 취득할 수가 있습니다. 만약, FORM 의 GET 또는 POST 를 사용하는 방법과 커멘드 라인 인수로서 건네주는 방법의 어디에서 데이터가 건네받는지 모르는 경우에, QUERY_STRING 로부터 데이터를 받아 처리하기 위해서는, + (을)를 스페이스에 변환해야할 것인가 변환해서는 안되는 것인지 판단할 필요가 있습니다. 판단하는 방법은 간단해,QUERY_STRING 에 = 하지만 포함되어 있는지 어떤지를 조사합니다. 만약 포함되어 있으면, 그것은 application/x-www-form-urlencoded 에서의 encode 를 하고 있다 됩니다. 포함되지 않으면, 커멘드 라인 인수로서 데이터가 건네받은 것이 됩니다.

탑에

개행 코드를 통일한다

s/\x0D\x0A|\x0D|\x0A/\n/g;

이 스크립트는 Windows(DOS), Mac, UNIX 의 몇개의 플랫폼의 개 행 코드를 자플랫폼의 개행 코드에 통일합니다. 개행 코드는 Windows(DOS)에서는 \x0D\x0A, Mac에서는 \x0D, UNIX 에서는 \x0A 이므로, 이것들 모든 개행 코드에 대응하려면 \x0D\x0A|\x0D|\x0A 로 할 필요가 있습니다. 이 때 차례는 \x0D\x0A (을)를 반드시 최초로 하지 않으면 안됩니다.

개행 코드를 통일하기 위해서 s/\r\n|\r/\n/g; (이)라고 쓰는 것은실수입니다. 이