macros.hpp

// Copyright Take Vos 2023.
// 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 <version>
#include <exception>
 
#define HI_OS_WINDOWS 'W'
#define HI_OS_ANDROID 'A'
#define HI_OS_LINUX 'L'
#define HI_OS_MACOS 'M'
#define HI_OS_IOS 'I'
 
// W don't use HI_GENERIC for the operating system, because too many things
// like mmap-file-io, vulkan, window, main-loop depend on this.
#if defined(_WIN32)
#define HI_OPERATING_SYSTEM HI_OS_WINDOWS
#elif defined(__ANDROID__)
#define HI_OPERATING_SYSTEM HI_OS_ANDROID
#elif defined(__linux__)
#define HI_OPERATING_SYSTEM HI_OS_LINUX
#elif defined(__APPLE__) and defined(__MACH__)
#include <TargetConditionals.h>
#if TARGET_IPHONE_SIMULATOR or TARGET_OS_IPHONE or TARGET_OS_MACCATALYST
#define HI_OPERATING_SYSTEM HI_OS_IOS
#else
#define HI_OPERATING_SYSTEM HI_OS_MACOS
#endif
#else
#error "Unknown operating system"
#endif
 
#define HI_CC_MSVC 'm'
#define HI_CC_GCC 'g'
#define HI_CC_CLANG 'c'
#define HI_CC_OTHER '-'
 
#if defined(HI_GENERIC)
#define HI_COMPILER HI_CC_OTHER
#elif defined(__clang__)
#define HI_COMPILER HI_CC_CLANG
#elif defined(_MSC_BUILD)
#define HI_COMPILER HI_CC_MSVC
#elif defined(__GNUC__)
#define HI_COMPILER HI_CC_GCC
#else
#define HI_COMPILER HI_CC_OTHER
#endif
 
#define HI_STL_MS 'm'
#define HI_STL_GNU 'g'
#define HI_STL_LLVM 'l'
#define HI_STL_OTHER '-'
 
#if defined(HI_GENERIC)
#define HI_STD_LIBRARY HI_STL_OTHER
#elif defined(__GLIBCXX__)
#define HI_STD_LIBRARY HI_STL_GNU
#elif defined(_LIBCPP_VERSION)
#define HI_STD_LIBRARY HI_STL_LLVM
#elif defined(_CPPLIB_VER)
#define HI_STD_LIBRARY HI_STL_MS
#else
#define HI_STD_LIBRARY HI_STL_OTHER
#endif
 
#define HI_CPU_X86 'i'
#define HI_CPU_X86_64 'I'
#define HI_CPU_ARM 'a'
#define HI_CPU_ARM64 'A'
#define HI_CPU_OTHER '-'
 
#if defined(HI_GENERIC)
#define HI_PROCESSOR HI_CPU_OTHER
#elif defined(__amd64__) or defined(__amd64) or defined(__x86_64__) or defined(__x86_64) or defined(_M_AMD64) or defined(_M_X64)
#define HI_PROCESSOR HI_CPU_X86_64
#elif defined(__aarch64__) or defined(_M_ARM64)
#define HI_PROCESSOR HI_CPU_ARM64
#elif defined(__i386__) or defined(_M_IX86)
#define HI_PROCESSOR HI_CPU_X86
#elif defined(__arm__) or defined(__arm) or defined(_ARM) or defined(_M_ARM)
#define HI_PROCESSOR HI_CPU_ARM
#else
#define HI_PROCESSOR HI_CPU_OTHER
#endif
 
// All the HI_HAS_* macros tell us if the compiler will generate code with these instructions.
// Therefor we can use intrinsics for these instructions without checking the cpu-id.
// Which instrinsics are available is handled by a different macro.
 
#if HI_PROCESSOR == HI_CPU_X86_64
#define HI_HAS_X86_64 1
#define HI_HAS_X86 1
#elif HI_PROCESSOR == HI_CPU_X86
#define HI_HAS_X86 1
#endif
 
