exception.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <optional>
#include <ostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
 
#include <hilti/rt/backtrace.h>
#include <hilti/rt/extension-points.h>
#include <hilti/rt/fmt.h>
 
namespace hilti::rt {
 
class Exception : public std::runtime_error {
public:
    Exception(std::string_view desc) : Exception(Internal(), "Exception", desc) {
#ifndef NDEBUG
        _backtrace = Backtrace();
#endif
    }
 
    Exception(std::string_view desc, std::string_view location) : Exception(Internal(), "Exception", desc, location) {
#ifndef NDEBUG
        _backtrace = Backtrace();
#endif
    }
 
    Exception();
 
    Exception(const Exception& other)
        : std::runtime_error(other),
          _description(other._description),
          _location(other._location),
          _backtrace(other._backtrace) {}
 
    Exception(Exception&&) noexcept = default;
    Exception& operator=(const Exception& other) = default;
 
    Exception& operator=(Exception&&) noexcept = default;
 
    // Empty, but required to make exception handling work between library
    // and host application. See:
    // http://www.toptip.ca/2012/06/c-exceptions-thrown-from-shared-library.html
    ~Exception() override;
 
    const auto& description() const { return _description; }
 
    const auto& location() const { return _location; }
 
    const Backtrace* backtrace() const {
        if ( ! _backtrace )
            return nullptr;
 
        return &*_backtrace;
    }
 
protected:
    enum Internal {};
 
    Exception(Internal, const char* type, std::string_view desc);
    Exception(Internal, const char* type, std::string_view desc, std::string_view location);
 
private:
    Exception(Internal, const char* type, std::string_view what, std::string_view desc, std::string_view location);
 
    std::string _description;
    std::string _location;
    std::optional<Backtrace> _backtrace; // null if unavailable.
};
 
inline std::ostream& operator<<(std::ostream& stream, const Exception& e) { return stream << e.what(); }
 
#define HILTI_EXCEPTION(name, base)                                                                                    \
    class name : public ::hilti::rt::base {                                                                            \
    public:                                                                                                            \
        name(std::string_view desc) : base(Internal(), #name, desc) {}                                                 \
        name(std::string_view desc, std::string_view location) : base(Internal(), #name, desc, location) {}            \
        virtual ~name(); /* required to create vtable, see hilti::rt::Exception */                                     \
    protected:                                                                                                         \
        using base::base;                                                                                              \
    }; // namespace hilti::rt
 
#define HILTI_EXCEPTION_NS(name, ns, base)                                                                             \
    class name : public ns::base {                                                                                     \
    public:                                                                                                            \
        name(std::string_view desc) : base(Internal(), #name, desc) {}                                                 \
        name(std::string_view desc, std::string_view location) : base(Internal(), #name, desc, location) {}            \
        virtual ~name(); /* required to create vtable, see hilti::rt::Exception */                                     \
    protected:                                                                                                         \
        using base::base;                                                                                              \
    };
 
#define HILTI_EXCEPTION_IMPL(name) name::name::~name() = default;
 
HILTI_EXCEPTION(RuntimeError, Exception)
 
 
HILTI_EXCEPTION(UsageError, Exception)
 
 
HILTI_EXCEPTION(RecoverableFailure, RuntimeError)
 
 
HILTI_EXCEPTION(AssertionFailure, RuntimeError)
 
/*
 * Exception triggered y the ".?" operator to signal to host applications that
 * a struct attribute isn't set.
 */
HILTI_EXCEPTION(AttributeNotSet, RuntimeError)
 
 
HILTI_EXCEPTION(DivisionByZero, RuntimeError)
 
 
HILTI_EXCEPTION(EnvironmentError, UsageError)
 
 
HILTI_EXCEPTION(ExpiredReference, RuntimeError)
 
 
HILTI_EXCEPTION(Frozen, RuntimeError)
 
 
HILTI_EXCEPTION(IllegalReference, RuntimeError)
 
 
HILTI_EXCEPTION(IndexError, RuntimeError)
 
 
HILTI_EXCEPTION(InvalidArgument, RuntimeError);
 
HILTI_EXCEPTION(InvalidIterator, RuntimeError)
 
HILTI_EXCEPTION(InvalidValue, RuntimeError);
 
HILTI_EXCEPTION(MatchStateReuse, RuntimeError)
 
HILTI_EXCEPTION(MissingData, RecoverableFailure);
 
HILTI_EXCEPTION(NotSupported, RuntimeError)
 
HILTI_EXCEPTION(NullReference, RuntimeError)
 
HILTI_EXCEPTION(OutOfRange, RuntimeError)
 
HILTI_EXCEPTION(Overflow, RuntimeError)
 
HILTI_EXCEPTION(PatternError, RuntimeError)
 
HILTI_EXCEPTION(UnhandledSwitchCase, RuntimeError)
 
HILTI_EXCEPTION(UnicodeError, RuntimeError)
 
HILTI_EXCEPTION(UnsetOptional, RuntimeError)
 
HILTI_EXCEPTION(UnsetTupleElement, RuntimeError)
 
HILTI_EXCEPTION(UnsetUnionMember, RuntimeError)
 
HILTI_EXCEPTION(StackSizeExceeded, RuntimeError)
 
class FormattingError : public RuntimeError {
public:
    FormattingError(std::string desc) : RuntimeError(_sanitize(std::move(desc))) {}
 
private:
    std::string _sanitize(std::string desc) {
        if ( auto pos = desc.find("tinyformat: "); pos != std::string::npos )
            desc.erase(pos, 12);
 
        return desc;
    }
};
 
class WouldBlock : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
 
    WouldBlock(std::string_view desc, std::string_view location);
};
 
namespace exception {
 
// Disables `Configuration::abort_on_exception` during its lifetime.
class DisableAbortOnExceptions {
public:
    DisableAbortOnExceptions();
    ~DisableAbortOnExceptions();
 
    DisableAbortOnExceptions(const DisableAbortOnExceptions&) = delete;
    DisableAbortOnExceptions(DisableAbortOnExceptions&&) noexcept = delete;
    DisableAbortOnExceptions& operator=(const DisableAbortOnExceptions&) = delete;
    DisableAbortOnExceptions& operator=(DisableAbortOnExceptions&&) noexcept = delete;
};
 
void printUncaught(const Exception& e);
 
void printUncaught(const Exception& e, std::ostream& out);
 
inline std::string what(const Exception& e) { return e.description(); }
 
inline std::string what(const std::exception& e) { return e.what(); }
 
inline std::string where(const Exception& e) { return e.location(); }
 
} // namespace exception
 
namespace detail::adl {
inline std::string to_string(const Exception& e, adl::tag /*unused*/) { return fmt("<exception: %s>", e.what()); }
inline std::string to_string(const WouldBlock& e, adl::tag /*unused*/) { return fmt("<exception: %s>", e.what()); }
} // namespace detail::adl
 
} // namespace hilti::rt