diff options
Diffstat (limited to 'fuzzylite/src/Exception.cpp')
-rw-r--r-- | fuzzylite/src/Exception.cpp | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/fuzzylite/src/Exception.cpp b/fuzzylite/src/Exception.cpp new file mode 100644 index 0000000..d24adac --- /dev/null +++ b/fuzzylite/src/Exception.cpp @@ -0,0 +1,183 @@ +/* + Author: Juan Rada-Vilela, Ph.D. + Copyright (C) 2010-2014 FuzzyLite Limited + All rights reserved + + This file is part of fuzzylite. + + fuzzylite is free software: you can redistribute it and/or modify it under + the terms of the GNU Lesser General Public License as published by the Free + Software Foundation, either version 3 of the License, or (at your option) + any later version. + + fuzzylite is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + for more details. + + You should have received a copy of the GNU Lesser General Public License + along with fuzzylite. If not, see <http://www.gnu.org/licenses/>. + + fuzzyliteâ„¢ is a trademark of FuzzyLite Limited. + + */ + +#include "fl/Exception.h" + + +#ifdef FL_BACKTRACE_OFF +//do nothing + +#elif defined FL_UNIX +#include <execinfo.h> + +#elif defined FL_WINDOWS +#include <windows.h> +#include <winbase.h> +#ifndef __MINGW32__ +#include <dbghelp.h> +#endif +#endif + + +#include <signal.h> +#include <stdlib.h> +#include <string.h> + +namespace fl { + + Exception::Exception(const std::string& what) + : std::exception(), _what(what) { + FL_DBG(this->what()); + } + + Exception::Exception(const std::string& what, const std::string& file, int line, + const std::string& function) + : std::exception(), _what(what) { + append(file, line, function); + FL_DBG(this->what()); + } + + Exception::~Exception() FL_INOEXCEPT { + } + + void Exception::setWhat(const std::string& what) { + this->_what = what; + } + + std::string Exception::getWhat() const { + return this->_what; + } + + const char* Exception::what() const FL_INOEXCEPT { + return this->_what.c_str(); + } + + void Exception::append(const std::string& whatElse) { + this->_what += whatElse + "\n"; + } + + void Exception::append(const std::string& file, int line, const std::string& function) { + std::ostringstream ss; + ss << "\n{at " << file << "::" << function << "() [line:" << line << "]}"; + _what += ss.str(); + } + + void Exception::append(const std::string& whatElse, + const std::string& file, int line, const std::string& function) { + append(whatElse); + append(file, line, function); + } + + std::string Exception::btCallStack() { +#ifdef FL_BACKTRACE_OFF + return "[backtrace disabled] fuzzylite was built with option -DFL_BACKTRACE_OFF"; +#elif defined FL_UNIX + std::ostringstream btStream; + const int bufferSize = 30; + void* buffer[bufferSize]; + int backtraceSize = backtrace(buffer, bufferSize); + char **btSymbols = backtrace_symbols(buffer, backtraceSize); + if (btSymbols == fl::null) { + btStream << "[backtrace error] no symbols could be retrieved"; + } else { + if (backtraceSize == 0) btStream << "[backtrace is empty]"; + for (int i = 0; i < backtraceSize; ++i) { + btStream << btSymbols[i] << "\n"; + } + } + free(btSymbols); + return btStream.str(); + + +#elif defined FL_WINDOWS && ! defined __MINGW32__ + std::ostringstream btStream; + const int bufferSize = 30; + void* buffer[bufferSize]; + SymInitialize(GetCurrentProcess(), fl::null, TRUE); + + int backtraceSize = CaptureStackBackTrace(0, bufferSize, buffer, fl::null); + SYMBOL_INFO* btSymbol = (SYMBOL_INFO *) calloc(sizeof ( SYMBOL_INFO) + 256 * sizeof ( char), 1); + if (not btSymbol) { + btStream << "[backtrace error] no symbols could be retrieved"; + } else { + btSymbol->MaxNameLen = 255; + btSymbol->SizeOfStruct = sizeof ( SYMBOL_INFO); + if (backtraceSize == 0) btStream << "[backtrace is empty]"; + for (int i = 0; i < backtraceSize; ++i) { + SymFromAddr(GetCurrentProcess(), (DWORD64) (buffer[ i ]), 0, btSymbol); + btStream << (backtraceSize - i - 1) << ": " << + btSymbol->Name << " at 0x" << btSymbol->Address << "\n"; + } + } + free(btSymbol); + return btStream.str(); +#else + return "[backtrace missing] supported only in Unix and Windows platforms"; +#endif + } + //execinfo + + void Exception::signalHandler(int signal) { + std::ostringstream ex; + ex << "[unexpected signal " << signal << "] "; +#ifdef FL_UNIX + ex << strsignal(signal); +#endif + ex << "\nBACKTRACE:\n" << btCallStack(); + fl::Exception::catchException(fl::Exception(ex.str(), FL_AT)); + exit(EXIT_FAILURE); + } + + void Exception::convertToException(int signal) { + std::string signalDescription; +#ifdef FL_UNIX + //Unblock the signal + sigset_t empty; + sigemptyset(&empty); + sigaddset(&empty, signal); + sigprocmask(SIG_UNBLOCK, &empty, fl::null); + signalDescription = strsignal(signal); +#endif + std::ostringstream ex; + ex << "[signal " << signal << "] " << signalDescription << "\n"; + ex << "BACKTRACE:\n" << btCallStack(); + throw fl::Exception(ex.str(), FL_AT); + } + + void Exception::terminate() { + fl::Exception::catchException(fl::Exception("[unexpected exception] BACKTRACE:\n" + btCallStack(), FL_AT)); + exit(EXIT_FAILURE); + } + + void Exception::catchException(const std::exception& exception) { + std::ostringstream ss; + ss << exception.what(); + std::string backtrace = btCallStack(); + if (not backtrace.empty()) { + ss << "\n\nBACKTRACE:\n" << backtrace; + } + FL_LOG(ss.str()); + } + +} |