зеркало из https://github.com/mozilla/pjs.git
607 строки
20 KiB
Perl
Executable File
607 строки
20 KiB
Perl
Executable File
#!/usr/bin/perl -w
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
#
|
|
# The contents of this file are subject to the Mozilla Public License Version
|
|
# 1.1 (the "License"); you may not use this file except in compliance with
|
|
# the License. You may obtain a copy of the License at
|
|
# http://www.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS" basis,
|
|
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
# for the specific language governing rights and limitations under the
|
|
# License.
|
|
#
|
|
# The Original Code is Mozilla Communicator.
|
|
#
|
|
# The Initial Developer of the Original Code is
|
|
# Jungshik Shin <jshin@mailaps.org>.
|
|
# Portions created by the Initial Developer are Copyright (C) 2002, 2003
|
|
# the Initial Developer. All Rights Reserved.
|
|
#
|
|
# Contributor(s):
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
# in which case the provisions of the GPL or the LGPL are applicable instead
|
|
# of those above. If you wish to allow use of your version of this file only
|
|
# under the terms of either the GPL or the LGPL, and not to allow others to
|
|
# use your version of this file under the terms of the MPL, indicate your
|
|
# decision by deleting the provisions above and replace them with the notice
|
|
# and other provisions required by the GPL or the LGPL. If you do not delete
|
|
# the provisions above, a recipient may use your version of this file under
|
|
# the terms of any one of the MPL, the GPL or the LGPL.
|
|
#
|
|
# ***** END LICENSE BLOCK *****
|
|
|
|
# This script is used to generate precompiled CCMap files.
|
|
# See bug 180266 for details.
|
|
#
|
|
# Revised to support extended CCMaps for non-BMP characters : 2003-09-19 (bug 205387)
|
|
# Revised to support the automatic generation of a macro defining the size
|
|
# of a CCMap in terms of PRUint16 : 2003-12-11 (bug 224337)
|
|
|
|
use strict;
|
|
|
|
|
|
use vars qw($fill_fmt $fu_sz);
|
|
use vars qw($e_mid_offset $e_pg_offset);
|
|
|
|
(@ARGV < 1 ) and usage();
|
|
|
|
my $ifn = $ARGV[0];
|
|
|
|
my ($ifh, $variable, $class);
|
|
open $ifh , "< $ifn" or die "Cannot open $ifn";
|
|
|
|
if (@ARGV >= 2) {
|
|
$variable = $ARGV[1];
|
|
printf STDERR
|
|
"$0:\n\t VARIABLE $variable is specified in the command line.\n" .
|
|
"\t The variable name spec. in the input file will be ignored.\n";
|
|
}
|
|
|
|
if (@ARGV >= 3) {
|
|
$class = $ARGV[2];
|
|
printf STDERR
|
|
"$0:\n\t CLASS $class is specified in the command line.\n" .
|
|
"\t The class spec. in the input file will be ignored.\n";
|
|
}
|
|
|
|
use constant N_PLANES => 17; # BMP + 16 non-BMP planes
|
|
use constant PLANE_SZ => 0x10000;
|
|
use constant MID_SZ => PLANE_SZ / 16;
|
|
use constant PG_SZ => MID_SZ / 16;
|
|
|
|
# Unlike FillInfo() method in Mozilla, let's use 16bit integer
|
|
# to pack the character coverage/representability. This way,
|
|
# we can just copy fillinfo to fill up page maps later.
|
|
use constant {
|
|
FILL_SZ => PLANE_SZ / 16,
|
|
MID_FILL_SZ => MID_SZ / 16,
|
|
PG_FILL_SZ => PG_SZ / 16
|
|
};
|
|
|
|
|
|
|
|
# network byte order short. actually, byte order doesn't matter.
|
|
$fill_fmt = "n1";
|
|
$fu_sz = length(pack $fill_fmt, 0); # fillinfo unit size in byte (size of short)
|
|
|
|
$e_mid_offset = 16;
|
|
$e_pg_offset = 32;
|
|
|
|
my @ccmap = ();
|
|
my %pg_flags = ();
|
|
my @fillinfo = ();
|
|
my %comments = ();
|
|
|
|
my $planes = &read_input(\@fillinfo,$ifh,\%comments);
|
|
|
|
if (!defined($variable) && !defined($comments{'VARIABLE'}))
|
|
{
|
|
printf STDERR "Variable name is not specified in the cmd line. " .
|
|
"Neither is it found in the input file.\n\n" ;
|
|
usage();
|
|
}
|
|
|
|
$variable = $comments{'VARIABLE'} if (! defined($variable));
|
|
|
|
if (!defined($class) && !defined($comments{'CLASS'}))
|
|
{
|
|
printf STDERR "Class name is not specified in the cmd line. " .
|
|
"Neither is it found in the input file.\n\n" ;
|
|
usage();
|
|
}
|
|
|
|
$class = $comments{'CLASS'} if (! defined($class));
|
|
|
|
my $have_non_bmp = 0;
|
|
|
|
# add the non_bmp flag and the bmp ccmap size (default to 0)
|
|
# at the very beginning if there are non-bmp characters.
|
|
if ($planes & 0x1fe) {
|
|
push @ccmap, (1, 0);
|
|
$have_non_bmp = 1;
|
|
}
|
|
|
|
my $plane_idx_offset;
|
|
foreach my $plane (0 .. ($have_non_bmp ? 16 : 0))
|
|
{
|
|
my @plane_ccmap = add_plane(\@ccmap, \@fillinfo, $plane);
|
|
my $size = @plane_ccmap;
|
|
push @ccmap, @plane_ccmap;
|
|
if ($plane == 0 && $have_non_bmp) {
|
|
$ccmap[1] = $size;
|
|
# add 2 for non-BMP flag and BMP plane size
|
|
# that have negative indices in C++.
|
|
$plane_idx_offset = $size + 2;
|
|
|
|
# 'Flag' the offset as holding the plane indices (any negative
|
|
# number would do)
|
|
$pg_flags{$plane_idx_offset} = -1;
|
|
$pg_flags{$plane_idx_offset + 16} = -1;
|
|
|
|
# plane indices are 16 PRUint32's(not 16 PRUint16's).
|
|
# In Perl, we assign each PRUint32 two slots in @ccmap (in BE order)
|
|
my $e_plane_offset = $size + 16 * 2;
|
|
|
|
# set plane indices to the empty plane by default
|
|
foreach my $i (1 .. 16) {
|
|
# split PRUint32 into two PRUint16's in BE
|
|
push @ccmap, $e_plane_offset >> 16;
|
|
push @ccmap, $e_plane_offset & 0xffff;
|
|
}
|
|
# add 'the' empty plane;
|
|
push @ccmap, (0) x 16;
|
|
}
|
|
if ($plane > 0) {
|
|
if ($size > 0) {
|
|
# split PRUint32 into two PRUint16's in BE.
|
|
# subtract 2 for non-BMP flag and BMP plane size
|
|
# that have negative indices in C++.
|
|
$ccmap[$plane_idx_offset + ($plane - 1) * 2] = (@ccmap - $size - 2) >> 16;
|
|
$ccmap[$plane_idx_offset + ($plane - 1) * 2 + 1] = (@ccmap - $size -2) & 0xffff;
|
|
}
|
|
}
|
|
}
|
|
|
|
&print_ccmap(\@ccmap, \%pg_flags, $variable, $class, \%comments, $have_non_bmp);
|
|
|
|
exit 0;
|
|
|
|
# END of Main
|
|
|
|
sub usage
|
|
{
|
|
print STDERR <<USAGE;
|
|
Usage: $0 input_file [variable [class]]
|
|
|
|
The output file "class.ccmap" will be generated with
|
|
all three cases LE(16/32/64bit)/BE(16bit), BE(32bit), and BE(64bit)
|
|
put together. 'variable' will be used to name two macros, one for
|
|
dimensioning the size of a PRUin16[] and the other for the array
|
|
initializer.
|
|
|
|
When 'variable' is omitted, it has to be specified in the input file with
|
|
the following syntax.
|
|
|
|
VARIABLE:: variable
|
|
|
|
When 'class' is omitted, it has to be specified in the input file with
|
|
the following syntax.
|
|
|
|
CLASS:: class_name
|
|
|
|
USAGE
|
|
|
|
exit 1;
|
|
}
|
|
|
|
sub read_input
|
|
{
|
|
my($fillinfo_p, $input, $comments_p) = @_;
|
|
@$fillinfo_p = (0) x (FILL_SZ * N_PLANES);
|
|
|
|
# init bitfield for plane flags (17bits : BMP + 16 non-BMP planes)
|
|
my $planes = 0;
|
|
my($lc)=0;
|
|
while (<$input>)
|
|
{
|
|
$lc++;
|
|
chomp;
|
|
/^\s*VARIABLE::\s*([a-zA-Z][a-zA-Z0-9_]*)$/ and
|
|
$comments_p->{'VARIABLE'} = $1,
|
|
next;
|
|
/^\s*CLASS::/ and
|
|
($comments_p->{'CLASS'} = $_) =~ s/^\s*CLASS::\s*([a-zA-Z0-9_]+).*$/$1/,
|
|
next;
|
|
/^\s*DESCRIPTION::/ and
|
|
($comments_p->{'DESC'} = $_) =~ s/^\s*DESCRIPTION::\s*//, next;
|
|
/^\s*FILE::/ and
|
|
($comments_p->{'FILE'} = $_) =~ s/^\s*FILE::\s*//, next;
|
|
|
|
next unless /^\s*0[Xx][0-9A-Fa-f]{4}/;
|
|
|
|
/^\s*(.*)\s*$/;
|
|
my ($u, $comment) = split /\s+/, $1, 2;
|
|
$u =~ s/,//g;
|
|
$u =~ tr/A-Z/a-z/;
|
|
next if /^0x.*[^0-9a-f]+.*/;
|
|
|
|
my $usv = oct $u;
|
|
if ( 0xd800 <= $usv && $usv <= 0xdfff || # surrogate code points
|
|
$usv > 0x10ffff ) {
|
|
printf STDERR "Invalid input $u at %4d\n", $lc;
|
|
next;
|
|
}
|
|
$fillinfo_p->[($usv >> 4)] |= (1 << ($usv & 0x0f));
|
|
# printf STDERR "input %s(%04x) \@line %d : put %04x @ %04x\n",
|
|
# $u,$usv, $lc, (1 << ($usv & 0x0f)), ($usv >> 4) & 0xfff;
|
|
|
|
# turn on plane flags
|
|
$planes |= (1 << ($usv >> 16));
|
|
|
|
my $key = sprintf("0X%06X", $usv);
|
|
$comments_p->{$key} = "";
|
|
|
|
# Remove '/*' and '*/' (C style comment) or '//' (C++ style comment)
|
|
# or ':' and store only the textual content of the comment.
|
|
if (defined($comment)) {
|
|
($comments_p->{$key} = $comment)
|
|
=~ s !
|
|
(?:/\*|//|:)? # '/*', '//' or ':' or NULL. Do not store.
|
|
\s* # zero or more of white space(s)
|
|
([^*]+) # one or more of non-white space(s).Store it
|
|
# in $1 for the reference in replace part.
|
|
\s* # zero or more of white space(s)
|
|
(?:\*/)? # '*/' or NONE. Do not store
|
|
!$1!sx # replace the whole match with $1 stored above.
|
|
}
|
|
}
|
|
|
|
return $planes;
|
|
}
|
|
|
|
sub add_full_mid
|
|
{
|
|
my($ccmap_p, $f_pg_offset) = @_;
|
|
# add a full page if not yet added.
|
|
if (! $f_pg_offset) {
|
|
$f_pg_offset = @$ccmap_p;
|
|
push @$ccmap_p, (0xffff) x 16;
|
|
}
|
|
# add the full mid-pointer array with all the pointers pointing to the full page.
|
|
my $f_mid_offset = @$ccmap_p;
|
|
push @$ccmap_p, ($f_pg_offset) x 16;
|
|
return ($f_mid_offset, $f_pg_offset);
|
|
}
|
|
|
|
sub add_new_mid
|
|
{
|
|
my($ccmap_p, $mid) = @_;
|
|
my $mid_offset = @$ccmap_p;
|
|
$ccmap_p->[$mid] = $mid_offset;
|
|
#by default, all mid-pointers point to the empty page.
|
|
push @$ccmap_p, ($e_pg_offset) x 16;
|
|
return $mid_offset;
|
|
}
|
|
|
|
sub add_plane
|
|
{
|
|
my ($full_ccmap_p, $fillinfo_p, $plane) = @_;
|
|
# my @ccmap = @$ccmap_p;
|
|
my @ccmap = (); # plane ccmap
|
|
my(@fillinfo) = splice @$fillinfo_p, 0, FILL_SZ;
|
|
# convert 4096(FILL_SZ) 16bit integers to a string of 4096 * $fu_sz
|
|
# characters.
|
|
my($plane_str) = pack $fill_fmt x FILL_SZ, @fillinfo;
|
|
|
|
# empty plane
|
|
if ($plane_str eq "\0" x ($fu_sz * FILL_SZ)) {
|
|
# for non-BMP plane, the default empty plane ccmap would work.
|
|
# for BMP, we need 'self-referring' folded CCMap (the smallest CCMap)
|
|
push @ccmap, (0) x 16 if (!$plane);
|
|
return @ccmap;
|
|
}
|
|
|
|
#get all upper pointers to point at empty mid pointers
|
|
push @ccmap, ($e_mid_offset) x 16;
|
|
#get all mid-pointers to point at empty page.
|
|
push @ccmap, ($e_pg_offset) x 16;
|
|
push @ccmap, (0) x 16; # empty pg
|
|
|
|
my $f_mid_offset = 0;
|
|
my $f_pg_offset;
|
|
|
|
foreach my $mid (0 .. 15)
|
|
{
|
|
my(@mid_fill) = splice @fillinfo, 0, MID_FILL_SZ;
|
|
# convert 256(MID_FILL_SZ) 16bit integers to a string of 256 * $fu_sz
|
|
# characters.
|
|
my($mid_str) = pack $fill_fmt x MID_FILL_SZ, @mid_fill;
|
|
|
|
# for an empty mid, upper-pointer is already pointing to the empty mid.
|
|
next if ($mid_str eq "\0" x ($fu_sz * MID_FILL_SZ));
|
|
|
|
# for a full mid, add full mid if necessary.
|
|
if ($mid_str eq "\xff" x ($fu_sz * MID_FILL_SZ)) {
|
|
($f_mid_offset, $f_pg_offset) =
|
|
add_full_mid(\@ccmap, $f_pg_offset) unless ($f_mid_offset);
|
|
$ccmap[$mid] = $f_mid_offset;
|
|
next;
|
|
}
|
|
|
|
my $mid_offset = add_new_mid(\@ccmap,$mid);
|
|
|
|
foreach my $pg (0 .. 15) {
|
|
my(@pg_fill) = splice @mid_fill, 0, PG_FILL_SZ;
|
|
my($pg_str) = pack $fill_fmt x PG_FILL_SZ, @pg_fill;
|
|
|
|
# for an empty pg, mid-pointer is already pointing to the empty page.
|
|
next if ($pg_str eq "\x0" x ($fu_sz * PG_FILL_SZ));
|
|
|
|
# for a full pg, add the full pg if necessary.
|
|
# and set the mid-pointer to the full pg offset.
|
|
if ($pg_str eq "\xff" x ($fu_sz * PG_FILL_SZ)) {
|
|
if (! $f_pg_offset) {
|
|
$f_pg_offset = @ccmap;
|
|
#for the full pg, endianess and ALU size are immaterial.
|
|
push @ccmap, (0xffff) x 16;
|
|
}
|
|
$ccmap[$mid_offset + $pg] = $f_pg_offset;
|
|
next;
|
|
}
|
|
|
|
$ccmap[$mid_offset + $pg] = @ccmap;
|
|
|
|
# 'Flag' the offset as the beginning of a page with actual data as
|
|
# opposed to pointer sections.
|
|
$pg_flags{(scalar @$full_ccmap_p) + (scalar @ccmap)} = @ccmap;
|
|
|
|
push @ccmap, @pg_fill;
|
|
}
|
|
}
|
|
return @ccmap;
|
|
}
|
|
|
|
sub print_ccmap
|
|
{
|
|
my($ccmap_p,$pg_flags_p, $variable, $class, $comments_p, $is_ext) = @_;
|
|
|
|
|
|
my $ofn = $class . ($is_ext ? ".x-ccmap" : ".ccmap");
|
|
|
|
open OUT, "> $ofn" or
|
|
die "cannot open $ofn for output\n";
|
|
|
|
print OUT print_preamble($variable, $class);
|
|
|
|
print OUT "\n/*\n";
|
|
# defined ($comments_p->{'CLASS'}) and
|
|
# print OUT " CLASS:: $comments_p->{'CLASS'}\n";
|
|
print OUT " VARIABLE:: $variable\n";
|
|
print OUT " CLASS:: $class\n";
|
|
defined ($comments_p->{'DESC'}) and
|
|
print OUT " DESCRIPTION:: $comments_p->{'DESC'}\n";
|
|
defined ($comments_p->{'FILE'}) and
|
|
print OUT " FILE:: $comments_p->{'FILE'}\n";
|
|
|
|
print OUT "\n";
|
|
|
|
for my $key (sort keys %$comments_p) {
|
|
next if ($key !~ /^0X/);
|
|
printf OUT " %s : %s\n", $key, $comments_p->{$key};
|
|
}
|
|
|
|
printf OUT "*/\n\n";
|
|
|
|
|
|
my(@idxlist, @int16toint32);
|
|
|
|
# When CCMap is accessed, (PRUint16 *) is cast to
|
|
# the pointer type of the ALU of a machine.
|
|
# For little endian machines, the size of the ALU
|
|
# doesn't matter (16, 32, 64). For Big endian
|
|
# machines with 32/64 bit ALU, two/four 16bit words
|
|
# have to be rearranged to be interpreted correctly
|
|
# as 32bit or 64bit integers with the 16bit word
|
|
# at the lowest address taking the highest place value.
|
|
# This shuffling is NOT necessary for the upper pointer section
|
|
# and mid-pointer sections.
|
|
|
|
# If non-BMP characters are present, 16 plane indices
|
|
# (32bit integers stored in two 16bit shorts in
|
|
# BE order) have to be treated differently based on the
|
|
# the endianness as well.
|
|
|
|
# For BMP-only CCMap, 16BE CCMap is identical to LE CCMaps.
|
|
# With non-BMP characters present, to avoid the misalignment on 64bit
|
|
# machines, we add two 16-bit units of 0-padding before the ccmap flag
|
|
# (indicating whether the map is extended or not) and the BMP map size
|
|
# (bug 225340, bug 445626).
|
|
my @fmts = $is_ext ? ("64LE", "LE", "16BE", "32BE", "64BE") : ("LE", "32BE", "64BE") ;
|
|
foreach my $fmt (@fmts)
|
|
{
|
|
|
|
my($offset) = 0;
|
|
for ($fmt) {
|
|
/64LE/ and do {
|
|
@idxlist = (0, 1, 2, 3);
|
|
@int16toint32 = (1, 0, 3, 2);
|
|
print OUT "#if (defined(IS_LITTLE_ENDIAN) && ALU_SIZE == 64)\n" .
|
|
"// Precompiled CCMap for Little Endian(64bit)\n";
|
|
printf OUT "#define ${variable}_SIZE %d\n", scalar @$ccmap_p + 2;
|
|
printf OUT "#define ${variable}_INITIALIZER \\\n";
|
|
printf OUT "/* EXTFLG */ 0x0000,0x0000,0x%04X,0x%04X, \\\n",
|
|
$ccmap_p->[0], $ccmap_p->[1];
|
|
last;
|
|
};
|
|
/LE/ and do {
|
|
@idxlist = (0, 1, 2, 3);
|
|
@int16toint32 = (1, 0, 3, 2);
|
|
print OUT $is_ext ?
|
|
"#elif defined(IS_LITTLE_ENDIAN)\n" .
|
|
"// Precompiled CCMap for Little Endian(16/32bit) \n" :
|
|
"#if (defined(IS_LITTLE_ENDIAN) || ALU_SIZE == 16)\n" .
|
|
"// Precompiled CCMap for Little Endian(16/32/64bit)\n" .
|
|
"// and Big Endian(16bit)\n";
|
|
printf OUT "#define ${variable}_SIZE %d\n", scalar @$ccmap_p;
|
|
printf OUT "#define ${variable}_INITIALIZER \\\n";
|
|
if ($is_ext) {
|
|
printf OUT "/* EXTFLG */ 0x%04X,0x%04X, \\\n",
|
|
$ccmap_p->[0], $ccmap_p->[1];
|
|
}
|
|
last;
|
|
};
|
|
/16BE/ and do {
|
|
@idxlist = (0, 1, 2, 3);
|
|
@int16toint32 = (0, 1, 2, 3);
|
|
print OUT "#elif (ALU_SIZE == 16)\n" .
|
|
"// Precompiled CCMap for Big Endian(16bit)\n";
|
|
printf OUT "#define ${variable}_SIZE %d\n", scalar @$ccmap_p;
|
|
printf OUT "#define ${variable}_INITIALIZER \\\n";
|
|
printf OUT "/* EXTFLG */ 0x%04X,0x%04X, \\\n",
|
|
$ccmap_p->[0], $ccmap_p->[1];
|
|
last;
|
|
};
|
|
/32BE/ and do {
|
|
@idxlist = (1, 0, 3, 2);
|
|
@int16toint32 = (0, 1, 2, 3);
|
|
print OUT "#elif (ALU_SIZE == 32)\n" .
|
|
"// Precompiled CCMap for Big Endian(32bit)\n";
|
|
printf OUT "#define ${variable}_SIZE %d\n", scalar @$ccmap_p;
|
|
printf OUT "#define ${variable}_INITIALIZER \\\n";
|
|
if ($is_ext) {
|
|
printf OUT "/* EXTFLG */ 0x%04X,0x%04X, \\\n",
|
|
$ccmap_p->[0], $ccmap_p->[1];
|
|
}
|
|
last;
|
|
};
|
|
/64BE/ and do {
|
|
@idxlist = (3, 2, 1, 0);
|
|
@int16toint32 = (0, 1, 2, 3);
|
|
print OUT "#elif (ALU_SIZE == 64)\n" .
|
|
"// Precompiled CCMap for Big Endian(64bit)\n";
|
|
printf OUT "#define ${variable}_SIZE %d\n", scalar @$ccmap_p +
|
|
($is_ext ? 2 : 0);
|
|
printf OUT "#define ${variable}_INITIALIZER \\\n";
|
|
if ($is_ext) {
|
|
printf OUT "/* EXTFLG */ 0x0000,0x0000,0x%04X,0x%04X, \\\n",
|
|
$ccmap_p->[0], $ccmap_p->[1];
|
|
}
|
|
last;
|
|
};
|
|
}
|
|
|
|
$offset = $is_ext ? 2 : 0;
|
|
|
|
while ($offset < @$ccmap_p) {
|
|
printf OUT "/* %06x */ ", $offset - ($is_ext ? 2 : 0);
|
|
for my $i (0 .. 3) {
|
|
for my $j (defined($pg_flags_p->{$offset}) ?
|
|
($pg_flags_p->{$offset} > 0 ?
|
|
@idxlist : @int16toint32) : (0,1,2,3)) {
|
|
printf OUT "0x%04X,", $ccmap_p->[$offset + $i * 4 + $j];
|
|
}
|
|
print OUT " \\\n " if $i==1;
|
|
}
|
|
if ($offset + 16 < @$ccmap_p) {print OUT " \\\n"; }
|
|
$offset += 16;
|
|
}
|
|
print OUT "\n";
|
|
}
|
|
|
|
print OUT <<END;
|
|
#else
|
|
#error "We don't support this architecture."
|
|
#endif
|
|
|
|
END
|
|
|
|
close OUT;
|
|
}
|
|
|
|
sub print_preamble
|
|
{
|
|
|
|
my($variable, $class) = @_;
|
|
sprintf <<PREAMBLE;
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Jungshik Shin <jshin\@mailaps.org>
|
|
* Portions created by the Initial Developer are Copyright (C) 2003
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
/*========================================================
|
|
This file contains a precompiled CCMap for a class of Unicode
|
|
characters ($class) to be identified quickly by Mozilla.
|
|
It was generated by ccmapbin.pl which you can find under
|
|
mozilla/intl/unicharutil/tools.
|
|
|
|
Enumerated below are characters included in the precompiled CCMap
|
|
which is human-readable but not so human-friendly. If you
|
|
needs to modify the list of characters belonging to "$class",
|
|
you have to make a new file (with the name of your choice)
|
|
listing characters (one character per line) you want to put
|
|
into "$class" in the format
|
|
|
|
0xuuuu // comment
|
|
|
|
In addition, the input file can have the following optional lines that
|
|
read
|
|
|
|
VARIABLE::$variable
|
|
CLASS::$class
|
|
DESCRIPTION:: description of a character class
|
|
FILE:: mozilla source file to include the output file
|
|
|
|
|
|
Then, run the following in the current directory.
|
|
|
|
perl ccmapbin.pl input_file [$variable [$class]]
|
|
|
|
which will generate $class.ccmap (or $class.x-ccmap if the ccmap
|
|
includes non-BMP characters.). $variable is used as the prefix
|
|
in macros for the array initializer and the array size.
|
|
|
|
(see bug 180266, bug 167136, and bug 224337)
|
|
|
|
*/
|
|
|
|
PREAMBLE
|
|
|
|
}
|
|
|