static int ShowErrorVA(UINT type, DWORD err, const char *pFmt, va_list va)
{
char buf[1024];
VSNPRINTF(buf, sizeof(buf)/sizeof(buf[0]), pFmt, va);
LPVOID pMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
err,
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
(LPTSTR) &pMsgBuf,
0,
NULL);
int len = lstrlen(buf);
if ((err & 0xFFFF0000) == 0)
SNPRINTF(buf + len, sizeof(buf)/sizeof(buf[0]) - len, "\nERROR: %lu - %s\n", (unsigned long)err, pMsgBuf);
else
SNPRINTF(buf + len, sizeof(buf)/sizeof(buf[0]) - len, "\nERROR: 0x%08lX - %s\n", (unsigned long)err, pMsgBuf);
LocalFree(pMsgBuf);
return ShowMsg(buf, type);
}
std::string StringUtil::vform(const char* format, va_list args) {
size_t size = 1024;
char* buffer = new char[size];
while (1) {
va_list args_copy;
#if defined(_MSC_VER) || defined(__BORLANDC__)
args_copy = args;
#else
va_copy(args_copy, args);
#endif
int n = VSNPRINTF(buffer, size, format, args_copy);
va_end(args_copy);
// If that worked, return a string.
if ((n > -1) && (static_cast<size_t>(n) < size)) {
std::string s(buffer);
delete [] buffer;
return s;
}
// Else try again with more space.
size = (n > -1) ?
n + 1 : // ISO/IEC 9899:1999
size * 2; // twice the old size
delete [] buffer;
buffer = new char[size];
}
}
void
sxe_log_entry(unsigned id, unsigned int verbosity, const char * file, int line, const char *fmt, ...)
{
char log_buffer[SXE_LOG_BUFFER_SIZE];
va_list ap;
unsigned i;
unsigned prefix_length;
SXE_CHECK_LOG_INITIALIZE();
SXE_CHECK_VERBOSITY_BEFORE_ANYTHING_ELSE();
prefix_length = sxe_log_buffer_set_prefix(log_buffer, id, verbosity);
i = prefix_length;
va_start(ap, fmt);
if (sxe_log_safe_append(log_buffer, &i, SNPRINTF(&log_buffer[i], SXE_LOG_BUFFER_SIZE - i, "%*s+ ", SXE_LOG_INDENT * 2, ""))
&& sxe_log_safe_append(log_buffer, &i, VSNPRINTF(&log_buffer[i], SXE_LOG_BUFFER_SIZE - i, fmt, ap))) {
sxe_log_safe_append(log_buffer, &i, SNPRINTF(&log_buffer[i], SXE_LOG_BUFFER_SIZE - i, "\n"));
}
sxe_log_line_out_escaped(log_buffer);
i = prefix_length;
sxe_log_safe_append(log_buffer, &i, SNPRINTF(&log_buffer[i], SXE_LOG_BUFFER_SIZE - i, "%*s { // %s:%d\n",
SXE_LOG_INDENT * 2, "", file, line));
sxe_log_line_out_escaped(log_buffer);
SXE_LOG_SET_INDENT(SXE_LOG_INDENT + 1);
} /* sxe_log_entry() */
static int send_msg(process *pp, int act, const char *fmt, ...)
{int nl;
char msg[BFLRG];
char *p;
dbgrsp *gr;
atdbgdes *st;
VA_START(fmt);
if (fmt == NULL)
p = NULL;
else
{VSNPRINTF(msg, BFLRG, fmt);
p = msg;};
VA_END;
gr = (dbgrsp *) pp->a;
st = gr->st;
gr->action = act;
/* log the message sent */
if ((st->log != NULL) && (p != NULL))
fprintf(st->log, "SND: %s\n", p);
nl = job_response(pp, 30000, p);
return(nl);}
// Note: This may be Windows specific way of handling
// variable args--there are other methods.
void sml::PrintDebugFormat(char const* pFormat, ...)
{
va_list args;
va_start(args, pFormat);
char szBuffer[10000];
int nBuf = VSNPRINTF(szBuffer, sizeof(szBuffer), pFormat, args);
// was there an error? was the expanded string too long?
if (nBuf < 0)
{
strcpy(szBuffer, "** Debug message too long for PrintDebugFormat's buffer **") ;
}
#ifdef DEBUG_CALLS
CTDebugEnterMethod::PrintStackTrace() ;
PrintDebugMethod(CTDebugEnterMethod::GetCurrentMethodName(), szBuffer) ;
#else
PrintDebugSimple(szBuffer) ;
#endif
va_end(args);
}
ErrorCode set_last_error( const char* fmt, va_list args )
{
char text[1024];
VSNPRINTF( text, sizeof(text), fmt, args );
mLastError = text;
return MB_SUCCESS;
}
/**------------------------------------------------------**/
void print_R(char* out, const char *format, ...)
{
LOG_FILETYPE stderr_f;
char buffer[64];
va_list argptr;
va_start(argptr, format);
VSNPRINTF(buffer, format, argptr);
va_end(argptr);
if(out == NULL)
{
printf_terminal(buffer);
}else
{
if(!monitor_openappend(out,&stderr_f))
{
if(!monitor_openwrite(out,&stderr_f))
{
return;
}
}
/* print to file */
(void)monitor_seek_end(&stderr_f);
(void)monitor_write(buffer,&stderr_f);
(void)monitor_close(&stderr_f);
}
}
int StrcatfHttpResponseBuffer( struct HttpEnv *e , char *format , ... )
{
va_list valist ;
long size ;
int len ;
int nret = 0 ;
size = e->rsp_buf->bufsize - e->rsp_buf->len - 1 ;
while(1)
{
va_start( valist , format );
len = VSNPRINTF( e->rsp_buf->ptr , size , format , valist ) ;
va_end( valist );
if( len == -1 || len == size )
{
nret = ReallocHttpBuffer( e->rsp_buf , e->rsp_buf->bufsize * 2 ) ;
if( nret )
return nret;
}
else
{
break;
}
}
e->rsp_buf->ptr += len ;
e->rsp_buf->len += len ;
return 0;
}
static void
voutf_master_tty (const char * format, va_list args)
{
char buf [1000];
VSNPRINTF (buf, 1000, format, args);
Screen_WriteText (master_tty_window, buf);
}
/* 输出日志 */
int WriteLogBaseV( int log_level , char *c_filename , long c_fileline , char *format , va_list valist )
{
char c_filename_copy[ MAXLEN_FILENAME + 1 ] ;
char *p_c_filename = NULL ;
char log_buffer[ 1024 + 1 ] ;
char *log_bufptr = NULL ;
size_t log_buflen ;
size_t log_buf_remain_len ;
size_t len ;
int nret = 0 ;
/* 处理源代码文件名 */
memset( c_filename_copy , 0x00 , sizeof(c_filename_copy) );
strncpy( c_filename_copy , c_filename , sizeof(c_filename_copy)-1 );
p_c_filename = strrchr( c_filename_copy , '\\' ) ;
if( p_c_filename )
p_c_filename++;
else
p_c_filename = c_filename_copy ;
/* 填充行日志 */
/* memset( log_buffer , 0x00 , sizeof(log_buffer) ); */
log_bufptr = log_buffer ;
log_buflen = 0 ;
log_buf_remain_len = sizeof(log_buffer) - 1 - sizeof(NEWLINE) ;
/*
{
struct timeval tv ;
gettimeofday( & tv , NULL );
len = SNPRINTF( log_bufptr , log_buf_remain_len , "%s.%06ld | %-5s | %lu:%lu:%s:%ld | " , g_date_time_cache[g_date_time_cache_index].date_and_time_str , tv.tv_usec , log_level_itoa[log_level] , g_pid , g_tid , p_c_filename , c_fileline ) ;
}
*/
len = SNPRINTF( log_bufptr , log_buf_remain_len , "%s | %-5s | %lu:%lu:%s:%ld | " , g_date_time_cache[g_date_time_cache_index].date_and_time_str , log_level_itoa[log_level] , g_pid , g_tid , p_c_filename , c_fileline ) ;
OFFSET_BUFPTR( log_buffer , log_bufptr , len , log_buflen , log_buf_remain_len );
len = VSNPRINTF( log_bufptr , log_buf_remain_len , format , valist );
OFFSET_BUFPTR( log_buffer , log_bufptr , len , log_buflen , log_buf_remain_len );
log_buf_remain_len += sizeof(NEWLINE) ;
len = SNPRINTF( log_bufptr , log_buf_remain_len , NEWLINE ) ;
OFFSET_BUFPTR( log_buffer , log_bufptr , len , log_buflen , log_buf_remain_len );
/* 输出行日志 */
if( g_file_fd == -1 )
{
nret = OpenLogFile() ;
if( nret )
return nret;
WRITE( g_file_fd , log_buffer , log_buflen );
}
else
{
WRITE( g_file_fd , log_buffer , log_buflen );
}
return 0;
}
void StrBuf::vstrcat(CHAR const* format, va_list args)
{
va_list org_args;
va_copy(org_args, args);
UINT l = VSNPRINTF(NULL, 0, format, args);
strcat(l, format, org_args);
va_end(org_args);
}
static int ShowMsgVA(UINT type, const char *pFmt, va_list va)
{
char buf[1024];
VSNPRINTF(buf, sizeof(buf)/sizeof(buf[0]), pFmt, va);
return ShowMsg(buf, type);
}
static std::string strformat(const char* fmt, ...)
{
char buf[256];
va_list args;
va_start(args,fmt);
VSNPRINTF(buf, sizeof(buf), fmt, args);
va_end(args);
return std::string(buf);
}
/* Wrapper for snprintf() */
int gtm_snprintf(char *str, size_t size, const char *format, ...)
{
va_list printargs;
int retval;
va_start(printargs, format);
VSNPRINTF(str, size, format, printargs, retval);
va_end(printargs);
return retval;
}
std::string SPrintf(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
char buf[512];
VSNPRINTF(buf, sizeof(buf), fmt, ap);
va_end(ap);
return buf;
}
/* 设置日志文件名 */
void SetLogFile( char *format , ... )
{
va_list valist ;
va_start( valist , format );
VSNPRINTF( g_log_pathfilename , sizeof(g_log_pathfilename)-1 , format , valist );
va_end( valist );
return;
}
// Printf style string formatting
string SPrintf(const char *fmt, ...)
{
va_list vl;
va_start(vl, fmt);
char buf[256];
VSNPRINTF(buf, sizeof(buf), fmt, vl);
va_end(vl);
return buf;
}
void CglFont::glFormat(float x, float y, float s, const int options, const char* fmt, ...)
{
char out[512];
va_list ap;
if (fmt == NULL) return;
va_start(ap, fmt);
VSNPRINTF(out, sizeof(out), fmt, ap);
va_end(ap);
glPrint(x, y, s, options, std::string(out));
}
void GLogicEngineCPP::LogException(const char * msg, ...)
{
char buffer[4096];
va_list args;
va_start(args, msg);
strcpy(buffer, "LOGIC EXCEPTION: ");
VSNPRINTF(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), msg, args);
buffer[sizeof(buffer) - 1] = 0;
Log(buffer);
}
void GRaportInterface::Raport(const char * format, ...)
{
va_list args;
va_start(args, format) ;
max_len = 4096 - 32; // Zostawiamy 32 bajty miejsca na date i znak konca linii.
VSNPRINTF(buffer_arg,max_len,format, args) ;
max_len=4096;
SNPRINTF(buffer_format,max_len,"[%s] %s\r\n", date, buffer_arg);
max_len=strlen(buffer_format);
AddBuffer(buffer_format);
}
void CLogOutput::Print(const char *fmt, ...)
{
char text[bufferSize];
va_list ap;
va_start(ap, fmt);
VSNPRINTF(text, sizeof(text), fmt, ap);
va_end(ap);
Output(0, text);
}
void d_trace(const char *fmt, ...)
{
static char buf[256];
va_list ap;
va_start(ap,fmt);
VSNPRINTF (buf,256,fmt,ap);
va_end(ap);
d_puts (buf);
}
static void simpleLog_logv(int level, const char* fmt, va_list argp) {
if (level > logLevel) {
return;
}
static char outBuffer[SIMPLELOG_OUTPUTBUFFER_SIZE];
VSNPRINTF(outBuffer, SIMPLELOG_OUTPUTBUFFER_SIZE, fmt, argp);
simpleLog_out(level, outBuffer);
}
void dbgprintf(const char *fmt,...) {
va_list ap;
va_start(ap, fmt);
char buf[512];
VSNPRINTF(buf, sizeof(buf), fmt, ap);
OutputDebugString(buf);
fputs(buf,stdout);
WriteToLog(buf);
va_end(ap);
}
void StrBuf::sprint(CHAR const* format, ...)
{
clean();
va_list args;
va_start(args, format);
va_list org_args;
va_copy(org_args, args);
UINT l = VSNPRINTF(NULL, 0, format, args);
strcat(l, format, org_args);
va_end(args);
va_end(org_args);
}
/**
* Like snprintf, just aborts if the buffer is of insufficient size.
*
* @param buf pointer to buffer that is written to
* @param size number of bytes in buf
* @param format format strings
* @param ... data for format string
* @return number of bytes written to buf or negative value on error
*/
int
GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
ret = VSNPRINTF (buf, size, format, args);
va_end (args);
GNUNET_assert (ret <= size);
return ret;
}
//The functions snprintf() and vsnprintf() do not write more than size
//bytes (including the terminating null byte ('\0')).
void StrBuf::nstrcat(UINT size, CHAR const* format, ...)
{
va_list args;
va_start(args, format);
va_list org_args;
va_copy(org_args, args);
UINT l = VSNPRINTF(NULL, 0, format, args);
if (l > size) { l = size; }
strcat(l, format, org_args);
va_end(args);
va_end(org_args);
}
/*===========================================================================
===========================================================================*/
void SamplePosDet_Printf( CSamplePosDet *pMe, int nLine, int nCol, AEEFont fnt, uint32 dwFlags,
const char *szFormat, ... )
{
char szBuf[64];
va_list args;
va_start( args, szFormat );
(void)VSNPRINTF( szBuf, 64, szFormat, args );
va_end( args );
xDisplay( (AEEApplet *)pMe, nLine, nCol, fnt, dwFlags, szBuf );
}
int SNPRINTF(char *pBuf, int size, const char *pFmt, ...)
{
va_list va;
va_start(va, pFmt);
int res1 = VSNPRINTF(pBuf, size, pFmt, va);
va_end(va);
return res1;
}
void TracePrint(int level, const char* szMessage, ...)
{
va_list VAList;
char szMsgBuf[2048] = {0};
va_start(VAList, szMessage);
VSNPRINTF(szMsgBuf, sizeof(szMsgBuf)-1, szMessage, VAList);
//std::thread::id tid = std::this_thread::get_id();
std::stringstream ss;
//ss << tid << ":" << getCurrentThreadId();
ss << getCurrentThreadId();
std::string stid = ss.str();
std::string str_log;
switch(level)
{
case KUMA_TRACE_LEVEL_INFO:
str_log = "INFO: ";
//printf("INFO: [%s] %s\n", stid.c_str(), szMsgBuf);
break;
case KUMA_TRACE_LEVEL_WARN:
str_log = "WARN: ";
//printf("WARN: [%s] %s\n", stid.c_str(), szMsgBuf);
break;
case KUMA_TRACE_LEVEL_ERROR:
str_log = "ERROR: ";
//printf("ERROR: [%s] %s\n", stid.c_str(), szMsgBuf);
break;
case KUMA_TRACE_LEVEL_DEBUG:
str_log = "DEBUG: ";
//printf("DEBUG: [%s] %s\n", stid.c_str(), szMsgBuf);
break;
default:
str_log = "INFO: ";
//printf("INFO: [%s] %s\n", stid.c_str(), szMsgBuf);
break;
}
str_log += "[" + stid + "] " + szMsgBuf;
/*ss.str("");
ss.clear();
ss << str_log << "[" << stid << "] " << szMsgBuf;
str_log = ss.str();*/
if (trace_func) {
trace_func(level, str_log.c_str());
} else {
#ifdef KUMA_OS_WIN
str_log += "\n";
OutputDebugString(str_log.c_str());
#else
printf("%s\n", str_log.c_str());
#endif
}
}
