old.debug.cc

Go to the documentation of this file.

#include "config.h"

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif

/*
 * For reasons unbeknownst to me, iostream must be included before fcntl.h, or
 * large-file support will break definitions for the C open() function.
 */
#include <iostream>
#include <fcntl.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <fstream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <cstdlib>
#include <cstdio>

#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include "debug.h"

#ifdef DEBUG

#define DEBUG_FLUSH

//-----------------------------------------------------------------------------

/** What base to use in displaying numbers. */
const debug_instance::size_type debug_instance::m_base = 10;

/** The "alphabet" to use to display numbers */
const char * debug_instance::m_alphabet = "0123456789";

debug_instance::debug_instance(
        const char * name,
        const char * file,
        const int line
        )
{
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;
        debug_manager.turn(name);
        if (!debug_manager.is_on()) {
                if (debug_manager.last_was_on())
                        debug_manager.mf_write_function_header(name,file,line);
                return;
        }

        debug_manager.mf_push(name, file, line);
        m_indent = 0;
        mf_set_newline(true);
}

debug_instance::~debug_instance()
{
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;
        if (!debug_manager.is_on()) {
                debug_manager.unturn();
                return;
        }

        debug_manager.mf_pop();
        debug_manager.unturn();
}

void debug_instance::indent(void)
{
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;
        if (!debug_manager.is_on())
                return;

        ++m_indent;
}

void debug_instance::unindent(void)
{
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;
        if (!debug_manager.is_on())
                return;

        if (m_indent > 0)
                --m_indent;
}

const bool debug_instance::ok(void) const
{
        return(debug_manager.m_ok);
}

void debug_instance::write(const bool a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        if (a_arg) {
                debug_manager.write("true");
        }
        else {
                debug_manager.write("false");
        }
}

void debug_instance::write(const char a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mf_check_newline();
        debug_manager.write(a_arg);
        if (a_arg == '\n')
                mf_set_newline(true);
}

void debug_instance::write(const unsigned int a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_unsigned_integral(a_arg);
}

void debug_instance::write(const int a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_integral(a_arg);
}

void debug_instance::write(const unsigned short a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_unsigned_integral(a_arg);
}

void debug_instance::write(const short a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_integral(a_arg);
}

void debug_instance::write(const unsigned long a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_unsigned_integral(a_arg);
}

void debug_instance::write(const long a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_integral(a_arg);
}

void debug_instance::write(const unsigned long long a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_unsigned_integral(a_arg);
}

void debug_instance::write(const long long a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_integral(a_arg);
}

void debug_instance::write(const float a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_fractional(a_arg);
}

void debug_instance::write(const double a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        mfT_write_fractional(a_arg);
}

void debug_instance::write(const std::string& a_arg)
{
        std::string::const_iterator si;

        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        for (si = a_arg.begin(); si != a_arg.end(); ++si) {
                write(*si);
        }
}

void debug_instance::write(const char * a_arg)
{
        char const * ch_ptr;

        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        for (ch_ptr = a_arg; *ch_ptr != '\0'; ++ch_ptr)
                write(*ch_ptr);
}

void debug_instance::write(const void * a_arg)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;
        if (!debug_manager.show_addresses())
                return;

        mf_clear_buffer();
        snprintf(debug_manager.m_buffer,debug_manager.m_buffer_size,"0x%p",a_arg);
        write(debug_manager.m_buffer);
}

void debug_instance::write(std::ostream& (*op)(std::ostream&))
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!ok())
                return;

        if (op == std::endl)
                write("\n");
}

void debug_instance::write_oeol(void)
{
        if (!debug_manager.is_on())
                return;
        if (debug_manager.is_paused())
                return;
        if (!m_newline)
                write("\n");
}

void debug_instance::mf_clear_buffer(void)
{
        debug_manager.mf_clear_buffer();
}

void debug_instance::mf_check_newline(void)
{
        if (!m_newline)
                return;
        mf_write_indent();
        m_newline = false;
}

void debug_instance::mf_set_newline(bool a_bool)
{
        m_newline = a_bool;
}

