/** 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
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 ); }
// ----------------------------------------------------------------------------- // 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; } }
// ----------------------------------------------------------------------------- // 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; } }
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); }
EXPORT_C void CPTPIPInitCmdAck::SetDeviceFriendlyName(TDesC16& aName) { OstTraceFunctionEntry0( CPTPIPINITCMDACK_SETDEVICEFRIENDLYNAME_ENTRY ); if(KErrNone == iBuffer.Create(aName,aName.Length()+KMTPNullCharLen)) { iBuffer.Append(KMTPNullChar); } }
// ----------------------------------------------------------------------------- // 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; }
//--------------------------------------------------------------------- // //--------------------------------------------------------------------- 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; } }
/** 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; }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // 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 ); }
void ExternalizeDesL(const TDesC16& aDes, RWriteStream& aStream) { TInt length = aDes.Length(); aStream.WriteInt32L(length); if (length > 0) { aStream << aDes; } }
EXPORT_C void CSenLogger::WriteAll(TInt aChannel, TInt aLevel, const TDesC16& aText) { RFileLogger* pLogger = Logger(aChannel, aLevel); if ( pLogger ) { TInt i = 0; TInt lineAmount(KColumnWidth); TInt length = aText.Length(); while(i<aText.Length()) { if ( length - i < KColumnWidth ) { lineAmount = length - i; } pLogger->Write(aText.Mid(i, lineAmount)); i += KColumnWidth; } } }
inline void CPppMsChap2::GenerateNTResponseL( const TDesC8& aAuthenticatorChallenge, const TDesC8& aPeerChallenge, const TDesC8& aUserName, const TDesC16& aPassword, TDes8& aResponse) /** Generates a MS-CHAP-V2 NT-Response. @param aAuthenticatorChallenge [in] The MS-CHAP-V2 authenticator challenge (16 octets). @param aPeerChallenge [in] The MS-CHAP-V2 peer challenge (16 octets). @param aUserName [in] The Microsoft Windows NT username (0 to 256 char). @param aPassword [in] The Microsoft Windows NT password (0 to 256 unicode char). @param aResponse [out] The MS-CHAP-V2 Challenge Response, NT-Response (24 octets). @note This function implements the GenerateNTResponse routine specified in RFC 2759. @internalComponent */ { ASSERT(aAuthenticatorChallenge.Length() == KPppMsChap2AuthenticatorChallengeSize); ASSERT(aPeerChallenge.Length() == KPppMsChap2PeerChallengeSize); ASSERT(aUserName.Length() <= KPppMsChapMaxNTUserNameLength); ASSERT(aPassword.Length() <= KPppMsChapMaxNTPasswordLength); ASSERT(aResponse.Length() == KPppMsChap2NTResponseSize); HBufC8* challengeHashBuf = HBufC8::NewMaxLC(KPppMsChap2ChallengeHashSize); TPtr8 challengeHash(challengeHashBuf->Des()); ChallengeHashL(aPeerChallenge, aAuthenticatorChallenge, aUserName, challengeHash); HBufC8* paddedPasswordHashBuf = HBufC8::NewLC(KPppMsChap2PaddedHashSize); TPtr8 paddablePasswordHash(paddedPasswordHashBuf->Des()); paddablePasswordHash.SetLength(KPppMsChap2HashSize); NtPasswordHashL(aPassword, paddablePasswordHash); ChallengeResponseL(challengeHash, paddablePasswordHash, aResponse); CleanupStack::PopAndDestroy(paddedPasswordHashBuf); CleanupStack::PopAndDestroy(challengeHashBuf); ASSERT(aResponse.Length()==KPppMsChap2NTResponseSize); }
/** Tests whether the input has a path. @param aUri descriptor to URI @return ETrue if it has a path */ TBool TUriShortcutParser16::HasPath( const TDesC16& aUri ) { for ( TInt i = aUri.Length() - 1; i >= 0; --i ) { if ( aUri[i] == KUriComponentSeparator || aUri[i] == KUriQueryDelimiter || aUri[i] == KUriFragmentDelimiter ) { return ETrue; } } return EFalse; }
void CPppMsChap2::NtPasswordHashL(const TDesC16& aPassword, TDes8& aPasswordHash) /** Computes the hash of the Microsoft Windows NT password using MD4. @param aPassword [in] The Microsoft Windows NT password (0 to 256 Unicode char). @param aPasswordHash [out] The MD4 hash of the Microsoft Windows NT password (16 octets). @note This function implements the NtPasswordHash routine specified in RFC 2759. @internalComponent */ { ASSERT(aPassword.Length() <= KPppMsChapMaxNTPasswordLength); ASSERT(aPasswordHash.Length()==KPppMsChap2HashSize); // The following code does not use the Symbian Security subsystem // components, because they do not provide a MD4 implementation yet. // This is a provisional solution until the Symbian Security subsystem // components will provide a MD4 implementation. CMd4* md4 = CMd4::NewL(); CleanupStack::PushL(md4); // The following code assumes that the data in TDesC16 descriptors is // stored in little endian byte order, which is currently a // characteristic of Symbian OS, so the reinterpret_cast is assumed to // be safe here. md4->Input(TPtrC8(reinterpret_cast<const TUint8*>( aPassword.Ptr()), aPassword.Length()*2)); md4->Output(aPasswordHash); CleanupStack::PopAndDestroy(md4); ASSERT(aPasswordHash.Length()==KPppMsChap2HashSize); }
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 ); }
/** Gets the number of components in the host name. @param aUri descriptor to URI @return Number of components @panic KErrBadName URI should not start with a '.' */ TInt TUriShortcutParser16::ComponentCount( const TDesC16& aUri ) { //make sure first character is not '.' __ASSERT_ALWAYS( aUri[0] != '.', User::Panic( KPanicDescriptor,KErrBadName ) ); TInt nComponentCount = 1; for ( TInt i = aUri.Length() - 1; i > 0; i-- ) { if ( aUri[i] == KSeparatorDot ) { nComponentCount++; } } return nComponentCount; }
// ----------------------------------------------------------------------------- // 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; }
/** @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); } }
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); } }
// ----------------------------------------------------------------------------- // CUpnpHttpFileAccess::ConstructL // Two-phased constructor, called when serving file // ----------------------------------------------------------------------------- // void CUpnpHttpFileAccess::ConstructL( CUpnpHttpSession* aSession, const TDesC8& aHeaderBuffer, const TDesC16& aFilename ) { LOGS1H( iHandle, "%i, CUpnpHttpFileAccess::ConstructL(CUpnpHttpSession*, TDesC8&, TDesC16&)", this ); iHeaderBuffer = HBufC8::NewL( aHeaderBuffer.Length( ) ); iHeaderBuffer->Des().Zero( ); iHeaderBuffer->Des().Append( aHeaderBuffer ); iFileToServe = HBufC16::NewL( aFilename.Length( ) ); iFileToServe->Des().Zero( ); iFileToServe->Des().Append( aFilename ); iHeaderLength = aHeaderBuffer.Length( ); User::LeaveIfError( iFsSession.Connect( ) ); iSession = aSession; iOpenedFile = KNullDesC().AllocL( ); }
// ----------------------------------------------------------------------------- // CSatNotifyCloseChannel::CreateTerminalRespL // Constructs Close channel specific part of terminal response and calls // DOS to send the actual message. // ----------------------------------------------------------------------------- // TInt CSatNotifyCloseChannel::CreateTerminalRespL ( TUint8 aPCmdNumber, TUint8 aGeneralResult, const TDesC16& aAdditionalInfo ) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSATNOTIFYCLOSECHANNEL_CREATETERMINALRESPL_1, "CSAT: CSatNotifyCloseChannel::CreateTerminalRespL"); TTlv tlvSpecificData; // Append general result tag tlvSpecificData.AddTag( KTlvResultTag ); // Append general result tlvSpecificData.AddByte( aGeneralResult ); if ( ( RSat::KMeUnableToProcessCmd == aGeneralResult ) || ( RSat::KNetworkUnableToProcessCmd == aGeneralResult ) || ( RSat::KInteractionWithCCPermanentError == aGeneralResult ) || ( RSat::KErrorRequiredValuesMissing == aGeneralResult ) || ( RSat::KBearerIndepProtocolError == aGeneralResult ) || ( RSat::KFramesError == aGeneralResult )) { // Unsuccessful result requires an additional info byte for ( TInt i = 0; i < aAdditionalInfo.Length(); i++ ) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSATNOTIFYCLOSECHANNEL_CREATETERMINALRESPL_2, "CSAT: CSatNotifyCloseChannel::CreateTerminalRespL, Unsuccessful result"); 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 ); }
// ------------------------------------------------ // LogLit // ------------------------------------------------ // void CMdSLogger::LogLit( const TDesC16& aText ) { if (!iValid) { return; } TInt offset = 0; TInt linecount = 0; TInt length = aText.Length(); while( offset < length ) { TInt partLength = Min( length-offset, KLineLength ); #ifdef MDE_FILE_LOGGING iLog.Write( aText.Mid( offset, partLength ) ); #else RDebug::Print( aText.Mid( offset, partLength ) ); #endif ++linecount; offset += partLength; } CheckSize( linecount ); }
/** * Converts a descriptor of type TLitc16 to Wstring * * @param aSrc is the descriptor to be converted , aDes is the * reference to the Wstring array where the result of conversion * is stored * @return Status code (0 is ESuccess, -1 is EInsufficientMemory, * -5 is EDescriptorNoData) */ EXPORT_C int Tlitc16ToWstring(TDesC16& aSrc, wstring& aDes) { unsigned int ilen = aSrc.Length(); if (0 == ilen) { return EDescriptorNoData; } wchar_t* wcharString = new wchar_t[ilen+1]; if (!wcharString) { return EInsufficientSystemMemory; } wmemcpy((wchar_t*)wcharString, (const wchar_t*)aSrc.Ptr(), ilen); wcharString[ilen] = L'\0'; aDes.assign(wcharString); delete []wcharString; return ESuccess; }
// ----------------------------------------------------------------------------- // JPLangUtil::ConvertFullToHalfWidthKatakana // Converts Full-width Katakana and Special Character text found in // aUnicodeSource to their Half-width counterparts and places the resulting text // into aUnicodeTarget. There will be a 2-for-1 conversion for each Full-width // Voiced and Semi-voiced Katakana character. // (detailed information about the parameters and return values can be found in // the header file) // ----------------------------------------------------------------------------- // EXPORT_C TInt JPLangUtil::ConvertFullToHalfWidthKatakana ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget ) { TInt totalConverted( 0 ); const TInt length( aUnicodeSource.Length() ); const TInt maxLength( aUnicodeTarget.MaxLength() ); if( length > maxLength ) { return KErrTooBig; } aUnicodeTarget.Zero(); for( TInt i( 0 ); i < length; ++i ) { const TText uniChar( aUnicodeSource[i] ); // First check if this is this Full Width Katakana if( ( uniChar >= KFullWidthKatakanaLowerBound && uniChar <= KFullWidthKatakanaUpperBound ) || ( uniChar == KFullWidthKatakanaVoicedSoundMark || uniChar == KFullWidthKatakanaSemiVoicedSoundMark ) ) { // Then check if it is (Semi-)Voiced and convert it properly const TBool isVoiced( UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar ) ); const TBool isSemiVoiced( UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar, ETrue ) ); if( isVoiced || isSemiVoiced ) { if( aUnicodeTarget.Length() + 2 > maxLength ) { // This descriptor can't hold the new data aUnicodeTarget.Zero(); return KErrTooBig; } UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget( EFullToHalfWidth, uniChar, aUnicodeTarget, isSemiVoiced ); totalConverted++; } else { if( aUnicodeTarget.Length() + 1 > maxLength ) { // This descriptor can't hold the new data aUnicodeTarget.Zero(); return KErrTooBig; } aUnicodeTarget.Append( UnicodeTextUtil::ConvertKatakanaChar( EFullToHalfWidth, uniChar ) ); totalConverted++; } } // This is not Full Width Katakana, so copy directly... else { if( aUnicodeTarget.Length() + 1 > maxLength ) { // This descriptor can't hold the new data aUnicodeTarget.Zero(); return KErrTooBig; } const TChar uniCharacter( uniChar ); aUnicodeTarget.Append( uniCharacter ); } } // 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; }
// ----------------------------------------------------------------------------- // JPLangUtil::ConvertHalfToFullWidthKatakana // Converts Half-width Katakana and Special Character text found in // aUnicodeSource to their Full-width counterparts and places the resulting text // into aUnicodeTarget. // (detailed information about the parameters and return values can be found in // the header file) // ----------------------------------------------------------------------------- // EXPORT_C TInt JPLangUtil::ConvertHalfToFullWidthKatakana ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget ) { TInt totalConverted( 0 ); const TInt length( aUnicodeSource.Length() ); if( length > aUnicodeTarget.MaxLength() ) { return KErrTooBig; } aUnicodeTarget.Zero(); for( TInt i( 0 ); i < length; ++i ) { const TText uniChar( aUnicodeSource[i] ); // Check if the next character is a Half Width Katakana (Semi-)Voiced // Sound Mark and if the current character + the voiced sound mark have // a Full Width counterpart if( i + 1 < length ) { const TBool isVoiced( ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana ( uniChar ) && ( aUnicodeSource[i + 1] == KHalfWidthKatakanaVoicedSoundMark ) ) ); const TBool isSemiVoiced( ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana ( uniChar, ETrue ) && ( aUnicodeSource[i + 1] == KHalfWidthKatakanaSemiVoicedSoundMark ) ) ); if( isVoiced || isSemiVoiced ) { UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget( EHalfToFullWidth, uniChar, aUnicodeTarget, isSemiVoiced ); i++; // Skip the (semi-)voice marker totalConverted++; continue; } } // If not, then just convert directly if in range if( uniChar >= KHalfWidthKatakanaLowerBound && uniChar <= KHalfWidthKatakanaUpperBound ) { aUnicodeTarget.Append( UnicodeTextUtil::ConvertKatakanaChar( EHalfToFullWidth, uniChar ) ); totalConverted++; } // Else this is not Half Width Katakana, so copy directly... else { const TChar uniCharacter( uniChar ); aUnicodeTarget.Append( uniCharacter ); } } // Now handle special characters // This logic may be moved into this function to avoid another // loop over the text. totalConverted += UnicodeTextUtil::ConvertSpecialCharactersInPlace( EHalfToFullWidth, aUnicodeTarget ); return totalConverted; }