← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/lib9/utf/runetypebody-6.0.0.h

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib9/utf/runetypebody-6.0.0.h
1
 
/* generated automatically by mkrunetype.c from UnicodeData-6.0.0.txt */
2
 
 
3
 
static Rune __isspacer[] = {
4
 
        0x0009, 0x000d,
5
 
        0x0020, 0x0020,
6
 
        0x0085, 0x0085,
7
 
        0x00a0, 0x00a0,
8
 
        0x1680, 0x1680,
9
 
        0x180e, 0x180e,
10
 
        0x2000, 0x200a,
11
 
        0x2028, 0x2029,
12
 
        0x202f, 0x202f,
13
 
        0x205f, 0x205f,
14
 
        0x3000, 0x3000,
15
 
        0xfeff, 0xfeff,
16
 
};
17
 
 
18
 
int
19
 
isspacerune(Rune c)
20
 
{
21
 
        Rune *p;
22
 
 
23
 
        p = rbsearch(c, __isspacer, nelem(__isspacer)/2, 2);
24
 
        if(p && c >= p[0] && c <= p[1])
25
 
                return 1;
26
 
        return 0;
27
 
}
28
 
 
29
 
static Rune __isdigitr[] = {
30
 
        0x0030, 0x0039,
31
 
        0x0660, 0x0669,
32
 
        0x06f0, 0x06f9,
33
 
        0x07c0, 0x07c9,
34
 
        0x0966, 0x096f,
35
 
        0x09e6, 0x09ef,
36
 
        0x0a66, 0x0a6f,
37
 
        0x0ae6, 0x0aef,
38
 
        0x0b66, 0x0b6f,
39
 
        0x0be6, 0x0bef,
40
 
        0x0c66, 0x0c6f,
41
 
        0x0ce6, 0x0cef,
42
 
        0x0d66, 0x0d6f,
43
 
        0x0e50, 0x0e59,
44
 
        0x0ed0, 0x0ed9,
45
 
        0x0f20, 0x0f29,
46
 
        0x1040, 0x1049,
47
 
        0x1090, 0x1099,
48
 
        0x17e0, 0x17e9,
49
 
        0x1810, 0x1819,
50
 
        0x1946, 0x194f,
51
 
        0x19d0, 0x19d9,
52
 
        0x1a80, 0x1a89,
53
 
        0x1a90, 0x1a99,
54
 
        0x1b50, 0x1b59,
55
 
        0x1bb0, 0x1bb9,
56
 
        0x1c40, 0x1c49,
57
 
        0x1c50, 0x1c59,
58
 
        0xa620, 0xa629,
59
 
        0xa8d0, 0xa8d9,
60
 
        0xa900, 0xa909,
61
 
        0xa9d0, 0xa9d9,
62
 
        0xaa50, 0xaa59,
63
 
        0xabf0, 0xabf9,
64
 
        0xff10, 0xff19,
65
 
        0x104a0, 0x104a9,
66
 
        0x11066, 0x1106f,
67
 
        0x1d7ce, 0x1d7ff,
68
 
};
69
 
 
70
 
int
71
 
isdigitrune(Rune c)
72
 
{
73
 
        Rune *p;
74
 
 
75
 
        p = rbsearch(c, __isdigitr, nelem(__isdigitr)/2, 2);
76
 
        if(p && c >= p[0] && c <= p[1])
77
 
                return 1;
78
 
        return 0;
79
 
}
80
 
 
81
 
