| /* Mapping tables for JOHAB handling. |
| Copyright (C) 1998 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Jungshik Shin <jshin@pantheon.yale.edu> |
| and Ulrich Drepper <drepper@cygnus.com>, 1998. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public License as |
| published by the Free Software Foundation; either version 2 of the |
| License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public |
| License along with the GNU C Library; see the file COPYING.LIB. If not, |
| write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. */ |
| |
| #include <stdint.h> |
| #include <ksc5601.h> |
| |
| /* The table for Bit pattern to Hangul Jamo |
| 5 bits each are used to encode |
| leading consonants(19 + 1 filler), medial vowels(21 + 1 filler) |
| and trailing consonants(27 + 1 filler). |
| |
| KS C 5601-1992 Annex 3 Table 2 |
| 0 : Filler, -1: invalid, >= 1 : valid |
| |
| */ |
| static const int init[32] = |
| { |
| -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, |
| 19, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 |
| }; |
| static const int mid[32] = |
| { |
| -1, -1, 0, 1, 2, 3, 4, 5, |
| -1, -1, 6, 7, 8, 9, 10, 11, |
| -1, -1, 12, 13, 14, 15, 16, 17, |
| -1, -1, 18, 19, 20, 21, -1, -1 |
| }; |
| static const int final[32] = |
| { |
| -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
| -1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1 |
| }; |
| |
| /* |
| Hangul Jamo in Johab to Unicode 2.0 : Unicode 2.0 |
| defines 51 Hangul Compatibility Jamos in the block [0x3131,0x314e] |
| |
| It's to be considered later which Jamo block to use, Compatibility |
| block [0x3131,0x314e] or Hangul Conjoining Jamo block, [0x1100,0x11ff] |
| |
| */ |
| static const uint32_t init_to_ucs[19] = |
| { |
| 0x3131, 0x3132, 0x3134, 0x3137, 0x3138, 0x3139, 0x3141, 0x3142, |
| 0x3143, 0x3145, 0x3146, 0x3147, 0x3148, 0x3149, 0x314a, 0x314b, |
| 0x314c, 0x314d, 0x314e |
| }; |
| |
| static const uint32_t final_to_ucs[27] = |
| { |
| L'\0', L'\0', 0x3133, L'\0', 0x3135, 0x3136, L'\0', L'\0', |
| 0x313a, 0x313b, 0x314c, 0x313d, 0x313e, 0x313f, |
| 0x3140, L'\0', L'\0', 0x3144, L'\0', L'\0', L'\0', |
| L'\0', L'\0', L'\0', L'\0', L'\0', L'\0' |
| }; |
| |
| /* The following three arrays are used to convert |
| precomposed Hangul syllables in [0xac00,0xd???] |
| to Jamo bit patterns for Johab encoding |
| |
| cf. : KS C 5601-1992, Annex3 Table 2 |
| |
| Arrays are used to speed up things although it's possible |
| to get the same result arithmetically. |
| |
| */ |
| static const int init_to_bit[19] = |
| { |
| 0x8800, 0x8c00, 0x9000, 0x9400, 0x9800, 0x9c00, |
| 0xa000, 0xa400, 0xa800, 0xac00, 0xb000, 0xb400, |
| 0xb800, 0xbc00, 0xc000, 0xc400, 0xc800, 0xcc00, |
| 0xd000 |
| }; |
| |
| static const int mid_to_bit[21] = |
| { |
| 0x0060, 0x0080, 0x00a0, 0x00c0, 0x00e0, |
| 0x0140, 0x0160, 0x0180, 0x01a0, 0x01c0, 0x1e0, |
| 0x0240, 0x0260, 0x0280, 0x02a0, 0x02c0, 0x02e0, |
| 0x0340, 0x0360, 0x0380, 0x03a0 |
| }; |
| |
| static const int final_to_bit[28] = |
| { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, |
| 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d |
| }; |
| |
| /* The conversion table from |
| UCS4 Hangul Compatibility Jamo in [0x3131,0x3163] |
| to Johab |
| |
| cf. 1. KS C 5601-1992 Annex 3 Table 2 |
| 2. Unicode 2.0 manual |
| |
| */ |
| static const uint16_t jamo_from_ucs_table[51] = |
| { |
| 0x8841, 0x8c41, |
| 0x8444, |
| 0x9041, |
| 0x8446, 0x8447, |
| 0x9441, 0x9841, 0x9c41, |
| 0x844a, 0x844b, 0x844c, 0x844d, 0x884e, 0x884f, 0x8450, |
| 0xa041, 0xa441, 0xa841, |
| 0x8454, |
| 0xac41, 0xb041, 0xb441, 0xb841, 0xbc41, |
| 0xc041, 0xc441, 0xc841, 0xca41, 0xd041, |
| 0x8461, 0x8481, 0x84a1, 0x84c1, 0x84e1, |
| 0x8541, 0x8561, 0x8581, 0x85a1, 0x85c1, 0x85e1, |
| 0x8641, 0x8661, 0x8681, 0x86a1, 0x86c1, 0x86e1, |
| 0x8741, 0x8761, 0x8781, 0x87a1 |
| }; |
| |
| |
| static inline uint32_t |
| johab_sym_hanja_to_ucs (uint_fast32_t idx, uint_fast32_t c1, uint_fast32_t c2) |
| { |
| if (idx <= 0xdefe) |
| return (uint32_t) __ksc5601_sym_to_ucs[(c1 - 0xd9) * 188 + c2 |
| - (c2 > 0x90 ? 0x43 : 0x31)]; |
| else |
| return (uint32_t) __ksc5601_hanja_to_ucs[(c1 - 0xe0) * 188 + c2 |
| - (c2 > 0x90 ? 0x43 : 0x31)]; |
| } |
| /* Definitions used in the body of the `gconv' function. */ |
| #define CHARSET_NAME "JOHAB//" |
| #define FROM_LOOP from_johab |
| #define TO_LOOP to_johab |
| #define DEFINE_INIT 1 |
| #define DEFINE_FINI 1 |
| #define MIN_NEEDED_FROM 1 |
| #define MAX_NEEDED_FROM 2 |
| #define MIN_NEEDED_TO 4 |
| |
| |
| /* First define the conversion function from JOHAB to UCS4. */ |
| #define MIN_NEEDED_INPUT MIN_NEEDED_FROM |
| #define MAX_NEEDED_INPUT MAX_NEEDED_FROM |
| #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO |
| #define LOOPFCT FROM_LOOP |
| #define BODY \ |
| { \ |
| uint32_t ch = *inptr; \ |
| \ |
| /* half-width Korean Currency WON sign \ |
| if (ch == 0x5c) \ |
| ch = 0x20a9; \ |
| else if (ch < 0x7f) \ |
| ch = (uint32_t) ch; \ |
| */ \ |
| if (ch < 0x7f) \ |
| /* Plain ASCII. */ \ |
| ++inptr; \ |
| /* Johab : 1. Hangul \ |
| 1st byte : 0x84-0xd3 \ |
| 2nd byte : 0x41-0x7e, 0x81-0xfe \ |
| 2. Hanja & Symbol : \ |
| 1st byte : 0xd8-0xde, 0xe0-0xf9 \ |
| 2nd byte : 0x31-0x7e, 0x91-0xfe \ |
| 0xd831-0xd87e and 0xd891-0xd8fe are user-defined area */ \ |
| else \ |
| { \ |
| if (ch > 0xf9 || ch == 0xdf || (ch > 0x7e && ch < 0x84) \ |
| || (ch > 0xd3 && ch < 0xd9)) \ |
| { \ |
| /* These are illegal. */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| else \ |
| { \ |
| /* Two-byte character. First test whether the next \ |
| character is also available. */ \ |
| uint32_t ch2; \ |
| uint_fast32_t idx; \ |
| \ |
| if (NEED_LENGTH_TEST && inptr + 1 >= inend) \ |
| { \ |
| /* The second character is not available. Store the \ |
| intermediate result. */ \ |
| result = GCONV_INCOMPLETE_INPUT; \ |
| break; \ |
| } \ |
| \ |
| ch2 = inptr[1]; \ |
| idx = ch * 256 + ch2; \ |
| if (ch <= 0xd3) \ |
| { \ |
| /* Hangul */ \ |
| uint_fast32_t i, m, f; \ |
| \ |
| i = init[(idx & 0x7c00) >> 10]; \ |
| m = mid[(idx & 0x03e0) >> 5]; \ |
| f = final[idx & 0x001f]; \ |
| \ |
| if (i == -1 || m == -1 || f == -1) \ |
| { \ |
| /* This is illegal. */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| else if (i > 0 && m > 0) \ |
| ch = ((i - 1) * 21 + (m - 1)) * 28 + f + 0xac00; \ |
| else if (i > 0 && m == 0 & f == 0) \ |
| ch = init_to_ucs[i - 1]; \ |
| else if (i == 0 && m > 0 & f == 0) \ |
| ch = 0x314e + m; /* 0x314f + m - 1 */ \ |
| else if (i == 0 && m == 0 & f > 0) \ |
| ch = final_to_ucs[f - 1]; /* round trip?? */ \ |
| else \ |
| { \ |
| /* This is illegal. */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| } \ |
| else \ |
| { \ |
| if (ch2 < 0x31 || (ch2 > 0x7e && ch2 < 0x91) || ch2 == 0xff) \ |
| { \ |
| /* This is illegal. */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| else if (ch == 0xda && ch2 > 0xa0 && ch2 < 0xd4) \ |
| { \ |
| /* This is illegal. Modern Hangul Jaso is defined \ |
| elsewhere in Johab */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| else \ |
| { \ |
| ch = johab_sym_hanja_to_ucs (idx, ch, ch2); \ |
| /* if (idx <= 0xdefe) \ |
| ch = __ksc5601_sym_to_ucs[(ch - 0xd9) * 192 \ |
| + ch2 - (ch2 > 0x90 \ |
| ? 0x43 : 0x31)]; \ |
| else \ |
| ch = __ksc5601_hanja_to_ucs[(ch - 0xe0) *192 \ |
| + ch2 - (ch2 > 0x90 \ |
| ?0x43 : 0x31)];\ |
| */ \ |
| } \ |
| } \ |
| } \ |
| \ |
| if (ch == 0) \ |
| { \ |
| /* This is an illegal character. */ \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| \ |
| inptr += 2; \ |
| } \ |
| \ |
| *((uint32_t *) outptr)++ = ch; \ |
| } |
| #include <iconv/loop.c> |
| |
| |
| /* Next, define the other direction. */ |
| #define MIN_NEEDED_INPUT MIN_NEEDED_TO |
| #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM |
| #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM |
| #define LOOPFCT TO_LOOP |
| #define BODY \ |
| { \ |
| uint32_t ch = *((uint32_t *) inptr); \ |
| /* \ |
| if (ch >= (sizeof (from_ucs4_lat1) / sizeof (from_ucs4_lat1[0]))) \ |
| { \ |
| if (ch >= 0x0391 && ch <= 0x0451) \ |
| cp = from_ucs4_greek[ch - 0x391]; \ |
| else if (ch >= 0x2010 && ch <= 0x9fa0) \ |
| cp = from_ucs4_cjk[ch - 0x02010]; \ |
| else \ |
| break; \ |
| } \ |
| else \ |
| cp = from_ucs4_lat1[ch]; \ |
| */ \ |
| \ |
| if (ch < 0x7f) \ |
| *outptr++ = ch; \ |
| else \ |
| { \ |
| if (ch >= 0xac00 && ch <= 0xd7a3) \ |
| { \ |
| ch -= 0xac00; \ |
| \ |
| ch = (init_to_bit[ch / 588] /* 21 * 28 = 588 */ \ |
| + mid_to_bit[(ch / 28) % 21]/* (ch % (21 * 28)) / 28 */ \ |
| + final_to_bit[ch % 28]); /* (ch % (21 * 28)) % 28 */ \ |
| \ |
| if (NEED_LENGTH_TEST && outptr + 2 > outend) \ |
| { \ |
| result = GCONV_FULL_OUTPUT; \ |
| break; \ |
| } \ |
| \ |
| *outptr++ = ch / 256; \ |
| *outptr++ = ch % 256; \ |
| } \ |
| /* KS C 5601-1992 Annex 3 regards 0xA4DA(Hangul Filler : U3164) \ |
| as symbol */ \ |
| else if (ch >= 0x3131 && ch <= 0x3163) \ |
| { \ |
| ch = jamo_from_ucs_table[ch - 0x3131]; \ |
| \ |
| if (NEED_LENGTH_TEST && outptr + 2 > outend) \ |
| { \ |
| result = GCONV_FULL_OUTPUT; \ |
| break; \ |
| } \ |
| \ |
| *outptr++ = ch / 256; \ |
| *outptr++ = ch % 256; \ |
| } \ |
| if ((ch >= 0x4e00 && ch <= 0x9fa5) || (ch >= 0xf900 && ch <= 0xfa0b)) \ |
| { \ |
| size_t written; \ |
| \ |
| written = ucs4_to_ksc5601_hanja (ch, outptr, \ |
| (NEED_LENGTH_TEST \ |
| ? outend - outptr : 2)); \ |
| if (NEED_LENGTH_TEST && written == 0) \ |
| { \ |
| result = GCONV_FULL_OUTPUT; \ |
| break; \ |
| } \ |
| if (written == UNKNOWN_10646_CHAR) \ |
| { \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| \ |
| outptr[0] -= 0x4a; \ |
| outptr[1] += 0x80; \ |
| \ |
| outptr[1] += (outptr[0] % 2 \ |
| ? 0 : (outptr[1] > 0xee ? 0x43 : 0x31)); \ |
| outptr[1] -= 0xa1; \ |
| outptr[0] /= 2; \ |
| outptr[0] += 0xe0; \ |
| \ |
| outptr += 2; \ |
| } \ |
| else \ |
| { \ |
| size_t written; \ |
| \ |
| written = ucs4_to_ksc5601_sym (ch, outptr, \ |
| (NEED_LENGTH_TEST \ |
| ? outend - outptr : 2)); \ |
| if (NEED_LENGTH_TEST && written == 0) \ |
| { \ |
| result = GCONV_FULL_OUTPUT; \ |
| break; \ |
| } \ |
| if (written == UNKNOWN_10646_CHAR) \ |
| { \ |
| result = GCONV_ILLEGAL_INPUT; \ |
| break; \ |
| } \ |
| \ |
| outptr[0] -= 0x4a; \ |
| outptr[1] += 0x80; \ |
| \ |
| outptr[1] += (outptr[0] % 2 \ |
| ? 0 : (outptr[1] > 0xee ? 0x43 : 0x31)); \ |
| outptr[1] -= 0xa1; \ |
| outptr[0] /= 2; \ |
| outptr[0] += 0xe0; \ |
| \ |
| outptr += 2; \ |
| } \ |
| } \ |
| \ |
| inptr += 4; \ |
| } |
| #include <iconv/loop.c> |
| |
| |
| /* Now define the toplevel functions. */ |
| #include <iconv/skeleton.c> |