debug Namespace Reference

---

Detailed Description

Debug specific code.

Classes
struct	InvisibleAllocations
	Interface for marking scopes of invisible memory allocations. More...
struct	Indent
	Interface for marking scopes with indented debug output. More...
struct	SecondaryConnection
class	TeeBuf
class	TeeStream
Namespaces
namespace	channels
	Debug Channels (dc) namespace.
Functions
bool	is_on_in_rcfile (char const *dc_label)
	Returns the the original state of a debug channel.
void	init_thread (void)
	Initialize debugging code from new threads.
void	init (void)
	Initialize debugging code from main.
void	dump_hex (libcwd::channel_ct const &channel, unsigned char const *buf, size_t size)
	Write a hexadecimal and ascii dump of a buffer to a given debug channel.
char const *	state_nt_name (state_nt state)
	Return a string literal representing the name of the state_nt state.
char const *	openmode_name (PersistXML::openmode_type openmode)
	Return a string literal representing the name of the PersistXML::openmode_type openmode.
char const *	match0_type_name (match0_type mt)
	Return a string literal representing the name of the match0_type mt.
char const *	match1_type_name (match1_type mt)
	Return a string literal representing the name of the match1_type mt.
char const *	command_name (int command)
	Return a string literal representing the name of the int command.

---

Function Documentation

bool debug::is_on_in_rcfile

(

char const *

dc_label

)

Returns the the original state of a debug channel.

For internal use only.

For a given dc_label, which must be the exact name (channel_ct::get_label) of an existing debug channel, this function returns true when the corresponding debug channel was on at the startup of the application, directly after reading the libcwd runtime configuration file (.libcwdrc).

If the label/channel did not exist at the start of the application, it will return false (note that libcwd disallows adding debug channels to modules - so this would probably a bug).

Definition at line 128 of file debug.cc.

Referenced by init_thread().

  {
    rcfile_dc_states_type::const_iterator iter = rcfile_dc_states.find(std::string(dc_label));
    if (iter == rcfile_dc_states.end())
    {
      Dout(dc::warning, "is_on_in_rcfile(\"" << dc_label << "\"): \"" << dc_label << "\" is an unknown label!");
      return false;
    }
    return iter->second;
  }

void debug::init_thread

(

void

)

Initialize debugging code from new threads.

This function needs to be called at the start of each new thread, because a new thread starts in a completely reset state.

The function turns on all debug channels that were turned on after reading the rcfile at the start of the application. Furthermore it initializes the debug ostream, its mutex and the margin of the default debug object (Dout).

Definition at line 149 of file debug.cc.

References is_on_in_rcfile().

Referenced by init().

  {
    // Turn on all debug channels that are turned on as per rcfile configuration.
    ForAllDebugChannels(
        if (!debugChannel.is_on() && is_on_in_rcfile(debugChannel.get_label()))
          debugChannel.on();
    );

    // Turn on debug output.
    Debug( libcw_do.on() );
#if LIBCWD_THREAD_SAFE
    Debug( libcw_do.set_ostream(&std::cout, &cout_mutex) );
#else
    Debug( libcw_do.set_ostream(&std::cout) );
#endif

    static bool first_thread = true;
    if (!first_thread)                  // So far, the application has only one thread.  So don't add a thread id.
    {
      // Set the thread id in the margin.
      char margin[12];
      sprintf(margin, "%-10lu ", pthread_self());
      Debug( libcw_do.margin().assign(margin, 11) );
    }
  }

void debug::init

(

void

)

Initialize debugging code from main.

This function initializes the debug code.

Definition at line 179 of file debug.cc.

References init_thread().

Referenced by Application::main_entered().

  {
#if CWDEBUG_ALLOC && defined(USE_LIBCW)
    // Tell the memory leak detector which parts of the code are
    // expected to leak so that we won't get an alarm for those.
    {
      std::vector<std::pair<std::string, std::string> > hide_list;
      hide_list.push_back(std::pair<std::string, std::string>("libdl.so.2", "_dlerror_run"));
      hide_list.push_back(std::pair<std::string, std::string>("libstdc++.so.6", "__cxa_get_globals"));
      // The following is actually necessary because of a bug in glibc
      // (see http://sources.redhat.com/bugzilla/show_bug.cgi?id=311).
      hide_list.push_back(std::pair<std::string, std::string>("libc.so.6", "dl_open_worker"));
      memleak_filter().hide_functions_matching(hide_list);
    }
    {
      std::vector<std::string> hide_list;
      // Also because of http://sources.redhat.com/bugzilla/show_bug.cgi?id=311
      hide_list.push_back(std::string("ld-linux.so.2"));
      memleak_filter().hide_objectfiles_matching(hide_list);
    }
    memleak_filter().set_flags(libcwd::show_objectfile|libcwd::show_function);
#endif

    // The following call allocated the filebuf's of cin, cout, cerr, wcin, wcout and wcerr.
    // Because this causes a memory leak being reported, make them invisible.
    Debug(set_invisible_on());

    // You want this, unless you mix streams output with C output.
    // Read  http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#8 for an explanation.
    //std::ios::sync_with_stdio(false);

    // Cancel previous call to set_invisible_on.
    Debug(set_invisible_off());

    // This will warn you when you are using header files that do not belong to the
    // shared libcwd object that you linked with.
    Debug( check_configuration() );

    Debug(
      libcw_do.on();            // Show which rcfile we are reading!
      ForAllDebugChannels(
        while (debugChannel.is_on())
          debugChannel.off()    // Print as little as possible though.
      );
      read_rcfile();            // Put 'silent = on' in the rcfile to suppress most of the output here.
      libcw_do.off()
    );
    save_dc_states();

    init_thread();
  }

