Coverage Report

Created: 2024-04-24 06:23

/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 */