[p5sagit/p5-mst-13.2.git] / ext / Encode / lib / Encode / Alias.pm

package Encode::Alias;
use strict;
use Encode;
our $VERSION = do { my @r = (q$Revision: 1.26 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
our $DEBUG = 0;
require Exporter;

our @ISA = qw(Exporter);

# Public, encouraged API is exported by default

our @EXPORT = 
    qw (
	define_alias
	find_alias
	);

our @Alias;  # ordered matching list
our %Alias;  # cached known aliases

sub find_alias
{
    my $class = shift;
    local $_ = shift;
    unless (exists $Alias{$_})
    {
	for (my $i=0; $i < @Alias; $i += 2)
	{
	    my $alias = $Alias[$i];
	    my $val   = $Alias[$i+1];
	    my $new;
	    if (ref($alias) eq 'Regexp' && $_ =~ $alias)
	    {
		$DEBUG and warn "eval $val";
		$new = eval $val;
		# $@ and warn "$val, $@";
	    }
	    elsif (ref($alias) eq 'CODE')
	    {
		$DEBUG and warn "$alias", "->", "($val)";
		$new = $alias->($val);
	    }
	    elsif (lc($_) eq lc($alias))
	    {
		$new = $val;
	    }
	    if (defined($new))
	    {
		next if $new eq $_; # avoid (direct) recursion on bugs
		$DEBUG and warn "$alias, $new";
		my $enc = (ref($new)) ? $new : Encode::find_encoding($new);
		if ($enc)
		{
		    $Alias{$_} = $enc;
		    last;
		}
	    }
	}
    }
    if ($DEBUG){
	my $name;
	if (my $e = $Alias{$_}){
	    $name = $e->name;
	}else{
	    $name = "";
	}
	warn "find_alias($class, $_)->name = $name";
    }
    return $Alias{$_};
}

sub define_alias
{
    while (@_)
    {
	my ($alias,$name) = splice(@_,0,2);
	unshift(@Alias, $alias => $name);   # newer one has precedence
	# clear %Alias cache to allow overrides
	if (ref($alias)){
	    my @a = keys %Alias;
	    for my $k (@a){
		if (ref($alias) eq 'Regexp' && $k =~ $alias)
		{
		    $DEBUG and warn "delete \$Alias\{$k\}";
		    delete $Alias{$k};
		}
		elsif (ref($alias) eq 'CODE')
		{
		    $DEBUG and warn "delete \$Alias\{$k\}";
		    delete $Alias{$alias->($name)};
		}
	    }
	}else{
	    $DEBUG and warn "delete \$Alias\{$alias\}";
	    delete $Alias{$alias};
	}
    }
}

# Allow latin-1 style names as well
                     # 0  1  2  3  4  5   6   7   8   9  10
our @Latin2iso = ( 0, 1, 2, 3, 4, 9, 10, 13, 14, 15, 16 );
# Allow winlatin1 style names as well
our %Winlatin2cp   = (
		      'latin1'     => 1252,
		      'latin2'     => 1250,
		      'cyrillic'   => 1251,
		      'greek'      => 1253,
		      'turkish'    => 1254,
		      'hebrew'     => 1255,
		      'arabic'     => 1256,
		      'baltic'     => 1257,
		      'vietnamese' => 1258,
		     );

init_aliases();

sub undef_aliases{
    @Alias = ();
    %Alias = ();
}

sub init_aliases
{
    undef_aliases();

    # Try all-lower-case version should all else fails
    define_alias( qr/^(.*)$/ => '"\L$1"' );

    # UTF/UCS stuff
    define_alias( qr/^UCS-?2-?LE$/i    => '"UCS-2LE"' );
    define_alias( qr/^UCS-?2-?(BE)?$/i => '"UCS-2BE"',
		  qr/^iso-10646-1$/i   => '"UCS-2BE"' );
    define_alias( qr/^UTF(16|32)-?BE$/i => '"UTF-$1BE"',
		  qr/^UTF(16|32)-?LE$/i => '"UTF-$1LE"',
		  qr/^UTF(16|32)$/i     => '"UTF-$1"',
		);
    # ASCII
    define_alias(qr/^(?:US-?)ascii$/i => '"ascii"');
    define_alias('C' => 'ascii');
    # Allow variants of iso-8859-1 etc.
    define_alias( qr/\biso[-_]?(\d+)[-_](\d+)$/i => '"iso-$1-$2"' );

    # At least HP-UX has these.
    define_alias( qr/\biso8859(\d+)$/i => '"iso-8859-$1"' );

    # More HP stuff.
    define_alias( qr/\b(?:hp-)?(arabic|greek|hebrew|kana|roman|thai|turkish)8$/i => '"${1}8"' );

    # The Official name of ASCII.
    define_alias( qr/\bANSI[-_]?X3\.4[-_]?1968$/i => '"ascii"' );

    # This is a font issue, not an encoding issue.
    # (The currency symbol of the Latin 1 upper half
    #  has been redefined as the euro symbol.)
    define_alias( qr/^(.+)\@euro$/i => '"$1"' );

    define_alias( qr/\b(?:iso[-_]?)?latin[-_]?(\d+)$/i 
		  => '"iso-8859-$Encode::Alias::Latin2iso[$1]"' );

    define_alias( qr/\bwin(latin[12]|cyrillic|baltic|greek|turkish|
			 hebrew|arabic|baltic|vietnamese)$/ix => 
		  '"cp" . $Encode::Alias::Winlatin2cp{lc($1)}' );

    # Common names for non-latin prefered MIME names
    define_alias( 'ascii'    => 'US-ascii',
		  'cyrillic' => 'iso-8859-5',
		  'arabic'   => 'iso-8859-6',
		  'greek'    => 'iso-8859-7',
		  'hebrew'   => 'iso-8859-8',
		  'thai'     => 'iso-8859-11',
		  'tis620'   => 'iso-8859-11',
		  );

    # At least AIX has IBM-NNN (surprisingly...) instead of cpNNN.
    # And Microsoft has their own naming (again, surprisingly).
    # And windows-* is registered in IANA! 
    define_alias( qr/\b(?:ibm|ms|windows)[-_]?(\d\d\d\d?)$/i => '"cp$1"');

    # Sometimes seen with a leading zero.
    # define_alias( qr/\bcp037\b/i => '"cp37"');

    # Mac Mappings
    # predefined in *.ucm; unneeded
    # define_alias( qr/\bmacIcelandic$/i => '"macIceland"');
    define_alias( qr/^mac_(.*)$/i => '"mac$1"');
    # Ououououou. gone.  They are differente!
    # define_alias( qr/\bmacRomanian$/i => '"macRumanian"');
  
    # Standardize on the dashed versions.
    # define_alias( qr/\butf8$/i  => 'utf-8' );
    define_alias( qr/\bkoi8r$/i => 'koi8-r' );
    define_alias( qr/\bkoi8u$/i => 'koi8-u' );

    unless ($Encode::ON_EBCDIC){
        # for Encode::CN
	define_alias( qr/\beuc.*cn$/i        => '"euc-cn"' );
	define_alias( qr/\bcn.*euc$/i        => '"euc-cn"' );
	# define_alias( qr/\bGB[- ]?(\d+)$/i => '"euc-cn"' )
	# CP936 doesn't have vendor-addon for GBK, so they're identical.
	define_alias( qr/^gbk$/i => '"cp936"');
	# This fixes gb2312 vs. euc-cn confusion, practically
	define_alias( qr/\bGB[-_ ]?2312(?:\D.*$|$)/i => '"euc-cn"' );
	# for Encode::JP
	define_alias( qr/\bjis$/i            => '"7bit-jis"' );
	define_alias( qr/\beuc.*jp$/i        => '"euc-jp"' );
	define_alias( qr/\bjp.*euc$/i        => '"euc-jp"' );
	define_alias( qr/\bujis$/i           => '"euc-jp"' );
	define_alias( qr/\bshift.*jis$/i     => '"shiftjis"' );
	define_alias( qr/\bsjis$/i           => '"shiftjis"' );
        # for Encode::KR
	define_alias( qr/\beuc.*kr$/i        => '"euc-kr"' );
	define_alias( qr/\bkr.*euc$/i        => '"euc-kr"' );
	# This fixes ksc5601 vs. euc-kr confusion, practically
        define_alias( qr/(?:x-)?uhc$/i            => '"cp949"' );
        define_alias( qr/(?:x-)?windows-949$/i    => '"cp949"' );
        define_alias( qr/\bks_c_5601-1987$/i      => '"cp949"' );
        # for Encode::TW
	define_alias( qr/\bbig-?5$/i		  => '"big5"' );
	define_alias( qr/\bbig5-hk(?:scs)?$/i	  => '"big5-hkscs"' );
    }
    # utf8 is blessed :)
    define_alias( qr/^UTF-8$/i => '"utf8"',);
    # At last, Map white space and _ to '-'
    define_alias( qr/^(\S+)[\s_]+(.*)$/i => '"$1-$2"' );
}

1;
__END__

# TODO: HP-UX '8' encodings arabic8 greek8 hebrew8 kana8 thai8 turkish8
# TODO: HP-UX '15' encodings japanese15 korean15 roi15
# TODO: Cyrillic encoding ISO-IR-111 (useful?)
# TODO: Armenian encoding ARMSCII-8
# TODO: Hebrew encoding ISO-8859-8-1
# TODO: Thai encoding TCVN
# TODO: Vietnamese encodings VPS
# TODO: Mac Asian+African encodings: Arabic Armenian Bengali Burmese
#       ChineseSimp ChineseTrad Devanagari Ethiopic ExtArabic
#       Farsi Georgian Gujarati Gurmukhi Hebrew Japanese
#       Kannada Khmer Korean Laotian Malayalam Mongolian
#       Oriya Sinhalese Symbol Tamil Telugu Tibetan Vietnamese

=head1 NAME

Encode::Alias - alias defintions to encodings

=head1 SYNOPSIS

  use Encode;
  use Encode::Alias;
  define_alias( newName => ENCODING);

=head1 DESCRIPTION

Allows newName to be used as an alias for ENCODING. ENCODING may be
either the name of an encoding or an encoding object (as described 
in L<Encode>).

Currently I<newName> can be specified in the following ways:

=over 4

=item As a simple string.

=item As a qr// compiled regular expression, e.g.:

  define_alias( qr/^iso8859-(\d+)$/i => '"iso-8859-$1"' );

In this case if I<ENCODING> is not a reference it is C<eval>-ed to
allow C<$1> etc. to be substituted.  The example is one way to alias
names as used in X11 fonts to the MIME names for the iso-8859-*
family.  Note the double quote inside the single quote.

If you are using a regex here, you have to use the quotes as shown or
it won't work.  Also note that regex handling is tricky even for the
experienced.  Use it with caution.

=item As a code reference, e.g.:

  define_alias( sub { return /^iso8859-(\d+)$/i ? "iso-8859-$1" : undef } , '');


In this case C<$_> will be set to the name that is being looked up and
I<ENCODING> is passed to the sub as its first argument.  The example
is another way to alias names as used in X11 fonts to the MIME names
for the iso-8859-* family.

=back

=head2  Alias overloading

You can override predefined aliases by simply applying define_alias().
New alias is always evaluated first and when neccessary define_alias()
flushes internal cache to make new definition available.

  # redirect  SHIFT_JIS to MS/IBM Code Page 932, which is a
  # superset of SHIFT_JIS

  define_alias( qr/shift.*jis$/i  => '"cp932"' );
  define_alias( qr/sjis$/i        => '"cp932"' );

If you want to zap all predefined aliases, you can

  Encode::Alias->undef_aliases;

to do so.  And

  Encode::Alias->init_aliases;

gets factory setting back.


=head1 SEE ALSO

L<Encode>, L<Encode::Supported>

=cut
Commit	Line	Data
5d030b67	1	package Encode::Alias;
5d030b67	2	use strict;
5129552c	3	use Encode;
c731e18e	4	our $VERSION = do { my @r = (q$Revision: 1.26 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
5d030b67	5	our $DEBUG = 0;
	6	require Exporter;
	7
	8	our @ISA = qw(Exporter);
	9
	10	# Public, encouraged API is exported by default
5129552c	11
	12	our @EXPORT =
	13	qw (
	14	define_alias
	15	find_alias
	16	);
5d030b67	17
	18	our @Alias; # ordered matching list
	19	our %Alias; # cached known aliases
	20
5129552c	21	sub find_alias
5d030b67	22	{
	23	my $class = shift;
	24	local $_ = shift;
	25	unless (exists $Alias{$_})
	26	{
	27	for (my $i=0; $i < @Alias; $i += 2)
	28	{
	29	my $alias = $Alias[$i];
	30	my $val = $Alias[$i+1];
	31	my $new;
	32	if (ref($alias) eq 'Regexp' && $_ =~ $alias)
	33	{
a63c962f	34	$DEBUG and warn "eval $val";
5d030b67	35	$new = eval $val;
	36	# $@ and warn "$val, $@";
	37	}
	38	elsif (ref($alias) eq 'CODE')
	39	{
a63c962f	40	$DEBUG and warn "$alias", "->", "($val)";
5d030b67	41	$new = $alias->($val);
	42	}
	43	elsif (lc($_) eq lc($alias))
	44	{
	45	$new = $val;
	46	}
	47	if (defined($new))
	48	{
	49	next if $new eq $_; # avoid (direct) recursion on bugs
a63c962f	50	$DEBUG and warn "$alias, $new";
5d030b67	51	my $enc = (ref($new)) ? $new : Encode::find_encoding($new);
	52	if ($enc)
	53	{
	54	$Alias{$_} = $enc;
	55	last;
	56	}
	57	}
	58	}
	59	}
a63c962f	60	if ($DEBUG){
	61	my $name;
	62	if (my $e = $Alias{$_}){
	63	$name = $e->name;
	64	}else{
	65	$name = "";
	66	}
	67	warn "find_alias($class, $_)->name = $name";
	68	}
5d030b67	69	return $Alias{$_};
	70	}
	71
	72	sub define_alias
	73	{
	74	while (@_)
	75	{
	76	my ($alias,$name) = splice(@_,0,2);
	77	unshift(@Alias, $alias => $name); # newer one has precedence
	78	# clear %Alias cache to allow overrides
	79	if (ref($alias)){
5129552c	80	my @a = keys %Alias;
5129552c	81	for my $k (@a){
5d030b67	82	if (ref($alias) eq 'Regexp' && $k =~ $alias)
5d030b67	83	{
a63c962f	84	$DEBUG and warn "delete \$Alias\{$k\}";
5d030b67	85	delete $Alias{$k};
	86	}
	87	elsif (ref($alias) eq 'CODE')
	88	{
a63c962f	89	$DEBUG and warn "delete \$Alias\{$k\}";
5d030b67	90	delete $Alias{$alias->($name)};
	91	}
	92	}
	93	}else{
a63c962f	94	$DEBUG and warn "delete \$Alias\{$alias\}";
5d030b67	95	delete $Alias{$alias};
	96	}
	97	}
	98	}
	99
5d030b67	100	# Allow latin-1 style names as well
	101	# 0 1 2 3 4 5 6 7 8 9 10
	102	our @Latin2iso = ( 0, 1, 2, 3, 4, 9, 10, 13, 14, 15, 16 );
5d030b67	103	# Allow winlatin1 style names as well
	104	our %Winlatin2cp = (
	105	'latin1' => 1252,
	106	'latin2' => 1250,
	107	'cyrillic' => 1251,
	108	'greek' => 1253,
	109	'turkish' => 1254,
	110	'hebrew' => 1255,
	111	'arabic' => 1256,
	112	'baltic' => 1257,
	113	'vietnamese' => 1258,
	114	);
	115
5129552c	116	init_aliases();
	117
	118	sub undef_aliases{
	119	@Alias = ();
	120	%Alias = ();
	121	}
	122
	123	sub init_aliases
	124	{
	125	undef_aliases();
a999c27c	126
f2a2953c	127	# Try all-lower-case version should all else fails
a999c27c	128	define_alias( qr/^(.*)$/ => '"\L$1"' );
a999c27c	129
f2a2953c	130	# UTF/UCS stuff
	131	define_alias( qr/^UCS-?2-?LE$/i => '"UCS-2LE"' );
	132	define_alias( qr/^UCS-?2-?(BE)?$/i => '"UCS-2BE"',
	133	qr/^iso-10646-1$/i => '"UCS-2BE"' );
	134	define_alias( qr/^UTF(16\|32)-?BE$/i => '"UTF-$1BE"',
	135	qr/^UTF(16\|32)-?LE$/i => '"UTF-$1LE"',
	136	qr/^UTF(16\|32)$/i => '"UTF-$1"',
	137	);
	138	# ASCII
a999c27c	139	define_alias(qr/^(?:US-?)ascii$/i => '"ascii"');
a999c27c	140	define_alias('C' => 'ascii');
67d7b5ef	141	# Allow variants of iso-8859-1 etc.
67d7b5ef	142	define_alias( qr/\biso[-_]?(\d+)[-_](\d+)$/i => '"iso-$1-$2"' );
5129552c	143
67d7b5ef	144	# At least HP-UX has these.
67d7b5ef	145	define_alias( qr/\biso8859(\d+)$/i => '"iso-8859-$1"' );
5129552c	146
67d7b5ef	147	# More HP stuff.
67d7b5ef	148	define_alias( qr/\b(?:hp-)?(arabic\|greek\|hebrew\|kana\|roman\|thai\|turkish)8$/i => '"${1}8"' );
5129552c	149
67d7b5ef	150	# The Official name of ASCII.
67d7b5ef	151	define_alias( qr/\bANSI[-_]?X3\.4[-_]?1968$/i => '"ascii"' );
5129552c	152
67d7b5ef	153	# This is a font issue, not an encoding issue.
	154	# (The currency symbol of the Latin 1 upper half
	155	# has been redefined as the euro symbol.)
5129552c	156	define_alias( qr/^(.+)\@euro$/i => '"$1"' );
5129552c	157
67d7b5ef	158	define_alias( qr/\b(?:iso[-_]?)?latin[-_]?(\d+)$/i
5129552c	159	=> '"iso-8859-$Encode::Alias::Latin2iso[$1]"' );
5129552c	160
67d7b5ef	161	define_alias( qr/\bwin(latin[12]\|cyrillic\|baltic\|greek\|turkish\|
5129552c	162	hebrew\|arabic\|baltic\|vietnamese)$/ix =>
5129552c	163	'"cp" . $Encode::Alias::Winlatin2cp{lc($1)}' );
5d030b67	164
67d7b5ef	165	# Common names for non-latin prefered MIME names
5129552c	166	define_alias( 'ascii' => 'US-ascii',
	167	'cyrillic' => 'iso-8859-5',
	168	'arabic' => 'iso-8859-6',
	169	'greek' => 'iso-8859-7',
	170	'hebrew' => 'iso-8859-8',
	171	'thai' => 'iso-8859-11',
	172	'tis620' => 'iso-8859-11',
	173	);
5d030b67	174
67d7b5ef	175	# At least AIX has IBM-NNN (surprisingly...) instead of cpNNN.
	176	# And Microsoft has their own naming (again, surprisingly).
	177	# And windows-* is registered in IANA!
	178	define_alias( qr/\b(?:ibm\|ms\|windows)[-_]?(\d\d\d\d?)$/i => '"cp$1"');
5d030b67	179
67d7b5ef	180	# Sometimes seen with a leading zero.
c731e18e	181	# define_alias( qr/\bcp037\b/i => '"cp37"');
5d030b67	182
3ef515df	183	# Mac Mappings
a999c27c	184	# predefined in *.ucm; unneeded
a999c27c	185	# define_alias( qr/\bmacIcelandic$/i => '"macIceland"');
3ef515df	186	define_alias( qr/^mac_(.*)$/i => '"mac$1"');
a999c27c	187	# Ououououou. gone. They are differente!
a999c27c	188	# define_alias( qr/\bmacRomanian$/i => '"macRumanian"');
f2a2953c	189
f2a2953c	190	# Standardize on the dashed versions.
67d7b5ef	191	# define_alias( qr/\butf8$/i => 'utf-8' );
	192	define_alias( qr/\bkoi8r$/i => 'koi8-r' );
	193	define_alias( qr/\bkoi8u$/i => 'koi8-u' );
5129552c	194
a63c962f	195	unless ($Encode::ON_EBCDIC){
a63c962f	196	# for Encode::CN
67d7b5ef	197	define_alias( qr/\beuc.*cn$/i => '"euc-cn"' );
	198	define_alias( qr/\bcn.*euc$/i => '"euc-cn"' );
	199	# define_alias( qr/\bGB[- ]?(\d+)$/i => '"euc-cn"' )
	200	# CP936 doesn't have vendor-addon for GBK, so they're identical.
	201	define_alias( qr/^gbk$/i => '"cp936"');
	202	# This fixes gb2312 vs. euc-cn confusion, practically
	203	define_alias( qr/\bGB[-_ ]?2312(?:\D.*$\|$)/i => '"euc-cn"' );
	204	# for Encode::JP
	205	define_alias( qr/\bjis$/i => '"7bit-jis"' );
	206	define_alias( qr/\beuc.*jp$/i => '"euc-jp"' );
	207	define_alias( qr/\bjp.*euc$/i => '"euc-jp"' );
	208	define_alias( qr/\bujis$/i => '"euc-jp"' );
	209	define_alias( qr/\bshift.*jis$/i => '"shiftjis"' );
	210	define_alias( qr/\bsjis$/i => '"shiftjis"' );
a63c962f	211	# for Encode::KR
67d7b5ef	212	define_alias( qr/\beuc.*kr$/i => '"euc-kr"' );
	213	define_alias( qr/\bkr.*euc$/i => '"euc-kr"' );
	214	# This fixes ksc5601 vs. euc-kr confusion, practically
	215	define_alias( qr/(?:x-)?uhc$/i => '"cp949"' );
	216	define_alias( qr/(?:x-)?windows-949$/i => '"cp949"' );
	217	define_alias( qr/\bks_c_5601-1987$/i => '"cp949"' );
a63c962f	218	# for Encode::TW
67d7b5ef	219	define_alias( qr/\bbig-?5$/i => '"big5"' );
67d7b5ef	220	define_alias( qr/\bbig5-hk(?:scs)?$/i => '"big5-hkscs"' );
a63c962f	221	}
f2a2953c	222	# utf8 is blessed :)
f2a2953c	223	define_alias( qr/^UTF-8$/i => '"utf8"',);
67d7b5ef	224	# At last, Map white space and _ to '-'
5129552c	225	define_alias( qr/^(\S+)[\s_]+(.*)$/i => '"$1-$2"' );
	226	}
	227
	228	1;
	229	__END__
5d030b67	230
	231	# TODO: HP-UX '8' encodings arabic8 greek8 hebrew8 kana8 thai8 turkish8
	232	# TODO: HP-UX '15' encodings japanese15 korean15 roi15
	233	# TODO: Cyrillic encoding ISO-IR-111 (useful?)
	234	# TODO: Armenian encoding ARMSCII-8
	235	# TODO: Hebrew encoding ISO-8859-8-1
	236	# TODO: Thai encoding TCVN
5d030b67	237	# TODO: Vietnamese encodings VPS
	238	# TODO: Mac Asian+African encodings: Arabic Armenian Bengali Burmese
	239	# ChineseSimp ChineseTrad Devanagari Ethiopic ExtArabic
	240	# Farsi Georgian Gujarati Gurmukhi Hebrew Japanese
	241	# Kannada Khmer Korean Laotian Malayalam Mongolian
	242	# Oriya Sinhalese Symbol Tamil Telugu Tibetan Vietnamese
	243
5d030b67	244	=head1 NAME
	245
	246	Encode::Alias - alias defintions to encodings
	247
	248	=head1 SYNOPSIS
	249
5129552c	250	use Encode;
5129552c	251	use Encode::Alias;
5d030b67	252	define_alias( newName => ENCODING);
	253
	254	=head1 DESCRIPTION
	255
3ef515df	256	Allows newName to be used as an alias for ENCODING. ENCODING may be
	257	either the name of an encoding or an encoding object (as described
	258	in L<Encode>).
5d030b67	259
	260	Currently I<newName> can be specified in the following ways:
	261
	262	=over 4
	263
	264	=item As a simple string.
	265
	266	=item As a qr// compiled regular expression, e.g.:
	267
	268	define_alias( qr/^iso8859-(\d+)$/i => '"iso-8859-$1"' );
	269
	270	In this case if I<ENCODING> is not a reference it is C<eval>-ed to
3ef515df	271	allow C<$1> etc. to be substituted. The example is one way to alias
	272	names as used in X11 fonts to the MIME names for the iso-8859-*
	273	family. Note the double quote inside the single quote.
5d030b67	274
3ef515df	275	If you are using a regex here, you have to use the quotes as shown or
	276	it won't work. Also note that regex handling is tricky even for the
	277	experienced. Use it with caution.
5d030b67	278
	279	=item As a code reference, e.g.:
	280
	281	define_alias( sub { return /^iso8859-(\d+)$/i ? "iso-8859-$1" : undef } , '');
	282
3ef515df	283
5d030b67	284	In this case C<$_> will be set to the name that is being looked up and
5d030b67	285	I<ENCODING> is passed to the sub as its first argument. The example
3ef515df	286	is another way to alias names as used in X11 fonts to the MIME names
3ef515df	287	for the iso-8859-* family.
5d030b67	288
5129552c	289	=back
	290
	291	=head2 Alias overloading
5d030b67	292
3ef515df	293	You can override predefined aliases by simply applying define_alias().
5d030b67	294	New alias is always evaluated first and when neccessary define_alias()
	295	flushes internal cache to make new definition available.
	296
	297	# redirect SHIFT_JIS to MS/IBM Code Page 932, which is a
	298	# superset of SHIFT_JIS
	299
5129552c	300	define_alias( qr/shift.*jis$/i => '"cp932"' );
	301	define_alias( qr/sjis$/i => '"cp932"' );
	302
	303	If you want to zap all predefined aliases, you can
	304
	305	Encode::Alias->undef_aliases;
	306
	307	to do so. And
	308
	309	Encode::Alias->init_aliases;
	310
	311	gets factory setting back.
	312
5d030b67	313
	314	=head1 SEE ALSO
	315
	316	L<Encode>, L<Encode::Supported>
	317
5129552c	318	=cut
5d030b67	319