static void cvt_wprintf(FILE *dest,const wchar *fmt,va_list arglist)
{
// This buffer is for format string only, not for entire output,
// so it can be short enough.
wchar fmtw[1024];
PrintfPrepareFmt(fmt,fmtw,ASIZE(fmtw));
#ifdef _WIN_ALL
safebuf wchar Msg[MaxMsgSize];
if (dest==stdout && StdoutRedirected || dest==stderr && StderrRedirected)
{
// Avoid Unicode for redirect in Windows, it does not work with pipes.
vswprintf(Msg,ASIZE(Msg),fmtw,arglist);
safebuf char MsgA[MaxMsgSize];
WideToChar(Msg,MsgA,ASIZE(MsgA));
CharToOemA(MsgA,MsgA); // Console tools like 'more' expect OEM encoding.
// We already converted \n to \r\n above, so we use WriteFile instead
// of C library to avoid unnecessary additional conversion.
HANDLE hOut=GetStdHandle(dest==stdout ? STD_OUTPUT_HANDLE:STD_ERROR_HANDLE);
DWORD Written;
WriteFile(hOut,MsgA,(DWORD)strlen(MsgA),&Written,NULL);
return;
}
// MSVC2008 vfwprintf writes every character to console separately
// and it is too slow. We use direct WriteConsole call instead.
vswprintf(Msg,ASIZE(Msg),fmtw,arglist);
HANDLE hOut=GetStdHandle(dest==stderr ? STD_ERROR_HANDLE:STD_OUTPUT_HANDLE);
DWORD Written;
WriteConsole(hOut,Msg,(DWORD)wcslen(Msg),&Written,NULL);
#else
vfwprintf(dest,fmtw,arglist);
// We do not use setbuf(NULL) in Unix (see comments in InitConsole).
fflush(dest);
#endif
}
int ivsprintf(ichar *buffer, size_t max_size, const ichar *format, va_list argptr)
{
#ifdef UNICODE__ICHAR_WIDE
#ifdef _INC_SWPRINTF_INL_
return vswprintf(buffer, max_size, format, argptr);
#else
return vswprintf(buffer, format, argptr);
#endif
#else
return vsprintf(buffer, format, argptr);
#endif
}
const char16 * FormatVL(const char16 * text, va_list ll)
{
if (formatString16Position + FORMAT_STRING_MAX_LEN >= FORMAT_STRING_SIZE)
{
formatString16Position = 0;
}
#if defined(_WIN32)
int32 len = vswprintf((wchar_t *)&formatString16[formatString16Position], (wchar_t *)text, ll);
#else // MAC_OS & other nix systems
int32 len = vswprintf((wchar_t *)&formatString16[formatString16Position], FORMAT_STRING_MAX_LEN, (wchar_t *)text, ll);
#endif
formatString16Position += (len + 1);
return &formatString16[formatString16Position - (len + 1)];
}
void
_testfmt(const char *result, int line, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
if (strcmp(result, s) != 0) {
fprintf(stderr,
"%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
line, fmt, argstr, s, result);
abort();
}
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
if (wcscmp(wresult, ws) != 0) {
fprintf(stderr,
"%d: wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]\n",
line, wfmt, argstr, ws, wresult);
abort();
}
}
void
Log(const wchar_t *fmt, ...)
{
#if !defined(SHOW_CONSOLE)
return;
#endif
va_list a = nullptr;
wchar_t szDebugString[1024];
if(!lstrlenW(fmt))
return;
va_start(a,fmt);
vswprintf(szDebugString, 1024, fmt, a);
va_end(a);
if(!lstrlenW(szDebugString))
return;
DWORD len;
WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);
WriteConsoleW(sCon, L"\n", 1, &len, nullptr);
if (IsDebuggerPresent()) {
OutputDebugStringW(szDebugString);
OutputDebugStringW(L"\n");
}
}
void Log::PushLog( ELogType::Type type, const CHAR *pError, ... )
{
if ( type > m_logLevel )
return;
CHAR *tempMsg;
SIZE_T len = 0;
va_list arg_ptr;
va_start( arg_ptr, pError );
#if defined(PSX_UNICODE)
len = _vscwprintf( pError, arg_ptr );
tempMsg = new CHAR[len + 1];
vswprintf( tempMsg, pError, arg_ptr );
#else
len = _vscprintf( pError, arg_ptr );
tempMsg = new CHAR[len + 1];
vsprintf( tempMsg, pError, arg_ptr );
#endif /* defined(PSX_UNICODE) */
// Display in output window
OutputDebugString( tempMsg );
OutputDebugString( PSX_String("\n") );
PSX_SafeDeleteArray( tempMsg );
}
void reportx(char *msg, int etype, ...)
{
letter mbuffer[4096];
letter msgbuffer[256];
va_list vlist;
COPYDATASTRUCT cd;
if(!reporting_initialized) return;
if(!reporting_window) return;
if(!IsWindow(reporting_window))
{
reporting_window = 0;
return;
}
va_start(vlist, etype);
MultiByteToWideChar(CP_ACP, 0, msg, -1, msgbuffer, sizeof(msgbuffer) / sizeof(letter));
vswprintf(mbuffer, sizeof(mbuffer) / sizeof(letter), msgbuffer, vlist);
cd.cbData = sizeof(mbuffer);
cd.dwData = etype;
cd.lpData = mbuffer;
SendMessage(reporting_window, WM_COPYDATA, sizeof(letter) /* Unicode */, (LPARAM)&cd);
va_end(vlist);
}
void Logger::Logv(eLogLevel ll, const char16* text, va_list li)
{
wchar_t tmp[4096] = {0};
vswprintf(tmp, sizeof(tmp)/sizeof(wchar_t) - 2, text, li);
wcscat(tmp, L"\n");
// always send log to custom subscribers
CustomLog(ll, tmp);
// print platform log or write log to file
// only if log level is acceptable
if (ll >= logLevel)
{
if(consoleModeEnabled)
{
ConsoleLog(ll, tmp);
}
else
{
PlatformLog(ll, tmp);
}
if(!logFilename.IsEmpty())
{
FileLog(ll, tmp);
}
}
}
I32 IFXAPI IFXDebugTraceGeneric( const IFXCHAR* pFormatString, ... )
{
#ifndef HAS_NO_WPRINT
if ( gs_debugLevel >= IFXDEBUG_MESSAGE )
{
const IFXCHAR *pComponentString =
_GetStringFromIFXRESULT_Component( IFXRESULT_COMPONENT_GENERIC );
IFXCHAR pMessage[ _MESSAGE_LENGTH_MAX ];
wcscpy( pMessage, _PREFIX_STRING );
if( pComponentString )
wcscat( pMessage, pComponentString );
wcscat( pMessage, L" " );
swprintf( gs_pDebugMessage, _MESSAGE_LENGTH_MAX, pMessage );
IFXOSOutputDebugString( gs_pDebugMessage );
va_list args;
va_start( args, pFormatString );
vswprintf( gs_pDebugMessage, _MESSAGE_LENGTH_MAX,
pFormatString, args );
va_end( args );
IFXOSOutputDebugString( gs_pDebugMessage );
}
#endif
return 0;
}
int swprintf(wchar_t* wcs, size_t maxlen, const wchar_t* format, ...) {
va_list ap;
va_start(ap, format);
int result = vswprintf(wcs, maxlen, format, ap);
va_end(ap);
return result;
}
_WCRTLINK int swprintf( CHAR_TYPE *dest, size_t n, const CHAR_TYPE *format, ... )
{
va_list args;
va_start( args, format );
return( vswprintf( dest, n, format, args ) );
}
void DisplayLoadProgress(const wchar_t *format, ...)
{
#if 0
va_list args;
wchar_t wbuf[INFO_BUF];
char buf[INFO_BUF];
/* process input */
va_start(args, format);
vswprintf(wbuf, format, args);
va_end(args);
/* XXX: convert to multibyte */
wcstombs(buf, wbuf, INFO_BUF);
printf(buf);
#else
static unsigned int i = 0;
i++;
if (i == 1) printf("\b-");
else if (i == 2) printf("\b\\");
else if (i == 3) printf("\b|");
else {
printf("\b/");
i = 0;
}
#endif
}
bool FormatArgsToWstring(wstring& wstr, LPCWSTR format, va_list args)
{
bool fRet = false;
int nCount = 0;
int nRet = 0;
WCHAR* pBuffer = NULL;
wstr.clear();
nCount = _vscwprintf(format, args);
if (!nCount)
goto END;
pBuffer = new WCHAR[nCount + 1];
if (!pBuffer)
goto END;
memset(pBuffer, 0, sizeof(WCHAR) * (nCount + 1));
nRet = vswprintf(pBuffer, nCount + 1, format, args);
if (nRet <= 0)
goto END;
wstr = pBuffer;
fRet = true;
END:
if (pBuffer)
delete[] pBuffer;
return fRet;
}
// Somewhat brute force, but works. Rewrite if necessary for speed.
IFXString& IFXString::VSPrintf(const IFXCHAR* fmt, va_list ap)
{
int sz = m_BufferLength;
if(!m_BufferLength)
{ // start at 80 bytes, seems reasonable (1 tty line)
NewBuffer(80);
sz = m_BufferLength;
}
else
{
NewBuffer(sz);
}
while(IFX_TRUE)
{
int n = vswprintf((IFXCHAR*)m_Buffer, m_BufferLength, fmt, ap);
if(n > -1 && n < sz)
{
break;
}
if(n > -1)
{
sz = n+1;
}
else
{
sz *= 2;
}
NewBuffer(sz);
}
return *this;
}
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(lpszMsgBuf, lpszMessage, arglist);
// Dump string to debug output.
OutputDebugStringW(lpszMsgBuf);
// Clean up.
delete[] lpszMsgBuf;
return TRUE;
}
int OS_Print(BOOL cond, const char* string, ...)
{
WCHAR message[OS_BUFFER_SIZE];
WCHAR wstring[OS_BUFFER_SIZE];
va_list ptr;
int iRequiredSize = 0;
if (!cond)
return 0;
// Find out required string size (if you don't have that info)
iRequiredSize = ::MultiByteToWideChar(CP_ACP, NULL, string, -1, NULL, 0);
if (iRequiredSize > OS_BUFFER_SIZE)
iRequiredSize = OS_BUFFER_SIZE;
// Do the string conversion
::MultiByteToWideChar(CP_ACP, NULL, string , -1, wstring, iRequiredSize);
va_start(ptr,string);
vswprintf(message, wstring, ptr);
va_end(ptr);
RETAILMSG(1, (message));
return 1;
}
wchar_t *dup_wprintf (int *rlen, wchar_t *format, ...)
{
va_list argptr;
wchar_t *result = NULL;
int len = 0;
if (format == NULL)
return NULL;
va_start(argptr, format);
len = _vscwprintf (format, argptr);
if (len >= 0)
{
result = (wchar_t *) malloc (sizeof (wchar_t *) * (len + 1));
if (result != NULL)
{
int len2 = vswprintf (result, format, argptr);
if (len2 != len || len2 <= 0)
{
free (result);
result = NULL;
}
else if (rlen != NULL)
*rlen = len;
}
}
va_end(argptr);
return result;
}
int Log(LPCTSTR pszFormat, ...)
{
va_list ptr;
va_start(ptr, pszFormat);
wchar_t pszBuffer[1024];
#pragma warning (push)
#pragma warning(disable : 4995)
#pragma warning(disable : 4996)
vswprintf( pszBuffer, 1024, pszFormat, ptr );
#pragma warning (pop)
va_end(ptr);
theApp.PrintfToString(pszBuffer);
CCodeTesterDlg* pDlg= (CCodeTesterDlg*)theApp.GetMainWnd();
if(pDlg)
{
theApp.m_CritSection.Lock();
pDlg->m_OutPutCtrl.OutPut(pszBuffer);
theApp.m_CritSection.Unlock();
return wcslen(pszBuffer);
}
return 0;
}
static void
_testfmt(const char *result, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
ATF_CHECK_MSG(strcmp(result, s) == 0,
"printf(\"%s\", %s) ==> [%s], expected [%s]",
fmt, argstr, s, result);
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
ATF_CHECK_MSG(wcscmp(wresult, ws) == 0,
"wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]",
wfmt, argstr, ws, wresult);
va_end(ap);
va_end(ap2);
}
int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...) {
va_list args;
va_start(args, format);
int result = vswprintf(s, n, format, args);
va_end(args);
return result;
}
void trace_fmt2(const char *fmt, ...) {
BOOL en;
va_list ap;
OEMCHAR buf[0x1000];
en = (tracewin.en & 2) &&
((tracewin.en & 4) || (tracewin.tf != NULL));
if (en) {
va_start(ap, fmt);
#if defined(OSLANG_UCS2)
OEMCHAR cnvfmt[0x800];
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, fmt, -1,
cnvfmt, NELEMENTS(cnvfmt));
vswprintf(buf, cnvfmt, ap);
#else
vsprintf(buf, fmt, ap);
#endif
va_end(ap);
if ((tracewin.en & 4) && (hView)) {
View_AddString(buf);
}
if (tracewin.tf != FILEH_INVALID) {
textfile_write(tracewin.tf, buf);
textfile_write(tracewin.tf, crlf);
}
}
}
inline VOID CharTraits<WCHAR>::FormatV( WCHAR* Buffer, SIZE_T Count, CONST WCHAR* Format, va_list Args )
{
va_list Args0;
va_copy(Args0,Args);
vswprintf( Buffer, Count, Format, Args0 );
va_end(Args0);
}
void GUI_Laftfont::printgl(int x, int y, int z, const wchar_t *fmt, ...)
{
wchar_t text[2048];
va_list ap;
size_t str_len;
if ((!listsFont) || (!fmt)) return;
va_start(ap, fmt);
#ifdef WIN32
_vsnwprintf(text, 2048, fmt, ap);
#else
vswprintf(text, 2048, fmt, ap);
#endif
va_end(ap);
str_len = wcslen(text);
// should be in modelview mode
glPushMatrix();
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glListBase(listsFont);
glTranslatef((float)x, (float)y, (float)z);
glScalef(1.0f, -1.0f, 1.0f);
#ifdef WIN32
glCallLists((GLsizei)(str_len), GL_UNSIGNED_SHORT, text);
#else
glCallLists((GLsizei)(str_len), GL_UNSIGNED_INT, text);
#endif
glDisable(GL_TEXTURE_2D);
glPopMatrix();
return;
}
const wchar_t* va(const wchar_t* string, ...)
{
static __thread int currentBuffer;
static __thread wchar_t* buffer;
if (!buffer)
{
buffer = new wchar_t[BUFFER_COUNT * BUFFER_LENGTH];
}
int thisBuffer = currentBuffer;
va_list ap;
va_start(ap, string);
int length = vswprintf(&buffer[thisBuffer * BUFFER_LENGTH], BUFFER_LENGTH, string, ap);
va_end(ap);
if (length >= BUFFER_LENGTH)
{
Com_Printf(0, "ERROR: Attempted to overrun string in call to va()!");
exit(1);
}
buffer[(thisBuffer * BUFFER_LENGTH) + BUFFER_LENGTH - 1] = '\0';
currentBuffer = (currentBuffer + 1) % BUFFER_COUNT;
return &buffer[thisBuffer * BUFFER_LENGTH];
}
int wchar_traits::Format( wchar_t** ppszDst, const wchar_t* pszFormat, va_list args )
{
int len = _vscwprintf( pszFormat, args ); // _vscprintf doesn't count terminating '\0'
*ppszDst = (wchar_t*)cui::CuiMalloc((len+1)*sizeof(wchar_t));
vswprintf(*ppszDst, pszFormat, args);
return len;
}
// Note: I could overload LogMsg to take a WCHAR* as the first argument but
// this way I am less likely to match the WCHAR* version with a char* argument
// or vice versa. It would also conflict with the UNICODE build.
// Function name : LogWMsg
// Description :
// Return type : void
// Argument : WCHAR* pFormat
// Argument : ...
void LogWMsg(WCHAR* pFormat, ...)
{
WCHAR wchMsg[LOCAL_BUFFER_SIZE];
va_list pArg;
va_start(pArg, pFormat);
vswprintf(wchMsg, pFormat, pArg);
va_end(pArg);
//*
openlog("MPILauncher", LOG_APP);
char msg[LOCAL_BUFFER_SIZE];
wcstombs(msg, wchMsg, wcslen(wchMsg)+1);
syslog(LOG_INFO, msg);
closelog();
/*/
WaitForSingleObject(g_hLogMutex, INFINITE);
FILE *fout = _tfopen(MPIJOB_LOG_FILENAME, TEXT("a"));
if (fout != NULL)
{
fprintf(fout, "%4d :%7u ", GetCurrentThreadId(), clock());
fwprintf(fout, L"%s", wchMsg);
fclose(fout);
}
ReleaseMutex(g_hLogMutex);
//*/
}
/*-----------------------------------------------------------------------------*/
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;
}
void
Log(const wchar_t *fmt, ...)
{
#if !defined(SHOW_CONSOLE)
DWORD dwRes = 0;
if (!GetDWORDRegKey(cehDumpDebugStrings, dwRes) || !dwRes) {
return;
}
#endif
va_list a = nullptr;
wchar_t szDebugString[1024];
if(!lstrlenW(fmt))
return;
va_start(a,fmt);
vswprintf(szDebugString, 1024, fmt, a);
va_end(a);
if(!lstrlenW(szDebugString))
return;
DWORD len;
WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);
WriteConsoleW(sCon, L"\n", 1, &len, nullptr);
OutputDebugStringW(szDebugString);
OutputDebugStringW(L"\n");
}
void reportu(string msg, int etype, ...)
{
letter mbuffer[4096];
va_list vlist;
COPYDATASTRUCT cd;
if(!reporting_initialized) return;
if(!reporting_window) return;
if(!IsWindow(reporting_window))
{
reporting_window = 0;
return;
}
va_start(vlist, etype);
vswprintf(mbuffer, sizeof(mbuffer) / sizeof(letter), msg, vlist);
cd.cbData = sizeof(mbuffer);
cd.dwData = etype;
cd.lpData = mbuffer;
SendMessage(reporting_window, WM_COPYDATA, sizeof(letter) /* Unicode */, (LPARAM)&cd);
va_end(vlist);
}
int send_msg (int id, int mode, int partner, wchar_t *format, ...) {
struct message msg;
struct msqid_ds msgstat;
va_list arglist;
va_start(arglist,format);
msg.prio = partner;
vswprintf(msg.text, MSGLEN, format, arglist);
if (mode == IPC_NOWAIT) {
msgsnd(id, &msg, MSGLEN, mode);
// wprintf (L"SEND -- free: %d / self: %d / partner: %d\n", 16 - msgstat.msg_qnum, getpid(), partner);
}
/*
ushort msg_cbytes; // Anzahl belegten Bytes in Queue
ushort msg_qnum; // Anzahl der Nachrichten in Queue
ushort msg_qbytes; // Max. Anzahl Bytes der Queue
*/
else {
while (1) {
msgctl(id, IPC_STAT, &msgstat);
if ((((msgstat.msg_qbytes - msgstat.msg_cbytes) * 100) / msgstat.msg_qbytes) > QRESERVE) {
// wprintf (L"SEND -- free: %d / self: %d / partner: %d\n", 16 - msgstat.msg_qnum, getpid(), partner);
msgsnd(id, &msg, MSGLEN, mode);
break;
}
// else wprintf(L"HOLD -- free: %d / self: %d / partner: %d\n", 16 - msgstat.msg_qnum, getpid(), partner);
usleep (FREQUENCY);
}
}
return 0;
}
