error.cc

Go to the documentation of this file.

#include "config.h"

#include <cerrno>
#include <cstring>
#ifdef HAVE_CSTDIO
#include <cstdio>
#endif
#ifdef HAVE_CSTDLIB
#include <cstdlib>
#endif

#include "asserts.h"
#include "types.h"
#include "error.h"

#define internal_TRY_nomem(code) \
        try { \
                code; \
        } \
        catch(...) { \
                if (errno == 12) \
                        std::cerr << err_nomem; \
                else \
                        std::cerr << err_unknown; \
        }

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

error_instance::error_instance()
{
        clear();
}

error_instance::error_instance(const error_instance& a_e)
{
        set(a_e);
}

error_instance::error_instance(
        const std::string a_what,
#ifdef __GNUC__
        const std::string a_where,
#endif
        const std::string a_file,
        const uint16 a_line
        )
{
        set(
                a_what,
#ifdef __GNUC__
                a_where,
#endif
                a_file,
                a_line
                );
}

void error_instance::clear(void)
{
        internal_TRY_nomem(m_what = "");
#ifdef __GNUC__
        internal_TRY_nomem(m_where = "");
#endif
        internal_TRY_nomem(m_file = "");
        m_line = 0;
}

void error_instance::set(void)
{
        clear();
}

void error_instance::set(
        const std::string a_what,
#ifdef __GNUC__
        const std::string a_where,
#endif
        const std::string a_file,
        const uint16 a_line
        )
{
        clear();

        internal_TRY_nomem(m_what = a_what);
#ifdef __GNUC__
        internal_TRY_nomem(m_where = a_where);
#endif
        internal_TRY_nomem(m_file = a_file);
        m_line = a_line;
}

void error_instance::set(const error_instance& a_e)
{
        clear();

        internal_TRY_nomem(m_what = a_e.what());
#ifdef __GNUC__
        internal_TRY_nomem(m_where = a_e.where());
#endif
        internal_TRY_nomem(m_file = a_e.file());
        m_line = a_e.line();
}

const std::string error_instance::what(void) const
{
        return(m_what);
}

#ifdef __GNUC__
const std::string error_instance::where(void) const
{
        return(m_where);
}
#endif

const std::string error_instance::file(void) const
{
        return(m_file);
}

const uint16 error_instance::line(void) const
{
        return(m_line);
}

error_instance& error_instance::operator=(const error_instance& a_e)
{
        set(a_e);

        return(*this);
}

/*
void 
error_instance::dump(std::ostream& a_out, const std::string& a_prefix) const
{
        a_out 
                << a_prefix 
                << "error_instance::what = \"" 
                << m_what 
                << "\"" 
                << std::endl;
#ifdef __GNUC__
        a_out 
                << a_prefix 
                << "              ::where = " 
                << m_where 
                << std::endl;
#endif
        a_out 
                << a_prefix 
                << "              ::at " 
                << m_file << "[" << m_line << "]" 
                << std::endl;
}
*/

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

error::error(const int a_errno)
{
        clear();
        num(a_errno);
}

error::error(
        const int a_errno,
        const error_instance& a_e, 
        const bool a_internal
        )
{
        clear();
        push_back(a_e);
        internal(a_internal);
        num(a_errno);
}

error::error(const error& a_e)
{
        assign(a_e);
}

void error::clear(void)
{
        m_errno = 0;
        m_internal = false;
        clear_stack();
}

void error::clear_stack(void)
{
        type::clear();
}

void error::internal(bool a_i)
{
        m_internal = a_i;
}

const bool error::internal(void) const
{
        return(m_internal);
}

void error::num(int a_i)
{
        m_errno = a_i;
}

int error::num(void) const
{
        return(m_errno);
}

void error::push_back(const error_instance& a_e)
{
        try {
                type::push_back(a_e);
        }
        catch(...) {
                std::cerr << "*** ERROR: ";
                if (errno != 0) {
                        std::cerr 
                                << "[" << errno << "]: " 
                                << get_error_str(errno) 
                                << std::endl;
                        std::cerr << "           ";
                        errno = 0;
                }
                std::cerr << "error::push_back() failed" << std::endl;
        }
}

