debug.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_DEBUG_H
#define NL_DEBUG_H

#include <cstdio>

#include "common.h"
#include "log.h"
#include "mutex.h"
#include "mem_displayer.h"
#include "displayer.h"
#include "app_context.h"
#include <set>

namespace NLMISC
{

#ifdef ASSERT_THROW_EXCEPTION
#define ASSERT_THROW_EXCEPTION_CODE(exp) ASSERT_THROW_EXCEPTION_CODE_EX(exp, #exp)
#define ASSERT_THROW_EXCEPTION_CODE_EX(exp, str) if(!(exp)) throw NLMISC::Exception(str" returns false");
#else
#define ASSERT_THROW_EXCEPTION_CODE(exp)
#define ASSERT_THROW_EXCEPTION_CODE_EX(exp, str)
#endif

class CImposterLog
{
private:
    typedef CLog *(INelContext::*TAccessor)();

    // Method to access the Log
    TAccessor   _Accessor;
public:
    CImposterLog(TAccessor accessor);
    CLog* operator -> ();
    operator CLog*();
    CLog &operator ()();
};


//
// Externals
//

// NOTE: The following are all NULL until createDebug() has been called at least once
// NOTE2: You must not use this class before the main() (not inside a static class ctor)
extern CImposterLog     ErrorLog;
extern CImposterLog     WarningLog;
extern CImposterLog     InfoLog;
extern CImposterLog     DebugLog;
extern CImposterLog     AssertLog;

extern CMemDisplayer *DefaultMemDisplayer;
extern CMsgBoxDisplayer *DefaultMsgBoxDisplayer;


//
// Functions
//

// internal use only
void createDebug (const char *logPath = NULL, bool logInFile = true, bool eraseLastLog = false);

void destroyDebug();

// call this if you want to change the dir of the log.log file
void changeLogDirectory(const std::string &dir);

// internal breakpoint window
void enterBreakpoint (const char *message);

// if true, the assert generates an assert
// if false, the assert just displays a warning and continue
void setAssert (bool assert);

// Beep (Windows only, no effect elsewhere)
void beep( uint freq, uint duration );


typedef std::string (*TCrashCallback)();

// this function enables user application to add information in the log when a crash occurs
void setCrashCallback(TCrashCallback crashCallback);

// For Crash report window. allow to know if a crash has already raised in the application
bool    isCrashAlreadyReported();
void    setCrashAlreadyReported(bool state);


// This very amazing macro __FUNCTION__ doesn't exist on VC6, map it to NULL
#ifdef NL_COMP_VC6
#   define __FUNCTION__ NULL
#endif


// Macros

#define NL_MACRO_TO_STR_SUBPART(x) #x

#define NL_MACRO_TO_STR(x) NL_MACRO_TO_STR_SUBPART(x)

#define NL_LOC_MSG __FILE__"("NL_MACRO_TO_STR(__LINE__)") : Message: "
#define NL_LOC_WRN __FILE__"("NL_MACRO_TO_STR(__LINE__)") : Warning Msg: "


#ifdef NL_NO_DEBUG
#   if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9)
#       define nldebug __noop
#   else
#       define nldebug 0&&
#   endif
#else // NL_NO_DEBUG
    extern bool DisableNLDebug;
#   define nldebug if (NLMISC::DisableNLDebug) {} else (NLMISC::createDebug(), NLMISC::INelContext::getInstance().getDebugLog()->setPosition( __LINE__, __FILE__, __FUNCTION__ ), NLMISC::INelContext::getInstance().getDebugLog())->displayNL
#endif // NL_NO_DEBUG

#ifdef NL_NO_DEBUG
#   if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9)
#       define nlinfo __noop
#   else
#       define nlinfo 0&&
#   endif
#else // NL_NO_DEBUG
#   define nlinfo (NLMISC::createDebug(), NLMISC::INelContext::getInstance().getInfoLog()->setPosition( __LINE__, __FILE__, __FUNCTION__ ), NLMISC::INelContext::getInstance().getInfoLog())->displayNL
#endif // NL_NO_DEBUG

#ifdef NL_NO_DEBUG
#   if defined(NL_COMP_VC71) || defined(NL_COMP_VC8) || defined(NL_COMP_VC9)
#       define nlwarning __noop
#   else
#       define nlwarning 0&&
#   endif
#else // NL_NO_DEBUG
#   define nlwarning (NLMISC::createDebug(), NLMISC::INelContext::getInstance().getWarningLog()->setPosition( __LINE__, __FILE__, __FUNCTION__ ), NLMISC::INelContext::getInstance().getWarningLog())->displayNL
#endif // NL_NO_DEBUG

#define nlerror (NLMISC::createDebug (), NLMISC::INelContext::getInstance().getErrorLog()->setPosition( __LINE__, __FILE__, __FUNCTION__ ), NLMISC::nlFatalError)


#define nlerrornoex (NLMISC::createDebug (), NLMISC::INelContext::getInstance().getErrorLog()->setPosition( __LINE__, __FILE__, __FUNCTION__ ), NLMISC::nlError)


// removed because we always check assert (even in release mode) #if defined (NL_OS_WINDOWS) && defined (NL_DEBUG)
#if defined (NL_OS_WINDOWS)
#define NLMISC_BREAKPOINT __debugbreak();
#else
#define NLMISC_BREAKPOINT abort()
#endif

// Internal, don't use it (make smaller assert code)
extern bool _assert_stop(bool &ignoreNextTime, sint line, const char *file, const char *funcName, const char *exp);
extern void _assertex_stop_0(bool &ignoreNextTime, sint line, const char *file, const char *funcName, const char *exp);
extern bool _assertex_stop_1(bool &ignoreNextTime);

// removed because we always check assert (even in release mode) #if defined(NL_DEBUG)

#ifdef NL_NO_DEBUG
#   define nlassert(exp) if(false)
#   define nlassertonce(exp) if(false)
#   define nlassertex(exp, str) if(false)
#   define nlverify(exp) { exp; }
#   define nlverifyonce(exp) { exp; }
#   define nlverifyex(exp, str) { exp; }
#else // NL_NO_DEBUG

#   ifdef NL_OS_UNIX

// Linux set of asserts is reduced due to that there is no message box displayer

#define nlassert(exp) \
{ \
    if (!(exp)) { \
        NLMISC::createDebug (); \
        NLMISC::INelContext::getInstance().getAssertLog()->setPosition (__LINE__, __FILE__, __FUNCTION__); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayNL ("\"%s\" ", #exp); \
        NLMISC_BREAKPOINT; \
    } \
}

#define nlassertonce(exp) nlassert(exp)

#define nlassertex(exp, str) \
{ \
    if (!(exp)) { \
        NLMISC::createDebug (); \
        NLMISC::INelContext::getInstance().getAssertLog()->setPosition (__LINE__, __FILE__, __FUNCTION__); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayNL ("\"%s\" ", #exp); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayRawNL str; \
        NLMISC_BREAKPOINT; \
    } \
}

#define nlverify(exp) nlassert(exp)
#define nlverifyonce(exp) nlassert(exp)
#define nlverifyex(exp, str) nlassertex(exp, str)

#   else // NL_OS_UNIX

#define nlassert(exp) \
{ \
    static bool ignoreNextTime = false; \
    bool _expResult_ = (exp) ? true : false; \
    if (!ignoreNextTime && !_expResult_) { \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp)) \
            NLMISC_BREAKPOINT; \
    } \
    ASSERT_THROW_EXCEPTION_CODE_EX(_expResult_, #exp) \
}

#define nlassertonce(exp) \
{ \
    static bool ignoreNextTime = false; \
    if (!ignoreNextTime && !(exp)) { \
        ignoreNextTime = true; \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp)) \
            NLMISC_BREAKPOINT; \
    } \
}