void debug::dump_hex	(	libcwd::channel_ct const &	channel,
		unsigned char const *	buf,
		size_t	size
	)

Write a hexadecimal and ascii dump of a buffer to a given debug channel.

This function can be used to print a binary block of data of size bytes, starting at buf. The output is written to debug channel channel.

Definition at line 236 of file debug.cc.

References DEBUGCHANNELS.

  {
    for (size_t addr = 0; addr < size; addr += 16)
    {
      LibcwDoutScopeBegin(DEBUGCHANNELS, libcwd::libcw_do, channel)
      LibcwDoutStream << std::hex << std::setfill('0') << std::setw(4) << addr << " |";
      int offset;
      for (offset = 0; offset < 16 && addr + offset < size; ++offset)
        LibcwDoutStream << ' ' << std::hex << std::setfill('0') << std::setw(2) << (int)buf[addr + offset];
      for (; offset < 16; ++offset)
        LibcwDoutStream << "   ";
      LibcwDoutStream << " | ";
      for (int offset = 0; offset < 16 && addr + offset < size; ++offset)
      {
        unsigned char c = buf[addr + offset];
        if (!std::isprint(c))
          c = '.';
        LibcwDoutStream << c;
      }
      LibcwDoutScopeEnd;
    }
  }

char const* debug::state_nt_name

(

state_nt

state

)

Return a string literal representing the name of the state_nt state.

For internal use only.

Definition at line 62 of file debug_ostream_operators.cc.

References authentication_started, CASERETURNSTR, disconnected, login_sent, pong_sent, real_nick_accepted, real_nick_sent, and successful_connect.

Referenced by operator<<().

{
  switch(state)
  {
    // See enum state_nt in ServerConnection.h
    CASERETURNSTR(disconnected);
    CASERETURNSTR(successful_connect);
    CASERETURNSTR(authentication_started);
    CASERETURNSTR(pong_sent);
    CASERETURNSTR(login_sent);
    CASERETURNSTR(real_nick_sent);
    CASERETURNSTR(real_nick_accepted);
  }
  DoutFatal(dc::fatal, "Unhandled state_nt in state_nt_name");
}

char const* debug::openmode_name

(

PersistXML::openmode_type

openmode

)

Return a string literal representing the name of the PersistXML::openmode_type openmode.

For internal use only.

Definition at line 82 of file debug_ostream_operators.cc.

References CASERETURNSTR, PersistXML::load, PersistXML::not_open, and PersistXML::store.

Referenced by operator<<().

{
  switch(openmode)
  {
    // See enum PersistXML::openmode_type in PersistXML.h
    CASERETURNSTR(PersistXML::not_open);
    CASERETURNSTR(PersistXML::store);
    CASERETURNSTR(PersistXML::load);
  }
  DoutFatal(dc::fatal, "Unhandled PersistXML::openmode in openmode_name");
}

char const* debug::match0_type_name

(

match0_type

mt

)

Return a string literal representing the name of the match0_type mt.

For internal use only.

Definition at line 98 of file debug_ostream_operators.cc.

References CASERETURNSTR.

Referenced by operator<<().

{
  switch(mt)
  {
    // See enum match0_type in Matcher.h
    CASERETURNSTR(anystring_mt);
    CASERETURNSTR(nonemptystring_mt);
    CASERETURNSTR(anyserver_mt);
    CASERETURNSTR(localserver_mt);
    CASERETURNSTR(anynick_mt);
    CASERETURNSTR(mynick_mt);
    CASERETURNSTR(anychannel_mt);
    CASERETURNSTR(anyglobalchannel_mt);
    CASERETURNSTR(anylocalchannel_mt);
  }
  DoutFatal(dc::fatal, "Unhandled match0_type in match0_type_name");
}

char const* debug::match1_type_name

(

match1_type

mt

)

Return a string literal representing the name of the match1_type mt.

For internal use only.

Definition at line 120 of file debug_ostream_operators.cc.

References CASERETURNSTR.

Referenced by operator<<().

{
  switch(mt)
  {
    // See enum match1_type in Matcher.h
    CASERETURNSTR(wildcard_mt);
    CASERETURNSTR(regexp_mt);
    CASERETURNSTR(exactmatch_mt);
  }
  DoutFatal(dc::fatal, "Unhandled match1_type in match1_type_name");
}

char const* debug::command_name

(

int

command

)

Return a string literal representing the name of the int command.

For internal use only.

Definition at line 136 of file debug_ostream_operators.cc.

References CASERETURNSTR.

Referenced by operator<<().

{
  using namespace keys;
  switch(command)
  {
    // See irc_commands
    CASERETURNSTR(PASS);
    CASERETURNSTR(USER);
    CASERETURNSTR(NICK);
    CASERETURNSTR(PING);
    CASERETURNSTR(ERROR);
    CASERETURNSTR(QUIT);
    CASERETURNSTR(WHO);
    CASERETURNSTR(WHOIS);
    CASERETURNSTR(WHOWAS);
    CASERETURNSTR(PRIVMSG);
    CASERETURNSTR(NOTICE);
    CASERETURNSTR(CPRIVMSG);
    CASERETURNSTR(CNOTICE);
    CASERETURNSTR(LINKS);
    CASERETURNSTR(JOIN);
    CASERETURNSTR(PART);
    CASERETURNSTR(KICK);
    CASERETURNSTR(MODE);
    CASERETURNSTR(NAMES);
    CASERETURNSTR(TOPIC);
  }
  DoutFatal(dc::fatal, "Unhandled command key in command_name");
}