static Rune __isalphar[] = {
82
 
        0x0041, 0x005a,
83
 
        0x0061, 0x007a,
84
 
        0x00c0, 0x00d6,
85
 
        0x00d8, 0x00f6,
86
 
        0x00f8, 0x02c1,
87
 
        0x02c6, 0x02d1,
88
 
        0x02e0, 0x02e4,
89
 
        0x0370, 0x0374,
90
 
        0x0376, 0x0377,
91
 
        0x037a, 0x037d,
92
 
        0x0388, 0x038a,
93
 
        0x038e, 0x03a1,
94
 
        0x03a3, 0x03f5,
95
 
        0x03f7, 0x0481,
96
 
        0x048a, 0x0527,
97
 
        0x0531, 0x0556,
98
 
        0x0561, 0x0587,
99
 
        0x05d0, 0x05ea,
100
 
        0x05f0, 0x05f2,
101
 
        0x0620, 0x064a,
102
 
        0x066e, 0x066f,
103
 
        0x0671, 0x06d3,
104
 
        0x06e5, 0x06e6,
105
 
        0x06ee, 0x06ef,
106
 
        0x06fa, 0x06fc,
107
 
        0x0712, 0x072f,
108
 
        0x074d, 0x07a5,
109
 
        0x07ca, 0x07ea,
110
 
        0x07f4, 0x07f5,
111
 
        0x0800, 0x0815,
112
 
        0x0840, 0x0858,
113
 
        0x0904, 0x0939,
114
 
        0x0958, 0x0961,
115
 
        0x0971, 0x0977,
116
 
        0x0979, 0x097f,
117
 
        0x0985, 0x098c,
118
 
        0x098f, 0x0990,
119
 
        0x0993, 0x09a8,
120
 
        0x09aa, 0x09b0,
121
 
        0x09b6, 0x09b9,
122
 
        0x09dc, 0x09dd,
123
 
        0x09df, 0x09e1,
124
 
        0x09f0, 0x09f1,
125
 
        0x0a05, 0x0a0a,
126
 
        0x0a0f, 0x0a10,
127
 
        0x0a13, 0x0a28,
128
 
        0x0a2a, 0x0a30,
129
 
        0x0a32, 0x0a33,
130
 
        0x0a35, 0x0a36,
131
 
        0x0a38, 0x0a39,
132
 
        0x0a59, 0x0a5c,
133
 
        0x0a72, 0x0a74,
134
 
        0x0a85, 0x0a8d,
135
 
        0x0a8f, 0x0a91,
136
 
        0x0a93, 0x0aa8,
137
 
        0x0aaa, 0x0ab0,
138
 
        0x0ab2, 0x0ab3,
139
 
        0x0ab5, 0x0ab9,
140
 
        0x0ae0, 0x0ae1,
141
 
        0x0b05, 0x0b0c,
142
 
        0x0b0f, 0x0b10,
143
 
        0x0b13, 0x0b28,
144
 
        0x0b2a, 0x0b30,
145
 
        0x0b32, 0x0b33,
146
 
        0x0b35, 0x0b39,
147
 
        0x0b5c, 0x0b5d,
148
 
        0x0b5f, 0x0b61,
149
 
        0x0b85, 0x0b8a,
150
 
        0x0b8e, 0x0b90,
151
 
        0x0b92, 0x0b95,
152
 
        0x0b99, 0x0b9a,
153
 
        0x0b9e, 0x0b9f,
154
 
        0x0ba3, 0x0ba4,
155
 
        0x0ba8, 0x0baa,
156
 
        0x0bae, 0x0bb9,
157
 
        0x0c05, 0x0c0c,
158
 
        0x0c0e, 0x0c10,
159
 
        0x0c12, 0x0c28,
160
 
        0x0c2a, 0x0c33,
161
 
        0x0c35, 0x0c39,
162
 
        0x0c58, 0x0c59,
163
 
        0x0c60, 0x0c61,
164
 
        0x0c85, 0x0c8c,
165
 
        0x0c8e, 0x0c90,
166
 
        0x0c92, 0x0ca8,
167
 
        0x0caa, 0x0cb3,
168
 
        0x0cb5, 0x0cb9,
169
 
        0x0ce0, 0x0ce1,
170
 
        0x0cf1, 0x0cf2,
171
 
        0x0d05, 0x0d0c,
172
 
        0x0d0e, 0x0d10,
173
 
        0x0d12, 0x0d3a,
174
 
        0x0d60, 0x0d61,
175
 
        0x0d7a, 0x0d7f,
176
 
        0x0d85, 0x0d96,
177
 
        0x0d9a, 0x0db1,
178
 
        0x0db3, 0x0dbb,
179
 
        0x0dc0, 0x0dc6,
180
 
        0x0e01, 0x0e30,
181
 
        0x0e32, 0x0e33,
182
 
        0x0e40, 0x0e46,
183
 
        0x0e81, 0x0e82,
184
 
        0x0e87, 0x0e88,
185
 
        0x0e94, 0x0e97,
186
 
        0x0e99, 0x0e9f,
187
 
        0x0ea1, 0x0ea3,
188
 
        0x0eaa, 0x0eab,
189
 
        0x0ead, 0x0eb0,
190
 
        0x0eb2, 0x0eb3,
191
 
        0x0ec0, 0x0ec4,
192
 
        0x0edc, 0x0edd,
193
 
        0x0f40, 0x0f47,
194
 
        0x0f49, 0x0f6c,
195
 
        0x0f88, 0x0f8c,
196
 
        0x1000, 0x102a,
197
 
        0x1050, 0x1055,
198
 
        0x105a, 0x105d,
199
 
        0x1065, 0x1066,
200
 
        0x106e, 0x1070,
201
 
        0x1075, 0x1081,
202
 
        0x10a0, 0x10c5,
203
 
        0x10d0, 0x10fa,
204
 
        0x1100, 0x1248,
205
 
        0x124a, 0x124d,
206
 
        0x1250, 0x1256,
207
 
        0x125a, 0x125d,
208
 
        0x1260, 0x1288,
209
 
        0x128a, 0x128d,
210
 
        0x1290, 0x12b0,
211
 
        0x12b2, 0x12b5,
212
 
        0x12b8, 0x12be,
213
 
        0x12c2, 0x12c5,
214
 
        0x12c8, 0x12d6,
215
 
        0x12d8, 0x1310,
216
 
        0x1312, 0x1315,
217
 
        0x1318, 0x135a,
218
 
        0x1380, 0x138f,
219
 
        0x13a0, 0x13f4,
220
 
        0x1401, 0x166c,
221
 
        0x166f, 0x167f,
222
 
        0x1681, 0x169a,
223
 
        0x16a0, 0x16ea,
224
 
        0x1700, 0x170c,
225
 
        0x170e, 0x1711,
226
 
        0x1720, 0x1731,
227
 
        0x1740, 0x1751,
228
 
        0x1760, 0x176c,
229
 
        0x176e, 0x1770,
230
 
        0x1780, 0x17b3,
231
 
        0x1820, 0x1877,
232
 
        0x1880, 0x18a8,
233
 
        0x18b0, 0x18f5,
234
 
        0x1900, 0x191c,
235
 
        0x1950, 0x196d,
236
 
        0x1970, 0x1974,
237
 
        0x1980, 0x19ab,
238
 
        0x19c1, 0x19c7,
239
 
        0x1a00, 0x1a16,
240
 
        0x1a20, 0x1a54,
241
 
        0x1b05, 0x1b33,
242
 
        0x1b45, 0x1b4b,
243
 
        0x1b83, 0x1ba0,
244
 
        0x1bae, 0x1baf,
245
 
        0x1bc0, 0x1be5,
246
 
        0x1c00, 0x1c23,
247
 
        0x1c4d, 0x1c4f,
248
 
        0x1c5a, 0x1c7d,
249
 
        0x1ce9, 0x1cec,
250
 
        0x1cee, 0x1cf1,
251
 
        0x1d00, 0x1dbf,
252
 
        0x1e00, 0x1f15,
253
 
        0x1f18, 0x1f1d,
254
 
        0x1f20, 0x1f45,
255
 
        0x1f48, 0x1f4d,
256
 
        0x1f50, 0x1f57,
257
 
        0x1f5f, 0x1f7d,
258
 
        0x1f80, 0x1fb4,
259
 
        0x1fb6, 0x1fbc,
260
 
        0x1fc2, 0x1fc4,
261
 
        0x1fc6, 0x1fcc,
262
 
        0x1fd0, 0x1fd3,
263
 
        0x1fd6, 0x1fdb,
264
 
        0x1fe0, 0x1fec,
265
 
        0x1ff2, 0x1ff4,
266
 
        0x1ff6, 0x1ffc,
267
 
        0x2090, 0x209c,
268
 
        0x210a, 0x2113,
269
 
        0x2119, 0x211d,
270
 
        0x212a, 0x212d,
271
 
        0x212f, 0x2139,
272
 
        0x213c, 0x213f,
273
 
        0x2145, 0x2149,
274
 
        0x2183, 0x2184,
275
 
        0x2c00, 0x2c2e,
276
 
        0x2c30, 0x2c5e,
277
 
        0x2c60, 0x2ce4,
278
 
        0x2ceb, 0x2cee,
279
 
        0x2d00, 0x2d25,
280
 
        0x2d30, 0x2d65,
281
 
        0x2d80, 0x2d96,
282
 
        0x2da0, 0x2da6,
283
 
        0x2da8, 0x2dae,
284
 
        0x2db0, 0x2db6,
285
 
        0x2db8, 0x2dbe,
286
 
        0x2dc0, 0x2dc6,
287
 
        0x2dc8, 0x2dce,
288
 
        0x2dd0, 0x2dd6,
289
 
        0x2dd8, 0x2dde,
290
 
        0x3005, 0x3006,
291
 
        0x3031, 0x3035,
292
 
        0x303b, 0x303c,
293
 
        0x3041, 0x3096,
294
 
        0x309d, 0x309f,
295
 
        0x30a1, 0x30fa,
296
 
        0x30fc, 0x30ff,
297
 
        0x3105, 0x312d,
298
 
        0x3131, 0x318e,
299
 
        0x31a0, 0x31ba,
300
 
        0x31f0, 0x31ff,
301
 
        0x3400, 0x4db5,
302
 
        0x4e00, 0x9fcb,
303
 
        0xa000, 0xa48c,
304
 
        0xa4d0, 0xa4fd,
305
 
        0xa500, 0xa60c,
306
 
        0xa610, 0xa61f,
307
 
        0xa62a, 0xa62b,
308
 
        0xa640, 0xa66e,
309
 
        0xa67f, 0xa697,
310
 
        0xa6a0, 0xa6e5,
311
 
        0xa717, 0xa71f,
312
 
        0xa722, 0xa788,
313
 
        0xa78b, 0xa78e,
314
 
        0xa790, 0xa791,
315
 
        0xa7a0, 0xa7a9,
316
 
        0xa7fa, 0xa801,
317
 
        0xa803, 0xa805,
318
 
        0xa807, 0xa80a,
319
 
        0xa80c, 0xa822,
320
 
        0xa840, 0xa873,
321
 
        0xa882, 0xa8b3,
322
 
        0xa8f2, 0xa8f7,
323
 
        0xa90a, 0xa925,
324
 
        0xa930, 0xa946,
325
 
        0xa960, 0xa97c,
326
 
        0xa984, 0xa9b2,
327
 
        0xaa00, 0xaa28,
328
 
        0xaa40, 0xaa42,
329
 
        0xaa44, 0xaa4b,
330
 
        0xaa60, 0xaa76,
331
 
        0xaa80, 0xaaaf,
332
 
        0xaab5, 0xaab6,
333
 
        0xaab9, 0xaabd,
334
 
        0xaadb, 0xaadd,
335
 
        0xab01, 0xab06,
336
 
        0xab09, 0xab0e,
337
 
        0xab11, 0xab16,
338
 
        0xab20, 0xab26,
339
 
        0xab28, 0xab2e,
340
 
        0xabc0, 0xabe2,
341
 
        0xac00, 0xd7a3,
342
 
        0xd7b0, 0xd7c6,
343
 
        0xd7cb, 0xd7fb,
344
 
        0xf900, 0xfa2d,
345
 
        0xfa30, 0xfa6d,
346
 
        0xfa70, 0xfad9,
347
 
        0xfb00, 0xfb06,
348
 
        0xfb13, 0xfb17,
349
 
        0xfb1f, 0xfb28,
350
 
        0xfb2a, 0xfb36,
351
 
        0xfb38, 0xfb3c,
352
 
        0xfb40, 0xfb41,
353
 
        0xfb43, 0xfb44,
354
 
        0xfb46, 0xfbb1,
355
 
        0xfbd3, 0xfd3d,
356
 
        0xfd50, 0xfd8f,
357
 
        0xfd92, 0xfdc7,
358
 
        0xfdf0, 0xfdfb,
359
 
        0xfe70, 0xfe74,
360
 
        0xfe76, 0xfefc,
361
 
        0xff21, 0xff3a,
362
 
        0xff41, 0xff5a,
363
 
        0xff66, 0xffbe,
364
 
        0xffc2, 0xffc7,
365
 
        0xffca, 0xffcf,
366
 
        0xffd2, 0xffd7,
367
 
        0xffda, 0xffdc,
368
 
        0x10000, 0x1000b,
369
 
        0x1000d, 0x10026,
370
 
        0x10028, 0x1003a,
371
 
        0x1003c, 0x1003d,
372
 
        0x1003f, 0x1004d,
373
 
        0x10050, 0x1005d,
374
 
        0x10080, 0x100fa,
375
 
        0x10280, 0x1029c,
376
 
        0x102a0, 0x102d0,
377
 
        0x10300, 0x1031e,
378
 
        0x10330, 0x10340,
379
 
        0x10342, 0x10349,
380
 
        0x10380, 0x1039d,
381
 
        0x103a0, 0x103c3,
382
 
        0x103c8, 0x103cf,
383
 
        0x10400, 0x1049d,
384
 
        0x10800, 0x10805,
385
 
        0x1080a, 0x10835,
386
 
        0x10837, 0x10838,
387
 
        0x1083f, 0x10855,
388
 
        0x10900, 0x10915,
389
 
        0x10920, 0x10939,
390
 
        0x10a10, 0x10a13,
391
 
        0x10a15, 0x10a17,
392
 
        0x10a19, 0x10a33,
393
 
        0x10a60, 0x10a7c,
394
 
        0x10b00, 0x10b35,
395
 
        0x10b40, 0x10b55,
396
 
        0x10b60, 0x10b72,
397
 
        0x10c00, 0x10c48,
398
 
        0x11003, 0x11037,
399
 
        0x11083, 0x110af,
400
 
        0x12000, 0x1236e,
401
 
        0x13000, 0x1342e,
402
 
        0x16800, 0x16a38,
403
 
        0x1b000, 0x1b001,
404
 
        0x1d400, 0x1d454,
405
 
        0x1d456, 0x1d49c,
406
 
        0x1d49e, 0x1d49f,
407
 
        0x1d4a5, 0x1d4a6,
408
 
        0x1d4a9, 0x1d4ac,
409
 
        0x1d4ae, 0x1d4b9,
410
 
        0x1d4bd, 0x1d4c3,
411
 
        0x1d4c5, 0x1d505,
412
 
        0x1d507, 0x1d50a,
413
 
        0x1d50d, 0x1d514,
414
 
        0x1d516, 0x1d51c,
415
 
        0x1d51e, 0x1d539,
416
 
        0x1d53b, 0x1d53e,
417
 
        0x1d540, 0x1d544,
418
 
        0x1d54a, 0x1d550,
419
 
        0x1d552, 0x1d6a5,
420
 
        0x1d6a8, 0x1d6c0,
421
 
        0x1d6c2, 0x1d6da,
422
 
        0x1d6dc, 0x1d6fa,
423
 
        0x1d6fc, 0x1d714,
424
 
        0x1d716, 0x1d734,
425
 
        0x1d736, 0x1d74e,
426
 
        0x1d750, 0x1d76e,
427
 
        0x1d770, 0x1d788,
428
 
        0x1d78a, 0x1d7a8,
429
 
        0x1d7aa, 0x1d7c2,
430
 
        0x1d7c4, 0x1d7cb,
431
 
        0x20000, 0x2a6d6,
432
 
        0x2a700, 0x2b734,
433
 
        0x2b740, 0x2b81d,
434
 
        0x2f800, 0x2fa1d,
435
 
};
436
 
 
437
 
