asserted.h

// The MIT License (MIT)
//
// Copyright(c) 2025, Damien Feneyrou <dfeneyrou@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#pragma once

// 'asserted' is a library making a trade-off between weight and features.
// It rather places itself on the light side while bringing much needed features and ease C++ development.
//
// Features:
// - Context display via variable content
// - Stacktrace dump (requires libunwind to build on Linux, and addr2line at run time for symbol resolution)
// - Signals override to catch crashes
// - Compile-time enabling of group of assertions
// - No "unused variable" when assertions are disabled
// - Single header
// - Linux & Windows support

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4996)  // Disable Windows's secure API warnings
#endif

//-----------------------------------------------------------------------------
// Library configuration
//-----------------------------------------------------------------------------

// The 3 main switches are:
// - ASSERTED_NO_ASSERT  set to 1 to disable the assertions at compile time. They are enabled by default.
// - ASSERTED_NO_SIGNALS set to 1 to disable the signal catching. Catching is enabled by default.
// - ASSERTED_WITH_STACKTRACE set to 1 to enable the stacktrace dump. Disabled by default, due to dependencies

// Disable assertions
#ifndef ASSERTED_NO_ASSERT
#define ASSERTED_NO_ASSERT 0
#endif

// Disable installing signal handlers (ABRT, FPE, ILL, SEGV, TERM and INT (if ASSERTED_NO_SIGINT is 0) )
#ifndef ASSERTED_NO_SIGNALS
#define ASSERTED_NO_SIGNALS 0
#endif

// Disable catching the SIGINT signal (N/A if ASSERTED_NO_SIGNALS==1). Signal is enabled by default
#ifndef ASSERTED_NO_SIGINT
#define ASSERTED_NO_SIGINT 0
#endif

// Disable automatically breaking into an attached debugger when a crash occurs, right before the process would
// otherwise exit. Independent of ASSERTED_NO_SIGNALS: a plain failed assertion reaches this too, not just a
// caught signal. Enabled by default. Always a no-op when no debugger is attached - see isDebuggerPresent_() below.
#ifndef ASSERTED_NO_DEBUG_BREAK
#define ASSERTED_NO_DEBUG_BREAK 0
#endif

// Display messages using terminal colors. Enabled by default.
#ifndef ASSERTED_NO_COLOR
#define ASSERTED_NO_COLOR 0
#endif
#if ASSERTED_NO_COLOR == 1
#define ASSERTED_COLOR_RED      ""
#define ASSERTED_COLOR_BLUE     ""
#define ASSERTED_COLOR_NUMBER   ""
#define ASSERTED_COLOR_FUNCTION ""
#define ASSERTED_COLOR_RESET    ""
#else
#define ASSERTED_COLOR_RED      "\033[31m"
#define ASSERTED_COLOR_BLUE     "\033[34m"
#define ASSERTED_COLOR_NUMBER   "\033[93m"
#define ASSERTED_COLOR_FUNCTION "\033[36m"
#define ASSERTED_COLOR_RESET    "\033[0m"
#endif

// Stacktrace logging when a crash occurs
//   - On Linux, stack trace logging is disabled by default. It requires libunwind.so (stack unwinding) to build:
//     install with "apt install libunwind-dev". Resolving addresses into function names and file:line is done at
//     run time by spawning 'addr2line' (part of binutils), rather than by linking a DWARF-reading library into
//     the process: see ASSERTED_ADDR2LINE_BIN below. If 'addr2line' is not installed or not on $PATH when a crash
//     happens, frames are still printed, just as raw addresses.
//   - On Windows, stacktrace logging is enabled by default as base system libraries cover the requirements.
//   Note: The executable shall contain debug information for file:line to resolve; function names, on Linux,
//         resolve from the symbol table regardless (unless the binary is fully stripped of it too).
#if defined(_MSC_VER) && !defined(ASSERTED_WITH_STACKTRACE)
#define ASSERTED_WITH_STACKTRACE 1
#endif
#ifndef ASSERTED_WITH_STACKTRACE
#define ASSERTED_WITH_STACKTRACE 0
#endif

// Exit function when a crash occurs, called after displaying the crash information. Default is a call to quick_exit().
// Note: it is declared [[noreturn]]-equivalent internally, so a replacement MUST NOT return to its caller.
#ifndef ASSERTED_CRASH_EXIT_FUNC
#define ASSERTED_CRASH_EXIT_FUNC() quick_exit(1)
#endif

// Error display function. On Windows, it shall probably be redirected on a MessageBox
#ifndef ASSERTED_MESSAGE
#define ASSERTED_MESSAGE(msg, isLastFromCrash) fprintf(stderr, "%s", msg)
#endif

// Size in bytes of the alternate signal stack used on Linux/Unix so that a SIGSEGV caused by stack overflow still
// has room to run the crash handler and, when ASSERTED_WITH_STACKTRACE=1, capture the raw addresses and spawn
// addr2line (see ASSERTED_ADDR2LINE_BIN below) - the bulk of the stacktrace machinery's own scratch buffers are
// static rather than on-stack precisely so this doesn't need to be large. The virtual memory cost of leaving this
// generous is negligible: unless actually used, the extra pages are never committed.
#ifndef ASSERTED_ALT_STACK_SIZE
#define ASSERTED_ALT_STACK_SIZE (256 * 1024)
#endif

// Binary used on Linux/Unix to resolve captured addresses into function names and file:line, when
// ASSERTED_WITH_STACKTRACE=1. Looked up via $PATH (or pass an absolute path to bypass that). Unlike libdw, which
// used to be called in-process here, this is a run-time dependency: it does not need to be present at build
// time, but does need to be reachable on whichever machine the crash actually happens on. If it isn't installed,
// or fails for any reason, resolution falls back to raw addresses - the same degradation already used for
// addresses that can't be resolved at all.
#ifndef ASSERTED_ADDR2LINE_BIN
#define ASSERTED_ADDR2LINE_BIN "addr2line"
#endif

// Library version
#define ASSERTED_VERSION     "0.1.0"
#define ASSERTED_VERSION_NUM 100  // Monotonic number. 100 per version component. Official releases are multiple of 100

#define ASSERTED_IS_ENABLED (ASSERTED_NO_SIGNALS == 0 || ASSERTED_NO_ASSERT == 0)
#ifndef ASSERTED_CRASH_MSG_SIZE
#define ASSERTED_CRASH_MSG_SIZE 2048
#endif

//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------

#if ASSERTED_IS_ENABLED

// Windows base header (hard to avoid this include...)
#if defined(_MSC_VER)
#define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff from Windows headers. If it is a problem, just comment it
#include <windows.h>

#include <cinttypes>
#include <cstdint>
#if ASSERTED_NO_DEBUG_BREAK == 0
#include <debugapi.h>  // For IsDebuggerPresent()
#endif
#endif

#include <cstdio>   // For snprintf etc...
#include <cstdlib>  // For abort(), quick_exit...
#include <cstring>  // For memset

#if ASSERTED_NO_ASSERT == 0
#include <string>       // For the std::string display handler
#include <type_traits>  // For the enum display handler
#endif

#if ASSERTED_NO_SIGNALS == 0 || (defined(__unix__) && ASSERTED_NO_DEBUG_BREAK == 0)
#include <csignal>  // For raising signals in crash handler, and/or SIGTRAP (debugger-break feature on Linux/Unix)
#endif

#if defined(__unix__) && ASSERTED_NO_DEBUG_BREAK == 0
#include <fcntl.h>   // For open() - detecting an attached debugger via /proc/self/status
#include <unistd.h>  // For read(), close()
#endif

#if ASSERTED_WITH_STACKTRACE == 1

#if defined(__unix__)
#define UNW_LOCAL_ONLY
#include <fcntl.h>      // For open()
#include <libunwind.h>  // Stack unwinding (need package libunwind-dev)
#include <sys/wait.h>   // For waitpid()
#include <unistd.h>     // For fork(), execvp(), pipe(), dup2(), read(), close(), _exit()

#include <cstdint>  // For uintptr_t
#endif              // if defined(__unix__)

