debug.h

/* Copyright (c) 2007-2012, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2013, Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LUNCHBOX_DEBUG_H
#define LUNCHBOX_DEBUG_H

#include <lunchbox/defines.h>
#include <lunchbox/log.h>

#include <typeinfo>

// assertions
// #define LB_RELEASE_ASSERT

namespace lunchbox
{
LUNCHBOX_API void abort();

LUNCHBOX_API void checkHeap();

LUNCHBOX_API std::ostream& sysError( std::ostream& os );

LUNCHBOX_API std::string sysError();

LUNCHBOX_API std::string backtrace( const size_t skipFrames );

LUNCHBOX_API std::ostream& backtrace( std::ostream& os );

LUNCHBOX_API std::string demangleTypeID( const char* mangled ); 

#ifdef _WIN32
#  pragma warning( disable: 4100 ) // VS Bug
#endif

template< class T > inline std::string className( const T* object )
    { return demangleTypeID( typeid( *object ).name( )); }

template< class T > inline std::string className( const T& object )
    { return demangleTypeID( typeid( object ).name( )); }
#ifdef _WIN32
#  pragma warning( default: 4100 )
#endif

template< class T > inline std::string format( const T* data, const size_t num )
{
    std::ostringstream os;
    os << num << " " << className( data ) << " @ " << std::hex
       << (const void*)data << ": 0x";
    for( size_t i = 0; i < num; ++i )
    {
        if( (i % 8) == 0 )
            os << "   " << std::endl;
        os << ' ' << data[i];
    }
    return os.str();
}

template<> inline std::string format( const uint8_t* data, const size_t num )
{
    std::ostringstream os;
    os << num << " bytes @ " << std::hex << (const void*)data << ": 0x";
    os.precision( 2 );
    for( size_t i = 0; i < num; ++i )
    {
        if( (i % 32) == 0 )
            os << "   " << std::endl;
        else if( (i % 8) == 0 )
            os << ' ';
        os << ' ' << std::setw(2) << int( data[i] );
    }
    return os.str();
}

template<> inline std::string format( const void* data, const size_t num )
    { return format( reinterpret_cast< const uint8_t* >( data ), num ); }

template< class T > inline std::string format( const std::vector< T >& data )
    { return format< T >( &data[0], data.size( )); }

} // namespace lunchbox

#ifdef NDEBUG
#  ifdef LB_RELEASE_ASSERT
#    define LBASSERT(x)                                                 \
    {                                                                   \
        if( !(x) )                                                      \
            LBERROR << "##### Assert: " << #x << " #####" << std::endl  \
                    << lunchbox::forceFlush;                            \
        lunchbox::checkHeap();                                          \
    }
#    define LBASSERTINFO(x, info)                                       \
    {                                                                   \
        if( !(x) )                                                      \
            LBERROR << "##### Assert: " << #x << " [" << info << "] #####" \
                    << std::endl << lunchbox::forceFlush;               \
        lunchbox::checkHeap();                                          \
    }
#    define LBCHECK(x) { const bool eqOk = x; LBASSERTINFO( eqOk, #x ) }
#  else
#    define LBASSERT(x)
#    define LBASSERTINFO(x, info)
#    define LBCHECK(x) { x; }
#  endif

#  define LBUNIMPLEMENTED { LBERROR << "Unimplemented code" << std::endl \
                                    << lunchbox::forceFlush; }
#  define LBUNREACHABLE   { LBERROR << "Unreachable code" << std::endl  \
                                    << lunchbox::forceFlush; }
#  define LBDONTCALL                                                    \
    { LBERROR << "Code is not supposed to be called in this context"    \
              << std::endl << lunchbox::forceFlush; }
#  define LBABORT( info ) {                                         \
        LBERROR << "##### Abort: " << info << " #####" << std::endl \
                << lunchbox::forceFlush; }

#else // NDEBUG

#  define LBASSERT(x)                                                   \
    {                                                                   \
        if( !(x) )                                                      \
        {                                                               \
            LBERROR << "Assert: " << #x << " ";                         \
            lunchbox::abort();                                          \
        }                                                               \
        lunchbox::checkHeap();                                          \
    }
#  define LBASSERTINFO(x, info)                                         \
    {                                                                   \
        if( !(x) )                                                      \
        {                                                               \
            LBERROR << "Assert: " << #x << " [" << info << "] ";        \
            lunchbox::abort();                                          \
        }                                                               \
        lunchbox::checkHeap();                                          \
    }

#  define LBUNIMPLEMENTED                                               \
    { LBERROR << "Unimplemented code in " << lunchbox::className( this ) \
              << " ";                                                   \
        lunchbox::abort(); }
#  define LBUNREACHABLE                                                 \
    { LBERROR << "Unreachable code in " << lunchbox::className( this )  \
              << " ";                                                   \
        lunchbox::abort(); }
#  define LBDONTCALL                                                    \
    { LBERROR << "Code is not supposed to be called in this context, type " \
              << lunchbox::className( this ) << " " ;                   \
        lunchbox::abort(); }

#  define LBCHECK(x) { const bool eqOk = x; LBASSERTINFO( eqOk, #x ) }
#  define LBABORT( info ) {                                             \
        LBERROR << "Abort: " << info;                                   \
        lunchbox::abort(); }
#endif // NDEBUG

#define LBSAFECAST( to, in ) static_cast< to >( in );   \
    LBASSERT( in == 0 || dynamic_cast< to >( static_cast< to >( in )))

#endif //LUNCHBOX_DEBUG_H