static Rune __isalphas[] = {
438
 
        0x00aa,
439
 
        0x00b5,
440
 
        0x00ba,
441
 
        0x02ec,
442
 
        0x02ee,
443
 
        0x0386,
444
 
        0x038c,
445
 
        0x0559,
446
 
        0x06d5,
447
 
        0x06ff,
448
 
        0x0710,
449
 
        0x07b1,
450
 
        0x07fa,
451
 
        0x081a,
452
 
        0x0824,
453
 
        0x0828,
454
 
        0x093d,
455
 
        0x0950,
456
 
        0x09b2,
457
 
        0x09bd,
458
 
        0x09ce,
459
 
        0x0a5e,
460
 
        0x0abd,
461
 
        0x0ad0,
462
 
        0x0b3d,
463
 
        0x0b71,
464
 
        0x0b83,
465
 
        0x0b9c,
466
 
        0x0bd0,
467
 
        0x0c3d,
468
 
        0x0cbd,
469
 
        0x0cde,
470
 
        0x0d3d,
471
 
        0x0d4e,
472
 
        0x0dbd,
473
 
        0x0e84,
474
 
        0x0e8a,
475
 
        0x0e8d,
476
 
        0x0ea5,
477
 
        0x0ea7,
478
 
        0x0ebd,
479
 
        0x0ec6,
480
 
        0x0f00,
481
 
        0x103f,
482
 
        0x1061,
483
 
        0x108e,
484
 
        0x10fc,
485
 
        0x1258,
486
 
        0x12c0,
487
 
        0x17d7,
488
 
        0x17dc,
489
 
        0x18aa,
490
 
        0x1aa7,
491
 
        0x1f59,
492
 
        0x1f5b,
493
 
        0x1f5d,
494
 
        0x1fbe,
495
 
        0x2071,
496
 
        0x207f,
497
 
        0x2102,
498
 
        0x2107,
499
 
        0x2115,
500
 
        0x2124,
501
 
        0x2126,
502
 
        0x2128,
503
 
        0x214e,
504
 
        0x2d6f,
505
 
        0x2e2f,
506
 
        0xa8fb,
507
 
        0xa9cf,
508
 
        0xaa7a,
509
 
        0xaab1,
510
 
        0xaac0,
511
 
        0xaac2,
512
 
        0xfb1d,
513
 
        0xfb3e,
514
 
        0x10808,
515
 
        0x1083c,
516
 
        0x10a00,
517
 
        0x1d4a2,
518
 
        0x1d4bb,
519
 
        0x1d546,
520
 
};
521
 
 
522
 
int
523
 
isalpharune(Rune c)
524
 
{
525
 
        Rune *p;
526
 
 
527
 
        p = rbsearch(c, __isalphar, nelem(__isalphar)/2, 2);
528
 
        if(p && c >= p[0] && c <= p[1])
529
 
                return 1;
530
 
        p = rbsearch(c, __isalphas, nelem(__isalphas), 1);
531
 
        if(p && c == p[0])
532
 
                return 1;
533
 
        return 0;
534
 
}
535
 
 
536
 
static Rune __isupperr[] = {
537
 
        0x0041, 0x005a,
538
 
        0x00c0, 0x00d6,
539
 
        0x00d8, 0x00de,
540
 
        0x0178, 0x0179,
541
 
        0x0181, 0x0182,
542
 
        0x0186, 0x0187,
543
 
        0x0189, 0x018b,
544
 
        0x018e, 0x0191,
545
 
        0x0193, 0x0194,
546
 
        0x0196, 0x0198,
547
 
        0x019c, 0x019d,
548
 
        0x019f, 0x01a0,
549
 
        0x01a6, 0x01a7,
550
 
        0x01ae, 0x01af,
551
 
        0x01b1, 0x01b3,
552
 
        0x01b7, 0x01b8,
553
 
        0x01f6, 0x01f8,
554
 
        0x023a, 0x023b,
555
 
        0x023d, 0x023e,
556
 
        0x0243, 0x0246,
557
 
        0x0388, 0x038a,
558
 
        0x038e, 0x038f,
559
 
        0x0391, 0x03a1,
560
 
        0x03a3, 0x03ab,
561
 
        0x03d2, 0x03d4,
562
 
        0x03f9, 0x03fa,
563
 
        0x03fd, 0x042f,
564
 
        0x04c0, 0x04c1,
565
 
        0x0531, 0x0556,
566
 
        0x10a0, 0x10c5,
567
 
        0x1f08, 0x1f0f,
568
 
        0x1f18, 0x1f1d,
569
 
        0x1f28, 0x1f2f,
570
 
        0x1f38, 0x1f3f,
571
 
        0x1f48, 0x1f4d,
572
 
        0x1f68, 0x1f6f,
573
 
        0x1f88, 0x1f8f,
574
 
        0x1f98, 0x1f9f,
575
 
        0x1fa8, 0x1faf,
576
 
        0x1fb8, 0x1fbc,
577
 
        0x1fc8, 0x1fcc,
578
 
        0x1fd8, 0x1fdb,
579
 
        0x1fe8, 0x1fec,
580
 
        0x1ff8, 0x1ffc,
581
 
        0x210b, 0x210d,
582
 
        0x2110, 0x2112,
583
 
        0x2119, 0x211d,
584
 
        0x212a, 0x212d,
585
 
        0x2130, 0x2133,
586
 
        0x213e, 0x213f,
587
 
        0x2160, 0x216f,
588
 
        0x24b6, 0x24cf,
589
 
        0x2c00, 0x2c2e,
590
 
        0x2c62, 0x2c64,
591
 
        0x2c6d, 0x2c70,
592
 
        0x2c7e, 0x2c80,
593
 
        0xa77d, 0xa77e,
594
 
        0xff21, 0xff3a,
595
 
        0x10400, 0x10427,
596
 
        0x1d400, 0x1d419,
597
 
        0x1d434, 0x1d44d,
598
 
        0x1d468, 0x1d481,
599
 
        0x1d49e, 0x1d49f,
600
 
        0x1d4a5, 0x1d4a6,
601
 
        0x1d4a9, 0x1d4ac,
602
 
        0x1d4ae, 0x1d4b5,
603
 
        0x1d4d0, 0x1d4e9,
604
 
        0x1d504, 0x1d505,
605
 
        0x1d507, 0x1d50a,
606
 
        0x1d50d, 0x1d514,
607
 
        0x1d516, 0x1d51c,
608
 
        0x1d538, 0x1d539,
609
 
        0x1d53b, 0x1d53e,
610
 
        0x1d540, 0x1d544,
611
 
        0x1d54a, 0x1d550,
612
 
        0x1d56c, 0x1d585,
613
 
        0x1d5a0, 0x1d5b9,
614
 
        0x1d5d4, 0x1d5ed,
615
 
        0x1d608, 0x1d621,
616
 
        0x1d63c, 0x1d655,
617
 
        0x1d670, 0x1d689,
618
 
        0x1d6a8, 0x1d6c0,
619
 
        0x1d6e2, 0x1d6fa,
620
 
        0x1d71c, 0x1d734,
621
 
        0x1d756, 0x1d76e,
622
 
        0x1d790, 0x1d7a8,
623
 
};
624
 
 
625
 
