// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

**********************************************************************

*   Copyright (C) 2010-2015, International Business Machines

*   Corporation and others.  All Rights Reserved.

**********************************************************************

*   file name:  ucnv_ct.c

*   encoding:   UTF-8

*   tab size:   8 (not used)

*   indentation:4

*

*   created on: 2010Dec09

*   created by: Michael Ow

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION

#include "unicode/ucnv.h"

#include "unicode/uset.h"

#include "unicode/ucnv_err.h"

#include "unicode/ucnv_cb.h"

#include "unicode/utf16.h"

#include "ucnv_imp.h"

#include "ucnv_bld.h"

#include "ucnv_cnv.h"

#include "ucnvmbcs.h"

#include "cstring.h"

#include "cmemory.h"

typedef enum {

    INVALID = -2,

    DO_SEARCH = -1,

    COMPOUND_TEXT_SINGLE_0 = 0,

    COMPOUND_TEXT_SINGLE_1 = 1,

    COMPOUND_TEXT_SINGLE_2 = 2,

    COMPOUND_TEXT_SINGLE_3 = 3,

    COMPOUND_TEXT_DOUBLE_1 = 4,

    COMPOUND_TEXT_DOUBLE_2 = 5,

    COMPOUND_TEXT_DOUBLE_3 = 6,

    COMPOUND_TEXT_DOUBLE_4 = 7,

    COMPOUND_TEXT_DOUBLE_5 = 8,

    COMPOUND_TEXT_DOUBLE_6 = 9,

    COMPOUND_TEXT_DOUBLE_7 = 10,

    COMPOUND_TEXT_TRIPLE_DOUBLE = 11,

    IBM_915 = 12,

    IBM_916 = 13,

    IBM_914 = 14,

    IBM_874 = 15,

    IBM_912 = 16,

    IBM_913 = 17,

    ISO_8859_14 = 18,

    IBM_923 = 19,

    NUM_OF_CONVERTERS = 20

} COMPOUND_TEXT_CONVERTERS;

#define SEARCH_LENGTH 12

static const uint8_t escSeqCompoundText[NUM_OF_CONVERTERS][5] = {

    /* Single */

    { 0x1B, 0x2D, 0x41, 0, 0 },

    { 0x1B, 0x2D, 0x4D, 0, 0 },

    { 0x1B, 0x2D, 0x46, 0, 0 },

    { 0x1B, 0x2D, 0x47, 0, 0 },

    /* Double */

    { 0x1B, 0x24, 0x29, 0x41, 0 },

    { 0x1B, 0x24, 0x29, 0x42, 0 },

    { 0x1B, 0x24, 0x29, 0x43, 0 },

    { 0x1B, 0x24, 0x29, 0x44, 0 },

    { 0x1B, 0x24, 0x29, 0x47, 0 },

    { 0x1B, 0x24, 0x29, 0x48, 0 },

    { 0x1B, 0x24, 0x29, 0x49, 0 },

    /* Triple/Double */

    { 0x1B, 0x25, 0x47, 0, 0 },

    /*IBM-915*/

    { 0x1B, 0x2D, 0x4C, 0, 0 },

    /*IBM-916*/

    { 0x1B, 0x2D, 0x48, 0, 0 },

    /*IBM-914*/

    { 0x1B, 0x2D, 0x44, 0, 0 },

    /*IBM-874*/

    { 0x1B, 0x2D, 0x54, 0, 0 },

    /*IBM-912*/

    { 0x1B, 0x2D, 0x42, 0, 0 },

    /* IBM-913 */

    { 0x1B, 0x2D, 0x43, 0, 0 },

    /* ISO-8859_14 */

    { 0x1B, 0x2D, 0x5F, 0, 0 },

    /* IBM-923 */

    { 0x1B, 0x2D, 0x62, 0, 0 },

};

#define ESC_START 0x1B

#define isASCIIRange(codepoint) \

        ((codepoint == 0x0000) || (codepoint == 0x0009) || (codepoint == 0x000A) || \

         (codepoint >= 0x0020 && codepoint <= 0x007f) || (codepoint >= 0x00A0 && codepoint <= 0x00FF))

#define isIBM915(codepoint) \

        ((codepoint >= 0x0401 && codepoint <= 0x045F) || (codepoint == 0x2116))