#define nlassertex(exp, str) \
{ \
    static bool ignoreNextTime = false; \
    bool _expResult_ = (exp) ? true : false; \
    if (!ignoreNextTime && !_expResult_) { \
        NLMISC::_assertex_stop_0(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayRawNL str; \
        if(NLMISC::_assertex_stop_1(ignoreNextTime)) \
            NLMISC_BREAKPOINT; \
    } \
    ASSERT_THROW_EXCEPTION_CODE_EX(_expResult_, #exp) \
}

#define nlverify(exp) \
{ \
    static bool ignoreNextTime = false; \
    bool _expResult_ = (exp) ? true : false; \
    if (!_expResult_ && !ignoreNextTime) { \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp)) \
            NLMISC_BREAKPOINT; \
    } \
    ASSERT_THROW_EXCEPTION_CODE_EX(_expResult_, #exp) \
}

#define nlverifyonce(exp) \
{ \
    static bool ignoreNextTime = false; \
    bool _expResult_ = (exp) ? true : false; \
    if (!_expResult_ && !ignoreNextTime) { \
        ignoreNextTime = true; \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp)) \
            NLMISC_BREAKPOINT; \
    } \
}

#define nlverifyex(exp, str) \
{ \
    static bool ignoreNextTime = false; \
    bool _expResult_ = (exp) ? true : false; \
    if (!_expResult_ && !ignoreNextTime) { \
        NLMISC::_assertex_stop_0(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, #exp); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayRawNL str; \
        if(NLMISC::_assertex_stop_1(ignoreNextTime)) \
            NLMISC_BREAKPOINT; \
    } \
    ASSERT_THROW_EXCEPTION_CODE_EX(_expResult_, #exp) \
}

#   endif // NL_OS_UNIX

#endif // NL_NO_DEBUG

#define nlunreferenced(identifier) (identifier)

#define nlstop \
{ \
    static bool ignoreNextTime = false; \
    if (!ignoreNextTime) { \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, NULL)) \
            NLMISC_BREAKPOINT; \
    } \
    ASSERT_THROW_EXCEPTION_CODE(false) \
}

