Debug.h

Go to the documentation of this file.

#ifndef DEBUG_H
#define DEBUG_H

#include "Arduino.h"

#ifndef UNUSED
#define UNUSED(x) (void) (x)
#endif

#ifndef UNLIKELY
#define UNLIKELY(x) __builtin_expect((x), false)
#endif

typedef const class __FlashStringHelper* str_P;

extern class Debug debug;

class Debug : public Stream {
public:
  Debug() :
    Stream(),
    m_dev(NULL),
    m_var(NULL)
  {}

  bool begin(Stream* 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);

  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(bool is_pointer = false);

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

protected:
  virtual size_t write(uint8_t c) { return (m_dev->write(c)); }
  virtual int available(void) { return (m_dev->available()); }
  virtual int peek(void) { return (m_dev->peek()); }
  virtual int read(void) { return (m_dev->read()); }
  virtual void flush(void) { m_dev->flush(); }

  void dump(uint16_t src, const void *ptr, size_t size);

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

#if !defined(DEBUG_NO_BACKTRACE)

  void do_backtrace(const char* func);
#endif

#if !defined(DEBUG_NO_LOOKUP_VARIABLES)

  bool do_lookup_variables(const char* name, bool is_pointer = false);
#endif

#if !defined(DEBUG_NO_MEMORY_USAGE)

  void do_memory_usage(int marker);
#endif

#if !defined(DEBUG_NO_PRINT_COMMANDS)

  void do_print_commands();
#endif

#if !defined(DEBUG_NO_PRINT_DATA)

  void do_print_data();
#endif

#if !defined(DEBUG_NO_PRINT_HEAP)

  void do_print_heap();
#endif

#if !defined(DEBUG_NO_PRINT_STACK)

  void do_print_stack(int marker);
#endif

#if !defined(DEBUG_NO_PRINT_VARIABLES)

  void do_print_variables();
#endif

#if !defined(DEBUG_NO_QUIT)

  void do_quit();
#endif

  friend class Variable;
  Stream* m_dev;                
  Variable* m_var;              
  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__,              \
                   F(# 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__,            \
                     F(# cond));                                        \
  } while (0)

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

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

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

#define REGISTER(var)                                                   \
  Debug::Variable debug__ ## var(__PRETTY_FUNCTION__,                   \
                                 F(#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