// Detect microarchitecture level.
#if defined(HI_HAS_X86)
#if HI_COMPILER == HI_CC_MSVC
// MSVC /arch:SSE (x86)
#if _M_IX86_FP >= 1 || defined(HI_HAS_X86_64)
#define HI_HAS_SSE 1
#define HI_HAS_MMX 1
 
#define HI_HAS_SCE 1
#define HI_HAS_OSFXSR 1
#define HI_HAS_FXSR 1
#define HI_HAS_FPU 1
#define HI_HAS_CX8 1
#define HI_HAS_CMOV 1
 
// MSVC /arch:SSE2 (x86)
#if _M_IX86_FP >= 2 || defined(HI_HAS_X86_64)
#define HI_HAS_SSE2 1
 
// MSVC /arch:AVX
#if defined(__AVX__)
// x86-64-v2
#define HI_HAS_SSSE3 1
#define HI_HAS_SSE4_1 1
#define HI_HAS_SSE4_2 1
#define HI_HAS_SSE3 1
#define HI_HAS_POPCNT 1
#define HI_HAS_LAHF 1
#define HI_HAS_CX16 1
 
#define HI_HAS_AVX 1
 
// MSVC /arch:AVX2
#if defined(__AVX2__)
// x86-64-v3
#define HI_HAS_AVX 1
#define HI_HAS_AVX2 1
#define HI_HAS_BMI1 1
#define HI_HAS_BMI2 1
#define HI_HAS_F16C 1
#define HI_HAS_FMA 1
#define HI_HAS_LZCNT 1
#define HI_HAS_MOVBE 1
#define HI_HAS_OSXSAVE 1
 
// MSVC /arch:AVX512
#if defined(__AVX512F__) && defined(__AVX512BW__) && defined(__AVX512CD__) && defined(__AVX512DQ__) && defined(__AVX512VL__)
// x86-64-v4
#define HI_HAS_AVX512F 1
#define HI_HAS_AVX512BW 1
#define HI_HAS_AVX512CD 1
#define HI_HAS_AVX512DQ 1
#define HI_HAS_AVX512VL 1
 
#endif // defined(__AVX512__)
#endif // defined(__AVX2__)
#endif // defined(__AVX__)
#endif // _M_IX86_FP >= 2
#endif // _M_IX86_FP >= 1
 
#elif HI_COMPILER == HI_CC_CLANG || HI_COMPILER == HI_CC_GCC
#if defined(__MMX__)
#define HI_HAS_MMX 1
#endif
#if defined(__SSE__)
#define HI_HAS_SSE 1
#endif
#if defined(__SSE2__)
#define HI_HAS_SSE2 1
#endif
#if defined(__SSE3__)
#define HI_HAS_SSE3 1
#endif
#if defined(__SSSE3__)
#define HI_HAS_SSSE3 1
#endif
#if defined(__SSE4_1__)
#define HI_HAS_SSE4_1 1
#endif
#if defined(__SSE4_2__)
#define HI_HAS_SSE4_2 1
#endif
#if defined(__POPCNT__)
#define HI_HAS_POPCNT 1
#endif
#if defined(__LAHF_SAHF__)
#define HI_HAS_LAHF 1
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define HI_HAS_CX16 1
#endif
#if defined(__AVX__)
#define HI_HAS_AVX 1
#endif
#if defined(__AVX2__)
#define HI_HAS_AVX2 1
#endif
#if defined(__BMI__)
#define HI_HAS_BMI1 1
#endif
#if defined(__BMI2__)
#define HI_HAS_BMI2 1
#endif
#if defined(__F16C__)
#define HI_HAS_F16C 1
#endif
#if defined(__FMA__)
#define HI_HAS_FMA 1
#endif
#if defined(__LZCNT__)
#define HI_HAS_LZCNT 1
#endif
#if defined(__MOVBE__)
#define HI_HAS_MOVBE 1
#endif
#if defined(__XSAVE__)
#define HI_HAS_XSAVE 1
#endif
#if defined(__AVX512BW__)
#define HI_HAS_AVX512BW 1
#endif
#if defined(__AVX512CD__)
#define HI_HAS_AVX512CD 1
#endif
#if defined(__AVX512DQ__)
#define HI_HAS_AVX512DQ 1
#endif
#if defined(__AVX512F__)
#define HI_HAS_AVX512F 1
#endif
#if defined(__AVX512VL__)
#define HI_HAS_AVX512VL 1
#endif
#if defined(__SHA__)
#define HI_HAS_SHA 1
#endif
#if defined(__AES__)
#define HI_HAS_AES 1
#endif
#if defined(__PCLMUL__)
#define HI_HAS_PCLMUL 1
#endif
#if defined(__RDRND__)
#define HI_HAS_RDRND 1
#endif
#if defined(__RDSEED__)
#define HI_HAS_RDSEED 1
#endif
 
