1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
#include <wctype.h>
static const unsigned char tab[];
static const unsigned char rulebases[512];
static const int rules[];
static const unsigned char exceptions[][2];
#include "casemap.h"
static int casemap(unsigned c, int dir)
{
unsigned b, x, y, v, rt, xb, xn;
int r, rd, c0 = c;
if (c >= 0x20000) return c;
b = c>>8;
c &= 255;
x = c/3;
y = c%3;
/* lookup entry in two-level base-6 table */
v = tab[tab[b]*86+x];
static const int mt[] = { 2048, 342, 57 };
v = (v*mt[y]>>11)%6;
/* use the bit vector out of the tables as an index into
* a block-specific set of rules and decode the rule into
* a type and a case-mapping delta. */
r = rules[rulebases[b]+v];
rt = r & 255;
rd = r >> 8;
/* rules 0/1 are simple lower/upper case with a delta.
* apply according to desired mapping direction. */
if (rt < 2) return c0 + (rd & -(rt^dir));
/* binary search. endpoints of the binary search for
* this block are stored in the rule delta field. */
xn = rd & 0xff;
xb = (unsigned)rd >> 8;
while (xn) {
unsigned try = exceptions[xb+xn/2][0];
if (try == c) {
r = rules[exceptions[xb+xn/2][1]];
rt = r & 255;
rd = r >> 8;
if (rt < 2) return c0 + (rd & -(rt^dir));
/* Hard-coded for the four exceptional titlecase */
return c0 + (dir ? -1 : 1);
} else if (try > c) {
xn /= 2;
} else {
xb += xn/2;
xn -= xn/2;
}
}
return c0;
}
wint_t towlower(wint_t wc)
{
return casemap(wc, 0);
}
wint_t towupper(wint_t wc)
{
return casemap(wc, 1);
}
wint_t __towupper_l(wint_t c, locale_t l)
{
return towupper(c);
}
wint_t __towlower_l(wint_t c, locale_t l)
{
return towlower(c);
}
weak_alias(__towupper_l, towupper_l);
weak_alias(__towlower_l, towlower_l);
|
