File Coverage

blib/lib/I18N/Charset.pm

Criterion	Covered	Total	%
statement	171	210	81.4
branch	78	100	78.0
condition	16	24	66.6
subroutine	31	35	88.5
pod	16	16	100.0
total	312	385	81.0

# $rcs = ' $Id: Charset.pm,v 1.414 2015-02-02 19:49:14 Martin Exp $ ' ;

package I18N::Charset;

use strict;
use warnings;

require 5.005;

use base 'Exporter';
use Carp;

=head1 NAME

I18N::Charset - IANA Character Set Registry names and Unicode::MapUTF8
(et al.) conversion scheme names

=head1 SYNOPSIS

  use I18N::Charset;

  $sCharset = iana_charset_name('WinCyrillic');
  # $sCharset is now 'windows-1251'
  $sCharset = umap_charset_name('Adobe DingBats');
  # $sCharset is now 'ADOBE-DINGBATS' which can be passed to Unicode::Map->new()
  $sCharset = map8_charset_name('windows-1251');
  # $sCharset is now 'cp1251' which can be passed to Unicode::Map8->new()
  $sCharset = umu8_charset_name('x-sjis');
  # $sCharset is now 'sjis' which can be passed to Unicode::MapUTF8->new()
  $sCharset = libi_charset_name('x-sjis');
  # $sCharset is now 'MS_KANJI' which can be passed to `iconv -f $sCharset ...`
  $sCharset = enco_charset_name('Shift-JIS');
  # $sCharset is now 'shiftjis' which can be passed to Encode::from_to()

  I18N::Charset::add_iana_alias('my-japanese' => 'iso-2022-jp');
  I18N::Charset::add_map8_alias('my-arabic' => 'arabic7');
  I18N::Charset::add_umap_alias('my-hebrew' => 'ISO-8859-8');
  I18N::Charset::add_libi_alias('my-sjis' => 'x-sjis');
  I18N::Charset::add_enco_alias('my-japanese' => 'shiftjis');

=head1 DESCRIPTION

The C module provides access to the IANA Character Set
Registry names for identifying character encoding schemes.  It also
provides a mapping to the character set names used by the
Unicode::Map and Unicode::Map8 modules.

So, for example, if you get an HTML document with a META CHARSET="..."
tag, you can fairly quickly determine what Unicode::MapXXX module can
be used to convert it to Unicode.

If you don't have the module Unicode::Map installed, the umap_
functions will always return undef.
If you don't have the module Unicode::Map8 installed, the map8_
functions will always return undef.
If you don't have the module Unicode::MapUTF8 installed, the umu8_
functions will always return undef.
If you don't have the iconv library installed, the libi_
functions will always return undef.
If you don't have the Encode module installed, the enco_
functions will always return undef.

=cut

#-----------------------------------------------------------------------
#	Public Global Variables
#-----------------------------------------------------------------------

our
$VERSION = 1.417;

our @EXPORT = qw( iana_charset_name
map8_charset_name
umap_charset_name
umu8_charset_name
mib_charset_name
mime_charset_name
libi_charset_name
enco_charset_name
mib_to_charset_name charset_name_to_mib
 );
our @EXPORT_OK = qw( add_iana_alias add_map8_alias add_umap_alias add_libi_alias add_enco_alias );

#-----------------------------------------------------------------------
#	Private Global Variables
#-----------------------------------------------------------------------

# %hsMIBofShortname is a hash of stripped names to mib.
my %hsMIBofShortname;
# %hsLongnameOfMIB is a hash of mib to long name.
my %hsLongnameOfMIB;
# %hsMIBofLongname is a hash of long name to mib.
my %hsMIBofLongname;
# %hsMIMEofMIB is a hash of mib to preferred MIME names.
my %hsMIMEofMIB;
# %MIBtoMAP8 is a hash of mib to Unicode::Map8 names.  (Only valid for
# those U::Map8 names that we can find in the IANA registry)
my %MIBtoMAP8;
# %MIBtoUMAP is a hash of mib to Unicode::Map names.  If a U::Map
# encoding does not have an official IANA entry, we create a dummy mib
# for it.
my %MIBtoUMAP;
# %MIBtoUMU8 is a hash of mib to Unicode::MapUTF8 names.  If a
# U::MapUTF8 encoding does not have an official IANA entry, we create
# a dummy mib for it.
my %MIBtoUMU8;
# %MIBtoLIBI is a hash of mib to libiconv names.  (Only valid for
# those libiconv names that we can find in the IANA registry)
my %MIBtoLIBI;
# %MIBtoENCO is a hash of mib to Encode names.  (Only valid for
# those Encode names that we can find in the IANA registry)
my %MIBtoENCO;

use constant DEBUG => 0;
use constant DEBUG_ENCO => 0;
use constant DEBUG_LIBI => 0;

=head1 CONVERSION ROUTINES

There are four main conversion routines: C,
C, C, and
C.

=over 4

=item iana_charset_name()

This function takes a string containing the name of a character set
and returns a string which contains the official IANA name of the
character set identified. If no valid character set name can be
identified, then C will be returned.  The case and punctuation
within the string are not important.

    $sCharset = iana_charset_name('WinCyrillic');

=cut

my $sDummy = 'dummymib';
my $sFakeMIB = $sDummy .'001';

sub _is_dummy
  {
  my $s = shift;
  return ($s =~ m!\A$sDummy!);
  } # _is_dummy

sub iana_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # $iDebug = ($code =~ m!sjis!);
  # print STDERR " + iana_charset_name($code)..." if $iDebug;
  my $mib = _short_to_mib($code);
  return undef unless defined $mib;
  # print STDERR " + mib is ($mib)..." if $iDebug;
  # Make sure this is really a IANA mib:
  return undef if _is_dummy($mib);
  # print STDERR " + is really iana..." if $iDebug;
  return $hsLongnameOfMIB{$mib};
  } # iana_charset_name


sub _try_list
  {
  my $code = shift;
  my @asTry = ($code, _strip($code));
  push @asTry, _strip($code) if $code =~ s!\A(x-)+!!;  # try without leading x-
  return @asTry;
  } # _try_list

sub _short_to_mib
  {
  my $code = shift;
  local $^W = 0;
  # print STDERR " + _short_to_mib($code)..." if DEBUG;
  my $answer = undef;
 TRY_SHORT:
  foreach my $sTry (_try_list($code))
    {
    my $iMIB = $hsMIBofShortname{$sTry} || 'undef';
    # print STDERR "try($sTry)...$iMIB..." if DEBUG;
    if ($iMIB ne 'undef')
      {
      $answer = $iMIB;
      last TRY_SHORT;
      } # if
    } # foreach
  # print STDERR "answer is $answer\n" if DEBUG;
  return $answer;
  } # _short_to_mib


sub _short_to_long
  {
  local $^W = 0;
  my $s = shift;
  # print STDERR " + _short_to_long($s)..." if DEBUG;
  return $hsLongnameOfMIB{_short_to_mib($s)};
  } # _short_to_long


=item mime_charset_name()

This function takes a string containing the name of a character set
and returns a string which contains the preferred MIME name of the
character set identified. If no valid character set name can be
identified, then C will be returned.  The case and punctuation
within the string are not important.

    $sCharset = mime_charset_name('Extended_UNIX_Code_Packed_Format_for_Japanese');

=cut

sub mime_charset_name
  {
  # This function contributed by Masafumi "Max" Nakane.  Thank you!
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # print STDERR " + mime_charset_name($code)..." if DEBUG;
  my $mib = _short_to_mib($code);
  return undef unless defined $mib;
  # print STDERR " + mib is ($mib)..." if DEBUG;
  # Make sure this is really an IANA mib:
  return undef if _is_dummy($mib);
  # print STDERR " + is really iana..." if DEBUG;
  return $hsMIMEofMIB{$mib};
  } # mime_charset_name


=item enco_charset_name()

This function takes a string containing the name of a character set
and returns a string which contains a name of the character set
suitable to be passed to the Encode module.  If no valid character set
name can be identified, or if Encode is not installed, then C
will be returned.  The case and punctuation within the string are not
important.

    $sCharset = enco_charset_name('Extended_UNIX_Code_Packed_Format_for_Japanese');

=cut

my $iEncoLoaded = 0;

sub _maybe_load_enco # PRIVATE
  {
  return if $iEncoLoaded;
  # Get a list of aliases from Encode:
  if (eval q{require Encode})
    {
    my @as;
    @as = Encode->encodings(':all');
    # push @as, Encode->encodings('EBCDIC');
    my $iFake = 0;
    my $iReal = 0;
 ENCODING:
    foreach my $s (@as)
      {
      # First, see if this already has an IANA mapping:
      my $mib;
      my $sIana = iana_charset_name($s);
      if (!defined $sIana)
        {
        # Create a dummy mib:
        $mib = $sFakeMIB++;
        $iFake++;
        } # if
      else
        {
        $mib = charset_name_to_mib($sIana);
        $iReal++;
        }
      # At this point we have a mib for this Encode entry.
      $MIBtoENCO{$mib} = $s;
      DEBUG_ENCO && print STDERR " +   mib for enco ==$s== is $mib\n";
      $hsMIBofShortname{_strip($s)} = $mib;
      DEBUG_ENCO && print STDERR " +   assign enco =$s==>$mib\n" if _is_dummy($mib);
      } # foreach ENCODING
    if (DEBUG_ENCO)
      {
      print STDERR " + Summary of Encode encodings:\n";
      printf STDERR (" +   %d encodings found.\n", scalar(@as));
      print STDERR " +   $iFake fake mibs created.\n";
      print STDERR " +   $iReal real mibs re-used.\n";
      } # if
    $iEncoLoaded = 1;
    add_enco_alias('Windows-31J', 'cp932');
    } # if
  else
    {
    print STDERR " --- Encode is not installed\n";
    }
  } # _maybe_load_enco

