static void _printf(LogEntry::Level level, LogEntry::Type type, const char* fmt, va_list argptr)
{
if (!active)
return;
Log::active = false;
char buffer[8192];
U32 offset = 0;
if (useTimestamp)
{
static U32 startTime = Platform::getRealMilliseconds();
U32 curTime = Platform::getRealMilliseconds() - startTime;
offset += dSprintf(buffer + offset, sizeof(buffer) - offset, "[+%4d.%03d]", U32(curTime * 0.001), curTime % 1000);
}
dVsprintf(buffer + offset, sizeof(buffer) - offset, fmt, argptr);
LogEntry entry;
entry.mData = buffer;
entry.mLevel = level;
entry.mType = type;
for(S32 i = 0; i < gConsumers.size(); i++)
gConsumers[i](level, &entry);
Log::active = true;
}
void Platform::outputDebugString( const char *string, ... )
{
// Expand string.
char buffer[ 2048 ];
va_list args;
va_start( args, string );
dVsprintf( buffer, sizeof( buffer ), string, args );
va_end( args );
// Append a newline to buffer. This is better than calling OutputDebugStringA
// twice as in a multi-threaded environment, some other thread may output some
// stuff in between the two calls.
U32 length = strlen( buffer );
if( length == ( sizeof( buffer ) - 1 ) )
length --;
buffer[ length ] = '\n';
buffer[ length + 1 ] = '\0';
OutputDebugStringA( buffer );
}
//--------------------------------------
const char* avar(const char *message, ...)
{
static char buffer[4096];
va_list args;
va_start(args, message);
dVsprintf(buffer, sizeof(buffer), message, args);
return( buffer );
}
//------------------------------------------------------------------------------
const char *evaluatef(const char* string, ...)
{
char buffer[4096];
va_list args;
va_start(args, string);
dVsprintf(buffer, sizeof(buffer), string, args);
CodeBlock *newCodeBlock = new CodeBlock();
return newCodeBlock->compileExec(NULL, buffer, false, 0);
}
void CDomiServer::showToConsole(const char* pFormat, ...){
if (!pFormat || !*pFormat)
return;
char szStrint[2048] = { 0 };
va_list argptr;
va_start(argptr, pFormat);
dVsprintf(szStrint, sizeof(szStrint), pFormat, argptr);
va_end(argptr);
CConsoleColor clColor(_BIT32(CConsoleColor::color_green) | _BIT32(CConsoleColor::color_intensity));
dPrintf("%s\n", szStrint);
}
void TypeValidator::consoleError(SimObject *object, const char *format, ...)
{
char buffer[1024];
va_list argptr;
va_start(argptr, format);
dVsprintf(buffer, sizeof(buffer), format, argptr);
va_end(argptr);
AbstractClassRep *rep = object->getClassRep();
AbstractClassRep::Field &fld = rep->mFieldList[fieldIndex];
const char *objectName = object->getName();
if(!objectName)
objectName = "unnamed";
Con::warnf("%s - %s(%d) - invalid value for %s: %s",
rep->getClassName(), objectName, object->getId(), fld.pFieldname, buffer);
}
//////////////////////////////////////////////////////////////////////////
// static
// windows 的messagebox
void CServerRoot::messageBoxOK(const char* pCaption,const char* pText,...)
{
char szStrint[2048] = {0};
if (pText)
{
va_list argptr;
va_start(argptr,pText);
dVsprintf(szStrint,sizeof(szStrint),pText,argptr);
va_end(argptr);
}
CConsoleColor clColor(_BIT32(CConsoleColor::color_blue)|_BIT32(CConsoleColor::color_intensity));
dPrintf("message>%s:%s\n",pCaption ? pCaption : "",szStrint);
#ifdef WIN32
::ShowCursor(true);
::MessageBox(nullptr,szStrint,pCaption, MB_ICONINFORMATION | MB_SETFOREGROUND | MB_TASKMODAL | MB_OK);
#endif
}
//-----------------------------------------------------------------------------
void Platform::outputDebugString(const char *string, ...)
{
char buffer[2048];
va_list args;
va_start( args, string );
dVsprintf( buffer, sizeof(buffer), string, args );
va_end( args );
U32 length = dStrlen(buffer);
if( length == (sizeof(buffer) - 1 ) )
length--;
buffer[length++] = '\n';
buffer[length] = '\0';
fwrite(buffer, sizeof(char), length, stderr);
}
void logprintf(const char *format, ...)
{
char buffer[4096];
size_t bufferStart = 0;
if(LogType::current)
{
strcpy(buffer, LogType::current->typeName);
bufferStart = strlen(buffer);
buffer[bufferStart] = ':';
buffer[bufferStart+1] = ' ';
bufferStart += 2;
}
va_list s;
va_start( s, format );
dVsprintf(buffer + bufferStart, sizeof(buffer) - bufferStart, format, s);
for(LogConsumer *walk = LogConsumer::getLinkedList(); walk; walk = walk->getNext())
walk->logString(buffer);
va_end(s);
Platform::outputDebugString(buffer);
Platform::outputDebugString("\n");
}
void CDomiServer::setServicesTitle(const char* pTitle, ...){
#ifdef WIN32 // 设置控制台标题
if (!pTitle && m_szTitle[0])
return;
char szTitle[256] = { 0 };
if (pTitle) {
va_list argptr;
va_start(argptr, pTitle);
dVsprintf(szTitle, sizeof(szTitle), pTitle, argptr);
va_end(argptr);
}
if (!m_tmStartTime)
m_tmStartTime = getTime();
tm tmTime;
getLocalTime(&tmTime, &m_tmStartTime);
dSprintf(m_szTitle, sizeof(m_szTitle), "%s StartTime: %02d-%02d %02d:%02d:%02d", szTitle, tmTime.tm_mon + 1, tmTime.tm_mday, tmTime.tm_hour, tmTime.tm_min, tmTime.tm_sec);
::SetConsoleTitle(m_szTitle);
#endif
}
static void _printf(ConsoleLogEntry::Level level, ConsoleLogEntry::Type type, const char* fmt, va_list argptr)
{
if (!active)
return;
Con::active = false;
char buffer[8192];
U32 offset = 0;
if( gEvalState.traceOn && gEvalState.getStackDepth() > 0 )
{
offset = gEvalState.getStackDepth() * 3;
for(U32 i = 0; i < offset; i++)
buffer[i] = ' ';
}
if (useTimestamp)
{
static U32 startTime = Platform::getRealMilliseconds();
U32 curTime = Platform::getRealMilliseconds() - startTime;
offset += dSprintf(buffer + offset, sizeof(buffer) - offset, "[+%4d.%03d]", U32(curTime * 0.001), curTime % 1000);
}
dVsprintf(buffer + offset, sizeof(buffer) - offset, fmt, argptr);
for(S32 i = 0; i < gConsumers.size(); i++)
gConsumers[i](level, buffer);
if(logBufferEnabled || consoleLogMode)
{
char *pos = buffer;
while(*pos)
{
if(*pos == '\t')
*pos = '^';
pos++;
}
pos = buffer;
for(;;)
{
char *eofPos = dStrchr(pos, '\n');
if(eofPos)
*eofPos = 0;
log(pos);
if(logBufferEnabled && !consoleLogLocked)
{
ConsoleLogEntry entry;
entry.mLevel = level;
entry.mType = type;
#ifndef TORQUE_SHIPPING // this is equivalent to a memory leak, turn it off in ship build
entry.mString = (const char *)consoleLogChunker.alloc(dStrlen(pos) + 1);
dStrcpy(const_cast<char*>(entry.mString), pos);
// This prevents infinite recursion if the console itself needs to
// re-allocate memory to accommodate the new console log entry, and
// LOG_PAGE_ALLOCS is defined. It is kind of a dirty hack, but the
// uses for LOG_PAGE_ALLOCS are limited, and it is not worth writing
// a lot of special case code to support this situation. -patw
const bool save = Con::active;
Con::active = false;
consoleLog.push_back(entry);
Con::active = save;
#endif
}
if(!eofPos)
break;
pos = eofPos + 1;
}
}
Con::active = true;
}
