mdw@git.distorted.org.uk Git - disorder/blob - scripts/make-unidata

   1 #! /usr/bin/perl -w
   2 #
   3 # This file is part of DisOrder.
   4 # Copyright (C) 2007 Richard Kettlewell
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19 # USA
  20 #
  21 #
  22 # Generate Unicode support tables
  23 #
  24 # This script will download data from unicode.org if the required files
  25 # aren't in the current directory.
  26 #
  27 # After modifying this script you should run:
  28 #  make -C lib rebuild-unicode check
  29 #
  30 # Things not supported yet:
  31 #  - SpecialCasing.txt data for case mapping
  32 #  - Title case offsets
  33 #  - Some kind of hinting for composition
  34 #  - ...
  35 #
  36 # NB the generated files DO NOT offer a stable ABI and so are not immediately
  37 # suitable for use in a general-purpose library.  Things that would need to
  38 # be done:
  39 #  - Hide unidata.h from applications; it will never be ABI- or even API-stable.
  40 #  - Stablized General_Category values
  41 #  - Extend the unicode.h API to general utility rather than just what
  42 #    DisOrder needs.
  43 #  - ...
  44 #
  45 use strict;
  46 use File::Basename;
  47
  48 sub out {
  49     print @_ or die "$!\n";
  50 }
  51
  52 sub key {
  53     my $d = shift;
  54     local $_;
  55
  56     return join("-", map($d->{$_}, sort keys %$d));
  57 }
  58
  59 # Size of a subtable
  60 #
  61 # This can be varied to trade off the number of subtables against their size.
  62 # 16 gave the smallest results last time I checked (on a Mac with a 32-bit
  63 # build).
  64 our $modulus = 16;
  65
  66 if(@ARGV) {
  67     $modulus = shift;
  68 }
  69
  70 # Where to break the table.  There is a huge empty section of the Unicode
  71 # code space and we deal with this by simply leaving it out of the table.
  72 # This complicates the lookup function a little but should not affect
  73 # performance in the cases we care about.
  74 our $break_start = 0x30000;
  75 our $break_end = 0xE0000;
  76
  77 # Similarly we simply omit the very top of the table and sort it out in the
  78 # lookup function.
  79 our $break_top = 0xE0200;
  80
  81 my %cats = ();                  # known general categories
  82 my %data = ();                  # mapping of codepoints to information
  83 my $max = 0;                    # maximum codepoint
  84 my $maxccc = 0;                 # maximum combining class
  85 my $maxud = 0;
  86 my $minud = 0;                  # max/min upper case offset
  87 my $maxld = 0;
  88 my $minld = 0;                  # max/min lower case offset
  89
  90 # Make sure we have our desired input files.  We explicitly specify a
  91 # Unicode standard version to make sure that a given version of DisOrder
  92 # supports a given version of Unicode.
  93 sub input {
  94     my $path = shift;
  95     my $lpath = basename($path);
  96     if(!-e $lpath) {
  97         system("wget http://www.unicode.org/Public/5.0.0/ucd/$path");
  98         chmod(0444, $lpath) or die "$lpath: $!\n";
  99     }
 100     open(STDIN, "<$lpath") or die "$lpath: $!\n";
 101     print STDERR "Reading $lpath...\n";
 102 }
 103
 104
 105 # Read the main data file
 106 input("UnicodeData.txt");
 107 my ($start, $end);
 108 while(<>) {
 109     my @f = split(/;/, $_);
 110     my $c = hex($f[0]);         # codepoint
 111     my $name = $f[1];
 112     die "$f[0] $name is in the break\n"
 113         if $c >= $break_start && $c < $break_end;
 114     my $gc = $f[2];             # General_Category
 115     # Variuos GCs we don't expect to see in UnicodeData.txt
 116     $cats{$gc} = 1;             # always record all GCs
 117     if($name =~ /first>/i) {
 118         $start = $c;
 119         next;
 120     } elsif($name =~ /last>/i) {
 121         $end = $c;
 122     } else {
 123         $start = $end = $c;
 124     }
 125     die "unexpected Cn" if $gc eq 'Cn';
 126     my $ccc = $f[3];            # Canonical_Combining_Class
 127     my $dm = $f[5];             # Decomposition_Type + Decomposition_Mapping
 128     my $sum = hex($f[12]) || $c; # Simple_Uppercase_Mapping
 129     my $slm = hex($f[13]) || $c; # Simple_Lowercase_Mapping
 130     # recalculate the upper/lower case mappings as offsets
 131     my $ud = $sum - $c;
 132     my $ld = $slm - $c;
 133     # update bounds on various values
 134     $maxccc = $ccc if $ccc > $maxccc; # assumed never to be -ve
 135     $minud = $ud if $ud < $minud;
 136     $maxud = $ud if $ud > $maxud;
 137     $minld = $ld if $ld < $minld;
 138     $maxld = $ld if $ld > $maxld;
 139     if($start != $end) {
 140         printf STDERR "> range %04X-%04X is %s\n", $start, $end, $gc;
 141     }
 142     for($c = $start; $c <= $end; ++$c) {
 143         my $d = {
 144             "gc" => $gc,
 145             "ccc" => $ccc,
 146             "ud" => $ud,
 147             "ld" => $ld,
 148         };
 149         if($dm ne '') {
 150             if($dm =~ /</) {
 151                 # This is a compatibility decomposition
 152                 $dm =~ s/^<.*>\s*//;
 153                 $d->{compat} = 1;
 154             }
 155             $d->{decomp} = $dm;
 156         }
 157         $data{$c} = $d;
 158     }
 159     $cats{$gc} = 1;
 160     $max = $end if $end > $max;
 161 }
 162
 163 sub read_prop_with_ranges {
 164     my $path = shift;
 165     my $propkey = shift;
 166     input($path);
 167     while(<>) {
 168         chomp;
 169         s/\s*\#.*//;
 170         next if $_ eq '';
 171         my ($range, $propval) = split(/\s*;\s*/, $_);
 172         if($range =~ /(.*)\.\.(.*)/) {
 173             for my $c (hex($1) .. hex($2)) {
 174                 die "($range)\n" if($c == 0xAC00 and $propkey eq 'gbreak');
 175                 $data{$c}->{$propkey} = $propval;
 176             }
 177         } else {
 178             my $c = hex($range);
 179             $data{$c}->{$propkey} = $propval;
 180         }
 181     }
 182 }
 183
 184 # Grapheme_Break etc
 185 read_prop_with_ranges("auxiliary/GraphemeBreakProperty.txt", "gbreak");
 186 read_prop_with_ranges("auxiliary/WordBreakProperty.txt", "wbreak");
 187 read_prop_with_ranges("auxiliary/SentenceBreakProperty.txt", "sbreak");
 188
 189 # Compute the full list and fill in the Extend category properly
 190 my %gbreak = ();
 191 my %wbreak = ();
 192 my %sbreak = ();
 193 for my $c (keys %data) {
 194     if(!exists $data{$c}->{gbreak}) {
 195         $data{$c}->{gbreak} = 'Other';
 196     }
 197     $gbreak{$data{$c}->{gbreak}} = 1;
 198
 199     if(!exists $data{$c}->{wbreak}) {
 200         if($data{$c}->{gbreak} eq 'Extend') {
 201             $data{$c}->{wbreak} = 'Extend';
 202         } else {
 203             $data{$c}->{wbreak} = 'Other';
 204         }
 205     }
 206     $wbreak{$data{$c}->{wbreak}} = 1;
 207
 208     if(!exists $data{$c}->{sbreak}) {
 209         if($data{$c}->{gbreak} eq 'Extend') {
 210             $data{$c}->{sbreak} = 'Extend';
 211         } else {
 212             $data{$c}->{sbreak} = 'Other';
 213         }
 214     }
 215     $sbreak{$data{$c}->{sbreak}} = 1;
 216 }
 217
 218 # Round up the maximum value to a whole number of subtables
 219 $max += ($modulus - 1) - ($max % $modulus);
 220
 221 # Private use characters
 222 # We only fill in values below $max, utf32__unidata()
 223 my $Co = {
 224     "gc" => "Co",
 225     "ccc" => 0,
 226     "ud" => 0,
 227     "ld" => 0
 228 };
 229 for(my $c = 0xE000; $c <= 0xF8FF && $c <= $max; ++$c) {
 230     $data{$c} = $Co;
 231 }
 232 for(my $c = 0xF0000; $c <= 0xFFFFD && $c <= $max; ++$c) {
 233     $data{$c} = $Co;
 234 }
 235 for(my $c = 0x100000; $c <= 0x10FFFD && $c <= $max; ++$c) {
 236     $data{$c} = $Co;
 237 }
 238
 239 # Anything left is not assigned
 240 my $Cn = {
 241     "gc" => "Cn",               # not assigned
 242     "ccc" => 0,
 243     "ud" => 0,
 244     "ld" => 0
 245 };
 246 for(my $c = 0; $c <= $max; ++$c) {
 247     if(!exists $data{$c}) {
 248         $data{$c} = $Cn;
 249     }
 250     if(!exists $data{$c}->{wbreak}) {
 251         $data{$c}->{wbreak} = 'Other';
 252     }
 253     if(!exists $data{$c}->{gbreak}) {
 254         $data{$c}->{gbreak} = 'Other';
 255     }
 256     if(!exists $data{$c}->{sbreak}) {
 257         $data{$c}->{sbreak} = 'Other';
 258     }
 259 }
 260 $cats{'Cn'} = 1;
 261
 262 # Read the casefolding data too
 263 input("CaseFolding.txt");
 264 while(<>) {
 265     chomp;
 266     next if /^\#/ or $_ eq '';
 267     my @f = split(/\s*;\s*/, $_);
 268     # Full case folding means use status C and F.
 269     # We discard status T, Turkish users may wish to change this.
 270     if($f[1] eq 'C' or $f[1] eq 'F') {
 271         my $c = hex($f[0]);
 272         $data{$c}->{casefold} = $f[2];
 273         # We are particularly interest in combining characters that
 274         # case-fold to non-combining characters, or characters that
 275         # case-fold to sequences with combining characters in non-initial
 276         # positions, as these required decomposiiton before case-folding
 277         my @d = map(hex($_), split(/\s+/, $data{$c}->{casefold}));
 278         if($data{$c}->{ccc} != 0) {
 279             # This is a combining character
 280             if($data{$d[0]}->{ccc} == 0) {
 281                 # The first character of its case-folded form is NOT
 282                 # a combining character.  The field name is the example
 283                 # explicitly mentioned in the spec.
 284                 $data{$c}->{ypogegrammeni} = 1;
 285             }
 286         } else {
 287             # This is a non-combining character; inspect the non-initial
 288             # code points of the case-folded sequence
 289             shift(@d);
 290             if(grep($data{$_}->{ccc} != 0, @d)) {
 291                 # Some non-initial code point in the case-folded for is NOT a
 292                 # a combining character.
 293                 $data{$c}->{ypogegrammeni} = 1;
 294             }
 295         }
 296     }
 297 }
 298
 299 # Generate the header file
 300 print STDERR "Generating unidata.h...\n";
 301 open(STDOUT, ">unidata.h") or die "unidata.h: $!\n";
 302
 303 out("/* Automatically generated file, see scripts/make-unidata */\n",
 304     "#ifndef UNIDATA_H\n",
 305     "#define UNIDATA_H\n");
 306
 307 # TODO choose stable values for General_Category
 308 out("enum unicode_General_Category {\n",
 309     join(",\n",
 310          map("  unicode_General_Category_$_", sort keys %cats)), "\n};\n");
 311
 312 out("enum unicode_Grapheme_Break {\n",
 313     join(",\n",
 314          map("  unicode_Grapheme_Break_$_", sort keys %gbreak)),
 315     "\n};\n");
 316 out("extern const char *const unicode_Grapheme_Break_names[];\n");
 317
 318 out("enum unicode_Word_Break {\n",
 319     join(",\n",
 320          map("  unicode_Word_Break_$_", sort keys %wbreak)),
 321     "\n};\n");
 322 out("extern const char *const unicode_Word_Break_names[];\n");
 323
 324 out("enum unicode_Sentence_Break {\n",
 325     join(",\n",
 326          map("  unicode_Sentence_Break_$_", sort keys %sbreak)),
 327     "\n};\n");
 328 out("extern const char *const unicode_Sentence_Break_names[];\n");
 329
 330 out("enum unicode_flags {\n",
 331     "  unicode_normalize_before_casefold = 1,\n",
 332     "  unicode_compatibility_decomposition = 2\n",
 333     "};\n",
 334     "\n");
 335
 336 # Choose the narrowest type that will fit the required values
 337 sub choosetype {
 338     my ($min, $max) = @_;
 339     if($min >= 0) {
 340         return "char" if $max <= 127;
 341         return "unsigned char" if $max <= 255;
 342         return "int16_t" if $max < 32767;
 343         return "uint16_t" if $max < 65535;
 344         return "int32_t";
 345     } else {
 346         return "char" if $min >= -127 && $max <= 127;
 347         return "int16_t" if $min >= -32767 && $max <= 32767;
 348         return "int32_t";
 349     }
 350 }
 351
 352 out("struct unidata {\n",
 353     "  const uint32_t *decomp;\n",
 354     "  const uint32_t *casefold;\n",
 355 #    "  ".choosetype($minud, $maxud)." upper_offset;\n",
 356 #    "  ".choosetype($minld, $maxld)." lower_offset;\n",
 357     "  ".choosetype(0, $maxccc)." ccc;\n",
 358     "  char general_category;\n",
 359     "  uint8_t flags;\n",
 360     "  char grapheme_break;\n",
 361     "  char word_break;\n",
 362     "  char sentence_break;\n",
 363     "};\n");
 364 # decomp and  casefold do have have non-BMP characters, so we
 365 # can't use a simple 16-bit table.  We could use UTF-8 or UTF-16
 366 # though, saving a bit of space (probably not that much...) at the
 367 # cost of marginally reduced performance and additional complexity
 368
 369 out("extern const struct unidata *const unidata[];\n");
 370
 371 out("extern const struct unicode_utf8_row {\n",
 372     "  uint8_t count;\n",
 373     "  uint8_t min2, max2;\n",
 374     "} unicode_utf8_valid[];\n");
 375
 376 out("#define UNICODE_NCHARS ", ($max + 1), "\n");
 377 out("#define UNICODE_MODULUS $modulus\n");
 378 out("#define UNICODE_BREAK_START $break_start\n");
 379 out("#define UNICODE_BREAK_END $break_end\n");
 380 out("#define UNICODE_BREAK_TOP $break_top\n");
 381
 382 out("#endif\n");
 383
 384 close STDOUT or die "unidata.h: $!\n";
 385
 386 print STDERR "Generating unidata.c...\n";
 387 open(STDOUT, ">unidata.c") or die "unidata.c: $!\n";
 388
 389 out("/* Automatically generated file, see scripts/make-unidata */\n",
 390     "#include <config.h>\n",
 391     "#include \"types.h\"\n",
 392     "#include \"unidata.h\"\n");
 393
 394 # Short aliases to keep .c file small
 395
 396 out(map(sprintf("#define %s unicode_General_Category_%s\n", $_, $_),
 397         sort keys %cats));
 398 out(map(sprintf("#define GB%s unicode_Grapheme_Break_%s\n", $_, $_),
 399         sort keys %gbreak));
 400 out(map(sprintf("#define WB%s unicode_Word_Break_%s\n", $_, $_),
 401         sort keys %wbreak));
 402 out(map(sprintf("#define SB%s unicode_Sentence_Break_%s\n", $_, $_),
 403         sort keys %sbreak));
 404
 405 # Names for *_Break properties
 406 out("const char *const unicode_Grapheme_Break_names[] = {\n",
 407     join(",\n",
 408          map("  \"$_\"", sort keys %gbreak)),
 409     "\n};\n");
 410 out("const char *const unicode_Word_Break_names[] = {\n",
 411     join(",\n",
 412          map("  \"$_\"", sort keys %wbreak)),
 413     "\n};\n");
 414 out("const char *const unicode_Sentence_Break_names[] = {\n",
 415     join(",\n",
 416          map("  \"$_\"", sort keys %sbreak)),
 417     "\n};\n");
 418
 419 # Generate the decomposition mapping tables.  We look out for duplicates
 420 # in order to save space and report this as decompsaved at the end.  In
 421 # Unicode 5.0.0 this saves 1795 entries, which is at least 14Kbytes.
 422 my $decompnum = 0;
 423 my %decompnums = ();
 424 my $decompsaved = 0;
 425 out("static const uint32_t ");
 426 for(my $c = 0; $c <= $max; ++$c) {
 427     if(exists $data{$c} && exists $data{$c}->{decomp}) {
 428         my $s = join(",",
 429                      (map(hex($_), split(/\s+/, $data{$c}->{decomp})), 0));
 430         if(!exists $decompnums{$s}) {
 431             out(",\n") if $decompnum != 0;
 432             out("cd$decompnum\[]={$s}");
 433             $decompnums{$s} = $decompnum++;
 434         } else {
 435             ++$decompsaved;
 436         }
 437         $data{$c}->{decompsym} = "cd$decompnums{$s}";
 438     }
 439 }
 440 out(";\n");
 441
 442 # ...and the case folding table.  Again we compress equal entries to save
 443 # space.  In Unicode 5.0.0 this saves 51 entries or at least 408 bytes.
 444 # This doesns't seem as worthwhile as the decomposition mapping saving above.
 445 my $cfnum = 0;
 446 my %cfnums = ();
 447 my $cfsaved = 0;
 448 out("static const uint32_t ");
 449 for(my $c = 0; $c <= $max; ++$c) {
 450     if(exists $data{$c} && exists $data{$c}->{casefold}) {
 451         my $s = join(",",
 452                      (map(hex($_), split(/\s+/, $data{$c}->{casefold})), 0));
 453         if(!exists $cfnums{$s}) {
 454             out(",\n") if $cfnum != 0;
 455             out("cf$cfnum\[]={$s}");
 456             $cfnums{$s} = $cfnum++;
 457         } else {
 458             ++$cfsaved;
 459         }
 460         $data{$c}->{cfsym} = "cf$cfnums{$s}";
 461     }
 462 }
 463 out(";\n");
 464
 465 # Visit all the $modulus-character blocks in turn and generate the
 466 # required subtables.  As above we spot duplicates to save space.  In
 467 # Unicode 5.0.0 with $modulus=128 and current table data this saves
 468 # 1372 subtables or at least three and a half megabytes on 32-bit
 469 # platforms.
 470
 471 my %subtable = ();              # base->subtable number
 472 my %subtableno = ();            # subtable number -> content
 473 my $subtablecounter = 0;        # counter for subtable numbers
 474 my $subtablessaved = 0;         # number of tables saved
 475 for(my $base = 0; $base <= $max; $base += $modulus) {
 476     next if $base >= $break_start && $base < $break_end;
 477     next if $base >= $break_top;
 478     my @t;
 479     for(my $c = $base; $c < $base + $modulus; ++$c) {
 480         my $d = $data{$c};
 481         my $decompsym = ($data{$c}->{decompsym} or "0");
 482         my $cfsym = ($data{$c}->{cfsym} or "0");
 483         my @flags = ();
 484         if($data{$c}->{ypogegrammeni}) {
 485             push(@flags, "unicode_normalize_before_casefold");
 486         }
 487         if($data{$c}->{compat}) {
 488             push(@flags, "unicode_compatibility_decomposition");
 489         }
 490         my $flags = @flags ? join("|", @flags) : 0;
 491         push(@t, "{".
 492              join(",",
 493                   $decompsym,
 494                   $cfsym,
 495 #                 $d->{ud},
 496 #                 $d->{ld},
 497                   $d->{ccc},
 498                   $d->{gc},
 499                   $flags,
 500                   "GB$d->{gbreak}",
 501                   "WB$d->{wbreak}",
 502                   "SB$d->{sbreak}",
 503              )."}");
 504     }
 505     my $t = join(",\n", @t);
 506     if(!exists $subtable{$t}) {
 507         out(sprintf("/* %04X-%04X */\n", $base, $base + $modulus - 1));
 508         out("static const struct unidata st$subtablecounter\[] = {\n",
 509             "$t\n",
 510             "};\n");
 511         $subtable{$t} = $subtablecounter++;
 512     } else {
 513         ++$subtablessaved;
 514     }
 515     $subtableno{$base} = $subtable{$t};
 516 }
 517
 518 out("const struct unidata *const unidata[]={\n");
 519 for(my $base = 0; $base <= $max; $base += $modulus) {
 520     next if $base >= $break_start && $base < $break_end;
 521     next if $base >= $break_top;
 522     #out("st$subtableno{$base} /* ".sprintf("%04x", $base)." */,\n");
 523     out("st$subtableno{$base},\n");
 524 }
 525 out("};\n");
 526
 527 out("const struct unicode_utf8_row unicode_utf8_valid[] = {\n");
 528 for(my $c = 0; $c <= 0x7F; ++$c) {
 529     out(" { 1, 0, 0 }, /* $c */\n");
 530 }
 531 for(my $c = 0x80; $c < 0xC2; ++$c) {
 532     out(" { 0, 0, 0 }, /* $c */\n");
 533 }
 534 for(my $c = 0xC2; $c <= 0xDF; ++$c) {
 535     out(" { 2, 0x80, 0xBF }, /* $c */\n");
 536 }
 537 for(my $c = 0xE0; $c <= 0xE0; ++$c) {
 538     out(" { 3, 0xA0, 0xBF }, /* $c */\n");
 539 }
 540 for(my $c = 0xE1; $c <= 0xEC; ++$c) {
 541     out(" { 3, 0x80, 0xBF }, /* $c */\n");
 542 }
 543 for(my $c = 0xED; $c <= 0xED; ++$c) {
 544     out(" { 3, 0x80, 0x9F }, /* $c */\n");
 545 }
 546 for(my $c = 0xEE; $c <= 0xEF; ++$c) {
 547     out(" { 3, 0x80, 0xBF }, /* $c */\n");
 548 }
 549 for(my $c = 0xF0; $c <= 0xF0; ++$c) {
 550     out(" { 4, 0x90, 0xBF }, /* $c */\n");
 551 }
 552 for(my $c = 0xF1; $c <= 0xF3; ++$c) {
 553     out(" { 4, 0x80, 0xBF }, /* $c */\n");
 554 }
 555 for(my $c = 0xF4; $c <= 0xF4; ++$c) {
 556     out(" { 4, 0x80, 0x8F }, /* $c */\n");
 557 }
 558 for(my $c = 0xF5; $c <= 0xFF; ++$c) {
 559     out(" { 0, 0, 0 }, /* $c */\n");
 560 }
 561 out("};\n");
 562
 563 close STDOUT or die "unidata.c: $!\n";
 564
 565 printf STDERR "modulus=%d\n", $modulus;
 566 printf STDERR "max=%04X\n", $max;
 567 print STDERR "subtables=$subtablecounter, subtablessaved=$subtablessaved\n";
 568 print STDERR "decompsaved=$decompsaved cfsaved=$cfsaved\n";