static Rune __isupperp[] = {
626
 
        0x0100, 0x0136,
627
 
        0x0139, 0x0147,
628
 
        0x014a, 0x0176,
629
 
        0x017b, 0x017d,
630
 
        0x01a2, 0x01a4,
631
 
        0x01cd, 0x01db,
632
 
        0x01de, 0x01ee,
633
 
        0x01fa, 0x0232,
634
 
        0x0248, 0x024e,
635
 
        0x0370, 0x0372,
636
 
        0x03d8, 0x03ee,
637
 
        0x0460, 0x0480,
638
 
        0x048a, 0x04be,
639
 
        0x04c3, 0x04cd,
640
 
        0x04d0, 0x0526,
641
 
        0x1e00, 0x1e94,
642
 
        0x1e9e, 0x1efe,
643
 
        0x1f59, 0x1f5f,
644
 
        0x2124, 0x2128,
645
 
        0x2c67, 0x2c6b,
646
 
        0x2c82, 0x2ce2,
647
 
        0x2ceb, 0x2ced,
648
 
        0xa640, 0xa66c,
649
 
        0xa680, 0xa696,
650
 
        0xa722, 0xa72e,
651
 
        0xa732, 0xa76e,
652
 
        0xa779, 0xa77b,
653
 
        0xa780, 0xa786,
654
 
        0xa78b, 0xa78d,
655
 
        0xa7a0, 0xa7a8,
656
 
};
657
 
 
658
 
static Rune __isuppers[] = {
659
 
        0x0184,
660
 
        0x01a9,
661
 
        0x01ac,
662
 
        0x01b5,
663
 
        0x01bc,
664
 
        0x01c4,
665
 
        0x01c7,
666
 
        0x01ca,
667
 
        0x01f1,
668
 
        0x01f4,
669
 
        0x0241,
670
 
        0x0376,
671
 
        0x0386,
672
 
        0x038c,
673
 
        0x03cf,
674
 
        0x03f4,
675
 
        0x03f7,
676
 
        0x2102,
677
 
        0x2107,
678
 
        0x2115,
679
 
        0x2145,
680
 
        0x2183,
681
 
        0x2c60,
682
 
        0x2c72,
683
 
        0x2c75,
684
 
        0xa790,
685
 
        0x1d49c,
686
 
        0x1d4a2,
687
 
        0x1d546,
688
 
        0x1d7ca,
689
 
};
690
 
 
691
 
int
692
 
isupperrune(Rune c)
693
 
{
694
 
        Rune *p;
695
 
 
696
 
        p = rbsearch(c, __isupperr, nelem(__isupperr)/2, 2);
697
 
        if(p && c >= p[0] && c <= p[1])
698
 
                return 1;
699
 
        p = rbsearch(c, __isupperp, nelem(__isupperp)/2, 2);
700
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
701
 
                return 1;
702
 
        p = rbsearch(c, __isuppers, nelem(__isuppers), 1);
703
 
        if(p && c == p[0])
704
 
                return 1;
705
 
        return 0;
706
 
}
707
 
 
708
 
static Rune __islowerr[] = {
709
 
        0x0061, 0x007a,
710
 
        0x00df, 0x00f6,
711
 
        0x00f8, 0x00ff,
712
 
        0x0137, 0x0138,
713
 
        0x0148, 0x0149,
714
 
        0x017e, 0x0180,
715
 
        0x018c, 0x018d,
716
 
        0x0199, 0x019b,
717
 
        0x01aa, 0x01ab,
718
 
        0x01b9, 0x01ba,
719
 
        0x01bd, 0x01bf,
720
 
        0x01dc, 0x01dd,
721
 
        0x01ef, 0x01f0,
722
 
        0x0233, 0x0239,
723
 
        0x023f, 0x0240,
724
 
        0x024f, 0x0293,
725
 
        0x0295, 0x02af,
726
 
        0x037b, 0x037d,
727
 
        0x03ac, 0x03ce,
728
 
        0x03d0, 0x03d1,
729
 
        0x03d5, 0x03d7,
730
 
        0x03ef, 0x03f3,
731
 
        0x03fb, 0x03fc,
732
 
        0x0430, 0x045f,
733
 
        0x04ce, 0x04cf,
734
 
        0x0561, 0x0587,
735
 
        0x1d00, 0x1d2b,
736
 
        0x1d62, 0x1d77,
737
 
        0x1d79, 0x1d9a,
738
 
        0x1e95, 0x1e9d,
739
 
        0x1eff, 0x1f07,
740
 
        0x1f10, 0x1f15,
741
 
        0x1f20, 0x1f27,
742
 
        0x1f30, 0x1f37,
743
 
        0x1f40, 0x1f45,
744
 
        0x1f50, 0x1f57,
745
 
        0x1f60, 0x1f67,
746
 
        0x1f70, 0x1f7d,
747
 
        0x1f80, 0x1f87,
748
 
        0x1f90, 0x1f97,
749
 
        0x1fa0, 0x1fa7,
750
 
        0x1fb0, 0x1fb4,
751
 
        0x1fb6, 0x1fb7,
752
 
        0x1fc2, 0x1fc4,
753
 
        0x1fc6, 0x1fc7,
754
 
        0x1fd0, 0x1fd3,
755
 
        0x1fd6, 0x1fd7,
756
 
        0x1fe0, 0x1fe7,
757
 
        0x1ff2, 0x1ff4,
758
 
        0x1ff6, 0x1ff7,
759
 
        0x210e, 0x210f,
760
 
        0x213c, 0x213d,
761
 
        0x2146, 0x2149,
762
 
        0x2170, 0x217f,
763
 
        0x24d0, 0x24e9,
764
 
        0x2c30, 0x2c5e,
765
 
        0x2c65, 0x2c66,
766
 
        0x2c73, 0x2c74,
767
 
        0x2c76, 0x2c7c,
768
 
        0x2ce3, 0x2ce4,
769
 
        0x2d00, 0x2d25,
770
 
        0xa72f, 0xa731,
771
 
        0xa771, 0xa778,
772
 
        0xfb00, 0xfb06,
773
 
        0xfb13, 0xfb17,
774
 
        0xff41, 0xff5a,
775
 
        0x10428, 0x1044f,
776
 
        0x1d41a, 0x1d433,
777
 
        0x1d44e, 0x1d454,
778
 
        0x1d456, 0x1d467,
779
 
        0x1d482, 0x1d49b,
780
 
        0x1d4b6, 0x1d4b9,
781
 
        0x1d4bd, 0x1d4c3,
782
 
        0x1d4c5, 0x1d4cf,
783
 
        0x1d4ea, 0x1d503,
784
 
        0x1d51e, 0x1d537,
785
 
        0x1d552, 0x1d56b,
786
 
        0x1d586, 0x1d59f,
787
 
        0x1d5ba, 0x1d5d3,
788
 
        0x1d5ee, 0x1d607,
789
 
        0x1d622, 0x1d63b,
790
 
        0x1d656, 0x1d66f,
791
 
        0x1d68a, 0x1d6a5,
792
 
        0x1d6c2, 0x1d6da,
793
 
        0x1d6dc, 0x1d6e1,
794
 
        0x1d6fc, 0x1d714,
795
 
        0x1d716, 0x1d71b,
796
 
        0x1d736, 0x1d74e,
797
 
        0x1d750, 0x1d755,
798
 
        0x1d770, 0x1d788,
799
 
        0x1d78a, 0x1d78f,
800
 
        0x1d7aa, 0x1d7c2,
801
 
        0x1d7c4, 0x1d7c9,
802
 
};
803
 
 
804
 