void error::push_back(const error& a_e)
{
        error::const_iterator ei;
        
        for (ei = a_e.begin(); ei != a_e.end(); ei++) {
                push_back(*ei);
        }
}

void error::push_back(const std::string& a_str)
{
        error_instance ei;

        internal_TRY_nomem(ei = ERROR_INSTANCE(a_str));
        push_back(ei);
}

void error::assign(const error& a_e)
{
        const_iterator eii;

        clear();
        m_errno = a_e.num();
        m_internal = a_e.internal();
        for (eii = a_e.begin(); eii != a_e.end(); eii++) {
                push_back(*eii);
        }
}

error& error::operator=(const error& a_e)
{
        assign(a_e);

        return(*this);
}

std::ostream&
        error::write(std::ostream& a_out, const std::string a_prefix) const
{
        const_iterator eii;

        if (a_prefix.size() != 0)
                a_out << a_prefix << " ";
        a_out << "*** ";
        if (m_internal)
                a_out << "INTERNAL ";
        a_out << "ERROR";

        if (m_errno != 0)
                a_out << " [" << m_errno << "]: " << strerror(m_errno);
        a_out << std::endl;

        for (eii = begin(); eii != end(); ++eii) {
                if (a_prefix.size() != 0)
                        a_out << a_prefix << " ";
                if (eii->what().size() != 0)
                        a_out << "    " << eii->what() << std::endl;
                if (m_internal) {
                        a_out << "      ";
#ifdef __GNUC__
                        a_out << "in " << eii->where() << " ";
#endif
                        a_out << "at " << eii->file() << "[" << eii->line() << "]";
                        a_out << std::endl;
                }
        }

        return(a_out);
}

const std::string error::str(const std::string a_prefix) const
{
        static const size_t buffer_len = 32;
        char buffer[buffer_len] = { 0 };
        std::string es;
        const_iterator eii;

        try {
                es.erase();
                if (a_prefix.size() != 0) {
                        es += a_prefix;
                        es += " ";
                }
                es += "*** ";
                if (m_internal)
                        es += "INTERNAL ";
                es += "ERROR";

                snprintf(buffer, buffer_len, "%d", m_errno);
                if (m_errno != 0) {
                        es += " [";
                        es += buffer;
                        es += "]: ";
                        es += strerror(m_errno);
                }
                es += "\n";

                for (eii = begin(); eii != end(); ++eii) {
                        if (a_prefix.size() != 0)
                                es += a_prefix + " ";
                        if (eii->what().size() != 0) {
                                es += "    ";
                                es += eii->what();
                                es += "\n";
                        }
                        snprintf(buffer, buffer_len, "%u", eii->line());
                        if (m_internal) {
                                es += "      ";
#ifdef __GNUC__
                                es += "in ";
                                es += eii->where();
                                es += " ";
#endif
                                es += "at ";
                                es += eii->file();
                                es += "[";
                                es += buffer;
                                es += "]";
                                es += "\n";
                        }
                }
        }
        catch(...) {
                if (errno == 12)
                        std::cerr << err_nomem;
                else
                        std::cerr << err_unknown;
        }

        return(es);
}

/*
std::ostream& error::dump(std::ostream& a_out) const
{
        const_iterator eii;

        a_out << "ERROR: errno = " << m_errno;
        if (m_errno != 0) {
                a_out << " \"" << strerror(m_errno) << "\"";
        }
        a_out << std::endl;
        for (eii = begin(); eii != end(); ++eii) {
                eii->dump(a_out, "       ");
        }

        return(a_out);
}
*/

std::ostream& operator<<(std::ostream& a_out, const error& a_e)
{
        return(a_e.write(a_out));
}

const char * get_error_str(const int a_err)
{
        return(strerror(a_err));
}

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