libhatchet.h

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
// Use minimal C style headers. The std:: namespace may not exist. "You can't
// get there from here."
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#ifndef __wasm__
#if __has_include(<x86intrin.h>)
#include <x86intrin.h>
#elif __has_include(<intrin.h>)
#include <intrin.h>
#endif
#endif
 
#if defined __STDC_VERSION__ && __STDC_VERSION__ < 202311l
#include <stdbool.h>
#endif

#define LIBHATCHET_VER 14904

#define LIBHATCHET_TAG "v1.49.4"
 
#if !defined HX_HARDENING_MODE
#define HX_HARDENING_MODE HX_HARDENING_MODE_DEBUG
#endif

#define HX_HARDENING_MODE_NONE 0
#define HX_HARDENING_MODE_STANDARD 1
#define HX_HARDENING_MODE_VERBOSE 2
#define HX_HARDENING_MODE_DEBUG 3

#if (HX_HARDENING_MODE) < 0 || (HX_HARDENING_MODE) > 3
#error HX_HARDENING_MODE must be [0..3]. See <hx/hxsettings.h>.
#endif
 
#include "hxsettings.h"
#if !(HX_USE_MACROS_WITH_MODULE)
#include "hxmemory_manager.h"
#endif

#define hxinit() (void)(hxg_init_ver_ == LIBHATCHET_VER || (hxinit_internal(LIBHATCHET_VER), 0))
 
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG // These are debug facilities.

#define hxassert(x_) (void)((bool)(x_)   /* THIS IS USED AS A COMPILE TIME ASSERT: */  \
    || (hxlog_handler_(hxlog_level_assert, #x_), hxassert_handler(__FILE__, __LINE__)) \
    || hxbreakpoint())

#define hxassertmsg(x_, ...) (void)((bool)(x_)    /* THIS IS USED AS A COMPILE TIME ASSERT: */ \
    || (hxlog_handler_(hxlog_level_assert, __VA_ARGS__), hxassert_handler(__FILE__, __LINE__)) \
    || hxbreakpoint())

#define hxassert_hard(x_, ...) (void)((bool)(x_) /* THIS IS USED AS A COMPILE TIME ASSERT: */  \
    || (hxlog_handler_(hxlog_level_assert, __VA_ARGS__), hxassert_handler(__FILE__, __LINE__)) \
    || hxbreakpoint())

#define hxassert_always(x_, ...) (void)((bool)(x_) /* THIS IS USED AS A COMPILE TIME ASSERT: */ \
    || (hxlog_handler_(hxlog_level_assert, __VA_ARGS__), hxassert_handler(__FILE__, __LINE__))  \
    || hxbreakpoint())
 
#else // HX_HARDENING_MODE != HX_HARDENING_MODE_DEBUG
#define hxassertmsg(x_, ...) ((void)0)
#define hxassert(x_) ((void)0)
#define hxassert_always(x_, ...) (void)((bool)(x_) \
    || (hxassert_handler(), 0)) // THIS IS USED AS A COMPILE TIME ASSERT.
 
#endif // HX_HARDENING_MODE != HX_HARDENING_MODE_DEBUG
 
#if (HX_USE_LOGGING) > 1
#define hxlog(...) hxlog_handler(hxlog_level_log, __VA_ARGS__)
#else
#define hxlog(...) ((void)0)
#endif
 
#if HX_USE_LOGGING
#define hxlog_release(...) hxlog_handler(hxlog_level_log, __VA_ARGS__)

#define hxlog_console(...) hxlog_handler(hxlog_level_console, __VA_ARGS__)

#define hxlog_warning(...) hxlog_handler(hxlog_level_warning, __VA_ARGS__)

#define hxwarn_msg(x_, ...) (void)((bool)(x_) \
    || (hxlog_handler(hxlog_level_warning, __VA_ARGS__), 0))
 
#else // !HX_USE_LOGGING
#define hxlog_release(...) ((void)0)
#define hxlog_console(...) ((void)0)
#define hxlog_warning(...) ((void)0)
#define hxwarn_msg(x_, ...) ((void)0)
#endif // !HX_USE_LOGGING
 