#if defined(_MSC_VER)
#include <dbghelp.h>         // For the symbol decoding
#include <errhandlingapi.h>  // For the HW exceptions
#pragma comment(lib, "DbgHelp.lib")
#endif  // if defined(_MSC_VER)

#endif  // if ASSERTED_WITH_STACKTRACE==1

#endif  // if ASSERTED_IS_ENABLED

// This line below is unfortunately the only way found to remove the zero-arguments-variadic-macro and
// the prohibited-anonymous-structs warnings with GCC when the build is using the option -Wpedantic
#ifndef _MSC_VER
#pragma GCC system_header
#endif

//-----------------------------------------------------------------------------
// Public assertion API. Macro-based due to compile-time removal cosntraint
//-----------------------------------------------------------------------------

// Macros to handle disabled assertions. Up to 10 parameters
#define ASSERTED_PRIV_UNUSED0()
#define ASSERTED_PRIV_UNUSED1(a)                             (void)(a)
#define ASSERTED_PRIV_UNUSED2(a, b)                          (void)(a), ASSERTED_PRIV_UNUSED1(b)
#define ASSERTED_PRIV_UNUSED3(a, b, c)                       (void)(a), ASSERTED_PRIV_UNUSED2(b, c)
#define ASSERTED_PRIV_UNUSED4(a, b, c, d)                    (void)(a), ASSERTED_PRIV_UNUSED3(b, c, d)
#define ASSERTED_PRIV_UNUSED5(a, b, c, d, e)                 (void)(a), ASSERTED_PRIV_UNUSED4(b, c, d, e)
#define ASSERTED_PRIV_UNUSED6(a, b, c, d, e, f)              (void)(a), ASSERTED_PRIV_UNUSED5(b, c, d, e, f)
#define ASSERTED_PRIV_UNUSED7(a, b, c, d, e, f, g)           (void)(a), ASSERTED_PRIV_UNUSED6(b, c, d, e, f, g)
#define ASSERTED_PRIV_UNUSED8(a, b, c, d, e, f, g, h)        (void)(a), ASSERTED_PRIV_UNUSED7(b, c, d, e, f, g, h)
#define ASSERTED_PRIV_UNUSED9(a, b, c, d, e, f, g, h, i)     (void)(a), ASSERTED_PRIV_UNUSED8(b, c, d, e, f, g, h, i)
#define ASSERTED_PRIV_UNUSED10(a, b, c, d, e, f, g, h, i, j) (void)(a), ASSERTED_PRIV_UNUSED9(b, c, d, e, f, g, h, i, j)

#define ASSERTED_PRIV_VA_NUM_ARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define ASSERTED_PRIV_VA_NUM_ARGS(...)        ASSERTED_PRIV_VA_NUM_ARGS_IMPL(100, ##__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define ASSERTED_PRIV_ALL_UNUSED_IMPL_(nargs) ASSERTED_PRIV_UNUSED##nargs
#define ASSERTED_PRIV_ALL_UNUSED_IMPL(nargs)  ASSERTED_PRIV_ALL_UNUSED_IMPL_(nargs)
// Note: the whole chain is wrapped in a never-taken "if(false)" (not a bare (void)-cast expression) so that the
// arguments are referenced (silencing "unused variable" warnings) without ever being evaluated at runtime, even
// at -O0. This matters when an argument is a function call or has other side effects: unlike a (void)-cast, which
// still evaluates its operand and only discards the result, a dead branch is simply never executed.
#define ASSERTED_PRIV_ALL_UNUSED(...)                                                           \
    do {                                                                                        \
        if (false) {                                                                            \
            ASSERTED_PRIV_ALL_UNUSED_IMPL(ASSERTED_PRIV_VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__); \
        }                                                                                       \
    } while (0)

// These assertions allow to easily dump the values which contribute to the condition.
// Ex: asserted(a<b);                                         // Standard form
//     asserted(a<b, "A shall always be less than b");        // Documented form
//     asserted(a<b, a, b);                                   // Extended form showing the values of 'a' and 'b' when assertion is failed
//     asserted(a<b, "A shall always be less than b", a, b);  // Displays up to 9 parameters... Ought to be enough for anybody (tm)
#if ASSERTED_NO_ASSERT == 0

// Macro to stringify the additional parameters of the enhanced assertions. Up to 10 parameters
// Note: in C99 and C++11, zero parameter is a problem, hence the forced & dummy first parameter "".
#define ASSERTED_PRIV_ASSERT_PARAM0()                           nullptr, 0
#define ASSERTED_PRIV_ASSERT_PARAM1(v1)                         nullptr, 0
#define ASSERTED_PRIV_ASSERT_PARAM2(v1, v2)                     nullptr, 0, #v2, v2
#define ASSERTED_PRIV_ASSERT_PARAM3(v1, v2, v3)                 nullptr, 0, #v2, v2, #v3, v3
#define ASSERTED_PRIV_ASSERT_PARAM4(v1, v2, v3, v4)             nullptr, 0, #v2, v2, #v3, v3, #v4, v4
#define ASSERTED_PRIV_ASSERT_PARAM5(v1, v2, v3, v4, v5)         nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5
#define ASSERTED_PRIV_ASSERT_PARAM6(v1, v2, v3, v4, v5, v6)     nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5, #v6, v6
#define ASSERTED_PRIV_ASSERT_PARAM7(v1, v2, v3, v4, v5, v6, v7) nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5, #v6, v6, #v7, v7
#define ASSERTED_PRIV_ASSERT_PARAM8(v1, v2, v3, v4, v5, v6, v7, v8) \
    nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5, #v6, v6, #v7, v7, #v8, v8
#define ASSERTED_PRIV_ASSERT_PARAM9(v1, v2, v3, v4, v5, v6, v7, v8, v9) \
    nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5, #v6, v6, #v7, v7, #v8, v8, #v9, v9
#define ASSERTED_PRIV_ASSERT_PARAM10(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) \
    nullptr, 0, #v2, v2, #v3, v3, #v4, v4, #v5, v5, #v6, v6, #v7, v7, #v8, v8, #v9, v9, #v10, v10

