pico_emitter.h

Go to the documentation of this file.

 
#ifndef PICO_EMITTER_H
#define PICO_EMITTER_H
 
#include <stdbool.h> // bool, true, false
#include <stddef.h>  // NULL
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void (*emitter_listener_fn)(const void* data, void* udata);
 
typedef struct emitter_s emitter_t;
 
emitter_t* emitter_create(int num_events);
 
void emitter_destroy(emitter_t* emitter);
 
bool emitter_resize(emitter_t* emitter, int num_events);
 
void emitter_on(emitter_t* emitter, int event, emitter_listener_fn listener, void* udata);
 
void emitter_once(emitter_t* emitter, int event, emitter_listener_fn listener, void* udata);
 
void emitter_off(emitter_t* emitter, int event, emitter_listener_fn listener);
 
void emitter_off_all(emitter_t* emitter, int event);
 
void emitter_emit(emitter_t* emitter, int event, const void* data);
 
int emitter_count(const emitter_t* emitter, int event);
 
/* --------------------------------------------------------------------------
 * Queued emitter
 * -------------------------------------------------------------------------- */
 
typedef struct queued_emitter_s queued_emitter_t;
 
queued_emitter_t* queued_emitter_create(int num_events);
 
void queued_emitter_destroy(queued_emitter_t* qe);
 
bool queued_emitter_resize(queued_emitter_t* qe, int num_events);
 
void queued_emitter_on(queued_emitter_t* qe, int event, emitter_listener_fn listener, void* udata);
 
void queued_emitter_once(queued_emitter_t* qe, int event, emitter_listener_fn listener, void* udata);
 
void queued_emitter_off(queued_emitter_t* qe, int event, emitter_listener_fn listener);
 
void queued_emitter_off_all(queued_emitter_t* qe, int event);
 
void queued_emitter_emit(queued_emitter_t* qe, int event, const void* data);
 
void queued_emitter_enqueue_raw(queued_emitter_t* qe, int event, const void* data, size_t data_size);
 
#define queued_emitter_enqueue(qe, event, ptr) \
    (queued_emitter_enqueue_raw((qe), (event), (ptr), sizeof(*(ptr))))
 
void queued_emitter_flush(queued_emitter_t* qe);
 
int queued_emitter_count(const queued_emitter_t* qe, int event);
 
#ifdef __cplusplus
}
#endif
 
#endif // PICO_EMITTER_H
 
#ifdef PICO_EMITTER_IMPLEMENTATION
 
#include <stdalign.h> // alignof
#include <stdint.h>   // uint8_t
#include <string.h>   // memset, memcpy
 
/* --------------------------------------------------------------------------
 * Configuration
 * -------------------------------------------------------------------------- */
 
#ifndef PICO_EMITTER_INIT_CAPACITY
    #define PICO_EMITTER_INIT_CAPACITY 8
#endif
 
#ifdef NDEBUG
    #define PICO_EMITTER_ASSERT(expr) ((void)0)
#else
    #ifndef PICO_EMITTER_ASSERT
        #include <assert.h>
        #define PICO_EMITTER_ASSERT(expr) assert(expr)
    #endif
#endif
 
#ifndef PICO_EMITTER_MALLOC
    #include <stdlib.h>
    #define PICO_EMITTER_MALLOC(size)    malloc(size)
    #define PICO_EMITTER_REALLOC(p, sz)  realloc(p, sz)
    #define PICO_EMITTER_FREE(ptr)       free(ptr)
#endif
 
#ifndef PICO_EMITTER_MEMCPY
    #include <string.h>
    #define PICO_EMITTER_MEMCPY(dst, src, n) memcpy(dst, src, n)
#endif
 
#ifndef PICO_EMITTER_MEMSET
    #include <string.h>
    #define PICO_EMITTER_MEMSET(dst, val, n) memset(dst, val, n)
#endif
 
/* --------------------------------------------------------------------------
 * Internal aliases
 * -------------------------------------------------------------------------- */
 
#define EMITTER_INIT_CAPACITY PICO_EMITTER_INIT_CAPACITY
#define EMITTER_ASSERT        PICO_EMITTER_ASSERT
#define EMITTER_MALLOC        PICO_EMITTER_MALLOC
#define EMITTER_REALLOC       PICO_EMITTER_REALLOC
#define EMITTER_FREE          PICO_EMITTER_FREE
#define EMITTER_MEMCPY        PICO_EMITTER_MEMCPY
#define EMITTER_MEMSET        PICO_EMITTER_MEMSET
 
