1/* Conversion module for ISO-2022-KR.
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
5
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.
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
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <dlfcn.h>
21#include <gconv.h>
22#include <stdint.h>
23#include <string.h>
24#include "ksc5601.h"
25
26#include <assert.h>
27
28/* This makes obvious what everybody knows: 0x1b is the Esc character. */
29#define ESC 0x1b
30
31/* The shift sequences for this charset (it does not use ESC). */
32#define SI 0x0f
33#define SO 0x0e
34
35/* Definitions used in the body of the `gconv' function. */
36#define CHARSET_NAME "ISO-2022-KR//"
37#define DEFINE_INIT 1
38#define DEFINE_FINI 1
39#define FROM_LOOP from_iso2022kr_loop
40#define TO_LOOP to_iso2022kr_loop
41#define MIN_NEEDED_FROM 1
42#define MAX_NEEDED_FROM 4
43#define MIN_NEEDED_TO 4
44#define MAX_NEEDED_TO 4
45#define ONE_DIRECTION 0
46#define PREPARE_LOOP \
47 int save_set; \
48 int *setp = &data->__statep->__count; \
49 if (!FROM_DIRECTION && !data->__internal_use \
50 && data->__invocation_counter == 0) \
51 { \
52 /* Emit the designator sequence. */ \
53 if (outbuf + 4 > outend) \
54 return __GCONV_FULL_OUTPUT; \
55 \
56 *outbuf++ = ESC; \
57 *outbuf++ = '$'; \
58 *outbuf++ = ')'; \
59 *outbuf++ = 'C'; \
60 }
61#define EXTRA_LOOP_ARGS , setp
62
63
64/* The COUNT element of the state keeps track of the currently selected
65 character set. The possible values are: */
66enum
67{
68 ASCII_set = 0,
69 KSC5601_set = 8
70};
71
72
73/* Since this is a stateful encoding we have to provide code which resets
74 the output state to the initial state. This has to be done during the
75 flushing. */
76#define EMIT_SHIFT_TO_INIT \
77 if (data->__statep->__count != ASCII_set) \
78 { \
79 if (FROM_DIRECTION) \
80 { \
81 /* It's easy, we don't have to emit anything, we just reset the \
82 state for the input. */ \
83 data->__statep->__count &= 7; \
84 data->__statep->__count |= ASCII_set; \
85 } \
86 else \
87 { \
88 /* We are not in the initial state. To switch back we have \
89 to emit `SI'. */ \
90 if (__glibc_unlikely (outbuf == outend)) \
91 /* We don't have enough room in the output buffer. */ \
92 status = __GCONV_FULL_OUTPUT; \
93 else \
94 { \
95 /* Write out the shift sequence. */ \
96 *outbuf++ = SI; \
97 data->__statep->__count = ASCII_set; \
98 } \
99 } \
100 }
101
102
103/* Since we might have to reset input pointer we must be able to save
104 and retore the state. */
105#define SAVE_RESET_STATE(Save) \
106 if (Save) \
107 save_set = *setp; \
108 else \
109 *setp = save_set
110
111
112/* First define the conversion function from ISO-2022-KR to UCS4. */
113#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
114#define MAX_NEEDED_INPUT MAX_NEEDED_FROM
115#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
116#define LOOPFCT FROM_LOOP
117#define BODY \
118 { \
119 uint32_t ch = *inptr; \
120 \
121 /* This is a 7bit character set, disallow all 8bit characters. */ \
122 if (__glibc_unlikely (ch > 0x7f)) \
123 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
124 \
125 /* Recognize escape sequences. */ \
126 if (__builtin_expect (ch, 0) == ESC) \
127 { \
128 /* We don't really have to handle escape sequences since all the \
129 switching is done using the SI and SO bytes. But we have to \
130 recognize `Esc $ ) C' since this is a kind of flag for this \
131 encoding. We simply ignore it. */ \
132 if (__builtin_expect (inptr + 2 > inend, 0) \
133 || (inptr[1] == '$' \
134 && (__builtin_expect (inptr + 3 > inend, 0) \
135 || (inptr[2] == ')' \
136 && __builtin_expect (inptr + 4 > inend, 0))))) \
137 { \
138 result = __GCONV_INCOMPLETE_INPUT; \
139 break; \
140 } \
141 if (inptr[1] == '$' && inptr[2] == ')' && inptr[3] == 'C') \
142 { \
143 /* Yeah, yeah, we know this is ISO 2022-KR. */ \
144 inptr += 4; \
145 continue; \
146 } \
147 } \
148 else if (__builtin_expect (ch, 0) == SO) \
149 { \
150 /* Switch to use KSC. */ \
151 ++inptr; \
152 set = KSC5601_set; \
153 continue; \
154 } \
155 else if (__builtin_expect (ch, 0) == SI) \
156 { \
157 /* Switch to use ASCII. */ \
158 ++inptr; \
159 set = ASCII_set; \
160 continue; \
161 } \
162 \
163 if (set == ASCII_set) \
164 { \
165 /* Almost done, just advance the input pointer. */ \
166 ++inptr; \
167 } \
168 else \
169 { \
170 assert (set == KSC5601_set); \
171 \
172 /* Use the KSC 5601 table. */ \
173 ch = ksc5601_to_ucs4 (&inptr, inend - inptr, 0); \
174 \
175 if (__glibc_unlikely (ch == 0)) \
176 { \
177 result = __GCONV_INCOMPLETE_INPUT; \
178 break; \
179 } \
180 else if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR)) \
181 { \
182 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
183 } \
184 } \
185 \
186 put32 (outptr, ch); \
187 outptr += 4; \
188 }
189#define LOOP_NEED_FLAGS
190#define EXTRA_LOOP_DECLS , int *setp
191#define INIT_PARAMS int set = *setp
192#define UPDATE_PARAMS *setp = set
193#include <iconv/loop.c>
194
195
196/* Next, define the other direction. */
197#define MIN_NEEDED_INPUT MIN_NEEDED_TO
198#define MIN_NEEDED_OUTPUT MIN_NEEDED_FROM
199#define MAX_NEEDED_OUTPUT MAX_NEEDED_FROM
200#define LOOPFCT TO_LOOP
201#define BODY \
202 { \
203 uint32_t ch = get32 (inptr); \
204 \
205 /* First see whether we can write the character using the currently \
206 selected character set. */ \
207 if (ch < 0x80) \
208 { \
209 if (set != ASCII_set) \
210 { \
211 *outptr++ = SI; \
212 set = ASCII_set; \
213 if (__glibc_unlikely (outptr == outend)) \
214 { \
215 result = __GCONV_FULL_OUTPUT; \
216 break; \
217 } \
218 } \
219 \
220 *outptr++ = ch; \
221 } \
222 else \
223 { \
224 unsigned char buf[2]; \
225 /* Fake initialization to keep gcc quiet. */ \
226 asm ("" : "=m" (buf)); \
227 \
228 size_t written = ucs4_to_ksc5601 (ch, buf, 2); \
229 if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
230 { \
231 UNICODE_TAG_HANDLER (ch, 4); \
232 \
233 /* Illegal character. */ \
234 STANDARD_TO_LOOP_ERR_HANDLER (4); \
235 } \
236 else \
237 { \
238 assert (written == 2); \
239 \
240 /* We use KSC 5601. */ \
241 if (set != KSC5601_set) \
242 { \
243 *outptr++ = SO; \
244 set = KSC5601_set; \
245 } \
246 \
247 if (__glibc_unlikely (outptr + 2 > outend)) \
248 { \
249 result = __GCONV_FULL_OUTPUT; \
250 break; \
251 } \
252 \
253 *outptr++ = buf[0]; \
254 *outptr++ = buf[1]; \
255 } \
256 } \
257 \
258 /* Now that we wrote the output increment the input pointer. */ \
259 inptr += 4; \
260 }
261#define LOOP_NEED_FLAGS
262#define EXTRA_LOOP_DECLS , int *setp
263#define INIT_PARAMS int set = *setp
264#define REINIT_PARAMS set = *setp
265#define UPDATE_PARAMS *setp = set
266#include <iconv/loop.c>
267
268
269/* Now define the toplevel functions. */
270#include <iconv/skeleton.c>
271