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());
+    }
+
+}