void debug_instance::mf_write_indent(void)
{
        unsigned int count;

        for (count = 0; count < m_indent; ++count)
                debug_manager.write("  ");
}

template<class T>
void debug_instance::mfT_write_unsigned_integral(const T& a_t)
{
        T num = 0;
        size_t len = 0;
        int digit = 0;
        char ch = 0;

        num = a_t;
        if (num == 0) {
                write('0');
        }

        while (num > 0) {
                ++len;
                num /= m_base;
        }
        num = a_t;

        mf_clear_buffer();
        while (num > 0) {
                digit = num % m_base;
                ch = m_alphabet[digit];
                debug_manager.m_buffer[len-1] = ch;
                num /= m_base;
                --len;
        }
        write(debug_manager.m_buffer);
}

template<class T>
void debug_instance::mfT_write_integral(const T& a_t)
{
        if (a_t < 0) {
                write('-');
                mfT_write_unsigned_integral(-a_t);
        }
        else {
                mfT_write_unsigned_integral(a_t);
        }
}

template<class T>
void debug_instance::mfT_write_fractional(const T& a_t)
{
        T fraction = a_t;
        T left = a_t;
        bool negative = false;
        unsigned long long whole_part;
        unsigned long long fractional_part;
        unsigned long long new_fractional_part;

        if (fraction < 0.0) {
                negative = true;
                fraction = -fraction;
        }

        whole_part = static_cast<unsigned long long>(fraction);
        fractional_part = 0;
        left = fraction - whole_part;
        while (left != 0.0) {
                left *= 10;
                new_fractional_part = fractional_part * 10;
                if (fractional_part != new_fractional_part / 10)
                        break;
                fractional_part = new_fractional_part;
                fractional_part += static_cast<unsigned long long>(left) % 10;
                left -= static_cast<unsigned long long>(left) % 10;
        }

        if (negative)
                write('-');
        write(whole_part);
        if (fractional_part > 0) {
                write('.');
                write(fractional_part);
        }
}

//-----------------------------------------------------------------------------

void __debug_write(debug_instance& di, const bool a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const char a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const unsigned int a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const int a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const unsigned short a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const short a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const unsigned long a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const long a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const unsigned long long a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const long long a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const float a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const double a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const std::string& a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const bool * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const char * a_arg)
{
        di.write(a_arg);
}

void __debug_write(debug_instance& di, const unsigned int * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const int * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const unsigned short * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const short * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const unsigned long * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const long * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const unsigned long long * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const long long * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const float * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, const double * a_arg)
{
        di.write((void*)a_arg);
}


void __debug_write(debug_instance& di, const void * a_arg)
{
        di.write((void*)a_arg);
}

void __debug_write(debug_instance& di, std::ostream& (*a_arg)(std::ostream&))
{
        di.write(a_arg);
}

//-----------------------------------------------------------------------------

debug_instance& operator<<(debug_instance& di, const bool a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const char a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned int a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const int a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned short a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const short a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned long a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const long a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned long long a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const long long a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const float a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const double a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const std::string& a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}


debug_instance& operator<<(debug_instance& di, const bool * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const char * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned int * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const int * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned short * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const short * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned long * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const long * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const unsigned long long * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const long long * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const float * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, const double * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}


debug_instance& operator<<(debug_instance& di, const void * a_arg)
{
        __debug_write(di,a_arg);
        return(di);
}

debug_instance& operator<<(debug_instance& di, std::ostream& (*a_arg)(std::ostream&))
{
        __debug_write(di,a_arg);
        return(di);
}

//-----------------------------------------------------------------------------

const char * __debug_type(const bool a_arg)
{
        return("bool");
}

const char * __debug_type(const char a_arg)
{
        return("char");
}

const char * __debug_type(const unsigned int a_arg)
{
        return("unsigned int");
}

const char * __debug_type(const int a_arg)
{
        return("int");
}

const char * __debug_type(const unsigned short a_arg)
{
        return("unsigned short");
}

const char * __debug_type(const short a_arg)
{
        return("short");
}

