/src/icu/source/common/ucnv_ct.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | // © 2016 and later: Unicode, Inc. and others. |
2 | | // License & terms of use: http://www.unicode.org/copyright.html |
3 | | /* |
4 | | ********************************************************************** |
5 | | * Copyright (C) 2010-2015, International Business Machines |
6 | | * Corporation and others. All Rights Reserved. |
7 | | ********************************************************************** |
8 | | * file name: ucnv_ct.c |
9 | | * encoding: UTF-8 |
10 | | * tab size: 8 (not used) |
11 | | * indentation:4 |
12 | | * |
13 | | * created on: 2010Dec09 |
14 | | * created by: Michael Ow |
15 | | */ |
16 | | |
17 | | #include "unicode/utypes.h" |
18 | | |
19 | | #if !UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION |
20 | | |
21 | | #include "unicode/ucnv.h" |
22 | | #include "unicode/uset.h" |
23 | | #include "unicode/ucnv_err.h" |
24 | | #include "unicode/ucnv_cb.h" |
25 | | #include "unicode/utf16.h" |
26 | | #include "ucnv_imp.h" |
27 | | #include "ucnv_bld.h" |
28 | | #include "ucnv_cnv.h" |
29 | | #include "ucnvmbcs.h" |
30 | | #include "cstring.h" |
31 | | #include "cmemory.h" |
32 | | |
33 | | typedef enum { |
34 | | INVALID = -2, |
35 | | DO_SEARCH = -1, |
36 | | |
37 | | COMPOUND_TEXT_SINGLE_0 = 0, |
38 | | COMPOUND_TEXT_SINGLE_1 = 1, |
39 | | COMPOUND_TEXT_SINGLE_2 = 2, |
40 | | COMPOUND_TEXT_SINGLE_3 = 3, |
41 | | |
42 | | COMPOUND_TEXT_DOUBLE_1 = 4, |
43 | | COMPOUND_TEXT_DOUBLE_2 = 5, |
44 | | COMPOUND_TEXT_DOUBLE_3 = 6, |
45 | | COMPOUND_TEXT_DOUBLE_4 = 7, |
46 | | COMPOUND_TEXT_DOUBLE_5 = 8, |
47 | | COMPOUND_TEXT_DOUBLE_6 = 9, |
48 | | COMPOUND_TEXT_DOUBLE_7 = 10, |
49 | | |
50 | | COMPOUND_TEXT_TRIPLE_DOUBLE = 11, |
51 | | |
52 | | IBM_915 = 12, |
53 | | IBM_916 = 13, |
54 | | IBM_914 = 14, |
55 | | IBM_874 = 15, |
56 | | IBM_912 = 16, |
57 | | IBM_913 = 17, |
58 | | ISO_8859_14 = 18, |
59 | | IBM_923 = 19, |
60 | | NUM_OF_CONVERTERS = 20 |
61 | | } COMPOUND_TEXT_CONVERTERS; |
62 | | |
63 | 0 | #define SEARCH_LENGTH 12 |
64 | | |
65 | | static const uint8_t escSeqCompoundText[NUM_OF_CONVERTERS][5] = { |
66 | | /* Single */ |
67 | | { 0x1B, 0x2D, 0x41, 0, 0 }, |
68 | | { 0x1B, 0x2D, 0x4D, 0, 0 }, |
69 | | { 0x1B, 0x2D, 0x46, 0, 0 }, |
70 | | { 0x1B, 0x2D, 0x47, 0, 0 }, |
71 | | |
72 | | /* Double */ |
73 | | { 0x1B, 0x24, 0x29, 0x41, 0 }, |
74 | | { 0x1B, 0x24, 0x29, 0x42, 0 }, |
75 | | { 0x1B, 0x24, 0x29, 0x43, 0 }, |
76 | | { 0x1B, 0x24, 0x29, 0x44, 0 }, |
77 | | { 0x1B, 0x24, 0x29, 0x47, 0 }, |
78 | | { 0x1B, 0x24, 0x29, 0x48, 0 }, |
79 | | { 0x1B, 0x24, 0x29, 0x49, 0 }, |
80 | | |
81 | | /* Triple/Double */ |
82 | | { 0x1B, 0x25, 0x47, 0, 0 }, |
83 | | |
84 | | /*IBM-915*/ |
85 | | { 0x1B, 0x2D, 0x4C, 0, 0 }, |
86 | | /*IBM-916*/ |
87 | | { 0x1B, 0x2D, 0x48, 0, 0 }, |
88 | | /*IBM-914*/ |
89 | | { 0x1B, 0x2D, 0x44, 0, 0 }, |
90 | | /*IBM-874*/ |
91 | | { 0x1B, 0x2D, 0x54, 0, 0 }, |
92 | | /*IBM-912*/ |
93 | | { 0x1B, 0x2D, 0x42, 0, 0 }, |
94 | | /* IBM-913 */ |
95 | | { 0x1B, 0x2D, 0x43, 0, 0 }, |
96 | | /* ISO-8859_14 */ |
97 | | { 0x1B, 0x2D, 0x5F, 0, 0 }, |
98 | | /* IBM-923 */ |
99 | | { 0x1B, 0x2D, 0x62, 0, 0 }, |
100 | | }; |
101 | | |
102 | 0 | #define ESC_START 0x1B |
103 | | |
104 | | #define isASCIIRange(codepoint) \ |
105 | 0 | ((codepoint == 0x0000) || (codepoint == 0x0009) || (codepoint == 0x000A) || \ |
106 | 0 | (codepoint >= 0x0020 && codepoint <= 0x007f) || (codepoint >= 0x00A0 && codepoint <= 0x00FF)) |
107 | | |
108 | | #define isIBM915(codepoint) \ |
109 | 0 | ((codepoint >= 0x0401 && codepoint <= 0x045F) || (codepoint == 0x2116)) |
110 | | |
111 | | #define isIBM916(codepoint) \ |
112 | 0 | ((codepoint >= 0x05D0 && codepoint <= 0x05EA) || (codepoint == 0x2017) || (codepoint == 0x203E)) |
113 | | |
114 | | #define isCompoundS3(codepoint) \ |
115 | 0 | ((codepoint == 0x060C) || (codepoint == 0x061B) || (codepoint == 0x061F) || (codepoint >= 0x0621 && codepoint <= 0x063A) || \ |
116 | 0 | (codepoint >= 0x0640 && codepoint <= 0x0652) || (codepoint >= 0x0660 && codepoint <= 0x066D) || (codepoint == 0x200B) || \ |
117 | 0 | (codepoint >= 0x0FE70 && codepoint <= 0x0FE72) || (codepoint == 0x0FE74) || (codepoint >= 0x0FE76 && codepoint <= 0x0FEBE)) |
118 | | |
119 | | #define isCompoundS2(codepoint) \ |
120 | 0 | ((codepoint == 0x02BC) || (codepoint == 0x02BD) || (codepoint >= 0x0384 && codepoint <= 0x03CE) || (codepoint == 0x2015)) |
121 | | |
122 | | #define isIBM914(codepoint) \ |
123 | 0 | ((codepoint == 0x0100) || (codepoint == 0x0101) || (codepoint == 0x0112) || (codepoint == 0x0113) || (codepoint == 0x0116) || (codepoint == 0x0117) || \ |
124 | 0 | (codepoint == 0x0122) || (codepoint == 0x0123) || (codepoint >= 0x0128 && codepoint <= 0x012B) || (codepoint == 0x012E) || (codepoint == 0x012F) || \ |
125 | 0 | (codepoint >= 0x0136 && codepoint <= 0x0138) || (codepoint == 0x013B) || (codepoint == 0x013C) || (codepoint == 0x0145) || (codepoint == 0x0146) || \ |
126 | 0 | (codepoint >= 0x014A && codepoint <= 0x014D) || (codepoint == 0x0156) || (codepoint == 0x0157) || (codepoint >= 0x0166 && codepoint <= 0x016B) || \ |
127 | 0 | (codepoint == 0x0172) || (codepoint == 0x0173)) |
128 | | |
129 | | #define isIBM874(codepoint) \ |
130 | 0 | ((codepoint >= 0x0E01 && codepoint <= 0x0E3A) || (codepoint >= 0x0E3F && codepoint <= 0x0E5B)) |
131 | | |
132 | | #define isIBM912(codepoint) \ |
133 | 0 | ((codepoint >= 0x0102 && codepoint <= 0x0107) || (codepoint >= 0x010C && codepoint <= 0x0111) || (codepoint >= 0x0118 && codepoint <= 0x011B) || \ |
134 | 0 | (codepoint == 0x0139) || (codepoint == 0x013A) || (codepoint == 0x013D) || (codepoint == 0x013E) || (codepoint >= 0x0141 && codepoint <= 0x0144) || \ |
135 | 0 | (codepoint == 0x0147) || (codepoint == 0x0147) || (codepoint == 0x0150) || (codepoint == 0x0151) || (codepoint == 0x0154) || (codepoint == 0x0155) || \ |
136 | 0 | (codepoint >= 0x0158 && codepoint <= 0x015B) || (codepoint == 0x015E) || (codepoint == 0x015F) || (codepoint >= 0x0160 && codepoint <= 0x0165) || \ |
137 | 0 | (codepoint == 0x016E) || (codepoint == 0x016F) || (codepoint == 0x0170) || (codepoint == 0x0171) || (codepoint >= 0x0179 && codepoint <= 0x017E) || \ |
138 | 0 | (codepoint == 0x02C7) || (codepoint == 0x02D8) || (codepoint == 0x02D9) || (codepoint == 0x02DB) || (codepoint == 0x02DD)) |
139 | | |
140 | | #define isIBM913(codepoint) \ |
141 | 0 | ((codepoint >= 0x0108 && codepoint <= 0x010B) || (codepoint == 0x011C) || \ |
142 | 0 | (codepoint == 0x011D) || (codepoint == 0x0120) || (codepoint == 0x0121) || \ |
143 | 0 | (codepoint >= 0x0124 && codepoint <= 0x0127) || (codepoint == 0x0134) || (codepoint == 0x0135) || \ |
144 | 0 | (codepoint == 0x015C) || (codepoint == 0x015D) || (codepoint == 0x016C) || (codepoint == 0x016D)) |
145 | | |
146 | | #define isCompoundS1(codepoint) \ |
147 | 0 | ((codepoint == 0x011E) || (codepoint == 0x011F) || (codepoint == 0x0130) || \ |
148 | 0 | (codepoint == 0x0131) || (codepoint >= 0x0218 && codepoint <= 0x021B)) |
149 | | |
150 | | #define isISO8859_14(codepoint) \ |
151 | 0 | ((codepoint >= 0x0174 && codepoint <= 0x0177) || (codepoint == 0x1E0A) || \ |
152 | 0 | (codepoint == 0x1E0B) || (codepoint == 0x1E1E) || (codepoint == 0x1E1F) || \ |
153 | 0 | (codepoint == 0x1E40) || (codepoint == 0x1E41) || (codepoint == 0x1E56) || \ |
154 | 0 | (codepoint == 0x1E57) || (codepoint == 0x1E60) || (codepoint == 0x1E61) || \ |
155 | 0 | (codepoint == 0x1E6A) || (codepoint == 0x1E6B) || (codepoint == 0x1EF2) || \ |
156 | 0 | (codepoint == 0x1EF3) || (codepoint >= 0x1E80 && codepoint <= 0x1E85)) |
157 | | |
158 | | #define isIBM923(codepoint) \ |
159 | 0 | ((codepoint == 0x0152) || (codepoint == 0x0153) || (codepoint == 0x0178) || (codepoint == 0x20AC)) |
160 | | |
161 | | |
162 | | typedef struct{ |
163 | | UConverterSharedData *myConverterArray[NUM_OF_CONVERTERS]; |
164 | | COMPOUND_TEXT_CONVERTERS state; |
165 | | } UConverterDataCompoundText; |
166 | | |
167 | | /*********** Compound Text Converter Protos ***********/ |
168 | | U_CDECL_BEGIN |
169 | | static void U_CALLCONV |
170 | | _CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode); |
171 | | |
172 | | static void U_CALLCONV |
173 | | _CompoundTextClose(UConverter *converter); |
174 | | |
175 | | static void U_CALLCONV |
176 | | _CompoundTextReset(UConverter *converter, UConverterResetChoice choice); |
177 | | |
178 | | static const char* U_CALLCONV |
179 | | _CompoundTextgetName(const UConverter* cnv); |
180 | | |
181 | | |
182 | 0 | static int32_t findNextEsc(const char *source, const char *sourceLimit) { |
183 | 0 | int32_t length = static_cast<int32_t>(sourceLimit - source); |
184 | 0 | int32_t i; |
185 | 0 | for (i = 1; i < length; i++) { |
186 | 0 | if (*(source + i) == 0x1B) { |
187 | 0 | return i; |
188 | 0 | } |
189 | 0 | } |
190 | | |
191 | 0 | return length; |
192 | 0 | } |
193 | | |
194 | 0 | static COMPOUND_TEXT_CONVERTERS getState(int codepoint) { |
195 | 0 | COMPOUND_TEXT_CONVERTERS state = DO_SEARCH; |
196 | |
|
197 | 0 | if (isASCIIRange(codepoint)) { |
198 | 0 | state = COMPOUND_TEXT_SINGLE_0; |
199 | 0 | } else if (isIBM912(codepoint)) { |
200 | 0 | state = IBM_912; |
201 | 0 | }else if (isIBM913(codepoint)) { |
202 | 0 | state = IBM_913; |
203 | 0 | } else if (isISO8859_14(codepoint)) { |
204 | 0 | state = ISO_8859_14; |
205 | 0 | } else if (isIBM923(codepoint)) { |
206 | 0 | state = IBM_923; |
207 | 0 | } else if (isIBM874(codepoint)) { |
208 | 0 | state = IBM_874; |
209 | 0 | } else if (isIBM914(codepoint)) { |
210 | 0 | state = IBM_914; |
211 | 0 | } else if (isCompoundS2(codepoint)) { |
212 | 0 | state = COMPOUND_TEXT_SINGLE_2; |
213 | 0 | } else if (isCompoundS3(codepoint)) { |
214 | 0 | state = COMPOUND_TEXT_SINGLE_3; |
215 | 0 | } else if (isIBM916(codepoint)) { |
216 | 0 | state = IBM_916; |
217 | 0 | } else if (isIBM915(codepoint)) { |
218 | 0 | state = IBM_915; |
219 | 0 | } else if (isCompoundS1(codepoint)) { |
220 | 0 | state = COMPOUND_TEXT_SINGLE_1; |
221 | 0 | } |
222 | |
|
223 | 0 | return state; |
224 | 0 | } |
225 | | |
226 | 0 | static COMPOUND_TEXT_CONVERTERS findStateFromEscSeq(const char* source, const char* sourceLimit, const uint8_t* toUBytesBuffer, int32_t toUBytesBufferLength, UErrorCode *err) { |
227 | 0 | COMPOUND_TEXT_CONVERTERS state = INVALID; |
228 | 0 | UBool matchFound = FALSE; |
229 | 0 | int32_t i, n, offset = toUBytesBufferLength; |
230 | |
|
231 | 0 | for (i = 0; i < NUM_OF_CONVERTERS; i++) { |
232 | 0 | matchFound = TRUE; |
233 | 0 | for (n = 0; escSeqCompoundText[i][n] != 0; n++) { |
234 | 0 | if (n < toUBytesBufferLength) { |
235 | 0 | if (toUBytesBuffer[n] != escSeqCompoundText[i][n]) { |
236 | 0 | matchFound = FALSE; |
237 | 0 | break; |
238 | 0 | } |
239 | 0 | } else if ((source + (n - offset)) >= sourceLimit) { |
240 | 0 | *err = U_TRUNCATED_CHAR_FOUND; |
241 | 0 | matchFound = FALSE; |
242 | 0 | break; |
243 | 0 | } else if (*(source + (n - offset)) != escSeqCompoundText[i][n]) { |
244 | 0 | matchFound = FALSE; |
245 | 0 | break; |
246 | 0 | } |
247 | 0 | } |
248 | |
|
249 | 0 | if (matchFound) { |
250 | 0 | break; |
251 | 0 | } |
252 | 0 | } |
253 | |
|
254 | 0 | if (matchFound) { |
255 | 0 | state = (COMPOUND_TEXT_CONVERTERS)i; |
256 | 0 | } |
257 | |
|
258 | 0 | return state; |
259 | 0 | } |
260 | | |
261 | | static void U_CALLCONV |
262 | 0 | _CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){ |
263 | 0 | cnv->extraInfo = uprv_malloc (sizeof (UConverterDataCompoundText)); |
264 | 0 | if (cnv->extraInfo != NULL) { |
265 | 0 | UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo; |
266 | |
|
267 | 0 | UConverterNamePieces stackPieces; |
268 | 0 | UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER; |
269 | |
|
270 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_0] = NULL; |
271 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_1] = ucnv_loadSharedData("icu-internal-compound-s1", &stackPieces, &stackArgs, errorCode); |
272 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_2] = ucnv_loadSharedData("icu-internal-compound-s2", &stackPieces, &stackArgs, errorCode); |
273 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_3] = ucnv_loadSharedData("icu-internal-compound-s3", &stackPieces, &stackArgs, errorCode); |
274 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_1] = ucnv_loadSharedData("icu-internal-compound-d1", &stackPieces, &stackArgs, errorCode); |
275 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_2] = ucnv_loadSharedData("icu-internal-compound-d2", &stackPieces, &stackArgs, errorCode); |
276 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_3] = ucnv_loadSharedData("icu-internal-compound-d3", &stackPieces, &stackArgs, errorCode); |
277 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_4] = ucnv_loadSharedData("icu-internal-compound-d4", &stackPieces, &stackArgs, errorCode); |
278 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_5] = ucnv_loadSharedData("icu-internal-compound-d5", &stackPieces, &stackArgs, errorCode); |
279 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_6] = ucnv_loadSharedData("icu-internal-compound-d6", &stackPieces, &stackArgs, errorCode); |
280 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_7] = ucnv_loadSharedData("icu-internal-compound-d7", &stackPieces, &stackArgs, errorCode); |
281 | 0 | myConverterData->myConverterArray[COMPOUND_TEXT_TRIPLE_DOUBLE] = ucnv_loadSharedData("icu-internal-compound-t", &stackPieces, &stackArgs, errorCode); |
282 | |
|
283 | 0 | myConverterData->myConverterArray[IBM_915] = ucnv_loadSharedData("ibm-915_P100-1995", &stackPieces, &stackArgs, errorCode); |
284 | 0 | myConverterData->myConverterArray[IBM_916] = ucnv_loadSharedData("ibm-916_P100-1995", &stackPieces, &stackArgs, errorCode); |
285 | 0 | myConverterData->myConverterArray[IBM_914] = ucnv_loadSharedData("ibm-914_P100-1995", &stackPieces, &stackArgs, errorCode); |
286 | 0 | myConverterData->myConverterArray[IBM_874] = ucnv_loadSharedData("ibm-874_P100-1995", &stackPieces, &stackArgs, errorCode); |
287 | 0 | myConverterData->myConverterArray[IBM_912] = ucnv_loadSharedData("ibm-912_P100-1995", &stackPieces, &stackArgs, errorCode); |
288 | 0 | myConverterData->myConverterArray[IBM_913] = ucnv_loadSharedData("ibm-913_P100-2000", &stackPieces, &stackArgs, errorCode); |
289 | 0 | myConverterData->myConverterArray[ISO_8859_14] = ucnv_loadSharedData("iso-8859_14-1998", &stackPieces, &stackArgs, errorCode); |
290 | 0 | myConverterData->myConverterArray[IBM_923] = ucnv_loadSharedData("ibm-923_P100-1998", &stackPieces, &stackArgs, errorCode); |
291 | |
|
292 | 0 | if (U_FAILURE(*errorCode) || pArgs->onlyTestIsLoadable) { |
293 | 0 | _CompoundTextClose(cnv); |
294 | 0 | return; |
295 | 0 | } |
296 | | |
297 | 0 | myConverterData->state = (COMPOUND_TEXT_CONVERTERS)0; |
298 | 0 | } else { |
299 | 0 | *errorCode = U_MEMORY_ALLOCATION_ERROR; |
300 | 0 | } |
301 | 0 | } |
302 | | |
303 | | |
304 | | static void U_CALLCONV |
305 | 0 | _CompoundTextClose(UConverter *converter) { |
306 | 0 | UConverterDataCompoundText* myConverterData = (UConverterDataCompoundText*)(converter->extraInfo); |
307 | 0 | int32_t i; |
308 | |
|
309 | 0 | if (converter->extraInfo != NULL) { |
310 | | /*close the array of converter pointers and free the memory*/ |
311 | 0 | for (i = 0; i < NUM_OF_CONVERTERS; i++) { |
312 | 0 | if (myConverterData->myConverterArray[i] != NULL) { |
313 | 0 | ucnv_unloadSharedDataIfReady(myConverterData->myConverterArray[i]); |
314 | 0 | } |
315 | 0 | } |
316 | |
|
317 | 0 | uprv_free(converter->extraInfo); |
318 | 0 | converter->extraInfo = NULL; |
319 | 0 | } |
320 | 0 | } |
321 | | |
322 | | static void U_CALLCONV |
323 | 0 | _CompoundTextReset(UConverter *converter, UConverterResetChoice choice) { |
324 | 0 | (void)converter; |
325 | 0 | (void)choice; |
326 | 0 | } |
327 | | |
328 | | static const char* U_CALLCONV |
329 | 0 | _CompoundTextgetName(const UConverter* cnv){ |
330 | 0 | (void)cnv; |
331 | 0 | return "x11-compound-text"; |
332 | 0 | } |
333 | | |
334 | | static void U_CALLCONV |
335 | 0 | UConverter_fromUnicode_CompoundText_OFFSETS(UConverterFromUnicodeArgs* args, UErrorCode* err){ |
336 | 0 | UConverter *cnv = args->converter; |
337 | 0 | uint8_t *target = (uint8_t *) args->target; |
338 | 0 | const uint8_t *targetLimit = (const uint8_t *) args->targetLimit; |
339 | 0 | const UChar* source = args->source; |
340 | 0 | const UChar* sourceLimit = args->sourceLimit; |
341 | | /* int32_t* offsets = args->offsets; */ |
342 | 0 | UChar32 sourceChar; |
343 | 0 | UBool useFallback = cnv->useFallback; |
344 | 0 | uint8_t tmpTargetBuffer[7]; |
345 | 0 | int32_t tmpTargetBufferLength = 0; |
346 | 0 | COMPOUND_TEXT_CONVERTERS currentState, tmpState; |
347 | 0 | uint32_t pValue; |
348 | 0 | int32_t pValueLength = 0; |
349 | 0 | int32_t i, n, j; |
350 | |
|
351 | 0 | UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo; |
352 | |
|
353 | 0 | currentState = myConverterData->state; |
354 | | |
355 | | /* check if the last codepoint of previous buffer was a lead surrogate*/ |
356 | 0 | if((sourceChar = cnv->fromUChar32)!=0 && target< targetLimit) { |
357 | 0 | goto getTrail; |
358 | 0 | } |
359 | | |
360 | 0 | while( source < sourceLimit){ |
361 | 0 | if(target < targetLimit){ |
362 | |
|
363 | 0 | sourceChar = *(source++); |
364 | | /*check if the char is a First surrogate*/ |
365 | 0 | if(U16_IS_SURROGATE(sourceChar)) { |
366 | 0 | if(U16_IS_SURROGATE_LEAD(sourceChar)) { |
367 | 0 | getTrail: |
368 | | /*look ahead to find the trail surrogate*/ |
369 | 0 | if(source < sourceLimit) { |
370 | | /* test the following code unit */ |
371 | 0 | UChar trail=(UChar) *source; |
372 | 0 | if(U16_IS_TRAIL(trail)) { |
373 | 0 | source++; |
374 | 0 | sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail); |
375 | 0 | cnv->fromUChar32=0x00; |
376 | | /* convert this supplementary code point */ |
377 | | /* exit this condition tree */ |
378 | 0 | } else { |
379 | | /* this is an unmatched lead code unit (1st surrogate) */ |
380 | | /* callback(illegal) */ |
381 | 0 | *err=U_ILLEGAL_CHAR_FOUND; |
382 | 0 | cnv->fromUChar32=sourceChar; |
383 | 0 | break; |
384 | 0 | } |
385 | 0 | } else { |
386 | | /* no more input */ |
387 | 0 | cnv->fromUChar32=sourceChar; |
388 | 0 | break; |
389 | 0 | } |
390 | 0 | } else { |
391 | | /* this is an unmatched trail code unit (2nd surrogate) */ |
392 | | /* callback(illegal) */ |
393 | 0 | *err=U_ILLEGAL_CHAR_FOUND; |
394 | 0 | cnv->fromUChar32=sourceChar; |
395 | 0 | break; |
396 | 0 | } |
397 | 0 | } |
398 | | |
399 | 0 | tmpTargetBufferLength = 0; |
400 | 0 | tmpState = getState(sourceChar); |
401 | |
|
402 | 0 | if (tmpState != DO_SEARCH && currentState != tmpState) { |
403 | | /* Get escape sequence if necessary */ |
404 | 0 | currentState = tmpState; |
405 | 0 | for (i = 0; escSeqCompoundText[currentState][i] != 0; i++) { |
406 | 0 | tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][i]; |
407 | 0 | } |
408 | 0 | } |
409 | |
|
410 | 0 | if (tmpState == DO_SEARCH) { |
411 | | /* Test all available converters */ |
412 | 0 | for (i = 1; i < SEARCH_LENGTH; i++) { |
413 | 0 | pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[i], sourceChar, &pValue, useFallback); |
414 | 0 | if (pValueLength > 0) { |
415 | 0 | tmpState = (COMPOUND_TEXT_CONVERTERS)i; |
416 | 0 | if (currentState != tmpState) { |
417 | 0 | currentState = tmpState; |
418 | 0 | for (j = 0; escSeqCompoundText[currentState][j] != 0; j++) { |
419 | 0 | tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][j]; |
420 | 0 | } |
421 | 0 | } |
422 | 0 | for (n = (pValueLength - 1); n >= 0; n--) { |
423 | 0 | tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8)); |
424 | 0 | } |
425 | 0 | break; |
426 | 0 | } |
427 | 0 | } |
428 | 0 | } else if (tmpState == COMPOUND_TEXT_SINGLE_0) { |
429 | 0 | tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)sourceChar; |
430 | 0 | } else { |
431 | 0 | pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[currentState], sourceChar, &pValue, useFallback); |
432 | 0 | if (pValueLength > 0) { |
433 | 0 | for (n = (pValueLength - 1); n >= 0; n--) { |
434 | 0 | tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8)); |
435 | 0 | } |
436 | 0 | } |
437 | 0 | } |
438 | |
|
439 | 0 | for (i = 0; i < tmpTargetBufferLength; i++) { |
440 | 0 | if (target < targetLimit) { |
441 | 0 | *target++ = tmpTargetBuffer[i]; |
442 | 0 | } else { |
443 | 0 | *err = U_BUFFER_OVERFLOW_ERROR; |
444 | 0 | break; |
445 | 0 | } |
446 | 0 | } |
447 | |
|
448 | 0 | if (*err == U_BUFFER_OVERFLOW_ERROR) { |
449 | 0 | for (; i < tmpTargetBufferLength; i++) { |
450 | 0 | args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = tmpTargetBuffer[i]; |
451 | 0 | } |
452 | 0 | } |
453 | 0 | } else { |
454 | 0 | *err = U_BUFFER_OVERFLOW_ERROR; |
455 | 0 | break; |
456 | 0 | } |
457 | 0 | } |
458 | | |
459 | | /*save the state and return */ |
460 | 0 | myConverterData->state = currentState; |
461 | 0 | args->source = source; |
462 | 0 | args->target = (char*)target; |
463 | 0 | } |
464 | | |
465 | | |
466 | | static void U_CALLCONV |
467 | | UConverter_toUnicode_CompoundText_OFFSETS(UConverterToUnicodeArgs *args, |
468 | 0 | UErrorCode* err){ |
469 | 0 | const char *mySource = (char *) args->source; |
470 | 0 | UChar *myTarget = args->target; |
471 | 0 | const char *mySourceLimit = args->sourceLimit; |
472 | 0 | const char *tmpSourceLimit = mySourceLimit; |
473 | 0 | uint32_t mySourceChar = 0x0000; |
474 | 0 | COMPOUND_TEXT_CONVERTERS currentState, tmpState; |
475 | 0 | int32_t sourceOffset = 0; |
476 | 0 | UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) args->converter->extraInfo; |
477 | 0 | UConverterSharedData* savedSharedData = NULL; |
478 | |
|
479 | 0 | UConverterToUnicodeArgs subArgs; |
480 | 0 | int32_t minArgsSize; |
481 | | |
482 | | /* set up the subconverter arguments */ |
483 | 0 | if(args->size<sizeof(UConverterToUnicodeArgs)) { |
484 | 0 | minArgsSize = args->size; |
485 | 0 | } else { |
486 | 0 | minArgsSize = (int32_t)sizeof(UConverterToUnicodeArgs); |
487 | 0 | } |
488 | |
|
489 | 0 | uprv_memcpy(&subArgs, args, minArgsSize); |
490 | 0 | subArgs.size = (uint16_t)minArgsSize; |
491 | |
|
492 | 0 | currentState = tmpState = myConverterData->state; |
493 | |
|
494 | 0 | while(mySource < mySourceLimit){ |
495 | 0 | if(myTarget < args->targetLimit){ |
496 | 0 | if (args->converter->toULength > 0) { |
497 | 0 | mySourceChar = args->converter->toUBytes[0]; |
498 | 0 | } else { |
499 | 0 | mySourceChar = (uint8_t)*mySource; |
500 | 0 | } |
501 | |
|
502 | 0 | if (mySourceChar == ESC_START) { |
503 | 0 | tmpState = findStateFromEscSeq(mySource, mySourceLimit, args->converter->toUBytes, args->converter->toULength, err); |
504 | |
|
505 | 0 | if (*err == U_TRUNCATED_CHAR_FOUND) { |
506 | 0 | for (; mySource < mySourceLimit;) { |
507 | 0 | args->converter->toUBytes[args->converter->toULength++] = *mySource++; |
508 | 0 | } |
509 | 0 | *err = U_ZERO_ERROR; |
510 | 0 | break; |
511 | 0 | } else if (tmpState == INVALID) { |
512 | 0 | if (args->converter->toULength == 0) { |
513 | 0 | mySource++; /* skip over the 0x1b byte */ |
514 | 0 | } |
515 | 0 | *err = U_ILLEGAL_CHAR_FOUND; |
516 | 0 | break; |
517 | 0 | } |
518 | | |
519 | 0 | if (tmpState != currentState) { |
520 | 0 | currentState = tmpState; |
521 | 0 | } |
522 | |
|
523 | 0 | sourceOffset = static_cast<int32_t>(uprv_strlen((char*)escSeqCompoundText[currentState]) - args->converter->toULength); |
524 | |
|
525 | 0 | mySource += sourceOffset; |
526 | |
|
527 | 0 | args->converter->toULength = 0; |
528 | 0 | } |
529 | | |
530 | 0 | if (currentState == COMPOUND_TEXT_SINGLE_0) { |
531 | 0 | while (mySource < mySourceLimit) { |
532 | 0 | if (*mySource == ESC_START) { |
533 | 0 | break; |
534 | 0 | } |
535 | 0 | if (myTarget < args->targetLimit) { |
536 | 0 | *myTarget++ = 0x00ff&(*mySource++); |
537 | 0 | } else { |
538 | 0 | *err = U_BUFFER_OVERFLOW_ERROR; |
539 | 0 | break; |
540 | 0 | } |
541 | 0 | } |
542 | 0 | } else if (mySource < mySourceLimit){ |
543 | 0 | sourceOffset = findNextEsc(mySource, mySourceLimit); |
544 | |
|
545 | 0 | tmpSourceLimit = mySource + sourceOffset; |
546 | |
|
547 | 0 | subArgs.source = mySource; |
548 | 0 | subArgs.sourceLimit = tmpSourceLimit; |
549 | 0 | subArgs.target = myTarget; |
550 | 0 | savedSharedData = subArgs.converter->sharedData; |
551 | 0 | subArgs.converter->sharedData = myConverterData->myConverterArray[currentState]; |
552 | |
|
553 | 0 | ucnv_MBCSToUnicodeWithOffsets(&subArgs, err); |
554 | |
|
555 | 0 | subArgs.converter->sharedData = savedSharedData; |
556 | |
|
557 | 0 | mySource = subArgs.source; |
558 | 0 | myTarget = subArgs.target; |
559 | |
|
560 | 0 | if (U_FAILURE(*err)) { |
561 | 0 | if(*err == U_BUFFER_OVERFLOW_ERROR) { |
562 | 0 | if(subArgs.converter->UCharErrorBufferLength > 0) { |
563 | 0 | uprv_memcpy(args->converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer, |
564 | 0 | subArgs.converter->UCharErrorBufferLength); |
565 | 0 | } |
566 | 0 | args->converter->UCharErrorBufferLength=subArgs.converter->UCharErrorBufferLength; |
567 | 0 | subArgs.converter->UCharErrorBufferLength = 0; |
568 | 0 | } |
569 | 0 | break; |
570 | 0 | } |
571 | 0 | } |
572 | 0 | } else { |
573 | 0 | *err = U_BUFFER_OVERFLOW_ERROR; |
574 | 0 | break; |
575 | 0 | } |
576 | 0 | } |
577 | 0 | myConverterData->state = currentState; |
578 | 0 | args->target = myTarget; |
579 | 0 | args->source = mySource; |
580 | 0 | } |
581 | | |
582 | | static void U_CALLCONV |
583 | | _CompoundText_GetUnicodeSet(const UConverter *cnv, |
584 | | const USetAdder *sa, |
585 | | UConverterUnicodeSet which, |
586 | 0 | UErrorCode *pErrorCode) { |
587 | 0 | UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *)cnv->extraInfo; |
588 | 0 | int32_t i; |
589 | |
|
590 | 0 | for (i = 1; i < NUM_OF_CONVERTERS; i++) { |
591 | 0 | ucnv_MBCSGetUnicodeSetForUnicode(myConverterData->myConverterArray[i], sa, which, pErrorCode); |
592 | 0 | } |
593 | 0 | sa->add(sa->set, 0x0000); |
594 | 0 | sa->add(sa->set, 0x0009); |
595 | 0 | sa->add(sa->set, 0x000A); |
596 | 0 | sa->addRange(sa->set, 0x0020, 0x007F); |
597 | 0 | sa->addRange(sa->set, 0x00A0, 0x00FF); |
598 | 0 | } |
599 | | U_CDECL_END |
600 | | |
601 | | static const UConverterImpl _CompoundTextImpl = { |
602 | | |
603 | | UCNV_COMPOUND_TEXT, |
604 | | |
605 | | NULL, |
606 | | NULL, |
607 | | |
608 | | _CompoundTextOpen, |
609 | | _CompoundTextClose, |
610 | | _CompoundTextReset, |
611 | | |
612 | | UConverter_toUnicode_CompoundText_OFFSETS, |
613 | | UConverter_toUnicode_CompoundText_OFFSETS, |
614 | | UConverter_fromUnicode_CompoundText_OFFSETS, |
615 | | UConverter_fromUnicode_CompoundText_OFFSETS, |
616 | | NULL, |
617 | | |
618 | | NULL, |
619 | | _CompoundTextgetName, |
620 | | NULL, |
621 | | NULL, |
622 | | _CompoundText_GetUnicodeSet, |
623 | | NULL, |
624 | | NULL |
625 | | }; |
626 | | |
627 | | static const UConverterStaticData _CompoundTextStaticData = { |
628 | | sizeof(UConverterStaticData), |
629 | | "COMPOUND_TEXT", |
630 | | 0, |
631 | | UCNV_IBM, |
632 | | UCNV_COMPOUND_TEXT, |
633 | | 1, |
634 | | 6, |
635 | | { 0xef, 0, 0, 0 }, |
636 | | 1, |
637 | | FALSE, |
638 | | FALSE, |
639 | | 0, |
640 | | 0, |
641 | | { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */ |
642 | | }; |
643 | | const UConverterSharedData _CompoundTextData = |
644 | | UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_CompoundTextStaticData, &_CompoundTextImpl); |
645 | | |
646 | | #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */ |