]>
Commit | Line | Data |
---|---|---|
c0d99958 | 1 | /* Conversion module for ISO-2022-CN-EXT. |
688903eb | 2 | Copyright (C) 2000-2018 Free Software Foundation, Inc. |
c0d99958 UD |
3 | This file is part of the GNU C Library. |
4 | Contributed by Ulrich Drepper <drepper@cygnus.com>, 2000. | |
5 | ||
6 | The GNU C Library is free software; you can redistribute it and/or | |
41bdb6e2 AJ |
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. | |
c0d99958 UD |
10 | |
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 | |
41bdb6e2 | 14 | Lesser General Public License for more details. |
c0d99958 | 15 | |
41bdb6e2 | 16 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 PE |
17 | License along with the GNU C Library; if not, see |
18 | <http://www.gnu.org/licenses/>. */ | |
c0d99958 UD |
19 | |
20 | #include <dlfcn.h> | |
21 | #include <gconv.h> | |
22 | #include <stdint.h> | |
466dc74c | 23 | #include <stdlib.h> |
c0d99958 UD |
24 | #include <string.h> |
25 | #include "gb2312.h" | |
26 | #include "iso-ir-165.h" | |
755104ed | 27 | #include "cns11643.h" |
c0d99958 UD |
28 | #include "cns11643l1.h" |
29 | #include "cns11643l2.h" | |
9090848d | 30 | #include <libc-diag.h> |
c0d99958 UD |
31 | |
32 | #include <assert.h> | |
33 | ||
34 | /* This makes obvious what everybody knows: 0x1b is the Esc character. */ | |
35 | #define ESC 0x1b | |
36 | ||
37 | /* We have single-byte shift-in and shift-out sequences, and the single | |
38 | shift sequences SS2 and SS3 which replaces the SS2/SS3 designation for | |
39 | the next two bytes. */ | |
40 | #define SI 0x0f | |
41 | #define SO 0x0e | |
42 | #define SS2_0 ESC | |
43 | #define SS2_1 0x4e | |
44 | #define SS3_0 ESC | |
45 | #define SS3_1 0x4f | |
46 | ||
47 | /* Definitions used in the body of the `gconv' function. */ | |
48 | #define CHARSET_NAME "ISO-2022-CN-EXT//" | |
49 | #define DEFINE_INIT 1 | |
50 | #define DEFINE_FINI 1 | |
13e402e7 | 51 | #define ONE_DIRECTION 0 |
c0d99958 UD |
52 | #define FROM_LOOP from_iso2022cn_ext_loop |
53 | #define TO_LOOP to_iso2022cn_ext_loop | |
faaa6f62 UD |
54 | #define FROM_LOOP_MIN_NEEDED_FROM 1 |
55 | #define FROM_LOOP_MAX_NEEDED_FROM 4 | |
56 | #define FROM_LOOP_MIN_NEEDED_TO 4 | |
57 | #define FROM_LOOP_MAX_NEEDED_TO 4 | |
58 | #define TO_LOOP_MIN_NEEDED_FROM 4 | |
59 | #define TO_LOOP_MAX_NEEDED_FROM 4 | |
60 | #define TO_LOOP_MIN_NEEDED_TO 1 | |
61 | #define TO_LOOP_MAX_NEEDED_TO 6 | |
c0d99958 UD |
62 | #define PREPARE_LOOP \ |
63 | int save_set; \ | |
64 | int *setp = &data->__statep->__count; | |
65 | #define EXTRA_LOOP_ARGS , setp | |
66 | ||
67 | ||
68 | /* The charsets GB/T 12345-90, GB 7589-87, GB/T 13131-9X, GB 7590-87, | |
69 | and GB/T 13132-9X are not registered to the best of my knowledge and | |
70 | therefore have no escape sequence assigned. We cannot handle them | |
71 | for this reason. Tell the implementation about this. */ | |
72 | #define X12345 '\0' | |
73 | #define X7589 '\0' | |
74 | #define X13131 '\0' | |
75 | #define X7590 '\0' | |
76 | #define X13132 '\0' | |
77 | ||
78 | ||
79 | /* The COUNT element of the state keeps track of the currently selected | |
80 | character set. The possible values are: */ | |
81 | enum | |
82 | { | |
83 | ASCII_set = 0, | |
84 | GB2312_set, | |
85 | GB12345_set, | |
86 | CNS11643_1_set, | |
87 | ISO_IR_165_set, | |
88 | SO_mask = 7, | |
89 | ||
755104ed UD |
90 | GB7589_set = 1 << 3, |
91 | GB13131_set = 2 << 3, | |
92 | CNS11643_2_set = 3 << 3, | |
93 | SS2_mask = 3 << 3, | |
c0d99958 | 94 | |
755104ed UD |
95 | GB7590_set = 1 << 5, |
96 | GB13132_set = 2 << 5, | |
97 | CNS11643_3_set = 3 << 5, | |
98 | CNS11643_4_set = 4 << 5, | |
99 | CNS11643_5_set = 5 << 5, | |
100 | CNS11643_6_set = 6 << 5, | |
101 | CNS11643_7_set = 7 << 5, | |
102 | SS3_mask = 7 << 5, | |
c0d99958 UD |
103 | |
104 | #define CURRENT_MASK (SO_mask | SS2_mask | SS3_mask) | |
105 | ||
755104ed UD |
106 | GB2312_ann = 1 << 8, |
107 | GB12345_ann = 2 << 8, | |
108 | CNS11643_1_ann = 3 << 8, | |
109 | ISO_IR_165_ann = 4 << 8, | |
110 | SO_ann = 7 << 8, | |
c0d99958 | 111 | |
755104ed UD |
112 | GB7589_ann = 1 << 11, |
113 | GB13131_ann = 2 << 11, | |
114 | CNS11643_2_ann = 3 << 11, | |
115 | SS2_ann = 3 << 11, | |
c0d99958 | 116 | |
755104ed UD |
117 | GB7590_ann = 1 << 13, |
118 | GB13132_ann = 2 << 13, | |
119 | CNS11643_3_ann = 3 << 13, | |
120 | CNS11643_4_ann = 4 << 13, | |
121 | CNS11643_5_ann = 5 << 13, | |
122 | CNS11643_6_ann = 6 << 13, | |
123 | CNS11643_7_ann = 7 << 13, | |
124 | SS3_ann = 7 << 13 | |
c0d99958 UD |
125 | }; |
126 | ||
127 | ||
128 | /* Since this is a stateful encoding we have to provide code which resets | |
129 | the output state to the initial state. This has to be done during the | |
130 | flushing. */ | |
131 | #define EMIT_SHIFT_TO_INIT \ | |
655de5fd | 132 | if (data->__statep->__count >> 3 != ASCII_set) \ |
c0d99958 UD |
133 | { \ |
134 | if (FROM_DIRECTION) \ | |
135 | /* It's easy, we don't have to emit anything, we just reset the \ | |
136 | state for the input. */ \ | |
655de5fd | 137 | data->__statep->__count = ASCII_set << 3; \ |
c0d99958 UD |
138 | else \ |
139 | { \ | |
c0d99958 UD |
140 | /* We are not in the initial state. To switch back we have \ |
141 | to emit `SI'. */ \ | |
a1ffb40e | 142 | if (__glibc_unlikely (outbuf == outend)) \ |
c0d99958 UD |
143 | /* We don't have enough room in the output buffer. */ \ |
144 | status = __GCONV_FULL_OUTPUT; \ | |
145 | else \ | |
146 | { \ | |
147 | /* Write out the shift sequence. */ \ | |
148 | *outbuf++ = SI; \ | |
149 | if (data->__flags & __GCONV_IS_LAST) \ | |
150 | *irreversible += 1; \ | |
655de5fd | 151 | data->__statep->__count = ASCII_set << 3; \ |
c0d99958 UD |
152 | } \ |
153 | } \ | |
154 | } | |
155 | ||
156 | ||
157 | /* Since we might have to reset input pointer we must be able to save | |
158 | and retore the state. */ | |
159 | #define SAVE_RESET_STATE(Save) \ | |
160 | if (Save) \ | |
161 | save_set = *setp; \ | |
162 | else \ | |
163 | *setp = save_set | |
164 | ||
165 | ||
166 | /* First define the conversion function from ISO-2022-CN to UCS4. */ | |
faaa6f62 UD |
167 | #define MIN_NEEDED_INPUT FROM_LOOP_MIN_NEEDED_FROM |
168 | #define MAX_NEEDED_INPUT FROM_LOOP_MAX_NEEDED_FROM | |
169 | #define MIN_NEEDED_OUTPUT FROM_LOOP_MIN_NEEDED_TO | |
170 | #define MAX_NEEDED_OUTPUT FROM_LOOP_MAX_NEEDED_TO | |
c0d99958 UD |
171 | #define LOOPFCT FROM_LOOP |
172 | #define BODY \ | |
173 | { \ | |
174 | uint32_t ch = *inptr; \ | |
175 | \ | |
176 | /* This is a 7bit character set, disallow all 8bit characters. */ \ | |
177 | if (ch > 0x7f) \ | |
e438a468 | 178 | STANDARD_FROM_LOOP_ERR_HANDLER (1); \ |
c0d99958 UD |
179 | \ |
180 | /* Recognize escape sequences. */ \ | |
181 | if (ch == ESC) \ | |
182 | { \ | |
183 | /* There are three kinds of escape sequences we have to handle: \ | |
184 | - those announcing the use of GB and CNS characters on the \ | |
185 | line; we can simply ignore them \ | |
186 | - the initial byte of the SS2 sequence. \ | |
187 | - the initial byte of the SS3 sequence. \ | |
188 | */ \ | |
755104ed | 189 | if (inptr + 2 > inend \ |
c0d99958 | 190 | || (inptr[1] == '$' \ |
755104ed UD |
191 | && (inptr + 3 > inend \ |
192 | || (inptr[2] == ')' && inptr + 4 > inend) \ | |
193 | || (inptr[2] == '*' && inptr + 4 > inend) \ | |
194 | || (inptr[2] == '+' && inptr + 4 > inend))) \ | |
195 | || (inptr[1] == SS2_1 && inptr + 4 > inend) \ | |
196 | || (inptr[1] == SS3_1 && inptr + 4 > inend)) \ | |
c0d99958 | 197 | { \ |
755104ed | 198 | result = __GCONV_INCOMPLETE_INPUT; \ |
c0d99958 UD |
199 | break; \ |
200 | } \ | |
201 | if (inptr[1] == '$' \ | |
202 | && ((inptr[2] == ')' \ | |
203 | && (inptr[3] == 'A' \ | |
204 | || (X12345 != '\0' && inptr[3] == X12345) \ | |
205 | || inptr[3] == 'E' || inptr[3] == 'G')) \ | |
206 | || (inptr[2] == '*' \ | |
207 | && ((X7589 != '\0' && inptr[3] == X7589) \ | |
208 | || (X13131 != '\0' && inptr[3] == X13131) \ | |
209 | || inptr[3] == 'H')) \ | |
210 | || (inptr[2] == '+' \ | |
211 | && ((X7590 != '\0' && inptr[3] == X7590) \ | |
212 | || (X13132 != '\0' && inptr[3] == X13132) \ | |
213 | || inptr[3] == 'I' || inptr[3] == 'J' \ | |
214 | || inptr[3] == 'K' || inptr[3] == 'L' \ | |
215 | || inptr[3] == 'M')))) \ | |
216 | { \ | |
217 | /* OK, we accept those character sets. */ \ | |
218 | if (inptr[3] == 'A') \ | |
219 | ann = (ann & ~SO_ann) | GB2312_ann; \ | |
220 | else if (inptr[3] == 'G') \ | |
221 | ann = (ann & ~SO_ann) | CNS11643_1_ann; \ | |
222 | else if (inptr[3] == 'E') \ | |
223 | ann = (ann & ~SO_ann) | ISO_IR_165_ann; \ | |
224 | else if (X12345 != '\0' && inptr[3] == X12345) \ | |
225 | ann = (ann & ~SO_ann) | GB12345_ann; \ | |
226 | else if (inptr[3] == 'H') \ | |
227 | ann = (ann & ~SS2_ann) | CNS11643_2_ann; \ | |
228 | else if (X7589 != '\0' && inptr[3] == X7589) \ | |
229 | ann = (ann & ~SS2_ann) | GB7589_ann; \ | |
230 | else if (X13131 != '\0' && inptr[3] == X13131) \ | |
231 | ann = (ann & ~SS2_ann) | GB13131_ann; \ | |
232 | else if (inptr[3] == 'I') \ | |
233 | ann = (ann & ~SS3_ann) | CNS11643_3_ann; \ | |
234 | else if (inptr[3] == 'J') \ | |
235 | ann = (ann & ~SS3_ann) | CNS11643_4_ann; \ | |
236 | else if (inptr[3] == 'K') \ | |
237 | ann = (ann & ~SS3_ann) | CNS11643_5_ann; \ | |
238 | else if (inptr[3] == 'L') \ | |
239 | ann = (ann & ~SS3_ann) | CNS11643_6_ann; \ | |
240 | else if (inptr[3] == 'M') \ | |
241 | ann = (ann & ~SS3_ann) | CNS11643_7_ann; \ | |
242 | else if (X7590 != '\0' && inptr[3] == X7590) \ | |
243 | ann = (ann & ~SS3_ann) | GB7590_ann; \ | |
244 | else if (X13132 != '\0' && inptr[3] == X13132) \ | |
245 | ann = (ann & ~SS3_ann) | GB13132_ann; \ | |
246 | inptr += 4; \ | |
247 | continue; \ | |
248 | } \ | |
249 | } \ | |
250 | else if (ch == SO) \ | |
251 | { \ | |
252 | /* Switch to use GB2312, GB12345, CNS 11643 plane 1, or ISO-IR-165, \ | |
253 | depending on which S0 designation came last. The only problem \ | |
254 | is what to do with faulty input files where no designator came. \ | |
255 | XXX For now I'll default to use GB2312. If this is not the \ | |
256 | best behavior (e.g., we should flag an error) let me know. */ \ | |
257 | ++inptr; \ | |
304d7abf UD |
258 | if ((ann & SO_ann) != 0) \ |
259 | switch (ann & SO_ann) \ | |
260 | { \ | |
261 | case GB2312_ann: \ | |
262 | set = GB2312_set; \ | |
263 | break; \ | |
264 | case GB12345_ann: \ | |
265 | set = GB12345_set; \ | |
266 | break; \ | |
267 | case CNS11643_1_ann: \ | |
268 | set = CNS11643_1_set; \ | |
269 | break; \ | |
270 | case ISO_IR_165_ann: \ | |
271 | set = ISO_IR_165_set; \ | |
272 | break; \ | |
273 | default: \ | |
274 | abort (); \ | |
275 | } \ | |
276 | else \ | |
c0d99958 | 277 | { \ |
e438a468 | 278 | STANDARD_FROM_LOOP_ERR_HANDLER (1); \ |
c0d99958 UD |
279 | } \ |
280 | continue; \ | |
281 | } \ | |
282 | else if (ch == SI) \ | |
283 | { \ | |
284 | /* Switch to use ASCII. */ \ | |
285 | ++inptr; \ | |
286 | set = ASCII_set; \ | |
287 | continue; \ | |
288 | } \ | |
289 | \ | |
755104ed | 290 | if (ch == ESC && inptr[1] == SS2_1) \ |
c0d99958 UD |
291 | { \ |
292 | /* This is a character from CNS 11643 plane 2. \ | |
293 | XXX We could test here whether the use of this character \ | |
294 | set was announced. \ | |
289ac9dd | 295 | XXX Currently GB7589 and GB13131 are not supported. */ \ |
c0d99958 UD |
296 | inptr += 2; \ |
297 | ch = cns11643l2_to_ucs4 (&inptr, 2, 0); \ | |
298 | if (ch == __UNKNOWN_10646_CHAR) \ | |
e438a468 | 299 | STANDARD_FROM_LOOP_ERR_HANDLER (2); \ |
c0d99958 | 300 | } \ |
755104ed | 301 | /* Note that we can assume here that at least 4 bytes are available if \ |
c0d99958 UD |
302 | the first byte is ESC since otherwise the first if would have been \ |
303 | true. */ \ | |
304 | else if (ch == ESC && inptr[1] == SS3_1) \ | |
305 | { \ | |
306 | /* This is a character from CNS 11643 plane 3 or higher. \ | |
755104ed | 307 | XXX Currently GB7590 and GB13132 are not supported. */ \ |
085a4412 UD |
308 | unsigned char buf[3]; \ |
309 | const unsigned char *tmp = buf; \ | |
755104ed UD |
310 | \ |
311 | buf[1] = inptr[2]; \ | |
312 | buf[2] = inptr[3]; \ | |
313 | switch (ann & SS3_ann) \ | |
c0d99958 | 314 | { \ |
755104ed | 315 | case CNS11643_3_ann: \ |
289ac9dd UD |
316 | buf[0] = 0x23; \ |
317 | ch = cns11643_to_ucs4 (&tmp, 3, 0); \ | |
318 | break; \ | |
319 | case CNS11643_4_ann: \ | |
320 | buf[0] = 0x24; \ | |
321 | ch = cns11643_to_ucs4 (&tmp, 3, 0); \ | |
322 | break; \ | |
323 | case CNS11643_5_ann: \ | |
324 | buf[0] = 0x25; \ | |
325 | ch = cns11643_to_ucs4 (&tmp, 3, 0); \ | |
326 | break; \ | |
327 | case CNS11643_6_ann: \ | |
328 | buf[0] = 0x26; \ | |
329 | ch = cns11643_to_ucs4 (&tmp, 3, 0); \ | |
330 | break; \ | |
331 | case CNS11643_7_ann: \ | |
332 | buf[0] = 0x27; \ | |
333 | ch = cns11643_to_ucs4 (&tmp, 3, 0); \ | |
755104ed UD |
334 | break; \ |
335 | default: \ | |
289ac9dd | 336 | /* XXX Currently GB7590 and GB13132 are not supported. */ \ |
755104ed | 337 | ch = __UNKNOWN_10646_CHAR; \ |
c0d99958 UD |
338 | break; \ |
339 | } \ | |
c0d99958 UD |
340 | if (ch == __UNKNOWN_10646_CHAR) \ |
341 | { \ | |
e438a468 | 342 | STANDARD_FROM_LOOP_ERR_HANDLER (4); \ |
c0d99958 | 343 | } \ |
755104ed UD |
344 | assert (tmp == buf + 3); \ |
345 | inptr += 4; \ | |
c0d99958 UD |
346 | } \ |
347 | else if (set == ASCII_set) \ | |
348 | { \ | |
349 | /* Almost done, just advance the input pointer. */ \ | |
350 | ++inptr; \ | |
351 | } \ | |
352 | else \ | |
353 | { \ | |
354 | /* That's pretty easy, we have a dedicated functions for this. */ \ | |
355 | if (inend - inptr < 2) \ | |
356 | { \ | |
357 | result = __GCONV_INCOMPLETE_INPUT; \ | |
358 | break; \ | |
359 | } \ | |
360 | if (set == GB2312_set) \ | |
361 | ch = gb2312_to_ucs4 (&inptr, inend - inptr, 0); \ | |
362 | else if (set == ISO_IR_165_set) \ | |
363 | ch = isoir165_to_ucs4 (&inptr, inend - inptr); \ | |
364 | else \ | |
365 | { \ | |
366 | assert (set == CNS11643_1_set); \ | |
367 | ch = cns11643l1_to_ucs4 (&inptr, inend - inptr, 0); \ | |
368 | } \ | |
369 | \ | |
370 | if (ch == 0) \ | |
371 | { \ | |
755104ed | 372 | result = __GCONV_INCOMPLETE_INPUT; \ |
c0d99958 UD |
373 | break; \ |
374 | } \ | |
375 | else if (ch == __UNKNOWN_10646_CHAR) \ | |
376 | { \ | |
e438a468 | 377 | STANDARD_FROM_LOOP_ERR_HANDLER (2); \ |
c0d99958 UD |
378 | } \ |
379 | } \ | |
380 | \ | |
b0df6f1a AJ |
381 | *((uint32_t *) outptr) = ch; \ |
382 | outptr += sizeof (uint32_t); \ | |
c0d99958 UD |
383 | } |
384 | #define EXTRA_LOOP_DECLS , int *setp | |
655de5fd UD |
385 | #define INIT_PARAMS int set = (*setp >> 3) & CURRENT_MASK; \ |
386 | int ann = (*setp >> 3) & ~CURRENT_MASK | |
387 | #define UPDATE_PARAMS *setp = (set | ann) << 3 | |
c0d99958 UD |
388 | #define LOOP_NEED_FLAGS |
389 | #include <iconv/loop.c> | |
390 | ||
391 | ||
392 | /* Next, define the other direction. */ | |
faaa6f62 UD |
393 | #define MIN_NEEDED_INPUT TO_LOOP_MIN_NEEDED_FROM |
394 | #define MAX_NEEDED_INPUT TO_LOOP_MAX_NEEDED_FROM | |
395 | #define MIN_NEEDED_OUTPUT TO_LOOP_MIN_NEEDED_TO | |
396 | #define MAX_NEEDED_OUTPUT TO_LOOP_MAX_NEEDED_TO | |
c0d99958 | 397 | #define LOOPFCT TO_LOOP |
93fe09cb CD |
398 | /* With GCC 5.3 when compiling with -Os the compiler emits a warning |
399 | that buf[0] and buf[1] may be used uninitialized. This can only | |
400 | happen in the case where tmpbuf[3] is used, and in that case the | |
401 | write to the tmpbuf[1] and tmpbuf[2] was assured because | |
402 | ucs4_to_cns11643 would have filled in those entries. The difficulty | |
403 | is in getting the compiler to see this logic because tmpbuf[0] is | |
404 | involved in determining the code page and is the indicator that | |
405 | tmpbuf[2] is initialized. */ | |
406 | DIAG_PUSH_NEEDS_COMMENT; | |
407 | DIAG_IGNORE_Os_NEEDS_COMMENT (5, "-Wmaybe-uninitialized"); | |
c0d99958 UD |
408 | #define BODY \ |
409 | { \ | |
410 | uint32_t ch; \ | |
411 | size_t written = 0; \ | |
412 | \ | |
8c0b7170 | 413 | ch = *((const uint32_t *) inptr); \ |
c0d99958 UD |
414 | \ |
415 | /* First see whether we can write the character using the currently \ | |
416 | selected character set. */ \ | |
417 | if (ch < 0x80) \ | |
418 | { \ | |
419 | if (set != ASCII_set) \ | |
420 | { \ | |
421 | *outptr++ = SI; \ | |
422 | set = ASCII_set; \ | |
423 | if (outptr == outend) \ | |
424 | { \ | |
425 | result = __GCONV_FULL_OUTPUT; \ | |
426 | break; \ | |
427 | } \ | |
428 | } \ | |
429 | \ | |
430 | *outptr++ = ch; \ | |
431 | written = 1; \ | |
432 | \ | |
433 | /* At the end of the line we have to clear the `ann' flags since \ | |
434 | every line must contain this information again. */ \ | |
435 | if (ch == L'\n') \ | |
436 | ann = 0; \ | |
437 | } \ | |
438 | else \ | |
439 | { \ | |
ad37480c | 440 | unsigned char buf[2] = { 0, 0 }; \ |
c0d99958 UD |
441 | int used; \ |
442 | \ | |
755104ed UD |
443 | if (set == GB2312_set || ((ann & SO_ann) != CNS11643_1_ann \ |
444 | && (ann & SO_ann) != ISO_IR_165_ann)) \ | |
c0d99958 UD |
445 | { \ |
446 | written = ucs4_to_gb2312 (ch, buf, 2); \ | |
447 | used = GB2312_set; \ | |
448 | } \ | |
755104ed | 449 | else if (set == ISO_IR_165_set || (ann & SO_ann) == ISO_IR_165_set) \ |
c0d99958 | 450 | { \ |
755104ed UD |
451 | written = ucs4_to_isoir165 (ch, buf, 2); \ |
452 | used = ISO_IR_165_set; \ | |
c0d99958 UD |
453 | } \ |
454 | else \ | |
455 | { \ | |
456 | written = ucs4_to_cns11643l1 (ch, buf, 2); \ | |
457 | used = CNS11643_1_set; \ | |
458 | } \ | |
459 | \ | |
460 | if (written == __UNKNOWN_10646_CHAR) \ | |
461 | { \ | |
462 | /* Cannot convert it using the currently selected SO set. \ | |
463 | Next try the SS2 set. */ \ | |
464 | written = ucs4_to_cns11643l2 (ch, buf, 2); \ | |
465 | if (written != __UNKNOWN_10646_CHAR) \ | |
466 | /* Yep, that worked. */ \ | |
467 | used = CNS11643_2_set; \ | |
468 | else \ | |
469 | { \ | |
085a4412 | 470 | unsigned char tmpbuf[3]; \ |
c0d99958 | 471 | \ |
755104ed | 472 | switch (0) \ |
c0d99958 | 473 | { \ |
755104ed UD |
474 | default: \ |
475 | /* Well, see whether we have to change the SO set. */ \ | |
476 | \ | |
477 | if (used != GB2312_set) \ | |
478 | { \ | |
479 | written = ucs4_to_gb2312 (ch, buf, 2); \ | |
480 | if (written != __UNKNOWN_10646_CHAR) \ | |
481 | { \ | |
482 | used = GB2312_set; \ | |
483 | break; \ | |
484 | } \ | |
485 | } \ | |
486 | \ | |
487 | if (used != ISO_IR_165_set) \ | |
488 | { \ | |
489 | written = ucs4_to_isoir165 (ch, buf, 2); \ | |
490 | if (written != __UNKNOWN_10646_CHAR) \ | |
491 | { \ | |
492 | used = ISO_IR_165_set; \ | |
493 | break; \ | |
494 | } \ | |
495 | } \ | |
496 | \ | |
497 | if (used != CNS11643_1_set) \ | |
498 | { \ | |
499 | written = ucs4_to_cns11643l1 (ch, buf, 2); \ | |
500 | if (written != __UNKNOWN_10646_CHAR) \ | |
501 | { \ | |
502 | used = CNS11643_1_set; \ | |
503 | break; \ | |
504 | } \ | |
505 | } \ | |
506 | \ | |
507 | written = ucs4_to_cns11643 (ch, tmpbuf, 3); \ | |
289ac9dd | 508 | if (written == 3 && tmpbuf[0] >= 3 && tmpbuf[0] <= 7) \ |
755104ed UD |
509 | { \ |
510 | buf[0] = tmpbuf[1]; \ | |
511 | buf[1] = tmpbuf[2]; \ | |
289ac9dd | 512 | switch (tmpbuf[0]) \ |
755104ed | 513 | { \ |
289ac9dd | 514 | case 3: \ |
755104ed UD |
515 | used = CNS11643_3_set; \ |
516 | break; \ | |
289ac9dd UD |
517 | case 4: \ |
518 | used = CNS11643_4_set; \ | |
519 | break; \ | |
520 | case 5: \ | |
521 | used = CNS11643_5_set; \ | |
522 | break; \ | |
523 | case 6: \ | |
524 | used = CNS11643_6_set; \ | |
525 | break; \ | |
526 | case 7: \ | |
527 | used = CNS11643_7_set; \ | |
528 | break; \ | |
529 | default: \ | |
530 | abort (); \ | |
755104ed | 531 | } \ |
289ac9dd UD |
532 | written = 2; \ |
533 | break; \ | |
755104ed UD |
534 | } \ |
535 | \ | |
289ac9dd UD |
536 | /* XXX Currently GB7590 and GB13132 are not supported. */\ |
537 | \ | |
c0d99958 | 538 | /* Even this does not work. Error. */ \ |
755104ed UD |
539 | used = ASCII_set; \ |
540 | } \ | |
541 | if (used == ASCII_set) \ | |
542 | { \ | |
601d2942 | 543 | UNICODE_TAG_HANDLER (ch, 4); \ |
e438a468 | 544 | STANDARD_TO_LOOP_ERR_HANDLER (4); \ |
c0d99958 UD |
545 | } \ |
546 | } \ | |
547 | } \ | |
548 | assert (written == 2); \ | |
549 | \ | |
550 | /* See whether we have to emit an escape sequence. */ \ | |
551 | if (set != used) \ | |
552 | { \ | |
553 | /* First see whether we announced that we use this \ | |
554 | character set. */ \ | |
755104ed | 555 | if ((used & SO_mask) != 0 && (ann & SO_ann) != (used << 8)) \ |
c0d99958 UD |
556 | { \ |
557 | const char *escseq; \ | |
558 | \ | |
559 | if (outptr + 4 > outend) \ | |
560 | { \ | |
561 | result = __GCONV_FULL_OUTPUT; \ | |
562 | break; \ | |
563 | } \ | |
564 | \ | |
565 | assert (used >= 1 && used <= 4); \ | |
755104ed UD |
566 | escseq = ")A\0\0)G)E" + (used - 1) * 2; \ |
567 | *outptr++ = ESC; \ | |
568 | *outptr++ = '$'; \ | |
569 | *outptr++ = *escseq++; \ | |
570 | *outptr++ = *escseq++; \ | |
571 | \ | |
572 | ann = (ann & ~SO_ann) | (used << 8); \ | |
573 | } \ | |
574 | else if ((used & SS2_mask) != 0 && (ann & SS2_ann) != (used << 8))\ | |
575 | { \ | |
576 | const char *escseq; \ | |
577 | \ | |
578 | assert (used == CNS11643_2_set); /* XXX */ \ | |
579 | escseq = "*H"; \ | |
580 | *outptr++ = ESC; \ | |
581 | *outptr++ = '$'; \ | |
c0d99958 UD |
582 | *outptr++ = *escseq++; \ |
583 | *outptr++ = *escseq++; \ | |
755104ed UD |
584 | \ |
585 | ann = (ann & ~SS2_ann) | (used << 8); \ | |
586 | } \ | |
587 | else if ((used & SS3_mask) != 0 && (ann & SS3_ann) != (used << 8))\ | |
588 | { \ | |
589 | const char *escseq; \ | |
590 | \ | |
591 | assert ((used >> 5) >= 3 && (used >> 5) <= 7); \ | |
592 | escseq = "+I+J+K+L+M" + ((used >> 5) - 3) * 2; \ | |
593 | *outptr++ = ESC; \ | |
594 | *outptr++ = '$'; \ | |
c0d99958 UD |
595 | *outptr++ = *escseq++; \ |
596 | *outptr++ = *escseq++; \ | |
597 | \ | |
755104ed | 598 | ann = (ann & ~SS3_ann) | (used << 8); \ |
c0d99958 UD |
599 | } \ |
600 | \ | |
601 | if (used == CNS11643_2_set) \ | |
602 | { \ | |
603 | if (outptr + 2 > outend) \ | |
604 | { \ | |
605 | result = __GCONV_FULL_OUTPUT; \ | |
606 | break; \ | |
607 | } \ | |
608 | *outptr++ = SS2_0; \ | |
609 | *outptr++ = SS2_1; \ | |
610 | } \ | |
755104ed UD |
611 | else if (used >= CNS11643_3_set && used <= CNS11643_7_set) \ |
612 | { \ | |
613 | if (outptr + 2 > outend) \ | |
614 | { \ | |
615 | result = __GCONV_FULL_OUTPUT; \ | |
616 | break; \ | |
617 | } \ | |
618 | *outptr++ = SS3_0; \ | |
619 | *outptr++ = SS3_1; \ | |
620 | } \ | |
c0d99958 UD |
621 | else \ |
622 | { \ | |
623 | /* We only have to emit something if currently ASCII is \ | |
624 | selected. Otherwise we are switching within the \ | |
625 | SO charset. */ \ | |
626 | if (set == ASCII_set) \ | |
627 | { \ | |
628 | if (outptr + 1 > outend) \ | |
629 | { \ | |
630 | result = __GCONV_FULL_OUTPUT; \ | |
631 | break; \ | |
632 | } \ | |
633 | *outptr++ = SO; \ | |
634 | } \ | |
635 | } \ | |
636 | \ | |
637 | /* Always test the length here since we have used up all the \ | |
638 | guaranteed output buffer slots. */ \ | |
639 | if (outptr + 2 > outend) \ | |
640 | { \ | |
641 | result = __GCONV_FULL_OUTPUT; \ | |
642 | break; \ | |
643 | } \ | |
644 | } \ | |
645 | else if (outptr + 2 > outend) \ | |
646 | { \ | |
647 | result = __GCONV_FULL_OUTPUT; \ | |
648 | break; \ | |
649 | } \ | |
650 | \ | |
651 | *outptr++ = buf[0]; \ | |
652 | *outptr++ = buf[1]; \ | |
755104ed | 653 | set = used; \ |
c0d99958 UD |
654 | } \ |
655 | \ | |
656 | /* Now that we wrote the output increment the input pointer. */ \ | |
657 | inptr += 4; \ | |
658 | } | |
93fe09cb | 659 | DIAG_POP_NEEDS_COMMENT; |
c0d99958 | 660 | #define EXTRA_LOOP_DECLS , int *setp |
655de5fd UD |
661 | #define INIT_PARAMS int set = (*setp >> 3) & CURRENT_MASK; \ |
662 | int ann = (*setp >> 3) & ~CURRENT_MASK | |
4b1b449d UD |
663 | #define REINIT_PARAMS do \ |
664 | { \ | |
665 | set = (*setp >> 3) & CURRENT_MASK; \ | |
666 | ann = (*setp >> 3) & ~CURRENT_MASK; \ | |
667 | } \ | |
668 | while (0) | |
655de5fd | 669 | #define UPDATE_PARAMS *setp = (set | ann) << 3 |
c0d99958 UD |
670 | #define LOOP_NEED_FLAGS |
671 | #include <iconv/loop.c> | |
672 | ||
673 | ||
674 | /* Now define the toplevel functions. */ | |
675 | #include <iconv/skeleton.c> |