static Rune __islowerp[] = {
805
 
        0x0101, 0x0135,
806
 
        0x013a, 0x0146,
807
 
        0x014b, 0x0177,
808
 
        0x017a, 0x017c,
809
 
        0x0183, 0x0185,
810
 
        0x01a1, 0x01a5,
811
 
        0x01b4, 0x01b6,
812
 
        0x01cc, 0x01da,
813
 
        0x01df, 0x01ed,
814
 
        0x01f3, 0x01f5,
815
 
        0x01f9, 0x0231,
816
 
        0x0247, 0x024d,
817
 
        0x0371, 0x0373,
818
 
        0x03d9, 0x03ed,
819
 
        0x0461, 0x0481,
820
 
        0x048b, 0x04bf,
821
 
        0x04c2, 0x04cc,
822
 
        0x04d1, 0x0527,
823
 
        0x1e01, 0x1e93,
824
 
        0x1e9f, 0x1efd,
825
 
        0x2c68, 0x2c6c,
826
 
        0x2c81, 0x2ce1,
827
 
        0x2cec, 0x2cee,
828
 
        0xa641, 0xa66d,
829
 
        0xa681, 0xa697,
830
 
        0xa723, 0xa72d,
831
 
        0xa733, 0xa76f,
832
 
        0xa77a, 0xa77c,
833
 
        0xa77f, 0xa787,
834
 
        0xa78c, 0xa78e,
835
 
        0xa7a1, 0xa7a9,
836
 
};
837
 
 
838
 
static Rune __islowers[] = {
839
 
        0x00aa,
840
 
        0x00b5,
841
 
        0x00ba,
842
 
        0x0188,
843
 
        0x0192,
844
 
        0x0195,
845
 
        0x019e,
846
 
        0x01a8,
847
 
        0x01ad,
848
 
        0x01b0,
849
 
        0x01c6,
850
 
        0x01c9,
851
 
        0x023c,
852
 
        0x0242,
853
 
        0x0377,
854
 
        0x0390,
855
 
        0x03f5,
856
 
        0x03f8,
857
 
        0x1fbe,
858
 
        0x210a,
859
 
        0x2113,
860
 
        0x212f,
861
 
        0x2134,
862
 
        0x2139,
863
 
        0x214e,
864
 
        0x2184,
865
 
        0x2c61,
866
 
        0x2c71,
867
 
        0xa791,
868
 
        0xa7fa,
869
 
        0x1d4bb,
870
 
        0x1d7cb,
871
 
};
872
 
 
873
 
int
874
 
islowerrune(Rune c)
875
 
{
876
 
        Rune *p;
877
 
 
878
 
        p = rbsearch(c, __islowerr, nelem(__islowerr)/2, 2);
879
 
        if(p && c >= p[0] && c <= p[1])
880
 
                return 1;
881
 
        p = rbsearch(c, __islowerp, nelem(__islowerp)/2, 2);
882
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
883
 
                return 1;
884
 
        p = rbsearch(c, __islowers, nelem(__islowers), 1);
885
 
        if(p && c == p[0])
886
 
                return 1;
887
 
        return 0;
888
 
}
889
 
 
890
 
static Rune __istitler[] = {
891
 
        0x0041, 0x005a,
892
 
        0x00c0, 0x00d6,
893
 
        0x00d8, 0x00de,
894
 
        0x0178, 0x0179,
895
 
        0x0181, 0x0182,
896
 
        0x0186, 0x0187,
897
 
        0x0189, 0x018b,
898
 
        0x018e, 0x0191,
899
 
        0x0193, 0x0194,
900
 
        0x0196, 0x0198,
901
 
        0x019c, 0x019d,
902
 
        0x019f, 0x01a0,
903
 
        0x01a6, 0x01a7,
904
 
        0x01ae, 0x01af,
905
 
        0x01b1, 0x01b3,
906
 
        0x01b7, 0x01b8,
907
 
        0x01f6, 0x01f8,
908
 
        0x023a, 0x023b,
909
 
        0x023d, 0x023e,
910
 
        0x0243, 0x0246,
911
 
        0x0388, 0x038a,
912
 
        0x038e, 0x038f,
913
 
        0x0391, 0x03a1,
914
 
        0x03a3, 0x03ab,
915
 
        0x03f9, 0x03fa,
916
 
        0x03fd, 0x042f,
917
 
        0x04c0, 0x04c1,
918
 
        0x0531, 0x0556,
919
 
        0x10a0, 0x10c5,
920
 
        0x1f08, 0x1f0f,
921
 
        0x1f18, 0x1f1d,
922
 
        0x1f28, 0x1f2f,
923
 
        0x1f38, 0x1f3f,
924
 
        0x1f48, 0x1f4d,
925
 
        0x1f68, 0x1f6f,
926
 
        0x1f88, 0x1f8f,
927
 
        0x1f98, 0x1f9f,
928
 
        0x1fa8, 0x1faf,
929
 
        0x1fb8, 0x1fbc,
930
 
        0x1fc8, 0x1fcc,
931
 
        0x1fd8, 0x1fdb,
932
 
        0x1fe8, 0x1fec,
933
 
        0x1ff8, 0x1ffc,
934
 
        0x2160, 0x216f,
935
 
        0x24b6, 0x24cf,
936
 
        0x2c00, 0x2c2e,
937
 
        0x2c62, 0x2c64,
938
 
        0x2c6d, 0x2c70,
939
 
        0x2c7e, 0x2c80,
940
 
        0xa77d, 0xa77e,
941
 
        0xff21, 0xff3a,
942
 
        0x10400, 0x10427,
943
 
};
944
 
 
945
 
static Rune __istitlep[] = {
946
 
        0x0100, 0x012e,
947
 
        0x0132, 0x0136,
948
 
        0x0139, 0x0147,
949
 
        0x014a, 0x0176,
950
 
        0x017b, 0x017d,
951
 
        0x01a2, 0x01a4,
952
 
        0x01cb, 0x01db,
953
 
        0x01de, 0x01ee,
954
 
        0x01f2, 0x01f4,
955
 
        0x01fa, 0x0232,
956
 
        0x0248, 0x024e,
957
 
        0x0370, 0x0372,
958
 
        0x03d8, 0x03ee,
959
 
        0x0460, 0x0480,
960
 
        0x048a, 0x04be,
961
 
        0x04c3, 0x04cd,
962
 
        0x04d0, 0x0526,
963
 
        0x1e00, 0x1e94,
964
 
        0x1ea0, 0x1efe,
965
 
        0x1f59, 0x1f5f,
966
 
        0x2c67, 0x2c6b,
967
 
        0x2c82, 0x2ce2,
968
 
        0x2ceb, 0x2ced,
969
 
        0xa640, 0xa66c,
970
 
        0xa680, 0xa696,
971
 
        0xa722, 0xa72e,
972
 
        0xa732, 0xa76e,
973
 
        0xa779, 0xa77b,
974
 
        0xa780, 0xa786,
975
 
        0xa78b, 0xa78d,
976
 
        0xa7a0, 0xa7a8,
977
 
};
978
 
 
979
 
static Rune __istitles[] = {
980
 
        0x0184,
981
 
        0x01a9,
982
 
        0x01ac,
983
 
        0x01b5,
984
 
        0x01bc,
985
 
        0x01c5,
986
 
        0x01c8,
987
 
        0x0241,
988
 
        0x0376,
989
 
        0x0386,
990
 
        0x038c,
991
 
        0x03cf,
992
 
        0x03f7,
993
 
        0x2132,
994
 
        0x2183,
995
 
        0x2c60,
996
 
        0x2c72,
997
 
        0x2c75,
998
 
        0xa790,
999
 
};
1000
 
 
1001
 
int
1002
 
istitlerune(Rune c)
1003
 
{
1004
 
        Rune *p;
1005
 
 
1006
 
        p = rbsearch(c, __istitler, nelem(__istitler)/2, 2);
1007
 
        if(p && c >= p[0] && c <= p[1])
1008
 
                return 1;
1009
 
        p = rbsearch(c, __istitlep, nelem(__istitlep)/2, 2);
1010
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
1011
 
                return 1;
1012
 
        p = rbsearch(c, __istitles, nelem(__istitles), 1);
1013
 
        if(p && c == p[0])
1014
 
                return 1;
1015
 
        return 0;
1016
 
}
1017
 
 
1018
 
