MIME/Charset/Jcode.pm


=head1 NAME

Message::MIME::Charset::Jcode --- Japanese Coding Systems Support
with jcode.pl and/or Jcode.pm for Message::* Perl Modules

=head1 DESCRIPTION

Message::* therselves don't convert coding systems of parts of
messages, but have mechanism to define to call external functions.
This module provides such macros for Japanese coding systems,
supported by jcode.pl, Jcode.pm and/or other modules.

=head1 USAGE

  use Message::MIME::Charset::Jcode $module_name;

where $module_name is name of module.  List of it is shown below:

=over 4

=item 'jcode.pl'

jcode.pl L<lt>http://srekcah.org/jcode/>

=item 'Jcode' or 'Jcode.pm'

Jcode.pm L<lt>http://openlab.ring.gr.jp/Jcode/index-j.html>

=item 'NKF' or 'NKF.pm'

Network Kanji Filter (Perl module version)
L<lt>http://bw-www.ie.u-ryukyu.ac.jp/~kono/software.html>

=item 'Unicode::Japanese' or 'Unicode::Japanese.pm'

Unicode::Japanese L<lt>http://tech.ymirlink.co.jp/>

=back

When this module is C<use>d multiple times with different
conversion module name, latest one is used.  For example,

  use Message::MIME::Charset::Jcode 'jcode.pl';
  use Message::MIME::Charset::Jcode 'Jcode';

results to instruct to use Jcode.pm.

  use Message::MIME::Charset::Jcode 'Jcode';
  use Message::MIME::Charset::Jcode 'jcode.pl';

This example code leads a bit different result.  Jcode.pm can 
treat UTF-8, but jcode.pl cann't.  So convertion from/to UTF-8
is done by Jcode.pm.  But between other coding systems such as EUC-JP
E<lt>-E<gt> Shift JIS, jcode.pl is used.

Note that this module does not support Encode modules available
with Perl 5.7 or later.  It will be supported by
Message::MIME::Charset::Encode.

=cut