#else // HI_COMPILER == HI_CC_CLANG || HI_COMPILER == HI_CC_GCC
#error "Unknown compiler for x86"
#endif
 
#endif // defined(HI_HAS_X86)
 
// clang-format off
#if defined(HI_HAS_SSE2) && defined(HI_HAS_SSE) && defined(HI_HAS_SCE) && \
    defined(HI_HAS_OSFXSR) && defined(HI_HAS_MMX) && defined(HI_HAS_FXSR) && \
    defined(HI_HAS_FPU) && defined(HI_HAS_CX8) && defined(HI_HAS_CMOV)
#define HI_HAS_X86_64_V1 1
#endif
 
#if defined(HI_HAS_X86_64_V1) && defined(HI_HAS_SSSE3) && defined(HI_HAS_SSE4_1) && \
    defined(HI_HAS_SSE4_2) && defined(HI_HAS_SSE3) && defined(HI_HAS_POPCNT) && \
    defined(HI_HAS_LAHF) && defined(HI_HAS_CX16)
#define HI_HAS_X86_64_V2 1
#endif
 
#if defined(HI_HAS_X86_64_V2) && defined(HI_HAS_AVX) && defined(HI_HAS_AVX2) && \
    defined(HI_HAS_BMI1) && defined(HI_HAS_BMI2) && defined(HI_HAS_F16C) && \
    defined(HI_HAS_FMA) && defined(HI_HAS_LZCNT) && defined(HI_HAS_MOVBE) && \
    defined(HI_HAS_OSXSAVE)
#define HI_HAS_X86_64_V3 1
#endif
 
#if defined(HI_HAS_X86_64_V3) && defined(HI_HAS_AVX512F) && defined(HI_HAS_AVX512BW) && \
    defined(HI_HAS_AVX512CD) && defined(HI_HAS_AVX512DQ) && defined(HI_HAS_AVX512VL)
#define HI_HAS_X86_64_V4 1
#endif
// clang-format on
 
inline void weak_terminate() noexcept
{
    std::terminate();
}
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_assert_break() __builtin_trap()
#elif HI_COMPILER == HI_CC_MSVC
#define hi_assert_break() __int2c()
#elif HI_COMPILER == HI_CC_GCC
#define hi_assert_break() __builtin_trap()
#else
#define hi_assert_break() weak_terminate()
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_debug_break() __builtin_debugtrap()
#elif HI_COMPILER == HI_CC_MSVC
#define hi_debug_break() __debugbreak()
#elif HI_COMPILER == HI_CC_GCC
#define hi_debug_break() __builtin_trap()
#else
#define hi_debug_break() weak_terminate()
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_target(...) [[gnu::target(__VA_ARGS__)]]
#elif HI_COMPILER == HI_CC_MSVC
#define hi_target(...)
#elif HI_COMPILER == HI_CC_GCC
#define hi_target(...) [[gnu::target(__VA_ARGS__)]]
#else
#define hi_target(...)
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_assume(...) __builtin_assume(not not(__VA_ARGS__))
#elif HI_COMPILER == HI_CC_MSVC
#define hi_assume(...) __assume(not not(__VA_ARGS__))
#elif HI_COMPILER == HI_CC_GCC
#define hi_assume(...) \
    do { \
        if (not(__VA_ARGS__)) { \
            std::unreachable(); \
        } \
    } while (false)
