Added result type and stacktrace capabilities.

LibConf

@@ -3,6 +3,7 @@ Import('env')
 
 mijin_sources = Split("""
     source/mijin/async/coroutine.cpp
+    source/mijin/debug/stacktrace.cpp
     source/mijin/debug/symbol_info.cpp
     source/mijin/io/process.cpp
     source/mijin/io/stream.cpp
@@ -12,15 +13,18 @@ mijin_sources = Split("""
     source/mijin/virtual_filesystem/stacked.cpp
 """)
 
-env.UnityStaticLibrary(
+lib_libbacktrace = env.Cook('libbacktrace')
+
+lib_mijin = env.UnityStaticLibrary(
     target = env['LIB_DIR']  + '/mijin',
-    source = mijin_sources
+    source = mijin_sources,
+    dependencies = [lib_libbacktrace]
 )
 
 LIB_CONFIG = {
     'CPPPATH': [env.Dir('source')],
     'CPPDEFINES': [],
-    'LIBS': ['mijin']
+    'DEPENDENCIES': [lib_mijin]
 }
 
 if env['BUILD_TYPE'] == 'debug':

source/mijin/debug/stacktrace.cpp

@@ -0,0 +1,88 @@
+
+#include "./stacktrace.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <backtrace.h>
+
+namespace mijin
+{
+namespace
+{
+//
+// internal defines
+//
+
+//
+// internal constants
+//
+
+//
+// internal types
+//
+
+struct BacktraceData
+{
+    std::optional<std::string> error;
+    std::vector<Stackframe> stackframes;
+};
+
+//
+// internal variables
+//
+
+//
+// internal functions
+//
+
+int backtraceFullCallback(void* data, std::uintptr_t programCounter, const char* filename, int lineno, const char* function)
+{
+    BacktraceData& btData = *static_cast<BacktraceData*>(data);
+    btData.stackframes.push_back({
+        .address = reinterpret_cast<void*>(programCounter),
+        .filename = filename ? filename : "<unknown>",
+        .function = function ? function : "<unknown>",
+        .lineNumber = lineno
+    });
+    return 0;
+}
+
+void backtraceErrorCallback(void* data, const char* msg, int /* errnum */)
+{
+    BacktraceData& btData = *static_cast<BacktraceData*>(data);
+    btData.error = msg;
+}
+
+backtrace_state* gBacktraceState = nullptr;
+} // namespace
+
+//
+// public functions
+//
+
+Result<Stacktrace> captureStacktrace(unsigned skipFrames) noexcept
+{
+    BacktraceData btData;
+    if (gBacktraceState == nullptr)
+    {
+        gBacktraceState = backtrace_create_state(/*filename = */ nullptr, /* threaded = */ false, &backtraceErrorCallback, &btData);
+    }
+    if (btData.error.has_value())
+    {
+        return ResultError(std::move(*btData.error));
+    }
+    if (gBacktraceState == nullptr)
+    {
+        return ResultError("Error initializing libbacktrace.");
+    }
+    backtrace_full(gBacktraceState, static_cast<int>(skipFrames) + 1, &backtraceFullCallback, &backtraceErrorCallback, &btData);
+    if (btData.error.has_value())
+    {
+        return ResultError(std::move(*btData.error));
+    }
+
+    return Stacktrace(std::move(btData.stackframes));
+}
+
+} // namespace mijin

source/mijin/debug/stacktrace.hpp

@@ -0,0 +1,85 @@
+
+#pragma once
+
+#if !defined(MIJIN_DEBUG_STACKTRACE_HPP_INCLUDED)
+#define MIJIN_DEBUG_STACKTRACE_HPP_INCLUDED 1
+
+#include <cmath>
+#include <iomanip>
+#include <vector>
+#include "./symbol_info.hpp"
+#include "../types/result.hpp"
+#include "../util/iterators.hpp"
+
+namespace mijin
+{
+
+//
+// public defines
+//
+
+//
+// public constants
+//
+
+//
+// public types
+//
+
+struct Stackframe
+{
+    void* address;
+    std::string filename;
+    std::string function;
+    int lineNumber;
+};
+
+class Stacktrace
+{
+private:
+    std::vector<Stackframe> frames_;
+public:
+    Stacktrace() = default;
+    Stacktrace(const Stacktrace&) = default;
+    Stacktrace(Stacktrace&&) = default;
+    explicit Stacktrace(std::vector<Stackframe> frames) noexcept : frames_(std::move(frames)) {}
+
+    Stacktrace& operator=(const Stacktrace&) = default;
+    Stacktrace& operator=(Stacktrace&&) = default;
+
+    [[nodiscard]] const std::vector<Stackframe>& getFrames() const noexcept { return frames_; }
+};
+
+//
+// public functions
+//
+
+[[nodiscard]] Result<Stacktrace> captureStacktrace(unsigned skipFrames = 0) noexcept;
+
+template<typename TStream>
+TStream& operator<<(TStream& stream, const Stackframe& stackframe)
+{
+    stream << "[" << stackframe.address << "] " << stackframe.filename << ":" << stackframe.lineNumber << " in " << demangleCPPIdentifier(stackframe.function.c_str());
+
+    return stream;
+}
+
+template<typename TStream>
+TStream& operator<<(TStream& stream, const Stacktrace& stacktrace)
+{
+    const int oldWidth = stream.width();
+    const std::ios::fmtflags oldFlags = stream.flags();
+    const int numDigits = static_cast<int>(std::ceil(std::log10(stacktrace.getFrames().size())));
+    stream << std::left;
+    for (const auto& [idx, frame] : mijin::enumerate(stacktrace.getFrames()))
+    {
+        stream << "  #" << std::setw(numDigits) << idx << std::setw(0) << " at " << frame << "\n";
+    }
+    stream << std::setw(oldWidth);
+    stream.flags(oldFlags);
+    return stream;
+}
+
+} // namespace mijin
+
+#endif // !defined(MIJIN_DEBUG_STACKTRACE_HPP_INCLUDED)

source/mijin/debug/symbol_info.cpp

@@ -75,12 +75,12 @@ std::string demangleCPPIdentifier(const char* identifier)
         std::free(demangled); // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
         return name;
     }
-    return "";
+    return identifier;
 }
 #else
-std::string demangleCPPIdentifier(const char* /* identifier */)
+std::string demangleCPPIdentifier(const char* identifier)
 {
-    return "";
+    return identifier;
 }
 #endif
 

source/mijin/types/result.hpp

@@ -0,0 +1,75 @@
+
+#pragma once
+
+#if !defined(MIJIN_TYPES_RESULT_HPP_INCLUDED)
+#define MIJIN_TYPES_RESULT_HPP_INCLUDED 1
+
+#include <string>
+#include <variant>
+
+namespace mijin
+{
+
+//
+// public defines
+//
+
+//
+// public constants
+//
+
+//
+// public types
+//
+
+template<typename TSuccess, typename TError>
+class ResultBase
+{
+private:
+    struct Empty {};
+
+    std::variant<Empty, TSuccess, TError> state_;
+public:
+    ResultBase() = default;
+    ResultBase(const ResultBase&) = default;
+    ResultBase(ResultBase&&) = default;
+    ResultBase(TSuccess successValue) noexcept : state_(std::move(successValue)) {}
+    ResultBase(TError errorValue) noexcept : state_(std::move(errorValue)) {}
+
+    ResultBase& operator=(const ResultBase&) = default;
+    ResultBase& operator=(ResultBase&&) = default;
+
+    bool operator==(const ResultBase& other) const noexcept { return state_ == other.state_; }
+    bool operator!=(const ResultBase& other) const noexcept { return state_ != other.state_; }
+    operator bool() const noexcept { return isSuccess(); }
+    bool operator!() const noexcept { return !isSuccess(); }
+    TSuccess& operator*() noexcept { return getValue(); }
+    const TSuccess& operator*() const noexcept { return getValue(); }
+    TSuccess* operator->() noexcept { return &getValue(); }
+    const TSuccess* operator->() const noexcept { return &getValue(); }
+
+    [[nodiscard]] bool isEmpty() const noexcept { return std::holds_alternative<Empty>(state_); }
+    [[nodiscard]] bool isSuccess() const noexcept { return std::holds_alternative<TSuccess>(state_); }
+    [[nodiscard]] bool isError() const noexcept { return std::holds_alternative<TError>(state_); }
+
+    [[nodiscard]] TSuccess& getValue() noexcept { return std::get<TSuccess>(state_); }
+    [[nodiscard]] TError& getError() noexcept { return std::get<TError>(state_); }
+    [[nodiscard]] const TSuccess& getValue() const noexcept { return std::get<TSuccess>(state_); }
+    [[nodiscard]] const TError& getError() const noexcept { return std::get<TError>(state_); }
+};
+
+struct ResultError
+{
+    std::string message;
+};
+
+template<typename TSuccess>
+using Result = ResultBase<TSuccess, ResultError>;
+
+//
+// public functions
+//
+
+} // namespace mijin
+
+#endif // !defined(MIJIN_TYPES_RESULT_HPP_INCLUDED)