#define nlstoponce \
{ \
    static bool ignoreNextTime = false; \
    if (!ignoreNextTime) { \
        ignoreNextTime = true; \
        if(NLMISC::_assert_stop(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, NULL)) \
            NLMISC_BREAKPOINT; \
    } \
}


#define nlstopex(str) \
{ \
    static bool ignoreNextTime = false; \
    if (!ignoreNextTime) { \
        NLMISC::_assertex_stop_0(ignoreNextTime, __LINE__, __FILE__, __FUNCTION__, NULL); \
        NLMISC::INelContext::getInstance().getAssertLog()->displayRawNL str; \
        if(NLMISC::_assertex_stop_1(ignoreNextTime)) \
            NLMISC_BREAKPOINT; \
    } \
}


struct EFatalError : public Exception
{
    EFatalError() : Exception( "nlerror() called" ) {}
};

class ETrapDebug : public Exception
{
};

// undef default assert to force people to use nlassert() instead of assert()
// if NL_MAP_ASSERT is set we map assert to nlassert instead of removing it
// this makes it compatible with zeroc's ICE network library

#ifdef NL_MAP_ASSERT
#   ifdef assert
#       undef assert
#       define assert nlassert
#   endif
#else
#   ifdef assert
#       undef assert
#       define assert(a) you_must_not_use_assert___use_nl_assert___read_debug_h_file
#   endif
#endif


void getCallStack(std::string &result, sint skipNFirst = 0);

void getCallStackAndLog (std::string &result, sint skipNFirst = 0);

template<class T, class U>  inline T    safe_cast(U o)
{
    // NB: must check debug because assert may still be here in release
#ifdef NL_DEBUG
    nlassert(dynamic_cast<T>(o));
#endif
    return static_cast<T>(o);
}

template<class T, class U>  inline T    type_cast(U o)
{
    // NB: must check debug because assert may still be here in release
#ifdef NL_DEBUG
    if (o)
        nlassert(dynamic_cast<T>(o));
#endif
    //  optimization made to check pointer validity before address translation. (hope it works on linux).
    if ((size_t)(static_cast<T>((U)0x0400)) == (size_t)((U)0x0400))
    {
        return static_cast<T>(o);
    }
    else
    {
        return (o==0)?0:static_cast<T>(o);
    }
}

#define nlctassert(cond) sizeof(uint[(cond) ? 1 : 0])

// Need a breakpoint in the assert / verify macro
extern bool DebugNeedAssert;

// Internal process, don't use it
extern bool NoAssert;


template<class T>
class CMustConsume
{
public:
    CMustConsume(const T &val) : Value(val)
#if !FINAL_VERSION
    , Consumed(false)
#endif
    {
    }

    ~CMustConsume()
    {
#if !FINAL_VERSION
        nlassert(Consumed == true);
#endif
    }

    //  Get the value without validating the access.
    const T &value() const
    {
        return Value;
    }

    operator const T &() const
    {
#if !FINAL_VERSION
        Consumed = true;
#endif
        return Value;
    }

    //  Get the value and validate the access.
    const T &consumeValue() const
    {
#if !FINAL_VERSION
        Consumed = true;
#endif
        return Value;
    }
    //  Only consume the access.
    void consume() const
    {
#if !FINAL_VERSION
        Consumed = true;
#endif
    }

private:
    T               Value;
#if !FINAL_VERSION
    mutable bool    Consumed;
#endif
};