static Rune __toupperr[] = {
1019
 
        0x0061, 0x007a, 1048544,
1020
 
        0x00e0, 0x00f6, 1048544,
1021
 
        0x00f8, 0x00fe, 1048544,
1022
 
        0x023f, 0x0240, 1059391,
1023
 
        0x0256, 0x0257, 1048371,
1024
 
        0x028a, 0x028b, 1048359,
1025
 
        0x037b, 0x037d, 1048706,
1026
 
        0x03ad, 0x03af, 1048539,
1027
 
        0x03b1, 0x03c1, 1048544,
1028
 
        0x03c3, 0x03cb, 1048544,
1029
 
        0x03cd, 0x03ce, 1048513,
1030
 
        0x0430, 0x044f, 1048544,
1031
 
        0x0450, 0x045f, 1048496,
1032
 
        0x0561, 0x0586, 1048528,
1033
 
        0x1f00, 0x1f07, 1048584,
1034
 
        0x1f10, 0x1f15, 1048584,
1035
 
        0x1f20, 0x1f27, 1048584,
1036
 
        0x1f30, 0x1f37, 1048584,
1037
 
        0x1f40, 0x1f45, 1048584,
1038
 
        0x1f60, 0x1f67, 1048584,
1039
 
        0x1f70, 0x1f71, 1048650,
1040
 
        0x1f72, 0x1f75, 1048662,
1041
 
        0x1f76, 0x1f77, 1048676,
1042
 
        0x1f78, 0x1f79, 1048704,
1043
 
        0x1f7a, 0x1f7b, 1048688,
1044
 
        0x1f7c, 0x1f7d, 1048702,
1045
 
        0x1f80, 0x1f87, 1048584,
1046
 
        0x1f90, 0x1f97, 1048584,
1047
 
        0x1fa0, 0x1fa7, 1048584,
1048
 
        0x1fb0, 0x1fb1, 1048584,
1049
 
        0x1fd0, 0x1fd1, 1048584,
1050
 
        0x1fe0, 0x1fe1, 1048584,
1051
 
        0x2170, 0x217f, 1048560,
1052
 
        0x24d0, 0x24e9, 1048550,
1053
 
        0x2c30, 0x2c5e, 1048528,
1054
 
        0x2d00, 0x2d25, 1041312,
1055
 
        0xff41, 0xff5a, 1048544,
1056
 
        0x10428, 0x1044f, 1048536,
1057
 
};
1058
 
 
1059
 
static Rune __toupperp[] = {
1060
 
        0x0101, 0x012f, 1048575,
1061
 
        0x0133, 0x0137, 1048575,
1062
 
        0x013a, 0x0148, 1048575,
1063
 
        0x014b, 0x0177, 1048575,
1064
 
        0x017a, 0x017e, 1048575,
1065
 
        0x0183, 0x0185, 1048575,
1066
 
        0x01a1, 0x01a5, 1048575,
1067
 
        0x01b4, 0x01b6, 1048575,
1068
 
        0x01ce, 0x01dc, 1048575,
1069
 
        0x01df, 0x01ef, 1048575,
1070
 
        0x01f9, 0x021f, 1048575,
1071
 
        0x0223, 0x0233, 1048575,
1072
 
        0x0247, 0x024f, 1048575,
1073
 
        0x0371, 0x0373, 1048575,
1074
 
        0x03d9, 0x03ef, 1048575,
1075
 
        0x0461, 0x0481, 1048575,
1076
 
        0x048b, 0x04bf, 1048575,
1077
 
        0x04c2, 0x04ce, 1048575,
1078
 
        0x04d1, 0x0527, 1048575,
1079
 
        0x1e01, 0x1e95, 1048575,
1080
 
        0x1ea1, 0x1eff, 1048575,
1081
 
        0x1f51, 0x1f57, 1048584,
1082
 
        0x2c68, 0x2c6c, 1048575,
1083
 
        0x2c81, 0x2ce3, 1048575,
1084
 
        0x2cec, 0x2cee, 1048575,
1085
 
        0xa641, 0xa66d, 1048575,
1086
 
        0xa681, 0xa697, 1048575,
1087
 
        0xa723, 0xa72f, 1048575,
1088
 
        0xa733, 0xa76f, 1048575,
1089
 
        0xa77a, 0xa77c, 1048575,
1090
 
        0xa77f, 0xa787, 1048575,
1091
 
        0xa7a1, 0xa7a9, 1048575,
1092
 
};
1093
 
 
1094
 
static Rune __touppers[] = {
1095
 
        0x00b5, 1049319,
1096
 
        0x00ff, 1048697,
1097
 
        0x0131, 1048344,
1098
 
        0x017f, 1048276,
1099
 
        0x0180, 1048771,
1100
 
        0x0188, 1048575,
1101
 
        0x018c, 1048575,
1102
 
        0x0192, 1048575,
1103
 
        0x0195, 1048673,
1104
 
        0x0199, 1048575,
1105
 
        0x019a, 1048739,
1106
 
        0x019e, 1048706,
1107
 
        0x01a8, 1048575,
1108
 
        0x01ad, 1048575,
1109
 
        0x01b0, 1048575,
1110
 
        0x01b9, 1048575,
1111
 
        0x01bd, 1048575,
1112
 
        0x01bf, 1048632,
1113
 
        0x01c5, 1048575,
1114
 
        0x01c6, 1048574,
1115
 
        0x01c8, 1048575,
1116
 
        0x01c9, 1048574,
1117
 
        0x01cb, 1048575,
1118
 
        0x01cc, 1048574,
1119
 
        0x01dd, 1048497,
1120
 
        0x01f2, 1048575,
1121
 
        0x01f3, 1048574,
1122
 
        0x01f5, 1048575,
1123
 
        0x023c, 1048575,
1124
 
        0x0242, 1048575,
1125
 
        0x0250, 1059359,
1126
 
        0x0251, 1059356,
1127
 
        0x0252, 1059358,
1128
 
        0x0253, 1048366,
1129
 
        0x0254, 1048370,
1130
 
        0x0259, 1048374,
1131
 
        0x025b, 1048373,
1132
 
        0x0260, 1048371,
1133
 
        0x0263, 1048369,
1134
 
        0x0265, 1090856,
1135
 
        0x0268, 1048367,
1136
 
        0x0269, 1048365,
1137
 
        0x026b, 1059319,
1138
 
        0x026f, 1048365,
1139
 
        0x0271, 1059325,
1140
 
        0x0272, 1048363,
1141
 
        0x0275, 1048362,
1142
 
        0x027d, 1059303,
1143
 
        0x0280, 1048358,
1144
 
        0x0283, 1048358,
1145
 
        0x0288, 1048358,
1146
 
        0x0289, 1048507,
1147
 
        0x028c, 1048505,
1148
 
        0x0292, 1048357,
1149
 
        0x0345, 1048660,
1150
 
        0x0377, 1048575,
1151
 
        0x03ac, 1048538,
1152
 
        0x03c2, 1048545,
1153
 
        0x03cc, 1048512,
1154
 
        0x03d0, 1048514,
1155
 
        0x03d1, 1048519,
1156
 
        0x03d5, 1048529,
1157
 
        0x03d6, 1048522,
1158
 
        0x03d7, 1048568,
1159
 
        0x03f0, 1048490,
1160
 
        0x03f1, 1048496,
1161
 
        0x03f2, 1048583,
1162
 
        0x03f5, 1048480,
1163
 
        0x03f8, 1048575,
1164
 
        0x03fb, 1048575,
1165
 
        0x04cf, 1048561,
1166
 
        0x1d79, 1083908,
1167
 
        0x1d7d, 1052390,
1168
 
        0x1e9b, 1048517,
1169
 
        0x1fb3, 1048585,
1170
 
        0x1fbe, 1041371,
1171
 
        0x1fc3, 1048585,
1172
 
        0x1fe5, 1048583,
1173
 
        0x1ff3, 1048585,
1174
 
        0x214e, 1048548,
1175
 
        0x2184, 1048575,
1176
 
        0x2c61, 1048575,
1177
 
        0x2c65, 1037781,
1178
 
        0x2c66, 1037784,
1179
 
        0x2c73, 1048575,
1180
 
        0x2c76, 1048575,
1181
 
        0xa78c, 1048575,
1182
 
        0xa791, 1048575,
1183
 
};
1184
 
 
1185
 
Rune
1186
 
toupperrune(Rune c)
1187
 
{
1188
 
        Rune *p;
1189
 
 
1190
 
        p = rbsearch(c, __toupperr, nelem(__toupperr)/3, 3);
1191
 
        if(p && c >= p[0] && c <= p[1])
1192
 
                return c + p[2] - 1048576;
1193
 
        p = rbsearch(c, __toupperp, nelem(__toupperp)/3, 3);
1194
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
1195
 
                return c + p[2] - 1048576;
1196
 
        p = rbsearch(c, __touppers, nelem(__touppers)/2, 2);
1197
 
        if(p && c == p[0])
1198
 
                return c + p[1] - 1048576;
1199
 
        return c;
1200
 
}
1201
 
 
1202
 
