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