struct TInstanceCounterData
{
    sint32      _InstanceCounter;
    sint32      _DeltaCounter;
    const char  *_ClassName;
    bool        _Touched;

    TInstanceCounterData(const char *className);

    ~TInstanceCounterData();
};

// forward declaration for members of CInstanceCounterManager
class CInstanceCounterLocalManager;

// The singleton used to display the instance counter
class CInstanceCounterManager
{
//  NLMISC_SAFE_SINGLETON_DECL(CInstanceCounterManager);
    private:
        /* declare private constructors*/
        CInstanceCounterManager () {}
        CInstanceCounterManager (const CInstanceCounterManager &) {}
        /* the local static pointer to the singleton instance */
        static CInstanceCounterManager  *_Instance;
    public:
        static CInstanceCounterManager &getInstance()
        {
            if (_Instance == NULL)
            {
                /* the nel context MUST be initialised */
//              nlassert(NLMISC::NelContext != NULL);
                void *ptr = NLMISC::INelContext::getInstance().getSingletonPointer("CInstanceCounterManager");
                if (ptr == NULL)
                {
                    /* allocate the singleton and register it */
                    _Instance = new CInstanceCounterManager;
                    NLMISC::INelContext::getInstance().setSingletonPointer("CInstanceCounterManager", _Instance);
                }
                else
                {
                    _Instance = reinterpret_cast<CInstanceCounterManager*>(ptr);
                }
            }
            return *_Instance;
        }
    private:
public:

    std::string displayCounters() const;

    void resetDeltaCounter();

    uint32 getInstanceCounter(const std::string &className) const;
    sint32 getInstanceCounterDelta(const std::string &className) const;

private:

    friend class CInstanceCounterLocalManager;

    void registerInstaceCounterLocalManager(CInstanceCounterLocalManager *localMgr);
    void unregisterInstaceCounterLocalManager(CInstanceCounterLocalManager *localMgr);

//  static CInstanceCounterManager      *_Instance;
    std::set<CInstanceCounterLocalManager*> _InstanceCounterMgrs;
};

//
// Local instance counter
//
class CInstanceCounterLocalManager
{
public:
    static CInstanceCounterLocalManager &getInstance()
    {
        if (_Instance == NULL)
        {
            _Instance = new CInstanceCounterLocalManager;
        }
        return *_Instance;
    }

    static void releaseInstance()
    {
        if (_Instance != NULL)
        {
            delete _Instance;
            _Instance = NULL;
        }
    }

    void registerInstanceCounter(TInstanceCounterData *counter)
    {
        _InstanceCounters.insert(counter);
    }

    void unregisterInstanceCounter(TInstanceCounterData *counter);

    ~CInstanceCounterLocalManager()
    {
        CInstanceCounterManager::getInstance().unregisterInstaceCounterLocalManager(this);
    }

private:
    friend class CInstanceCounterManager;
    friend class INelContext;

    CInstanceCounterLocalManager()
    {
    }

    void registerLocalManager()
    {
        CInstanceCounterManager::getInstance().registerInstaceCounterLocalManager(this);
    }

    static CInstanceCounterLocalManager     *_Instance;
    std::set<TInstanceCounterData*>         _InstanceCounters;
};


#define NL_INSTANCE_COUNTER_DECL(className) \
public: \
    struct className##InstanceCounter \
    { \
        className##InstanceCounter() \
        { \
            _InstanceCounterData._InstanceCounter++; \
            _InstanceCounterData._Touched = true; \
        } \
        className##InstanceCounter(const className##InstanceCounter &/* other */) \
        { \
            _InstanceCounterData._InstanceCounter++; \
            _InstanceCounterData._Touched = true; \
        } \
        \
        ~className##InstanceCounter()\
        { \
            _InstanceCounterData._InstanceCounter--; \
        } \
        static sint32 getInstanceCounter() \
        { \
            return _InstanceCounterData._InstanceCounter; \
        } \
        static sint32 getInstanceCounterDelta() \
        { \
            return _InstanceCounterData._InstanceCounter - _InstanceCounterData._DeltaCounter; \
        } \
        static NLMISC::TInstanceCounterData _InstanceCounterData; \
    }; \
     \
    className##InstanceCounter  _##className##InstanceCounter; \
private:

#define NL_INSTANCE_COUNTER_IMPL(className) NLMISC::TInstanceCounterData className::className##InstanceCounter::_InstanceCounterData(#className);

