assert.hpp

Go to the documentation of this file.

// Copyright Take Vos 2020-2022.
// 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)
 
#pragma once
 
#include "architecture.hpp"
#include "debugger.hpp"
#include "utility.hpp"
#include "type_traits.hpp"
#include "exception.hpp"
#include <exception>
#include <ranges>
 
namespace hi::inline v1 {
 
[[nodiscard]] constexpr bool bound_check(std::unsigned_integral auto index, std::unsigned_integral auto upper) noexcept
{
    using value_type = common_integer_t<decltype(index), decltype(upper)>;
 
    auto index_ = static_cast<value_type>(index);
    auto upper_ = static_cast<value_type>(upper);
    return index_ < upper_;
}
 
[[nodiscard]] constexpr bool bound_check(std::integral auto index, std::integral auto lower, std::integral auto upper) noexcept
{
    using value_type = common_integer_t<decltype(index), decltype(lower), decltype(upper)>;
 
    auto index_ = static_cast<value_type>(index);
    auto lower_ = static_cast<value_type>(lower);
    auto upper_ = static_cast<value_type>(upper);
 
    hi_axiom(lower_ <= upper_);
    return index_ >= lower_ and index_ < upper_;
}
 
template<typename Context>
concept bound_check_range_helper = requires(Context&& range) {
                                       {
                                           std::ranges::size(range)
                                           } -> std::unsigned_integral;
                                   };
 
[[nodiscard]] constexpr bool bound_check(std::integral auto index, bound_check_range_helper auto&& range) noexcept
{
    static_assert(sizeof(index) <= sizeof(size_t));
 
    if constexpr (std::is_signed_v<std::decay_t<decltype(index)>>) {
        if (index < 0) {
            return false;
        }
    }
 
    return static_cast<size_t>(index) < std::ranges::size(range);
}
 
#define hi_assert(expression) \
    do { \
        if (not(expression)) { \
            hi_set_terminate_message("assert: " hi_stringify(expression)); \
            hi_debug_abort(); \
        } \
    } while (false)
 
#define hi_assert_or_return(x, y) \
    if (!(x)) { \
        [[unlikely]] return y; \
    }
 
#define hi_assert_bounds(x, ...) \
    do { \
        if (not ::hi::bound_check(x, __VA_ARGS__)) { \
            hi_set_terminate_message("assert bounds: " hi_stringify(x) " between " hi_stringify(__VA_ARGS__)); \
            hi_debug_abort(); \
        } \
    } while (false)
 
#define hi_assert_not_null(x) \
    do { \
        if (x == nullptr) { \
            hi_set_terminate_message("assert not-null: " hi_stringify(x)); \
            hi_debug_abort(); \
        } \
    } while (false)
 
#ifndef NDEBUG
#define hi_axiom(expression) hi_assert(expression)
 
#define hi_axiom_not_null(expression) hi_assert_not_null(expression)
 
#define hi_no_default() [[unlikely]] hi_debug_abort()
 
#else
#define hi_axiom(expression) hi_assume(expression)
 
#define hi_axiom_not_null(expression) hi_assume(expression != nullptr)
 
#define hi_no_default() hi_unreachable()
#endif
 
#define hi_static_no_default() \
    []<bool Flag = false>() \
    { \
        static_assert(Flag); \
    } \
    ()
 
#define hi_not_implemented() [[unlikely]] hi_debug_abort();
 
#define hi_static_not_implemented() hi_static_no_default()
 
} // namespace hi::inline v1