/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/regc_locale.c
ViewVC logotype

Diff of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/regc_locale.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 70 by dashley, Mon Oct 31 00:57:34 2016 UTC revision 71 by dashley, Sat Nov 5 11:07:06 2016 UTC
# Line 1  Line 1 
1  /* $Header$ */  /* $Header$ */
2  /*  /*
3   * regc_locale.c --   * regc_locale.c --
4   *   *
5   *      This file contains the Unicode locale specific regexp routines.   *      This file contains the Unicode locale specific regexp routines.
6   *      This file is #included by regcomp.c.   *      This file is #included by regcomp.c.
7   *   *
8   * Copyright (c) 1998 by Scriptics Corporation.   * Copyright (c) 1998 by Scriptics Corporation.
9   *   *
10   * See the file "license.terms" for information on usage and redistribution   * See the file "license.terms" for information on usage and redistribution
11   * of this file, and for a DISCLAIMER OF ALL WARRANTIES.   * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
12   *   *
13   * RCS: @(#) $Id: regc_locale.c,v 1.1.1.1 2001/06/13 04:32:00 dtashley Exp $   * RCS: @(#) $Id: regc_locale.c,v 1.1.1.1 2001/06/13 04:32:00 dtashley Exp $
14   */   */
15    
16  /* ASCII character-name table */  /* ASCII character-name table */
17    
18  static struct cname {  static struct cname {
19          char *name;          char *name;
20          char code;          char code;
21  } cnames[] = {  } cnames[] = {
22          {"NUL", '\0'},          {"NUL", '\0'},
23          {"SOH", '\001'},          {"SOH", '\001'},
24          {"STX", '\002'},          {"STX", '\002'},
25          {"ETX", '\003'},          {"ETX", '\003'},
26          {"EOT", '\004'},          {"EOT", '\004'},
27          {"ENQ", '\005'},          {"ENQ", '\005'},
28          {"ACK", '\006'},          {"ACK", '\006'},
29          {"BEL", '\007'},          {"BEL", '\007'},
30          {"alert",       '\007'},          {"alert",       '\007'},
31          {"BS",          '\010'},          {"BS",          '\010'},
32          {"backspace",   '\b'},          {"backspace",   '\b'},
33          {"HT",          '\011'},          {"HT",          '\011'},
34          {"tab",         '\t'},          {"tab",         '\t'},
35          {"LF",          '\012'},          {"LF",          '\012'},
36          {"newline",     '\n'},          {"newline",     '\n'},
37          {"VT",          '\013'},          {"VT",          '\013'},
38          {"vertical-tab",        '\v'},          {"vertical-tab",        '\v'},
39          {"FF",          '\014'},          {"FF",          '\014'},
40          {"form-feed",   '\f'},          {"form-feed",   '\f'},
41          {"CR",          '\015'},          {"CR",          '\015'},
42          {"carriage-return",     '\r'},          {"carriage-return",     '\r'},
43          {"SO",  '\016'},          {"SO",  '\016'},
44          {"SI",  '\017'},          {"SI",  '\017'},
45          {"DLE", '\020'},          {"DLE", '\020'},
46          {"DC1", '\021'},          {"DC1", '\021'},
47          {"DC2", '\022'},          {"DC2", '\022'},
48          {"DC3", '\023'},          {"DC3", '\023'},
49          {"DC4", '\024'},          {"DC4", '\024'},
50          {"NAK", '\025'},          {"NAK", '\025'},
51          {"SYN", '\026'},          {"SYN", '\026'},
52          {"ETB", '\027'},          {"ETB", '\027'},
53          {"CAN", '\030'},          {"CAN", '\030'},
54          {"EM",  '\031'},          {"EM",  '\031'},
55          {"SUB", '\032'},          {"SUB", '\032'},
56          {"ESC", '\033'},          {"ESC", '\033'},
57          {"IS4", '\034'},          {"IS4", '\034'},
58          {"FS",  '\034'},          {"FS",  '\034'},
59          {"IS3", '\035'},          {"IS3", '\035'},
60          {"GS",  '\035'},          {"GS",  '\035'},
61          {"IS2", '\036'},          {"IS2", '\036'},
62          {"RS",  '\036'},          {"RS",  '\036'},
63          {"IS1", '\037'},          {"IS1", '\037'},
64          {"US",  '\037'},          {"US",  '\037'},
65          {"space",               ' '},          {"space",               ' '},
66          {"exclamation-mark",    '!'},          {"exclamation-mark",    '!'},
67          {"quotation-mark",      '"'},          {"quotation-mark",      '"'},
68          {"number-sign",         '#'},          {"number-sign",         '#'},
69          {"dollar-sign",         '$'},          {"dollar-sign",         '$'},
70          {"percent-sign",                '%'},          {"percent-sign",                '%'},
71          {"ampersand",           '&'},          {"ampersand",           '&'},
72          {"apostrophe",          '\''},          {"apostrophe",          '\''},
73          {"left-parenthesis",    '('},          {"left-parenthesis",    '('},
74          {"right-parenthesis",   ')'},          {"right-parenthesis",   ')'},
75          {"asterisk",    '*'},          {"asterisk",    '*'},
76          {"plus-sign",   '+'},          {"plus-sign",   '+'},
77          {"comma",       ','},          {"comma",       ','},
78          {"hyphen",      '-'},          {"hyphen",      '-'},
79          {"hyphen-minus",        '-'},          {"hyphen-minus",        '-'},
80          {"period",      '.'},          {"period",      '.'},
81          {"full-stop",   '.'},          {"full-stop",   '.'},
82          {"slash",       '/'},          {"slash",       '/'},
83          {"solidus",     '/'},          {"solidus",     '/'},
84          {"zero",                '0'},          {"zero",                '0'},
85          {"one",         '1'},          {"one",         '1'},
86          {"two",         '2'},          {"two",         '2'},
87          {"three",       '3'},          {"three",       '3'},
88          {"four",                '4'},          {"four",                '4'},
89          {"five",                '5'},          {"five",                '5'},
90          {"six",         '6'},          {"six",         '6'},
91          {"seven",       '7'},          {"seven",       '7'},
92          {"eight",       '8'},          {"eight",       '8'},
93          {"nine",                '9'},          {"nine",                '9'},
94          {"colon",       ':'},          {"colon",       ':'},
95          {"semicolon",   ';'},          {"semicolon",   ';'},
96          {"less-than-sign",      '<'},          {"less-than-sign",      '<'},
97          {"equals-sign",         '='},          {"equals-sign",         '='},
98          {"greater-than-sign",   '>'},          {"greater-than-sign",   '>'},
99          {"question-mark",       '?'},          {"question-mark",       '?'},
100          {"commercial-at",       '@'},          {"commercial-at",       '@'},
101          {"left-square-bracket", '['},          {"left-square-bracket", '['},
102          {"backslash",           '\\'},          {"backslash",           '\\'},
103          {"reverse-solidus",     '\\'},          {"reverse-solidus",     '\\'},
104          {"right-square-bracket",        ']'},          {"right-square-bracket",        ']'},
105          {"circumflex",          '^'},          {"circumflex",          '^'},
106          {"circumflex-accent",   '^'},          {"circumflex-accent",   '^'},
107          {"underscore",          '_'},          {"underscore",          '_'},
108          {"low-line",            '_'},          {"low-line",            '_'},
109          {"grave-accent",                '`'},          {"grave-accent",                '`'},
110          {"left-brace",          '{'},          {"left-brace",          '{'},
111          {"left-curly-bracket",  '{'},          {"left-curly-bracket",  '{'},
112          {"vertical-line",       '|'},          {"vertical-line",       '|'},
113          {"right-brace",         '}'},          {"right-brace",         '}'},
114          {"right-curly-bracket", '}'},          {"right-curly-bracket", '}'},
115          {"tilde",               '~'},          {"tilde",               '~'},
116          {"DEL", '\177'},          {"DEL", '\177'},
117          {NULL,  0}          {NULL,  0}
118  };  };
119    
120  /* Unicode character-class tables */  /* Unicode character-class tables */
121    
122  typedef struct crange {  typedef struct crange {
123      chr start;      chr start;
124      chr end;      chr end;
125  } crange;  } crange;
126    
127  /* Unicode: (Alphabetic) */  /* Unicode: (Alphabetic) */
128    
129  static crange alphaRangeTable[] = {  static crange alphaRangeTable[] = {
130      {0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6},      {0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6},
131      {0x00f8, 0x01f5}, {0x01fa, 0x0217}, {0x0250, 0x02a8}, {0x02b0, 0x02b8},      {0x00f8, 0x01f5}, {0x01fa, 0x0217}, {0x0250, 0x02a8}, {0x02b0, 0x02b8},
132      {0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1},      {0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1},
133      {0x03a3, 0x03ce}, {0x03d0, 0x03d6}, {0x03e2, 0x03f3}, {0x0401, 0x040c},      {0x03a3, 0x03ce}, {0x03d0, 0x03d6}, {0x03e2, 0x03f3}, {0x0401, 0x040c},
134      {0x040e, 0x044f}, {0x0451, 0x045c}, {0x045e, 0x0481}, {0x0490, 0x04c4},      {0x040e, 0x044f}, {0x0451, 0x045c}, {0x045e, 0x0481}, {0x0490, 0x04c4},
135      {0x04d0, 0x04eb}, {0x04ee, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587},      {0x04d0, 0x04eb}, {0x04ee, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587},
136      {0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a},      {0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a},
137      {0x0671, 0x06b7}, {0x06ba, 0x06be}, {0x06c0, 0x06ce}, {0x06d0, 0x06d3},      {0x0671, 0x06b7}, {0x06ba, 0x06be}, {0x06c0, 0x06ce}, {0x06d0, 0x06d3},
138      {0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8},      {0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8},
139      {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a},      {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a},
140      {0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74},      {0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74},
141      {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},      {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},
142      {0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30},      {0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30},
143      {0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90},      {0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90},
144      {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9},      {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9},
145      {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33},      {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33},
146      {0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8},      {0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8},
147      {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10},      {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10},
148      {0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46},      {0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46},
149      {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0},      {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0},
150      {0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f69}, {0x0f88, 0x0f8b},      {0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f69}, {0x0f88, 0x0f8b},
151      {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2},      {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2},
152      {0x11a8, 0x11f9}, {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},      {0x11a8, 0x11f9}, {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
153      {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},      {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
154      {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4},      {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4},
155      {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec},      {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec},
156      {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x210a, 0x2113}, {0x2118, 0x211d},      {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x210a, 0x2113}, {0x2118, 0x211d},
157      {0x212a, 0x2131}, {0x2133, 0x2138}, {0x3031, 0x3035}, {0x3041, 0x3094},      {0x212a, 0x2131}, {0x2133, 0x2138}, {0x3031, 0x3035}, {0x3041, 0x3094},
158      {0x30a1, 0x30fa}, {0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e},      {0x30a1, 0x30fa}, {0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e},
159      {0x4e00, 0x9fa5}, {0xac00, 0xd7a3}, {0xf900, 0xfa2d}, {0xfb00, 0xfb06},      {0x4e00, 0x9fa5}, {0xac00, 0xd7a3}, {0xf900, 0xfa2d}, {0xfb00, 0xfb06},
160      {0xfb13, 0xfb17}, {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c},      {0xfb13, 0xfb17}, {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c},
161      {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7},      {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7},
162      {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff21, 0xff3a},      {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff21, 0xff3a},
163      {0xff41, 0xff5a}, {0xff66, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf},      {0xff41, 0xff5a}, {0xff66, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf},
164      {0xffd2, 0xffd7}, {0xffda, 0xffdc}      {0xffd2, 0xffd7}, {0xffda, 0xffdc}
165  };  };
166    
167  #define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))  #define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
168    
169  static chr alphaCharTable[] = {  static chr alphaCharTable[] = {
170      0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x037a, 0x0386, 0x038c, 0x03da,      0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x037a, 0x0386, 0x038c, 0x03da,
171      0x03dc, 0x03de, 0x03e0, 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9,      0x03dc, 0x03de, 0x03e0, 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9,
172      0x0559, 0x06d5, 0x06e5, 0x06e6, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2,      0x0559, 0x06d5, 0x06e5, 0x06e6, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2,
173      0x09dc, 0x09dd, 0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35,      0x09dc, 0x09dd, 0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35,
174      0x0a36, 0x0a38, 0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0,      0x0a36, 0x0a38, 0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0,
175      0x0ae0, 0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99,      0x0ae0, 0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99,
176      0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde,      0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde,
177      0x0ce0, 0x0ce1, 0x0d60, 0x0d61, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84,      0x0ce0, 0x0ce1, 0x0d60, 0x0d61, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84,
178      0x0e87, 0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2,      0x0e87, 0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2,
179      0x0eb3, 0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1f59, 0x1f5b, 0x1f5d,      0x0eb3, 0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1f59, 0x1f5b, 0x1f5d,
180      0x1fbe, 0x207f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005,      0x1fbe, 0x207f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005,
181      0x3006, 0x309d, 0x309e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74      0x3006, 0x309d, 0x309e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74
182  };  };
183    
184  #define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))  #define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
185    
186  /* Unicode: (Decimal digit) */  /* Unicode: (Decimal digit) */
187    
188  static crange digitRangeTable[] = {  static crange digitRangeTable[] = {
189      {0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f},      {0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f},
190      {0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f},      {0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f},
191      {0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f},      {0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f},
192      {0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0xff10, 0xff19}      {0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0xff10, 0xff19}
193  };  };
194    
195  #define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))  #define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
196    
197  /* Unicode: (Punctuation) */  /* Unicode: (Punctuation) */
198    
199  static crange punctRangeTable[] = {  static crange punctRangeTable[] = {
200      {0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d},      {0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d},
201      {0x055a, 0x055f}, {0x066a, 0x066d}, {0x0f04, 0x0f12}, {0x0f3a, 0x0f3d},      {0x055a, 0x055f}, {0x066a, 0x066d}, {0x0f04, 0x0f12}, {0x0f3a, 0x0f3d},
202      {0x2010, 0x2027}, {0x2030, 0x2043}, {0x3001, 0x3003}, {0x3008, 0x3011},      {0x2010, 0x2027}, {0x2030, 0x2043}, {0x3001, 0x3003}, {0x3008, 0x3011},
203      {0x3014, 0x301f}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61},      {0x3014, 0x301f}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61},
204      {0xff01, 0xff03}, {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d},      {0xff01, 0xff03}, {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d},
205      {0xff61, 0xff65}      {0xff61, 0xff65}
206  };  };
207    
208  #define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))  #define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
209    
210  static chr punctCharTable[] = {  static chr punctCharTable[] = {
211      0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab,      0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab,
212      0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x05be, 0x05c0,      0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x05be, 0x05c0,
213      0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964, 0x0965,      0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964, 0x0965,
214      0x0970, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x2045, 0x2046, 0x207d, 0x207e,      0x0970, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x2045, 0x2046, 0x207d, 0x207e,
215      0x208d, 0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63,      0x208d, 0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63,
216      0xfe68, 0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b,      0xfe68, 0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b,
217      0xff5d      0xff5d
218  };  };
219    
220  #define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))  #define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
221    
222  /* Unicode: (White space) */  /* Unicode: (White space) */
223    
224  static crange spaceRangeTable[] = {  static crange spaceRangeTable[] = {
225      {0x0009, 0x000d}, {0x2000, 0x200b},      {0x0009, 0x000d}, {0x2000, 0x200b},
226  };  };
227    
228  #define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))  #define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))
229    
230  static chr spaceCharTable[] = {  static chr spaceCharTable[] = {
231      0x0020, 0x00a0, 0x2028, 0x2029, 0x3000      0x0020, 0x00a0, 0x2028, 0x2029, 0x3000
232  };  };
233    
234  #define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))  #define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))
235    
236  /* Unicode: lowercase characters */  /* Unicode: lowercase characters */
237    
238  static crange lowerRangeTable[] = {  static crange lowerRangeTable[] = {
239      {0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180},      {0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180},
240      {0x0199, 0x019b}, {0x0250, 0x02a8}, {0x03ac, 0x03ce}, {0x03ef, 0x03f2},      {0x0199, 0x019b}, {0x0250, 0x02a8}, {0x03ac, 0x03ce}, {0x03ef, 0x03f2},
241      {0x0430, 0x044f}, {0x0451, 0x045c}, {0x0561, 0x0587}, {0x10d0, 0x10f6},      {0x0430, 0x044f}, {0x0451, 0x045c}, {0x0561, 0x0587}, {0x10d0, 0x10f6},
242      {0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27},      {0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27},
243      {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67},      {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67},
244      {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7},      {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7},
245      {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7},      {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7},
246      {0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}      {0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
247  };  };
248    
249  #define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))  #define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))
250    
251  static chr lowerCharTable[] = {  static chr lowerCharTable[] = {
252      0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b,      0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b,
253      0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d,      0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d,
254      0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f,      0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f,
255      0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140,      0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140,
256      0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151,      0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151,
257      0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163,      0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163,
258      0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175,      0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175,
259      0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192,      0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192,
260      0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01ab, 0x01ad, 0x01b0,      0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01ab, 0x01ad, 0x01b0,
261      0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01bd, 0x01c6, 0x01c9, 0x01cc, 0x01ce,      0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01bd, 0x01c6, 0x01c9, 0x01cc, 0x01ce,
262      0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df,      0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df,
263      0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0,      0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0,
264      0x01f3, 0x01f5, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205, 0x0207,      0x01f3, 0x01f5, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205, 0x0207,
265      0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217, 0x0390,      0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217, 0x0390,
266      0x03d0, 0x03d1, 0x03d5, 0x03d6, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb,      0x03d0, 0x03d1, 0x03d5, 0x03d6, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb,
267      0x03ed, 0x045e, 0x045f, 0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b,      0x03ed, 0x045e, 0x045f, 0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b,
268      0x046d, 0x046f, 0x0471, 0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d,      0x046d, 0x046f, 0x0471, 0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d,
269      0x047f, 0x0481, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d,      0x047f, 0x0481, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d,
270      0x049f, 0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af,      0x049f, 0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af,
271      0x04b1, 0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2,      0x04b1, 0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2,
272      0x04c4, 0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db,      0x04c4, 0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db,
273      0x04dd, 0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ef,      0x04dd, 0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ef,
274      0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09,      0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09,
275      0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b,      0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b,
276      0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d,      0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d,
277      0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f,      0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f,
278      0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51,      0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51,
279      0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63,      0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63,
280      0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75,      0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75,
281      0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87,      0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87,
282      0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5,      0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5,
283      0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7,      0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7,
284      0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9,      0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9,
285      0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb,      0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb,
286      0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed,      0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed,
287      0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe,      0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe,
288      0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e,      0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e,
289      0x210f, 0x2113, 0x2118, 0x212e, 0x212f, 0x2134      0x210f, 0x2113, 0x2118, 0x212e, 0x212f, 0x2134
290  };  };
291    
292  #define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))  #define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
293    
294  /* Unicode: uppercase characters */  /* Unicode: uppercase characters */
295    
296  static crange upperRangeTable[] = {  static crange upperRangeTable[] = {
297      {0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b},      {0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b},
298      {0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x0388, 0x038a},      {0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x0388, 0x038a},
299      {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4}, {0x0401, 0x040c},      {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4}, {0x0401, 0x040c},
300      {0x040e, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f},      {0x040e, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f},
301      {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d},      {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d},
302      {0x1f68, 0x1f6f}, {0x1f88, 0x1f8f}, {0x1f98, 0x1f9f}, {0x1fa8, 0x1faf},      {0x1f68, 0x1f6f}, {0x1f88, 0x1f8f}, {0x1f98, 0x1f9f}, {0x1fa8, 0x1faf},
303      {0x1fb8, 0x1fbc}, {0x1fc8, 0x1fcc}, {0x1fd8, 0x1fdb}, {0x1fe8, 0x1fec},      {0x1fb8, 0x1fbc}, {0x1fc8, 0x1fcc}, {0x1fd8, 0x1fdb}, {0x1fe8, 0x1fec},
304      {0x1ff8, 0x1ffc}, {0x210b, 0x210d}, {0x2110, 0x2112}, {0x2119, 0x211d},      {0x1ff8, 0x1ffc}, {0x210b, 0x210d}, {0x2110, 0x2112}, {0x2119, 0x211d},
305      {0x212a, 0x212d}, {0xff21, 0xff3a}      {0x212a, 0x212d}, {0xff21, 0xff3a}
306  };  };
307    
308  #define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))  #define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))
309    
310  static chr upperCharTable[] = {  static chr upperCharTable[] = {
311      0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110,      0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110,
312      0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122,      0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122,
313      0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134,      0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134,
314      0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147,      0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147,
315      0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a,      0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a,
316      0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c,      0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c,
317      0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d,      0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d,
318      0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d,      0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d,
319      0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae,      0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae,
320      0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd,      0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd,
321      0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0,      0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0,
322      0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4,      0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4,
323      0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a,      0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a,
324      0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0386, 0x038c, 0x038e,      0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0386, 0x038c, 0x038e,
325      0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0, 0x03e2, 0x03e4, 0x03e6, 0x03e8,      0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0, 0x03e2, 0x03e4, 0x03e6, 0x03e8,
326      0x03ea, 0x03ec, 0x03ee, 0x0460, 0x0462, 0x0464, 0x0466, 0x0468, 0x046a,      0x03ea, 0x03ec, 0x03ee, 0x0460, 0x0462, 0x0464, 0x0466, 0x0468, 0x046a,
327      0x046c, 0x046e, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478, 0x047a, 0x047c,      0x046c, 0x046e, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478, 0x047a, 0x047c,
328      0x047e, 0x0480, 0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c,      0x047e, 0x0480, 0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c,
329      0x049e, 0x04a0, 0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae,      0x049e, 0x04a0, 0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae,
330      0x04b0, 0x04b2, 0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c1,      0x04b0, 0x04b2, 0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c1,
331      0x04c3, 0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da,      0x04c3, 0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da,
332      0x04dc, 0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ee,      0x04dc, 0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ee,
333      0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08,      0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08,
334      0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a,      0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a,
335      0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c,      0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c,
336      0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e,      0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e,
337      0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50,      0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50,
338      0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62,      0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62,
339      0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74,      0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74,
340      0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86,      0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86,
341      0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2,      0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2,
342      0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4,      0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4,
343      0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6,      0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6,
344      0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8,      0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8,
345      0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea,      0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea,
346      0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b,      0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b,
347      0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130,      0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130,
348      0x2131, 0x2133      0x2131, 0x2133
349  };  };
350    
351  #define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))  #define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
352    
353  /*  /*
354   * The graph table includes the set of characters that are Unicode   * The graph table includes the set of characters that are Unicode
355   * print characters excluding space.   * print characters excluding space.
356   */   */
357    
358  static crange graphRangeTable[] = {  static crange graphRangeTable[] = {
359      {0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x01f5}, {0x01fa, 0x0217},      {0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x01f5}, {0x01fa, 0x0217},
360      {0x0250, 0x02a8}, {0x02b0, 0x02de}, {0x02e0, 0x02e9}, {0x0300, 0x031f},      {0x0250, 0x02a8}, {0x02b0, 0x02de}, {0x02e0, 0x02e9}, {0x0300, 0x031f},
361      {0x0321, 0x0345}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce},      {0x0321, 0x0345}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce},
362      {0x03d0, 0x03d6}, {0x03e2, 0x03f3}, {0x0401, 0x040c}, {0x040e, 0x041f},      {0x03d0, 0x03d6}, {0x03e2, 0x03f3}, {0x0401, 0x040c}, {0x040e, 0x041f},
363      {0x0421, 0x044f}, {0x0451, 0x045c}, {0x045e, 0x0486}, {0x0490, 0x04c4},      {0x0421, 0x044f}, {0x0451, 0x045c}, {0x045e, 0x0486}, {0x0490, 0x04c4},
364      {0x04d0, 0x04eb}, {0x04ee, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f},      {0x04d0, 0x04eb}, {0x04ee, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f},
365      {0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4},      {0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4},
366      {0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0652},      {0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0652},
367      {0x0660, 0x066d}, {0x0670, 0x06b7}, {0x06ba, 0x06be}, {0x06c0, 0x06ce},      {0x0660, 0x066d}, {0x0670, 0x06b7}, {0x06ba, 0x06be}, {0x06c0, 0x06ce},
368      {0x06d0, 0x06ed}, {0x06f0, 0x06f9}, {0x0901, 0x0903}, {0x0905, 0x091f},      {0x06d0, 0x06ed}, {0x06f0, 0x06f9}, {0x0901, 0x0903}, {0x0905, 0x091f},
369      {0x0921, 0x0939}, {0x093c, 0x094d}, {0x0950, 0x0954}, {0x0958, 0x0970},      {0x0921, 0x0939}, {0x093c, 0x094d}, {0x0950, 0x0954}, {0x0958, 0x0970},
370      {0x0981, 0x0983}, {0x0985, 0x098c}, {0x0993, 0x09a8}, {0x09aa, 0x09b0},      {0x0981, 0x0983}, {0x0985, 0x098c}, {0x0993, 0x09a8}, {0x09aa, 0x09b0},
371      {0x09b6, 0x09b9}, {0x09be, 0x09c4}, {0x09cb, 0x09cd}, {0x09df, 0x09e3},      {0x09b6, 0x09b9}, {0x09be, 0x09c4}, {0x09cb, 0x09cd}, {0x09df, 0x09e3},
372      {0x09e6, 0x09fa}, {0x0a05, 0x0a0a}, {0x0a13, 0x0a1f}, {0x0a21, 0x0a28},      {0x09e6, 0x09fa}, {0x0a05, 0x0a0a}, {0x0a13, 0x0a1f}, {0x0a21, 0x0a28},
373      {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42}, {0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c},      {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42}, {0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c},
374      {0x0a66, 0x0a74}, {0x0a81, 0x0a83}, {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91},      {0x0a66, 0x0a74}, {0x0a81, 0x0a83}, {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91},
375      {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, {0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5},      {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0}, {0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5},
376      {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd}, {0x0ae6, 0x0aef}, {0x0b01, 0x0b03},      {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd}, {0x0ae6, 0x0aef}, {0x0b01, 0x0b03},
377      {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f}, {0x0b21, 0x0b28}, {0x0b2a, 0x0b30},      {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f}, {0x0b21, 0x0b28}, {0x0b2a, 0x0b30},
378      {0x0b36, 0x0b39}, {0x0b3c, 0x0b43}, {0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61},      {0x0b36, 0x0b39}, {0x0b3c, 0x0b43}, {0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61},
379      {0x0b66, 0x0b70}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90}, {0x0b92, 0x0b95},      {0x0b66, 0x0b70}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90}, {0x0b92, 0x0b95},
380      {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2},      {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2},
381      {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd}, {0x0be7, 0x0bf2}, {0x0c01, 0x0c03},      {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd}, {0x0be7, 0x0bf2}, {0x0c01, 0x0c03},
382      {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c1f}, {0x0c21, 0x0c28},      {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c1f}, {0x0c21, 0x0c28},
383      {0x0c2a, 0x0c33}, {0x0c35, 0x0c39}, {0x0c3e, 0x0c44}, {0x0c46, 0x0c48},      {0x0c2a, 0x0c33}, {0x0c35, 0x0c39}, {0x0c3e, 0x0c44}, {0x0c46, 0x0c48},
384      {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90},      {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90},
385      {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4},      {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4},
386      {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd}, {0x0ce6, 0x0cef}, {0x0d05, 0x0d0c},      {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd}, {0x0ce6, 0x0cef}, {0x0d05, 0x0d0c},
387      {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f}, {0x0d21, 0x0d28}, {0x0d2a, 0x0d39},      {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f}, {0x0d21, 0x0d28}, {0x0d2a, 0x0d39},
388      {0x0d3e, 0x0d43}, {0x0d46, 0x0d48}, {0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f},      {0x0d3e, 0x0d43}, {0x0d46, 0x0d48}, {0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f},
389      {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b}, {0x0e94, 0x0e97},      {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b}, {0x0e94, 0x0e97},
390      {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9}, {0x0ebb, 0x0ebd},      {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9}, {0x0ebb, 0x0ebd},
391      {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9}, {0x0f00, 0x0f1f},      {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9}, {0x0f00, 0x0f1f},
392      {0x0f21, 0x0f47}, {0x0f49, 0x0f69}, {0x0f71, 0x0f8b}, {0x0f90, 0x0f95},      {0x0f21, 0x0f47}, {0x0f49, 0x0f69}, {0x0f71, 0x0f8b}, {0x0f90, 0x0f95},
393      {0x0f99, 0x0fad}, {0x0fb1, 0x0fb7}, {0x10a0, 0x10c5}, {0x10d0, 0x10f6},      {0x0f99, 0x0fad}, {0x0fb1, 0x0fb7}, {0x10a0, 0x10c5}, {0x10d0, 0x10f6},
394      {0x1100, 0x111f}, {0x1121, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},      {0x1100, 0x111f}, {0x1121, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
395      {0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},      {0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
396      {0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},      {0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
397      {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3},      {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3},
398      {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe},      {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe},
399      {0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x2030, 0x2046},      {0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x2030, 0x2046},
400      {0x2074, 0x208e}, {0x20a0, 0x20ac}, {0x20d0, 0x20e1}, {0x2100, 0x211f},      {0x2074, 0x208e}, {0x20a0, 0x20ac}, {0x20d0, 0x20e1}, {0x2100, 0x211f},
401      {0x2121, 0x2138}, {0x2153, 0x2182}, {0x2190, 0x21ea}, {0x2200, 0x221f},      {0x2121, 0x2138}, {0x2153, 0x2182}, {0x2190, 0x21ea}, {0x2200, 0x221f},
402      {0x2221, 0x22f1}, {0x2302, 0x231f}, {0x2321, 0x237a}, {0x2400, 0x241f},      {0x2221, 0x22f1}, {0x2302, 0x231f}, {0x2321, 0x237a}, {0x2400, 0x241f},
403      {0x2421, 0x2424}, {0x2440, 0x244a}, {0x2460, 0x24ea}, {0x2500, 0x251f},      {0x2421, 0x2424}, {0x2440, 0x244a}, {0x2460, 0x24ea}, {0x2500, 0x251f},
404      {0x2521, 0x2595}, {0x25a0, 0x25ef}, {0x2600, 0x2613}, {0x261a, 0x261f},      {0x2521, 0x2595}, {0x25a0, 0x25ef}, {0x2600, 0x2613}, {0x261a, 0x261f},
405      {0x2621, 0x266f}, {0x2701, 0x2704}, {0x2706, 0x2709}, {0x270c, 0x271f},      {0x2621, 0x266f}, {0x2701, 0x2704}, {0x2706, 0x2709}, {0x270c, 0x271f},
406      {0x2721, 0x2727}, {0x2729, 0x274b}, {0x274f, 0x2752}, {0x2758, 0x275e},      {0x2721, 0x2727}, {0x2729, 0x274b}, {0x274f, 0x2752}, {0x2758, 0x275e},
407      {0x2761, 0x2767}, {0x2776, 0x2794}, {0x2798, 0x27af}, {0x27b1, 0x27be},      {0x2761, 0x2767}, {0x2776, 0x2794}, {0x2798, 0x27af}, {0x27b1, 0x27be},
408      {0x3000, 0x301f}, {0x3021, 0x3037}, {0x3041, 0x3094}, {0x3099, 0x309e},      {0x3000, 0x301f}, {0x3021, 0x3037}, {0x3041, 0x3094}, {0x3099, 0x309e},
409      {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c}, {0x3131, 0x318e},      {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c}, {0x3131, 0x318e},
410      {0x3190, 0x319f}, {0x3200, 0x321c}, {0x3221, 0x3243}, {0x3260, 0x327b},      {0x3190, 0x319f}, {0x3200, 0x321c}, {0x3221, 0x3243}, {0x3260, 0x327b},
411      {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe}, {0x3300, 0x331f},      {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe}, {0x3300, 0x331f},
412      {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe}, {0x4e00, 0x4e1f},      {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe}, {0x4e00, 0x4e1f},
413      {0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f},      {0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f},
414      {0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f},      {0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f},
415      {0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f},      {0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f},
416      {0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f},      {0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f},
417      {0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f},      {0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f},
418      {0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f},      {0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f},
419      {0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f},      {0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f},
420      {0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f},      {0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f},
421      {0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f},      {0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f},
422      {0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f},      {0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f},
423      {0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f},      {0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f},
424      {0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f},      {0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f},
425      {0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f},      {0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f},
426      {0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f},      {0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f},
427      {0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f},      {0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f},
428      {0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f},      {0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f},
429      {0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f},      {0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f},
430      {0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f},      {0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f},
431      {0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f},      {0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f},
432      {0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f},      {0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f},
433      {0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xac00, 0xac1f}, {0xac21, 0xad1f},      {0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xac00, 0xac1f}, {0xac21, 0xad1f},
434      {0xad21, 0xae1f}, {0xae21, 0xaf1f}, {0xaf21, 0xb01f}, {0xb021, 0xb11f},      {0xad21, 0xae1f}, {0xae21, 0xaf1f}, {0xaf21, 0xb01f}, {0xb021, 0xb11f},
435      {0xb121, 0xb21f}, {0xb221, 0xb31f}, {0xb321, 0xb41f}, {0xb421, 0xb51f},      {0xb121, 0xb21f}, {0xb221, 0xb31f}, {0xb321, 0xb41f}, {0xb421, 0xb51f},
436      {0xb521, 0xb61f}, {0xb621, 0xb71f}, {0xb721, 0xb81f}, {0xb821, 0xb91f},      {0xb521, 0xb61f}, {0xb621, 0xb71f}, {0xb721, 0xb81f}, {0xb821, 0xb91f},
437      {0xb921, 0xba1f}, {0xba21, 0xbb1f}, {0xbb21, 0xbc1f}, {0xbc21, 0xbd1f},      {0xb921, 0xba1f}, {0xba21, 0xbb1f}, {0xbb21, 0xbc1f}, {0xbc21, 0xbd1f},
438      {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f}, {0xbf21, 0xc01f}, {0xc021, 0xc11f},      {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f}, {0xbf21, 0xc01f}, {0xc021, 0xc11f},
439      {0xc121, 0xc21f}, {0xc221, 0xc31f}, {0xc321, 0xc41f}, {0xc421, 0xc51f},      {0xc121, 0xc21f}, {0xc221, 0xc31f}, {0xc321, 0xc41f}, {0xc421, 0xc51f},
440      {0xc521, 0xc61f}, {0xc621, 0xc71f}, {0xc721, 0xc81f}, {0xc821, 0xc91f},      {0xc521, 0xc61f}, {0xc621, 0xc71f}, {0xc721, 0xc81f}, {0xc821, 0xc91f},
441      {0xc921, 0xca1f}, {0xca21, 0xcb1f}, {0xcb21, 0xcc1f}, {0xcc21, 0xcd1f},      {0xc921, 0xca1f}, {0xca21, 0xcb1f}, {0xcb21, 0xcc1f}, {0xcc21, 0xcd1f},
442      {0xcd21, 0xce1f}, {0xce21, 0xcf1f}, {0xcf21, 0xd01f}, {0xd021, 0xd11f},      {0xcd21, 0xce1f}, {0xce21, 0xcf1f}, {0xcf21, 0xd01f}, {0xd021, 0xd11f},
443      {0xd121, 0xd21f}, {0xd221, 0xd31f}, {0xd321, 0xd41f}, {0xd421, 0xd51f},      {0xd121, 0xd21f}, {0xd221, 0xd31f}, {0xd321, 0xd41f}, {0xd421, 0xd51f},
444      {0xd521, 0xd61f}, {0xd621, 0xd71f}, {0xd721, 0xd7a3}, {0xf900, 0xf91f},      {0xd521, 0xd61f}, {0xd621, 0xd71f}, {0xd721, 0xd7a3}, {0xf900, 0xf91f},
445      {0xf921, 0xfa1f}, {0xfa21, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17},      {0xf921, 0xfa1f}, {0xfa21, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17},
446      {0xfb21, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f},      {0xfb21, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f},
447      {0xfc21, 0xfd1f}, {0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7},      {0xfc21, 0xfd1f}, {0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7},
448      {0xfdf0, 0xfdfb}, {0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52},      {0xfdf0, 0xfdfb}, {0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52},
449      {0xfe54, 0xfe66}, {0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc},      {0xfe54, 0xfe66}, {0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc},
450      {0xff01, 0xff1f}, {0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7},      {0xff01, 0xff1f}, {0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7},
451      {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6},      {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6},
452      {0xffe8, 0xffee}      {0xffe8, 0xffee}
453  };  };
454    
455  #define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))  #define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
456    
457  static chr graphCharTable[] = {  static chr graphCharTable[] = {
458      0x0360, 0x0361, 0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x03da, 0x03dc,      0x0360, 0x0361, 0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x03da, 0x03dc,
459      0x03de, 0x03e0, 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589,      0x03de, 0x03e0, 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589,
460      0x060c, 0x061b, 0x061f, 0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8,      0x060c, 0x061b, 0x061f, 0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8,
461      0x09d7, 0x09dc, 0x09dd, 0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35,      0x09d7, 0x09dc, 0x09dd, 0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35,
462      0x0a36, 0x0a38, 0x0a39, 0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2,      0x0a36, 0x0a38, 0x0a39, 0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2,
463      0x0ab3, 0x0ad0, 0x0ae0, 0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48,      0x0ab3, 0x0ad0, 0x0ae0, 0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48,
464      0x0b56, 0x0b57, 0x0b5c, 0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c,      0x0b56, 0x0b57, 0x0b5c, 0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c,
465      0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61,      0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61,
466      0x0c82, 0x0c83, 0x0cd5, 0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03,      0x0c82, 0x0c83, 0x0cd5, 0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03,
467      0x0d57, 0x0d60, 0x0d61, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 0x0e88, 0x0e8a,      0x0d57, 0x0d60, 0x0d61, 0x0e81, 0x0e82, 0x0e84, 0x0e87, 0x0e88, 0x0e8a,
468      0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc, 0x0edd, 0x0f97,      0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc, 0x0edd, 0x0f97,
469      0x0fb9, 0x10fb, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x2300, 0x274d, 0x2756,      0x0fb9, 0x10fb, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x2300, 0x274d, 0x2756,
470      0x303f, 0xfb1e, 0xfb1f, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74,      0x303f, 0xfb1e, 0xfb1f, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74,
471      0xfffc, 0xfffd      0xfffc, 0xfffd
472  };  };
473    
474  #define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))  #define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
475    
476    
477  #define CH      NOCELT  #define CH      NOCELT
478    
479  /*  /*
480   - nmcces - how many distinct MCCEs are there?   - nmcces - how many distinct MCCEs are there?
481   ^ static int nmcces(struct vars *);   ^ static int nmcces(struct vars *);
482   */   */
483  static int  static int
484  nmcces(v)  nmcces(v)
485  struct vars *v;  struct vars *v;
486  {  {
487          return 0;          return 0;
488  }  }
489    
490  /*  /*
491   - nleaders - how many chrs can be first chrs of MCCEs?   - nleaders - how many chrs can be first chrs of MCCEs?
492   ^ static int nleaders(struct vars *);   ^ static int nleaders(struct vars *);
493   */   */
494  static int  static int
495  nleaders(v)  nleaders(v)
496  struct vars *v;  struct vars *v;
497  {  {
498          return 0;          return 0;
499  }  }
500    
501  /*  /*
502   - allmcces - return a cvec with all the MCCEs of the locale   - allmcces - return a cvec with all the MCCEs of the locale
503   ^ static struct cvec *allmcces(struct vars *, struct cvec *);   ^ static struct cvec *allmcces(struct vars *, struct cvec *);
504   */   */
505  static struct cvec *  static struct cvec *
506  allmcces(v, cv)  allmcces(v, cv)
507  struct vars *v;  struct vars *v;
508  struct cvec *cv;                /* this is supposed to have enough room */  struct cvec *cv;                /* this is supposed to have enough room */
509  {  {
510          return clearcvec(cv);          return clearcvec(cv);
511  }  }
512    
513  /*  /*
514   - element - map collating-element name to celt   - element - map collating-element name to celt
515   ^ static celt element(struct vars *, chr *, chr *);   ^ static celt element(struct vars *, chr *, chr *);
516   */   */
517  static celt  static celt
518  element(v, startp, endp)  element(v, startp, endp)
519  struct vars *v;  struct vars *v;
520  chr *startp;                    /* points to start of name */  chr *startp;                    /* points to start of name */
521  chr *endp;                      /* points just past end of name */  chr *endp;                      /* points just past end of name */
522  {  {
523          struct cname *cn;          struct cname *cn;
524          size_t len;          size_t len;
525          Tcl_DString ds;          Tcl_DString ds;
526          char *np;          char *np;
527    
528          /* generic:  one-chr names stand for themselves */          /* generic:  one-chr names stand for themselves */
529          assert(startp < endp);          assert(startp < endp);
530          len = endp - startp;          len = endp - startp;
531          if (len == 1)          if (len == 1)
532                  return *startp;                  return *startp;
533    
534          NOTE(REG_ULOCALE);          NOTE(REG_ULOCALE);
535    
536          /* search table */          /* search table */
537          Tcl_DStringInit(&ds);          Tcl_DStringInit(&ds);
538          np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);          np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
539          for (cn = cnames; cn->name != NULL; cn++)          for (cn = cnames; cn->name != NULL; cn++)
540                  if (strlen(cn->name) == len && strncmp(cn->name, np, len) == 0)                  if (strlen(cn->name) == len && strncmp(cn->name, np, len) == 0)
541                          break;          /* NOTE BREAK OUT */                          break;          /* NOTE BREAK OUT */
542          Tcl_DStringFree(&ds);          Tcl_DStringFree(&ds);
543          if (cn->name != NULL)          if (cn->name != NULL)
544                  return CHR(cn->code);                  return CHR(cn->code);
545    
546          /* couldn't find it */          /* couldn't find it */
547          ERR(REG_ECOLLATE);          ERR(REG_ECOLLATE);
548          return 0;          return 0;
549  }  }
550    
551  /*  /*
552   - range - supply cvec for a range, including legality check   - range - supply cvec for a range, including legality check
553   ^ static struct cvec *range(struct vars *, celt, celt, int);   ^ static struct cvec *range(struct vars *, celt, celt, int);
554   */   */
555  static struct cvec *  static struct cvec *
556  range(v, a, b, cases)  range(v, a, b, cases)
557  struct vars *v;  struct vars *v;
558  celt a;  celt a;
559  celt b;                         /* might equal a */  celt b;                         /* might equal a */
560  int cases;                      /* case-independent? */  int cases;                      /* case-independent? */
561  {  {
562          int nchrs;          int nchrs;
563          struct cvec *cv;          struct cvec *cv;
564          celt c, lc, uc, tc;          celt c, lc, uc, tc;
565    
566          if (a != b && !before(a, b)) {          if (a != b && !before(a, b)) {
567                  ERR(REG_ERANGE);                  ERR(REG_ERANGE);
568                  return NULL;                  return NULL;
569          }          }
570    
571          if (!cases) {           /* easy version */          if (!cases) {           /* easy version */
572                  cv = getcvec(v, 0, 1, 0);                  cv = getcvec(v, 0, 1, 0);
573                  NOERRN();                  NOERRN();
574                  addrange(cv, a, b);                  addrange(cv, a, b);
575                  return cv;                  return cv;
576          }          }
577    
578          /*          /*
579           * When case-independent, it's hard to decide when cvec ranges are           * When case-independent, it's hard to decide when cvec ranges are
580           * usable, so for now at least, we won't try.  We allocate enough           * usable, so for now at least, we won't try.  We allocate enough
581           * space for two case variants plus a little extra for the two           * space for two case variants plus a little extra for the two
582           * title case variants.           * title case variants.
583           */           */
584    
585          nchrs = (b - a + 1)*2 + 4;          nchrs = (b - a + 1)*2 + 4;
586    
587          cv = getcvec(v, nchrs, 0, 0);          cv = getcvec(v, nchrs, 0, 0);
588          NOERRN();          NOERRN();
589    
590          for (c = a; c <= b; c++) {          for (c = a; c <= b; c++) {
591                  addchr(cv, c);                  addchr(cv, c);
592                  lc = Tcl_UniCharToLower((chr)c);                  lc = Tcl_UniCharToLower((chr)c);
593                  uc = Tcl_UniCharToUpper((chr)c);                  uc = Tcl_UniCharToUpper((chr)c);
594                  tc = Tcl_UniCharToTitle((chr)c);                  tc = Tcl_UniCharToTitle((chr)c);
595                  if (c != lc) {                  if (c != lc) {
596                          addchr(cv, lc);                          addchr(cv, lc);
597                  }                  }
598                  if (c != uc) {                  if (c != uc) {
599                          addchr(cv, uc);                          addchr(cv, uc);
600                  }                  }
601                  if (c != tc && tc != uc) {                  if (c != tc && tc != uc) {
602                          addchr(cv, tc);                          addchr(cv, tc);
603                  }                  }
604          }          }
605    
606          return cv;          return cv;
607  }  }
608    
609  /*  /*
610   - before - is celt x before celt y, for purposes of range legality?   - before - is celt x before celt y, for purposes of range legality?
611   ^ static int before(celt, celt);   ^ static int before(celt, celt);
612   */   */
613  static int                      /* predicate */  static int                      /* predicate */
614  before(x, y)  before(x, y)
615  celt x;  celt x;
616  celt y;  celt y;
617  {  {
618          /* trivial because no MCCEs */          /* trivial because no MCCEs */
619          if (x < y)          if (x < y)
620                  return 1;                  return 1;
621          return 0;          return 0;
622  }  }
623    
624  /*  /*
625   - eclass - supply cvec for an equivalence class   - eclass - supply cvec for an equivalence class
626   * Must include case counterparts on request.   * Must include case counterparts on request.
627   ^ static struct cvec *eclass(struct vars *, celt, int);   ^ static struct cvec *eclass(struct vars *, celt, int);
628   */   */
629  static struct cvec *  static struct cvec *
630  eclass(v, c, cases)  eclass(v, c, cases)
631  struct vars *v;  struct vars *v;
632  celt c;  celt c;
633  int cases;                      /* all cases? */  int cases;                      /* all cases? */
634  {  {
635          struct cvec *cv;          struct cvec *cv;
636    
637          /* crude fake equivalence class for testing */          /* crude fake equivalence class for testing */
638          if ((v->cflags&REG_FAKE) && c == 'x') {          if ((v->cflags&REG_FAKE) && c == 'x') {
639                  cv = getcvec(v, 4, 0, 0);                  cv = getcvec(v, 4, 0, 0);
640                  addchr(cv, (chr)'x');                  addchr(cv, (chr)'x');
641                  addchr(cv, (chr)'y');                  addchr(cv, (chr)'y');
642                  if (cases) {                  if (cases) {
643                          addchr(cv, (chr)'X');                          addchr(cv, (chr)'X');
644                          addchr(cv, (chr)'Y');                          addchr(cv, (chr)'Y');
645                  }                  }
646                  return cv;                  return cv;
647          }          }
648    
649          /* otherwise, none */          /* otherwise, none */
650          if (cases)          if (cases)
651                  return allcases(v, c);                  return allcases(v, c);
652          cv = getcvec(v, 1, 0, 0);          cv = getcvec(v, 1, 0, 0);
653          assert(cv != NULL);          assert(cv != NULL);
654          addchr(cv, (chr)c);          addchr(cv, (chr)c);
655          return cv;          return cv;
656  }  }
657    
658  /*  /*
659   - cclass - supply cvec for a character class   - cclass - supply cvec for a character class
660   * Must include case counterparts on request.   * Must include case counterparts on request.
661   ^ static struct cvec *cclass(struct vars *, chr *, chr *, int);   ^ static struct cvec *cclass(struct vars *, chr *, chr *, int);
662   */   */
663  static struct cvec *  static struct cvec *
664  cclass(v, startp, endp, cases)  cclass(v, startp, endp, cases)
665  struct vars *v;  struct vars *v;
666  chr *startp;                    /* where the name starts */  chr *startp;                    /* where the name starts */
667  chr *endp;                      /* just past the end of the name */  chr *endp;                      /* just past the end of the name */
668  int cases;                      /* case-independent? */  int cases;                      /* case-independent? */
669  {  {
670      size_t len;      size_t len;
671      struct cvec *cv = NULL;      struct cvec *cv = NULL;
672      Tcl_DString ds;      Tcl_DString ds;
673      char *np, **namePtr;      char *np, **namePtr;
674      int i, index;      int i, index;
675    
676      /*      /*
677       * The following arrays define the valid character class names.       * The following arrays define the valid character class names.
678       */       */
679    
680      static char *classNames[] = {      static char *classNames[] = {
681          "alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",          "alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
682          "lower", "print", "punct", "space", "upper", "xdigit", NULL          "lower", "print", "punct", "space", "upper", "xdigit", NULL
683      };      };
684    
685      enum classes {      enum classes {
686          CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,          CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
687          CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT          CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT
688      };      };
689            
690    
691      /*      /*
692       * Extract the class name       * Extract the class name
693       */       */
694    
695      len = endp - startp;      len = endp - startp;
696      Tcl_DStringInit(&ds);      Tcl_DStringInit(&ds);
697      np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);      np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
698    
699      /*      /*
700       * Remap lower and upper to alpha if the match is case insensitive.       * Remap lower and upper to alpha if the match is case insensitive.
701       */       */
702    
703      if (cases && len == 5 && (strncmp("lower", np, 5) == 0      if (cases && len == 5 && (strncmp("lower", np, 5) == 0
704              || strncmp("upper", np, 5) == 0)) {              || strncmp("upper", np, 5) == 0)) {
705          np = "alpha";          np = "alpha";
706      }      }
707    
708      /*      /*
709       * Map the name to the corresponding enumerated value.       * Map the name to the corresponding enumerated value.
710       */       */
711    
712      index = -1;      index = -1;
713      for (namePtr = classNames, i = 0; *namePtr != NULL; namePtr++, i++) {      for (namePtr = classNames, i = 0; *namePtr != NULL; namePtr++, i++) {
714          if ((strlen(*namePtr) == len) && (strncmp(*namePtr, np, len) == 0)) {          if ((strlen(*namePtr) == len) && (strncmp(*namePtr, np, len) == 0)) {
715              index = i;              index = i;
716              break;              break;
717          }          }
718      }      }
719      Tcl_DStringInit(&ds);      Tcl_DStringInit(&ds);
720      if (index == -1) {      if (index == -1) {
721          ERR(REG_ECTYPE);          ERR(REG_ECTYPE);
722          return NULL;          return NULL;
723      }      }
724            
725      /*      /*
726       * Now compute the character class contents.       * Now compute the character class contents.
727       */       */
728    
729      switch((enum classes) index) {      switch((enum classes) index) {
730          case CC_PRINT:          case CC_PRINT:
731          case CC_ALNUM:          case CC_ALNUM:
732              cv = getcvec(v, NUM_ALPHA_CHAR,              cv = getcvec(v, NUM_ALPHA_CHAR,
733                      NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);                      NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);
734              if (cv) {              if (cv) {
735                  for (i = 0; i < NUM_ALPHA_CHAR; i++) {                  for (i = 0; i < NUM_ALPHA_CHAR; i++) {
736                      addchr(cv, alphaCharTable[i]);                      addchr(cv, alphaCharTable[i]);
737                  }                  }
738                  for (i = 0; i < NUM_ALPHA_RANGE; i++) {                  for (i = 0; i < NUM_ALPHA_RANGE; i++) {
739                      addrange(cv, alphaRangeTable[i].start,                      addrange(cv, alphaRangeTable[i].start,
740                               alphaRangeTable[i].end);                               alphaRangeTable[i].end);
741                  }                  }
742                  for (i = 0; i < NUM_DIGIT_RANGE; i++) {                  for (i = 0; i < NUM_DIGIT_RANGE; i++) {
743                      addrange(cv, digitRangeTable[i].start,                      addrange(cv, digitRangeTable[i].start,
744                              digitRangeTable[i].end);                              digitRangeTable[i].end);
745                  }                  }
746              }              }
747              break;              break;
748          case CC_ALPHA:          case CC_ALPHA:
749              cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);              cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);
750              if (cv) {              if (cv) {
751                  for (i = 0; i < NUM_ALPHA_RANGE; i++) {                  for (i = 0; i < NUM_ALPHA_RANGE; i++) {
752                      addrange(cv, alphaRangeTable[i].start,                      addrange(cv, alphaRangeTable[i].start,
753                               alphaRangeTable[i].end);                               alphaRangeTable[i].end);
754                  }                  }
755                  for (i = 0; i < NUM_ALPHA_CHAR; i++) {                  for (i = 0; i < NUM_ALPHA_CHAR; i++) {
756                      addchr(cv, alphaCharTable[i]);                      addchr(cv, alphaCharTable[i]);
757                  }                  }
758              }              }
759              break;              break;
760          case CC_ASCII:          case CC_ASCII:
761              cv = getcvec(v, 0, 1, 0);              cv = getcvec(v, 0, 1, 0);
762              if (cv) {              if (cv) {
763                  addrange(cv, 0, 0x7f);                  addrange(cv, 0, 0x7f);
764              }              }
765              break;              break;
766          case CC_BLANK:          case CC_BLANK:
767              cv = getcvec(v, 2, 0, 0);              cv = getcvec(v, 2, 0, 0);
768              addchr(cv, '\t');              addchr(cv, '\t');
769              addchr(cv, ' ');              addchr(cv, ' ');
770              break;              break;
771          case CC_CNTRL:          case CC_CNTRL:
772              cv = getcvec(v, 0, 2, 0);              cv = getcvec(v, 0, 2, 0);
773              addrange(cv, 0x0, 0x1f);              addrange(cv, 0x0, 0x1f);
774              addrange(cv, 0x7f, 0x9f);              addrange(cv, 0x7f, 0x9f);
775              break;              break;
776          case CC_DIGIT:          case CC_DIGIT:
777              cv = getcvec(v, 0, NUM_DIGIT_RANGE, 0);              cv = getcvec(v, 0, NUM_DIGIT_RANGE, 0);
778              if (cv) {                if (cv) {  
779                  for (i = 0; i < NUM_DIGIT_RANGE; i++) {                  for (i = 0; i < NUM_DIGIT_RANGE; i++) {
780                      addrange(cv, digitRangeTable[i].start,                      addrange(cv, digitRangeTable[i].start,
781                              digitRangeTable[i].end);                              digitRangeTable[i].end);
782                  }                  }
783              }              }
784              break;              break;
785          case CC_PUNCT:          case CC_PUNCT:
786              cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);              cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);
787              if (cv) {              if (cv) {
788                  for (i = 0; i < NUM_PUNCT_RANGE; i++) {                  for (i = 0; i < NUM_PUNCT_RANGE; i++) {
789                      addrange(cv, punctRangeTable[i].start,                      addrange(cv, punctRangeTable[i].start,
790                               punctRangeTable[i].end);                               punctRangeTable[i].end);
791                  }                  }
792                  for (i = 0; i < NUM_PUNCT_CHAR; i++) {                  for (i = 0; i < NUM_PUNCT_CHAR; i++) {
793                      addchr(cv, punctCharTable[i]);                      addchr(cv, punctCharTable[i]);
794                  }                  }
795              }              }
796              break;              break;
797          case CC_XDIGIT:          case CC_XDIGIT:
798              cv = getcvec(v, 0, NUM_DIGIT_RANGE+2, 0);              cv = getcvec(v, 0, NUM_DIGIT_RANGE+2, 0);
799              if (cv) {                if (cv) {  
800                  addrange(cv, '0', '9');                  addrange(cv, '0', '9');
801                  addrange(cv, 'a', 'f');                  addrange(cv, 'a', 'f');
802                  addrange(cv, 'A', 'F');                  addrange(cv, 'A', 'F');
803              }              }
804              break;              break;
805          case CC_SPACE:          case CC_SPACE:
806              cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);              cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);
807              if (cv) {              if (cv) {
808                  for (i = 0; i < NUM_SPACE_RANGE; i++) {                  for (i = 0; i < NUM_SPACE_RANGE; i++) {
809                      addrange(cv, spaceRangeTable[i].start,                      addrange(cv, spaceRangeTable[i].start,
810                               spaceRangeTable[i].end);                               spaceRangeTable[i].end);
811                  }                  }
812                  for (i = 0; i < NUM_SPACE_CHAR; i++) {                  for (i = 0; i < NUM_SPACE_CHAR; i++) {
813                      addchr(cv, spaceCharTable[i]);                      addchr(cv, spaceCharTable[i]);
814                  }                  }
815              }              }
816              break;              break;
817          case CC_LOWER:          case CC_LOWER:
818              cv  = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);              cv  = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);
819              if (cv) {              if (cv) {
820                  for (i = 0; i < NUM_LOWER_RANGE; i++) {                  for (i = 0; i < NUM_LOWER_RANGE; i++) {
821                      addrange(cv, lowerRangeTable[i].start,                      addrange(cv, lowerRangeTable[i].start,
822                               lowerRangeTable[i].end);                               lowerRangeTable[i].end);
823                  }                  }
824                  for (i = 0; i < NUM_LOWER_CHAR; i++) {                  for (i = 0; i < NUM_LOWER_CHAR; i++) {
825                      addchr(cv, lowerCharTable[i]);                      addchr(cv, lowerCharTable[i]);
826                  }                  }
827              }              }
828              break;              break;
829          case CC_UPPER:          case CC_UPPER:
830              cv  = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);              cv  = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);
831              if (cv) {              if (cv) {
832                  for (i = 0; i < NUM_UPPER_RANGE; i++) {                  for (i = 0; i < NUM_UPPER_RANGE; i++) {
833                      addrange(cv, upperRangeTable[i].start,                      addrange(cv, upperRangeTable[i].start,
834                               upperRangeTable[i].end);                               upperRangeTable[i].end);
835                  }                  }
836                  for (i = 0; i < NUM_UPPER_CHAR; i++) {                  for (i = 0; i < NUM_UPPER_CHAR; i++) {
837                      addchr(cv, upperCharTable[i]);                      addchr(cv, upperCharTable[i]);
838                  }                  }
839              }              }
840              break;              break;
841          case CC_GRAPH:          case CC_GRAPH:
842              cv  = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);              cv  = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);
843              if (cv) {              if (cv) {
844                  for (i = 0; i < NUM_GRAPH_RANGE; i++) {                  for (i = 0; i < NUM_GRAPH_RANGE; i++) {
845                      addrange(cv, graphRangeTable[i].start,                      addrange(cv, graphRangeTable[i].start,
846                               graphRangeTable[i].end);                               graphRangeTable[i].end);
847                  }                  }
848                  for (i = 0; i < NUM_GRAPH_CHAR; i++) {                  for (i = 0; i < NUM_GRAPH_CHAR; i++) {
849                      addchr(cv, graphCharTable[i]);                      addchr(cv, graphCharTable[i]);
850                  }                  }
851              }              }
852              break;              break;
853      }      }
854      if (cv == NULL) {      if (cv == NULL) {
855          ERR(REG_ESPACE);          ERR(REG_ESPACE);
856      }      }
857      return cv;      return cv;
858  }  }
859    
860  /*  /*
861   - allcases - supply cvec for all case counterparts of a chr (including itself)   - allcases - supply cvec for all case counterparts of a chr (including itself)
862   * This is a shortcut, preferably an efficient one, for simple characters;   * This is a shortcut, preferably an efficient one, for simple characters;
863   * messy cases are done via range().   * messy cases are done via range().
864   ^ static struct cvec *allcases(struct vars *, pchr);   ^ static struct cvec *allcases(struct vars *, pchr);
865   */   */
866  static struct cvec *  static struct cvec *
867  allcases(v, pc)  allcases(v, pc)
868  struct vars *v;  struct vars *v;
869  pchr pc;  pchr pc;
870  {  {
871          struct cvec *cv;          struct cvec *cv;
872          chr c = (chr)pc;          chr c = (chr)pc;
873          chr lc, uc, tc;          chr lc, uc, tc;
874    
875          lc = Tcl_UniCharToLower((chr)c);          lc = Tcl_UniCharToLower((chr)c);
876          uc = Tcl_UniCharToUpper((chr)c);          uc = Tcl_UniCharToUpper((chr)c);
877          tc = Tcl_UniCharToTitle((chr)c);          tc = Tcl_UniCharToTitle((chr)c);
878    
879          if (tc != uc) {          if (tc != uc) {
880              cv = getcvec(v, 3, 0, 0);              cv = getcvec(v, 3, 0, 0);
881              addchr(cv, tc);              addchr(cv, tc);
882          } else {          } else {
883              cv = getcvec(v, 2, 0, 0);              cv = getcvec(v, 2, 0, 0);
884          }          }
885          addchr(cv, lc);          addchr(cv, lc);
886          if (lc != uc) {          if (lc != uc) {
887              addchr(cv, uc);              addchr(cv, uc);
888          }          }
889          return cv;          return cv;
890  }  }
891    
892  /*  /*
893   - cmp - chr-substring compare   - cmp - chr-substring compare
894   * Backrefs need this.  It should preferably be efficient.   * Backrefs need this.  It should preferably be efficient.
895   * Note that it does not need to report anything except equal/unequal.   * Note that it does not need to report anything except equal/unequal.
896   * Note also that the length is exact, and the comparison should not   * Note also that the length is exact, and the comparison should not
897   * stop at embedded NULs!   * stop at embedded NULs!
898   ^ static int cmp(CONST chr *, CONST chr *, size_t);   ^ static int cmp(CONST chr *, CONST chr *, size_t);
899   */   */
900  static int                      /* 0 for equal, nonzero for unequal */  static int                      /* 0 for equal, nonzero for unequal */
901  cmp(x, y, len)  cmp(x, y, len)
902  CONST chr *x;  CONST chr *x;
903  CONST chr *y;  CONST chr *y;
904  size_t len;                     /* exact length of comparison */  size_t len;                     /* exact length of comparison */
905  {  {
906          return memcmp(VS(x), VS(y), len*sizeof(chr));          return memcmp(VS(x), VS(y), len*sizeof(chr));
907  }  }
908    
909  /*  /*
910   - casecmp - case-independent chr-substring compare   - casecmp - case-independent chr-substring compare
911   * REG_ICASE backrefs need this.  It should preferably be efficient.   * REG_ICASE backrefs need this.  It should preferably be efficient.
912   * Note that it does not need to report anything except equal/unequal.   * Note that it does not need to report anything except equal/unequal.
913   * Note also that the length is exact, and the comparison should not   * Note also that the length is exact, and the comparison should not
914   * stop at embedded NULs!   * stop at embedded NULs!
915   ^ static int casecmp(CONST chr *, CONST chr *, size_t);   ^ static int casecmp(CONST chr *, CONST chr *, size_t);
916   */   */
917  static int                      /* 0 for equal, nonzero for unequal */  static int                      /* 0 for equal, nonzero for unequal */
918  casecmp(x, y, len)  casecmp(x, y, len)
919  CONST chr *x;  CONST chr *x;
920  CONST chr *y;  CONST chr *y;
921  size_t len;                     /* exact length of comparison */  size_t len;                     /* exact length of comparison */
922  {  {
923          size_t i;          size_t i;
924          CONST chr *xp;          CONST chr *xp;
925          CONST chr *yp;          CONST chr *yp;
926    
927          for (xp = x, yp = y, i = len; i > 0; i--)          for (xp = x, yp = y, i = len; i > 0; i--)
928                  if (Tcl_UniCharToLower(*xp++) != Tcl_UniCharToLower(*yp++))                  if (Tcl_UniCharToLower(*xp++) != Tcl_UniCharToLower(*yp++))
929                          return 1;                          return 1;
930          return 0;          return 0;
931  }  }
932    
933  /* End of regc_locale.c */  /* End of regc_locale.c */

Legend:
Removed from v.70  
changed lines
  Added in v.71

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25