sub _mib_to_enco # PRIVATE
  {
  _maybe_load_enco();
  return $MIBtoENCO{shift()};
  } # _mib_to_enco

sub enco_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  _maybe_load_enco();
  my $iDebug = 0; # ($code =~ m!johab!i);
  print STDERR " + enco_charset_name($code)..." if ($iDebug || DEBUG_ENCO);
  my $mib = _short_to_mib($code);
  return undef unless defined $mib;
  print STDERR " + mib is ($mib)..." if ($iDebug || DEBUG_ENCO);
  my $ret = _mib_to_enco($mib);
  print STDERR " + enco is ($ret)..." if ($iDebug || DEBUG_ENCO);
  return $ret;
  } # enco_charset_name


=item libi_charset_name()

This function takes a string containing the name of a character set
and returns a string which contains a name of the character set
suitable to be passed to iconv.  If no valid character set name can be
identified, then C will be returned.  The case and punctuation
within the string are not important.

    $sCharset = libi_charset_name('Extended_UNIX_Code_Packed_Format_for_Korean');

=cut

my $iLibiLoaded = 0;

sub _maybe_load_libi # PRIVATE
  {
  return if $iLibiLoaded;
  # Get a list of aliases from iconv:
  return unless eval 'require App::Info::Lib::Iconv';
  my $oAILI = new App::Info::Lib::Iconv;
  if (ref $oAILI)
    {
    my $iLibiVersion = $oAILI->version;
    DEBUG_LIBI && warn " DDD libiconv version is $iLibiVersion\n";
    if ($oAILI->installed && (1.08 <= $iLibiVersion))
      {
      my $sCmd = $oAILI->bin_dir . '/iconv -l';
      DEBUG_LIBI && warn " DDD iconv cmdline is $sCmd\n";
      my @asIconv = split(/\n/, `$sCmd`);
 ICONV_LINE:
      foreach my $sLine (@asIconv)
        {
        my @asWord = split(/\s+/, $sLine);
        # First, go through and find one of these that has an IANA mapping:
        my $mib;
        my $sIana = undef;
 FIND_IANA:
        foreach my $sWord (@asWord)
          {
          last FIND_IANA if ($sIana = iana_charset_name($sWord));
          } # foreach FIND_IANA
        if (!defined $sIana)
          {
          # Create a dummy mib:
          $mib = $sFakeMIB++;
          } # if
        else
          {
          $mib = charset_name_to_mib($sIana);
          }
        # At this point we have a mib for this iconv entry.  Assign them all:
 ADD_LIBI:
        foreach my $sWord (reverse @asWord)
          {
          $MIBtoLIBI{$mib} = $sWord;
          DEBUG_LIBI && warn " +   mib for libi ==$sWord== is $mib\n";
          $hsMIBofShortname{_strip($sWord)} = $mib;
          } # foreach ADD_LIBI
        } # foreach ICONV_LINE
      } # if
    } # if
  $iLibiLoaded = 1;
  } # _maybe_load_libi

sub _mib_to_libi # PRIVATE
  {
  _maybe_load_libi();
  return $MIBtoLIBI{shift()};
  } # _mib_to_libi

sub libi_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # my $iDebug = 1; # ($code =~ m!johab!i);
  # print STDERR " + libi_charset_name($code)..." if $iDebug;
  my $mib = _short_to_mib($code);
  return undef unless defined $mib;
  # print STDERR " + mib is ($mib)..." if $iDebug;
  my $ret = _mib_to_libi($mib);
  # print STDERR " + libi is ($ret)..." if $iDebug;
  return $ret;
  } # libi_charset_name


=item mib_to_charset_name

This function takes a string containing the MIBenum of a character set
and returns a string which contains a name for the character set.
If the given MIBenum does not correspond to any character set,
then C will be returned.

    $sCharset = mib_to_charset_name('3');

=cut

sub mib_to_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  local $^W = 0;
  return $hsLongnameOfMIB{$code};
  } # mib_to_charset_name


=item mib_charset_name

This is a synonum for mib_to_charset_name

=cut

sub mib_charset_name
  {
  mib_to_charset_name(@_);
  } # mib_charset_name


=item charset_name_to_mib

This function takes a string containing the name of a character set in
almost any format and returns a MIBenum for the character set.  For
IANA-registered character sets, this is the IANA-registered MIB.  For
non-IANA character sets, this is an unambiguous unique string whose
only use is to pass to other functions in this module.  If no valid
character set name can be identified, then C will be returned.

    $iMIB = charset_name_to_mib('US-ASCII');

=cut

sub charset_name_to_mib
  {
  my $s = shift;
  return undef unless defined($s);
  return $hsMIBofLongname{$s} || $hsMIBofLongname{
                                                  iana_charset_name($s) ||
                                                  umap_charset_name($s) ||
                                                  map8_charset_name($s) ||
                                                  umu8_charset_name($s) ||
                                                  ''
                                                 };
  } # charset_name_to_mib


=item map8_charset_name()

This function takes a string containing the name of a character set
(in almost any format) and returns a string which contains a name for
the character set that can be passed to Unicode::Map8::new().
Note: the returned string will be capitalized just like
the name of the .bin file in the Unicode::Map8::MAPS_DIR directory.
If no valid character set name can be identified,
then C will be returned.
The case and punctuation within the argument string are not important.

    $sCharset = map8_charset_name('windows-1251');

=cut

sub map8_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # $iDebug = 0 && ($code =~ m!037!);
  # print STDERR " + map8_charset_name($code)..." if $iDebug;
  $code = _strip($code);
  # print STDERR "$code..." if $iDebug;
  my $iMIB = _short_to_mib($code) || 'undef';
  # print STDERR "$iMIB..." if $iDebug;
  if ($iMIB ne 'undef')
    {
    # print STDERR "$MIBtoMAP8{$iMIB}\n" if $iDebug;
    return $MIBtoMAP8{$iMIB};
    } # if
  # print STDERR "undef\n" if $iDebug;
  return undef;
  } # map8_charset_name


=item umap_charset_name()

This function takes a string containing the name of a character set
(in almost any format) and returns a string which contains a name for
the character set that can be passed to Unicode::Map::new(). If no
valid character set name can be identified, then C will be
returned.  The case and punctuation within the argument string are not
important.

    $sCharset = umap_charset_name('hebrew');

=cut

sub umap_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # $iDebug = ($code =~ m!apple!i);
  # print STDERR "\n + MIBtoUMAP{dummymib029} == $MIBtoUMAP{$sDummy .'029'}\n\n" if $iDebug;
  # print STDERR " + umap_charset_name($code)..." if $iDebug;
  my $iMIB = _short_to_mib(_strip($code)) || 'undef';
  # print STDERR "$iMIB..." if $iDebug;
  if ($iMIB ne 'undef')
    {
    # print STDERR "$MIBtoUMAP{$iMIB}\n" if $iDebug;
    return $MIBtoUMAP{$iMIB};
    } # if
  # print STDERR "undef\n" if $iDebug;
  return undef;
  } # umap_charset_name


our @asMap8Debug;

=item umu8_charset_name()

This function takes a string containing the name of a character set
(in almost any format) and returns a string which contains a name for
the character set that can be passed to Unicode::MapUTF8::new(). If no
valid character set name can be identified, then C will be
returned.  The case and punctuation within the argument string are not
important.

    $sCharset = umu8_charset_name('windows-1251');

=cut

sub umu8_charset_name
  {
  my $code = shift;
  return undef unless defined $code;
  return undef unless $code ne '';
  # $iDebug = ($code =~ m!u!);
  # print STDERR " + umu8_charset_name($code)..." if $iDebug;
  my $iMIB = _short_to_mib($code) || 'undef';
  # print STDERR "$iMIB..." if $iDebug;
  if ($iMIB ne 'undef')
    {
    # print STDERR "$MIBtoUMU8{$iMIB}\n" if $iDebug;
    return $MIBtoUMU8{$iMIB};
    } # if
  # print STDERR "undef\n" if $iDebug;
  return undef;
  } # umu8_charset_name

=back

=head1 QUERY ROUTINES

There is one function which can be used to obtain a list of all
IANA-registered character set names.

=over 4

=item C

Returns a list of all registered IANA character set names.
The names are not in any particular order.

=back

=cut

sub all_iana_charset_names
  {
  return values %hsLongnameOfMIB;
  } # all_iana_charset_names

#-----------------------------------------------------------------------

=head1 CHARACTER SET NAME ALIASING

This module supports several semi-private routines for specifying
character set name aliases.

=over 4

=item  add_iana_alias()

This function takes two strings: a new alias, and a target IANA
Character Set Name (or another alias).  It defines the new alias to
refer to that character set name (or to the character set name to
which the second alias refers).

Returns the target character set name of the successfully installed alias.
Returns 'undef' if the target character set name is not registered.
Returns 'undef' if the target character set name of the second alias
is not registered.

  I18N::Charset::add_iana_alias('my-alias1' => 'Shift_JIS');

With this code, "my-alias1" becomes an alias for the existing IANA
character set name 'Shift_JIS'.

  I18N::Charset::add_iana_alias('my-alias2' => 'sjis');

With this code, "my-alias2" becomes an alias for the IANA character set
name referred to by the existing alias 'sjis' (which happens to be 'Shift_JIS').

=cut

sub add_iana_alias
  {
  my ($sAlias, $sReal) = @_;
  # print STDERR " + add_iana_alias($sAlias, $sReal)\n";
  my $sName = iana_charset_name($sReal);
  if (not defined($sName))
    {
    carp qq{attempt to alias "$sAlias" to unknown IANA charset "$sReal"};
    return undef;
    } # if
  my $mib = _short_to_mib(_strip($sName));
  # print STDERR " --> $sName --> $mib\n";
  $hsMIBofShortname{_strip($sAlias)} = $mib;
  return $sName;
  } # add_iana_alias

#-----------------------------------------------------------------------