/* --------------------------------------------------------------------------
 * Emitter types
 * -------------------------------------------------------------------------- */
 
/*
 * Per-event listener slot. Uses a struct-of-arrays layout so that function
 * pointers are contiguous in memory, improving cache performance during emit.
 * Arrays are heap-allocated and grow by doubling when capacity is exceeded.
 */
typedef struct
{
    emitter_listener_fn* listeners; // function pointers
    void**               udatas;    // corresponding user data
    bool*                once;      // fire-once flag
    int                  count;     // active listener count
    int                  capacity;  // allocated capacity
    bool                 emitting;  // true while iterating
} emitter_slot_t;
 
struct emitter_s
{
    emitter_slot_t* events;
    int num_events;
};
 
/* --------------------------------------------------------------------------
 * Arena allocator types
 * -------------------------------------------------------------------------- */
 
typedef struct arena_block_s
{
    uint8_t*              memory;
    size_t                size;
    size_t                offset;
    struct arena_block_s* next;
} arena_block_t;
 
typedef struct arena_s
{
    arena_block_t* first;
    arena_block_t* current;
    size_t         block_size;
} arena_t;
 
/* --------------------------------------------------------------------------
 * Forward declarations
 * -------------------------------------------------------------------------- */
 
static void           emitter_grow_slot(emitter_slot_t* slot);
static void           emitter_compact(emitter_slot_t* slot);
static void           emitter_subscribe(emitter_t* emitter, int event, emitter_listener_fn listener, void* udata, bool once);
static void           queued_emitter_grow(queued_emitter_t* qe);
static arena_block_t* arena_block_create(size_t size);
static bool           arena_init(arena_t* arena, size_t initial_block_size);
static bool           arena_grow(arena_t* arena, size_t min_size);
static uintptr_t      arena_align_forward(uintptr_t ptr, size_t align);
static void*          arena_alloc_align(arena_t* arena, size_t size, size_t align);
static void*          arena_alloc(arena_t* arena, size_t size);
static void           arena_reset(arena_t* arena);
static void           arena_destroy(arena_t* arena);
 
/* --------------------------------------------------------------------------
 * Emitter public API implementation
 * -------------------------------------------------------------------------- */
 
emitter_t* emitter_create(int num_events)
{
    EMITTER_ASSERT(num_events > 0);
 
    emitter_t* emitter = (emitter_t*)EMITTER_MALLOC(sizeof(emitter_t));
 
    if (!emitter)
    {
        return NULL;
    }
 
    emitter->events = (emitter_slot_t*)EMITTER_MALLOC((size_t)num_events * sizeof(emitter_slot_t));
 
    if (!emitter->events)
    {
        EMITTER_FREE(emitter);
        return NULL;
    }
 
    EMITTER_MEMSET(emitter->events, 0, (size_t)num_events * sizeof(emitter_slot_t));
 
    emitter->num_events = num_events;
 
    return emitter;
}
 
void emitter_destroy(emitter_t* emitter)
{
    EMITTER_ASSERT(emitter != NULL);
 
    for (int i = 0; i < emitter->num_events; i++)
    {
        EMITTER_FREE(emitter->events[i].listeners);
        EMITTER_FREE(emitter->events[i].udatas);
        EMITTER_FREE(emitter->events[i].once);
    }
 
    EMITTER_FREE(emitter->events);
    EMITTER_FREE(emitter);
}
 
