void roadmap_internet_open_browser (char *url) { RApaLsSession apaLsSession; const TUid KOSSBrowserUidValue = {0x10008D39}; // 0x1020724D for S60 3rd Ed TUid id(KOSSBrowserUidValue); TApaTaskList taskList(CEikonEnv::Static()->WsSession()); TApaTask task = taskList.FindApp(id); if(task.Exists()) { task.BringToForeground(); task.SendMessage(TUid::Uid(0), TPtrC8((TUint8 *)url,strlen(url))); // UID not used } else { if(!apaLsSession.Handle()) { User::LeaveIfError(apaLsSession.Connect()); } TThreadId thread; TBuf16<128> buf; buf.Copy(TPtrC8((TUint8 *)url,strlen(url))); User::LeaveIfError(apaLsSession.StartDocument(buf, KOSSBrowserUidValue, thread)); apaLsSession.Close(); } }
TPtrC8 Read(TDes8& aTempBuf, TPtrC8& aData, TInt aLength, TPtrC8& aOverflowData) { if (aLength <= aData.Length()) { // Can read it from this buffer TPtrC8 res(aData.Left(aLength)); aData.Set(aData.Mid(aLength)); return res; } else /*if (aLength > aData.Length())*/ { // Descriptor spans wrap point, so need to copy into temp buf aTempBuf.Copy(aData.Left(aTempBuf.MaxLength())); // If anyone's crazy enough to write a platsec diagnostic string longer than 2k, it gets truncated TInt overflowLen = aLength - aData.Length(); aData.Set(aOverflowData); // Wrap aData aOverflowData.Set(TPtrC8()); if (overflowLen > aData.Length()) { ASSERT(EFalse); // Shouldn't happen // in urel, return everything we've got return aData; } aTempBuf.Append(aData.Left(overflowLen)); aData.Set(aData.Mid(overflowLen)); return TPtrC8(aTempBuf); } }
void TclPrint2(const char* aFmt, const char* aStr, int aNum) { TBuf<128> fmt; fmt.Copy(TPtrC8((const TUint8*)aFmt)); TBuf<128> str; str.Copy(TPtrC8((const TUint8*)aStr)); RDebug::Print(fmt, &str, aNum); }
// ---------------------------------------------------------------------------- // Creates a narrow ptr descriptor on a unicode descriptor // ---------------------------------------------------------------------------- // EXPORT_C TPtrC8 MPXUser::Ptr(const TDesC& aDes) { #ifdef _UNICODE TInt len=aDes.Length()*2; // Unicode->Narrow return TPtrC8((TUint8*)(&aDes[0]),len); #else return TPtrC8(aDes); #endif }
TInt CheckKeywords() // // ensure that the keyword table is in alphabetical order // { for (TInt ii=1;ii<KSqlKeywordCount;++ii) __ASSERT(TPtrC8(KSqlKeywords[ii-1])<TPtrC8(KSqlKeywords[ii])); return 1; }
/** @return Represents the content of the current flat buffer field as binary (8 bit) descriptor. If the current flat buffer field type does not refer to a binary block of data, then the function will do a data conversion as described in the table which can be found in SqlBufIterator.h file. */ TPtrC8 TSqlBufRIterator::Binary() const { __ASSERT_DEBUG(iCurrent >= iBegin && iCurrent < iEnd, __SQLPANIC(ESqlPanicInternalError)); TInt size = Size(); if(Type() != ESqlBinary || size == 0) { return TPtrC8(); } return TPtrC8(reinterpret_cast <const TUint8*> (iBegin) + iCurrent->iPos, size); }
// ---------------------------------------------------------- // CSimpleNamespace::URI // ---------------------------------------------------------- // TPtrC8 CSimpleNamespace::URI() { if ( iUri ) { return TPtrC8(*iUri); } else { return TPtrC8(); } }
// ---------------------------------------------------------- // CSimpleNamespace::Prefix // ---------------------------------------------------------- // TPtrC8 CSimpleNamespace::Prefix() { if ( iPrefix ) { return TPtrC8(*iPrefix); } else { return TPtrC8(); } }
void CMemEntry::Write() // // Write the current entry. // { test(TheFile.Write(TPtrC8((TUint8*)&iEntry,KRomEntrySize))==KErrNone); test(TheFile.Write(TPtrC8((TUint8*)iName->Ptr(),iName->Size()))==KErrNone); TInt rem=EntrySize()-iName->Size()-KRomEntrySize; if (rem) test(TheFile.Write(TheFiller,rem)==KErrNone); }
// ----------------------------------------------------------------------------- // CUpnpDevice::ServiceId // Return service ID. // ----------------------------------------------------------------------------- // EXPORT_C const TPtrC8 CUpnpDevice::ServiceId( const TDesC8 &aServiceType ) { //return Content( KServiceId(), aServiceType ); for( TInt i(0); i < iServiceTypes->Count(); i++) { TInt pos =(*iServiceTypes)[i].Find( aServiceType ); if( pos != KErrNotFound ) return TPtrC8( ( *iServicesId )[i] ); } return TPtrC8( (TUint8*)"", 0); }
void COsmo4AppView::MessageBox(const char *text, const char *title) { HBufC *msg1, *msg2; TInt length = User::StringLength( ( TUint8* ) text) + 1; msg1 = HBufC::NewL( length ); msg1->Des().Copy( TPtrC8(( TText8* ) text) ); length = User::StringLength( ( TUint8* ) title) + 1; msg2 = HBufC::NewL( length ); msg2->Des().Copy( TPtrC8(( TText8* ) title) ); CEikonEnv::Static()->InfoWinL(*msg2, *msg1); delete msg1; delete msg2; }
/** @SYMTestCaseID PDS-SQLITE3SEC-UT-4034 @SYMTestCaseDesc SQL server multi-insert performance test. The test inserts 1000 records in a single transaction and stores the execution time for later use (comparison and printing). @SYMTestPriority High @SYMTestActions SQL server multi-insert performance test. @SYMTestExpectedResults Test must not fail @SYMREQ REQ11320 */ static void SqlServerMultiInsertTest(const char aInsertSql[], TInt aInsertRecCnt) { TheTest.Next( _L("@SYMTestCaseID:PDS-SQLITE3SEC-UT-4034")); (void)KillProcess(KSqlSrvName); TInt err = TheDb.Open(KTestDbName); TEST2(err, KErrNone); RSqlStatement stmt; err = stmt.Prepare(TheDb, TPtrC8((const TUint8*)aInsertSql)); TEST2(err, KErrNone); TUint32 fc = FastCounterValue(); err = TheDb.Exec(_L8("BEGIN")); TEST(err >= 0); for(TInt i=0;i<aInsertRecCnt;++i) { err = stmt.BindInt(0, i + 1); TEST2(err, KErrNone); err = stmt.Exec(); TEST2(err, 1); err = stmt.Reset(); TEST2(err, KErrNone); } err = TheDb.Exec(_L8("COMMIT")); TEST(err >= 0); StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiInsert, FastCounterValue() - fc); stmt.Close(); TheDb.Close(); }
void DoSymbianSpecificCases() { gLogFailureData.iTCTypeName = KSymbianFATSpecific; gLogFailureData.iAPIName= KNone; // the preprocessor macro gives a C/C++ zero-terminated string; use overloaded ::Copy() // Why oh why does TPtrC8 not have a "char *" constructor ... gFileName.Copy(TPtrC8((const TUint8*)__FILE__)); gLogFailureData.iFuncName = KTestLeadingE5Handling; TestLeadingE5Handling(); gLogFailureData.iFuncName = KTestIllegalCharsWithDll; TestIllegalCharsWithDll(); gLogFailureData.iFuncName = KTestIllegalCharsWithoutDLL; TestIllegalCharsWithoutDLL(); gLogFailureData.iFuncName = KTestFileLengthMax; TestFileLengthMax(); gLogFailureData.iFuncName = KTestFileLengthExceedMax; TestFileLengthExceedMax(); gLogFailureData.iFuncName = KTestVFATCase2; TestVFATCase2(); gLogFailureData.iFuncName = KTestVFATCase3; TestVFATCase3(); gLogFailureData.iFuncName = KTestVFATCase1; TestVFATCase1(); }
TPtrC8 CVersionFileReader::GetOldVersion(enum TOldVersionType aVersionType) { if(aVersionType < iOldVersionArray->Count()) { return iOldVersionArray->MdcaPoint(aVersionType); } return TPtrC8(); }
void pcdata_s::TruncateL( TInt aConsumed ) { HBufC8* buffer = TPtrC8((TUint8*)content + aConsumed, length - aConsumed).AllocLC(); SetDataL(*buffer); CleanupStack::PopAndDestroy(); // buffer }
// ----------------------------------------------------------------------------- void CPresenceCacheBuddyInfo::ExternalizeL( RWriteStream& aStream ) const { aStream.WriteInt32L( iAvailability ); ExternalizeFieldL( BuddyId(), aStream ); // externalize expiry time TUint32 time_high = I64HIGH( iExpiryTime ); TUint32 time_low = I64LOW( iExpiryTime ); aStream.WriteUint32L(time_high); aStream.WriteUint32L(time_low); TInt count = iIds.Count(); aStream.WriteInt32L( count ); for ( TInt i=0; i < count; i++ ) { if ( iIds[i] ) { TPtrC key = iIds[i]->Des(); TPtrC8 value = iValues[i] ? iValues[i]->Des() : TPtrC8(); ExternalizeFieldL( key, aStream ); ExternalizeFieldL( value, aStream ); } else { // nothing to insert, special case if replacement has been failed earlier } } }
void CSprocketsEngine::RunL() { DBG("RunL"); TUint length = 0; if(OneMoreMessage(length)){ TPtrC8 temp = TPtrC8(iBuffer->accessRawData(), length); iBuffer->jumpReadPos(length); //need to arm here since ReceiveMessageL may block and cause //multiple active schedulers. iBuffer needs to be consistent and //the reader rearmed. ArmOrCompleteL(); //handle message. WARNING! may block and become reentrant. Weird huh! iConsole->ReceiveMessageL( temp ); DBG("iBuffer->remaining() : %"PRIu32, iBuffer->remaining()); return; //all done } else { // Can only get here if iBuffer did not contain one message last run - // reader must have been armed if(iToNav2) { if (!iToNav2->readData(iBuffer)){ iEngineStatus = ENotConnected; iConsole->Panic(); return; } //wait for new data from nav2. ArmOrCompleteL(); } } DBG("RunL ends."); }
EXPORT_C TPtrC8 CTestConfig::TrimLeft(const TDesC8& aInput) { const TText8* first = aInput.Ptr(); // pointer to first char const TText8* last = first + aInput.Length() - 1; // pointer to last char while (first < last && TChar(*first).IsSpace()) first++; // trim the left return TPtrC8(first, last + 1 - first); // return the result }
/** Reads a record from security policies table. @param aStmtHandle Statement handle. It cannot be NULL. @param aSecurityPolicy Security policies container. @param aObjType Output parameter, will be initialized with the database object type: KDefaultObjType, KDbObjType, RSqlSecurityPolicy::ETable. @param aObjName Output parameter, database object name (for example, table name), which is protected by the current security policy. @param aPolicyType Output parameter, will be initialized with the database policy type: RSqlSecurityPolicy::EReadPolicy, RSqlSecurityPolicy::EWritePolicy, RSqlSecurityPolicy::ESchemaPolicy. @return The created security policy object. @leave KErrGeneral, invalid security policy data; KErrNoMemory, Out of memory. */ TSecurityPolicy TSqlDbSysSettings::ReadCurrSecurityPolicyL(sqlite3_stmt* aStmtHandle, TInt& aObjType, TPtrC& aObjName, TInt& aPolicyType) { __ASSERT_DEBUG(aStmtHandle != NULL, __SQLPANIC(ESqlPanicBadArgument)); aObjType = sqlite3_column_int(aStmtHandle, KObjTypeColIdx); //The "ObjectName" column type might be different than SQLITE_TEXT - malformed database. if(sqlite3_column_type(aStmtHandle, KObjNameColIdx) != SQLITE_TEXT) { __SQLLEAVE(KErrGeneral); } const void* text = sqlite3_column_text16(aStmtHandle, KObjNameColIdx); //Null column value - this might be an indication of an "out of memory" problem, if the column text //is in UTF8 format. (sqlite3_column_text16() may allocate memory for UTF8->UTF16 conversion) __SQLLEAVE_IF_NULL(const_cast<void*>(text)); TInt len = (TUint)sqlite3_column_bytes16(aStmtHandle, KObjNameColIdx) / sizeof(TUint16); aObjName.Set(reinterpret_cast <const TUint16*> (text), len); aPolicyType = sqlite3_column_int(aStmtHandle, KObjPolicyTypeColIdx); len = sqlite3_column_bytes(aStmtHandle, KObjPolicyDataColIdx); if(len != sizeof(TSecurityPolicy)) { //Check if the error is "out of memory" (which may happen when retrieving text column data //and the column encoding is different, in which case the column text has to be converted //and a new block of memory has to be allocated for the conversion). TInt err2 = ::StmtReset(aStmtHandle); __SQLLEAVE(err2 == KErrNoMemory ? KErrNoMemory : KErrGeneral); } const void* data = sqlite3_column_blob(aStmtHandle, KObjPolicyDataColIdx); TSecurityPolicy policy; policy.Set(TPtrC8(reinterpret_cast <const TUint8*> (data), len)); return policy; }
TPtrC8 CStringParser::CurrentLine() const { TInt len=iLastChar-iLineStart; if (len>0 && iInDelimiter) len-=1; return TPtrC8(iLineStart, len); }
void CHandleSynchronization::HandleThirdXmlData(CContentItem* aContentItem,TiXmlElement* aElement) { TiXmlElement* pRecord=aElement->FirstChildElement("uptime"); if(pRecord!=0) { aContentItem->SetPreTimeFlag(atoi(pRecord->FirstChild()->Value())); } // <third id="60">角色扮演</third> pRecord=aElement->FirstChildElement("third"); TInt index=0; while(pRecord!=0) { HBufC* buf = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8((const TUint8*)pRecord->FirstChild()->Value())); CleanupStack::PushL(buf); iMainEngine.WriteLog16(_L("------3-----")); iMainEngine.WriteLog16(*buf); aContentItem->AppendChildItem(*buf,atoi(pRecord->Attribute("id")),0); CleanupStack::PopAndDestroy(1); iMainEngine.WriteLog16(aContentItem->GetChildItem(index).GetName()); iMainEngine.WriteLog16(_L("------3-----")); index++; pRecord=pRecord->NextSiblingElement("third"); } }
void fatal(char *fmt, ...) { char buf[128]; TInt block; RHeap &heap = User::Heap(); TInt avail = heap.Available(block); RDebug::Printf( "Max: %d, Size: %d, Avail: %d, Large Block: %d", (int)heap.MaxLength(), (int)heap.Size(), (int)avail, (int)block ); va_list ap; va_start(ap, fmt); vsnprintf(buf, 127, fmt, ap); va_end(ap); buf[127] = 0; TBuf<128> panic; panic.Copy(TPtrC8((TUint8*)buf)); User::Panic(panic, 0); }
LOCAL_C void testTLitC8() { test.Start(_L("All members")); test (_L8("")==KNullDesC8); // operator const TDesC8& test (KNullDesC8()==TPtrC8()); // operator() const TDesC8* pNull=&KNullDesC8; // operator& test (pNull->Compare(_L8(""))==0); test (&testByRef8(KNullDesC8)==&KNullDesC8); // operator const TRefByValue<const TDesC8> // test.Next(_L("Literal values")); const TDesC8& t1=KLitTest1_8; test (t1.Length()==1); test (t1[0]=='1'); test (t1==_L8("1")); const TDesC8& t12=KLitTest12_8; test (t12.Length()==2); test (t12[0]=='1'); test (t12==_L8("12")); const TDesC8& t123=KLitTest123_8; test (t123.Length()==3); test (t123[0]=='1'); test (t123==_L8("123")); const TDesC8& t1234=KLitTest1234_8; test (t1234.Length()==4); test (t1234[0]=='1'); test (t1234==_L8("1234")); const TDesC8& talpha=KLitTestalpha_8; test (talpha.Length()==26); test (talpha[0]=='a'); test (talpha==_L8("abcdefghijklmnopqrstuvwxyz")); // test.End(); }
EXPORT_C void NSmlDebugPrintArgs8L( const TText8* aFmt, ... ) { VA_LIST args; VA_START (args, aFmt); TInt err(KErrNone); TRAP(err, _NSmlDebugPrintArgs8L(TPtrC8(aFmt), args)); VA_END(args); }
void CResourceManager::OnReceiveData(MResConn* conn, char* data, int length, int comprLen) { if (conn->MainDoc()) { CProbe::FileWrite(KDumpDataFile, TPtrC8((TUint8*) data, length)); } loader_onReceiveData(conn->iRequest, data, length, comprLen); }
// ---------------------------------------------------------- // CBTEnterpriseItSecurityInfoNotifier::StartL // Synchronic notifier launch. Contructs and shows a global // note when temp visibility expire, no parameters need here. // ---------------------------------------------------------- // TPtrC8 CBTEnterpriseItSecurityInfoNotifier::StartL(const TDesC8& /*aBuffer*/) { FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::StartL()")); ShowNoteAndCompleteL(); FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::StartL() completed")); return TPtrC8(KNullDesC8); }
EXPORT_C void TPfkeySendMsgBase::Finalize() { const TInt length = Length()/KWordLen; __ASSERT_DEBUG(Length()%KWordLen == 0, User::Panic(_L("SA"),0)); TPtrC8 len = TPtrC8((TUint8 *)&length, sizeof(TUint16)); Replace(_FOFF(struct sadb_msg, sadb_msg_len), sizeof(((struct sadb_msg *)0)->sadb_msg_len), len); }
void CSigComp::ConstructL(TMemorySize aDecompressionMemSize, TCyclesPerBit aCyclesPerBit, TMemorySize aStateMemorySize, const TDesC8& aAlgorithm, const TSigCompStateItem& aStateItem, TBool aUploadState) { ConstructL(aDecompressionMemSize, aCyclesPerBit, aStateMemorySize, aUploadState); RFs rfs; User::LeaveIfError(rfs.Connect()); CleanupClosePushL(rfs); #if !defined(__WINS__) && !defined(__WINSCW__) TParsePtrC parser(RProcess().FileName()); User::LeaveIfError(rfs.SetSessionPath(parser.Drive())); #endif TInt stateLen = 0; RFile file; User::LeaveIfError(file.Open(rfs, aStateItem.iStateValue, EFileRead)); CleanupClosePushL(file); file.Size(stateLen); HBufC8* valueBuf = HBufC8::NewL(stateLen); TPtr8 valueBufDes = valueBuf->Des(); file.Read(valueBufDes, stateLen); CleanupStack::PopAndDestroy(2); // file, rfs CleanupStack::PushL(valueBuf); TStateItem* stateItem = iStateMgr->CreateStateL(NULL, (TInt16)stateLen, aStateItem.iStateAddress, aStateItem.iStateInstruction, aStateItem.iMinimumAccessLength, valueBuf->Ptr(), 0xffff); if (aStateItem.iStateIdentifier.Size() > 0) { if (aStateItem.iStateIdentifier.Compare(TPtrC8( stateItem->iStateIdentifier, 20))) { User::Leave(KErrNotFound); } } iCompressor = CSigCompCompressor::NewL(aAlgorithm, iStateMgr, stateItem, aStateItem.iStateLength, aUploadState); CleanupStack::PopAndDestroy(valueBuf); }
void CLog::Log(TRefByValue<const TDesC> aFmt,...) { VA_LIST list; VA_START(list,aFmt); TBuf<KMaxLogLength> buf; buf.FormatList(aFmt,list); iLogFile.Write(TPtrC8((TUint8 *)buf.Ptr(),buf.Size())); iLogFile.Flush(); iTest.Printf(buf); }
// ----------------------------------------------------------------------------- TPtrC8 CPresenceCacheBuddyInfo::GetAnyField( const TDesC16& aKey ) { HBufC8* val = NULL; TInt* pos = iHashMap.Find( STRCNST( aKey ) ); if ( pos ) { val = iValues[*pos]; } return val ? val->Des() : TPtrC8(); }