#define isIBM916(codepoint) \

        ((codepoint >= 0x05D0 && codepoint <= 0x05EA) || (codepoint == 0x2017) || (codepoint == 0x203E))

#define isCompoundS3(codepoint) \

        ((codepoint == 0x060C) || (codepoint == 0x061B) || (codepoint == 0x061F) || (codepoint >= 0x0621 && codepoint <= 0x063A) || \

         (codepoint >= 0x0640 && codepoint <= 0x0652) || (codepoint >= 0x0660 && codepoint <= 0x066D) || (codepoint == 0x200B) || \

         (codepoint >= 0x0FE70 && codepoint <= 0x0FE72) || (codepoint == 0x0FE74) || (codepoint >= 0x0FE76 && codepoint <= 0x0FEBE))

#define isCompoundS2(codepoint) \

        ((codepoint == 0x02BC) || (codepoint == 0x02BD) || (codepoint >= 0x0384 && codepoint <= 0x03CE) || (codepoint == 0x2015))

#define isIBM914(codepoint) \

        ((codepoint == 0x0100) || (codepoint == 0x0101) || (codepoint == 0x0112) || (codepoint == 0x0113) || (codepoint == 0x0116) || (codepoint == 0x0117) || \

         (codepoint == 0x0122) || (codepoint == 0x0123) || (codepoint >= 0x0128 && codepoint <= 0x012B) || (codepoint == 0x012E) || (codepoint == 0x012F) || \

         (codepoint >= 0x0136 && codepoint <= 0x0138) || (codepoint == 0x013B) || (codepoint == 0x013C) || (codepoint == 0x0145) || (codepoint ==  0x0146) || \

         (codepoint >= 0x014A && codepoint <= 0x014D) || (codepoint == 0x0156) || (codepoint == 0x0157) || (codepoint >= 0x0166 && codepoint <= 0x016B) || \

         (codepoint == 0x0172) || (codepoint == 0x0173))

#define isIBM874(codepoint) \

        ((codepoint >= 0x0E01 && codepoint <= 0x0E3A) || (codepoint >= 0x0E3F && codepoint <= 0x0E5B))

#define isIBM912(codepoint) \

        ((codepoint >= 0x0102 && codepoint <= 0x0107) || (codepoint >= 0x010C && codepoint <= 0x0111) || (codepoint >= 0x0118 && codepoint <= 0x011B) || \

         (codepoint == 0x0139) || (codepoint == 0x013A) || (codepoint == 0x013D) || (codepoint == 0x013E) || (codepoint >= 0x0141 && codepoint <= 0x0144) || \

         (codepoint == 0x0147) || (codepoint == 0x0147) || (codepoint == 0x0150) || (codepoint == 0x0151) || (codepoint == 0x0154) || (codepoint == 0x0155) || \

         (codepoint >= 0x0158 && codepoint <= 0x015B) || (codepoint == 0x015E) || (codepoint == 0x015F) || (codepoint >= 0x0160 && codepoint <= 0x0165) || \

         (codepoint == 0x016E) || (codepoint == 0x016F) || (codepoint == 0x0170) || (codepoint ==  0x0171) || (codepoint >= 0x0179 && codepoint <= 0x017E) || \

         (codepoint == 0x02C7) || (codepoint == 0x02D8) || (codepoint == 0x02D9) || (codepoint == 0x02DB) || (codepoint == 0x02DD))

#define isIBM913(codepoint) \

        ((codepoint >= 0x0108 && codepoint <= 0x010B) || (codepoint == 0x011C) || \

         (codepoint == 0x011D) || (codepoint == 0x0120) || (codepoint == 0x0121) || \

         (codepoint >= 0x0124 && codepoint <= 0x0127) || (codepoint == 0x0134) || (codepoint == 0x0135) || \

         (codepoint == 0x015C) || (codepoint == 0x015D) || (codepoint == 0x016C) || (codepoint ==  0x016D))

#define isCompoundS1(codepoint) \

        ((codepoint == 0x011E) || (codepoint == 0x011F) || (codepoint == 0x0130) || \

         (codepoint == 0x0131) || (codepoint >= 0x0218 && codepoint <= 0x021B))