const char * __debug_type(const unsigned long a_arg)
{
        return("unsigned long");
}

const char * __debug_type(const long a_arg)
{
        return("long");
}

const char * __debug_type(const unsigned long long a_arg)
{
        return("unsigned long long");
}

const char * __debug_type(const long long a_arg)
{
        return("long long");
}

const char * __debug_type(const float a_arg)
{
        return("float");
}

const char * __debug_type(const double a_arg)
{
        return("double");
}

const char * __debug_type(const std::string& a_arg)
{
        return("std::string");
}

const char * __debug_type(const bool * a_arg)
{
        return("bool *");
}

const char * __debug_type(const char * a_arg)
{
        return("char *");
}

const char * __debug_type(const unsigned int * a_arg)
{
        return("unsigned int *");
}

const char * __debug_type(const int * a_arg)
{
        return("int *");
}

const char * __debug_type(const unsigned short * a_arg)
{
        return("unsigned short *");
}

const char * __debug_type(const short * a_arg)
{
        return("short *");
}

const char * __debug_type(const unsigned long * a_arg)
{
        return("unsigned long *");
}

const char * __debug_type(const long * a_arg)
{
        return("long *");
}

const char * __debug_type(const unsigned long long * a_arg)
{
        return("unsigned long long *");
}

const char * __debug_type(const long long * a_arg)
{
        return("long long *");
}

const char * __debug_type(const float * a_arg)
{
        return("float *");
}

const char * __debug_type(const double * a_arg)
{
        return("double *");
}


const char * __debug_type(const void * a_arg)
{
        return("void *");
}

const char * __debug_type(const std::string * a_arg)
{
        return("std::string *");
}

//-----------------------------------------------------------------------------

void ___debug_write_type_char(debug_instance& di, const char a_char)
{
        switch (a_char) {
                case '\a': di << "\\a"; break;
                case '\b': di << "\\b"; break;
                case '\f': di << "\\f"; break;
                case '\n': di << "\\n"; break;
                case '\r': di << "\\r"; break;
                case '\t': di << "\\t"; break;
                case '"': di << "\\\""; break;
                default: di << a_char; break;
        }
}

void __debug_write_type(debug_instance& di, const bool& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const char& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") '";
        ___debug_write_type_char(di,a_arg);
        di << "'";
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned int& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const int& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned short& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const short& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned long& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const long& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned long long& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const long long& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const float& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const double& a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const std::string& a_arg)
{
        std::string::const_iterator si;

        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)&a_arg;
        }
        di << ") \"";
        for (si = a_arg.begin(); si != a_arg.end(); ++si)
                ___debug_write_type_char(di,*si);
        di << "\"";
        di.write_oeol();
}


void __debug_write_type(debug_instance& di, const bool * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const char * a_arg)
{
        const char * chptr;

        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        if (a_arg != 0) {
                di << "\"";
                for (chptr = a_arg; *chptr != 0; ++chptr)
                        ___debug_write_type_char(di,*chptr);
                di << "\"";
        }
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned int * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const int * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned short * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const short * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned long * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const long * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const unsigned long long * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const long long * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const float * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const double * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}