bool emitter_resize(emitter_t* emitter, int num_events)
{
    EMITTER_ASSERT(emitter    != NULL);
    EMITTER_ASSERT(num_events >  0);
 
    int old_num = emitter->num_events;
 
    if (num_events == old_num)
    {
        return true;
    }
 
    // When shrinking, release the listener arrays of the slots being dropped
    // before they become unreachable past the reallocated boundary.
    for (int i = num_events; i < old_num; i++)
    {
        EMITTER_FREE(emitter->events[i].listeners);
        EMITTER_FREE(emitter->events[i].udatas);
        EMITTER_FREE(emitter->events[i].once);
        // Clear the slot so a failed shrink-realloc below cannot leave dangling
        // freed pointers that emitter_destroy would later double-free.
        EMITTER_MEMSET(&emitter->events[i], 0, sizeof(emitter_slot_t));
    }
 
    emitter_slot_t* events = (emitter_slot_t*)EMITTER_REALLOC(emitter->events, (size_t)num_events * sizeof(emitter_slot_t));
 
    if (!events)
    {
        return false;
    }
 
    // When growing, the newly added slots must start empty.
    if (num_events > old_num)
    {
        EMITTER_MEMSET(&events[old_num], 0, (size_t)(num_events - old_num) * sizeof(emitter_slot_t));
    }
 
    emitter->events     = events;
    emitter->num_events = num_events;
 
    return true;
}
 
void emitter_on(emitter_t* emitter, int event, emitter_listener_fn listener, void* udata)
{
    emitter_subscribe(emitter, event, listener, udata, false);
}
 
void emitter_once(emitter_t* emitter, int event, emitter_listener_fn listener, void* udata)
{
    emitter_subscribe(emitter, event, listener, udata, true);
}
 
void emitter_off(emitter_t* emitter, int event, emitter_listener_fn listener)
{
    EMITTER_ASSERT(emitter  != NULL);
    EMITTER_ASSERT(event    >= 0 && event < emitter->num_events);
    EMITTER_ASSERT(listener != NULL);
 
    emitter_slot_t* slot = &emitter->events[event];
 
    for (int i = 0; i < slot->count; i++)
    {
        if (slot->listeners[i] != listener)
        {
            continue;
        }
 
        if (slot->emitting)
        {
            // Tombstone; emitter_emit will compact after iteration.
            slot->listeners[i] = NULL;
        }
        else
        {
            // Compact in-place immediately.
            for (int j = i; j < slot->count - 1; j++)
            {
                slot->listeners[j] = slot->listeners[j + 1];
                slot->udatas[j]    = slot->udatas[j + 1];
                slot->once[j]      = slot->once[j + 1];
            }
 
            slot->count--;
        }
 
        return; // Remove first match only.
    }
}
 
void emitter_off_all(emitter_t* emitter, int event)
{
    EMITTER_ASSERT(emitter != NULL);
    EMITTER_ASSERT(event   >= 0 && event < emitter->num_events);
 
    emitter_slot_t* slot = &emitter->events[event];
 
    if (slot->emitting)
    {
        // Tombstone all; emitter_emit will compact after iteration.
        for (int i = 0; i < slot->count; i++)
        {
            slot->listeners[i] = NULL;
        }
    }
    else
    {
        slot->count = 0;
    }
}
 
void emitter_emit(emitter_t* emitter, int event, const void* data)
{
    EMITTER_ASSERT(emitter != NULL);
    EMITTER_ASSERT(event   >= 0 && event < emitter->num_events);
 
    emitter_slot_t* slot = &emitter->events[event];
 
    /*
     * Capture the count before iterating so that listeners added during emit
     * are not called in the current dispatch.
     */
    int  count         = slot->count;
    bool needs_compact = false;
 
    slot->emitting = true;
 
    for (int i = 0; i < count; i++)
    {
        emitter_listener_fn fn = slot->listeners[i];
 
        if (!fn)
        {
            // Tombstoned by emitter_off or emitter_off_all from a prior callback.
            needs_compact = true;
            continue;
        }
 
        /*
         * Tombstone once-listeners before calling so that re-registration
         * from within the callback is safe.
         */
        if (slot->once[i])
        {
            slot->listeners[i] = NULL;
            needs_compact = true;
        }
 
        fn(data, slot->udatas[i]);
 
        /*
         * The listener may have tombstoned itself (or a later slot) via
         * emitter_off during the callback. Check whether this slot became NULL
         * after the call.
         */
        if (slot->listeners[i] == NULL)
        {
            needs_compact = true;
        }
    }
 
    slot->emitting = false;
 
    if (needs_compact)
    {
        emitter_compact(slot);
    }
}
 
int emitter_count(const emitter_t* emitter, int event)
{
    EMITTER_ASSERT(emitter != NULL);
    EMITTER_ASSERT(event   >= 0 && event < emitter->num_events);
 
    return emitter->events[event].count;
}
 