#define isISO8859_14(codepoint) \

        ((codepoint >= 0x0174 && codepoint <= 0x0177) || (codepoint == 0x1E0A) || \

         (codepoint == 0x1E0B) || (codepoint == 0x1E1E) || (codepoint == 0x1E1F) || \

         (codepoint == 0x1E40) || (codepoint == 0x1E41) || (codepoint == 0x1E56) || \

         (codepoint == 0x1E57) || (codepoint == 0x1E60) || (codepoint == 0x1E61) || \

         (codepoint == 0x1E6A) || (codepoint == 0x1E6B) || (codepoint == 0x1EF2) || \

         (codepoint == 0x1EF3) || (codepoint >= 0x1E80 && codepoint <= 0x1E85))

#define isIBM923(codepoint) \

        ((codepoint == 0x0152) || (codepoint == 0x0153) || (codepoint == 0x0178) || (codepoint == 0x20AC))

typedef struct{

    UConverterSharedData *myConverterArray[NUM_OF_CONVERTERS];

    COMPOUND_TEXT_CONVERTERS state;

} UConverterDataCompoundText;

/*********** Compound Text Converter Protos ***********/

U_CDECL_BEGIN

static void U_CALLCONV

_CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode);

static void U_CALLCONV

 _CompoundTextClose(UConverter *converter);

static void U_CALLCONV

_CompoundTextReset(UConverter *converter, UConverterResetChoice choice);

static const char* U_CALLCONV

_CompoundTextgetName(const UConverter* cnv);

static int32_t findNextEsc(const char *source, const char *sourceLimit) {

    int32_t length = sourceLimit - source;

    int32_t i;

    for (i = 1; i < length; i++) {

        if (*(source + i) == 0x1B) {

            return i;

        }

    }

    return length;

}

static COMPOUND_TEXT_CONVERTERS getState(int codepoint) {

    COMPOUND_TEXT_CONVERTERS state = DO_SEARCH;

    if (isASCIIRange(codepoint)) {

        state = COMPOUND_TEXT_SINGLE_0;

    } else if (isIBM912(codepoint)) {

        state = IBM_912;

    }else if (isIBM913(codepoint)) {

        state = IBM_913;

    } else if (isISO8859_14(codepoint)) {

        state = ISO_8859_14;

    } else if (isIBM923(codepoint)) {

        state = IBM_923;

    } else if (isIBM874(codepoint)) {

        state = IBM_874;

    } else if (isIBM914(codepoint)) {

        state = IBM_914;

    } else if (isCompoundS2(codepoint)) {

        state = COMPOUND_TEXT_SINGLE_2;

    } else if (isCompoundS3(codepoint)) {

        state = COMPOUND_TEXT_SINGLE_3;

    } else if (isIBM916(codepoint)) {

        state = IBM_916;

    } else if (isIBM915(codepoint)) {

        state = IBM_915;

    } else if (isCompoundS1(codepoint)) {

        state = COMPOUND_TEXT_SINGLE_1;

    }

    return state;

}

static COMPOUND_TEXT_CONVERTERS findStateFromEscSeq(const char* source, const char* sourceLimit, const uint8_t* toUBytesBuffer, int32_t toUBytesBufferLength, UErrorCode *err) {

    COMPOUND_TEXT_CONVERTERS state = INVALID;

    UBool matchFound = FALSE;

    int32_t i, n, offset = toUBytesBufferLength;

    for (i = 0; i < NUM_OF_CONVERTERS; i++) {

        matchFound = TRUE;

        for (n = 0; escSeqCompoundText[i][n] != 0; n++) {

            if (n < toUBytesBufferLength) {

                if (toUBytesBuffer[n] != escSeqCompoundText[i][n]) {

                    matchFound = FALSE;

                    break;

                }

            } else if ((source + (n - offset)) >= sourceLimit) {

                *err = U_TRUNCATED_CHAR_FOUND;

                matchFound = FALSE;

                break;

            } else if (*(source + (n - offset)) != escSeqCompoundText[i][n]) {

                matchFound = FALSE;

                break;

            }

        }

        if (matchFound) {

            break;

        }

    }

    if (matchFound) {

        state = (COMPOUND_TEXT_CONVERTERS)i;

    }

    return state;

}

static void U_CALLCONV

_CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){

    cnv->extraInfo = uprv_malloc (sizeof (UConverterDataCompoundText));

    if (cnv->extraInfo != NULL) {

        UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;

        UConverterNamePieces stackPieces;

        UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER;

        myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_0] = NULL;

        myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_1] = ucnv_loadSharedData("icu-internal-compound-s1", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_2] = ucnv_loadSharedData("icu-internal-compound-s2", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_3] = ucnv_loadSharedData("icu-internal-compound-s3", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_1] = ucnv_loadSharedData("icu-internal-compound-d1", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_2] = ucnv_loadSharedData("icu-internal-compound-d2", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_3] = ucnv_loadSharedData("icu-internal-compound-d3", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_4] = ucnv_loadSharedData("icu-internal-compound-d4", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_5] = ucnv_loadSharedData("icu-internal-compound-d5", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_6] = ucnv_loadSharedData("icu-internal-compound-d6", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_7] = ucnv_loadSharedData("icu-internal-compound-d7", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[COMPOUND_TEXT_TRIPLE_DOUBLE] = ucnv_loadSharedData("icu-internal-compound-t", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_915] = ucnv_loadSharedData("ibm-915_P100-1995", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_916] = ucnv_loadSharedData("ibm-916_P100-1995", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_914] = ucnv_loadSharedData("ibm-914_P100-1995", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_874] = ucnv_loadSharedData("ibm-874_P100-1995", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_912] = ucnv_loadSharedData("ibm-912_P100-1995", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_913] = ucnv_loadSharedData("ibm-913_P100-2000", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[ISO_8859_14] = ucnv_loadSharedData("iso-8859_14-1998", &stackPieces, &stackArgs, errorCode);

        myConverterData->myConverterArray[IBM_923] = ucnv_loadSharedData("ibm-923_P100-1998", &stackPieces, &stackArgs, errorCode);

        if (U_FAILURE(*errorCode) || pArgs->onlyTestIsLoadable) {

            _CompoundTextClose(cnv);

            return;

        }

        myConverterData->state = (COMPOUND_TEXT_CONVERTERS)0;

    } else {

        *errorCode = U_MEMORY_ALLOCATION_ERROR;

    }

}

static void U_CALLCONV

_CompoundTextClose(UConverter *converter) {

    UConverterDataCompoundText* myConverterData = (UConverterDataCompoundText*)(converter->extraInfo);

    int32_t i;

    if (converter->extraInfo != NULL) {

        /*close the array of converter pointers and free the memory*/

        for (i = 0; i < NUM_OF_CONVERTERS; i++) {

            if (myConverterData->myConverterArray[i] != NULL) {

                ucnv_unloadSharedDataIfReady(myConverterData->myConverterArray[i]);

            }

        }

        uprv_free(converter->extraInfo);

    }

}

static void U_CALLCONV

_CompoundTextReset(UConverter *converter, UConverterResetChoice choice) {

    (void)converter;

    (void)choice;

}

static const char* U_CALLCONV

_CompoundTextgetName(const UConverter* cnv){

    (void)cnv;

    return "x11-compound-text";

}

static void U_CALLCONV

