3 # This file is part of DisOrder.
4 # Copyright (C) 2007 Richard Kettlewell
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.
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.
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
22 # Generate Unicode support tables
24 # This script will download data from unicode.org if the required files
25 # aren't in the current directory.
27 # After modifying this script you should run:
28 # make -C lib rebuild-unicode check
30 # Things not supported yet:
31 # - SpecialCasing.txt data for case mapping
32 # - Title case offsets
33 # - Some kind of hinting for composition
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
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
49 print @_ or die "$!\n";
56 return join("-", map($d->{$_}, sort keys %$d));
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
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;
77 # Similarly we simply omit the very top of the table and sort it out in the
79 our $break_top = 0xE0200;
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
86 my $minud = 0; # max/min upper case offset
88 my $minld = 0; # max/min lower case offset
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.
95 my $lpath = basename($path);
97 system("wget http://www.unicode.org/Public/5.0.0/ucd/$path");
98 chmod(0444, $lpath) or die "$lpath: $!\n";
100 open(STDIN, "<$lpath") or die "$lpath: $!\n";
101 print STDERR "Reading $lpath...\n";
105 # Read the main data file
106 input("UnicodeData.txt");
109 my @f = split(/;/, $_);
110 my $c = hex($f[0]); # codepoint
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) {
120 } elsif($name =~ /last>/i) {
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
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;
140 printf STDERR "> range %04X-%04X is %s\n", $start, $end, $gc;
142 for($c = $start; $c <= $end; ++$c) {
151 # This is a canonical decomposition
155 # This is only a compatibility decomposition
163 $max = $end if $end > $max;
166 sub read_prop_with_ranges {
174 my ($range, $propval) = split(/\s*;\s*/, $_);
175 if($range =~ /(.*)\.\.(.*)/) {
176 for my $c (hex($1) .. hex($2)) {
177 die "($range)\n" if($c == 0xAC00 and $propkey eq 'gbreak');
178 $data{$c}->{$propkey} = $propval;
182 $data{$c}->{$propkey} = $propval;
188 read_prop_with_ranges("auxiliary/GraphemeBreakProperty.txt", "gbreak");
189 read_prop_with_ranges("auxiliary/WordBreakProperty.txt", "wbreak");
190 read_prop_with_ranges("auxiliary/SentenceBreakProperty.txt", "sbreak");
192 # Compute the full list and fill in the Extend category properly
196 for my $c (keys %data) {
197 if(!exists $data{$c}->{gbreak}) {
198 $data{$c}->{gbreak} = 'Other';
200 $gbreak{$data{$c}->{gbreak}} = 1;
202 if(!exists $data{$c}->{wbreak}) {
203 if($data{$c}->{gbreak} eq 'Extend') {
204 $data{$c}->{wbreak} = 'Extend';
206 $data{$c}->{wbreak} = 'Other';
209 $wbreak{$data{$c}->{wbreak}} = 1;
211 if(!exists $data{$c}->{sbreak}) {
212 if($data{$c}->{gbreak} eq 'Extend') {
213 $data{$c}->{sbreak} = 'Extend';
215 $data{$c}->{sbreak} = 'Other';
218 $sbreak{$data{$c}->{sbreak}} = 1;
221 # Round up the maximum value to a whole number of subtables
222 $max += ($modulus - 1) - ($max % $modulus);
224 # Private use characters
225 # We only fill in values below $max, utf32__unidata()
232 for(my $c = 0xE000; $c <= 0xF8FF && $c <= $max; ++$c) {
235 for(my $c = 0xF0000; $c <= 0xFFFFD && $c <= $max; ++$c) {
238 for(my $c = 0x100000; $c <= 0x10FFFD && $c <= $max; ++$c) {
242 # Anything left is not assigned
244 "gc" => "Cn", # not assigned
249 for(my $c = 0; $c <= $max; ++$c) {
250 if(!exists $data{$c}) {
253 if(!exists $data{$c}->{wbreak}) {
254 $data{$c}->{wbreak} = 'Other';
256 if(!exists $data{$c}->{gbreak}) {
257 $data{$c}->{gbreak} = 'Other';
259 if(!exists $data{$c}->{sbreak}) {
260 $data{$c}->{sbreak} = 'Other';
265 # Read the casefolding data too
266 input("CaseFolding.txt");
269 next if /^\#/ or $_ eq '';
270 my @f = split(/\s*;\s*/, $_);
271 # Full case folding means use status C and F.
272 # We discard status T, Turkish users may wish to change this.
273 if($f[1] eq 'C' or $f[1] eq 'F') {
275 $data{$c}->{casefold} = $f[2];
276 # We are particularly interest in combining characters that
277 # case-fold to non-combining characters, or characters that
278 # case-fold to sequences with combining characters in non-initial
279 # positions, as these required decomposiiton before case-folding
280 my @d = map(hex($_), split(/\s+/, $data{$c}->{casefold}));
281 if($data{$c}->{ccc} != 0) {
282 # This is a combining character
283 if($data{$d[0]}->{ccc} == 0) {
284 # The first character of its case-folded form is NOT
285 # a combining character. The field name is the example
286 # explicitly mentioned in the spec.
287 $data{$c}->{ypogegrammeni} = 1;
290 # This is a non-combining character; inspect the non-initial
291 # code points of the case-folded sequence
293 if(grep($data{$_}->{ccc} != 0, @d)) {
294 # Some non-initial code point in the case-folded for is NOT a
295 # a combining character.
296 $data{$c}->{ypogegrammeni} = 1;
302 # Generate the header file
303 print STDERR "Generating unidata.h...\n";
304 open(STDOUT, ">unidata.h") or die "unidata.h: $!\n";
306 out("/* Automatically generated file, see scripts/make-unidata */\n",
307 "#ifndef UNIDATA_H\n",
308 "#define UNIDATA_H\n");
310 # TODO choose stable values for General_Category
311 out("enum unicode_General_Category {\n",
313 map(" unicode_General_Category_$_", sort keys %cats)), "\n};\n");
315 out("enum unicode_Grapheme_Break {\n",
317 map(" unicode_Grapheme_Break_$_", sort keys %gbreak)),
319 out("extern const char *const unicode_Grapheme_Break_names[];\n");
321 out("enum unicode_Word_Break {\n",
323 map(" unicode_Word_Break_$_", sort keys %wbreak)),
325 out("extern const char *const unicode_Word_Break_names[];\n");
327 out("enum unicode_Sentence_Break {\n",
329 map(" unicode_Sentence_Break_$_", sort keys %sbreak)),
331 out("extern const char *const unicode_Sentence_Break_names[];\n");
333 out("enum unicode_flags {\n",
334 " unicode_normalize_before_casefold = 1\n",
338 # Choose the narrowest type that will fit the required values
340 my ($min, $max) = @_;
342 return "char" if $max <= 127;
343 return "unsigned char" if $max <= 255;
344 return "int16_t" if $max < 32767;
345 return "uint16_t" if $max < 65535;
348 return "char" if $min >= -127 && $max <= 127;
349 return "int16_t" if $min >= -32767 && $max <= 32767;
354 out("struct unidata {\n",
355 " const uint32_t *compat;\n",
356 " const uint32_t *canon;\n",
357 " const uint32_t *casefold;\n",
358 # " ".choosetype($minud, $maxud)." upper_offset;\n",
359 # " ".choosetype($minld, $maxld)." lower_offset;\n",
360 " ".choosetype(0, $maxccc)." ccc;\n",
361 " char general_category;\n",
363 " char grapheme_break;\n",
364 " char word_break;\n",
365 " char sentence_break;\n",
367 # compat, canon and casefold do have have non-BMP characters, so we
368 # can't use a simple 16-bit table. We could use UTF-8 or UTF-16
369 # though, saving a bit of space (probably not that much...) at the
370 # cost of marginally reduced performance and additional complexity
372 out("extern const struct unidata *const unidata[];\n");
374 out("extern const struct unicode_utf8_row {\n",
376 " uint8_t min2, max2;\n",
377 "} unicode_utf8_valid[];\n");
379 out("#define UNICODE_NCHARS ", ($max + 1), "\n");
380 out("#define UNICODE_MODULUS $modulus\n");
381 out("#define UNICODE_BREAK_START $break_start\n");
382 out("#define UNICODE_BREAK_END $break_end\n");
383 out("#define UNICODE_BREAK_TOP $break_top\n");
387 close STDOUT or die "unidata.h: $!\n";
389 print STDERR "Generating unidata.c...\n";
390 open(STDOUT, ">unidata.c") or die "unidata.c: $!\n";
392 out("/* Automatically generated file, see scripts/make-unidata */\n",
393 "#include <config.h>\n",
394 "#include \"types.h\"\n",
395 "#include \"unidata.h\"\n");
397 # Short aliases to keep .c file small
399 out(map(sprintf("#define %s unicode_General_Category_%s\n", $_, $_),
401 out(map(sprintf("#define GB%s unicode_Grapheme_Break_%s\n", $_, $_),
403 out(map(sprintf("#define WB%s unicode_Word_Break_%s\n", $_, $_),
405 out(map(sprintf("#define SB%s unicode_Sentence_Break_%s\n", $_, $_),
408 # Names for *_Break properties
409 out("const char *const unicode_Grapheme_Break_names[] = {\n",
411 map(" \"$_\"", sort keys %gbreak)),
413 out("const char *const unicode_Word_Break_names[] = {\n",
415 map(" \"$_\"", sort keys %wbreak)),
417 out("const char *const unicode_Sentence_Break_names[] = {\n",
419 map(" \"$_\"", sort keys %sbreak)),
422 # Generate the decomposition mapping tables. We look out for duplicates
423 # in order to save space and report this as decompsaved at the end. In
424 # Unicode 5.0.0 this saves 1795 entries, which is at least 14Kbytes.
428 out("static const uint32_t ");
429 for(my $c = 0; $c <= $max; ++$c) {
430 # If canon is set then compat will be too and will be identical.
431 # If compat is set the canon might be clear. So we use the
432 # compat version and fix up the symbols after.
433 if(exists $data{$c} && exists $data{$c}->{compat}) {
435 (map(hex($_), split(/\s+/, $data{$c}->{compat})), 0));
436 if(!exists $decompnums{$s}) {
437 out(",\n") if $decompnum != 0;
438 out("cd$decompnum\[]={$s}");
439 $decompnums{$s} = $decompnum++;
443 $data{$c}->{compatsym} = "cd$decompnums{$s}";
444 if(exists $data{$c}->{canon}) {
445 $data{$c}->{canonsym} = "cd$decompnums{$s}";
451 # ...and the case folding table. Again we compress equal entries to save
452 # space. In Unicode 5.0.0 this saves 51 entries or at least 408 bytes.
453 # This doesns't seem as worthwhile as the decomposition mapping saving above.
457 out("static const uint32_t ");
458 for(my $c = 0; $c <= $max; ++$c) {
459 if(exists $data{$c} && exists $data{$c}->{casefold}) {
461 (map(hex($_), split(/\s+/, $data{$c}->{casefold})), 0));
462 if(!exists $cfnums{$s}) {
463 out(",\n") if $cfnum != 0;
464 out("cf$cfnum\[]={$s}");
465 $cfnums{$s} = $cfnum++;
469 $data{$c}->{cfsym} = "cf$cfnums{$s}";
474 # Visit all the $modulus-character blocks in turn and generate the
475 # required subtables. As above we spot duplicates to save space. In
476 # Unicode 5.0.0 with $modulus=128 and current table data this saves
477 # 1372 subtables or at least three and a half megabytes on 32-bit
480 my %subtable = (); # base->subtable number
481 my %subtableno = (); # subtable number -> content
482 my $subtablecounter = 0; # counter for subtable numbers
483 my $subtablessaved = 0; # number of tables saved
484 for(my $base = 0; $base <= $max; $base += $modulus) {
485 next if $base >= $break_start && $base < $break_end;
486 next if $base >= $break_top;
488 for(my $c = $base; $c < $base + $modulus; ++$c) {
490 my $canonsym = ($data{$c}->{canonsym} or "0");
491 my $compatsym = ($data{$c}->{compatsym} or "0");
492 my $cfsym = ($data{$c}->{cfsym} or "0");
494 if($data{$c}->{ypogegrammeni}) {
495 push(@flags, "unicode_normalize_before_casefold");
497 my $flags = @flags ? join("|", @flags) : 0;
513 my $t = join(",\n", @t);
514 if(!exists $subtable{$t}) {
515 out(sprintf("/* %04X-%04X */\n", $base, $base + $modulus - 1));
516 out("static const struct unidata st$subtablecounter\[] = {\n",
519 $subtable{$t} = $subtablecounter++;
523 $subtableno{$base} = $subtable{$t};
526 out("const struct unidata *const unidata[]={\n");
527 for(my $base = 0; $base <= $max; $base += $modulus) {
528 next if $base >= $break_start && $base < $break_end;
529 next if $base >= $break_top;
530 #out("st$subtableno{$base} /* ".sprintf("%04x", $base)." */,\n");
531 out("st$subtableno{$base},\n");
535 out("const struct unicode_utf8_row unicode_utf8_valid[] = {\n");
536 for(my $c = 0; $c <= 0x7F; ++$c) {
537 out(" { 1, 0, 0 }, /* $c */\n");
539 for(my $c = 0x80; $c < 0xC2; ++$c) {
540 out(" { 0, 0, 0 }, /* $c */\n");
542 for(my $c = 0xC2; $c <= 0xDF; ++$c) {
543 out(" { 2, 0x80, 0xBF }, /* $c */\n");
545 for(my $c = 0xE0; $c <= 0xE0; ++$c) {
546 out(" { 3, 0xA0, 0xBF }, /* $c */\n");
548 for(my $c = 0xE1; $c <= 0xEC; ++$c) {
549 out(" { 3, 0x80, 0xBF }, /* $c */\n");
551 for(my $c = 0xED; $c <= 0xED; ++$c) {
552 out(" { 3, 0x80, 0x9F }, /* $c */\n");
554 for(my $c = 0xEE; $c <= 0xEF; ++$c) {
555 out(" { 3, 0x80, 0xBF }, /* $c */\n");
557 for(my $c = 0xF0; $c <= 0xF0; ++$c) {
558 out(" { 4, 0x90, 0xBF }, /* $c */\n");
560 for(my $c = 0xF1; $c <= 0xF3; ++$c) {
561 out(" { 4, 0x80, 0xBF }, /* $c */\n");
563 for(my $c = 0xF4; $c <= 0xF4; ++$c) {
564 out(" { 4, 0x80, 0x8F }, /* $c */\n");
566 for(my $c = 0xF5; $c <= 0xFF; ++$c) {
567 out(" { 0, 0, 0 }, /* $c */\n");
571 close STDOUT or die "unidata.c: $!\n";
573 printf STDERR "modulus=%d\n", $modulus;
574 printf STDERR "max=%04X\n", $max;
575 print STDERR "subtables=$subtablecounter, subtablessaved=$subtablessaved\n";
576 print STDERR "decompsaved=$decompsaved cfsaved=$cfsaved\n";