#else
#define hi_assume(...) static_assert(std::convertible_to<decltype(not not(__VA_ARGS__)), bool>)
#endif
 
#if defined(NDEBUG)
#if HI_COMPILER == HI_CC_CLANG
#define hi_force_inline __attribute__((always_inline))
#elif HI_COMPILER == HI_CC_MSVC
#define hi_force_inline __forceinline
#elif HI_COMPILER == HI_CC_GCC
#define hi_force_inline __attribute__((always_inline))
#else
#define hi_force_inline
#endif
#else
#define hi_force_inline
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_no_inline __attribute__((noinline))
#elif HI_COMPILER == HI_CC_MSVC
#define hi_no_inline __declspec(noinline)
#elif HI_COMPILER == HI_CC_GCC
#define hi_no_inline __attribute__((noinline))
#else
#define hi_no_inline
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_restrict __restrict__
#elif HI_COMPILER == HI_CC_MSVC
#define hi_restrict __restrict
#elif HI_COMPILER == HI_CC_GCC
#define hi_restrict __restrict__
#else
#define hi_restrict
#endif
 
#if HI_COMPILER == HI_CC_CLANG
#define hi_no_sanitize_address
#elif HI_COMPILER == HI_CC_MSVC
#define hi_no_sanitize_address __declspec(no_sanitize_address)
#elif HI_COMPILER == HI_CC_GCC
#define hi_no_sanitize_address
#else
#define hi_no_sanitize_address
#endif
 
// Even when HI_GENERIC is set, we want the warning for the specific compilers
// to be properly suppressed.
#if defined(__clang__)
#define hi_warning_push() _Pragma("warning(push)")
#define hi_warning_pop() _Pragma("warning(push)")
#define hi_warning_ignore_msvc(...)
#define hi_warning_ignore_clang(...) _Pragma(hi_stringify(clang diagnostic ignored __VA_ARGS__))
#define hi_warning_ignore_gcc(...)
#elif defined(_MSC_BUILD)
#define hi_warning_push() _Pragma("warning( push )")
#define hi_warning_pop() _Pragma("warning( pop )")
#define hi_msvc_pragma(...) _Pragma(__VA_ARGS__)
#define hi_warning_ignore_msvc(...) _Pragma(hi_stringify(warning(disable : __VA_ARGS__)))
#define hi_warning_ignore_clang(...)
#define hi_warning_ignore_gcc(...)
#elif defined(__GNUC__)
#define hi_warning_push() _Pragma("warning(push)")
#define hi_warning_pop() _Pragma("warning(pop)")
#define hi_warning_ignore_msvc(...)
#define hi_warning_ignore_clang(...)
#define hi_warning_ignore_gcc(...) _Pragma(hi_stringify(clang diagnostic ignored __VA_ARGS__))
#else
#define hi_warning_push()
#define hi_warning_pop()
#define hi_warning_ignore_msvc(...)
#define hi_warning_ignore_clang(...)
#define hi_warning_ignore_gcc(...)
#endif
 
 
#ifndef hi_export_module
#define hi_export_module(x)
#endif
 
#ifndef hi_export
#define hi_export
#endif
 
#ifndef hi_inline
#define hi_inline inline
#endif
 
#define hi_return_if_valid(expression) \
    do { \
        if constexpr (requires { expression; }) { \
            return expression; \
        } \
    } while (false)
 
// One clang-format off is not enough to stop clang-format to format.
// clang-format off
#define hi_num_va_args_impl( \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N
#define hi_num_va_args_(...) hi_num_va_args_impl(__VA_ARGS__)
// clang-format on        
 
// clang-format off
#define hi_num_va_args(...) hi_num_va_args_(__VA_ARGS__ __VA_OPT__(,) \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0)
// clang-format on
 
