This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
charnames pragma extended with :alias for customized
authorH.Merijn Brand <h.m.brand@xs4all.nl>
Thu, 24 Oct 2002 08:20:09 +0000 (08:20 +0000)
committerH.Merijn Brand <h.m.brand@xs4all.nl>
Thu, 24 Oct 2002 08:20:09 +0000 (08:20 +0000)
unicode naming aliases
Mon, 21 Oct 2002; "H.Merijn Brand" <h.m.brand@hccnet.nl>

p4raw-id: //depot/perl@18053

lib/charnames.pm
lib/charnames.t

index fc3ad8b..6037ea8 100644 (file)
@@ -2,7 +2,7 @@ package charnames;
 use strict;
 use warnings;
 use Carp;
-our $VERSION = '1.01';
+our $VERSION = '1.02';
 
 use bytes ();          # for $bytes::hint_bits
 $charnames::hint_bits = 0x20000;
@@ -38,20 +38,44 @@ my %alias2 = (
                'PARTIAL LINE UP'       => 'PARTIAL LINE BACKWARD',
            );
 
+my %alias3 = (
+               # User defined aliasses. Even more convenient :)
+           );
 my $txt;
 
+sub alias (@)
+{
+  @_ or return %alias3;
+  my $alias = ref $_[0] ? $_[0] : { @_ };
+  @alias3{keys %$alias} = values %$alias;
+} # alias
+
+sub alias_file ($)
+{
+  my $arg = shift;
+  my $file = -f $arg ? $arg : "unicore/${arg}_alias.pl";
+  if (my @alias = do $file) {
+    alias (@alias);
+    return (1);
+  }
+  0;
+} # alias_file
+
 # This is not optimized in any way yet
 sub charnames
 {
   my $name = shift;
 
   if (exists $alias1{$name}) {
-      $name = $alias1{$name};
+    $name = $alias1{$name};
   }
-  if (exists $alias2{$name}) {
-      require warnings;
-      warnings::warnif('deprecated', qq{Unicode character name "$name" is deprecated, use "$alias2{$name}" instead});
-      $name = $alias2{$name};
+  elsif (exists $alias2{$name}) {
+    require warnings;
+    warnings::warnif('deprecated', qq{Unicode character name "$name" is deprecated, use "$alias2{$name}" instead});
+    $name = $alias2{$name};
+  }
+  elsif (exists $alias3{$name}) {
+    $name = $alias3{$name};
   }
 
   my $ord;
@@ -59,72 +83,70 @@ sub charnames
   my $fname;
 
   if ($name eq "BYTE ORDER MARK") {
-      $fname = $name;
-      $ord = 0xFEFF;
+    $fname = $name;
+    $ord = 0xFEFF;
   } else {
-      ## Suck in the code/name list as a big string.
-      ## Lines look like:
-      ##     "0052\t\tLATIN CAPITAL LETTER R\n"
-      $txt = do "unicore/Name.pl" unless $txt;
-
-      ## @off will hold the index into the code/name string of the start and
-      ## end of the name as we find it.
-      
-      ## If :full, look for the the name exactly
-      if ($^H{charnames_full} and $txt =~ /\t\t\Q$name\E$/m) {
+    ## Suck in the code/name list as a big string.
+    ## Lines look like:
+    ##     "0052\t\tLATIN CAPITAL LETTER R\n"
+    $txt = do "unicore/Name.pl" unless $txt;
+
+    ## @off will hold the index into the code/name string of the start and
+    ## end of the name as we find it.
+
+    ## If :full, look for the the name exactly
+    if ($^H{charnames_full} and $txt =~ /\t\t\Q$name\E$/m) {
+      @off = ($-[0], $+[0]);
+    }
+
+    ## If we didn't get above, and :short allowed, look for the short name.
+    ## The short name is like "greek:Sigma"
+    unless (@off) {
+      if ($^H{charnames_short} and $name =~ /^(.+?):(.+)/s) {
+       my ($script, $cname) = ($1, $2);
+       my $case = $cname =~ /[[:upper:]]/ ? "CAPITAL" : "SMALL";
+       if ($txt =~ m/\t\t\U$script\E (?:$case )?LETTER \U\Q$cname\E$/m) {
          @off = ($-[0], $+[0]);
+       }
       }
+    }
 
-      ## If we didn't get above, and :short allowed, look for the short name.
-      ## The short name is like "greek:Sigma"
-      unless (@off) {
-         if ($^H{charnames_short} and $name =~ /^(.+?):(.+)/s) {
-             my ($script, $cname) = ($1,$2);
-             my $case = ( $cname =~ /[[:upper:]]/ ? "CAPITAL" : "SMALL");
-             if ($txt =~ m/\t\t\U$script\E (?:$case )?LETTER \U\Q$cname\E$/m) {
-                 @off = ($-[0], $+[0]);
-             }
-         }
-      }
-      
-      ## If we still don't have it, check for the name among the loaded
-      ## scripts.
-      if (not @off)
-      {
-         my $case = ( $name =~ /[[:upper:]]/ ? "CAPITAL" : "SMALL");
-         for my $script ( @{$^H{charnames_scripts}} )
-         {
-             if ($txt =~ m/\t\t$script (?:$case )?LETTER \U\Q$name\E$/m) {
-                 @off = ($-[0], $+[0]);
-                 last;
-             }
-         }
-      }
-      
-      ## If we don't have it by now, give up.
-      unless (@off) {
-         carp "Unknown charname '$name'";
-         return "\x{FFFD}";
+    ## If we still don't have it, check for the name among the loaded
+    ## scripts.
+    if (not @off) {
+      my $case = $name =~ /[[:upper:]]/ ? "CAPITAL" : "SMALL";
+      for my $script (@{$^H{charnames_scripts}}) {
+       if ($txt =~ m/\t\t$script (?:$case )?LETTER \U\Q$name\E$/m) {
+         @off = ($-[0], $+[0]);
+         last;
+       }
       }
-      
-      ##
-      ## Now know where in the string the name starts.
-      ## The code, in hex, is before that.
-      ##
-      ## The code can be 4-6 characters long, so we've got to sort of
-      ## go look for it, just after the newline that comes before $off[0].
-      ##
-      ## This would be much easier if unicore/Name.pl had info in
-      ## a name/code order, instead of code/name order.
-      ##
-      ## The +1 after the rindex() is to skip past the newline we're finding,
-      ## or, if the rindex() fails, to put us to an offset of zero.
-      ##
-      my $hexstart = rindex($txt, "\n", $off[0]) + 1;
-
-      ## we know where it starts, so turn into number -
-      ## the ordinal for the char.
-      $ord = hex substr($txt, $hexstart, $off[0] - $hexstart);
+    }
+
+    ## If we don't have it by now, give up.
+    unless (@off) {
+      carp "Unknown charname '$name'";
+      return "\x{FFFD}";
+    }
+
+    ##
+    ## Now know where in the string the name starts.
+    ## The code, in hex, is before that.
+    ##
+    ## The code can be 4-6 characters long, so we've got to sort of
+    ## go look for it, just after the newline that comes before $off[0].
+    ##
+    ## This would be much easier if unicore/Name.pl had info in
+    ## a name/code order, instead of code/name order.
+    ##
+    ## The +1 after the rindex() is to skip past the newline we're finding,
+    ## or, if the rindex() fails, to put us to an offset of zero.
+    ##
+    my $hexstart = rindex($txt, "\n", $off[0]) + 1;
+
+    ## we know where it starts, so turn into number -
+    ## the ordinal for the char.
+    $ord = hex substr($txt, $hexstart, $off[0] - $hexstart);
   }
 
   if ($^H & $bytes::hint_bits) {       # "use bytes" in effect?
@@ -132,22 +154,21 @@ sub charnames
     return chr $ord if $ord <= 255;
     my $hex = sprintf "%04x", $ord;
     if (not defined $fname) {
-       $fname = substr $txt, $off[0] + 2, $off[1] - $off[0] - 2;
+      $fname = substr $txt, $off[0] + 2, $off[1] - $off[0] - 2;
     }
     croak "Character 0x$hex with name '$fname' is above 0xFF";
   }
 
   no warnings 'utf8'; # allow even illegal characters
   return pack "U", $ord;
-}
+} # charnames
 
 sub import
 {
   shift; ## ignore class name
 
-  if (not @_)
-  {
-      carp("`use charnames' needs explicit imports list");
+  if (not @_) {
+    carp("`use charnames' needs explicit imports list");
   }
   $^H |= $charnames::hint_bits;
   $^H{charnames} = \&charnames ;
@@ -155,8 +176,25 @@ sub import
   ##
   ## fill %h keys with our @_ args.
   ##
-  my %h;
-  @h{@_} = (1) x @_;
+  my ($promote, %h, @args) = (0);
+  while (@_ and $_ = shift) {
+    if ($_ eq ":alias" && @_) {
+      my $alias = shift;
+      if (ref $alias) {
+       ref $alias eq "HASH" or
+         die "Only HASH reference supported as argument to :alias";
+       alias ($alias);
+       next;
+      }
+      if ($alias =~ m{:(\w+)$} and $1 ne "full" && $1 ne "short") {
+       alias_file ($1) and $promote = 1, next;
+      }
+      alias_file ($alias) and next;
+    }
+    push @args, $_;
+  }
+  @args == 0 && $promote and @args = (":full");
+  @h{@args} = (1) x @args;
 
   $^H{charnames_full} = delete $h{':full'};
   $^H{charnames_short} = delete $h{':short'};
@@ -166,18 +204,16 @@ sub import
   ## If utf8? warnings are enabled, and some scripts were given,
   ## see if at least we can find one letter of each script.
   ##
-  if (warnings::enabled('utf8') && @{$^H{charnames_scripts}})
-  {
-      $txt = do "unicore/Name.pl" unless $txt;
-
-      for my $script (@{$^H{charnames_scripts}})
-      {
-          if (not $txt =~ m/\t\t$script (?:CAPITAL |SMALL )?LETTER /) {
-              warnings::warn('utf8',  "No such script: '$script'");
-          }
+  if (warnings::enabled('utf8') && @{$^H{charnames_scripts}}) {
+    $txt = do "unicore/Name.pl" unless $txt;
+
+    for my $script (@{$^H{charnames_scripts}}) {
+      if (not $txt =~ m/\t\t$script (?:CAPITAL |SMALL )?LETTER /) {
+       warnings::warn('utf8',  "No such script: '$script'");
       }
+    }
   }
-}
+} # import
 
 require Unicode::UCD; # for Unicode::UCD::_getcode()
 
@@ -185,73 +221,73 @@ my %viacode;
 
 sub viacode
 {
-    if (@_ != 1) {
-        carp "charnames::viacode() expects one argument";
-        return ()
-    }
+  if (@_ != 1) {
+    carp "charnames::viacode() expects one argument";
+    return ()
+  }
 
-    my $arg = shift;
-    my $code = Unicode::UCD::_getcode($arg);
+  my $arg = shift;
+  my $code = Unicode::UCD::_getcode($arg);
 
-    my $hex;
+  my $hex;
 
-    if (defined $code) {
-        $hex = sprintf "%04X", $arg;
-    } else {
-        carp("unexpected arg \"$arg\" to charnames::viacode()");
-        return;
-    }
+  if (defined $code) {
+    $hex = sprintf "%04X", $arg;
+  } else {
+    carp("unexpected arg \"$arg\" to charnames::viacode()");
+    return;
+  }
 
-    if ($code > 0x10FFFF) {
-       carp sprintf "Unicode characters only allocated up to U+10FFFF (you asked for U+%X)", $hex;
-       return;
-    }
+  if ($code > 0x10FFFF) {
+    carp sprintf "Unicode characters only allocated up to U+10FFFF (you asked for U+%X)", $hex;
+    return;
+  }
 
-    return $viacode{$hex} if exists $viacode{$hex};
+  return $viacode{$hex} if exists $viacode{$hex};
 
-    $txt = do "unicore/Name.pl" unless $txt;
+  $txt = do "unicore/Name.pl" unless $txt;
 
-    if ($txt =~ m/^$hex\t\t(.+)/m) {
-        return $viacode{$hex} = $1;
-    } else {
-        return;
-    }
-}
+  if ($txt =~ m/^$hex\t\t(.+)/m) {
+    return $viacode{$hex} = $1;
+  } else {
+    return;
+  }
+} # viacode
 
 my %vianame;
 
 sub vianame
 {
-    if (@_ != 1) {
-        carp "charnames::vianame() expects one name argument";
-        return ()
-    }
+  if (@_ != 1) {
+    carp "charnames::vianame() expects one name argument";
+    return ()
+  }
 
-    my $arg = shift;
+  my $arg = shift;
 
-    return chr hex $1 if $arg =~ /^U\+([0-9a-fA-F]+)$/;
+  return chr hex $1 if $arg =~ /^U\+([0-9a-fA-F]+)$/;
 
-    return $vianame{$arg} if exists $vianame{$arg};
+  return $vianame{$arg} if exists $vianame{$arg};
 
-    $txt = do "unicore/Name.pl" unless $txt;
+  $txt = do "unicore/Name.pl" unless $txt;
 
-    my $pos = index $txt, "\t\t$arg\n";
-    if ($[ <= $pos) {
-       my $posLF = rindex $txt, "\n", $pos;
-       (my $code = substr $txt, $posLF + 1, 6) =~ tr/\t//d;
-       return $vianame{$arg} = hex $code;
-
-       # If $pos is at the 1st line, $posLF must be $[ - 1 (not found);
-       # then $posLF + 1 equals to $[ (at the beginning of $txt).
-       # Otherwise $posLF is the position of "\n";
-       # then $posLF + 1 must be the position of the next to "\n"
-       # (the beginning of the line).
-       # substr($txt, $posLF + 1, 6) may be "0000\t\t", "00A1\t\t",
-       # "10300\t", "100000", etc. So we can get the code via removing TAB.
-    } else {
-        return;
-    }
-}
+  my $pos = index $txt, "\t\t$arg\n";
+  if ($[ <= $pos) {
+    my $posLF = rindex $txt, "\n", $pos;
+    (my $code = substr $txt, $posLF + 1, 6) =~ tr/\t//d;
+    return $vianame{$arg} = hex $code;
+
+    # If $pos is at the 1st line, $posLF must be $[ - 1 (not found);
+    # then $posLF + 1 equals to $[ (at the beginning of $txt).
+    # Otherwise $posLF is the position of "\n";
+    # then $posLF + 1 must be the position of the next to "\n"
+    # (the beginning of the line).
+    # substr($txt, $posLF + 1, 6) may be "0000\t\t", "00A1\t\t",
+    # "10300\t", "100000", etc. So we can get the code via removing TAB.
+  } else {
+    return;
+  }
+} # vianame
 
 
 1;
@@ -272,20 +308,25 @@ charnames - define character names for C<\N{named}> string literal escapes
   use charnames qw(cyrillic greek);
   print "\N{sigma} is Greek sigma, and \N{be} is Cyrillic b.\n";
 
+  use charnames ":full", ":alias" => {
+    e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE",
+    };
+  print "\N{e_ACUTE} is a small letter e with an acute.\n";
+
   print charnames::viacode(0x1234); # prints "ETHIOPIC SYLLABLE SEE"
   printf "%04X", charnames::vianame("GOTHIC LETTER AHSA"); # prints "10330"
 
 =head1 DESCRIPTION
 
-Pragma C<use charnames> supports arguments C<:full>, C<:short> and
-script names.  If C<:full> is present, for expansion of
+Pragma C<use charnames> supports arguments C<:full>, C<:short>, script
+names and customized aliases.  If C<:full> is present, for expansion of
 C<\N{CHARNAME}> string C<CHARNAME> is first looked in the list of
 standard Unicode names of chars.  If C<:short> is present, and
 C<CHARNAME> has the form C<SCRIPT:CNAME>, then C<CNAME> is looked up
 as a letter in script C<SCRIPT>.  If pragma C<use charnames> is used
 with script name arguments, then for C<\N{CHARNAME}> the name
 C<CHARNAME> is looked up as a letter in the given scripts (in the
-specified order).
+specified order). Customized aliases are explained in L</CUSTOM ALIASES>.
 
 For lookup of C<CHARNAME> inside a given script C<SCRIPTNAME>
 this pragma looks for the names
@@ -343,6 +384,43 @@ state of C<bytes>-flag as in:
        }
     }
 
+=head1 CUSTOM ALIASES
+
+This version of charnames supports three mechanisms of adding local
+or customized aliases to standard Unicode naming conventions (:full)
+
+=head2 Anonymous hashes
+
+    use charnames ":full", ":alias" => {
+        e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE",
+        };
+    my $str = "\N{e_ACUTE}";
+
+=head2 Alias file
+
+    use charnames ":full", ":alias" => "pro";
+
+    will try to read "unicore/pro_alias.pl" from the @INC path. This
+    file should return a list in plain perl:
+
+    (
+    A_GRAVE         => "LATIN CAPITAL LETTER A WITH GRAVE",
+    A_CIRCUM        => "LATIN CAPITAL LETTER A WITH CIRCUMFLEX",
+    A_DIAERES       => "LATIN CAPITAL LETTER A WITH DIAERESIS",
+    A_TILDE         => "LATIN CAPITAL LETTER A WITH TILDE",
+    A_BREVE         => "LATIN CAPITAL LETTER A WITH BREVE",
+    A_RING          => "LATIN CAPITAL LETTER A WITH RING ABOVE",
+    A_MACRON        => "LATIN CAPITAL LETTER A WITH MACRON",
+    );
+
+=head2 Alias shortcut
+
+    use charnames ":alias" => ":pro";
+
+    works exactly the same as the alias pairs, only this time,
+    ":full" is inserted automatically as first argument (if no
+    other argument is given).
+
 =head1 charnames::viacode(code)
 
 Returns the full name of the character indicated by the numeric code.
@@ -354,7 +432,7 @@ prints "FOUR TEARDROP-SPOKED ASTERISK".
 
 Returns undef if no name is known for the code.
 
-This works only for the standard names, and does not yet apply 
+This works only for the standard names, and does not yet apply
 to custom translators.
 
 Notice that the name returned for of U+FEFF is "ZERO WIDTH NO-BREAK
@@ -371,7 +449,7 @@ prints "2722".
 
 Returns undef if the name is unknown.
 
-This works only for the standard names, and does not yet apply 
+This works only for the standard names, and does not yet apply
 to custom translators.
 
 =head1 ALIASES
index 29ee0f3..8472abf 100644 (file)
@@ -12,7 +12,7 @@ BEGIN {
 
 $| = 1;
 
-print "1..46\n";
+print "1..69\n";
 
 use charnames ':full';
 
@@ -264,3 +264,250 @@ print "ok 45\n";
 
 print "not " if grep { /you asked for U+110000/ } @WARN;
 print "ok 46\n";
+
+
+# ---- Alias extensions
+
+my $tmpfile = "tmp0000";
+my $alifile = "../lib/unicore/xyzzy_alias.pl";
+my $i = 0;
+1 while -e ++$tmpfile;
+END { if ($tmpfile) { 1 while unlink $tmpfile; } }
+
+my @prgs;
+{   local $/ = undef;
+    @prgs = split "\n########\n", <DATA>;
+    }
+
+my $i = 46;
+for (@prgs) {
+    my ($code, $exp) = ((split m/\nEXPECT\n/), '$');
+    my ($prog, $fil) = ((split m/\nFILE\n/, $code), "");
+    open my $tmp, "> $tmpfile" or die "Could not open $tmpfile: $!";
+    print $tmp $prog, "\n";
+    close $tmp or die "Could not close $tmpfile: $!";
+    if ($fil) {
+       $fil .= "\n";
+       open my $ali, "> $alifile" or die "Could not open $alifile: $!";
+       print $ali $fil;
+       close $ali or die "Could not close $alifile: $!";
+       }
+    my $res =
+       $^O eq "MSWin32" ? `.\\perl -I../lib $switch $tmpfile 2>&1` :
+       $^O eq "NetWare" ? `perl    -I../lib $switch $tmpfile 2>&1` :
+       $^O eq "MacOS"   ? `$^X     -I::lib -MMac::err=unix $switch $tmpfile` :
+                          `./perl -I. -I../lib $switch $tmpfile 2>&1`;
+    my $status = $?;
+    $res =~ s/[\r\n]+$//;
+    $res =~ s/tmp\d+/-/g;                      # fake $prog from STDIN
+    $res =~ s/\n%[A-Z]+-[SIWEF]-.*$//          # clip off DCL status msg
+       if $^O eq "VMS";
+    $exp =~ s/[\r\n]+$//;
+    if ($^O eq "MacOS") {
+       $exp =~ s{(\./)?abc\.pm}{:abc.pm}g;
+       $exp =~ s{./abc}        {:abc}g;
+       }
+    my $pfx = ($res =~ s/^PREFIX\n//);
+    my $rexp = qr{^$exp};
+    if ($res =~ s/^SKIPPED\n//) {
+       print "$results\n";
+       }
+    elsif (($pfx and $res !~ /^\Q$expected/) or
+         (!$pfx and $res !~ $rexp)) {
+        print STDERR
+           "PROG:\n$prog\n",
+           "FILE:\n$fil",
+           "EXPECTED:\n$exp\n",
+           "GOT:\n$res\n";
+        print "not ";
+       }
+    print "ok ", ++$i, "\n";
+    1 while unlink $tmpfile;
+    $fil or next;
+    1 while unlink $alifile;
+    }
+
+__END__
+# wrong type of alias (missing colon)
+use charnames "alias";
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Unknown charname 'e_ACUTE' at 
+########
+# alias without an argument
+use charnames ":alias";
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Unknown charname 'e_ACUTE' at 
+########
+# alias with hashref but no :full
+use charnames ":alias" => { e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE" };
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN SMALL LETTER E WITH ACUTE' at
+########
+# alias with hashref but with :short
+use charnames ":short", ":alias" => { e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE" };
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN SMALL LETTER E WITH ACUTE' at
+########
+# alias with hashref to :full OK
+use charnames ":full", ":alias" => { e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE" };
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+$
+########
+# alias with hashref to :short but using :full
+use charnames ":full", ":alias" => { e_ACUTE => "LATIN:e WITH ACUTE" };
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN:e WITH ACUTE' at
+########
+# alias with hashref to :short OK
+use charnames ":short", ":alias" => { e_ACUTE => "LATIN:e WITH ACUTE" };
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+$
+########
+# alias with bad hashref
+use charnames ":short", ":alias" => "e_ACUTE";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Odd number of elements in anonymous hash at
+########
+# alias with arrayref
+use charnames ":short", ":alias" => [ e_ACUTE => "LATIN:e WITH ACUTE" ];
+"Here: \N{e_ACUTE}!\n";
+EXPECT
+Only HASH reference supported as argument to :alias at
+########
+# alias with bad hashref
+use charnames ":short", ":alias" => { e_ACUTE => "LATIN:e WITH ACUTE", "a_ACUTE" };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Use of uninitialized value in string eq at
+########
+# alias with hashref two aliases
+use charnames ":short", ":alias" => {
+    e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "",
+    };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Unknown charname '' at
+########
+# alias with hashref two aliases
+use charnames ":short", ":alias" => {
+    e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN:a WITH ACUTE",
+    };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+$
+########
+# alias with hashref using mixed aliasses
+use charnames ":short", ":alias" => {
+    e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN SMALL LETTER A WITH ACUT",
+    };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN SMALL LETTER A WITH ACUT' at
+########
+# alias with hashref using mixed aliasses
+use charnames ":short", ":alias" => {
+    e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN SMALL LETTER A WITH ACUTE",
+    };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN SMALL LETTER A WITH ACUTE' at
+########
+# alias with hashref using mixed aliasses
+use charnames ":full", ":alias" => {
+    e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN SMALL LETTER A WITH ACUTE",
+    };
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Unknown charname 'LATIN:e WITH ACUTE' at
+########
+# alias with nonexisting file
+use charnames ":full", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+EXPECT
+Odd number of elements in anonymous hash at
+########
+# alias with bad file
+use charnames ":full", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+0;
+EXPECT
+Odd number of elements in anonymous hash at
+########
+# alias with file with empty list
+use charnames ":full", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+();
+EXPECT
+Unknown charname 'e_ACUTE' at
+########
+# alias with file OK but file has :short aliasses
+use charnames ":full", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+(   e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN:a WITH ACUTE",
+    );
+EXPECT
+Unknown charname 'LATIN:e WITH ACUTE' at
+########
+# alias with :short and file OK
+use charnames ":short", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+(   e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN:a WITH ACUTE",
+    );
+EXPECT
+$
+########
+# alias with :short and file OK has :long aliasses
+use charnames ":short", ":alias" => "xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+(   e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE",
+    a_ACUTE => "LATIN SMALL LETTER A WITH ACUTE",
+    );
+EXPECT
+Unknown charname 'LATIN SMALL LETTER E WITH ACUTE' at
+########
+# alias with file implicit :full but file has :short aliasses
+use charnames ":alias" => ":xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+(   e_ACUTE => "LATIN:e WITH ACUTE",
+    a_ACUTE => "LATIN:a WITH ACUTE",
+    );
+EXPECT
+Unknown charname 'LATIN:e WITH ACUTE' at
+########
+# alias with file implicit :full and file has :long aliasses
+use charnames ":alias" => ":xyzzy";
+"Here: \N{e_ACUTE}\N{a_ACUTE}!\n";
+FILE
+#!perl
+(   e_ACUTE => "LATIN SMALL LETTER E WITH ACUTE",
+    a_ACUTE => "LATIN SMALL LETTER A WITH ACUTE",
+    );
+EXPECT
+$