/* --------------------------------------------------------------------------
 * Queued Emitter types
 * -------------------------------------------------------------------------- */
 
struct queued_emitter_s
{
    emitter_t*   emitter;
    arena_t      arenas[2];    // ping-pong pair
    int          write_arena;  // index of the arena new emits write into
    int*         events;
    const void** datas;
    int          count;
    int          capacity;
};
 
/* --------------------------------------------------------------------------
 * Queued Emitter public API implementation
 * -------------------------------------------------------------------------- */
 
queued_emitter_t* queued_emitter_create(int num_events)
{
    EMITTER_ASSERT(num_events > 0);
 
    queued_emitter_t* qe = (queued_emitter_t*)EMITTER_MALLOC(sizeof(queued_emitter_t));
 
    if (!qe)
    {
        return NULL;
    }
 
    qe->emitter = emitter_create(num_events);
 
    if (!qe->emitter)
    {
        EMITTER_FREE(qe);
        return NULL;
    }
 
    size_t init_block = (size_t)EMITTER_INIT_CAPACITY * sizeof(void*);
 
    if (!arena_init(&qe->arenas[0], init_block))
    {
        emitter_destroy(qe->emitter);
        EMITTER_FREE(qe);
        return NULL;
    }
 
    if (!arena_init(&qe->arenas[1], init_block))
    {
        arena_destroy(&qe->arenas[0]);
        emitter_destroy(qe->emitter);
        EMITTER_FREE(qe);
        return NULL;
    }
 
    qe->write_arena = 0;
    qe->events      = NULL;
    qe->datas       = NULL;
    qe->count       = 0;
    qe->capacity    = 0;
 
    return qe;
}
 
void queued_emitter_destroy(queued_emitter_t* qe)
{
    EMITTER_ASSERT(qe != NULL);
 
    emitter_destroy(qe->emitter);
    arena_destroy(&qe->arenas[0]);
    arena_destroy(&qe->arenas[1]);
    EMITTER_FREE(qe->events);
    EMITTER_FREE(qe->datas);
    EMITTER_FREE(qe);
}
 
bool queued_emitter_resize(queued_emitter_t* qe, int num_events)
{
    EMITTER_ASSERT(qe != NULL);
    return emitter_resize(qe->emitter, num_events);
}
 
void queued_emitter_on(queued_emitter_t* qe, int event, emitter_listener_fn listener, void* udata)
{
    EMITTER_ASSERT(qe != NULL);
    emitter_on(qe->emitter, event, listener, udata);
}
 
void queued_emitter_once(queued_emitter_t* qe, int event, emitter_listener_fn listener, void* udata)
{
    EMITTER_ASSERT(qe != NULL);
    emitter_once(qe->emitter, event, listener, udata);
}
 
void queued_emitter_off(queued_emitter_t* qe, int event, emitter_listener_fn listener)
{
    EMITTER_ASSERT(qe != NULL);
    emitter_off(qe->emitter, event, listener);
}
 
void queued_emitter_off_all(queued_emitter_t* qe, int event)
{
    EMITTER_ASSERT(qe != NULL);
    emitter_off_all(qe->emitter, event);
}
 
void queued_emitter_emit(queued_emitter_t* qe, int event, const void* data)
{
    EMITTER_ASSERT(qe != NULL);
    emitter_emit(qe->emitter, event, data);
}
 
void queued_emitter_enqueue_raw(queued_emitter_t* qe, int event, const void* data, size_t data_size)
{
    EMITTER_ASSERT(qe != NULL);
    EMITTER_ASSERT(event >= 0 && event < qe->emitter->num_events);
 
    if (qe->count == qe->capacity)
    {
        queued_emitter_grow(qe);
    }
 
    const void* stored = NULL;
 
    if (data != NULL && data_size > 0)
    {
        void* copy = arena_alloc(&qe->arenas[qe->write_arena], data_size);
        EMITTER_ASSERT(copy != NULL);
        EMITTER_MEMCPY(copy, data, data_size);
        stored = copy;
    }
 
    qe->events[qe->count] = event;
    qe->datas[qe->count]  = stored;
    qe->count++;
}
 