#define hi_parans ()
 
#define hi_expand1(...) __VA_ARGS__
#define hi_expand2(...) hi_expand1(hi_expand1(hi_expand1(hi_expand1(__VA_ARGS__))))
#define hi_expand3(...) hi_expand2(hi_expand2(hi_expand2(hi_expand2(__VA_ARGS__))))
#define hi_expand4(...) hi_expand3(hi_expand3(hi_expand3(hi_expand3(__VA_ARGS__))))
 
#define hi_expand(...) hi_expand4(hi_expand4(hi_expand4(hi_expand4(__VA_ARGS__))))
 
#define hi_for_each_again() hi_for_each_helper
#define hi_for_each_helper(macro, first_arg, ...) macro(first_arg) __VA_OPT__(hi_for_each_again hi_parans(macro, __VA_ARGS__))
 
#define hi_for_each(macro, ...) __VA_OPT__(hi_expand(hi_for_each_helper(macro, __VA_ARGS__)))
 
#define hi_stringify_(x) #x
#define hi_stringify(x) hi_stringify_(x)
 
#define hi_cat_(a, b) a##b
#define hi_cat(a, b) hi_cat_(a, b)
 
#define hi_return_on_self_assignment(other) \
    if (&(other) == this) [[unlikely]] \
        return *this;
 
#define hi_get_overloaded_macro2(_1, _2, name, ...) name
 
#define ssizeof(x) (static_cast<ssize_t>(sizeof(x)))
 
#define hi_assert_abort(...) \
    do { \
        ::hi::set_debug_message(__FILE__ ":" hi_stringify(__LINE__) ":" __VA_ARGS__); \
        hi_assert_break(); \
    } while (false)
 
#define hi_check(expression, message, ...) \
    do { \
        if (not(expression)) { \
            if constexpr (__VA_OPT__(not ) false) { \
                throw parse_error(std::format(message __VA_OPT__(, ) __VA_ARGS__)); \
            } else { \
                throw parse_error(message); \
            } \
        } \
    } while (false)
 
#define hi_check_bounds(x, ...) \
    do { \
        if (not ::hi::bound_check(x, __VA_ARGS__)) { \
            throw parse_error("assert bounds: " hi_stringify(x) " between " hi_for_each(hi_stringify, (__VA_ARGS__))); \
        } \
    } while (false)
 
#define hi_check_subspan(span, offset, ...) \
    [&](auto _hi_check_subspan_span, size_t _hi_check_subspan_offset, auto... _hi_check_subspan_count) { \
        if constexpr (sizeof...(_hi_check_subspan_count) == 0) { \
            if (_hi_check_subspan_offset < _hi_check_subspan_span.size()) { \
                return _hi_check_subspan_span.subspan(_hi_check_subspan_offset); \
            } \
        } else if constexpr (sizeof...(_hi_check_subspan_count) == 1) { \
            if (_hi_check_subspan_offset + wide_cast<size_t>(_hi_check_subspan_count...) <= _hi_check_subspan_span.size()) { \
                return _hi_check_subspan_span.subspan(_hi_check_subspan_offset, _hi_check_subspan_count...); \
            } \
        } \
        throw parse_error( \
            "assert bounds on: " hi_stringify(span) ".subspan(" hi_stringify(offset __VA_OPT__(", ") __VA_ARGS__) ")"); \
    }(span, offset __VA_OPT__(, ) __VA_ARGS__)
 
#define hi_check_at(span, index) \
    [&](auto _hi_check_subspan_span, size_t _hi_check_subspan_index) { \
        if (_hi_check_subspan_index < _hi_check_subspan_span.size()) { \
            return _hi_check_subspan_span[_hi_check_subspan_index]; \
        } else { \
            throw parse_error("assert bounds on: " hi_stringify(span) "[" hi_stringify(index) "]"); \
        } \
    }(span, index)
 
