Debug.hh

Go to the documentation of this file.

#ifndef COSA_DEBUG_HH
#define COSA_DEBUG_HH

#include "Cosa/Types.h"
#include "Cosa/IOStream.hh"

extern class Debug debug;

class Debug : public IOStream {
public:
  Debug() :
    IOStream(),
    m_var(NULL),
    EXITCHARACTER(0x1d)
  {}

  bool begin(IOStream::Device* dev,
             const char* file,
             int line,
             const char* func);

  void assert(const char* file,
              int line,
              const char* func,
              str_P cond);

  void break_at(const char* file,
                int line,
                const char* func,
                str_P cond);

  bool check_stack(int room = 128);

  void observe_at(const char* file,
                  int line,
                  const char* func,
                  str_P expr)
  {
    UNUSED(file);
    printf(PSTR("Debug::observe_at:%s:%d:%S="), func, line, expr);
  }

  bool end();

  class Variable {
  public:
    Variable(const char* func, str_P name, void* ref, size_t size) :
      m_next(debug.m_var),
      m_func(func),
      m_name(name),
      m_ref(ref),
      m_size(size)
    {
      debug.m_var = this;
    }

    ~Variable()
    {
      debug.m_var = m_next;
    }

    void print();

  protected:
    friend class Debug;
    class Variable* m_next;     
    const char* m_func;         
    str_P m_name;               
    void* m_ref;                
    size_t m_size;              
  };

protected:
  void run(const char* file = NULL,
           int line = 0,
           const char* func = NULL,
           str_P expr = NULL);

#if !defined(COSA_DEBUG_NO_BACKTRACE)

  void do_backtrace(const char* func);
#endif

#if !defined(COSA_DEBUG_NO_HELP)

  void do_help();
#endif

#if !defined(COSA_DEBUG_NO_LOOKUP_VARIABLES)

  bool do_lookup_variables(const char* name);
#endif

#if !defined(COSA_DEBUG_NO_MEMORY_USAGE)

  void do_memory_usage(int marker);
#endif

#if !defined(COSA_DEBUG_NO_PRINT_DATA)

  void do_print_data();
#endif

#if !defined(COSA_DEBUG_NO_PRINT_HEAP)

  void do_print_heap();
#endif

#if !defined(COSA_DEBUG_NO_PRINT_STACK)

  void do_print_stack(int marker);
#endif

#if !defined(COSA_DEBUG_NO_PRINT_VARIABLES)

  void do_print_variables();
#endif

#if !defined(COSA_DEBUG_NO_QUIT)

  void do_quit();
#endif

  friend class Variable;
  Variable* m_var;              
  char EXITCHARACTER;           
  int DATAEND;                  
  int DATASIZE;                 
};

#if !defined(NDEBUG)

#define DEBUG_STREAM(dev)                                               \
  do {                                                                  \
    debug.begin(&dev, __FILE__,__LINE__, __PRETTY_FUNCTION__);          \
  } while (0)

#if defined(ASSERT)
#undef ASSERT
#endif

#define ASSERT(cond)                                                    \
  do {                                                                  \
    if (UNLIKELY(!(cond)))                                              \
      debug.assert(__FILE__,__LINE__, __PRETTY_FUNCTION__,              \
                   __PSTR(# cond));                                     \
  } while (0)

#define BREAKPOINT()                                                    \
  do {                                                                  \
    debug.break_at(__FILE__,__LINE__, __PRETTY_FUNCTION__, NULL);       \
  } while (0)

#define BREAK_IF(cond)                                                  \
  do {                                                                  \
    if (UNLIKELY(cond))                                                 \
      debug.break_at(__FILE__,__LINE__, __PRETTY_FUNCTION__,            \
                     __PSTR(# cond));                                   \
  } while (0)

#define CHECK_STACK(room)                                               \
  do {                                                                  \
    if (UNLIKELY(!(debug.check_stack(room))))                           \
      debug.assert(__FILE__,__LINE__, __PRETTY_FUNCTION__,              \
                   __PSTR("check_stack()"));                            \
  } while (0)

#define OBSERVE_IF(cond,expr)                                           \
  do {                                                                  \
    if (UNLIKELY(cond)) {                                               \
      debug.observe_at(__FILE__,__LINE__, __PRETTY_FUNCTION__,          \
                       __PSTR(# expr));                                 \
      debug.print(expr);                                                \
      debug.println();                                                  \
    }                                                                   \
  } while (0)

#define OBSERVE(expr) OBSERVE_IF(expr,true)

#define REGISTER(var)                                                   \
  Debug::Variable debug__ ## var(__PRETTY_FUNCTION__,                   \
                                 __PSTR(#var),                          \
                                 (void*) &var,                          \
                                 sizeof(var));

#else

#if !defined(ASSERT)
#define ASSERT(cond) do { if (!(cond)) exit(0); } while (0)
#endif
#define BREAKPOINT()
#define BREAK_IF(cond)
#define CHECK_STACK(room)
#define DEBUG_STREAM(dev)
#define OBSERVE_IF(cond,expr)
#define OBSERVE(expr)
#define REGISTER(var)

#endif
#endif