/** @SYMTestCaseID SYSLIB-CHARCONV-CT-0538 @SYMTestCaseDesc Splitting and converting from EucJpPacked to Unicode test @SYMTestPriority Medium @SYMTestActions Tests for conversion after splitting, from EucJpPacked to Unicode and back to EucJpPacked @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ void CT_EUCJP_PACKED_2::TestSplittingConvertingToUnicodeFromEucJpPacked(CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfEucJpPackedBytesNotConvertedAtSplit, TInt aExpectedLengthOfFirstPartOfUnicode, const TDesC16& aExpectedUnicode, const TDesC8& aOriginalEucJpPacked) { INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0538 ")); test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit); test(aMaximumLengthUpperLimit<=KBufferLength); TUint16 unicodeBuffer[KBufferLength]; for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i) { TPtr16 generatedFirstPartOfUnicode(unicodeBuffer, i); TInt state=CCnvCharacterSetConverter::KStateDefault; test(aCharacterSetConverter.ConvertToUnicode(generatedFirstPartOfUnicode, aOriginalEucJpPacked, state)==aExpectedNumberOfEucJpPackedBytesNotConvertedAtSplit); test(generatedFirstPartOfUnicode==aExpectedUnicode.Left(aExpectedLengthOfFirstPartOfUnicode)); test(state==CCnvCharacterSetConverter::KStateDefault); TBuf16<KBufferLength> generatedSecondPartOfUnicode; test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, aOriginalEucJpPacked.Right(aExpectedNumberOfEucJpPackedBytesNotConvertedAtSplit), state)==0); test(generatedSecondPartOfUnicode==aExpectedUnicode.Mid(aExpectedLengthOfFirstPartOfUnicode)); test(state==CCnvCharacterSetConverter::KStateDefault); TBuf8<KBufferLength> generatedEucJpPacked; test(aCharacterSetConverter.ConvertFromUnicode(generatedEucJpPacked, generatedFirstPartOfUnicode)==0); TBuf8<KBufferLength> generatedSecondPartOfEucJpPacked; test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfEucJpPacked, generatedSecondPartOfUnicode)==0); generatedEucJpPacked.Append(generatedSecondPartOfEucJpPacked); test(generatedEucJpPacked==aOriginalEucJpPacked); } }
/** Sets an existing descriptor setting to a new value or creates a new setting with a descriptor value if it doesn't exist. @param aKey Key of setting to be written to. @param aValue Value to be written. @return KErrNone if successful, KErrArgument if aValue is longer than KMaxUnicodeStringLength or the setting exists but is not a descriptor, plus other system-wide error codes. @post Transactions fail on all error conditions. Outside transactions: on success the new value is persistent, on failure the repository is unmodified. @capability Dependent Caller must satisfy the write access policy of that key in the repository. */ EXPORT_C TInt CRepository::Set(TUint32 aKey, const TDesC16& aValue) { if (aValue.Length()>KMaxUnicodeStringLength) return KErrArgument; TPtrC8 pVal((const TUint8*)aValue.Ptr(), aValue.Length()*2); return Set(aKey,pVal); }
// ========================================================================== // METHOD: Write // // DESIGN: Write the given buffer. Chunk the string if it is longer than // KMaxTextPerLine. // ========================================================================== void CLogFileHandler::Write( const TDesC8& aClassName, const TDesC8& aFuncName, const TDesC16& aDes ) { TRAP_IGNORE( AddTimestampToOutputBufferL() ); TInt prefixLength = iOutputBuffer.Length(); TRAP_IGNORE( AddClassAndFunctionToOutputBufferL( aClassName, aFuncName ) ); TInt curPos = 0; while( curPos < aDes.Length() ) { TInt lengthToWrite = Min( KMaxTextPerLine - iOutputBuffer.Length(), aDes.Length() - curPos ); TRAP_IGNORE( WriteLineL( aDes.Mid( curPos, lengthToWrite ) ) ); iOutputBuffer.SetLength( prefixLength ); curPos += lengthToWrite; } // end while } // END Write
// --------------------------------------------------------------------------- // From MsearchInfo class. // CSearchInfoImp::SetFieldInfoL() // --------------------------------------------------------------------------- // void CSearchInfoImp::SetFieldInfoL(const TDesC16& aFieldInfo ,TInfoType aType) { switch(aType) { case EFirstName: { HBufC16* buf = aFieldInfo.AllocL(); iFirstname.Close(); iFirstname.Assign( buf ); break; } case ELastName: { HBufC16* buf= aFieldInfo.AllocL(); iLastname.Close(); iLastname.Assign( buf ); break; } case EEmailAddress: { HBufC16* buf = aFieldInfo.AllocL(); iEmailId.Close(); iEmailId.Assign( buf ); break; } } }
void CTestVwAppUi::ActivateViewL(const TVwsViewId& aViewId,TUid aCustomMessageId,const TDesC16& aCustomMessage) { HBufC8* narrowMessage=HBufC8::NewLC(aCustomMessage.Size()); TPtr8 ptr=narrowMessage->Des(); ptr.Copy((TUint8*)aCustomMessage.Ptr(),aCustomMessage.Size()); CCoeAppUi::ActivateViewL(aViewId,aCustomMessageId,*narrowMessage); CleanupStack::PopAndDestroy(); // narrowMessage. }
/** Finds all the settings that match the specification given by aPartialKey and aMask, but are either not string values or do not match the given string. @param aPartialKey Contains a bit pattern that all the keys returned must at least partially match. @param aMask Has bits set for all the bits in aPartialKey that must match the returned keys. @param aValue Settings for the keys found will be settings that either contain values that are not strings or strings with value other than aValue. @param aFoundKeys All the keys found. For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and the setting with key k is either not a string value or a string value not equal to aValue. @see FindL() @return KErrNone if successful, KErrNotFound if capability check passed but no non-matching items are found, plus other system-wide error codes. @post Transactions fail only on those "other system-wide error codes". @capability Dependent Caller must satisfy the read policies of all settings found in the source range. */ EXPORT_C TInt CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, const TDesC16& aValue, RArray<TUint32>& aFoundKeys) { TPtrC8 pVal((const TUint8*)aValue.Ptr(), aValue.Length()*2); TRAPD(ret,iImpl->FindSettingsComparisonL(aPartialKey,aMask,pVal,ENotEqual,aFoundKeys)); if (ret==KErrNoMemory) User::LeaveNoMemory(); return ret; }
/** @internalComponent Returns the type of the URIs scheme @param aScheme The descriptor with the scheme. @return The scheme type */ TUriSchemeType SchemeType(const TDesC16& aScheme) { // Compares the scheme with both sip and sips if (aScheme.CompareF(KSipScheme()) == 0 || aScheme.CompareF(KSipsScheme()) == 0) { // there's a match so this is a sip scheme return ESchemeTypeSip; } return ESchemeTypeUnknown; }
void TDes8::Copy(const TDesC16 &aDes) { TInt len=aDes.Length(); SetLength(len); const TUint16 *pS=aDes.Ptr(); const TUint16 *pE=pS+len; TUint8 *pT=const_cast<TUint8 *>(Ptr()); while (pS<pE) { TUint c=(*pS++); if (c>=0x100) c=1; *pT++=(TUint8)c; } }
// ----------------------------------------------------------------------------- // CSyncMLFilterProperty::AddDefaultValueText16L // Adds default value for text16 property. // This is useful only if data type is text16. // ----------------------------------------------------------------------------- EXPORT_C void CSyncMLFilterProperty::AddDefaultValueText16L( TDesC16& aNewDefaultValue, const TBool aSelected ) { if ( iDataTypeForDefaultValues != ESyncMLDataTypeText16 ) { User::Leave( KErrNotSupported ); } if ( aNewDefaultValue.Length() > iMaxTextLength ) { User::Leave( KErrArgument ); } iDefaultValueText16List.AppendL( aNewDefaultValue.AllocLC() ); CleanupStack::Pop(); // aNewDefaultValue.AllocLC() iDefaultValueSelected.AppendL( aSelected ); }
void CCatalogsBaseMessageImpl::CompleteAndReleaseL( const TDesC16& aOutputData, TInt aStatus ) { DLTRACEIN(("TDesC16, TInt, handle: %d, this: %x", Handle(), this)); if ( iSenderLost ) { DLINFO(("Sender was lost, deleting message")); delete this; DLTRACEOUT(("")); return; } TInt clientDescLength( iMessage.GetDesMaxLengthL( 3 ) ); if ( clientDescLength < aOutputData.Length() ) { if( iMessage.Function() == ECatalogsExternalAllocMessage ) { TInt incompMsgHandle( iSession.WriteToLargerDesL( aOutputData, aStatus ) ); TBuf16<KCatalogsMinimumAllocSize> internalMsg( KCatalogsMinimumAllocLength ); internalMsg.Num( incompMsgHandle ); internalMsg.Append( KCatalogsTooSmallDescMsgElementDivider ); internalMsg.AppendNum( aOutputData.Length() ); TRAPD( error, iMessage.WriteL( KOutputSlot, internalMsg ) ); if ( error != KErrNone ) { iSession.RemoveIncompleteMessage( incompMsgHandle ); User::Leave( error ); } } iMessage.Complete( KCatalogsErrorTooSmallDescriptor ); } else { iMessage.WriteL( KOutputSlot, aOutputData ); iMessage.Complete( aStatus ); } delete this; DLTRACEOUT(("")); }
// ----------------------------------------------------------------------------- // CSatNotifySendSs::CreateTerminalRespL // Constructs SendSs specific part of terminal response and calls // DOS to send the actual message. // ----------------------------------------------------------------------------- // TInt CSatNotifySendSs::CreateTerminalRespL ( TUint8 aPCmdNumber, TUint8 aGeneralResult, const TDesC16& aAdditionalInfo ) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSATNOTIFYSENDSS_CREATETERMINALRESPL_1, "CSAT:: CSatNotifySendSs::CreateTerminalRespL"); // Create and append response data TTlv tlvSpecificData; tlvSpecificData.AddTag( KTlvResultTag ); // Append general result tlvSpecificData.AddByte( aGeneralResult ); for (TInt i = 0; i < aAdditionalInfo.Length(); i++ ) { tlvSpecificData.AddByte( static_cast<TUint8>( aAdditionalInfo[i] ) ); } // Prepare data iNotificationsTsy->iTerminalRespData.iPCmdNumber = aPCmdNumber; TPtrC8 data = tlvSpecificData.GetDataWithoutTopLevelTag(); // Pack data CSatDataPackage dataPackage; dataPackage.PackData( &iNotificationsTsy->iTerminalRespData, &data ); // Forward request to the DOS return iNotificationsTsy->iSatTsy->MessageManager()->HandleRequestL( ESatTerminalRsp, &dataPackage ); }
inline void CPppMsChap::NTChallengeResponseL(const TDesC8& aChallenge, const TDesC16& aPassword, TDes8& aResponse) /** Computes a MS-CHAP Windows NT compatible Challenge Response. @param aChallenge [in] A MS-CHAP Challenge (8 octets). @param aPassword [in] The Microsoft Windows NT password (0 to 256 Unicode char). @param aResponse [out] The MS-CHAP Windows NT compatible Challenge Response (24 octets). @note This function implements the NTChallengeResponse routine specified in RFC 2433. @internalComponent */ { ASSERT(aChallenge.Length() == KPppMsChapChallengeSize); ASSERT(aPassword.Length() <= KPppMsChapMaxNTPasswordLength); ASSERT(aResponse.Length() == KPppMsChapNTResponseSize); HBufC8* paddedPasswordHashBuf = HBufC8::NewLC(KPppMsChapPaddedHashSize); TPtr8 paddablePasswordHash(paddedPasswordHashBuf->Des()); paddablePasswordHash.SetLength(KPppMsChapHashSize); NtPasswordHashL(aPassword, paddablePasswordHash); ChallengeResponseL(aChallenge, paddablePasswordHash, aResponse); CleanupStack::PopAndDestroy(paddedPasswordHashBuf); ASSERT(aResponse.Length() == KPppMsChapNTResponseSize); }
// ----------------------------------------------------------------------------- // Sets poly1D points. // ----------------------------------------------------------------------------- // void CAknsAlPolyBase::SetPolyPoints1DL( const TDesC16& aPointString ) { TInt coordCount = aPointString.Length(); if ((coordCount & 0x1) || coordCount < 4) // odd number or too few point coordinates User::Leave(KErrArgument); iPointCount = coordCount >> 1; iPoints = new (ELeave) TPolyPoint[iPointCount]; iPoints[0].iX = aPointString[0]; iPoints[0].iY = aPointString[1]; TUint16 oldX = iPoints[0].iX; // parse numbers from the descriptor for (TInt i = 1; i < iPointCount; i++) // first point already set { iPoints[i].iX = aPointString[i*2]; iPoints[i].iY = aPointString[i*2+1]; if (iPoints[i].iX < oldX) // points must be in ascending order User::Leave(KErrArgument); oldX = iPoints[i].iX; } }
// ----------------------------------------------------------------------------- // Sets poly points. // ----------------------------------------------------------------------------- // void CAknsAlPolyBase::SetPolyPointsL( const TDesC16& aPointString ) { TInt coordCount = aPointString.Length(); if ((coordCount & 0x1) || coordCount < 4) // odd number or too few point coordinates { RDebug::Printf("%s, line %d, ERROR: Illegal coordinate count", __FILE__, __LINE__); User::Leave(KErrArgument); } iPointCount = coordCount >> 1; iPoints = new (ELeave) TPolyPoint[iPointCount]; iPoints[0].iX = aPointString[0]; iPoints[0].iY = aPointString[1]; TUint16 oldX = iPoints[0].iX; TUint16 oldY = iPoints[0].iY; // parse numbers from the descriptor for (TInt i = 1; i < iPointCount; i++) // first point already set { iPoints[i].iX = aPointString[i*2]; iPoints[i].iY = aPointString[i*2+1]; if (oldX == iPoints[i].iX && oldY == iPoints[i].iY) { RDebug::Printf("%s, line %d, ERROR: subsequent coordinates cannot be equal", __FILE__, __LINE__); User::Leave(KErrArgument); } oldX = iPoints[i].iX; oldY = iPoints[i].iY; } }
void CT_ISO2022JP1_2::TestSplittingConvertingFromUnicodeToIso2022Jp( CCnvCharacterSetConverter& aCharacterSetConverter, TInt aMaximumLengthLowerLimit, TInt aMaximumLengthUpperLimit, TInt aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit, const TDesC8& aExpectedFirstPartOfIso2022Jp, const TDesC8& aExpectedSecondPartOfIso2022Jp, const TDesC16& aOriginalUnicode) { INFO_PRINTF1(_L(" TestTruncatedConversionFromUnicodeToIso2022Jp ")); test(aMaximumLengthLowerLimit<=aMaximumLengthUpperLimit); test(aMaximumLengthUpperLimit<=KBufferLength); TUint8 iso2022JpBuffer[KBufferLength]; for (TInt i=aMaximumLengthLowerLimit; i<=aMaximumLengthUpperLimit; ++i) { TPtr8 generatedFirstPartOfIso2022Jp(iso2022JpBuffer, i); test(aCharacterSetConverter.ConvertFromUnicode(generatedFirstPartOfIso2022Jp, aOriginalUnicode)==aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit); test(generatedFirstPartOfIso2022Jp==aExpectedFirstPartOfIso2022Jp); TBuf8<KBufferLength> generatedSecondPartOfIso2022Jp; test(aCharacterSetConverter.ConvertFromUnicode(generatedSecondPartOfIso2022Jp, aOriginalUnicode.Right(aExpectedNumberOfUnicodeCharactersNotConvertedAtSplit))==0); test(generatedSecondPartOfIso2022Jp==aExpectedSecondPartOfIso2022Jp); TInt state=CCnvCharacterSetConverter::KStateDefault; TBuf16<KBufferLength> generatedUnicode; test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedFirstPartOfIso2022Jp, state)==0); TBuf16<KBufferLength> generatedSecondPartOfUnicode; test(aCharacterSetConverter.ConvertToUnicode(generatedSecondPartOfUnicode, generatedSecondPartOfIso2022Jp, state)==0); generatedUnicode.Append(generatedSecondPartOfUnicode); test(generatedUnicode==aOriginalUnicode); } }
// --------------------------------------------------------------------------- // From MPresentityGroupInfo class. // CPresentityGroupInfoImp::SetGroupDisplayNameL() // --------------------------------------------------------------------------- // void CPresentityGroupInfoImp::SetGroupDisplayNameL( const TDesC16& aDisplayName ) { HBufC16* displayNameBuf = aDisplayName.AllocL(); iDisplayName.Close(); iDisplayName.Assign( displayNameBuf ); }
EXPORT_C void TcLog::Write( const TDesC16& aBuf ) { // Convert to narrow TBuf8< KTcBufferSize > buf; buf.Copy( aBuf.Left( KTcBufferSize ) ); Write( buf ); }
// ----------------------------------------------------------------------------- void CPresenceCacheBuddyInfo::SetAnyFieldL( const TDesC16& aKey, const TDesC8& aValue ) { if( NPresenceCacheFieldName::KExpiry().CompareF( aKey ) == 0 ) { TPckg<TInt64> expiryPck( iExpiryTime ); expiryPck.Copy( aValue ); // write also to key-value map } // Remove old values first RemoveField( aKey ); HBufC8* valueBuffer = aValue.AllocLC(); HBufC* keyBuffer = aKey.AllocLC(); TInt insertPos = iIds.Find(0); if ( insertPos < 0 ) { insertPos = iIds.Count(); iIds.Append( keyBuffer ); iValues.Append( valueBuffer ); } else { iIds[insertPos] = keyBuffer; iValues[insertPos] = valueBuffer; } iHashMap.InsertL( keyBuffer, insertPos ); CleanupStack::Pop( keyBuffer ); CleanupStack::Pop( valueBuffer ); }
TBool TUriShortcutParser16::HasScheme( const TDesC16& aUri ) { int posSchemeComponentDelimiter = aUri.Locate( KSchemeComponentDelimiter ); if ( posSchemeComponentDelimiter > 0 ) { int posOpeningSquareBracket = aUri.Locate( KOpeningSquareBracket ); if ( posOpeningSquareBracket == KErrNotFound || posOpeningSquareBracket > posSchemeComponentDelimiter ) { //scheme present return ETrue; } } return EFalse; }
void CUpnpHttpFileAccess::ConstructL( CUpnpHttpSession* aSession, const TDesC16& aFilename ) { LOGS1( "%i, CUpnpHttpFileAccess::ConstructL(CUpnpHttpSession*, TDesC16&)", this ); User::LeaveIfError(iFsSession.Connect()); iFileToServe = aFilename.AllocL(); TInt error = 0; iPosInFile = 0; iHeaderLength = 0; iSession = aSession; if (iSession->OverwriteExisting() && !iSession->SaveAtOffset()) { error = iFile.Replace(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); User::LeaveIfError(error); } else if (iSession->OverwriteExisting() && iSession->SaveAtOffset()) { error = iFile.Open(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); if (error != KErrNotFound) { TInt size = 0; error = iFile.Size(size); if (size >= (iSession->Offset())) { iPosInFile = iSession->Offset(); } else { iFile.Close(); error = iFile.Replace(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); User::LeaveIfError(error); } } else { error = iFile.Create(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); User::LeaveIfError(error); } } else { error = iFile.Open(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); if (error == KErrNotFound) { error = iFile.Create(iFsSession, *iFileToServe, EFileWrite | EFileShareAny); User::LeaveIfError(error); } } }
EXPORT_C void CPTPIPInitCmdAck::SetDeviceFriendlyName(TDesC16& aName) { OstTraceFunctionEntry0( CPTPIPINITCMDACK_SETDEVICEFRIENDLYNAME_ENTRY ); if(KErrNone == iBuffer.Create(aName,aName.Length()+KMTPNullCharLen)) { iBuffer.Append(KMTPNullChar); } }
/** @SYMTestCaseID SYSLIB-CHARCONV-CT-0535 @SYMTestCaseDesc Tests for truncated conversion from Unicode to EucJpPacked @SYMTestPriority Medium @SYMTestActions Tests for truncated conversion from Unicode to EucJpPacked and back to Unicode @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ void CT_EUCJP_PACKED_2::TestTruncatedConversionFromUnicodeToEucJpPacked(CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode) { INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0535 ")); for (TInt i=aOriginalUnicode.Length(); i>=0; --i) { TBuf8<KBufferLength> generatedEucJpPacked; const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedEucJpPacked, aOriginalUnicode.Left(i)); test(returnValue>=0); TBuf8<KBufferLength> generatedsecondPartOfEucJpPacked; test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfEucJpPacked, aOriginalUnicode.Mid(i-returnValue))==0); generatedEucJpPacked.Append(generatedsecondPartOfEucJpPacked); TInt state=CCnvCharacterSetConverter::KStateDefault; TBuf16<KBufferLength> generatedUnicode; test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedEucJpPacked, state)==0); test(generatedUnicode==aOriginalUnicode); } }
// ----------------------------------------------------------------------------- // CSyncMLFilterProperty::SetQueryValueText16L // Sets query value for text16 property. // This is useful only if data type is text16 and if query value can be used. // This method also selects query value. // ----------------------------------------------------------------------------- EXPORT_C void CSyncMLFilterProperty::SetQueryValueText16L( const TDesC16& aValue ) { if ( iDataTypeForQueryValue != ESyncMLDataTypeText16 || !iCanUseQueryValue ) { User::Leave( KErrNotSupported ); } if ( aValue.Length() > iMaxTextLength ) { User::Leave( KErrArgument ); } delete iQueryValueText16; iQueryValueText16 = NULL; iQueryValueText16 = aValue.AllocL(); iQueryValueSelected = ETrue; }
void TEnvVar::ConstructL(const TDesC16& aName, const wchar_t* aValue) { TPtrC16 valueZ = ValuePtr(aValue); HBufC16* valueCopy = valueZ.AllocLC(); iName = aName.AllocL(); iValue = valueCopy; CleanupStack::Pop(); }
// ----------------------------------------------------------------------------- // JPLangUtil::ConvertFullHiragnaToFullKatakana // Converts Full-width Hiragana and Special Character text found in // aUnicodeSource to their Full-width counterparts and places the // resulting text into aUnicodeTarget. // ----------------------------------------------------------------------------- // EXPORT_C TInt JPLangUtil::ConvertFullHiragnaToFullKatakana ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget ) { TInt totalConverted( 0 ); const TInt length( aUnicodeSource.Length() ); const TInt maxLength( aUnicodeTarget.MaxLength() ); if( length > maxLength ) { return KErrTooBig; } const TUint comp = KFullWidthKatakanaSmallA - KFullWidthHiraganaSmallA; aUnicodeTarget.Zero(); for( TInt i( 0 ); i < length; ++i ) { const TText uniChar( aUnicodeSource[i] ); TText uniChar2(0); if (i + 1 < length) { uniChar2 = aUnicodeSource[i+1]; } // First check if this is this Full Width Katakana if (KFullWidthHiraganaSmallA <= uniChar && uniChar <= KFullWidthHiraganaVU) { if (uniChar == KFullWidthHiraganaU && uniChar2 == KFullWidthHiraganaVoicedSound) { aUnicodeTarget.Append(KFullWidthKatakanaSmallVU); totalConverted++; i++; } else { TUint katakana = uniChar + comp; if (IsKatakana(katakana)) { aUnicodeTarget.Append(katakana); totalConverted++; } } } else { aUnicodeTarget.Append(uniChar); totalConverted++; } } // Now handle special characters // This logic may be moved into this function to avoid another loop over // the text totalConverted += UnicodeTextUtil::ConvertSpecialCharactersInPlace( EFullToHalfWidth, aUnicodeTarget ); return totalConverted; }
/** Gets a matching scheme for the prefix contained in the URI. @param aUri descriptor to URI @return Scheme @panic KErrBadName URI should contain a '.' */ const TPtrC16 TUriShortcutParser16::MatchingScheme( const TDesC16& aUri ) const { TInt pos = aUri.Locate( KSeparatorDot ); //make sure it contains at least one '.' __ASSERT_DEBUG( pos > 0 ,User::Panic( KPanicDescriptor,KErrBadName ) ); TPtrC16 prefix( aUri.Left( pos ) ); TPtrC16 scheme ( DefaultScheme() ); if ( KWww().CompareF( prefix ) == 0 ) { scheme.Set( KHttp() ); } else if ( KFtp().CompareF( prefix ) == 0 ) { scheme.Set( KFtp() ); } else if( CheckUncommonSchemes() ) { if ( KGopher().CompareF( prefix ) == 0 ) { scheme.Set( KGopher() ); } else if ( KTelnet().CompareF( prefix ) == 0 ) { scheme.Set( KTelnet() ); } else if ( KWais().CompareF( prefix ) == 0 ) { scheme.Set( KWais() ); } else if ( KProspero().CompareF( prefix ) == 0 ) { scheme.Set( KProspero() ); } else if ( KNews().CompareF( prefix ) == 0 || KNntp().CompareF( prefix ) == 0 ) { scheme.Set( KNntp() ); } } return scheme; }
//--------------------------------------------------------------------- // //--------------------------------------------------------------------- CLogEntry::CLogEntry(const TDesC16& aMsg, TInt aNbrArg, TInt aArg1, TInt aArg2, TInt aArg3, TInt aArg4) : iNbrArgs(aNbrArg), iArg1(aArg1), iArg2(aArg2), iArg3(aArg3), iArg4(aArg4) { iMsg = HBufC16::New(aMsg.Length()); if(iMsg) { (*iMsg) = aMsg; } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CNcdConfigurationParser::ParseL( const TDesC16& aData ) { DLTRACEIN(("16-bit parse, length=%d",aData.Length())); HBufC8* utf8 = NcdProtocolUtils::ConvertUnicodeToUtf8L( aData ); CleanupStack::PushL( utf8 ); ParseL( *utf8 ); CleanupStack::PopAndDestroy( utf8 ); }
EXPORT_C int Tlitc16ToChar(const TDesC16& aSrc, char* aDes, int& n_size) { unsigned int ilen = 0; int retval = ESuccess; ilen = aSrc.Length(); wchar_t* temp16String = NULL; int minusone = -1; if (0 == ilen ) { return EDescriptorNoData; } else if ( !aDes ) { return EInvalidPointer; } else if (n_size < ilen*2 +1) { n_size = ilen*2 + 1; return EInvalidSize; } temp16String = new wchar_t [ilen+1]; if (!temp16String) { return EInsufficientSystemMemory; } wmemcpy(temp16String, (const wchar_t*)aSrc.Ptr(), ilen); temp16String[ilen] = L'\0'; if(minusone != wcstombs(aDes, temp16String, ilen*2)) { aDes[ilen*2] = '\0'; } else { retval = EInvalidWCSSequence; } delete []temp16String; return retval; }
void CT_ISO2022JP1_2::TestTruncatedConversionFromUnicodeToIso2022Jp( CCnvCharacterSetConverter& aCharacterSetConverter, const TDesC16& aOriginalUnicode) { INFO_PRINTF1(_L(" TestTruncatedConversionFromUnicodeToIso2022Jp ")); for (TInt i=aOriginalUnicode.Length(); i>=0; --i) { TBuf8<KBufferLength> generatedIso2022Jp; const TInt returnValue=aCharacterSetConverter.ConvertFromUnicode(generatedIso2022Jp, aOriginalUnicode.Left(i)); test(returnValue>=0); TBuf8<KBufferLength> generatedsecondPartOfIso2022Jp; test(aCharacterSetConverter.ConvertFromUnicode(generatedsecondPartOfIso2022Jp, aOriginalUnicode.Mid(i-returnValue))==0); generatedIso2022Jp.Append(generatedsecondPartOfIso2022Jp); TInt state=CCnvCharacterSetConverter::KStateDefault; TBuf16<KBufferLength> generatedUnicode; test(aCharacterSetConverter.ConvertToUnicode(generatedUnicode, generatedIso2022Jp, state)==0); test(generatedUnicode==aOriginalUnicode); } }