| /* |
| ********************************************************************** |
| * Copyright (C) 2000, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * file name: ucnv2022.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2000feb03 |
| * created by: Markus W. Scherer |
| * |
| * Change history: |
| * |
| * 06/29/2000 helena Major rewrite of the callback APIs. |
| * 08/08/2000 Ram Included support for ISO-2022-JP-2 |
| * Changed implementation of toUnicode |
| * function |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "cmemory.h" |
| #include "ucmp16.h" |
| #include "ucmp8.h" |
| #include "unicode/ucnv_err.h" |
| #include "ucnv_bld.h" |
| #include "unicode/ucnv.h" |
| #include "ucnv_cnv.h" |
| #include "unicode/ustring.h" |
| #include "cstring.h" |
| |
| |
| |
| /* Added by ram for ISO-2022JP implementation*/ |
| typedef enum { |
| ASCII = 0, |
| ISO8859_1 , |
| ISO8859_7 , |
| JISX201 , |
| JISX208 , |
| JISX212 , |
| GB2312 , |
| KSC5601 |
| |
| } StateEnum; |
| |
| |
| typedef enum { |
| SBCS = 0, |
| DBCS, |
| MBCS, |
| LATIN1 |
| }Cnv2022Type; |
| |
| |
| typedef struct |
| { |
| UConverter *currentConverter; |
| UConverter *previousConverter; |
| UConverter *fromUnicodeConverter; |
| UBool isFirstBuffer; |
| StateEnum currentState; |
| uint8_t escSeq2022[10]; |
| int8_t escSeq2022Length; |
| UConverter* myConverterArray[8]; |
| int32_t targetIndex; |
| int32_t sourceIndex; |
| UBool isEscapeAppended; |
| UBool soAppended; |
| char *currentLocale; |
| } |
| UConverterDataISO2022; |
| |
| /* ISO-2022 ----------------------------------------------------------------- */ |
| |
| U_CFUNC void T_UConverter_fromUnicode_UTF8 (UConverterFromUnicodeArgs * args, |
| UErrorCode * err); |
| |
| U_CFUNC void T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC (UConverterFromUnicodeArgs * converter, |
| UErrorCode * err); |
| |
| U_CFUNC void T_UConverter_fromUnicode_ISO_2022_JP(UConverterFromUnicodeArgs* args, |
| UErrorCode* err); |
| |
| #define ESC_2022 0x1B /*ESC*/ |
| |
| typedef enum |
| { |
| INVALID_2022 = -1, /*Doesn't correspond to a valid iso 2022 escape sequence*/ |
| VALID_NON_TERMINAL_2022 = 0, /*so far corresponds to a valid iso 2022 escape sequence*/ |
| VALID_TERMINAL_2022 = 1, /*corresponds to a valid iso 2022 escape sequence*/ |
| VALID_MAYBE_TERMINAL_2022 = 2 /*so far matches one iso 2022 escape sequence, but by adding more characters might match another escape sequence*/ |
| /* VALID_TERMINAL_2022_DONOT_CHANGE_STATE =3 /* for ISO-2022 JP support*/ |
| } UCNV_TableStates_2022; |
| |
| /* |
| * The way these state transition arrays work is: |
| * ex : ESC$B is the sequence for JISX208 |
| * a) First Iteration: char is ESC |
| * i) Get the value of ESC from normalize_esq_chars_2022[] with int value of ESC as index |
| * int x = normalize_esq_chars_2022[27] which is equal to 1 |
| * ii) Search for this value in escSeqStateTable_Key_2022[] |
| * value of x is stored at escSeqStateTable_Key_2022[0] |
| * iii) Save this index as offset |
| * iv) Get state of this sequence from escSeqStateTable_Value_2022[] |
| * escSeqStateTable_Value_2022[offset], which is VALID_NON_TERMINAL_2022 |
| * b) Switch on this state and continue to next char |
| * i) Get the value of $ from normalize_esq_chars_2022[] with int value of $ as index |
| * which is normalize_esq_chars_2022[36] == 4 |
| * ii) x is currently 1(from above) |
| * x<<=5 -- x is now 32 |
| * x+=normalize_esq_chars_2022[36] |
| * now x is 36 |
| * iii) Search for this value in escSeqStateTable_Key_2022[] |
| * value of x is stored at escSeqStateTable_Key_2022[2], so offset is 2 |
| * iv) Get state of this sequence from escSeqStateTable_Value_2022[] |
| * escSeqStateTable_Value_2022[offset], which is VALID_NON_TERMINAL_2022 |
| * c) Switch on this state and continue to next char |
| * i) Get the value of B from normalize_esq_chars_2022[] with int value of B as index |
| * ii) x is currently 36 (from above) |
| * x<<=5 -- x is now 1152 |
| * x+=normalize_esq_chars_2022[66] |
| * now x is 1161 |
| * iii) Search for this value in escSeqStateTable_Key_2022[] |
| * value of x is stored at escSeqStateTable_Key_2022[21], so offset is 21 |
| * iv) Get state of this sequence from escSeqStateTable_Value_2022[21] |
| * escSeqStateTable_Value_2022[offset], which is VALID_TERMINAL_2022 |
| * v) Get the converter name form escSeqStateTable_Result_2022[21] which is JISX208 |
| */ |
| |
| |
| /*Below are the 3 arrays depicting a state transition table*/ |
| int8_t normalize_esq_chars_2022[256] = { |
| /* 0 1 2 3 4 5 6 7 8 9 */ |
| |
| 0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,4 ,7 ,0 ,0 |
| ,2 ,0 ,0 ,0 ,0 ,3 ,23 ,6 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,5 ,8 ,9 ,10 ,11 ,12 |
| ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,0 ,0 |
| ,0 ,0 ,21 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,22 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 |
| ,0 ,0 ,0 ,0 ,0 ,0 |
| }; |
| |
| #define MAX_STATES_2022 58 |
| int32_t escSeqStateTable_Key_2022[MAX_STATES_2022] = { |
| /* 0 1 2 3 4 5 6 7 8 9 */ |
| |
| 1 ,34 ,36 ,39 ,55 ,1093 ,1096 ,1097 ,1098 ,1099 |
| ,1100 ,1101 ,1102 ,1103 ,1104 ,1105 ,1106 ,1109 ,1154 ,1157 |
| ,1160 ,1161 ,1254 ,1257 ,1768 ,1773 ,35105 ,36933 ,36936 ,36937 |
| ,36938 ,36939 ,36940 ,36942 ,36943 ,36944 ,36945 ,36946 ,36947 ,36948 |
| ,40133 ,40136 ,40138 ,40139 ,40140 ,40141 ,1123363 ,35947624 ,35947625 ,35947626 |
| ,35947627 ,35947629 ,35947630 ,35947631 ,35947635 ,35947636 ,35947638}; |
| |
| |
| const char* escSeqStateTable_Result_2022[MAX_STATES_2022] = { |
| /* 0 1 2 3 4 5 6 7 8 9 */ |
| |
| NULL ,NULL ,NULL ,NULL ,NULL ,"latin1" ,"latin1" ,"latin1" ,"ibm-865" ,"ibm-865" |
| ,"ibm-865" ,"ibm-865" ,"ibm-865" ,"ibm-865" ,"ibm-895" ,"jisx-201" ,"latin1" ,"latin1" ,NULL ,"ibm-955" |
| ,"GB2312" ,"jisx-208" ,NULL ,"UTF8" ,"ISO-8859-1" ,"ISO-8859-7" ,NULL ,"ibm-955" ,"bm-367" ,"ibm-952" |
| ,"ibm-949" ,"jisx-212" ,"ibm-1383" ,"ibm-952" ,"ibm-964" ,"ibm-964" ,"ibm-964" ,"ibm-964" ,"ibm-964" ,"ibm-964" |
| ,"UTF16_PlatformEndian" ,"UTF16_PlatformEndian" ,"UTF16_PlatformEndian" ,"UTF16_PlatformEndian" ,"UTF16_PlatformEndian" ,"UTF16_PlatformEndian" ,NULL ,"latin1" ,"ibm-912" ,"ibm-913" |
| ,"ibm-914" ,"ibm-813" ,"ibm-1089","ibm-920" ,"ibm-915" ,"ibm-915" ,"latin1"}; |
| |
| |
| UCNV_TableStates_2022 escSeqStateTable_Value_2022[MAX_STATES_2022] = { |
| /* 0 1 2 3 4 5 6 7 8 9 */ |
| |
| VALID_NON_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_MAYBE_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 |
| ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_TERMINAL_2022 |
| ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 |
| ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 |
| ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_NON_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 |
| ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022 ,VALID_TERMINAL_2022}; |
| |
| |
| /*for 2022 looks ahead in the stream |
| *to determine the longest possible convertible |
| *data stream*/ |
| static const char* getEndOfBuffer_2022(const char* source, |
| const char* sourceLimit, |
| UBool flush); |
| /*runs through a state machine to determine the escape sequence - codepage correspondance |
| *changes the pointer pointed to be _this->extraInfo*/ |
| static void changeState_2022(UConverter* _this, |
| const char** source, |
| const char* sourceLimit, |
| UBool flush, |
| UErrorCode* err); |
| |
| UCNV_TableStates_2022 getKey_2022(char source, |
| int32_t* key, |
| int32_t* offset); |
| |
| static void |
| _ISO2022Open(UConverter *cnv, const char *name, const char *locale, UErrorCode *errorCode) { |
| void *oldContext, *newContext=NULL; |
| UConverterFromUCallback *oldAction=malloc(sizeof(UConverterFromUCallback)); |
| /* cnv->charErrorBufferLength = 3; |
| cnv->charErrorBuffer[0] = 0x1b; |
| cnv->charErrorBuffer[1] = 0x25; |
| cnv->charErrorBuffer[2] = 0x42;*/ |
| cnv->extraInfo = uprv_malloc (sizeof (UConverterDataISO2022)); |
| if(cnv->extraInfo != NULL) { |
| UConverterDataISO2022 *myConverterData=(UConverterDataISO2022 *) cnv->extraInfo; |
| UConverter **array= myConverterData->myConverterArray; |
| |
| if( (locale != NULL) && (uprv_strlen(locale) > 0) ) { |
| myConverterData->currentLocale = (char*) uprv_malloc((sizeof(char) * uprv_strlen(locale)) + 1); |
| uprv_strcpy(myConverterData->currentLocale,locale); |
| } |
| else { |
| myConverterData->currentLocale = NULL; |
| } |
| |
| myConverterData->myConverterArray[0] =NULL; |
| if(locale && uprv_stricmp(locale,"jp")==0){ |
| myConverterData->myConverterArray[0]= ucnv_open("ASCII", errorCode ); |
| myConverterData->myConverterArray[1]= ucnv_open("ISO8859_1", errorCode); |
| myConverterData->myConverterArray[2]= ucnv_open("ISO8859_7", errorCode); |
| myConverterData->myConverterArray[3]= ucnv_open("jisx-201", errorCode); |
| myConverterData->myConverterArray[4]= ucnv_open("jisx-208", errorCode); |
| myConverterData->myConverterArray[5]= ucnv_open("jisx-212", errorCode); |
| myConverterData->myConverterArray[6]= ucnv_open("GB2312", errorCode); |
| myConverterData->myConverterArray[7]= ucnv_open("KSC5601", errorCode); |
| |
| myConverterData->myConverterArray[8]= NULL; |
| myConverterData->currentState =0; |
| myConverterData->targetIndex = 0; |
| myConverterData->sourceIndex =0; |
| myConverterData->isEscapeAppended=FALSE; |
| myConverterData->soAppended=FALSE; |
| while(*array!=NULL){ |
| ucnv_setFromUCallBack(*array,UCNV_FROM_U_CALLBACK_STOP, |
| newContext, oldAction,&oldContext, errorCode); |
| *array++; |
| } |
| myConverterData->isFirstBuffer = TRUE; |
| } |
| else{ |
| cnv->charErrorBufferLength = 3; |
| cnv->charErrorBuffer[0] = 0x1b; |
| cnv->charErrorBuffer[1] = 0x25; |
| cnv->charErrorBuffer[2] = 0x42; |
| myConverterData->currentLocale=NULL; |
| } |
| ((UConverterDataISO2022 *) cnv->extraInfo)->currentConverter = NULL; |
| ((UConverterDataISO2022 *) cnv->extraInfo)->previousConverter = NULL; |
| ((UConverterDataISO2022 *) cnv->extraInfo)->fromUnicodeConverter = NULL; |
| ((UConverterDataISO2022 *) cnv->extraInfo)->escSeq2022Length = 0; |
| cnv->fromUnicodeStatus =FALSE; |
| |
| free(oldAction); |
| } else { |
| *errorCode = U_MEMORY_ALLOCATION_ERROR; |
| } |
| |
| } |
| |
| |
| static void |
| _ISO2022Close(UConverter *converter) { |
| UConverter **array = ((UConverterDataISO2022 *) (converter->extraInfo))->myConverterArray; |
| if (converter->extraInfo != NULL) { |
| ucnv_close (((UConverterDataISO2022 *) (converter->extraInfo))->currentConverter); |
| /*close the array of converter pointers and free the memory*/ |
| |
| while(*array!=NULL){ |
| ucnv_close(*array++); |
| } |
| uprv_free(((UConverterDataISO2022 *) (converter->extraInfo))->currentLocale); |
| uprv_free (converter->extraInfo); |
| } |
| } |
| /*** ??? why are we going to UTF-8??*/ |
| static void |
| _ISO2022Reset(UConverter *converter) { |
| if(!((UConverterDataISO2022 *) (converter->extraInfo))->currentLocale){ |
| converter->charErrorBufferLength = 3; |
| converter->charErrorBuffer[0] = 0x1b; |
| converter->charErrorBuffer[1] = 0x28; |
| converter->charErrorBuffer[2] = 0x42; |
| } |
| if (converter->mode == UCNV_SO) |
| { |
| /* converter->charErrorBufferLength = 3; |
| converter->charErrorBuffer[0] = 0x1b; |
| converter->charErrorBuffer[1] = 0x25; |
| converter->charErrorBuffer[2] = 0x42;*/ |
| ucnv_close (((UConverterDataISO2022 *) (converter->extraInfo))->currentConverter); |
| ((UConverterDataISO2022 *) (converter->extraInfo))->currentConverter = NULL; |
| ((UConverterDataISO2022 *) (converter->extraInfo))->escSeq2022Length = 0; |
| converter->mode = UCNV_SI; |
| } |
| } |
| |
| |
| U_CFUNC void T_UConverter_fromUnicode_ISO_2022(UConverterFromUnicodeArgs *args, |
| UErrorCode* err) |
| { |
| UConverterDataISO2022 *myConverterData=(UConverterDataISO2022*)args->converter->extraInfo; |
| const char *locale =myConverterData->currentLocale; |
| if(locale && uprv_stricmp(locale,"jp")==0){ |
| T_UConverter_fromUnicode_ISO_2022_JP(args,err); |
| }else{ |
| T_UConverter_fromUnicode_UTF8(args, err); |
| } |
| } |
| |
| |
| U_CFUNC void T_UConverter_fromUnicode_ISO_2022_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args, |
| UErrorCode* err) |
| { |
| |
| char const* targetStart = args->target; |
| UConverterDataISO2022 *myConverterData=(UConverterDataISO2022*)args->converter->extraInfo; |
| const char *locale =myConverterData->currentLocale; |
| if(locale && uprv_stricmp(locale,"jp")==0){ |
| T_UConverter_fromUnicode_ISO_2022_JP(args,err); |
| } |
| else{ |
| T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC(args, err); |
| { |
| |
| int32_t len = args->target - targetStart; |
| int32_t i; |
| /* uprv_memmove(offsets+3, offsets, len); MEMMOVE SEEMS BROKEN --srl*/ |
| |
| for(i=len-1;i>=0;i--) args->offsets[i] = args->offsets[i]; |
| } |
| |
| } |
| } |
| |
| /*************************** BEGIN ****************************/ |
| |
| /************************************** IMPORTANT ************************************************** |
| * The T_fromUnicode_ISO2022_JP converter doesnot use ucnv_fromUnicode() functions for SBCS and DBCS, |
| * instead the values are obtained directly by accessing the sharedData structs through ucmp8_getU() |
| * and ucmp16_getU() macros to increase speed, reduce the overhead of function call and make it |
| * efficient.The converter iterates over each Unicode codepoint to obtain the equivalent codepoints |
| * from the codepages supported. Since the source buffer is processed one char at a time it would |
| * make sense to reduce the extra processing a canned converter would do as far as possible. |
| * |
| * If the implementation of these macros or structure of sharedData struct change in the future, make |
| * sure that ISO-2022-JP is also changed. |
| *************************************************************************************************** |
| */ |
| |
| /*************************************************************************************************** |
| * Rules for ISO-2022-jp encoding |
| * (i) Escape sequences must be fully contained within a line they should not |
| * span new lines or CRs |
| * (ii) If the last character on a line is represented by two bytes then an ASCII or |
| * JIS-Roman character escape sequence should follow before the line terminates |
| * (iii) If the first character on the line is represented by two bytes then a two |
| * byte character escape sequence should precede it |
| * (iv) If no escape sequence is encountered then the characters are ASCII |
| * (v) Latin(ISO-8859-1) and Greek(ISO-8859-7) characters must be designated to G2, |
| * and invoked with SS2 (ESC N). |
| * (vi) If there is any G0 designation in text, there must be a switch to |
| * ASCII or to JIS X 0201-Roman before a space character (but not |
| * necessarily before "ESC 4/14 2/0" or "ESC N ' '") or control |
| * characters such as tab or CRLF. |
| * (vi) Supported encodings: |
| * ASCII, JISX201, JISX208, JISX212, GB2312, KSC5601, ISO-8859-1,ISO-8859-7 |
| * |
| * source : RFC-1554 |
| * |
| * JISX201, JISX208,JISX212 : new .cnv data files created |
| * KSC5601 : alias to ibm-949 mapping table |
| * GB2312 : alias to ibm-1386 mapping table |
| * ISO-8859-1 : Algorithmic implemented as LATIN1 case |
| * ISO-8859-7 : alisas to ibm-9409 mapping table |
| */ |
| |
| |
| static Cnv2022Type myConverterType[8]={ |
| SBCS, |
| LATIN1, |
| SBCS, |
| SBCS, |
| DBCS, |
| DBCS, |
| MBCS, |
| MBCS, |
| |
| }; |
| #define UCNV_SS2 "\x0BN" |
| |
| #define ESC 0x0B |
| |
| static const char* escSeqChars[8] ={ |
| "\x1B\x28\x42", |
| "\x1B\x2E\x41", |
| "\x1B\x2E\x46", |
| "\x1B\x28\x4A", |
| "\x1B\x24\x42", |
| "\x1B\x24\x28\x44", |
| "\x1B\x24\x41", |
| "\x1B\x24\x28\x43", |
| |
| }; |
| |
| |
| static void concatChar(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| int8_t charToAppend,UErrorCode* err); |
| |
| static void concatEscape(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| const char* strToAppend,UErrorCode* err,int len); |
| |
| static void concatString(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| const UChar* strToAppend,UErrorCode* err,int32_t *sourceIndex); |
| |
| /* |
| * The iteration over various code pages works this way: |
| * i) Get the currentState from myConverterData->currentState |
| * ii) Check if the character is mapped to a valid character in the currentState |
| * Yes -> a) set the initIterState to currentState |
| * b) remain in this state until an invalid character is found |
| * No -> a) go to the next code page and find the character |
| * iii) Before changing the state increment the current state check if the current state |
| * is equal to the intitIteration state |
| * Yes -> A character that cannot be represented in any of the supported encodings |
| * break and return a U_INVALID_CHARACTER error |
| * No -> Continue and find the character in next code page |
| * |
| * Offsets Logic is handled by utility functions concatChar(), concatEscape() and concatString() |
| * |
| */ |
| |
| |
| U_CFUNC void T_UConverter_fromUnicode_ISO_2022_JP(UConverterFromUnicodeArgs* args, UErrorCode* err){ |
| UChar* mySource =(UChar*)args->source; |
| |
| UConverterDataISO2022 *myConverterData=(UConverterDataISO2022*)args->converter->extraInfo; |
| UConverterCallbackReason reason; |
| UBool isEscapeAppended = FALSE; |
| StateEnum initIterState; |
| unsigned char *myTarget = (unsigned char *) args->target; |
| |
| char *uBuf =(char*) malloc(sizeof(char) * 4); |
| char *targetChar; |
| char *targetLimit; |
| |
| const UChar *saveSource; |
| char *saveTarget; |
| int32_t *saveOffsets ; |
| const UChar* mySourceLimit; |
| int32_t myTargetLength = args->targetLimit - args->target; |
| int32_t mySourceLength = args->sourceLimit - args->source; |
| int32_t mySourceIndex = 0; |
| int32_t myTargetIndex = 0; |
| |
| CompactShortArray *myFromUnicodeDBCS = NULL; |
| CompactShortArray *myFromUnicodeDBCSFallback = NULL; |
| CompactByteArray *myFromUnicodeSBCS = NULL; |
| CompactByteArray *myFromUnicodeSBCSFallback = NULL; |
| UChar targetUniChar = missingCharMarker; |
| |
| StateEnum currentState=0; |
| Cnv2022Type myType; |
| UChar mySourceChar = 0x0000; |
| UChar *sourceCharPtr=NULL; |
| int iterCount = 0; |
| const char *escSeq = NULL; |
| UBool soAppended = FALSE; |
| UBool isTargetUCharDBCS=FALSE,oldIsTargetUCharDBCS=FALSE; |
| |
| mySourceIndex = myConverterData->sourceIndex; |
| myTargetIndex = myConverterData->targetIndex; |
| isEscapeAppended =(UBool) myConverterData->isEscapeAppended; |
| soAppended =(UBool) myConverterData->soAppended; |
| initIterState =0; |
| /* arguments check*/ |
| if ((args->converter == NULL) || (args->targetLimit < args->target) || (args->sourceLimit < args->source)){ |
| *err = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| while(mySourceIndex < mySourceLength){ |
| currentState = myConverterData->currentState; |
| myConverterData->fromUnicodeConverter = (myConverterData->fromUnicodeConverter == NULL) ? |
| myConverterData->myConverterArray[0] : |
| myConverterData->myConverterArray[(int)myConverterData->currentState]; |
| isTargetUCharDBCS = (UBool) args->converter->fromUnicodeStatus; |
| |
| if(myTargetIndex < myTargetLength){ |
| |
| mySourceChar = (UChar) args->source[mySourceIndex++]; |
| |
| myType= (Cnv2022Type) myConverterType[currentState]; |
| |
| /* I am handling surrogates in the begining itself so that I donot have to go through 8 |
| * iterations on codepages that we support. |
| */ |
| if(UTF_IS_LEAD(mySourceChar)){ |
| |
| args->converter->invalidUCharBuffer[0] = (UChar)mySource[mySourceIndex - 1]; |
| args->converter->invalidUCharLength = 1; |
| |
| /*mySourceIndex has already been incremented*/ |
| if(mySourceIndex < mySourceLength){ |
| if(UTF_IS_TRAIL(mySource[mySourceIndex])){ |
| args->converter->invalidUCharBuffer[1] = (UChar)mySource[mySourceIndex]; |
| args->converter->invalidUCharLength++; |
| mySourceIndex++; |
| continue; |
| } |
| else if (args->flush == TRUE){ |
| reason = UCNV_ILLEGAL; |
| *err = U_TRUNCATED_CHAR_FOUND; |
| goto CALLBACK; |
| } |
| else{ |
| reason=UCNV_ILLEGAL; |
| goto CALLBACK; |
| } |
| } |
| else{ |
| args->converter->invalidUCharBuffer[1] = (UChar)mySource[mySourceIndex]; |
| continue; |
| } |
| } |
| else if(UTF_IS_TRAIL(mySourceChar)){ |
| if(args->converter->fromUSurrogateLead == 0){ |
| reason = UCNV_ILLEGAL; |
| goto CALLBACK; |
| } |
| else{ |
| /* the only way we can arrive here is if UTF lead surrogate was found |
| * at the end of previous buffer. So we need to check if the current |
| * current source index is 0 or not |
| */ |
| if(mySourceIndex-1 ==0){ |
| args->converter->invalidUCharBuffer[1] = (UChar)mySource[mySourceIndex]; |
| args->converter->invalidUCharLength++; |
| mySourceIndex++; |
| continue; |
| } |
| else{ |
| reason=UCNV_ILLEGAL; |
| goto CALLBACK; |
| } |
| } |
| } |
| |
| /*Do the conversion*/ |
| else if(mySourceChar == 0x0020){ |
| targetUniChar = mySourceChar; |
| if(currentState > 2){ |
| concatEscape(args, &myTargetIndex, &myTargetLength, escSeqChars[0],err,strlen(escSeqChars[0])); |
| |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| } |
| } |
| /* if the source character is CR or LF then append the ASCII escape sequence*/ |
| else if(mySourceChar== 0x000A || mySourceChar== 0x000D){ |
| |
| if(isTargetUCharDBCS && mySource[mySourceIndex-2]!=0x000A){ |
| concatEscape(args, &myTargetIndex, &myTargetLength, escSeqChars[0],err,strlen(escSeqChars[0])); |
| isTargetUCharDBCS=FALSE; |
| soAppended =FALSE; |
| myConverterData->soAppended=FALSE; |
| |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| } |
| |
| targetUniChar = mySourceChar; |
| concatString(args, &myTargetIndex, &myTargetLength,&targetUniChar,err,&mySourceIndex); |
| |
| if(currentState==ISO8859_1 || currentState ==ISO8859_7) |
| isEscapeAppended =FALSE; |
| |
| if(*err ==U_BUFFER_OVERFLOW_ERROR) |
| break; |
| continue; |
| } |
| else{ |
| |
| switch (myType){ |
| |
| case SBCS: |
| myFromUnicodeSBCS = &myConverterData->fromUnicodeConverter->sharedData->table->sbcs.fromUnicode; |
| myFromUnicodeSBCSFallback = &myConverterData->fromUnicodeConverter->sharedData->table->sbcs.fromUnicodeFallback; |
| |
| targetUniChar = (UChar) ucmp8_getu (myFromUnicodeSBCS, mySourceChar); |
| |
| if ((targetUniChar==0)&&(myConverterData->fromUnicodeConverter->useFallback == TRUE) && |
| (myConverterData->fromUnicodeConverter->sharedData->staticData->hasFromUnicodeFallback == TRUE)){ |
| targetUniChar = (UChar) ucmp8_getu (myFromUnicodeSBCSFallback, mySourceChar); |
| } |
| /* ucmp8_getU returns 0 for missing char so explicitly set it missingCharMarker*/ |
| targetUniChar=(UChar)((targetUniChar==0) ? (UChar) missingCharMarker : targetUniChar); |
| break; |
| |
| case DBCS: |
| |
| myFromUnicodeDBCS = &myConverterData->fromUnicodeConverter->sharedData->table->dbcs.fromUnicode; |
| myFromUnicodeDBCSFallback = &myConverterData->fromUnicodeConverter->sharedData->table->dbcs.fromUnicodeFallback; |
| targetUniChar = (UChar) ucmp16_getu (myFromUnicodeDBCS, mySourceChar); |
| |
| if ((targetUniChar==missingCharMarker)&&(myConverterData->fromUnicodeConverter->useFallback == TRUE) && |
| (myConverterData->fromUnicodeConverter->sharedData->staticData->hasFromUnicodeFallback == TRUE)){ |
| targetUniChar = (UChar) ucmp16_getu (myFromUnicodeDBCSFallback, mySourceChar); |
| } |
| break; |
| |
| case MBCS: |
| |
| sourceCharPtr =&mySourceChar; |
| mySourceLimit= sourceCharPtr+1; |
| targetChar =uBuf; |
| targetLimit = uBuf+4; |
| |
| ucnv_fromUnicode(myConverterData->fromUnicodeConverter, |
| &targetChar,targetLimit, |
| &sourceCharPtr, |
| mySourceLimit,args->offsets,args->flush,err); |
| if(U_FAILURE(*err)){ |
| targetUniChar = missingCharMarker; |
| *err =U_ZERO_ERROR; |
| }else{ |
| /*convert to targetUniChar*/ |
| uint8_t len=(uint8_t)(targetChar-uBuf); |
| targetChar=uBuf; |
| targetUniChar=0; |
| |
| /* the below switch structure is not required since IS2022-JP-2 |
| * supports only DBCS char sets. Reverse engineered from DBCS code. |
| * the cases fall through without break |
| */ |
| switch(len){ |
| case 4: |
| targetUniChar+=(uint32_t)((uint8_t)(*targetChar++))<<24; |
| case 3: |
| targetUniChar+=(uint32_t)((uint8_t)(*targetChar++))<<16; |
| case 2: |
| targetUniChar+=(uint32_t)((uint8_t)(*targetChar++))<<8; |
| case 1: |
| targetUniChar+=(uint8_t)(*targetChar); |
| default: |
| break; |
| } |
| |
| } |
| |
| break; |
| |
| case LATIN1: |
| if(mySourceChar < 0x0100){ |
| targetUniChar = mySourceChar; |
| } else targetUniChar = missingCharMarker; |
| break; |
| |
| default: |
| /*not expected */ |
| break; |
| } |
| } |
| |
| if(targetUniChar!= missingCharMarker){ |
| |
| oldIsTargetUCharDBCS = isTargetUCharDBCS; |
| isTargetUCharDBCS =(UBool) (targetUniChar >0x00FF); |
| args->converter->fromUnicodeStatus= isTargetUCharDBCS; |
| /* set the iteration state and iteration count */ |
| initIterState = currentState; |
| iterCount =0; |
| /* Append the escpace sequence */ |
| if(!isEscapeAppended){ |
| escSeq = escSeqChars[(int)currentState]; |
| concatEscape(args, &myTargetIndex, &myTargetLength, |
| escSeqChars[(int)currentState], |
| err,strlen(escSeqChars[(int)currentState])); |
| |
| isEscapeAppended =TRUE; |
| myConverterData->isEscapeAppended=TRUE; |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| |
| /* Append SSN for shifting to G2 */ |
| if(currentState==ISO8859_1 || currentState==ISO8859_7){ |
| concatEscape(args, &myTargetIndex, &myTargetLength, |
| UCNV_SS2,err,strlen(UCNV_SS2)); |
| |
| |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| } |
| } |
| else{ |
| |
| if(oldIsTargetUCharDBCS != isTargetUCharDBCS ){ |
| /*Shifting from a double byte to single byte mode*/ |
| if(!isTargetUCharDBCS){ |
| |
| concatChar(args, &myTargetIndex, |
| &myTargetLength, UCNV_SI,err); |
| soAppended =FALSE; |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| } |
| else{ /* Shifting from a single byte to double byte mode*/ |
| concatChar(args, &myTargetIndex, |
| &myTargetLength, UCNV_SO,err); |
| soAppended =TRUE; |
| myConverterData->soAppended =soAppended; |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| } |
| } |
| } |
| |
| concatString(args, &myTargetIndex, &myTargetLength, |
| &targetUniChar,err, &mySourceIndex); |
| if(*err ==U_BUFFER_OVERFLOW_ERROR){ |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| return; |
| } |
| |
| }/* end of end if(targetUniChar==missingCharMarker)*/ |
| else{ |
| myConverterData->currentState=currentState=(currentState<7)? currentState+1:0; |
| iterCount = (iterCount<8)? iterCount+1 : 0; |
| |
| if((currentState!= initIterState) ){ |
| |
| /* explicitly decrement source since it has already been incremented */ |
| mySourceIndex--; |
| targetUniChar =missingCharMarker; |
| isEscapeAppended = FALSE; |
| /* save the state */ |
| myConverterData->isEscapeAppended = isEscapeAppended; |
| myConverterData->soAppended =soAppended; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| myConverterData->sourceIndex = mySourceIndex; |
| myConverterData->targetIndex = myTargetIndex; |
| continue; |
| } |
| else{ |
| /* if we cannot find the character after checking all codepages |
| * then this is an error |
| */ |
| reason = UCNV_UNASSIGNED; |
| *err = U_INVALID_CHAR_FOUND; |
| |
| CALLBACK: |
| saveSource = args->source; |
| saveTarget = args->target; |
| saveOffsets = args->offsets; |
| args->target = (char*)myTarget + myTargetIndex; |
| args->source = mySource + mySourceIndex; |
| myConverterData->isEscapeAppended = isEscapeAppended; |
| myConverterData->soAppended =soAppended; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| myConverterData->sourceIndex = mySourceIndex; |
| myConverterData->targetIndex = myTargetIndex; |
| |
| FromU_CALLBACK_MACRO(args->converter->fromUContext, |
| args, |
| args->converter->invalidUCharBuffer, |
| args->converter->invalidUCharLength, |
| (UChar32) (args->converter->invalidUCharLength == 2 ? |
| UTF16_GET_PAIR_VALUE(args->converter->invalidUCharBuffer[0], |
| args->converter->invalidUCharBuffer[1]) |
| : args->converter->invalidUCharBuffer[0]), |
| reason, |
| err); |
| |
| args->source = saveSource; |
| args->target = saveTarget; |
| args->offsets = saveOffsets; |
| if (U_FAILURE (*err)){ |
| break; |
| } |
| args->converter->invalidUCharLength = 0; |
| } |
| } |
| } /* end if(myTargetIndex<myTargetLength) */ |
| else{ |
| *err =U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| }/* end while(mySourceIndex<mySourceLength) */ |
| |
| free(uBuf); /* free the malloced memory */ |
| |
| /*save the state and return */ |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| myConverterData->sourceIndex = 0; |
| myConverterData->targetIndex = 0; |
| args->converter->fromUnicodeStatus = isTargetUCharDBCS; |
| |
| } |
| |
| static void concatString(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| const UChar* strToAppend,UErrorCode* err, int32_t *sourceIndex){ |
| |
| if(*strToAppend < 0x00FF){ |
| if( (*targetIndex)+1 >= *targetLength){ |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (unsigned char) *strToAppend; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| }else{ |
| args->target[*targetIndex] = (unsigned char) *strToAppend; |
| |
| if(args->offsets!=NULL){ |
| args->offsets[*targetIndex] = *sourceIndex-1; |
| } |
| (*targetIndex)++; |
| |
| } |
| } |
| else{ |
| if(*targetIndex < *targetLength){ |
| args->target[*targetIndex] =(unsigned char) (*strToAppend>>8); |
| if(args->offsets!=NULL){ |
| args->offsets[*targetIndex] = *sourceIndex-1; |
| } |
| (*targetIndex)++; |
| |
| if(*targetIndex < *targetLength){ |
| args->target[(*targetIndex)] =(unsigned char) (*strToAppend & 0x00FF); |
| |
| if(args->offsets!=NULL){ |
| args->offsets[*targetIndex] = *sourceIndex-1; |
| } |
| (*targetIndex)++; |
| } |
| else{ |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (unsigned char) (*strToAppend & 0x00FF); |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| |
| } |
| |
| } |
| else{ |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (unsigned char) (*strToAppend>>8); |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (unsigned char) (*strToAppend & 0x00FF); |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| if(args->offsets!=NULL){ |
| args->offsets[*targetIndex] = *sourceIndex-1; |
| |
| } |
| } |
| } |
| |
| } |
| |
| |
| static void concatEscape(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| const char* strToAppend,UErrorCode* err,int len){ |
| while(len-->0){ |
| if(*targetIndex < *targetLength){ |
| args->target[(*targetIndex)++] = (unsigned char) *strToAppend; |
| } |
| else{ |
| args->converter->charErrorBuffer[(int)args->converter->charErrorBufferLength++] = (unsigned char) *strToAppend; |
| *err =U_BUFFER_OVERFLOW_ERROR; |
| } |
| strToAppend++; |
| } |
| } |
| |
| static void concatChar(UConverterFromUnicodeArgs* args, int32_t *targetIndex, int32_t *targetLength, |
| int8_t charToAppend,UErrorCode* err){ |
| if( *targetIndex < *targetLength){ |
| args->target[(*targetIndex)++] = (unsigned char) charToAppend; |
| }else{ |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (unsigned char) charToAppend; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| } |
| } |
| |
| /*************** to unicode *******************/ |
| |
| UCNV_TableStates_2022 getKey_2022(char c, |
| int32_t* key, |
| int32_t* offset){ |
| int32_t togo = *key; |
| int32_t low = 0; |
| int32_t hi = MAX_STATES_2022; |
| int32_t oldmid=0; |
| |
| if (*key == 0){ |
| togo = (int8_t)normalize_esq_chars_2022[c]; |
| } |
| else{ |
| togo <<= 5; |
| togo += (int8_t)normalize_esq_chars_2022[c]; |
| } |
| |
| while (hi != low) /*binary search*/{ |
| |
| register int32_t mid = (hi+low) >> 1; /*Finds median*/ |
| |
| if (mid == oldmid) |
| break; |
| |
| if (escSeqStateTable_Key_2022[mid] > togo){ |
| hi = mid; |
| } |
| else if (escSeqStateTable_Key_2022[mid] < togo){ |
| low = mid; |
| } |
| else /*we found it*/{ |
| *key = togo; |
| *offset = mid; |
| return escSeqStateTable_Value_2022[mid]; |
| } |
| oldmid = mid; |
| |
| } |
| |
| *key = 0; |
| *offset = 0; |
| return INVALID_2022; |
| } |
| |
| |
| |
| void changeState_2022(UConverter* _this, |
| const char** source, |
| const char* sourceLimit, |
| UBool flush, |
| UErrorCode* err){ |
| UConverter* myUConverter; |
| uint32_t key = _this->toUnicodeStatus; |
| UCNV_TableStates_2022 value; |
| UConverterDataISO2022* myData2022 = ((UConverterDataISO2022*)_this->extraInfo); |
| const char* chosenConverterName = NULL; |
| |
| int32_t offset; |
| |
| /*In case we were in the process of consuming an escape sequence |
| we need to reprocess it */ |
| |
| do{ |
| |
| /* Needed explicit cast for key on MVS to make compiler happy - JJD */ |
| value = getKey_2022(**source,(int32_t *) &key, &offset); |
| switch (value){ |
| case VALID_NON_TERMINAL_2022 : |
| break; |
| |
| case VALID_TERMINAL_2022: |
| { |
| (*source)++; |
| chosenConverterName = escSeqStateTable_Result_2022[offset]; |
| key = 0; |
| goto DONE; |
| }; |
| break; |
| |
| case INVALID_2022: |
| { |
| _this->toUnicodeStatus = 0; |
| *err = U_ILLEGAL_CHAR_FOUND; |
| return; |
| } |
| |
| case VALID_MAYBE_TERMINAL_2022: |
| { |
| const char* mySource = (*source+1); |
| int32_t myKey = key; |
| UCNV_TableStates_2022 myValue = value; |
| int32_t myOffset=0; |
| if(*mySource==ESC_2022){ |
| while ((mySource < sourceLimit) && |
| ((myValue == VALID_MAYBE_TERMINAL_2022)||(myValue == VALID_NON_TERMINAL_2022))){ |
| myValue = getKey_2022(*(mySource++), &myKey, &myOffset); |
| } |
| } |
| else{ |
| (*source)++; |
| myValue=1; |
| myOffset = 5; |
| } |
| |
| switch (myValue){ |
| case INVALID_2022: |
| { |
| /*Backs off*/ |
| chosenConverterName = escSeqStateTable_Result_2022[offset]; |
| value = VALID_TERMINAL_2022; |
| goto DONE; |
| }; |
| break; |
| |
| case VALID_TERMINAL_2022: |
| { |
| /*uses longer escape sequence*/ |
| chosenConverterName = escSeqStateTable_Result_2022[myOffset]; |
| key = 0; |
| value = VALID_TERMINAL_2022; |
| goto DONE; |
| }; |
| break; |
| |
| case VALID_NON_TERMINAL_2022: |
| |
| case VALID_MAYBE_TERMINAL_2022: |
| { |
| if (flush){ |
| /*Backs off*/ |
| chosenConverterName = escSeqStateTable_Result_2022[offset]; |
| value = VALID_TERMINAL_2022; |
| key = 0; |
| goto DONE; |
| } |
| else{ |
| key = myKey; |
| value = VALID_NON_TERMINAL_2022; |
| } |
| }; |
| break; |
| }; |
| break; |
| }; |
| break; |
| } |
| }while (++(*source) < sourceLimit); |
| |
| DONE: |
| _this->toUnicodeStatus = key; |
| |
| if ((value == VALID_NON_TERMINAL_2022) || (value == VALID_MAYBE_TERMINAL_2022)) { |
| return; |
| } |
| if (value > 0) { |
| if(uprv_strcmp(chosenConverterName,"latin1")==0 && uprv_strcmp(myData2022->currentLocale,"jp")==0){ |
| _this->mode = UCNV_SI; |
| myUConverter =myData2022->currentConverter; |
| |
| } |
| else{ |
| _this->mode = UCNV_SI; |
| ucnv_close(myData2022->currentConverter); |
| myData2022->currentConverter = myUConverter = ucnv_open(chosenConverterName, err); |
| |
| } |
| if (U_SUCCESS(*err)){ |
| /*Customize the converter with the attributes set on the 2022 converter*/ |
| myUConverter->fromUCharErrorBehaviour = _this->fromUCharErrorBehaviour; |
| myUConverter->fromUContext = _this->fromUContext; |
| myUConverter->fromCharErrorBehaviour = _this->fromCharErrorBehaviour; |
| myUConverter->toUContext = _this->toUContext; |
| |
| uprv_memcpy(myUConverter->subChar, |
| _this->subChar, |
| myUConverter->subCharLen = _this->subCharLen); |
| |
| _this->mode = UCNV_SO; |
| } |
| } |
| |
| return; |
| } |
| |
| /*Checks the characters of the buffer against valid 2022 escape sequences |
| *if the match we return a pointer to the initial start of the sequence otherwise |
| *we return sourceLimit |
| */ |
| const char* getEndOfBuffer_2022(const char* source, |
| const char* sourceLimit, |
| UBool flush){ |
| |
| const char* mySource = source; |
| |
| if (source >= sourceLimit) |
| return sourceLimit; |
| |
| do{ |
| |
| if (*mySource == ESC_2022){ |
| int8_t i; |
| int32_t key = 0; |
| int32_t offset; |
| UCNV_TableStates_2022 value = VALID_NON_TERMINAL_2022; |
| /* check for SS2*/ |
| if(*mySource+1 == 0x4E){ |
| if(mySource == source){ |
| source++; |
| source++; |
| return getEndOfBuffer_2022(source,sourceLimit,flush); |
| } |
| else{ |
| return mySource; |
| } |
| } |
| |
| for (i=0; |
| (mySource+i < sourceLimit)&&(value == VALID_NON_TERMINAL_2022); |
| i++) { |
| value = getKey_2022(*(mySource+i), &key, &offset); |
| } |
| |
| if (value > 0) |
| return mySource; |
| |
| if ((value == VALID_NON_TERMINAL_2022)&&(!flush) ) |
| return sourceLimit; |
| } |
| else if(*mySource == (char)UCNV_SI || *mySource==(char)UCNV_SO){ |
| if(mySource == source){ |
| source++; |
| return getEndOfBuffer_2022(source,sourceLimit,flush); |
| } |
| else{ |
| return mySource; |
| } |
| } |
| |
| }while (mySource++ < sourceLimit); |
| |
| return sourceLimit; |
| } |
| |
| |
| |
| U_CFUNC void T_UConverter_toUnicode_ISO_2022(UConverterToUnicodeArgs *args, |
| UErrorCode* err){ |
| |
| const char *mySourceLimit; |
| char const* sourceStart; |
| UConverter *saveThis; |
| |
| /*Arguments Check*/ |
| if (U_FAILURE(*err)) |
| return; |
| |
| if ((args->converter == NULL) || (args->targetLimit < args->target) || (args->sourceLimit < args->source)){ |
| *err = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| do{ |
| |
| /*Find the end of the buffer e.g : Next Escape Seq | end of Buffer*/ |
| mySourceLimit = getEndOfBuffer_2022(args->source, args->sourceLimit, args->flush); |
| |
| if (args->converter->mode == UCNV_SO) /*Already doing some conversion*/{ |
| |
| saveThis = args->converter; |
| args->offsets = NULL; |
| args->converter = ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter; |
| ucnv_toUnicode(args->converter, |
| &args->target, |
| args->targetLimit, |
| &args->source, |
| mySourceLimit, |
| args->offsets, |
| args->flush, |
| err); |
| args->converter = saveThis; |
| } |
| /* in ISO-2022-jp the characters preceeding any escape sequence are assumed |
| * to be ASCII so we need to explicitly check for it |
| */ |
| if((((UConverterDataISO2022 *)args->converter->extraInfo)->isFirstBuffer) && (args->source[0]!=(char)ESC_2022) |
| && (((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter==NULL)){ |
| |
| |
| saveThis = args->converter; |
| args->offsets = NULL; |
| ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter = ucnv_open("ASCII",err); |
| |
| if(U_FAILURE(*err)){ |
| break; |
| } |
| |
| args->converter = ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter; |
| ucnv_toUnicode(args->converter, |
| &args->target, |
| args->targetLimit, |
| &args->source, |
| mySourceLimit, |
| args->offsets, |
| args->flush, |
| err); |
| args->converter = saveThis; |
| args->converter->mode = UCNV_SO; |
| ((UConverterDataISO2022*)(args->converter->extraInfo))->isFirstBuffer=FALSE; |
| |
| } |
| |
| /*-Done with buffer with entire buffer |
| -Error while converting |
| */ |
| |
| if (U_FAILURE(*err) || (args->source == args->sourceLimit)) |
| return; |
| |
| sourceStart = args->source; |
| changeState_2022(args->converter, |
| &(args->source), |
| args->sourceLimit, |
| args->flush, |
| err); |
| /* args->source = sourceStart; */ |
| |
| |
| }while(args->source < args->sourceLimit); |
| |
| ((UConverterDataISO2022*)(args->converter->extraInfo))->isFirstBuffer=FALSE; |
| |
| return; |
| } |
| |
| U_CFUNC void T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverterToUnicodeArgs* args, |
| UErrorCode* err){ |
| |
| int32_t myOffset=0; |
| int32_t base = 0; |
| const char* mySourceLimit; |
| char const* sourceStart; |
| UConverter* _this = NULL; |
| |
| /*Arguments Check*/ |
| if (U_FAILURE(*err)) |
| return; |
| if ((args->converter == NULL) || (args->targetLimit < args->target) || (args->sourceLimit < args->source)){ |
| *err = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| do{ |
| mySourceLimit = getEndOfBuffer_2022(args->source, args->sourceLimit, args->flush); |
| /*Find the end of the buffer e.g : Next Escape Seq | end of Buffer*/ |
| |
| if (args->converter->mode == UCNV_SO) /*Already doing some conversion*/{ |
| const UChar* myTargetStart = args->target; |
| |
| _this = args->converter; |
| args->converter = ((UConverterDataISO2022*)(_this->extraInfo))->currentConverter; |
| ucnv_toUnicode(args->converter, |
| &(args->target), |
| args->targetLimit, |
| &(args->source), |
| mySourceLimit, |
| args->offsets, |
| args->flush, |
| err); |
| |
| args->converter = _this; |
| { |
| int32_t lim = args->target - myTargetStart; |
| int32_t i = 0; |
| for (i=base; i < lim;i++){ |
| args->offsets[i] += myOffset; |
| } |
| base += lim; |
| } |
| |
| } |
| if(((UConverterDataISO2022 *)args->converter->extraInfo)->isFirstBuffer && args->source[0]!=ESC_2022 |
| && ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter==NULL){ |
| |
| const UChar* myTargetStart = args->target; |
| UConverter* saveThis = args->converter; |
| args->offsets = NULL; |
| ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter = ucnv_open("ASCII",err); |
| |
| if(U_FAILURE(*err)){ |
| break; |
| } |
| |
| args->converter = ((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter; |
| ucnv_toUnicode(args->converter, |
| &args->target, |
| args->targetLimit, |
| &args->source, |
| mySourceLimit, |
| args->offsets, |
| args->flush, |
| err); |
| args->converter = saveThis; |
| args->converter->mode = UCNV_SO; |
| ((UConverterDataISO2022*)(args->converter->extraInfo))->isFirstBuffer=FALSE; |
| args->converter = _this; |
| { |
| int32_t lim = args->target - myTargetStart; |
| int32_t i = 0; |
| for (i=base; i < lim;i++){ |
| args->offsets[i] += myOffset; |
| } |
| base += lim; |
| } |
| } |
| /*-Done with buffer with entire buffer |
| -Error while converting |
| */ |
| |
| if (U_FAILURE(*err) || (args->source == args->sourceLimit)) |
| return; |
| |
| sourceStart = args->source; |
| changeState_2022(args->converter, |
| &(args->source), |
| args->sourceLimit, |
| args->flush, |
| err); |
| myOffset += args->source - sourceStart; |
| |
| }while(mySourceLimit != args->sourceLimit); |
| |
| return; |
| } |
| |
| /******************************* END *****************************/ |
| |
| |
| U_CFUNC UChar32 T_UConverter_getNextUChar_ISO_2022(UConverterToUnicodeArgs* args, |
| UErrorCode* err) |
| { |
| const char* mySourceLimit; |
| /*Arguments Check*/ |
| if (args->sourceLimit < args->source){ |
| *err = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0xffff; |
| } |
| |
| do{ |
| |
| mySourceLimit = getEndOfBuffer_2022(args->source, args->sourceLimit, TRUE); |
| /*Find the end of the buffer e.g : Next Escape Seq | end of Buffer*/ |
| if (args->converter->mode == UCNV_SO) /*Already doing some conversion*/{ |
| |
| return ucnv_getNextUChar(((UConverterDataISO2022*)(args->converter->extraInfo))->currentConverter, |
| &(args->source), |
| mySourceLimit, |
| err); |
| } |
| /*-Done with buffer with entire buffer |
| *-Error while converting |
| */ |
| changeState_2022(args->converter, |
| &(args->source), |
| args->sourceLimit, |
| TRUE, |
| err); |
| }while(args->source < args->sourceLimit); |
| |
| return 0xffff; |
| } |
| |
| static const UConverterImpl _ISO2022Impl={ |
| UCNV_ISO_2022, |
| |
| NULL, |
| NULL, |
| |
| _ISO2022Open, |
| _ISO2022Close, |
| _ISO2022Reset, |
| |
| T_UConverter_toUnicode_ISO_2022, |
| T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC, |
| T_UConverter_fromUnicode_ISO_2022, |
| T_UConverter_fromUnicode_ISO_2022_OFFSETS_LOGIC, |
| T_UConverter_getNextUChar_ISO_2022, |
| |
| NULL |
| }; |
| |
| const UConverterStaticData _ISO2022StaticData={ |
| sizeof(UConverterStaticData), |
| "ISO_2022", |
| 2022, UCNV_IBM, UCNV_ISO_2022, 1, 4, |
| 1, { 0x1a, 0, 0, 0 }, FALSE, FALSE, |
| { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} /* reserved */ |
| }; |
| |
| |
| const UConverterSharedData _ISO2022Data={ |
| sizeof(UConverterSharedData), ~((uint32_t) 0), |
| NULL, NULL, &_ISO2022StaticData, FALSE, &_ISO2022Impl, |
| 0 |
| }; |
| |
| /* EBCDICStateful ----------------------------------------------------------- */ |
| |
| U_CFUNC void |
| _DBCSLoad(UConverterSharedData *sharedData, const uint8_t *raw, UErrorCode *pErrorCode); |
| |
| U_CFUNC void |
| _DBCSUnload(UConverterSharedData *sharedData); |
| |
| U_CFUNC void T_UConverter_toUnicode_EBCDIC_STATEFUL (UConverterToUnicodeArgs *args, |
| UErrorCode * err) |
| { |
| char *mySource = (char *) args->source; |
| UChar *myTarget = args->target; |
| int32_t mySourceIndex = 0; |
| int32_t myTargetIndex = 0; |
| int32_t targetLength = args->targetLimit - args->target; |
| int32_t sourceLength = args->sourceLimit - args->source; |
| CompactShortArray *myToUnicode = NULL; |
| UChar targetUniChar = 0x0000; |
| UChar mySourceChar = 0x0000; |
| int32_t myMode = args->converter->mode; |
| |
| myToUnicode = &(args->converter->sharedData->table->dbcs.toUnicode); |
| while (mySourceIndex < sourceLength) |
| { |
| if (myTargetIndex < targetLength) |
| { |
| /*gets the corresponding UniChar */ |
| mySourceChar = (unsigned char) (args->source[mySourceIndex++]); |
| if (mySourceChar == UCNV_SI) myMode = UCNV_SI; |
| else if (mySourceChar == UCNV_SO) myMode = UCNV_SO; |
| else if ((myMode == UCNV_SO) && |
| (args->converter->toUnicodeStatus == 0x00)) |
| { |
| args->converter->toUnicodeStatus = (unsigned char) mySourceChar; |
| } |
| else |
| { |
| /*In case there is a state, we update the source char |
| *by concatenating the previous char with the current |
| *one |
| */ |
| if (args->converter->toUnicodeStatus != 0x00) |
| { |
| mySourceChar |= (UChar) (args->converter->toUnicodeStatus << 8); |
| args->converter->toUnicodeStatus = 0x00; |
| } |
| else mySourceChar &= 0x00FF; |
| |
| /*gets the corresponding Unicode codepoint */ |
| targetUniChar = (UChar) ucmp16_getu (myToUnicode, mySourceChar); |
| |
| /*writing the UniChar to the output stream */ |
| if (targetUniChar < 0xfffe) |
| { |
| /*writes the UniChar to the output stream */ |
| args->target[myTargetIndex++] = targetUniChar; |
| } |
| |
| else |
| { |
| const char* saveSource = args->source; |
| UChar* saveTarget = args->target; |
| int32_t *saveOffsets = args->offsets; |
| UConverterCallbackReason reason; |
| |
| if (targetUniChar == 0xfffe) |
| { |
| reason = UCNV_UNASSIGNED; |
| *err = U_INVALID_CHAR_FOUND; |
| } |
| else |
| { |
| reason = UCNV_ILLEGAL; |
| *err = U_ILLEGAL_CHAR_FOUND; |
| } |
| |
| if (mySourceChar > 0xff) |
| { |
| args->converter->invalidCharLength = 2; |
| args->converter->invalidCharBuffer[0] = (char) (mySourceChar >> 8); |
| args->converter->invalidCharBuffer[1] = (char) mySourceChar; |
| } |
| else |
| { |
| args->converter->invalidCharLength = 1; |
| args->converter->invalidCharBuffer[0] = (char) mySourceChar; |
| } |
| args->converter->mode = myMode; |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| ToU_CALLBACK_MACRO(args->converter->toUContext, |
| args, |
| args->converter->invalidCharBuffer, |
| args->converter->invalidCharLength, |
| reason, |
| err); |
| |
| myMode = args->converter->mode; |
| args->source = saveSource; |
| args->target = saveTarget; |
| args->offsets = saveOffsets; |
| myMode = args->converter->mode; |
| if (U_FAILURE (*err)) break; |
| args->converter->invalidCharLength = 0; |
| } |
| } |
| } |
| else |
| { |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| |
| /*If at the end of conversion we are still carrying state information |
| *flush is TRUE, we can deduce that the input stream is truncated |
| */ |
| if (args->converter->toUnicodeStatus |
| && (mySourceIndex == sourceLength) |
| && (args->flush == TRUE)) |
| { |
| if (U_SUCCESS(*err)) |
| { |
| *err = U_TRUNCATED_CHAR_FOUND; |
| args->converter->toUnicodeStatus = 0x00; |
| } |
| } |
| |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| args->converter->mode = myMode; |
| |
| return; |
| } |
| |
| U_CFUNC void T_UConverter_toUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC (UConverterToUnicodeArgs * args, |
| UErrorCode * err) |
| { |
| char *mySource = (char *) args->source; |
| UChar *myTarget = args->target; |
| int32_t mySourceIndex = 0; |
| int32_t myTargetIndex = 0; |
| int32_t targetLength = args->targetLimit - args->target; |
| int32_t sourceLength = args->sourceLimit - args->source; |
| CompactShortArray *myToUnicode = NULL; |
| UChar targetUniChar = 0x0000; |
| UChar mySourceChar = 0x0000; |
| int32_t myMode = args->converter->mode; |
| |
| myToUnicode = &args->converter->sharedData->table->dbcs.toUnicode; |
| |
| while (mySourceIndex < sourceLength) |
| { |
| if (myTargetIndex < targetLength) |
| { |
| /*gets the corresponding UniChar */ |
| mySourceChar = (unsigned char) (args->source[mySourceIndex++]); |
| if (mySourceChar == UCNV_SI) myMode = UCNV_SI; |
| else if (mySourceChar == UCNV_SO) myMode = UCNV_SO; |
| else if ((myMode == UCNV_SO) && |
| (args->converter->toUnicodeStatus == 0x00)) |
| { |
| args->converter->toUnicodeStatus = (unsigned char) mySourceChar; |
| } |
| else |
| { |
| /*In case there is a state, we update the source char |
| *by concatenating the previous char with the current |
| *one |
| */ |
| if (args->converter->toUnicodeStatus != 0x00) |
| { |
| mySourceChar |= (UChar) (args->converter->toUnicodeStatus << 8); |
| args->converter->toUnicodeStatus = 0x00; |
| } |
| else mySourceChar &= 0x00FF; |
| |
| /*gets the corresponding Unicode codepoint */ |
| targetUniChar = (UChar) ucmp16_getu (myToUnicode, mySourceChar); |
| |
| /*writing the UniChar to the output stream */ |
| if (targetUniChar < 0xfffe) |
| { |
| /*writes the UniChar to the output stream */ |
| { |
| if(myMode == UCNV_SO) |
| args->offsets[myTargetIndex] = mySourceIndex-2; /* double byte */ |
| else |
| args->offsets[myTargetIndex] = mySourceIndex-1; /* single byte */ |
| } |
| args->target[myTargetIndex++] = targetUniChar; |
| } |
| else |
| { |
| int32_t currentOffset = args->offsets[myTargetIndex-1] + 2;/* Because mySourceIndex was already incremented */ |
| int32_t My_i = myTargetIndex; |
| const char* saveSource = args->source; |
| UChar* saveTarget = args->target; |
| int32_t *saveOffsets = args->offsets; |
| UConverterCallbackReason reason; |
| |
| if (targetUniChar == 0xfffe) |
| { |
| reason = UCNV_UNASSIGNED; |
| *err = U_INVALID_CHAR_FOUND; |
| } |
| else |
| { |
| reason = UCNV_ILLEGAL; |
| *err = U_ILLEGAL_CHAR_FOUND; |
| } |
| |
| if (mySourceChar > 0xFF) |
| { |
| args->converter->invalidCharLength = 2; |
| args->converter->invalidCharBuffer[0] = (char) (mySourceChar >> 8); |
| args->converter->invalidCharBuffer[1] = (char) mySourceChar; |
| } |
| else |
| { |
| args->converter->invalidCharLength = 1; |
| args->converter->invalidCharBuffer[0] = (char) mySourceChar; |
| } |
| args->converter->mode = myMode; |
| |
| args->target = args->target + myTargetIndex; |
| args->source = args->source + mySourceIndex; |
| args->offsets = args->offsets?args->offsets+myTargetIndex:0; |
| /* call back handles the offset array */ |
| ToU_CALLBACK_OFFSETS_LOGIC_MACRO(args->converter->toUContext, |
| args, |
| args->source, |
| 1, |
| reason, |
| err); |
| |
| args->source = saveSource; |
| args->target = saveTarget; |
| myMode = args->converter->mode; |
| if (U_FAILURE (*err)) break; |
| args->converter->invalidCharLength = 0; |
| myMode = args->converter->mode; |
| } |
| } |
| } |
| else |
| { |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| |
| /*If at the end of conversion we are still carrying state information |
| *flush is TRUE, we can deduce that the input stream is truncated |
| */ |
| if (args->converter->toUnicodeStatus |
| && (mySourceIndex == sourceLength) |
| && (args->flush == TRUE)) |
| { |
| if (U_SUCCESS(*err)) |
| { |
| *err = U_TRUNCATED_CHAR_FOUND; |
| args->converter->toUnicodeStatus = 0x00; |
| } |
| } |
| |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| args->converter->mode = myMode; |
| |
| return; |
| } |
| |
| U_CFUNC void T_UConverter_fromUnicode_EBCDIC_STATEFUL (UConverterFromUnicodeArgs * args, |
| UErrorCode * err) |
| |
| { |
| const UChar *mySource = args->source; |
| unsigned char *myTarget = (unsigned char *) args->target; |
| int32_t mySourceIndex = 0; |
| int32_t myTargetIndex = 0; |
| int32_t targetLength = args->targetLimit - args->target; |
| int32_t sourceLength = args->sourceLimit - args->source; |
| CompactShortArray *myFromUnicode = NULL; |
| UChar targetUniChar = 0x0000; |
| UChar mySourceChar = 0x0000; |
| UBool isTargetUCharDBCS = (UBool)args->converter->fromUnicodeStatus; |
| UBool oldIsTargetUCharDBCS = isTargetUCharDBCS; |
| |
| myFromUnicode = &args->converter->sharedData->table->dbcs.fromUnicode; |
| /*writing the char to the output stream */ |
| while (mySourceIndex < sourceLength) |
| { |
| if (myTargetIndex < targetLength) |
| { |
| mySourceChar = (UChar) args->source[mySourceIndex++]; |
| targetUniChar = (UChar) ucmp16_getu (myFromUnicode, mySourceChar); |
| oldIsTargetUCharDBCS = isTargetUCharDBCS; |
| isTargetUCharDBCS = (UBool)(targetUniChar>0x00FF); |
| |
| if (targetUniChar != missingCharMarker) |
| { |
| if (oldIsTargetUCharDBCS != isTargetUCharDBCS) |
| { |
| if (isTargetUCharDBCS) args->target[myTargetIndex++] = UCNV_SO; |
| else args->target[myTargetIndex++] = UCNV_SI; |
| |
| |
| if ((!isTargetUCharDBCS)&&(myTargetIndex+1 >= targetLength)) |
| { |
| args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (char) targetUniChar; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| else if (myTargetIndex+1 >= targetLength) |
| { |
| args->converter->charErrorBuffer[0] = (char) (targetUniChar >> 8); |
| args->converter->charErrorBuffer[1] = (char)(targetUniChar & 0x00FF); |
| args->converter->charErrorBufferLength = 2; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| } |
| |
| if (!isTargetUCharDBCS) |
| { |
| args->target[myTargetIndex++] = (char) targetUniChar; |
| } |
| else |
| { |
| args->target[myTargetIndex++] = (char) (targetUniChar >> 8); |
| if (myTargetIndex < targetLength) |
| { |
| args->target[myTargetIndex++] = (char) targetUniChar; |
| } |
| else |
| { |
| args->converter->charErrorBuffer[0] = (char) targetUniChar; |
| args->converter->charErrorBufferLength = 1; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| } |
| else |
| { |
| const UChar* saveSource = args->source; |
| char* saveTarget = args->target; |
| int32_t *saveOffsets = args->offsets; |
| |
| isTargetUCharDBCS = oldIsTargetUCharDBCS; |
| *err = U_INVALID_CHAR_FOUND; |
| args->converter->invalidUCharBuffer[0] = (UChar) mySourceChar; |
| args->converter->invalidUCharLength = 1; |
| |
| args->converter->fromUnicodeStatus = (int32_t)isTargetUCharDBCS; |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| FromU_CALLBACK_MACRO(args->converter->fromUContext, |
| args, |
| args->converter->invalidUCharBuffer, |
| 1, |
| (UChar32) mySourceChar, |
| UCNV_UNASSIGNED, |
| err); |
| args->source = saveSource; |
| args->target = saveTarget; |
| args->offsets = saveOffsets; |
| isTargetUCharDBCS = (UBool) args->converter->fromUnicodeStatus; |
| if (U_FAILURE (*err)) break; |
| args->converter->invalidUCharLength = 0; |
| } |
| } |
| else |
| { |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| } |
| |
| |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| |
| args->converter->fromUnicodeStatus = (int32_t)isTargetUCharDBCS; |
| |
| return; |
| } |
| |
| U_CFUNC void T_UConverter_fromUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args, |
| UErrorCode * err) |
| |
| { |
| const UChar *mySource = args->source; |
| unsigned char *myTarget = (unsigned char *) args->target; |
| int32_t mySourceIndex = 0; |
| int32_t myTargetIndex = 0; |
| int32_t targetLength = args->targetLimit - args->target; |
| int32_t sourceLength = args->sourceLimit - args->source; |
| CompactShortArray *myFromUnicode = NULL; |
| UChar targetUniChar = 0x0000; |
| UChar mySourceChar = 0x0000; |
| UBool isTargetUCharDBCS = (UBool)args->converter->fromUnicodeStatus; |
| UBool oldIsTargetUCharDBCS = isTargetUCharDBCS; |
| |
| myFromUnicode = &args->converter->sharedData->table->dbcs.fromUnicode; |
| /*writing the char to the output stream */ |
| while (mySourceIndex < sourceLength) |
| { |
| if (myTargetIndex < targetLength) |
| { |
| mySourceChar = (UChar) args->source[mySourceIndex++]; |
| targetUniChar = (UChar) ucmp16_getu (myFromUnicode, mySourceChar); |
| oldIsTargetUCharDBCS = isTargetUCharDBCS; |
| isTargetUCharDBCS =(UBool) (targetUniChar>0x00FF); |
| |
| if (targetUniChar != missingCharMarker) |
| { |
| if (oldIsTargetUCharDBCS != isTargetUCharDBCS) |
| { |
| args->offsets[myTargetIndex] = mySourceIndex-1; |
| if (isTargetUCharDBCS) args->target[myTargetIndex++] = UCNV_SO; |
| else args->target[myTargetIndex++] = UCNV_SI; |
| |
| |
| if ((!isTargetUCharDBCS)&&(myTargetIndex+1 >= targetLength)) |
| { |
| args->converter->charErrorBuffer[0] = (char) targetUniChar; |
| args->converter->charErrorBufferLength = 1; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| else if (myTargetIndex+1 >= targetLength) |
| { |
| args->converter->charErrorBuffer[0] = (char) (targetUniChar >> 8); |
| args->converter->charErrorBuffer[1] = (char) (targetUniChar & 0x00FF); |
| args->converter->charErrorBufferLength = 2; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| |
| if (!isTargetUCharDBCS) |
| { |
| args->offsets[myTargetIndex] = mySourceIndex-1; |
| args->target[myTargetIndex++] = (char) targetUniChar; |
| } |
| else |
| { |
| args->offsets[myTargetIndex] = mySourceIndex-1; |
| args->target[myTargetIndex++] = (char) (targetUniChar >> 8); |
| if (myTargetIndex < targetLength) |
| { |
| args->offsets[myTargetIndex] = mySourceIndex-1; |
| args->target[myTargetIndex++] = (char) targetUniChar; |
| } |
| else |
| { |
| args->converter->charErrorBuffer[0] = (char) targetUniChar; |
| args->converter->charErrorBufferLength = 1; |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| } |
| } |
| else |
| { |
| int32_t currentOffset = args->offsets[myTargetIndex-1]+1; |
| char * saveTarget = args->target; |
| const UChar* saveSource = args->source; |
| int32_t *saveOffsets = args->offsets; |
| *err = U_INVALID_CHAR_FOUND; |
| args->converter->invalidUCharBuffer[0] = (UChar) mySourceChar; |
| args->converter->invalidUCharLength = 1; |
| |
| /* Breaks out of the loop since behaviour was set to stop */ |
| args->converter->fromUnicodeStatus = (int32_t)isTargetUCharDBCS; |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| args->offsets = args->offsets?args->offsets+myTargetIndex:0; |
| FromU_CALLBACK_OFFSETS_LOGIC_MACRO(args->converter->fromUContext, |
| args, |
| args->converter->invalidUCharBuffer, |
| 1, |
| (UChar32)mySourceChar, |
| UCNV_UNASSIGNED, |
| err); |
| isTargetUCharDBCS = (UBool)(args->converter->fromUnicodeStatus); |
| args->source = saveSource; |
| args->target = saveTarget; |
| args->offsets = saveOffsets; |
| isTargetUCharDBCS = (UBool)(args->converter->fromUnicodeStatus); |
| if (U_FAILURE (*err)) break; |
| args->converter->invalidUCharLength = 0; |
| } |
| } |
| else |
| { |
| *err = U_BUFFER_OVERFLOW_ERROR; |
| break; |
| } |
| |
| } |
| |
| |
| args->target += myTargetIndex; |
| args->source += mySourceIndex; |
| |
| args->converter->fromUnicodeStatus = (int32_t)isTargetUCharDBCS; |
| |
| return; |
| } |
| |
| U_CFUNC UChar32 T_UConverter_getNextUChar_EBCDIC_STATEFUL(UConverterToUnicodeArgs* args, |
| UErrorCode* err) |
| { |
| UChar myUChar; |
| char const *sourceInitial = args->source; |
| /*safe keeps a ptr to the beginning in case we need to step back*/ |
| |
| /*Input boundary check*/ |
| if (args->source >= args->sourceLimit) |
| { |
| *err = U_INDEX_OUTOFBOUNDS_ERROR; |
| return 0xffff; |
| } |
| |
| /*Checks to see if with have SI/SO shifters |
| if we do we change the mode appropriately and we consume the byte*/ |
| while ((*(args->source) == UCNV_SI) || (*(args->source) == UCNV_SO)) |
| { |
| args->converter->mode = *(args->source); |
| args->source++; |
| sourceInitial = args->source; |
| |
| /*Rechecks boundary after consuming the shift sequence*/ |
| if (args->source >= args->sourceLimit) |
| { |
| *err = U_INDEX_OUTOFBOUNDS_ERROR; |
| return 0xffff; |
| } |
| } |
| |
| if (args->converter->mode == UCNV_SI) |
| { |
| myUChar = ucmp16_getu( (&(args->converter->sharedData->table->dbcs.toUnicode)), |
| ((UChar)(uint8_t)(*(args->source)))); |
| args->source++; |
| } |
| else |
| { |
| /*Lead byte: we Build the codepoint and get the corresponding character |
| * and update the source ptr*/ |
| if ((args->source + 2) > args->sourceLimit) |
| { |
| *err = U_TRUNCATED_CHAR_FOUND; |
| return 0xffff; |
| } |
| |
| myUChar = ucmp16_getu( (&(args->converter->sharedData->table->dbcs.toUnicode)), |
| (((UChar)(uint8_t)((*(args->source))) << 8) |((uint8_t)*(args->source+1))) ); |
| |
| args->source += 2; |
| } |
| |
| if (myUChar < 0xfffe) return myUChar; |
| else |
| { |
| /* HSYS: Check logic here */ |
| UChar* myUCharPtr = &myUChar; |
| UConverterCallbackReason reason; |
| |
| if (myUChar == 0xfffe) |
| { |
| reason = UCNV_UNASSIGNED; |
| *err = U_INVALID_CHAR_FOUND; |
| } |
| else |
| { |
| reason = UCNV_ILLEGAL; |
| *err = U_ILLEGAL_CHAR_FOUND; |
| } |
| |
| /*It's is very likely that the ErrorFunctor will write to the |
| *internal buffers */ |
| args->target = myUCharPtr; |
| args->targetLimit = myUCharPtr + 1; |
| |
| args->converter->fromCharErrorBehaviour(args->converter->toUContext, |
| args, |
| sourceInitial, |
| args->source - sourceInitial, |
| reason, |
| err); |
| |
| /*makes the internal caching transparent to the user*/ |
| if (*err == U_BUFFER_OVERFLOW_ERROR) *err = U_ZERO_ERROR; |
| |
| return myUChar; |
| } |
| } |
| |
| static const UConverterImpl _EBCDICStatefulImpl={ |
| UCNV_EBCDIC_STATEFUL, |
| |
| _DBCSLoad, |
| _DBCSUnload, |
| |
| NULL, |
| NULL, |
| NULL, |
| |
| T_UConverter_toUnicode_EBCDIC_STATEFUL, |
| T_UConverter_toUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC, |
| T_UConverter_fromUnicode_EBCDIC_STATEFUL, |
| T_UConverter_fromUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC, |
| T_UConverter_getNextUChar_EBCDIC_STATEFUL, |
| |
| NULL |
| }; |
| |
| /* Static data is in tools/makeconv/ucnvstat.c for data-based |
| * converters. Be sure to update it as well. |
| */ |
| |
| const UConverterSharedData _EBCDICStatefulData={ |
| sizeof(UConverterSharedData), 1, |
| NULL, NULL, NULL, FALSE, &_EBCDICStatefulImpl, |
| 0 |
| }; |
| |