=item  add_map8_alias()

This function takes two strings: a new alias, and a target
Unicode::Map8 Character Set Name (or an existing alias to a Map8 name).
It defines the new alias to refer to that mapping name (or to the
mapping name to which the second alias refers).

If the first argument is a registered IANA character set name, then
all aliases of that IANA character set name will end up pointing to
the target Map8 mapping name.

Returns the target mapping name of the successfully installed alias.
Returns 'undef' if the target mapping name is not registered.
Returns 'undef' if the target mapping name of the second alias
is not registered.

  I18N::Charset::add_map8_alias('normal' => 'ANSI_X3.4-1968');

With the above statement, "normal" becomes an alias for the existing
Unicode::Map8 mapping name 'ANSI_X3.4-1968'.

  I18N::Charset::add_map8_alias('normal' => 'US-ASCII');

With the above statement, "normal" becomes an alias for the existing
Unicode::Map mapping name 'ANSI_X3.4-1968' (which is what "US-ASCII"
is an alias for).

  I18N::Charset::add_map8_alias('IBM297' => 'EBCDIC-CA-FR');

With the above statement, "IBM297" becomes an alias for the existing
Unicode::Map mapping name 'EBCDIC-CA-FR'.  As a side effect, all the
aliases for 'IBM297' (i.e. 'cp297' and 'ebcdic-cp-fr') also become
aliases for 'EBCDIC-CA-FR'.

=cut

sub add_map8_alias
  {
  my ($sAlias, $sReal) = @_;
  my $sName = map8_charset_name($sReal);
  my $sShort = _strip($sAlias);
  my $sShortName = _strip($sName);
  if (not defined($sName))
    {
    carp qq{attempt to alias "$sAlias" to unknown Map8 charset "$sReal"};
    return undef;
    } # if
  if (exists $hsMIBofShortname{$sShortName})
    {
    $hsMIBofShortname{$sShort} = $hsMIBofShortname{$sShortName};
    } # if
  return $sName;
  } # add_map8_alias

#-----------------------------------------------------------------------

=item  add_umap_alias()

This function works identically to add_map8_alias() above, but
operates on Unicode::Map encoding tables.

=cut

sub add_umap_alias
  {
  my ($sAlias, $sReal) = @_;
  my $sName = umap_charset_name($sReal);
  my $sShort = _strip($sAlias);
  my $sShortName = _strip($sName);
  if (not defined($sName))
    {
    carp qq{attempt to alias "$sAlias" to unknown U::Map charset "$sReal"};
    return undef;
    } # if
  if (exists $hsMIBofShortname{$sShortName})
    {
    $hsMIBofShortname{$sShort} = $hsMIBofShortname{$sShortName};
    } # if
  return $sName;
  } # add_umap_alias

#-----------------------------------------------------------------------

=item  add_libi_alias()

This function takes two strings: a new alias, and a target iconv
Character Set Name (or existing iconv alias).  It defines the new
alias to refer to that character set name (or to the character set
name to which the existing alias refers).

Returns the target conversion scheme name of the successfully installed alias.
Returns 'undef' if there is no such target conversion scheme or alias.

Examples:

  I18N::Charset::add_libi_alias('my-chinese1' => 'CN-GB');

With this code, "my-chinese1" becomes an alias for the existing iconv
conversion scheme 'CN-GB'.

  I18N::Charset::add_libi_alias('my-chinese2' => 'EUC-CN');

With this code, "my-chinese2" becomes an alias for the iconv
conversion scheme referred to by the existing alias 'EUC-CN' (which
happens to be 'CN-GB').

=cut

sub add_libi_alias
  {
  my ($sAlias, $sReal) = @_;
  # print STDERR " + add_libi_alias($sAlias,$sReal)...";
  my $sName = libi_charset_name($sReal);
  if (not defined($sName))
    {
    carp qq{attempt to alias "$sAlias" to unknown iconv charset "$sReal"};
    return undef;
    } # if
  my $mib = _short_to_mib(_strip($sName));
  # print STDERR "sName=$sName...mib=$mib\n";
  $hsMIBofShortname{_strip($sAlias)} = $mib;
  return $sName;
  } # add_libi_alias

#-----------------------------------------------------------------------

=item  add_enco_alias()

This function takes two strings: a new alias, and a target Encode
encoding Name (or existing Encode alias).  It defines the new alias
referring to that encoding name (or to the encoding to which the
existing alias refers).

Returns the target encoding name of the successfully installed alias.
Returns 'undef' if there is no such encoding or alias.

Examples:

  I18N::Charset::add_enco_alias('my-japanese1' => 'jis0201-raw');

With this code, "my-japanese1" becomes an alias for the existing
encoding 'jis0201-raw'.

  I18N::Charset::add_enco_alias('my-japanese2' => 'my-japanese1');

With this code, "my-japanese2" becomes an alias for the encoding
referred to by the existing alias 'my-japanese1' (which happens to be
'jis0201-raw' after the previous call).

=cut

sub add_enco_alias
  {
  my ($sAlias, $sReal) = @_;
  my $iDebug = 0;
  print STDERR " + add_enco_alias($sAlias,$sReal)..." if ($iDebug || DEBUG_ENCO);
  my $sName = enco_charset_name($sReal);
  if (not defined($sName))
    {
    carp qq{attempt to alias "$sAlias" to unknown Encode charset "$sReal"};
    return undef;
    } # if
  my $mib = _short_to_mib(_strip($sName));
  print STDERR "sName=$sName...mib=$mib\n" if ($iDebug || DEBUG_ENCO);
  $hsMIBofShortname{_strip($sAlias)} = $mib;
  return $sName;
  } # add_enco_alias

#-----------------------------------------------------------------------

=back

=head1 KNOWN BUGS AND LIMITATIONS

=over 4

=item *

There could probably be many more aliases added (for convenience) to
all the IANA names.
If you have some specific recommendations, please email the author!

=item *

The only character set names which have a corresponding mapping in the
Unicode::Map8 module are the character sets that Unicode::Map8 can
convert.

Similarly, the only character set names which have a corresponding
mapping in the Unicode::Map module are the character sets that
Unicode::Map can convert.

=item *

In the current implementation, all tables are read in and initialized
when the module is loaded, and then held in memory until the program
exits.  A "lazy" implementation (or a less-portable tied hash) might
lead to a shorter startup time.  Suggestions, patches, comments are
always welcome!

=back

=head1 SEE ALSO

=over 4

=item Unicode::Map

Convert strings from various multi-byte character encodings to and from Unicode.

=item Unicode::Map8

Convert strings from various 8-bit character encodings to and from Unicode.

=item Jcode

Convert strings among various Japanese character encodings and Unicode.

=item Unicode::MapUTF8

A wrapper around all three of these character set conversion distributions.

=back

=head1 AUTHOR

Martin 'Kingpin' Thurn, C, L.

=head1 LICENSE

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

#-----------------------------------------------------------------------

sub _strip
  {
  my $s = lc(shift);
  $s =~ tr/[0-9a-zA-Z]//dc;
  return $s;
  } # _strip

# initialization code - stuff the DATA into some data structure

