?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Consider TTL of CNAME record and return minimum TTL in the chain
[glibc.git] / iconvdata / johab.c
blobf5749aba7f4f516bc3a4b6230738d2bdfa368c3e
1 /* Mapping tables for JOHAB handling.
2 Copyright (C) 1998-2002, 2007, 2011 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.
6
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.
11
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.
16
17 You should have received a copy of the GNU Lesser General Public
18 License along with the GNU C Library; if not, see
19 <http://www.gnu.org/licenses/>. */
20
21 #include <dlfcn.h>
22 #include <stdint.h>
23 #include <ksc5601.h>
24
25 /* The table for Bit pattern to Hangul Jamo
26 5 bits each are used to encode
27 leading consonants(19 + 1 filler), medial vowels(21 + 1 filler)
28 and trailing consonants(27 + 1 filler).
29
30 KS C 5601-1992 Annex 3 Table 2
31 0 : Filler, -1: invalid, >= 1 : valid
32
33 */
34 static const int init[32] =
35 {
36 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
37 19, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
38 };
39 static const int mid[32] =
40 {
41 -1, -1, 0, 1, 2, 3, 4, 5,
42 -1, -1, 6, 7, 8, 9, 10, 11,
43 -1, -1, 12, 13, 14, 15, 16, 17,
44 -1, -1, 18, 19, 20, 21, -1, -1
45 };
46 static const int final[32] =
47 {
48 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
49 -1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1
50 };
51
52 /*
53 Hangul Jamo in Johab to Unicode 2.0 : Unicode 2.0
54 defines 51 Hangul Compatibility Jamos in the block [0x3131,0x314e]
55
56 It's to be considered later which Jamo block to use, Compatibility
57 block [0x3131,0x314e] or Hangul Conjoining Jamo block, [0x1100,0x11ff]
58
59 */
60 static const uint32_t init_to_ucs[19] =
61 {
62 0x3131, 0x3132, 0x3134, 0x3137, 0x3138, 0x3139, 0x3141, 0x3142,
63 0x3143, 0x3145, 0x3146, 0x3147, 0x3148, 0x3149, 0x314a, 0x314b,
64 0x314c, 0x314d, 0x314e
65 };
66
67 static const uint32_t final_to_ucs[31] =
68 {
69 L'\0', L'\0', 0x3133, L'\0', 0x3135, 0x3136, L'\0', L'\0',
70 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
71 0x3140, L'\0', L'\0', 0x3144, L'\0', L'\0', L'\0', L'\0',
72 L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0', L'\0'
73 };
74
75 /* The following three arrays are used to convert
76 precomposed Hangul syllables in [0xac00,0xd???]
77 to Jamo bit patterns for Johab encoding
78
79 cf. : KS C 5601-1992, Annex3 Table 2
80
81 Arrays are used to speed up things although it's possible
82 to get the same result arithmetically.
83
84 */
85 static const int init_to_bit[19] =
86 {
87 0x8800, 0x8c00, 0x9000, 0x9400, 0x9800, 0x9c00,
88 0xa000, 0xa400, 0xa800, 0xac00, 0xb000, 0xb400,
89 0xb800, 0xbc00, 0xc000, 0xc400, 0xc800, 0xcc00,
90 0xd000
91 };
92
93 static const int mid_to_bit[21] =
94 {
95 0x0060, 0x0080, 0x00a0, 0x00c0, 0x00e0,
96 0x0140, 0x0160, 0x0180, 0x01a0, 0x01c0, 0x1e0,
97 0x0240, 0x0260, 0x0280, 0x02a0, 0x02c0, 0x02e0,
98 0x0340, 0x0360, 0x0380, 0x03a0
99 };
100
101 static const int final_to_bit[28] =
102 {
103 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
104 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d
105 };
106
107 /* The conversion table from
108 UCS4 Hangul Compatibility Jamo in [0x3131,0x3163]
109 to Johab
110
111 cf. 1. KS C 5601-1992 Annex 3 Table 2
112 2. Unicode 2.0 manual
113
114 */
115 static const uint16_t jamo_from_ucs_table[51] =
116 {
117 0x8841, 0x8c41,
118 0x8444,
119 0x9041,
120 0x8446, 0x8447,
121 0x9441, 0x9841, 0x9c41,
122 0x844a, 0x844b, 0x844c, 0x844d, 0x844e, 0x844f, 0x8450,
123 0xa041, 0xa441, 0xa841,
124 0x8454,
125 0xac41, 0xb041, 0xb441, 0xb841, 0xbc41,
126 0xc041, 0xc441, 0xc841, 0xcc41, 0xd041,
127 0x8461, 0x8481, 0x84a1, 0x84c1, 0x84e1,
128 0x8541, 0x8561, 0x8581, 0x85a1, 0x85c1, 0x85e1,
129 0x8641, 0x8661, 0x8681, 0x86a1, 0x86c1, 0x86e1,
130 0x8741, 0x8761, 0x8781, 0x87a1
131 };
132
133
134 static uint32_t
135 johab_sym_hanja_to_ucs (uint_fast32_t idx, uint_fast32_t c1, uint_fast32_t c2)
136 {
137 if (idx <= 0xdefe)
138 return (uint32_t) __ksc5601_sym_to_ucs[(c1 - 0xd9) * 188 + c2
139 - (c2 > 0x90 ? 0x43 : 0x31)];
140 else
141 return (uint32_t) __ksc5601_hanja_to_ucs[(c1 - 0xe0) * 188 + c2
142 - (c2 > 0x90 ? 0x43 : 0x31)];
143 }
144 /* Definitions used in the body of the `gconv' function. */
145 #define CHARSET_NAME "JOHAB//"
146 #define FROM_LOOP from_johab
147 #define TO_LOOP to_johab
148 #define DEFINE_INIT 1
149 #define DEFINE_FINI 1
150 #define MIN_NEEDED_FROM 1
151 #define MAX_NEEDED_FROM 2
152 #define MIN_NEEDED_TO 4
153
154
155 /* First define the conversion function from JOHAB to UCS4. */
156 #define MIN_NEEDED_INPUT MIN_NEEDED_FROM
157 #define MAX_NEEDED_INPUT MAX_NEEDED_FROM
158 #define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
159 #define LOOPFCT FROM_LOOP
160 #define BODY \
161 { \
162 uint32_t ch = *inptr; \
163 \
164 if (ch <= 0x7f) \
165 { \
166 /* Plain ISO646-KR. */ \
167 if (ch == 0x5c) \
168 ch = 0x20a9; /* half-width Korean Currency WON sign */ \
169 ++inptr; \
170 } \
171 /* Johab : 1. Hangul \
172 1st byte : 0x84-0xd3 \
173 2nd byte : 0x41-0x7e, 0x81-0xfe \
174 2. Hanja & Symbol : \
175 1st byte : 0xd8-0xde, 0xe0-0xf9 \
176 2nd byte : 0x31-0x7e, 0x91-0xfe \
177 0xd831-0xd87e and 0xd891-0xd8fe are user-defined area */ \
178 else \
179 { \
180 if (__builtin_expect (ch > 0xf9, 0) \
181 || __builtin_expect (ch == 0xdf, 0) \
182 || (__builtin_expect (ch > 0x7e, 0) && ch < 0x84) \
183 || (__builtin_expect (ch > 0xd3, 0) && ch < 0xd9)) \
184 { \
185 /* These are illegal. */ \
186 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
187 } \
188 else \
189 { \
190 /* Two-byte character. First test whether the next \
191 character is also available. */ \
192 uint32_t ch2; \
193 uint_fast32_t idx; \
194 \
195 if (__builtin_expect (inptr + 1 >= inend, 0)) \
196 { \
197 /* The second character is not available. Store the \
198 intermediate result. */ \
199 result = __GCONV_INCOMPLETE_INPUT; \
200 break; \
201 } \
202 \
203 ch2 = inptr[1]; \
204 idx = ch * 256 + ch2; \
205 if (__builtin_expect (ch <= 0xd3, 1)) \
206 { \
207 /* Hangul */ \
208 int_fast32_t i, m, f; \
209 \
210 i = init[(idx & 0x7c00) >> 10]; \
211 m = mid[(idx & 0x03e0) >> 5]; \
212 f = final[idx & 0x001f]; \
213 \
214 if (__builtin_expect (i == -1, 0) \
215 || __builtin_expect (m == -1, 0) \
216 || __builtin_expect (f == -1, 0)) \
217 { \
218 /* This is illegal. */ \
219 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
220 } \
221 else if (i > 0 && m > 0) \
222 ch = ((i - 1) * 21 + (m - 1)) * 28 + f + 0xac00; \
223 else if (i > 0 && m == 0 && f == 0) \
224 ch = init_to_ucs[i - 1]; \
225 else if (i == 0 && m > 0 && f == 0) \
226 ch = 0x314e + m; /* 0x314f + m - 1 */ \
227 else if (__builtin_expect ((i | m) == 0, 1) \
228 && __builtin_expect (f > 0, 1)) \
229 ch = final_to_ucs[f - 1]; /* round trip?? */ \
230 else \
231 { \
232 /* This is illegal. */ \
233 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
234 } \
235 } \
236 else \
237 { \
238 if (__builtin_expect (ch2 < 0x31, 0) \
239 || (__builtin_expect (ch2 > 0x7e, 0) && ch2 < 0x91) \
240 || __builtin_expect (ch2, 0) == 0xff \
241 || (__builtin_expect (ch, 0) == 0xd9 && ch2 > 0xe8) \
242 || (__builtin_expect (ch, 0) == 0xda \
243 && ch2 > 0xa0 && ch2 < 0xd4) \
244 || (__builtin_expect (ch, 0) == 0xde && ch2 > 0xf1)) \
245 { \
246 /* This is illegal. */ \
247 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
248 } \
249 else \
250 { \
251 ch = johab_sym_hanja_to_ucs (idx, ch, ch2); \
252 /* if (idx <= 0xdefe) \
253 ch = __ksc5601_sym_to_ucs[(ch - 0xd9) * 192 \
254 + ch2 - (ch2 > 0x90 \
255 ? 0x43 : 0x31)]; \
256 else \
257 ch = __ksc5601_hanja_to_ucs[(ch - 0xe0) *192 \
258 + ch2 - (ch2 > 0x90 \
259 ?0x43 : 0x31)];\
260 */ \
261 } \
262 } \
263 } \
264 \
265 if (__builtin_expect (ch == 0, 0)) \
266 { \
267 /* This is an illegal character. */ \
268 STANDARD_FROM_LOOP_ERR_HANDLER (2); \
269 } \
270 \
271 inptr += 2; \
272 } \
273 \
274 put32 (outptr, ch); \
275 outptr += 4; \
276 }
277 #define LOOP_NEED_FLAGS
278 #define ONEBYTE_BODY \
279 { \
280 if (c <= 0x7f) \
281 return (c == 0x5c ? 0x20a9 : c); \
282 else \
283 return WEOF; \
284 }
285 #include <iconv/loop.c>
286
287
288 /* Next, define the other direction. */
289 #define MIN_NEEDED_INPUT MIN_NEEDED_TO
290 #define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
291 #define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
292 #define LOOPFCT TO_LOOP
293 #define BODY \
294 { \
295 uint32_t ch = get32 (inptr); \
296 /* \
297 if (ch >= (sizeof (from_ucs4_lat1) / sizeof (from_ucs4_lat1[0]))) \
298 { \
299 if (ch >= 0x0391 && ch <= 0x0451) \
300 cp = from_ucs4_greek[ch - 0x391]; \
301 else if (ch >= 0x2010 && ch <= 0x9fa0) \
302 cp = from_ucs4_cjk[ch - 0x02010]; \
303 else \
304 break; \
305 } \
306 else \
307 cp = from_ucs4_lat1[ch]; \
308 */ \
309 \
310 if (ch <= 0x7f && ch != 0x5c) \
311 *outptr++ = ch; \
312 else \
313 { \
314 if (ch >= 0xac00 && ch <= 0xd7a3) \
315 { \
316 if (__builtin_expect (outptr + 2 > outend, 0)) \
317 { \
318 result = __GCONV_FULL_OUTPUT; \
319 break; \
320 } \
321 \
322 ch -= 0xac00; \
323 \
324 ch = (init_to_bit[ch / 588] /* 21 * 28 = 588 */ \
325 + mid_to_bit[(ch / 28) % 21]/* (ch % (21 * 28)) / 28 */ \
326 + final_to_bit[ch % 28]); /* (ch % (21 * 28)) % 28 */ \
327 \
328 *outptr++ = ch / 256; \
329 *outptr++ = ch % 256; \
330 } \
331 /* KS C 5601-1992 Annex 3 regards 0xA4DA(Hangul Filler : U3164) \
332 as symbol */ \
333 else if (ch >= 0x3131 && ch <= 0x3163) \
334 { \
335 ch = jamo_from_ucs_table[ch - 0x3131]; \
336 \
337 if (__builtin_expect (outptr + 2 > outend, 0)) \
338 { \
339 result = __GCONV_FULL_OUTPUT; \
340 break; \
341 } \
342 \
343 *outptr++ = ch / 256; \
344 *outptr++ = ch % 256; \
345 } \
346 else if ((ch >= 0x4e00 && ch <= 0x9fa5) \
347 || (ch >= 0xf900 && ch <= 0xfa0b)) \
348 { \
349 size_t written; \
350 uint32_t temp; \
351 \
352 written = ucs4_to_ksc5601_hanja (ch, outptr, outend - outptr); \
353 if (__builtin_expect (written, 1) == 0) \
354 { \
355 result = __GCONV_FULL_OUTPUT; \
356 break; \
357 } \
358 if (__builtin_expect (written == __UNKNOWN_10646_CHAR, 0)) \
359 { \
360 STANDARD_TO_LOOP_ERR_HANDLER (4); \
361 } \
362 \
363 outptr[0] -= 0x4a; \
364 outptr[1] -= 0x21; \
365 \
366 temp = outptr[0] * 94 + outptr[1]; \
367 \
368 outptr[0] = 0xe0 + temp / 188; \
369 outptr[1] = temp % 188; \
370 outptr[1] += outptr[1] >= 78 ? 0x43 : 0x31; \
371 \
372 outptr += 2; \
373 } \
374 else if (ch == 0x20a9) \
375 *outptr++ = 0x5c; \
376 else \
377 { \
378 size_t written; \
379 uint32_t temp; \
380 \
381 written = ucs4_to_ksc5601_sym (ch, outptr, outend - outptr); \
382 if (__builtin_expect (written, 1) == 0) \
383 { \
384 result = __GCONV_FULL_OUTPUT; \
385 break; \
386 } \
387 if (__builtin_expect (written == __UNKNOWN_10646_CHAR, 0) \
388 || (outptr[0] == 0x22 && outptr[1] > 0x68)) \
389 { \
390 UNICODE_TAG_HANDLER (ch, 4); \
391 STANDARD_TO_LOOP_ERR_HANDLER (4); \
392 } \
393 \
394 temp = (outptr[0] < 0x4a ? outptr[0] + 0x191 : outptr[0] + 0x176);\
395 outptr[1] += (temp % 2 ? 0x5e : 0); \
396 outptr[1] += (outptr[1] < 0x6f ? 0x10 : 0x22); \
397 outptr[0] = temp / 2; \
398 \
399 outptr += 2; \
400 } \
401 } \
402 \
403 inptr += 4; \
404 }
405 #define LOOP_NEED_FLAGS
406 #include <iconv/loop.c>
407
408
409 /* Now define the toplevel functions. */
410 #include <iconv/skeleton.c>
sources.redhat.com git mirror of glibc CVS