#define hi_hresult_check(expression) \
    ([](HRESULT result) { \
        if (FAILED(result)) { \
            throw ::hi::io_error(std::format("Call to '{}' failed with {:08x}", #expression, result)); \
        } \
        return result; \
    }(expression))
 
#define hi_assert(expression, ...) \
    do { \
        if (not(expression)) { \
            hi_assert_abort("assert: " __VA_ARGS__ " not (" hi_stringify(expression) ")"); \
        } \
    } 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_assert_abort("assert bounds: " hi_stringify(x) " between " hi_for_each(hi_stringify, (__VA_ARGS__))); \
        } \
    } while (false)
 
#define hi_assert_not_null(x, ...) \
    do { \
        if (x == nullptr) { \
            hi_assert_abort("assert not-null: " __VA_ARGS__ " (" hi_stringify(x) ")"); \
        } \
    } while (false)
 
#ifndef NDEBUG
#define hi_axiom(expression, ...) hi_assert(expression __VA_OPT__(, ) __VA_ARGS__)
#else
#define hi_axiom(expression, ...) hi_assume(expression)
#endif
 
#ifndef NDEBUG
#define hi_axiom_bounds(x, ...) hi_assert_bounds(x, __VA_ARGS__)
#else
#define hi_axiom_bounds(x, ...) hi_assume(not ::hi::bound_check(x, __VA_ARGS__))
#endif
 
#ifndef NDEBUG
#define hi_axiom_not_null(expression, ...) hi_assert_not_null(expression __VA_OPT__(, ) __VA_ARGS__)
#else
#define hi_axiom_not_null(expression, ...) hi_assume(expression != nullptr)
#endif
 
#ifndef NDEBUG
#define hi_no_default(...) \
    [[unlikely]] hi_assert_abort("Reached no-default:" __VA_ARGS__); \
    std::terminate()
#else
#define hi_no_default(...) std::unreachable()
#endif
 
#define hi_static_no_default(...) \
    []<bool Flag = false>() \
    { \
        static_assert(Flag, "No default: " __VA_ARGS__); \
    } \
    ()
 
#define hi_not_implemented(...) \
    [[unlikely]] hi_assert_abort("Not implemented: " __VA_ARGS__); \
    std::terminate()
 
#define hi_static_not_implemented(...) hi_static_no_default("Not implemented: " __VA_ARGS__)
 
#define hi_print(fmt, ...) console_output(std::format(fmt __VA_OPT__(, ) __VA_ARGS__))
 
