// // SetFileName // // Implemented for IFileSinkFilter support // STDMETHODIMP CDump::SetFileName(LPCOLESTR pszFileName,const AM_MEDIA_TYPE *pmt) { // Is this a valid filename supplied CheckPointer(pszFileName,E_POINTER); if(wcslen(pszFileName) > MAX_PATH) return ERROR_FILENAME_EXCED_RANGE; // Take a copy of the filename size_t len = 1+lstrlenW(pszFileName); m_pFileName = new WCHAR[len]; if (m_pFileName == 0) return E_OUTOFMEMORY; HRESULT hr = StringCchCopyW(m_pFileName, len, pszFileName); // Clear the global 'write error' flag that would be set // if we had encountered a problem writing the previous dump file. // (eg. running out of disk space). m_fWriteError = FALSE; // Create the file then close it hr = OpenFile(); CloseFile(); return hr; } // SetFileName
DWORD GetFormattedErrorMessage(__out PWSTR * pwszErrorMessage, DWORD dwMessageId, va_list* arguments) { DWORD dwLength = 0; LPWSTR wszSystemErrorMessage = NULL; do { if (NULL == pwszErrorMessage) { break; } *pwszErrorMessage = NULL; if (NULL == g_hResourceInstance) { #ifdef CORECLR g_hResourceInstance = LoadLibraryEx(g_MAIN_BINARY_NAME, 0, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE); #else g_hResourceInstance = LoadMUILibraryW(g_MAIN_BINARY_NAME, MUI_LANGUAGE_NAME, 0); #endif } dwLength = FormatMessageW( FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ALLOCATE_BUFFER, g_hResourceInstance, dwMessageId, 0, (LPWSTR)&wszSystemErrorMessage, 0, arguments); if (dwLength == 0) { break; } *pwszErrorMessage = new WCHAR[dwLength + 1]; if (*pwszErrorMessage == NULL) { dwLength = 0; break; } if (FAILED(StringCchCopyW(*pwszErrorMessage, dwLength + 1, wszSystemErrorMessage))) { dwLength = 0; delete [] (*pwszErrorMessage); *pwszErrorMessage = NULL; } }while(false); if (NULL != wszSystemErrorMessage) { LocalFree(wszSystemErrorMessage); } return dwLength; }
int __cdecl fwprintfEntry( FILE *stream, const wchar_t *format, ... ) { PDBG_OUTPUTW Filter; PBTR_FILTER_RECORD Record; BTR_PROBE_CONTEXT Context; FWPRINTF Routine; size_t Length; ULONG UserLength; va_list argptr; PULONG_PTR Sp; ULONG Result; WCHAR buffer[512]; BtrFltGetContext(&Context); Routine = Context.Destine; // // N.B. Maximum support 16 arguments // Sp = (PULONG_PTR)&format + 1; Result = (*Routine)(stream, format, Sp[0], Sp[1], Sp[2], Sp[3], Sp[4], Sp[5], Sp[6], Sp[7], Sp[8], Sp[9], Sp[10], Sp[11], Sp[12], Sp[13]); BtrFltSetContext(&Context); __try { va_start(argptr, format); StringCchVPrintfW(buffer, 512, format, argptr); Length = wcslen(buffer) + 1; va_end(argptr); UserLength = FIELD_OFFSET(DBG_OUTPUTW, Text[Length]); Record = BtrFltAllocateRecord(UserLength, DbgUuid, _fwprintf); if (!Record) { return Result; } Filter = FILTER_RECORD_POINTER(Record, DBG_OUTPUTW); Filter->Length = Length; StringCchCopyW(Filter->Text, Length, buffer); BtrFltQueueRecord(Record); } __except (EXCEPTION_EXECUTE_HANDLER) { if (Record) { BtrFltFreeRecord(Record); } } return Result; }
HRESULT OnRender(HDC hdc, const RECT &rcPaint) { WCHAR wzText[512]; FillRect(hdc, &rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH)); StringCchCopyW(wzText, ARRAYSIZE(wzText), L"Source: "); switch(g_inputSource.deviceType) { case IMDT_UNAVAILABLE: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Unavailable\n"); break; case IMDT_KEYBOARD: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Keyboard\n"); break; case IMDT_MOUSE: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Mouse\n"); break; case IMDT_TOUCH: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Touch\n"); break; case IMDT_PEN: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Pen\n"); break; } StringCchCatW(wzText, ARRAYSIZE(wzText), L"Origin: "); switch(g_inputSource.originId) { case IMO_UNAVAILABLE: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Unavailable\n"); break; case IMO_HARDWARE: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Hardware\n"); break; case IMO_INJECTED: StringCchCatW(wzText, ARRAYSIZE(wzText), L"Injected\n"); break; case IMO_SYSTEM: StringCchCatW(wzText, ARRAYSIZE(wzText), L"System\n"); break; } DrawText(hdc, wzText, (int)wcslen(wzText), (LPRECT)&rcPaint, DT_TOP | DT_LEFT); return S_OK; }
//----------------------------------------------------------------------------------- // CImpICommandText::GetCommandText // // @mfunc Echos the current command as text, including all post-processing // operations added. // // @rdesc HResult // @flag S_OK | Method Succeeded // @flag DB_S_DIALECTIGNORED | Method succeeded, but dialect ignored // @flag E_INVALIDARG | ppwszCommand was a null pointer // @flag E_OUTOFMEMORY | Out of Memory // STDMETHODIMP CImpICommandText::GetCommandText ( GUID *pguidDialect, //@parm INOUT | Guid denoting the dialect of sql LPOLESTR *ppwszCommand //@parm OUT | Pointer for the command text ) { HRESULT hr; // Check Function Arguments if( ppwszCommand == NULL ) { hr = ResultFromScode(E_INVALIDARG); goto exit; } *ppwszCommand = NULL; // If the command has not been set, make sure the buffer // contains an empty stringt to return to the consumer if( !m_pObj->IsCommandSet() ) { hr = ResultFromScode(DB_E_NOCOMMAND); goto exit; } assert( m_pObj->m_strCmdText ); hr = NOERROR; if( pguidDialect != NULL && *pguidDialect != DBGUID_DEFAULT && *pguidDialect != DBGUID_SAMPLEDIALECT ) { hr = DB_S_DIALECTIGNORED; *pguidDialect = DBGUID_DEFAULT; } // Allocate memory for the string we're going to return to the caller *ppwszCommand = (LPWSTR) PROVIDER_ALLOC( (wcslen(m_pObj->m_strCmdText) + 1) * sizeof(WCHAR)); if( !(*ppwszCommand) ) { hr = ResultFromScode(E_OUTOFMEMORY); goto exit; } // Copy our saved text into the newly allocated string StringCchCopyW(*ppwszCommand,wcslen(m_pObj->m_strCmdText) + 1,m_pObj->m_strCmdText); exit: if( FAILED(hr) && pguidDialect ) memset(pguidDialect, 0, sizeof(GUID)); return hr; }
PEVENT_TRACE_PROPERTIES AllocateTraceProperties ( _In_opt_ PWSTR LoggerName, _In_opt_ PWSTR LogFileName ) { PEVENT_TRACE_PROPERTIES TraceProperties = NULL; ULONG BufferSize; BufferSize = sizeof(EVENT_TRACE_PROPERTIES) + (MAXIMUM_SESSION_NAME + MAX_PATH) * sizeof(WCHAR); TraceProperties = (PEVENT_TRACE_PROPERTIES)malloc(BufferSize); if (TraceProperties == NULL) { wprintf(L"Unable to allocate %d bytes for properties structure.\n", BufferSize); goto Exit; } // // Set the session properties. // ZeroMemory(TraceProperties, BufferSize); TraceProperties->Wnode.BufferSize = BufferSize; TraceProperties->Wnode.Flags = WNODE_FLAG_TRACED_GUID; TraceProperties->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES); TraceProperties->LogFileNameOffset = sizeof(EVENT_TRACE_PROPERTIES) + (MAXIMUM_SESSION_NAME * sizeof(WCHAR)); if (LoggerName != NULL) { StringCchCopyW((LPWSTR)((PCHAR)TraceProperties + TraceProperties->LoggerNameOffset), MAXIMUM_SESSION_NAME, LoggerName); } if (LogFileName != NULL) { StringCchCopyW((LPWSTR)((PCHAR)TraceProperties + TraceProperties->LogFileNameOffset), MAX_PATH, LogFileName); } Exit: return TraceProperties; }
HRESULT CpiReadPropertyList( LPWSTR* ppwzData, CPI_PROPERTY** ppPropList ) { HRESULT hr = S_OK; CPI_PROPERTY* pItm = NULL; LPWSTR pwzName = NULL; // clear list if it already contains items if (*ppPropList) CpiFreePropertyList(*ppPropList); *ppPropList = NULL; // read property count int iPropCnt = 0; hr = WcaReadIntegerFromCaData(ppwzData, &iPropCnt); ExitOnFailure(hr, "Failed to read property count"); for (int i = 0; i < iPropCnt; i++) { // allocate new element pItm = (CPI_PROPERTY*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CPI_PROPERTY)); if (!pItm) ExitFunction1(hr = E_OUTOFMEMORY); // Name hr = WcaReadStringFromCaData(ppwzData, &pwzName); ExitOnFailure(hr, "Failed to read name"); StringCchCopyW(pItm->wzName, countof(pItm->wzName), pwzName); // Value hr = WcaReadStringFromCaData(ppwzData, &pItm->pwzValue); ExitOnFailure(hr, "Failed to read property value"); // add to list if (*ppPropList) pItm->pNext = *ppPropList; *ppPropList = pItm; pItm = NULL; } hr = S_OK; LExit: // clean up ReleaseStr(pwzName); if (pItm) CpiFreePropertyList(pItm); return hr; }
wchar_t* lstrdup(const wchar_t* asText) { int nLen = asText ? lstrlenW(asText) : 0; wchar_t* psz = (wchar_t*)malloc((nLen+1) * sizeof(*psz)); if (nLen) StringCchCopyW(psz, nLen+1, asText); else psz[0] = 0; return psz; }
//============================================================================ // Set the process-wide behavior of Watson. Default is to prompt. //============================================================================ void SetWatsonType(WATSON_TYPE WatsonType, LCID WatsonLcid, _In_opt_z_ WCHAR *wszAdditionalFiles) { g_WatsonType = WatsonType; g_WatsonLcid = WatsonLcid; if (wszAdditionalFiles) { g_wszAdditionalFiles[0] = '\0'; g_fAdditionalFiles = true; StringCchCopyW(g_wszAdditionalFiles, DIM(g_wszAdditionalFiles), wszAdditionalFiles); } }
/* * Allocate (duplicate) a wide char string. */ PWSTR MEMHEAP::AllocStr(PCWSTR str) { if (str == NULL) return NULL; size_t str_len = wcslen(str) + 1; PWSTR strNew = (PWSTR) Alloc(str_len * sizeof(WCHAR)); HRESULT hr; hr = StringCchCopyW(strNew, str_len, str); ASSERT (SUCCEEDED (hr)); return strNew; }
//------------------------------------------------------------ //描述: void CCommonFunc::GetFileNoExt(wchar_t* strPathName, wchar_t* strName, int iNameLen) { wchar_t strTempPathName[256] = L"\0"; SafeWStringPrintf(strTempPathName, _countof(strTempPathName), L"%s", strPathName); wchar_t* pChar = strTempPathName; while(*pChar != L'.') { pChar++; } *pChar = L'\0'; StringCchCopyW(strName, iNameLen, strTempPathName); }
BOOL GetEventCategory(IN LPCWSTR KeyName, IN LPCWSTR SourceName, IN EVENTLOGRECORD *pevlr, OUT PWCHAR CategoryName) { HANDLE hLibrary = NULL; WCHAR szMessageDLL[MAX_PATH]; LPVOID lpMsgBuf = NULL; if (GetEventMessageFileDLL (KeyName, SourceName, EVENT_CATEGORY_MESSAGE_FILE , szMessageDLL)) { hLibrary = LoadLibraryExW(szMessageDLL, NULL, DONT_RESOLVE_DLL_REFERENCES | LOAD_LIBRARY_AS_DATAFILE); if (hLibrary != NULL) { /* Retrieve the message string. */ if (FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY, hLibrary, pevlr->EventCategory, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&lpMsgBuf, EVENT_MESSAGE_FILE_BUFFER, NULL) != 0) { /* Trim the string */ TrimNulls(lpMsgBuf); /* Copy the category name */ StringCchCopyW(CategoryName, MAX_PATH, lpMsgBuf); } else { LoadStringW(hInst, IDS_NONE, CategoryName, MAX_PATH); } if (hLibrary != NULL) FreeLibrary(hLibrary); /* Free the buffer allocated by FormatMessage */ if (lpMsgBuf) LocalFree(lpMsgBuf); return TRUE; } } LoadStringW(hInst, IDS_NONE, CategoryName, MAX_PATH); return FALSE; }
void HippoIcon::updateTip(const WCHAR *tip) { NOTIFYICONDATA notifyIconData = { 0 }; notifyIconData.uID = 0; notifyIconData.hWnd = window_; notifyIconData.uFlags = NIF_TIP; StringCchCopyW(notifyIconData.szTip, sizeof(notifyIconData.szTip) / sizeof(notifyIconData.szTip[0]), tip); notifyIconData.szTip; Shell_NotifyIcon(NIM_MODIFY, ¬ifyIconData); }
IFACEMETHODIMP OCContextMenu::GetCommandString(UINT_PTR idCmd, UINT uFlags, UINT *pwReserved, LPSTR pszName, UINT cchMax) { HRESULT hr = E_INVALIDARG; if (idCmd == IDM_SHARE) { switch (uFlags) { case GCS_HELPTEXTW: hr = StringCchCopyW(reinterpret_cast<PWSTR>(pszName), cchMax, L"Shares file or directory with ownCloud"); break; case GCS_VERBW: // GCS_VERBW is an optional feature that enables a caller // to discover the canonical name for the verb that is passed in // through idCommand. hr = StringCchCopyW(reinterpret_cast<PWSTR>(pszName), cchMax, L"ownCloudShare"); break; } } return hr; }
wchar_t* lstrdup(const wchar_t* asText, size_t cchExtraSizeAdd /* = 0 */) { size_t nLen = asText ? lstrlenW(asText) : 0; wchar_t* psz = (wchar_t*)malloc((nLen+1+cchExtraSizeAdd) * sizeof(*psz)); if (nLen) StringCchCopyW(psz, nLen+1, asText); // Ensure AsciiZ psz[nLen] = 0; return psz; }
HRESULT WINAPI GetImmFileName(PWSTR lpBuffer, UINT uSize) { UINT length; STRSAFE_LPWSTR Safe = lpBuffer; length = GetSystemDirectoryW(lpBuffer, uSize); if ( length && length < uSize ) { StringCchCatW(Safe, uSize, L"\\"); return StringCchCatW(Safe, uSize, L"imm32.dll"); } return StringCchCopyW(Safe, uSize, L"imm32.dll"); }
HRESULT ScaWebAppExtensionsWrite(IMSAdminBase* piMetabase, LPCWSTR wzRootOfWeb, SCA_WEB_APPLICATION_EXTENSION* pswappextList ) { HRESULT hr = S_OK; LPWSTR wzAppExt = NULL; DWORD cchAppExt; WCHAR wzAppExtension[1024]; WCHAR wzAppExtensions[65536]; SCA_WEB_APPLICATION_EXTENSION* pswappext = NULL; if (!pswappextList) ExitFunction(); ::ZeroMemory(wzAppExtensions, sizeof(wzAppExtensions)); wzAppExt = wzAppExtensions; cchAppExt = countof(wzAppExtensions); pswappext = pswappextList; while (pswappext) { if (0 == lstrcmpW(wzAppExtension, L"*")) StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L"*,%s,%d", pswappext->wzExecutable, pswappext->iAttributes); else if (*pswappext->wzExtension) StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L".%s,%s,%d", pswappext->wzExtension, pswappext->wzExecutable, pswappext->iAttributes); else // blank means "*" (all) StringCchPrintfW(wzAppExtension, countof(wzAppExtension), L"*,%s,%d", pswappext->wzExecutable, pswappext->iAttributes); // if verbs were specified and not the keyword "all" if (pswappext->wzVerbs[0] && CSTR_EQUAL != CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pswappext->wzVerbs, -1, L"all", -1)) { StringCchCatW(wzAppExtension, countof(wzAppExtension), L","); StringCchCatW(wzAppExtension, countof(wzAppExtension), pswappext->wzVerbs); } StringCchCopyW(wzAppExt, cchAppExt, wzAppExtension); wzAppExt += lstrlenW(wzAppExtension) + 1; cchAppExt -= lstrlenW(wzAppExtension) + 1; pswappext = pswappext->pswappextNext; } if (*wzAppExtensions) { hr = ScaWriteMetabaseValue(piMetabase, wzRootOfWeb, NULL, MD_SCRIPT_MAPS, METADATA_INHERIT, IIS_MD_UT_FILE, MULTISZ_METADATA, wzAppExtensions); ExitOnFailure1(hr, "Failed to write AppExtension: '%S'", wzAppExtension); } LExit: return hr; }
/************************************************************************** * CNetFolder::BindToObject */ HRESULT WINAPI CNetFolder::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) { #ifdef HACKY_UNC_PATHS /* Create the target folder info */ PERSIST_FOLDER_TARGET_INFO pfti = {0}; pfti.dwAttributes = -1; pfti.csidl = -1; StringCchCopyW(pfti.szTargetParsingName, MAX_PATH, (WCHAR*)pidl->mkid.abID); return SHELL32_BindToSF(pidlRoot, &pfti, pidl, &CLSID_ShellFSFolder, riid, ppvOut); #else return E_NOTIMPL; #endif }
static HKEY GetKeyW(LPCWSTR appname, BOOL * closekey, BOOL fCreate) { HKEY key = 0; WCHAR achName[MAX_PATH]; #if !MMPROFILECACHE *closekey = TRUE; #else UINT n; ATOM atm; *closekey = FALSE; // // See if we have already used this key // atm = FindAtomW(appname); if (atm != 0) { // Atom exists... search the table for it. for (n=0; n<keyscached; ++n) { if (akeyatoms[n] == atm) { DPF2(("(W)Found existing key for %ls\n", appname)); return ahkey[n]; } } } DPF2(("(W)No key found for %ls\n", appname)); #endif StringCchCopyW(achName, MAX_PATH, KEYNAME ); StrCchCatW(achName, MAX_PATH, appname); if ((!fCreate && RegOpenKeyW(ROOTKEY, achName, &key) == ERROR_SUCCESS) || (fCreate && RegCreateKeyW(ROOTKEY, achName, &key) == ERROR_SUCCESS)) { #if MMPROFILECACHE if (keyscached < KEYSCACHED && (atm = AddAtomW(appname))) { // Add this key to the cache array akeyatoms[keyscached] = atm; ahkey[keyscached] = key; DPF1(("Adding key %ls to cache array in position %d\n", appname, keyscached)); ++keyscached; } else { DPF2(("Not adding key to cache array\n")); *closekey = TRUE; } #endif } return(key); }
bool ConsoleArgs::GetFullFileName(LPCWSTR szSource, const WCBuffer filenameBuffer, bool fOutputFilename) { if (0 == GetCanonFilePath( szSource, filenameBuffer, fOutputFilename)) { if (filenameBuffer[0] == L'\0') { // This could easily fail because of an overflow, but that's OK // we only want what will fit in the output buffer so we can print // a good error message StringCchCopyW(filenameBuffer.GetData(), filenameBuffer.Count() - 4, szSource); // Don't cat on the ..., only stick it in the last 4 characters // to indicate truncation (if the string is short than this it just won't print) StringCchCopyW(filenameBuffer.GetData() + filenameBuffer.Count() - 4, 4, L"..."); } if (GetLastError() == ERROR_FILE_EXISTS) { ASSERT(fOutputFilename); m_output->ShowErrorIdString(FTL_OutputFileExists, ERROR_FATAL, filenameBuffer.Str()); } else { m_output->ShowErrorIdString(FTL_InputFileNameTooLong, ERROR_FATAL, filenameBuffer.Str()); } return false; } return true; }
bool CCommonFunc::SearchFile(wchar_t* strDir, wchar_t* strExt,FileNameSet& Set) { Set.iItemNum = 0; WIN32_FIND_DATA FindFileData; //int iFileNum = 0; HANDLE hFind; wchar_t strSearchPath[256]; SafeWStringPrintf(strSearchPath, _countof(strSearchPath), L"%s\\*.*", strDir); hFind = ::FindFirstFileW(strSearchPath,(LPWIN32_FIND_DATAW)&FindFileData); wchar_t strUppExt[20]; wcscpy_s(strUppExt,_countof(strUppExt), strExt); _wcsupr_s(strUppExt, _countof(strUppExt)); if (hFind != INVALID_HANDLE_VALUE) { do { if((FindFileData.dwFileAttributes &FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY) { size_t iLength = wcslen((wchar_t*)FindFileData.cFileName); //wsprintfW(Set.Items[Set.iItemNum], FindFileData.cFileName); StringCchCopyW(Set.Items[Set.iItemNum], _countof(Set.Items[Set.iItemNum]), FindFileData.cFileName); if(iLength > 1) { int lastLen = 0; wchar_t* pEndChar = (wchar_t*)FindFileData.cFileName + iLength; while(*pEndChar != L'.') { pEndChar--; lastLen++; } pEndChar++; _wcsupr_s(pEndChar, lastLen); if(wcscmp(pEndChar, strUppExt) == 0) { Set.iItemNum++; if(Set.iItemNum >= Set.MAX_ITEM_NUM) { break; } } } } } while(FindNextFile(hFind, &FindFileData)); FindClose(hFind); } return (Set.iItemNum != 0); }
STDMETHODIMP CEapCfg::Initialize( LPCOLESTR pwszMachineName, DWORD dwEapTypeId, ULONG_PTR* puConnectionParam ) { DWORD cch; WCHAR* pwsz = NULL; DWORD dwErr = NO_ERROR; *puConnectionParam = NULL; // // Save machine name as connection param. // // // How many chars are there in the name? // if ( NULL == pwszMachineName ) { dwErr = ERROR_INVALID_PARAMETER; goto LDone; } cch = wcslen(pwszMachineName); pwsz = (WCHAR*) LocalAlloc(LPTR, (cch + 1) * sizeof(WCHAR)); if (NULL == pwsz) { dwErr = GetLastError(); goto LDone; } // // Copy machine name // StringCchCopyW(pwsz, cch+1,pwszMachineName); *puConnectionParam = (ULONG_PTR)pwsz; pwsz = NULL; LDone: LocalFree(pwsz); return(HRESULT_FROM_WIN32(dwErr)); }
// Function returns S_OK and *ppszValue = NULL if retrieved string property is // actually a NULL variant HRESULT WpcuWmiStringFromInstance(IWbemClassObject* piInstance, PCWSTR pcszProperty, PWSTR* ppszValue) { HRESULT hr = E_INVALIDARG; if (piInstance && pcszProperty && ppszValue) { *ppszValue = NULL; VARIANT var; VariantInit(&var); hr = piInstance->Get(pcszProperty, 0, &var, NULL, NULL); if (SUCCEEDED(hr)) { // Only allow BSTR and NULL states if (var.vt != VT_BSTR) { if (var.vt != VT_NULL) { hr = E_FAIL; } else { hr = S_OK; } } else { size_t cch; hr = StringCchLengthW(var.bstrVal, STRSAFE_MAX_CCH, &cch); if (SUCCEEDED(hr)) { // Allocate with null terminator *ppszValue = new WCHAR[++cch]; if (!(*ppszValue)) { hr = E_OUTOFMEMORY; } else { hr = StringCchCopyW(*ppszValue, cch, var.bstrVal); } } } } VariantClear(&var); } return hr; }
inline HRESULT StringCchCatW( LPWSTR pszDest, size_t cchDest, LPCWSTR pszSrc) { HRESULT hr = S_OK; if(cchDest==0||pszDest==nullptr) return STRSAFE_E_INVALID_PARAMETER; size_t lengthDest; if(StringCchLengthW(pszDest,cchDest,&lengthDest)!=S_OK){ hr=STRSAFE_E_INVALID_PARAMETER; }else{ hr=StringCchCopyW(pszDest+lengthDest,cchDest-lengthDest,pszSrc); } return hr; }
STDMETHODIMP BaseFilter::QueryFilterInfo(FILTER_INFO* aInfo) { if (!aInfo) return E_POINTER; if (!mName.empty()) { StringCchCopyW(aInfo->achName, NUMELMS(aInfo->achName), mName.data()); } else { aInfo->achName[0] = L'\0'; } aInfo->pGraph = mGraph; NS_IF_ADDREF(mGraph); return S_OK; }
HRESULT ContentStudioProperties::GetStringW(LPCSTR id, LPWSTR pvalue, size_t cch) { HRESULT hr = S_OK; _variant_t v; _bstr_t bstr; hr = Get(id, v); if (SUCCEEDED(hr)) { bstr = v; std::wstring s = stde::to_wstring(bstr); hr = StringCchCopyW(pvalue, cch, s.c_str()); } return hr; }
HRESULT GetGUIDNameNew(const GUID& guid, WCHAR **ppwsz) { HRESULT hr = S_OK; WCHAR *pName = NULL; LPCWSTR pcwsz = GetGUIDNameConstNew(guid); if (pcwsz) { size_t cchLength = 0; hr = StringCchLengthW(pcwsz, STRSAFE_MAX_CCH, &cchLength); if (FAILED(hr)) { goto done; } pName = (WCHAR*)CoTaskMemAlloc((cchLength + 1) * sizeof(WCHAR)); if (pName == NULL) { hr = E_OUTOFMEMORY; goto done; } hr = StringCchCopyW(pName, cchLength + 1, pcwsz); if (FAILED(hr)) { goto done; } } else { hr = StringFromCLSID(guid, &pName); } done: if (FAILED(hr)) { *ppwsz = NULL; CoTaskMemFree(pName); } else { *ppwsz = pName; } return hr; }
//---------------------------------------------------------------------------- std::wstring FormatReader::StringFromGUID( const GUID& aGuid ) { HRESULT hr = S_OK; WCHAR *pName = NULL; LPCWSTR pcwsz = GetGUIDNameConstNew(aGuid); if (pcwsz) { size_t cchLength = 0; hr = StringCchLengthW(pcwsz, STRSAFE_MAX_CCH, &cchLength); if (FAILED(hr)) { goto done; } pName = (WCHAR*)CoTaskMemAlloc((cchLength + 1) * sizeof(WCHAR)); if (pName == NULL) { hr = E_OUTOFMEMORY; goto done; } hr = StringCchCopyW(pName, cchLength + 1, pcwsz); if (FAILED(hr)) { goto done; } } else { hr = StringFromCLSID(aGuid, &pName); } done: std::wstring result; if (FAILED(hr)) { CoTaskMemFree(pName); } else { result = std::wstring(pName); } return result; }
static void set_buffer(LPWSTR *buffer, LPCWSTR string) { static const WCHAR empty_string[] = {0}; ULONG len; if (string == NULL) string = empty_string; len = (wcslen(string) + 1)*sizeof(WCHAR); LPWSTR tmp = (LPWSTR) heap_realloc(*buffer, len); if (tmp) *buffer = tmp; else len = wcslen(*buffer) + 1; StringCchCopyW(*buffer, len, string); }
//------------------------------------------------------------ //描述: void CCommonFunc::GetFileExt(wchar_t* strPathName, wchar_t* strExt, size_t iStrExtLen) { wchar_t strTempPathName[256] = L"\0"; SafeWStringPrintf(strTempPathName, _countof(strTempPathName), L"%s", strPathName); //wsprintfW(strTempPathName, L"%s", strPathName); wchar_t* pChar = strTempPathName; while(*pChar != L'\0') { pChar++; } while(*pChar != L'.') { pChar--; } pChar++; StringCchCopyW(strExt, iStrExtLen, pChar); }