?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update.
[glibc.git] / iconvdata / iso-2022-jp.c
blobe888d310b722f3e469c09e49fe241859acf96697
1 /* Conversion module for ISO-2022-JP.
2 Copyright (C) 1998 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 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 Library General Public License for more details.
15
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21 #include <gconv.h>
22 #include <stdint.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include "jis0201.h"
26 #include "jis0208.h"
27 #include "jis0212.h"
28 #include "gb2312.h"
29 #include "ksc5601.h"
30
31 struct gap
32 {
33 uint16_t start;
34 uint16_t end;
35 int32_t idx;
36 };
37
38 #include "iso8859-7jp.h"
39
40 /* This makes obvious what everybody knows: 0x1b is the Esc character. */
41 #define ESC 0x1b
42
43 /* We provide our own initialization and destructor function. */
44 #define DEFINE_INIT 0
45 #define DEFINE_FINI 0
46
47 /* Definitions used in the body of the `gconv' function. */
48 #define FROM_LOOP from_iso2022jp_loop
49 #define TO_LOOP to_iso2022jp_loop
50 #define MIN_NEEDED_FROM 1
51 #define MAX_NEEDED_FROM 4
52 #define MIN_NEEDED_TO 4
53 #define MAX_NEEDED_TO 4
54 #define FROM_DIRECTION (dir == from_iso2022jp)
55 #define PREPARE_LOOP \
56 enum direction dir = ((struct iso2022jp_data *) step->data)->dir; \
57 enum variant var = ((struct iso2022jp_data *) step->data)->var; \
58 int save_set; \
59 int *setp = &data->statep->count;
60 #define EXTRA_LOOP_ARGS , var, setp
61
62
63 /* Direction of the transformation. */
64 enum direction
65 {
66 illegal_dir,
67 to_iso2022jp,
68 from_iso2022jp
69 };
70
71 /* We handle ISO-2022-jp and ISO-2022-JP-2 here. */
72 enum variant
73 {
74 illegal_var,
75 iso2022jp,
76 iso2022jp2
77 };
78
79
80 struct iso2022jp_data
81 {
82 enum direction dir;
83 enum variant var;
84 };
85
86
87 /* The COUNT element of the state keeps track of the currently selected
88 character set. The possible values are: */
89 enum
90 {
91 ASCII_set = 0,
92 JISX0208_1978_set,
93 JISX0208_1983_set,
94 JISX0201_Roman_set,
95 JISX0201_Kana_set,
96 GB2312_set,
97 KSC5601_set,
98 JISX0212_set,
99 ISO88591_set,
100 ISO88597_set
101 };
102
103
104 int
105 gconv_init (struct gconv_step *step)
106 {
107 /* Determine which direction. */
108 struct iso2022jp_data *new_data;
109 enum direction dir = illegal_dir;
110 enum variant var = illegal_var;
111 int result;
112
113 if (__strcasecmp (step->from_name, "ISO-2022-JP//") == 0)
114 {
115 dir = from_iso2022jp;
116 var = iso2022jp;
117 }
118 else if (__strcasecmp (step->to_name, "ISO-2022-JP//") == 0)
119 {
120 dir = to_iso2022jp;
121 var = iso2022jp;
122 }
123 else if (__strcasecmp (step->from_name, "ISO-2022-JP-2//") == 0)
124 {
125 dir = from_iso2022jp;
126 var = iso2022jp2;
127 }
128 else if (__strcasecmp (step->to_name, "ISO-2022-JP-2//") == 0)
129 {
130 dir = to_iso2022jp;
131 var = iso2022jp2;
132 }
133
134 result = GCONV_NOCONV;
135 if (dir != illegal_dir
136 && ((new_data
137 = (struct iso2022jp_data *) malloc (sizeof (struct iso2022jp_data)))
138 != NULL))
139 {
140 new_data->dir = dir;
141 new_data->var = var;
142 step->data = new_data;
143
144 if (dir == from_iso2022jp)
145 {
146 step->min_needed_from = MIN_NEEDED_FROM;
147 step->max_needed_from = MAX_NEEDED_FROM;
148 step->min_needed_to = MIN_NEEDED_TO;
149 step->max_needed_to = MIN_NEEDED_TO;
150 }
151 else
152 {
153 step->min_needed_from = MIN_NEEDED_TO;
154 step->max_needed_from = MAX_NEEDED_TO;
155 step->min_needed_to = MIN_NEEDED_FROM;
156 step->max_needed_to = MIN_NEEDED_FROM + 2;
157 }
158
159 /* Yes, this is a stateful encoding. */
160 step->stateful = 1;
161
162 result = GCONV_OK;
163 }
164
165 return result;
166 }
167
168
169 void
170 gconv_end (struct gconv_step *data)
171 {
172 free (data->data);
173 }
174
175
176 /* Since this is a stateful encoding we have to provide code which resets
177 the output state to the initial state. This has to be done during the
178 flushing. */
179 #define EMIT_SHIFT_TO_INIT \
180 if (data->statep->count != ASCII_set) \
181 { \
182 enum direction dir = ((struct iso2022jp_data *) step->data)->dir; \
183 \
184 if (dir == from_iso2022jp) \
185 /* It's easy, we don't have to emit anything, we just reset the \
186 state for the input. */ \
187 data->statep->count = ASCII_set; \
188 else \
189 { \
190 char *outbuf = data->outbuf; \
191 \
192 /* We are not in the initial state. To switch back we have \
193 to emit the sequence `Esc ( B'. */ \
194 if (outbuf + 3 > data->outbufend) \
195 /* We don't have enough room in the output buffer. */ \
196 status = GCONV_FULL_OUTPUT; \
197 else \
198 { \
199 /* Write out the shift sequence. */ \
200 *outbuf++ = ESC; \
201 *outbuf++ = '('; \
202 *outbuf++ = 'B'; \
203 data->outbuf = outbuf; \
204 data->statep->count = ASCII_set; \
205 } \
206 } \
207 }
208
209
210 /* Since we might have to reset input pointer we must be able to save
211 and retore the state. */
212 #define SAVE_RESET_STATE(Save) \
213 if (Save) \
214 save_set = *setp; \
215 else \
216 *setp = save_set
217
218
219 /* First define the conversion function from ISO-2022-JP to UCS4. */
220 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
221 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
222 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
223 #define LOOPFCT FROM_LOOP
224 #define BODY \
225 { \
226 uint32_t ch = *inptr; \
227 \
228 /* Recognize escape sequences. */ \
229 if (ch == ESC) \
230 { \
231 /* We now must be prepared to read two to three more \
232 chracters. If we have a match in the first character but \
233 then the input buffer ends we terminate with an error since \
234 we must not risk missing an escape sequence just because it \
235 is not entirely in the current input buffer. */ \
236 if (inptr + 2 >= inend \
237 || (var == iso2022jp2 && inptr[1] == '$' && inptr[2] == '(' \
238 && inptr + 3 >= inend)) \
239 { \
240 /* Not enough input available. */ \
241 result = GCONV_EMPTY_INPUT; \
242 break; \
243 } \
244 \
245 if (inptr[1] == '(') \
246 { \
247 if (inptr[2] == 'B') \
248 { \
249 /* ASCII selected. */ \
250 set = ASCII_set; \
251 inptr += 3; \
252 continue; \
253 } \
254 else if (inptr[2] == 'J') \
255 { \
256 /* JIS X 0201 selected. */ \
257 set = JISX0201_Roman_set; \
258 inptr += 3; \
259 continue; \
260 } \
261 else if (var == iso2022jp2 && inptr[2] == 'I') \
262 { \
263 /* JIS X 0201 selected. */ \
264 set = JISX0201_Kana_set; \
265 inptr += 3; \
266 continue; \
267 } \
268 } \
269 else if (inptr[1] == '$') \
270 { \
271 if (inptr[2] == '@') \
272 { \
273 /* JIS X 0208-1978 selected. */ \
274 set = JISX0208_1978_set; \
275 inptr += 3; \
276 continue; \
277 } \
278 else if (inptr[2] == 'B') \
279 { \
280 /* JIS X 0208-1983 selected. */ \
281 set = JISX0208_1983_set; \
282 inptr += 3; \
283 continue; \
284 } \
285 else if (var == iso2022jp2) \
286 { \
287 if (inptr[2] == 'A') \
288 { \
289 /* GB 2312-1980 selected. */ \
290 set = GB2312_set; \
291 inptr += 3; \
292 continue; \
293 } \
294 else if (inptr[2] == '(') \
295 { \
296 if (inptr[3] == 'C') \
297 { \
298 /* KSC 5601-1987 selected. */ \
299 set = KSC5601_set; \
300 inptr += 4; \
301 continue; \
302 } \
303 else if (inptr[3] == 'D') \
304 { \
305 /* JIS X 0212-1990 selected. */ \
306 set = JISX0212_set; \
307 inptr += 4; \
308 continue; \
309 } \
310 } \
311 } \
312 } \
313 else if (var == iso2022jp2 && inptr[1] == '.') \
314 { \
315 if (inptr[2] == 'A') \
316 { \
317 /* ISO 8859-1-GR selected. */ \
318 set = ISO88591_set; \
319 inptr += 3; \
320 continue; \
321 } \
322 else if (inptr[2] == 'F') \
323 { \
324 /* ISO 8859-7-GR selected. */ \
325 set = ISO88597_set; \
326 inptr += 3; \
327 continue; \
328 } \
329 } \
330 } \
331 \
332 if (set == ASCII_set \
333 || (var < ISO88591_set && (ch < 0x21 || ch == 0x7f)) \
334 || (var >= ISO88591_set && ch < 0x20)) \
335 /* Almost done, just advance the input pointer. */ \
336 ++inptr; \
337 else if (set == JISX0201_Roman_set) \
338 { \
339 /* Use the JIS X 0201 table. */ \
340 ch = jisx0201_to_ucs4 (ch); \
341 if (ch == UNKNOWN_10646_CHAR) \
342 { \
343 result = GCONV_ILLEGAL_INPUT; \
344 break; \
345 } \
346 ++inptr; \
347 } \
348 else if (set == JISX0201_Kana_set) \
349 { \
350 /* Use the JIS X 0201 table. */ \
351 ch = jisx0201_to_ucs4 (ch + 0x80); \
352 if (ch == UNKNOWN_10646_CHAR) \
353 { \
354 result = GCONV_ILLEGAL_INPUT; \
355 break; \
356 } \
357 ++inptr; \
358 } \
359 else if (set == ISO88591_set) \
360 { \
361 /* This is quite easy. All characters are defined and the \
362 ISO 10646 value is computed by adding 0x80. */ \
363 ch |= 0x80; \
364 ++inptr; \
365 } \
366 else if (set == ISO88597_set) \
367 { \
368 /* We use the table from the ISO 8859-7 module. */ \
369 ch = iso88597_to_ucs4[(ch & 0x7f) - 0x20]; \
370 if (ch == 0) \
371 { \
372 result = GCONV_ILLEGAL_INPUT; \
373 break; \
374 } \
375 ++inptr; \
376 } \
377 else \
378 { \
379 if (set == JISX0208_1978_set || set == JISX0208_1983_set) \
380 /* XXX I don't have the tables for these two old variants of \
381 JIS X 0208. Therefore I'm using the tables for JIS X \
382 0208-1990. If somebody has problems with this please \
383 provide the appropriate tables. */ \
384 ch = jisx0208_to_ucs4 (&inptr, \
385 NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
386 else if (set == JISX0212_set) \
387 /* Use the JIS X 0212 table. */ \
388 ch = jisx0212_to_ucs4 (&inptr, \
389 NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
390 else if (set == GB2312_set) \
391 /* Use the GB 2312 table. */ \
392 ch = gb2312_to_ucs4 (&inptr, \
393 NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
394 else \
395 { \
396 assert (set == KSC5601_set); \
397 \
398 /* Use the KSC 5601 table. */ \
399 ch = ksc5601_to_ucs4 (&inptr, \
400 NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
401 } \
402 \
403 if (NEED_LENGTH_TEST && ch == 0) \
404 { \
405 result = GCONV_EMPTY_INPUT; \
406 break; \
407 } \
408 else if (ch == UNKNOWN_10646_CHAR) \
409 { \
410 result = GCONV_ILLEGAL_INPUT; \
411 break; \
412 } \
413 } \
414 \
415 *((uint32_t *) outptr)++ = ch; \
416 }
417 #define EXTRA_LOOP_DECLS , enum variant var, int *setp
418 #define INIT_PARAMS int set = *setp
419 #define UPDATE_PARAMS *setp = set
420 #include <iconv/loop.c>
421
422
423 /* Next, define the other direction. */
424 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
425 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
426 #define MAX_NEEDED_OUTPUT (MAX_NEEDED_FROM + 2)
427 #define LOOPFCT TO_LOOP
428 #define BODY \
429 { \
430 uint32_t ch; \
431 size_t written = 0; \
432 \
433 ch = *((uint32_t *) inptr); \
434 \
435 /* First see whether we can write the character using the currently \
436 selected character set. */ \
437 if (set == ASCII_set) \
438 { \
439 /* Please note that the NUL byte is *not* matched if we are not \
440 currently using the ASCII charset. This is because we must \
441 switch to the initial state whenever a NUL byte is written. */ \
442 if (ch <= 0x7f) \
443 { \
444 *outptr++ = ch; \
445 written = 1; \
446 } \
447 } \
448 else if (set == JISX0201_Roman_set) \
449 { \
450 unsigned char buf[2]; \
451 written = ucs4_to_jisx0201 (ch, buf); \
452 if (written != UNKNOWN_10646_CHAR && buf[0] > 0x20 && buf[0] < 0x80) \
453 { \
454 *outptr++ = buf[0]; \
455 written = 1; \
456 } \
457 else \
458 written = UNKNOWN_10646_CHAR; \
459 } \
460 else if (set == JISX0201_Kana_set) \
461 { \
462 unsigned char buf[2]; \
463 written = ucs4_to_jisx0201 (ch, buf); \
464 if (written != UNKNOWN_10646_CHAR && buf[0] > 0xa0 && buf[0] < 0xe0) \
465 { \
466 *outptr++ = buf[0] - 0x80; \
467 written = 1; \
468 } \
469 else \
470 written = UNKNOWN_10646_CHAR; \
471 } \
472 else if (set == ISO88591_set) \
473 { \
474 if (ch >= 0x80 && ch <= 0xff) \
475 { \
476 *outptr++ = ch; \
477 written = 1; \
478 } \
479 } \
480 else if (set == ISO88597_set) \
481 { \
482 const struct gap *rp = from_idx; \
483 \
484 while (ch > rp->end) \
485 ++rp; \
486 if (ch >= rp->start) \
487 { \
488 unsigned char res = iso88597_from_ucs4[ch + rp->idx]; \
489 if (res != '\0') \
490 { \
491 *outptr++ = res | 0x80; \
492 written = 1; \
493 } \
494 } \
495 } \
496 else \
497 { \
498 if (set == JISX0208_1978_set || set == JISX0208_1983_set) \
499 written = ucs4_to_jisx0208 (ch, outptr, \
500 (NEED_LENGTH_TEST \
501 ? outend - outptr : 2)); \
502 else if (set == JISX0212_set) \
503 written = ucs4_to_jisx0212 (ch, outptr, \
504 (NEED_LENGTH_TEST \
505 ? outend - outptr : 2)); \
506 else if (set == GB2312_set) \
507 written = ucs4_to_gb2312 (ch, outptr, (NEED_LENGTH_TEST \
508 ? outend - outptr : 2)); \
509 else \
510 { \
511 assert (set == KSC5601_set); \
512 \
513 written = ucs4_to_ksc5601 (ch, outptr, \
514 (NEED_LENGTH_TEST \
515 ? outend - outptr : 2)); \
516 } \
517 \
518 if (NEED_LENGTH_TEST && written == 0) \
519 { \
520 result = GCONV_FULL_OUTPUT; \
521 break; \
522 } \
523 else if (written != UNKNOWN_10646_CHAR) \
524 outptr += written; \
525 } \
526 \
527 if (written == UNKNOWN_10646_CHAR || written == 0) \
528 { \
529 /* Either this is an unknown character or we have to switch \
530 the currently selected character set. The character sets \
531 do not code entirely separate parts of ISO 10646 and \
532 therefore there is no single correct result. If we choose \
533 the character set to use wrong we might be end up with \
534 using yet another character set for the next character \
535 though the current and the next could be encoded with one \
536 character set. We leave this kind of optimization for \
537 later and now simply use a fixed order in which we test for \
538 availability */ \
539 \
540 /* First test whether we have at least three more bytes for \
541 the escape sequence. The two charsets which require four \
542 bytes will be handled later. */ \
543 if (NEED_LENGTH_TEST && outptr + 3 > outend) \
544 { \
545 result = GCONV_FULL_OUTPUT; \
546 break; \
547 } \
548 \
549 if (ch <= 0x7f) \
550 { \
551 /* We must encode using ASCII. First write out the \
552 escape sequence. */ \
553 *outptr++ = ESC; \
554 *outptr++ = '('; \
555 *outptr++ = 'B'; \
556 set = ASCII_set; \
557 \
558 if (NEED_LENGTH_TEST && outptr == outend) \
559 { \
560 result = GCONV_FULL_OUTPUT; \
561 break; \
562 } \
563 \
564 *outptr++ = ch; \
565 } \
566 else \
567 { \
568 /* Now it becomes difficult. We must search the other \
569 character sets one by one and we cannot use simple \
570 arithmetic to determine whether the character can be \
571 encoded using this set. */ \
572 size_t written; \
573 unsigned char buf[2]; \
574 \
575 written = ucs4_to_jisx0201 (ch, buf); \
576 if (written != UNKNOWN_10646_CHAR && buf[0] < 0x80) \
577 { \
578 /* We use JIS X 0201. */ \
579 *outptr++ = ESC; \
580 *outptr++ = '('; \
581 *outptr++ = 'J'; \
582 set = JISX0201_Roman_set; \
583 \
584 if (NEED_LENGTH_TEST && outptr == outend) \
585 { \
586 result = GCONV_FULL_OUTPUT; \
587 break; \
588 } \
589 \
590 *outptr++ = buf[0]; \
591 } \
592 else \
593 { \
594 written = ucs4_to_jisx0208 (ch, buf, 2); \
595 if (written != UNKNOWN_10646_CHAR) \
596 { \
597 /* We use JIS X 0208. */ \
598 *outptr++ = ESC; \
599 *outptr++ = '$'; \
600 *outptr++ = 'B'; \
601 set = JISX0208_1983_set; \
602 \
603 if (NEED_LENGTH_TEST && outptr + 2 > outend) \
604 { \
605 result = GCONV_FULL_OUTPUT; \
606 break; \
607 } \
608 \
609 *outptr++ = buf[0]; \
610 *outptr++ = buf[1]; \
611 } \
612 else if (var == iso2022jp) \
613 { \
614 /* We have no other choice. */ \
615 result = GCONV_ILLEGAL_INPUT; \
616 break; \
617 } \
618 else \
619 { \
620 written = ucs4_to_jisx0212 (ch, buf, 2); \
621 if (written != UNKNOWN_10646_CHAR) \
622 { \
623 /* We use JIS X 0212. */ \
624 if (NEED_LENGTH_TEST && outptr + 4 > outend) \
625 { \
626 result = GCONV_FULL_OUTPUT; \
627 break; \
628 } \
629 *outptr++ = ESC; \
630 *outptr++ = '$'; \
631 *outptr++ = '('; \
632 *outptr++ = 'D'; \
633 set = JISX0212_set; \
634 \
635 if (NEED_LENGTH_TEST && outptr + 2 > outend) \
636 { \
637 result = GCONV_FULL_OUTPUT; \
638 break; \
639 } \
640 \
641 *outptr++ = buf[0]; \
642 *outptr++ = buf[1]; \
643 } \
644 else \
645 { \
646 written = ucs4_to_jisx0201 (ch, buf); \
647 if (written != UNKNOWN_10646_CHAR && buf[0] >= 0x80) \
648 { \
649 /* We use JIS X 0201. */ \
650 *outptr++ = ESC; \
651 *outptr++ = '('; \
652 *outptr++ = 'I'; \
653 set = JISX0201_Kana_set; \
654 \
655 if (NEED_LENGTH_TEST && outptr == outend) \
656 { \
657 result = GCONV_FULL_OUTPUT; \
658 break; \
659 } \
660 \
661 *outptr++ = buf[0] - 0x80; \
662 } \
663 else if (ch != 0xa5 && ch >= 0x80 && ch <= 0xff) \
664 { \
665 /* ISO 8859-1 upper half. */ \
666 *outptr++ = ESC; \
667 *outptr++ = '.'; \
668 *outptr++ = 'A'; \
669 set = ISO88591_set; \
670 \
671 if (NEED_LENGTH_TEST && outptr == outend) \
672 { \
673 result = GCONV_FULL_OUTPUT; \
674 break; \
675 } \
676 \
677 *outptr++ = ch; \
678 } \
679 else \
680 { \
681 written = ucs4_to_gb2312 (ch, buf, 2); \
682 if (written != UNKNOWN_10646_CHAR) \
683 { \
684 /* We use GB 2312. */ \
685 *outptr++ = ESC; \
686 *outptr++ = '$'; \
687 *outptr++ = 'A'; \
688 set = GB2312_set; \
689 \
690 if (NEED_LENGTH_TEST && outptr + 2 > outend) \
691 { \
692 result = GCONV_FULL_OUTPUT; \
693 break; \
694 } \
695 \
696 *outptr++ = buf[0]; \
697 *outptr++ = buf[1]; \
698 } \
699 else \
700 { \
701 written = ucs4_to_ksc5601 (ch, buf, 2); \
702 if (written != UNKNOWN_10646_CHAR) \
703 { \
704 /* We use KSC 5601. */ \
705 if (NEED_LENGTH_TEST \
706 && outptr + 4 > outend) \
707 { \
708 result = GCONV_FULL_OUTPUT; \
709 break; \
710 } \
711 *outptr++ = ESC; \
712 *outptr++ = '$'; \
713 *outptr++ = '('; \
714 *outptr++ = 'C'; \
715 set = KSC5601_set; \
716 \
717 if (NEED_LENGTH_TEST \
718 && outptr + 2 > outend) \
719 { \
720 result = GCONV_FULL_OUTPUT; \
721 break; \
722 } \
723 \
724 *outptr++ = buf[0]; \
725 *outptr++ = buf[1]; \
726 } \
727 else \
728 { \
729 result = GCONV_ILLEGAL_INPUT; \
730 break; \
731 } \
732 } \
733 } \
734 } \
735 } \
736 } \
737 } \
738 } \
739 \
740 /* Now that we wrote the output increment the input pointer. */ \
741 inptr += 4; \
742 }
743 #define EXTRA_LOOP_DECLS , enum variant var, int *setp
744 #define INIT_PARAMS int set = *setp
745 #define UPDATE_PARAMS *setp = set
746 #include <iconv/loop.c>
747
748
749 /* Now define the toplevel functions. */
750 #include <iconv/skeleton.c>
sources.redhat.com git mirror of glibc CVS