?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update.
[glibc.git] / iconvdata / iso-2022-cn-ext.c
blob60e875cf02e45fc1a6965836606fc706dd80184c
1 /* Conversion module for ISO-2022-CN-EXT.
2 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 2000.
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 <gconv.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include "gb2312.h"
27 #include "iso-ir-165.h"
28 #include "cns11643.h"
29 #include "cns11643l1.h"
30 #include "cns11643l2.h"
31
32 #include <assert.h>
33
34 /* This makes obvious what everybody knows: 0x1b is the Esc character. */
35 #define ESC 0x1b
36
37 /* We have single-byte shift-in and shift-out sequences, and the single
38 shift sequences SS2 and SS3 which replaces the SS2/SS3 designation for
39 the next two bytes. */
40 #define SI 0x0f
41 #define SO 0x0e
42 #define SS2_0 ESC
43 #define SS2_1 0x4e
44 #define SS3_0 ESC
45 #define SS3_1 0x4f
46
47 /* Definitions used in the body of the `gconv' function. */
48 #define CHARSET_NAME "ISO-2022-CN-EXT//"
49 #define DEFINE_INIT 1
50 #define DEFINE_FINI 1
51 #define FROM_LOOP from_iso2022cn_ext_loop
52 #define TO_LOOP to_iso2022cn_ext_loop
53 #define MIN_NEEDED_FROM 1
54 #define MAX_NEEDED_FROM 4
55 #define MIN_NEEDED_TO 4
56 #define MAX_NEEDED_TO 4
57 #define PREPARE_LOOP \
58 int save_set; \
59 int *setp = &data->__statep->__count;
60 #define EXTRA_LOOP_ARGS , setp
61
62
63 /* The charsets GB/T 12345-90, GB 7589-87, GB/T 13131-9X, GB 7590-87,
64 and GB/T 13132-9X are not registered to the best of my knowledge and
65 therefore have no escape sequence assigned. We cannot handle them
66 for this reason. Tell the implementation about this. */
67 #define X12345 '\0'
68 #define X7589 '\0'
69 #define X13131 '\0'
70 #define X7590 '\0'
71 #define X13132 '\0'
72
73
74 /* The COUNT element of the state keeps track of the currently selected
75 character set. The possible values are: */
76 enum
77 {
78 ASCII_set = 0,
79 GB2312_set,
80 GB12345_set,
81 CNS11643_1_set,
82 ISO_IR_165_set,
83 SO_mask = 7,
84
85 GB7589_set = 1 << 3,
86 GB13131_set = 2 << 3,
87 CNS11643_2_set = 3 << 3,
88 SS2_mask = 3 << 3,
89
90 GB7590_set = 1 << 5,
91 GB13132_set = 2 << 5,
92 CNS11643_3_set = 3 << 5,
93 CNS11643_4_set = 4 << 5,
94 CNS11643_5_set = 5 << 5,
95 CNS11643_6_set = 6 << 5,
96 CNS11643_7_set = 7 << 5,
97 SS3_mask = 7 << 5,
98
99 #define CURRENT_MASK (SO_mask | SS2_mask | SS3_mask)
100
101 GB2312_ann = 1 << 8,
102 GB12345_ann = 2 << 8,
103 CNS11643_1_ann = 3 << 8,
104 ISO_IR_165_ann = 4 << 8,
105 SO_ann = 7 << 8,
106
107 GB7589_ann = 1 << 11,
108 GB13131_ann = 2 << 11,
109 CNS11643_2_ann = 3 << 11,
110 SS2_ann = 3 << 11,
111
112 GB7590_ann = 1 << 13,
113 GB13132_ann = 2 << 13,
114 CNS11643_3_ann = 3 << 13,
115 CNS11643_4_ann = 4 << 13,
116 CNS11643_5_ann = 5 << 13,
117 CNS11643_6_ann = 6 << 13,
118 CNS11643_7_ann = 7 << 13,
119 SS3_ann = 7 << 13
120 };
121
122
123 /* Since this is a stateful encoding we have to provide code which resets
124 the output state to the initial state. This has to be done during the
125 flushing. */
126 #define EMIT_SHIFT_TO_INIT \
127 if (data->__statep->__count >> 3 != ASCII_set) \
128 { \
129 if (FROM_DIRECTION) \
130 /* It's easy, we don't have to emit anything, we just reset the \
131 state for the input. */ \
132 data->__statep->__count = ASCII_set << 3; \
133 else \
134 { \
135 /* We are not in the initial state. To switch back we have \
136 to emit `SI'. */ \
137 if (__builtin_expect (outbuf == outend, 0)) \
138 /* We don't have enough room in the output buffer. */ \
139 status = __GCONV_FULL_OUTPUT; \
140 else \
141 { \
142 /* Write out the shift sequence. */ \
143 *outbuf++ = SI; \
144 if (data->__flags & __GCONV_IS_LAST) \
145 *irreversible += 1; \
146 data->__statep->__count = ASCII_set << 3; \
147 } \
148 } \
149 }
150
151
152 /* Since we might have to reset input pointer we must be able to save
153 and retore the state. */
154 #define SAVE_RESET_STATE(Save) \
155 if (Save) \
156 save_set = *setp; \
157 else \
158 *setp = save_set
159
160
161 /* First define the conversion function from ISO-2022-CN to UCS4. */
162 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
163 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
164 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
165 #define LOOPFCT FROM_LOOP
166 #define BODY \
167 { \
168 uint32_t ch = *inptr; \
169 \
170 /* This is a 7bit character set, disallow all 8bit characters. */ \
171 if (ch > 0x7f) \
172 { \
173 if (! ignore_errors_p ()) \
174 { \
175 result = __GCONV_ILLEGAL_INPUT; \
176 break; \
177 } \
178 ++inptr; \
179 ++*irreversible; \
180 continue; \
181 } \
182 \
183 /* Recognize escape sequences. */ \
184 if (ch == ESC) \
185 { \
186 /* There are three kinds of escape sequences we have to handle: \
187 - those announcing the use of GB and CNS characters on the \
188 line; we can simply ignore them \
189 - the initial byte of the SS2 sequence. \
190 - the initial byte of the SS3 sequence. \
191 */ \
192 if (inptr + 2 > inend \
193 || (inptr[1] == '$' \
194 && (inptr + 3 > inend \
195 || (inptr[2] == ')' && inptr + 4 > inend) \
196 || (inptr[2] == '*' && inptr + 4 > inend) \
197 || (inptr[2] == '+' && inptr + 4 > inend))) \
198 || (inptr[1] == SS2_1 && inptr + 4 > inend) \
199 || (inptr[1] == SS3_1 && inptr + 4 > inend)) \
200 { \
201 result = __GCONV_INCOMPLETE_INPUT; \
202 break; \
203 } \
204 if (inptr[1] == '$' \
205 && ((inptr[2] == ')' \
206 && (inptr[3] == 'A' \
207 || (X12345 != '\0' && inptr[3] == X12345) \
208 || inptr[3] == 'E' || inptr[3] == 'G')) \
209 || (inptr[2] == '*' \
210 && ((X7589 != '\0' && inptr[3] == X7589) \
211 || (X13131 != '\0' && inptr[3] == X13131) \
212 || inptr[3] == 'H')) \
213 || (inptr[2] == '+' \
214 && ((X7590 != '\0' && inptr[3] == X7590) \
215 || (X13132 != '\0' && inptr[3] == X13132) \
216 || inptr[3] == 'I' || inptr[3] == 'J' \
217 || inptr[3] == 'K' || inptr[3] == 'L' \
218 || inptr[3] == 'M')))) \
219 { \
220 /* OK, we accept those character sets. */ \
221 if (inptr[3] == 'A') \
222 ann = (ann & ~SO_ann) | GB2312_ann; \
223 else if (inptr[3] == 'G') \
224 ann = (ann & ~SO_ann) | CNS11643_1_ann; \
225 else if (inptr[3] == 'E') \
226 ann = (ann & ~SO_ann) | ISO_IR_165_ann; \
227 else if (X12345 != '\0' && inptr[3] == X12345) \
228 ann = (ann & ~SO_ann) | GB12345_ann; \
229 else if (inptr[3] == 'H') \
230 ann = (ann & ~SS2_ann) | CNS11643_2_ann; \
231 else if (X7589 != '\0' && inptr[3] == X7589) \
232 ann = (ann & ~SS2_ann) | GB7589_ann; \
233 else if (X13131 != '\0' && inptr[3] == X13131) \
234 ann = (ann & ~SS2_ann) | GB13131_ann; \
235 else if (inptr[3] == 'I') \
236 ann = (ann & ~SS3_ann) | CNS11643_3_ann; \
237 else if (inptr[3] == 'J') \
238 ann = (ann & ~SS3_ann) | CNS11643_4_ann; \
239 else if (inptr[3] == 'K') \
240 ann = (ann & ~SS3_ann) | CNS11643_5_ann; \
241 else if (inptr[3] == 'L') \
242 ann = (ann & ~SS3_ann) | CNS11643_6_ann; \
243 else if (inptr[3] == 'M') \
244 ann = (ann & ~SS3_ann) | CNS11643_7_ann; \
245 else if (X7590 != '\0' && inptr[3] == X7590) \
246 ann = (ann & ~SS3_ann) | GB7590_ann; \
247 else if (X13132 != '\0' && inptr[3] == X13132) \
248 ann = (ann & ~SS3_ann) | GB13132_ann; \
249 inptr += 4; \
250 continue; \
251 } \
252 } \
253 else if (ch == SO) \
254 { \
255 /* Switch to use GB2312, GB12345, CNS 11643 plane 1, or ISO-IR-165, \
256 depending on which S0 designation came last. The only problem \
257 is what to do with faulty input files where no designator came. \
258 XXX For now I'll default to use GB2312. If this is not the \
259 best behavior (e.g., we should flag an error) let me know. */ \
260 ++inptr; \
261 if ((ann & SO_ann) != 0) \
262 switch (ann & SO_ann) \
263 { \
264 case GB2312_ann: \
265 set = GB2312_set; \
266 break; \
267 case GB12345_ann: \
268 set = GB12345_set; \
269 break; \
270 case CNS11643_1_ann: \
271 set = CNS11643_1_set; \
272 break; \
273 case ISO_IR_165_ann: \
274 set = ISO_IR_165_set; \
275 break; \
276 default: \
277 abort (); \
278 } \
279 else \
280 { \
281 if (! ignore_errors_p ()) \
282 { \
283 result = __GCONV_ILLEGAL_INPUT; \
284 break; \
285 } \
286 ++inptr; \
287 ++*irreversible; \
288 } \
289 continue; \
290 } \
291 else if (ch == SI) \
292 { \
293 /* Switch to use ASCII. */ \
294 ++inptr; \
295 set = ASCII_set; \
296 continue; \
297 } \
298 \
299 if (ch == ESC && inptr[1] == SS2_1) \
300 { \
301 /* This is a character from CNS 11643 plane 2. \
302 XXX We could test here whether the use of this character \
303 set was announced. \
304 XXX Currently GB7589 and GB13131 are not supported. */ \
305 inptr += 2; \
306 ch = cns11643l2_to_ucs4 (&inptr, 2, 0); \
307 if (ch == __UNKNOWN_10646_CHAR) \
308 { \
309 if (! ignore_errors_p ()) \
310 { \
311 inptr -= 2; \
312 result = __GCONV_ILLEGAL_INPUT; \
313 break; \
314 } \
315 inptr += 2; \
316 ++*irreversible; \
317 continue; \
318 } \
319 } \
320 /* Note that we can assume here that at least 4 bytes are available if \
321 the first byte is ESC since otherwise the first if would have been \
322 true. */ \
323 else if (ch == ESC && inptr[1] == SS3_1) \
324 { \
325 /* This is a character from CNS 11643 plane 3 or higher. \
326 XXX Currently GB7590 and GB13132 are not supported. */ \
327 char buf[3]; \
328 const char *tmp = buf; \
329 \
330 buf[1] = inptr[2]; \
331 buf[2] = inptr[3]; \
332 switch (ann & SS3_ann) \
333 { \
334 case CNS11643_3_ann: \
335 buf[0] = 0x23; \
336 ch = cns11643_to_ucs4 (&tmp, 3, 0); \
337 break; \
338 case CNS11643_4_ann: \
339 buf[0] = 0x24; \
340 ch = cns11643_to_ucs4 (&tmp, 3, 0); \
341 break; \
342 case CNS11643_5_ann: \
343 buf[0] = 0x25; \
344 ch = cns11643_to_ucs4 (&tmp, 3, 0); \
345 break; \
346 case CNS11643_6_ann: \
347 buf[0] = 0x26; \
348 ch = cns11643_to_ucs4 (&tmp, 3, 0); \
349 break; \
350 case CNS11643_7_ann: \
351 buf[0] = 0x27; \
352 ch = cns11643_to_ucs4 (&tmp, 3, 0); \
353 break; \
354 default: \
355 /* XXX Currently GB7590 and GB13132 are not supported. */ \
356 ch = __UNKNOWN_10646_CHAR; \
357 break; \
358 } \
359 if (ch == __UNKNOWN_10646_CHAR) \
360 { \
361 if (! ignore_errors_p ()) \
362 { \
363 result = __GCONV_ILLEGAL_INPUT; \
364 break; \
365 } \
366 inptr += 4; \
367 ++*irreversible; \
368 continue; \
369 } \
370 assert (tmp == buf + 3); \
371 inptr += 4; \
372 } \
373 else if (set == ASCII_set) \
374 { \
375 /* Almost done, just advance the input pointer. */ \
376 ++inptr; \
377 } \
378 else \
379 { \
380 /* That's pretty easy, we have a dedicated functions for this. */ \
381 if (inend - inptr < 2) \
382 { \
383 result = __GCONV_INCOMPLETE_INPUT; \
384 break; \
385 } \
386 if (set == GB2312_set) \
387 ch = gb2312_to_ucs4 (&inptr, inend - inptr, 0); \
388 else if (set == ISO_IR_165_set) \
389 ch = isoir165_to_ucs4 (&inptr, inend - inptr); \
390 else \
391 { \
392 assert (set == CNS11643_1_set); \
393 ch = cns11643l1_to_ucs4 (&inptr, inend - inptr, 0); \
394 } \
395 \
396 if (ch == 0) \
397 { \
398 result = __GCONV_INCOMPLETE_INPUT; \
399 break; \
400 } \
401 else if (ch == __UNKNOWN_10646_CHAR) \
402 { \
403 if (! ignore_errors_p ()) \
404 { \
405 result = __GCONV_ILLEGAL_INPUT; \
406 break; \
407 } \
408 inptr += 2; \
409 ++*irreversible; \
410 continue; \
411 } \
412 } \
413 \
414 *((uint32_t *) outptr)++ = ch; \
415 }
416 #define EXTRA_LOOP_DECLS , int *setp
417 #define INIT_PARAMS int set = (*setp >> 3) & CURRENT_MASK; \
418 int ann = (*setp >> 3) & ~CURRENT_MASK
419 #define UPDATE_PARAMS *setp = (set | ann) << 3
420 #define LOOP_NEED_FLAGS
421 #include <iconv/loop.c>
422
423
424 /* Next, define the other direction. */
425 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
426 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
427 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
428 #define LOOPFCT TO_LOOP
429 #define BODY \
430 { \
431 uint32_t ch; \
432 size_t written = 0; \
433 \
434 ch = *((const uint32_t *) inptr); \
435 \
436 /* First see whether we can write the character using the currently \
437 selected character set. */ \
438 if (ch < 0x80) \
439 { \
440 if (set != ASCII_set) \
441 { \
442 *outptr++ = SI; \
443 set = ASCII_set; \
444 if (outptr == outend) \
445 { \
446 result = __GCONV_FULL_OUTPUT; \
447 break; \
448 } \
449 } \
450 \
451 *outptr++ = ch; \
452 written = 1; \
453 \
454 /* At the end of the line we have to clear the `ann' flags since \
455 every line must contain this information again. */ \
456 if (ch == L'\n') \
457 ann = 0; \
458 } \
459 else \
460 { \
461 char buf[2]; \
462 int used; \
463 \
464 if (set == GB2312_set || ((ann & SO_ann) != CNS11643_1_ann \
465 && (ann & SO_ann) != ISO_IR_165_ann)) \
466 { \
467 written = ucs4_to_gb2312 (ch, buf, 2); \
468 used = GB2312_set; \
469 } \
470 else if (set == ISO_IR_165_set || (ann & SO_ann) == ISO_IR_165_set) \
471 { \
472 written = ucs4_to_isoir165 (ch, buf, 2); \
473 used = ISO_IR_165_set; \
474 } \
475 else \
476 { \
477 written = ucs4_to_cns11643l1 (ch, buf, 2); \
478 used = CNS11643_1_set; \
479 } \
480 \
481 if (written == __UNKNOWN_10646_CHAR) \
482 { \
483 /* Cannot convert it using the currently selected SO set. \
484 Next try the SS2 set. */ \
485 written = ucs4_to_cns11643l2 (ch, buf, 2); \
486 if (written != __UNKNOWN_10646_CHAR) \
487 /* Yep, that worked. */ \
488 used = CNS11643_2_set; \
489 else \
490 { \
491 char tmpbuf[3]; \
492 \
493 switch (0) \
494 { \
495 default: \
496 /* Well, see whether we have to change the SO set. */ \
497 \
498 if (used != GB2312_set) \
499 { \
500 written = ucs4_to_gb2312 (ch, buf, 2); \
501 if (written != __UNKNOWN_10646_CHAR) \
502 { \
503 used = GB2312_set; \
504 break; \
505 } \
506 } \
507 \
508 if (used != ISO_IR_165_set) \
509 { \
510 written = ucs4_to_isoir165 (ch, buf, 2); \
511 if (written != __UNKNOWN_10646_CHAR) \
512 { \
513 used = ISO_IR_165_set; \
514 break; \
515 } \
516 } \
517 \
518 if (used != CNS11643_1_set) \
519 { \
520 written = ucs4_to_cns11643l1 (ch, buf, 2); \
521 if (written != __UNKNOWN_10646_CHAR) \
522 { \
523 used = CNS11643_1_set; \
524 break; \
525 } \
526 } \
527 \
528 written = ucs4_to_cns11643 (ch, tmpbuf, 3); \
529 if (written == 3 && tmpbuf[0] >= 3 && tmpbuf[0] <= 7) \
530 { \
531 buf[0] = tmpbuf[1]; \
532 buf[1] = tmpbuf[2]; \
533 switch (tmpbuf[0]) \
534 { \
535 case 3: \
536 used = CNS11643_3_set; \
537 break; \
538 case 4: \
539 used = CNS11643_4_set; \
540 break; \
541 case 5: \
542 used = CNS11643_5_set; \
543 break; \
544 case 6: \
545 used = CNS11643_6_set; \
546 break; \
547 case 7: \
548 used = CNS11643_7_set; \
549 break; \
550 default: \
551 abort (); \
552 } \
553 written = 2; \
554 break; \
555 } \
556 \
557 /* XXX Currently GB7590 and GB13132 are not supported. */\
558 \
559 /* Even this does not work. Error. */ \
560 used = ASCII_set; \
561 } \
562 if (used == ASCII_set) \
563 { \
564 UNICODE_TAG_HANDLER (ch, 4); \
565 STANDARD_ERR_HANDLER (4); \
566 } \
567 } \
568 } \
569 assert (written == 2); \
570 \
571 /* See whether we have to emit an escape sequence. */ \
572 if (set != used) \
573 { \
574 /* First see whether we announced that we use this \
575 character set. */ \
576 if ((used & SO_mask) != 0 && (ann & SO_ann) != (used << 8)) \
577 { \
578 const char *escseq; \
579 \
580 if (outptr + 4 > outend) \
581 { \
582 result = __GCONV_FULL_OUTPUT; \
583 break; \
584 } \
585 \
586 assert (used >= 1 && used <= 4); \
587 escseq = ")A\0\0)G)E" + (used - 1) * 2; \
588 *outptr++ = ESC; \
589 *outptr++ = '$'; \
590 *outptr++ = *escseq++; \
591 *outptr++ = *escseq++; \
592 \
593 ann = (ann & ~SO_ann) | (used << 8); \
594 } \
595 else if ((used & SS2_mask) != 0 && (ann & SS2_ann) != (used << 8))\
596 { \
597 const char *escseq; \
598 \
599 assert (used == CNS11643_2_set); /* XXX */ \
600 escseq = "*H"; \
601 *outptr++ = ESC; \
602 *outptr++ = '$'; \
603 *outptr++ = *escseq++; \
604 *outptr++ = *escseq++; \
605 \
606 ann = (ann & ~SS2_ann) | (used << 8); \
607 } \
608 else if ((used & SS3_mask) != 0 && (ann & SS3_ann) != (used << 8))\
609 { \
610 const char *escseq; \
611 \
612 assert ((used >> 5) >= 3 && (used >> 5) <= 7); \
613 escseq = "+I+J+K+L+M" + ((used >> 5) - 3) * 2; \
614 *outptr++ = ESC; \
615 *outptr++ = '$'; \
616 *outptr++ = *escseq++; \
617 *outptr++ = *escseq++; \
618 \
619 ann = (ann & ~SS3_ann) | (used << 8); \
620 } \
621 \
622 if (used == CNS11643_2_set) \
623 { \
624 if (outptr + 2 > outend) \
625 { \
626 result = __GCONV_FULL_OUTPUT; \
627 break; \
628 } \
629 *outptr++ = SS2_0; \
630 *outptr++ = SS2_1; \
631 } \
632 else if (used >= CNS11643_3_set && used <= CNS11643_7_set) \
633 { \
634 if (outptr + 2 > outend) \
635 { \
636 result = __GCONV_FULL_OUTPUT; \
637 break; \
638 } \
639 *outptr++ = SS3_0; \
640 *outptr++ = SS3_1; \
641 } \
642 else \
643 { \
644 /* We only have to emit something if currently ASCII is \
645 selected. Otherwise we are switching within the \
646 SO charset. */ \
647 if (set == ASCII_set) \
648 { \
649 if (outptr + 1 > outend) \
650 { \
651 result = __GCONV_FULL_OUTPUT; \
652 break; \
653 } \
654 *outptr++ = SO; \
655 } \
656 } \
657 \
658 /* Always test the length here since we have used up all the \
659 guaranteed output buffer slots. */ \
660 if (outptr + 2 > outend) \
661 { \
662 result = __GCONV_FULL_OUTPUT; \
663 break; \
664 } \
665 } \
666 else if (outptr + 2 > outend) \
667 { \
668 result = __GCONV_FULL_OUTPUT; \
669 break; \
670 } \
671 \
672 *outptr++ = buf[0]; \
673 *outptr++ = buf[1]; \
674 set = used; \
675 } \
676 \
677 /* Now that we wrote the output increment the input pointer. */ \
678 inptr += 4; \
679 }
680 #define EXTRA_LOOP_DECLS , int *setp
681 #define INIT_PARAMS int set = (*setp >> 3) & CURRENT_MASK; \
682 int ann = (*setp >> 3) & ~CURRENT_MASK
683 #define UPDATE_PARAMS *setp = (set | ann) << 3
684 #define LOOP_NEED_FLAGS
685 #include <iconv/loop.c>
686
687
688 /* Now define the toplevel functions. */
689 #include <iconv/skeleton.c>
sources.redhat.com git mirror of glibc CVS