fs/sys/fsLog.cpp

Go to the documentation of this file.

/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
/*                          _______      ______    ______          __      */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~    / ____(_)___ / ___ /)  / ____/___  ____/ /__    */
/*       [fsLog]          / /_  / / __ \\__ \|/  / /   / __ \/ __  / _ \   */
/*       rev.  12        / __/ / / /_/ /__/ /   / /___/ /_/ / /_/ /  __/   */
/*    29th Jan 2007     /_/   /_/ ,___/____/    \____/\____/\__,_/\___/    */
/*     [x] stable              /_/ (c) 2004-7 Filip STOKLAS (FipS)         */
/*  ~ ~ ~ ~ ~ ~ ~ ~ ~ ~       http://HOLE.4FipS.com/fips_code.php          */
/*                                                                         */
/* This code is free for personal and commercial use. You may redistribute */
/* it by any means. If you use the code for your own projects please give  */
/* me credit. Please send a bug report. Don't alter or remove this header! */
/*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
#include <fs/sys/fsLog.h>

// >>> COMMON SUPPORT BLOCK (rev. 6)
#if defined(FS_HAS_FSASSERT)
#   include <fs/sys/fsAssert.h>
#else
#   include <cassert>
#   if !defined(FS_ASSERT)
#       define FS_ASSERT(exp) assert(exp)
#   endif
#   if !defined(FS_ASSERT_MSG)
#       define FS_ASSERT_MSG(exp, msg) assert(exp && msg)
#   endif
#   if !defined(FS_VERIFY)
#       define FS_VERIFY(exp) \
        { bool bExp = !!(exp); assert(bExp && #exp); bExp; }
#   endif
#   if !defined(FS_VERIFY_MSG)
#       define FS_VERIFY_MSG(exp, msg) \
        { bool bExp = !!(exp); assert(bExp && #exp && msg); bExp; }
#   endif
#   if !defined(FS_STATIC_ASSERT)
#       define FS_STATIC_ASSERT(exp) { char error[(exp) ? 1 : 0]; error; }
#   endif
#endif
#if !defined(FS_VERIFY_RETURN)
#   define FS_VERIFY_RETURN(exp) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<return>"); return; }
#endif
#if !defined(FS_VERIFY_RETURN_VAL)
#   define FS_VERIFY_RETURN_VAL(exp, ret) \
    if(!(exp)) { FS_ASSERT_MSG(0, #exp "<returns:>" #ret); return (ret); }
#endif
// <<< COMMON SUPPORT BLOCK (rev. 6)

#include <queue>
#include <string>
#include <stdarg.h> // va_list

#if defined(_WIN32)
#   include <windows.h> // time, debug output
#else
#   include <time.h> // clock
#endif

// provide detailed memory tracking information
#if defined(FS_HAS_FSMEMMGR)
#   include <fs/sys/fsMemMgr.h>
#endif
//---------------------------------------------------------------------------
#if (_MSC_VER >= 1400) // MSVC8
#   pragma warning(disable : 4996) // function was marked as deprecated
#endif
//---------------------------------------------------------------------------
using namespace fs::sys;
//---------------------------------------------------------------------------
namespace fs { namespace sys {
//---------------------------------------------------------------------------
//--- CLASS LogImpl_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------

class LogImpl_t : public Log_t
{
public:

    LogImpl_t(unsigned int fMode, size_t uHist, const char *pszFile);
    virtual ~LogImpl_t();

    virtual void SetTgt(Log_t *pTgt);
    
protected:

    virtual void RegSrc(Log_t *pSrc, bool bReg = true);
    virtual void PushLn(const char *pszText, bool bMsgBrk = false);
    
private:

    LogImpl_t();
    LogImpl_t(const LogImpl_t &);
    LogImpl_t & operator = (const LogImpl_t &);
    
    unsigned int m_fMode; 
    
    Log_t *m_pTgt; 
    typedef std::vector<Log_t *> TSrcs;
    TSrcs m_Srcs; 
            
    void *m_hFile; 
    
    typedef std::deque<std::string> Hist_t;
    Hist_t m_Hist; 
    size_t m_uHist; 
        
    size_t m_uWrns; 
    size_t m_uErrs; 
};
//---------------------------------------------------------------------------
}} //namespace fs::sys
//---------------------------------------------------------------------------
LogImpl_t::LogImpl_t(unsigned int fMode, size_t uHist, const char 
 *pszFile):
m_fMode(fMode),
m_pTgt(0),
m_hFile(0),
m_uHist(uHist),
m_uWrns(0),
m_uErrs(0)
{
    if((fMode & LOG_FILE) && pszFile)
        m_hFile = static_cast<FILE *>(::fopen(pszFile, "w"));
}
//---------------------------------------------------------------------------
LogImpl_t::~LogImpl_t()
{
    // stop being a source
    SetTgt(0);

    // disconnect from all sources
    while(!m_Srcs.empty())
        m_Srcs[0]->SetTgt(0);
        
    // log statistics
    char szBuf[96];

    ::sprintf(szBuf, "o.LOG %u warning(s), %u error(s) found.",
     m_uWrns, m_uErrs);

    PushLn(szBuf);

    // close resources
    if(m_hFile)
        ::fclose(static_cast<FILE *>(m_hFile));
}
//---------------------------------------------------------------------------
void LogImpl_t::SetTgt(Log_t *pTgt)
{
    if(pTgt == this || m_pTgt == pTgt) // do nothing
        return;

    if(m_pTgt) // brake current link
        m_pTgt->RegSrc(this, false);

    m_pTgt = pTgt;
    if(!m_pTgt) // no new target
        return;

    if(m_pTgt) // make a new link
        m_pTgt->RegSrc(this);
        
    // dump the history
    for(Hist_t::const_iterator it = m_Hist.begin(); it != m_Hist.end(); ++it)
        m_pTgt->PushLn((*it).c_str());
    
    // clear the history
    Hist_t().swap(m_Hist);
}
//---------------------------------------------------------------------------
void LogImpl_t::RegSrc(Log_t *pSrc, bool bReg)
{
    FS_ASSERT(pSrc);
    
    if(bReg)
        m_Srcs.push_back(pSrc);
    else
    {
        m_Srcs.erase(
         std::remove(m_Srcs.begin(), m_Srcs.end(), pSrc), m_Srcs.end()
        );
    }
}
//---------------------------------------------------------------------------
void LogImpl_t::PushLn(const char *pszText, bool bMsgBrk)
{
    if(bMsgBrk) // message break request
    {
        //             RUNTIME BREAK: A Message break has been invoked
        //                            (see 'pszText').
        FS_ASSERT_MSG(0, pszText); // ^^^
    }

    // scan for error / warning tag
    bool bWrn = pszText && ::strstr(pszText,"] !.");
    bool bErr = pszText && ::strstr(pszText,"] x.");
    
    if((m_fMode & LOG_RTMBRK) && (bWrn || bErr)) // notify break
    {
        //             RUNTIME BREAK: An Error / warning message has been
        //                            occurred (see 'pszText').
        FS_ASSERT_MSG(0, pszText); // ^^^
    }

    if(m_pTgt) // target is set, redirect the message
    {
        m_pTgt->PushLn(pszText);
        return;
    }

    // log to selected outputs
    if(m_fMode & LOG_HIST)
    {
        if(m_Hist.size() > m_uHist)
            m_Hist.pop_front();

        m_Hist.push_back(pszText);
    }
    if(m_hFile)
    {
        ::fputs(pszText, static_cast<FILE *>(m_hFile));
        ::fputs("\n", static_cast<FILE *>(m_hFile));
        ::fflush(static_cast<FILE *>(m_hFile));
    }
    if(m_fMode & LOG_STDOUT)
    {
        ::puts(pszText);
    }
#if defined(_WIN32)
    if(m_fMode & LOG_DBGOUT)
    {
        ::OutputDebugStringA(pszText);
        ::OutputDebugStringA("\n");
    }
#endif

    // update statistics
    if(bWrn) ++m_uWrns;
    if(bErr) ++m_uErrs;
}
//---------------------------------------------------------------------------
//--- CLASS Log_t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//---------------------------------------------------------------------------
Log_t::Log_t(unsigned int fMode, size_t uHist, const char *pszFile):
m_pImpl(new LogImpl_t(fMode, uHist, pszFile))
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
}
//---------------------------------------------------------------------------
Log_t::Log_t():
m_pImpl(0)
{
}
//---------------------------------------------------------------------------
Log_t::~Log_t()
{
    // note that if 'm_pImpl' is 0, it means that this 'Log_t' instance is
    // nested in 'LogImpl_t'
    delete m_pImpl;
}
//---------------------------------------------------------------------------
void Log_t::Push(const char *pszFmt, ...)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");

    // time stamp
    unsigned int uTimeMs = 0;
    // note that if there are multiple modules the time stamp should be
    // based on a common time source...

#if defined(UNDER_CE)

    uTimeMs = ::GetTickCount();
    
#elif defined(_WIN32)

    ::FILETIME tmCreation;
    ::FILETIME tmExit;
    ::FILETIME tmKernel;
    ::FILETIME tmUser;
    ::GetProcessTimes(::GetCurrentProcess(), &tmCreation, &tmExit,
     &tmKernel, &tmUser);
     
    ::FILETIME tmCurrent;
    ::GetSystemTimeAsFileTime(&tmCurrent);
    
    const __int64 nDur100NS =
     (static_cast<__int64>
     (tmCurrent.dwHighDateTime - tmCreation.dwHighDateTime) << 32) +
     (tmCurrent.dwLowDateTime - tmCreation.dwLowDateTime);
    
    uTimeMs = static_cast<unsigned int>(nDur100NS / 10000);
    
#else

    uTimeMs = static_cast<unsigned int>
     (1000.0 * ::clock() / CLOCKS_PER_SEC);

#endif
     
    char szBuf[1024];
    ::sprintf(szBuf,  "[%06u:%03u] ", uTimeMs / 1000, uTimeMs % 1000);
    
    // form the message
    va_list Args;
    va_start(Args, pszFmt);
    const size_t uSize = sizeof(szBuf);
    const size_t uCount = ::strlen(szBuf);
    ::_vsnprintf(szBuf + uCount, sizeof(szBuf) - uCount, pszFmt, Args);
    va_end(Args);
    
    // handle a truncated message (note that szBuf is never empty)
    szBuf[uSize - 2] = szBuf[uSize - 3] = szBuf[uSize - 4] = '.';
    szBuf[uSize - 1] = '\0';
    
    // truncate new-line codes
    for(size_t n = ::strlen(szBuf) - 1; n > 0; --n)
    {
        if(szBuf[n] == 0x0D || szBuf[n] == 0x0A)
            szBuf[n] = '\0';
        else
            break;
    }
    
    // handle 'message brake' tag
    bool bMsgBrk = false;
    size_t uLen = strlen(szBuf);
    if(uLen > 0 && szBuf[uLen - 1] == '@')
    {
        szBuf[uLen - 1] = '\0';
        bMsgBrk = true;     
    }
    
    // lot the line
    m_pImpl->PushLn(szBuf, bMsgBrk);
}
//---------------------------------------------------------------------------
void Log_t::PushLn(const char *pszText, bool bMsgBrk)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    m_pImpl->PushLn(pszText, bMsgBrk);
}
//---------------------------------------------------------------------------
void Log_t::SetTgt(Log_t *pTgt)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    m_pImpl->SetTgt(pTgt ? pTgt->m_pImpl : 0);
}
//---------------------------------------------------------------------------
void Log_t::RegSrc(Log_t *pSrc, bool bReg)
{
    FS_ASSERT_MSG(m_pImpl, "Invalid implementation pointer!");
    m_pImpl->RegSrc(pSrc, bReg);
}
//---------------------------------------------------------------------------
#if defined (FS_LOG_ENABLE_MODLOG)
Log_t & fs::sys::ModLog()
{
    static Log_t Inst(
     FS_LOG_MODLOG_MODE,
     FS_LOG_MODLOG_HIST,
     FS_LOG_MODLOG_FILE
    );
    
    return Inst;
}
#endif
//---------------------------------------------------------------------------

---

FipS' Code (Thu Feb 15 22:43:35 2007) - (c) Filip STOKLAS (FipS) - [ www ] [ Guest Book ]