int hv_snprintf(char* str, hv_size_t size, const char* format, ...) {
// http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
int count = -1;
va_list ap;
va_start(ap, format);
if (size != 0) {
count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
}
if (count == -1) {
count = _vscprintf(format, ap);
}
va_end(ap);
return count;
}
void OutputDebugInfo(const char *pFileName, const char *pFormat, ...)
{
va_list ArgList;
va_start(ArgList, pFormat);
char Buffer[1024] = { 0 };
int Ret = _vsnprintf_s(Buffer, 1024, _TRUNCATE, pFormat, ArgList); // Format 后字符串最大长度为 1023
//int Ret = _vsnprintf(Buffer, 1024, /*_TRUNCATE,*/ pFormat, ArgList);
if (Ret < 0)
Buffer[1023] = '\0';
va_end(ArgList);
putLog(pFileName, Buffer);
}
void TRACE(const CHAR* format,...)
{
#ifdef _DEBUG
static const int BufferLen = 1212; //注意此处大小根据需要修改
va_list pNextArg;
CHAR szMessageBuffer[BufferLen];
szMessageBuffer[BufferLen-1] = '\0';
va_start(pNextArg,format);
_vsnprintf_s(szMessageBuffer,BufferLen-1,format, pNextArg);
va_end(pNextArg);
OutputDebugStringA(szMessageBuffer);
#endif //#ifdef _DEBUG
}
void debugf(const char* format, ...)
{
if (g_bOutput)
{
const size_t size = 2048; //Avalanche: Changed to handle longer messages (from 512)
char bfr[size];
va_list vl;
va_start(vl, format);
_vsnprintf_s(bfr, size, (size-1), format, vl); //Avalanche: Fix off by one error.
va_end(vl);
ZDebugOutputImpl(bfr);
}
}
void __cdecl sdlog(const char *fmt, ...) {
if(ofile.good()) {
if(!fmt) { return; }
va_list va_alist;
char logbuf[9999] = {0};
va_start (va_alist, fmt);
_vsnprintf_s(logbuf+strlen(logbuf), sizeof(logbuf) - strlen(logbuf), _TRUNCATE, fmt, va_alist);
va_end (va_alist);
ofile << logbuf;
ofile.flush();
}
}
int msg_print(const char *message, ...) {
#define MAX_OUTPUT_TEXT_SIZE 0x300
va_list list;
va_start(list, message);
char szBuffer[MAX_OUTPUT_TEXT_SIZE];
_vsnprintf_s(szBuffer, sizeof(szBuffer), message, list);
szBuffer[MAX_OUTPUT_TEXT_SIZE - 1]= '\0';
fprintf(stderr, "%s", szBuffer);
va_end(list);
return 0;
}
void SaveFile(LPCTSTR lpszFormat,...)
{
if(!lpszFormat) return;
char _buf[409600];
va_list args;
va_start(args, lpszFormat);
_vsnprintf_s(_buf,(sizeof(_buf)/sizeof(_buf[0])),lpszFormat,args);
va_end(args);
FILE *fp=fopen("\\packet.txt","a");
fprintf_s(fp,"%s\n",_buf);
fclose(fp);
return;
}
int c99_vsnprintf_retro__(char *outBuf, size_t size, const char *format, va_list ap)
{
int count = -1;
if (size != 0)
#if (_MSC_VER <= 1310)
count = _vsnprintf(outBuf, size, format, ap);
#else
count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
#endif
if (count == -1)
count = _vscprintf(format, ap);
return count;
}
HRESULT __stdcall Log(
__in const char * channelName,
__in const char * format,
...
)
{
if ( (channelName == 0) ||
(format == 0) )
{
return E_INVALID_PARAMETER;
}
SharedChannelW * ch = ChannelObjLookUp::GetSharedChannel(channelName, CH_TYPE_LOG, 0);
if (!ch->IsType(CH_TYPE_LOG))
return E_PLOT_TYPE_MISMATCH;
ch->Lock();
const size_t TEXT_BUF_LEN = 4096;
char * textBuffer = ch->GetTextBuffer(TEXT_BUF_LEN);
SYSTEMTIME sysTime;
GetLocalTime(&sysTime);
_snprintf_s(
textBuffer,
TEXT_BUF_LEN,
_TRUNCATE,
"[%d:%d:%.3f]: ",
sysTime.wHour,
sysTime.wMinute,
(double)(sysTime.wSecond*1000 + sysTime.wMilliseconds)/1000);
size_t size1 = strlen(textBuffer);
char * ptr2 = textBuffer + size1;
va_list ap;
va_start(ap, format);
_vsnprintf_s(ptr2, TEXT_BUF_LEN - size1, _TRUNCATE, format, ap);
va_end(ap);
ch->Write((const char *)textBuffer, strlen(textBuffer));
ch->Unlock();
return S_OK;
}
void AbstrDebugOut::Message(const char* source, const char* format, ...)
{
if (!m_bShowMessages) return;
char buff[16384];
va_list args;
va_start(args, format);
#ifdef DETECTED_OS_WINDOWS
_vsnprintf_s(buff, 16384, sizeof(buff), format, args);
#else
vsnprintf(buff, sizeof(buff), format, args);
#endif
va_end(args);
this->printf(CHANNEL_MESSAGE, source, buff);
}
/* Our version of snprintf; this is NOT semantically the same as C99's
* snprintf; rather, it's a "lowest common denominator" implementation
* blending C99 and MS-C */
void gregorio_snprintf(char *s, size_t size, const char *format, ...)
{
va_list args;
#ifdef _MSC_VER
memset(s, 0, size);
#endif
va_start(args, format);
#ifdef _MSC_VER
_vsnprintf_s(s, size, _TRUNCATE, format, args);
#else
vsnprintf(s, size, format, args);
#endif
va_end(args);
}
void Log(const char* fmt, ...)
{
static std::vector<char> buf;
va_list args;
va_start(args, fmt);
int len = _vscprintf(fmt, args);
if(len >= (int)buf.size())
buf.resize(len + 1);
len = _vsnprintf_s(buf.data(), buf.size(), len, fmt, args);
va_end(args);
if(len > 0)
{
OutputDebugStringA(buf.data());
_write(logfile, buf.data(), len);
}
}
size_t ossSnprintf(char* pBuffer, size_t iLength, const char* pFormat, ...)
{
va_list ap;
size_t n;
va_start(ap, pFormat);
#if defined (_WINDOWS)
n=_vsnprintf_s(pBuffer, iLength, _TRUNCATE, pFormat, ap);
#else
n=vsnprintf(pBuffer, iLength, pFormat, ap);
#endif
va_end(ap);
if((n<0) || (size_t)n>=iLength)
n=iLength-1;
pBuffer[n]='\0';
return n;
}
COMMON_SYSDEP void __cilkrts_dbgprintf(const char *fmt,...)
{
char message[2048];
va_list l;
// Cilkscreen shouldn't watch this
__cilkscreen_disable_checking();
va_start(l, fmt);
_vsnprintf_s(message, 2048, _TRUNCATE, fmt, l);
va_end(l);
OutputDebugStringA (message);
// Re-enable Cilkscreen
__cilkscreen_enable_checking();
}
const char *va(const char *fmt, ...)
{
va_list VarArgs;
int32_t StringLength = 0;
char DestinationBuffer[BUFFER_SIZE / LARGEBUFFER_SIZE]{};
// Create a temporary string from the arguments.
va_start(VarArgs, fmt);
StringLength = _vsnprintf_s(DestinationBuffer, BUFFER_SIZE / LARGEBUFFER_SIZE, _TRUNCATE, fmt, VarArgs);
va_end(VarArgs);
// Send the string to permanent storage.
if (StringLength > BUFFER_SIZE / SMALLBUFFER_SIZE)
return va_large(DestinationBuffer);
else
return va_small(DestinationBuffer);
}
void Logs::COM_LOG(const char* file, int line, const char* function, const char* format, ...)
{
if (Settings::getInstance()->IsLogEnabled && Settings::getInstance()->SeeCommunicationLog)
{
char buffer[2048];
memset(buffer, 0x00, sizeof(buffer));
va_list args;
va_start (args, format);
#if defined(__unix__)
vsnprintf(buffer, sizeof(buffer) - 1, format, args);
#else
_vsnprintf_s(buffer, sizeof(buffer) - 1, format, args);
#endif
log_INFORMATIONAL(processLog(file, line, function, buffer));
va_end(args);
}
}
void Logs::PLUGIN_ERROR(const char* file, int line, const char* function, const char* format, ...)
{
if (Settings::getInstance()->IsLogEnabled && Settings::getInstance()->SeePluginLog)
{
char buffer[2048];
memset(buffer, 0x00, sizeof(buffer));
va_list args;
va_start (args, format);
#ifdef __unix__
vsnprintf(buffer, sizeof(buffer) - 1, format, args);
#else
_vsnprintf_s(buffer, sizeof(buffer) - 1, format, args);
#endif
log_ERROR(processLog(file, line, function, buffer));
va_end(args);
}
}
static void area_fatal_error(const char* pFunc, const char* pMsg, ...)
{
pFunc;
va_list args;
va_start(args, pMsg);
char buf[512];
#ifdef _MSC_VER
_vsnprintf_s(buf, sizeof(buf), pMsg, args);
#else
vsnprintf(buf, sizeof(buf), pMsg, args);
#endif
va_end(args);
CRNLIB_FAIL(buf);
}
void Logs::EMERGENCY_LOG(const char* file, int line, const char* function, const char* format, ...)
{
if (!Settings::getInstance()->IsLogEnabled)
return;
char buffer[2048];
memset(buffer, 0x00, sizeof(buffer));
va_list args;
va_start (args, format);
#if defined(__unix__)
vsnprintf(buffer, sizeof(buffer) - 1, format, args);
#else
_vsnprintf_s(buffer, sizeof(buffer) - 1, format, args);
#endif
log_EMERGENCY(processLog(file, line, function, buffer));
va_end(args);
}
int myPrintfToLog(const char* format, ...)
{
if (g_logFile == INVALID_HANDLE_VALUE)
return 1;
va_list arglist;
va_start(arglist, format);
char buffer[2048];
int len = _vsnprintf_s(buffer, 2048, _TRUNCATE, format, arglist);
if (len <= 0)
return 0;
DWORD cbWritten;
WriteFile(g_logFile, buffer, len, &cbWritten, NULL);
return 1;
}
static void
sg_dologv(sg_log_level_t level, struct sg_error *err,
const char *msg, va_list ap)
{
char buf[LOG_BUFSZ];
int r, s;
#if defined _WIN32
r = _vsnprintf_s(buf, sizeof(buf), _TRUNCATE, msg, ap);
#else
r = vsnprintf(buf, sizeof(buf), msg, ap);
#endif
if (r < 0)
r = 0;
else if ((size_t) r >= sizeof(buf))
r = sizeof(buf) - 1;
if (err) {
#if defined _WIN32
if (err->code) {
s = _snprintf_s(
buf + r, sizeof(buf)-r, _TRUNCATE,
": %s (%s %ld)", err->msg, err->domain->name, err->code);
} else {
s = _snprintf_s(
buf + r, sizeof(buf) - r, _TRUNCATE,
": %s (%s)", err->msg, err->domain->name);
}
#else
if (err->code) {
s = snprintf(
buf + r, sizeof(buf) - r,
": %s (%s %ld)", err->msg, err->domain->name, err->code);
} else {
s = snprintf(
buf + r, sizeof(buf) - r,
": %s (%s)", err->msg, err->domain->name);
}
#endif
if (s > 0) {
r += s;
if ((size_t) r >= sizeof(buf))
r = sizeof(buf) - 1;
}
}
sg_dologmem(level, buf, r);
}
string CLogger::FormatString(const char *lpcszFormat, ...)
{
string strResult;
if (NULL != lpcszFormat)
{
va_list marker = NULL;
va_start(marker, lpcszFormat); //初始化变量参数
size_t nLength = _vscprintf(lpcszFormat, marker) + 1; //获取格式化字符串长度
std::vector<char> vBuffer(nLength, '\0'); //创建用于存储格式化字符串的字符数组
int nWritten = _vsnprintf_s(&vBuffer[0], vBuffer.size(), nLength, lpcszFormat, marker);
if (nWritten > 0)
{
strResult = &vBuffer[0];
}
va_end(marker); //重置变量参数
}
return strResult;
}
void cdraw::Text(float x, float y, float size, float *colour, int align, LPSTR font, const char *txtformat, ...)
{
char szBuffer[512] = "";
va_list ap;
va_start( ap, txtformat );
_vsnprintf_s( szBuffer, 512, 511, txtformat, ap );
va_end( ap );
float sztext = strlen(szBuffer)*10*size;
if (align == F_CENTER)
x = x-(sztext/2);
else if (align == F_RIGHT)
x = x-sztext;
vec4_t Black = {0.0f,0.0f,0.0f,1.0f};
trap_R_DrawStringExt(szBuffer, 0x7FFFFFFF, font, (x+0.5f), (y+0.5f), size, size, Black, 1);
trap_R_DrawStringExt(szBuffer, 0x7FFFFFFF, font, x, y, size, size, colour, 1);
}
void Log(const char* text, ...)
{
char buffer[MAX_DEBUG_LINE_LEN];
va_list args;
va_start(args, text);
int buf = _vsnprintf_s(buffer, MAX_DEBUG_LINE_LEN, text, args);
assert((buf >= 0) && (buf < MAX_DEBUG_LINE_LEN));
va_end(args);
// Log output to debug windows and/or disk depending on options
char buffer2[MAX_DEBUG_LINE_LEN];
strcpy_s(buffer2, MAX_DEBUG_LINE_LEN, "DEBUG: ");
strcpy_s(buffer2+7, MAX_DEBUG_LINE_LEN-7, buffer);
LogOutput(buffer);
}
void log_handler_platform(LogCategory category, LogLevel level,
const char *file, int line,
const char *function, const char *format,
va_list arguments) {
WORD type;
DWORD event_id;
char message[512 + 1] = "<unknown>";
LPCSTR insert_strings[1];
(void)category;
(void)file;
(void)line;
(void)function;
if (_event_log == NULL) {
return;
}
switch (level) {
case LOG_LEVEL_ERROR:
type = EVENTLOG_ERROR_TYPE;
event_id = BRICKD_GENERIC_ERROR;
break;
case LOG_LEVEL_WARN:
type = EVENTLOG_WARNING_TYPE;
event_id = BRICKD_GENERIC_WARNING;
break;
default:
// ignore all other log levels
return;
}
#ifdef _MSC_VER
_vsnprintf_s(message, sizeof(message), sizeof(message) - 1, format, arguments);
#else
vsnprintf(message, sizeof(message), format, arguments);
#endif
insert_strings[0] = message;
ReportEvent(_event_log, type, 0, event_id, NULL, 1, 0, insert_strings, NULL);
}
_tsTraceMethodExt &_tsTraceMethodExt::returnCOMMsg(HRESULT hr, tscrypto::tsCryptoString fmt, ...)
{
tscrypto::tsCryptoString sHr;
va_list args;
switch (hr)
{
case S_OK: sHr = "OK"; break;
case S_FALSE: sHr = "FALSE"; break;
case E_NOTIMPL: sHr = "Not Implemented"; break;
case E_UNEXPECTED: sHr = "Unexpected operation"; break;
case E_OUTOFMEMORY: sHr = "Out Of Memory"; break;
case E_INVALIDARG: sHr = "Invalid Argument"; break;
case E_NOINTERFACE: sHr = "No Interface"; break;
case E_POINTER: sHr = "Invalid Pointer"; break;
case E_HANDLE: sHr = "Invalid Handle"; break;
case E_ABORT: sHr = "Aborted"; break;
case E_FAIL: sHr = "General Failure"; break;
case E_ACCESSDENIED: sHr = "Access Denied"; break;
case E_PENDING: sHr = ""; break;
default:
sHr.Format("0x%08X", hr);
break;
}
setErrorTo(FAILED(hr) != FALSE);
va_start(args, fmt);
m_outMessage.clear();
m_outMessage.resize(MAX_TRACE_MSG_LEN);
#ifdef HAVE__VSNPRINTF_S
_vsnprintf_s(m_outMessage.rawData(), m_outMessage.size(), m_outMessage.size(), fmt.c_str(), args);
#elif defined(HAVE_VSNPRINTF)
vsnprintf(m_outMessage.rawData(), m_outMessage.size(), fmt.c_str(), args);
#elif defined(HAVE_VSPRINTF_S)
vsprintf_s(m_outMessage.rawData(), m_outMessage.size(), fmt.c_str(), args);
#elif defined(HAVE_VSPRINTF)
vsprintf(m_outMessage.rawData(), fmt.c_str(), args);
#else
#error Implement me
#endif
m_outMessage.resize((uint32_t)TsStrLen(m_outMessage.c_str()));
m_outMessage.Replace("~~", sHr.c_str());
returns(hr);
return *this;
}
void Log( _In_ LogType lType, _In_ char* szStr, _In_ ... )
{
char szBuff[256] = {0,};
va_list arg;
va_start(arg, szStr);
_vsnprintf_s(szBuff, 256, szStr, arg);
va_end(arg);
HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
__time64_t time = _time64( nullptr );
struct tm t;
_localtime64_s(&t, &time);
printf("[%02d:%02d:%02d]", t.tm_hour, t.tm_min, t.tm_sec );
switch(lType)
{
case Error:
{
SetConsoleTextAttribute( hStdout, Red );
printf("[ERROR]");
break;
}
case Success:
{
SetConsoleTextAttribute( hStdout, Green );
printf("[SUCCESS]");
break;
}
case Info:
{
SetConsoleTextAttribute( hStdout, Blue );
printf("[INFO]");
break;
}
}
SetConsoleTextAttribute( hStdout, Silver );
printf( " %s\n", szBuff );
}
void DbgPrint(const char *fmt, ...)
{
if(!(bLogToDebugger||bLogToFile))
return;
if(bLogToDebugger)
{
char buffer[512];
va_list argptr;
va_start(argptr, fmt);
_vsnprintf_s(buffer, 512, _TRUNCATE, fmt, argptr);
va_end(argptr);
strcat_s(buffer, 512, "\r\n");
OutputDebugString(buffer);
}
}
int ssnprintf(char* Buffer, int BufSize, const char *Format, ...)
{
int WrittenBytes;
va_list Args;
va_start(Args, Format);
if (Buffer == NULL)
return -1;
#if defined(_WIN32) && (_MSC_VER >= 1400) /* Visual Studio 2005 */
WrittenBytes= _vsnprintf_s(Buffer, BufSize - 1, _TRUNCATE, Format, Args);
#else
WrittenBytes= vsnprintf(Buffer, BufSize - 1, Format, Args);
#endif
Buffer[BufSize - 1] = 0;
return WrittenBytes;
};
std::string FormatStr(const char *pszFormat, ...)
{
std::string strRet;
va_list arg;
int cch;
va_start(arg, pszFormat);
// Check the required size
cch = _vscprintf(pszFormat, arg);
strRet.resize(cch);
va_start(arg, pszFormat);
_vsnprintf_s(&strRet[0], cch+1, cch, pszFormat, arg);
va_end(arg);
return strRet;
}
