ircproxy  The Ultimate Cyborg

---

debug.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer
//
//! @file debug.h
//! @brief This file contains the declaration of debug related macros, objects and functions.
//
// Copyright (C) 2005 - 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef DEBUG_H
#define DEBUG_H

#ifndef CWDEBUG

#ifndef DOXYGEN         // No need to document this.  See http://libcwd.sourceforge.net/ for more info.

#include <iostream>
#include <cstdlib>      // std::exit, EXIT_FAILURE

#define AllocTag1(p)
#define AllocTag2(p, desc)
#define AllocTag_dynamic_description(p, x)
#define AllocTag(p, x)
#define Debug(x)
#define Dout(a, b)
#define DoutEntering(a, b)
#define DoutFatal(a, b) LibcwDoutFatal(::std, , a, b)
#define ForAllDebugChannels(STATEMENT)
#define ForAllDebugObjects(STATEMENT)
#define LibcwDebug(dc_namespace, x)
#define LibcwDout(a, b, c, d)
#define LibcwDoutFatal(a, b, c, d) do { ::std::cerr << d << ::std::endl; ::std::exit(EXIT_FAILURE); } while (1)
#define NEW(x) new x
#define CWDEBUG_ALLOC 0
#define CWDEBUG_MAGIC 0
#define CWDEBUG_LOCATION 0
#define CWDEBUG_LIBBFD 0
#define CWDEBUG_DEBUG 0
#define CWDEBUG_DEBUGOUTPUT 0
#define CWDEBUG_DEBUGM 0
#define CWDEBUG_DEBUGT 0
#define CWDEBUG_MARKER 0

#endif // !DOXYGEN

#include <cassert>
#ifdef DEBUG
#define ASSERT(x) assert(x)
#else
#define ASSERT(x)
#endif

#else // CWDEBUG

//! Assert \a if debugging is turned on.
#define ASSERT(x) LIBCWD_ASSERT(x)

#ifndef DEBUGCHANNELS
/*! @brief The namespace in which the \c dc namespace is declared.
 *
 * <A HREF="http://libcwd.sourceforge.net/">Libcwd</A> demands that this macro is defined
 * before <libcwd/debug.h> is included and must be the name of the namespace containing
 * the \c dc (Debug Channels) namespace.
 *
 * @sa debug::channels::dc
 */
#define DEBUGCHANNELS ::debug::channels
#endif
#include <libcwd/debug.h>

//! Debug specific code.
namespace debug {

void init(void);                // Initialize debugging code, called once from main.
void init_thread(void);         // Initialize debugging code, called once for each thread.

  /*! @brief Debug Channels (dc) namespace.
   *
   * @sa debug::channels::dc
   */
  namespace channels {  // namespace DEBUGCHANNELS

