Update.
[glibc.git] / iconvdata / johab.c
blob83a76d1ff0d51fe0207bad21124bb85d4df07c30
1 /* Mapping tables for JOHAB handling.
2 Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Jungshik Shin <jshin@pantheon.yale.edu>
5 and Ulrich Drepper <drepper@cygnus.com>, 1998.
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public
18 License along with the GNU C Library; if not, write to the Free
19 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 02111-1307 USA. */
22 #include <dlfcn.h>
23 #include <stdint.h>
24 #include <ksc5601.h>
26 /* The table for Bit pattern to Hangul Jamo
27 5 bits each are used to encode
28 leading consonants(19 + 1 filler), medial vowels(21 + 1 filler)
29 and trailing consonants(27 + 1 filler).
31 KS C 5601-1992 Annex 3 Table 2
32 0 : Filler, -1: invalid, >= 1 : valid
35 static const int init[32] =
37 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
38 19, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
40 static const int mid[32] =
42 -1, -1, 0, 1, 2, 3, 4, 5,
43 -1, -1, 6, 7, 8, 9, 10, 11,
44 -1, -1, 12, 13, 14, 15, 16, 17,
45 -1, -1, 18, 19, 20, 21, -1, -1
47 static const int final[32] =
49 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
50 -1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1
54 Hangul Jamo in Johab to Unicode 2.0 : Unicode 2.0
55 defines 51 Hangul Compatibility Jamos in the block [0x3131,0x314e]
57 It's to be considered later which Jamo block to use, Compatibility
58 block [0x3131,0x314e] or Hangul Conjoining Jamo block, [0x1100,0x11ff]
61 static const uint32_t init_to_ucs[19] =
63 0x3131, 0x3132, 0x3134, 0x3137, 0x3138, 0x3139, 0x3141, 0x3142,
64 0x3143, 0x3145, 0x3146, 0x3147, 0x3148, 0x3149, 0x314a, 0x314b,
65 0x314c, 0x314d, 0x314e
68 static const uint32_t final_to_ucs[31] =
70 L'\0', L'\0', 0x3133, L'\0', 0x3135, 0x3136, L'\0', L'\0',
71 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
72 0x3140, L'\0', L'\0', 0x3144, L'\0', L'\0', L'\0', L'\0',
73 L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0'
76 /* The following three arrays are used to convert
77 precomposed Hangul syllables in [0xac00,0xd???]
78 to Jamo bit patterns for Johab encoding
80 cf. : KS C 5601-1992, Annex3 Table 2
82 Arrays are used to speed up things although it's possible
83 to get the same result arithmetically.
86 static const int init_to_bit[19] =
88 0x8800, 0x8c00, 0x9000, 0x9400, 0x9800, 0x9c00,
89 0xa000, 0xa400, 0xa800, 0xac00, 0xb000, 0xb400,
90 0xb800, 0xbc00, 0xc000, 0xc400, 0xc800, 0xcc00,
91 0xd000
94 static const int mid_to_bit[21] =
96 0x0060, 0x0080, 0x00a0, 0x00c0, 0x00e0,
97 0x0140, 0x0160, 0x0180, 0x01a0, 0x01c0, 0x1e0,
98 0x0240, 0x0260, 0x0280, 0x02a0, 0x02c0, 0x02e0,
99 0x0340, 0x0360, 0x0380, 0x03a0
102 static const int final_to_bit[28] =
104 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
105 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d
108 /* The conversion table from
109 UCS4 Hangul Compatibility Jamo in [0x3131,0x3163]
110 to Johab
112 cf. 1. KS C 5601-1992 Annex 3 Table 2
113 2. Unicode 2.0 manual
116 static const uint16_t jamo_from_ucs_table[51] =
118 0x8841, 0x8c41,
119 0x8444,
120 0x9041,
121 0x8446, 0x8447,
122 0x9441, 0x9841, 0x9c41,
123 0x844a, 0x844b, 0x844c, 0x844d, 0x844e, 0x844f, 0x8450,
124 0xa041, 0xa441, 0xa841,
125 0x8454,
126 0xac41, 0xb041, 0xb441, 0xb841, 0xbc41,
127 0xc041, 0xc441, 0xc841, 0xcc41, 0xd041,
128 0x8461, 0x8481, 0x84a1, 0x84c1, 0x84e1,
129 0x8541, 0x8561, 0x8581, 0x85a1, 0x85c1, 0x85e1,
130 0x8641, 0x8661, 0x8681, 0x86a1, 0x86c1, 0x86e1,
131 0x8741, 0x8761, 0x8781, 0x87a1
135 static inline uint32_t
136 johab_sym_hanja_to_ucs (uint_fast32_t idx, uint_fast32_t c1, uint_fast32_t c2)
138 if (idx <= 0xdefe)
139 return (uint32_t) __ksc5601_sym_to_ucs[(c1 - 0xd9) * 188 + c2
140 - (c2 > 0x90 ? 0x43 : 0x31)];
141 else
142 return (uint32_t) __ksc5601_hanja_to_ucs[(c1 - 0xe0) * 188 + c2
143 - (c2 > 0x90 ? 0x43 : 0x31)];
145 /* Definitions used in the body of the `gconv' function. */
146 #define CHARSET_NAME "JOHAB//"
147 #define FROM_LOOP from_johab
148 #define TO_LOOP to_johab
149 #define DEFINE_INIT 1
150 #define DEFINE_FINI 1
151 #define MIN_NEEDED_FROM 1
152 #define MAX_NEEDED_FROM 2
153 #define MIN_NEEDED_TO 4
156 /* First define the conversion function from JOHAB to UCS4. */
157 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
158 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
159 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
160 #define LOOPFCT FROM_LOOP
161 #define BODY \
163 uint32_t ch = *inptr; \
165 if (ch <= 0x7f) \
167 /* Plain ISO646-KR. */ \
168 if (ch == 0x5c) \
169 ch = 0x20a9; /* half-width Korean Currency WON sign */ \
170 ++inptr; \
172 /* Johab : 1. Hangul \
173 1st byte : 0x84-0xd3 \
174 2nd byte : 0x41-0x7e, 0x81-0xfe \
175 2. Hanja & Symbol : \
176 1st byte : 0xd8-0xde, 0xe0-0xf9 \
177 2nd byte : 0x31-0x7e, 0x91-0xfe \
178 0xd831-0xd87e and 0xd891-0xd8fe are user-defined area */ \
179 else \
181 if (__builtin_expect (ch > 0xf9, 0) \
182 || __builtin_expect (ch == 0xdf, 0) \
183 || (__builtin_expect (ch > 0x7e, 0) && ch < 0x84) \
184 || (__builtin_expect (ch > 0xd3, 0) && ch < 0xd9)) \
186 /* These are illegal. */ \
187 if (! ignore_errors_p ()) \
189 /* This is an illegal character. */ \
190 result = __GCONV_ILLEGAL_INPUT; \
191 break; \
194 ++inptr; \
195 ++*irreversible; \
196 continue; \
198 else \
200 /* Two-byte character. First test whether the next \
201 character is also available. */ \
202 uint32_t ch2; \
203 uint_fast32_t idx; \
205 if (__builtin_expect (inptr + 1 >= inend, 0)) \
207 /* The second character is not available. Store the \
208 intermediate result. */ \
209 result = __GCONV_INCOMPLETE_INPUT; \
210 break; \
213 ch2 = inptr[1]; \
214 idx = ch * 256 + ch2; \
215 if (__builtin_expect (ch <= 0xd3, 1)) \
217 /* Hangul */ \
218 uint_fast32_t i, m, f; \
220 i = init[(idx & 0x7c00) >> 10]; \
221 m = mid[(idx & 0x03e0) >> 5]; \
222 f = final[idx & 0x001f]; \
224 if (__builtin_expect (i, 0) == -1 \
225 || __builtin_expect (m, 0) == -1 \
226 || __builtin_expect (f, 0) == -1) \
228 /* This is illegal. */ \
229 if (! ignore_errors_p ()) \
231 /* This is an illegal character. */ \
232 result = __GCONV_ILLEGAL_INPUT; \
233 break; \
236 ++inptr; \
237 ++*irreversible; \
238 continue; \
240 else if (i > 0 && m > 0) \
241 ch = ((i - 1) * 21 + (m - 1)) * 28 + f + 0xac00; \
242 else if (i > 0 && m == 0 && f == 0) \
243 ch = init_to_ucs[i - 1]; \
244 else if (i == 0 && m > 0 && f == 0) \
245 ch = 0x314e + m; /* 0x314f + m - 1 */ \
246 else if (__builtin_expect (i | m, 0) == 0 \
247 && __builtin_expect (f > 0, 1)) \
248 ch = final_to_ucs[f - 1]; /* round trip?? */ \
249 else \
251 /* This is illegal. */ \
252 if (! ignore_errors_p ()) \
254 /* This is an illegal character. */ \
255 result = __GCONV_ILLEGAL_INPUT; \
256 break; \
259 ++inptr; \
260 ++*irreversible; \
261 continue; \
264 else \
266 if (__builtin_expect (ch2 < 0x31, 0) \
267 || (__builtin_expect (ch2 > 0x7e, 0) && ch2 < 0x91) \
268 || __builtin_expect (ch2, 0) == 0xff \
269 || (__builtin_expect (ch, 0) == 0xd9 && ch2 > 0xe5) \
270 || (__builtin_expect (ch, 0) == 0xda \
271 && ch2 > 0xa0 && ch2 < 0xd4) \
272 || (__builtin_expect (ch, 0) == 0xde && ch2 > 0xf1)) \
274 /* This is illegal. */ \
275 if (! ignore_errors_p ()) \
277 /* This is an illegal character. */ \
278 result = __GCONV_ILLEGAL_INPUT; \
279 break; \
282 ++inptr; \
283 ++*irreversible; \
284 continue; \
286 else \
288 ch = johab_sym_hanja_to_ucs (idx, ch, ch2); \
289 /* if (idx <= 0xdefe) \
290 ch = __ksc5601_sym_to_ucs[(ch - 0xd9) * 192 \
291 + ch2 - (ch2 > 0x90 \
292 ? 0x43 : 0x31)]; \
293 else \
294 ch = __ksc5601_hanja_to_ucs[(ch - 0xe0) *192 \
295 + ch2 - (ch2 > 0x90 \
296 ?0x43 : 0x31)];\
297 */ \
302 if (__builtin_expect (ch, 1) == 0) \
304 /* This is an illegal character. */ \
305 if (! ignore_errors_p ()) \
307 /* This is an illegal character. */ \
308 result = __GCONV_ILLEGAL_INPUT; \
309 break; \
312 inptr += 2; \
313 ++*irreversible; \
314 continue; \
317 inptr += 2; \
320 put32 (outptr, ch); \
321 outptr += 4; \
323 #define LOOP_NEED_FLAGS
324 #include <iconv/loop.c>
327 /* Next, define the other direction. */
328 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
329 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
330 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
331 #define LOOPFCT TO_LOOP
332 #define BODY \
334 uint32_t ch = get32 (inptr); \
335 /* \
336 if (ch >= (sizeof (from_ucs4_lat1) / sizeof (from_ucs4_lat1[0]))) \
338 if (ch >= 0x0391 && ch <= 0x0451) \
339 cp = from_ucs4_greek[ch - 0x391]; \
340 else if (ch >= 0x2010 && ch <= 0x9fa0) \
341 cp = from_ucs4_cjk[ch - 0x02010]; \
342 else \
343 break; \
345 else \
346 cp = from_ucs4_lat1[ch]; \
347 */ \
349 if (ch <= 0x7f && ch != 0x5c) \
350 *outptr++ = ch; \
351 else \
353 if (ch >= 0xac00 && ch <= 0xd7a3) \
355 if (__builtin_expect (outptr + 2 > outend, 0)) \
357 result = __GCONV_FULL_OUTPUT; \
358 break; \
361 ch -= 0xac00; \
363 ch = (init_to_bit[ch / 588] /* 21 * 28 = 588 */ \
364 + mid_to_bit[(ch / 28) % 21]/* (ch % (21 * 28)) / 28 */ \
365 + final_to_bit[ch % 28]); /* (ch % (21 * 28)) % 28 */ \
367 *outptr++ = ch / 256; \
368 *outptr++ = ch % 256; \
370 /* KS C 5601-1992 Annex 3 regards 0xA4DA(Hangul Filler : U3164) \
371 as symbol */ \
372 else if (ch >= 0x3131 && ch <= 0x3163) \
374 ch = jamo_from_ucs_table[ch - 0x3131]; \
376 if (__builtin_expect (outptr + 2 > outend, 0)) \
378 result = __GCONV_FULL_OUTPUT; \
379 break; \
382 *outptr++ = ch / 256; \
383 *outptr++ = ch % 256; \
385 else if ((ch >= 0x4e00 && ch <= 0x9fa5) \
386 || (ch >= 0xf900 && ch <= 0xfa0b)) \
388 size_t written; \
389 uint32_t temp; \
391 written = ucs4_to_ksc5601_hanja (ch, outptr, outend - outptr); \
392 if (__builtin_expect (written, 1) == 0) \
394 result = __GCONV_FULL_OUTPUT; \
395 break; \
397 if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
399 STANDARD_ERR_HANDLER (4); \
402 outptr[0] -= 0x4a; \
403 outptr[1] -= 0x21; \
405 temp = outptr[0] * 94 + outptr[1]; \
407 outptr[0] = 0xe0 + temp / 188; \
408 outptr[1] = temp % 188; \
409 outptr[1] += outptr[1] >= 78 ? 0x43 : 0x31; \
411 outptr += 2; \
413 else if (ch == 0x20a9) \
414 *outptr++ = 0x5c; \
415 else \
417 size_t written; \
418 uint32_t temp; \
420 written = ucs4_to_ksc5601_sym (ch, outptr, outend - outptr); \
421 if (__builtin_expect (written, 1) == 0) \
423 result = __GCONV_FULL_OUTPUT; \
424 break; \
426 if (__builtin_expect (written, 1) == __UNKNOWN_10646_CHAR \
427 || (outptr[0] == 0x22 && outptr[1] > 0x65)) \
429 UNICODE_TAG_HANDLER (ch, 4); \
430 STANDARD_ERR_HANDLER (4); \
433 temp = (outptr[0] < 0x4a ? outptr[0] + 0x191 : outptr[0] + 0x176);\
434 outptr[1] += (temp % 2 ? 0x5e : 0); \
435 outptr[1] += (outptr[1] < 0x6f ? 0x10 : 0x22); \
436 outptr[0] = temp / 2; \
438 outptr += 2; \
442 inptr += 4; \
444 #define LOOP_NEED_FLAGS
445 #include <iconv/loop.c>
448 /* Now define the toplevel functions. */
449 #include <iconv/skeleton.c>