Example #1
0
VOID
cdecl
CPSUIDbgPrint
(
    LPCSTR   pszFormat,
    ...
)
/*++

Routine Description:

    This fucntion output the debug informat to the debugger

Arguments:

    pszFormat   - format string

    ...         - variable data

Return Value:

    VOID

--*/
{
    va_list         vaList;
    static TCHAR    OutBuf[768];
#ifdef UNICODE
    static WCHAR    FormatBuf[256];
#endif
    //
    // We assume that UNICODE flag is turn on for the compilation, bug the
    // format string passed to here is ASCII version, so we need to convert
    // it to LPWSTR before the wvsprintf()
    //

    va_start(vaList, pszFormat);

#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, 0, pszFormat, -1, FormatBuf, COUNT_ARRAY(FormatBuf));
    StringCchVPrintf(OutBuf, COUNT_ARRAY(OutBuf), FormatBuf, vaList);
#else
    StringCchVPrintf(OutBuf, COUNT_ARRAY(OutBuf), pszFormat, vaList);
#endif
    va_end(vaList);

    OutputDebugString((LPTSTR)OutBuf);
    OutputDebugString(TEXT("\n"));
}
Example #2
0
void RTrace(TCHAR* szFormat, ...)
{
#ifdef MESSAGE_TRACE
	TCHAR szTempBuf[2048] ;
	va_list vlMarker ;

	va_start(vlMarker,szFormat) ;
	StringCchVPrintf(szTempBuf, 2048, szFormat, vlMarker) ;
	va_end(vlMarker) ;

#ifdef LOG_FILE_DEBUG
	USES_CONVERSION;
	char	des[2048];
	CFile logFile;
	int z = (int)wcslen(szTempBuf);

	wcstombs(des, szTempBuf, z);

	des[z - 1] = 0x0d;
	des[z] = 0x0a;

	logFile.Open(L"C:\\Earzone\\EzCam\\EzCamLog.txt", CFile::modeCreate | CFile::modeWrite | CFile::modeNoTruncate);
	logFile.SeekToEnd();
	logFile.Write(des, z + 1);
	logFile.Close();
#endif		// CODEC DEBUG

	OutputDebugString(szTempBuf) ;
#endif		// MESSAGE_TRACE
}
Example #3
0
/// Function name  : appendStringToTextStreamf
// Description     : Appends a formatted string to a TextStream object
///                                             NB: New strings are limited to an expanded size of MAX_STRING characters
// 
// TEXT_STREAM*  pTextStream : [in/out]       TextStream to append
// CONST TCHAR*  szFormat    : [in]           Printf-style formatting string
// ...           ...         : [in][optional] Arguments
// 
BearScriptAPI 
VOID  appendStringToTextStreamf(TEXT_STREAM*  pTextStream, CONST TCHAR*  szFormat, ...)
{
   va_list  pArguments;       // Variable argument pointer

   // Prepare
   pArguments = utilGetFirstVariableArgument(&szFormat);

   /// Assemble input text
   StringCchVPrintf(pTextStream->szAssembledText, MAX_STRING, szFormat, pArguments);

   // [CHECK] Extend buffer if necessary
   //if (pTextStream->iBufferUsed > utilCalculatePercentage(pTextStream->iBufferSize, 85))      // Extend stream if buffer more than 85% full
   if (pTextStream->iBufferUsed + lstrlen(pTextStream->szAssembledText) >= pTextStream->iBufferSize)
   {
      pTextStream->iBufferSize *= 2;
      pTextStream->szBuffer = utilExtendString(pTextStream->szBuffer, pTextStream->iBufferUsed, pTextStream->iBufferSize);
   }

   /// Append input text to existing buffer
   StringCchCopy(getTextStreamBuffer(pTextStream), pTextStream->iBufferSize - pTextStream->iBufferUsed, pTextStream->szAssembledText);

   // Increment current position
   pTextStream->iBufferUsed += lstrlen(pTextStream->szAssembledText);
}
Example #4
0
BOOL WINAPIV LSLogPrintf(int nLevel, LPCSTR pszModule, LPCSTR pszFormat, ...)
{
#if defined(LS_COMPAT_LOGGING)
    if (!pszModule || !pszFormat)
    {
        return FALSE;
    }
    
    BOOL bReturn = FALSE;
    char szMessage[MAX_LINE_LENGTH];
    
    va_list argList;
    va_start(argList, pszFormat);
    
    if (SUCCEEDED(StringCchVPrintf(szMessage, MAX_LINE_LENGTH,
        pszFormat, argList)))
    {
        bReturn = LSLog(nLevel, pszModule, szMessage);
    }
    
    va_end(argList);
    
    return bReturn;
#else
    return TRUE;
#endif // LS_COMPAT_LOGGING
}
Example #5
0
extern void _tMyPrintf(IN  LPCTSTR tracemsg, ...)
{
    TCHAR buf[MAX_PATH + 2048] = { 0 };
    HRESULT ret;

    __try {
        va_list ptr;
        va_start(ptr, tracemsg);

        ret = StringCchVPrintf(
            buf,
            MAX_PATH + 2048,
            tracemsg,
            ptr
            );

        if (ret == S_OK) {
            DWORD ws;
            WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, (DWORD)_tcslen(buf), &ws, NULL);
        }
    }
    __finally {
        ;
    }

    return;
}
Example #6
0
void WINAPI DbgBreakPoint(LPCTSTR pFileName,INT iLine,__format_string LPCTSTR szFormatString,...)
{
    // A debug break point message can have at most 2000 characters if
    // ANSI or UNICODE characters are being used.  A debug break point message
    // can have between 1000 and 2000 double byte characters in it.  If a
    // particular message needs more characters, then the value of this constant
    // should be increased.
    const DWORD MAX_BREAK_POINT_MESSAGE_SIZE = 2000;

    TCHAR szBreakPointMessage[MAX_BREAK_POINT_MESSAGE_SIZE];

    va_list va;
    va_start( va, szFormatString );

    HRESULT hr = StringCchVPrintf( szBreakPointMessage, NUMELMS(szBreakPointMessage), szFormatString, va );

    va_end(va);

    if( FAILED(hr) ) {
        DbgBreak( "ERROR in DbgBreakPoint().  The variable length debug message could not be displayed because StringCchVPrintf() failed." );
        return;
    }

    ::DbgBreakPoint( szBreakPointMessage, pFileName, iLine );
}
Example #7
0
void AddSPASMErrorSessionAnnotation(int nSession, LPCTSTR lpszFormat, ...)
{
    va_list valist;
    va_start(valist, lpszFormat);

    TCHAR szBuffer[256];
    TCHAR szDescription[128] = _T("An error occurred");

    StringCchVPrintf(szDescription, ARRAYSIZE(szDescription), lpszFormat, valist);
    StringCchPrintf(szBuffer, ARRAYSIZE(szBuffer), _T("%s:%d: %s"),
                    curr_input_file, line_num, szDescription);

    va_end(valist);

    list_t *pList = (list_t *) g_ErrorList;
    while (pList != NULL)
    {
        LPERRORINSTANCE lpErr = (LPERRORINSTANCE) pList->data;
        if (lpErr->nSession >= nSession)
        {
            if (lpErr->lpszAnnotation != NULL)
            {
                free(lpErr->lpszAnnotation);
            }
            lpErr->lpszAnnotation = _tcsdup(szBuffer);
        }
        pList = pList->next;
    }
}
HRESULT CRegisterExtension::RegSetKeyValueBinaryPrintf(HKEY hkey, PCWSTR pszKeyFormatString, PCWSTR pszValueName, PCSTR pszBase64, ...) const
{
    va_list argList;
    va_start(argList, pszBase64);

    WCHAR szKeyName[512];
    HRESULT hr = StringCchVPrintf(szKeyName, ARRAYSIZE(szKeyName), pszKeyFormatString, argList);
    if (SUCCEEDED(hr))
    {
        DWORD dwDecodedImageSize, dwSkipChars, dwActualFormat;
        hr = CryptStringToBinaryA(pszBase64, NULL, CRYPT_STRING_BASE64, NULL,
            &dwDecodedImageSize, &dwSkipChars, &dwActualFormat) ? S_OK : E_FAIL;
        if (SUCCEEDED(hr))
        {
            BYTE *pbDecodedImage = (BYTE*)LocalAlloc(LPTR, dwDecodedImageSize);
            hr = pbDecodedImage ? S_OK : E_OUTOFMEMORY;
            if (SUCCEEDED(hr))
            {
                hr = CryptStringToBinaryA(pszBase64, lstrlenA(pszBase64), CRYPT_STRING_BASE64,
                    pbDecodedImage, &dwDecodedImageSize, &dwSkipChars, &dwActualFormat) ? S_OK : E_FAIL;
                if (SUCCEEDED(hr))
                {
                    hr = HRESULT_FROM_WIN32(RegSetKeyValueW(hkey, szKeyName, pszValueName, REG_BINARY, pbDecodedImage, dwDecodedImageSize));
                }
            }
        }
    }

    va_end(argList);

    _UpdateAssocChanged(hr, pszKeyFormatString);
    return hr;
}
Example #9
0
//
// warning -- this function is implemented twice for ansi applications
// linking to the unicode library
//
void WINAPI DbgLogInfo(DWORD Type,DWORD Level,LPCTSTR pFormat,...)
{

    /* Check the current level for this type combination */

    BOOL bAccept = DbgCheckModuleLevel(Type,Level);
    if (bAccept == FALSE) {
        return;
    }

    TCHAR szInfo[2000];

    /* Format the variable length parameter list */

    va_list va;
    va_start(va, pFormat);

    (void)StringCchPrintf(szInfo, NUMELMS(szInfo),
             TEXT("%s(tid %x) %8d : "),
             m_ModuleName,
             GetCurrentThreadId(), timeGetTime() - dwTimeOffset);

    (void)StringCchVPrintf(szInfo + lstrlen(szInfo), NUMELMS(szInfo) - lstrlen(szInfo), pFormat, va);
    (void)StringCchCat(szInfo, NUMELMS(szInfo), TEXT("\r\n"));
    DbgOutString(szInfo);

    va_end(va);
}
Example #10
0
void CControlsModule::WriteLog (LPCWSTR pfunction, int line, LPCWSTR pformat, ...)
{
	LPWSTR pmessage = new WCHAR [256];
	va_list args;
	va_start (args, pformat);
	StringCchVPrintf (pmessage, 256, pformat, args);
	Log (PB_LOG_WARNING, pmessage, pfunction, line);
	delete [] pmessage;
}
void OutputFormattedDebugString(PCWSTR pszFormat, ...)
{
    TCHAR szBuffer[1024];
    va_list pArgPtr;
    va_start(pArgPtr, pszFormat);
    StringCchVPrintf(szBuffer, ARRAYSIZE(szBuffer), pszFormat, pArgPtr);
    va_end(pArgPtr);

    OutputDebugString(szBuffer);
}
Example #12
0
BOOL PRINT_ERRMSG(LPCTSTR szError,...)
{
	static TCHAR   szBuff[128] = PREFIX;
	va_list        vl;
	
	va_start(vl, szError);
	StringCchVPrintf(szBuff + PREFIX_LEN, (128-PREFIX_LEN), szError, vl);
	OutputDebugString(szBuff);
	va_end(vl);

	return FALSE;
}
Example #13
0
int MCDECL wsprtf( PTSTR pf, ... )
{
   static WCHAR _s_sprtfwbuf[1024];
   PWSTR pb = _s_sprtfwbuf;
   int   i = 1;
   va_list arglist;
   va_start(arglist, pf);
   *pb = 0;
   StringCchVPrintf(pb,1024,pf,arglist);
   va_end(arglist);
   wprt(pb);
   return i;
}
Example #14
0
void AppState::LogInfo(const TCHAR *pszFormat, ...)
{
    if (_logFile.m_hFile != INVALID_HANDLE_VALUE)
    {
        TCHAR szMessage[MAX_PATH];
        va_list argList;
        va_start(argList, pszFormat);
        StringCchVPrintf(szMessage, ARRAYSIZE(szMessage), pszFormat, argList);
        StringCchCat(szMessage, ARRAYSIZE(szMessage), TEXT("\n"));
        _logFile.Write(szMessage, lstrlen(szMessage) * sizeof(TCHAR));
        va_end(argList);
    }
}
//
// OutputTraceString
//
// multiple argument front-end to OutputDebugString
//
void OutputTraceString(LPTSTR lpszFormatString, ...)
{
  const DWORD MAX_DEBUGSTR = 256;      // max string for ouput
  va_list arglist;                     // variable argument list
  TCHAR szOutputString[MAX_DEBUGSTR];  // the string to print - limited

  // create the new string limited to the char count as indicated
  va_start(arglist, lpszFormatString);
  StringCchVPrintf(szOutputString, CELEMS( szOutputString ), lpszFormatString, arglist);
  va_end(arglist);

  // send it out
  OutputDebugString(szOutputString);
}
Example #16
0
//
// GetResStrEx
//
void GetResStrEx(HINSTANCE hInstance, UINT uIDText, LPSTR pszText, size_t cchText, LPCSTR pszDefText, ...)
{
    char szFormat[MAX_LINE_LENGTH];
    va_list vargs;
    
    if (pszText != NULL && cchText > 0)
    {
        GetResStr(hInstance, uIDText, szFormat, MAX_LINE_LENGTH, pszDefText);
        
        va_start(vargs, pszDefText);
        StringCchVPrintf(pszText, cchText, szFormat, vargs);
        va_end(vargs);
    }
}
Example #17
0
static void SetLastSPASMProblem(DWORD dwErrorCode, bool fIsWarning, va_list valist)
{
    if (dwErrorCode == SPASM_ERR_SUCCESS)
    {
        return;
    }

    LPERRORINSTANCE lpErr = AllocErrorInstance();
    lpErr->dwErrorCode = dwErrorCode;
    lpErr->line_num = line_num;
    lpErr->lpszFileName = _strdup(curr_input_file);
    //lpErr->fSuppressErrors = suppress_errors;
    lpErr->fIsWarning = fIsWarning;

    TCHAR szBuffer[256];
    TCHAR szDescription[128] = _T("An error occurred");

    for (int i = 0; i < ARRAYSIZE(g_ErrorCodes); i++)
    {
        if (g_ErrorCodes[i].dwCode == lpErr->dwErrorCode)
        {
            StringCchVPrintf(szDescription, ARRAYSIZE(szDescription),
                             g_ErrorCodes[i].lpszDescription, valist);
            break;
        }
    }

    LPCTSTR lpszProblemType = (fIsWarning) ? _T("warning") : _T("error");
    LPCTSTR lpszProblemCode = (fIsWarning) ? _T("SW") : _T("SE");

    if (lpErr->line_num != -1)
    {
        StringCchPrintf(szBuffer, ARRAYSIZE(szBuffer), _T("%s:%d: %s %s%03X: %s"),
                        lpErr->lpszFileName, lpErr->line_num, lpszProblemType, lpszProblemCode, lpErr->dwErrorCode, szDescription);
    }
    else
    {
        StringCchPrintf(szBuffer, ARRAYSIZE(szBuffer), _T("%s: %s %s%03X: %s"),
                        lpErr->lpszFileName, lpszProblemType, lpszProblemCode, lpErr->dwErrorCode, szDescription);
    }

    lpErr->lpszErrorText = _strdup(szBuffer);

    g_ErrorList = (errorlist_t *) list_prepend((list_t *) g_ErrorList, (LPVOID) lpErr);

    //if (suppress_errors == false)
    //{
    //PrintSPASMError(lpErr);
    //}
}
Example #18
0
void __logHelper(PCWSTR pszFmt, ...)
{
    if (g_hStdOut == NULL)
    {
        return;
    }

    va_list arg;
    va_start(arg, pszFmt);
    HRESULT hr = StringCchVPrintf(s_szBuffer, ARRAYSIZE(s_szBuffer), pszFmt, arg);
    if (SUCCEEDED(hr) || (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)))
    {
        WriteConsole(g_hStdOut, s_szBuffer, wcslen(s_szBuffer), NULL, NULL);
    }

}
Example #19
0
void Debug(LPCTSTR szFormat, ...)
{
    static  TCHAR   szHeader[] = TEXT("TUXTest: ");
    TCHAR   szBuffer[1024];

    va_list pArgs;
    va_start(pArgs, szFormat);
    wcscpy_s(szBuffer,_countof(szBuffer),szHeader);

    VERIFY(SUCCEEDED(StringCchVPrintf((szBuffer + wcslen(szHeader)), (_countof(szBuffer)-wcslen(szHeader)) , szFormat,pArgs)));
    va_end(pArgs);

    _tcscat_s(szBuffer, _countof(szBuffer),TEXT("\r\n"));

    OutputDebugString(szBuffer);
}
HRESULT IStream_CchPrintfAsUTF8(IStream *pstm, PCWSTR pszKeyFormatString, ...)
{
    va_list argList;
    va_start(argList, pszKeyFormatString);

    WCHAR szBuffer[2048];
    HRESULT hr = StringCchVPrintf(szBuffer, ARRAYSIZE(szBuffer), pszKeyFormatString, argList);
    if (SUCCEEDED(hr))
    {
        hr = IStream_WriteStringAsUTF8(pstm, szBuffer);
    }

    va_end(argList);

    return hr;
}
Example #21
0
//  error conditions
static
void
MessageBoxError (
    IN  TCHAR * title,
    IN  TCHAR * szfmt,
    ...
    )
{
    TCHAR   achbuffer [512] ;
    va_list va ;

    va_start (va, szfmt) ;
    StringCchVPrintf (achbuffer, NUMELMS(achbuffer), szfmt, va) ;

    MessageBox (NULL, achbuffer, title, MB_OK | MB_ICONEXCLAMATION) ;
}
HRESULT CRegisterExtension::RegSetKeyValuePrintf(HKEY hkey, PCWSTR pszKeyFormatString, PCWSTR pszValueName, const unsigned char pc[], DWORD dwSize, ...) const
{
    va_list argList;
    va_start(argList, pc);

    WCHAR szKeyName[512];
    HRESULT hr = StringCchVPrintf(szKeyName, ARRAYSIZE(szKeyName), pszKeyFormatString, argList);
    if (SUCCEEDED(hr))
    {
        hr = HRESULT_FROM_WIN32(RegSetKeyValueW(hkey, szKeyName, pszValueName, REG_BINARY, pc, dwSize));
    }

    va_end(argList);

    _UpdateAssocChanged(hr, pszKeyFormatString);
    return hr;
}
Example #23
0
VOID
DebugTraceW(
	IN PWSTR Format,
	IN ...
	)
{
	WCHAR Buffer [0x200];
	va_list Arguments;

	va_start(Arguments, Format);

	StringCchVPrintf(Buffer, sizeof(Buffer), Format, Arguments);
	OutputDebugStringW(Buffer);
	OutputDebugStringW(L"\n");
	
	va_end(Arguments);
}
HRESULT CRegisterExtension::RegDeleteKeyValuePrintf(HKEY hkey, PCWSTR pszKeyFormatString, PCWSTR pszValue, ...) const
{
    va_list argList;
    va_start(argList, pszKeyFormatString);

    WCHAR szKeyName[512];
    HRESULT hr = StringCchVPrintf(szKeyName, ARRAYSIZE(szKeyName), pszKeyFormatString, argList);
    if (SUCCEEDED(hr))
    {
        hr = HRESULT_FROM_WIN32(RegDeleteKeyValueW(hkey, szKeyName, pszValue));
    }

    va_end(argList);

    _UpdateAssocChanged(hr, pszKeyFormatString);
    return MapNotFoundToSuccess(hr);
}
HRESULT CRegisterExtension::RegSetKeyValuePrintf(HKEY hkey, PCWSTR pszKeyFormatString, PCWSTR pszValueName, PCWSTR pszValue, ...) const
{
    va_list argList;
    va_start(argList, pszValue);

    WCHAR szKeyName[512];
    HRESULT hr = StringCchVPrintf(szKeyName, ARRAYSIZE(szKeyName), pszKeyFormatString, argList);
    if (SUCCEEDED(hr))
    {
        hr = HRESULT_FROM_WIN32(RegSetKeyValueW(hkey, szKeyName, pszValueName, REG_SZ, pszValue,
            lstrlen(pszValue) * sizeof(*pszValue)));
    }

    va_end(argList);

    _UpdateAssocChanged(hr, pszKeyFormatString);
    return hr;
}
Example #26
0
//----------------------------------------------------------------------------
// Função privada que sabe mostrar um erro
//
void DisplayError(int errorn, const TCHAR * fmtStr, va_list args) {
    LPVOID errorBuf;
    TCHAR msgBuffer[MAX_CH_ERROR_MESSAGE];
    TCHAR title[MAX_CH_ERROR_TITLE] = TEXT("");
    TCHAR * progName;


    if ( GetConsoleTitle(title, MAX_CH_ERROR_TITLE) ) {
        progName = _tcsrchr(title, '\\');

        if ( progName != NULL ) {

            if ( progName[ _tcslen(progName)-1 ] == '"')
                progName[ _tcslen(progName)-1 ] = '\0';

            //_stprintf(title, TEXT("Error on %s"), ++progName);
            StringCchPrintf(title, MAX_CH_ERROR_TITLE, TEXT("Error on %s"), ++progName);
        }
    }

    DWORD res = FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        errorn,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Linguagem por omissão do sistema
        (LPTSTR) &errorBuf,
        0,
        NULL );

    //_vstprintf( msgBuffer, fmtStr, args );
    StringCchVPrintf(msgBuffer, MAX_CH_ERROR_MESSAGE, fmtStr, args );

    //_stprintf( msgBuffer + _tcsclen(msgBuffer), TEXT(": (%d) %s"), errorn, (res ? errorBuf : "") );
    size_t dimMsg = _tcsclen(msgBuffer);
    StringCchPrintf(msgBuffer + dimMsg, MAX_CH_ERROR_MESSAGE - dimMsg,
                    TEXT(": (%d) %s"), errorn, (res ? errorBuf : TEXT("")) );

    MessageBox( NULL, (LPCTSTR)msgBuffer, title, MB_OK | MB_ICONERROR  | MB_SETFOREGROUND);

    // Libertar memória referenciada por lpMsgBuf alocada pela função FormatMessage
    LocalFree( errorBuf );
} // DisplayError
Example #27
0
int print(const char *format, ... )
{
	char buffer[512];
	ZeroMemory(buffer, sizeof(buffer));

	va_list list;
	va_start(list, format);

	int ret = StringCchVPrintf(buffer, 512, format, list);
	int len = lstrlen(format);

	if(ret >= len || GetLastError() == 0)
	{
		HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
		if(h != INVALID_HANDLE_VALUE)
			WriteConsole(h, buffer, lstrlen(buffer), (LPDWORD)&len, 0);
	}

	return len;
}
void Msg(TCHAR *szFormat, ...)
{
    TCHAR szBuffer[1024];  // Large buffer for long filenames or URLs
    const size_t NUMCHARS = sizeof(szBuffer) / sizeof(szBuffer[0]);
    const int LASTCHAR = NUMCHARS - 1;

    // Format the input string
    va_list pArgs;
    va_start(pArgs, szFormat);

    // Use a bounded buffer size to prevent buffer overruns.  Limit count to
    // character size minus one to allow for a NULL terminating character.
    (void)StringCchVPrintf(szBuffer, NUMCHARS - 1, szFormat, pArgs);
    va_end(pArgs);

    // Ensure that the formatted string is NULL-terminated
    szBuffer[LASTCHAR] = TEXT('\0');

    MessageBox(NULL, szBuffer, TEXT("PlayCap Message"), MB_OK | MB_ICONERROR);
}
Example #29
0
static VOID
#pragma prefast(suppress:6262) // Function uses '1036' bytes of stack: exceeds /analyze:stacksize'1024'
__Log(
    IN  const CHAR  *Format,
    IN  ...
    )
{
    TCHAR               Buffer[MAXIMUM_BUFFER_SIZE];
    va_list             Arguments;
    size_t              Length;
    SP_LOG_TOKEN        LogToken;
    DWORD               Category;
    DWORD               Flags;
    HRESULT             Result;

    va_start(Arguments, Format);
    Result = StringCchVPrintf(Buffer, MAXIMUM_BUFFER_SIZE, Format, Arguments);
    va_end(Arguments);

    if (Result != S_OK && Result != STRSAFE_E_INSUFFICIENT_BUFFER)
        return;

    Result = StringCchLength(Buffer, MAXIMUM_BUFFER_SIZE, &Length);
    if (Result != S_OK)
        return;

    LogToken = SetupGetThreadLogToken();
    Category = TXTLOG_VENDOR;
    Flags = TXTLOG_WARNING;

    SetupWriteTextLog(LogToken, Category, Flags, Buffer);
    Length = __min(MAXIMUM_BUFFER_SIZE - 1, Length + 2);

    __analysis_assume(Length < MAXIMUM_BUFFER_SIZE);
    __analysis_assume(Length >= 2);
    Buffer[Length] = '\0';
    Buffer[Length - 1] = '\n';
    Buffer[Length - 2] = '\r';

    OutputDebugString(Buffer);
}
Example #30
0
	void SPMessageHelper::Msg( std::string msg, ... )
	{
		TCHAR szBuffer[1024];  // Large buffer for long filenames or URLs
		const size_t NUMCHARS = sizeof(szBuffer) / sizeof(szBuffer[0]);
		const int LASTCHAR = NUMCHARS - 1;

		// Format the input string
		va_list pArgs;
		va_start(pArgs, msg);

		// Use a bounded buffer size to prevent buffer overruns.  Limit count to
		// character size minus one to allow for a NULL terminating character.
		(void)StringCchVPrintf(szBuffer, NUMCHARS - 1, SPStringHelper::MultiByteCStringToWideChar(msg.c_str()), pArgs);
		va_end(pArgs);

		// Ensure that the formatted string is NULL-terminated
		szBuffer[LASTCHAR] = TEXT('\0');

		MessageBox(NULL, szBuffer, TEXT("SPEngine"),
			MB_OK | MB_ICONERROR);
	}