TInt CISO2022KRImplementation::ConvertFromUnicode( CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, TDes8& aForeign, const TDesC16& aUnicode, CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters) { TInt ret; TInt currPos = 3; TUint outputConversionFlags = 0; TUint inputConversionFlags = CCnvCharacterSetConverter::EInputConversionFlagAppend; TISO2022FromUniState currState = EISO2022Initialize; TUint8 shiftByte = 0; TPtr8 shiftBytePtr(NULL, 0); aForeign.SetLength(0); /* Start with escape sequence */ aForeign.Append( KLit8EscapeSequence ); ret = CCnvCharacterSetConverter::DoConvertFromUnicode( CnvCp949Table::ConversionData(), aDefaultEndiannessOfForeignCharacters, aReplacementForUnconvertibleUnicodeCharacters, aForeign, aUnicode, aIndicesOfUnconvertibleCharacters, outputConversionFlags, inputConversionFlags ); /* Append shift in and out bytes as needed */ while( currPos < aForeign.Length() ) { TUint8 *currChar = (TUint8 *)aForeign.Mid(currPos).Ptr(); if( *currChar > KMaxAscii ) { /* KSC character */ if( currState != EISO2022KSC ) { /* Insert shift out byte */ shiftByte = SHIFT_OUT_BYTE; currState = EISO2022KSC; } /* Clear the 8th bit */ *currChar = (*currChar & ~(0x80)); } else { /* ASCII character */ if( currState != EISO2022Ascii ) { /* Insert shift in byte */ shiftByte = SHIFT_IN_BYTE; currState = EISO2022Ascii; } } if( shiftByte ) { if( (aForeign.Length() + 1) > aForeign.MaxLength() ) { /* Make room for shift byte */ if( aForeign[ (aForeign.Length() - 1) ] > KMaxAscii ) { /* Drop a dual byte KSC character */ aForeign.SetLength( aForeign.Length() - 2 ); } else { /* Drop a single byte ASCII character */ aForeign.SetLength( aForeign.Length() - 1 ); } /* Increase unconverted amount */ ret++; /* TBD, propably should try to fix aIndicesOfUnconvertibleCharacters if possible */ } shiftBytePtr.Set( &shiftByte, 1, 1 ); aForeign.Insert( currPos, shiftBytePtr ); currPos++; shiftByte = 0; } /* Skip current character */ currPos++; } return ret; }
TInt ParseMixedBinaryAsciiDataL(TDes8& aTextToConvert) /** Parses aTextToConvert based on the following rules: '\\' (double backslash) is used to denote a single '\' (single backslash) '\xnn' denote a byte of binary data where nn is in hex-decimal. The '\xnn' in aTextToConvert is replaced by the binary byte that it represents. For example: If aTextToConvert contains "abc\\def\xFF", after parsing, it will contain "abc\def?" where ? = 0xFF. @param aTextToConvert Modifiable buffer which will be parsed. @return KErrNone if aTextToConvert is in valid EAdditionalParamDataFormatMixedBinaryAndAscii format. KErrArgument if aTextToConvert is in an incorrect format. @panic KErrNoMemory if there is not enough memory to do the parsing. */ { // Pointer to unparsed portion of additionalParamDataBuffer HBufC8* resultBuffer = HBufC8::NewLC(aTextToConvert.Length()); __ASSERT_ALWAYS(resultBuffer, PanicClient(KErrNoMemory)); TPtr8 result(resultBuffer->Des()); // Position of backslash TInt pos = 0; while ((pos = aTextToConvert.Locate('\\')) != KErrNotFound) { // Check that the backslash is followed by at least one more character if ((pos+1) >= aTextToConvert.Length()) { return KErrArgument; } TUint8 modifier = aTextToConvert[pos+1]; // Parse depending on character after the backslash switch (modifier) { case '\\': // Next character after the '\' is another '\'. // Replace it with a single '\' and move // on. result.Append(aTextToConvert.Left(pos+1)); aTextToConvert.Delete(0, pos+2); break; case 'x': // Next character is an 'x' so check that there are three // characters after the backslash (one for the x and two // characters of HEX. if ((pos+3) >= aTextToConvert.Length()) { return KErrArgument; } // Convert those to HEX and replace '\xNN' with this. result.Append(aTextToConvert.Left(pos)); TUint8 hexAsInt; if (AsciiHexToNum(aTextToConvert.MidTPtr(pos+2,2), hexAsInt) != KErrNone) { return KErrArgument; } // Append the raw byte to the result result.SetLength(result.Length()+1); result[result.Length()-1] = hexAsInt; aTextToConvert.Delete(0, pos+4); break; } } // End while aTextToConvert.Insert(0, result); CleanupStack::PopAndDestroy(resultBuffer); return KErrNone; }