]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/regex/regc_locale.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
missing commit
[wxWidgets.git] / src / regex / regc_locale.c
... / ...
CommitLineData
1/*
2 * regc_locale.c --
3 *
4 * This file contains the Unicode locale specific regexp routines.
5 * This file is #included by regcomp.c.
6 *
7 * Copyright (c) 1998 by Scriptics Corporation.
8 *
9 * See the file "license.terms" for information on usage and redistribution
10 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
11 *
12 * RCS: @(#) $Id$
13 *
14 * wxWidgets:
15 * The Scriptics license can be found in the file COPYRIGHT. Modifications
16 * for wxWidgets are under the wxWindows licence, see README for details.
17 */
18
19#ifndef CONST
20#define CONST const
21#endif
22
23/* ASCII character-name table */
24
25static struct cname {
26 chr *name;
27 char code;
28} cnames[] = {
29 {wxT("NUL"), '\0'},
30 {wxT("SOH"), '\001'},
31 {wxT("STX"), '\002'},
32 {wxT("ETX"), '\003'},
33 {wxT("EOT"), '\004'},
34 {wxT("ENQ"), '\005'},
35 {wxT("ACK"), '\006'},
36 {wxT("BEL"), '\007'},
37 {wxT("alert"), '\007'},
38 {wxT("BS"), '\010'},
39 {wxT("backspace"), '\b'},
40 {wxT("HT"), '\011'},
41 {wxT("tab"), '\t'},
42 {wxT("LF"), '\012'},
43 {wxT("newline"), '\n'},
44 {wxT("VT"), '\013'},
45 {wxT("vertical-tab"), '\v'},
46 {wxT("FF"), '\014'},
47 {wxT("form-feed"), '\f'},
48 {wxT("CR"), '\015'},
49 {wxT("carriage-return"), '\r'},
50 {wxT("SO"), '\016'},
51 {wxT("SI"), '\017'},
52 {wxT("DLE"), '\020'},
53 {wxT("DC1"), '\021'},
54 {wxT("DC2"), '\022'},
55 {wxT("DC3"), '\023'},
56 {wxT("DC4"), '\024'},
57 {wxT("NAK"), '\025'},
58 {wxT("SYN"), '\026'},
59 {wxT("ETB"), '\027'},
60 {wxT("CAN"), '\030'},
61 {wxT("EM"), '\031'},
62 {wxT("SUB"), '\032'},
63 {wxT("ESC"), '\033'},
64 {wxT("IS4"), '\034'},
65 {wxT("FS"), '\034'},
66 {wxT("IS3"), '\035'},
67 {wxT("GS"), '\035'},
68 {wxT("IS2"), '\036'},
69 {wxT("RS"), '\036'},
70 {wxT("IS1"), '\037'},
71 {wxT("US"), '\037'},
72 {wxT("space"), ' '},
73 {wxT("exclamation-mark"), '!'},
74 {wxT("quotation-mark"), '"'},
75 {wxT("number-sign"), '#'},
76 {wxT("dollar-sign"), '$'},
77 {wxT("percent-sign"), '%'},
78 {wxT("ampersand"), '&'},
79 {wxT("apostrophe"), '\''},
80 {wxT("left-parenthesis"), '('},
81 {wxT("right-parenthesis"), ')'},
82 {wxT("asterisk"), '*'},
83 {wxT("plus-sign"), '+'},
84 {wxT("comma"), ','},
85 {wxT("hyphen"), '-'},
86 {wxT("hyphen-minus"), '-'},
87 {wxT("period"), '.'},
88 {wxT("full-stop"), '.'},
89 {wxT("slash"), '/'},
90 {wxT("solidus"), '/'},
91 {wxT("zero"), '0'},
92 {wxT("one"), '1'},
93 {wxT("two"), '2'},
94 {wxT("three"), '3'},
95 {wxT("four"), '4'},
96 {wxT("five"), '5'},
97 {wxT("six"), '6'},
98 {wxT("seven"), '7'},
99 {wxT("eight"), '8'},
100 {wxT("nine"), '9'},
101 {wxT("colon"), ':'},
102 {wxT("semicolon"), ';'},
103 {wxT("less-than-sign"), '<'},
104 {wxT("equals-sign"), '='},
105 {wxT("greater-than-sign"), '>'},
106 {wxT("question-mark"), '?'},
107 {wxT("commercial-at"), '@'},
108 {wxT("left-square-bracket"), '['},
109 {wxT("backslash"), '\\'},
110 {wxT("reverse-solidus"), '\\'},
111 {wxT("right-square-bracket"), ']'},
112 {wxT("circumflex"), '^'},
113 {wxT("circumflex-accent"), '^'},
114 {wxT("underscore"), '_'},
115 {wxT("low-line"), '_'},
116 {wxT("grave-accent"), '`'},
117 {wxT("left-brace"), '{'},
118 {wxT("left-curly-bracket"), '{'},
119 {wxT("vertical-line"), '|'},
120 {wxT("right-brace"), '}'},
121 {wxT("right-curly-bracket"), '}'},
122 {wxT("tilde"), '~'},
123 {wxT("DEL"), '\177'},
124 {NULL, 0}
125};
126
127#if wxUSE_UNICODE
128
129/* Unicode character-class tables */
130
131typedef struct crange {
132 chr start;
133 chr end;
134} crange;
135
136/*
137 * Declarations of Unicode character ranges. This code
138 * is automatically generated by the tools/uniClass.tcl script
139 * and used in generic/regc_locale.c. Do not modify by hand.
140 */
141
142/* Unicode: alphabetic characters */
143
144static crange alphaRangeTable[] = {
145 {0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6},
146 {0x00f8, 0x021f}, {0x0222, 0x0233}, {0x0250, 0x02ad}, {0x02b0, 0x02b8},
147 {0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1},
148 {0x03a3, 0x03ce}, {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x0481},
149 {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587},
150 {0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a},
151 {0x0671, 0x06d3}, {0x06fa, 0x06fc}, {0x0712, 0x072c}, {0x0780, 0x07a5},
152 {0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8},
153 {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a},
154 {0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74},
155 {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},
156 {0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30},
157 {0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90},
158 {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9},
159 {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33},
160 {0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8},
161 {0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10},
162 {0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1},
163 {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46},
164 {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0},
165 {0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f88, 0x0f8b},
166 {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1050, 0x1055}, {0x10a0, 0x10c5},
167 {0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
168 {0x1200, 0x1206}, {0x1208, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256},
169 {0x125a, 0x125d}, {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae},
170 {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce},
171 {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315},
172 {0x1318, 0x131e}, {0x1320, 0x1346}, {0x1348, 0x135a}, {0x13a0, 0x13f4},
173 {0x1401, 0x166c}, {0x166f, 0x1676}, {0x1681, 0x169a}, {0x16a0, 0x16ea},
174 {0x1780, 0x17b3}, {0x1820, 0x1877}, {0x1880, 0x18a8}, {0x1e00, 0x1e9b},
175 {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45},
176 {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4},
177 {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3},
178 {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc},
179 {0x210a, 0x2113}, {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2131},
180 {0x2133, 0x2139}, {0x3031, 0x3035}, {0x3041, 0x3094}, {0x30a1, 0x30fa},
181 {0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7},
182 {0x3400, 0x4db5}, {0x4e00, 0x9fa5}, {0xa000, 0xa48c}, {0xac00, 0xd7a3},
183 {0xf900, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1f, 0xfb28},
184 {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d},
185 {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72},
186 {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe},
187 {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}
188};
189
190#define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
191
192static chr alphaCharTable[] = {
193 0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x02ee, 0x037a, 0x0386, 0x038c,
194 0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0559, 0x06d5, 0x06e5,
195 0x06e6, 0x0710, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2, 0x09dc, 0x09dd,
196 0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38,
197 0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0, 0x0ae0, 0x0b0f,
198 0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99, 0x0b9a, 0x0b9c,
199 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde, 0x0ce0, 0x0ce1,
200 0x0d60, 0x0d61, 0x0dbd, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84, 0x0e87,
201 0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2, 0x0eb3,
202 0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1029, 0x102a, 0x1248, 0x1258,
203 0x1288, 0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x1fbe, 0x207f,
204 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005, 0x3006, 0x309d,
205 0x309e, 0xfb1d, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74, 0xfffe
206};
207
208#define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
209
210/* Unicode: decimal digit characters */
211
212static crange digitRangeTable[] = {
213 {0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f},
214 {0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f},
215 {0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f},
216 {0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0x1040, 0x1049},
217 {0x1369, 0x1371}, {0x17e0, 0x17e9}, {0x1810, 0x1819}, {0xff10, 0xff19}
218};
219
220#define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
221
222/* no singletons of digit characters */
223
224/* Unicode: punctuation characters */
225
226static crange punctRangeTable[] = {
227 {0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d},
228 {0x055a, 0x055f}, {0x066a, 0x066d}, {0x0700, 0x070d}, {0x0f04, 0x0f12},
229 {0x0f3a, 0x0f3d}, {0x104a, 0x104f}, {0x1361, 0x1368}, {0x16eb, 0x16ed},
230 {0x17d4, 0x17da}, {0x1800, 0x180a}, {0x2010, 0x2027}, {0x2030, 0x2043},
231 {0x2048, 0x204d}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f},
232 {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61}, {0xff01, 0xff03},
233 {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d}, {0xff61, 0xff65}
234};
235
236#define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
237
238static chr punctCharTable[] = {
239 0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab,
240 0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x058a, 0x05be,
241 0x05c0, 0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964,
242 0x0965, 0x0970, 0x0df4, 0x0e4f, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x166d,
243 0x166e, 0x169b, 0x169c, 0x17dc, 0x2045, 0x2046, 0x207d, 0x207e, 0x208d,
244 0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63, 0xfe68,
245 0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b, 0xff5d
246};
247
248#define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
249
250/* Unicode: white space characters */
251
252static crange spaceRangeTable[] = {
253 {0x0009, 0x000d}, {0x2000, 0x200b}
254};
255
256#define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))
257
258static chr spaceCharTable[] = {
259 0x0020, 0x00a0, 0x1680, 0x2028, 0x2029, 0x202f, 0x3000
260};
261
262#define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))
263
264/* Unicode: lowercase characters */
265
266static crange lowerRangeTable[] = {
267 {0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180},
268 {0x0199, 0x019b}, {0x01bd, 0x01bf}, {0x0250, 0x02ad}, {0x03ac, 0x03ce},
269 {0x03d5, 0x03d7}, {0x03ef, 0x03f3}, {0x0430, 0x045f}, {0x0561, 0x0587},
270 {0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27},
271 {0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67},
272 {0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7},
273 {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7},
274 {0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
275};
276
277#define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))
278
279static chr lowerCharTable[] = {
280 0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b,
281 0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d,
282 0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f,
283 0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140,
284 0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151,
285 0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163,
286 0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175,
287 0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192,
288 0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01aa, 0x01ab, 0x01ad,
289 0x01b0, 0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01c6, 0x01c9, 0x01cc, 0x01ce,
290 0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df,
291 0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0,
292 0x01f3, 0x01f5, 0x01f9, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205,
293 0x0207, 0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217,
294 0x0219, 0x021b, 0x021d, 0x021f, 0x0223, 0x0225, 0x0227, 0x0229, 0x022b,
295 0x022d, 0x022f, 0x0231, 0x0233, 0x0390, 0x03d0, 0x03d1, 0x03db, 0x03dd,
296 0x03df, 0x03e1, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb, 0x03ed, 0x03f5,
297 0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b, 0x046d, 0x046f, 0x0471,
298 0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d, 0x047f, 0x0481, 0x048d,
299 0x048f, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d, 0x049f,
300 0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af, 0x04b1,
301 0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2, 0x04c4,
302 0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db, 0x04dd,
303 0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ed, 0x04ef,
304 0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09,
305 0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b,
306 0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d,
307 0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f,
308 0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51,
309 0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63,
310 0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75,
311 0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87,
312 0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5,
313 0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7,
314 0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9,
315 0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb,
316 0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed,
317 0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe,
318 0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e,
319 0x210f, 0x2113, 0x212f, 0x2134, 0x2139
320};
321
322#define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
323
324/* Unicode: uppercase characters */
325
326static crange upperRangeTable[] = {
327 {0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b},
328 {0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x01f6, 0x01f8},
329 {0x0388, 0x038a}, {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4},
330 {0x0400, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f},
331 {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d},
332 {0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb},
333 {0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, {0x210b, 0x210d}, {0x2110, 0x2112},
334 {0x2119, 0x211d}, {0x212a, 0x212d}, {0xff21, 0xff3a}
335};
336
337#define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))
338
339static chr upperCharTable[] = {
340 0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110,
341 0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122,
342 0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134,
343 0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147,
344 0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a,
345 0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c,
346 0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d,
347 0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d,
348 0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae,
349 0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd,
350 0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0,
351 0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4,
352 0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a,
353 0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021a, 0x021c,
354 0x021e, 0x0222, 0x0224, 0x0226, 0x0228, 0x022a, 0x022c, 0x022e, 0x0230,
355 0x0232, 0x0386, 0x038c, 0x038e, 0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0,
356 0x03e2, 0x03e4, 0x03e6, 0x03e8, 0x03ea, 0x03ec, 0x03ee, 0x03f4, 0x0460,
357 0x0462, 0x0464, 0x0466, 0x0468, 0x046a, 0x046c, 0x046e, 0x0470, 0x0472,
358 0x0474, 0x0476, 0x0478, 0x047a, 0x047c, 0x047e, 0x0480, 0x048c, 0x048e,
359 0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c, 0x049e, 0x04a0,
360 0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae, 0x04b0, 0x04b2,
361 0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c0, 0x04c1, 0x04c3,
362 0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da, 0x04dc,
363 0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ec, 0x04ee,
364 0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08,
365 0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a,
366 0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c,
367 0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e,
368 0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50,
369 0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62,
370 0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74,
371 0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86,
372 0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2,
373 0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4,
374 0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6,
375 0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8,
376 0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea,
377 0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b,
378 0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130,
379 0x2131, 0x2133
380};
381
382#define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
383
384/* Unicode: unicode print characters excluding space */
385
386static crange graphRangeTable[] = {
387 {0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x021f}, {0x0222, 0x0233},
388 {0x0250, 0x02ad}, {0x02b0, 0x02ee}, {0x0300, 0x031f}, {0x0321, 0x034e},
389 {0x0360, 0x0362}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce},
390 {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x041f}, {0x0421, 0x0486},
391 {0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f},
392 {0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4},
393 {0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0655},
394 {0x0660, 0x066d}, {0x0670, 0x06ed}, {0x06f0, 0x06fe}, {0x0700, 0x070d},
395 {0x0710, 0x071f}, {0x0721, 0x072c}, {0x0730, 0x074a}, {0x0780, 0x07b0},
396 {0x0901, 0x0903}, {0x0905, 0x091f}, {0x0921, 0x0939}, {0x093c, 0x094d},
397 {0x0950, 0x0954}, {0x0958, 0x0970}, {0x0981, 0x0983}, {0x0985, 0x098c},
398 {0x0993, 0x09a8}, {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09be, 0x09c4},
399 {0x09cb, 0x09cd}, {0x09df, 0x09e3}, {0x09e6, 0x09fa}, {0x0a05, 0x0a0a},
400 {0x0a13, 0x0a1f}, {0x0a21, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42},
401 {0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c}, {0x0a66, 0x0a74}, {0x0a81, 0x0a83},
402 {0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},
403 {0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5}, {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd},
404 {0x0ae6, 0x0aef}, {0x0b01, 0x0b03}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f},
405 {0x0b21, 0x0b28}, {0x0b2a, 0x0b30}, {0x0b36, 0x0b39}, {0x0b3c, 0x0b43},
406 {0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61}, {0x0b66, 0x0b70}, {0x0b85, 0x0b8a},
407 {0x0b8e, 0x0b90}, {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5},
408 {0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2}, {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd},
409 {0x0be7, 0x0bf2}, {0x0c01, 0x0c03}, {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10},
410 {0x0c12, 0x0c1f}, {0x0c21, 0x0c28}, {0x0c2a, 0x0c33}, {0x0c35, 0x0c39},
411 {0x0c3e, 0x0c44}, {0x0c46, 0x0c48}, {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f},
412 {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3},
413 {0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4}, {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd},
414 {0x0ce6, 0x0cef}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f},
415 {0x0d21, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d3e, 0x0d43}, {0x0d46, 0x0d48},
416 {0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1},
417 {0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0dcf, 0x0dd4}, {0x0dd8, 0x0ddf},
418 {0x0df2, 0x0df4}, {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b},
419 {0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9},
420 {0x0ebb, 0x0ebd}, {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9},
421 {0x0f00, 0x0f1f}, {0x0f21, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f71, 0x0f8b},
422 {0x0f90, 0x0f97}, {0x0f99, 0x0fbc}, {0x0fbe, 0x0fcc}, {0x1000, 0x101f},
423 {0x1023, 0x1027}, {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1040, 0x1059},
424 {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x111f}, {0x1121, 0x1159},
425 {0x115f, 0x11a2}, {0x11a8, 0x11f9}, {0x1200, 0x1206}, {0x1208, 0x121f},
426 {0x1221, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d},
427 {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b2, 0x12b5},
428 {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, {0x12d0, 0x12d6},
429 {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, {0x1318, 0x131e},
430 {0x1321, 0x1346}, {0x1348, 0x135a}, {0x1361, 0x137c}, {0x13a0, 0x13f4},
431 {0x1401, 0x141f}, {0x1421, 0x151f}, {0x1521, 0x161f}, {0x1621, 0x1676},
432 {0x1680, 0x169c}, {0x16a0, 0x16f0}, {0x1780, 0x17dc}, {0x17e0, 0x17e9},
433 {0x1800, 0x180a}, {0x1810, 0x1819}, {0x1821, 0x1877}, {0x1880, 0x18a9},
434 {0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
435 {0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
436 {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3},
437 {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe},
438 {0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x202f, 0x2046},
439 {0x2048, 0x204d}, {0x2074, 0x208e}, {0x20a0, 0x20af}, {0x20d0, 0x20e3},
440 {0x2100, 0x211f}, {0x2121, 0x213a}, {0x2153, 0x2183}, {0x2190, 0x21f3},
441 {0x2200, 0x221f}, {0x2221, 0x22f1}, {0x2300, 0x231f}, {0x2321, 0x237b},
442 {0x237d, 0x239a}, {0x2400, 0x241f}, {0x2421, 0x2426}, {0x2440, 0x244a},
443 {0x2460, 0x24ea}, {0x2500, 0x251f}, {0x2521, 0x2595}, {0x25a0, 0x25f7},
444 {0x2600, 0x2613}, {0x2619, 0x261f}, {0x2621, 0x2671}, {0x2701, 0x2704},
445 {0x2706, 0x2709}, {0x270c, 0x271f}, {0x2721, 0x2727}, {0x2729, 0x274b},
446 {0x274f, 0x2752}, {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2776, 0x2794},
447 {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x2800, 0x281f}, {0x2821, 0x28ff},
448 {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2f1f}, {0x2f21, 0x2fd5},
449 {0x2ff0, 0x2ffb}, {0x3000, 0x301f}, {0x3021, 0x303a}, {0x3041, 0x3094},
450 {0x3099, 0x309e}, {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c},
451 {0x3131, 0x318e}, {0x3190, 0x31b7}, {0x3200, 0x321c}, {0x3221, 0x3243},
452 {0x3260, 0x327b}, {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe},
453 {0x3300, 0x331f}, {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe},
454 {0x3400, 0x341f}, {0x3421, 0x351f}, {0x3521, 0x361f}, {0x3621, 0x371f},
455 {0x3721, 0x381f}, {0x3821, 0x391f}, {0x3921, 0x3a1f}, {0x3a21, 0x3b1f},
456 {0x3b21, 0x3c1f}, {0x3c21, 0x3d1f}, {0x3d21, 0x3e1f}, {0x3e21, 0x3f1f},
457 {0x3f21, 0x401f}, {0x4021, 0x411f}, {0x4121, 0x421f}, {0x4221, 0x431f},
458 {0x4321, 0x441f}, {0x4421, 0x451f}, {0x4521, 0x461f}, {0x4621, 0x471f},
459 {0x4721, 0x481f}, {0x4821, 0x491f}, {0x4921, 0x4a1f}, {0x4a21, 0x4b1f},
460 {0x4b21, 0x4c1f}, {0x4c21, 0x4d1f}, {0x4d21, 0x4db5}, {0x4e00, 0x4e1f},
461 {0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f},
462 {0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f},
463 {0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f},
464 {0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f},
465 {0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f},
466 {0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f},
467 {0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f},
468 {0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f},
469 {0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f},
470 {0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f},
471 {0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f},
472 {0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f},
473 {0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f},
474 {0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f},
475 {0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f},
476 {0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f},
477 {0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f},
478 {0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f},
479 {0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f},
480 {0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f},
481 {0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xa000, 0xa01f}, {0xa021, 0xa11f},
482 {0xa121, 0xa21f}, {0xa221, 0xa31f}, {0xa321, 0xa41f}, {0xa421, 0xa48c},
483 {0xa490, 0xa4a1}, {0xa4a4, 0xa4b3}, {0xa4b5, 0xa4c0}, {0xa4c2, 0xa4c4},
484 {0xac00, 0xac1f}, {0xac21, 0xad1f}, {0xad21, 0xae1f}, {0xae21, 0xaf1f},
485 {0xaf21, 0xb01f}, {0xb021, 0xb11f}, {0xb121, 0xb21f}, {0xb221, 0xb31f},
486 {0xb321, 0xb41f}, {0xb421, 0xb51f}, {0xb521, 0xb61f}, {0xb621, 0xb71f},
487 {0xb721, 0xb81f}, {0xb821, 0xb91f}, {0xb921, 0xba1f}, {0xba21, 0xbb1f},
488 {0xbb21, 0xbc1f}, {0xbc21, 0xbd1f}, {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f},
489 {0xbf21, 0xc01f}, {0xc021, 0xc11f}, {0xc121, 0xc21f}, {0xc221, 0xc31f},
490 {0xc321, 0xc41f}, {0xc421, 0xc51f}, {0xc521, 0xc61f}, {0xc621, 0xc71f},
491 {0xc721, 0xc81f}, {0xc821, 0xc91f}, {0xc921, 0xca1f}, {0xca21, 0xcb1f},
492 {0xcb21, 0xcc1f}, {0xcc21, 0xcd1f}, {0xcd21, 0xce1f}, {0xce21, 0xcf1f},
493 {0xcf21, 0xd01f}, {0xd021, 0xd11f}, {0xd121, 0xd21f}, {0xd221, 0xd31f},
494 {0xd321, 0xd41f}, {0xd421, 0xd51f}, {0xd521, 0xd61f}, {0xd621, 0xd71f},
495 {0xd721, 0xd7a3}, {0xf900, 0xf91f}, {0xf921, 0xfa1f}, {0xfa21, 0xfa2d},
496 {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1f}, {0xfb21, 0xfb36},
497 {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f}, {0xfc21, 0xfd1f},
498 {0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb},
499 {0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe66},
500 {0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff01, 0xff1f},
501 {0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf},
502 {0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6}, {0xffe8, 0xffee},
503 {0xfffc, 0xffff}
504};
505
506#define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
507
508static chr graphCharTable[] = {
509 0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x0488, 0x0489, 0x04c7, 0x04c8,
510 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589, 0x058a, 0x060c, 0x061b, 0x061f,
511 0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8, 0x09d7, 0x09dc, 0x09dd,
512 0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39,
513 0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0ad0, 0x0ae0,
514 0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48, 0x0b56, 0x0b57, 0x0b5c,
515 0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3,
516 0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61, 0x0c82, 0x0c83, 0x0cd5,
517 0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03, 0x0d57, 0x0d60, 0x0d61,
518 0x0d82, 0x0d83, 0x0dbd, 0x0dca, 0x0dd6, 0x0e81, 0x0e82, 0x0e84, 0x0e87,
519 0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc,
520 0x0edd, 0x0fcf, 0x1021, 0x1029, 0x102a, 0x10fb, 0x1248, 0x1258, 0x1288,
521 0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x274d, 0x2756,
522 0x303e, 0x303f, 0xa4c6, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74
523};
524
525#define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
526
527/*
528 * End of auto-generated Unicode character ranges declarations.
529 */
530
531/*
532 * Supply implementations for some tcl functions that this module depends on
533 * to make it self contained
534 */
535
536#include "tclUniData.c"
537#define Tcl_UniChar wxChar
538
539/*
540 * Compute the uppercase equivalent of the given Unicode character.
541 * Taken from tcl.
542 */
543
544Tcl_UniChar Tcl_UniCharToUpper(int ch)
545{
546 int info = GetUniCharInfo(ch);
547
548 if (GetCaseType(info) & 0x04) {
549 return (Tcl_UniChar) (ch - GetDelta(info));
550 } else {
551 return ch;
552 }
553}
554
555/*
556 * Compute the lowercase equivalent of the given Unicode character.
557 * Taken from tcl.
558 */
559
560Tcl_UniChar Tcl_UniCharToLower(int ch)
561{
562 int info = GetUniCharInfo(ch);
563
564 if (GetCaseType(info) & 0x02) {
565 return (Tcl_UniChar) (ch + GetDelta(info));
566 } else {
567 return ch;
568 }
569}
570
571/*
572 * Compute the titlecase equivalent of the given Unicode character.
573 * Taken from tcl.
574 */
575
576Tcl_UniChar Tcl_UniCharToTitle(int ch)
577{
578 int info = GetUniCharInfo(ch);
579 int mode = GetCaseType(info);
580
581 if (mode & 0x1) {
582 /*
583 * Subtract or add one depending on the original case.
584 */
585
586 return (Tcl_UniChar) (ch + ((mode & 0x4) ? -1 : 1));
587 } else if (mode == 0x4) {
588 return (Tcl_UniChar) (ch - GetDelta(info));
589 } else {
590 return ch;
591 }
592}
593
594#else /* wxUSE_UNICODE */
595
596#include <locale.h>
597
598typedef int (*isfunc_t)(int);
599
600/* ASCII character-class table */
601static struct cclass {
602 char *name;
603 char *chars;
604 int hasch;
605 isfunc_t isfunc;
606} cclasses[] = {
607 {"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
6080123456789", 1, isalnum},
609 {"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
610 1, isalpha},
611 {"blank", " \t", 0, NULL},
612 {"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
613\25\26\27\30\31\32\33\34\35\36\37\177", 0, iscntrl},
614 {"digit", "0123456789", 0, isdigit},
615 {"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
6160123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
617 1, isgraph},
618 {"lower", "abcdefghijklmnopqrstuvwxyz",
619 1, islower},
620 {"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
6210123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
622 1, isprint},
623 {"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
624 0, ispunct},
625 {"space", "\t\n\v\f\r ", 0, isspace},
626 {"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
627 0, isupper},
628 {"xdigit", "0123456789ABCDEFabcdef",
629 0, isxdigit},
630 {NULL, 0, 0, NULL}
631};
632
633/*
634 * Supply implementations for some tcl functions that this module depends on
635 * to make it self contained
636 */
637
638#define Tcl_UniChar wxChar
639Tcl_UniChar Tcl_UniCharToUpper(int ch) { return wxCRT_ToupperNative(ch); }
640Tcl_UniChar Tcl_UniCharToLower(int ch) { return wxCRT_TolowerNative(ch); }
641Tcl_UniChar Tcl_UniCharToTitle(int ch) { return wxCRT_ToupperNative(ch); }
642
643#endif /* !wxUSE_UNICODE */
644
645#define CH NOCELT
646
647/*
648 - nmcces - how many distinct MCCEs are there?
649 ^ static int nmcces(struct vars *);
650 */
651static int
652nmcces(v)
653 struct vars *v; /* context */
654{
655 /*
656 * No multi-character collating elements defined at the moment.
657 */
658 return 0;
659}
660
661/*
662 - nleaders - how many chrs can be first chrs of MCCEs?
663 ^ static int nleaders(struct vars *);
664 */
665static int
666nleaders(v)
667 struct vars *v; /* context */
668{
669 return 0;
670}
671
672/*
673 - allmcces - return a cvec with all the MCCEs of the locale
674 ^ static struct cvec *allmcces(struct vars *, struct cvec *);
675 */
676static struct cvec *
677allmcces(v, cv)
678 struct vars *v; /* context */
679 struct cvec *cv; /* this is supposed to have enough room */
680{
681 return clearcvec(cv);
682}
683
684/*
685 - element - map collating-element name to celt
686 ^ static celt element(struct vars *, chr *, chr *);
687 */
688static celt
689element(v, startp, endp)
690 struct vars *v; /* context */
691 chr *startp; /* points to start of name */
692 chr *endp; /* points just past end of name */
693{
694 struct cname *cn;
695 size_t len;
696
697 /* generic: one-chr names stand for themselves */
698 assert(startp < endp);
699 len = endp - startp;
700 if (len == 1) {
701 return *startp;
702 }
703
704 NOTE(REG_ULOCALE);
705
706 /* search table */
707 for (cn=cnames; cn->name!=NULL; cn++) {
708 if (wxCRT_StrlenNative(cn->name)==len && wxCRT_StrncmpNative(cn->name, startp, len)==0) {
709 break; /* NOTE BREAK OUT */
710 }
711 }
712 if (cn->name != NULL) {
713 return CHR(cn->code);
714 }
715
716 /* couldn't find it */
717 ERR(REG_ECOLLATE);
718 return 0;
719}
720
721/*
722 - range - supply cvec for a range, including legality check
723 ^ static struct cvec *range(struct vars *, celt, celt, int);
724 */
725static struct cvec *
726range(v, a, b, cases)
727 struct vars *v; /* context */
728 celt a; /* range start */
729 celt b; /* range end, might equal a */
730 int cases; /* case-independent? */
731{
732 int nchrs;
733 struct cvec *cv;
734 celt c, lc, uc, tc;
735
736 if (a != b && !before(a, b)) {
737 ERR(REG_ERANGE);
738 return NULL;
739 }
740
741 if (!cases) { /* easy version */
742 cv = getcvec(v, 0, 1, 0);
743 NOERRN();
744 addrange(cv, a, b);
745 return cv;
746 }
747
748 /*
749 * When case-independent, it's hard to decide when cvec ranges are
750 * usable, so for now at least, we won't try. We allocate enough
751 * space for two case variants plus a little extra for the two
752 * title case variants.
753 */
754
755 nchrs = (b - a + 1)*2 + 4;
756
757 cv = getcvec(v, nchrs, 0, 0);
758 NOERRN();
759
760 for (c=a; c<=b; c++) {
761 addchr(cv, c);
762 lc = Tcl_UniCharToLower((chr)c);
763 uc = Tcl_UniCharToUpper((chr)c);
764 tc = Tcl_UniCharToTitle((chr)c);
765 if (c != lc) {
766 addchr(cv, lc);
767 }
768 if (c != uc) {
769 addchr(cv, uc);
770 }
771 if (c != tc && tc != uc) {
772 addchr(cv, tc);
773 }
774 }
775
776 return cv;
777}
778
779/*
780 - before - is celt x before celt y, for purposes of range legality?
781 ^ static int before(celt, celt);
782 */
783static int /* predicate */
784before(x, y)
785 celt x, y; /* collating elements */
786{
787 /* trivial because no MCCEs */
788 if (x < y) {
789 return 1;
790 }
791 return 0;
792}
793
794/*
795 - eclass - supply cvec for an equivalence class
796 * Must include case counterparts on request.
797 ^ static struct cvec *eclass(struct vars *, celt, int);
798 */
799static struct cvec *
800eclass(v, c, cases)
801 struct vars *v; /* context */
802 celt c; /* Collating element representing
803 * the equivalence class. */
804 int cases; /* all cases? */
805{
806 struct cvec *cv;
807
808 /* crude fake equivalence class for testing */
809 if ((v->cflags&REG_FAKE) && c == 'x') {
810 cv = getcvec(v, 4, 0, 0);
811 addchr(cv, (chr)'x');
812 addchr(cv, (chr)'y');
813 if (cases) {
814 addchr(cv, (chr)'X');
815 addchr(cv, (chr)'Y');
816 }
817 return cv;
818 }
819
820 /* otherwise, none */
821 if (cases) {
822 return allcases(v, c);
823 }
824 cv = getcvec(v, 1, 0, 0);
825 assert(cv != NULL);
826 addchr(cv, (chr)c);
827 return cv;
828}
829
830#if wxUSE_UNICODE
831
832/*
833 - cclass - supply cvec for a character class
834 * Must include case counterparts on request.
835 ^ static struct cvec *cclass(struct vars *, chr *, chr *, int);
836 */
837static struct cvec *
838cclass(v, startp, endp, cases)
839 struct vars *v; /* context */
840 chr *startp; /* where the name starts */
841 chr *endp; /* just past the end of the name */
842 int cases; /* case-independent? */
843{
844 size_t len;
845 struct cvec *cv = NULL;
846 CONST chr *np;
847 chr **namePtr;
848 int i, index;
849
850 /*
851 * The following arrays define the valid character class names.
852 */
853
854 static chr *classNames[] = {
855 wxT("alnum"), wxT("alpha"), wxT("ascii"), wxT("blank"), wxT("cntrl"), wxT("digit"), wxT("graph"),
856 wxT("lower"), wxT("print"), wxT("punct"), wxT("space"), wxT("upper"), wxT("xdigit"), NULL
857 };
858
859 enum classes {
860 CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
861 CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT
862 };
863
864
865 /*
866 * Extract the class name
867 */
868
869 len = endp - startp;
870 np = startp;
871
872 /*
873 * Remap lower and upper to alpha if the match is case insensitive.
874 */
875
876 if (cases && len == 5 && (wxCRT_StrncmpNative(wxT("lower"), np, 5) == 0
877 || wxCRT_StrncmpNative(wxT("upper"), np, 5) == 0)) {
878 np = wxT("alpha");
879 }
880
881 /*
882 * Map the name to the corresponding enumerated value.
883 */
884
885 index = -1;
886 for (namePtr=classNames,i=0 ; *namePtr!=NULL ; namePtr++,i++) {
887 if ((wxCRT_StrlenNative(*namePtr) == len) && (wxCRT_StrncmpNative(*namePtr, np, len) == 0)) {
888 index = i;
889 break;
890 }
891 }
892 if (index == -1) {
893 ERR(REG_ECTYPE);
894 return NULL;
895 }
896
897 /*
898 * Now compute the character class contents.
899 */
900
901 switch((enum classes) index) {
902 case CC_PRINT:
903 case CC_ALNUM:
904 cv = getcvec(v, NUM_ALPHA_CHAR, NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);
905 if (cv) {
906 for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
907 addchr(cv, alphaCharTable[i]);
908 }
909 for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
910 addrange(cv, alphaRangeTable[i].start,
911 alphaRangeTable[i].end);
912 }
913 for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
914 addrange(cv, digitRangeTable[i].start,
915 digitRangeTable[i].end);
916 }
917 }
918 break;
919 case CC_ALPHA:
920 cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);
921 if (cv) {
922 for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
923 addrange(cv, alphaRangeTable[i].start,
924 alphaRangeTable[i].end);
925 }
926 for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
927 addchr(cv, alphaCharTable[i]);
928 }
929 }
930 break;
931 case CC_ASCII:
932 cv = getcvec(v, 0, 1, 0);
933 if (cv) {
934 addrange(cv, 0, 0x7f);
935 }
936 break;
937 case CC_BLANK:
938 cv = getcvec(v, 2, 0, 0);
939 addchr(cv, '\t');
940 addchr(cv, ' ');
941 break;
942 case CC_CNTRL:
943 cv = getcvec(v, 0, 2, 0);
944 addrange(cv, 0x0, 0x1f);
945 addrange(cv, 0x7f, 0x9f);
946 break;
947 case CC_DIGIT:
948 cv = getcvec(v, 0, NUM_DIGIT_RANGE, 0);
949 if (cv) {
950 for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
951 addrange(cv, digitRangeTable[i].start,
952 digitRangeTable[i].end);
953 }
954 }
955 break;
956 case CC_PUNCT:
957 cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);
958 if (cv) {
959 for (i=0 ; i<NUM_PUNCT_RANGE ; i++) {
960 addrange(cv, punctRangeTable[i].start,
961 punctRangeTable[i].end);
962 }
963 for (i=0 ; i<NUM_PUNCT_CHAR ; i++) {
964 addchr(cv, punctCharTable[i]);
965 }
966 }
967 break;
968 case CC_XDIGIT:
969 /*
970 * This is a 3 instead of (NUM_DIGIT_RANGE+2) because I've no
971 * idea how to define the digits 'a' through 'f' in
972 * non-western locales. The concept is quite possibly non
973 * portable, or only used in contextx where the characters
974 * used would be the western ones anyway! Whatever is
975 * actually the case, the number of ranges is fixed (until
976 * someone comes up with a better arrangement!)
977 */
978 cv = getcvec(v, 0, 3, 0);
979 if (cv) {
980 addrange(cv, '0', '9');
981 addrange(cv, 'a', 'f');
982 addrange(cv, 'A', 'F');
983 }
984 break;
985 case CC_SPACE:
986 cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);
987 if (cv) {
988 for (i=0 ; i<NUM_SPACE_RANGE ; i++) {
989 addrange(cv, spaceRangeTable[i].start,
990 spaceRangeTable[i].end);
991 }
992 for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
993 addchr(cv, spaceCharTable[i]);
994 }
995 }
996 break;
997 case CC_LOWER:
998 cv = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);
999 if (cv) {
1000 for (i=0 ; i<NUM_LOWER_RANGE ; i++) {
1001 addrange(cv, lowerRangeTable[i].start,
1002 lowerRangeTable[i].end);
1003 }
1004 for (i=0 ; i<NUM_LOWER_CHAR ; i++) {
1005 addchr(cv, lowerCharTable[i]);
1006 }
1007 }
1008 break;
1009 case CC_UPPER:
1010 cv = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);
1011 if (cv) {
1012 for (i=0 ; i<NUM_UPPER_RANGE ; i++) {
1013 addrange(cv, upperRangeTable[i].start,
1014 upperRangeTable[i].end);
1015 }
1016 for (i=0 ; i<NUM_UPPER_CHAR ; i++) {
1017 addchr(cv, upperCharTable[i]);
1018 }
1019 }
1020 break;
1021 case CC_GRAPH:
1022 cv = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);
1023 if (cv) {
1024 for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
1025 addrange(cv, graphRangeTable[i].start,
1026 graphRangeTable[i].end);
1027 }
1028 for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
1029 addchr(cv, graphCharTable[i]);
1030 }
1031 }
1032 break;
1033 }
1034 if (cv == NULL) {
1035 ERR(REG_ESPACE);
1036 }
1037 return cv;
1038}
1039
1040#else /* wxUSE_UNICODE */
1041
1042static struct cvec *
1043cclass(v, startp, endp, cases)
1044struct vars *v;
1045chr *startp; /* where the name starts */
1046chr *endp; /* just past the end of the name */
1047int cases; /* case-independent? */
1048{
1049 size_t len;
1050 char *p;
1051 struct cclass *cc;
1052 struct cvec *cv;
1053 chr *np;
1054 int i;
1055 int count;
1056 char buf[256];
1057 const char *loc;
1058
1059 /* find the name */
1060 len = endp - startp;
1061 np = startp;
1062 if (cases && len == 5 && (wxCRT_StrncmpNative(wxT("lower"), np, 5) == 0 ||
1063 wxCRT_StrncmpNative(wxT("upper"), np, 5) == 0))
1064 np = wxT("alpha");
1065 for (cc = cclasses; cc->name != NULL; cc++)
1066 if (wxCRT_StrlenNative(cc->name) == len && wxCRT_StrncmpNative(cc->name, np, len) == 0)
1067 break; /* NOTE BREAK OUT */
1068 if (cc->name == NULL) {
1069 ERR(REG_ECTYPE);
1070 return NULL;
1071 }
1072
1073 loc = setlocale(LC_CTYPE, NULL);
1074
1075 if (!cc->isfunc || loc == NULL || strcmp(loc, "C") == 0)
1076 {
1077 /* set up vector */
1078 cv = getcvec(v, (int)strlen(cc->chars), 0, 0);
1079 if (cv == NULL) {
1080 ERR(REG_ESPACE);
1081 return NULL;
1082 }
1083
1084 /* fill it in */
1085 for (p = cc->chars; *p != '\0'; p++)
1086 addchr(cv, (chr)*p);
1087 }
1088 else
1089 {
1090 count = 0;
1091 for (i = 0; i < 256; i++)
1092 if (cc->isfunc(i))
1093 buf[count++] = i;
1094
1095 /* set up vector */
1096 cv = getcvec(v, count, 0, 0);
1097 if (cv == NULL) {
1098 ERR(REG_ESPACE);
1099 return NULL;
1100 }
1101
1102 /* fill it in */
1103 for (i = 0; i < count; i++)
1104 addchr(cv, buf[i]);
1105 }
1106
1107 return cv;
1108}
1109
1110#endif /* !wxUSE_UNICODE */
1111
1112
1113/*
1114 - allcases - supply cvec for all case counterparts of a chr (including itself)
1115 * This is a shortcut, preferably an efficient one, for simple characters;
1116 * messy cases are done via range().
1117 ^ static struct cvec *allcases(struct vars *, pchr);
1118 */
1119static struct cvec *
1120allcases(v, pc)
1121 struct vars *v; /* context */
1122 pchr pc; /* character to get case equivs of */
1123{
1124 struct cvec *cv;
1125 chr c = (chr)pc;
1126 chr lc, uc, tc;
1127
1128 lc = Tcl_UniCharToLower((chr)c);
1129 uc = Tcl_UniCharToUpper((chr)c);
1130 tc = Tcl_UniCharToTitle((chr)c);
1131
1132 if (tc != uc) {
1133 cv = getcvec(v, 3, 0, 0);
1134 addchr(cv, tc);
1135 } else {
1136 cv = getcvec(v, 2, 0, 0);
1137 }
1138 addchr(cv, lc);
1139 if (lc != uc) {
1140 addchr(cv, uc);
1141 }
1142 return cv;
1143}
1144
1145/*
1146 - cmp - chr-substring compare
1147 * Backrefs need this. It should preferably be efficient.
1148 * Note that it does not need to report anything except equal/unequal.
1149 * Note also that the length is exact, and the comparison should not
1150 * stop at embedded NULs!
1151 ^ static int cmp(CONST chr *, CONST chr *, size_t);
1152 */
1153static int /* 0 for equal, nonzero for unequal */
1154cmp(x, y, len)
1155 CONST chr *x, *y; /* strings to compare */
1156 size_t len; /* exact length of comparison */
1157{
1158 return memcmp(VS(x), VS(y), len*sizeof(chr));
1159}
1160
1161/*
1162 - casecmp - case-independent chr-substring compare
1163 * REG_ICASE backrefs need this. It should preferably be efficient.
1164 * Note that it does not need to report anything except equal/unequal.
1165 * Note also that the length is exact, and the comparison should not
1166 * stop at embedded NULs!
1167 ^ static int casecmp(CONST chr *, CONST chr *, size_t);
1168 */
1169static int /* 0 for equal, nonzero for unequal */
1170casecmp(x, y, len)
1171 CONST chr *x, *y; /* strings to compare */
1172 size_t len; /* exact length of comparison */
1173{
1174 for (; len > 0; len--, x++, y++) {
1175 if ((*x!=*y) && (Tcl_UniCharToLower(*x) != Tcl_UniCharToLower(*y))) {
1176 return 1;
1177 }
1178 }
1179 return 0;
1180}
wxWidgets (Impactor)