/* * _DoStdin - get stuff from stdin */ unsigned _DoStdin( LPWDATA w, void *in_buff, unsigned size ) { unsigned rc; char * buff; buff = (char *)in_buff; if( w == NULL ) return( 0 ); if( !w->active) _MakeWindowActive( w ); rc = _GetString( w, buff, size ); if( _GotEOF ) { if( rc < size ) { buff[rc++] = CTRL_Z; } } else { if( (rc+2) < size ) { buff[rc++] = 0x0d; buff[rc++] = 0x0a; } else if( ( rc == 0 ) && ( size == 1 ) ) {/* rc==0 ==> key was enter */ /* kludge to allow readers to get a single new line from the * system */ buff[rc++] = 0x0a; } } return( rc ); } /* _DoStdin */
HRESULT XmlProfileParser::_ParseRandomDataSource(IXMLDOMNode *pXmlNode, Target *pTarget) { CComPtr<IXMLDOMNodeList> spNodeList = nullptr; CComVariant query("RandomDataSource"); HRESULT hr = pXmlNode->selectNodes(query.bstrVal, &spNodeList); if (SUCCEEDED(hr)) { long cNodes; hr = spNodeList->get_length(&cNodes); if (SUCCEEDED(hr) && (cNodes == 1)) { CComPtr<IXMLDOMNode> spNode = nullptr; hr = spNodeList->get_item(0, &spNode); if (SUCCEEDED(hr)) { UINT64 cb; hr = _GetUINT64(spNode, "SizeInBytes", &cb); if (SUCCEEDED(hr) && (S_FALSE != hr)) { pTarget->SetRandomDataWriteBufferSize(cb); string sPath; hr = _GetString(spNode, "FilePath", &sPath); if (SUCCEEDED(hr) && (S_FALSE != hr)) { pTarget->SetRandomDataWriteBufferSourcePath(sPath); } } } } } return hr; }
void Language::Load() { String sTranslatedLanguageFile = IniFileSettings::Instance()->GetLanguageDirectory() + "\\" + m_sName + ".ini"; String sTranslatedContents = FileUtilities::ReadCompleteTextFile(sTranslatedLanguageFile); std::vector<String> vecTranslatedStrings = StringParser::SplitString(sTranslatedContents, "\r\n"); std::vector<String>::iterator iterTranslatedString = vecTranslatedStrings.begin(); std::vector<String>::iterator iterTranslatedStringEnd = vecTranslatedStrings.end(); for (; iterTranslatedString != iterTranslatedStringEnd; iterTranslatedString++) { String sString = (*iterTranslatedString); std::pair<int, String> translatedPair = _GetString(sString); std::map<int, String>::iterator englishPair = mapEnglishContent.find(translatedPair.first); if (englishPair != mapEnglishContent.end()) { m_mapStrings[(*englishPair).second] = translatedPair.second; } } m_bIsLoaded = true; }
HRESULT XmlProfileParser::_ParseWriteBufferContent(IXMLDOMNode *pXmlNode, Target *pTarget) { CComPtr<IXMLDOMNodeList> spNodeList = nullptr; CComVariant query("WriteBufferContent"); HRESULT hr = pXmlNode->selectNodes(query.bstrVal, &spNodeList); if (SUCCEEDED(hr)) { long cNodes; hr = spNodeList->get_length(&cNodes); if (SUCCEEDED(hr) && (cNodes == 1)) { CComPtr<IXMLDOMNode> spNode = nullptr; hr = spNodeList->get_item(0, &spNode); if (SUCCEEDED(hr)) { string sPattern; hr = _GetString(spNode, "Pattern", &sPattern); if (SUCCEEDED(hr) && (hr != S_FALSE)) { if (sPattern == "sequential") { // that's the default option - do nothing } else if (sPattern == "zero") { pTarget->SetZeroWriteBuffers(true); } else if (sPattern == "random") { hr = _ParseRandomDataSource(spNode, pTarget); } else { hr = E_INVALIDARG; } } } } } return hr; }
/********************************************************************* * * _BuildStringDesc * * Notes * (1) */ static const U8 * _BuildStringDesc(unsigned StringIndex) { USB_INFO_BUFFER InfoBuffer; unsigned i; unsigned NumChars; const char * s; // // String Index == 0 means Language identifier. // if (StringIndex == 0) { USB_DEBUGOUT(":Lang"); USB_IB_Init(&InfoBuffer, &_aDescBuffer[0], sizeof(_aDescBuffer)); USB_IB_AddU8(&InfoBuffer, 4); USB_IB_AddU8(&InfoBuffer, USB_DESC_TYPE_STRING); USB_IB_AddU16(&InfoBuffer, 0x409); } else { // // Get string from application // s = _GetString(StringIndex); if (s == NULL) { return NULL; } // // Build the descriptor from string // NumChars = _strlen(s); USB_IB_Init(&InfoBuffer, &_aDescBuffer[0], sizeof(_aDescBuffer)); USB_IB_AddU8(&InfoBuffer, (U8)(2 + 2 * NumChars)); USB_IB_AddU8(&InfoBuffer, USB_DESC_TYPE_STRING); for (i = 0; i < NumChars; i++) { U16 Char16; Char16 = *(s + i); USB_IB_AddU16(&InfoBuffer, Char16); } } return _aDescBuffer; }
void Language::LoadEnglish() { String sEnglishLanguageFile = IniFileSettings::Instance()->GetLanguageDirectory() + "\\english.ini"; String sEnglishContents = FileUtilities::ReadCompleteTextFile(sEnglishLanguageFile); std::vector<String> vecEnglishStrings = StringParser::SplitString(sEnglishContents, "\r\n"); std::vector<String>::iterator iterEnglishString = vecEnglishStrings.begin(); std::vector<String>::iterator iterEnglishStringEnd = vecEnglishStrings.end(); for (; iterEnglishString != iterEnglishStringEnd; iterEnglishString++) { String sString = (*iterEnglishString); if (sString.Left(7) != _T("String_")) continue; std::pair<int, String> pair = _GetString(sString); mapEnglishContent[pair.first] = pair.second; } }
// GetName void CompoundCommand::GetName(BString& name) { name << _GetString(fNameIndex, fName.String()); }
bool XmlProfileParser::ParseFile(const char *pszPath, Profile *pProfile, HMODULE hModule) { assert(pszPath != nullptr); assert(pProfile != nullptr); // import schema from the named resource HRSRC hSchemaXmlResource = FindResource(hModule, L"DISKSPD.XSD", RT_HTML); assert(hSchemaXmlResource != NULL); HGLOBAL hSchemaXml = LoadResource(hModule, hSchemaXmlResource); assert(hSchemaXml != NULL); LPVOID pSchemaXml = LockResource(hSchemaXml); assert(pSchemaXml != NULL); // convert from utf-8 produced by the xsd authoring tool to utf-16 int cchSchemaXml = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pSchemaXml, -1, NULL, 0); vector<WCHAR> vWideSchemaXml(cchSchemaXml); int dwcchWritten = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pSchemaXml, -1, vWideSchemaXml.data(), cchSchemaXml); UNREFERENCED_PARAMETER(dwcchWritten); assert(dwcchWritten == cchSchemaXml); // ... and finally, packed in a bstr for the loadXml interface CComBSTR bSchemaXml(vWideSchemaXml.data()); bool fComInitialized = false; HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED); if (SUCCEEDED(hr)) { fComInitialized = true; CComPtr<IXMLDOMDocument2> spXmlDoc = nullptr; CComPtr<IXMLDOMDocument2> spXmlSchema = nullptr; CComPtr<IXMLDOMSchemaCollection2> spXmlSchemaColl = nullptr; CComPtr<IXMLDOMParseError> spXmlParseError = nullptr; // create com objects and decorate hr = CoCreateInstance(__uuidof(DOMDocument60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlSchema)); if (SUCCEEDED(hr)) { hr = spXmlSchema->put_async(VARIANT_FALSE); } if (SUCCEEDED(hr)) { hr = spXmlSchema->setProperty(CComBSTR("ProhibitDTD"), CComVariant(VARIANT_FALSE)); } if (SUCCEEDED(hr)) { hr = CoCreateInstance(__uuidof(XMLSchemaCache60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlSchemaColl)); } if (SUCCEEDED(hr)) { hr = spXmlSchemaColl->put_validateOnLoad(VARIANT_TRUE); } if (SUCCEEDED(hr)) { hr = CoCreateInstance(__uuidof(DOMDocument60), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&spXmlDoc)); } if (SUCCEEDED(hr)) { hr = spXmlDoc->put_async(VARIANT_FALSE); } if (SUCCEEDED(hr)) { hr = spXmlDoc->put_validateOnParse(VARIANT_TRUE); } if (SUCCEEDED(hr)) { VARIANT_BOOL fvIsOk; hr = spXmlSchema->loadXML(bSchemaXml, &fvIsOk); if (FAILED(hr) || fvIsOk != VARIANT_TRUE) { hr = spXmlSchema->get_parseError(&spXmlParseError); if (SUCCEEDED(hr)) { ReportXmlError("schema", spXmlParseError); } hr = E_FAIL; } } if (SUCCEEDED(hr)) { CComVariant vXmlSchema(spXmlSchema); CComBSTR bNull(""); hr = spXmlSchemaColl->add(bNull, vXmlSchema); } if (SUCCEEDED(hr)) { CComVariant vSchemaCache(spXmlSchemaColl); hr = spXmlDoc->putref_schemas(vSchemaCache); } if (SUCCEEDED(hr)) { VARIANT_BOOL fvIsOk; CComVariant vPath(pszPath); hr = spXmlDoc->load(vPath, &fvIsOk); if (FAILED(hr) || fvIsOk != VARIANT_TRUE) { hr = spXmlDoc->get_parseError(&spXmlParseError); if (SUCCEEDED(hr)) { ReportXmlError("profile", spXmlParseError); } hr = E_FAIL; } } // now parse the specification, if correct if (SUCCEEDED(hr)) { bool fVerbose; hr = _GetVerbose(spXmlDoc, &fVerbose); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pProfile->SetVerbose(fVerbose); } if (SUCCEEDED(hr)) { DWORD dwProgress; hr = _GetProgress(spXmlDoc, &dwProgress); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pProfile->SetProgress(dwProgress); } } if (SUCCEEDED(hr)) { string sResultFormat; hr = _GetString(spXmlDoc, "//Profile/ResultFormat", &sResultFormat); if (SUCCEEDED(hr) && (hr != S_FALSE) && sResultFormat == "xml") { pProfile->SetResultsFormat(ResultsFormat::Xml); } } if (SUCCEEDED(hr)) { string sCreateFiles; hr = _GetString(spXmlDoc, "//Profile/PrecreateFiles", &sCreateFiles); if (SUCCEEDED(hr) && (hr != S_FALSE)) { if (sCreateFiles == "UseMaxSize") { pProfile->SetPrecreateFiles(PrecreateFiles::UseMaxSize); } else if (sCreateFiles == "CreateOnlyFilesWithConstantSizes") { pProfile->SetPrecreateFiles(PrecreateFiles::OnlyFilesWithConstantSizes); } else if (sCreateFiles == "CreateOnlyFilesWithConstantOrZeroSizes") { pProfile->SetPrecreateFiles(PrecreateFiles::OnlyFilesWithConstantOrZeroSizes); } else { hr = E_INVALIDARG; } } } if (SUCCEEDED(hr)) { hr = _ParseEtw(spXmlDoc, pProfile); } if (SUCCEEDED(hr)) { hr = _ParseTimeSpans(spXmlDoc, pProfile); } } } if (fComInitialized) { CoUninitialize(); } return SUCCEEDED(hr); }
HRESULT XmlProfileParser::_ParseTarget(IXMLDOMNode *pXmlNode, Target *pTarget) { string sPath; HRESULT hr = _GetString(pXmlNode, "Path", &sPath); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetPath(sPath); } if (SUCCEEDED(hr)) { DWORD dwBlockSize; hr = _GetDWORD(pXmlNode, "BlockSize", &dwBlockSize); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetBlockSizeInBytes(dwBlockSize); } } if (SUCCEEDED(hr)) { UINT64 ullStrideSize; hr = _GetUINT64(pXmlNode, "StrideSize", &ullStrideSize); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetBlockAlignmentInBytes(ullStrideSize); } } if (SUCCEEDED(hr)) { bool fInterlockedSequential; hr = _GetBool(pXmlNode, "InterlockedSequential", &fInterlockedSequential); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetUseInterlockedSequential(fInterlockedSequential); } } if (SUCCEEDED(hr)) { UINT64 ullBaseFileOffset; hr = _GetUINT64(pXmlNode, "BaseFileOffset", &ullBaseFileOffset); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetBaseFileOffsetInBytes(ullBaseFileOffset); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "SequentialScan", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetSequentialScanHint(fBool); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "RandomAccess", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetRandomAccessHint(fBool); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "TemporaryFile", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetTemporaryFileHint(fBool); } } if (SUCCEEDED(hr)) { bool fUseLargePages; hr = _GetBool(pXmlNode, "UseLargePages", &fUseLargePages); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetUseLargePages(fUseLargePages); } } if (SUCCEEDED(hr)) { DWORD dwRequestCount; hr = _GetDWORD(pXmlNode, "RequestCount", &dwRequestCount); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetRequestCount(dwRequestCount); } } if (SUCCEEDED(hr)) { UINT64 ullRandom; hr = _GetUINT64(pXmlNode, "Random", &ullRandom); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetUseRandomAccessPattern(true); pTarget->SetBlockAlignmentInBytes(ullRandom); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "DisableOSCache", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool) { pTarget->SetCacheMode(TargetCacheMode::DisableOSCache); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "DisableAllCache", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool) { pTarget->SetCacheMode(TargetCacheMode::DisableOSCache); pTarget->SetWriteThroughMode(WriteThroughMode::On); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "DisableLocalCache", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool) { pTarget->SetCacheMode(TargetCacheMode::DisableLocalCache); } } if (SUCCEEDED(hr)) { bool fBool; hr = _GetBool(pXmlNode, "WriteThrough", &fBool); if (SUCCEEDED(hr) && (hr != S_FALSE) && fBool) { pTarget->SetWriteThroughMode(WriteThroughMode::On); } } if (SUCCEEDED(hr)) { hr = _ParseWriteBufferContent(pXmlNode, pTarget); } if (SUCCEEDED(hr)) { DWORD dwBurstSize; hr = _GetDWORD(pXmlNode, "BurstSize", &dwBurstSize); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetBurstSize(dwBurstSize); pTarget->SetUseBurstSize(true); } } if (SUCCEEDED(hr)) { DWORD dwThinkTime; hr = _GetDWORD(pXmlNode, "ThinkTime", &dwThinkTime); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetThinkTime(dwThinkTime); pTarget->SetEnableThinkTime(true); } } if (SUCCEEDED(hr)) { DWORD dwThroughput; hr = _GetDWORD(pXmlNode, "Throughput", &dwThroughput); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetThroughput(dwThroughput); } } if (SUCCEEDED(hr)) { DWORD dwThreadsPerFile; hr = _GetDWORD(pXmlNode, "ThreadsPerFile", &dwThreadsPerFile); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetThreadsPerFile(dwThreadsPerFile); } } if (SUCCEEDED(hr)) { UINT64 ullFileSize; hr = _GetUINT64(pXmlNode, "FileSize", &ullFileSize); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetFileSize(ullFileSize); pTarget->SetCreateFile(true); } } if (SUCCEEDED(hr)) { UINT64 ullMaxFileSize; hr = _GetUINT64(pXmlNode, "MaxFileSize", &ullMaxFileSize); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetMaxFileSize(ullMaxFileSize); } } if (SUCCEEDED(hr)) { UINT32 ulWriteRatio; hr = _GetUINT32(pXmlNode, "WriteRatio", &ulWriteRatio); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetWriteRatio(ulWriteRatio); } } if (SUCCEEDED(hr)) { bool fParallelAsyncIO; hr = _GetBool(pXmlNode, "ParallelAsyncIO", &fParallelAsyncIO); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetUseParallelAsyncIO(fParallelAsyncIO); } } if (SUCCEEDED(hr)) { UINT64 ullThreadStride; hr = _GetUINT64(pXmlNode, "ThreadStride", &ullThreadStride); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetThreadStrideInBytes(ullThreadStride); } } if (SUCCEEDED(hr)) { UINT32 ulIOPriority; hr = _GetUINT32(pXmlNode, "IOPriority", &ulIOPriority); if (SUCCEEDED(hr) && (hr != S_FALSE)) { PRIORITY_HINT hint[] = { IoPriorityHintVeryLow, IoPriorityHintLow, IoPriorityHintNormal }; pTarget->SetIOPriorityHint(hint[ulIOPriority - 1]); } } if (SUCCEEDED(hr)) { UINT32 ulWeight; hr = _GetUINT32(pXmlNode, "Weight", &ulWeight); if (SUCCEEDED(hr) && (hr != S_FALSE)) { pTarget->SetWeight(ulWeight); } } if (SUCCEEDED(hr)) { hr = _ParseThreadTargets(pXmlNode, pTarget); } return hr; }