UConverter_fromUnicode_CompoundText_OFFSETS(UConverterFromUnicodeArgs* args, UErrorCode* err){

    UConverter *cnv = args->converter;

    uint8_t *target = (uint8_t *) args->target;

    const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;

    const UChar* source = args->source;

    const UChar* sourceLimit = args->sourceLimit;

    /* int32_t* offsets = args->offsets; */

    UChar32 sourceChar;

    UBool useFallback = cnv->useFallback;

    uint8_t tmpTargetBuffer[7];

    int32_t tmpTargetBufferLength = 0;

    COMPOUND_TEXT_CONVERTERS currentState, tmpState;

    uint32_t pValue;

    int32_t pValueLength = 0;

    int32_t i, n, j;

    UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;

    currentState = myConverterData->state;

    /* check if the last codepoint of previous buffer was a lead surrogate*/

    if((sourceChar = cnv->fromUChar32)!=0 && target< targetLimit) {

        goto getTrail;

    }

    while( source < sourceLimit){

        if(target < targetLimit){

            sourceChar  = *(source++);

            /*check if the char is a First surrogate*/

             if(U16_IS_SURROGATE(sourceChar)) {

                if(U16_IS_SURROGATE_LEAD(sourceChar)) {

getTrail:

                    /*look ahead to find the trail surrogate*/

                    if(source < sourceLimit) {

                        /* test the following code unit */

                        UChar trail=(UChar) *source;

                        if(U16_IS_TRAIL(trail)) {

                            source++;

                            sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);

                            cnv->fromUChar32=0x00;

                            /* convert this supplementary code point */

                            /* exit this condition tree */

                        } else {

                            /* this is an unmatched lead code unit (1st surrogate) */

                            /* callback(illegal) */

                            *err=U_ILLEGAL_CHAR_FOUND;

                            cnv->fromUChar32=sourceChar;

                            break;

                        }

                    } else {

                        /* no more input */

                        cnv->fromUChar32=sourceChar;

                        break;

                    }

                } else {

                    /* this is an unmatched trail code unit (2nd surrogate) */

                    /* callback(illegal) */

                    *err=U_ILLEGAL_CHAR_FOUND;

                    cnv->fromUChar32=sourceChar;

                    break;

                }

            }

             tmpTargetBufferLength = 0;

             tmpState = getState(sourceChar);

             if (tmpState != DO_SEARCH && currentState != tmpState) {

                 /* Get escape sequence if necessary */

                 currentState = tmpState;

                 for (i = 0; escSeqCompoundText[currentState][i] != 0; i++) {

                     tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][i];

                 }

             }

             if (tmpState == DO_SEARCH) {

                 /* Test all available converters */

                 for (i = 1; i < SEARCH_LENGTH; i++) {

                     pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[i], sourceChar, &pValue, useFallback);

                     if (pValueLength > 0) {

                         tmpState = (COMPOUND_TEXT_CONVERTERS)i;

                         if (currentState != tmpState) {

                             currentState = tmpState;

                             for (j = 0; escSeqCompoundText[currentState][j] != 0; j++) {

                                 tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][j];

                             }

                         }

                         for (n = (pValueLength - 1); n >= 0; n--) {

                             tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));

                         }

                         break;

                     }

                 }

             } else if (tmpState == COMPOUND_TEXT_SINGLE_0) {

                 tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)sourceChar;

             } else {

                 pValueLength = ucnv_MBCSFromUChar32(myConverterData->myConverterArray[currentState], sourceChar, &pValue, useFallback);

                 if (pValueLength > 0) {

                     for (n = (pValueLength - 1); n >= 0; n--) {

                         tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));

                     }

                 }

             }

             for (i = 0; i < tmpTargetBufferLength; i++) {

                 if (target < targetLimit) {

                     *target++ = tmpTargetBuffer[i];

                 } else {

                     *err = U_BUFFER_OVERFLOW_ERROR;

                     break;

                 }

             }

             if (*err == U_BUFFER_OVERFLOW_ERROR) {

                 for (; i < tmpTargetBufferLength; i++) {

                     args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = tmpTargetBuffer[i];

                 }

             }

        } else {

            *err = U_BUFFER_OVERFLOW_ERROR;

            break;

        }

    }

    /*save the state and return */

    myConverterData->state = currentState;

    args->source = source;

    args->target = (char*)target;

}

static void U_CALLCONV

