// PRIMARY FUNCTION TO WRITE A LINE TO THE LOGFILE
bool
LogAnalysis::AnalysisLog(const char* p_function,LogType p_type,bool p_doFormat,const char* p_format,...)
{
// Multi threaded protection
AutoCritSec lock(&m_lock);
CString logBuffer;
bool result = false;
// Make sure the system is initialized
Initialisation();
// Make sure we ARE logging
if(m_logLevel == HLL_NOLOG)
{
return result;
}
// Check on the loglevel
if(m_logLevel == HLL_ERRORS && (p_type == LogType::LOG_INFO || p_type == LogType::LOG_TRACE))
{
return result;
}
// Timing position in the buffer
int position = 0;
// Set the type
char type = ' ';
switch(p_type)
{
case LogType::LOG_TRACE:type = 'T'; break;
case LogType::LOG_INFO: type = '-'; break;
case LogType::LOG_ERROR:type = 'E'; break;
case LogType::LOG_WARN: type = 'W'; break;
}
// Get/print the time
if(m_doTiming)
{
__timeb64 now;
struct tm today;
position = 26; // Prefix string length
_ftime64_s(&now);
_localtime64_s(&today,&now.time);
logBuffer.Format("%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d.%03d %c "
,today.tm_year + 1900
,today.tm_mon + 1
,today.tm_mday
,today.tm_hour
,today.tm_min
,today.tm_sec
,now.millitm
,type);
}
// Print the calling function
logBuffer += p_function;
if(logBuffer.GetLength() < position + ANALYSIS_FUNCTION_SIZE)
{
logBuffer.Append(" "
,position + ANALYSIS_FUNCTION_SIZE - logBuffer.GetLength());
}
// Print the arguments
if(p_doFormat)
{
va_list varargs;
va_start(varargs,p_format);
logBuffer.AppendFormatV(p_format,varargs);
va_end(varargs);
}
else
{
logBuffer += p_format;
}
// Add end-of line
logBuffer += "\r\n";
if(m_file)
{
// Locked m_list gets a buffer
m_list.push_back(logBuffer);
result = true;
}
else if(m_doEvents)
{
WriteEvent(m_eventLog,p_type,logBuffer);
result = true;
}
// In case of an error, flush immediately!
if(m_file && p_type == LogType::LOG_ERROR)
{
SetEvent(m_event);
}
return result;
}
_CRTIMP void __cdecl _ftime64 (
struct __timeb64 *tp
)
{
_ftime64_s(tp);
}
INLINE
#endif /* PTW32_BUILD_INLINED */
DWORD
ptw32_relmillisecs (const struct timespec * abstime)
{
const int64_t NANOSEC_PER_MILLISEC = 1000000;
const int64_t MILLISEC_PER_SEC = 1000;
DWORD milliseconds;
int64_t tmpAbsMilliseconds;
int64_t tmpCurrMilliseconds;
#ifdef NEED_FTIME
struct timespec currSysTime;
FILETIME ft;
SYSTEMTIME st;
#else /* ! NEED_FTIME */
#if (defined(__MINGW64__) || defined(__MINGW32__)) && __MSVCRT_VERSION__ >= 0x0601
struct __timeb64 currSysTime;
#else
struct _timeb currSysTime;
#endif
#endif /* NEED_FTIME */
/*
* Calculate timeout as milliseconds from current system time.
*/
/*
* subtract current system time from abstime in a way that checks
* that abstime is never in the past, or is never equivalent to the
* defined INFINITE value (0xFFFFFFFF).
*
* Assume all integers are unsigned, i.e. cannot test if less than 0.
*/
tmpAbsMilliseconds = (int64_t)abstime->tv_sec * MILLISEC_PER_SEC;
tmpAbsMilliseconds += ((int64_t)abstime->tv_nsec + (NANOSEC_PER_MILLISEC/2)) / NANOSEC_PER_MILLISEC;
/* get current system time */
#ifdef NEED_FTIME
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
/*
* GetSystemTimeAsFileTime(&ft); would be faster,
* but it does not exist on WinCE
*/
ptw32_filetime_to_timespec(&ft, &currSysTime);
tmpCurrMilliseconds = (int64_t)currSysTime.tv_sec * MILLISEC_PER_SEC;
tmpCurrMilliseconds += ((int64_t)currSysTime.tv_nsec + (NANOSEC_PER_MILLISEC/2))
/ NANOSEC_PER_MILLISEC;
#else /* ! NEED_FTIME */
#ifdef _MSC_VER
_ftime64_s(&currSysTime);
#elif (defined(__MINGW64__) || defined(__MINGW32__)) && __MSVCRT_VERSION__ >= 0x0601
_ftime64(&currSysTime);
#else
_ftime(&currSysTime);
#endif
tmpCurrMilliseconds = (int64_t) currSysTime.time * MILLISEC_PER_SEC;
tmpCurrMilliseconds += (int64_t) currSysTime.millitm;
#endif /* NEED_FTIME */
if (tmpAbsMilliseconds > tmpCurrMilliseconds)
{
milliseconds = (DWORD) (tmpAbsMilliseconds - tmpCurrMilliseconds);
if (milliseconds == INFINITE)
{
/* Timeouts must be finite */
milliseconds--;
}
}
else
{
/* The abstime given is in the past */
milliseconds = 0;
}
return milliseconds;
}