#include "unicode/utypes.h"
#if !UCONFIG_NO_LEGACY_CONVERSION
#include "cmemory.h"
#include "unicode/ucnv_err.h"
#include "ucnv_bld.h"
#include "unicode/ucnv.h"
#include "ucnv_cnv.h"
#define ULMBCS_CHARSIZE_MAX 3
#define ULMBCS_C0END 0x1F
#define ULMBCS_C1START 0x80
typedef uint8_t ulmbcs_byte_t;
#define ULMBCS_GRP_L1 0x01
#define ULMBCS_GRP_GR 0x02
#define ULMBCS_GRP_HE 0x03
#define ULMBCS_GRP_AR 0x04
#define ULMBCS_GRP_RU 0x05
#define ULMBCS_GRP_L2 0x06
#define ULMBCS_GRP_TR 0x08
#define ULMBCS_GRP_TH 0x0B
#define ULMBCS_GRP_JA 0x10
#define ULMBCS_GRP_KO 0x11
#define ULMBCS_GRP_TW 0x12
#define ULMBCS_GRP_CN 0x13
#define ULMBCS_DOUBLEOPTGROUP_START 0x10
#define ULMBCS_HT 0x09
#define ULMBCS_LF 0x0A
#define ULMBCS_CR 0x0D
#define ULMBCS_123SYSTEMRANGE 0x19
#define ULMBCS_GRP_CTRL 0x0F
#define ULMBCS_CTRLOFFSET 0x20
#define ULMBCS_GRP_EXCEPT 0x00
#define ULMBCS_GRP_UNICODE 0x14
#define ULMBCS_UNICOMPATZERO 0xF6
#define ULMBCS_UNICODE_SIZE 3
#define ULMBCS_DEFAULTOPTGROUP 0x1
static const char * const OptGroupByteToCPName[ULMBCS_CTRLOFFSET] = {
"lmb-excp",
"ibm-850",
"ibm-851",
"windows-1255",
"windows-1256",
"windows-1251",
"ibm-852",
NULL,
"windows-1254",
NULL,
NULL,
"windows-874",
NULL,
NULL,
NULL,
NULL,
"windows-932",
"windows-949",
"windows-950",
"windows-936"
};
#define ULMBCS_GRP_LAST 0x13
#define ULMBCS_AMBIGUOUS_SBCS 0x80
#define ULMBCS_AMBIGUOUS_MBCS 0x81
#define ULMBCS_AMBIGUOUS_MATCH(agroup, xgroup) \
((((agroup) == ULMBCS_AMBIGUOUS_SBCS) && \
(xgroup) < ULMBCS_DOUBLEOPTGROUP_START) || \
(((agroup) == ULMBCS_AMBIGUOUS_MBCS) && \
(xgroup) >= ULMBCS_DOUBLEOPTGROUP_START))
static const struct _UniLMBCSGrpMap
{
const UChar uniStartRange;
const UChar uniEndRange;
const ulmbcs_byte_t GrpType;
} UniLMBCSGrpMap[]
=
{
{0x0001, 0x001F, ULMBCS_GRP_CTRL},
{0x0080, 0x009F, ULMBCS_GRP_CTRL},
{0x00A0, 0x01CD, ULMBCS_AMBIGUOUS_SBCS},
{0x01CE, 0x01CE, ULMBCS_GRP_TW },
{0x01CF, 0x02B9, ULMBCS_AMBIGUOUS_SBCS},
{0x02BA, 0x02BA, ULMBCS_GRP_CN},
{0x02BC, 0x02C8, ULMBCS_AMBIGUOUS_SBCS},
{0x02C9, 0x02D0, ULMBCS_AMBIGUOUS_MBCS},
{0x02D8, 0x02DD, ULMBCS_AMBIGUOUS_SBCS},
{0x0384, 0x03CE, ULMBCS_AMBIGUOUS_SBCS},
{0x0400, 0x044E, ULMBCS_GRP_RU},
{0x044F, 0x044F, ULMBCS_AMBIGUOUS_MBCS},
{0x0450, 0x0491, ULMBCS_GRP_RU},
{0x05B0, 0x05F2, ULMBCS_GRP_HE},
{0x060C, 0x06AF, ULMBCS_GRP_AR},
{0x0E01, 0x0E5B, ULMBCS_GRP_TH},
{0x200C, 0x200F, ULMBCS_AMBIGUOUS_SBCS},
{0x2010, 0x2010, ULMBCS_AMBIGUOUS_MBCS},
{0x2013, 0x2015, ULMBCS_AMBIGUOUS_SBCS},
{0x2016, 0x2016, ULMBCS_AMBIGUOUS_MBCS},
{0x2017, 0x2024, ULMBCS_AMBIGUOUS_SBCS},
{0x2025, 0x2025, ULMBCS_AMBIGUOUS_MBCS},
{0x2026, 0x2026, ULMBCS_AMBIGUOUS_SBCS},
{0x2027, 0x2027, ULMBCS_GRP_CN},
{0x2030, 0x2033, ULMBCS_AMBIGUOUS_SBCS},
{0x2035, 0x2035, ULMBCS_AMBIGUOUS_MBCS},
{0x2039, 0x203A, ULMBCS_AMBIGUOUS_SBCS},
{0x203B, 0x203B, ULMBCS_AMBIGUOUS_MBCS},
{0x2074, 0x2074, ULMBCS_GRP_KO},
{0x207F, 0x207F, ULMBCS_GRP_EXCEPT},
{0x2081, 0x2084, ULMBCS_GRP_KO},
{0x20A4, 0x20AC, ULMBCS_AMBIGUOUS_SBCS},
{0x2103, 0x2109, ULMBCS_AMBIGUOUS_MBCS},
{0x2111, 0x2126, ULMBCS_AMBIGUOUS_SBCS},
{0x212B, 0x212B, ULMBCS_AMBIGUOUS_MBCS},
{0x2135, 0x2135, ULMBCS_AMBIGUOUS_SBCS},
{0x2153, 0x2154, ULMBCS_GRP_KO},
{0x215B, 0x215E, ULMBCS_GRP_EXCEPT},
{0x2160, 0x2179, ULMBCS_AMBIGUOUS_MBCS},
{0x2190, 0x2195, ULMBCS_GRP_EXCEPT},
{0x2196, 0x2199, ULMBCS_AMBIGUOUS_MBCS},
{0x21A8, 0x21A8, ULMBCS_GRP_EXCEPT},
{0x21B8, 0x21B9, ULMBCS_GRP_CN},
{0x21D0, 0x21D5, ULMBCS_GRP_EXCEPT},
{0x21E7, 0x21E7, ULMBCS_GRP_CN},
{0x2200, 0x220B, ULMBCS_GRP_EXCEPT},
{0x220F, 0x2215, ULMBCS_AMBIGUOUS_MBCS},
{0x2219, 0x2220, ULMBCS_GRP_EXCEPT},
{0x2223, 0x2228, ULMBCS_AMBIGUOUS_MBCS},
{0x2229, 0x222B, ULMBCS_GRP_EXCEPT},
{0x222C, 0x223D, ULMBCS_AMBIGUOUS_MBCS},
{0x2245, 0x2248, ULMBCS_GRP_EXCEPT},
{0x224C, 0x224C, ULMBCS_GRP_TW},
{0x2252, 0x2252, ULMBCS_AMBIGUOUS_MBCS},
{0x2260, 0x2265, ULMBCS_GRP_EXCEPT},
{0x2266, 0x226F, ULMBCS_AMBIGUOUS_MBCS},
{0x2282, 0x2297, ULMBCS_GRP_EXCEPT},
{0x2299, 0x22BF, ULMBCS_AMBIGUOUS_MBCS},
{0x22C0, 0x22C0, ULMBCS_GRP_EXCEPT},
{0x2310, 0x2310, ULMBCS_GRP_EXCEPT},
{0x2312, 0x2312, ULMBCS_AMBIGUOUS_MBCS},
{0x2318, 0x2321, ULMBCS_GRP_EXCEPT},
{0x2318, 0x2321, ULMBCS_GRP_CN},
{0x2460, 0x24E9, ULMBCS_AMBIGUOUS_MBCS},
{0x2500, 0x2500, ULMBCS_AMBIGUOUS_SBCS},
{0x2501, 0x2501, ULMBCS_AMBIGUOUS_MBCS},
{0x2502, 0x2502, ULMBCS_AMBIGUOUS_SBCS},
{0x2503, 0x2503, ULMBCS_AMBIGUOUS_MBCS},
{0x2504, 0x2505, ULMBCS_GRP_TW},
{0x2506, 0x2665, ULMBCS_AMBIGUOUS_MBCS},
{0x2666, 0x2666, ULMBCS_GRP_EXCEPT},
{0x2666, 0x2666, ULMBCS_GRP_EXCEPT},
{0x2667, 0x2E7F, ULMBCS_AMBIGUOUS_SBCS},
{0x2E80, 0xF861, ULMBCS_AMBIGUOUS_MBCS},
{0xF862, 0xF8FF, ULMBCS_GRP_EXCEPT},
{0xF900, 0xFA2D, ULMBCS_AMBIGUOUS_MBCS},
{0xFB00, 0xFEFF, ULMBCS_AMBIGUOUS_SBCS},
{0xFF01, 0xFFEE, ULMBCS_AMBIGUOUS_MBCS},
{0xFFFF, 0xFFFF, ULMBCS_GRP_UNICODE}
};
static ulmbcs_byte_t
FindLMBCSUniRange(UChar uniChar)
{
const struct _UniLMBCSGrpMap * pTable = UniLMBCSGrpMap;
while (uniChar > pTable->uniEndRange)
{
pTable++;
}
if (uniChar >= pTable->uniStartRange)
{
return pTable->GrpType;
}
return ULMBCS_GRP_UNICODE;
}
static const struct _LocaleLMBCSGrpMap
{
const char *LocaleID;
const ulmbcs_byte_t OptGroup;
} LocaleLMBCSGrpMap[] =
{
{"ar", ULMBCS_GRP_AR},
{"be", ULMBCS_GRP_RU},
{"bg", ULMBCS_GRP_L2},
{"cs", ULMBCS_GRP_L2},
{"el", ULMBCS_GRP_GR},
{"he", ULMBCS_GRP_HE},
{"hu", ULMBCS_GRP_L2},
{"iw", ULMBCS_GRP_HE},
{"ja", ULMBCS_GRP_JA},
{"ko", ULMBCS_GRP_KO},
{"mk", ULMBCS_GRP_RU},
{"pl", ULMBCS_GRP_L2},
{"ro", ULMBCS_GRP_L2},
{"ru", ULMBCS_GRP_RU},
{"sh", ULMBCS_GRP_L2},
{"sk", ULMBCS_GRP_L2},
{"sl", ULMBCS_GRP_L2},
{"sq", ULMBCS_GRP_L2},
{"sr", ULMBCS_GRP_RU},
{"th", ULMBCS_GRP_TH},
{"tr", ULMBCS_GRP_TR},
{"uk", ULMBCS_GRP_RU},
{"zhTW", ULMBCS_GRP_TW},
{"zh", ULMBCS_GRP_CN},
{NULL, ULMBCS_GRP_L1}
};
static ulmbcs_byte_t
FindLMBCSLocale(const char *LocaleID)
{
const struct _LocaleLMBCSGrpMap *pTable = LocaleLMBCSGrpMap;
if ((!LocaleID) || (!*LocaleID))
{
return 0;
}
while (pTable->LocaleID)
{
if (*pTable->LocaleID == *LocaleID)
{
if (strncmp(pTable->LocaleID, LocaleID, strlen(pTable->LocaleID)) == 0)
return pTable->OptGroup;
}
else
if (*pTable->LocaleID > *LocaleID)
break;
pTable++;
}
return ULMBCS_GRP_L1;
}
#define DECLARE_LMBCS_DATA(n) \
static const UConverterImpl _LMBCSImpl##n={\
UCNV_LMBCS_##n,\
NULL,NULL,\
_LMBCSOpen##n,\
_LMBCSClose,\
NULL,\
_LMBCSToUnicodeWithOffsets,\
_LMBCSToUnicodeWithOffsets,\
_LMBCSFromUnicode,\
_LMBCSFromUnicode,\
_LMBCSGetNextUChar,\
NULL,\
NULL,\
NULL,\
NULL,\
ucnv_getCompleteUnicodeSet\
};\
static const UConverterStaticData _LMBCSStaticData##n={\
sizeof(UConverterStaticData),\
"LMBCS-" #n,\
0, UCNV_IBM, UCNV_LMBCS_##n, 1, 2,\
{ 0x3f, 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} \
};\
const UConverterSharedData _LMBCSData##n={\
sizeof(UConverterSharedData), ~((uint32_t) 0),\
NULL, NULL, &_LMBCSStaticData##n, FALSE, &_LMBCSImpl##n, \
0 \
};
#define DEFINE_LMBCS_OPEN(n) \
static void \
_LMBCSOpen##n(UConverter* _this,const char* name,const char* locale,uint32_t options,UErrorCode* err) \
{ _LMBCSOpenWorker(_this, name,locale,options, err, n);}
static void
_LMBCSOpenWorker(UConverter* _this,
const char* name,
const char* locale,
uint32_t options,
UErrorCode* err,
ulmbcs_byte_t OptGroup
)
{
UConverterDataLMBCS * extraInfo = (UConverterDataLMBCS*)uprv_malloc (sizeof (UConverterDataLMBCS));
if(extraInfo != NULL)
{
ulmbcs_byte_t i;
ulmbcs_byte_t imax;
imax = sizeof(extraInfo->OptGrpConverter)/sizeof(extraInfo->OptGrpConverter[0]);
for (i=0; i < imax; i++)
{
extraInfo->OptGrpConverter[i] =
(OptGroupByteToCPName[i] != NULL) ?
ucnv_open(OptGroupByteToCPName[i], err) : NULL;
}
extraInfo->OptGroup = OptGroup;
extraInfo->localeConverterIndex = FindLMBCSLocale(locale);
}
else
{
*err = U_MEMORY_ALLOCATION_ERROR;
}
_this->extraInfo = extraInfo;
}
static void
_LMBCSClose(UConverter * _this)
{
if (_this->extraInfo != NULL && !_this->isExtraLocal)
{
ulmbcs_byte_t Ix;
UConverterDataLMBCS * extraInfo = (UConverterDataLMBCS *) _this->extraInfo;
for (Ix=0; Ix < ULMBCS_GRP_UNICODE; Ix++)
{
if (extraInfo->OptGrpConverter[Ix] != NULL)
ucnv_close (extraInfo->OptGrpConverter[Ix]);
}
uprv_free (_this->extraInfo);
}
}
#if LMBCS_DEBUG
#define MyAssert(b) {if (!(b)) {*(char *)0 = 1;}}
#else
#define MyAssert(b)
#endif
static size_t
LMBCSConversionWorker (
UConverterDataLMBCS * extraInfo,
ulmbcs_byte_t group,
ulmbcs_byte_t * pStartLMBCS,
UChar * pUniChar,
ulmbcs_byte_t * lastConverterIndex,
UBool * groups_tried
)
{
ulmbcs_byte_t * pLMBCS = pStartLMBCS;
UConverter * xcnv = extraInfo->OptGrpConverter[group];
int bytesConverted;
uint32_t value;
ulmbcs_byte_t firstByte;
MyAssert(xcnv);
MyAssert(group<ULMBCS_GRP_UNICODE);
bytesConverted = _MBCSFromUChar32(xcnv->sharedData, *pUniChar, &value, FALSE);
switch(bytesConverted)
{
case 4:
firstByte = (ulmbcs_byte_t)(value >> 24);
break;
case 3:
firstByte = (ulmbcs_byte_t)(value >> 16);
break;
case 2:
firstByte = (ulmbcs_byte_t)(value >> 8);
break;
case 1:
firstByte = (ulmbcs_byte_t)value;
break;
default:
groups_tried[group] = TRUE;
return 0;
}
*lastConverterIndex = group;
MyAssert((firstByte <= ULMBCS_C0END) || (firstByte >= ULMBCS_C1START) || (group == ULMBCS_GRP_EXCEPT));
if (group != ULMBCS_GRP_EXCEPT && extraInfo->OptGroup != group)
{
*pLMBCS++ = group;
if (bytesConverted == 1 && group >= ULMBCS_DOUBLEOPTGROUP_START)
{
*pLMBCS++ = group;
}
}
if ( bytesConverted == 1 && firstByte < 0x20 )
return 0;
switch(bytesConverted)
{
case 4:
*pLMBCS++ = (ulmbcs_byte_t)(value >> 24);
case 3:
*pLMBCS++ = (ulmbcs_byte_t)(value >> 16);
case 2:
*pLMBCS++ = (ulmbcs_byte_t)(value >> 8);
case 1:
*pLMBCS++ = (ulmbcs_byte_t)value;
default:
break;
}
return (pLMBCS - pStartLMBCS);
}
static size_t
LMBCSConvertUni(ulmbcs_byte_t * pLMBCS, UChar uniChar)
{
uint8_t LowCh = (uint8_t)(uniChar & 0x00FF);
uint8_t HighCh = (uint8_t)(uniChar >> 8);
*pLMBCS++ = ULMBCS_GRP_UNICODE;
if (LowCh == 0)
{
*pLMBCS++ = ULMBCS_UNICOMPATZERO;
*pLMBCS++ = HighCh;
}
else
{
*pLMBCS++ = HighCh;
*pLMBCS++ = LowCh;
}
return ULMBCS_UNICODE_SIZE;
}
static void
_LMBCSFromUnicode(UConverterFromUnicodeArgs* args,
UErrorCode* err)
{
ulmbcs_byte_t lastConverterIndex = 0;
UChar uniChar;
ulmbcs_byte_t LMBCS[ULMBCS_CHARSIZE_MAX];
ulmbcs_byte_t * pLMBCS;
int bytes_written;
UBool groups_tried[ULMBCS_GRP_LAST+1];
UConverterDataLMBCS * extraInfo = (UConverterDataLMBCS *) args->converter->extraInfo;
int sourceIndex = 0;
while (args->source < args->sourceLimit && !U_FAILURE(*err))
{
if (args->target >= args->targetLimit)
{
*err = U_BUFFER_OVERFLOW_ERROR;
break;
}
uniChar = *(args->source);
bytes_written = 0;
pLMBCS = LMBCS;
if (((uniChar > ULMBCS_C0END) && (uniChar < ULMBCS_C1START)) ||
uniChar == 0 || uniChar == ULMBCS_HT || uniChar == ULMBCS_CR ||
uniChar == ULMBCS_LF || uniChar == ULMBCS_123SYSTEMRANGE
)
{
*pLMBCS++ = (ulmbcs_byte_t ) uniChar;
bytes_written = 1;
}
if (!bytes_written)
{
ulmbcs_byte_t group = FindLMBCSUniRange(uniChar);
if (group == ULMBCS_GRP_UNICODE)
{
pLMBCS += LMBCSConvertUni(pLMBCS,uniChar);
bytes_written = pLMBCS - LMBCS;
}
else if (group == ULMBCS_GRP_CTRL)
{
if (uniChar <= ULMBCS_C0END)
{
*pLMBCS++ = ULMBCS_GRP_CTRL;
*pLMBCS++ = (ulmbcs_byte_t)(ULMBCS_CTRLOFFSET + uniChar);
}
else if (uniChar >= ULMBCS_C1START && uniChar <= ULMBCS_C1START + ULMBCS_CTRLOFFSET)
{
*pLMBCS++ = ULMBCS_GRP_CTRL;
*pLMBCS++ = (ulmbcs_byte_t ) (uniChar & 0x00FF);
}
bytes_written = pLMBCS - LMBCS;
}
else if (group < ULMBCS_GRP_UNICODE)
{
bytes_written = LMBCSConversionWorker (
extraInfo, group, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
if (!bytes_written)
{
memset(groups_tried, 0, sizeof(groups_tried));
if (extraInfo->OptGroup != 1
&& ULMBCS_AMBIGUOUS_MATCH(group, extraInfo->OptGroup))
{
bytes_written = LMBCSConversionWorker (extraInfo,
extraInfo->OptGroup, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
if (!bytes_written
&& (extraInfo->localeConverterIndex)
&& (ULMBCS_AMBIGUOUS_MATCH(group, extraInfo->localeConverterIndex)))
{
bytes_written = LMBCSConversionWorker (extraInfo,
extraInfo->localeConverterIndex, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
if (!bytes_written
&& (lastConverterIndex)
&& (ULMBCS_AMBIGUOUS_MATCH(group, lastConverterIndex)))
{
bytes_written = LMBCSConversionWorker (extraInfo,
lastConverterIndex, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
if (!bytes_written)
{
ulmbcs_byte_t grp_start;
ulmbcs_byte_t grp_end;
ulmbcs_byte_t grp_ix;
grp_start = (ulmbcs_byte_t)((group == ULMBCS_AMBIGUOUS_MBCS)
? ULMBCS_DOUBLEOPTGROUP_START
: ULMBCS_GRP_L1);
grp_end = (ulmbcs_byte_t)((group == ULMBCS_AMBIGUOUS_MBCS)
? ULMBCS_GRP_LAST
: ULMBCS_GRP_TH);
for (grp_ix = grp_start;
grp_ix <= grp_end && !bytes_written;
grp_ix++)
{
if (extraInfo->OptGrpConverter [grp_ix] && !groups_tried [grp_ix])
{
bytes_written = LMBCSConversionWorker (extraInfo,
grp_ix, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
}
if (!bytes_written && grp_start == ULMBCS_GRP_L1)
{
bytes_written = LMBCSConversionWorker (extraInfo,
ULMBCS_GRP_EXCEPT, pLMBCS, &uniChar,
&lastConverterIndex, groups_tried);
}
}
if (!bytes_written)
{
pLMBCS += LMBCSConvertUni(pLMBCS, uniChar);
bytes_written = pLMBCS - LMBCS;
}
}
}
args->source++;
pLMBCS = LMBCS;
while (args->target < args->targetLimit && bytes_written--)
{
*(args->target)++ = *pLMBCS++;
if (args->offsets)
{
*(args->offsets)++ = sourceIndex;
}
}
sourceIndex++;
if (bytes_written > 0)
{
uint8_t * pErrorBuffer = args->converter->charErrorBuffer;
*err = U_BUFFER_OVERFLOW_ERROR;
args->converter->charErrorBufferLength = (int8_t)bytes_written;
while (bytes_written--)
{
*pErrorBuffer++ = *pLMBCS++;
}
}
}
}
#define ULMBCS_SKIP U_ERROR_LIMIT
#define ULMBCS_MULTI ULMBCS_SKIP+1
static UChar
GetUniFromLMBCSUni(char const ** ppLMBCSin)
{
uint8_t HighCh = *(*ppLMBCSin)++;
uint8_t LowCh = *(*ppLMBCSin)++;
if (HighCh == ULMBCS_UNICOMPATZERO )
{
HighCh = LowCh;
LowCh = 0;
}
return (UChar)((HighCh << 8) | LowCh);
}
#define CHECK_SOURCE_LIMIT(index) \
if (args->source+index > args->sourceLimit){\
*err = U_TRUNCATED_CHAR_FOUND;\
args->source = saveSource;\
return 0xffff;}
static UChar32
_LMBCSGetNextUCharWorker(UConverterToUnicodeArgs* args,
UErrorCode* err,
UBool returnUTF32)
{
UChar32 uniChar = 0;
ulmbcs_byte_t CurByte;
const char * saveSource;
if (args->source >= args->sourceLimit)
{
*err = U_ILLEGAL_ARGUMENT_ERROR;
return 0xffff;
}
CurByte = *((ulmbcs_byte_t *) (saveSource = args->source++));
if(((CurByte > ULMBCS_C0END) && (CurByte < ULMBCS_C1START))
|| (CurByte == 0)
|| CurByte == ULMBCS_HT || CurByte == ULMBCS_CR
|| CurByte == ULMBCS_LF || CurByte == ULMBCS_123SYSTEMRANGE)
{
uniChar = CurByte;
}
else
{
UConverterDataLMBCS * extraInfo;
ulmbcs_byte_t group;
UConverter* cnv;
if (CurByte == ULMBCS_GRP_CTRL)
{
ulmbcs_byte_t C0C1byte;
CHECK_SOURCE_LIMIT(1);
C0C1byte = *(args->source)++;
uniChar = (C0C1byte < ULMBCS_C1START) ? C0C1byte - ULMBCS_CTRLOFFSET : C0C1byte;
}
else
if (CurByte == ULMBCS_GRP_UNICODE)
{
UChar second;
CHECK_SOURCE_LIMIT(2);
uniChar = GetUniFromLMBCSUni(&(args->source));
if(returnUTF32 && UTF_IS_FIRST_SURROGATE(uniChar) && (args->source+3 <= args->sourceLimit)
&& *(args->source)++ == ULMBCS_GRP_UNICODE
&& UTF_IS_SECOND_SURROGATE(second = GetUniFromLMBCSUni(&(args->source))))
{
uniChar = UTF16_GET_PAIR_VALUE(uniChar, second);
}
}
else if (CurByte <= ULMBCS_CTRLOFFSET)
{
group = CurByte;
extraInfo = (UConverterDataLMBCS *) args->converter->extraInfo;
cnv = extraInfo->OptGrpConverter[group];
if (!cnv)
{
*err = U_INVALID_CHAR_FOUND;
}
else if (group >= ULMBCS_DOUBLEOPTGROUP_START)
{
CHECK_SOURCE_LIMIT(2);
if (*args->source == group) {
++args->source;
uniChar = _MBCSSimpleGetNextUChar(cnv->sharedData, &args->source, args->source + 1, FALSE);
} else {
const char *newLimit = args->source + 2;
uniChar = _MBCSSimpleGetNextUChar(cnv->sharedData, &args->source, newLimit, FALSE);
args->source = newLimit;
}
}
else {
CHECK_SOURCE_LIMIT(1);
CurByte = *(args->source)++;
if (CurByte >= ULMBCS_C1START)
{
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP(cnv->sharedData, CurByte);
}
else
{
const char *s;
char bytes[2];
extraInfo = (UConverterDataLMBCS *) args->converter->extraInfo;
cnv = extraInfo->OptGrpConverter [ULMBCS_GRP_EXCEPT];
bytes[0] = group;
bytes[1] = CurByte;
s = bytes;
uniChar = _MBCSSimpleGetNextUChar(cnv->sharedData, &s, bytes + 2, FALSE);
}
}
}
else if (CurByte >= ULMBCS_C1START)
{
extraInfo = (UConverterDataLMBCS *) args->converter->extraInfo;
group = extraInfo->OptGroup;
cnv = extraInfo->OptGrpConverter[group];
if (group >= ULMBCS_DOUBLEOPTGROUP_START)
{
if (!_MBCSIsLeadByte(cnv->sharedData, CurByte))
{
CHECK_SOURCE_LIMIT(0);
--args->source;
uniChar = _MBCSSimpleGetNextUChar(cnv->sharedData, &args->source, args->source + 1, FALSE);
}
else
{
CHECK_SOURCE_LIMIT(1);
--args->source;
uniChar = _MBCSSimpleGetNextUChar(cnv->sharedData, &args->source, args->source + 2, FALSE);
}
}
else
{
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP(cnv->sharedData, CurByte);
}
}
}
if (((uint32_t)uniChar - 0xfffe) <= 1)
{
UConverterToUnicodeArgs cbArgs = *args;
UConverterCallbackReason reason;
UChar UCh;
if (uniChar == 0xfffe)
{
reason = UCNV_UNASSIGNED;
*err = U_INVALID_CHAR_FOUND;
}
else
{
reason = UCNV_ILLEGAL;
*err = U_ILLEGAL_CHAR_FOUND;
}
cbArgs.target = &UCh;
cbArgs.targetLimit = &UCh + 1;
cbArgs.converter->fromCharErrorBehaviour(cbArgs.converter->toUContext,
&cbArgs,
saveSource,
args->source - saveSource,
reason,
err);
if (cbArgs.target != &UCh)
{
uniChar = (UChar32) UCh;
}
if (U_SUCCESS(*err) && cbArgs.target == &UCh)
{
*err = ULMBCS_SKIP;
}
else if (*err == U_BUFFER_OVERFLOW_ERROR)
{
*err = ULMBCS_MULTI;
}
}
return uniChar;
}
static UChar32
_LMBCSGetNextUChar(UConverterToUnicodeArgs* args,
UErrorCode* err)
{
UChar32 nextUChar;
do {
nextUChar = _LMBCSGetNextUCharWorker(args, err, TRUE);
} while (*err == ULMBCS_SKIP);
if (*err == ULMBCS_MULTI)
{
*err = U_ZERO_ERROR;
}
return nextUChar;
}
static void
_LMBCSToUnicodeWithOffsets(UConverterToUnicodeArgs* args,
UErrorCode* err)
{
UChar uniChar;
const char * saveSource = args->source;
const char * pStartLMBCS = args->source;
if (args->targetLimit == args->target)
{
*err = U_BUFFER_OVERFLOW_ERROR;
return;
}
while (!*err && args->sourceLimit > args->source && args->targetLimit > args->target)
{
saveSource = args->source;
if (args->converter->invalidCharLength)
{
char LMBCS [ULMBCS_CHARSIZE_MAX];
const char *pLMBCS = LMBCS, *saveSourceLimit;
size_t size_old = args->converter->invalidCharLength;
size_t size_new_maybe_1 = sizeof(LMBCS) - size_old;
size_t size_new_maybe_2 = args->sourceLimit - args->source;
size_t size_new = (size_new_maybe_1 < size_new_maybe_2) ? size_new_maybe_1 : size_new_maybe_2;
uprv_memcpy(LMBCS, args->converter->invalidCharBuffer, size_old);
uprv_memcpy(LMBCS + size_old, args->source, size_new);
saveSourceLimit = args->sourceLimit;
args->source = pLMBCS;
args->sourceLimit = pLMBCS+size_old+size_new;
uniChar = (UChar) _LMBCSGetNextUCharWorker(args, err, FALSE);
pLMBCS = args->source;
args->source =saveSource;
args->sourceLimit = saveSourceLimit;
args->source += (pLMBCS - LMBCS - size_old);
if (*err == U_TRUNCATED_CHAR_FOUND && !args->flush)
{
int8_t savebytes = (int8_t)(size_old+size_new);
args->converter->invalidCharLength = savebytes;
uprv_memcpy(args->converter->invalidCharBuffer, LMBCS, savebytes);
args->source = args->sourceLimit;
*err = U_ZERO_ERROR;
return;
}
else
{
args->converter->invalidCharLength = 0;
}
}
else
{
uniChar = (UChar) _LMBCSGetNextUCharWorker(args, err, FALSE);
}
if (U_SUCCESS(*err))
{
if (uniChar < 0xfffe)
{
*(args->target)++ = uniChar;
if(args->offsets)
{
*(args->offsets)++ = saveSource - pStartLMBCS;
}
}
else if (uniChar == 0xfffe)
{
*err = U_INVALID_CHAR_FOUND;
}
else
{
*err = U_ILLEGAL_CHAR_FOUND;
}
}
else if (*err == ULMBCS_MULTI)
{
UChar * pUChar = args->converter->UCharErrorBuffer;
int8_t BufferLength = args->converter->UCharErrorBufferLength;
*err = U_ZERO_ERROR;
do
{
*(args->target)++ = uniChar;
if(args->offsets)
{
*(args->offsets)++ = saveSource - pStartLMBCS;
}
uniChar = *pUChar++;
}
while(BufferLength-- && args->targetLimit > args->target);
if (++BufferLength > 0)
{
uprv_memmove( args->converter->UCharErrorBuffer,
args->converter->UCharErrorBuffer + args->converter->UCharErrorBufferLength - BufferLength,
sizeof(UChar) * BufferLength);
}
args->converter->UCharErrorBufferLength = BufferLength;
}
else if (*err == ULMBCS_SKIP)
{
*err = U_ZERO_ERROR;
}
}
if (U_SUCCESS(*err) && args->sourceLimit > args->source && args->targetLimit <= args->target)
{
*err = U_BUFFER_OVERFLOW_ERROR;
}
if (*err == U_TRUNCATED_CHAR_FOUND)
{
args->source = args->sourceLimit;
if (!args->flush )
{
int8_t savebytes = (int8_t)(args->sourceLimit - saveSource);
args->converter->invalidCharLength = (int8_t)savebytes;
uprv_memcpy(args->converter->invalidCharBuffer, saveSource, savebytes);
*err = U_ZERO_ERROR;
}
}
}
DEFINE_LMBCS_OPEN(1)
DEFINE_LMBCS_OPEN(2)
DEFINE_LMBCS_OPEN(3)
DEFINE_LMBCS_OPEN(4)
DEFINE_LMBCS_OPEN(5)
DEFINE_LMBCS_OPEN(6)
DEFINE_LMBCS_OPEN(8)
DEFINE_LMBCS_OPEN(11)
DEFINE_LMBCS_OPEN(16)
DEFINE_LMBCS_OPEN(17)
DEFINE_LMBCS_OPEN(18)
DEFINE_LMBCS_OPEN(19)
DECLARE_LMBCS_DATA(1)
DECLARE_LMBCS_DATA(2)
DECLARE_LMBCS_DATA(3)
DECLARE_LMBCS_DATA(4)
DECLARE_LMBCS_DATA(5)
DECLARE_LMBCS_DATA(6)
DECLARE_LMBCS_DATA(8)
DECLARE_LMBCS_DATA(11)
DECLARE_LMBCS_DATA(16)
DECLARE_LMBCS_DATA(17)
DECLARE_LMBCS_DATA(18)
DECLARE_LMBCS_DATA(19)
#endif