package Message::MIME::Charset::Jcode;
use strict;
use vars qw(%CODE $VERSION);
$VERSION=do{my @r=(q$Revision: 1.2 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};

require Message::Util;
require Message::MIME::Charset;

=head1 CODING SYSTEMS NAMES

These names can be used as the value of L</VARIABLES>.
(These name are NOT same as MIME charset name, which is acutually
written down in message header fields.)

=over 4

=item C<euc>

Japanese EUC.  (MIME: euc-jp)

=item C<jis>

7bit ISO/IEC 2022, so-called junet code.  ASCII, JIS X 0201 Roman,
JIS X 0201 Katakana, JIS X 0208, JIS X 0212 are supported by
jcode.pl and Jcode.pm.  ISO-2022-JP, ISO-2022-JP-1 are subsets of
junet code.

=item C<sjis>

Shift JIS.  (MIME: Shift_JIS)

=item C<utf8>

UTF-8.  (MIME: UTF-8)  This coding system is not supported by jcode.pl
and NKF.pm.

=item C<ucs2>

UCS-2 (or Unicode without surrogate pairs) big endian (network
byte order).  This coding system is not supported by jcode.pl
and NKF.pm.

=back

=head1 VARIABLES

=over 4

=item $Messag::MIME::Charset::Jcode::CODE{internal}

Internal coding system.  You can get strings written in this
coding system from Message::* Perl modules.  (Default: C<euc>)

=item $Messag::MIME::Charset::Jcode::CODE{input}

Coding system of input string.  (Default: auto-detect)

=item $Messag::MIME::Charset::Jcode::CODE{output}

Coding system of output string.  (Default: C<jis>)

=back

=cut

$CODE{internal} = 'euc';        ## default: 'euc' / 'utf8' (Unicode::Japanese)
$CODE{input} = '';      ## default: auto-detect
$CODE{output} = 'jis';  ## default: 'jis'

sub import ($;%) {
  shift;
  for (@_) {
    if ($_ eq 'jcode.pl') {
      require 'jcode.pl';
      Message::MIME::Charset::make_charset ('*default' =>
        encoder => sub { jcode::to ($CODE{output},   $_[1], $CODE{internal}) },
        decoder => sub { jcode::to ($CODE{internal}, $_[1], $CODE{input}) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('iso-2022-jp' =>
        encoder => sub {
          my $s = jcode::jis ($_[1], $CODE{internal});
          ($s, iso_2022_mime_charset_name ($s));
        },
        decoder => sub { jcode::to ($CODE{internal}, $_[1], 'jis') },
        mime_text       => 1,
        cte_7bit_preferred      => 'base64',
      );
      Message::MIME::Charset::make_charset ('euc-jp' =>
        encoder => sub {
          my $s = jcode::euc ($_[1], $CODE{internal});
          ($s, euc_japan_mime_charset_name ($s));
        },
        decoder => sub { jcode::to ($CODE{internal}, $_[1], 'euc') },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset (shift_jis =>
        encoder => sub {
          my $s = jcode::sjis ($_[1], $CODE{internal});
          ($s, shift_jis_mime_charset_name ($s));
        },
        decoder => sub { jcode::to ($CODE{internal}, $_[1], 'sjis') },
        mime_text       => 1,
      );
    } elsif ($_ eq 'Jcode' || $_ eq 'Jcode.pm') {
      require Jcode;
      Message::MIME::Charset::make_charset ('*default' =>
        encoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{output}, $CODE{internal}); $s },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, $CODE{input}); $s },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('iso-2022-jp' =>
        encoder => sub {
          my $s = Jcode->new ($_[1], $CODE{internal})->jis; ## ->iso_2022_jp;
          ($s, iso_2022_mime_charset_name ($s));
        },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'jis'); $s },
        mime_text       => 1,
        cte_7bit_preferred      => 'base64',
      );
      Message::MIME::Charset::make_charset ('euc-jp' =>
        encoder => sub {
          my $s = Jcode->new ($_[1], $CODE{internal})->euc;
          ($s, euc_japan_mime_charset_name ($s));
        },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'euc'); $s },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset (shift_jis =>
        encoder => sub {
          my $s = Jcode->new ($_[1], $CODE{internal})->sjis;
          ($s, shift_jis_mime_charset_name ($s));
        },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'sjis'); $s },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('utf-8' =>
        encoder => sub { Jcode->new ($_[1], $CODE{internal})->utf8 },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'utf8'); $s },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('ucs-2be' =>
        encoder => sub { Jcode->new ($_[1], $CODE{internal})->ucs2 },
        decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'ucs2'); $s },
      );
      Message::MIME::Charset::make_charset ('ucs-2' => alias_of => 'ucs-2be');
      Message::MIME::Charset::make_charset ('utf-16' => alias_of => 'ucs-2');
      Message::MIME::Charset::make_charset ('utf-16be' => alias_of => 'ucs-2be');
    } elsif ($_ eq 'NKF' || $_ eq 'NKF.pm') {
      unless ($NKF::VERSION) {
        eval { use NKF } or Carp::croak ("Message::MIME::Charset::Jcode: NKF: $@");
      }
      Message::MIME::Charset::make_charset ('*default' =>
        encoder => sub { nkf ( "-".    substr ($CODE{output},   0, 1)
                            . " -".uc (substr ($CODE{internal}, 0, 1)), $_[1] ) },
        decoder => sub { nkf ( "-".    substr ($CODE{internal}, 0, 1)
                            . " -".uc (substr ($CODE{input},    0, 1)), $_[1] ) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('iso-2022-jp' =>
        encoder => sub {
          my $s = nkf ( "-j -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
          ($s, iso_2022_mime_charset_name ($s));
        },
        decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -J", $_[1] ) },
        mime_text       => 1,
        cte_7bit_preferred      => 'base64',
      );
      Message::MIME::Charset::make_charset ('euc-jp' =>
        encoder => sub {
          my $s = nkf ( "-e -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
          ($s, euc_japan_mime_charset_name ($s));
        },
        decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -E", $_[1] ) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset (shift_jis =>
        encoder => sub {
          my $s = nkf ( "-s -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
          ($s, shift_jis_mime_charset_name ($s));
        },
        decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -S", $_[1] ) },
        mime_text       => 1,
      );
    } elsif ($_ eq 'Unicode::Japanese' || $_ eq 'Unicode::Japanese.pm') {
      require Unicode::Japanese;
      $CODE{internal} = 'utf8';
      Message::MIME::Charset::make_charset ('*default' =>
        ## Very tricky:-)
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->conv ($CODE{output}) },
        decoder => sub { Unicode::Japanese->new ($_[1], $CODE{input} || 'auto')->conv ($CODE{internal}) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('iso-2022-jp' =>
        encoder => sub {
          my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->jis;
          ($s, iso_2022_mime_charset_name ($s));
        },
        decoder => sub { Unicode::Japanese->new ($_[1], 'jis')->conv ($CODE{internal}) },
        mime_text       => 1,
        cte_7bit_preferred      => 'base64',
      );
      Message::MIME::Charset::make_charset ('euc-jp' =>
        encoder => sub {
          my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->euc;
          ($s, euc_japan_mime_charset_name ($s));
        },
        decoder => sub { Unicode::Japanese->new ($_[1], 'euc')->conv ($CODE{internal}) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset (shift_jis =>
        encoder => sub {
          my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->sjis;
          ($s, shift_jis_mime_charset_name ($s));
        },
        decoder => sub { Unicode::Japanese->new ($_[1], 'sjis')->conv ($CODE{internal}) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('utf-8' =>
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf8 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf8')->conv ($CODE{internal}) },
        mime_text       => 1,
      );
      Message::MIME::Charset::make_charset ('ucs-2' =>
        encoder => sub { "\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs2 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'ucs2')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('ucs-2be' =>
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs2 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'ucs2')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('utf-16' =>
        encoder => sub { "\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf16')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('utf-16be' =>
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf16-ge')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('utf-16le' =>
        #encoder        => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf16-le')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('ucs-2le' => alias_of => 'utf-16le');
      Message::MIME::Charset::make_charset ('utf-32' =>
        encoder => sub { "\x00\x00\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf32')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('ucs-4' =>
        encoder => sub { "\x00\x00\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'ucs4')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('utf-32be' =>
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf32-ge')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('ucs-4be' =>
        encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'ucs4')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('utf-32le' =>
        #encoder        => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf32 },
        decoder => sub { Unicode::Japanese->new ($_[1], 'utf32-le')->conv ($CODE{internal}) },
      );
      Message::MIME::Charset::make_charset ('ucs-4le' => alias_of => 'utf-32le');
    } else {
      Carp::croak "Jcode: $_: Module not supported";
    }
    ## Defines common alias names
    Message::MIME::Charset::make_charset (jis => alias_of => 'iso-2022-jp');
    Message::MIME::Charset::make_charset (junet => alias_of => 'iso-2022-jp');
    Message::MIME::Charset::make_charset ('junet-code' => alias_of => 'iso-2022-jp');
    Message::MIME::Charset::make_charset ('iso-2022-jp-1' => alias_of => 'iso-2022-jp');
    Message::MIME::Charset::make_charset ('iso-2022-jp-3' => alias_of => 'iso-2022-jp');
    Message::MIME::Charset::make_charset ('x-iso-2022-jp-3' => alias_of => 'iso-2022-jp-3');
    Message::MIME::Charset::make_charset ('iso-2022-jp-3-plane1' => alias_of => 'iso-2022-jp-3');
    Message::MIME::Charset::make_charset (euc => alias_of => 'euc-jp');
    Message::MIME::Charset::make_charset (euc_jp => alias_of => 'euc-jp');
    Message::MIME::Charset::make_charset ('x-euc' => alias_of => 'euc-jp');
    Message::MIME::Charset::make_charset ('x-euc-jp' => alias_of => 'euc-jp');
    Message::MIME::Charset::make_charset ('euc-jisx0213' => alias_of => 'euc-jp');
    Message::MIME::Charset::make_charset ('x-euc-jisx0213' => alias_of => 'euc-jisx0213');
    Message::MIME::Charset::make_charset ('euc-jisx0213-plane1' => alias_of => 'euc-jisx0213');
    Message::MIME::Charset::make_charset ('x-euc-jisx0213-packed' => alias_of => 'euc-jisx0213');
    Message::MIME::Charset::make_charset (sjis => alias_of => 'shift_jis');
    Message::MIME::Charset::make_charset ('shift-jis' => alias_of => 'shift_jis');
    Message::MIME::Charset::make_charset ('x-sjis' => alias_of => 'shift_jis');
    Message::MIME::Charset::make_charset (shift_jisx0213 => alias_of => 'shift_jis');
    Message::MIME::Charset::make_charset ('shift-jisx0213' => alias_of => 'shift_jisx0213');
    Message::MIME::Charset::make_charset ('x-shift_jisx0213' => alias_of => 'shift_jisx0213');
    Message::MIME::Charset::make_charset ('x-shift-jisx0213' => alias_of => 'shift_jisx0213');
    Message::MIME::Charset::make_charset ('shift_jisx0213-plane1' => alias_of => 'shift_jisx0213');
    Message::MIME::Charset::make_charset (jis_x0201 => alias_of => 'shift_jis');
    Message::MIME::Charset::make_charset (x0201 => alias_of => 'jis_x0201');
  }
}

## Returns MIME charset of 7bit ISO 2022 (*junet* family)
sub iso_2022_mime_charset_name ($) {
  my $s = shift;
          if ($s =~ /\x1B\x28[^BJ]|\x1B\x24\x28[^D]|\x1B\x24[^\x28\x40B]/) {
            if ($s =~ /\x1B\x28[^B]|\x1B\x24[^\x28]|\x1B\x24\x28[^OP]/) {
              (charset => 'junet');
            } elsif ($s =~ /\x1B\x24\x28P/) {
              (charset => 'iso-2022-jp-3');
            } else {
              (charset => 'iso-2022-jp-3-plane1');
            }
          } elsif ($s =~ /\x1B\x24\x28D/) {
            (charset => 'iso-2022-jp-1');
          } elsif ($s =~ /\x1B\x28[BJ]|\x1B\x24[\x40B]/) {
            (charset => 'iso-2022-jp');
          } else {
            (charset => 'us-ascii');
          }
}

## Returns MIME charset of 8bit ISO 2022 (EUC-Japan)
sub euc_japan_mime_charset_name ($) {
  my $s = shift;
  if ($s =~ /[\x80-\xFF]/) {
    if ($s =~ /\x8F[\xA1\xA3-\xA5\xA8\xAC-\xAF\xEE-\xFE][\xA1-\xFE]/) {
      if ($s =~ /\x8F[\xA2\xA6\xA7\xA9-\xAB\xB0-\xED][\xA1-\xFE]/) {
      ## JIS X 0213 plane 2 + JIS X 0212
        (charset => 'x-euc-jisx0213-packed');
      } else {
        (charset => 'euc-jisx0213');
      }
    } elsif ($s =~ /(?<!\x8F)   ## Not G3 character
                    (?: ## JIS X 0213:2000
                       [\xA9-\xAF\xF5-\xFE][\xA1-\xFE]
                      |\xA2[\xAF-\xB9\xC2-\xC9\xD1-\xDB\xE9-\xF1\xFA-\xFD]
                      |\xA3[\xA1-\xAF\xBA-\xC0\xDB-\xE0\xFB-\xFE]
                      |\xA4[\xF4-\xFE]|\xA5[\xF7-\xFE]
                      |\xA6[\xB9-\xC0\xD9-\xFE]|\xA7[\xC2-\xD0\xF2-\xFE]
                      |\xA8[\xC1-\xFE]|\xCF[\xD4-\xFE]|\xF4[\xA7-\xFE]
                    )
                    (?=(?:[\xA1-\xFE][\xA1-\xFE])*(?:[\x00-\xA0FF]|\z))/x) {
      if ($s =~ /\x8F/) {       ## JIS X 0213 plane 1 + JIS X 0212
        (charset => 'x-euc-jisx0213-packed');
      } else {
        (charset => 'euc-jisx0213-plane1');
      }
    } else {
      (charset => 'euc-jp');
    }
  } else {
    (charset => 'us-ascii');
  }
}

## Returns MIME charset of 8bit ISO 2022 (EUC-Japan)
sub shift_jis_mime_charset_name ($) {
  my $s = shift;
  if ($s =~ /[\x80-\xFF]/) {
    if ($s =~ /
                  (?:\G|[\x00-\x3F\x7F])
                  (?:[\x81-\x9F\xE0-\xFC][\x40-\x7E\x80-\xFC]
                    |[\x40-\x7E\xA1-\xDF])*
               [\xF0-\xFC][\x40-\x7E\x80-\xFC]
    /x) {
      (charset => 'shift_jisx0213');
    } elsif ($s =~ /
                  (?:\G|[\x00-\x3F\x7F])
                  (?:[\x81-\x9F\xE0-\xFC][\x40-\x7E\x80-\xFC]
                    |[\x40-\x7E\xA1-\xDF])*
              (?:
               [\x85-\x87\xEB-\xEF][\x40-\x7E\x80-\xFC]
              |\x81[\xAD-\xB7\xC0-\xC7\xCF-\xD9\xE9-\xEF\xF8-\xFB]
              |\x82[\x40-\x4E\x59-\x5F\x7A-\x80\x9B-\x9E\xF2-\xFC]
              |\x83[\x97-\x9E\xB7-\xBE\xD7-\xFC]
              |\x84[\x61-\x6F\x72-\x9E\xBF-\xFC]
              |\x88[\x40-\x9E]|\x98[\x73-\x9E]|\xEA[\xA5-\xFC]
              )
    /x) {
      (charset => 'shift_jisx0213-plane1');
    } else {
      (charset => 'shift_jis');
    }
  } elsif ($s =~ /[\x5C\x7E]/) {
    (charset => 'jis_x0201');
  } else {
    (charset => 'us-ascii');
  }
}

=head1 EXAMPLE

  ## Uses jcode.pl.  Input is euc-japan, output is junet.
  use Message::MIME::Charset::Jcode 'jcode.pl';
        ## You don't have to do {require 'jcode.pl'}.
  $Message::MIME::Charset::Jcode::CODE{input} = 'euc';
  $Message::MIME::Charset::Jcode::CODE{output} = 'jis';
  require Message::Entity;
  #...

  ## Uses Jcode.pm.
  use Message::MIME::Charset::Jcode 'Jcode';
  require Message::Entity;
  #...

  ## Uses jcode.pl, but also Jcode.pm for Unicode encodings.
  ## Internal code is UTF-8.
  use Message::MIME::Charset::Jcode 'Jcode';
  use Message::MIME::Charset::Jcode 'jcode.pl';
  $Message::MIME::Charset::Jcode::CODE{internal} = 'utf-8';
  require Message::Entity;
  #...

=head1 SEE ALSO

Message::MIME::Charset

Message::Entity

jcode.pl

Jcode.pm

=head1 LICENSE

Copyright 2002 wakaba E<lt>[email protected]<gt>.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

=head1 CHANGE

See F<ChangeLog>.
$Date: 2002/06/01 05:33:52 $

=cut

1;
1	wakaba	1.1
2			=head1 NAME
3
4			Message::MIME::Charset::Jcode --- Japanese Coding Systems Support
5			with jcode.pl and/or Jcode.pm for Message::* Perl Modules
6
7			=head1 DESCRIPTION
8
9			Message::* therselves don't convert coding systems of parts of
10			messages, but have mechanism to define to call external functions.
11			This module provides such macros for Japanese coding systems,
12	wakaba	1.3	supported by jcode.pl, Jcode.pm and/or other modules.
13
14			=head1 USAGE
15
16			use Message::MIME::Charset::Jcode $module_name;
17
18			where $module_name is name of module. List of it is shown below:
19
20			=over 4
21
22			=item 'jcode.pl'
23
24			jcode.pl L<lt>http://srekcah.org/jcode/>
25
26			=item 'Jcode' or 'Jcode.pm'
27
28			Jcode.pm L<lt>http://openlab.ring.gr.jp/Jcode/index-j.html>
29
30			=item 'NKF' or 'NKF.pm'
31
32			Network Kanji Filter (Perl module version)
33			L<lt>http://bw-www.ie.u-ryukyu.ac.jp/~kono/software.html>
34
35			=item 'Unicode::Japanese' or 'Unicode::Japanese.pm'
36
37			Unicode::Japanese L<lt>http://tech.ymirlink.co.jp/>
38
39			=back
40
41			When this module is C<use>d multiple times with different
42			conversion module name, latest one is used. For example,
43
44			use Message::MIME::Charset::Jcode 'jcode.pl';
45			use Message::MIME::Charset::Jcode 'Jcode';
46
47			results to instruct to use Jcode.pm.
48
49			use Message::MIME::Charset::Jcode 'Jcode';
50			use Message::MIME::Charset::Jcode 'jcode.pl';
51
52			This example code leads a bit different result. Jcode.pm can
53			treat UTF-8, but jcode.pl cann't. So convertion from/to UTF-8
54			is done by Jcode.pm. But between other coding systems such as EUC-JP
55			E<lt>-E<gt> Shift JIS, jcode.pl is used.
56
57			Note that this module does not support Encode modules available
58			with Perl 5.7 or later. It will be supported by
59			Message::MIME::Charset::Encode.
60	wakaba	1.1
61			=cut
62
63			package Message::MIME::Charset::Jcode;
64			use strict;
65			use vars qw(%CODE $VERSION);
66	wakaba	1.3	$VERSION=do{my @r=(q$Revision: 1.2 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
67	wakaba	1.1
68			require Message::Util;
69			require Message::MIME::Charset;
70
71	wakaba	1.3	=head1 CODING SYSTEMS NAMES
72
73			These names can be used as the value of L</VARIABLES>.
74			(These name are NOT same as MIME charset name, which is acutually
75			written down in message header fields.)
76	wakaba	1.1
77			=over 4
78
79			=item C<euc>
80
81			Japanese EUC. (MIME: euc-jp)
82
83			=item C<jis>
84
85			7bit ISO/IEC 2022, so-called junet code. ASCII, JIS X 0201 Roman,
86			JIS X 0201 Katakana, JIS X 0208, JIS X 0212 are supported by
87			jcode.pl and Jcode.pm. ISO-2022-JP, ISO-2022-JP-1 are subsets of
88			junet code.
89
90			=item C<sjis>
91
92			Shift JIS. (MIME: Shift_JIS)
93
94			=item C<utf8>
95
96	wakaba	1.3	UTF-8. (MIME: UTF-8) This coding system is not supported by jcode.pl
97			and NKF.pm.
98	wakaba	1.1
99			=item C<ucs2>
100
101			UCS-2 (or Unicode without surrogate pairs) big endian (network
102	wakaba	1.3	byte order). This coding system is not supported by jcode.pl
103			and NKF.pm.
104	wakaba	1.1
105			=back
106
107			=head1 VARIABLES
108
109			=over 4
110
111			=item $Messag::MIME::Charset::Jcode::CODE{internal}
112
113			Internal coding system. You can get strings written in this
114			coding system from Message::* Perl modules. (Default: C<euc>)
115
116			=item $Messag::MIME::Charset::Jcode::CODE{input}
117
118			Coding system of input string. (Default: auto-detect)
119
120			=item $Messag::MIME::Charset::Jcode::CODE{output}
121
122			Coding system of output string. (Default: C<jis>)
123
124			=back
125
126			=cut
127
128	wakaba	1.3	$CODE{internal} = 'euc'; ## default: 'euc' / 'utf8' (Unicode::Japanese)
129			$CODE{input} = ''; ## default: auto-detect
130			$CODE{output} = 'jis'; ## default: 'jis'
131	wakaba	1.1
132			sub import ($;%) {
133			shift;
134			for (@_) {
135			if ($_ eq 'jcode.pl') {
136			require 'jcode.pl';
137			Message::MIME::Charset::make_charset ('*default' =>
138			encoder => sub { jcode::to ($CODE{output}, $_[1], $CODE{internal}) },
139			decoder => sub { jcode::to ($CODE{internal}, $_[1], $CODE{input}) },
140			mime_text => 1,
141			);
142			Message::MIME::Charset::make_charset ('iso-2022-jp' =>
143	wakaba	1.2	encoder => sub {
144			my $s = jcode::jis ($_[1], $CODE{internal});
145	wakaba	1.3	($s, iso_2022_mime_charset_name ($s));
146	wakaba	1.2	},
147	wakaba	1.1	decoder => sub { jcode::to ($CODE{internal}, $_[1], 'jis') },
148			mime_text => 1,
149			cte_7bit_preferred => 'base64',
150			);
151			Message::MIME::Charset::make_charset ('euc-jp' =>
152	wakaba	1.2	encoder => sub {
153			my $s = jcode::euc ($_[1], $CODE{internal});
154	wakaba	1.4	($s, euc_japan_mime_charset_name ($s));
155	wakaba	1.2	},
156	wakaba	1.1	decoder => sub { jcode::to ($CODE{internal}, $_[1], 'euc') },
157			mime_text => 1,
158			);
159			Message::MIME::Charset::make_charset (shift_jis =>
160	wakaba	1.2	encoder => sub {
161			my $s = jcode::sjis ($_[1], $CODE{internal});
162	wakaba	1.4	($s, shift_jis_mime_charset_name ($s));
163	wakaba	1.2	},
164	wakaba	1.1	decoder => sub { jcode::to ($CODE{internal}, $_[1], 'sjis') },
165			mime_text => 1,
166			);
167			} elsif ($_ eq 'Jcode' \|\| $_ eq 'Jcode.pm') {
168			require Jcode;
169			Message::MIME::Charset::make_charset ('*default' =>
170			encoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{output}, $CODE{internal}); $s },
171			decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, $CODE{input}); $s },
172			mime_text => 1,
173			);
174			Message::MIME::Charset::make_charset ('iso-2022-jp' =>
175	wakaba	1.2	encoder => sub {
176	wakaba	1.3	my $s = Jcode->new ($_[1], $CODE{internal})->jis; ## ->iso_2022_jp;
177			($s, iso_2022_mime_charset_name ($s));
178	wakaba	1.2	},
179	wakaba	1.1	decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'jis'); $s },
180			mime_text => 1,
181			cte_7bit_preferred => 'base64',
182			);
183			Message::MIME::Charset::make_charset ('euc-jp' =>
184	wakaba	1.2	encoder => sub {
185			my $s = Jcode->new ($_[1], $CODE{internal})->euc;
186	wakaba	1.4	($s, euc_japan_mime_charset_name ($s));
187	wakaba	1.2	},
188	wakaba	1.1	decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'euc'); $s },
189			mime_text => 1,
190			);
191			Message::MIME::Charset::make_charset (shift_jis =>
192	wakaba	1.2	encoder => sub {
193			my $s = Jcode->new ($_[1], $CODE{internal})->sjis;
194	wakaba	1.4	($s, shift_jis_mime_charset_name ($s));
195	wakaba	1.2	},
196	wakaba	1.1	decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'sjis'); $s },
197			mime_text => 1,
198			);
199			Message::MIME::Charset::make_charset ('utf-8' =>
200			encoder => sub { Jcode->new ($_[1], $CODE{internal})->utf8 },
201			decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'utf8'); $s },
202			mime_text => 1,
203			);
204			Message::MIME::Charset::make_charset ('ucs-2be' =>
205			encoder => sub { Jcode->new ($_[1], $CODE{internal})->ucs2 },
206			decoder => sub { my $s = $_[1]; Jcode::convert (\$s, $CODE{internal}, 'ucs2'); $s },
207			);
208			Message::MIME::Charset::make_charset ('ucs-2' => alias_of => 'ucs-2be');
209			Message::MIME::Charset::make_charset ('utf-16' => alias_of => 'ucs-2');
210			Message::MIME::Charset::make_charset ('utf-16be' => alias_of => 'ucs-2be');
211	wakaba	1.3	} elsif ($_ eq 'NKF' \|\| $_ eq 'NKF.pm') {
212			unless ($NKF::VERSION) {
213			eval { use NKF } or Carp::croak ("Message::MIME::Charset::Jcode: NKF: $@");
214			}
215			Message::MIME::Charset::make_charset ('*default' =>
216			encoder => sub { nkf ( "-". substr ($CODE{output}, 0, 1)
217			. " -".uc (substr ($CODE{internal}, 0, 1)), $_[1] ) },
218			decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1)
219			. " -".uc (substr ($CODE{input}, 0, 1)), $_[1] ) },
220			mime_text => 1,
221			);
222			Message::MIME::Charset::make_charset ('iso-2022-jp' =>
223			encoder => sub {
224			my $s = nkf ( "-j -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
225			($s, iso_2022_mime_charset_name ($s));
226			},
227			decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -J", $_[1] ) },
228			mime_text => 1,
229			cte_7bit_preferred => 'base64',
230			);
231			Message::MIME::Charset::make_charset ('euc-jp' =>
232			encoder => sub {
233			my $s = nkf ( "-e -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
234	wakaba	1.4	($s, euc_japan_mime_charset_name ($s));
235	wakaba	1.3	},
236			decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -E", $_[1] ) },
237			mime_text => 1,
238			);
239			Message::MIME::Charset::make_charset (shift_jis =>
240			encoder => sub {
241			my $s = nkf ( "-s -".uc (substr ($CODE{internal}, 0, 1)), $_[1] );
242	wakaba	1.4	($s, shift_jis_mime_charset_name ($s));
243	wakaba	1.3	},
244			decoder => sub { nkf ( "-". substr ($CODE{internal}, 0, 1) . " -S", $_[1] ) },
245			mime_text => 1,
246			);
247			} elsif ($_ eq 'Unicode::Japanese' \|\| $_ eq 'Unicode::Japanese.pm') {
248			require Unicode::Japanese;
249			$CODE{internal} = 'utf8';
250			Message::MIME::Charset::make_charset ('*default' =>
251			## Very tricky:-)
252			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->conv ($CODE{output}) },
253			decoder => sub { Unicode::Japanese->new ($_[1], $CODE{input} \|\| 'auto')->conv ($CODE{internal}) },
254			mime_text => 1,
255			);
256			Message::MIME::Charset::make_charset ('iso-2022-jp' =>
257			encoder => sub {
258			my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->jis;
259			($s, iso_2022_mime_charset_name ($s));
260			},
261			decoder => sub { Unicode::Japanese->new ($_[1], 'jis')->conv ($CODE{internal}) },
262			mime_text => 1,
263			cte_7bit_preferred => 'base64',
264			);
265			Message::MIME::Charset::make_charset ('euc-jp' =>
266			encoder => sub {
267			my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->euc;
268	wakaba	1.4	($s, euc_japan_mime_charset_name ($s));
269	wakaba	1.3	},
270			decoder => sub { Unicode::Japanese->new ($_[1], 'euc')->conv ($CODE{internal}) },
271			mime_text => 1,
272			);
273			Message::MIME::Charset::make_charset (shift_jis =>
274			encoder => sub {
275			my $s = Unicode::Japanese->new ($_[1], $CODE{internal})->sjis;
276	wakaba	1.4	($s, shift_jis_mime_charset_name ($s));
277	wakaba	1.3	},
278			decoder => sub { Unicode::Japanese->new ($_[1], 'sjis')->conv ($CODE{internal}) },
279			mime_text => 1,
280			);
281			Message::MIME::Charset::make_charset ('utf-8' =>
282			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf8 },
283			decoder => sub { Unicode::Japanese->new ($_[1], 'utf8')->conv ($CODE{internal}) },
284			mime_text => 1,
285			);
286			Message::MIME::Charset::make_charset ('ucs-2' =>
287			encoder => sub { "\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs2 },
288			decoder => sub { Unicode::Japanese->new ($_[1], 'ucs2')->conv ($CODE{internal}) },
289			);
290			Message::MIME::Charset::make_charset ('ucs-2be' =>
291			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs2 },
292			decoder => sub { Unicode::Japanese->new ($_[1], 'ucs2')->conv ($CODE{internal}) },
293			);
294			Message::MIME::Charset::make_charset ('utf-16' =>
295			encoder => sub { "\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
296			decoder => sub { Unicode::Japanese->new ($_[1], 'utf16')->conv ($CODE{internal}) },
297			);
298			Message::MIME::Charset::make_charset ('utf-16be' =>
299			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
300			decoder => sub { Unicode::Japanese->new ($_[1], 'utf16-ge')->conv ($CODE{internal}) },
301			);
302			Message::MIME::Charset::make_charset ('utf-16le' =>
303			#encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf16 },
304			decoder => sub { Unicode::Japanese->new ($_[1], 'utf16-le')->conv ($CODE{internal}) },
305			);
306			Message::MIME::Charset::make_charset ('ucs-2le' => alias_of => 'utf-16le');
307			Message::MIME::Charset::make_charset ('utf-32' =>
308			encoder => sub { "\x00\x00\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
309			decoder => sub { Unicode::Japanese->new ($_[1], 'utf32')->conv ($CODE{internal}) },
310			);
311			Message::MIME::Charset::make_charset ('ucs-4' =>
312			encoder => sub { "\x00\x00\xFF\xFE".Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
313			decoder => sub { Unicode::Japanese->new ($_[1], 'ucs4')->conv ($CODE{internal}) },
314			);
315			Message::MIME::Charset::make_charset ('utf-32be' =>
316			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
317			decoder => sub { Unicode::Japanese->new ($_[1], 'utf32-ge')->conv ($CODE{internal}) },
318			);
319			Message::MIME::Charset::make_charset ('ucs-4be' =>
320			encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->ucs4 },
321			decoder => sub { Unicode::Japanese->new ($_[1], 'ucs4')->conv ($CODE{internal}) },
322			);
323			Message::MIME::Charset::make_charset ('utf-32le' =>
324			#encoder => sub { Unicode::Japanese->new ($_[1], $CODE{internal})->utf32 },
325			decoder => sub { Unicode::Japanese->new ($_[1], 'utf32-le')->conv ($CODE{internal}) },
326			);
327			Message::MIME::Charset::make_charset ('ucs-4le' => alias_of => 'utf-32le');
328	wakaba	1.1	} else {
329			Carp::croak "Jcode: $_: Module not supported";
330			}
331	wakaba	1.3	## Defines common alias names
332	wakaba	1.1	Message::MIME::Charset::make_charset (jis => alias_of => 'iso-2022-jp');
333	wakaba	1.2	Message::MIME::Charset::make_charset (junet => alias_of => 'iso-2022-jp');
334	wakaba	1.4	Message::MIME::Charset::make_charset ('junet-code' => alias_of => 'iso-2022-jp');
335	wakaba	1.1	Message::MIME::Charset::make_charset ('iso-2022-jp-1' => alias_of => 'iso-2022-jp');
336			Message::MIME::Charset::make_charset ('iso-2022-jp-3' => alias_of => 'iso-2022-jp');
337			Message::MIME::Charset::make_charset ('x-iso-2022-jp-3' => alias_of => 'iso-2022-jp-3');
338			Message::MIME::Charset::make_charset ('iso-2022-jp-3-plane1' => alias_of => 'iso-2022-jp-3');
339			Message::MIME::Charset::make_charset (euc => alias_of => 'euc-jp');
340			Message::MIME::Charset::make_charset (euc_jp => alias_of => 'euc-jp');
341			Message::MIME::Charset::make_charset ('x-euc' => alias_of => 'euc-jp');
342			Message::MIME::Charset::make_charset ('x-euc-jp' => alias_of => 'euc-jp');
343			Message::MIME::Charset::make_charset ('euc-jisx0213' => alias_of => 'euc-jp');
344			Message::MIME::Charset::make_charset ('x-euc-jisx0213' => alias_of => 'euc-jisx0213');
345			Message::MIME::Charset::make_charset ('euc-jisx0213-plane1' => alias_of => 'euc-jisx0213');
346	wakaba	1.4	Message::MIME::Charset::make_charset ('x-euc-jisx0213-packed' => alias_of => 'euc-jisx0213');
347	wakaba	1.1	Message::MIME::Charset::make_charset (sjis => alias_of => 'shift_jis');
348			Message::MIME::Charset::make_charset ('shift-jis' => alias_of => 'shift_jis');
349			Message::MIME::Charset::make_charset ('x-sjis' => alias_of => 'shift_jis');
350			Message::MIME::Charset::make_charset (shift_jisx0213 => alias_of => 'shift_jis');
351			Message::MIME::Charset::make_charset ('shift-jisx0213' => alias_of => 'shift_jisx0213');
352			Message::MIME::Charset::make_charset ('x-shift_jisx0213' => alias_of => 'shift_jisx0213');
353			Message::MIME::Charset::make_charset ('x-shift-jisx0213' => alias_of => 'shift_jisx0213');
354			Message::MIME::Charset::make_charset ('shift_jisx0213-plane1' => alias_of => 'shift_jisx0213');
355	wakaba	1.2	Message::MIME::Charset::make_charset (jis_x0201 => alias_of => 'shift_jis');
356			Message::MIME::Charset::make_charset (x0201 => alias_of => 'jis_x0201');
357	wakaba	1.1	}
358			}
359
360	wakaba	1.3	## Returns MIME charset of 7bit ISO 2022 (junet family)
361			sub iso_2022_mime_charset_name ($) {
362			my $s = shift;
363			if ($s =~ /\x1B\x28[^BJ]\|\x1B\x24\x28[^D]\|\x1B\x24[^\x28\x40B]/) {
364			if ($s =~ /\x1B\x28[^B]\|\x1B\x24[^\x28]\|\x1B\x24\x28[^OP]/) {
365			(charset => 'junet');
366			} elsif ($s =~ /\x1B\x24\x28P/) {
367			(charset => 'iso-2022-jp-3');
368			} else {
369			(charset => 'iso-2022-jp-3-plane1');
370			}
371			} elsif ($s =~ /\x1B\x24\x28D/) {
372			(charset => 'iso-2022-jp-1');
373			} elsif ($s =~ /\x1B\x28[BJ]\|\x1B\x24[\x40B]/) {
374			(charset => 'iso-2022-jp');
375			} else {
376			(charset => 'us-ascii');
377			}
378	wakaba	1.4	}
379
380			## Returns MIME charset of 8bit ISO 2022 (EUC-Japan)
381			sub euc_japan_mime_charset_name ($) {
382			my $s = shift;
383			if ($s =~ /[\x80-\xFF]/) {
384			if ($s =~ /\x8F[\xA1\xA3-\xA5\xA8\xAC-\xAF\xEE-\xFE][\xA1-\xFE]/) {
385			if ($s =~ /\x8F[\xA2\xA6\xA7\xA9-\xAB\xB0-\xED][\xA1-\xFE]/) {
386			## JIS X 0213 plane 2 + JIS X 0212
387			(charset => 'x-euc-jisx0213-packed');
388			} else {
389			(charset => 'euc-jisx0213');
390			}
391			} elsif ($s =~ /(?<!\x8F) ## Not G3 character
392			(?: ## JIS X 0213:2000
393			[\xA9-\xAF\xF5-\xFE][\xA1-\xFE]
394			\|\xA2[\xAF-\xB9\xC2-\xC9\xD1-\xDB\xE9-\xF1\xFA-\xFD]
395			\|\xA3[\xA1-\xAF\xBA-\xC0\xDB-\xE0\xFB-\xFE]
396			\|\xA4[\xF4-\xFE]\|\xA5[\xF7-\xFE]
397			\|\xA6[\xB9-\xC0\xD9-\xFE]\|\xA7[\xC2-\xD0\xF2-\xFE]
398			\|\xA8[\xC1-\xFE]\|\xCF[\xD4-\xFE]\|\xF4[\xA7-\xFE]
399			)
400			(?=(?:[\xA1-\xFE][\xA1-\xFE])*(?:[\x00-\xA0FF]\|\z))/x) {
401			if ($s =~ /\x8F/) { ## JIS X 0213 plane 1 + JIS X 0212
402			(charset => 'x-euc-jisx0213-packed');
403			} else {
404			(charset => 'euc-jisx0213-plane1');
405			}
406			} else {
407			(charset => 'euc-jp');
408			}
409			} else {
410			(charset => 'us-ascii');
411			}
412			}
413
414			## Returns MIME charset of 8bit ISO 2022 (EUC-Japan)
415			sub shift_jis_mime_charset_name ($) {
416			my $s = shift;
417			if ($s =~ /[\x80-\xFF]/) {
418			if ($s =~ /
419			(?:\G\|[\x00-\x3F\x7F])
420			(?:[\x81-\x9F\xE0-\xFC][\x40-\x7E\x80-\xFC]
421			\|[\x40-\x7E\xA1-\xDF])*
422			[\xF0-\xFC][\x40-\x7E\x80-\xFC]
423			/x) {
424			(charset => 'shift_jisx0213');
425			} elsif ($s =~ /
426			(?:\G\|[\x00-\x3F\x7F])
427			(?:[\x81-\x9F\xE0-\xFC][\x40-\x7E\x80-\xFC]
428			\|[\x40-\x7E\xA1-\xDF])*
429			(?:
430			[\x85-\x87\xEB-\xEF][\x40-\x7E\x80-\xFC]
431			\|\x81[\xAD-\xB7\xC0-\xC7\xCF-\xD9\xE9-\xEF\xF8-\xFB]
432			\|\x82[\x40-\x4E\x59-\x5F\x7A-\x80\x9B-\x9E\xF2-\xFC]
433			\|\x83[\x97-\x9E\xB7-\xBE\xD7-\xFC]
434			\|\x84[\x61-\x6F\x72-\x9E\xBF-\xFC]
435			\|\x88[\x40-\x9E]\|\x98[\x73-\x9E]\|\xEA[\xA5-\xFC]
436			)
437			/x) {
438			(charset => 'shift_jisx0213-plane1');
439			} else {
440			(charset => 'shift_jis');
441			}
442			} elsif ($s =~ /[\x5C\x7E]/) {
443			(charset => 'jis_x0201');
444			} else {
445			(charset => 'us-ascii');
446			}
447	wakaba	1.3	}
448
449	wakaba	1.1	=head1 EXAMPLE
450
451			## Uses jcode.pl. Input is euc-japan, output is junet.
452			use Message::MIME::Charset::Jcode 'jcode.pl';
453			## You don't have to do {require 'jcode.pl'}.
454			$Message::MIME::Charset::Jcode::CODE{input} = 'euc';
455			$Message::MIME::Charset::Jcode::CODE{output} = 'jis';
456			require Message::Entity;
457			#...
458
459			## Uses Jcode.pm.
460			use Message::MIME::Charset::Jcode 'Jcode';
461			require Message::Entity;
462			#...
463
464			## Uses jcode.pl, but also Jcode.pm for Unicode encodings.
465			## Internal code is UTF-8.
466			use Message::MIME::Charset::Jcode 'Jcode';
467			use Message::MIME::Charset::Jcode 'jcode.pl';
468			$Message::MIME::Charset::Jcode::CODE{internal} = 'utf-8';
469			require Message::Entity;
470			#...
471
472			=head1 SEE ALSO
473
474			Message::MIME::Charset
475
476			Message::Entity
477
478			jcode.pl
479
480			Jcode.pm
481
482			=head1 LICENSE
483
484			Copyright 2002 wakaba E<lt>[email protected]<gt>.
485
486			This program is free software; you can redistribute it and/or modify
487			it under the terms of the GNU General Public License as published by
488			the Free Software Foundation; either version 2 of the License, or
489			(at your option) any later version.
490
491			This program is distributed in the hope that it will be useful,
492			but WITHOUT ANY WARRANTY; without even the implied warranty of
493			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
494			GNU General Public License for more details.
495
496			You should have received a copy of the GNU General Public License
497			along with this program; see the file COPYING. If not, write to
498			the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
499			Boston, MA 02111-1307, USA.
500
501			=head1 CHANGE
502
503			See F<ChangeLog>.
504	wakaba	1.3	$Date: 2002/06/01 05:33:52 $
505	wakaba	1.1
506			=cut
507
508			1;