1 /*
2 * Copyright (C) 2012 Grigori Goronzy <greg@kinoho.net>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include "ucdn.h"
20
21 typedef struct {
22 unsigned char category;
23 unsigned char combining;
24 unsigned char bidi_class;
25 unsigned char mirrored;
26 unsigned char east_asian_width;
27 unsigned char normalization_check;
28 unsigned char script;
29 } UCDRecord;
30
31 typedef struct {
32 unsigned short from, to;
33 } MirrorPair;
34
35 typedef struct {
36 unsigned int start;
37 short count, index;
38 } Reindex;
39
40 #include "unicodedata_db.h"
41
42 /* constants required for Hangul (de)composition */
43 #define SBASE 0xAC00
44 #define LBASE 0x1100
45 #define VBASE 0x1161
46 #define TBASE 0x11A7
47 #define SCOUNT 11172
48 #define LCOUNT 19
49 #define VCOUNT 21
50 #define TCOUNT 28
51 #define NCOUNT (VCOUNT * TCOUNT)
52
get_ucd_record(uint32_t code)53 static const UCDRecord *get_ucd_record(uint32_t code)
54 {
55 int index, offset;
56
57 if (code >= 0x110000)
58 index = 0;
59 else {
60 index = index0[code >> (SHIFT1+SHIFT2)] << SHIFT1;
61 offset = (code >> SHIFT2) & ((1<<SHIFT1) - 1);
62 index = index1[index + offset] << SHIFT2;
63 offset = code & ((1<<SHIFT2) - 1);
64 index = index2[index + offset];
65 }
66
67 return &ucd_records[index];
68 }
69
get_decomp_record(uint32_t code)70 static const unsigned short *get_decomp_record(uint32_t code)
71 {
72 int index, offset;
73
74 if (code >= 0x110000)
75 index = 0;
76 else {
77 index = decomp_index0[code >> (DECOMP_SHIFT1+DECOMP_SHIFT2)]
78 << DECOMP_SHIFT1;
79 offset = (code >> DECOMP_SHIFT2) & ((1<<DECOMP_SHIFT1) - 1);
80 index = decomp_index1[index + offset] << DECOMP_SHIFT2;
81 offset = code & ((1<<DECOMP_SHIFT2) - 1);
82 index = decomp_index2[index + offset];
83 }
84
85 return &decomp_data[index];
86 }
87
get_comp_index(uint32_t code,const Reindex * idx)88 static int get_comp_index(uint32_t code, const Reindex *idx)
89 {
90 int i;
91
92 for (i = 0; idx[i].start; i++) {
93 const Reindex *cur = &idx[i];
94 if (code < cur->start)
95 return -1;
96 if (code <= cur->start + cur->count) {
97 return cur->index + (code - cur->start);
98 }
99 }
100
101 return -1;
102 }
103
compare_mp(const void * a,const void * b)104 static int compare_mp(const void *a, const void *b)
105 {
106 MirrorPair *mpa = (MirrorPair *)a;
107 MirrorPair *mpb = (MirrorPair *)b;
108 return mpa->from - mpb->from;
109 }
110
hangul_pair_decompose(uint32_t code,uint32_t * a,uint32_t * b)111 static int hangul_pair_decompose(uint32_t code, uint32_t *a, uint32_t *b)
112 {
113 int si = code - SBASE;
114
115 if (si < 0 || si >= SCOUNT)
116 return 0;
117
118 if (si % TCOUNT) {
119 /* LV,T */
120 *a = SBASE + (si / TCOUNT) * TCOUNT;
121 *b = TBASE + (si % TCOUNT);
122 return 3;
123 } else {
124 /* L,V */
125 *a = LBASE + (si / NCOUNT);
126 *b = VBASE + (si % NCOUNT) / TCOUNT;
127 return 2;
128 }
129 }
130
hangul_pair_compose(uint32_t * code,uint32_t a,uint32_t b)131 static int hangul_pair_compose(uint32_t *code, uint32_t a, uint32_t b)
132 {
133 if (b < VBASE || b >= (TBASE + TCOUNT))
134 return 0;
135
136 if ((a < LBASE || a >= (LBASE + LCOUNT))
137 && (a < SBASE || a >= (SBASE + SCOUNT)))
138 return 0;
139
140 if (a >= SBASE) {
141 /* LV,T */
142 *code = a + (b - TBASE);
143 return 3;
144 } else {
145 /* L,V */
146 int li = a - LBASE;
147 int vi = b - VBASE;
148 *code = SBASE + li * NCOUNT + vi * TCOUNT;
149 return 2;
150 }
151 }
152
decode_utf16(const unsigned short ** code_ptr)153 static uint32_t decode_utf16(const unsigned short **code_ptr)
154 {
155 const unsigned short *code = *code_ptr;
156
157 if ((code[0] & 0xd800) != 0xd800) {
158 *code_ptr += 1;
159 return (uint32_t)code[0];
160 } else {
161 *code_ptr += 2;
162 return 0x10000 + ((uint32_t)code[1] - 0xdc00) +
163 (((uint32_t)code[0] - 0xd800) << 10);
164 }
165 }
166
ucdn_get_unicode_version(void)167 const char *ucdn_get_unicode_version(void)
168 {
169 return UNIDATA_VERSION;
170 }
171
ucdn_get_combining_class(uint32_t code)172 int ucdn_get_combining_class(uint32_t code)
173 {
174 return get_ucd_record(code)->combining;
175 }
176
ucdn_get_east_asian_width(uint32_t code)177 int ucdn_get_east_asian_width(uint32_t code)
178 {
179 return get_ucd_record(code)->east_asian_width;
180 }
181
ucdn_get_general_category(uint32_t code)182 int ucdn_get_general_category(uint32_t code)
183 {
184 return get_ucd_record(code)->category;
185 }
186
ucdn_get_bidi_class(uint32_t code)187 int ucdn_get_bidi_class(uint32_t code)
188 {
189 return get_ucd_record(code)->bidi_class;
190 }
191
ucdn_get_mirrored(uint32_t code)192 int ucdn_get_mirrored(uint32_t code)
193 {
194 return get_ucd_record(code)->mirrored;
195 }
196
ucdn_get_script(uint32_t code)197 int ucdn_get_script(uint32_t code)
198 {
199 return get_ucd_record(code)->script;
200 }
201
ucdn_mirror(uint32_t code)202 uint32_t ucdn_mirror(uint32_t code)
203 {
204 MirrorPair mp = {0};
205 MirrorPair *res;
206
207 if (get_ucd_record(code)->mirrored == 0)
208 return code;
209
210 mp.from = code;
211 res = bsearch(&mp, mirror_pairs, BIDI_MIRROR_LEN, sizeof(MirrorPair),
212 compare_mp);
213
214 if (res == NULL)
215 return code;
216 else
217 return res->to;
218 }
219
ucdn_decompose(uint32_t code,uint32_t * a,uint32_t * b)220 int ucdn_decompose(uint32_t code, uint32_t *a, uint32_t *b)
221 {
222 const unsigned short *rec;
223 int len;
224
225 if (hangul_pair_decompose(code, a, b))
226 return 1;
227
228 rec = get_decomp_record(code);
229 len = rec[0] >> 8;
230
231 if ((rec[0] & 0xff) != 0 || len == 0)
232 return 0;
233
234 rec++;
235 *a = decode_utf16(&rec);
236 if (len > 1)
237 *b = decode_utf16(&rec);
238 else
239 *b = 0;
240
241 return 1;
242 }
243
ucdn_compose(uint32_t * code,uint32_t a,uint32_t b)244 int ucdn_compose(uint32_t *code, uint32_t a, uint32_t b)
245 {
246 int l, r, index, indexi, offset;
247
248 if (hangul_pair_compose(code, a, b))
249 return 1;
250
251 l = get_comp_index(a, nfc_first);
252 r = get_comp_index(b, nfc_last);
253
254 if (l < 0 || r < 0)
255 return 0;
256
257 indexi = l * TOTAL_LAST + r;
258 index = comp_index0[indexi >> (COMP_SHIFT1+COMP_SHIFT2)] << COMP_SHIFT1;
259 offset = (indexi >> COMP_SHIFT2) & ((1<<COMP_SHIFT1) - 1);
260 index = comp_index1[index + offset] << COMP_SHIFT2;
261 offset = indexi & ((1<<COMP_SHIFT2) - 1);
262 *code = comp_data[index + offset];
263
264 return *code != 0;
265 }
266
ucdn_compat_decompose(uint32_t code,uint32_t * decomposed)267 int ucdn_compat_decompose(uint32_t code, uint32_t *decomposed)
268 {
269 int i, len;
270 const unsigned short *rec = get_decomp_record(code);
271 len = rec[0] >> 8;
272
273 if (len == 0)
274 return 0;
275
276 rec++;
277 for (i = 0; i < len; i++)
278 decomposed[i] = decode_utf16(&rec);
279
280 return len;
281 }
282