static Rune __tolowerr[] = {
1203
 
        0x0041, 0x005a, 1048608,
1204
 
        0x00c0, 0x00d6, 1048608,
1205
 
        0x00d8, 0x00de, 1048608,
1206
 
        0x0189, 0x018a, 1048781,
1207
 
        0x01b1, 0x01b2, 1048793,
1208
 
        0x0388, 0x038a, 1048613,
1209
 
        0x038e, 0x038f, 1048639,
1210
 
        0x0391, 0x03a1, 1048608,
1211
 
        0x03a3, 0x03ab, 1048608,
1212
 
        0x03fd, 0x03ff, 1048446,
1213
 
        0x0400, 0x040f, 1048656,
1214
 
        0x0410, 0x042f, 1048608,
1215
 
        0x0531, 0x0556, 1048624,
1216
 
        0x10a0, 0x10c5, 1055840,
1217
 
        0x1f08, 0x1f0f, 1048568,
1218
 
        0x1f18, 0x1f1d, 1048568,
1219
 
        0x1f28, 0x1f2f, 1048568,
1220
 
        0x1f38, 0x1f3f, 1048568,
1221
 
        0x1f48, 0x1f4d, 1048568,
1222
 
        0x1f68, 0x1f6f, 1048568,
1223
 
        0x1f88, 0x1f8f, 1048568,
1224
 
        0x1f98, 0x1f9f, 1048568,
1225
 
        0x1fa8, 0x1faf, 1048568,
1226
 
        0x1fb8, 0x1fb9, 1048568,
1227
 
        0x1fba, 0x1fbb, 1048502,
1228
 
        0x1fc8, 0x1fcb, 1048490,
1229
 
        0x1fd8, 0x1fd9, 1048568,
1230
 
        0x1fda, 0x1fdb, 1048476,
1231
 
        0x1fe8, 0x1fe9, 1048568,
1232
 
        0x1fea, 0x1feb, 1048464,
1233
 
        0x1ff8, 0x1ff9, 1048448,
1234
 
        0x1ffa, 0x1ffb, 1048450,
1235
 
        0x2160, 0x216f, 1048592,
1236
 
        0x24b6, 0x24cf, 1048602,
1237
 
        0x2c00, 0x2c2e, 1048624,
1238
 
        0x2c7e, 0x2c7f, 1037761,
1239
 
        0xff21, 0xff3a, 1048608,
1240
 
        0x10400, 0x10427, 1048616,
1241
 
};
1242
 
 
1243
 
static Rune __tolowerp[] = {
1244
 
        0x0100, 0x012e, 1048577,
1245
 
        0x0132, 0x0136, 1048577,
1246
 
        0x0139, 0x0147, 1048577,
1247
 
        0x014a, 0x0176, 1048577,
1248
 
        0x017b, 0x017d, 1048577,
1249
 
        0x01a2, 0x01a4, 1048577,
1250
 
        0x01b3, 0x01b5, 1048577,
1251
 
        0x01cd, 0x01db, 1048577,
1252
 
        0x01de, 0x01ee, 1048577,
1253
 
        0x01f8, 0x021e, 1048577,
1254
 
        0x0222, 0x0232, 1048577,
1255
 
        0x0248, 0x024e, 1048577,
1256
 
        0x0370, 0x0372, 1048577,
1257
 
        0x03d8, 0x03ee, 1048577,
1258
 
        0x0460, 0x0480, 1048577,
1259
 
        0x048a, 0x04be, 1048577,
1260
 
        0x04c3, 0x04cd, 1048577,
1261
 
        0x04d0, 0x0526, 1048577,
1262
 
        0x1e00, 0x1e94, 1048577,
1263
 
        0x1ea0, 0x1efe, 1048577,
1264
 
        0x1f59, 0x1f5f, 1048568,
1265
 
        0x2c67, 0x2c6b, 1048577,
1266
 
        0x2c80, 0x2ce2, 1048577,
1267
 
        0x2ceb, 0x2ced, 1048577,
1268
 
        0xa640, 0xa66c, 1048577,
1269
 
        0xa680, 0xa696, 1048577,
1270
 
        0xa722, 0xa72e, 1048577,
1271
 
        0xa732, 0xa76e, 1048577,
1272
 
        0xa779, 0xa77b, 1048577,
1273
 
        0xa780, 0xa786, 1048577,
1274
 
        0xa7a0, 0xa7a8, 1048577,
1275
 
};
1276
 
 
1277
 
static Rune __tolowers[] = {
1278
 
        0x0130, 1048377,
1279
 
        0x0178, 1048455,
1280
 
        0x0179, 1048577,
1281
 
        0x0181, 1048786,
1282
 
        0x0182, 1048577,
1283
 
        0x0184, 1048577,
1284
 
        0x0186, 1048782,
1285
 
        0x0187, 1048577,
1286
 
        0x018b, 1048577,
1287
 
        0x018e, 1048655,
1288
 
        0x018f, 1048778,
1289
 
        0x0190, 1048779,
1290
 
        0x0191, 1048577,
1291
 
        0x0193, 1048781,
1292
 
        0x0194, 1048783,
1293
 
        0x0196, 1048787,
1294
 
        0x0197, 1048785,
1295
 
        0x0198, 1048577,
1296
 
        0x019c, 1048787,
1297
 
        0x019d, 1048789,
1298
 
        0x019f, 1048790,
1299
 
        0x01a0, 1048577,
1300
 
        0x01a6, 1048794,
1301
 
        0x01a7, 1048577,
1302
 
        0x01a9, 1048794,
1303
 
        0x01ac, 1048577,
1304
 
        0x01ae, 1048794,
1305
 
        0x01af, 1048577,
1306
 
        0x01b7, 1048795,
1307
 
        0x01b8, 1048577,
1308
 
        0x01bc, 1048577,
1309
 
        0x01c4, 1048578,
1310
 
        0x01c5, 1048577,
1311
 
        0x01c7, 1048578,
1312
 
        0x01c8, 1048577,
1313
 
        0x01ca, 1048578,
1314
 
        0x01cb, 1048577,
1315
 
        0x01f1, 1048578,
1316
 
        0x01f2, 1048577,
1317
 
        0x01f4, 1048577,
1318
 
        0x01f6, 1048479,
1319
 
        0x01f7, 1048520,
1320
 
        0x0220, 1048446,
1321
 
        0x023a, 1059371,
1322
 
        0x023b, 1048577,
1323
 
        0x023d, 1048413,
1324
 
        0x023e, 1059368,
1325
 
        0x0241, 1048577,
1326
 
        0x0243, 1048381,
1327
 
        0x0244, 1048645,
1328
 
        0x0245, 1048647,
1329
 
        0x0246, 1048577,
1330
 
        0x0376, 1048577,
1331
 
        0x0386, 1048614,
1332
 
        0x038c, 1048640,
1333
 
        0x03cf, 1048584,
1334
 
        0x03f4, 1048516,
1335
 
        0x03f7, 1048577,
1336
 
        0x03f9, 1048569,
1337
 
        0x03fa, 1048577,
1338
 
        0x04c0, 1048591,
1339
 
        0x04c1, 1048577,
1340
 
        0x1e9e, 1040961,
1341
 
        0x1fbc, 1048567,
1342
 
        0x1fcc, 1048567,
1343
 
        0x1fec, 1048569,
1344
 
        0x1ffc, 1048567,
1345
 
        0x2126, 1041059,
1346
 
        0x212a, 1040193,
1347
 
        0x212b, 1040314,
1348
 
        0x2132, 1048604,
1349
 
        0x2183, 1048577,
1350
 
        0x2c60, 1048577,
1351
 
        0x2c62, 1037833,
1352
 
        0x2c63, 1044762,
1353
 
        0x2c64, 1037849,
1354
 
        0x2c6d, 1037796,
1355
 
        0x2c6e, 1037827,
1356
 
        0x2c6f, 1037793,
1357
 
        0x2c70, 1037794,
1358
 
        0x2c72, 1048577,
1359
 
        0x2c75, 1048577,
1360
 
        0xa77d, 1013244,
1361
 
        0xa77e, 1048577,
1362
 
        0xa78b, 1048577,
1363
 
        0xa78d, 1006296,
1364
 
        0xa790, 1048577,
1365
 
};
1366
 
 
1367
 
Rune
1368
 
tolowerrune(Rune c)
1369
 
{
1370
 
        Rune *p;
1371
 
 
1372
 
        p = rbsearch(c, __tolowerr, nelem(__tolowerr)/3, 3);
1373
 
        if(p && c >= p[0] && c <= p[1])
1374
 
                return c + p[2] - 1048576;
1375
 
        p = rbsearch(c, __tolowerp, nelem(__tolowerp)/3, 3);
1376
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
1377
 
                return c + p[2] - 1048576;
1378
 
        p = rbsearch(c, __tolowers, nelem(__tolowers)/2, 2);
1379
 
        if(p && c == p[0])
1380
 
                return c + p[1] - 1048576;
1381
 
        return c;
1382
 
}
1383
 
 
1384
 