# The only reason this is a while loop is so that I can bail out
# (e.g. for debugging) without using goto ;-)
INITIALIZATION:
  {
  my ($sName, $iMIB, $sAlias, $mimename);
  my $iDebug = 0;
  # I used to use the __DATA__ mechanism to initialize the data, but
  # that is not compatible with perlapp.  NOTE that storing the IANA
  # charset data as a file separate from this module code will not
  # work with perlapp either!
  my $s = _init_data();
  my $iRecord = 0;
 RECORD:
  while ($s =~ m//gs)
    {
    my $sRecord = $1;
    $iRecord++;
    if ($sRecord !~ m/(.+?)<\/name>/)
      {
      warn " WWW found record with no name.\n";
      next RECORD;
      } # if
    my $sName = $1;
    if ($sRecord !~ m/(\d+)<\/value>/)
      {
      warn " WWW found record '$sName' with no value.\n";
      next RECORD;
      } # if
    my $iMIB = $1;
    if ($sRecord =~ m/(.+?)<\/preferred_alias>/)
      {
      $hsMIMEofMIB{$iMIB} = $1;
      $hsMIBofShortname{_strip($1)} = $iMIB;
      }
    else
      {
      # warn " WWW found record '$sName' with no preferred alias.\n";
      } # if
    my $sMime = $1;
    $hsLongnameOfMIB{$iMIB} = $sName;
    $hsMIBofLongname{$sName} = $iMIB;
    # warn " DDD '$sName' ==> $iMIB\n";
    $hsMIBofShortname{_strip($sName)} = $iMIB;
 ALIAS:
    while ($sRecord =~ m/(.+?)<\/alias>/g)
      {
      my $sAlias = $1;
      $hsMIBofShortname{_strip($sAlias)} = $iMIB;
      } # while ALIAS
    } # while RECORD
  # Now that we have all the standard definitions, process the special
  # === directives:
  my @asEqualLines = split(/\n/, _init_data_extra());
  chomp @asEqualLines;
 EQUAL_LINE:
  foreach my $sLine (@asEqualLines)
    {
    next if ($sLine =~ m!\A#!);
    # print STDERR " +   equal-sign line $sLine...\n";
    my @as = split(/\ ===\ /, $sLine);
    my $sName = shift @as || q{};
    next unless $sName ne '';
    my $iMIB = $hsMIBofShortname{_strip($sName)} || 0;
    if (! $iMIB)
      {
      print STDERR " EEE can not find IANA entry for equal-sign directive $sName\n";
      next EQUAL_LINE;
      } # unless
 EQUAL_ITEM:
    foreach my $s (@as)
      {
      my $sStrip = _strip($s);
      # print STDERR " +     $sStrip --> $iMIB\n";
      $hsMIBofShortname{$sStrip} = $iMIB;
      } # foreach EQUAL_ITEM
    } # foreach EQUAL_LINE

  # last;  # for debugging

  if (eval "require Unicode::Map8")
    {
    # $iDebug = 1;
    my $sDir = $Unicode::Map8::MAPS_DIR;
    my $sAliasesFname = "$sDir/aliases";
    # Ah, how to get all the Unicode::Map8 supported charsets...  It
    # sure ain't easy!  The aliases file in the MAPS_DIR has a nice
    # set of aliases, but since some charsets have no aliases, they're
    # not listed in the aliases file!  Ergo, we have to read the
    # aliases file *and* all the file names in the MAPS_DIR!
    push @asMap8Debug, " DDD found Unicode::Map8 installed, will build map8 tables based on $sAliasesFname and files in that directory...\n";
    # First, read all the files in the MAPS_DIR folder and register in our local data structures:
    if (opendir(DIR, $sDir))
      {
      my @asFname = grep(!/^\.\.?$/, readdir(DIR));
      foreach my $sLong (@asFname)
        {
        next unless -f "$Unicode::Map8::MAPS_DIR/$sLong";
        $sLong =~ s/\.(?:bin|txt)$//;
        # Try to find the official IANA name for this encoding:
        push @asMap8Debug, " DDD   looking for $sLong in iana table...\n";
        my $sFound = '';
        if (defined (my $sTemp = iana_charset_name($sLong)))
          {
          $sFound = $sTemp;
          } # if
        if ($sFound eq '')
          {
          # $iDebug = 1;
          $iMIB = $sFakeMIB++;
          push @asMap8Debug, " DDD   had to use a dummy mib ($iMIB) for U::Map8==$sLong==\n";
          $hsMIBofLongname{$sLong} = $iMIB;
          } # unless
        else
          {
          $iMIB = $hsMIBofLongname{$sFound};
          push @asMap8Debug, " DDD   found IANA name $sFound ($iMIB) for Map8 entry $sLong\n";
          }
        # Make this IANA mib map to this Map8 name:
        push @asMap8Debug, " DDD      map $iMIB to $sLong in MIBtoMAP8...\n";
        $MIBtoMAP8{$iMIB} = $sLong;
        my $s = _strip($sLong);
        push @asMap8Debug, " DDD      map $s to $iMIB in hsMIBofShortname...\n";
        $hsMIBofShortname{$s} = $iMIB;
        } # foreach
      } # if
    # Now, go through the Unicode::Map8 aliases hash and process the aliases:
    my $avoid_warning = keys %Unicode::Map8::ALIASES;
    while (my ($alias, $charset) = each %Unicode::Map8::ALIASES)
      {
      my $iMIB = charset_name_to_mib($charset); # qqq
      my $s = _strip($alias);
      push @asMap8Debug, " DDD      map $s to $iMIB in hsMIBofShortname...\n";
      $hsMIBofShortname{$s} = $iMIB;
      } # while
    # If there are special cases for Unicode::Map8, add them here:
    add_map8_alias('ISO_8859-13:1998', 'ISO_8859-13');
    add_map8_alias('L 7', 'ISO_8859-13');
    add_map8_alias('Latin 7', 'ISO_8859-13');
    add_map8_alias('ISO_8859-15:1998', 'ISO_8859-15');
    add_map8_alias('L 0', 'ISO_8859-15');
    add_map8_alias('Latin 0', 'ISO_8859-15');
    add_map8_alias('L 9', 'ISO_8859-15');
    add_map8_alias('Latin 9', 'ISO_8859-15');
    add_map8_alias('ISO-8859-1-Windows-3.1-Latin-1', 'cp1252');
    add_map8_alias('csWindows31Latin1', 'cp1252');
    # Above aliases were described in RT#18802
    push @asMap8Debug, "done.\n";
    print STDERR @asMap8Debug if $iDebug;
    } # if Unicode::Map8 installed

  # last;  # for debugging

  # $iDebug = 1;
  if (eval "require Unicode::Map")
    {
    print STDERR " + found Unicode::Map installed, will build tables..." if $iDebug;
    my $MAP_Path = $INC{'Unicode/Map.pm'};
    $MAP_Path =~ s/\.pm//;
    my $sMapFile = "$MAP_Path/REGISTRY";
    if (open MAPS, $sMapFile)
      {
      local $/ = undef;
      my @asMAPS = split(/\n\s*\n/, );
 UMAP_ENTRY:
      foreach my $sEntry (@asMAPS)
        {
        $iDebug = 0;
        # print STDERR " + working on Umap entry >>>>>$sEntry<<<<<...\n";
        my ($sName, $iMIB) = ('', '');
        # Get the value of the name field, and skip entries with no name:
        next UMAP_ENTRY unless $sEntry =~ m!^name:\s+(\S+)!mi;
        $sName = $1;
        # $iDebug = ($sName =~ m!apple!);
        print STDERR " +   UMAP sName is $sName\n" if $iDebug;
        my @asAlias = split /\n/, $sEntry;
        @asAlias = map { /alias:\s+(.*)/; $1 } (grep /alias/, @asAlias);
        # See if this entry already has the MIB identified:
        if ($sEntry =~ m!^#mib:\s+(\d+)!mi)
          {
          $iMIB = $1;
          } # if
        else
          {
          # This entry does not have the MIB listed.  See if the name
          # of any of the aliases are known to our iana tables:
 UMAP_ALIAS:
          foreach my $sAlias ($sName, @asAlias)
            {
            print STDERR " +     try alias $sAlias\n" if $iDebug;
            my $iMIBtry = _short_to_mib(_strip($sAlias));
            if ($iMIBtry)
              {
              print STDERR " +       matched\n" if $iDebug;
              $iMIB = $iMIBtry;
              last UMAP_ALIAS;
              } # if
            } # foreach
          # If nothing matched, create a dummy mib:
          if ($iMIB eq '')
            {
            $iMIB = $sFakeMIB++;
            print STDERR " +   had to use a dummy mib ($iMIB) for U::Map==$sName==\n" if $iDebug;
            } # if
          } # else
        # $iDebug = ($iMIB =~ m!225[23]!);
        # $iDebug = ($iMIB eq '17');
        print STDERR " +   UMAP mib is $iMIB\n" if $iDebug;
        $MIBtoUMAP{$iMIB} = $sName;
        $hsMIBofLongname{$sName} ||= $iMIB;
        $hsMIBofShortname{_strip($sName)} ||= $iMIB;
        foreach my $sAlias (@asAlias)
          {
          print STDERR " +   UMAP alias $sAlias\n" if $iDebug;
          $hsMIBofShortname{_strip($sAlias)} = $iMIB;
          } # foreach $sAlias
        } # foreach UMAP_ENTRY
      close MAPS;
      # print STDERR "\n + MIBtoUMAP{dummymib029} == $MIBtoUMAP{$sDummy .'029'}\n\n";
      } # if open
    else
      {
      carp " --- couldn't open $sMapFile for read" if $iDebug;
      }
    # If there are special cases for Unicode::Map, add them here:
    # add_umap_alias("new-name", "existing-name");
    print STDERR "done.\n" if $iDebug;
    } # if Unicode::Map installed

  # Make sure to do U::MapUTF8 last, because it (in turn) depends on
  # the others.
  # $iDebug = 1;
  if (1.0 <= (eval q{ require Unicode::MapUTF8; $Unicode::MapUTF8::VERSION } || 0))
    {
    print STDERR " + found Unicode::MapUTF8 $Unicode::MapUTF8::VERSION installed, will build tables...\n" if $iDebug;
    my @as;
    # Wrap this in an eval to avoid compiler warning(?):
    eval { @as = Unicode::MapUTF8::utf8_supported_charset() };
UMU8_NAME:
    foreach my $sName (@as)
      {
      # $iDebug = ($sName =~ m!jis!i);
      print STDERR " + working on UmapUTF8 entry >>>>>$sName<<<<<...\n" if $iDebug;
      my $s = iana_charset_name($sName) || '';
      if ($s ne '')
        {
        # print STDERR " +   iana name is >>>>>$s<<<<<...\n" if $iDebug;
        $MIBtoUMU8{charset_name_to_mib($s)} = $sName;
        next UMU8_NAME;
        } # if already maps to IANA
      # print STDERR " +   UmapUTF8 entry ===$sName=== has no iana entry\n" if $iDebug;
      $s = umap_charset_name($sName) || '';
      if ($s ne '')
        {
        print STDERR " +   U::Map name is >>>>>$s<<<<<...\n" if $iDebug;
        $MIBtoUMU8{charset_name_to_mib($s)} = $sName;
        next UMU8_NAME;
        } # if maps to U::Map
      # print STDERR " +   UmapUTF8 entry ==$sName== has no U::Map entry\n" if $iDebug;
      $s = map8_charset_name($sName) || '';
      if ($s ne '')
        {
        print STDERR " +   U::Map8 name is >>>>>$s<<<<<...\n" if $iDebug;
        $MIBtoUMU8{charset_name_to_mib($s)} = $sName;
        next UMU8_NAME;
        } # if maps to U::Map8
      print STDERR " +   UmapUTF8 entry ==$sName== has no entries at all\n" if $iDebug;
      } # foreach
    # If there are special cases for Unicode::MapUTF8, add them here:
    # add_umap_alias("new-name", "existing-name");
    print STDERR "done.\n" if $iDebug;
    } # if Unicode::MapUTF8 installed

  # Initialization is all finished:
  last;
  # Below here is debugging code:

  print STDERR " + the following IANA names do *not* have entries in the Map8 table:\n";
  my %hiTried = ();
  foreach my $sIANA (sort values %hsLongnameOfMIB)
    {
    next if $hiTried{$sIANA};
    print "$sIANA\n" unless defined map8_charset_name($sIANA);
    $hiTried{$sIANA}++;
    } # foreach

  # last;  # for debugging

  # debugging: selective dump:
  print STDERR " + after init, iana_charset_name returns:\n";
  foreach my $key (qw(cp1251 windows-1251 WinCyrillic sjis x-sjis Shift_JIS ASCII US-ASCII us-ascii iso-2022-jp iso-8859-1 Unicode-2-0-utf-8 EUC-KR big5 x-x-big5))
    {
    print STDERR " +   $key => ", iana_charset_name($key) || 'undef', "\n";
    } # foreach

  # exit 88;

  print STDERR " + after init, map8_charset_name() returns:\n";
  foreach my $key (qw(cp1251 windows-1251 WinCyrillic sjis x-sjis Shift_JIS ASCII US-ASCII us-ascii iso-2022-jp iso-8859-1 Unicode-2-0-utf-8 EUC-KR big5 x-x-big5))
    {
    print STDERR " +   $key => ", map8_charset_name($key) || 'undef', "\n";
    } # foreach

  last;

  # debugging: huge dump:
  # _dump_hash('hsLongnameOfMIB', \%hsLongnameOfMIB);
  # _dump_hash('hsMIBofLongname', \%hsMIBofLongname);
  # _dump_hash('hsMIBofShortname', \%hsMIBofShortname);
  foreach (keys %hsMIBofShortname)
    {
    print STDERR " + _short_to_long($_) == ", _short_to_long($_) || 'undef', "\n";
    } # foreach

  } # end of INITIALIZATION block

sub _dump_hash
  {
  my ($sName, $rh) = @_;
  print STDERR " + after initialization, $sName is:\n";
  foreach my $key (keys %$rh)
    {
    print STDERR " +   $key => $$rh{$key}\n";
    } # foreach
  } # _dump_hash

sub _init_data_extra
  {
  # This little piece of data is a hand-made list of IANA names and
  # aliases, in the form AAA === BBB === CCC, where AAA is the
  # canonical IANA name and BBB and CCC are aliases.  Note that
  # capitalization and punctuation of aliases are meaningless (but
  # whitespace is not allowed).
  return <<'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';

Shift_JIS === sjis
windows-1250 === winlatin2 === cp1250
windows-1251 === wincyrillic === cp1251
windows-1252 === winlatin1 === cp1252
windows-1253 === wingreek === cp1253
windows-1254 === winturkish === cp1254
windows-1255 === winhebrew === cp1255
windows-1256 === winarabic === cp1256
windows-1257 === winbaltic === cp1257
windows-1258 === winvietnamese === cp1258
Adobe-Standard-Encoding === adobe-standard
Adobe-Symbol-Encoding === adobe-symbol
EBCDIC-ES === ebcdic-cp-es
EBCDIC-FR === ebcdic-cp-fr
EBCDIC-IT === ebcdic-cp-it
EBCDIC-UK === ebcdic-cp-gb
EBCDIC-FI-SE === ebcdic-cp-fi
UTF-7 === Unicode-2-0-utf-7
UTF-8 === Unicode-2-0-utf-8
Extended_UNIX_Code_Packed_Format_for_Japanese === euc === euc-jp
# These are for Unicode::MapUTF8:
ISO-10646-UCS-2 === ucs2
ISO-10646-UCS-4 === ucs4
# These are for iconv:
ISO-2022-JP === ISO-2022-JP-1
# These are for Encode:
IBM1047 === cp1047
GB2312 === gb2312-raw
HZ-GB-2312 === hz
JIS_X0201 === jis0201-raw
JIS_C6226-1983 === jis0208-raw
JIS_X0212-1990 === jis0212-raw
KS_C_5601-1987 === ksc5601-raw
CP037 === CP37
cp863 === DOSCanadaF
cp860 === DOSPortuguese
cp869 === DOSGreek2
koi8-r === cp878
# These encodings are handled by Encode, but I don't know what they are:
# ??? === AdobeZdingbats
# ??? === MacArabic
# ??? === MacCentralEurRoman
# ??? === MacChineseSimp
# ??? === MacChineseTrad
# ??? === MacCroatian
# ??? === MacCyrillic
# ??? === MacDingbats
# ??? === MacFarsi
# ??? === MacGreek
# ??? === MacHebrew
# ??? === MacIcelandic
# ??? === MacJapanese
# ??? === MacKorean
# ??? === MacRomanian
# ??? === MacRumanian
# ??? === MacSami
# ??? === MacThai
# ??? === MacTurkish
# ??? === MacUkrainian
# ??? === MacVietnamese
# ??? === cp1006
# ??? === dingbats
# ??? === nextstep
# ??? === posix-bc
# The following aliases are listed in RT#18802:
ISO-8859-10 === 8859-10 === ISO_8859-10:1993
# TCVN-5712 x-viet-tcvn viet-tcvn VN-1 TCVN-5712:1993
TIS-620 === TIS_620-2553 === TIS_620-2553:1990
# VPS x-viet-vps viet-vps
# The above aliases are listed in RT#18802
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  } # _init_data_extra


sub _init_data
  {
  # This big piece of data is the original document from
  # http://www.iana.org/assignments/character-sets
  return <<'EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE';




  2013-10-01
  Character Sets
  Character Sets

  Expert Review
  Primary Expert Ned Freed and Secondary Expert Martin Dürst
  These are the official names for character sets that may be used in
the Internet and may be referred to in Internet documentation.  These
names are expressed in ANSI_X3.4-1968 which is commonly called
US-ASCII or simply ASCII.  The character set most commonly use in the
Internet and used especially in protocol standards is US-ASCII, this
is strongly encouraged.  The use of the name US-ASCII is also
encouraged.

The character set names may be up to 40 characters taken from the
printable characters of US-ASCII.  However, no distinction is made
between use of upper and lower case letters.

The MIBenum value is a unique value for use in MIBs to identify coded
character sets.

The value space for MIBenum values has been divided into three
regions. The first region (3-999) consists of coded character sets
that have been standardized by some standard setting organization.
This region is intended for standards that do not have subset
implementations. The second region (1000-1999) is for the Unicode and
ISO/IEC 10646 coded character sets together with a specification of a
(set of) sub-repertoires that may occur.  The third region (>1999) is
intended for vendor specific coded character sets.

        Assigned MIB enum Numbers
        -------------------------
        0-2             Reserved
        3-999           Set By Standards Organizations
        1000-1999       Unicode / 10646
        2000-2999       Vendor

The aliases that start with "cs" have been added for use with the
IANA-CHARSET-MIB as originally defined in , and as currently
maintained by IANA at .
Note that the ianacharset-mib needs to be kept in sync with this
registry.  These aliases that start with "cs" contain the standard
numbers along with suggestive names in order to facilitate applications
that want to display the names in user interfaces.  The "cs" stands
for character set and is provided for applications that need a lower
case first letter but want to use mixed case thereafter that cannot
contain any special characters, such as underbar ("_") and dash ("-").

If the character set is from an ISO standard, its cs alias is the ISO
standard number or name.  If the character set is not from an ISO
standard, but is registered with ISO (IPSJ/ITSCJ is the current ISO
Registration Authority), the ISO Registry number is specified as
ISOnnn followed by letters suggestive of the name or standards number
of the code set.  When a national or international standard is
revised, the year of revision is added to the cs alias of the new
character set entry in the IANA Registry in order to distinguish the
revised character set from the original character set.


      US-ASCII

      3
      ANSI X3.4-1986
      iso-ir-6
      ANSI_X3.4-1968
      ANSI_X3.4-1986
      ISO_646.irv:1991
      ISO646-US
      US-ASCII
      us
      IBM367
      cp367
      csASCII
      US-ASCII


      ISO_8859-1:1987


      4

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-100
      ISO_8859-1
      ISO-8859-1
      latin1
      l1
      IBM819
      CP819
      csISOLatin1
      ISO-8859-1


      ISO_8859-2:1987


      5

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-101
      ISO_8859-2
      ISO-8859-2
      latin2
      l2
      csISOLatin2
      ISO-8859-2


      ISO_8859-3:1988


      6

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-109
      ISO_8859-3
      ISO-8859-3
      latin3
      l3
      csISOLatin3
      ISO-8859-3


      ISO_8859-4:1988


      7

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-110
      ISO_8859-4
      ISO-8859-4
      latin4
      l4
      csISOLatin4
      ISO-8859-4


      ISO_8859-5:1988


      8

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-144
      ISO_8859-5
      ISO-8859-5
      cyrillic
      csISOLatinCyrillic
      ISO-8859-5


      ISO_8859-6:1987


      9

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-127
      ISO_8859-6
      ISO-8859-6
      ECMA-114
      ASMO-708
      arabic
      csISOLatinArabic
      ISO-8859-6


      ISO_8859-7:1987



      10

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-126
      ISO_8859-7
      ISO-8859-7
      ELOT_928
      ECMA-118
      greek
      greek8
      csISOLatinGreek
      ISO-8859-7


      ISO_8859-8:1988


      11

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-138
      ISO_8859-8
      ISO-8859-8
      hebrew
      csISOLatinHebrew
      ISO-8859-8


      ISO_8859-9:1989


      12

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-148
      ISO_8859-9
      ISO-8859-9
      latin5
      l5
      csISOLatin5
      ISO-8859-9


      ISO-8859-10


      13

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-157
      l6
      ISO_8859-10:1992
      csISOLatin6
      latin6
      ISO-8859-10


      ISO_6937-2-add


      14

        ISO-IR: International Register of Escape Sequences and ISO 6937-2:1983
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-142
      csISOTextComm


      JIS_X0201


      15
      JIS X 0201-1976.   One byte only, this is equivalent to
JIS/Roman (similar to ASCII) plus eight-bit half-width
Katakana
      X0201
      csHalfWidthKatakana


      JIS_Encoding
      16
      JIS X 0202-1991.  Uses ISO 2022 escape sequences to
shift code sets as documented in JIS X 0202-1991.
      csJISEncoding


      Shift_JIS
      17
      This charset is an extension of csHalfWidthKatakana by
adding graphic characters in JIS X 0208.  The CCS's are
JIS X0201:1997 and JIS X0208:1997.  The
complete definition is shown in Appendix 1 of JIS
X0208:1997.
This charset can be used for the top-level media type "text".
      MS_Kanji
      csShiftJIS
      Shift_JIS


      Extended_UNIX_Code_Packed_Format_for_Japanese
      18
      Standardized by OSF, UNIX International, and UNIX Systems
Laboratories Pacific.  Uses ISO 2022 rules to select
code set 0: US-ASCII (a single 7-bit byte set)
code set 1: JIS X0208-1990 (a double 8-bit byte set)
restricted to A0-FF in both bytes
code set 2: Half Width Katakana (a single 7-bit byte set)
requiring SS2 as the character prefix
code set 3: JIS X0212-1990 (a double 7-bit byte set)
restricted to A0-FF in both bytes
requiring SS3 as the character prefix
      csEUCPkdFmtJapanese
      EUC-JP
      EUC-JP


      Extended_UNIX_Code_Fixed_Width_for_Japanese
      19
      Used in Japan.  Each character is 2 octets.
code set 0: US-ASCII (a single 7-bit byte set)
1st byte = 00
2nd byte = 20-7E
code set 1: JIS X0208-1990 (a double 7-bit byte set)
restricted  to A0-FF in both bytes
code set 2: Half Width Katakana (a single 7-bit byte set)
1st byte = 00
2nd byte = A0-FF
code set 3: JIS X0212-1990 (a double 7-bit byte set)
restricted to A0-FF in
the first byte
and 21-7E in the second byte
      csEUCFixWidJapanese


      BS_4730


      20

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-4
      ISO646-GB
      gb
      uk
      csISO4UnitedKingdom


      SEN_850200_C


      21

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-11
      ISO646-SE2
      se2
      csISO11SwedishForNames


      IT


      22

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-15
      ISO646-IT
      csISO15Italian


      ES


      23

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-17
      ISO646-ES
      csISO17Spanish


      DIN_66003


      24

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-21
      de
      ISO646-DE
      csISO21German


      NS_4551-1


      25

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-60
      ISO646-NO
      no
      csISO60DanishNorwegian
      csISO60Norwegian1


      NF_Z_62-010


      26

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-69
      ISO646-FR
      fr
      csISO69French


      ISO-10646-UTF-1
      27
      Universal Transfer Format (1), this is the multibyte
encoding, that subsets ASCII-7. It does not have byte
ordering issues.
      csISO10646UTF1


      ISO_646.basic:1983


      28

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      ref
      csISO646basic1983


      INVARIANT


      29
      csINVARIANT


      ISO_646.irv:1983


      30

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-2
      irv
      csISO2IntlRefVersion


      NATS-SEFI


      31

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-8-1
      csNATSSEFI


      NATS-SEFI-ADD


      32

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-8-2
      csNATSSEFIADD


      NATS-DANO


      33

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-9-1
      csNATSDANO


      NATS-DANO-ADD


      34

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-9-2
      csNATSDANOADD


      SEN_850200_B


      35

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-10
      FI
      ISO646-FI
      ISO646-SE
      se
      csISO10Swedish


      KS_C_5601-1987


      36

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-149
      KS_C_5601-1989
      KSC_5601
      korean
      csKSC56011987


      ISO-2022-KR


      37
       (see also KS_C_5601-1987)
      csISO2022KR
      ISO-2022-KR


      EUC-KR


      38
       (see also KS_C_5861-1992)
      csEUCKR
      EUC-KR


      ISO-2022-JP


      39
       (see also )
      csISO2022JP
      ISO-2022-JP


      ISO-2022-JP-2


      40



      csISO2022JP2
      ISO-2022-JP-2


      JIS_C6220-1969-jp


      41

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      JIS_C6220-1969
      iso-ir-13
      katakana
      x0201-7
      csISO13JISC6220jp


      JIS_C6220-1969-ro


      42

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-14
      jp
      ISO646-JP
      csISO14JISC6220ro


      PT


      43

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-16
      ISO646-PT
      csISO16Portuguese


      greek7-old


      44

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-18
      csISO18Greek7Old


      latin-greek


      45

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-19
      csISO19LatinGreek


      NF_Z_62-010_(1973)


      46

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-25
      ISO646-FR1
      csISO25French


      Latin-greek-1


      47

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-27
      csISO27LatinGreek1


      ISO_5427


      48

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-37
      csISO5427Cyrillic


      JIS_C6226-1978


      49

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-42
      csISO42JISC62261978


      BS_viewdata


      50

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-47
      csISO47BSViewdata


      INIS


      51

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-49
      csISO49INIS


      INIS-8


      52

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-50
      csISO50INIS8


      INIS-cyrillic


      53

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-51
      csISO51INISCyrillic


      ISO_5427:1981


      54

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-54
      ISO5427Cyrillic1981
      csISO54271981


      ISO_5428:1980


      55

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-55
      csISO5428Greek


      GB_1988-80


      56

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-57
      cn
      ISO646-CN
      csISO57GB1988


      GB_2312-80


      57

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-58
      chinese
      csISO58GB231280


      NS_4551-2


      58

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      ISO646-NO2
      iso-ir-61
      no2
      csISO61Norwegian2


      videotex-suppl


      59

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-70
      csISO70VideotexSupp1


      PT2


      60

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-84
      ISO646-PT2
      csISO84Portuguese2


      ES2


      61

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-85
      ISO646-ES2
      csISO85Spanish2


      MSZ_7795.3


      62

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-86
      ISO646-HU
      hu
      csISO86Hungarian


      JIS_C6226-1983


      63

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-87
      x0208
      JIS_X0208-1983
      csISO87JISX0208


      greek7


      64

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-88
      csISO88Greek7


      ASMO_449


      65

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      ISO_9036
      arabic7
      iso-ir-89
      csISO89ASMO449


      iso-ir-90


      66

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      csISO90


      JIS_C6229-1984-a


      67

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-91
      jp-ocr-a
      csISO91JISC62291984a


      JIS_C6229-1984-b


      68

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-92
      ISO646-JP-OCR-B
      jp-ocr-b
      csISO92JISC62991984b


      JIS_C6229-1984-b-add


      69

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-93
      jp-ocr-b-add
      csISO93JIS62291984badd


      JIS_C6229-1984-hand


      70

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-94
      jp-ocr-hand
      csISO94JIS62291984hand


      JIS_C6229-1984-hand-add


      71

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-95
      jp-ocr-hand-add
      csISO95JIS62291984handadd


      JIS_C6229-1984-kana


      72

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-96
      csISO96JISC62291984kana


      ISO_2033-1983


      73

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-98
      e13b
      csISO2033


      ANSI_X3.110-1983


      74

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-99
      CSA_T500-1983
      NAPLPS
      csISO99NAPLPS


      T.61-7bit


      75

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-102
      csISO102T617bit


      T.61-8bit


      76

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      T.61
      iso-ir-103
      csISO103T618bit


      ECMA-cyrillic
      77
      ISO registry
        (formerly ECMA
          registry)
      iso-ir-111
      KOI8-E
      csISO111ECMACyrillic


      CSA_Z243.4-1985-1


      78

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-121
      ISO646-CA
      csa7-1
      csa71
      ca
      csISO121Canadian1


      CSA_Z243.4-1985-2


      79

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-122
      ISO646-CA2
      csa7-2
      csa72
      csISO122Canadian2


      CSA_Z243.4-1985-gr


      80

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-123
      csISO123CSAZ24341985gr


      ISO_8859-6-E


      81



      csISO88596E
      ISO-8859-6-E
      ISO-8859-6-E


      ISO_8859-6-I


      82



      csISO88596I
      ISO-8859-6-I
      ISO-8859-6-I


      T.101-G2


      83

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-128
      csISO128T101G2


      ISO_8859-8-E


      84



      csISO88598E
      ISO-8859-8-E
      ISO-8859-8-E


      ISO_8859-8-I


      85



      csISO88598I
      ISO-8859-8-I
      ISO-8859-8-I


      CSN_369103


      86

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-139
      csISO139CSN369103


      JUS_I.B1.002


      87

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-141
      ISO646-YU
      js
      yu
      csISO141JUSIB1002


      IEC_P27-1


      88

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-143
      csISO143IECP271


      JUS_I.B1.003-serb


      89

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-146
      serbian
      csISO146Serbian


      JUS_I.B1.003-mac


      90

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      macedonian
      iso-ir-147
      csISO147Macedonian


      greek-ccitt


      91

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-150
      csISO150
      csISO150GreekCCITT


      NC_NC00-10:81


      92

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      cuba
      iso-ir-151
      ISO646-CU
      csISO151Cuba


      ISO_6937-2-25


      93

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-152
      csISO6937Add


      GOST_19768-74


      94

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      ST_SEV_358-88
      iso-ir-153
      csISO153GOST1976874


      ISO_8859-supp


      95

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-154
      latin1-2-5
      csISO8859Supp


      ISO_10367-box


      96

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      iso-ir-155
      csISO10367Box


      latin-lap


      97

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      lap
      iso-ir-158
      csISO158Lap


      JIS_X0212-1990


      98

        ISO-IR: International Register of Escape Sequences
        Note: The current registration authority is IPSJ/ITSCJ, Japan.

      x0212
      iso-ir-159
      csISO159JISX02121990


      DS_2089


      99
      Danish Standard, DS 2089, February 1974
      DS2089
      ISO646-DK
      dk
      csISO646Danish


      us-dk


      100
      csUSDK


      dk-us


      101
      csDKUS


      KSC5636


      102
      ISO646-KR
      csKSC5636


      UNICODE-1-1-UTF-7

      103



      csUnicode11UTF7


      ISO-2022-CN

      104



      csISO2022CN


      ISO-2022-CN-EXT

      105



      csISO2022CNEXT


      UTF-8

      106



      csUTF8


      ISO-8859-13
      109
      ISO See
      csISO885913


      ISO-8859-14
      110
      ISO See
      iso-ir-199
      ISO_8859-14:1998
      ISO_8859-14
      latin8
      iso-celtic
      l8
      csISO885914


      ISO-8859-15
      111
      ISO
Please see:
      ISO_8859-15
      Latin-9
      csISO885915


      ISO-8859-16
      112
      ISO
      iso-ir-226
      ISO_8859-16:2001
      ISO_8859-16
      latin10
      l10
      csISO885916


      GBK
      113
      Chinese IT Standardization Technical Committee
Please see:
      CP936
      MS936
      windows-936
      csGBK


      GB18030
      114
      Chinese IT Standardization Technical Committee
Please see:
      csGB18030


      OSD_EBCDIC_DF04_15
      115
      Fujitsu-Siemens standard mainframe EBCDIC encoding
Please see:
      csOSDEBCDICDF0415


      OSD_EBCDIC_DF03_IRV
      116
      Fujitsu-Siemens standard mainframe EBCDIC encoding
Please see:
      csOSDEBCDICDF03IRV


      OSD_EBCDIC_DF04_1
      117
      Fujitsu-Siemens standard mainframe EBCDIC encoding
Please see:
      csOSDEBCDICDF041


      ISO-11548-1
      118
      See
      ISO_11548-1
      ISO_TR_11548-1
      csISO115481


      KZ-1048
      119
      See
      STRK1048-2002
      RK1048
      csKZ1048


      ISO-10646-UCS-2
      1000
      the 2-octet Basic Multilingual Plane, aka Unicode
this needs to specify network byte order: the standard
does not specify (it is a 16-bit integer space)
      csUnicode


      ISO-10646-UCS-4
      1001
      the full code space. (same comment about byte order,
these are 31-bit numbers.
      csUCS4


      ISO-10646-UCS-Basic
      1002
      ASCII subset of Unicode.  Basic Latin = collection 1
See ISO 10646, Appendix A
      csUnicodeASCII


      ISO-10646-Unicode-Latin1
      1003
      ISO Latin-1 subset of Unicode. Basic Latin and Latin-1
Supplement  = collections 1 and 2.  See ISO 10646,
Appendix A.  See .
      csUnicodeLatin1
      ISO-10646


      ISO-10646-J-1
      1004
      ISO 10646 Japanese, see .
      csUnicodeJapanese


      ISO-Unicode-IBM-1261
      1005
      IBM Latin-2, -3, -5, Extended Presentation Set, GCSGID: 1261
      csUnicodeIBM1261


      ISO-Unicode-IBM-1268
      1006
      IBM Latin-4 Extended Presentation Set, GCSGID: 1268
      csUnicodeIBM1268


      ISO-Unicode-IBM-1276
      1007
      IBM Cyrillic Greek Extended Presentation Set, GCSGID: 1276
      csUnicodeIBM1276


      ISO-Unicode-IBM-1264
      1008
      IBM Arabic Presentation Set, GCSGID: 1264
      csUnicodeIBM1264


      ISO-Unicode-IBM-1265
      1009
      IBM Hebrew Presentation Set, GCSGID: 1265
      csUnicodeIBM1265


      UNICODE-1-1

      1010



      csUnicode11


      SCSU
      1011
      SCSU See
      csSCSU


      UTF-7

      1012



      csUTF7


      UTF-16BE

      1013



      csUTF16BE


      UTF-16LE

      1014



      csUTF16LE


      UTF-16

      1015



      csUTF16


      CESU-8

      1016



      csCESU8
      csCESU-8


      UTF-32

      1017



      csUTF32


      UTF-32BE

      1018



      csUTF32BE


      UTF-32LE

      1019



      csUTF32LE


      BOCU-1

      1020



      csBOCU1
      csBOCU-1


      ISO-8859-1-Windows-3.0-Latin-1
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2000
      Extended ISO 8859-1 Latin-1 for Windows 3.0.
PCL Symbol Set id: 9U
      csWindows30Latin1


      ISO-8859-1-Windows-3.1-Latin-1
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2001
      Extended ISO 8859-1 Latin-1 for Windows 3.1.
PCL Symbol Set id: 19U
      csWindows31Latin1


      ISO-8859-2-Windows-Latin-2
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2002
      Extended ISO 8859-2.  Latin-2 for Windows 3.1.
PCL Symbol Set id: 9E
      csWindows31Latin2


      ISO-8859-9-Windows-Latin-5
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2003
      Extended ISO 8859-9.  Latin-5 for Windows 3.1
PCL Symbol Set id: 5T
      csWindows31Latin5


      hp-roman8
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.


      2004
      LaserJet IIP Printer User's Manual,
HP part no 33471-90901, Hewlet-Packard, June 1989.
      roman8
      r8
      csHPRoman8


      Adobe-Standard-Encoding
      Adobe Systems Incorporated, PostScript Language Reference
Manual, second edition, Addison-Wesley Publishing Company,
Inc., 1990.
      2005
      PostScript Language Reference Manual
PCL Symbol Set id: 10J
      csAdobeStandardEncoding


      Ventura-US
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2006
      Ventura US.  ASCII plus characters typically used in
publishing, like pilcrow, copyright, registered, trade mark,
section, dagger, and double dagger in the range A0 (hex)
to FF (hex).
PCL Symbol Set id: 14J
      csVenturaUS


      Ventura-International
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2007
      Ventura International.  ASCII plus coded characters similar
to Roman8.
PCL Symbol Set id: 13J
      csVenturaInternational


      DEC-MCS


      2008
      VAX/VMS User's Manual,
Order Number: AI-Y517A-TE, April 1986.
      dec
      csDECMCS


      IBM850


      2009
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp850
      850
      csPC850Multilingual


      PC8-Danish-Norwegian
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2012
      PC Danish Norwegian
8-bit PC set for Danish Norwegian
PCL Symbol Set id: 11U
      csPC8DanishNorwegian


      IBM862


      2013
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp862
      862
      csPC862LatinHebrew


      PC8-Turkish
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2014
      PC Latin Turkish.  PCL Symbol Set id: 9T
      csPC8Turkish


      IBM-Symbols
      IBM Corporation, "ABOUT TYPE: IBM's Technical Reference
for Core Interchange Digitized Type", Publication number
S544-3708-01
      2015
      Presentation Set, CPGID: 259
      csIBMSymbols


      IBM-Thai
      IBM Corporation, "ABOUT TYPE: IBM's Technical Reference
for Core Interchange Digitized Type", Publication number
S544-3708-01
      2016
      Presentation Set, CPGID: 838
      csIBMThai


      HP-Legal
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2017
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 1U
      csHPLegal


      HP-Pi-font
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2018
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 15U
      csHPPiFont


      HP-Math8
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2019
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 8M
      csHPMath8


      Adobe-Symbol-Encoding
      Adobe Systems Incorporated, PostScript Language Reference
Manual, second edition, Addison-Wesley Publishing Company,
Inc., 1990.
      2020
      PostScript Language Reference Manual
PCL Symbol Set id: 5M
      csHPPSMath


      HP-DeskTop
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2021
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 7J
      csHPDesktop


      Ventura-Math
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2022
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 6M
      csVenturaMath


      Microsoft-Publishing
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2023
      PCL 5 Comparison Guide, Hewlett-Packard,
HP part number 5961-0510, October 1992
PCL Symbol Set id: 6J
      csMicrosoftPublishing


      Windows-31J
      2024
      Windows Japanese.  A further extension of Shift_JIS
to include NEC special characters (Row 13), NEC
selection of IBM extensions (Rows 89 to 92), and IBM
extensions (Rows 115 to 119).  The CCS's are
JIS X0201:1997, JIS X0208:1997, and these extensions.
This charset can be used for the top-level media type "text",
but it is of limited or specialized use (see ).
PCL Symbol Set id: 19K
      csWindows31J


      GB2312
      2025
      Chinese for People's Republic of China (PRC) mixed one byte,
two byte set:
20-7E = one byte ASCII
A1-FE = two byte PRC Kanji
See GB 2312-80
PCL Symbol Set Id: 18C
      csGB2312
      GB2312


      Big5
      2026
      Chinese for Taiwan Multi-byte set.
PCL Symbol Set Id: 18T
      csBig5
      Big5


      macintosh


      2027
      The Unicode Standard ver1.0, ISBN 0-201-56788-1, Oct 1991
      mac
      csMacintosh


      IBM037


      2028
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp037
      ebcdic-cp-us
      ebcdic-cp-ca
      ebcdic-cp-wt
      ebcdic-cp-nl
      csIBM037


      IBM038


      2029
      IBM 3174 Character Set Ref, GA27-3831-02, March 1990
      EBCDIC-INT
      cp038
      csIBM038


      IBM273


      2030
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP273
      csIBM273


      IBM274


      2031
      IBM 3174 Character Set Ref, GA27-3831-02, March 1990
      EBCDIC-BE
      CP274
      csIBM274


      IBM275


      2032
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      EBCDIC-BR
      cp275
      csIBM275


      IBM277


      2033
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      EBCDIC-CP-DK
      EBCDIC-CP-NO
      csIBM277


      IBM278


      2034
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP278
      ebcdic-cp-fi
      ebcdic-cp-se
      csIBM278


      IBM280


      2035
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP280
      ebcdic-cp-it
      csIBM280


      IBM281


      2036
      IBM 3174 Character Set Ref, GA27-3831-02, March 1990
      EBCDIC-JP-E
      cp281
      csIBM281


      IBM284


      2037
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP284
      ebcdic-cp-es
      csIBM284


      IBM285


      2038
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP285
      ebcdic-cp-gb
      csIBM285


      IBM290


      2039
      IBM 3174 Character Set Ref, GA27-3831-02, March 1990
      cp290
      EBCDIC-JP-kana
      csIBM290


      IBM297


      2040
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp297
      ebcdic-cp-fr
      csIBM297


      IBM420


      2041
      IBM NLS RM Vol2 SE09-8002-01, March 1990,
IBM NLS RM p 11-11
      cp420
      ebcdic-cp-ar1
      csIBM420


      IBM423


      2042
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp423
      ebcdic-cp-gr
      csIBM423


      IBM424


      2043
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp424
      ebcdic-cp-he
      csIBM424


      IBM437


      2011
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp437
      437
      csPC8CodePage437


      IBM500


      2044
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP500
      ebcdic-cp-be
      ebcdic-cp-ch
      csIBM500


      IBM851


      2045
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp851
      851
      csIBM851


      IBM852


      2010
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp852
      852
      csPCp852


      IBM855


      2046
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp855
      855
      csIBM855


      IBM857


      2047
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp857
      857
      csIBM857


      IBM860


      2048
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp860
      860
      csIBM860


      IBM861


      2049
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp861
      861
      cp-is
      csIBM861


      IBM863


      2050
      IBM Keyboard layouts and code pages, PN 07G4586 June 1991
      cp863
      863
      csIBM863


      IBM864


      2051
      IBM Keyboard layouts and code pages, PN 07G4586 June 1991
      cp864
      csIBM864


      IBM865


      2052
      IBM DOS 3.3 Ref (Abridged), 94X9575 (Feb 1987)
      cp865
      865
      csIBM865


      IBM868


      2053
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP868
      cp-ar
      csIBM868


      IBM869


      2054
      IBM Keyboard layouts and code pages, PN 07G4586 June 1991
      cp869
      869
      cp-gr
      csIBM869


      IBM870


      2055
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP870
      ebcdic-cp-roece
      ebcdic-cp-yu
      csIBM870


      IBM871


      2056
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP871
      ebcdic-cp-is
      csIBM871


      IBM880


      2057
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp880
      EBCDIC-Cyrillic
      csIBM880


      IBM891


      2058
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp891
      csIBM891


      IBM903


      2059
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp903
      csIBM903


      IBM904


      2060
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      cp904
      904
      csIBBM904


      IBM905


      2061
      IBM 3174 Character Set Ref, GA27-3831-02, March 1990
      CP905
      ebcdic-cp-tr
      csIBM905


      IBM918


      2062
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP918
      ebcdic-cp-ar2
      csIBM918


      IBM1026


      2063
      IBM NLS RM Vol2 SE09-8002-01, March 1990
      CP1026
      csIBM1026


      EBCDIC-AT-DE


      2064
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csIBMEBCDICATDE


      EBCDIC-AT-DE-A


      2065
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICATDEA


      EBCDIC-CA-FR


      2066
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICCAFR


      EBCDIC-DK-NO


      2067
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICDKNO


      EBCDIC-DK-NO-A


      2068
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICDKNOA


      EBCDIC-FI-SE


      2069
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICFISE


      EBCDIC-FI-SE-A


      2070
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICFISEA


      EBCDIC-FR


      2071
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICFR


      EBCDIC-IT


      2072
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICIT


      EBCDIC-PT


      2073
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICPT


      EBCDIC-ES


      2074
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICES


      EBCDIC-ES-A


      2075
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICESA


      EBCDIC-ES-S


      2076
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICESS


      EBCDIC-UK


      2077
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICUK


      EBCDIC-US


      2078
      IBM 3270 Char Set Ref Ch 10, GA27-2837-9, April 1987
      csEBCDICUS


      UNKNOWN-8BIT

      2079
      csUnknown8BiT


      MNEMONIC


      2080
      , also known as "mnemonic+ascii+38"
      csMnemonic


      MNEM


      2081
      , also known as "mnemonic+ascii+8200"
      csMnem


      VISCII

      2082



      csVISCII


      VIQR

      2083



      csVIQR


      KOI8-R

      2084
      , based on GOST-19768-74, ISO-6937/8,
INIS-Cyrillic, ISO-5427.
      csKOI8R
      KOI8-R


      HZ-GB-2312
      2085
      ,


      IBM866

      2086
      IBM NLDG Volume 2 (SE09-8002-03) August 1994
      cp866
      866
      csIBM866


      IBM775
      Hewlett-Packard Company, "HP PCL 5 Comparison Guide",
(P/N 5021-0329) pp B-13, 1996.
      2087
      HP PCL 5 Comparison Guide (P/N 5021-0329) pp B-13, 1996
      cp775
      csPC775Baltic


      KOI8-U

      2088



      csKOI8U


      IBM00858
      2089
      IBM See
      CCSID00858
      CP00858
      PC-Multilingual-850+euro
      csIBM00858


      IBM00924
      2090
      IBM See
      CCSID00924
      CP00924
      ebcdic-Latin9--euro
      csIBM00924


      IBM01140
      2091
      IBM See
      CCSID01140
      CP01140
      ebcdic-us-37+euro
      csIBM01140


      IBM01141
      2092
      IBM See
      CCSID01141
      CP01141
      ebcdic-de-273+euro
      csIBM01141


      IBM01142
      2093
      IBM See
      CCSID01142
      CP01142
      ebcdic-dk-277+euro
      ebcdic-no-277+euro
      csIBM01142


      IBM01143
      2094
      IBM See
      CCSID01143
      CP01143
      ebcdic-fi-278+euro
      ebcdic-se-278+euro
      csIBM01143


      IBM01144
      2095
      IBM See
      CCSID01144
      CP01144
      ebcdic-it-280+euro
      csIBM01144


      IBM01145
      2096
      IBM See
      CCSID01145
      CP01145
      ebcdic-es-284+euro
      csIBM01145


      IBM01146
      2097
      IBM See
      CCSID01146
      CP01146
      ebcdic-gb-285+euro
      csIBM01146


      IBM01147
      2098
      IBM See
      CCSID01147
      CP01147
      ebcdic-fr-297+euro
      csIBM01147


      IBM01148
      2099
      IBM See
      CCSID01148
      CP01148
      ebcdic-international-500+euro
      csIBM01148


      IBM01149
      2100
      IBM See
      CCSID01149
      CP01149
      ebcdic-is-871+euro
      csIBM01149


      Big5-HKSCS

      2101
      See
      csBig5HKSCS


      IBM1047

      2102
      IBM1047 (EBCDIC Latin 1/Open Systems)

      IBM-1047
      csIBM1047


      PTCP154

      2103
      See
      csPTCP154
      PT154
      CP154
      Cyrillic-Asian
      csPTCP154


      Amiga-1251
      2104
      See
      Ami1251
      Amiga1251
      Ami-1251
      csAmiga1251
(Aliases are provided for historical reasons and should not be used) [Malyshev]


      KOI7-switched
      2105
      See
      csKOI7switched


      BRF
      2106
      See
      csBRF


      TSCII
      2107
      See
      csTSCII


      CP51932
      2108
      See
      csCP51932


      windows-874
      2109
      See
      cswindows874


      windows-1250
      2250
      Microsoft
      cswindows1250


      windows-1251
      2251
      Microsoft
      cswindows1251


      windows-1252
      2252
      Microsoft
      cswindows1252


      windows-1253
      2253
      Microsoft
      cswindows1253


      windows-1254
      2254
      Microsoft
      cswindows1254


      windows-1255
      2255
      Microsoft
      cswindows1255


      windows-1256
      2256
      Microsoft
      cswindows1256


      windows-1257
      2257
      Microsoft
      cswindows1257


      windows-1258
      2258
      Microsoft
      cswindows1258


      TIS-620
      2259
      Thai Industrial Standards Institute (TISI)
      csTIS620
      ISO-8859-11


      CP50220
      2260
      See
      csCP50220




      Alexander Uskov
      mailto:auskov&idc.kz
      2002-09


      Alexei Veremeev
      mailto:Alexey.Veremeev&oracle.com
      2006-12-07


      Chris Wendt
      mailto:christw&microsoft.com
      1999-12


      Hank Nussbacher
      mailto:hank&vm.tau.ac.il


      Internet Assigned Numbers Authority
      mailto:iana&iana.org


      Jun Murai
      mailto:jun&wide.ad.jp


      Katya Lazhintseva
      mailto:katyal&microsoft.com
      1996-05


      Keld Simonsen
      mailto:Keld.Simonsen&dkuug.dk


      Keld Simonsen
      mailto:Keld.Simonsen&rap.dk
      2000-08


      Kuppuswamy Kalyanasundaram
      mailto:kalyan.geo&yahoo.com
      2007-05-14


      Mark Davis
      mailto:mark&unicode.org
      2002-04


      Markus Scherer
      mailto:markus.scherer&jtcsv.com
      2002-09


      Masataka Ohta
      mailto:mohta&cc.titech.ac.jp
      1995-07


      Nicky Yick
      mailto:cliac&itsd.gcn.gov.hk
      2000-10


      Reuel Robrigado
      mailto:reuelr&ca.ibm.com
      2002-09


      Rick Pond
      mailto:rickpond&vnet.ibm.com
      1997-03


      Sairan M. Kikkarin
      mailto:sairan&sci.kz
      2006-12-07


      Samuel Thibault
      mailto:samuel.thibault&ens-lyon.org
      2006-12-07


      Shawn Steele
      mailto:Shawn.Steele&microsoft.com
      2010-11-04


      Tamer Mahdi
      mailto:tamer&ca.ibm.com
      2000-08


      Toby Phipps
      mailto:tphipps&peoplesoft.com
      2002-03


      Trin Tantsetthi
      mailto:trin&mozart.inet.co.th
      1998-09


      Vladas Tumasonis
      mailto:vladas.tumasonis&maf.vu.lt
      2000-08


      Woohyong Choi
      mailto:whchoi&cosmos.kaist.ac.kr


      Yui Naruse
      mailto:naruse&airemix.jp
      2011-09-23



EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
  } # _init_data

1;

__END__