void queued_emitter_flush(queued_emitter_t* qe)
{
    EMITTER_ASSERT(qe != NULL);
 
    int remaining = 0;
 
    do {
 
        int flush_count = qe->count;
        int read_arena  = qe->write_arena;
 
        /* Flip write arena before dispatching so that nested emits during flush
        * copy payload into the other arena. Their data pointers remain valid
        * after the read arena is reset below. */
        qe->write_arena = 1 - read_arena;
 
        for (int i = 0; i < flush_count; i++)
        {
            emitter_emit(qe->emitter, qe->events[i], qe->datas[i]);
        }
 
        /* Shift deferred events (enqueued during flush) to the front.
        * events/datas are heap-resident so no arena pointer fixup is needed. */
        remaining = qe->count - flush_count;
 
        for (int i = 0; i < remaining; i++)
        {
            qe->events[i] = qe->events[flush_count + i];
            qe->datas[i]  = qe->datas[flush_count + i];
        }
 
        qe->count = remaining;
 
        // All dispatched payloads are consumed — O(1) reset of the read arena.
        arena_reset(&qe->arenas[read_arena]);
 
    } while (remaining > 0);
}
 
int queued_emitter_count(const queued_emitter_t* qe, int event)
{
    EMITTER_ASSERT(qe != NULL);
    return emitter_count(qe->emitter, event);
}
 
/* --------------------------------------------------------------------------
 * Emitter static helpers
 * -------------------------------------------------------------------------- */
 
/*
 * Grows a slot's listener arrays by doubling capacity.
 */
static void emitter_grow_slot(emitter_slot_t* slot)
{
    int new_cap = slot->capacity == 0 ? EMITTER_INIT_CAPACITY : slot->capacity * 2;
 
    emitter_listener_fn* l = (emitter_listener_fn*)EMITTER_REALLOC(slot->listeners, (size_t)new_cap * sizeof(emitter_listener_fn));
    void**               u = (void**)              EMITTER_REALLOC(slot->udatas,    (size_t)new_cap * sizeof(void*));
    bool*                o = (bool*)               EMITTER_REALLOC(slot->once,      (size_t)new_cap * sizeof(bool));
 
    EMITTER_ASSERT(l != NULL);
    EMITTER_ASSERT(u != NULL);
    EMITTER_ASSERT(o != NULL);
 
    slot->listeners = l;
    slot->udatas    = u;
    slot->once      = o;
    slot->capacity  = new_cap;
}
 
/*
 * Removes NULL-tombstoned entries from a slot after emit or emitter_off.
 */
static void emitter_compact(emitter_slot_t* slot)
{
    int dst = 0;
 
    for (int src = 0; src < slot->count; src++)
    {
        if (slot->listeners[src] != NULL)
        {
            slot->listeners[dst] = slot->listeners[src];
            slot->udatas[dst]    = slot->udatas[src];
            slot->once[dst]      = slot->once[src];
            dst++;
        }
    }
 
    slot->count = dst;
}
 
/*
 * Internal helper for both emitter_on and emitter_once.
 */
static void emitter_subscribe(emitter_t* emitter, int event,
                              emitter_listener_fn listener, void* udata,
                              bool once)
{
    EMITTER_ASSERT(emitter  != NULL);
    EMITTER_ASSERT(event    >= 0 && event < emitter->num_events);
    EMITTER_ASSERT(listener != NULL);
 
    emitter_slot_t* slot = &emitter->events[event];
 
    if (slot->count == slot->capacity)
    {
        emitter_grow_slot(slot);
    }
 
    slot->listeners[slot->count] = listener;
    slot->udatas[slot->count]    = udata;
    slot->once[slot->count]      = once;
    slot->count++;
}
 
/* --------------------------------------------------------------------------
 * Queued Emitter static helpers
 * -------------------------------------------------------------------------- */
 
static void queued_emitter_grow(queued_emitter_t* qe)
{
    int new_cap = qe->capacity == 0 ? EMITTER_INIT_CAPACITY : qe->capacity * 2;
 
    int*         events = (int*)        EMITTER_REALLOC(qe->events, (size_t)new_cap * sizeof(int));
    const void** datas  = (const void**)EMITTER_REALLOC(qe->datas,  (size_t)new_cap * sizeof(const void*));
 
    EMITTER_ASSERT(events != NULL);
    EMITTER_ASSERT(datas  != NULL);
 
    qe->events   = events;
    qe->datas    = datas;
    qe->capacity = new_cap;
}
 
