| #!/usr/bin/perl -w | |
| # unicode-to-chartables.pl -- generate Unicode database for java.lang.Character | |
| # Copyright (C) 1998, 2002, 2004, 2006 Free Software Foundation, Inc. | |
| # | |
| # This file is part of GNU Classpath. | |
| # | |
| # GNU Classpath is free software; you can redistribute it and/or modify | |
| # it under the terms of the GNU General Public License as published by | |
| # the Free Software Foundation; either version 2, or (at your option) | |
| # any later version. | |
| # | |
| # GNU Classpath is distributed in the hope that it will be useful, but | |
| # WITHOUT ANY WARRANTY; without even the implied warranty of | |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| # General Public License for more details. | |
| # | |
| # You should have received a copy of the GNU General Public License | |
| # along with GNU Classpath; see the file COPYING. If not, write to the | |
| # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| # 02110-1301 USA. | |
| # | |
| # Linking this library statically or dynamically with other modules is | |
| # making a combined work based on this library. Thus, the terms and | |
| # conditions of the GNU General Public License cover the whole | |
| # combination. | |
| # | |
| # As a special exception, the copyright holders of this library give you | |
| # permission to link this library with independent modules to produce an | |
| # executable, regardless of the license terms of these independent | |
| # modules, and to copy and distribute the resulting executable under | |
| # terms of your choice, provided that you also meet, for each linked | |
| # independent module, the terms and conditions of the license of that | |
| # module. An independent module is a module which is not derived from | |
| # or based on this library. If you modify this library, you may extend | |
| # this exception to your version of the library, but you are not | |
| # obligated to do so. If you do not wish to do so, delete this | |
| # exception statement from your version. | |
| # Code for reading UnicodeData-4.0.0.txt and SpecialCasing-4.0.0.txt to generate | |
| # the code for java-chartables.h. The relevant files can be found here: | |
| # | |
| # http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt | |
| # http://www.unicode.org/Public/4.0-Update/SpecialCasing-4.0.0.txt | |
| # | |
| # Inspired by code from Jochen Hoenicke. | |
| # author Eric Blake <ebb9@email.byu.edu> | |
| # Unicode 4.0.0 support by Anthony Balkissoon <abalkiss@redhat.com> | |
| # | |
| # Usage: ./unicode-to-chartables.pl <UnicodeData> <SpecialCasing> <tables> | |
| # where <UnicodeData.txt> is obtained from www.unicode.org (named | |
| # UnicodeData-4.0.0.txt for Unicode version 4.0.0), <SpecialCasing> | |
| # is obtained from www.unicode too (named SpecialCasing-4.0.0.txt for Unicode | |
| # version 4.0.0), and <tables> is the final location for the header file | |
| # java-chartables.h. As of JDK 1.5, use Unicode version 4.0.0 | |
| # for best results. | |
| ## | |
| ## Return the given variable interpreted as a 16 bit signed number. | |
| ## | |
| sub cShort($) { | |
| my ($char) = @_; | |
| return unpack "s", pack "I", $char; | |
| } | |
| ## | |
| ## Convert the text UnicodeData file from www.unicode.org into a header file | |
| ## interface with arrays holding the compressed information. | |
| ## | |
| my @TYPECODES = qw(Cn Lu Ll Lt Lm Lo Mn Me Mc Nd Nl No Zs Zl Zp Cc Cf | |
| SKIPPED Co Cs Pd Ps Pe Pc Po Sm Sc Sk So Pi Pf); | |
| my @DIRCODES = qw(L R AL EN ES ET AN CS NSM BN B S WS ON LRE LRO RLE RLO PDF); | |
| my $NOBREAK_FLAG = 32; | |
| my $MIRRORED_FLAG = 64; | |
| my %special = (); | |
| # infoArray is an array where each element is a list of character information | |
| # for characters in a plane. The index of each list is equal to the plane | |
| # that it corresponds to even though most of these lists will currently be | |
| # empty. This is done so that that this script can be easily modified to | |
| # accomodate future versions of Unicode. | |
| my @infoArray = \((), (), (), (), (), (), (), (), | |
| (), (), (), (), (), (), (), (), ()); | |
| # info is a reference to one of the lists in infoArray, depending on which | |
| # plane we're currently parsing. | |
| my $info; | |
| # largeNums is an array of numerical values that are too large to fit | |
| # into the 16 bit char where most numerical values are stored. | |
| # What is stored in the char then is a number N such that (-N - 3) is | |
| # the index into largeNums where the numerical value can be found. | |
| my @largeNums = (); | |
| my $titlecase = ""; | |
| my $count = 0; | |
| my $range = 0; | |
| die "Usage: $0 <UnicodeData.txt> <SpecialCasing.txt> <java-chartables.h>" | |
| unless @ARGV == 3; | |
| $| = 1; | |
| print "GNU Classpath Unicode Attribute Database Generator 2.1\n"; | |
| print "Copyright (C) 1998, 2002 Free Software Foundation, Inc.\n"; | |
| ################################################################################ | |
| ################################################################################ | |
| # Stage 0: Parse the special casing file | |
| print "Parsing special casing file\n"; | |
| open (SPECIAL, "< $ARGV[1]") || die "Can't open special casing file: $!\n"; | |
| while (<SPECIAL>) { | |
| next if /^\#/; | |
| my ($ch, undef, undef, $upper) = split / *; */; | |
| # This grabs only the special casing for multi-char uppercase. Note that | |
| # there are no multi-char lowercase, and that Sun ignores multi-char | |
| # titlecase rules. This script omits 3 special cases in Unicode 3.0.0, | |
| # which must be hardcoded in java.lang.String: | |
| # \u03a3 (Sun ignores this special case) | |
| # \u0049 - lowercases to \u0131, but only in Turkish locale | |
| # \u0069 - uppercases to \u0130, but only in Turkish locale | |
| next unless defined $upper and $upper =~ / /; | |
| $special{hex $ch} = [map {hex} split ' ', $upper]; | |
| } | |
| close SPECIAL; | |
| ################################################################################ | |
| ################################################################################ | |
| ## Stage 1: Parse the attribute file | |
| print "Parsing attributes file"; | |
| open (UNICODE, "< $ARGV[0]") || die "Can't open Unicode attribute file: $!\n"; | |
| while (<UNICODE>) { | |
| print "." unless $count++ % 1000; | |
| chomp; | |
| s/\r//g; | |
| my ($ch, $name, $category, undef, $bidir, $decomp, undef, undef, $numeric, | |
| $mirrored, undef, undef, $upcase, $lowcase, $title) = split ';'; | |
| $ch = hex($ch); | |
| # plane tells us which Unicode code plane we're currently in and is an | |
| # index into infoArray. | |
| my $plane = int($ch / 0x10000); | |
| my $planeBase = $plane * 0x10000; | |
| $info = \@{$infoArray[$plane]}; | |
| my ($type, $numValue, $upperchar, $lowerchar, $direction); | |
| $type = 0; | |
| while ($category !~ /^$TYPECODES[$type]$/) { | |
| if (++$type == @TYPECODES) { | |
| die "$ch: Unknown type: $category"; | |
| } | |
| } | |
| $type |= $NOBREAK_FLAG if ($decomp =~ /noBreak/); | |
| $type |= $MIRRORED_FLAG if ($mirrored =~ /Y/); | |
| if ($numeric =~ /^[0-9]+$/) { | |
| $numValue = $numeric; | |
| # If numeric takes more than 16 bits to store we want to store that | |
| # number in a separate array and store a number N in numValue such | |
| # that (-N - 3) is the offset into the separate array containing the | |
| # large numerical value. | |
| if ($numValue >= 0x7fff) { | |
| $numValue = -3 - @largeNums; | |
| push @largeNums, $numeric; | |
| } | |
| } elsif ($numeric eq "") { | |
| # Special case sequences of 'a'-'z' | |
| if ($ch >= 0x0041 && $ch <= 0x005a) { | |
| $numValue = $ch - 0x0037; | |
| } elsif ($ch >= 0x0061 && $ch <= 0x007a) { | |
| $numValue = $ch - 0x0057; | |
| } elsif ($ch >= 0xff21 && $ch <= 0xff3a) { | |
| $numValue = $ch - 0xff17; | |
| } elsif ($ch >= 0xff41 && $ch <= 0xff5a) { | |
| $numValue = $ch - 0xff37; | |
| } else { | |
| $numValue = -1; | |
| } | |
| } else { | |
| $numValue = -2; | |
| } | |
| $upperchar = $upcase ? hex($upcase) - $ch : 0; | |
| $lowerchar = $lowcase ? hex($lowcase) - $ch : 0; | |
| if ($title ne $upcase) { | |
| my $titlechar = $title ? hex($title) : $ch; | |
| $titlecase .= pack("n2", $ch, $titlechar); | |
| } | |
| $direction = 0; | |
| while ($bidir !~ /^$DIRCODES[$direction]$/) { | |
| if (++$direction == @DIRCODES) { | |
| $direction = -1; | |
| last; | |
| } | |
| } | |
| $direction <<= 2; | |
| $direction += $#{$special{$ch}} if defined $special{$ch}; | |
| if ($range) { | |
| die "Expecting end of range at $ch\n" unless $name =~ /Last>$/; | |
| for ($range + 1 .. $ch - 1) { | |
| $info->[$_ - $planeBase] = pack("n5", $type, $numValue, $upperchar, | |
| $lowerchar, $direction); | |
| } | |
| $range = 0; | |
| } elsif ($name =~ /First>$/) { | |
| $range = $ch; | |
| } | |
| # Store all this parsed information into the element in infoArray that info | |
| # points to. | |
| $info->[$ch - $planeBase] = pack("n5", $type, $numValue, $upperchar, $lowerchar, | |
| $direction); | |
| } | |
| close UNICODE; | |
| ################################################################################ | |
| ################################################################################ | |
| ## Stage 2: Compress the data structures | |
| printf "\nCompressing data structures"; | |
| $count = 0; | |
| # data is a String that will be used to create the DATA String containing | |
| # character information and offsets into the attribute tables. | |
| my @data = (); | |
| # charhashArray is an array of hashtables used so that we can reuse character | |
| # attributes when characters share the same attributes ... this makes our | |
| # attribute tables smaller. charhash is a pointer into this array. | |
| my @charhashArray = ({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}); | |
| my $charhash = (); | |
| # charinfoArray is an array of arrays, one per plane, for storing character | |
| # information. charinfo is a pointer into this array. | |
| my @charinfoArray = \((), (), (), (), (), (), (), (), | |
| (), (), (), (), (), (), (), (), ()); | |
| my $charinfo; | |
| # charlen is an array, one element per plane, that tells us how many unique | |
| # character attributes there are for that plane. | |
| my @charlen = (); | |
| for my $plane (0 .. 0x10) { | |
| $info = \@{$infoArray[$plane]}; | |
| my $planeBase = $plane * 0x10000; | |
| $charhash = \%{$charhashArray[$plane]}; | |
| $charinfo = \@{$charinfoArray[$plane]}; | |
| for my $ch ($planeBase .. $planeBase + 0xffff) { | |
| my $index = $ch - $planeBase; | |
| print "." unless $count++ % 0x1000; | |
| $info->[$index] = pack("n5", 0, -1, 0, 0, -4) unless defined $info->[$index]; | |
| my ($type, $numVal, $upper, $lower, $direction) = unpack("n5", $info->[$index]); | |
| if (! exists $charhash->{$info->[$index]}) { | |
| # If we entered this loop that means the character we're looking at | |
| # now has attributes that are unique from those that we've looked | |
| # at so far for this plane. So we push its attributes into charinfo | |
| # and store in charhash the offset into charinfo where these | |
| # attributes can later be found. | |
| push @{$charinfo}, [ $numVal, $upper, $lower, $direction ]; | |
| $charhash->{$info->[$index]} = @{$charinfo} - 1; | |
| # When the file is generaged, the number we just stored in charhas | |
| # will be the upper 9 bits in the DATA String that are an offset | |
| # into the attribute tables. | |
| } | |
| $data[$plane] .= pack("n", ($charhash->{$info->[$index]} << 7) | $type); | |
| } | |
| $charlen[$plane] = scalar(@{$charinfoArray[$plane]}); | |
| } | |
| # the shift that results in the best compression of the table. This is an array | |
| # because different shifts are better for the different tables for each plane. | |
| my @bestshift; | |
| # an initial guess. | |
| my $bestest = 1000000; | |
| my @bestblkstr; | |
| my @blksize = (); | |
| for my $plane (0 .. 0x10) { | |
| print "\n\nplane: $plane\n"; | |
| print "Unique character entries: $charlen[$plane]\n"; | |
| $bestest = 1000000; | |
| for my $i (3 .. 8) { | |
| my $blksize = 1 << $i; | |
| my %blocks = (); | |
| my @blkarray = (); | |
| my ($j, $k); | |
| print "shift: $i"; | |
| for ($j = 0; $j < 0x10000; $j += $blksize) { | |
| my $blkkey = substr $data[$plane], 2 * $j, 2 * $blksize; | |
| if (! exists $blocks{$blkkey}) { | |
| push @blkarray, $blkkey; | |
| $blocks{$blkkey} = $#blkarray; | |
| } | |
| } | |
| my $blknum = @blkarray; | |
| my $blocklen = $blknum * $blksize; | |
| printf " before %5d", $blocklen; | |
| # Now we try to pack the blkarray as tight as possible by finding matching | |
| # heads and tails. | |
| for ($j = $blksize - 1; $j > 0; $j--) { | |
| my %tails = (); | |
| for $k (0 .. $#blkarray) { | |
| next unless defined $blkarray[$k]; | |
| my $len = length $blkarray[$k]; | |
| my $tail = substr $blkarray[$k], $len - $j * 2; | |
| if (exists $tails{$tail}) { | |
| push @{$tails{$tail}}, $k; | |
| } else { | |
| $tails{$tail} = [ $k ]; | |
| } | |
| } | |
| # tails are calculated, now calculate the heads and merge. | |
| BLOCK: | |
| for $k (0 .. $#blkarray) { | |
| next unless defined $blkarray[$k]; | |
| my $tomerge = $k; | |
| while (1) { | |
| my $head = substr($blkarray[$tomerge], 0, $j * 2); | |
| my $entry = $tails{$head}; | |
| next BLOCK unless defined $entry; | |
| my $other = shift @{$entry}; | |
| if ($other == $tomerge) { | |
| if (@{$entry}) { | |
| push @{$entry}, $other; | |
| $other = shift @{$entry}; | |
| } else { | |
| push @{$entry}, $other; | |
| next BLOCK; | |
| } | |
| } | |
| if (@{$entry} == 0) { | |
| delete $tails{$head}; | |
| } | |
| # a match was found | |
| my $merge = $blkarray[$other] | |
| . substr($blkarray[$tomerge], $j * 2); | |
| $blocklen -= $j; | |
| $blknum--; | |
| if ($other < $tomerge) { | |
| $blkarray[$tomerge] = undef; | |
| $blkarray[$other] = $merge; | |
| my $len = length $merge; | |
| my $tail = substr $merge, $len - $j * 2; | |
| $tails{$tail} = [ map { $_ == $tomerge ? $other : $_ } | |
| @{$tails{$tail}} ]; | |
| next BLOCK; | |
| } | |
| $blkarray[$tomerge] = $merge; | |
| $blkarray[$other] = undef; | |
| } | |
| } | |
| } | |
| my $blockstr; | |
| for $k (0 .. $#blkarray) { | |
| $blockstr .= $blkarray[$k] if defined $blkarray[$k]; | |
| } | |
| die "Unexpected $blocklen" if length($blockstr) != 2 * $blocklen; | |
| my $estimate = 2 * $blocklen + (0x20000 >> $i); | |
| printf " after merge %5d: %6d bytes\n", $blocklen, $estimate; | |
| if ($estimate < $bestest) { | |
| $bestest = $estimate; | |
| $bestshift[$plane] = $i; | |
| $bestblkstr[$plane] = $blockstr; | |
| } | |
| } | |
| $blksize[$plane] = 1 << $bestshift[$plane]; | |
| print "best shift: ", $bestshift[$plane]; | |
| print " blksize: ", $blksize[$plane]; | |
| } | |
| my @blocksArray = \((), (), (), (), (), (), (), (), | |
| (), (), (), (), (), (), (), (), ()); | |
| for my $plane (0 .. 0x10) { | |
| for (my $j = 0; $j < 0x10000; $j += $blksize[$plane]) { | |
| my $blkkey = substr $data[$plane], 2 * $j, 2 * $blksize[$plane]; | |
| my $index = index $bestblkstr[$plane], $blkkey; | |
| while ($index & 1) { | |
| die "not found: $j" if $index == -1; | |
| $index = index $bestblkstr[$plane], $blkkey, $index + 1; | |
| } | |
| push @{$blocksArray[$plane]}, ($index / 2 - $j) & 0xffff; | |
| } | |
| } | |
| ################################################################################ | |
| ################################################################################ | |
| ## Stage 3: Generate the file | |
| for my $plane (0 .. 0x10) { | |
| die "UTF-8 limit of blocks may be exceeded for plane $plane: " . scalar(@{$blocksArray[$plane]}) . "\n" | |
| if @{$blocksArray[$plane]} > 0xffff / 3; | |
| die "UTF-8 limit of data may be exceeded for plane $plane: " . length($bestblkstr[$plane]) . "\n" | |
| if length($bestblkstr[$plane]) > 0xffff / 3; | |
| } | |
| { | |
| print "\nGenerating $ARGV[2]."; | |
| my ($i, $j); | |
| open OUTPUT, "> $ARGV[2]" or die "Failed creating output file: $!\n"; | |
| print OUTPUT <<EOF; | |
| /* java-chartables.h -- Character tables for java.lang.Character -*- c++ -*- | |
| Copyright (C) 2002, 2006 Free Software Foundation, Inc. | |
| *** This file is generated by scripts/unicode-to-chartables.pl *** | |
| This file is part of GNU Classpath. | |
| GNU Classpath is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 2, or (at your option) | |
| any later version. | |
| GNU Classpath is distributed in the hope that it will be useful, but | |
| WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GNU Classpath; see the file COPYING. If not, write to the | |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| 02110-1301 USA. | |
| Linking this library statically or dynamically with other modules is | |
| making a combined work based on this library. Thus, the terms and | |
| conditions of the GNU General Public License cover the whole | |
| combination. | |
| As a special exception, the copyright holders of this library give you | |
| permission to link this library with independent modules to produce an | |
| executable, regardless of the license terms of these independent | |
| modules, and to copy and distribute the resulting executable under | |
| terms of your choice, provided that you also meet, for each linked | |
| independent module, the terms and conditions of the license of that | |
| module. An independent module is a module which is not derived from | |
| or based on this library. If you modify this library, you may extend | |
| this exception to your version of the library, but you are not | |
| obligated to do so. If you do not wish to do so, delete this | |
| exception statement from your version. */ | |
| #ifndef __JAVA_CHARTABLES_H__ | |
| #define __JAVA_CHARTABLES_H__ | |
| // These tables are automatically generated by scripts/unicode_to_chartables.pl. | |
| // The Unicode data comes from www.unicode.org; this header is based on | |
| // UnicodeData-4.0.0.txt. JDK 1.5 uses Unicode version 4.0.0. | |
| // DO NOT EDIT the tables. Instead, fix the upstream scripts and run | |
| // them again. | |
| // The data is stored in C style arrays of the appropriate CNI types, to | |
| // guarantee that the data is constant and non-relocatable. The field | |
| // <code>blocks</code> stores the offset of a block of 2<sup>SHIFT</sup> | |
| // characters within <code>data</code>. The data field, in turn, stores | |
| // information about each character in the low order bits, and an offset | |
| // into the attribute tables <code>upper</code>, <code>lower</code>, | |
| // <code>numValue</code>, and <code>direction</code>. Notice that the | |
| // attribute tables are much smaller than 0xffff entries; as many characters | |
| // in Unicode share common attributes. Finally, there is a listing for | |
| // <code>title</code> exceptions (most characters just have the same title | |
| // case as upper case). | |
| // This file should only be included by natCharacter.cc | |
| /** | |
| * The array containing the numeric values that are too large to be stored as | |
| * chars in NUM_VALUE. NUM_VALUE in this case will contain a negative integer | |
| * N such that LARGENUMS[-N - 3] contains the correct numeric value. | |
| */ | |
| EOF | |
| print OUTPUT "static const jint largenums[] = {\n "; | |
| for ($i = 0; $i < @largeNums; $i++) { | |
| print OUTPUT $largeNums[$i], ", "; | |
| } | |
| print OUTPUT "}"; | |
| print OUTPUT <<EOF; | |
| ; | |
| /** | |
| * The character shift amount to look up the block offset. In other words, | |
| * <code>(char) (blocks[p][off >> SHIFT[p]] + off)</code> is the index where | |
| * <code>ch</code> is described in <code>data</code>, where <code>off</code> | |
| * is ch & 0xffff and <code>p</code> is the plane the character belongs to. | |
| */ | |
| EOF | |
| print OUTPUT "static const int shift[] = {\n "; | |
| for ($i = 0; $i < @bestshift; $i++) { | |
| print OUTPUT $bestshift[$i], ", "; | |
| } | |
| print OUTPUT "}"; | |
| print OUTPUT <<EOF; | |
| ; | |
| /** | |
| * The mapping of character blocks to their location in <code>data</code>. | |
| * Each entry has been adjusted so that a modulo 16 sum with the desired | |
| * character gives the actual index into <code>data</code>. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14) ; | |
| print OUTPUT "static const jchar blocks", $plane, "[] = {\n"; | |
| for ($i = 0; $i < @{$blocksArray[$plane]} / 10; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 9) { | |
| last if @{$blocksArray[$plane]} <= $i * 10 + $j; | |
| my $val = $blocksArray[$plane]->[$i * 10 + $j]; | |
| print OUTPUT $val, ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int blocks_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT scalar(@{$blocksArray[$plane]}), ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jchar* blocks[] = { | |
| blocks0, blocks1, blocks2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, blocks14, NULL, NULL}; | |
| /** | |
| * Information about each character. The low order 5 bits form the | |
| * character type, the next bit is a flag for non-breaking spaces, and the | |
| * next bit is a flag for mirrored directionality. The high order 9 bits | |
| * form the offset into the attribute tables. Note that this limits the | |
| * number of unique character attributes per plane to 512, which is not a | |
| * problem as of Unicode version 4.0.0, but may soon become one. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14); | |
| print OUTPUT "static const jchar data", $plane, "[] = {\n"; | |
| my $len = length($bestblkstr[$plane]) / 2; | |
| for ($i = 0; $i < $len / 10; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 9) { | |
| last if $len <= $i * 10 + $j; | |
| my $val = unpack "n", substr($bestblkstr[$plane], 2 * ($i * 10 + $j), 2); | |
| print OUTPUT $val, ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int data_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT length($bestblkstr[$plane]) / 2, ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jchar* data[] = { | |
| data0, data1, data2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, data14, NULL, NULL}; | |
| /** | |
| * This is the attribute table for computing the numeric value of a | |
| * character. The value is -1 if Unicode does not define a value, -2 | |
| * if the value is not a positive integer, otherwise it is the value. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14); | |
| print OUTPUT "static const jshort numValue", $plane, "[] = {\n"; | |
| $len = @{$charinfoArray[$plane]}; | |
| for ($i = 0; $i < $len / 13; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 12) { | |
| last if $len <= $i * 13 + $j; | |
| my $val = $charinfoArray[$plane]->[$i * 13 + $j][0]; | |
| print OUTPUT cShort($val), ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int numValue_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT scalar(@{$charinfoArray[$plane]}), ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jshort* numValue[] = { | |
| numValue0, numValue1, numValue2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, numValue14, NULL, NULL}; | |
| /** | |
| * This is the attribute table for computing the uppercase representation | |
| * of a character. The value is the difference between the character and | |
| * its uppercase version. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14); | |
| print OUTPUT "static const jshort upper", $plane, "[] = {\n"; | |
| $len = @{$charinfoArray[$plane]}; | |
| for ($i = 0; $i < $len / 13; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 12) { | |
| last if $len <= $i * 13 + $j; | |
| my $val = $charinfoArray[$plane]->[$i * 13 + $j][1]; | |
| print OUTPUT cShort($val), ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int upper_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT scalar(@{$charinfoArray[$plane]}), ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jshort* upper[] = { | |
| upper0, upper1, upper2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, upper14, NULL, NULL}; | |
| /** | |
| * This is the attribute table for computing the lowercase representation | |
| * of a character. The value is the difference between the character and | |
| * its lowercase version. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14); | |
| print OUTPUT "static const jshort lower", $plane, "[] = {\n"; | |
| $len = @{$charinfoArray[$plane]}; | |
| for ($i = 0; $i < $len / 13; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 12) { | |
| last if $len <= $i * 13 + $j; | |
| my $val = $charinfoArray[$plane]->[$i * 13 + $j][2]; | |
| print OUTPUT cShort($val), ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int lower_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT scalar(@{$charinfoArray[$plane]}), ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jshort* lower[] = { | |
| lower0, lower1, lower2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, lower14, NULL, NULL}; | |
| /** | |
| * This is the attribute table for computing the directionality class | |
| * of a character. At present, the value is in the range 0 - 18 if the | |
| * character has a direction, otherwise it is -1. | |
| */ | |
| EOF | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| # The following if statement handles the cases of unassigned planes | |
| # specially so we don't waste space with unused Strings. As of | |
| # Unicode version 4.0.0 only planes 0, 1, 2, and 14 are used. If | |
| # you are updating this script to work with a later version of | |
| # Unicode you may have to alter this if statement. | |
| next if ($plane > 2 && $plane != 14); | |
| print OUTPUT "static const jbyte direction", $plane, "[] = {\n"; | |
| $len = @{$charinfoArray[$plane]}; | |
| for ($i = 0; $i < $len / 19; $i++) { | |
| print OUTPUT " "; | |
| for $j (0 .. 18) { | |
| last if $len <= $i * 19 + $j; | |
| my $val = $charinfoArray[$plane]->[$i * 19 + $j][3]; | |
| $val >>= 2; | |
| if ($val < 0 || $val > 18){ | |
| $val = -1; | |
| } | |
| print OUTPUT cShort($val), ", "; | |
| } | |
| print OUTPUT "\n"; | |
| } | |
| print OUTPUT "};\n\n"; | |
| } | |
| print OUTPUT "static const int direction_length[] = {\n "; | |
| for ($plane = 0; $plane <= 0x10; $plane++) { | |
| if ($plane > 2 && $plane != 14){ | |
| print OUTPUT "-1, "; | |
| } | |
| else { | |
| print OUTPUT scalar(@{$charinfoArray[$plane]}), ", "; | |
| } | |
| } | |
| print OUTPUT "};\n"; | |
| print OUTPUT <<EOF; | |
| static const jbyte* direction[] = { | |
| direction0, direction1, direction2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
| NULL, NULL, NULL, NULL, direction14, NULL, NULL}; | |
| /** | |
| * This is the listing of titlecase special cases (all other character | |
| * can use <code>upper</code> to determine their titlecase). The listing | |
| * is a sequence of character pairs; converting the first character of the | |
| * pair to titlecase produces the second character. | |
| */ | |
| static const jchar title[] = { | |
| EOF | |
| $len = length($titlecase) / 2; | |
| for ($i = 0; $i < $len / 10; $i++) { | |
| print OUTPUT $i ? "\n " : " "; | |
| for $j (0 .. 9) { | |
| last if $len <= $i * 10 + $j; | |
| my $val = unpack "n", substr($titlecase, 2 * ($i * 10 + $j), 2); | |
| print OUTPUT $val, ", "; | |
| } | |
| } | |
| print OUTPUT "\n };"; | |
| print OUTPUT "\n/** Length of title. */\nstatic const int title_length = ", $len; | |
| print OUTPUT <<EOF; | |
| ; | |
| #endif /* __JAVA_CHARTABLES_H__ */ | |
| EOF | |
| close OUTPUT; | |
| } | |
| print "\nDone.\n"; |