#define NL_GET_LOCAL_INSTANCE_COUNTER(className) className::className##InstanceCounter::getInstanceCounter()
#define NL_GET_INSTANCE_COUNTER(className) NLMISC::CInstanceCounterManager::getInstance().getInstanceCounter(#className)

#define NL_GET_LOCAL_INSTANCE_COUNTER_DELTA(className) className::className##InstanceCounter::getInstanceCounterDelta()
#define NL_GET_INSTANCE_COUNTER_DELTA(className) NLMISC::CInstanceCounterManager::getInstance().getInstanceCounterDelta(#className)

//
// Following are internal functions, you should never use them
//

void nlFatalError (const char *format, ...);

void nlError (const char *format, ...);

#define NL_CRASH_DUMP_FILE "nel_debug.dmp"

// Standard API to retrieve error code and test for windows or unix platform

int getLastError();

std::string formatErrorMessage(int errorCode);


//-------------------------------------------------------------------------------------------------
// A handy 'nldebug', 'nlinfo' & 'nlwarning' override system
//-------------------------------------------------------------------------------------------------
//
// The system includes a set of object classes
// To override one or more of the standard NeL log channels one simply instantiates the appropriate class
// with the new log channel as a parameter.
// The log channel in question will revert to its previous value on destruction of the override object
//
// Usage Example:
//
//  void doSomething()
//  {
//      nlinfo("bla");
//      nlwarning("bla");
//  }
//
//  NLMISC_COMMAND(bla,"bla","bla")
//  {
//      CNLLogOverride(&log);
//      doSomething();
//      return true;
//  }
//

//-------------------------------------------------------------------------------------------------

class CNLDebugOverride
{
public:
    CNLDebugOverride(NLMISC::CLog *debugLog)
    {
        nlassert(debugLog!=NULL);
        _OldValue=NLMISC::DebugLog;
        nlassert(_OldValue!=NULL);
        NLMISC::INelContext::getInstance().setDebugLog(debugLog);
    }
    ~CNLDebugOverride()
    {
        NLMISC::INelContext::getInstance().setDebugLog(_OldValue);
    }
private:
    // prohibit copy
    CNLDebugOverride(const CNLDebugOverride&);
    NLMISC::CLog *_OldValue;
};

//-------------------------------------------------------------------------------------------------

class CNLInfoOverride
{
public:
    CNLInfoOverride(NLMISC::CLog *infoLog)
    {
        nlassert(infoLog!=NULL);
        _OldValue=NLMISC::InfoLog;
        nlassert(_OldValue!=NULL);
        NLMISC::INelContext::getInstance().setInfoLog(infoLog);
    }
    ~CNLInfoOverride()
    {
        NLMISC::INelContext::getInstance().setInfoLog(_OldValue);
    }
private:
    // prohibit copy
    CNLInfoOverride(const CNLInfoOverride&);
    NLMISC::CLog *_OldValue;
};

//-------------------------------------------------------------------------------------------------

class CNLWarningOverride
{
public:
    CNLWarningOverride(NLMISC::CLog *warningLog)
    {
        nlassert(warningLog!=NULL);
        _OldValue=NLMISC::WarningLog;
        nlassert(_OldValue!=NULL);
        NLMISC::INelContext::getInstance().setWarningLog(warningLog);
    }
    ~CNLWarningOverride()
    {
        NLMISC::INelContext::getInstance().setWarningLog(_OldValue);
    }
private:
    // prohibit copy
    CNLWarningOverride(const CNLWarningOverride&);
    NLMISC::CLog *_OldValue;
};

//-------------------------------------------------------------------------------------------------

class CNLLogOverride
{
public:
    CNLLogOverride(NLMISC::CLog *commonLog): _DebugLog(commonLog), _InfoLog(commonLog), _WarningLog(commonLog)  {}

private:
    CNLDebugOverride    _DebugLog;
    CNLInfoOverride     _InfoLog;
    CNLWarningOverride  _WarningLog;
};


//-------------------------------------------------------------------------------------------------

class CNLSmartLogOverride
{
public:
    CNLSmartLogOverride(NLMISC::CLog *commonLog):
        _DebugLog(commonLog==NLMISC::InfoLog?NLMISC::DebugLog:commonLog),
        _InfoLog(commonLog),
        _WarningLog(commonLog==NLMISC::InfoLog?NLMISC::WarningLog:commonLog)
        {}

private:
    CNLDebugOverride    _DebugLog;
    CNLInfoOverride     _InfoLog;
    CNLWarningOverride  _WarningLog;
};




} // NLMISC

#endif // NL_DEBUG_H

/* End of debug.h */