| blob | b6bf2c0696f259faf435e6590b43899e59dde8c0 |
1 /* Generic conversion to and from ISO 6937-2.
2 Copyright (C) 1998, 1999, 2000-2002 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 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.
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.
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. */
21 #include <dlfcn.h>
22 #include <stdint.h>
24 /* Data taken from the WG15 tables. */
26 {
59 };
61 /* The outer array range runs from 0xc1 to 0xcf, the inner range from 0x20
62 to 0x7f. */
64 {
65 /* 0xc1 */
66 {
79 },
80 /* 0xc2 */
81 {
94 },
95 /* 0xc3 */
96 {
109 },
110 /* 0xc4 */
111 {
124 },
125 /* 0xc5 */
126 {
139 },
140 /* 0xc6 */
141 {
154 },
155 /* 0xc7 */
156 {
169 },
170 /* 0xc8 */
171 {
184 },
185 /* 0xc9 */
186 {
188 },
189 /* 0xca */
190 {
203 },
204 /* 0xcb */
205 {
218 },
219 /* 0xcc */
220 {
222 },
223 /* 0xcd */
224 {
237 },
238 /* 0xce */
239 {
252 },
253 /* 0xcf */
254 {
267 }
268 };
272 {
350 /*
351 This table does not cover the following positions:
353 0x02c7 "\xcf\x20",
354 ...
355 0x02d8 "\xc6\x20", "\xc7\x20", "\xca\x20", "\xce\x20", "\x00\x00",
356 0x02dd "\xcd\x20",
357 ...
358 0x2014 "\xd0\x00", "\x00\x00", "\x00\x00", "\x00\x00", "\xa9\x00",
359 0x2019 "\xb9\x00", "\x00\x00", "\x00\x00", "\xaa\x00", "\xba\x00",
360 0x201e "\x00\x00", "\x00\x00", "\x00\x00", "\x00\x00", "\xd4\x00",
361 0x2123 "\x00\x00", "\x00\x00", "\x00\x00", "\xe0\x00",
362 ...
363 0x215b "\xdc\x00", "\xdd\x00", "\xde\x00"
364 ...
365 0x2190 "\xac\x00", "\xad\x00", "\xae\x00", "\xaf\x00",
366 ...
367 0x2500 "\xd6\x00", "\x00\x00", "\xd7\x00",
368 ...
369 0x253c "\xe5\x00",
370 ...
371 0x2571 "\xd8\x00", "\xd9\x00",
372 ...
373 0x25e2 "\xda\x00", "\xdb\x00",
374 ...
375 0x266a "\xd5\x00"
377 These would blow up the table and are therefore handled specially in
378 the code.
379 */
380 };
383 /* Definitions used in the body of the `gconv' function. */
385 #define FROM_LOOP from_iso6937_2
386 #define TO_LOOP to_iso6937_2
387 #define DEFINE_INIT 1
388 #define DEFINE_FINI 1
389 #define MIN_NEEDED_FROM 1
390 #define MAX_NEEDED_FROM 2
391 #define MIN_NEEDED_TO 4
394 /* First define the conversion function from ISO 6937-2 to UCS4. */
395 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
396 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
397 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
398 #define LOOPFCT FROM_LOOP
399 #define BODY \
400 { \
401 uint32_t ch = *inptr; \
402 \
403 if (__builtin_expect (ch >= 0xc1, 0) && ch <= 0xcf) \
404 { \
405 /* Composed character. First test whether the next byte \
407 int ch2; \
408 \
409 if (__builtin_expect (inptr + 1 >= inend, 0)) \
410 { \
411 /* The second character is not available. Store the \
413 result = __GCONV_INCOMPLETE_INPUT; \
414 break; \
415 } \
416 \
417 ch2 = inptr[1]; \
418 \
419 if (__builtin_expect (ch2 < 0x20, 0) \
420 || __builtin_expect (ch2 >= 0x80, 0)) \
421 { \
423 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
424 } \
425 \
426 ch = to_ucs4_comb[ch - 0xc1][ch2 - 0x20]; \
427 \
428 if (__builtin_expect (ch == 0, 0)) \
429 { \
431 STANDARD_FROM_LOOP_ERR_HANDLER (2); \
432 } \
433 \
434 inptr += 2; \
435 } \
436 else \
437 { \
438 ch = to_ucs4[ch]; \
439 \
441 { \
443 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
444 } \
445 ++inptr; \
446 } \
447 \
448 put32 (outptr, ch); \
449 outptr += 4; \
450 }
451 #define LOOP_NEED_FLAGS
452 #define ONEBYTE_BODY \
453 { \
454 uint32_t ch = to_ucs4[c]; \
456 return WEOF; \
457 return ch; \
458 }
459 #include <iconv/loop.c>
462 /* Next, define the other direction. */
463 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
464 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
465 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
466 #define LOOPFCT TO_LOOP
467 #define BODY \
468 { \
469 char tmp[2]; \
470 uint32_t ch = get32 (inptr); \
471 const char *cp; \
472 \
473 if (__builtin_expect (ch >= sizeof (from_ucs4) / sizeof (from_ucs4[0]), \
474 0)) \
475 { \
476 switch (ch) \
477 { \
478 case 0x2c7: \
480 break; \
481 case 0x2d8 ... 0x2dd: \
482 { \
484 \
485 tmp[0] = map[ch - 0x2d8]; \
487 cp = tmp; \
488 } \
489 break; \
490 case 0x2014: \
492 break; \
493 case 0x2018: \
495 break; \
496 case 0x2019: \
498 break; \
499 case 0x201c: \
501 break; \
502 case 0x201d: \
504 break; \
505 case 0x2122: \
507 break; \
508 case 0x2126: \
510 break; \
511 case 0x215b ... 0x215e: \
512 tmp[0] = 0xdc + (ch - 0x215b); \
514 cp = tmp; \
515 break; \
516 case 0x2190 ... 0x2193: \
517 tmp[0] = 0xac + (ch - 0x2190); \
519 cp = tmp; \
520 break; \
521 case 0x2500: \
523 break; \
524 case 0x2502: \
526 break; \
527 case 0x253c: \
529 break; \
530 case 0x2571: \
532 break; \
533 case 0x2572: \
535 break; \
536 case 0x25e2: \
538 break; \
539 case 0x25e3: \
541 break; \
542 case 0x266a: \
544 break; \
545 default: \
546 UNICODE_TAG_HANDLER (ch, 4); \
548 cp = NULL; \
549 break; \
550 } \
551 if (cp == NULL) \
552 { \
553 STANDARD_TO_LOOP_ERR_HANDLER (4); \
554 } \
555 } \
557 { \
559 STANDARD_TO_LOOP_ERR_HANDLER (4); \
560 } \
561 else \
562 cp = from_ucs4[ch]; \
563 \
564 *outptr++ = cp[0]; \
567 { \
568 if (__builtin_expect (outptr >= outend, 0)) \
569 { \
571 --outptr; \
572 result = __GCONV_FULL_OUTPUT; \
573 break; \
574 } \
575 *outptr++ = cp[1]; \
576 } \
577 \
578 inptr += 4; \
579 }
580 #define LOOP_NEED_FLAGS
581 #include <iconv/loop.c>
584 /* Now define the toplevel functions. */
585 #include <iconv/skeleton.c>