]> git.saurik.com Git - wxWidgets.git/blame - src/regex/regc_locale.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
No real changes, just use wxString::clear() instead of assignment.
[wxWidgets.git] / src / regex / regc_locale.c
CommitLineData
3ca4086b 1/*
830efc9b
RN		 2 * regc_locale.c --
3 *
3ca4086b 4 * This file contains the Unicode locale specific regexp routines.
830efc9b
RN		 5 * This file is #included by regcomp.c.
6 *
7 * Copyright (c) 1998 by Scriptics Corporation.
8 *
3ca4086b
VS		 9 * See the file "license.terms" for information on usage and redistribution
10 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
830efc9b 11 *
3ca4086b 12 * RCS: @(#) $Id$
1701c4d4 13 *
77ffb593 14 * wxWidgets:
1701c4d4 15 * The Scriptics license can be found in the file COPYRIGHT. Modifications
526954c5 16 * for wxWidgets are under the wxWindows licence, see README for details.
830efc9b
RN		 17 */
18
1ad95342 19#ifndef CONST
1701c4d4 20#define CONST const
1ad95342 21#endif
1701c4d4 22
3ca4086b 23/* ASCII character-name table */
830efc9b 24
3ca4086b 25static struct cname {
1701c4d4 26 chr *name;
3ca4086b
VS		 27 char code;
28} cnames[] = {
9a83f860
VZ		 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'},
1701c4d4 124 {NULL, 0}
3ca4086b 125};
c5feba0e 126
1701c4d4
VS		 127#if wxUSE_UNICODE
128
3ca4086b 129/* Unicode character-class tables */
c5feba0e 130
3ca4086b
VS		 131typedef struct crange {
132 chr start;
133 chr end;
134} crange;
c5feba0e 135
3ca4086b
VS		 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 */
830efc9b 141
3ca4086b
VS		 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};
830efc9b 189
3ca4086b
VS		 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
830efc9b
RN		 380};
381
3ca4086b
VS		 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
1701c4d4
VS		 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
52de37c7
VS		 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); }
1701c4d4
VS		 642
643#endif /* !wxUSE_UNICODE */
644
3ca4086b 645#define CH NOCELT
830efc9b
RN		 646
647/*
3ca4086b
VS		 648 - nmcces - how many distinct MCCEs are there?
649 ^ static int nmcces(struct vars *);
830efc9b
RN		 650 */
651static int
3ca4086b
VS		 652nmcces(v)
653 struct vars *v; /* context */
830efc9b 654{
3ca4086b
VS		 655 /*
656 * No multi-character collating elements defined at the moment.
657 */
658 return 0;
830efc9b
RN		 659}
660
661/*
3ca4086b
VS		 662 - nleaders - how many chrs can be first chrs of MCCEs?
663 ^ static int nleaders(struct vars *);
830efc9b
RN		 664 */
665static int
3ca4086b
VS		 666nleaders(v)
667 struct vars *v; /* context */
830efc9b 668{
3ca4086b 669 return 0;
830efc9b
RN		 670}
671
672/*
3ca4086b
VS		 673 - allmcces - return a cvec with all the MCCEs of the locale
674 ^ static struct cvec *allmcces(struct vars *, struct cvec *);
830efc9b
RN		 675 */
676static struct cvec *
3ca4086b
VS		 677allmcces(v, cv)
678 struct vars *v; /* context */
679 struct cvec *cv; /* this is supposed to have enough room */
830efc9b 680{
3ca4086b 681 return clearcvec(cv);
830efc9b
RN		 682}
683
684/*
3ca4086b
VS		 685 - element - map collating-element name to celt
686 ^ static celt element(struct vars *, chr *, chr *);
830efc9b
RN		 687 */
688static celt
3ca4086b
VS		 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 */
830efc9b 693{
3ca4086b
VS		 694 struct cname *cn;
695 size_t len;
3ca4086b
VS		 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 */
3ca4086b 707 for (cn=cnames; cn->name!=NULL; cn++) {
52de37c7 708 if (wxCRT_StrlenNative(cn->name)==len && wxCRT_StrncmpNative(cn->name, startp, len)==0) {
3ca4086b 709 break; /* NOTE BREAK OUT */
830efc9b 710 }
3ca4086b 711 }
3ca4086b
VS		 712 if (cn->name != NULL) {
713 return CHR(cn->code);
714 }
715
716 /* couldn't find it */
717 ERR(REG_ECOLLATE);
718 return 0;
830efc9b
RN		 719}
720
721/*
3ca4086b
VS		 722 - range - supply cvec for a range, including legality check
723 ^ static struct cvec *range(struct vars *, celt, celt, int);
830efc9b
RN		 724 */
725static struct cvec *
3ca4086b
VS		 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? */
830efc9b 731{
3ca4086b
VS		 732 int nchrs;
733 struct cvec *cv;
734 celt c, lc, uc, tc;
830efc9b 735
3ca4086b
VS		 736 if (a != b && !before(a, b)) {
737 ERR(REG_ERANGE);
738 return NULL;
739 }
830efc9b 740
3ca4086b
VS		 741 if (!cases) { /* easy version */
742 cv = getcvec(v, 0, 1, 0);
830efc9b 743 NOERRN();
3ca4086b
VS		 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);
830efc9b 773 }
3ca4086b 774 }
830efc9b 775
3ca4086b 776 return cv;
830efc9b
RN		 777}
778
779/*
3ca4086b
VS		 780 - before - is celt x before celt y, for purposes of range legality?
781 ^ static int before(celt, celt);
830efc9b 782 */
3ca4086b
VS		 783static int /* predicate */
784before(x, y)
785 celt x, y; /* collating elements */
830efc9b 786{
3ca4086b
VS		 787 /* trivial because no MCCEs */
788 if (x < y) {
789 return 1;
790 }
791 return 0;
830efc9b
RN		 792}
793
794/*
3ca4086b 795 - eclass - supply cvec for an equivalence class
830efc9b 796 * Must include case counterparts on request.
3ca4086b 797 ^ static struct cvec *eclass(struct vars *, celt, int);
830efc9b
RN		 798 */
799static struct cvec *
3ca4086b
VS		 800eclass(v, c, cases)
801 struct vars *v; /* context */
802 celt c; /* Collating element representing
803 * the equivalence class. */
804 int cases; /* all cases? */
830efc9b 805{
3ca4086b
VS		 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');
830efc9b 816 }
830efc9b 817 return cv;
3ca4086b
VS		 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;
830efc9b
RN		 828}
829
1701c4d4
VS		 830#if wxUSE_UNICODE
831
830efc9b 832/*
3ca4086b 833 - cclass - supply cvec for a character class
830efc9b 834 * Must include case counterparts on request.
3ca4086b 835 ^ static struct cvec *cclass(struct vars *, chr *, chr *, int);
830efc9b
RN		 836 */
837static struct cvec *
3ca4086b
VS		 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? */
830efc9b 843{
3ca4086b
VS		 844 size_t len;
845 struct cvec *cv = NULL;
1701c4d4
VS		 846 CONST chr *np;
847 chr **namePtr;
3ca4086b
VS		 848 int i, index;
849
850 /*
851 * The following arrays define the valid character class names.
852 */
853
1701c4d4 854 static chr *classNames[] = {
9a83f860
VZ		 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
3ca4086b
VS		 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
830efc9b 864
3ca4086b
VS		 865 /*
866 * Extract the class name
867 */
830efc9b 868
3ca4086b 869 len = endp - startp;
1701c4d4 870 np = startp;
830efc9b 871
3ca4086b
VS		 872 /*
873 * Remap lower and upper to alpha if the match is case insensitive.
874 */
830efc9b 875
9a83f860
VZ		 876 if (cases && len == 5 && (wxCRT_StrncmpNative(wxT("lower"), np, 5) == 0
877 || wxCRT_StrncmpNative(wxT("upper"), np, 5) == 0)) {
878 np = wxT("alpha");
3ca4086b 879 }
830efc9b 880
3ca4086b
VS		 881 /*
882 * Map the name to the corresponding enumerated value.
883 */
830efc9b 884
3ca4086b
VS		 885 index = -1;
886 for (namePtr=classNames,i=0 ; *namePtr!=NULL ; namePtr++,i++) {
52de37c7 887 if ((wxCRT_StrlenNative(*namePtr) == len) && (wxCRT_StrncmpNative(*namePtr, np, len) == 0)) {
3ca4086b
VS		 888 index = i;
889 break;
890 }
891 }
3ca4086b
VS		 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:
830efc9b 969 /*
3ca4086b
VS		 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!)
830efc9b 977 */
3ca4086b
VS		 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');
830efc9b 983 }
3ca4086b
VS		 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;
830efc9b
RN		 1038}
1039
1701c4d4
VS		 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;
9a83f860
VZ		 1062 if (cases && len == 5 && (wxCRT_StrncmpNative(wxT("lower"), np, 5) == 0 ||
1063 wxCRT_StrncmpNative(wxT("upper"), np, 5) == 0))
1064 np = wxT("alpha");
1701c4d4 1065 for (cc = cclasses; cc->name != NULL; cc++)
52de37c7 1066 if (wxCRT_StrlenNative(cc->name) == len && wxCRT_StrncmpNative(cc->name, np, len) == 0)
1701c4d4
VS		 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
830efc9b 1113/*
3ca4086b 1114 - allcases - supply cvec for all case counterparts of a chr (including itself)
830efc9b
RN		 1115 * This is a shortcut, preferably an efficient one, for simple characters;
1116 * messy cases are done via range().
3ca4086b 1117 ^ static struct cvec *allcases(struct vars *, pchr);
830efc9b
RN		 1118 */
1119static struct cvec *
3ca4086b
VS		 1120allcases(v, pc)
1121 struct vars *v; /* context */
1122 pchr pc; /* character to get case equivs of */
830efc9b 1123{
3ca4086b
VS		 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 {
830efc9b 1136 cv = getcvec(v, 2, 0, 0);
3ca4086b
VS		 1137 }
1138 addchr(cv, lc);
1139 if (lc != uc) {
1140 addchr(cv, uc);
1141 }
1142 return cv;
830efc9b
RN		 1143}
1144
1145/*
3ca4086b
VS		 1146 - cmp - chr-substring compare
1147 * Backrefs need this. It should preferably be efficient.
830efc9b
RN		 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!
3ca4086b 1151 ^ static int cmp(CONST chr *, CONST chr *, size_t);
830efc9b 1152 */
3ca4086b
VS		 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 */
830efc9b 1157{
3ca4086b 1158 return memcmp(VS(x), VS(y), len*sizeof(chr));
830efc9b
RN		 1159}
1160
1161/*
3ca4086b 1162 - casecmp - case-independent chr-substring compare
830efc9b
RN		 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!
3ca4086b 1167 ^ static int casecmp(CONST chr *, CONST chr *, size_t);
830efc9b 1168 */
3ca4086b
VS		 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 */
830efc9b 1173{
3ca4086b
VS		 1174 for (; len > 0; len--, x++, y++) {
1175 if ((*x!=*y) && (Tcl_UniCharToLower(*x) != Tcl_UniCharToLower(*y))) {
1176 return 1;
830efc9b 1177 }
3ca4086b
VS		 1178 }
1179 return 0;
830efc9b 1180}
wxWidgets (Impactor)