Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * EUC_JP and SJIS
4 : *
5 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
6 : * Portions Copyright (c) 1994, Regents of the University of California
7 : *
8 : * IDENTIFICATION
9 : * src/backend/utils/mb/conversion_procs/euc_jp_and_sjis/euc_jp_and_sjis.c
10 : *
11 : *-------------------------------------------------------------------------
12 : */
13 :
14 : #include "postgres.h"
15 : #include "fmgr.h"
16 : #include "mb/pg_wchar.h"
17 :
18 : /*
19 : * SJIS alternative code.
20 : * this code is used if a mapping EUC -> SJIS is not defined.
21 : */
22 : #define PGSJISALTCODE 0x81ac
23 : #define PGEUCALTCODE 0xa2ae
24 :
25 : /*
26 : * conversion table between SJIS UDC (IBM kanji) and EUC_JP
27 : */
28 : #include "sjis.map"
29 :
30 4 : PG_MODULE_MAGIC_EXT(
31 : .name = "euc_jp_and_sjis",
32 : .version = PG_VERSION
33 : );
34 :
35 4 : PG_FUNCTION_INFO_V1(euc_jp_to_sjis);
36 4 : PG_FUNCTION_INFO_V1(sjis_to_euc_jp);
37 :
38 : /* ----------
39 : * conv_proc(
40 : * INTEGER, -- source encoding id
41 : * INTEGER, -- destination encoding id
42 : * CSTRING, -- source string (null terminated C string)
43 : * CSTRING, -- destination string (null terminated C string)
44 : * INTEGER, -- source string length
45 : * BOOL -- if true, don't throw an error if conversion fails
46 : * ) returns INTEGER;
47 : *
48 : * Returns the number of bytes successfully converted.
49 : * ----------
50 : */
51 :
52 : static int euc_jp2sjis(const unsigned char *euc, unsigned char *p, int len, bool noError);
53 : static int sjis2euc_jp(const unsigned char *sjis, unsigned char *p, int len, bool noError);
54 :
55 : Datum
56 4 : euc_jp_to_sjis(PG_FUNCTION_ARGS)
57 : {
58 4 : unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
59 4 : unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
60 4 : int len = PG_GETARG_INT32(4);
61 4 : bool noError = PG_GETARG_BOOL(5);
62 : int converted;
63 :
64 4 : CHECK_ENCODING_CONVERSION_ARGS(PG_EUC_JP, PG_SJIS);
65 :
66 4 : converted = euc_jp2sjis(src, dest, len, noError);
67 :
68 4 : PG_RETURN_INT32(converted);
69 : }
70 :
71 : Datum
72 4 : sjis_to_euc_jp(PG_FUNCTION_ARGS)
73 : {
74 4 : unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
75 4 : unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
76 4 : int len = PG_GETARG_INT32(4);
77 4 : bool noError = PG_GETARG_BOOL(5);
78 : int converted;
79 :
80 4 : CHECK_ENCODING_CONVERSION_ARGS(PG_SJIS, PG_EUC_JP);
81 :
82 4 : converted = sjis2euc_jp(src, dest, len, noError);
83 :
84 4 : PG_RETURN_INT32(converted);
85 : }
86 :
87 : /*
88 : * EUC_JP -> SJIS
89 : */
90 : static int
91 4 : euc_jp2sjis(const unsigned char *euc, unsigned char *p, int len, bool noError)
92 : {
93 4 : const unsigned char *start = euc;
94 : int c1,
95 : c2,
96 : k;
97 : int l;
98 :
99 16 : while (len > 0)
100 : {
101 12 : c1 = *euc;
102 12 : if (!IS_HIGHBIT_SET(c1))
103 : {
104 : /* ASCII */
105 12 : if (c1 == 0)
106 : {
107 0 : if (noError)
108 0 : break;
109 0 : report_invalid_encoding(PG_EUC_JP,
110 : (const char *) euc, len);
111 : }
112 12 : *p++ = c1;
113 12 : euc++;
114 12 : len--;
115 12 : continue;
116 : }
117 0 : l = pg_encoding_verifymbchar(PG_EUC_JP, (const char *) euc, len);
118 0 : if (l < 0)
119 : {
120 0 : if (noError)
121 0 : break;
122 0 : report_invalid_encoding(PG_EUC_JP,
123 : (const char *) euc, len);
124 : }
125 0 : if (c1 == SS2)
126 : {
127 : /* hankaku kana? */
128 0 : *p++ = euc[1];
129 : }
130 0 : else if (c1 == SS3)
131 : {
132 : /* JIS X0212 kanji? */
133 0 : c1 = euc[1];
134 0 : c2 = euc[2];
135 0 : k = c1 << 8 | c2;
136 0 : if (k >= 0xf5a1)
137 : {
138 : /* UDC2 */
139 0 : c1 -= 0x54;
140 0 : *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x74;
141 0 : *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
142 : }
143 : else
144 : {
145 : int i,
146 : k2;
147 :
148 : /* IBM kanji */
149 0 : for (i = 0;; i++)
150 : {
151 0 : k2 = ibmkanji[i].euc & 0xffff;
152 0 : if (k2 == 0xffff)
153 : {
154 0 : *p++ = PGSJISALTCODE >> 8;
155 0 : *p++ = PGSJISALTCODE & 0xff;
156 0 : break;
157 : }
158 0 : if (k2 == k)
159 : {
160 0 : k = ibmkanji[i].sjis;
161 0 : *p++ = k >> 8;
162 0 : *p++ = k & 0xff;
163 0 : break;
164 : }
165 : }
166 : }
167 : }
168 : else
169 : {
170 : /* JIS X0208 kanji? */
171 0 : c2 = euc[1];
172 0 : k = (c1 << 8) | (c2 & 0xff);
173 0 : if (k >= 0xf5a1)
174 : {
175 : /* UDC1 */
176 0 : c1 -= 0x54;
177 0 : *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1) + 0x6f;
178 : }
179 : else
180 0 : *p++ = ((c1 - 0xa1) >> 1) + ((c1 < 0xdf) ? 0x81 : 0xc1);
181 0 : *p++ = c2 - ((c1 & 1) ? ((c2 < 0xe0) ? 0x61 : 0x60) : 2);
182 : }
183 0 : euc += l;
184 0 : len -= l;
185 : }
186 4 : *p = '\0';
187 :
188 4 : return euc - start;
189 : }
190 :
191 : /*
192 : * SJIS ---> EUC_JP
193 : */
194 : static int
195 4 : sjis2euc_jp(const unsigned char *sjis, unsigned char *p, int len, bool noError)
196 : {
197 4 : const unsigned char *start = sjis;
198 : int c1,
199 : c2,
200 : i,
201 : k,
202 : k2;
203 : int l;
204 :
205 16 : while (len > 0)
206 : {
207 12 : c1 = *sjis;
208 12 : if (!IS_HIGHBIT_SET(c1))
209 : {
210 : /* ASCII */
211 12 : if (c1 == 0)
212 : {
213 0 : if (noError)
214 0 : break;
215 0 : report_invalid_encoding(PG_SJIS,
216 : (const char *) sjis, len);
217 : }
218 12 : *p++ = c1;
219 12 : sjis++;
220 12 : len--;
221 12 : continue;
222 : }
223 0 : l = pg_encoding_verifymbchar(PG_SJIS, (const char *) sjis, len);
224 0 : if (l < 0)
225 : {
226 0 : if (noError)
227 0 : break;
228 0 : report_invalid_encoding(PG_SJIS,
229 : (const char *) sjis, len);
230 : }
231 0 : if (c1 >= 0xa1 && c1 <= 0xdf)
232 : {
233 : /* JIS X0201 (1 byte kana) */
234 0 : *p++ = SS2;
235 0 : *p++ = c1;
236 : }
237 : else
238 : {
239 : /*
240 : * JIS X0208, X0212, user defined extended characters
241 : */
242 0 : c2 = sjis[1];
243 0 : k = (c1 << 8) + c2;
244 0 : if (k >= 0xed40 && k < 0xf040)
245 : {
246 : /* NEC selection IBM kanji */
247 0 : for (i = 0;; i++)
248 : {
249 0 : k2 = ibmkanji[i].nec;
250 0 : if (k2 == 0xffff)
251 0 : break;
252 0 : if (k2 == k)
253 : {
254 0 : k = ibmkanji[i].sjis;
255 0 : c1 = (k >> 8) & 0xff;
256 0 : c2 = k & 0xff;
257 : }
258 : }
259 : }
260 :
261 0 : if (k < 0xeb3f)
262 : {
263 : /* JIS X0208 */
264 0 : *p++ = ((c1 & 0x3f) << 1) + 0x9f + (c2 > 0x9e);
265 0 : *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
266 : }
267 0 : else if ((k >= 0xeb40 && k < 0xf040) || (k >= 0xfc4c && k <= 0xfcfc))
268 : {
269 : /* NEC selection IBM kanji - Other undecided justice */
270 0 : *p++ = PGEUCALTCODE >> 8;
271 0 : *p++ = PGEUCALTCODE & 0xff;
272 : }
273 0 : else if (k >= 0xf040 && k < 0xf540)
274 : {
275 : /*
276 : * UDC1 mapping to X0208 85 ku - 94 ku JIS code 0x7521 -
277 : * 0x7e7e EUC 0xf5a1 - 0xfefe
278 : */
279 0 : c1 -= 0x6f;
280 0 : *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
281 0 : *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
282 : }
283 0 : else if (k >= 0xf540 && k < 0xfa40)
284 : {
285 : /*
286 : * UDC2 mapping to X0212 85 ku - 94 ku JIS code 0x7521 -
287 : * 0x7e7e EUC 0x8ff5a1 - 0x8ffefe
288 : */
289 0 : *p++ = SS3;
290 0 : c1 -= 0x74;
291 0 : *p++ = ((c1 & 0x3f) << 1) + 0xf3 + (c2 > 0x9e);
292 0 : *p++ = c2 + ((c2 > 0x9e) ? 2 : 0x60) + (c2 < 0x80);
293 : }
294 0 : else if (k >= 0xfa40)
295 : {
296 : /*
297 : * mapping IBM kanji to X0208 and X0212
298 : *
299 : */
300 0 : for (i = 0;; i++)
301 : {
302 0 : k2 = ibmkanji[i].sjis;
303 0 : if (k2 == 0xffff)
304 0 : break;
305 0 : if (k2 == k)
306 : {
307 0 : k = ibmkanji[i].euc;
308 0 : if (k >= 0x8f0000)
309 : {
310 0 : *p++ = SS3;
311 0 : *p++ = 0x80 | ((k & 0xff00) >> 8);
312 0 : *p++ = 0x80 | (k & 0xff);
313 : }
314 : else
315 : {
316 0 : *p++ = 0x80 | (k >> 8);
317 0 : *p++ = 0x80 | (k & 0xff);
318 : }
319 : }
320 : }
321 : }
322 : }
323 0 : sjis += l;
324 0 : len -= l;
325 : }
326 4 : *p = '\0';
327 :
328 4 : return sjis - start;
329 : }
|