static Rune __totitler[] = {
1385
 
        0x0061, 0x007a, 1048544,
1386
 
        0x00e0, 0x00f6, 1048544,
1387
 
        0x00f8, 0x00fe, 1048544,
1388
 
        0x023f, 0x0240, 1059391,
1389
 
        0x0256, 0x0257, 1048371,
1390
 
        0x028a, 0x028b, 1048359,
1391
 
        0x037b, 0x037d, 1048706,
1392
 
        0x03ad, 0x03af, 1048539,
1393
 
        0x03b1, 0x03c1, 1048544,
1394
 
        0x03c3, 0x03cb, 1048544,
1395
 
        0x03cd, 0x03ce, 1048513,
1396
 
        0x0430, 0x044f, 1048544,
1397
 
        0x0450, 0x045f, 1048496,
1398
 
        0x0561, 0x0586, 1048528,
1399
 
        0x1f00, 0x1f07, 1048584,
1400
 
        0x1f10, 0x1f15, 1048584,
1401
 
        0x1f20, 0x1f27, 1048584,
1402
 
        0x1f30, 0x1f37, 1048584,
1403
 
        0x1f40, 0x1f45, 1048584,
1404
 
        0x1f60, 0x1f67, 1048584,
1405
 
        0x1f70, 0x1f71, 1048650,
1406
 
        0x1f72, 0x1f75, 1048662,
1407
 
        0x1f76, 0x1f77, 1048676,
1408
 
        0x1f78, 0x1f79, 1048704,
1409
 
        0x1f7a, 0x1f7b, 1048688,
1410
 
        0x1f7c, 0x1f7d, 1048702,
1411
 
        0x1f80, 0x1f87, 1048584,
1412
 
        0x1f90, 0x1f97, 1048584,
1413
 
        0x1fa0, 0x1fa7, 1048584,
1414
 
        0x1fb0, 0x1fb1, 1048584,
1415
 
        0x1fd0, 0x1fd1, 1048584,
1416
 
        0x1fe0, 0x1fe1, 1048584,
1417
 
        0x2170, 0x217f, 1048560,
1418
 
        0x24d0, 0x24e9, 1048550,
1419
 
        0x2c30, 0x2c5e, 1048528,
1420
 
        0x2d00, 0x2d25, 1041312,
1421
 
        0xff41, 0xff5a, 1048544,
1422
 
        0x10428, 0x1044f, 1048536,
1423
 
};
1424
 
 
1425
 
static Rune __totitlep[] = {
1426
 
        0x0101, 0x012f, 1048575,
1427
 
        0x0133, 0x0137, 1048575,
1428
 
        0x013a, 0x0148, 1048575,
1429
 
        0x014b, 0x0177, 1048575,
1430
 
        0x017a, 0x017e, 1048575,
1431
 
        0x0183, 0x0185, 1048575,
1432
 
        0x01a1, 0x01a5, 1048575,
1433
 
        0x01b4, 0x01b6, 1048575,
1434
 
        0x01cc, 0x01dc, 1048575,
1435
 
        0x01df, 0x01ef, 1048575,
1436
 
        0x01f3, 0x01f5, 1048575,
1437
 
        0x01f9, 0x021f, 1048575,
1438
 
        0x0223, 0x0233, 1048575,
1439
 
        0x0247, 0x024f, 1048575,
1440
 
        0x0371, 0x0373, 1048575,
1441
 
        0x03d9, 0x03ef, 1048575,
1442
 
        0x0461, 0x0481, 1048575,
1443
 
        0x048b, 0x04bf, 1048575,
1444
 
        0x04c2, 0x04ce, 1048575,
1445
 
        0x04d1, 0x0527, 1048575,
1446
 
        0x1e01, 0x1e95, 1048575,
1447
 
        0x1ea1, 0x1eff, 1048575,
1448
 
        0x1f51, 0x1f57, 1048584,
1449
 
        0x2c68, 0x2c6c, 1048575,
1450
 
        0x2c81, 0x2ce3, 1048575,
1451
 
        0x2cec, 0x2cee, 1048575,
1452
 
        0xa641, 0xa66d, 1048575,
1453
 
        0xa681, 0xa697, 1048575,
1454
 
        0xa723, 0xa72f, 1048575,
1455
 
        0xa733, 0xa76f, 1048575,
1456
 
        0xa77a, 0xa77c, 1048575,
1457
 
        0xa77f, 0xa787, 1048575,
1458
 
        0xa7a1, 0xa7a9, 1048575,
1459
 
};
1460
 
 
1461
 
static Rune __totitles[] = {
1462
 
        0x00b5, 1049319,
1463
 
        0x00ff, 1048697,
1464
 
        0x0131, 1048344,
1465
 
        0x017f, 1048276,
1466
 
        0x0180, 1048771,
1467
 
        0x0188, 1048575,
1468
 
        0x018c, 1048575,
1469
 
        0x0192, 1048575,
1470
 
        0x0195, 1048673,
1471
 
        0x0199, 1048575,
1472
 
        0x019a, 1048739,
1473
 
        0x019e, 1048706,
1474
 
        0x01a8, 1048575,
1475
 
        0x01ad, 1048575,
1476
 
        0x01b0, 1048575,
1477
 
        0x01b9, 1048575,
1478
 
        0x01bd, 1048575,
1479
 
        0x01bf, 1048632,
1480
 
        0x01c4, 1048577,
1481
 
        0x01c6, 1048575,
1482
 
        0x01c7, 1048577,
1483
 
        0x01c9, 1048575,
1484
 
        0x01ca, 1048577,
1485
 
        0x01dd, 1048497,
1486
 
        0x01f1, 1048577,
1487
 
        0x023c, 1048575,
1488
 
        0x0242, 1048575,
1489
 
        0x0250, 1059359,
1490
 
        0x0251, 1059356,
1491
 
        0x0252, 1059358,
1492
 
        0x0253, 1048366,
1493
 
        0x0254, 1048370,
1494
 
        0x0259, 1048374,
1495
 
        0x025b, 1048373,
1496
 
        0x0260, 1048371,
1497
 
        0x0263, 1048369,
1498
 
        0x0265, 1090856,
1499
 
        0x0268, 1048367,
1500
 
        0x0269, 1048365,
1501
 
        0x026b, 1059319,
1502
 
        0x026f, 1048365,
1503
 
        0x0271, 1059325,
1504
 
        0x0272, 1048363,
1505
 
        0x0275, 1048362,
1506
 
        0x027d, 1059303,
1507
 
        0x0280, 1048358,
1508
 
        0x0283, 1048358,
1509
 
        0x0288, 1048358,
1510
 
        0x0289, 1048507,
1511
 
        0x028c, 1048505,
1512
 
        0x0292, 1048357,
1513
 
        0x0345, 1048660,
1514
 
        0x0377, 1048575,
1515
 
        0x03ac, 1048538,
1516
 
        0x03c2, 1048545,
1517
 
        0x03cc, 1048512,
1518
 
        0x03d0, 1048514,
1519
 
        0x03d1, 1048519,
1520
 
        0x03d5, 1048529,
1521
 
        0x03d6, 1048522,
1522
 
        0x03d7, 1048568,
1523
 
        0x03f0, 1048490,
1524
 
        0x03f1, 1048496,
1525
 
        0x03f2, 1048583,
1526
 
        0x03f5, 1048480,
1527
 
        0x03f8, 1048575,
1528
 
        0x03fb, 1048575,
1529
 
        0x04cf, 1048561,
1530
 
        0x1d79, 1083908,
1531
 
        0x1d7d, 1052390,
1532
 
        0x1e9b, 1048517,
1533
 
        0x1fb3, 1048585,
1534
 
        0x1fbe, 1041371,
1535
 
        0x1fc3, 1048585,
1536
 
        0x1fe5, 1048583,
1537
 
        0x1ff3, 1048585,
1538
 
        0x214e, 1048548,
1539
 
        0x2184, 1048575,
1540
 
        0x2c61, 1048575,
1541
 
        0x2c65, 1037781,
1542
 
        0x2c66, 1037784,
1543
 
        0x2c73, 1048575,
1544
 
        0x2c76, 1048575,
1545
 
        0xa78c, 1048575,
1546
 
        0xa791, 1048575,
1547
 
};
1548
 
 
1549
 
Rune
1550
 
totitlerune(Rune c)
1551
 
{
1552
 
        Rune *p;
1553
 
 
1554
 
        p = rbsearch(c, __totitler, nelem(__totitler)/3, 3);
1555
 
        if(p && c >= p[0] && c <= p[1])
1556
 
                return c + p[2] - 1048576;
1557
 
        p = rbsearch(c, __totitlep, nelem(__totitlep)/3, 3);
1558
 
        if(p && c >= p[0] && c <= p[1] && !((c - p[0]) & 1))
1559
 
                return c + p[2] - 1048576;
1560
 
        p = rbsearch(c, __totitles, nelem(__totitles)/2, 2);
1561
 
        if(p && c == p[0])
1562
 
                return c + p[1] - 1048576;
1563
 
        return c;
1564
 
}
1565