// hxassert_hard has 4 variations. See above. It is only evaluated when
// HX_HARDENING_MODE != HX_HARDENING_MODE_NONE.
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_VERBOSE
#define hxassert_hard(x_, ...) (void)((bool)(x_)         \
    || (hxlog_handler_(hxlog_level_assert, __VA_ARGS__), \
        hxassert_handler(), 0)) // THIS IS USED AS A COMPILE TIME ASSERT.
#elif (HX_HARDENING_MODE) == HX_HARDENING_MODE_STANDARD
#define hxassert_hard(x_, ...) (void)((bool)(x_) \
    || (hxassert_handler(), 0)) // THIS IS USED AS A COMPILE TIME ASSERT.
#elif (HX_HARDENING_MODE) == HX_HARDENING_MODE_NONE
#define hxassert_hard(x_, ...) ((void)0)
#endif
 
#if !(HX_USE_MACROS_WITH_MODULE)
#if HX_CPLUSPLUS
extern "C" {
#endif

enum hxlog_level_t {
    hxlog_level_log,
    hxlog_level_console,
    hxlog_level_warning,
    hxlog_level_assert
};

typedef ptrdiff_t hxsize_t;

typedef uint32_t hxhash_t;

typedef uint64_t hxhandle_t;

void hxinit_internal(int version_) hxattr_cold;

// `hxg_init_ver_` - Internal. Set to the current library version by `hxinit`.
// It is zero when the platform has not been initialized.
extern int hxg_init_ver_;

void hxshutdown(void) hxattr_cold;
 
#if (HX_HARDENING_MODE) == HX_HARDENING_MODE_DEBUG
bool hxassert_handler(const char* file_, size_t line_) hxattr_noexcept hxattr_nonnull(1) hxattr_cold;
#else // HX_HARDENING_MODE != HX_HARDENING_MODE_DEBUG
// Errors from consteval code calling this function are how you know a compile
// time assert has been hit. hxattr_cold tells the compiler this call is
// unlikely.
// WARNING: THIS IS USED AS A COMPILE TIME ASSERT.
void hxassert_handler(void) hxattr_noexcept hxattr_cold;
#endif

void hxset_assert_handler(bool (*handler_)(void)) hxattr_noexcept;

void hxlog_handler(enum hxlog_level_t level_, const char* format_, ...) hxattr_noexcept hxattr_printf(2, 3);

void hxlog_handler_v(enum hxlog_level_t level_, const char* format_, va_list args_) hxattr_noexcept hxattr_nonnull(2);

hxattr_noreturn void hxexit(int status_) hxattr_noexcept hxattr_cold;
 
#if HX_CPLUSPLUS
} // extern "C"
#endif
#endif // !HX_USE_MACROS_WITH_MODULE

#define hxnull 0
 
#if HX_CPLUSPLUS
#if !(HX_USE_MACROS_WITH_MODULE)
hxinline_constexpr hxhash_t hxhash_bits = 32u;

hxinline_constexpr hxhandle_t hxnull_handle = 0u;

template<typename T_> constexpr hxsize_t hxsizeof(void) { return static_cast<hxsize_t>(sizeof(T_)); }
template<typename T_> constexpr hxsize_t hxsizeof(T_&) { return static_cast<hxsize_t>(sizeof(T_)); }
#endif // !HX_USE_MACROS_WITH_MODULE
#else
#define hxhash_bits 32u
#define hxnull_handle 0u
#define hxsizeof(x) (hxsize_t)sizeof(x)
#endif

// WARNING: gcc version 13 was reporting the wrong __cplusplus for C++23.
#if HX_CPLUSPLUS >= 202302L
#if !(HX_USE_MACROS_WITH_MODULE)
// This allows hxassert_handler and hxlog_handler to be used by compile time
// asserts in C++23.
hxattr_noexcept constexpr void hxlog_handler_(enum hxlog_level_t level_, const char* format_, ...) {
    if !consteval {
        va_list args_;
        va_start(args_, format_);
        hxlog_handler_v(level_, format_, args_);
        va_end(args_);
    }
}
#endif // !HX_USE_MACROS_WITH_MODULE
#else // HX_CPLUSPLUS < 202302L
// Disable the compile time version of hxlog_handler_.
#define hxlog_handler_ hxlog_handler
#endif // HX_CPLUSPLUS < 202302L