Exception.cpp

/*
** libutil++
** $Id: Exception.cpp 1664 2016-04-04 03:57:40Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Exception.cpp 1664 2016-04-04 03:57:40Z sella $";

#include "Exception.h"
#include "util/Process.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

#ifdef __GNUG__
        #include <cxxabi.h>
#endif

#include <string>

#define BUFFER_SIZE 32768

using namespace sella;

/* Global Variables */
extern bool libutilxx__exception_stacktrace;
extern int errno;

Exception::Exception(const char *function, const char *file, int line, int code) throw () :
        function(function),
        file(file),
        line(line),
        code(code)
{
        if (libutilxx__exception_stacktrace) {
                using namespace sella::util;

                try {
                        stack = Process::stackTrace(Process::getPath());
                } catch (...) { }
        }
}

Exception::Exception(bool sysmsg, const char *function, const char *file, int line, int code, const char *format, ...) throw () :
        function(function),
        file(file),
        line(line),
        code(code)
{
        EXCEPTION_BUILDMESSAGE_CODE

        if (libutilxx__exception_stacktrace) {
                using namespace sella::util;

                try {
                        stack = Process::stackTrace(Process::getPath());
                } catch (...) { }
        }
}

Exception::Exception(const Exception &other) throw () :
        function(other.function),
        file(other.file),
        line(other.line),
        code(other.code),
        message(other.message),
        stack(other.stack),
        cache(other.cache)
{ }

Exception::Exception(const Exception &&other) throw () :
        function(std::move(other.function)),
        file(std::move(other.file)),
        line(other.line),
        code(other.code),
        message(std::move(other.message)),
        stack(std::move(other.stack)),
        cache(std::move(other.cache))
{ }

Exception::~Exception() throw () { }

Exception& sella::Exception::operator=(const Exception &other) throw () {
        if (this != &other) {
                this->function = other.function;
                this->file = other.file;
                this->line = other.line;
                this->code = other.code;
                this->message = other.message;
                this->stack = other.stack;
                this->cache = other.cache;
        }

        return *this;
}

Exception& sella::Exception::operator=(const Exception &&other) throw () {
        if (this != &other) {
                this->function = std::move(other.function);
                this->file = std::move(other.file);
                this->line = other.line;
                this->code = other.code;
                this->message = std::move(other.message);
                this->stack = std::move(other.stack);
                this->cache = std::move(other.cache);
        }

        return *this;
}

const std::string& Exception::getFunction() const throw () {
        return this->function;
}

const std::string& Exception::getFile() const throw () {
        return this->file;
}

int Exception::getLine() const throw () {
        return this->line;
}

int Exception::getCode() const throw () {
        return this->code;
}

const std::string& Exception::getMessage() const throw () {
        return this->message;
}

const char* Exception::what() const throw () {
        return this->message.c_str();
}

const std::string& Exception::getStackTrace() const throw () {
        return stack;
}

const std::string Exception::getName() const throw () {
        return std::string("sella::Exception");
}

const std::string& Exception::str() const throw () {
        if (cache.empty()) {
                char buf[20];

                snprintf(buf, sizeof(buf), ":%d]", this->line);

                cache = (this->message + " [" + this->file + buf);
        }

        return cache;
}

const char* Exception::c_str() const throw () {
        return str().c_str();
}

void Exception::enableStackTrace(bool on) throw () {
        libutilxx__exception_stacktrace = on;
}

void Exception::buildMessage(bool sysmsg, const char *format, va_list list) throw () {
        char buffer[BUFFER_SIZE] = { 0 }; /* Prevent garbage output on empty error messages. */
        std::string     error;

        if (sysmsg) {
                error = ": ";
                error.append(strerror_r(errno, buffer, sizeof(buffer)));
        }

        vsnprintf(buffer, sizeof(buffer), format, list);

        this->message = buffer;
        this->message.append(error);

        cache.clear();
}

const std::string Exception::demangle(const char *name) const throw () {
#ifdef __GNUG__
        int s;
        char *d;
        std::string res;

        d = abi::__cxa_demangle(name, NULL, NULL, &s);

        if (s == 0) {
                res = d;
                std::free(d);
        }

        return std::move(res);
#else
        return std::string(name);
#endif
}

/*
** vim: noet ts=3 sw=3
*/