#define hi_format_argument_check(arg) \
    static_assert( \
        ::std::is_default_constructible_v<std::formatter<std::decay_t<decltype(arg)>>>, \
        "std::format, argument '" #arg "' does not have a specialized std::formatter<>.");
 
#define hi_format_check(fmt, ...) \
    static_assert(::hi::format_count(fmt) != -1, "std::format, Unexpected '{' inside argument-format."); \
    static_assert(::hi::format_count(fmt) != -2, "std::format, Unexpected '}' without corresponding '{'."); \
    static_assert(::hi::format_count(fmt) != -3, "std::format, Missing '}' at end of format string."); \
    static_assert( \
        ::hi::format_count(fmt) == hi_num_va_args(__VA_ARGS__), "std::format, invalid number of arguments for format string."); \
    hi_for_each(hi_format_argument_check, __VA_ARGS__)
 
#define hi_log(level, fmt, ...) \
    hi_format_check(fmt __VA_OPT__(, ) __VA_ARGS__); \
    ::hi::log_global.add<level, __FILE__, __LINE__, fmt>(__VA_ARGS__)
 
#define hi_log_debug(fmt, ...) hi_log(::hi::global_state_type::log_debug, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_info(fmt, ...) hi_log(::hi::global_state_type::log_info, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_statistics(fmt, ...) hi_log(::hi::global_state_type::log_statistics, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_trace(fmt, ...) hi_log(::hi::global_state_type::log_trace, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_audit(fmt, ...) hi_log(::hi::global_state_type::log_audit, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_warning(fmt, ...) hi_log(::hi::global_state_type::log_warning, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_error(fmt, ...) hi_log(::hi::global_state_type::log_error, fmt __VA_OPT__(, ) __VA_ARGS__)
#define hi_log_fatal(fmt, ...) \
    hi_log(::hi::global_state_type::log_fatal, fmt __VA_OPT__(, ) __VA_ARGS__); \
    hi_assert_abort(); \
    std::terminate()
 
#define hi_log_info_once(name, fmt, ...) \
    do { \
        if (++::hi::global_counter<name> == 1) { \
            hi_log(::hi::global_state_type::log_info, fmt __VA_OPT__(, ) __VA_ARGS__); \
        } \
    } while (false)
 
#define hi_log_error_once(name, fmt, ...) \
    do { \
        if (++::hi::global_counter<name> == 1) { \
            hi_log(::hi::global_state_type::log_error, fmt __VA_OPT__(, ) __VA_ARGS__); \
        } \
    } while (false)
 
#define hi_num_valid_arguments(ATTRIBUTES, NAME, CHECK_CALLABLE) \
    template<size_t I, typename First, typename... Rest> \
    ATTRIBUTES size_t _ ## NAME() \
    { \
        if constexpr (I > 1) { \
            return _ ## NAME<I - 1, Rest..., First>(); \
        } else if constexpr (I == 1) { \
            return _ ## NAME<0, Rest...>(); \
        } else if constexpr (requires (First &&f, Rest &&...r) { CHECK_CALLABLE(std::forward<First>(f), std::forward<Rest>(r)...); }) { \
            return sizeof...(Rest) + 1; \
        } else if constexpr (sizeof...(Rest)) { \
            return _ ## NAME<sizeof...(Rest) + 1, First, Rest...>(); \
        } else { \
            return 0; \
        } \
    } \
    template<typename... Args> \
    ATTRIBUTES size_t NAME() \
    { \
        if constexpr (sizeof...(Args) != 0) { \
            return _ ## NAME<0, Args...>(); \
        } else { \
            return 0; \
        } \
    }
 
// To use the right arguments, we first need to rotate them before we can
// remove the ones we don't need. Since we can only remove arguments on the left
// side.
#define hi_call_left_arguments(ATTRIBUTES, NAME, CALLABLE) \
    template<size_t N, size_t R, typename First, typename... Rest>\
    ATTRIBUTES auto _ ## NAME(First &&first, Rest &&...rest)\
    {\
        if constexpr (R != 0) { \
            return _ ## NAME<N, R - 1, Rest..., First>(std::forward<Rest>(rest)..., std::forward<First>(first)); \
        } else if constexpr (N != sizeof...(Rest) + 1) {\
            return _ ## NAME<N, 0, Rest...>(std::forward<Rest>(rest)...);\
        } else { \
            return CALLABLE(std::forward<First>(first), std::forward<Rest>(rest)...);\
        }\
    }\
    template<size_t N, typename... Args>\
    ATTRIBUTES auto NAME(Args &&...args)\
    {\
        static_assert(N <= sizeof...(Args)); \
        if constexpr (N == sizeof...(Args)) { \
            return CALLABLE(std::forward<Args>(args)...); \
        } else {\
            return _ ## NAME<N, N, Args...>(std::forward<Args>(args)...); \
        }\
    }
 
#define hi_call_right_arguments(ATTRIBUTES, NAME, CALLABLE) \
    template<size_t Skip>\
    ATTRIBUTES auto NAME()\
    {\
        static_assert(Skip == 0); \
        return CALLABLE();\
    }\
    template<size_t Skip, typename First, typename... Rest>\
    ATTRIBUTES auto NAME(First &&first, Rest &&...rest)\
    {\
        static_assert(Skip <= (sizeof...(Rest) + 1)); \
        if constexpr (Skip != 0) {\
            return NAME<Skip - 1, Rest...>(std::forward<Rest>(rest)...);\
        } else {\
            return CALLABLE(std::forward<First>(first), std::forward<Rest>(rest)...);\
        }\
    }