dbg.h

Go to the documentation of this file.

//======================================================================
//======================================================================

#ifndef DBG_h_
#define DBG_h_

#include "sdhlibrary_settings.h"

#if SDH_USE_VCC
# pragma warning(disable : 4996)
#endif

//----------------------------------------------------------------------
// System Includes - include with <>
//----------------------------------------------------------------------

#include <iostream>
#include <iomanip>
#include <string>
#include <stdarg.h>
#include <cstring>    // needed in gcc-4.3 for prototypes like strcmp according to http://gcc.gnu.org/gcc-4.3/porting_to.html
#include <stdlib.h>   // needed in gcc-4.3 for prototypes like getenv
#include <cstdio>     // needed in gcc-4.4 (as reported by Hannes Saal)

//----------------------------------------------------------------------
// Project Includes - include with ""
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Defines, enums, unions, structs
//----------------------------------------------------------------------

NAMESPACE_SDH_START


//----------------------------------------------------------------------
// Global variables (declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// External functions and classes (declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Function prototypes (function declarations)
//----------------------------------------------------------------------


//----------------------------------------------------------------------
// Class declarations
//----------------------------------------------------------------------


class VCC_EXPORT cDBG
{
protected:
    char const*   debug_color;
    char const*   normal_color;
    std::ostream *output;
    bool          debug_flag;
    std::streamsize mywidth;
public:

    cDBG( bool flag=false, char const* color="red", std::ostream *fd=&std::cerr )
    {
        debug_flag     = flag;
        SetColor( color );
        output         = fd;
        mywidth = output->width();
    }
    //---------------------

    ~cDBG()
    {
        output->flush();
    }

    void SetFlag( bool flag )
    {
        debug_flag  = flag;
    }


    bool GetFlag( void ) const
    {
        return debug_flag;
    }

    void SetColor( char const* color )
    {
        debug_color = GetColor( color );
        if ( !strcmp( debug_color, "" ) )
            // no debug color hence no normal color needed
            normal_color = debug_color;
        else
            // the code to set color back to normal
            normal_color = GetColor( "normal" );
    }
    //---------------------

    void SetOutput( std::ostream *fd )
    {
        output = fd;
    }
    //---------------------

    void PDM( char const* fmt, ... ) SDH__attribute__ ((format (printf, 2, 3)))
    /*
    * Remark:
    *   Since non-static C++ methods have an implicit `this' argument,
    *   the arguments of such methods should be counted from two, not
    *   one, when giving values for STRING-INDEX and FIRST-TO-CHECK
    *   parameter of the format __attribute__.)
    */
    {
        if (!debug_flag) return;

        char buffer[ 256 ];

        va_list arglist;
        va_start( arglist, fmt );
#if SDH_USE_VCC
        vsnprintf_s( buffer, 256, 256, fmt, arglist );
#else
        vsnprintf( buffer, 256, fmt, arglist );
#endif
        va_end( arglist );

        *output << debug_color << buffer << normal_color << std::flush;
    }
    //---------------------

    char const* GetColor( char const* c )
    {
        char* sdh_no_color = getenv( "SDH_NO_COLOR" );
        if ( sdh_no_color != NULL )
            return "";

        char* os = getenv( "OS" );
        char* ostype = getenv( "OSTYPE" );
        if ( os && (!strncmp( os, "WIN", 3 ) || !strncmp( os, "Win", 3 )) && (! ostype || (ostype && strcmp( ostype, "cygwin" ))) )
            return "";

        if ( !strcmp( c, "normal" ) )       return "\x1b[0m";
        if ( !strcmp( c, "bold" ) )         return "\x1b[1m";
        if ( !strcmp( c, "red" ) )          return "\x1b[31m";
        if ( !strcmp( c, "green" ) )        return "\x1b[32m";
        if ( !strcmp( c, "yellow" ) )       return "\x1b[33m";
        if ( !strcmp( c, "blue" ) )         return "\x1b[34m";
        if ( !strcmp( c, "magenta" ) )      return "\x1b[35m";
        if ( !strcmp( c, "cyan" ) )         return "\x1b[36m";
        if ( !strcmp( c, "white" ) )        return "\x1b[37m";
        if ( !strcmp( c, "black" ) )        return "\x1b[39m";
        if ( !strcmp( c, "black_back" ) )   return "\x1b[40m";
        if ( !strcmp( c, "red_back" ) )     return "\x1b[41m";
        if ( !strcmp( c, "green_back" ) )   return "\x1b[42m";
        if ( !strcmp( c, "yellow_back" ) )  return "\x1b[43m";
        if ( !strcmp( c, "blue_back" ) )    return "\x1b[44m";
        if ( !strcmp( c, "cyan_back" ) )    return "\x1b[45m";
        if ( !strcmp( c, "magenta_back" ) ) return "\x1b[46m";
        if ( !strcmp( c, "white_back" ) )   return "\x1b[47m";

        // no coloring possible or unknown color: return ""
        return "";
    }

    template <typename T>
    cDBG& operator<<( T const& v )
    {
        if (!debug_flag) return *this;

        output->width( 0 );
        *output << debug_color;
        output->width( mywidth );
        *output << v;
        mywidth = output->width();
        output->width( 0 );
        *output << normal_color << std::flush;
        return *this;
    }
    //---------------------

    std::ostream& flush()
    {
        return output->flush();
    }
    //---------------------


# define VAR( _d, _var )                        \
    (_d) << #_var << "='" << _var << "'\n"

# define VAL( _var )                      \
    #_var << "='" << _var << "' "
};

class VCC_EXPORT cHexByteString
{
    char const* bytes;
    int         len;
public:
    cHexByteString( char const* _bytes, int _len ) :
        bytes(_bytes),
        len(_len)
        {};

    friend VCC_EXPORT std::ostream &operator<<(std::ostream &stream, cHexByteString const &s);
};

inline VCC_EXPORT std::ostream &operator<<(std::ostream &stream, cHexByteString const &s)
{
    //-----
    // print all bytes as hex bytes:
    bool is_all_printable_ascii = true;
    for ( int i = 0; i < s.len; i++ )
    {
        stream << std::hex << std::setw(2) << std::setfill('0') << int( ((unsigned char const*)s.bytes)[i] ) << " ";
        if ( s.bytes[i] < 0x20 || ((unsigned char) s.bytes[i]) >= 0x80 )
            is_all_printable_ascii = false;
    }
    //-----

    //-----
    // if the bytes were all printable ascii codes then print them as string as well:
    if ( is_all_printable_ascii && s.len >= 0 )
        stream << "= \"" << std::string( s.bytes, s.len ) << "\"";
    //-----

    return stream << std::dec;
}

NAMESPACE_SDH_END

#endif


//======================================================================
/*
  Here are some settings for the emacs/xemacs editor (and can be safely ignored):
  (e.g. to explicitely set C++ mode for *.h header files)

  Local Variables:
  mode:C++
  mode:ELSE
  End:
 */
//======================================================================