VOID Console::FormatV( LPCWSTR wstrFormat, va_list pArgList )
{
// Count the required length of the string
DWORD dwStrLen = _vscwprintf( wstrFormat, pArgList ) + 1; // +1 = null terminator
WCHAR* strMessage = ( WCHAR* )_malloca( dwStrLen * sizeof( WCHAR ) );
vswprintf_s( strMessage, dwStrLen, wstrFormat, pArgList );
// Output the string to the console
for( DWORD i = 0; i < wcslen( strMessage ); i++ )
{
Add( strMessage[i] );
}
// Output the string to the debug channel, if requested
if( m_bOutputToDebugChannel )
{
OutputDebugStringW( strMessage );
}
// Render the new output
Render();
_freea( strMessage );
}
void LogDebug(const wchar_t *fmt, ...)
{
//#ifdef DEBUG
va_list ap;
va_start(ap,fmt);
va_start(ap,fmt);
vswprintf_s(logbufferw, fmt, ap);
va_end(ap);
wchar_t fileName[MAX_PATH];
GetLogFile(fileName);
FILE* fp = _wfopen(fileName,L"a+, ccs=UTF-8");
if (fp!=NULL)
{
SYSTEMTIME systemTime;
GetLocalTime(&systemTime);
fwprintf(fp,L"%02.2d-%02.2d-%04.4d %02.2d:%02.2d:%02.2d.%02.2d %s\n",
systemTime.wDay, systemTime.wMonth, systemTime.wYear,
systemTime.wHour,systemTime.wMinute,systemTime.wSecond,systemTime.wMilliseconds,
logbufferw);
fclose(fp);
//::OutputDebugStringW(logbufferw);::OutputDebugStringW(L"\n");
}
//#endif
};
void LogWriter::log(WCHAR *fmt, va_list args)
{
wstr_t logMessage = CLOCK.nowTimeWithMilliSec();
size_t threadId = GET_CURRENT_THREAD_ID();
logMessage += L"\t";
Thread *thread = ThreadManager::getInstance().at(threadId);
if (thread) {
logMessage += thread->name();
}
else {
logMessage += prefix_;
}
array<WCHAR, SIZE_8 * 2> threadIdStr;
snwprintf(threadIdStr, L"0x%X", threadId);
logMessage += L":";
logMessage += threadIdStr.data();
logMessage += L"\t";
array<WCHAR, SIZE_1024> logStr;
vswprintf_s(logStr.data(), logStr.size(), fmt, args);
logMessage += logStr.data();
logMessage += L"\n";
base_->log((WCHAR *)logMessage.c_str());
}
BOOL Application::Error(BOOL Fatal, LPCTSTR Text, ...)
{
TCHAR CaptionText[12];
TCHAR ErrorText[2048];
va_list valist;
// Build the message box caption based on fatal flag
if(Fatal == FALSE)
lstrcpy(CaptionText, L"Error");
else
lstrcpy(CaptionText, L"Fatal Error");
// Build variable text buffer
va_start(valist, Text);
vswprintf_s(ErrorText, sizeof(ErrorText), Text, valist);
va_end(valist);
// Display the message box
MessageBox(NULL, ErrorText, CaptionText, MB_OK | MB_ICONEXCLAMATION);
// Post a quit message if error was fatal
if(Fatal == TRUE)
PostQuitMessage(0);
return TRUE;
}
static BOOL DebugMessageV(DWORD dwSize, LPCWSTR lpszMessage, va_list arglist)
{
LPWSTR lpszMsgBuf;
// Parameter checking.
if( (NULL == lpszMessage)
||
(0 == dwSize)
)
{
return FALSE;
}
// Allocate memory for message buffer.
lpszMsgBuf = new WCHAR[dwSize + 1];
if(NULL == lpszMsgBuf)
return FALSE;
// Pass the variable parameters to wvsprintf to be formated.
vswprintf_s(lpszMsgBuf, dwSize + 1, lpszMessage, arglist);
// Dump string to debug output.
OutputDebugStringW(lpszMsgBuf);
// Clean up.
delete[] lpszMsgBuf;
return TRUE;
}
HRESULT StringCchAVPrintfW(_In_ HANDLE hHeap, _Outptr_result_nullonfailure_ LPWSTR *plpszDest, _Out_opt_ size_t *pcchDest, _In_ LPCWSTR lpszFormat, _In_ va_list argList)
{
LPWSTR lpszDest;
int cchDest;
if (!hHeap || !plpszDest || !lpszFormat)
return STRSAFE_E_INVALID_PARAMETER;
*plpszDest = NULL;
if (pcchDest)
*pcchDest = 0;
cchDest = _vscwprintf(lpszFormat, argList);
if (cchDest < 0 || cchDest > STRSAFE_MAX_CCH)
return STRSAFE_E_INVALID_PARAMETER;
if ((cchDest+1) <= cchDest)
return STRSAFE_E_INVALID_PARAMETER;
cchDest += 1;
lpszDest = (LPWSTR) HeapAlloc(hHeap, HEAP_ZERO_MEMORY, cchDest * sizeof(WCHAR));
if (lpszDest) {
cchDest = vswprintf_s(lpszDest, cchDest, lpszFormat, argList);
if (cchDest >= 0) {
*plpszDest = lpszDest;
if (pcchDest)
*pcchDest = cchDest;
return S_OK;
} else {
HeapSafeFree(hHeap, 0, lpszDest);
}
}
return STRSAFE_E_INSUFFICIENT_BUFFER;
}
void log(const wchar_t* format, ...)
{
if (!s_enableLogging)
{
return;
}
auto dir = settings::settingsDirectory();
CreateDirectory(dir.c_str(), nullptr);
auto file = CreateFile((dir + L"\\log.txt").c_str(), GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
if (file == INVALID_HANDLE_VALUE)
{
return;
}
SetFilePointer(file, 0, nullptr, FILE_END);
va_list args1, args2;
va_start(args1, format);
va_copy(args2, args1);
int length = _vscwprintf(format, args1);
if (length > 0)
{
size_t size = size_t(length + 3);
wchar_t* buffer = new wchar_t[size];
buffer[0] = 0;
vswprintf_s(buffer, size, format, args2);
wcscat_s(buffer, size, L"\r\n");
DWORD written;
WriteFile(file, buffer, (length + 2) * sizeof(wchar_t), &written, nullptr);
delete[] buffer;
}
va_end(args1);
va_end(args2);
CloseHandle(file);
}
static void DbgPrint(LPCWSTR format, ...) {
if (g_DebugMode) {
const WCHAR *outputString;
WCHAR *buffer = NULL;
size_t length;
va_list argp;
va_start(argp, format);
length = _vscwprintf(format, argp) + 1;
buffer = _malloca(length * sizeof(WCHAR));
if (buffer) {
vswprintf_s(buffer, length, format, argp);
outputString = buffer;
} else {
outputString = format;
}
if (g_UseStdErr)
fputws(outputString, stderr);
else
OutputDebugStringW(outputString);
if (buffer)
_freea(buffer);
va_end(argp);
}
}
void JavascriptError::SetErrorMessage(JavascriptError *pError, HRESULT hr, ScriptContext* scriptContext, va_list argList)
{
Assert(FAILED(hr));
wchar_t * allocatedString = nullptr;
if (FACILITY_CONTROL == HRESULT_FACILITY(hr) || FACILITY_JSCRIPT == HRESULT_FACILITY(hr))
{
if (argList != nullptr)
{
HRESULT hrAdjusted = GetAdjustedResourceStringHr(hr, /* isFormatString */ true);
BSTR message = BstrGetResourceString(hrAdjusted);
if (message != nullptr)
{
size_t len = _vscwprintf(message, argList);
Assert(len > 0);
len = AllocSizeMath::Add(len, 1);
allocatedString = RecyclerNewArrayLeaf(scriptContext->GetRecycler(), wchar_t, len);
#pragma prefast(push)
#pragma prefast(disable:26014, "allocatedString allocated size more than msglen")
#pragma prefast(disable:26000, "allocatedString allocated size more than msglen")
len = vswprintf_s(allocatedString, len, message, argList);
Assert(len > 0);
#pragma prefast(pop)
SysFreeString(message);
}
}
void _cdecl CGameUpdate::SetErrorInfo(UpdateErrorCode enErrCode, ...)
{
AutoLock lock(m_lockStatus);
if (m_UpdateStuats.dwStatus == UPDATE_STATUS_ERROR)
{
return;
}
m_UpdateStuats.dwStatus = UPDATE_STATUS_ERROR;
m_UpdateStuats.dwLeftTime = 0;
m_UpdateStuats.enErrCode = enErrCode;
TCHAR atErrInfo[MAX_PATH] = _T("Unknown Error.");
for (int i = 0; i < _countof(C_ERR_INFO); ++i)
{
if (C_ERR_INFO[i].enErrCode == enErrCode)
{
_tcscpy_s(atErrInfo, C_ERR_INFO[i].lpszErrInfo);
break;
}
}
va_list marker;
va_start(marker, enErrCode);
vswprintf_s(m_UpdateStuats.awInfo, atErrInfo, marker);
va_end(marker);
//notify thread exit.
if (m_hExited != NULL)
SetEvent(m_hExited);
}
void kprintf(PCWCHAR format, ...)
{
#ifdef _WINDLL
int varBuf;
size_t tempSize;
#endif
va_list args;
va_start(args, format);
#ifndef _WINDLL
vwprintf(format, args);
fflush(stdout);
#else
if(outputBuffer)
{
varBuf = _vscwprintf(format, args);
if(varBuf > 0)
{
if((size_t) varBuf > (outputBufferElements - outputBufferElementsPosition - 1)) // NULL character
{
tempSize = (outputBufferElements + varBuf + 1) * 2; // * 2, just to be cool
if(outputBuffer = (wchar_t *) LocalReAlloc(outputBuffer, tempSize * sizeof(wchar_t), LMEM_MOVEABLE))
outputBufferElements = tempSize;
}
varBuf = vswprintf_s(outputBuffer + outputBufferElementsPosition, outputBufferElements - outputBufferElementsPosition, format, args);
if(varBuf > 0)
outputBufferElementsPosition += varBuf;
}
}
#endif
if(logfile)
vfwprintf(logfile, format, args);
va_end(args);
fflush(logfile);
}
void LogDebug(const wchar_t *fmt, ...)
{
va_list ap;
va_start(ap,fmt);
va_start(ap,fmt);
vswprintf_s(logbufferw, fmt, ap);
va_end(ap);
wchar_t folder[MAX_PATH];
wchar_t fileName[MAX_PATH];
::SHGetSpecialFolderPathW(NULL, folder, CSIDL_COMMON_APPDATA, FALSE);
swprintf_s(fileName, L"%s\\Team MediaPortal\\MediaPortal TV Server\\log\\streaming server.Log", folder);
FILE* fp = _wfopen(fileName,L"a+, ccs=UTF-8");
if (fp!=NULL)
{
SYSTEMTIME systemTime;
GetLocalTime(&systemTime);
fwprintf(fp,L"[%04.4d-%02.2d-%02.2d %02.2d:%02.2d:%02.2d,%03.3d] [%x] - %s\n",
systemTime.wYear, systemTime.wMonth, systemTime.wDay,
systemTime.wHour, systemTime.wMinute, systemTime.wSecond, systemTime.wMilliseconds,
GetCurrentThreadId(),
logbufferw);
fclose(fp);
}
};
/*-----------------------------------------------------------------------------*/
std::wstring StringUtil::Format(const wchar_t* fmt, ...)
{
va_list arguments;
std::wstring buffer = L"";
assert(fmt);
va_start(arguments, fmt);
{
int length = _vscwprintf(fmt, arguments);
if (length >= 0)
{
std::unique_ptr<wchar_t[]> buf(new wchar_t[length + 1]);
#ifdef _WIN32
int result = vswprintf_s(buf.get(), length + 1, fmt, arguments);
#else
int result = vswprintf(buf.get(), length + 1, fmt, arguments);
#endif
if (result >= 0)
{
buffer = buf.get();
}
}
}
va_end(arguments);
return buffer;
}
//-----------------------------------------------------------------
//printf形式で文字列データを作る
std::vector<wchar_t> CXmlWriter::FormatV(LPCWSTR lpszFormat, va_list args)
{
int len = _vscwprintf(lpszFormat, args);
std::vector<wchar_t> buf(len+1);
len = vswprintf_s( &buf[0], len+1, lpszFormat, args );
return buf;
}
void CMfmLog::Log(int nLevel, LPCWSTR szFormat, ...)
{
if (m_hLogFile != INVALID_HANDLE_VALUE &&
m_nLogLevel >= nLevel)
{
SYSTEMTIME st;
WCHAR szBuf[MAXLOGLINE - 25];
DWORD wri;
va_list args;
va_start(args, szFormat);
vswprintf_s(szBuf, LENGTHOF(szBuf), szFormat, args);
va_end(args);
GetLocalTime(&st);
EnterCriticalSection(&m_CSLog);
int len = swprintf_s(m_szBuffer, LENGTHOF(m_szBuffer), L"%02i/%02i/%04i %02i:%02i:%02i.%03i %s\r\n",
st.wMonth, st.wDay, st.wYear, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, szBuf);
if (len > 0)
{
WriteFile(m_hLogFile, m_szBuffer, len * sizeof(WCHAR), &wri, NULL);
FlushFileBuffers(m_hLogFile);
}
LeaveCriticalSection(&m_CSLog);
}
}
void LogDebug(const wchar_t *fmt, ...)
{
CAutoLock logLock(&m_logLock);
if (!m_hLogger) {
m_bLoggerRunning = true;
StartLogger();
}
wchar_t buffer[2000];
int tmp;
va_list ap;
va_start(ap,fmt);
tmp = vswprintf_s(buffer, fmt, ap);
va_end(ap);
SYSTEMTIME systemTime;
GetLocalTime(&systemTime);
wchar_t msg[5000];
swprintf_s(msg, 5000,L"[%04.4d-%02.2d-%02.2d %02.2d:%02.2d:%02.2d,%03.3d] [%x] [%x] - %s\n",
systemTime.wYear, systemTime.wMonth, systemTime.wDay,
systemTime.wHour, systemTime.wMinute, systemTime.wSecond, systemTime.wMilliseconds,
(unsigned int)instanceID,
GetCurrentThreadId(),
buffer);
CAutoLock l(&m_qLock);
if (m_logQueue.size() < 2000)
{
m_logQueue.push((wstring)msg);
}
};
BOOL CDebugLog::Log(TCHAR *fmt, ...)
{
if(m_hLogFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
size_t nLen;
TCHAR szOutBuffer[1024] = {0};
TCHAR szInBuffer[1024] = {0};
DWORD dwInBuffer = _countof(szInBuffer);
DWORD dwOutBuffer = _countof(szOutBuffer);
DWORD dwBytesWritten;
auto va_list argptr;
time_t rawtime = 0;
struct tm timeinfo = {0};
time(&rawtime);
localtime_s(&timeinfo, &rawtime);
_wasctime_s(szInBuffer, _countof(szInBuffer), &timeinfo);
nLen = wcslen(szInBuffer);
szInBuffer[nLen - 1] = ' ';
va_start(argptr, fmt);
vswprintf_s(szInBuffer + nLen, _countof(szInBuffer) - nLen - 1, fmt, argptr);
va_end(argptr);
nLen = wcslen(szInBuffer);
if(nLen == 0)
{
return TRUE;
}
wcscat_s(szInBuffer, _countof(szInBuffer), _T("\n"));
dwInBuffer = (DWORD)wcslen(szInBuffer);
char *pszOutBuffer = new char[dwInBuffer + 4];
WideCharToMultiByte(CP_ACP, 0, szInBuffer, -1, pszOutBuffer, dwInBuffer + 1, NULL, NULL);
if(m_hLogFile == INVALID_HANDLE_VALUE)
{
delete [] pszOutBuffer;
return FALSE;
}
OutputDebugString(szInBuffer);
WriteFile(m_hLogFile, pszOutBuffer, dwInBuffer, &dwBytesWritten, NULL);
delete [] pszOutBuffer;
return TRUE;
}
inline void SetUpdateInfo(LPCWSTR formater, ...)
{
AutoLock lock(m_lockStatus);
va_list marker;
va_start(marker, formater);
vswprintf_s(m_UpdateStuats.awInfo, formater, marker);
va_end(marker);
}
const WCHAR* Sprintf(const WCHAR *pcStr, ...)
{
va_list var;
va_start(var, pcStr);
vswprintf_s(g_SprintBuffer, sizeof(g_SprintBuffer) / sizeof(g_SprintBuffer[0]), pcStr, var);
va_end(var);
return g_SprintBuffer;
}
void StringBuffer::format(PCWSTR fmt, ...) throw()
{
WCHAR buffer[1024];
va_list args;
va_start(args, fmt);
vswprintf_s(buffer, fmt, args);
va_end(args);
append(buffer);
}
void odPrintfW(const WCHAR * format,...)
{
WCHAR wbuff[MAX_DBG_MSG_LEN] = {'[','W','Y','X',']',' '};
va_list body;
va_start(body,format);
vswprintf_s(wbuff + 6,MAX_DBG_MSG_LEN - 6,format,body);
va_end(body);
OutputDebugStringW(wbuff);
}
static int my_swprintf_s( wchar_t *buf, rsize_t n, const wchar_t *fmt, ... )
{
va_list arg;
int rc;
va_start( arg, fmt );
rc = vswprintf_s( buf, n, fmt, arg );
va_end( arg );
return( rc );
}
void CCommonUtils::DebugPrintf(LPCWSTR fmt, ...)
{
WCHAR buf[1024];
va_list va;
va_start(va, fmt);
vswprintf_s(buf, fmt, va);
OutputDebugString(buf);
va_end(va);
}
void dbgoutW(wchar_t* fmt, ...)
{
wchar_t buffer[MAX_OUT] = {0};
va_list args;
va_start(args, fmt);
vswprintf_s(buffer, MAX_OUT, fmt, args);
OutputDebugStringW(buffer);
va_end(args);
}
void fcyDebug::Trace(fcStrW Format, ...)
{
wchar_t szText[1024];
va_list marker;
va_start(marker, Format);
vswprintf_s(szText, Format, marker);
va_end(marker);
OutputDebugStringW(szText);
}
// フォーマットにしたがってデバッグ出力する(UNICODE)
void Trace(const wchar_t *format, ...){
va_list arg;
wchar_t buf[4096];
va_start(arg, format);
vswprintf_s(buf, 4096, format, arg);
va_end(arg);
OutputDebugString(buf);
OutputDebugString(L"\n");
fputws(buf, stderr);
}
void GamePlayer::ShowErrorMsg(HWND hWnd, const wchar_t* szTitle, const wchar_t* szFormat, ...)
{
static wchar_t szError[1024];
va_list ap;
va_start(ap, szFormat);
vswprintf_s(szError, szFormat, ap);
va_end(ap);
MessageBoxW(hWnd, szError, szTitle, MB_ICONERROR);
}
/// <summary>
/// Format string
/// </summary>
/// <param name="fmt">Format specifier</param>
/// <param name="">Arguments</param>
/// <returns>Formatted string</returns>
std::wstring Utils::FormatString( const wchar_t* fmt, ... )
{
wchar_t buf[4096] = { 0 };
va_list vl;
va_start( vl, fmt );
vswprintf_s( buf, fmt, vl );
va_end( vl );
return buf;
}
int swprintf_s (wchar_t* strDest, size_t destMax, const wchar_t* format, ...)
{
int ret = 0;
va_list arglist;
va_start(arglist, format);
ret = vswprintf_s(strDest, destMax, format, arglist);
va_end(arglist);
return ret;
}
void cLog::xwriteW(LPCWSTR format, ... )
{
ZLockHolder holder(&m_formatWriteMutex);
va_list vl;
va_start (vl, format);
vswprintf_s(g_szWideBuffer, MAX_SIZE_BUFFER, format, vl);
va_end (vl);
writeW(g_szWideBuffer);
}
