Home | History | Annotate | Download | only in common
      1 /*
      2 **********************************************************************
      3 *   Copyright (C) 2010-2012, International Business Machines
      4 *   Corporation and others.  All Rights Reserved.
      5 **********************************************************************
      6 *   file name:  ucnv_ct.c
      7 *   encoding:   US-ASCII
      8 *   tab size:   8 (not used)
      9 *   indentation:4
     10 *
     11 *   created on: 2010Dec09
     12 *   created by: Michael Ow
     13 */
     14 
     15 #include "unicode/utypes.h"
     16 
     17 #if !UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION
     18 
     19 #include "unicode/ucnv.h"
     20 #include "unicode/uset.h"
     21 #include "unicode/ucnv_err.h"
     22 #include "unicode/ucnv_cb.h"
     23 #include "unicode/utf16.h"
     24 #include "ucnv_imp.h"
     25 #include "ucnv_bld.h"
     26 #include "ucnv_cnv.h"
     27 #include "ucnvmbcs.h"
     28 #include "cstring.h"
     29 #include "cmemory.h"
     30 
     31 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
     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 #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 #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 
    162 typedef struct{
    163     UConverterSharedData *myConverterArray[NUM_OF_CONVERTERS];
    164     COMPOUND_TEXT_CONVERTERS state;
    165 } UConverterDataCompoundText;
    166 
    167 /*********** Compound Text Converter Protos ***********/
    168 static void
    169 _CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode);
    170 
    171 static void
    172  _CompoundTextClose(UConverter *converter);
    173 
    174 static void
    175 _CompoundTextReset(UConverter *converter, UConverterResetChoice choice);
    176 
    177 static const char*
    178 _CompoundTextgetName(const UConverter* cnv);
    179 
    180 
    181 static int32_t findNextEsc(const char *source, const char *sourceLimit) {
    182     int32_t length = sourceLimit - source;
    183     int32_t i;
    184     for (i = 1; i < length; i++) {
    185         if (*(source + i) == 0x1B) {
    186             return i;
    187         }
    188     }
    189 
    190     return length;
    191 }
    192 
    193 static COMPOUND_TEXT_CONVERTERS getState(int codepoint) {
    194     COMPOUND_TEXT_CONVERTERS state = DO_SEARCH;
    195 
    196     if (isASCIIRange(codepoint)) {
    197         state = COMPOUND_TEXT_SINGLE_0;
    198     } else if (isIBM912(codepoint)) {
    199         state = IBM_912;
    200     }else if (isIBM913(codepoint)) {
    201         state = IBM_913;
    202     } else if (isISO8859_14(codepoint)) {
    203         state = ISO_8859_14;
    204     } else if (isIBM923(codepoint)) {
    205         state = IBM_923;
    206     } else if (isIBM874(codepoint)) {
    207         state = IBM_874;
    208     } else if (isIBM914(codepoint)) {
    209         state = IBM_914;
    210     } else if (isCompoundS2(codepoint)) {
    211         state = COMPOUND_TEXT_SINGLE_2;
    212     } else if (isCompoundS3(codepoint)) {
    213         state = COMPOUND_TEXT_SINGLE_3;
    214     } else if (isIBM916(codepoint)) {
    215         state = IBM_916;
    216     } else if (isIBM915(codepoint)) {
    217         state = IBM_915;
    218     } else if (isCompoundS1(codepoint)) {
    219         state = COMPOUND_TEXT_SINGLE_1;
    220     }
    221 
    222     return state;
    223 }
    224 
    225 static COMPOUND_TEXT_CONVERTERS findStateFromEscSeq(const char* source, const char* sourceLimit, const uint8_t* toUBytesBuffer, int32_t toUBytesBufferLength, UErrorCode *err) {
    226     COMPOUND_TEXT_CONVERTERS state = INVALID;
    227     UBool matchFound = FALSE;
    228     int32_t i, n, offset = toUBytesBufferLength;
    229 
    230     for (i = 0; i < NUM_OF_CONVERTERS; i++) {
    231         matchFound = TRUE;
    232         for (n = 0; escSeqCompoundText[i][n] != 0; n++) {
    233             if (n < toUBytesBufferLength) {
    234                 if (toUBytesBuffer[n] != escSeqCompoundText[i][n]) {
    235                     matchFound = FALSE;
    236                     break;
    237                 }
    238             } else if ((source + (n - offset)) >= sourceLimit) {
    239                 *err = U_TRUNCATED_CHAR_FOUND;
    240                 matchFound = FALSE;
    241                 break;
    242             } else if (*(source + (n - offset)) != escSeqCompoundText[i][n]) {
    243                 matchFound = FALSE;
    244                 break;
    245             }
    246         }
    247 
    248         if (matchFound) {
    249             break;
    250         }
    251     }
    252 
    253     if (matchFound) {
    254         state = (COMPOUND_TEXT_CONVERTERS)i;
    255     }
    256 
    257     return state;
    258 }
    259 
    260 static void
    261 _CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){
    262     cnv->extraInfo = uprv_malloc (sizeof (UConverterDataCompoundText));
    263     if (cnv->extraInfo != NULL) {
    264         UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;
    265 
    266         UConverterNamePieces stackPieces;
    267         UConverterLoadArgs stackArgs={ (int32_t)sizeof(UConverterLoadArgs) };
    268 
    269         myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_0] = NULL;
    270         myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_1] = ucnv_loadSharedData("icu-internal-compound-s1", &stackPieces, &stackArgs, errorCode);
    271         myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_2] = ucnv_loadSharedData("icu-internal-compound-s2", &stackPieces, &stackArgs, errorCode);
    272         myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_3] = ucnv_loadSharedData("icu-internal-compound-s3", &stackPieces, &stackArgs, errorCode);
    273         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_1] = ucnv_loadSharedData("icu-internal-compound-d1", &stackPieces, &stackArgs, errorCode);
    274         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_2] = ucnv_loadSharedData("icu-internal-compound-d2", &stackPieces, &stackArgs, errorCode);
    275         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_3] = ucnv_loadSharedData("icu-internal-compound-d3", &stackPieces, &stackArgs, errorCode);
    276         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_4] = ucnv_loadSharedData("icu-internal-compound-d4", &stackPieces, &stackArgs, errorCode);
    277         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_5] = ucnv_loadSharedData("icu-internal-compound-d5", &stackPieces, &stackArgs, errorCode);
    278         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_6] = ucnv_loadSharedData("icu-internal-compound-d6", &stackPieces, &stackArgs, errorCode);
    279         myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_7] = ucnv_loadSharedData("icu-internal-compound-d7", &stackPieces, &stackArgs, errorCode);
    280         myConverterData->myConverterArray[COMPOUND_TEXT_TRIPLE_DOUBLE] = ucnv_loadSharedData("icu-internal-compound-t", &stackPieces, &stackArgs, errorCode);
    281 
    282         myConverterData->myConverterArray[IBM_915] = ucnv_loadSharedData("ibm-915_P100-1995", &stackPieces, &stackArgs, errorCode);
    283         myConverterData->myConverterArray[IBM_916] = ucnv_loadSharedData("ibm-916_P100-1995", &stackPieces, &stackArgs, errorCode);
    284         myConverterData->myConverterArray[IBM_914] = ucnv_loadSharedData("ibm-914_P100-1995", &stackPieces, &stackArgs, errorCode);
    285         myConverterData->myConverterArray[IBM_874] = ucnv_loadSharedData("ibm-874_P100-1995", &stackPieces, &stackArgs, errorCode);
    286         myConverterData->myConverterArray[IBM_912] = ucnv_loadSharedData("ibm-912_P100-1995", &stackPieces, &stackArgs, errorCode);
    287         myConverterData->myConverterArray[IBM_913] = ucnv_loadSharedData("ibm-913_P100-2000", &stackPieces, &stackArgs, errorCode);
    288         myConverterData->myConverterArray[ISO_8859_14] = ucnv_loadSharedData("iso-8859_14-1998", &stackPieces, &stackArgs, errorCode);
    289         myConverterData->myConverterArray[IBM_923] = ucnv_loadSharedData("ibm-923_P100-1998", &stackPieces, &stackArgs, errorCode);
    290 
    291         if (U_FAILURE(*errorCode) || pArgs->onlyTestIsLoadable) {
    292             _CompoundTextClose(cnv);
    293             return;
    294         }
    295 
    296         myConverterData->state = (COMPOUND_TEXT_CONVERTERS)0;
    297     } else {
    298         *errorCode = U_MEMORY_ALLOCATION_ERROR;
    299     }
    300 }
    301 
    302 
    303 static void
    304 _CompoundTextClose(UConverter *converter) {
    305     UConverterDataCompoundText* myConverterData = (UConverterDataCompoundText*)(converter->extraInfo);
    306     int32_t i;
    307 
    308     if (converter->extraInfo != NULL) {
    309         /*close the array of converter pointers and free the memory*/
    310         for (i = 0; i < NUM_OF_CONVERTERS; i++) {
    311             if (myConverterData->myConverterArray[i] != NULL) {
    312                 ucnv_unloadSharedDataIfReady(myConverterData->myConverterArray[i]);
    313             }
    314         }
    315 
    316         uprv_free(converter->extraInfo);
    317     }
    318 }
    319 
    320 static void
    321 _CompoundTextReset(UConverter *converter, UConverterResetChoice choice) {
    322 }
    323 
    324 static const char*
    325 _CompoundTextgetName(const UConverter* cnv){
    326     return "x11-compound-text";
    327 }
    328 
    329 static void
    330 UConverter_fromUnicode_CompoundText_OFFSETS(UConverterFromUnicodeArgs* args, UErrorCode* err){
    331     UConverter *cnv = args->converter;
    332     uint8_t *target = (uint8_t *) args->target;
    333     const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;
    334     const UChar* source = args->source;
    335     const UChar* sourceLimit = args->sourceLimit;
    336     /* int32_t* offsets = args->offsets; */
    337     UChar32 sourceChar;
    338     UBool useFallback = cnv->useFallback;
    339     uint8_t tmpTargetBuffer[7];
    340     int32_t tmpTargetBufferLength = 0;
    341     COMPOUND_TEXT_CONVERTERS currentState, tmpState;
    342     uint32_t pValue;
    343     int32_t pValueLength = 0;
    344     int32_t i, n, j;
    345 
    346     UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;
    347 
    348     currentState = myConverterData->state;
    349 
    350     /* check if the last codepoint of previous buffer was a lead surrogate*/
    351     if((sourceChar = cnv->fromUChar32)!=0 && target< targetLimit) {
    352         goto getTrail;
    353     }
    354 
    355     while( source < sourceLimit){
    356         if(target < targetLimit){
    357 
    358             sourceChar  = *(source++);
    359             /*check if the char is a First surrogate*/
    360              if(U16_IS_SURROGATE(sourceChar)) {
    361                 if(U16_IS_SURROGATE_LEAD(sourceChar)) {
    362 getTrail:
    363                     /*look ahead to find the trail surrogate*/
    364                     if(source < sourceLimit) {
    365                         /* test the following code unit */
    366                         UChar trail=(UChar) *source;
    367                         if(U16_IS_TRAIL(trail)) {
    368                             source++;
    369                             sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
    370                             cnv->fromUChar32=0x00;
    371                             /* convert this supplementary code point */
    372                             /* exit this condition tree */
    373                         } else {
    374                             /* this is an unmatched lead code unit (1st surrogate) */
    375                             /* callback(illegal) */
    376                             *err=U_ILLEGAL_CHAR_FOUND;
    377                             cnv->fromUChar32=sourceChar;
    378                             break;
    379                         }
    380                     } else {
    381                         /* no more input */
    382                         cnv->fromUChar32=sourceChar;
    383                         break;
    384                     }
    385                 } else {
    386                     /* this is an unmatched trail code unit (2nd surrogate) */
    387                     /* callback(illegal) */
    388                     *err=U_ILLEGAL_CHAR_FOUND;
    389                     cnv->fromUChar32=sourceChar;
    390                     break;
    391                 }
    392             }
    393 
    394              tmpTargetBufferLength = 0;
    395              tmpState = getState(sourceChar);
    396 
    397              if (tmpState != DO_SEARCH && currentState != tmpState) {
    398                  /* Get escape sequence if necessary */
    399                  currentState = tmpState;
    400                  for (i = 0; escSeqCompoundText[currentState][i] != 0; i++) {
    401                      tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][i];
    402                  }
    403              }
    404 
    405              if (tmpState == DO_SEARCH) {
    406                  /* Test all available converters */
    407                  for (i = 1; i < SEARCH_LENGTH; i++) {
    408                      pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[i], sourceChar, &pValue, useFallback);
    409                      if (pValueLength > 0) {
    410                          tmpState = (COMPOUND_TEXT_CONVERTERS)i;
    411                          if (currentState != tmpState) {
    412                              currentState = tmpState;
    413                              for (j = 0; escSeqCompoundText[currentState][j] != 0; j++) {
    414                                  tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][j];
    415                              }
    416                          }
    417                          for (n = (pValueLength - 1); n >= 0; n--) {
    418                              tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));
    419                          }
    420                          break;
    421                      }
    422                  }
    423              } else if (tmpState == COMPOUND_TEXT_SINGLE_0) {
    424                  tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)sourceChar;
    425              } else {
    426                  pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[currentState], sourceChar, &pValue, useFallback);
    427                  if (pValueLength > 0) {
    428                      for (n = (pValueLength - 1); n >= 0; n--) {
    429                          tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));
    430                      }
    431                  }
    432              }
    433 
    434              for (i = 0; i < tmpTargetBufferLength; i++) {
    435                  if (target < targetLimit) {
    436                      *target++ = tmpTargetBuffer[i];
    437                  } else {
    438                      *err = U_BUFFER_OVERFLOW_ERROR;
    439                      break;
    440                  }
    441              }
    442 
    443              if (*err == U_BUFFER_OVERFLOW_ERROR) {
    444                  for (; i < tmpTargetBufferLength; i++) {
    445                      args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = tmpTargetBuffer[i];
    446                  }
    447              }
    448         } else {
    449             *err = U_BUFFER_OVERFLOW_ERROR;
    450             break;
    451         }
    452     }
    453 
    454     /*save the state and return */
    455     myConverterData->state = currentState;
    456     args->source = source;
    457     args->target = (char*)target;
    458 }
    459 
    460 
    461 static void
    462 UConverter_toUnicode_CompoundText_OFFSETS(UConverterToUnicodeArgs *args,
    463                                                UErrorCode* err){
    464     const char *mySource = (char *) args->source;
    465     UChar *myTarget = args->target;
    466     const char *mySourceLimit = args->sourceLimit;
    467     const char *tmpSourceLimit = mySourceLimit;
    468     uint32_t mySourceChar = 0x0000;
    469     COMPOUND_TEXT_CONVERTERS currentState, tmpState;
    470     int32_t sourceOffset = 0;
    471     UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) args->converter->extraInfo;
    472     UConverterSharedData* savedSharedData = NULL;
    473 
    474     UConverterToUnicodeArgs subArgs;
    475     int32_t minArgsSize;
    476 
    477     /* set up the subconverter arguments */
    478     if(args->size<sizeof(UConverterToUnicodeArgs)) {
    479         minArgsSize = args->size;
    480     } else {
    481         minArgsSize = (int32_t)sizeof(UConverterToUnicodeArgs);
    482     }
    483 
    484     uprv_memcpy(&subArgs, args, minArgsSize);
    485     subArgs.size = (uint16_t)minArgsSize;
    486 
    487     currentState = tmpState =  myConverterData->state;
    488 
    489     while(mySource < mySourceLimit){
    490         if(myTarget < args->targetLimit){
    491             if (args->converter->toULength > 0) {
    492                 mySourceChar = args->converter->toUBytes[0];
    493             } else {
    494                 mySourceChar = (uint8_t)*mySource;
    495             }
    496 
    497             if (mySourceChar == ESC_START) {
    498                 tmpState = findStateFromEscSeq(mySource, mySourceLimit, args->converter->toUBytes, args->converter->toULength, err);
    499 
    500                 if (*err == U_TRUNCATED_CHAR_FOUND) {
    501                     for (; mySource < mySourceLimit;) {
    502                         args->converter->toUBytes[args->converter->toULength++] = *mySource++;
    503                     }
    504                     *err = U_ZERO_ERROR;
    505                     break;
    506                 } else if (tmpState == INVALID) {
    507                     if (args->converter->toULength == 0) {
    508                         mySource++; /* skip over the 0x1b byte */
    509                     }
    510                     *err = U_ILLEGAL_CHAR_FOUND;
    511                     break;
    512                 }
    513 
    514                 if (tmpState != currentState) {
    515                     currentState = tmpState;
    516                 }
    517 
    518                 sourceOffset = uprv_strlen((char*)escSeqCompoundText[currentState]) - args->converter->toULength;
    519 
    520                 mySource += sourceOffset;
    521 
    522                 args->converter->toULength = 0;
    523             }
    524 
    525             if (currentState == COMPOUND_TEXT_SINGLE_0) {
    526                 while (mySource < mySourceLimit) {
    527                     if (*mySource == ESC_START) {
    528                         break;
    529                     }
    530                     if (myTarget < args->targetLimit) {
    531                         *myTarget++ = 0x00ff&(*mySource++);
    532                     } else {
    533                         *err = U_BUFFER_OVERFLOW_ERROR;
    534                         break;
    535                     }
    536                 }
    537             } else if (mySource < mySourceLimit){
    538                 sourceOffset = findNextEsc(mySource, mySourceLimit);
    539 
    540                 tmpSourceLimit = mySource + sourceOffset;
    541 
    542                 subArgs.source = mySource;
    543                 subArgs.sourceLimit = tmpSourceLimit;
    544                 subArgs.target = myTarget;
    545                 savedSharedData = subArgs.converter->sharedData;
    546                 subArgs.converter->sharedData = myConverterData->myConverterArray[currentState];
    547 
    548                 ucnv_MBCSToUnicodeWithOffsets(&subArgs, err);
    549 
    550                 subArgs.converter->sharedData = savedSharedData;
    551 
    552                 mySource = subArgs.source;
    553                 myTarget = subArgs.target;
    554 
    555                 if (U_FAILURE(*err)) {
    556                     if(*err == U_BUFFER_OVERFLOW_ERROR) {
    557                         if(subArgs.converter->UCharErrorBufferLength > 0) {
    558                             uprv_memcpy(args->converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer,
    559                                         subArgs.converter->UCharErrorBufferLength);
    560                         }
    561                         args->converter->UCharErrorBufferLength=subArgs.converter->UCharErrorBufferLength;
    562                         subArgs.converter->UCharErrorBufferLength = 0;
    563                     }
    564                     break;
    565                 }
    566             }
    567         } else {
    568             *err = U_BUFFER_OVERFLOW_ERROR;
    569             break;
    570         }
    571     }
    572     myConverterData->state = currentState;
    573     args->target = myTarget;
    574     args->source = mySource;
    575 }
    576 
    577 static void
    578 _CompoundText_GetUnicodeSet(const UConverter *cnv,
    579                     const USetAdder *sa,
    580                     UConverterUnicodeSet which,
    581                     UErrorCode *pErrorCode) {
    582     UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *)cnv->extraInfo;
    583     int32_t i;
    584 
    585     for (i = 1; i < NUM_OF_CONVERTERS; i++) {
    586         ucnv_MBCSGetUnicodeSetForUnicode(myConverterData->myConverterArray[i], sa, which, pErrorCode);
    587     }
    588     sa->add(sa->set, 0x0000);
    589     sa->add(sa->set, 0x0009);
    590     sa->add(sa->set, 0x000A);
    591     sa->addRange(sa->set, 0x0020, 0x007F);
    592     sa->addRange(sa->set, 0x00A0, 0x00FF);
    593 }
    594 
    595 static const UConverterImpl _CompoundTextImpl = {
    596 
    597     UCNV_COMPOUND_TEXT,
    598 
    599     NULL,
    600     NULL,
    601 
    602     _CompoundTextOpen,
    603     _CompoundTextClose,
    604     _CompoundTextReset,
    605 
    606     UConverter_toUnicode_CompoundText_OFFSETS,
    607     UConverter_toUnicode_CompoundText_OFFSETS,
    608     UConverter_fromUnicode_CompoundText_OFFSETS,
    609     UConverter_fromUnicode_CompoundText_OFFSETS,
    610     NULL,
    611 
    612     NULL,
    613     _CompoundTextgetName,
    614     NULL,
    615     NULL,
    616     _CompoundText_GetUnicodeSet
    617 };
    618 static const UConverterStaticData _CompoundTextStaticData = {
    619     sizeof(UConverterStaticData),
    620     "COMPOUND_TEXT",
    621     0,
    622     UCNV_IBM,
    623     UCNV_COMPOUND_TEXT,
    624     1,
    625     6,
    626     { 0xef, 0, 0, 0 },
    627     1,
    628     FALSE,
    629     FALSE,
    630     0,
    631     0,
    632     { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
    633 };
    634 const UConverterSharedData _CompoundTextData = {
    635     sizeof(UConverterSharedData),
    636     ~((uint32_t) 0),
    637     NULL,
    638     NULL,
    639     &_CompoundTextStaticData,
    640     FALSE,
    641     &_CompoundTextImpl,
    642     0
    643 };
    644 
    645 #endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */
    646