]>
Commit | Line | Data |
---|---|---|
fa00744e | 1 | /* Conversion from and to TSCII. |
a7467d52 | 2 | Copyright (C) 2002, 2004 Free Software Foundation, Inc. |
fa00744e UD |
3 | This file is part of the GNU C Library. |
4 | Contributed by Bruno Haible <bruno@clisp.org>, 2002. | |
5 | ||
6 | The GNU C Library is free software; you can redistribute it and/or | |
7 | modify it under the terms of the GNU Lesser General Public | |
8 | License as published by the Free Software Foundation; either | |
9 | version 2.1 of the License, or (at your option) any later version. | |
10 | ||
11 | The GNU C Library is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | Lesser General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU Lesser General Public | |
59ba27a6 PE |
17 | License along with the GNU C Library; if not, see |
18 | <http://www.gnu.org/licenses/>. */ | |
fa00744e UD |
19 | |
20 | #include <dlfcn.h> | |
21 | #include <stdint.h> | |
22 | #include <gconv.h> | |
23 | #include <assert.h> | |
24 | ||
25 | /* TSCII is an 8-bit encoding consisting of: | |
26 | 0x00..0x7F: ASCII | |
27 | 0x80..0x90, 0x95..0x9F, 0xAB..0xFE: | |
28 | Tamil letters and glyphs | |
29 | 0xA1..0xA5, 0xAA: Tamil combining letters (after the base character) | |
30 | 0xA6..0xA8: Tamil combining letters (before the base character) | |
31 | 0x91..0x94: Punctuation | |
32 | 0xA9: Symbols | |
33 | */ | |
34 | ||
35 | /* Definitions used in the body of the `gconv' function. */ | |
36 | #define CHARSET_NAME "TSCII//" | |
37 | #define FROM_LOOP from_tscii | |
38 | #define TO_LOOP to_tscii | |
39 | #define DEFINE_INIT 1 | |
40 | #define DEFINE_FINI 1 | |
41 | #define FROM_LOOP_MIN_NEEDED_FROM 1 | |
42 | #define FROM_LOOP_MAX_NEEDED_FROM 2 | |
43 | #define FROM_LOOP_MIN_NEEDED_TO 4 | |
44 | #define FROM_LOOP_MAX_NEEDED_TO 16 | |
45 | #define TO_LOOP_MIN_NEEDED_FROM 4 | |
46 | #define TO_LOOP_MAX_NEEDED_FROM 4 | |
47 | #define TO_LOOP_MIN_NEEDED_TO 1 | |
48 | #define TO_LOOP_MAX_NEEDED_TO 3 | |
49 | #define PREPARE_LOOP \ | |
50 | int saved_state; \ | |
51 | int *statep = &data->__statep->__count; | |
52 | #define EXTRA_LOOP_ARGS , statep | |
53 | ||
54 | ||
55 | /* Since we might have to reset input pointer we must be able to save | |
56 | and restore the state. */ | |
57 | #define SAVE_RESET_STATE(Save) \ | |
58 | if (Save) \ | |
59 | saved_state = *statep; \ | |
60 | else \ | |
61 | *statep = saved_state | |
62 | ||
63 | ||
64 | /* During TSCII to UCS-4 conversion, the COUNT element of the state contains | |
65 | the last UCS-4 character to be output, shifted by 8 bits, and an encoded | |
66 | representation of additional UCS-4 characters to be output (if any), | |
67 | shifted by 4 bits. This character can be: | |
68 | 0x0000 Nothing pending. | |
69 | 0x0BCD Pending VIRAMA sign. If bit 3 is set, it may be | |
70 | omitted if followed by a vowel sign U or UU. | |
71 | 0x0BC6, 0x0BC7, 0x0BC8 Pending vowel sign. Bit 3 is set after the | |
72 | consonant was seen. | |
73 | Other Bit 3 always cleared. */ | |
74 | ||
75 | /* During UCS-4 to TSCII conversion, the COUNT element of the state contains | |
76 | the last byte (or sometimes the last two bytes) to be output, shifted by | |
77 | 3 bits. This can be: | |
78 | 0x00 Nothing pending. | |
79 | 0xB8..0xC9, 0x83..0x86 A consonant. | |
80 | 0xEC, 0x8A A consonant with VIRAMA sign (final or joining). | |
81 | 0x87, 0xC38A Two consonants combined through a VIRAMA sign. */ | |
82 | ||
83 | /* Since this is a stateful encoding we have to provide code which resets | |
84 | the output state to the initial state. This has to be done during the | |
85 | flushing. */ | |
86 | #define EMIT_SHIFT_TO_INIT \ | |
87 | if (data->__statep->__count != 0) \ | |
88 | { \ | |
89 | if (FROM_DIRECTION) \ | |
90 | { \ | |
91 | do \ | |
92 | { \ | |
93 | if (__builtin_expect (outbuf + 4 > outend, 0)) \ | |
94 | { \ | |
95 | /* We don't have enough room in the output buffer. */ \ | |
96 | status = __GCONV_FULL_OUTPUT; \ | |
97 | break; \ | |
98 | } \ | |
99 | /* Write out the pending character. */ \ | |
a7467d52 AJ |
100 | *((uint32_t *) outbuf) = data->__statep->__count >> 8; \ |
101 | outbuf += sizeof (uint32_t); \ | |
fa00744e UD |
102 | /* Retrieve the successor state. */ \ |
103 | data->__statep->__count = \ | |
104 | tscii_next_state[(data->__statep->__count >> 4) & 0x0f]; \ | |
105 | } \ | |
106 | while (data->__statep->__count != 0); \ | |
107 | } \ | |
108 | else \ | |
109 | { \ | |
110 | uint32_t last = data->__statep->__count >> 3; \ | |
111 | if (__builtin_expect (last >> 8, 0)) \ | |
112 | { \ | |
113 | /* Write out the last character, two bytes. */ \ | |
114 | if (__builtin_expect (outbuf + 2 <= outend, 1)) \ | |
115 | { \ | |
116 | *outbuf++ = last & 0xff; \ | |
117 | *outbuf++ = (last >> 8) & 0xff; \ | |
118 | data->__statep->__count = 0; \ | |
119 | } \ | |
120 | else \ | |
121 | /* We don't have enough room in the output buffer. */ \ | |
122 | status = __GCONV_FULL_OUTPUT; \ | |
123 | } \ | |
124 | else \ | |
125 | { \ | |
126 | /* Write out the last character, a single byte. */ \ | |
127 | if (__builtin_expect (outbuf < outend, 1)) \ | |
128 | { \ | |
129 | *outbuf++ = last & 0xff; \ | |
130 | data->__statep->__count = 0; \ | |
131 | } \ | |
132 | else \ | |
133 | /* We don't have enough room in the output buffer. */ \ | |
134 | status = __GCONV_FULL_OUTPUT; \ | |
135 | } \ | |
136 | } \ | |
137 | } | |
138 | ||
139 | ||
140 | /* First define the conversion function from TSCII to UCS-4. */ | |
141 | ||
142 | static const uint16_t tscii_to_ucs4[128][2] = | |
143 | { | |
144 | { 0x0BE6, 0 }, | |
145 | { 0x0BE7, 0 }, | |
146 | { 0, 0 }, /* 0x82 - maps to <U0BB8><U0BCD><U0BB0><U0BC0> */ | |
147 | { 0x0B9C, 0 }, | |
148 | { 0x0BB7, 0 }, | |
149 | { 0x0BB8, 0 }, | |
150 | { 0x0BB9, 0 }, | |
151 | { 0, 0 }, /* 0x87 - maps to <U0B95><U0BCD><U0BB7> */ | |
152 | { 0x0B9C, 0x0BCD }, | |
153 | { 0x0BB7, 0x0BCD }, | |
154 | { 0, 0 }, /* 0x8a - maps to <U0BB8> and buffers <U0BCD> */ | |
155 | { 0, 0 }, /* 0x8b - maps to <U0BB9> and buffers <U0BCD> */ | |
156 | { 0, 0 }, /* 0x8c - maps to <U0B95><U0BCD><U0BB7><U0BCD> */ | |
157 | { 0x0BE8, 0 }, | |
158 | { 0x0BE9, 0 }, | |
159 | { 0x0BEA, 0 }, | |
160 | { 0x0BEB, 0 }, | |
161 | { 0x2018, 0 }, | |
162 | { 0x2019, 0 }, | |
163 | { 0x201C, 0 }, | |
164 | { 0x201D, 0 }, | |
165 | { 0x0BEC, 0 }, | |
166 | { 0x0BED, 0 }, | |
167 | { 0x0BEE, 0 }, | |
168 | { 0x0BEF, 0 }, | |
169 | { 0x0B99, 0x0BC1 }, | |
170 | { 0x0B9E, 0x0BC1 }, | |
171 | { 0x0B99, 0x0BC2 }, | |
172 | { 0x0B9E, 0x0BC2 }, | |
173 | { 0x0BF0, 0 }, | |
174 | { 0x0BF1, 0 }, | |
175 | { 0x0BF2, 0 }, | |
176 | { 0, 0 }, /* 0xa0 - unmapped */ | |
177 | { 0x0BBE, 0 }, | |
178 | { 0x0BBF, 0 }, | |
179 | { 0x0BC0, 0 }, | |
180 | { 0x0BC1, 0 }, | |
181 | { 0x0BC2, 0 }, | |
182 | { 0, 0 }, /* 0xa6 - buffers <U0BC6> */ | |
183 | { 0, 0 }, /* 0xa7 - buffers <U0BC7> */ | |
184 | { 0, 0 }, /* 0xa8 - buffers <U0BC8> */ | |
185 | { 0x00A9, 0 }, | |
186 | { 0x0BD7, 0 }, | |
187 | { 0x0B85, 0 }, | |
188 | { 0x0B86, 0 }, | |
189 | { 0x0B87, 0 }, | |
190 | { 0x0B88, 0 }, | |
191 | { 0x0B89, 0 }, | |
192 | { 0x0B8A, 0 }, | |
193 | { 0x0B8E, 0 }, | |
194 | { 0x0B8F, 0 }, | |
195 | { 0x0B90, 0 }, | |
196 | { 0x0B92, 0 }, | |
197 | { 0x0B93, 0 }, | |
198 | { 0x0B94, 0 }, | |
199 | { 0x0B83, 0 }, | |
200 | { 0x0B95, 0 }, | |
201 | { 0x0B99, 0 }, | |
202 | { 0x0B9A, 0 }, | |
203 | { 0x0B9E, 0 }, | |
204 | { 0x0B9F, 0 }, | |
205 | { 0x0BA3, 0 }, | |
206 | { 0x0BA4, 0 }, | |
207 | { 0x0BA8, 0 }, | |
208 | { 0x0BAA, 0 }, | |
209 | { 0x0BAE, 0 }, | |
210 | { 0x0BAF, 0 }, | |
211 | { 0x0BB0, 0 }, | |
212 | { 0x0BB2, 0 }, | |
213 | { 0x0BB5, 0 }, | |
214 | { 0x0BB4, 0 }, | |
215 | { 0x0BB3, 0 }, | |
216 | { 0x0BB1, 0 }, | |
217 | { 0x0BA9, 0 }, | |
218 | { 0x0B9F, 0x0BBF }, | |
219 | { 0x0B9F, 0x0BC0 }, | |
220 | { 0x0B95, 0x0BC1 }, | |
221 | { 0x0B9A, 0x0BC1 }, | |
222 | { 0x0B9F, 0x0BC1 }, | |
223 | { 0x0BA3, 0x0BC1 }, | |
224 | { 0x0BA4, 0x0BC1 }, | |
225 | { 0x0BA8, 0x0BC1 }, | |
226 | { 0x0BAA, 0x0BC1 }, | |
227 | { 0x0BAE, 0x0BC1 }, | |
228 | { 0x0BAF, 0x0BC1 }, | |
229 | { 0x0BB0, 0x0BC1 }, | |
230 | { 0x0BB2, 0x0BC1 }, | |
231 | { 0x0BB5, 0x0BC1 }, | |
232 | { 0x0BB4, 0x0BC1 }, | |
233 | { 0x0BB3, 0x0BC1 }, | |
234 | { 0x0BB1, 0x0BC1 }, | |
235 | { 0x0BA9, 0x0BC1 }, | |
236 | { 0x0B95, 0x0BC2 }, | |
237 | { 0x0B9A, 0x0BC2 }, | |
238 | { 0x0B9F, 0x0BC2 }, | |
239 | { 0x0BA3, 0x0BC2 }, | |
240 | { 0x0BA4, 0x0BC2 }, | |
241 | { 0x0BA8, 0x0BC2 }, | |
242 | { 0x0BAA, 0x0BC2 }, | |
243 | { 0x0BAE, 0x0BC2 }, | |
244 | { 0x0BAF, 0x0BC2 }, | |
245 | { 0x0BB0, 0x0BC2 }, | |
246 | { 0x0BB2, 0x0BC2 }, | |
247 | { 0x0BB5, 0x0BC2 }, | |
248 | { 0x0BB4, 0x0BC2 }, | |
249 | { 0x0BB3, 0x0BC2 }, | |
250 | { 0x0BB1, 0x0BC2 }, | |
251 | { 0x0BA9, 0x0BC2 }, | |
252 | { 0x0B95, 0x0BCD }, | |
253 | { 0x0B99, 0x0BCD }, | |
254 | { 0x0B9A, 0x0BCD }, | |
255 | { 0x0B9E, 0x0BCD }, | |
256 | { 0x0B9F, 0x0BCD }, | |
257 | { 0x0BA3, 0x0BCD }, | |
258 | { 0x0BA4, 0x0BCD }, | |
259 | { 0x0BA8, 0x0BCD }, | |
260 | { 0x0BAA, 0x0BCD }, | |
261 | { 0x0BAE, 0x0BCD }, | |
262 | { 0x0BAF, 0x0BCD }, | |
263 | { 0x0BB0, 0x0BCD }, | |
264 | { 0x0BB2, 0x0BCD }, | |
265 | { 0x0BB5, 0x0BCD }, | |
266 | { 0x0BB4, 0x0BCD }, | |
267 | { 0x0BB3, 0x0BCD }, | |
268 | { 0x0BB1, 0x0BCD }, | |
269 | { 0x0BA9, 0x0BCD }, | |
270 | { 0x0B87, 0 }, | |
271 | { 0, 0 } /* 0xff - unmapped */ | |
272 | }; | |
273 | ||
274 | static const uint32_t tscii_next_state[6] = | |
275 | { | |
276 | /* 0 means no more pending Unicode characters. */ | |
277 | 0, | |
278 | /* 1 means <U0BB7>. */ | |
279 | (0x0BB7 << 8), | |
280 | /* 2 means <U0BC0>. */ | |
281 | (0x0BC0 << 8), | |
282 | /* 3 means <U0BCD>. */ | |
283 | (0x0BCD << 8), | |
284 | /* 4 means <U0BB0><U0BC0>. */ | |
285 | (0x0BB0 << 8) + (2 << 4), | |
286 | /* 5 means <U0BB7><U0BCD>. */ | |
287 | (0x0BB7 << 8) + (3 << 4) | |
288 | }; | |
289 | ||
290 | #define MIN_NEEDED_INPUT FROM_LOOP_MIN_NEEDED_FROM | |
291 | #define MAX_NEEDED_INPUT FROM_LOOP_MAX_NEEDED_FROM | |
292 | #define MIN_NEEDED_OUTPUT FROM_LOOP_MIN_NEEDED_TO | |
293 | #define MAX_NEEDED_OUTPUT FROM_LOOP_MAX_NEEDED_TO | |
294 | #define LOOPFCT FROM_LOOP | |
295 | #define BODY \ | |
296 | { \ | |
297 | uint32_t ch = *inptr; \ | |
298 | \ | |
299 | if ((*statep >> 8) != 0) \ | |
300 | { \ | |
301 | /* Attempt to combine the last character with this one. */ \ | |
302 | uint32_t last = *statep >> 8; \ | |
303 | \ | |
304 | if (last == 0x0BCD && (*statep & (1 << 3))) \ | |
305 | { \ | |
306 | if (ch == 0xa4 || ch == 0xa5) \ | |
307 | { \ | |
308 | ch += 0xb1d; \ | |
309 | /* Now ch = 0x0BC1 or ch = 0x0BC2. */ \ | |
310 | put32 (outptr, ch); \ | |
311 | outptr += 4; \ | |
312 | *statep = 0; \ | |
313 | inptr++; \ | |
314 | continue; \ | |
315 | } \ | |
316 | } \ | |
317 | else if (last >= 0x0BC6 && last <= 0x0BC8) \ | |
318 | { \ | |
319 | if ((last == 0x0BC6 && ch == 0xa1) \ | |
320 | || (last == 0x0BC7 && (ch == 0xa1 || ch == 0xaa))) \ | |
321 | { \ | |
322 | ch = last + 4 + (ch != 0xa1); \ | |
323 | /* Now ch = 0x0BCA or ch = 0x0BCB or ch = 0x0BCC. */ \ | |
324 | put32 (outptr, ch); \ | |
325 | outptr += 4; \ | |
326 | *statep = 0; \ | |
327 | inptr++; \ | |
328 | continue; \ | |
329 | } \ | |
330 | if ((ch >= 0xb8 && ch <= 0xc9) && (*statep & (1 << 3)) == 0) \ | |
331 | { \ | |
332 | ch = tscii_to_ucs4[ch - 0x80][0]; \ | |
333 | put32 (outptr, ch); \ | |
334 | outptr += 4; \ | |
335 | *statep |= 1 << 3; \ | |
336 | inptr++; \ | |
337 | continue; \ | |
338 | } \ | |
339 | } \ | |
340 | \ | |
341 | do \ | |
342 | { \ | |
343 | /* Output the buffered character. */ \ | |
344 | put32 (outptr, last); \ | |
345 | outptr += 4; \ | |
346 | /* Retrieve the successor state. */ \ | |
347 | *statep = tscii_next_state[(*statep >> 4) & 0x0f]; \ | |
348 | } \ | |
349 | while (*statep != 0 && __builtin_expect (outptr + 4 <= outend, 1)); \ | |
350 | \ | |
351 | if (*statep != 0) \ | |
352 | { \ | |
353 | /* We don't have enough room in the output buffer. \ | |
354 | Tell the caller why we terminate the loop. */ \ | |
355 | result = __GCONV_FULL_OUTPUT; \ | |
356 | break; \ | |
357 | } \ | |
358 | \ | |
359 | continue; \ | |
360 | } \ | |
361 | \ | |
362 | if (ch < 0x80) \ | |
363 | { \ | |
364 | /* Plain ASCII character. */ \ | |
365 | put32 (outptr, ch); \ | |
366 | outptr += 4; \ | |
367 | } \ | |
368 | else \ | |
369 | { \ | |
370 | /* Tamil character. */ \ | |
371 | uint32_t u1 = tscii_to_ucs4[ch - 0x80][0]; \ | |
372 | \ | |
373 | if (u1 != 0) \ | |
374 | { \ | |
375 | uint32_t u2 = tscii_to_ucs4[ch - 0x80][1]; \ | |
376 | \ | |
377 | inptr++; \ | |
378 | \ | |
379 | put32 (outptr, u1); \ | |
380 | outptr += 4; \ | |
381 | \ | |
382 | if (u2 != 0) \ | |
383 | { \ | |
384 | /* See whether we have room for two characters. Otherwise \ | |
385 | store only the first character now, and put the second \ | |
386 | one into the queue. */ \ | |
387 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
388 | { \ | |
389 | *statep = u2 << 8; \ | |
390 | result = __GCONV_FULL_OUTPUT; \ | |
391 | break; \ | |
392 | } \ | |
393 | put32 (outptr, u2); \ | |
394 | outptr += 4; \ | |
395 | } \ | |
396 | continue; \ | |
397 | } \ | |
398 | /* Special handling of a few Tamil characters. */ \ | |
399 | else if (ch == 0xa6 || ch == 0xa7 || ch == 0xa8) \ | |
400 | { \ | |
401 | ch += 0x0b20; \ | |
402 | /* Now ch = 0x0BC6 or ch = 0x0BC7 or ch = 0x0BC8. */ \ | |
403 | *statep = ch << 8; \ | |
404 | inptr++; \ | |
405 | continue; \ | |
406 | } \ | |
407 | else if (ch == 0x8a || ch == 0x8b) \ | |
408 | { \ | |
409 | ch += 0x0b2e; \ | |
410 | /* Now ch = 0x0BB8 or ch = 0x0BB9. */ \ | |
411 | put32 (outptr, ch); \ | |
412 | outptr += 4; \ | |
413 | *statep = (0x0BCD << 8) + (1 << 3); \ | |
414 | inptr++; \ | |
415 | continue; \ | |
416 | } \ | |
417 | else if (ch == 0x82) \ | |
418 | { \ | |
419 | /* Output <U0BB8><U0BCD><U0BB0><U0BC0>, if we have room for \ | |
420 | four characters. */ \ | |
421 | inptr++; \ | |
422 | put32 (outptr, 0x0BB8); \ | |
423 | outptr += 4; \ | |
424 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
425 | { \ | |
426 | *statep = (0x0BCD << 8) + (4 << 4); \ | |
427 | result = __GCONV_FULL_OUTPUT; \ | |
428 | break; \ | |
429 | } \ | |
430 | put32 (outptr, 0x0BCD); \ | |
431 | outptr += 4; \ | |
432 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
433 | { \ | |
434 | *statep = (0x0BB0 << 8) + (2 << 4); \ | |
435 | result = __GCONV_FULL_OUTPUT; \ | |
436 | break; \ | |
437 | } \ | |
438 | put32 (outptr, 0x0BB0); \ | |
439 | outptr += 4; \ | |
440 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
441 | { \ | |
442 | *statep = (0x0BC0 << 8); \ | |
443 | result = __GCONV_FULL_OUTPUT; \ | |
444 | break; \ | |
445 | } \ | |
446 | put32 (outptr, 0x0BC0); \ | |
447 | outptr += 4; \ | |
448 | continue; \ | |
449 | } \ | |
450 | else if (ch == 0x87) \ | |
451 | { \ | |
452 | /* Output <U0B95><U0BCD><U0BB7>, if we have room for \ | |
453 | three characters. */ \ | |
454 | inptr++; \ | |
455 | put32 (outptr, 0x0B95); \ | |
456 | outptr += 4; \ | |
457 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
458 | { \ | |
459 | *statep = (0x0BCD << 8) + (1 << 4); \ | |
460 | result = __GCONV_FULL_OUTPUT; \ | |
461 | break; \ | |
462 | } \ | |
463 | put32 (outptr, 0x0BCD); \ | |
464 | outptr += 4; \ | |
465 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
466 | { \ | |
467 | *statep = (0x0BB7 << 8); \ | |
468 | result = __GCONV_FULL_OUTPUT; \ | |
469 | break; \ | |
470 | } \ | |
471 | put32 (outptr, 0x0BB7); \ | |
472 | outptr += 4; \ | |
473 | continue; \ | |
474 | } \ | |
475 | else if (ch == 0x8c) \ | |
476 | { \ | |
477 | /* Output <U0B95><U0BCD><U0BB7><U0BCD>, if we have room for \ | |
478 | four characters. */ \ | |
479 | inptr++; \ | |
480 | put32 (outptr, 0x0B95); \ | |
481 | outptr += 4; \ | |
482 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
483 | { \ | |
484 | *statep = (0x0BCD << 8) + (5 << 4); \ | |
485 | result = __GCONV_FULL_OUTPUT; \ | |
486 | break; \ | |
487 | } \ | |
488 | put32 (outptr, 0x0BCD); \ | |
489 | outptr += 4; \ | |
490 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
491 | { \ | |
492 | *statep = (0x0BB7 << 8) + (3 << 4); \ | |
493 | result = __GCONV_FULL_OUTPUT; \ | |
494 | break; \ | |
495 | } \ | |
496 | put32 (outptr, 0x0BB7); \ | |
497 | outptr += 4; \ | |
498 | if (__builtin_expect (outptr + 4 > outend, 0)) \ | |
499 | { \ | |
500 | *statep = (0x0BCD << 8); \ | |
501 | result = __GCONV_FULL_OUTPUT; \ | |
502 | break; \ | |
503 | } \ | |
504 | put32 (outptr, 0x0BCD); \ | |
505 | outptr += 4; \ | |
506 | continue; \ | |
507 | } \ | |
508 | else \ | |
509 | { \ | |
510 | /* This is illegal. */ \ | |
511 | STANDARD_FROM_LOOP_ERR_HANDLER (1); \ | |
512 | } \ | |
513 | } \ | |
514 | \ | |
515 | /* Now that we wrote the output increment the input pointer. */ \ | |
516 | inptr++; \ | |
517 | } | |
518 | #define LOOP_NEED_FLAGS | |
519 | #define EXTRA_LOOP_DECLS , int *statep | |
520 | #include <iconv/loop.c> | |
521 | ||
522 | ||
523 | /* Next, define the other direction, from UCS-4 to TSCII. */ | |
524 | ||
525 | static const uint8_t ucs4_to_tscii[128] = | |
526 | { | |
527 | 0, 0, 0, 0xb7, 0, 0xab, 0xac, 0xfe, /* 0x0B80..0x0B87 */ | |
528 | 0xae, 0xaf, 0xb0, 0, 0, 0, 0xb1, 0xb2, /* 0x0B88..0x0B8F */ | |
529 | 0xb3, 0, 0xb4, 0xb5, 0xb6, 0xb8, 0, 0, /* 0x0B90..0x0B97 */ | |
530 | 0, 0xb9, 0xba, 0, 0x83, 0, 0xbb, 0xbc, /* 0x0B98..0x0B9F */ | |
531 | 0, 0, 0, 0xbd, 0xbe, 0, 0, 0, /* 0x0BA0..0x0BA7 */ | |
532 | 0xbf, 0xc9, 0xc0, 0, 0, 0, 0xc1, 0xc2, /* 0x0BA8..0x0BAF */ | |
533 | 0xc3, 0xc8, 0xc4, 0xc7, 0xc6, 0xc5, 0, 0x84, /* 0x0BB0..0x0BB7 */ | |
534 | 0x85, 0x86, 0, 0, 0, 0, 0xa1, 0xa2, /* 0x0BB8..0x0BBF */ | |
535 | 0xa3, 0xa4, 0xa5, 0, 0, 0, 0xa6, 0xa7, /* 0x0BC0..0x0BC7 */ | |
536 | 0xa8, 0, 0, 0, 0, 0, 0, 0, /* 0x0BC8..0x0BCF */ | |
537 | 0, 0, 0, 0, 0, 0, 0, 0xaa, /* 0x0BD0..0x0BD7 */ | |
538 | 0, 0, 0, 0, 0, 0, 0, 0, /* 0x0BD8..0x0BDF */ | |
539 | 0, 0, 0, 0, 0, 0, 0x80, 0x81, /* 0x0BE0..0x0BE7 */ | |
540 | 0x8d, 0x8e, 0x8f, 0x90, 0x95, 0x96, 0x97, 0x98, /* 0x0BE8..0x0BEF */ | |
541 | 0x9d, 0x9e, 0x9f, 0, 0, 0, 0, 0, /* 0x0BF0..0x0BF7 */ | |
542 | 0, 0, 0, 0, 0, 0, 0, 0 /* 0x0BF8..0x0BFF */ | |
543 | }; | |
544 | ||
545 | static const uint8_t consonant_with_u[18] = | |
546 | { | |
547 | 0xcc, 0x99, 0xcd, 0x9a, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, | |
548 | 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb | |
549 | }; | |
550 | ||
551 | static const uint8_t consonant_with_uu[18] = | |
552 | { | |
553 | 0xdc, 0x9b, 0xdd, 0x9c, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, | |
554 | 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb | |
555 | }; | |
556 | ||
557 | static const uint8_t consonant_with_virama[18] = | |
558 | { | |
559 | 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, | |
560 | 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd | |
561 | }; | |
562 | ||
563 | #define MIN_NEEDED_INPUT TO_LOOP_MIN_NEEDED_FROM | |
564 | #define MAX_NEEDED_INPUT TO_LOOP_MAX_NEEDED_FROM | |
565 | #define MIN_NEEDED_OUTPUT TO_LOOP_MIN_NEEDED_TO | |
566 | #define MAX_NEEDED_OUTPUT TO_LOOP_MAX_NEEDED_TO | |
567 | #define LOOPFCT TO_LOOP | |
568 | #define BODY \ | |
569 | { \ | |
570 | uint32_t ch = get32 (inptr); \ | |
571 | \ | |
572 | if ((*statep >> 3) != 0) \ | |
573 | { \ | |
574 | /* Attempt to combine the last character with this one. */ \ | |
575 | uint32_t last = *statep >> 3; \ | |
576 | \ | |
577 | if (last >= 0xb8 && last <= 0xc9) \ | |
578 | { \ | |
579 | if (ch == 0x0BC1) \ | |
580 | { \ | |
581 | *outptr++ = consonant_with_u[last - 0xb8]; \ | |
582 | *statep = 0; \ | |
583 | inptr += 4; \ | |
584 | continue; \ | |
585 | } \ | |
586 | if (ch == 0x0BC2) \ | |
587 | { \ | |
588 | *outptr++ = consonant_with_uu[last - 0xb8]; \ | |
589 | *statep = 0; \ | |
590 | inptr += 4; \ | |
591 | continue; \ | |
592 | } \ | |
593 | if (ch == 0x0BC6) \ | |
594 | { \ | |
595 | if (__builtin_expect (outptr + 2 <= outend, 1)) \ | |
596 | { \ | |
597 | *outptr++ = 0xa6; \ | |
598 | *outptr++ = last; \ | |
599 | *statep = 0; \ | |
600 | inptr += 4; \ | |
601 | continue; \ | |
602 | } \ | |
603 | else \ | |
604 | { \ | |
605 | result = __GCONV_FULL_OUTPUT; \ | |
606 | break; \ | |
607 | } \ | |
608 | } \ | |
609 | if (ch == 0x0BC7) \ | |
610 | { \ | |
611 | if (__builtin_expect (outptr + 2 <= outend, 1)) \ | |
612 | { \ | |
613 | *outptr++ = 0xa7; \ | |
614 | *outptr++ = last; \ | |
615 | *statep = 0; \ | |
616 | inptr += 4; \ | |
617 | continue; \ | |
618 | } \ | |
619 | else \ | |
620 | { \ | |
621 | result = __GCONV_FULL_OUTPUT; \ | |
622 | break; \ | |
623 | } \ | |
624 | } \ | |
625 | if (ch == 0x0BC8) \ | |
626 | { \ | |
627 | if (__builtin_expect (outptr + 2 <= outend, 1)) \ | |
628 | { \ | |
629 | *outptr++ = 0xa8; \ | |
630 | *outptr++ = last; \ | |
631 | *statep = 0; \ | |
632 | inptr += 4; \ | |
633 | continue; \ | |
634 | } \ | |
635 | else \ | |
636 | { \ | |
637 | result = __GCONV_FULL_OUTPUT; \ | |
638 | break; \ | |
639 | } \ | |
640 | } \ | |
641 | if (ch == 0x0BCA) \ | |
642 | { \ | |
643 | if (__builtin_expect (outptr + 3 <= outend, 1)) \ | |
644 | { \ | |
645 | *outptr++ = 0xa6; \ | |
646 | *outptr++ = last; \ | |
647 | *outptr++ = 0xa1; \ | |
648 | *statep = 0; \ | |
649 | inptr += 4; \ | |
650 | continue; \ | |
651 | } \ | |
652 | else \ | |
653 | { \ | |
654 | result = __GCONV_FULL_OUTPUT; \ | |
655 | break; \ | |
656 | } \ | |
657 | } \ | |
658 | if (ch == 0x0BCB) \ | |
659 | { \ | |
660 | if (__builtin_expect (outptr + 3 <= outend, 1)) \ | |
661 | { \ | |
662 | *outptr++ = 0xa7; \ | |
663 | *outptr++ = last; \ | |
664 | *outptr++ = 0xa1; \ | |
665 | *statep = 0; \ | |
666 | inptr += 4; \ | |
667 | continue; \ | |
668 | } \ | |
669 | else \ | |
670 | { \ | |
671 | result = __GCONV_FULL_OUTPUT; \ | |
672 | break; \ | |
673 | } \ | |
674 | } \ | |
675 | if (ch == 0x0BCC) \ | |
676 | { \ | |
677 | if (__builtin_expect (outptr + 3 <= outend, 1)) \ | |
678 | { \ | |
679 | *outptr++ = 0xa7; \ | |
680 | *outptr++ = last; \ | |
681 | *outptr++ = 0xaa; \ | |
682 | *statep = 0; \ | |
683 | inptr += 4; \ | |
684 | continue; \ | |
685 | } \ | |
686 | else \ | |
687 | { \ | |
688 | result = __GCONV_FULL_OUTPUT; \ | |
689 | break; \ | |
690 | } \ | |
691 | } \ | |
692 | if (ch == 0x0BCD) \ | |
693 | { \ | |
694 | if (last != 0xb8) \ | |
695 | { \ | |
696 | *outptr++ = consonant_with_virama[last - 0xb8]; \ | |
697 | *statep = 0; \ | |
698 | } \ | |
699 | else \ | |
700 | *statep = 0xec << 3; \ | |
701 | inptr += 4; \ | |
702 | continue; \ | |
703 | } \ | |
704 | if (last == 0xbc && (ch == 0x0BBF || ch == 0x0BC0)) \ | |
705 | { \ | |
706 | *outptr++ = ch - 0x0af5; \ | |
707 | *statep = 0; \ | |
708 | inptr += 4; \ | |
709 | continue; \ | |
710 | } \ | |
711 | } \ | |
712 | else if (last >= 0x83 && last <= 0x86) \ | |
713 | { \ | |
714 | if (last >= 0x85 && (ch == 0x0BC1 || ch == 0x0BC2)) \ | |
715 | { \ | |
716 | *outptr++ = last + 5; \ | |
717 | *statep = 0; \ | |
718 | continue; \ | |
719 | } \ | |
720 | if (ch == 0x0BCD) \ | |
721 | { \ | |
722 | if (last != 0x85) \ | |
723 | { \ | |
724 | *outptr++ = last + 5; \ | |
725 | *statep = 0; \ | |
726 | } \ | |
727 | else \ | |
728 | *statep = 0x8a << 3; \ | |
729 | inptr += 4; \ | |
730 | continue; \ | |
731 | } \ | |
732 | } \ | |
733 | else if (last == 0xec) \ | |
734 | { \ | |
735 | if (ch == 0x0BB7) \ | |
736 | { \ | |
737 | *statep = 0x87 << 3; \ | |
738 | inptr += 4; \ | |
739 | continue; \ | |
740 | } \ | |
741 | } \ | |
742 | else if (last == 0x8a) \ | |
743 | { \ | |
744 | if (ch == 0x0BB0) \ | |
745 | { \ | |
746 | *statep = 0xc38a << 3; \ | |
747 | inptr += 4; \ | |
748 | continue; \ | |
749 | } \ | |
750 | } \ | |
751 | else if (last == 0x87) \ | |
752 | { \ | |
753 | if (ch == 0x0BCD) \ | |
754 | { \ | |
755 | *outptr++ = 0x8c; \ | |
756 | *statep = 0; \ | |
757 | inptr += 4; \ | |
758 | continue; \ | |
759 | } \ | |
760 | } \ | |
761 | else \ | |
762 | { \ | |
763 | assert (last == 0xc38a); \ | |
764 | if (ch == 0x0BC0) \ | |
765 | { \ | |
766 | *outptr++ = 0x82; \ | |
767 | *statep = 0; \ | |
768 | inptr += 4; \ | |
769 | continue; \ | |
770 | } \ | |
771 | } \ | |
772 | \ | |
773 | /* Output the buffered character. */ \ | |
774 | if (__builtin_expect (last >> 8, 0)) \ | |
775 | { \ | |
776 | if (__builtin_expect (outptr + 2 <= outend, 1)) \ | |
777 | { \ | |
778 | *outptr++ = last & 0xff; \ | |
779 | *outptr++ = (last >> 8) & 0xff; \ | |
780 | } \ | |
781 | else \ | |
782 | { \ | |
783 | result = __GCONV_FULL_OUTPUT; \ | |
784 | break; \ | |
785 | } \ | |
786 | } \ | |
787 | else \ | |
788 | *outptr++ = last & 0xff; \ | |
789 | *statep = 0; \ | |
790 | continue; \ | |
791 | } \ | |
792 | \ | |
793 | if (ch < 0x80) \ | |
794 | /* Plain ASCII character. */ \ | |
795 | *outptr++ = ch; \ | |
796 | else if (ch >= 0x0B80 && ch <= 0x0BFF) \ | |
797 | { \ | |
798 | /* Tamil character. */ \ | |
799 | uint8_t t = ucs4_to_tscii[ch - 0x0B80]; \ | |
800 | \ | |
801 | if (t != 0) \ | |
802 | { \ | |
803 | if ((t >= 0xb8 && t <= 0xc9) || (t >= 0x83 && t <= 0x86)) \ | |
804 | *statep = (uint32_t) t << 3; \ | |
805 | else \ | |
806 | *outptr++ = t; \ | |
807 | } \ | |
808 | else if (ch >= 0x0BCA && ch <= 0x0BCC) \ | |
809 | { \ | |
810 | /* See whether we have room for two bytes. */ \ | |
811 | if (__builtin_expect (outptr + 2 <= outend, 1)) \ | |
812 | { \ | |
813 | *outptr++ = (ch == 0x0BCA ? 0xa6 : 0xa7); \ | |
814 | *outptr++ = (ch != 0x0BCC ? 0xa1 : 0xaa); \ | |
815 | } \ | |
816 | else \ | |
817 | { \ | |
818 | result = __GCONV_FULL_OUTPUT; \ | |
819 | break; \ | |
820 | } \ | |
821 | } \ | |
822 | else \ | |
823 | { \ | |
824 | /* Illegal character. */ \ | |
825 | STANDARD_TO_LOOP_ERR_HANDLER (4); \ | |
826 | } \ | |
827 | } \ | |
828 | else if (ch == 0x00A9) \ | |
829 | *outptr++ = ch; \ | |
830 | else if (ch == 0x2018 || ch == 0x2019) \ | |
831 | *outptr++ = ch - 0x1f87; \ | |
832 | else if (ch == 0x201C || ch == 0x201D) \ | |
833 | *outptr++ = ch - 0x1f89; \ | |
834 | else \ | |
835 | { \ | |
836 | UNICODE_TAG_HANDLER (ch, 4); \ | |
837 | \ | |
838 | /* Illegal character. */ \ | |
839 | STANDARD_TO_LOOP_ERR_HANDLER (4); \ | |
840 | } \ | |
841 | \ | |
842 | /* Now that we wrote the output increment the input pointer. */ \ | |
843 | inptr += 4; \ | |
844 | } | |
845 | #define LOOP_NEED_FLAGS | |
846 | #define EXTRA_LOOP_DECLS , int *statep | |
847 | #include <iconv/loop.c> | |
848 | ||
849 | ||
850 | /* Now define the toplevel functions. */ | |
851 | #include <iconv/skeleton.c> |