#define asserted(cond_, ...)                                                  \
    if (ASSERTED_UNLIKELY(!(cond_)))                                          \
    assertedPriv::failedAssert(__FILE__, __LINE__, ASSERTED_FUNCTION, #cond_, \
                               ASSERTED_PRIV_CALL_OVERLOAD(ASSERTED_PRIV_ASSERT_PARAM, "", ##__VA_ARGS__))
#define group_asserted(group_, cond_, ...) \
    ASSERTED_PRIV_IF(ASSERTED_IS_COMPILE_TIME_ENABLED_(group_), asserted(cond_, ##__VA_ARGS__), do {} while (0))

#ifdef NDEBUG
#define debug_asserted(...) ASSERTED_PRIV_ALL_UNUSED(__VA_ARGS__)
#else
#define debug_asserted(...) asserted(__VA_ARGS__)
#endif

#else  // if ASSERTED_NO_ASSERT == 0

#define asserted(...)              ASSERTED_PRIV_ALL_UNUSED(__VA_ARGS__)
#define group_asserted(group, ...) ASSERTED_PRIV_ALL_UNUSED(__VA_ARGS__)
#define debug_asserted(...)        ASSERTED_PRIV_ALL_UNUSED(__VA_ARGS__)

#endif  // if ASSERTED_NO_ASSERT==0

//-----------------------------------------------------------------------------
// Macro helpers
//-----------------------------------------------------------------------------

// Optimization of the branching
#if defined(__GNUC__) || defined(__clang__)
#define ASSERTED_LIKELY(x)   (__builtin_expect(!!(x), 1))
#define ASSERTED_UNLIKELY(x) (__builtin_expect(!!(x), 0))
#define ASSERTED_NOINLINE    __attribute__((noinline))
#define ASSERTED_NORETURN    __attribute__((__noreturn__))
#else
#define ASSERTED_LIKELY(x)   (x)
#define ASSERTED_UNLIKELY(x) (x)
#define ASSERTED_NOINLINE
#define ASSERTED_NORETURN
#endif

// Best possible function name for assertions
#if defined(__GNUC__) || defined(__clang__)
#define ASSERTED_FUNCTION __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
#define ASSERTED_FUNCTION __FUNCSIG__
#else
#define ASSERTED_FUNCTION __func__
#endif

// Conditional inclusion macro trick
#define ASSERTED_PRIV_IF(cond, foo1, foo2)       ASSERTED_PRIV_IF_IMPL(cond, foo1, foo2)
#define ASSERTED_PRIV_IF_IMPL(cond, foo1, foo2)  ASSERTED_PRIV_IF_IMPL2(cond, foo1, foo2)
#define ASSERTED_PRIV_IF_IMPL2(cond, foo1, foo2) ASSERTED_PRIV_IF_##cond(foo1, foo2)
#define ASSERTED_PRIV_IF_0(foo1, foo2)           foo2
#define ASSERTED_PRIV_IF_1(foo1, foo2)           foo1

// Variadic macro trick (from 0 up to 10 arguments)
#define ASSERTED_PRIV_EXPAND(x)                                         x
#define ASSERTED_PRIV_PREFIX(...)                                       0, ##__VA_ARGS__
#define ASSERTED_PRIV_LASTOF12(a, b, c, d, e, f, g, h, i, j, k, l, ...) l
#define ASSERTED_PRIV_SUB_NBARG(...) ASSERTED_PRIV_EXPAND(ASSERTED_PRIV_LASTOF12(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
#define ASSERTED_PRIV_NBARG(...)     ASSERTED_PRIV_SUB_NBARG(ASSERTED_PRIV_PREFIX(__VA_ARGS__))
#define ASSERTED_PRIV_GLUE(x, y)     x y
#define ASSERTED_PRIV_OVERLOAD_MACRO2(name, count) name##count
#define ASSERTED_PRIV_OVERLOAD_MACRO1(name, count) ASSERTED_PRIV_OVERLOAD_MACRO2(name, count)
#define ASSERTED_PRIV_OVERLOAD_MACRO(name, count)  ASSERTED_PRIV_OVERLOAD_MACRO1(name, count)
#define ASSERTED_PRIV_CALL_OVERLOAD(name, ...) \
    ASSERTED_PRIV_GLUE(ASSERTED_PRIV_OVERLOAD_MACRO(name, ASSERTED_PRIV_NBARG(__VA_ARGS__)), (__VA_ARGS__))

#define ASSERTED_IS_COMPILE_TIME_ENABLED_(group_) ASSERTED_GROUP_##group_

//-----------------------------------------------------------------------------
// Private implementation
//-----------------------------------------------------------------------------

#if ASSERTED_IS_ENABLED

// Tags assertedPriv's content with the configuration macros that affect its struct layouts and code paths
// (ASSERTED_NO_ASSERT, ASSERTED_NO_SIGNALS, ASSERTED_NO_SIGINT, ASSERTED_NO_DEBUG_BREAK, ASSERTED_WITH_STACKTRACE,
// ASSERTED_NO_COLOR). If two translation units in the same binary are built with different values for these -
// which the README warns against but nothing previously prevented - this makes their content live under distinct,
// non-colliding mangled names instead of silently violating the One Definition Rule (e.g. two different
// GlobalContext layouts sharing one symbol, with whichever definition the linker happens to keep used by every TU).
#define ASSERTED_PRIV_CAT2_(a, b) a##b
#define ASSERTED_PRIV_CAT_(a, b)  ASSERTED_PRIV_CAT2_(a, b)
#define ASSERTED_PRIV_CFG_TAG_                                                                                                             \
    ASSERTED_PRIV_CAT_(                                                                                                                    \
        cfg, ASSERTED_PRIV_CAT_(                                                                                                           \
                 ASSERTED_NO_ASSERT,                                                                                                       \
                 ASSERTED_PRIV_CAT_(ASSERTED_NO_SIGNALS,                                                                                   \
                                    ASSERTED_PRIV_CAT_(ASSERTED_NO_SIGINT, ASSERTED_PRIV_CAT_(ASSERTED_NO_DEBUG_BREAK,                     \
                                                                                              ASSERTED_PRIV_CAT_(ASSERTED_WITH_STACKTRACE, \
                                                                                                                 ASSERTED_NO_COLOR))))))

namespace assertedPriv
{
inline namespace ASSERTED_PRIV_CFG_TAG_
{

// Break inside this function in debugger
void ASSERTED_NORETURN
assertedCrash(const char* message);

#if ASSERTED_NO_ASSERT == 0

// Accumulates a snprintf() return value into offset, clamped to a valid [0, ASSERTED_CRASH_MSG_SIZE-1] range.
// snprintf() returns the length it *would* have written (which can exceed the buffer), or a negative value on an
// encoding error; either way, blindly adding it to offset could push it out of bounds and make a later
// `infoStr + offset` / `(size_t)(ASSERTED_CRASH_MSG_SIZE - offset)` under/overflow.
inline void
advanceOffset_(int& offset, int written)
{
    if (written > 0) offset += written;
    if (offset > ASSERTED_CRASH_MSG_SIZE - 1) offset = ASSERTED_CRASH_MSG_SIZE - 1;
    if (offset < 0) offset = 0;
}

// Declared here (the specializations/overloads below need it declared first) but defined only after them - see
// the definition further down for why.
template<typename T>
inline void
printParamType_(char* infoStr, int& offset, const char* name, T param);

template<typename T>
inline void
printParamType_(char* infoStr, int& offset, const char* name, T* param)
{
    advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                    "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%p\n" ASSERTED_COLOR_RESET, "pointer", name, (void*)param));
}
template<>
inline void
printParamType_<std::string>(char* infoStr, int& offset, const char* name, std::string param)
{
    advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                    "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "string", name, param.c_str()));
}
template<>
inline void
printParamType_<bool>(char* infoStr, int& offset, const char* name, bool param)
{
    advanceOffset_(
        offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                         "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "bool", name, param ? "true" : "false"));
}
template<>
inline void
printParamType_<char>(char* infoStr, int& offset, const char* name, char* param)
{
    // The stringified token of a string literal always starts with '"' (e.g. #v for `"text"` is `"\"text\""`),
    // whereas the stringified token of an identifier never does. This tells apart the optional leading message
    // (a literal, shown unlabeled) from a genuine named char*/const char* context variable (shown with its name,
    // like the std::string case above), even though both share the exact same runtime type.
    if (name && name[0] == '"') {
        advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                        "    %-28s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "message", param));
    } else {
        advanceOffset_(
            offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                             "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "string", name ? name : "?", param));
    }
}
template<>
inline void
printParamType_<const char>(char* infoStr, int& offset, const char* name, const char* param)
{
    if (name && name[0] == '"') {
        advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                        "    %-28s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "message", param));
    } else {
        advanceOffset_(
            offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                             "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_RESET, "string", name ? name : "?", param));
    }
}
#define ASSERTED_DECLARE_ASSERT_TYPE(type_, code_, display_)                                                                               \
    template<>                                                                                                                             \
    inline void printParamType_<type_>(char* infoStr, int& offset, const char* name, type_ param)                                          \
    {                                                                                                                                      \
        advanceOffset_(offset,                                                                                                             \
                       snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),                                              \
                                "    %-7s %-20s => " ASSERTED_COLOR_NUMBER "%" #code_ "\n" ASSERTED_COLOR_RESET, #display_, name, param)); \
    }

ASSERTED_DECLARE_ASSERT_TYPE(char, d, s8)
ASSERTED_DECLARE_ASSERT_TYPE(unsigned char, u, u8)
ASSERTED_DECLARE_ASSERT_TYPE(short int, d, s16)
ASSERTED_DECLARE_ASSERT_TYPE(unsigned short, u, u16)
ASSERTED_DECLARE_ASSERT_TYPE(int, d, int)
ASSERTED_DECLARE_ASSERT_TYPE(unsigned int, u, u32)
ASSERTED_DECLARE_ASSERT_TYPE(long, ld, s64)
ASSERTED_DECLARE_ASSERT_TYPE(unsigned long, lu, u64)
ASSERTED_DECLARE_ASSERT_TYPE(long long, lld, s64)
ASSERTED_DECLARE_ASSERT_TYPE(unsigned long long, llu, u64)
ASSERTED_DECLARE_ASSERT_TYPE(float, f, float)
ASSERTED_DECLARE_ASSERT_TYPE(double, lf, double)

// Fallback for every type without a dedicated overload above. Defined only now (rather than alongside the other
// overloads) so that, for an enum, the recursive call below to the underlying integer type's own overload is
// visible via ordinary lookup and actually dispatches to one of the numeric printers declared just above, instead
// of recursing back into this same fallback.
template<typename T>
inline void
printParamType_(char* infoStr, int& offset, const char* name, T param)
{
    if constexpr (std::is_enum_v<T>) {
        printParamType_(infoStr, offset, name, static_cast<std::underlying_type_t<T>>(param));
    } else {
        advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                        "    %s is not a numeric or string type\n", name));
        (void)(param);
    }
}

template<typename T>
inline void
printParams_(bool isFirst, char* infoStr, int& offset, const char* name, T param)
{
    if (isFirst) {
        advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                        ASSERTED_COLOR_BLUE "  Context:\n" ASSERTED_COLOR_RESET));
    }
    if (name) {
        printParamType_(infoStr, offset, name, param);
    }
}
template<typename T, typename... Args>
inline void
printParams_(bool isFirst, char* infoStr, int& offset, const char* name, T value, Args... args)
{
    if (isFirst) {
        advanceOffset_(offset, snprintf(infoStr + offset, (size_t)(ASSERTED_CRASH_MSG_SIZE - offset),
                                        ASSERTED_COLOR_BLUE "  Context:\n" ASSERTED_COLOR_RESET));
    }
    if (name) {
        printParamType_(infoStr, offset, name, value);
    }
    printParams_(false, infoStr, offset, args...);
}

// Variadic template based assertion display
template<typename... Args>
void ASSERTED_NOINLINE ASSERTED_NORETURN
failedAssert(const char* filename, int lineNbr, const char* function, const char* condition, Args... args)
{
    char infoStr[ASSERTED_CRASH_MSG_SIZE];
    int  offset = 0;
    advanceOffset_(offset, snprintf(infoStr, sizeof(infoStr),
                                    ASSERTED_COLOR_RED "[ASSERTED] Assertion failed: " ASSERTED_COLOR_NUMBER "%s\n" ASSERTED_COLOR_BLUE
                                                       "  Where:\n" ASSERTED_COLOR_RESET "    Function => " ASSERTED_COLOR_FUNCTION
                                                       "%s\n" ASSERTED_COLOR_RESET "    File     => " ASSERTED_COLOR_FUNCTION
                                                       "%s:" ASSERTED_COLOR_NUMBER "%d\n" ASSERTED_COLOR_RESET,
                                    condition, function, filename, lineNbr));
    printParams_(true, infoStr, offset, args...);  // Recursive display of provided items
    assertedCrash(infoStr);
}

#endif  // if ASSERTED_NO_ASSERT==0

#if defined(_MSC_VER) && ASSERTED_WITH_STACKTRACE == 1
extern "C" {
typedef unsigned long(__stdcall* rtlWalkFrameChain_t)(void**, unsigned long, unsigned long);
}
#endif

typedef void (*assertedSignalHandler_t)(int);

inline struct GlobalContext {
    bool signalHandlersSaved = false;
#if ASSERTED_NO_SIGNALS == 0 && defined(__unix__)
    struct sigaction signalsOldHandlers[7] = {};
    void*            altStackMemory        = nullptr;  // Alternate signal stack, to survive SIGSEGV from stack overflow
    stack_t          altStackOld           = {};
#if ASSERTED_NO_DEBUG_BREAK == 0
    struct sigaction debugBreakOldHandler   = {};  // Defensive fallback SIGTRAP handler, see maybeBreakIntoDebugger_()
    bool             debugBreakHandlerSaved = false;
#endif
#else
    assertedSignalHandler_t signalsOldHandlers[7] = {0};
#endif
#if defined(_MSC_VER)
    PVOID exceptionHandler = 0;
#if ASSERTED_WITH_STACKTRACE == 1
    rtlWalkFrameChain_t rtlWalkFrameChain = 0;
#endif
#endif                         // if defined(_MSC_VER)
    volatile int inCrash = 0;  // Reentrancy guard: set once a crash starts being handled, see assertedCrash()
} gc;

#if ASSERTED_WITH_STACKTRACE == 1

#if defined(__unix__)
// Linux/Unix version.
//
// Only libunwind is used in-process, to capture raw return addresses - no DWARF reading, no demangling, no
// allocation. Turning those addresses into function names and file:line is done out-of-process, by spawning
// ASSERTED_ADDR2LINE_BIN (see its definition above): calling into libdw/__cxa_demangle directly from a signal
// handler, as an earlier version of this file did, risks a deadlock or worse if the thread that faulted was
// itself inside malloc() at the time (e.g. a crash caused by heap corruption), since both call it internally.
//
// fork() and the whole exec() family are POSIX async-signal-safe, and are the only two "risky-sounding" calls
// used here. Critically, argv is built entirely by the parent *before* forking, so the forked child does nothing
// beyond dup2()/close()/execvp() - also async-signal-safe - before its image is replaced outright by exec(), or
// it _exit()s if that failed: it never reuses the (possibly broken) inherited allocator state, which is what
// actually makes this safe, unlike the previous in-process approach. The /proc/self/maps parsing in between uses
// only open()/read()/close() plus plain string/number parsing (no stdio buffering, no allocation) - not
// officially on the async-signal-safe list, but with no shared/lockable state of their own, which is the
// specific hazard being avoided here.

// Describes one file-backed, executable mapping found in /proc/self/maps.
struct MappedModule_ {
    uintptr_t start     = 0;
    uintptr_t end       = 0;
    uintptr_t bias      = 0;  // This mapping's start address minus its offset inside the backing file
    char      path[192] = {0};
};

// Parses one already null-terminated "/proc/self/maps" line. Returns true and fills *outModule if it describes a
// file-backed executable mapping - the only kind that can contain a return address addr2line can resolve.
inline bool
parseMapsLine_(const char* line, MappedModule_& outModule)
{
    char*              endp  = nullptr;
    unsigned long long start = strtoull(line, &endp, 16);
    if (endp == line || *endp != '-') return false;
    const char*        p   = endp + 1;
    unsigned long long end = strtoull(p, &endp, 16);
    if (endp == p) return false;
    p = endp;
    while (*p == ' ') ++p;
    const char* perms = p;
    while (*p && *p != ' ') ++p;
    if (p - perms < 3 || perms[2] != 'x') return false;  // Not executable: cannot hold a return address
    while (*p == ' ') ++p;
    unsigned long long fileOffset = strtoull(p, &endp, 16);
    if (endp == p) return false;
    const char* slash = strchr(endp, '/');
    if (!slash) return false;  // Anonymous mapping: no backing file for addr2line to read

    outModule.start = (uintptr_t)start;
    outModule.end   = (uintptr_t)end;
    outModule.bias  = (uintptr_t)start - (uintptr_t)fileOffset;
    size_t len      = strlen(slash);
    if (len >= sizeof(outModule.path)) len = sizeof(outModule.path) - 1;
    memcpy(outModule.path, slash, len);
    outModule.path[len] = 0;
    return true;
}

// Reads "/proc/self/maps" (open()/read()/close() only) and fills modules[] with the file-backed executable
// mappings found in it. Returns how many were found.
inline int
buildModuleTable_(char* buf, size_t bufSize, MappedModule_* modules, int maxModules)
{
    int fd = open("/proc/self/maps", O_RDONLY);
    if (fd < 0) return 0;
    size_t total = 0;
    while (total + 1 < bufSize) {
        ssize_t n = read(fd, buf + total, bufSize - 1 - total);
        if (n <= 0) break;
        total += (size_t)n;
    }
    close(fd);
    buf[total] = 0;

    int   count = 0;
    char* line  = buf;
    while (line && *line && count < maxModules) {
        char* nextLine = strchr(line, '\n');
        if (nextLine) *nextLine = 0;
        if (parseMapsLine_(line, modules[count])) ++count;
        line = nextLine ? nextLine + 1 : nullptr;
    }
    return count;
}

// Returns the index of the mapping containing 'addr', or -1.
inline int
findModule_(const MappedModule_* modules, int moduleQty, uintptr_t addr)
{
    for (int i = 0; i < moduleQty; ++i) {
        if (addr >= modules[i].start && addr < modules[i].end) return i;
    }
    return -1;
}

// Runs `addr2line -e modulePath -f -C -p -s <addrs...>` and captures its stdout into outBuf: one
// "function at file:line" pretty-printed line per requested address, in the same order (unresolved ones read as
// "?? at ??:?"). Returns false, leaving outBuf untouched, if the tool could not be run at all (e.g. not
// installed) or exited with an error - the caller then falls back to raw addresses for that batch.
inline bool
runAddr2Line_(const char* modulePath, const uintptr_t* addrs, int addrQty, char* outBuf, size_t outBufSize)
{
    constexpr int MaxBatch = 48;
    if (addrQty <= 0 || addrQty > MaxBatch) return false;

    // Build argv fully before forking: the child must not construct anything itself, only hand off to exec().
    char        hexAddrs[MaxBatch][2 + sizeof(uintptr_t) * 2 + 1];
    const char* argv[8 + MaxBatch + 1];
    int         argc = 0;
    argv[argc++]     = ASSERTED_ADDR2LINE_BIN;
    argv[argc++]     = "-e";
    argv[argc++]     = modulePath;
    argv[argc++]     = "-f";
    argv[argc++]     = "-C";
    argv[argc++]     = "-p";
    argv[argc++]     = "-s";
    for (int i = 0; i < addrQty; ++i) {
        snprintf(hexAddrs[i], sizeof(hexAddrs[i]), "0x%llx", (unsigned long long)addrs[i]);
        argv[argc++] = hexAddrs[i];
    }
    argv[argc] = nullptr;

    int pipeFds[2];
    if (pipe(pipeFds) != 0) return false;

    pid_t child = fork();
    if (child < 0) {
        close(pipeFds[0]);
        close(pipeFds[1]);
        return false;
    }
    if (child == 0) {
        // Child: only async-signal-safe calls until execvp() replaces this image outright.
        dup2(pipeFds[1], STDOUT_FILENO);
        close(pipeFds[0]);
        close(pipeFds[1]);
        int devNull = open("/dev/null", O_WRONLY);
        if (devNull >= 0) dup2(devNull, STDERR_FILENO);
        execvp(ASSERTED_ADDR2LINE_BIN, (char* const*)argv);
        _exit(127);  // Only reached if execvp() itself failed (e.g. the tool is not installed)
    }

    // Parent: read the child's output, then reap it.
    close(pipeFds[1]);
    size_t total = 0;
    while (total + 1 < outBufSize) {
        ssize_t n = read(pipeFds[0], outBuf + total, outBufSize - 1 - total);
        if (n <= 0) break;
        total += (size_t)n;
    }
    outBuf[total] = 0;
    close(pipeFds[0]);

    int status = 0;
    waitpid(child, &status, 0);
    return WIFEXITED(status) && WEXITSTATUS(status) == 0 && total > 0;
}

inline void
crashLogStackTrace(void)
{
    // Capture raw return addresses only - see the comment above for why resolving them happens further down.
    unw_context_t uc;
    unw_getcontext(&uc);
    unw_cursor_t cursor;
    unw_init_local(&cursor, &uc);
    unw_word_t offset;

    constexpr int MaxStackLines = 48;
    // Scratch state below is static (not stack-allocated): it keeps the alternate signal stack small and, since
    // GlobalContext::inCrash already ensures only one crash is handled process-wide at a time (see
    // assertedCrash()), sharing it is safe in practice even though it is not itself thread-safe.
    static uintptr_t addrs[MaxStackLines];
    int              addrQty = 0;
    char             tmpStr[128];

    const int skipDepthQty = 2;  // No need to display the bottom machinery (assertedCrash(), signalHandler())
    int       depth        = 0;
    while (unw_step(&cursor) > 0) {
        unw_word_t ip;
        unw_get_reg(&cursor, UNW_REG_IP, &ip);
        if (depth >= skipDepthQty) {
            // The frame libunwind itself flags as a signal frame is exactly where execution was interrupted, so
            // it and everything after it is meaningful. Anything captured before it, on the other hand, is the
            // kernel/libc signal-delivery trampoline rather than real caller frames: it can still "successfully"
            // unwind to a plausible-looking but unrelated nearby symbol instead of failing outright, so discard
            // whatever was captured so far as soon as the real starting point is found. Without an actual signal
            // involved (e.g. a plain failed assertion, not a crash), no frame is ever flagged and this is a
            // no-op - capturing just proceeds from skipDepthQty as usual.
            if (unw_is_signal_frame(&cursor) > 0) addrQty = 0;
            if (addrQty < MaxStackLines) addrs[addrQty++] = (uintptr_t)(ip - 4);
        }

        tmpStr[0] = 0;
        unw_get_proc_name(&cursor, tmpStr, sizeof(tmpStr), &offset);  // Fails if there is no debug symbols
        if (!strcmp(tmpStr, "main")) break;
        ++depth;
    }  // End of unwinding

    // Resolve which module (executable/shared library) each address belongs to and its file-relative address
    static char          mapsBuf[64 * 1024];
    static MappedModule_ modules[128];
    int                  moduleQty = buildModuleTable_(mapsBuf, sizeof(mapsBuf), modules, 128);

    static int       moduleIdx[MaxStackLines];
    static uintptr_t vaddr[MaxStackLines];
    for (int i = 0; i < addrQty; ++i) {
        moduleIdx[i] = findModule_(modules, moduleQty, addrs[i]);
        vaddr[i]     = (moduleIdx[i] >= 0) ? addrs[i] - modules[moduleIdx[i]].bias : 0;
    }

    struct StackLine {
        char filenameAndLineNbr[128];
        char functionName[256];
        int  firstPartSize;
    };
    static StackLine lines[MaxStackLines];
    int              lineQty          = 0;
    int              maxFirstPartSize = 0;

    // Symbolize in per-module runs: consecutive frames commonly share the same module (e.g. deep recursion, or a
    // whole stack local to the main executable), so this is typically one or two addr2line invocations for the
    // entire stack rather than one per frame.
    static char resolveBuf[8192];
    for (int i = 0; i < addrQty;) {
        int runEnd = i + 1;
        while (runEnd < addrQty && moduleIdx[runEnd] == moduleIdx[i]) ++runEnd;

        bool resolved =
            (moduleIdx[i] >= 0) && runAddr2Line_(modules[moduleIdx[i]].path, &vaddr[i], runEnd - i, resolveBuf, sizeof(resolveBuf));
        char* outLine = resolveBuf;

        for (int frame = i; frame < runEnd; ++frame) {
            StackLine& l        = lines[lineQty++];
            char*      thisLine = nullptr;
            if (resolved && outLine) {
                thisLine       = outLine;
                char* nextLine = strchr(outLine, '\n');
                if (nextLine) {
                    *nextLine = 0;
                    outLine   = nextLine + 1;
                } else {
                    outLine = nullptr;
                }
            }

            if (thisLine) {
                const char* sep       = strstr(thisLine, " at ");
                const char* func      = thisLine;
                size_t      funcLen   = sep ? (size_t)(sep - thisLine) : strlen(thisLine);
                const char* loc       = sep ? sep + 4 : nullptr;
                const char* lastColon = loc ? strrchr(loc, ':') : nullptr;
                if (loc && lastColon) {
                    snprintf(l.filenameAndLineNbr, sizeof(l.filenameAndLineNbr),
                             "    #" ASSERTED_COLOR_NUMBER "%-2d " ASSERTED_COLOR_RESET "%.*s:" ASSERTED_COLOR_NUMBER "%s ", frame,
                             (int)(lastColon - loc), loc, lastColon + 1);
                } else {
                    snprintf(l.filenameAndLineNbr, sizeof(l.filenameAndLineNbr),
                             "    #" ASSERTED_COLOR_NUMBER "%-2d " ASSERTED_COLOR_RESET "0x%llx" ASSERTED_COLOR_NUMBER, frame,
                             (unsigned long long)addrs[frame]);
                }
                snprintf(l.functionName, sizeof(l.functionName), ASSERTED_COLOR_FUNCTION "%.*s", (int)funcLen, func);
            } else {
                snprintf(l.filenameAndLineNbr, sizeof(l.filenameAndLineNbr),
                         "    #" ASSERTED_COLOR_NUMBER "%-2d " ASSERTED_COLOR_RESET "0x%llx" ASSERTED_COLOR_NUMBER, frame,
                         (unsigned long long)addrs[frame]);
                snprintf(l.functionName, sizeof(l.functionName), ASSERTED_COLOR_FUNCTION "<unknown>");
            }
            l.firstPartSize = (int)strlen(l.filenameAndLineNbr);
            if (l.firstPartSize > maxFirstPartSize) maxFirstPartSize = l.firstPartSize;
        }
        i = runEnd;
    }

    // Display the stack trace. Thanks to this 2-pass, the functions are aligned.
    for (int lineNbr = 0; lineNbr < lineQty; ++lineNbr) {
        StackLine& l = lines[lineNbr];
        ASSERTED_MESSAGE(l.filenameAndLineNbr, false);
        snprintf(tmpStr, sizeof(tmpStr), "%*s", maxFirstPartSize - l.firstPartSize, "");
        ASSERTED_MESSAGE(tmpStr, false);
        ASSERTED_MESSAGE(l.functionName, false);
        // Avoid long line truncation
        ASSERTED_MESSAGE(ASSERTED_COLOR_RESET "\n", false);
    }

    // End session
    ASSERTED_MESSAGE("\n", false);
}
#endif  // if defined(__unix__)

#if defined(_MSC_VER)
// Windows version
inline void
crashLogStackTrace(void)
{
    char tmpStr[128];
    char depthStr[8];

    // Get the addresses of the stacktrace
    constexpr int MaxStackLines = 64;  // 64 levels of depth should be enough for everyone
    struct StackLine {
        char filenameAndLineNbr[128];
        char functionName[256];
        int  firstPartSize;
    };
    StackLine lines[MaxStackLines];
    int       lineQty          = 0;
    int       maxFirstPartSize = 0;
    PVOID     stacktrace[MaxStackLines];
    int       foundStackDepth = gc.rtlWalkFrameChain ? gc.rtlWalkFrameChain(stacktrace, 64, 0) : 0;

    // Some required windows structures for the used APIs
    IMAGEHLP_LINE64 line;
    line.SizeOfStruct          = sizeof(IMAGEHLP_LINE64);
    DWORD         displacement = 0;
    constexpr int MaxNameSize  = 8192;
    char          symBuffer[sizeof(SYMBOL_INFO) + MaxNameSize];
    SYMBOL_INFO*  symInfo = (SYMBOL_INFO*)symBuffer;
    symInfo->SizeOfStruct = sizeof(SYMBOL_INFO);
    symInfo->MaxNameLen   = MaxNameSize;
    HANDLE proc           = GetCurrentProcess();

#define ASSERTED_CRASH_STACKTRACE_DUMP_INFO_(itemNbrStr)                                                                               \
    if (isFuncValid || isLineValid) {                                                                                                  \
        snprintf(tmpStr, sizeof(tmpStr), ":%u", isLineValid ? line.LineNumber : 0);                                                    \
        const char* shortFileName = "<unknown>";                                                                                       \
        if (isLineValid) {                                                                                                             \
            const char* backslash = strrchr(line.FileName, '\\');                                                                      \
            shortFileName         = backslash ? backslash + 1 : line.FileName;                                                         \
        }                                                                                                                              \
        snprintf(l.filenameAndLineNbr, sizeof(l.filenameAndLineNbr),                                                                   \
                 "     " ASSERTED_COLOR_NUMBER "%s " ASSERTED_COLOR_RESET "%s" ASSERTED_COLOR_NUMBER "%s ", itemNbrStr, shortFileName, \
                 isLineValid ? tmpStr : "");                                                                                           \
        snprintf(l.functionName, sizeof(l.functionName), ASSERTED_COLOR_FUNCTION "%s", isFuncValid ? symInfo->Name : "<unknown>");     \
    } else {                                                                                                                           \
        snprintf(l.filenameAndLineNbr, sizeof(l.filenameAndLineNbr),                                                                   \
                 "     " ASSERTED_COLOR_NUMBER "%s" ASSERTED_COLOR_FUNCTION " 0x%" PRIX64 ASSERTED_COLOR_RESET, itemNbrStr, ptr);      \
        l.functionName[0] = 0;                                                                                                         \
    }                                                                                                                                  \
    l.firstPartSize = (int)strlen(l.filenameAndLineNbr);                                                                               \
    if (l.firstPartSize > maxFirstPartSize) maxFirstPartSize = l.firstPartSize;

    constexpr int skipDepthQty = 3;  // No need to display the bottom machinery
    for (int depth = skipDepthQty; depth < foundStackDepth; ++depth) {
        // -1 because the captured PC is already pointing on the next code line at snapshot time
        uint64_t ptr = ((uint64_t)stacktrace[depth]) - 1;

        // Get the nested inline function calls, if any
        DWORD frameIdx, curContext = 0;
        int   inlineQty = SymAddrIncludeInlineTrace(proc, ptr);
        if (inlineQty > 0 && SymQueryInlineTrace(proc, ptr, 0, ptr, ptr, &curContext, &frameIdx)) {
            for (int i = 0; i < inlineQty; ++i) {
                bool isFuncValid = (SymFromInlineContext(proc, ptr, curContext, 0, symInfo) != 0);
                bool isLineValid = (SymGetLineFromInlineContext(proc, ptr, curContext, 0, &displacement, &line) != 0);
                ++curContext;
                if (lineQty < MaxStackLines) {
                    StackLine& l = lines[lineQty++];
                    ASSERTED_CRASH_STACKTRACE_DUMP_INFO_("inl");
                }
            }
        }

        // Get the function call for this depth
        if (lineQty < MaxStackLines) {
            StackLine& l           = lines[lineQty++];
            bool       isFuncValid = (SymFromAddr(proc, ptr, 0, symInfo) != 0);
            bool       isLineValid = (SymGetLineFromAddr64(proc, ptr - 1, &displacement, &line) != 0);
            snprintf(depthStr, sizeof(depthStr), "#%-2d", depth - skipDepthQty);
            ASSERTED_CRASH_STACKTRACE_DUMP_INFO_(depthStr);
        }
    }  // End of loop on stack depth

    // Display the stack trace. Thanks to this 2-pass, the functions are aligned.
    for (int lineNbr = 0; lineNbr < lineQty; ++lineNbr) {
        StackLine& l = lines[lineNbr];
        ASSERTED_MESSAGE(l.filenameAndLineNbr, false);
        snprintf(tmpStr, sizeof(tmpStr), "%*s", maxFirstPartSize - l.firstPartSize, "");
        ASSERTED_MESSAGE(tmpStr, false);
        ASSERTED_MESSAGE(l.functionName, false);
        // Avoid long line truncation
        ASSERTED_MESSAGE(ASSERTED_COLOR_RESET "\n", false);
    }
}
#endif  // if defined(_MSC_VER)

#endif  // if ASSERTED_WITH_STACKTRACE == 1

#if ASSERTED_NO_DEBUG_BREAK == 0

#if defined(__unix__)
// Returns true if a ptrace-based tracer (a debugger like gdb, or e.g. strace) is attached, by reading the
// TracerPid field of /proc/self/status. Uses only open()/read()/close(): no stdio buffering, no allocation.
inline bool
isDebuggerPresent_(void)
{
    char buf[4096];
    int  fd = open("/proc/self/status", O_RDONLY);
    if (fd < 0) return false;
    ssize_t n = read(fd, buf, sizeof(buf) - 1);
    close(fd);
    if (n <= 0) return false;
    buf[n] = 0;

    const char* tag = strstr(buf, "TracerPid:");
    return tag && strtol(tag + 10, nullptr, 10) != 0;
}
#endif  // if defined(__unix__)

// Traps into an attached debugger right at the point where the process is about to exit because of a crash, and
// is a complete no-op otherwise, so a run without a debugger is unaffected.
//
// On Linux/Unix: raise(SIGTRAP) is only ever called after confirming, via isDebuggerPresent_(), that a tracer is
// actually attached - gdb's default handling of SIGTRAP is to stop and not pass it to the program, so this halts
// execution right here without ever reaching debugBreakSignalHandler() (declared below, in the signal-handling
// section). That handler exists purely as a defensive fallback for e.g. the tracer detaching between the check
// and the raise: if SIGTRAP is ever delivered with nothing to intercept it, it does nothing and execution simply
// continues, rather than the process being killed by SIGTRAP's default disposition.
//
// On Windows: IsDebuggerPresent() is the direct equivalent check, and __debugbreak() the trap instruction. The
// existing VEH handler already declines to handle EXCEPTION_BREAKPOINT itself (see exceptionHandler() below),
// deferring to whichever debugger the OS delivered the first-chance exception to.
inline void
maybeBreakIntoDebugger_(void)
{
#if defined(__unix__)
    if (isDebuggerPresent_()) raise(SIGTRAP);
#elif defined(_MSC_VER)
    if (IsDebuggerPresent()) __debugbreak();
#endif
}

#endif  // if ASSERTED_NO_DEBUG_BREAK==0

inline void ASSERTED_NORETURN
assertedCrash(const char* message)
{
    // Reentrancy guard: a crash occurring while already handling one (a different signal firing mid-handling, or
    // the handler itself faulting) bails out immediately instead of re-running through possibly broken state.
    if (gc.inCrash) {
        std::_Exit(1);
    }
    gc.inCrash = 1;

    // Log and display the crash message
    ASSERTED_MESSAGE(message, false);

    // Log and display the call stack
#if ASSERTED_WITH_STACKTRACE == 1
    ASSERTED_MESSAGE(ASSERTED_COLOR_BLUE "  Stacktrace:\n" ASSERTED_COLOR_RESET, false);  // Standard
    assertedPriv::crashLogStackTrace();
#endif
    ASSERTED_MESSAGE("\n", true);  // End of full crash display

#if ASSERTED_NO_DEBUG_BREAK == 0
    maybeBreakIntoDebugger_();  // No-op unless a debugger is actually attached
#endif

    // Stop the process
    ASSERTED_CRASH_EXIT_FUNC();
}

#if ASSERTED_NO_SIGNALS == 0

#if defined(__unix__) && ASSERTED_NO_DEBUG_BREAK == 0
// Defensive fallback for maybeBreakIntoDebugger_()'s raise(SIGTRAP): only ever reached if that SIGTRAP was
// delivered with nothing (i.e. no debugger) to intercept it first, which should not normally happen since it is
// only raised after confirming a tracer is attached. Doing nothing here just lets execution continue normally,
// so this exists purely so that edge case still can't take down a run without a debugger.
[[maybe_unused]] static void
debugBreakSignalHandler(int)
{
}
#endif  // if defined(__unix__) && ASSERTED_NO_DEBUG_BREAK==0

[[maybe_unused]] static void
signalHandler(int signalId)
{
    const char* sigDescr = "*Unknown*";
    switch (signalId) {
        case SIGABRT:
            sigDescr = "Abort";
            break;
        case SIGFPE:
            sigDescr = "Floating point exception";
            break;
        case SIGILL:
            sigDescr = "Illegal instruction";
            break;
        case SIGSEGV:
            sigDescr = "Segmentation fault";
            break;
        case SIGINT:
            sigDescr = "Interrupt";
            break;
        case SIGTERM:
            sigDescr = "Termination";
            break;
#if defined(__unix__)
        case SIGPIPE:
            sigDescr = "Broken pipe";
            break;
#endif
        default:
            break;
    }
    char infoStr[256];
    snprintf(infoStr, sizeof(infoStr), ASSERTED_COLOR_RED "[ASSERTED] signal %d '%s' received\n" ASSERTED_COLOR_RESET, signalId, sigDescr);
    assertedCrash(infoStr);
}

#if _MSC_VER
// Specific to windows, on top of the signal handler
static LONG WINAPI
exceptionHandler(struct _EXCEPTION_POINTERS* pExcept)
{
    char         infoStr[256];
    int          tmp;
    unsigned int code = pExcept->ExceptionRecord->ExceptionCode;
#define ASSERTED_LOG_EXCEPTION_(str)                                                                                          \
    snprintf(infoStr, sizeof(infoStr), ASSERTED_COLOR_RED "[ASSERTED] exception '%s' received.\n" ASSERTED_COLOR_RESET, str); \
    assertedCrash(infoStr)

    switch (code) {
        case EXCEPTION_ACCESS_VIOLATION:
            tmp = (int)pExcept->ExceptionRecord->ExceptionInformation[0];
            snprintf(infoStr, sizeof(infoStr),
                     ASSERTED_COLOR_RED "[ASSERTED] exception 'ACCESS_VIOLATION' (%s) received." ASSERTED_COLOR_RESET,
                     (tmp == 0) ? "read" : ((tmp == 1) ? "write" : "user-mode data execution prevention (DEP) violation"));
            assertedCrash(infoStr);
            break;
        case EXCEPTION_BREAKPOINT:
            break;  // Let this one go through the handler
        case EXCEPTION_SINGLE_STEP:
            break;  // Let this one go through the handler
        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
            ASSERTED_LOG_EXCEPTION_("ARRAY_BOUNDS_EXCEEDED");
            break;
        case EXCEPTION_DATATYPE_MISALIGNMENT:
            ASSERTED_LOG_EXCEPTION_("DATATYPE_MISALIGNMENT");
            break;
        case EXCEPTION_FLT_DENORMAL_OPERAND:
            ASSERTED_LOG_EXCEPTION_("FLT_DENORMAL_OPERAND");
            break;
        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
            ASSERTED_LOG_EXCEPTION_("FLT_DIVIDE_BY_ZERO");
            break;
        case EXCEPTION_FLT_INEXACT_RESULT:
            ASSERTED_LOG_EXCEPTION_("FLT_INEXACT_RESULT");
            break;
        case EXCEPTION_FLT_INVALID_OPERATION:
            ASSERTED_LOG_EXCEPTION_("FLT_INVALID_OPERATION");
            break;
        case EXCEPTION_FLT_OVERFLOW:
            ASSERTED_LOG_EXCEPTION_("FLT_OVERFLOW");
            break;
        case EXCEPTION_FLT_STACK_CHECK:
            ASSERTED_LOG_EXCEPTION_("FLT_STACK_CHECK");
            break;
        case EXCEPTION_FLT_UNDERFLOW:
            ASSERTED_LOG_EXCEPTION_("FLT_UNDERFLOW");
            break;
        case EXCEPTION_ILLEGAL_INSTRUCTION:
            ASSERTED_LOG_EXCEPTION_("ILLEGAL_INSTRUCTION");
            break;
        case EXCEPTION_IN_PAGE_ERROR:
            ASSERTED_LOG_EXCEPTION_("IN_PAGE_ERROR");
            break;
        case EXCEPTION_INT_DIVIDE_BY_ZERO:
            ASSERTED_LOG_EXCEPTION_("INT_DIVIDE_BY_ZERO");
            break;
        case EXCEPTION_INT_OVERFLOW:
            ASSERTED_LOG_EXCEPTION_("INT_OVERFLOW");
            break;
        case EXCEPTION_INVALID_DISPOSITION:
            ASSERTED_LOG_EXCEPTION_("INVALID_DISPOSITION");
            break;
        case EXCEPTION_NONCONTINUABLE_EXCEPTION:
            ASSERTED_LOG_EXCEPTION_("NONCONTINUABLE_EXCEPTION");
            break;
        case EXCEPTION_PRIV_INSTRUCTION:
            ASSERTED_LOG_EXCEPTION_("PRIV_INSTRUCTION");
            break;
        case EXCEPTION_STACK_OVERFLOW:
            ASSERTED_LOG_EXCEPTION_("STACK_OVERFLOW");
            break;
        default:
            ASSERTED_LOG_EXCEPTION_("UNKNOWN");
            break;
    }
    // Go to the next handler
    return EXCEPTION_CONTINUE_SEARCH;
}
#endif  // if _MSC_VER

#endif  // if ASSERTED_NO_SIGNALS == 0

// =======================================================================================================
// Automatic instantiation
// =======================================================================================================

struct Bootstrap {
    Bootstrap()
    {
        [[maybe_unused]] auto& ic = assertedPriv::gc;

        // Register POSIX signals
#if ASSERTED_NO_SIGNALS == 0
#if defined(__unix__)
        memset(&ic.signalsOldHandlers, 0, sizeof(ic.signalsOldHandlers));

        // Alternate signal stack: without it, a SIGSEGV caused by stack overflow has no stack left to run the
        // handler on (crashLogStackTrace and the message formatting use several KB of locals).
        ic.altStackMemory = malloc(ASSERTED_ALT_STACK_SIZE);
        if (ic.altStackMemory) {
            stack_t ss;
            ss.ss_sp    = ic.altStackMemory;
            ss.ss_size  = ASSERTED_ALT_STACK_SIZE;
            ss.ss_flags = 0;
            sigaltstack(&ss, &ic.altStackOld);
        }

        struct sigaction sa;
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = assertedPriv::signalHandler;
        sigemptyset(&sa.sa_mask);
        // SA_ONSTACK: run on the alternate stack above. SA_RESETHAND: a second occurrence of the *same* signal
        // while already handling one reverts to the default disposition instead of recursing into a possibly
        // broken handler (assertedCrash() additionally guards against a *different* signal doing the same).
        sa.sa_flags = static_cast<int>(SA_ONSTACK | SA_RESETHAND);
        sigaction(SIGABRT, &sa, &ic.signalsOldHandlers[0]);
        sigaction(SIGFPE, &sa, &ic.signalsOldHandlers[1]);
        sigaction(SIGILL, &sa, &ic.signalsOldHandlers[2]);
        sigaction(SIGSEGV, &sa, &ic.signalsOldHandlers[3]);
#if ASSERTED_NO_SIGINT == 0
        sigaction(SIGINT, &sa, &ic.signalsOldHandlers[4]);
#endif
        sigaction(SIGTERM, &sa, &ic.signalsOldHandlers[5]);
        sigaction(SIGPIPE, &sa, &ic.signalsOldHandlers[6]);
        ic.signalHandlersSaved = true;

#if ASSERTED_NO_DEBUG_BREAK == 0
        // Defensive fallback handler for maybeBreakIntoDebugger_()'s raise(SIGTRAP) - see debugBreakSignalHandler().
        // No SA_RESETHAND here: unlike the crash signals above, this one is expected to fire repeatedly over the
        // program's life (each failed assertion under a debugger), not just once.
        struct sigaction dsa;
        memset(&dsa, 0, sizeof(dsa));
        dsa.sa_handler = assertedPriv::debugBreakSignalHandler;
        sigemptyset(&dsa.sa_mask);
        dsa.sa_flags = SA_ONSTACK;
        sigaction(SIGTRAP, &dsa, &ic.debugBreakOldHandler);
        ic.debugBreakHandlerSaved = true;
#endif  // if ASSERTED_NO_DEBUG_BREAK==0
#else   // if defined(__unix__)
        memset(ic.signalsOldHandlers, 0, sizeof(ic.signalsOldHandlers));
        ic.signalsOldHandlers[0] = std::signal(SIGABRT, assertedPriv::signalHandler);
        ic.signalsOldHandlers[1] = std::signal(SIGFPE, assertedPriv::signalHandler);
        ic.signalsOldHandlers[2] = std::signal(SIGILL, assertedPriv::signalHandler);
        ic.signalsOldHandlers[3] = std::signal(SIGSEGV, assertedPriv::signalHandler);
#if ASSERTED_NO_SIGINT == 0
        ic.signalsOldHandlers[4] = std::signal(SIGINT, assertedPriv::signalHandler);
#endif
        ic.signalsOldHandlers[5] = std::signal(SIGTERM, assertedPriv::signalHandler);
        ic.signalHandlersSaved   = true;

        // Register the exception handler
        ic.exceptionHandler = AddVectoredExceptionHandler(1, assertedPriv::exceptionHandler);
#endif  // if defined(__unix__)
#endif  // if ASSERTED_NO_SIGNALS==0

#if defined(_MSC_VER) && ASSERTED_WITH_STACKTRACE == 1
        // Initialize the symbol reading for the stacktrace (in case of crash)
        SymInitialize(GetCurrentProcess(), 0, true);
        SymSetOptions(SYMOPT_LOAD_LINES);
        ic.rtlWalkFrameChain = (assertedPriv::rtlWalkFrameChain_t)GetProcAddress(GetModuleHandleA("ntdll.dll"), "RtlWalkFrameChain");
        asserted(ic.rtlWalkFrameChain);
#endif  // if defined(_MSC_VER) && ASSERTED_WITH_STACKTRACE==1
    }

    ~Bootstrap()
    {
        // Unregister signals
#if ASSERTED_NO_SIGNALS == 0
        auto& ic = assertedPriv::gc;
        if (ic.signalHandlersSaved) {
#if defined(__unix__)
            sigaction(SIGABRT, &ic.signalsOldHandlers[0], nullptr);
            sigaction(SIGFPE, &ic.signalsOldHandlers[1], nullptr);
            sigaction(SIGILL, &ic.signalsOldHandlers[2], nullptr);
            sigaction(SIGSEGV, &ic.signalsOldHandlers[3], nullptr);
#if ASSERTED_NO_SIGINT == 0
            sigaction(SIGINT, &ic.signalsOldHandlers[4], nullptr);
#endif
            sigaction(SIGTERM, &ic.signalsOldHandlers[5], nullptr);
            sigaction(SIGPIPE, &ic.signalsOldHandlers[6], nullptr);
#if ASSERTED_NO_DEBUG_BREAK == 0
            if (ic.debugBreakHandlerSaved) {
                sigaction(SIGTRAP, &ic.debugBreakOldHandler, nullptr);
            }
#endif

            // Restore the previous alternate signal stack and release ours
            if (ic.altStackMemory) {
                sigaltstack(&ic.altStackOld, nullptr);
                free(ic.altStackMemory);
                ic.altStackMemory = nullptr;
            }
#else  // if defined(__unix__)
            std::signal(SIGABRT, ic.signalsOldHandlers[0]);
            std::signal(SIGFPE, ic.signalsOldHandlers[1]);
            std::signal(SIGILL, ic.signalsOldHandlers[2]);
            std::signal(SIGSEGV, ic.signalsOldHandlers[3]);
#if ASSERTED_NO_SIGINT == 0
            std::signal(SIGINT, ic.signalsOldHandlers[4]);
#endif
            std::signal(SIGTERM, ic.signalsOldHandlers[5]);
            RemoveVectoredExceptionHandler(ic.exceptionHandler);
#endif  // if defined(__unix__)
        }
#endif  // if ASSERTED_NO_SIGNALS==0
    }

    Bootstrap(Bootstrap const&)            = delete;
    Bootstrap(Bootstrap&&)                 = delete;
    Bootstrap& operator=(Bootstrap const&) = delete;
    Bootstrap& operator=(Bootstrap&&)      = delete;
};

inline Bootstrap bootstrap;

}  // namespace ASSERTED_PRIV_CFG_TAG_
}  // namespace assertedPriv

#endif  // if ASSERTED_IS_ENABLED

#if defined(_MSC_VER)
#pragma warning(pop)
#endif