UConverter_toUnicode_CompoundText_OFFSETS(UConverterToUnicodeArgs *args,

                                               UErrorCode* err){

    const char *mySource = (char *) args->source;

    UChar *myTarget = args->target;

    const char *mySourceLimit = args->sourceLimit;

    const char *tmpSourceLimit = mySourceLimit;

    uint32_t mySourceChar = 0x0000;

    COMPOUND_TEXT_CONVERTERS currentState, tmpState;

    int32_t sourceOffset = 0;

    UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) args->converter->extraInfo;

    UConverterSharedData* savedSharedData = NULL;

    UConverterToUnicodeArgs subArgs;

    int32_t minArgsSize;

    /* set up the subconverter arguments */

    if(args->size<sizeof(UConverterToUnicodeArgs)) {

        minArgsSize = args->size;

    } else {

        minArgsSize = (int32_t)sizeof(UConverterToUnicodeArgs);

    }

    uprv_memcpy(&subArgs, args, minArgsSize);

    subArgs.size = (uint16_t)minArgsSize;

    currentState = tmpState =  myConverterData->state;

    while(mySource < mySourceLimit){

        if(myTarget < args->targetLimit){

            if (args->converter->toULength > 0) {

                mySourceChar = args->converter->toUBytes[0];

            } else {

                mySourceChar = (uint8_t)*mySource;

            }

            if (mySourceChar == ESC_START) {

                tmpState = findStateFromEscSeq(mySource, mySourceLimit, args->converter->toUBytes, args->converter->toULength, err);

                if (*err == U_TRUNCATED_CHAR_FOUND) {

                    for (; mySource < mySourceLimit;) {

                        args->converter->toUBytes[args->converter->toULength++] = *mySource++;

                    }

                    *err = U_ZERO_ERROR;

                    break;

                } else if (tmpState == INVALID) {

                    if (args->converter->toULength == 0) {

                        mySource++; /* skip over the 0x1b byte */

                    }

                    *err = U_ILLEGAL_CHAR_FOUND;

                    break;

                }

                if (tmpState != currentState) {

                    currentState = tmpState;

                }

                sourceOffset = uprv_strlen((char*)escSeqCompoundText[currentState]) - args->converter->toULength;

                mySource += sourceOffset;

                args->converter->toULength = 0;

            }

            if (currentState == COMPOUND_TEXT_SINGLE_0) {

                while (mySource < mySourceLimit) {

                    if (*mySource == ESC_START) {

                        break;

                    }

                    if (myTarget < args->targetLimit) {

                        *myTarget++ = 0x00ff&(*mySource++);

                    } else {

                        *err = U_BUFFER_OVERFLOW_ERROR;

                        break;

                    }

                }

            } else if (mySource < mySourceLimit){

                sourceOffset = findNextEsc(mySource, mySourceLimit);

                tmpSourceLimit = mySource + sourceOffset;

                subArgs.source = mySource;

                subArgs.sourceLimit = tmpSourceLimit;

                subArgs.target = myTarget;

                savedSharedData = subArgs.converter->sharedData;

                subArgs.converter->sharedData = myConverterData->myConverterArray[currentState];

                ucnv_MBCSToUnicodeWithOffsets(&subArgs, err);

                subArgs.converter->sharedData = savedSharedData;

                mySource = subArgs.source;

                myTarget = subArgs.target;

                if (U_FAILURE(*err)) {

                    if(*err == U_BUFFER_OVERFLOW_ERROR) {

                        if(subArgs.converter->UCharErrorBufferLength > 0) {

                            uprv_memcpy(args->converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer,

                                        subArgs.converter->UCharErrorBufferLength);

                        }

                        args->converter->UCharErrorBufferLength=subArgs.converter->UCharErrorBufferLength;

                        subArgs.converter->UCharErrorBufferLength = 0;

                    }

                    break;

                }

            }

        } else {

            *err = U_BUFFER_OVERFLOW_ERROR;

            break;

        }

    }

    myConverterData->state = currentState;

    args->target = myTarget;

    args->source = mySource;

}

static void U_CALLCONV

_CompoundText_GetUnicodeSet(const UConverter *cnv,

                    const USetAdder *sa,

                    UConverterUnicodeSet which,

                    UErrorCode *pErrorCode) {

    UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *)cnv->extraInfo;

    int32_t i;

    for (i = 1; i < NUM_OF_CONVERTERS; i++) {

        ucnv_MBCSGetUnicodeSetForUnicode(myConverterData->myConverterArray[i], sa, which, pErrorCode);

    }

    sa->add(sa->set, 0x0000);

    sa->add(sa->set, 0x0009);

    sa->add(sa->set, 0x000A);

    sa->addRange(sa->set, 0x0020, 0x007F);

    sa->addRange(sa->set, 0x00A0, 0x00FF);

}

U_CDECL_END

static const UConverterImpl _CompoundTextImpl = {

    UCNV_COMPOUND_TEXT,

    NULL,

    NULL,

    _CompoundTextOpen,

    _CompoundTextClose,

    _CompoundTextReset,

    UConverter_toUnicode_CompoundText_OFFSETS,

    UConverter_toUnicode_CompoundText_OFFSETS,

    UConverter_fromUnicode_CompoundText_OFFSETS,

    UConverter_fromUnicode_CompoundText_OFFSETS,

    NULL,

    NULL,

    _CompoundTextgetName,

    NULL,

    NULL,

    _CompoundText_GetUnicodeSet,

    NULL,

    NULL

};

static const UConverterStaticData _CompoundTextStaticData = {

    sizeof(UConverterStaticData),

    "COMPOUND_TEXT",

    0,

    UCNV_IBM,

    UCNV_COMPOUND_TEXT,

    1,

    6,

    { 0xef, 0, 0, 0 },

    1,

    FALSE,

    FALSE,

    0,

    0,

    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */

};

const UConverterSharedData _CompoundTextData =

        UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_CompoundTextStaticData, &_CompoundTextImpl);

#endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */