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