void SHVConsole::fwprintf(FILE* f, const WCHAR* str, ...) { SHVVA_LIST args; SHVVA_START(args,str); vfwprintf(f,str,args); SHVVA_END(args); }
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 }
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 tzf_logger_t::Log (_In_z_ _Printf_format_string_ wchar_t const* const _Format, ...) { va_list _ArgList; if (! initialized) return; EnterCriticalSection (&log_mutex); if ((! fLog) || silent) { LeaveCriticalSection (&log_mutex); return; } wchar_t wszLogTime [128]; WORD ms = TZF_Timestamp (wszLogTime); fwprintf (fLog, L"%s%03u: ", wszLogTime, ms); va_start (_ArgList, _Format); { vfwprintf (fLog, _Format, _ArgList); } va_end (_ArgList); fwprintf (fLog, L"\n"); fflush (fLog); LeaveCriticalSection (&log_mutex); }
void report(const char* modName, Level severity, const wchar_t* format, va_list ap) { _reportHead(modName, nullptr, severity); vfwprintf(stderr, format, ap); fprintf(stderr, "\n"); }
void PdfError::LogMessageInternal( ELogSeverity eLogSeverity, const wchar_t* pszMsg, va_list & args ) { const wchar_t* pszPrefix = NULL; switch( eLogSeverity ) { case eLogSeverity_Error: break; case eLogSeverity_Critical: pszPrefix = L"CRITICAL: "; break; case eLogSeverity_Warning: pszPrefix = L"WARNING: "; break; case eLogSeverity_Information: break; case eLogSeverity_Debug: pszPrefix = L"DEBUG: "; break; case eLogSeverity_None: case eLogSeverity_Unknown: default: break; } if( pszPrefix ) fwprintf( stderr, pszPrefix ); vfwprintf( stderr, pszMsg, args ); }
int vswprintf(wchar_t* s, size_t n, const wchar_t* fmt, va_list args) { Sfio_t f; int v; if (!s) return -1; /* * make a fake stream */ SFCLEAR(&f, NiL); f.flags = SF_STRING|SF_WRITE; f.bits = SF_PRIVATE; f.mode = SF_WRITE; f.size = n - 1; f.data = f.next = f.endr = (uchar*)s; f.endb = f.endw = f.data + f.size; /* * call and adjust */ v = vfwprintf(&f, fmt, args); *f.next = 0; _Sfi = f.next - f.data; return v; }
DLL_EXPORTED int libintl_vfwprintf (FILE *stream, const wchar_t *format, va_list args) { if (wcschr (format, '$') == NULL) return vfwprintf (stream, format, args); else { size_t length; wchar_t *result = libintl_vasnwprintf (NULL, &length, format, args); int retval = -1; if (result != NULL) { size_t i; for (i = 0; i < length; i++) if (fputwc (result[i], stream) == WEOF) break; free (result); if (i == length) { if (length > INT_MAX) errno = EOVERFLOW; else retval = length; } } return retval; } }
int fwprintf(FILE* stream, const wchar_t* format, ...) { va_list args; va_start(args, format); int result = vfwprintf(stream, format, args); va_end(args); return result; }
__inline void TraceW(const wchar_t *format, ...) { if(g_bDebug) { if (format) { va_list arglist; wchar_t str[4096]; va_start(arglist, format); if (g_fLogFile) { FILE *fout = fopen(g_fLogFile, "a+t"); if (fout) { vfwprintf(fout, format, arglist); fclose(fout); } } StringCchVPrintfW(str, 4096, format, arglist); wprintf(str); if (g_bDebugString) { OutputDebugStringW(str); } va_end(arglist); } } }
void WriteWideFormatted (FILE * stream, const wchar_t * format, ...) { va_list args; va_start (args, format); vfwprintf (stream, format, args); va_end (args); }
int __fxprintf (FILE *fp, const char *fmt, ...) { if (fp == NULL) fp = stderr; va_list ap; va_start (ap, fmt); int res; if (fwide (fp, 0) > 0) { size_t len = strlen (fmt) + 1; wchar_t wfmt[len]; for (size_t i = 0; i < len; ++i) { assert (isascii (fmt[i])); wfmt[i] = fmt[i]; } res = vfwprintf (fp, wfmt, ap); } else res = INTUSE(vfprintf) (fp, fmt, ap); va_end (ap); return res; }
// Diagnostic logging SBTRDUTIL_API_CLASS void SBtrdEvent::Diag (VXIunsigned tag, const VXIchar *subtag, const VXIchar *format, ...) const { if ( _log ) { if ( format ) { va_list arguments; va_start(arguments, format); (*_log->VDiagnostic)(_log, tag + _diagTagBase, subtag, format, arguments); va_end(arguments); } else { (*_log->Diagnostic)(_log, tag + _diagTagBase, subtag, NULL); } #if 0 } else { VXIchar temp[1024]; va_list arguments; va_start(arguments, format); wcscpy (temp, subtag); wcscat (temp, L"|"); wcscat (temp, format); wcscat (temp, L"\n"); vfwprintf(stderr, temp, arguments); va_end(arguments); #endif } }
BOOL ATEFile::VPrintf(const WCHAR* pszFormat, va_list arg) { if(NULL == pszFormat) { return FALSE; } INT32 nRet = vfwprintf(m_pFile, pszFormat, arg); if(0 != fflush(m_pFile)) { return FALSE; } return (nRet < 0 ? FALSE : TRUE); }
void msgff(DWORD ErrorCode, LPCWSTR Format, ...) { va_list ap; va_start(ap, Format); vfwprintf(stdout, Format, ap); va_end(ap); report_error(stdout, ErrorCode); }
int vfwprintfDotsShell( FILE * stream, const wchar_t * format, ... ) { int res; va_list argList; va_start( argList, format ); res = vfwprintf( stream, format, argList ); va_end( argList ); return res; }
void kprintf_inputline(PCWCHAR format, ...) { va_list args; va_start(args, format); if(logfile) vfwprintf(logfile, format, args); va_end(args); fflush(logfile); }
int fwprintf(FILE *f, const wchar_t *fmt, ...) { int ret; va_list ap; va_start(ap, fmt); ret = vfwprintf(f, fmt, ap); va_end(ap); return ret; }
void terminate(wchar_t *message, ...) { va_list argptr; va_start(argptr, message); vfwprintf(stderr, message, argptr); va_end(argptr); fwprintf(stderr, L"\n"); exit(1); }
void report(const char* modName, Level severity, const wchar_t* format, va_list ap) { openFile(); _reportHead(modName, nullptr, severity); vfwprintf(fp, format, ap); fprintf(fp, "\n"); closeFile(); }
static void badVaSinkB(wchar_t * data, ...) { { va_list args; va_start(args, data); /* POTENTIAL FLAW: Do not specify the format allowing a possible format string vulnerability */ vfwprintf(stdout, data, args); va_end(args); } }
static void goodB2GVaSinkG(wchar_t * data, ...) { { va_list args; va_start(args, data); /* FIX: Specify the format disallowing a format string vulnerability */ vfwprintf(stdout, L"%s", args); va_end(args); } }
/* * This takes strings from a resource stringtable * and outputs it to the console. */ VOID PrintResourceString(INT resID, ...) { WCHAR tmpBuffer[MAX_BUFFER_SIZE]; va_list arg_ptr; va_start(arg_ptr, resID); LoadStringW(GetModuleHandle(NULL), resID, tmpBuffer, MAX_BUFFER_SIZE); vfwprintf(stdout, tmpBuffer, arg_ptr); va_end(arg_ptr); }
void Helpers::LogError(__in __nullterminated const char16 *msg, ...) { va_list args; va_start(args, msg); wprintf(_u("ERROR: ")); vfwprintf(stderr, msg, args); wprintf(_u("\n")); fflush(stdout); va_end(args); }
void reportSource(const char* modName, Level severity, const char* file, unsigned linenum, const wchar_t* format, va_list ap) { char sourceInfo[128]; snprintf(sourceInfo, 128, "%s:%u", file, linenum); _reportHead(modName, sourceInfo, severity); vfwprintf(stderr, format, ap); fprintf(stderr, "\n"); }
static void debug(wchar_t* format, ...) { if (debug_fp != NULL) { va_list ap; va_start(ap, format); vfwprintf(debug_fp, format, ap); va_end(ap); } }
int wprintf(const wchar_t* fmt, ...) { va_list args; int v; va_start(args, fmt); v = vfwprintf(sfstdout, fmt, args); va_end(args); return v; }
void klog(FILE * logfile, PCWCHAR format, ...) { if(logfile) { va_list args; va_start(args, format); vfwprintf(logfile, format, args); va_end(args); fflush(logfile); } }
int fwprintf(Sfio_t* f, const wchar_t* fmt, ...) { va_list args; int v; va_start(args, fmt); v = vfwprintf(f, fmt, args); va_end(args); return v; }
BOOL ATEFile::Printf(const WCHAR* pszFormat, ...) { if(NULL == pszFormat) { return FALSE; } va_list arg; va_start(arg, pszFormat); INT32 nRet = vfwprintf(m_pFile, pszFormat, arg); va_end(arg); if(0 != fflush(m_pFile)) { return FALSE; } return (nRet < 0 ? FALSE : TRUE); }