    //! The namespace containing the actual debug channels.
    namespace dc {
      using namespace libcwd::channels::dc;
      using libcwd::channel_ct;

#ifndef DOXYGEN         // Doxygen bug causes a warning here.
      // Add the declaration of new debug channels here
      // and add their definition in a custom debug.cc file.
      extern channel_ct persist;
      extern channel_ct exceptions;
      extern channel_ct objects;
      extern channel_ct matcher;
      extern channel_ct expression;
      extern channel_ct maps;
      extern channel_ct clientinput;
      extern channel_ct serverinput;
#endif

    } // namespace dc

  } // namespace DEBUGCHANNELS

void dump_hex(libcwd::channel_ct const& channel, unsigned char const* buf, size_t size);
#if CWDEBUG_LOCATION
std::string call_location(void const* return_addr);
#endif

/*! @brief Interface for marking scopes of invisible memory allocations.
 *
 * Creation of the object does nothing, you have to explicitly call
 * InvisibleAllocations::on.  Destruction of the object automatically
 * cancels any call to \c on of this object.  This makes it exception-
 * (stack unwinding) and recursive-safe.
 */
struct InvisibleAllocations {
  int M_on;             //!< The number of times that InvisibleAllocations::on() was called.
  //! Constructor.
  InvisibleAllocations() : M_on(0) { }
  //! Destructor.
  ~InvisibleAllocations() { while (M_on > 0) off(); }
  //! Set invisible allocations on. Can be called recursively.
  void on(void) { libcwd::set_invisible_on(); ++M_on; }
  //! Cancel one call to on().
  void off(void) { assert(M_on > 0); --M_on; libcwd::set_invisible_off(); }
};

/*! @brief Interface for marking scopes with indented debug output.
 *
 * Creation of the object increments the debug indentation. Destruction
 * of the object automatically decrements the indentation again.
 */
struct Indent {
  int M_indent;                 //!< The extra number of spaces that were added to the indentation.
  //! Construct an Indent object.
  Indent(int indent) : M_indent(indent) { if (M_indent > 0) libcwd::libcw_do.inc_indent(M_indent); }
  //! Destructor.
  ~Indent() { if (M_indent > 0) libcwd::libcw_do.dec_indent(M_indent); }
};

extern bool secondary_connection;
//! @internal
//
// Debug code needed to track if we're processing a secondary connection.
struct SecondaryConnection {
  bool M_value;
  static int S_count;
  SecondaryConnection(bool value) : M_value(value)
      {
        if (value)
        {
          if (!secondary_connection)
          {
            Debug(libcw_do.push_marker());
            Debug(libcw_do.marker().append("[SECONDARY] "));
          }
          ++S_count;
          secondary_connection = true;
        }
      }
  ~SecondaryConnection()
      {
        if (M_value)
        {
          if (--S_count == 0)
          {
            secondary_connection = false;
            Debug(libcw_do.pop_marker());
          }
        }
      }
};

//! @internal
//
// A class streambuf that splits what is written to two streambufs.
class TeeBuf : public std::streambuf {
  private:
    std::streambuf* M_sb1;
    std::streambuf* M_sb2;

  public:
    TeeBuf(std::streambuf* sb1, std::streambuf* sb2) : M_sb1(sb1), M_sb2(sb2) { }

  protected:
    virtual int sync(void) { M_sb2->pubsync(); return M_sb1->pubsync(); }
    virtual std::streamsize xsputn(char_type const* p, std::streamsize n) { M_sb2->sputn(p, n); return M_sb1->sputn(p, n); }
    virtual int_type overflow(int_type c = traits_type::eof()) { M_sb2->sputc(c); return M_sb1->sputc(c); }
};

//! @internal
//
// An ostream that passes what is written to it on to two other ostreams.
class TeeStream : public std::ostream {
  private:
    TeeBuf M_teebuf;
  public:
    TeeStream(std::ostream& os1, std::ostream& os2) : std::ostream(&M_teebuf), M_teebuf(os1.rdbuf(), os2.rdbuf()) { }
};

} // namespace debug

//! Debugging macro.
//
// Print "Entering " << \a data to channel \a cntrl and increment
// debugging output indentation until the end of the current scope.
#define DoutEntering(cntrl, data) \
  int __ircproxy_debug_indentation = 2;                                                                                 \
  {                                                                                                                     \
    LIBCWD_TSD_DECLARATION;                                                                                             \
    if (LIBCWD_DO_TSD_MEMBER_OFF(::libcwd::libcw_do) < 0)                                                               \
    {                                                                                                                   \
      ::libcwd::channel_set_bootstrap_st __libcwd_channel_set(LIBCWD_DO_TSD(::libcwd::libcw_do) LIBCWD_COMMA_TSD);      \
      bool on;                                                                                                          \
      {                                                                                                                 \
        using namespace LIBCWD_DEBUGCHANNELS;                                                                           \
        on = (__libcwd_channel_set|cntrl).on;                                                                           \
      }                                                                                                                 \
      if (on)                                                                                                           \
        Dout(cntrl, "Entering " << data);                                                                               \
      else                                                                                                              \
        __ircproxy_debug_indentation = 0;                                                                               \
    }                                                                                                                   \
  }                                                                                                                     \
  debug::Indent __ircproxy_debug_indent(__ircproxy_debug_indentation);

#endif // CWDEBUG

#include "debug_ostream_operators.h"

#endif // DEBUG_H

---