exception.hpp

Go to the documentation of this file.

// Copyright Take Vos 2020-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#include "utility.hpp"
#include <exception>
#include <stdexcept>
#include <atomic>
#include <bit>
#include <format>
 
#pragma once
 
namespace hi { inline namespace v1 {
 
inline std::atomic<char const *> terminate_message = nullptr;
 
#define hi_set_terminate_message(...) \
    ::hi::terminate_message.store(__FILE__ ":" hi_stringify(__LINE__) ":" __VA_ARGS__, std::memory_order::relaxed)
 
[[nodiscard]] uint32_t get_last_error_code() noexcept;
 
[[nodiscard]] std::string get_last_error_message(uint32_t error_code);
 
[[nodiscard]] std::string get_last_error_message();
 
class parse_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
 
    template<typename It, typename... Args>
    [[nodiscard]] constexpr parse_error(It first, It last, int tab_size, char const *msg, Args const&...args) noexcept :
        runtime_error(make_what(first, last, tab_size, msg, args...))
    {
    }
 
    template<typename It, typename... Args>
    [[nodiscard]] constexpr parse_error(It first, It last, char const *msg, Args const&...args) noexcept :
        parse_error(first, last, 8, msg, args...)
    {
    }
 
    template<typename It>
    [[nodiscard]] static constexpr std::pair<size_t, size_t> get_line_position(It first, It last, size_t tab_size) noexcept
    {
        auto line_nr = 0_uz;
        auto column_nr = 0_uz;
 
        auto c32 = char32_t{};
        auto continue_count = int{};
        while (first != last) {
            hilet c8 = char_cast<char8_t>(*first++);
 
            if ((c8 & 0xc0) == 0x80) {
                --continue_count;
                c32 <<= 6;
                c32 |= c8 & 0x3f;
 
            } else if (c8 & 0x80) {
                continue_count = std::countl_one(c8) - 1;
                c32 = c8 & (0b00'111'111 >> continue_count);
 
            } else {
                continue_count = 0;
                c32 = c8;
            }
 
            if (not continue_count) {
                ++column_nr;
                switch (c32) {
                case '\n':
                case '\v':
                case '\f':
                case U'\u0085':
                case U'\u2028':
                case U'\u2029':
                    ++line_nr;
                    [[fallthrough]];
                case '\r':
                    column_nr = 0;
                    break;
                case '\t':
                    column_nr /= tab_size;
                    column_nr *= tab_size;
                    break;
                default:;
                }
            }
        }
 
        return {line_nr, column_nr};
    }
 
private:
    template<typename It, typename... Args>
    [[nodiscard]] static constexpr std::string
    make_what(It first, It last, size_t tab_size, char const *msg, Args const&...args) noexcept
    {
        hilet[line_nr, column_nr] = get_line_position(first, last, tab_size);
        return {std::format("{}:{}: {}", line_nr + 1, column_nr + 1, std::format(msg, args...))};
    }
};
 
class not_found_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class operation_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class io_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class os_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class gui_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class key_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class url_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
class uri_error : public parse_error {
public:
    using parse_error::parse_error;
};
 
class cancel_error : public std::runtime_error {
public:
    using std::runtime_error::runtime_error;
};
 
}} // namespace hi::v1