void loop() { char tmp[3]; int charPosition = 0; // While there is data in the buffer, lets read it. while(client.available()) { char c = client.read(); // Check if we reached the end of the data if(c == ',') { // use the accumulated value pData(tmp); // Reset tmp[0]; charPosition = 0; } else { // Save char in to the temp array tmp[charPosition] = c; // Increment the position of the array charPosition++; } } }
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ void GameObjectType::addChild(Zen::Studio::Workbench::I_ExplorerNode& _selectedNode) { Zen::Studio::Workbench::I_ExplorerNode::pUserData_type pData(new GameObjectType(m_project, "NewObjectType")); m_project.getController().createChildNode(*getNode(), pData); }
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ void Project::onCreated() { /// Create the default child node Zen::Studio::Workbench::I_ExplorerNode::pUserData_type pData(new Folder(*this, "Game Object Types")); getController().createChildNode(*getNode(), pData); }
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ void Folder::newTerrainGroup(Zen::Studio::Workbench::I_ExplorerNode& _selectedNode) { Zen::Studio::Workbench::I_ExplorerNode::pUserData_type pData( new TerrainGroupNode(m_parent, "NewTerrainGroup") ); m_parent.getController().createChildNode(*getNode(), pData); }
void SBVAR::SetupSBVAR(void) { TData_predetermined *data=(TData_predetermined*)pData(); YY=lambda*TransposeMultiply(data->Data(),data->Data()); XX=lambda*TransposeMultiply(data->PredeterminedData(),data->PredeterminedData()); XY=lambda*TransposeMultiply(data->PredeterminedData(),data->Data()); log_likelihood_constant=-lambda_T*n_vars*0.918938533204673; // 0.918938533204673 = 0.5*ln(2*pi) delete data; }
void KbIntCallback( const char* name, int name_len, const char* instruction, int instruction_len, int num_prompts, const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts, LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses, void** anstract ) { if ( num_prompts <= 0 ) { return; } if ( !kbdIntInfo ) { return; } try { std::vector<FSPromptData> pData( num_prompts ); int i; for ( i = 0; i < num_prompts; i++ ) { pData[i].visible = prompts[i].echo != 0; pData[i].prompt = utf8_to_unicode( CopyToStrZ( prompts[i].text, prompts[i].length ).data() ).data(); } static unicode_t userSymbol = '@'; if ( !kbdIntInfo->Prompt( utf8_to_unicode( "SFTP" ).data(), carray_cat<unicode_t>( kbdIntParam->user.Data(), &userSymbol, kbdIntParam->server.Data() ).data(), pData.data(), num_prompts ) ) { return; } for ( i = 0; i < num_prompts; i++ ) { std::vector<char> str = new_char_str( ( char* )FSString( pData[i].prompt.Data() ).Get( kbdIntParam->charset ) ); if ( str.data() ) { int l = strlen( str.data() ); responses[i].length = l; responses[i].text = ( char* ) malloc( l + 1 ); if ( responses[i].text ) { strcpy( responses[i].text, str.data() ); } } } } catch ( cexception* ex ) { fprintf( stderr, "exception in kbdint callback used with libssh2: %s\n", ex->message() ); ex->destroy(); } catch ( ... ) { fprintf( stderr, "excention (...) in kbdint callback used with libssh2\n" ); } }
int CRealControlSocket::ContinueConnect() { wxString host; unsigned int port = 0; const int proxy_type = m_pEngine->GetOptions()->GetOptionVal(OPTION_PROXY_TYPE); if (proxy_type > CProxySocket::unknown && proxy_type < CProxySocket::proxytype_count && !m_pCurrentServer->GetBypassProxy()) { LogMessage(::Status, _("Connecting to %s through proxy"), m_pCurrentServer->FormatHost().c_str()); host = m_pEngine->GetOptions()->GetOption(OPTION_PROXY_HOST); port = m_pEngine->GetOptions()->GetOptionVal(OPTION_PROXY_PORT); delete m_pBackend; m_pProxyBackend = new CProxySocket(this, m_pSocket, this); m_pBackend = m_pProxyBackend; int res = m_pProxyBackend->Handshake((enum CProxySocket::ProxyType)proxy_type, m_pCurrentServer->GetHost(), m_pCurrentServer->GetPort(), m_pEngine->GetOptions()->GetOption(OPTION_PROXY_USER), m_pEngine->GetOptions()->GetOption(OPTION_PROXY_PASS)); if (res != EINPROGRESS) { LogMessage(::Error, _("Could not start proxy handshake: %s"), CSocket::GetErrorDescription(res).c_str()); DoClose(); return FZ_REPLY_ERROR; } } else { if (m_pCurOpData && m_pCurOpData->opId == cmd_connect) { CConnectOpData* pData(static_cast<CConnectOpData*>(m_pCurOpData)); host = ConvertDomainName(pData->host); port = pData->port; } if (host == _T("")) { host = m_pCurrentServer->GetHost(); port = m_pCurrentServer->GetPort(); } } if (!IsIpAddress(host)) LogMessage(Status, _("Resolving address of %s"), host.c_str()); int res = m_pSocket->Connect(host, port); // Treat success same as EINPROGRESS, we wait for connect notification in any case if (res && res != EINPROGRESS) { LogMessage(::Error, _("Could not connect to server: %s"), CSocket::GetErrorDescription(res).c_str()); DoClose(); return FZ_REPLY_ERROR; } return FZ_REPLY_WOULDBLOCK; }
void QEnginioOperationShared::dumpDebugInfo(QDebug &d) const { QRestOperationShared::dumpDebugInfo(d); #if 0 QByteArray json = _client->_requestData.value(_nreply); if (!json.isEmpty()) { if (request.url().toString(QUrl::None).endsWith(QString::fromUtf8("account/auth/identity"))) { qDebug() << "Request Data hidden because it contains password"; } else { qDebug() << "Request Data:" << json; } } if (!pData().isEmpty()) { qDebug() << "Reply Data:" << pData(); } #endif }
void tGauge::SetCaptions() { if( m_Indicators.size() > 0 ) { //Get everything we need from tDigitalData tDigitalData pData( m_Indicators.at( 0 ).dataId ); //Captions and units m_ShortCaption = pData.Caption( true ).toUpper(); m_Caption = pData.Caption( false ).toUpper(); m_UnitsStr = pData.UnitStr(); } }
void tGauge::UnitsChanged( tUnitsType type, int unitsValue ) { if( ( m_Indicators.size() > 0 ) && ( m_UnitsType == type ) ) { tDigitalData pData( m_Indicators.at( 0 ).dataId ); tConvert* pConverter = tConvert::Instance(); //special case for UNITS_ECONOMY. They can be inverted by the user, and we need //to retrieve the new limits from tDigitalData, which handles this. if( type == UNITS_ECONOMY ) { RealLimits.max = pData.MaxConverted(); RealLimits.min = pData.MinConverted(); RealWarnings.max = pData.WarningHighConverted(); RealWarnings.min = pData.WarningLowConverted(); AbsoluteLimits.max = pData.AbsoluteMaxConverted(); AbsoluteLimits.min = pData.AbsoluteMinConverted(); } else { tFloatLimits limits; limits.max = pConverter->ToUser( m_UnitsType, m_UnitsValue, RealLimits.max ); limits.min = pConverter->ToUser( m_UnitsType, m_UnitsValue, RealLimits.min ); tFloatLimits warnings; warnings.max = pConverter->ToUser( m_UnitsType, m_UnitsValue, RealWarnings.max ); warnings.min = pConverter->ToUser( m_UnitsType, m_UnitsValue, RealWarnings.min ); tFloatLimits absLimits; absLimits.max = pConverter->ToUser( m_UnitsType, m_UnitsValue, AbsoluteLimits.max ); absLimits.min = pConverter->ToUser( m_UnitsType, m_UnitsValue, AbsoluteLimits.min ); AbsoluteLimits = absLimits; SetLimits( limits, warnings ); } m_UnitsType = type; m_UnitsValue = unitsValue; int limitIndex = GetCustomHobartLimits(); SetCustomHobartLimits( limitIndex ); OnLimitsChanged(); m_UnitsStr = pData.UnitStr(); ReconfigureGauge(); InvalidateBackground(); } }
size_t BinaryData::ReadFromResource(LPCTSTR lpName, LPCTSTR lpType, HMODULE hModule /* = NULL */) { SetData(); HRSRC hRSRC(FindResource(hModule, lpName, lpType)); if (hRSRC != NULL) { HGLOBAL hRes(LoadResource(hModule, hRSRC)); if (hRes != NULL) { LPVOID pData(LockResource(hRes)); if (pData != NULL) { SetData(pData, SizeofResource(hModule, hRSRC), true); } } } return Size(); }
TDenseMatrix SBVAR::SimulateData(const TDenseVector ¶meters, int n_obs) { TData_predetermined *data=(TData_predetermined*)pData(); int n_exogenous=data->NumberPredeterminedVariables() - data->NumberLags()*data->NumberVariables(); if ((n_exogenous > 1) || ((n_exogenous == 1) && !(data->IsConstant()))) throw dw_exception("SBVAR::SimulateData() - the only exogenous variable permissible is a constant"); if (parameters.dim != NumberParameters()) throw dw_exception("SBVAR::SimulationData() - invalid number of parameters"); SetParameters(parameters.vector); TDenseMatrix A0=GetA0(), Aplus=GetAplus(); return ::SimulateData(n_obs+n_lags,A0,Aplus,data->IsConstant(),n_obs); }
void* FX_OpenFolder(const FX_WCHAR* path) { #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ std::unique_ptr<CFindFileDataW> pData(new CFindFileDataW); pData->m_Handle = FindFirstFileExW((CFX_WideString(path) + L"/*.*").c_str(), FindExInfoStandard, &pData->m_FindData, FindExSearchNameMatch, nullptr, 0); if (pData->m_Handle == INVALID_HANDLE_VALUE) return nullptr; pData->m_bEnd = FALSE; return pData.release(); #else DIR* dir = opendir(CFX_ByteString::FromUnicode(path).c_str()); return dir; #endif }
HBufC8* CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC( TAny*& aCellAddress, TThreadId aThreadId ) { //RDebug::Printf("CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC() - START - aCellAddress: 0x%08x, aThread: %d", aCellAddress, I64INT(aThreadId.Id())); // This is what we'll return, if we find it... HBufC8* heapCellData = NULL; // Now walk the heap! TInt err = iEngine.Driver().WalkHeapInit( aThreadId ); User::LeaveIfError( err ); // Now we can try to find the cell's info TMemSpyDriverCellType cellType; TInt cellLength; TInt cellNestingLevel; TInt cellAllocationNumber; TInt cellHeaderSize; TAny* cellPayloadAddress; // err = iEngine.Driver().WalkHeapGetCellInfo( aCellAddress, cellType, cellLength, cellNestingLevel, cellAllocationNumber, cellHeaderSize, cellPayloadAddress ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC() - err: %d, cellLength: %d, cellAllocationNumber: %d, cellType: %d", err, cellLength, cellAllocationNumber, cellType); User::LeaveIfError( err ); if (cellType & EMemSpyDriverAllocatedCellMask) { const TInt payloadLength = cellLength; HBufC8* data = HBufC8::NewLC( payloadLength ); TPtr8 pData( data->Des() ); // err = iEngine.Driver().WalkHeapReadCellData( aCellAddress, pData, payloadLength ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC() - data fetch returned error: %d", err); User::LeaveIfError( err ); heapCellData = data; CleanupStack::Pop( data ); } // if ( heapCellData == NULL ) { //RDebug::Printf("CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC() - END - didn't find the right cell => KErrNotFound"); User::Leave( KErrNotFound ); } // CleanupStack::PushL( heapCellData ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::SchedulerHeapCellDataLC() - END - everything okay, cell is: 0x%08x", aCellAddress); return heapCellData; }
void tGauge::ChangeDataType( const tDataId& dataId ) { m_SaveLimits = false; if( dataId == DATA_TYPE_INVALID ) { return; } //clear existing indicators m_Indicators.clear(); m_Indicators << tIndicator( dataId ); //set captions and limits tDigitalData pData( dataId ); AbsoluteLimits = pData.AbsoluteLimitsConverted(); tFloatLimits limits( pData.MinConverted(), pData.MaxConverted() ); tFloatLimits warnings( pData.WarningLowConverted(), pData.WarningHighConverted() ); m_UnitsType = pData.Units(); m_UnitsValue = tUnitsSettings::Instance()->Units( m_UnitsType ); //set update timer and update immediately UpdateValues(); //autoconfigure if applicable if( CanAutoConfigure() && AutoConfigure() ) { DoAutoConfigure(); } SetLimits( limits, warnings ); SetCaptions(); //does any type specific config ReconfigureGauge(); m_BackIsCached = false; m_ForeIsCached = false; update(); m_Modified = true; if( m_UnitsType != UNITS_ECONOMY ) { // m_SaveLimits = true; } }
void ListProcessInfo::decapsulate(std::string &message, int id){ namespace bpt = boost::property_tree; std::stringstream ss(message); bpt::ptree pt; bpt::read_json(ss, pt); lock_.lock(); lProcesses.clear(); // std::cout << "--- message ("<< id << ") [" << strip(message)<<"]"<<std::endl; BOOST_FOREACH(const bpt::ptree::value_type& child, pt.get_child("data") ) { std::shared_ptr<ProcessInfo> pData(new ProcessInfo); pData->name = child.second.get<std::string>("name"); // std::cout << "--- name:\t\t\t" << pData->name << std::endl; pData->username = child.second.get<std::string>("username"); // std::cout << "--- username:\t\t" << pData->username << std::endl; pData->status = child.second.get<std::string>("status"); // std::cout << "--- status:\t\t\t" << pData->status << std::endl; pData->cpu_times = child.second.get<std::string>("cpu_times"); // std::cout << "--- cpu_times:\t\t" << pData->cpu_times << std::endl; pData->memory_vms_label = child.second.get<std::string>("memory_vms_label"); // std::cout << "--- memory_vms_label:\t" << pData->memory_vms_label << std::endl; pData->memory_rss_label = child.second.get<std::string>("memory_rss_label"); // std::cout << "--- memory_rss_label:\t" << pData->memory_rss_label << std::endl; pData->memory_vms_info = child.second.get<long>("memory_vms_info"); // std::cout << "--- memory_vms_info:\t\t" << pData->memory_vms_info << std::endl; pData->memory_rss_info = child.second.get<long>("memory_rss_info"); // std::cout << "--- memory_rss_info:\t\t" << pData->memory_rss_info << std::endl; pData->nice = child.second.get<int>("nice"); // std::cout << "--- nice:\t\t\t" << pData->nice << std::endl; pData->pid = child.second.get<int>("pid"); // std::cout << "--- pid:\t" << pData->pid << std::endl; pData->cpu_percent = child.second.get<double>("cpu_percent"); // std::cout << "--- cpu_percent:\t\t" << pData->cpu_percent << std::endl; pData->memory_percent = child.second.get<double>("memory_percent"); // std::cout << "--- memory_percent:\t\t" << pData->memory_percent << std::endl; // cout << " *** name: " << pData->name << endl; lProcesses.push_back ( std::move(pData) ); } processSize = lProcesses.size(); lock_.unlock(); // cout << " *** processSize: " << processSize << endl; }
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ ExplorerNodeFactory::pUserData_type ExplorerNodeFactory::createTerrainChunk(Zen::Studio::Workbench::I_ExplorerNode& _node) { Zen::Studio::Workbench::I_ExplorerNode::UserData* pParentUserData = _node.getUserData().get(); TerrainGroupNode* pParentNode = dynamic_cast<TerrainGroupNode*>(pParentUserData); if (pParentNode != NULL) { // The TerrainGroupNode will get the name from the database later, so // just pass an empty string for now. pUserData_type pData(new TerrainChunkNode(pParentNode->getProject(), "")); return pData; } else { throw Zen::Utility::runtime_exception("Error, invalid parent type."); } }
//************************************************************************************* void CConsoleAlarmAlertSession::SetAlarmL(const RMessage2& aMessage) { TPckg<TASShdAlarm> pA(iAlarm); aMessage.ReadL(KSlot0, pA); if (iAlarm.HasAssociatedData()) { iAlarmAssociatedDataSize = aMessage.GetDesLength(2); TPckg<TAgnAlarmInfo> pB(iAlarmData); aMessage.ReadL(KSlot2, pB); //Storing the data in the server for the test session to read.. HBufC8* data = HBufC8::NewLC(iAlarmAssociatedDataSize); TPtr8 pData(data->Des()); aMessage.ReadL(KSlot2, pData); iServer->SetAttachment(data); //Server takes an ownership CleanupStack::Pop(data); } else iAlarmAssociatedDataSize = 0; }
void CTreSubfile::ParseLevels() { if (m_fLevelsParsed || !m_pSubFile) return; // Levels // Read levels data std::auto_ptr<Byte> pData(new Byte[m_uiMapLevelsLen]); m_pSubFile->Read(pData.get(), m_uiMapLevelsOffset, m_uiMapLevelsLen); // Parse the data from the beginning UInt uiLevelOffset; for (uiLevelOffset = 0; uiLevelOffset < m_uiMapLevelsLen; uiLevelOffset += CMapLevel::cnSize) { // Add level & make it read its data m_Levels.push_back(CMapLevel()); m_Levels.back().Read(pData.get() + uiLevelOffset); } // Tell the last level it's last m_Levels.back().SetLast(); m_fLevelsParsed = true; }
void VJSXMLHttpRequest::Construct(XBOX::VJSParms_construct& ioParms) { XMLHttpRequest* xhr=new XMLHttpRequest(); if(!xhr) { XBOX::vThrowError(VE_XHRQ_IMPL_FAIL_ERROR); return; } XBOX::VJSObject pData(ioParms.GetContext()); bool resData; resData=ioParms.GetParamObject(1, pData); if(resData) { XBOX::VJSValue hostValue=pData.GetProperty("host", NULL); XBOX::VString hostString; bool hostRes=hostValue.GetString(hostString, NULL); if(hostRes) //we have a proxy { XBOX::VJSValue portValue=pData.GetProperty("port", NULL); sLONG portLong=0; bool portRes=portValue.GetLong(&portLong, NULL); portLong=(portRes && portLong>0) ? portLong : 80; //todo : user and passwd XBOX::VError res=xhr->SetProxy(hostString, portLong); if(res!=XBOX::VE_OK) XBOX::vThrowError(res); } } ioParms.ReturnConstructedObject(VJSXMLHttpRequest::CreateInstance(ioParms.GetContextRef(), xhr)); }
tGaugeParams tGauge::GetGaugeParams() { tGaugeParams params; if( m_Indicators.size() > 0 ) { params.m_Limits = tFloatLimits(); tDigitalData pData( tDataId( m_Indicators.at( 0 ).dataId ) ); if( ( tFloatLimits( pData.MinConverted(), pData.MaxConverted() ) != RealLimits ) /*|| m_SaveLimits*/ ) { //the user has set their own limits - save them in base units. params.m_Limits = pData.UnconvertLimits( RealLimits ); } params.m_Warnings = tFloatLimits(); if( ( tFloatLimits( pData.WarningLowConverted(), pData.WarningHighConverted() ) != RealWarnings ) /*|| m_SaveLimits*/ ) { //the user has set their own warnings - save them in base units params.m_Warnings = pData.UnconvertLimits( RealWarnings ); } params.m_DataList = GetDataSources(); params.m_UsesGauge = objectName(); params.m_Geometry = QRect(); params.m_GaugeFlags = GaugeFlags(); if( m_IsOverlay ) { params.m_Geometry = QRect( pos(), size() ); params.m_GaugeType = GaugeType(); } } m_Modified = false; m_SaveLimits = false; return params; }
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~ ExplorerNodeFactory::pUserData_type ExplorerNodeFactory::createFolder(Zen::Studio::Workbench::I_ExplorerNode& _node) { Zen::Studio::Workbench::I_ExplorerNode::UserData* pParentUserData = _node.getUserData().get(); // This is a folder, so quite likely (always?) the parent's user data is // a project. Project* pParentProject = dynamic_cast<Project*>(pParentUserData); if (pParentProject != NULL) { // The Folder will get the name from the database, so just // pass an empty string for now. pUserData_type pData(new Folder(*pParentProject, "")); return pData; } else { throw Zen::Utility::runtime_exception("Error, invalid parent type."); } }
static void TestUtcAlarmDataFunctionalityL() { TheAlarmTest.Test().Next(_L("Test alarm data functionality")); time.HomeTime(); time += TTimeIntervalMinutes(1); id = AddUtcAlarm(time); _LIT8(KAlarmData, "some 8-bit data to attach to the alarm"); ret = TheAlarmTest.Session().AlarmDataAttachL(id, KAlarmData()); TheAlarmTest(ret == KErrNone, __LINE__); ret = TheAlarmTest.Session().AlarmDataSize(id); TheAlarmTest(ret > 0, __LINE__); HBufC8* temp = HBufC8::NewLC(KAlarmData().Size()); TPtr8 pData(temp->Des()); ret = TheAlarmTest.Session().GetAlarmData(id, pData); TheAlarmTest(ret == KErrNone, __LINE__); TheAlarmTest(pData.CompareC(KAlarmData()) == 0, __LINE__); CleanupStack::PopAndDestroy(temp); }
void tGauge::InitialiseLimits() { tDigitalData pData( GetDataId() ); m_UnitsType = pData.Units( GetDataId().DataType() ); m_UnitsValue = tUnitsSettings::Instance()->Units( m_UnitsType ); AbsoluteLimits = pData.AbsoluteLimitsConverted(); //Check for user specified limits, else get from tDigitalData. tFloatLimits limits; if( m_GaugeParams.m_Limits.IsValid() && m_UnitsType != UNITS_ECONOMY ) { limits = pData.ConvertLimits( m_GaugeParams.m_Limits ); } else { limits = tFloatLimits( pData.MinConverted(), pData.MaxConverted() ); } //Check for user specified warnings, else get from tDigitalData. tFloatLimits warnings; if( m_GaugeParams.m_Warnings.IsValid() && m_UnitsType != UNITS_ECONOMY ) { warnings = pData.ConvertLimits( m_GaugeParams.m_Warnings ); } else { warnings = tFloatLimits( pData.WarningLowConverted(), pData.WarningHighConverted() ); } SetCaptions(); //mildly bad form when called from the constructor as SetLimits is virtual.. but base implementation is desired in this case, so all good. tGauge::SetLimits( limits, warnings ); // We may have dynamically changing custom limits. OnLimitsChanged(); }
bool tGauge::UpdateValues() { bool changed = false; for( int i = 0; i < m_Indicators.size(); ++i ) { tDigitalData pData( m_Indicators[ i ].dataId ); float value = 0.0f; if( pData.DampedValueConverted( value ) ) { if( m_Indicators[ i ].value != value || m_Indicators[ i ].isValid == false ) { m_Indicators[ i ].isValid = true; m_Indicators[ i ].value = value; changed = true; } } else { if( m_Indicators[ i ].isValid != false ) { m_Indicators[ i ].isValid = false; changed = true; } } } if( GaugeType() == AnalogGauge ) { setEnabled( AnyValidIndicators() ); } if( changed ) { InvalidateForeground(); } return changed; }
bool CGeppetto::BuildFromInputScript(const tstring& sScript) { FILE* fp = tfopen_asset(GetPath(sScript), "r"); if (!fp) { TError("Could not read input script '" + sScript + "'\n"); return false; } std::shared_ptr<CData> pData(new CData()); CDataSerializer::Read(fp, pData.get()); CData* pOutput = pData->FindChild("Output"); if (!pOutput) { TError("Could not find Output section in input script '" + sScript + "'\n"); return false; } CData* pGame = pData->FindChild("Game"); if (!pGame) { TError("Could not find Game section in input script '" + sScript + "'\n"); return false; } t.SetGameDirectory(FindAbsolutePath(GetPath(pGame->GetValueString()))); tstring sOutputDir = ToForwardSlashes(pOutput->GetValueString()); t.SetOutputDirectory(GetDirectory(sOutputDir)); t.SetOutputFile(GetFilename(sOutputDir)); t.SetScriptDirectory(GetDirectory((GetPath(sScript)))); m_sOutput = FindAbsolutePath(t.GetGameDirectory() + T_DIR_SEP + pOutput->GetValueString()); CData* pSceneAreas = pData->FindChild("SceneAreas"); CData* pMesh = pData->FindChild("Mesh"); CData* pPhysics = pData->FindChild("Physics"); CData* pPhysicsShapes = pData->FindChild("PhysicsShapes"); // Find all file modification times. time_t iScriptModificationTime = GetFileModificationTime(sScript.c_str()); time_t iOutputModificationTime = GetFileModificationTime(m_sOutput.c_str()); tmap<tstring, time_t> aiSceneModificationTimes; if (pSceneAreas) { for (size_t i = 0; i < pSceneAreas->GetNumChildren(); i++) { CData* pArea = pSceneAreas->GetChild(i); if (pArea->GetKey() != "Area") continue; tstring sFile = pArea->FindChildValueString("File"); TAssert(sFile.length()); if (!sFile.length()) continue; auto it = aiSceneModificationTimes.find(sFile); if (it == aiSceneModificationTimes.end()) aiSceneModificationTimes[sFile] = GetFileModificationTime(sFile.c_str()); } } time_t iInputModificationTime = 0; if (pMesh) iInputModificationTime = GetFileModificationTime(pMesh->GetValueString().c_str()); time_t iPhysicsModificationTime = 0; if (pPhysics) iPhysicsModificationTime = GetFileModificationTime(pPhysics->GetValueString().c_str()); bool bRecompile = false; if (iScriptModificationTime > iOutputModificationTime) bRecompile = true; else if (iInputModificationTime > iOutputModificationTime) bRecompile = true; else if (iPhysicsModificationTime > iOutputModificationTime) bRecompile = true; else if (m_iBinaryModificationTime > iOutputModificationTime) bRecompile = true; else { for (auto it = aiSceneModificationTimes.begin(); it != aiSceneModificationTimes.end(); it++) { if (it->second > iOutputModificationTime) { bRecompile = true; break; } } } if (!bRecompile) { if (m_bForceCompile) { TMsg("Forcing rebuild even though no changes detected.\n"); } else { TMsg("No changes detected. Skipping '" + m_sOutput + "'.\n\n"); return true; } } CData* pGlobalTransforms = pData->FindChild("UseGlobalTransforms"); if (pGlobalTransforms) t.UseGlobalTransformations(); else t.UseLocalTransformations(); t.UseUV(); t.UseNormals(); if (pMesh) { tstring sExtension = pMesh->GetValueString().substr(pMesh->GetValueString().length()-4); if (sExtension == ".png") { TUnimplemented(); // Not updated since the switch to materials. int x, y, n; unsigned char* pData = stbi_load((GetPath(pMesh->GetValueString())).c_str(), &x, &y, &n, 0); if (!pData) { TError("Couldn't load '" + pMesh->GetValueString() + "', reason: " + stbi_failure_reason() + "\n"); return false; } stbi_image_free(pData); // Don't need it, just need the dimensions. Vector vecUp = Vector(0, 0, 0.5f) * ((float)y/100); Vector vecLeft = Vector(0, 0.5f, 0) * ((float)x/100); t.UseNormals(false); if (IsAbsolutePath(pMesh->GetValueString())) t.AddMaterial(GetPath(pMesh->GetValueString())); else t.AddMaterial(t.GetOutputDirectory() + "/" + pMesh->GetValueString(), GetPath(pMesh->GetValueString())); t.AddVertex(0, -vecLeft + vecUp, Vector2D(0.0f, 1.0f)); t.AddVertex(0, -vecLeft - vecUp, Vector2D(0.0f, 0.0f)); t.AddVertex(0, vecLeft - vecUp, Vector2D(1.0f, 0.0f)); t.AddVertex(0, -vecLeft + vecUp, Vector2D(0.0f, 1.0f)); t.AddVertex(0, vecLeft - vecUp, Vector2D(1.0f, 0.0f)); t.AddVertex(0, vecLeft + vecUp, Vector2D(1.0f, 1.0f)); } else if (sExtension == ".mat") { CMaterialHandle hMaterial(pMesh->GetValueString()); if (!hMaterial.IsValid()) { TError("Input material '" + pMesh->GetValueString() + "' does not exist or is invalid.\n"); return false; } if (!hMaterial->m_ahTextures.size()) { TError("Input material '" + pMesh->GetValueString() + "' has no textures.\n"); return false; } float w = (float)hMaterial->m_ahTextures[0]->m_iWidth; float h = (float)hMaterial->m_ahTextures[0]->m_iHeight; Vector vecUp = Vector(0, 0.5f, 0) * (h/hMaterial->m_iTexelsPerMeter); Vector vecRight = Vector(0, 0, 0.5f) * (w/hMaterial->m_iTexelsPerMeter); t.UseNormals(false); t.AddMaterial(pMesh->GetValueString()); t.AddVertex(0, -vecRight + vecUp, Vector2D(0.0f, 1.0f)); t.AddVertex(0, -vecRight - vecUp, Vector2D(0.0f, 0.0f)); t.AddVertex(0, vecRight - vecUp, Vector2D(1.0f, 0.0f)); t.AddVertex(0, -vecRight + vecUp, Vector2D(0.0f, 1.0f)); t.AddVertex(0, vecRight - vecUp, Vector2D(1.0f, 0.0f)); t.AddVertex(0, vecRight + vecUp, Vector2D(1.0f, 1.0f)); } else { TMsg("Reading model '" + GetPath(pMesh->GetValueString()) + "' ..."); std::shared_ptr<CConversionScene> pScene(new CConversionScene()); CModelConverter c(pScene.get()); if (!c.ReadModel(GetPath(pMesh->GetValueString()))) { TError("Couldn't read '" + GetPath(pMesh->GetValueString()) + "'.\n"); return false; } TMsg(" Done.\n"); TMsg("Building toy mesh ..."); LoadSceneIntoToy(pScene.get(), &t); TMsg(" Done.\n"); } } if (pPhysics) { TMsg("Reading physics model '" + GetPath(pPhysics->GetValueString()) + "' ..."); std::shared_ptr<CConversionScene> pScene(new CConversionScene()); CModelConverter c(pScene.get()); if (!c.ReadModel(GetPath(pPhysics->GetValueString()))) { TError("Couldn't read '" + GetPath(pPhysics->GetValueString()) + "'.\n"); return false; } TMsg(" Done.\n"); TMsg("Building toy physics model ..."); LoadSceneIntoToyPhysics(pScene.get(), &t); TMsg(" Done.\n"); } if (pPhysicsShapes) { for (size_t i = 0; i < pPhysicsShapes->GetNumChildren(); i++) { CData* pShape = pPhysicsShapes->GetChild(i); TAssert(pShape->GetKey() == "Box"); if (pShape->GetKey() != "Box") continue; TRS trs = pShape->GetValueTRS(); t.AddPhysBox(trs); } } if (pSceneAreas) LoadSceneAreas(pSceneAreas); return Compile(); }
void CMemSpyEngineHelperHeap::OutputHeapDataKernelL(const TMemSpyHeapInfo& aHeapInfo, TBool aCreateDataStream, const RArray<TMemSpyDriverCell>* aCells) { TFullName threadName; MemSpyEngineUtils::GetKernelHeapThreadName( threadName, EFalse ); // Begin a new data stream if ( aCreateDataStream ) { _LIT( KMemSpyFolder, "Heap\\Data" ); _LIT( KMemSpyContext, "Heap Data - %S" ); HBufC* context = HBufC::NewLC( KMaxFileName ); TPtr pContext( context->Des() ); pContext.Format( KMemSpyContext, &threadName ); iEngine.Sink().DataStreamBeginL( pContext, KMemSpyFolder ); CleanupStack::PopAndDestroy( context ); } TBuf<KMaxFullName + 100> printFormat; // Start marker iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KNullDesC, aHeapInfo.Tid() ); // Set overall prefix iEngine.Sink().OutputPrefixSetFormattedLC( KMemSpyPrefixHeapData, &threadName ); // Info section OutputHeapInfoL( aHeapInfo, threadName, aCells ); // Code segments (needed for map file reading...) _LIT(KCellListCodeSegInfoFormat, "CodeSegs - "); iEngine.HelperCodeSegment().OutputCodeSegmentsL( aHeapInfo.Pid(), printFormat, KCellListCodeSegInfoFormat, '-', ETrue ); // Dump section _LIT(KHeaderDump, "Heap Data"); iEngine.Sink().OutputSectionHeadingL( KHeaderDump, '-' ); HBufC8* data = HBufC8::NewLC( 4096 * 12 ); TPtr8 pData(data->Des()); TUint remaining = 0; TUint readAddress = 0; TInt r = iEngine.Driver().GetHeapDataKernel(aHeapInfo.Tid(), pData, readAddress, remaining); TUint prevEndAddress = readAddress + pData.Length(); if (r == KErrNone) { while (r == KErrNone) { if (readAddress > prevEndAddress) { // We've hit a discontinuity, ie one or more unmapped pages _LIT(KBreak, "........"); iEngine.Sink().OutputLineL(KBreak); } _LIT(KHeapDumpDataFormat, "%S"); iEngine.Sink().OutputBinaryDataL(KHeapDumpDataFormat, pData.Ptr(), (const TUint8*) readAddress, pData.Length()); readAddress += pData.Length(); if (remaining > 0) { prevEndAddress = readAddress; r = iEngine.Driver().GetHeapDataKernelNext(aHeapInfo.Tid(), pData, readAddress, remaining); } else break; } } else { _LIT( KHeapFetchError, "Heap error: %d"); iEngine.Sink().OutputLineFormattedL( KHeapFetchError, r ); } CleanupStack::PopAndDestroy( data ); CleanupStack::PopAndDestroy(); // clear prefix // End marker iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KMemSpySinkTagClose, aHeapInfo.Tid() ); if ( aCreateDataStream ) { iEngine.Sink().DataStreamEndL(); } }
TAny* CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL( TAny* aCellAddress, CMemSpyEngineActiveObjectArray& aArray ) { //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - START"); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.cellAddress: 0x%08x", aCellAddress); TAny* nextCellAddress = NULL; TMemSpyDriverCellType cellType; TInt cellLength; TInt cellNestingLevel; TInt cellAllocationNumber; TInt cellHeaderSize; TAny* cellPayloadAddress; // Make a separate copy of the cell address - calling GetCellInfo may well result in the address being // changed in order to match the real starting address of a *heap cell*. TAny* requestedCellAddress = aCellAddress; TInt err = iEngine.Driver().WalkHeapGetCellInfo( requestedCellAddress, cellType, cellLength, cellNestingLevel, cellAllocationNumber, cellHeaderSize, cellPayloadAddress ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - err: %d, cellLength: %d, cellAllocationNumber: %d, cellType: %d", err, cellLength, cellAllocationNumber, cellType); User::LeaveIfError( err ); if (cellType & EMemSpyDriverAllocatedCellMask) { const TInt payloadLength = cellLength; //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - payloadLength: %d", payloadLength); // const TInt payloadLength = Max( 512, cellLength - iHeapInfo.iHeapCellHeaderLengthAllocated ); // Prevent negative payload lengths? CBufFlat* data = CBufFlat::NewL( payloadLength ); CleanupStack::PushL( data ); data->ResizeL( payloadLength ); TPtr8 pData( data->Ptr( 0 ) ); // err = iEngine.Driver().WalkHeapReadCellData( requestedCellAddress, pData, payloadLength ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.heapCellAddress: 0x%08x (err: %d)", requestedCellAddress, err); User::LeaveIfError( err ); // If an object is embedded directly within a class, for example // // class CSomething : public CBase // { // CIdle iEmbeddedIdler; // } // // then aCellAddress actually points to somewhere *within* a heap cell, not to the actual starting address of // the heap cell itself. We must take this into account when parsing the heap cell data (i.e. the bit of the cell we // are interested in starts part way through the cell data). TInt cellOffset = TUint32( aCellAddress ) - TUint32( requestedCellAddress ); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.cellOffset: %d (ignoring cell header)", cellOffset); cellOffset -= cellHeaderSize; //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.cellOffset: %d (adjusted for cell header)", cellOffset); // Got the cell data for the active object. Let's parse it. RBufReadStream stream( *data, cellOffset ); CleanupClosePushL( stream ); // First item should be vTable TAny* vTable = (TAny*) stream.ReadUint32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.vTable: 0x%08x", vTable ); // Next item should be the request status. First the iStatus, then the iFlags const TInt requestStatusValue = stream.ReadInt32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.rsVal: %10d", requestStatusValue ); const TUint requestStatusFlags = stream.ReadUint32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.rsFlags: 0x%02x", requestStatusFlags ); // Next comes the baseclass for the link - TDblQueLinkBase TAny* nextEntryAddress = (TAny*) stream.ReadUint32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.iLink.Next: 0x%08x", nextEntryAddress ); TAny* prevEntryAddress = (TAny*) stream.ReadUint32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.iLink.Prev: 0x%08x", prevEntryAddress ); // Next comes the TPriQueueLink itself const TInt priority = stream.ReadInt32L(); //RDebug::Printf("CMemSpyEngineHelperActiveObject::ReadActiveObjectDataL() - AO.iLink.Pri: %d", priority ); // Done - save object & tidy up CMemSpyEngineActiveObject* object = CMemSpyEngineActiveObject::NewLC( aCellAddress, vTable, priority, requestStatusValue, requestStatusFlags, nextEntryAddress, prevEntryAddress, iEngine ); aArray.AddItemL( object ); CleanupStack::Pop( object ); CleanupStack::PopAndDestroy( 2, data ); // stream & data nextCellAddress = (TAny*) nextEntryAddress; //RDebug::Printf(" "); } return nextCellAddress; }
UIAbout::UIAbout( QWidget* parent ) : QDialog( parent ) { const QString tabString = " "; const QString teamatesMask = "\t<tr>" "\t\t<td>%1 aka %2 (%3)<br />" +tabString +"<a href=\"mailto:%4\">%4</a><br />" +tabString +"%5</td>" "\t</tr>"; const QString linksMask = "\t<tr>" "\t\t<td>%1<br />" +tabString +"<a href=\"%2\">%2</a></td>" "\t</tr>"; const QString donationsMask = "\t<tr>" "\t\t<td>%1 aka %2 (%3)<br />" +tabString +"<a href=\"mailto:%4\">%4</a><br />" +tabString +"%5</td>" "\t</tr>"; const QList<pData> teamates = QList<pData>() << pData( "Filipe Azevedo", "Nox P@sNox", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "Creator & Principal Developer" ) ) << pData( "Kopats Andrei", "hlamer", QObject::tr( "Belarus" ), "*****@*****.**", QObject::tr( "Principal Developer, Class Browser, Beloruss translator" ) ) << pData( "Yannick", "xiantia", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "GNU Debugger Plugin" ) ) << pData( "Roper Alexander", "Minirop", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "Qt Pro Parser, Some Features/Help" ) ) << pData( "Mashin Evgeniy", "evgenM", QObject::tr( "Russia" ), "*****@*****.**", QObject::tr( "Many shared code between our IDEs" ) ) << pData( "Manuel Schmidt", "oversize", QObject::tr( "Germany" ), "*****@*****.**", QObject::tr( "Web Developer & Web Designer" ) ) << pData( "Julien Decologne", "Judd", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "Splashscreen & Icons Designer" ) ) << pData( "Plano Marc", "Marc31", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "French Translator" ) ) << pData( "Lukic Djordje", "rumpl", QObject::tr( "Serbia" ), "*****@*****.**", QObject::tr( "SDK Script Generator" ) ) << pData( QString::fromUtf8( "Aurélien MICHON" ), "aurelien", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "Winter Splashscreen Designer" ) ) ; const QList<pData> links = QList<pData>() << pData( QString::null, QString::null, QString::null, QString( "http://%1" ).arg( PACKAGE_DOMAIN ), QObject::tr( "%1 homepage" ).arg( PACKAGE_NAME ) ) << pData( QString::null, QString::null, QString::null, "https://launchpad.net/monkeystudio", QObject::tr( "Bug tracker" ) ) << pData( QString::null, QString::null, QString::null, "http://monkeystudio.org/forum", QObject::tr( "Forums" ) ) << pData( QString::null, QString::null, QString::null, "http://monkeystudio.org/rss.xml", QObject::tr( "News feed" ) ) << pData( QString::null, QString::null, QString::null, "http://monkeystudio.org/team", QObject::tr( "MkS Team" ) ) << pData( QString::null, QString::null, QString::null, "http://qt.nokia.com", QObject::tr( "Nokia's Qt homepage" ) ) << pData( QString::null, QString::null, QString::null, "http://webissues.mimec.org", QObject::tr( "WebIssues" ) ) << pData( QString::null, QString::null, QString::null, "http://webissues.monkeystudio.org", QObject::tr( "Our WebIssues Server (login/password: anonymous)" ) ) ; const QList<pData> donations = QList<pData>() << pData( "Filipe Azevedo", "Nox P@sNox", QObject::tr( "France" ), "*****@*****.**", QObject::tr( "You can use this <a href=\"%1\">link</a> to make donation. Donations will help paying host/domain, and relatives things about the project." ).arg( PACKAGE_DONATION_LINK ) ) << pData( "Viosoft Corporation", "Viosoft Corporation", QObject::tr( "U.S.A." ), "*****@*****.**", QObject::tr( "<a href=\"http://www.viosoft.com\">Homepage</a>" ) ) ; setAttribute( Qt::WA_DeleteOnClose ); setWindowTitle( tr( "About : %1" ).arg( PACKAGE_NAME ) ); ui = new Ui::UIAbout; ui->setupUi( this ); foreach ( QWidget* widget, findChildren<QWidget*>() ) { widget->setAttribute( Qt::WA_MacSmallSize ); }
void CMemSpyEngineHelperHeap::OutputHeapDataUserL(const TProcessId& aPid, const TThreadId& aTid, const TDesC& aThreadName, const TMemSpyHeapInfo& aInfo, TBool aCreateDataStream, const RArray<TMemSpyDriverCell>* aCells ) { TBuf<KMaxFullName + 100> printFormat; // Begin a new data stream if ( aCreateDataStream ) { _LIT( KMemSpyFolder, "Heap\\Data" ); _LIT( KMemSpyContext, "Heap Data - %S" ); HBufC* context = HBufC::NewLC( KMaxFileName ); TPtr pContext( context->Des() ); pContext.Format( KMemSpyContext, &aThreadName ); iEngine.Sink().DataStreamBeginL( pContext, KMemSpyFolder ); CleanupStack::PopAndDestroy( context ); } // Get the heap info first of all iEngine.ProcessSuspendLC( aPid ); // Start marker iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KNullDesC, (TUint) aTid ); // Set overall prefix iEngine.Sink().OutputPrefixSetFormattedLC( KMemSpyPrefixHeapData, &aThreadName ); // Info section OutputHeapInfoL( aInfo, aThreadName, aCells ); // Code segments (needed for map file reading...) _LIT(KCellListCodeSegInfoFormat, "CodeSegs - "); iEngine.HelperCodeSegment().OutputCodeSegmentsL( aPid, printFormat, KCellListCodeSegInfoFormat, '-', ETrue ); // Dump section _LIT(KHeaderDump, "Heap Data"); iEngine.Sink().OutputSectionHeadingL( KHeaderDump, '-' ); HBufC8* data = HBufC8::NewLC( 4096 * 12 ); TPtr8 pData(data->Des()); TUint remaining = 0; TUint readAddress = 0; // When we obtained the heap info, we also obtained a checksum of all the free cells // within the specified heap. We validate that this hasn't changed at the time we // request the heap data for paranoia purposes (There have been "Issues" with MemSpy // not actually suspending a process between fetching heap info & heap data, causing // a mismatch in free cell information). const TUint32 checksum = aInfo.AsRHeap().Statistics().StatsFree().Checksum(); TRACE( RDebug::Printf( "CMemSpyEngineHelperHeap::OutputHeapDataUserL() - checksum: 0x%08x", checksum ) ); TInt r = iEngine.Driver().GetHeapData( aTid, checksum, pData, readAddress, remaining ); TUint prevEndAddress = readAddress + pData.Length(); if (r == KErrNone) { while (r == KErrNone) { if (readAddress > prevEndAddress) { // We've hit a discontinuity, ie one or more unmapped pages _LIT(KBreak, "........"); iEngine.Sink().OutputLineL(KBreak); } _LIT(KHeapDumpDataFormat, "%S"); iEngine.Sink().OutputBinaryDataL(KHeapDumpDataFormat, pData.Ptr(), (const TUint8*) readAddress, pData.Length()); readAddress += pData.Length(); if (remaining > 0) { prevEndAddress = readAddress; r = iEngine.Driver().GetHeapDataNext(aTid, pData, readAddress, remaining); } else break; } } else { _LIT( KHeapFetchError, "Heap error: %d"); iEngine.Sink().OutputLineFormattedL( KHeapFetchError, r ); } CleanupStack::PopAndDestroy( data ); CleanupStack::PopAndDestroy(); // clear prefix CleanupStack::PopAndDestroy(); // resume process // End marker iEngine.Sink().OutputLineFormattedL( KMemSpyMarkerHeapData, &KMemSpySinkTagClose, (TUint) aTid ); if ( aCreateDataStream ) { iEngine.Sink().DataStreamEndL(); } }