void MCExecPoint::dounicodetomultibyte(bool p_native, bool p_reverse)
{
const char *t_input;
t_input = getsvalue() . getstring();
uint4 t_input_length;
t_input_length = getsvalue() . getlength();
uint4 t_output_length;
if (p_reverse)
{
if (p_native)
MCS_multibytetounicode(t_input, t_input_length, NULL, 0, t_output_length, LCH_ROMAN);
else
t_output_length = UTF8ToUnicode(t_input, t_input_length, NULL, 0);
}
else
{
if (p_native)
MCS_unicodetomultibyte(t_input, t_input_length, NULL, 0, t_output_length, LCH_ROMAN);
else
t_output_length = UnicodeToUTF8((uint2 *)t_input, t_input_length, NULL, 0);
}
char *t_buffer;
uint4 t_buffer_length;
t_buffer_length = (t_output_length + EP_PAD) & EP_MASK;
t_buffer = new char[t_buffer_length];
if (p_reverse)
{
if (p_native)
MCS_multibytetounicode(t_input, t_input_length, t_buffer, t_output_length, t_output_length, LCH_ROMAN);
else
t_output_length = UTF8ToUnicode(t_input, t_input_length, (uint2 *)t_buffer, t_output_length);
}
else
{
if (p_native)
MCS_unicodetomultibyte(t_input, t_input_length, t_buffer, t_output_length, t_output_length, LCH_ROMAN);
else
t_output_length = UnicodeToUTF8((uint2 *)t_input, t_input_length, t_buffer, t_output_length);
}
delete buffer;
buffer = t_buffer;
size = t_buffer_length;
svalue . set(buffer, t_output_length);
}
void xstring_unicode_to_utf8(XScriptVM* vm)
{
CheckParam(string.unicodetoutf8, 0, str, OP_TYPE_STRING);
std::wstring s((wchar_t*)stringRawValue(&str));
std::string result = UnicodeToUTF8(s);
vm->setReturnAsStr(result.c_str());
}
void MGUI_Button::Click(void)
{
if(!m_bVisible || !m_bEnabled) return;
g_mgui_keynum = -1;
g_Next_Key_CanUse = g_flTime + 0.15;
if(m_iType == MGUI_BUTTON_TYPE_CHANGE_NAME)
{
char *name = ((MGUI_Panel *)pParent)->GetTextEntryText(1);
if(name)
{
char szCmd[64];
sprintf(szCmd,"name %s",UnicodeToUTF8(ANSIToUnicode(name)));
MGUI_Send_Cmd(szCmd);
}
}
else if(m_iType == MGUI_BUTTON_TYPE_COMMAND_CLOSEPANEL)
{
MGUI_Send_Cmd(pszCommand);
((MGUI_Panel *)pParent)->m_iClosing = 1;
}
else if(m_iType == MGUI_BUTTON_TYPE_CLOSEALL)
{
MGUI_Send_Cmd(pszCommand);
((MGUI_Panel *)pParent)->m_iClosing = 1;
g_mgui_candraw = 0;
}
else
{
MGUI_Send_Cmd(pszCommand);
}
}
/* Reads a directory entry from a directory. */
MVMString * MVM_dir_read(MVMThreadContext *tc, MVMObject *oshandle) {
MVMOSHandle *handle = get_dirhandle(tc, oshandle, "readdir");
MVMIODirIter *data = (MVMIODirIter *)handle->body.data;
#ifdef _WIN32
MVMString *result;
TCHAR dir[MAX_PATH];
WIN32_FIND_DATAW ffd;
char *dir_str;
if (data->dir_handle == INVALID_HANDLE_VALUE) {
HANDLE hFind = FindFirstFileW(data->dir_name, &ffd);
if (hFind == INVALID_HANDLE_VALUE) {
MVM_exception_throw_adhoc(tc, "read from dirhandle failed: %d", GetLastError());
}
data->dir_handle = hFind;
dir_str = UnicodeToUTF8(ffd.cFileName);
result = MVM_string_utf8_decode(tc, tc->instance->VMString, dir_str, strlen(dir_str));
MVM_free(dir_str);
return result;
}
else if (FindNextFileW(data->dir_handle, &ffd) != 0) {
dir_str = UnicodeToUTF8(ffd.cFileName);
result = MVM_string_decode(tc, tc->instance->VMString, dir_str, strlen(dir_str),
data->encoding);
MVM_free(dir_str);
return result;
} else {
return tc->instance->str_consts.empty;
}
#else
struct dirent entry;
struct dirent *result;
int ret;
ret = readdir_r(data->dir_handle, &entry, &result);
if (ret == 0) {
if (result == NULL)
return tc->instance->str_consts.empty;
return MVM_string_decode(tc, tc->instance->VMString, entry.d_name, strlen(entry.d_name), data->encoding);
}
MVM_exception_throw_adhoc(tc, "Failed to read dirhandle: %d", errno);
#endif
}
static char* ANSIToUTF8(MVMuint16 acp, const char* str)
{
wchar_t * const wstr = ANSIToUnicode(acp, str);
char * const result = UnicodeToUTF8(wstr);
free(wstr);
return result;
}
Json& Json::operator = (const WString& val) {
std::string target;
for(size_t i = 0; i < val.size(); ++i) {
target += UnicodeToUTF8(val[i]);
}
return operator = (target);
}
//将tagName字符串翻译为UTF8的字节流，即生成键的字节流
LPSTR ProduceNameString(LPWSTR tagName)
{
int dec,len=(int)wcslen(tagName),i,j,k;
List value=InitList();
LPSTR utf8,hex=(LPSTR)malloc(sizeof(char)*2);
LPWSTR charString=(LPWSTR)malloc(sizeof(wchar_t)*2);
*(charString+1)=0;
for(i=0;i<len;i++)
{
if (tagName[i] < 48 || tagName[i] > 57 && tagName[i] < 65 || tagName[i] > 90 && tagName[i] < 97 || tagName[i] > 122)
{
*charString=tagName[i];
utf8=UnicodeToUTF8(charString);
int templen=(int)strlen(utf8);
for(j=0;j<templen;j++)
{
dec = (unsigned char)*((LPSTR)utf8+j);
hex[0]=hex[1]=48;
k=1;
while (dec != 0)
{
switch (dec % 16)
{
case 0:hex[k]='0'; break;
case 1: hex[k]='1'; break;
case 2: hex[k]='2'; break;
case 3: hex[k]='3'; break;
case 4: hex[k]='4'; break;
case 5: hex[k]='5'; break;
case 6: hex[k]='6'; break;
case 7: hex[k]='7'; break;
case 8: hex[k]='8'; break;
case 9: hex[k]='9'; break;
case 10: hex[k]='A'; break;
case 11: hex[k]='B'; break;
case 12: hex[k]='C'; break;
case 13: hex[k]='D'; break;
case 14: hex[k]='E'; break;
case 15: hex[k]='F'; break;
}
dec /= 16;
k--;
}
AddNode(value,(void*)'#');
for(k=0;k<2;k++)
{
AddNode(value,(void*)hex[k]);
}
}
}
else
{
AddNode(value,(void*)tagName[i]);
}
}
return CharListGetString(value);
}
XString AnsiToUTF8(const char* str)
{
XString rs;
if (str && (::strlen(str) > 0))
{
CA2W input(str,CP_ACP);
rs = UnicodeToUTF8(input);
}
return rs;
}
void CDuiFrameWnd::Play( LPCTSTR pszPath )
{
if (! pszPath)
{
return;
}
m_strPath = pszPath;
if (m_cAVPlayer.Play(UnicodeToUTF8(pszPath)))
{
ShowControlsForPlay(true);
}
}
// 文字コード表示用 UNICODE → Hex 変換 2008/6/21 Uchi
EConvertResult CUtf8::_UnicodeToHex(const wchar_t* cSrc, const int iSLen, TCHAR* pDst, const CommonSetting_Statusbar* psStatusbar, const bool bCESUMode)
{
CNativeW cBuff;
EConvertResult res;
int i;
TCHAR* pd;
unsigned char* ps;
bool bbinary=false;
if (psStatusbar->m_bDispUtf8Codepoint) {
// Unicodeで表示
return CCodeBase::UnicodeToHex(cSrc, iSLen, pDst, psStatusbar);
}
cBuff.AllocStringBuffer(4);
// 1文字データバッファ
if (IsUTF16High(cSrc[0]) && iSLen >= 2 && IsUTF16Low(cSrc[1])) {
cBuff._GetMemory()->SetRawDataHoldBuffer(cSrc, 4);
}
else {
cBuff._GetMemory()->SetRawDataHoldBuffer(cSrc, 2);
if( IsBinaryOnSurrogate(cSrc[0]) ){
bbinary = true;
}
}
// UTF-8/CESU-8 変換
if (bCESUMode != true) {
res = UnicodeToUTF8(cBuff, cBuff._GetMemory());
}
else {
res = UnicodeToCESU8(cBuff, cBuff._GetMemory());
}
if (res != RESULT_COMPLETE) {
return res;
}
// Hex変換
ps = reinterpret_cast<unsigned char*>( cBuff._GetMemory()->GetRawPtr() );
pd = pDst;
if( bbinary == false ){
for (i = cBuff._GetMemory()->GetRawLength(); i >0; i--, ps ++, pd += 2) {
auto_sprintf( pd, _T("%02X"), *ps);
}
}else{
auto_sprintf( pd, _T("?%02X"), *ps );
}
return RESULT_COMPLETE;
}
void
CharacterButton::SetCharacter(unsigned _character)
{
if (_character == character)
return;
character = _character;
#ifdef _UNICODE
const TCHAR buffer[2] = { TCHAR(character), _T('\0') };
#else
char buffer[7];
*UnicodeToUTF8(character, buffer) = '\0';
#endif
SetCaption(buffer);
}
//ANSI转换UTF8
char* ANSIToUTF8(const char* str)
{
if (NULL == str)
{
return NULL;
}
char* result = NULL;
wchar_t* pUTF16 = ANSIToUnicode(str);
if (pUTF16)
{
result = UnicodeToUTF8(pUTF16);
free(pUTF16);
pUTF16 = NULL;
}
return result;
}
char * ConvertMessageToUTF8(char* wText)
{
char * utf8RetStr = NULL;
int tmpLen = 0;
if(!wText)
return utf8RetStr;
#ifdef WIN32
utf8RetStr = ANSIToUTF8(wText);
tmpLen = !utf8RetStr ? 0 : strlen(utf8RetStr);
if(tmpLen == 1)
{
if(utf8RetStr) free(utf8RetStr);
utf8RetStr = UnicodeToUTF8(wText);
}
#else
utf8RetStr = strdup(wText);
#endif
return utf8RetStr;
}
std::string CStringConverter::CStringTostring( CString &strSource )
{
return UnicodeToUTF8( strSource );
/*
* another method
char* pString(NULL);
int iSize = ::WideCharToMultiByte(CP_ACP, 0, strSource, strSource.GetLength(), pString, 0, NULL, NULL);
if(iSize > 0)
{
pString = new char[iSize + 1];
iSize = ::WideCharToMultiByte(CP_ACP, 0, strSource, strSource.GetLength(), pString, iSize + 1, NULL, NULL);
pString[iSize] = '\0';
std::string sString(pString);
delete[] pString;
return sString;
}
return "";
*/
}
char * xml_ansitoutf8(char* wText)
{
char * utf8RetStr = NULL;
int tmpLen = 0;
if(!wText)
return utf8RetStr;
if(!IsUTF8(wText))
{
utf8RetStr = ANSIToUTF8(wText);
tmpLen = !utf8RetStr ? 0 : strlen(utf8RetStr);
if(tmpLen == 1)
{
if(utf8RetStr) free(utf8RetStr);
utf8RetStr = UnicodeToUTF8((wchar_t *)wText);
}
}
else
{
tmpLen = strlen(wText)+1;
utf8RetStr = (char *)malloc(tmpLen);
memcpy(utf8RetStr, wText, tmpLen);
}
return utf8RetStr;
}
HRESULT CAsmLink::SetAssemblyProps(mdAssembly AssemblyID, mdToken FileToken, AssemblyOptions Option, VARIANT Value)
{
ASSERT(m_bInited && !m_bPreClosed && m_pAssem && !m_bManifestEmitted);
ASSERT(AssemblyID == TokenFromRid(mdtAssembly, 1) || AssemblyID == AssemblyIsUBM);
ASSERT((RidFromToken(FileToken) < m_pAssem->CountFiles() && TypeFromToken(FileToken) == mdtFile) ||
(FileToken == AssemblyID));
HRESULT hr = S_OK;
if (Option >= optLastAssemOption || OptionCAs[Option].flag & 0x40)
return E_INVALIDARG;
if (AssemblyID == AssemblyIsUBM || (OptionCAs[Option].flag & 0x02)) {
CFile *file = NULL;
if (FileToken == AssemblyID)
file = m_pAssem;
else if (FAILED(hr = m_pAssem->GetFile(FileToken, &file)))
return hr;
ASSERT(file->GetEmitScope());
IMetaDataEmit* pEmit = file->GetEmitScope();
CComPtr<IMetaDataImport> pImport;
mdToken tkAttrib = mdTokenNil, tkCtor;
DWORD cbValue = 0, cbSig = 4;
BYTE pbValue[2048];
PBYTE pBlob = pbValue;
COR_SIGNATURE newSig[9];
LPCWSTR wszStr = NULL;
ULONG wLen = 0;
if (FAILED(hr = pEmit->QueryInterface(IID_IMetaDataImport, (void**)&pImport)))
return hr;
// Find or Create the TypeRef (This always scopes it to MSCORLIB)
if (FAILED(hr = file->GetTypeRef(OptionCAs[Option].name, &tkAttrib)))
return hr;
// Make the Blob
newSig[0] = (IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS);
newSig[1] = 1; // One parameter
newSig[2] = ELEMENT_TYPE_VOID;
*(WORD*)pBlob = VAL16(1); // This is aligned
pBlob += sizeof(WORD);
if (V_VT(&Value) != OptionCAs[Option].vt)
return E_INVALIDARG;
switch(OptionCAs[Option].vt) {
case VT_BOOL:
*pBlob++ = (V_BOOL(&Value) == VARIANT_TRUE);
newSig[3] = ELEMENT_TYPE_BOOLEAN;
break;
case VT_UI4:
SET_UNALIGNED_VAL32(pBlob, V_UI4(&Value));
pBlob += sizeof(ULONG);
newSig[3] = ELEMENT_TYPE_U4;
break;
case VT_BSTR:
if (Option == optAssemOS) {
LPWSTR end = NULL;
mdToken tkPlatform = mdTokenNil;
newSig[1] = 2; // Two parameters
newSig[3] = ELEMENT_TYPE_VALUETYPE;
// Make the TypeRef
if (FAILED(hr = file->GetTypeRef( PLATFORMID_NAME, &tkPlatform)))
break;
cbSig = 5 + CorSigCompressToken(tkPlatform, newSig + 4);
newSig[cbSig - 1] = ELEMENT_TYPE_STRING;
SET_UNALIGNED_VAL32(pBlob, wcstoul(V_BSTR(&Value), &end, 0)); // Parse Hex, Octal, and Decimal
pBlob += sizeof(ULONG);
if (*end == L'.') {
wszStr = end++;
wLen = SysStringLen(V_BSTR(&Value)) - (UINT)(V_BSTR(&Value) - end);
goto ADDSTRING;
} else {
hr = file->ReportError(ERR_InvalidOSString);
return hr;
}
} else {
newSig[3] = ELEMENT_TYPE_STRING;
wLen = SysStringLen(V_BSTR(&Value));
wszStr = V_BSTR(&Value);
ADDSTRING:
if (wLen == 0) {
// Too small for unilib
*pBlob++ = 0xFF;
} else if (wLen & 0x80000000) {
// Too big!
return ReportOptionError(file, Option, E_INVALIDARG);
} else if ((OptionCAs[Option].flag & 0x10) && wLen > MAX_PATH) {
// Too big!
return ReportOptionError(file, Option, HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW)); // File name too long
} else {
CHAR pUTF8[2048];
int iLen = wLen;
wLen = (UINT)UnicodeToUTF8(wszStr, &iLen, pUTF8, lengthof(pUTF8));
iLen = (int)CorSigCompressData( wLen, pBlob);
pBlob += iLen;
if (wLen > (UINT)(pbValue + lengthof(pbValue) - pBlob)) {
// Too big!
return ReportOptionError(file, Option, HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW));
}
memcpy(pBlob, pUTF8, wLen);
pBlob += wLen;
}
}
break;
default:
VSFAIL("Unknown Option Type!");
newSig[3] = ELEMENT_TYPE_OBJECT;
break;
}
hr = pImport->FindMemberRef(tkAttrib, L".ctor", newSig, cbSig, &tkCtor);
if ((hr == CLDB_E_RECORD_NOTFOUND && FAILED(hr = pEmit->DefineMemberRef(tkAttrib, L".ctor", newSig, 4, &tkCtor))) ||
FAILED(hr))
return hr;
cbValue = (DWORD)(pBlob - pbValue);
// Emit the CA
// This will also set the option if appropriate
hr = EmitAssemblyCustomAttribute( AssemblyID, FileToken, tkCtor, pbValue, cbValue,
(OptionCAs[Option].flag & 0x08) ? TRUE : FALSE,
(OptionCAs[Option].flag & 0x04) ? TRUE : FALSE);
} else {
// An assembly level custom attribute
hr = m_pAssem->SetOption(Option, &Value);
}
return hr;
}
int main(int argc, char **argv)
{
plan_tests(2 * ARRAY_SIZE(valid) +
2 * ARRAY_SIZE(invalid) +
2 * ARRAY_SIZE(length) +
4 * ARRAY_SIZE(crop) +
ARRAY_SIZE(latin1_chars) +
#ifndef _UNICODE
ARRAY_SIZE(truncate_string_tests) +
#endif
9 + 27);
for (auto i : valid) {
ok1(ValidateUTF8(i));
ok1(LengthUTF8(i) == MyLengthUTF8(i));
}
for (auto i : invalid) {
ok1(!ValidateUTF8(i));
ok1(!MyValidateUTF8(i));
}
for (auto &l : length) {
ok1(l.length == LengthUTF8(l.value));
ok1(l.length == MyLengthUTF8(l.value));
}
char buffer[64];
for (auto &l : latin1_chars) {
*Latin1ToUTF8(l.ch, buffer) = 0;
ok1(strcmp(l.utf8, buffer) == 0);
}
for (auto &c : crop) {
strcpy(buffer, c.input);
auto *end = CropIncompleteUTF8(buffer);
ok1(strcmp(c.output, buffer) == 0);
ok1(end != nullptr);
ok1(*end == '\0');
ok1(end == buffer + strlen(buffer));
}
#ifndef _UNICODE
TestTruncateString();
#endif
{
const char *p = "foo\xe7\x9b\xae";
auto n = NextUTF8(p);
ok1(n.first == 'f');
ok1(n.second == p + 1);
n = NextUTF8(p + 1);
ok1(n.first == 'o');
ok1(n.second == p + 2);
n = NextUTF8(p + 2);
ok1(n.first == 'o');
ok1(n.second == p + 3);
n = NextUTF8(p + 3);
ok1(n.first == 30446);
ok1(n.second == p + 6);
n = NextUTF8(p + 6);
ok1(n.first == 0);
}
/* test UnicodeToUTF8() */
buffer[0] = 1;
ok1(UnicodeToUTF8(0, buffer) == buffer + 1);
ok1(buffer[0] == 0);
ok1(UnicodeToUTF8(' ', buffer) == buffer + 1);
ok1(buffer[0] == ' ');
ok1(UnicodeToUTF8(0x7f, buffer) == buffer + 1);
ok1(buffer[0] == 0x7f);
ok1(UnicodeToUTF8(0xa2, buffer) == buffer + 2);
ok1(buffer[0] == char(0xc2));
ok1(buffer[1] == char(0xa2));
ok1(UnicodeToUTF8(0x6fb3, buffer) == buffer + 3);
ok1(buffer[0] == char(0xe6));
ok1(buffer[1] == char(0xbe));
ok1(buffer[2] == char(0xb3));
ok1(UnicodeToUTF8(0xffff, buffer) == buffer + 3);
ok1(buffer[0] == char(0xef));
ok1(buffer[1] == char(0xbf));
ok1(buffer[2] == char(0xbf));
ok1(UnicodeToUTF8(0x10000, buffer) == buffer + 4);
ok1(buffer[0] == char(0xf0));
ok1(buffer[1] == char(0x90));
ok1(buffer[2] == char(0x80));
ok1(buffer[3] == char(0x80));
ok1(UnicodeToUTF8(0x10ffff, buffer) == buffer + 4);
ok1(buffer[0] == char(0xf4));
ok1(buffer[1] == char(0x8f));
ok1(buffer[2] == char(0xbf));
ok1(buffer[3] == char(0xbf));
return exit_status();
}
int main(int argc, char **argv)
{
plan_tests(ARRAY_SIZE(valid) + ARRAY_SIZE(invalid) +
ARRAY_SIZE(length) +
ARRAY_SIZE(crop) +
ARRAY_SIZE(latin1_chars) +
9 + 27);
for (auto i : valid)
ok1(ValidateUTF8(i));
for (auto i : invalid)
ok1(!ValidateUTF8(i));
for (auto &l : length)
ok1(l.length == LengthUTF8(l.value));
char buffer[64];
for (auto &l : latin1_chars) {
*Latin1ToUTF8(l.ch, buffer) = 0;
ok1(strcmp(l.utf8, buffer) == 0);
}
for (auto &c : crop) {
strcpy(buffer, c.input);
CropIncompleteUTF8(buffer);
ok1(strcmp(c.output, buffer) == 0);
}
{
const char *p = "foo\xe7\x9b\xae";
auto n = NextUTF8(p);
ok1(n.first == 'f');
ok1(n.second == p + 1);
n = NextUTF8(p + 1);
ok1(n.first == 'o');
ok1(n.second == p + 2);
n = NextUTF8(p + 2);
ok1(n.first == 'o');
ok1(n.second == p + 3);
n = NextUTF8(p + 3);
ok1(n.first == 30446);
ok1(n.second == p + 6);
n = NextUTF8(p + 6);
ok1(n.first == 0);
}
/* test UnicodeToUTF8() */
buffer[0] = 1;
ok1(UnicodeToUTF8(0, buffer) == buffer + 1);
ok1(buffer[0] == 0);
ok1(UnicodeToUTF8(' ', buffer) == buffer + 1);
ok1(buffer[0] == ' ');
ok1(UnicodeToUTF8(0x7f, buffer) == buffer + 1);
ok1(buffer[0] == 0x7f);
ok1(UnicodeToUTF8(0xa2, buffer) == buffer + 2);
ok1(buffer[0] == char(0xc2));
ok1(buffer[1] == char(0xa2));
ok1(UnicodeToUTF8(0x6fb3, buffer) == buffer + 3);
ok1(buffer[0] == char(0xe6));
ok1(buffer[1] == char(0xbe));
ok1(buffer[2] == char(0xb3));
ok1(UnicodeToUTF8(0xffff, buffer) == buffer + 3);
ok1(buffer[0] == char(0xef));
ok1(buffer[1] == char(0xbf));
ok1(buffer[2] == char(0xbf));
ok1(UnicodeToUTF8(0x10000, buffer) == buffer + 4);
ok1(buffer[0] == char(0xf0));
ok1(buffer[1] == char(0x90));
ok1(buffer[2] == char(0x80));
ok1(buffer[3] == char(0x80));
ok1(UnicodeToUTF8(0x10ffff, buffer) == buffer + 4);
ok1(buffer[0] == char(0xf4));
ok1(buffer[1] == char(0x8f));
ok1(buffer[2] == char(0xbf));
ok1(buffer[3] == char(0xbf));
return exit_status();
}
std::string UrlEncode(const std::wstring& str)
{
std::string utf8 = UnicodeToUTF8(str);
return utf8;
}
char* ANSIToUTF8(const char* str)
{
return UnicodeToUTF8(ANSIToUnicode(str));
}
eString ChineseTradToSimp(const char *szIn,int len)
{
if (eString::convertChineseTradToSimp==0)
return eString(szIn,len);
unsigned long code=0;
unsigned char temp[4096];
unsigned int j=0;
for (int i=0; i < len; ++i)
{
if (!(szIn[i]&0x80)){ // normal ASCII
temp[j++]=szIn[i];
continue;
}else if ((szIn[i] & 0xE0) == 0xC0) // one char following.
{
// first, length check:
if (i+1 >= len){
temp[j++]=szIn[i];
break;
}else if ((szIn[i+1]&0xC0) != 0x80){
temp[j++]=szIn[i++];
temp[j++]=szIn[i];
continue;
}
code=(szIn[i] & 0x1F)<<6 | (szIn[i+1] & 0x3F);
i++;
} else if ((szIn[i] & 0xF0) == 0xE0)
{
if ((i+2) >= len){
temp[j++]=szIn[i];
break;
}else if ((szIn[i+1]&0xC0) != 0x80 || (szIn[i+2]&0xC0) != 0x80 ){
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i];
continue;
}
code=((szIn[i] & 0x0F)<<12) | ((szIn[i+1] & 0x3F)<<6) | (szIn[i+2] & 0x3F);
i+=2;
} else if ((szIn[i] & 0xF8) == 0xF0)
{
if ((i+3) >= len){
temp[j++]=szIn[i];
break;
}else if ((szIn[i+1]&0xC0) != 0x80 || (szIn[i+2]&0xC0) != 0x80 || (szIn[i+3]&0xC0) != 0x80){
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i];
continue;
}
code=((szIn[i] & 0x07)<<18)|((szIn[i+1] & 0x3F)<<12) | ((szIn[i+2] & 0x3F)<<6) | (szIn[i+3] & 0x3F);
i+=3;
} else if ((szIn[i] & 0xFC) == 0xF8)
{
if ((i+4) >= len){
temp[j++]=szIn[i];
break;
}else if ((szIn[i+1]&0xC0) != 0x80 || (szIn[i+2]&0xC0) != 0x80 || (szIn[i+3]&0xC0) != 0x80
|| (szIn[i+4]&0xC0) != 0x80){
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i];
continue;
}
code=((szIn[i] & 0x03)<<24)|((szIn[i+1] & 0x3F)<<18)|((szIn[i+2] & 0x3F)<<12) | ((szIn[i+3] & 0x3F)<<6) | (szIn[i+4] & 0x3F);
i+=4;
} else if ((szIn[i] & 0xFD) == 0xFC)
{
if ((i+5) >= len){
temp[j++]=szIn[i];
break;
}else if ((szIn[i+1]&0xC0) != 0x80 || (szIn[i+2]&0xC0) != 0x80 || (szIn[i+3]&0xC0) != 0x80
|| (szIn[i+4]&0xC0) != 0x80 || (szIn[i+5]&0xC0) != 0x80){
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i++];
temp[j++]=szIn[i];
continue;
}
code=((szIn[i] & 0x01)<<30)|((szIn[i+1] & 0x03F)<<24)|((szIn[i+2] & 0x3F)<<18)|((szIn[i+3] & 0x3F)<<12) | ((szIn[i+4] & 0x3F)<<6) | (szIn[i+5] & 0x3F);
i+=5;
}else{
temp[j++]=szIn[i];
continue;
}
code=ChineseTradToSimp(code);
int ret=UnicodeToUTF8(code,(char*)temp+j);
j+=ret;
}
temp[j]='\0';
// eDebug("[ChineseTradToSimp] %s",temp);
return eString((const char *)temp,j);
}