/* --------------------------------------------------------------------------
 * Arena allocator implementation
 * -------------------------------------------------------------------------- */
 
static arena_block_t* arena_block_create(size_t size)
{
    arena_block_t* block = (arena_block_t*)EMITTER_MALLOC(sizeof(arena_block_t));
 
    if (!block)
        return NULL;
 
    block->memory = (uint8_t*)EMITTER_MALLOC(size);
 
    if (!block->memory)
    {
        EMITTER_FREE(block);
        return NULL;
    }
 
    block->size   = size;
    block->offset = 0;
    block->next   = NULL;
 
    return block;
}
 
static bool arena_init(arena_t* arena, size_t initial_block_size)
{
    arena_block_t* block = arena_block_create(initial_block_size);
 
    if (!block)
        return false;
 
    arena->first      = block;
    arena->current    = block;
    arena->block_size = initial_block_size;
 
    return true;
}
 
static bool arena_grow(arena_t* arena, size_t min_size)
{
    size_t new_size = arena->block_size;
 
    while (new_size < min_size)
    {
        new_size *= 2;
    }
 
    arena_block_t* block = arena_block_create(new_size);
 
    if (!block)
        return false;
 
    arena->current->next = block;
    arena->current       = block;
 
    return true;
}
 
static uintptr_t arena_align_forward(uintptr_t ptr, size_t align)
{
    uintptr_t mask = (uintptr_t)align - 1;
    return (ptr + mask) & ~mask;
}
 
static void* arena_alloc_align(arena_t* arena, size_t size, size_t align)
{
    if ((align & (align - 1)) != 0)
        return NULL; // align must be a power of two
 
    arena_block_t* block = arena->current;
 
    uintptr_t base      = (uintptr_t)block->memory;
    uintptr_t ptr       = base + block->offset;
    uintptr_t aligned   = arena_align_forward(ptr, align);
    size_t    new_offset = (aligned - base) + size;
 
    if (new_offset > block->size)
    {
        size_t required = size + align;
 
        if (!arena_grow(arena, required))
            return NULL;
 
        block      = arena->current;
        base       = (uintptr_t)block->memory;
        aligned    = arena_align_forward(base, align);
        new_offset = (aligned - base) + size;
    }
 
    block->offset = new_offset;
 
    return (void*)aligned;
}
 
static void* arena_alloc(arena_t* arena, size_t size)
{
    return arena_alloc_align(arena, size, alignof(max_align_t));
}
 
static void arena_reset(arena_t* arena)
{
    arena_block_t* block = arena->first->next;
 
    while (block)
    {
        arena_block_t* next = block->next;
        EMITTER_FREE(block->memory);
        EMITTER_FREE(block);
        block = next;
    }
 
    arena->first->next   = NULL;
    arena->first->offset = 0;
    arena->current       = arena->first;
}
 
static void arena_destroy(arena_t* arena)
{
    arena_block_t* block = arena->first;
 
    while (block)
    {
        arena_block_t* next = block->next;
        EMITTER_FREE(block->memory);
        EMITTER_FREE(block);
        block = next;
    }
 
    arena->first   = NULL;
    arena->current = NULL;
}
 
#endif // PICO_EMITTER_IMPLEMENTATION
 
/*
    ----------------------------------------------------------------------------
    This software is available under two licenses (A) or (B). You may choose
    either one as you wish:
    ----------------------------------------------------------------------------
 
    (A) The MIT License
 
    Copyright (c) 2026 James McLean
 
    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.
 
    ----------------------------------------------------------------------------
 
    (B) Public Domain (www.unlicense.org)
 
    This is free and unencumbered software released into the public domain.
 
    Anyone is free to copy, modify, publish, use, compile, sell, or distribute
    this software, either in source code form or as a compiled binary, for any
    purpose, commercial or non-commercial, and by any means.
 
    In jurisdictions that recognize copyright laws, the author or authors of
    this software dedicate any and all copyright interest in the software to the
    public domain. We make this dedication for the benefit of the public at
    large and to the detriment of our heirs and successors. We intend this
    dedication to be an overt act of relinquishment in perpetuity of all present
    and future rights to this software under copyright law.
 
    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 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.
*/
 
// EoF