ext/Unicode/Normalize/mkheader

   1 #!perl
   2 #
   3 # This script generates "unfcan.h", "unfcpt.h", "unfcmb.h",
   4 # "unfcmp.h", and "unfexc.h"
   5 # from CombiningClass.pl, Decomposition.pl, CompExcl.txt
   6 # in lib/unicore or unicode directory
   7 # for Unicode::Normalize.xs. (cf. Makefile.PL)
   8 #
   9 use 5.006;
  10 use strict;
  11 use warnings;
  12 use Carp;
  13
  14 our $PACKAGE = 'Unicode::Normalize, mkheader';
  15
  16 our $Combin = do "unicore/CombiningClass.pl"
  17   || do "unicode/CombiningClass.pl"
  18   || croak "$PACKAGE: CombiningClass.pl not found";
  19
  20 our $Decomp = do "unicore/Decomposition.pl"
  21   || do "unicode/Decomposition.pl"
  22   || croak "$PACKAGE: Decomposition.pl not found";
  23
  24 our %Combin; # $codepoint => $number      : combination class
  25 our %Canon;  # $codepoint => $hexstring   : canonical decomp.
  26 our %Compat; # $codepoint => $hexstring   : compat. decomp.
  27 our %Compos; # $string    => $codepoint   : composite
  28
  29 our %Exclus; # $codepoint => 1            : composition exclusions
  30
  31 {
  32   my($f, $fh);
  33   foreach my $d (@INC) {
  34     use File::Spec;
  35     $f = File::Spec->catfile($d, "unicore", "CompExcl.txt");
  36     last if open($fh, $f);
  37     $f = File::Spec->catfile($d, "unicode", "CompExcl.txt");
  38     last if open($fh, $f);
  39     $f = undef;
  40   }
  41   croak "$PACKAGE: CompExcl.txt not found in @INC" unless defined $f;
  42   while(<$fh>) {
  43     next if /^#/ or /^$/;
  44     s/#.*//;
  45     $Exclus{ hex($1) } =1 if /([0-9A-Fa-f]+)/;
  46   }
  47   close $fh;
  48 }
  49
  50 while($Combin =~ /(.+)/g) {
  51   my @tab = split /\t/, $1;
  52   my $ini = hex $tab[0];
  53   if($tab[1] eq '') {
  54     $Combin{ $ini } = $tab[2];
  55   } else {
  56     $Combin{ $_ } = $tab[2] foreach $ini .. hex($tab[1]);
  57   }
  58 }
  59
  60 while($Decomp =~ /(.+)/g) {
  61   my @tab = split /\t/, $1;
  62   my $compat = $tab[2] =~ s/<[^>]+>//;
  63   my $dec = [ _getHexArray($tab[2]) ]; # decomposition
  64   my $com = pack('U*', @$dec); # composable sequence
  65   my $ini = hex($tab[0]);
  66   if($tab[1] eq '') {
  67     $Compat{ $ini } = $dec;
  68     if(! $compat) {
  69       $Canon{  $ini } = $dec;
  70       $Compos{ $com } = $ini if @$dec > 1;
  71     }
  72   } else {
  73     foreach my $u ($ini .. hex($tab[1])){
  74       $Compat{ $u } = $dec;
  75       if(! $compat){
  76         $Canon{  $u }   = $dec;
  77         $Compos{ $com } = $ini if @$dec > 1;
  78       }
  79     }
  80   }
  81 }
  82
  83 # exhaustive decomposition
  84 foreach my $key (keys %Canon) {
  85   $Canon{$key}  = [ getCanonList($key) ];
  86 }
  87
  88 # exhaustive decomposition
  89 foreach my $key (keys %Compat) {
  90   $Compat{$key} = [ getCompatList($key) ];
  91 }
  92
  93 sub getCanonList {
  94   my @src = @_;
  95   my @dec = map $Canon{$_} ? @{ $Canon{$_} } : $_, @src;
  96   join(" ",@src) eq join(" ",@dec) ? @dec : getCanonList(@dec);
  97   # condition @src == @dec is not ok.
  98 }
  99
 100 sub getCompatList {
 101   my @src = @_;
 102   my @dec = map $Compat{$_} ? @{ $Compat{$_} } : $_, @src;
 103   join(" ",@src) eq join(" ",@dec) ? @dec : getCompatList(@dec);
 104   # condition @src == @dec is not ok.
 105 }
 106
 107 sub _getHexArray {
 108   my $str = shift;
 109   map hex(), $str =~ /([0-9A-Fa-f]+)/g;
 110 }
 111
 112 sub _U_stringify {
 113   sprintf '"%s"', join '',
 114     map sprintf("\\x%2x", $_), unpack 'C*', pack 'U*', @_;
 115 }
 116
 117 foreach my $hash (\%Canon, \%Compat) {
 118   foreach my $key (keys %$hash) {
 119     $hash->{$key} = _U_stringify( @{ $hash->{$key} } );
 120   }
 121 }
 122
 123 sub utf8len {
 124   my $uv = shift;
 125   return $uv < 0x80 ? 1 :
 126         $uv < 0x800 ? 2 :
 127       $uv < 0x10000 ? 3 :
 128      $uv < 0x110000 ? 4 :
 129   croak "$PACKAGE: illegal char in the composite. utf-8 max is 0x10ffff.";
 130 }
 131
 132 my $prefix = "UNF_";
 133
 134 my $structname = "${prefix}complist";
 135
 136 our (%Comp1st, %CompList);
 137
 138 foreach(sort keys %Compos) {
 139   my @a = unpack('U*', $_);
 140   my $val = $Compos{$_};
 141   my $name = sprintf "${structname}_%06x", $a[0];
 142   $Comp1st{ $a[0] } = $name;
 143   $CompList{ $name }{ $a[1] } = $val;
 144
 145   if( utf8len($a[0]) + utf8len($a[1]) < utf8len($val) ) {
 146     croak "$PACKAGE: "
 147       . "composable pair is longer than the composite in bytes!\n"
 148       . sprintf("%d + %d => %d", $a[0], $a[1], $val);
 149   }
 150 }
 151
 152 my $compinit =
 153   "typedef struct { UV nextchar; UV composite; } $structname;\n\n";
 154
 155 foreach my $i (sort keys %CompList) {
 156   $compinit .= "$structname $i [] = {\n";
 157   $compinit .= join ",\n",
 158     map sprintf("\t{ %d, %d }", $_, $CompList{$i}{$_}),
 159     sort {$a <=> $b } keys %{ $CompList{$i} };
 160   $compinit .= ",\n{0,0}\n};\n\n"; # with sentinel
 161 }
 162
 163 ####################################
 164
 165 my @Exclus = sort {$a <=> $b} keys %Exclus;
 166
 167 my $file = "unfexc.h";
 168 open FH, ">$file" or croak "$PACKAGE: $file can't be made";
 169 binmode FH; select FH;
 170
 171 print "bool getExclusion (UV uv) \n{\nreturn\n\t";
 172
 173 while(@Exclus) {
 174   my $cur = shift @Exclus;
 175   if(@Exclus && $cur + 1 == $Exclus[0]) {
 176     print "$cur <= uv && uv <= ";
 177     while(@Exclus && $cur + 1 == $Exclus[0]) {
 178       $cur = shift @Exclus;
 179     }
 180     print $cur;
 181     print "\n\t|| " if @Exclus;
 182   } else {
 183     print "uv == $cur";
 184     print "\n\t|| " if @Exclus;
 185   }
 186 }
 187
 188 print "\n\t? TRUE : FALSE;\n}\n\n";
 189 close FH;
 190
 191 ####################################
 192
 193 my @tripletable = (
 194   {
 195     file => "unfcmb",
 196     name => "combin",
 197     type => "STDCHAR",
 198     hash => \%Combin,
 199     null =>  0,
 200   },
 201   {
 202     file => "unfcan",
 203     name => "canon",
 204     type => "char*",
 205     hash => \%Canon,
 206     null => "NULL",
 207   },
 208   {
 209     file => "unfcpt",
 210     name => "compat",
 211     type => "char*",
 212     hash => \%Compat,
 213     null => "NULL",
 214   },
 215   {
 216     file => "unfcmp",
 217     name => "compos",
 218     type => "$structname *",
 219     hash => \%Comp1st,
 220     null => "NULL",
 221     init => $compinit,
 222   },
 223 );
 224
 225 foreach my $tbl (@tripletable) {
 226   my $file = "$tbl->{file}.h";
 227   my $head = "${prefix}$tbl->{name}";
 228   my $type = $tbl->{type};
 229   my $hash = $tbl->{hash};
 230   my $null = $tbl->{null};
 231   my $init = $tbl->{init};
 232
 233   open FH, ">$file" or croak "$PACKAGE: $file can't be made";
 234   binmode FH; select FH;
 235   my %val;
 236
 237   print FH << 'EOF';
 238 /*
 239  * This file is auto-generated by mkheader.
 240  * Any changes here will be lost!
 241  */
 242 EOF
 243
 244   print $init if defined $init;
 245
 246   foreach my $uv (keys %$hash) {
 247     my @c = unpack 'CCCC', pack 'N', $uv;
 248     $val{ $c[1] }{ $c[2] }{ $c[3] } = $hash->{$uv};
 249   }
 250
 251   foreach my $p (sort { $a <=> $b } keys %val) {
 252     next if ! $val{ $p };
 253     for(my $r = 0; $r < 256; $r++){
 254       next if ! $val{ $p }{ $r };
 255       printf "$type ${head}_%02x_%02x [256] = {\n", $p, $r;
 256       for(my $c = 0; $c < 256; $c++){
 257         print "\t", defined $val{$p}{$r}{$c} ? $val{$p}{$r}{$c} : $null;
 258         print ','  if $c != 255;
 259         print "\n" if $c % 8 == 7;
 260       }
 261       print "};\n\n";
 262     }
 263   }
 264   foreach my $p (sort { $a <=> $b } keys %val) {
 265     next if ! $val{ $p };
 266     printf "$type* ${head}_%02x [256] = {\n", $p;
 267     for(my $r = 0; $r < 256; $r++){
 268       print $val{ $p }{ $r } ? sprintf("${head}_%02x_%02x", $p, $r) : "NULL";
 269       print ','  if $r != 255;
 270       print "\n" if $val{ $p }{ $r } || ($r+1) % 8 == 0;
 271     }
 272     print "};\n\n";
 273   }
 274   print "$type** $head [] = {\n";
 275   for(my $p = 0; $p <= 0x10; $p++){
 276     print $val{ $p } ? sprintf("${head}_%02x", $p) : "NULL";
 277     print ','  if $p != 0x10;
 278     print "\n";
 279   }
 280   print "};\n\n";
 281   close FH;
 282 }
 283
 284 __END__