]>
Commit | Line | Data |
---|---|---|
9b26f5c4 | 1 | /* Conversion from and to CP1255. |
d4697bc9 | 2 | Copyright (C) 1998-2014 Free Software Foundation, Inc. |
9b26f5c4 | 3 | This file is part of the GNU C Library. |
2373b30e UD |
4 | Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998, |
5 | and Bruno Haible <haible@clisp.cons.org>, 2001. | |
9b26f5c4 UD |
6 | |
7 | The GNU C Library is free software; you can redistribute it and/or | |
41bdb6e2 AJ |
8 | modify it under the terms of the GNU Lesser General Public |
9 | License as published by the Free Software Foundation; either | |
10 | version 2.1 of the License, or (at your option) any later version. | |
9b26f5c4 UD |
11 | |
12 | The GNU C Library is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
41bdb6e2 | 15 | Lesser General Public License for more details. |
9b26f5c4 | 16 | |
41bdb6e2 | 17 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 PE |
18 | License along with the GNU C Library; if not, see |
19 | <http://www.gnu.org/licenses/>. */ | |
9b26f5c4 | 20 | |
2373b30e | 21 | #include <dlfcn.h> |
9b26f5c4 | 22 | #include <stdint.h> |
2373b30e | 23 | #include <assert.h> |
9b26f5c4 | 24 | |
2373b30e | 25 | #define NELEMS(arr) (sizeof (arr) / sizeof (arr[0])) |
9b26f5c4 | 26 | |
2373b30e UD |
27 | /* Definitions used in the body of the `gconv' function. */ |
28 | #define CHARSET_NAME "CP1255//" | |
29 | #define FROM_LOOP from_cp1255 | |
30 | #define TO_LOOP to_cp1255 | |
31 | #define DEFINE_INIT 1 | |
32 | #define DEFINE_FINI 1 | |
faaa6f62 UD |
33 | #define FROM_LOOP_MIN_NEEDED_FROM 1 |
34 | #define FROM_LOOP_MAX_NEEDED_FROM 1 | |
35 | #define FROM_LOOP_MIN_NEEDED_TO 4 | |
36 | #define FROM_LOOP_MAX_NEEDED_TO 4 | |
37 | #define TO_LOOP_MIN_NEEDED_FROM 4 | |
38 | #define TO_LOOP_MAX_NEEDED_FROM 4 | |
39 | #define TO_LOOP_MIN_NEEDED_TO 1 | |
40 | #define TO_LOOP_MAX_NEEDED_TO 3 | |
2373b30e UD |
41 | #define PREPARE_LOOP \ |
42 | int saved_state; \ | |
43 | int *statep = &data->__statep->__count; | |
44 | #define EXTRA_LOOP_ARGS , statep | |
9b26f5c4 | 45 | |
2373b30e UD |
46 | |
47 | /* Since we might have to reset input pointer we must be able to save | |
48 | and restore the state. */ | |
49 | #define SAVE_RESET_STATE(Save) \ | |
50 | if (Save) \ | |
51 | saved_state = *statep; \ | |
52 | else \ | |
53 | *statep = saved_state | |
54 | ||
55 | ||
56 | /* During CP1255 to UCS4 conversion, the COUNT element of the state | |
57 | contains the last UCS4 character, shifted by 3 bits. */ | |
58 | ||
59 | ||
60 | /* Since this is a stateful encoding we have to provide code which resets | |
61 | the output state to the initial state. This has to be done during the | |
62 | flushing. */ | |
63 | #define EMIT_SHIFT_TO_INIT \ | |
64 | if (data->__statep->__count != 0) \ | |
65 | { \ | |
66 | if (FROM_DIRECTION) \ | |
67 | { \ | |
a1ffb40e | 68 | if (__glibc_likely (outbuf + 4 <= outend)) \ |
2373b30e UD |
69 | { \ |
70 | /* Write out the last character. */ \ | |
33ed6903 AJ |
71 | *((uint32_t *) outbuf) = data->__statep->__count >> 3; \ |
72 | outbuf += sizeof (uint32_t); \ | |
2373b30e UD |
73 | data->__statep->__count = 0; \ |
74 | } \ | |
75 | else \ | |
76 | /* We don't have enough room in the output buffer. */ \ | |
77 | status = __GCONV_FULL_OUTPUT; \ | |
78 | } \ | |
79 | else \ | |
80 | /* We don't use shift states in the TO_DIRECTION. */ \ | |
81 | data->__statep->__count = 0; \ | |
82 | } | |
83 | ||
84 | ||
85 | /* First define the conversion function from CP1255 to UCS4. */ | |
86 | ||
87 | static const uint16_t to_ucs4[128] = { | |
88 | /* 0x80 */ | |
89 | 0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, | |
90 | 0x02C6, 0x2030, 0, 0x2039, 0, 0, 0, 0, | |
91 | /* 0x90 */ | |
92 | 0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, | |
93 | 0x02DC, 0x2122, 0, 0x203A, 0, 0, 0, 0, | |
94 | /* 0xA0 */ | |
95 | 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7, | |
96 | 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, | |
97 | /* 0xB0 */ | |
98 | 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, | |
99 | 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, | |
100 | /* 0xC0 */ | |
101 | 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7, | |
102 | 0x05B8, 0x05B9, 0, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF, | |
103 | /* 0xD0 */ | |
104 | 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3, | |
105 | 0x05F4, 0, 0, 0, 0, 0, 0, 0, | |
106 | /* 0xE0 */ | |
107 | 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, | |
108 | 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF, | |
109 | /* 0xF0 */ | |
110 | 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, | |
111 | 0x05E8, 0x05E9, 0x05EA, 0, 0, 0x200E, 0x200F, 0, | |
112 | }; | |
113 | ||
114 | /* CP1255 contains eight combining characters: | |
115 | 0x05b4, 0x05b7, 0x05b8, 0x05b9, 0x05bc, 0x05bf, 0x05c1, 0x05c2. */ | |
116 | ||
117 | /* Composition tables for each of the relevant combining characters. */ | |
118 | static const struct { | |
119 | uint16_t base; | |
120 | uint16_t composed; | |
121 | } comp_table_data[] = { | |
122 | #define COMP_TABLE_IDX_05B4 0 | |
123 | #define COMP_TABLE_LEN_05B4 1 | |
124 | { 0x05D9, 0xFB1D }, | |
125 | #define COMP_TABLE_IDX_05B7 (COMP_TABLE_IDX_05B4 + COMP_TABLE_LEN_05B4) | |
126 | #define COMP_TABLE_LEN_05B7 2 | |
127 | { 0x05D0, 0xFB2E }, | |
128 | { 0x05F2, 0xFB1F }, | |
129 | #define COMP_TABLE_IDX_05B8 (COMP_TABLE_IDX_05B7 + COMP_TABLE_LEN_05B7) | |
130 | #define COMP_TABLE_LEN_05B8 1 | |
131 | { 0x05D0, 0xFB2F }, | |
132 | #define COMP_TABLE_IDX_05B9 (COMP_TABLE_IDX_05B8 + COMP_TABLE_LEN_05B8) | |
133 | #define COMP_TABLE_LEN_05B9 1 | |
134 | { 0x05D5, 0xFB4B }, | |
135 | #define COMP_TABLE_IDX_05BC (COMP_TABLE_IDX_05B9 + COMP_TABLE_LEN_05B9) | |
136 | #define COMP_TABLE_LEN_05BC 24 | |
137 | { 0x05D0, 0xFB30 }, | |
138 | { 0x05D1, 0xFB31 }, | |
139 | { 0x05D2, 0xFB32 }, | |
140 | { 0x05D3, 0xFB33 }, | |
141 | { 0x05D4, 0xFB34 }, | |
142 | { 0x05D5, 0xFB35 }, | |
143 | { 0x05D6, 0xFB36 }, | |
144 | { 0x05D8, 0xFB38 }, | |
145 | { 0x05D9, 0xFB39 }, | |
146 | { 0x05DA, 0xFB3A }, | |
147 | { 0x05DB, 0xFB3B }, | |
148 | { 0x05DC, 0xFB3C }, | |
149 | { 0x05DE, 0xFB3E }, | |
150 | { 0x05E0, 0xFB40 }, | |
151 | { 0x05E1, 0xFB41 }, | |
152 | { 0x05E3, 0xFB43 }, | |
153 | { 0x05E4, 0xFB44 }, | |
154 | { 0x05E6, 0xFB46 }, | |
155 | { 0x05E7, 0xFB47 }, | |
156 | { 0x05E8, 0xFB48 }, | |
157 | { 0x05E9, 0xFB49 }, | |
158 | { 0x05EA, 0xFB4A }, | |
159 | { 0xFB2A, 0xFB2C }, | |
160 | { 0xFB2B, 0xFB2D }, | |
161 | #define COMP_TABLE_IDX_05BF (COMP_TABLE_IDX_05BC + COMP_TABLE_LEN_05BC) | |
162 | #define COMP_TABLE_LEN_05BF 3 | |
163 | { 0x05D1, 0xFB4C }, | |
164 | { 0x05DB, 0xFB4D }, | |
165 | { 0x05E4, 0xFB4E }, | |
166 | #define COMP_TABLE_IDX_05C1 (COMP_TABLE_IDX_05BF + COMP_TABLE_LEN_05BF) | |
167 | #define COMP_TABLE_LEN_05C1 2 | |
168 | { 0x05E9, 0xFB2A }, | |
169 | { 0xFB49, 0xFB2C }, | |
170 | #define COMP_TABLE_IDX_05C2 (COMP_TABLE_IDX_05C1 + COMP_TABLE_LEN_05C1) | |
171 | #define COMP_TABLE_LEN_05C2 2 | |
172 | { 0x05E9, 0xFB2B }, | |
173 | { 0xFB49, 0xFB2D }, | |
174 | #define COMP_TABLE_IDX_END (COMP_TABLE_IDX_05C2 + COMP_TABLE_LEN_05C2) | |
175 | }; | |
176 | /* Compile-time verification of table size. */ | |
177 | typedef int verify1[(NELEMS (comp_table_data) == COMP_TABLE_IDX_END) - 1]; | |
178 | ||
179 | static const struct { unsigned int idx; unsigned int len; } comp_table[8] = { | |
180 | { COMP_TABLE_IDX_05B4, COMP_TABLE_LEN_05B4 }, | |
181 | { COMP_TABLE_IDX_05B7, COMP_TABLE_LEN_05B7 }, | |
182 | { COMP_TABLE_IDX_05B8, COMP_TABLE_LEN_05B8 }, | |
183 | { COMP_TABLE_IDX_05B9, COMP_TABLE_LEN_05B9 }, | |
184 | { COMP_TABLE_IDX_05BC, COMP_TABLE_LEN_05BC }, | |
185 | { COMP_TABLE_IDX_05BF, COMP_TABLE_LEN_05BF }, | |
186 | { COMP_TABLE_IDX_05C1, COMP_TABLE_LEN_05C1 }, | |
187 | { COMP_TABLE_IDX_05C2, COMP_TABLE_LEN_05C2 }, | |
188 | }; | |
189 | ||
faaa6f62 UD |
190 | #define MIN_NEEDED_INPUT FROM_LOOP_MIN_NEEDED_FROM |
191 | #define MAX_NEEDED_INPUT FROM_LOOP_MAX_NEEDED_FROM | |
192 | #define MIN_NEEDED_OUTPUT FROM_LOOP_MIN_NEEDED_TO | |
193 | #define MAX_NEEDED_OUTPUT FROM_LOOP_MAX_NEEDED_TO | |
2373b30e UD |
194 | #define LOOPFCT FROM_LOOP |
195 | #define BODY \ | |
196 | { \ | |
197 | uint32_t ch = *inptr; \ | |
198 | uint32_t last_ch; \ | |
199 | int must_buffer_ch; \ | |
200 | \ | |
201 | if (ch >= 0x80) \ | |
202 | { \ | |
203 | ch = to_ucs4[ch - 0x80]; \ | |
a1ffb40e | 204 | if (__glibc_unlikely (ch == L'\0')) \ |
2373b30e UD |
205 | { \ |
206 | /* This is an illegal character. */ \ | |
e438a468 | 207 | STANDARD_FROM_LOOP_ERR_HANDLER (1); \ |
2373b30e UD |
208 | } \ |
209 | } \ | |
210 | \ | |
211 | /* Determine whether there is a buffered character pending. */ \ | |
212 | last_ch = *statep >> 3; \ | |
213 | \ | |
214 | /* We have to buffer ch if it is a possible match in comp_table_data. */ \ | |
215 | must_buffer_ch = (ch >= 0x05d0 && ch <= 0x05f2); \ | |
216 | \ | |
217 | if (last_ch) \ | |
218 | { \ | |
219 | if (ch >= 0x05b0 && ch < 0x05c5) \ | |
220 | { \ | |
221 | /* See whether last_ch and ch can be combined. */ \ | |
222 | unsigned int i, i1, i2; \ | |
223 | \ | |
224 | switch (ch) \ | |
225 | { \ | |
226 | case 0x05b4: \ | |
227 | i = 0; \ | |
228 | break; \ | |
229 | case 0x05b7: \ | |
230 | i = 1; \ | |
231 | break; \ | |
232 | case 0x05b8: \ | |
233 | i = 2; \ | |
234 | break; \ | |
235 | case 0x05b9: \ | |
236 | i = 3; \ | |
237 | break; \ | |
238 | case 0x05bc: \ | |
239 | i = 4; \ | |
240 | break; \ | |
241 | case 0x05bf: \ | |
242 | i = 5; \ | |
243 | break; \ | |
244 | case 0x05c1: \ | |
245 | i = 6; \ | |
246 | break; \ | |
247 | case 0x05c2: \ | |
248 | i = 7; \ | |
249 | break; \ | |
250 | default: \ | |
251 | goto not_combining; \ | |
252 | } \ | |
253 | \ | |
254 | i1 = comp_table[i].idx; \ | |
255 | i2 = i1 + comp_table[i].len - 1; \ | |
256 | \ | |
257 | if (last_ch >= comp_table_data[i1].base \ | |
258 | && last_ch <= comp_table_data[i2].base) \ | |
259 | { \ | |
260 | for (;;) \ | |
261 | { \ | |
262 | i = (i1 + i2) >> 1; \ | |
263 | if (last_ch == comp_table_data[i].base) \ | |
264 | break; \ | |
265 | if (last_ch < comp_table_data[i].base) \ | |
266 | { \ | |
267 | if (i1 == i) \ | |
268 | goto not_combining; \ | |
269 | i2 = i; \ | |
270 | } \ | |
271 | else \ | |
272 | { \ | |
273 | if (i1 != i) \ | |
274 | i1 = i; \ | |
275 | else \ | |
276 | { \ | |
277 | i = i2; \ | |
278 | if (last_ch == comp_table_data[i].base) \ | |
279 | break; \ | |
280 | goto not_combining; \ | |
281 | } \ | |
282 | } \ | |
283 | } \ | |
284 | last_ch = comp_table_data[i].composed; \ | |
285 | if (last_ch == 0xfb2a || last_ch == 0xfb2b \ | |
286 | || last_ch == 0xfb49) \ | |
287 | /* Buffer the combined character. */ \ | |
288 | *statep = last_ch << 3; \ | |
289 | else \ | |
290 | { \ | |
291 | /* Output the combined character. */ \ | |
292 | put32 (outptr, last_ch); \ | |
293 | outptr += 4; \ | |
294 | *statep = 0; \ | |
295 | } \ | |
296 | ++inptr; \ | |
297 | continue; \ | |
298 | } \ | |
299 | } \ | |
300 | \ | |
301 | not_combining: \ | |
302 | /* Output the buffered character. */ \ | |
303 | put32 (outptr, last_ch); \ | |
304 | outptr += 4; \ | |
305 | *statep = 0; \ | |
306 | \ | |
307 | /* If we don't have enough room to output ch as well, then deal \ | |
308 | with it in another round. */ \ | |
309 | if (!must_buffer_ch && __builtin_expect (outptr + 4 > outend, 0)) \ | |
310 | continue; \ | |
311 | } \ | |
312 | \ | |
313 | if (must_buffer_ch) \ | |
314 | *statep = ch << 3; \ | |
315 | else \ | |
316 | { \ | |
317 | put32 (outptr, ch); \ | |
318 | outptr += 4; \ | |
319 | } \ | |
320 | ++inptr; \ | |
321 | } | |
322 | #define LOOP_NEED_FLAGS | |
323 | #define EXTRA_LOOP_DECLS , int *statep | |
f9ad060c UD |
324 | #define ONEBYTE_BODY \ |
325 | { \ | |
326 | if (c < 0x80) \ | |
327 | return c; \ | |
328 | uint32_t ch = to_ucs4[c - 0x80]; \ | |
329 | if (ch == L'\0' || (ch >= 0x05d0 && ch <= 0x05f2)) \ | |
330 | return WEOF; \ | |
331 | return ch; \ | |
332 | } | |
2373b30e UD |
333 | #include <iconv/loop.c> |
334 | ||
335 | ||
336 | /* Next, define the conversion function from UCS4 to CP1255. */ | |
337 | ||
338 | static const unsigned char from_ucs4[] = { | |
339 | #define FROM_IDX_00 0 | |
340 | 0xa0, 0xa1, 0xa2, 0xa3, 0x00, 0xa5, 0xa6, 0xa7, /* 0x00a0-0x00a7 */ | |
341 | 0xa8, 0xa9, 0x00, 0xab, 0xac, 0xad, 0xae, 0xaf, /* 0x00a8-0x00af */ | |
342 | 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, /* 0x00b0-0x00b7 */ | |
343 | 0xb8, 0xb9, 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, /* 0x00b8-0x00bf */ | |
344 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c0-0x00c7 */ | |
345 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c8-0x00cf */ | |
346 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, /* 0x00d0-0x00d7 */ | |
347 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00d8-0x00df */ | |
348 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e0-0x00e7 */ | |
349 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e8-0x00ef */ | |
350 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, /* 0x00f0-0x00f7 */ | |
351 | #define FROM_IDX_02 (FROM_IDX_00 + 88) | |
352 | 0x88, 0x00, /* 0x02c6-0x02c7 */ | |
353 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02c8-0x02cf */ | |
354 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02d0-0x02d7 */ | |
355 | 0x00, 0x00, 0x00, 0x00, 0x98, /* 0x02d8-0x02dc */ | |
356 | #define FROM_IDX_05 (FROM_IDX_02 + 23) | |
357 | 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 0x05b0-0x05b7 */ | |
358 | 0xc8, 0xc9, 0x00, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, /* 0x05b8-0x05bf */ | |
359 | 0xd0, 0xd1, 0xd2, 0xd3, 0x00, 0x00, 0x00, 0x00, /* 0x05c0-0x05c7 */ | |
360 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05c8-0x05cf */ | |
361 | 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, /* 0x05d0-0x05d7 */ | |
362 | 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, /* 0x05d8-0x05df */ | |
363 | 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 0x05e0-0x05e7 */ | |
364 | 0xf8, 0xf9, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05e8-0x05ef */ | |
365 | 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, /* 0x05f0-0x05f4 */ | |
366 | #define FROM_IDX_20 (FROM_IDX_05 + 69) | |
367 | 0xfd, 0xfe, /* 0x200e-0x200f */ | |
368 | 0x00, 0x00, 0x00, 0x96, 0x97, 0x00, 0x00, 0x00, /* 0x2010-0x2017 */ | |
369 | 0x91, 0x92, 0x82, 0x00, 0x93, 0x94, 0x84, 0x00, /* 0x2018-0x201f */ | |
370 | 0x86, 0x87, 0x95, 0x00, 0x00, 0x00, 0x85, 0x00, /* 0x2020-0x2027 */ | |
371 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2028-0x202f */ | |
372 | 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2030-0x2037 */ | |
373 | 0x00, 0x8b, 0x9b, /* 0x2038-0x203a */ | |
374 | #define FROM_IDX_FF (FROM_IDX_20 + 45) | |
375 | }; | |
376 | /* Compile-time verification of table size. */ | |
377 | typedef int verify2[(NELEMS (from_ucs4) == FROM_IDX_FF) - 1]; | |
378 | ||
379 | static const unsigned char comb_table[8] = { | |
380 | 0xc4, 0xc7, 0xc8, 0xc9, 0xcc, 0xcf, 0xd1, 0xd2, | |
381 | }; | |
382 | ||
383 | /* Decomposition table for the relevant Unicode characters. */ | |
384 | static const struct { | |
385 | uint16_t composed; | |
386 | uint16_t base; | |
387 | uint32_t comb1 : 8; | |
388 | int32_t comb2 : 8; | |
389 | } decomp_table[] = { | |
390 | { 0xFB1D, 0x05D9, 0, -1 }, | |
391 | { 0xFB1F, 0x05F2, 1, -1 }, | |
392 | { 0xFB2A, 0x05E9, 6, -1 }, | |
393 | { 0xFB2B, 0x05E9, 7, -1 }, | |
394 | { 0xFB2C, 0x05E9, 4, 6 }, | |
395 | { 0xFB2D, 0x05E9, 4, 7 }, | |
396 | { 0xFB2E, 0x05D0, 1, -1 }, | |
397 | { 0xFB2F, 0x05D0, 2, -1 }, | |
398 | { 0xFB30, 0x05D0, 4, -1 }, | |
399 | { 0xFB31, 0x05D1, 4, -1 }, | |
400 | { 0xFB32, 0x05D2, 4, -1 }, | |
401 | { 0xFB33, 0x05D3, 4, -1 }, | |
402 | { 0xFB34, 0x05D4, 4, -1 }, | |
403 | { 0xFB35, 0x05D5, 4, -1 }, | |
404 | { 0xFB36, 0x05D6, 4, -1 }, | |
405 | { 0xFB38, 0x05D8, 4, -1 }, | |
406 | { 0xFB39, 0x05D9, 4, -1 }, | |
407 | { 0xFB3A, 0x05DA, 4, -1 }, | |
408 | { 0xFB3B, 0x05DB, 4, -1 }, | |
409 | { 0xFB3C, 0x05DC, 4, -1 }, | |
410 | { 0xFB3E, 0x05DE, 4, -1 }, | |
411 | { 0xFB40, 0x05E0, 4, -1 }, | |
412 | { 0xFB41, 0x05E1, 4, -1 }, | |
413 | { 0xFB43, 0x05E3, 4, -1 }, | |
414 | { 0xFB44, 0x05E4, 4, -1 }, | |
415 | { 0xFB46, 0x05E6, 4, -1 }, | |
416 | { 0xFB47, 0x05E7, 4, -1 }, | |
417 | { 0xFB48, 0x05E8, 4, -1 }, | |
418 | { 0xFB49, 0x05E9, 4, -1 }, | |
419 | { 0xFB4A, 0x05EA, 4, -1 }, | |
420 | { 0xFB4B, 0x05D5, 3, -1 }, | |
421 | { 0xFB4C, 0x05D1, 5, -1 }, | |
422 | { 0xFB4D, 0x05DB, 5, -1 }, | |
423 | { 0xFB4E, 0x05E4, 5, -1 }, | |
424 | }; | |
425 | ||
faaa6f62 UD |
426 | #define MIN_NEEDED_INPUT TO_LOOP_MIN_NEEDED_FROM |
427 | #define MAX_NEEDED_INPUT TO_LOOP_MAX_NEEDED_FROM | |
428 | #define MIN_NEEDED_OUTPUT TO_LOOP_MIN_NEEDED_TO | |
429 | #define MAX_NEEDED_OUTPUT TO_LOOP_MAX_NEEDED_TO | |
2373b30e UD |
430 | #define LOOPFCT TO_LOOP |
431 | #define BODY \ | |
432 | { \ | |
433 | uint32_t ch = get32 (inptr); \ | |
434 | \ | |
435 | if (ch < 0x0080) \ | |
436 | { \ | |
437 | *outptr++ = ch; \ | |
438 | inptr += 4; \ | |
439 | } \ | |
440 | else \ | |
441 | { \ | |
442 | unsigned char res; \ | |
443 | \ | |
444 | if (ch >= 0x00a0 && ch < 0x00f8) \ | |
445 | res = from_ucs4[ch - 0x00a0 + FROM_IDX_00]; \ | |
446 | else if (ch == 0x0192) \ | |
447 | res = 0x83; \ | |
448 | else if (ch >= 0x02c6 && ch < 0x02dd) \ | |
449 | res = from_ucs4[ch - 0x02c6 + FROM_IDX_02]; \ | |
450 | else if (ch >= 0x05b0 && ch < 0x05f5) \ | |
451 | res = from_ucs4[ch - 0x05b0 + FROM_IDX_05]; \ | |
452 | else if (ch >= 0x200e && ch < 0x203b) \ | |
453 | res = from_ucs4[ch - 0x200e + FROM_IDX_20]; \ | |
454 | else if (ch == 0x20aa) \ | |
455 | res = 0xa4; \ | |
456 | else if (ch == 0x20ac) \ | |
457 | res = 0x80; \ | |
458 | else if (ch == 0x2122) \ | |
459 | res = 0x99; \ | |
460 | else \ | |
601d2942 UD |
461 | { \ |
462 | UNICODE_TAG_HANDLER (ch, 4); \ | |
463 | res = 0; \ | |
464 | } \ | |
2373b30e | 465 | \ |
a1ffb40e | 466 | if (__glibc_likely (res != 0)) \ |
2373b30e UD |
467 | { \ |
468 | *outptr++ = res; \ | |
469 | inptr += 4; \ | |
470 | } \ | |
471 | else \ | |
472 | { \ | |
473 | /* Try canonical decomposition. */ \ | |
474 | unsigned int i1, i2; \ | |
475 | \ | |
476 | i1 = 0; \ | |
477 | i2 = sizeof (decomp_table) / sizeof (decomp_table[0]) - 1; \ | |
478 | if (ch >= decomp_table[i1].composed \ | |
479 | && ch <= decomp_table[i2].composed) \ | |
480 | { \ | |
481 | unsigned int i; \ | |
482 | \ | |
483 | for (;;) \ | |
484 | { \ | |
485 | i = (i1 + i2) >> 1; \ | |
486 | if (ch == decomp_table[i].composed) \ | |
487 | break; \ | |
488 | if (ch < decomp_table[i].composed) \ | |
489 | { \ | |
490 | if (i1 == i) \ | |
491 | goto failed; \ | |
492 | i2 = i; \ | |
493 | } \ | |
494 | else \ | |
495 | { \ | |
496 | if (i1 != i) \ | |
497 | i1 = i; \ | |
498 | else \ | |
499 | { \ | |
500 | i = i2; \ | |
501 | if (ch == decomp_table[i].composed) \ | |
502 | break; \ | |
503 | goto failed; \ | |
504 | } \ | |
505 | } \ | |
506 | } \ | |
507 | \ | |
508 | /* Found a canonical decomposition. */ \ | |
509 | ch = decomp_table[i].base; \ | |
510 | /* ch is one of 0x05d0..0x05d6, 0x05d8..0x05dc, 0x05de, \ | |
511 | 0x05e0..0x05e1, 0x05e3..0x05e4, 0x05e6..0x05ea, 0x05f2. */ \ | |
512 | ch = from_ucs4[ch - 0x05b0 + FROM_IDX_05]; \ | |
513 | assert (ch != 0); \ | |
514 | \ | |
515 | if (decomp_table[i].comb2 < 0) \ | |
516 | { \ | |
517 | /* See whether we have room for two bytes. */ \ | |
a1ffb40e | 518 | if (__glibc_unlikely (outptr + 1 >= outend)) \ |
2373b30e UD |
519 | { \ |
520 | result = __GCONV_FULL_OUTPUT; \ | |
521 | break; \ | |
522 | } \ | |
523 | \ | |
524 | *outptr++ = (unsigned char) ch; \ | |
525 | *outptr++ = comb_table[decomp_table[i].comb1]; \ | |
526 | } \ | |
527 | else \ | |
528 | { \ | |
529 | /* See whether we have room for three bytes. */ \ | |
a1ffb40e | 530 | if (__glibc_unlikely (outptr + 2 >= outend)) \ |
2373b30e UD |
531 | { \ |
532 | result = __GCONV_FULL_OUTPUT; \ | |
533 | break; \ | |
534 | } \ | |
535 | \ | |
536 | *outptr++ = (unsigned char) ch; \ | |
537 | *outptr++ = comb_table[decomp_table[i].comb1]; \ | |
538 | *outptr++ = comb_table[decomp_table[i].comb2]; \ | |
539 | } \ | |
540 | \ | |
541 | inptr += 4; \ | |
542 | continue; \ | |
543 | } \ | |
544 | \ | |
545 | failed: \ | |
546 | /* This is an illegal character. */ \ | |
e438a468 | 547 | STANDARD_TO_LOOP_ERR_HANDLER (4); \ |
2373b30e UD |
548 | } \ |
549 | } \ | |
550 | } | |
551 | #define LOOP_NEED_FLAGS | |
552 | #define EXTRA_LOOP_DECLS , int *statep | |
553 | #include <iconv/loop.c> | |
554 | ||
555 | ||
556 | /* Now define the toplevel functions. */ | |
557 | #include <iconv/skeleton.c> |