Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * EUC_TW and BIG5
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_tw_and_big5/euc_tw_and_big5.c
10 : : *
11 : : *-------------------------------------------------------------------------
12 : : */
13 : :
14 : : #include "postgres.h"
15 : : #include "fmgr.h"
16 : : #include "mb/pg_wchar.h"
17 : :
18 : 4 : PG_MODULE_MAGIC_EXT(
19 : : .name = "euc_tw_and_big5",
20 : : .version = PG_VERSION
21 : : );
22 : :
23 : 4 : PG_FUNCTION_INFO_V1(euc_tw_to_big5);
24 : 4 : PG_FUNCTION_INFO_V1(big5_to_euc_tw);
25 : :
26 : : /* ----------
27 : : * conv_proc(
28 : : * INTEGER, -- source encoding id
29 : : * INTEGER, -- destination encoding id
30 : : * CSTRING, -- source string (null terminated C string)
31 : : * CSTRING, -- destination string (null terminated C string)
32 : : * INTEGER, -- source string length
33 : : * BOOL -- if true, don't throw an error if conversion fails
34 : : * ) returns INTEGER;
35 : : *
36 : : * Returns the number of bytes successfully converted.
37 : : * ----------
38 : : */
39 : :
40 : : static int euc_tw2big5(const unsigned char *euc, unsigned char *p, int len, bool noError);
41 : : static int big52euc_tw(const unsigned char *big5, unsigned char *p, int len, bool noError);
42 : :
43 : : Datum
44 : 4 : euc_tw_to_big5(PG_FUNCTION_ARGS)
45 : : {
46 : 4 : unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
47 : 4 : unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
48 : 4 : int len = PG_GETARG_INT32(4);
49 : 4 : bool noError = PG_GETARG_BOOL(5);
50 : : int converted;
51 : :
52 : 4 : CHECK_ENCODING_CONVERSION_ARGS(PG_EUC_TW, PG_BIG5);
53 : :
54 : 4 : converted = euc_tw2big5(src, dest, len, noError);
55 : :
56 : 4 : PG_RETURN_INT32(converted);
57 : : }
58 : :
59 : : Datum
60 : 4 : big5_to_euc_tw(PG_FUNCTION_ARGS)
61 : : {
62 : 4 : unsigned char *src = (unsigned char *) PG_GETARG_CSTRING(2);
63 : 4 : unsigned char *dest = (unsigned char *) PG_GETARG_CSTRING(3);
64 : 4 : int len = PG_GETARG_INT32(4);
65 : 4 : bool noError = PG_GETARG_BOOL(5);
66 : : int converted;
67 : :
68 : 4 : CHECK_ENCODING_CONVERSION_ARGS(PG_BIG5, PG_EUC_TW);
69 : :
70 : 4 : converted = big52euc_tw(src, dest, len, noError);
71 : :
72 : 4 : PG_RETURN_INT32(converted);
73 : : }
74 : :
75 : : static int
76 : 4 : euc_tw2big5(const unsigned char *euc, unsigned char *p, int len, bool noError)
77 : : {
78 : 4 : const unsigned char *start = euc;
79 : : unsigned char c1;
80 : : unsigned short big5buf,
81 : : cnsBuf;
82 : : unsigned char lc;
83 : : int l;
84 : :
85 [ + + ]: 16 : while (len > 0)
86 : : {
87 : 12 : c1 = *euc;
88 [ - + ]: 12 : if (IS_HIGHBIT_SET(c1))
89 : : {
90 : : /* Verify and decode the next EUC_TW input character */
91 : 0 : l = pg_encoding_verifymbchar(PG_EUC_TW, (const char *) euc, len);
92 [ # # ]: 0 : if (l < 0)
93 : : {
94 [ # # ]: 0 : if (noError)
95 : 0 : break;
96 : 0 : report_invalid_encoding(PG_EUC_TW,
97 : : (const char *) euc, len);
98 : : }
99 [ # # ]: 0 : if (c1 == SS2)
100 : : {
101 : 0 : c1 = euc[1]; /* plane No. */
102 [ # # ]: 0 : if (c1 == 0xa1)
103 : 0 : lc = LC_CNS11643_1;
104 [ # # ]: 0 : else if (c1 == 0xa2)
105 : 0 : lc = LC_CNS11643_2;
106 : : else
107 : 0 : lc = c1 - 0xa3 + LC_CNS11643_3;
108 : 0 : cnsBuf = (euc[2] << 8) | euc[3];
109 : : }
110 : : else
111 : : { /* CNS11643-1 */
112 : 0 : lc = LC_CNS11643_1;
113 : 0 : cnsBuf = (c1 << 8) | euc[1];
114 : : }
115 : :
116 : : /* Write it out in Big5 */
117 : 0 : big5buf = CNStoBIG5(cnsBuf, lc);
118 [ # # ]: 0 : if (big5buf == 0)
119 : : {
120 [ # # ]: 0 : if (noError)
121 : 0 : break;
122 : 0 : report_untranslatable_char(PG_EUC_TW, PG_BIG5,
123 : : (const char *) euc, len);
124 : : }
125 : 0 : *p++ = (big5buf >> 8) & 0x00ff;
126 : 0 : *p++ = big5buf & 0x00ff;
127 : :
128 : 0 : euc += l;
129 : 0 : len -= l;
130 : : }
131 : : else
132 : : { /* should be ASCII */
133 [ - + ]: 12 : if (c1 == 0)
134 : : {
135 [ # # ]: 0 : if (noError)
136 : 0 : break;
137 : 0 : report_invalid_encoding(PG_EUC_TW,
138 : : (const char *) euc, len);
139 : : }
140 : 12 : *p++ = c1;
141 : 12 : euc++;
142 : 12 : len--;
143 : : }
144 : : }
145 : 4 : *p = '\0';
146 : :
147 : 4 : return euc - start;
148 : : }
149 : :
150 : : /*
151 : : * Big5 ---> EUC_TW
152 : : */
153 : : static int
154 : 4 : big52euc_tw(const unsigned char *big5, unsigned char *p, int len, bool noError)
155 : : {
156 : 4 : const unsigned char *start = big5;
157 : : unsigned short c1;
158 : : unsigned short big5buf,
159 : : cnsBuf;
160 : : unsigned char lc;
161 : : int l;
162 : :
163 [ + + ]: 16 : while (len > 0)
164 : : {
165 : : /* Verify and decode the next Big5 input character */
166 : 12 : c1 = *big5;
167 [ - + ]: 12 : if (IS_HIGHBIT_SET(c1))
168 : : {
169 : 0 : l = pg_encoding_verifymbchar(PG_BIG5, (const char *) big5, len);
170 [ # # ]: 0 : if (l < 0)
171 : : {
172 [ # # ]: 0 : if (noError)
173 : 0 : break;
174 : 0 : report_invalid_encoding(PG_BIG5,
175 : : (const char *) big5, len);
176 : : }
177 : 0 : big5buf = (c1 << 8) | big5[1];
178 : 0 : cnsBuf = BIG5toCNS(big5buf, &lc);
179 : :
180 [ # # ]: 0 : if (lc == LC_CNS11643_1)
181 : : {
182 : 0 : *p++ = (cnsBuf >> 8) & 0x00ff;
183 : 0 : *p++ = cnsBuf & 0x00ff;
184 : : }
185 [ # # ]: 0 : else if (lc == LC_CNS11643_2)
186 : : {
187 : 0 : *p++ = SS2;
188 : 0 : *p++ = 0xa2;
189 : 0 : *p++ = (cnsBuf >> 8) & 0x00ff;
190 : 0 : *p++ = cnsBuf & 0x00ff;
191 : : }
192 [ # # # # ]: 0 : else if (lc >= LC_CNS11643_3 && lc <= LC_CNS11643_7)
193 : : {
194 : 0 : *p++ = SS2;
195 : 0 : *p++ = lc - LC_CNS11643_3 + 0xa3;
196 : 0 : *p++ = (cnsBuf >> 8) & 0x00ff;
197 : 0 : *p++ = cnsBuf & 0x00ff;
198 : : }
199 : : else
200 : : {
201 [ # # ]: 0 : if (noError)
202 : 0 : break;
203 : 0 : report_untranslatable_char(PG_BIG5, PG_EUC_TW,
204 : : (const char *) big5, len);
205 : : }
206 : :
207 : 0 : big5 += l;
208 : 0 : len -= l;
209 : : }
210 : : else
211 : : {
212 : : /* ASCII */
213 [ - + ]: 12 : if (c1 == 0)
214 : : {
215 [ # # ]: 0 : if (noError)
216 : 0 : break;
217 : 0 : report_invalid_encoding(PG_BIG5,
218 : : (const char *) big5, len);
219 : : }
220 : 12 : *p++ = c1;
221 : 12 : big5++;
222 : 12 : len--;
223 : 12 : continue;
224 : : }
225 : : }
226 : 4 : *p = '\0';
227 : :
228 : 4 : return big5 - start;
229 : : }
|
