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:
 */
//======================================================================