void __debug_write_type(debug_instance& di, const void * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

void __debug_write_type(debug_instance& di, const std::string * a_arg)
{
        di << "(";
        di << __debug_type(a_arg);
        if (debug_manager.show_addresses()) {
                di << " at ";
                di << (void*)a_arg;
        }
        di << ") ";
        di << a_arg;
        di.write_oeol();
}

//-----------------------------------------------------------------------------

void __debug_write_name_and_type(debug_instance& di, const bool& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const char& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned int& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const int& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned short& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const short& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned long& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const long& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned long long& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const long long& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const float& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const double& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const std::string& a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}


void __debug_write_name_and_type(debug_instance& di, const bool * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const char * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned int * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const int * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned short * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const short * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned long * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const long * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const unsigned long long * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const long long * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const float * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const double * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}


void __debug_write_name_and_type(debug_instance& di, const void * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

void __debug_write_name_and_type(debug_instance& di, const std::string * a_arg, const char * name)
{
        di << name;
        di << " = ";
        __debug_write_type(di,a_arg);
        di.write_oeol();
}

//-----------------------------------------------------------------------------

debugger::debugger()
{
        m_ok = false;
        m_buffer = 0;
        m_newline = true;
        m_context = context_begin;
        m_fd = -1;
        m_pause_level = 0;
        m_show_addresses = true;

        set_depth();
}

debugger::~debugger()
{
        close();
}

void debugger::init(const char * a_filename)
{
        std::string tmpstr;

        m_ok = true;

        try {
                tmpstr = a_filename;
        }
        catch(...) {
                mf_print_error("Memory allocation error\n");
                m_ok = false;
                return;
        }

        if ((tmpstr == "-") || (tmpstr == "std::cout"))
                m_fd = STDOUT_FILENO;
        else if (tmpstr == "std::cerr")
                m_fd = STDERR_FILENO;
        else {
                int old_errno = errno;
                unlink(a_filename);
                errno = old_errno;
                m_fd = open(a_filename, O_WRONLY|O_CREAT
#ifdef O_LARGEFILE
                        |O_LARGEFILE
#endif
                        ,
                        S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
                        );
        }

        if (m_fd == -1) {
                mf_print_error("Could not open debug output file\n");
                m_ok = false;
                return;
        }

        m_out.attach(m_fd);
        if (errno != 0)
                errno = 0;

        if (!m_out.is_open()) {
                mf_print_error("Could not attach output stream to file descriptor\n");
                m_ok = false;
        }

        if (m_buffer != 0)
                delete[] m_buffer;
        m_buffer = new char[m_buffer_size];
        if (m_buffer == 0) {
                mf_print_error("Could not allocate buffer\n");
                m_out.close();
                m_ok = false;
                return;
        }

        m_depth = 0;
        m_newline = true;
        m_context = context_begin;
        try {
                m_filename = a_filename;
        }
        catch(...) {
                mf_print_error("Could not allocate memory\n");
                m_ok = false;
        }

        if (mf_errno() != 0) {
                mf_print_error("Errno is already non-zero!\n");
        }

        m_out << "# vim:foldmethod=marker:foldmarker={,}" << std::endl;
}

void debugger::init(int * argc, char * argv[])
{
        int c, x;
        char * filename = 0;
        char * level = 0;

        for (c = 1; c < *argc; ++c) {
                if (strncmp(argv[c],"--debug",7) == 0) {
                        if (strcmp(argv[c],"--debug-level") == 0) {
                                if (c > (*argc)-2) {
                                        mf_print_error("Integer expected after --debug-level\n");
                                        continue;
                                }
                                level = argv[c+1];
                                for (x = c; x < (*argc)-2; ++x) {
                                        argv[x] = argv[x+2];
                                }
                                *argc -= 2;
                                --c;
                        }
                        else if (strcmp(argv[c],"--debug-on-at") == 0) {
                                if (c > (*argc)-2) {
                                        mf_print_error("String expected after --debug-on-at\n");
                                        continue;
                                }
                                filter new_filter;

                                new_filter.first = argv[c+1];
                                new_filter.second = true;
                                m_filter.push_back(new_filter);
                                for (x = c; x < (*argc)-2; ++x) {
                                        argv[x] = argv[x+2];
                                }
                                *argc -= 2;
                                --c;
                        }
                        else if (strcmp(argv[c],"--debug-off-at") == 0) {
                                if (c > (*argc)-2) {
                                        mf_print_error("String expected after --debug-off-at\n");
                                        continue;
                                }
                                filter new_filter;

                                new_filter.first = argv[c+1];
                                new_filter.second = false;
                                m_filter.push_back(new_filter);
                                for (x = c; x < (*argc)-2; ++x) {
                                        argv[x] = argv[x+2];
                                }
                                *argc -= 2;
                                --c;
                        }
                        else if (strcmp(argv[c],"--debug-no-addresses") == 0) {
                                m_show_addresses = false;
                                for (x = c; x < (*argc)-1; ++x) {
                                        argv[x] = argv[x+1];
                                }
                                *argc -= 1;
                                --c;
                        }
                        else {
                                if ((strlen(argv[c]) != strlen("--debug"))
                                        || (strcmp(argv[c],"--debug") != 0))
                                {
                                        const int buffer_size = 1024;
                                        char buffer[buffer_size] = { 0 };

                                        sprintf(buffer, "Invalid debug argument: %s\n", argv[c]);
                                        mf_print_error(buffer);
                                        continue;
                                }
                                if (c > (*argc)-2) {
                                        mf_print_error("Filename expected after --debug\n");
                                        continue;
                                }
                                filename = argv[c+1];
                                for (x = c; x < (*argc)-2; ++x) {
                                        argv[x] = argv[x+2];
                                }
                                *argc -= 2;
                                --c;
                        }
                }
        }

        if (level != 0) {
                size_type n;

                sscanf(level,"%u",&n);
                set_depth(n);
        }

        if (filename != 0) {
                init(filename);
        }
}

void debugger::close(void)
{
        if (m_buffer != 0)
                delete[] m_buffer;
        if (m_out.is_open())
                m_out.close();
        m_depth = 0;
        m_ok = false;
}

const bool debugger::ok(void) const
{
        return(m_ok);
}

void debugger::set_depth(void)
{
        size_type last_depth = 0;
        m_max_depth = 1;
        while (m_max_depth != last_depth) {
                last_depth = m_max_depth;
                m_max_depth *= 2;
                m_max_depth += 1;
        }
}

void debugger::set_depth(const debugger::size_type a_depth)
{
        m_max_depth = a_depth;
}

const std::string& debugger::filename(void) const
{
        return(m_filename);
}

void debugger::fork(void)
{
        std::string filename;

        if ((m_filename == "-")
                || (m_filename == "std::cout")
                || (m_filename == "std::cerr")
                || (m_filename.substr(0,4) == "/dev"))
        {
                mf_print_error("Child debugger has no output\n");
                close();
                return;
        }

        mf_clear_buffer();
        snprintf(m_buffer,m_buffer_size,"%s.%d",m_filename.c_str(),getpid());
        try {
                filename = m_buffer;
        }
        catch(...) {
                mf_print_error("Could not allocate memory\n");
                m_ok = false;
        }
        close();
        init(filename.c_str());
}

void debugger::write(const char a_char)
{
        if (m_depth > m_max_depth)
                return;
        if (!is_on())
                return;
        if (is_paused())
                return;
        if (!m_ok)
                return;
        if (!mf_check_output_stream())
                return;
        mf_check_newline();
        m_out << a_char;
#ifdef DEBUG_FLUSH
        m_out.flush();
#endif
        if (a_char == '\n') {
                mf_set_newline(true);
                m_out.flush();
        }
}

void debugger::write(const char * a_char_ptr)
{
        char const * ch_ptr;

        if (m_depth > m_max_depth)
                return;
        if (!is_on())
                return;
        if (is_paused())
                return;
        if (!m_ok)
                return;
        if (!mf_check_output_stream())
                return;
        if (a_char_ptr == 0) {
                write("(null)");
                return;
        }
        for (ch_ptr = a_char_ptr; *ch_ptr != '\0'; ++ch_ptr)
                write(*ch_ptr);
}

void debugger::write(const std::string& a_string)
{
        std::string::const_iterator si;
        char ch;

        if (m_depth > m_max_depth)
                return;
        if (!is_on())
                return;
        if (is_paused())
                return;
        if (!m_ok)
                return;
        if (!mf_check_output_stream())
                return;
        
        for (si = a_string.begin(); si != a_string.end(); ++si) {
                ch = *si;
                write(ch);
        }
}

void debugger::set_context(const debugger::context a_context)
{
        context old_context = m_context;

        if (!m_ok)
                return;
        if (!is_on())
                return;
        m_context = a_context;
        switch(old_context) {
                case context_begin:
                        switch(a_context) {
                                case context_begin:
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        break;
                                case context_message: 
                                        break;
                                case context_errno:
                                        break;
                        }
                        break;
                case context_end:
                        switch(a_context) {
                                case context_begin: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        mf_write_blank_line(); 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        mf_write_blank_line(); 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_message: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_errno:
                                        break;
                        }
                        break;
                case context_input:
                        switch(a_context) {
                                case context_begin: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        break;
                                case context_output: 
                                        mf_write_blank_line(); 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_message: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_errno:
                                        mf_write_blank_line();
                                        break;
                        }
                        break;
                case context_output:
                        switch(a_context) {
                                case context_begin:
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        mf_write_blank_line(); 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_message: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_errno:
                                        mf_write_blank_line();
                                        break;
                        }
                        break;
                case context_variable:
                        switch(a_context) {
                                case context_begin:
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        mf_write_blank_line(); 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        mf_write_blank_line(); 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        break;
                                case context_message: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_errno:
                                        mf_write_blank_line();
                                        break;
                        }
                        break;
                case context_message:
                        switch(a_context) {
                                case context_begin:
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        mf_write_blank_line(); 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        mf_write_blank_line(); 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_message: 
                                        break;
                                case context_errno:
                                        mf_write_blank_line();
                                        break;
                        }
                        break;
                case context_errno:
                        // This should never happen
                        switch(a_context) {
                                case context_begin:
                                        mf_write_blank_line(); 
                                        break;
                                case context_end: 
                                        break;
                                case context_input: 
                                        mf_write_blank_line(); 
                                        write("Input:\n");
                                        break;
                                case context_output: 
                                        mf_write_blank_line(); 
                                        write("Output:\n");
                                        break;
                                case context_variable: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_message: 
                                        mf_write_blank_line(); 
                                        break;
                                case context_errno:
                                        break;
                        }
                        break;
        }
}

void debugger::pause(void)
{
        m_pause_level++;
}

void debugger::unpause(void)
{
        m_pause_level--;
}

const bool debugger::is_paused(void) const
{
        return(m_pause_level > 0);
}

void debugger::turn(const char * name)
{
        std::string str;
        vector<filter>::const_iterator oi;

        str = name;
        for (oi = m_filter.begin(); oi != m_filter.end(); oi++) {
                if (str.find(oi->first) != std::string::npos) {
                        turn(oi->second);
                        return;
                }
                else if (oi->first == "*") {
                        turn(oi->second);
                        return;
                }
        }
        if (m_on.size() == 0)
                if (m_filter.size() == 0)
                        turn(true);
                else
                        turn(false);
        else
                turn(m_on[0]);
}

void debugger::turn(const bool a_value)
{
        m_on.push_front(a_value);
}

void debugger::unturn(void)
{
        if (m_on.size() > 0)
                m_on.pop_front();
}

const bool debugger::is_on(void) const
{
        if (m_filter.size() == 0)
                return(true);
        if (m_on.size() == 0)
                return(false);
        if (m_on[0] == true)
                return(true);
        return(false);
}

const bool debugger::last_was_on(void) const
{
        if (m_filter.size() == 0)
                return(true);
        if (m_on.size() < 2)
                return(false);
        if (m_on[1] == true)
                return(true);
        return(false);
}

const bool debugger::show_addresses(void) const
{
        return(m_show_addresses);
}

const int debugger::mf_errno(void) const
{
        return(errno);
}

const char * debugger::mf_errno_str(const int a_errno) const
{
        return(strerror(a_errno));
}

void debugger::mf_print_error(const char * a_message) const
{
        char const * ch_ptr;
        static bool newline = true;

        std::cerr << "*** ERROR: ";
        if (mf_errno() != 0) {
                std::cerr << "[" << mf_errno() << "]: " << mf_errno_str(mf_errno());
        }
        else {
                std::cerr << "An unknown error has occured";
        }
        std::cerr << std::endl;
        if (a_message != 0) {
                for (ch_ptr = a_message; *ch_ptr != '\0'; ++ch_ptr) {
                        if (newline) {
                                std::cerr << "           ";
                                newline = false;
                        }
                        std::cerr << (*ch_ptr);
                        if (*ch_ptr == '\n')
                                newline = true;
                }
        }
}

bool debugger::mf_check_output_stream(void)
{
        if (!m_ok)
                return(false);
        if (!m_out.is_open()) {
                mf_print_error("Debug output stream is not open\n");
                m_ok = false;
                return(false);
        }
        if (!m_out) {
                mf_print_error("Debug output stream error\n");
                m_ok = false;
                return(false);
        }

        return(true);
}

void debugger::mf_write(const char * a_message)
{
        char const * ch_ptr;

        if (m_depth > m_max_depth)
                return;
        if (!is_on())
                return;
        if (is_paused())
                return;
        if (!mf_check_output_stream())
                return;

        for (ch_ptr = a_message; *ch_ptr != 0; ++ch_ptr) {
                m_out << *ch_ptr;
#ifdef DEBUG_FLUSH
                m_out.flush();
#endif
                if (!mf_check_output_stream())
                        return;
        }
}

void debugger::mf_write_prefix(void)
{
        size_type count;

        if (!is_on())
                return;
        if (is_paused())
                return;
        if (!m_ok)
                return;
        for (count = 0; count < m_depth; ++count)
                mf_write("| ");
}

void debugger::mf_write_blank_line(void)
{
        mf_write_prefix();
        mf_write("\n");
}

const std::string debugger::mf_function_header(
        const char * a_name,
        const char * a_file,
        const int a_line
        )
{
        std::string l_str;

        mf_clear_buffer();
        snprintf(m_buffer, m_buffer_size, "%d", a_line);

        l_str = a_file;
        l_str += "[";
        l_str += m_buffer;
        l_str += "]: ";
        l_str += a_name;

        return(l_str);
}

void debugger::mf_push(
        const char * a_name,
        const char * a_file,
        const int a_line
        )
{
        if (!m_ok)
                return;

        set_context(context_begin);
        mf_write_prefix();
        mf_write(mf_function_header(a_name, a_file, a_line).c_str());
        mf_write("\n");
        mf_write_prefix();
        mf_write("{\n");

        m_depth++;

        if (mf_errno() != 0) {
                set_context(context_errno);
                mf_write_prefix();
                mf_clear_buffer();
                snprintf(m_buffer, m_buffer_size, 
                        "errno: [%d] - %s\n", mf_errno(), mf_errno_str(mf_errno()));
                mf_write(m_buffer);
        }

        mf_set_newline(true);
}

void debugger::mf_pop(void)
{
        if (!m_ok)
                return;

        if (m_depth == 0) {
                /*
                std::cerr 
                        << "*** ERROR: Attempt to pop from empty debugger stack"
                        << std::endl;
                */
                return;
        }

        if (mf_errno() != 0) {
                set_context(context_errno);
                mf_write_prefix();
                mf_clear_buffer();
                snprintf(m_buffer, m_buffer_size, 
                        "errno: [%d] - %s\n", mf_errno(), mf_errno_str(mf_errno()));
                mf_write(m_buffer);
        }

        set_context(context_end);

        --m_depth;

        mf_write_prefix();
        mf_write("}\n");
}

void debugger::mf_write_function_header(
        const char * a_name,
        const char * a_file,
        const int a_line
        )
{
        if (!m_ok)
                return;

        turn(true);
        set_context(context_message);
        mf_write_prefix();
        mf_write(mf_function_header(a_name, a_file, a_line).c_str());
        mf_write(";\n");
        unturn();
}

void debugger::mf_set_newline(const bool a_bool)
{
        m_newline = a_bool;
}

void debugger::mf_check_newline(void)
{
        if (!m_newline) 
                return;
        mf_write_prefix();
        m_newline = false;
}

const size_t debugger::m_buffer_size = 256;

void debugger::mf_clear_buffer(void)
{
        size_t n;

        for (n = 0; n < m_buffer_size; ++n)
                m_buffer[n] = 0;
}

//-----------------------------------------------------------------------------

debugger debug_manager;

//-----------------------------------------------------------------------------

#endif

---