| blob | f403773d9dfc086cd338e4118079c53a9d304821 |
1 /* Generic conversion to and from ANSI_X3.110-1983.
2 Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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.
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.
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. */
21 #include <dlfcn.h>
22 #include <gconv.h>
23 #include <stdint.h>
24 #include <string.h>
26 /* Data taken from the WG15 tables. */
28 {
61 };
63 /* The outer array range runs from 0xc1 to 0xcf, the inner range from 0x20
64 to 0x7f. */
66 {
67 /* 0xc1 */
68 {
81 },
82 /* 0xc2 */
83 {
96 },
97 /* 0xc3 */
98 {
111 },
112 /* 0xc4 */
113 {
126 },
127 /* 0xc5 */
128 {
141 },
142 /* 0xc6 */
143 {
156 },
157 /* 0xc7 */
158 {
171 },
172 /* 0xc8 */
173 {
186 },
187 /* 0xc9 */
188 {
190 },
191 /* 0xca */
192 {
205 },
206 /* 0xcb */
207 {
220 },
221 /* 0xcc */
222 {
224 },
225 /* 0xcd */
226 {
239 },
240 /* 0xce */
241 {
254 },
255 /* 0xcf */
256 {
269 }
270 };
274 {
352 /*
353 This table does not cover the following positions:
355 0x02c7 "\xcf\x20",
356 ...
357 0x02d8 "\xc6\x20", "\xc7\x20", "\xca\x20", "\xce\x20", "\x00\x00",
358 0x02dd "\xcd\x20",
359 ...
360 0x2014 "\xd0\x00", "\x00\x00", "\x00\x00", "\x00\x00", "\xa9\x00",
361 0x2019 "\xb9\x00", "\x00\x00", "\x00\x00", "\xaa\x00", "\xba\x00",
362 0x201e "\x00\x00", "\x00\x00", "\x00\x00", "\x00\x00", "\xd4\x00",
363 0x2023 "\x00\x00", "\x00\x00", "\x00\x00", "\xe0\x00",
364 ...
365 0x215b "\xdc\x00", "\xdd\x00", "\xde\x00", "\xdf\x00",
366 ...
367 0x2190 "\xac\x00", "\xad\x00", "\xae\x00", "\xaf\x00",
368 ...
369 0x2500 "\xd6\x00", "\x00\x00", "\xd7\x00",
370 ...
371 0x253c "\xe5\x00",
372 ...
373 0x2571 "\xd8\x00", "\xd9\x00",
374 ...
375 0x25e2 "\xda\x00", "\xdb\x00",
376 ...
377 0x266a "\xd5\x00",
379 These would blow up the table and are therefore handled specially in
380 the code.
381 */
382 };
385 /* Definitions used in the body of the `gconv' function. */
387 #define FROM_LOOP from_ansi_x3_110
388 #define TO_LOOP to_ansi_x3_110
389 #define DEFINE_INIT 1
390 #define DEFINE_FINI 1
391 #define MIN_NEEDED_FROM 1
392 #define MAX_NEEDED_FROM 2
393 #define MIN_NEEDED_TO 4
395 /* First define the conversion function from ANSI_X3.110 to UCS4. */
396 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
397 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
398 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
399 #define LOOPFCT FROM_LOOP
400 #define BODY \
401 { \
402 uint32_t ch = *inptr; \
403 int incr; \
404 \
405 if (__builtin_expect (ch, 0x00) >= 0xc1 && ch <= 0xcf) \
406 { \
407 /* Composed character. First test whether the next character \
409 uint32_t ch2; \
410 \
411 if (inptr + 1 >= inend) \
412 { \
414 result = __GCONV_INCOMPLETE_INPUT; \
415 break; \
416 } \
417 \
418 ch2 = inptr[1]; \
419 \
420 if (__builtin_expect (ch2, 0x20) < 0x20 \
421 || __builtin_expect (ch2, 0x7f) >= 0x80) \
422 { \
424 if (! ignore_errors_p ()) \
425 { \
426 result = __GCONV_ILLEGAL_INPUT; \
427 break; \
428 } \
429 \
430 ++*irreversible; \
431 incr = 1; \
432 } \
433 else \
434 { \
435 ch = to_ucs4_comb[ch - 0xc1][ch2 - 0x20]; \
436 incr = 2; \
437 } \
438 } \
439 else \
440 { \
441 ch = to_ucs4[ch]; \
442 incr = 1; \
443 } \
444 \
446 { \
448 if (! ignore_errors_p ()) \
449 { \
450 result = __GCONV_ILLEGAL_INPUT; \
451 break; \
452 } \
453 } \
454 else \
455 { \
456 put32 (outptr, ch); \
457 outptr += 4; \
458 } \
459 \
460 inptr += incr; \
461 }
462 #define LOOP_NEED_FLAGS
463 #include <iconv/loop.c>
466 /* Next, define the other direction. */
467 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
468 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
469 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
470 #define LOOPFCT TO_LOOP
471 #define BODY \
472 { \
473 char tmp[2]; \
474 uint32_t ch = get32 (inptr); \
475 const char *cp; \
476 \
477 if (__builtin_expect (ch, 0) \
478 >= sizeof (from_ucs4) / sizeof (from_ucs4[0])) \
479 { \
480 if (ch == 0x2c7) \
482 else if (ch >= 0x2d8 && ch <= 0x2dd && ch != 0x2dc) \
483 { \
485 \
486 tmp[0] = map[ch - 0x2d8]; \
488 cp = tmp; \
489 } \
490 else if (ch >= 0x2014 && ch <= 0x2026) \
491 { \
492 static const char map[19] = \
495 \
496 tmp[0] = map[ch - 0x2014]; \
498 { \
500 if (step_data->__trans.__trans_fct != NULL) \
501 { \
502 result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
503 (step, step_data, *inptrp, &inptr, \
504 inend, *outptrp, &outptr, outend, \
505 irreversible)); \
506 if (result != __GCONV_OK) \
507 break; \
508 } \
509 else if (! ignore_errors_p ()) \
510 { \
511 result = __GCONV_ILLEGAL_INPUT; \
512 break; \
513 } \
514 else \
515 { \
516 ++*irreversible; \
517 inptr += 4; \
518 } \
519 continue; \
520 } \
522 cp = tmp; \
523 } \
524 else if (ch >= 0x215b && ch <= 0x215e) \
525 { \
526 tmp[0] = 0xdc + ch - 0x215b; \
528 cp = tmp; \
529 } \
530 else if (ch >= 0x2190 && ch <= 0x2193) \
531 { \
532 tmp[0] = 0xac + ch - 0x2190; \
534 cp = tmp; \
535 } \
536 else if (ch == 0x2500) \
538 else if (ch == 0x2502) \
540 else if (ch == 0x253c) \
542 else if (ch >= 0x2571 && ch <= 0x2572) \
543 { \
544 tmp[0] = 0xd8 + ch - 0x2571; \
546 cp = tmp; \
547 } \
548 else if (ch >= 0x25e2 && ch <= 0x25e3) \
549 { \
550 tmp[0] = 0xda + ch - 0x25e2; \
552 cp = tmp; \
553 } \
554 else if (__builtin_expect (ch, 0x266a) == 0x266a) \
556 else \
557 { \
559 if (step_data->__trans.__trans_fct != NULL) \
560 { \
561 result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
562 (step, step_data, *inptrp, &inptr, \
563 inend, *outptrp, &outptr, outend, \
564 irreversible)); \
565 if (result != __GCONV_OK) \
566 break; \
567 } \
568 else if (! ignore_errors_p ()) \
569 { \
570 result = __GCONV_ILLEGAL_INPUT; \
571 break; \
572 } \
573 else \
574 { \
575 ++*irreversible; \
576 inptr += 4; \
577 } \
578 continue; \
579 } \
580 } \
581 else \
582 { \
583 cp = from_ucs4[ch]; \
584 \
586 { \
588 if (step_data->__trans.__trans_fct != NULL) \
589 { \
590 result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
591 (step, step_data, *inptrp, &inptr, \
592 inend, *outptrp, &outptr, outend, \
593 irreversible)); \
594 if (result != __GCONV_OK) \
595 break; \
596 } \
597 else if (! ignore_errors_p ()) \
598 { \
599 result = __GCONV_ILLEGAL_INPUT; \
600 break; \
601 } \
602 else \
603 { \
604 ++*irreversible; \
605 inptr += 4; \
606 } \
607 continue; \
608 } \
609 } \
610 \
611 *outptr++ = cp[0]; \
614 { \
615 if (__builtin_expect (outptr >= outend, 0)) \
616 { \
618 --outptr; \
619 result = __GCONV_FULL_OUTPUT; \
620 break; \
621 } \
622 \
623 *outptr++ = cp[1]; \
624 } \
625 \
626 inptr += 4; \
627 }
628 #define LOOP_NEED_FLAGS
629 #include <iconv/loop.c>
632 /* Now define the toplevel functions. */
633 #include <iconv/skeleton.c>