Home /Modules/impl/sleela_events.c

sleela_events.c

impl/core/sleela_events.c · 273 line(s) · c

#ifndef _WIN32
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif
#endif
#include "sleela_events.h"

#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#include <time.h>
#include <unistd.h>
#endif

#define SL_EVENT_QUEUE_CAPACITY 64

/* NSIG is not part of ISO C and is not exposed under a strict -std=c11 (no
 * feature-test macro). The signal-flag table is clamped to 64 entries anyway,
 * so provide a portable fallback bound when the platform does not define it. */
#ifndef NSIG
#define NSIG 64
#endif

static volatile sig_atomic_t sl_signal_flags[NSIG > 64 ? 64 : NSIG];
static SLEvent sl_queue[SL_EVENT_QUEUE_CAPACITY];
static size_t sl_queue_head;
static size_t sl_queue_tail;
static size_t sl_queue_count;
#ifdef _WIN32
static CRITICAL_SECTION sl_queue_lock;
static INIT_ONCE sl_queue_once = INIT_ONCE_STATIC_INIT;
static BOOL CALLBACK sl_queue_init(PINIT_ONCE once, PVOID param, PVOID* context) {
    (void)once; (void)param; (void)context;
    InitializeCriticalSection(&sl_queue_lock);
    return TRUE;
}
static void sl_lock(void) { InitOnceExecuteOnce(&sl_queue_once, sl_queue_init, NULL, NULL); EnterCriticalSection(&sl_queue_lock); }
static void sl_unlock(void) { LeaveCriticalSection(&sl_queue_lock); }
#else
static pthread_mutex_t sl_queue_lock = PTHREAD_MUTEX_INITIALIZER;
static void sl_lock(void) { pthread_mutex_lock(&sl_queue_lock); }
static void sl_unlock(void) { pthread_mutex_unlock(&sl_queue_lock); }
#endif

static void sl_signal_handler(int signal_number) {
    if (signal_number >= 0 && signal_number < (int)(sizeof(sl_signal_flags) / sizeof(sl_signal_flags[0]))) {
        sl_signal_flags[signal_number] = 1;
    }
#ifdef _WIN32
    /* The Windows CRT resets a signal() handler to SIG_DFL before calling it,
     * so without re-installing, a second delivery would terminate the process
     * (the POSIX branch uses sigaction for the same reason). */
    (void)signal(signal_number, sl_signal_handler);
#endif
}

SLEventPlatform slevent_platform(void) {
#if defined(_WIN32)
    return SL_EVENT_WINDOWS;
#elif defined(__APPLE__)
    return SL_EVENT_MACOS;
#else
    return SL_EVENT_LINUX;
#endif
}

const char* slevent_platform_name(void) {
#if defined(_WIN32)
    return "windows-events";
#elif defined(__APPLE__)
    return "macos-signals-events";
#else
    return "linux-signals-events";
#endif
}

int slevent_platform_is_available(SLEventPlatform platform) {
    if (platform == SL_EVENT_AUTO) return 1;
    return platform == slevent_platform();
}

int slevent_install_signal(int signal_number) {
    if (signal_number <= 0 || signal_number >= (int)(sizeof(sl_signal_flags) / sizeof(sl_signal_flags[0]))) return EINVAL;
#ifdef _WIN32
    return signal(signal_number, sl_signal_handler) == SIG_ERR ? errno : 0;
#else
    /* sigaction, not signal(): signal() resets the handler after the first
     * delivery under strict ISO feature macros (SysV semantics), which made a
     * second delivery kill the process. */
    {
        struct sigaction action;
        memset(&action, 0, sizeof action);
        action.sa_handler = sl_signal_handler;
        sigemptyset(&action.sa_mask);
        action.sa_flags = SA_RESTART;
        return sigaction(signal_number, &action, NULL) == 0 ? 0 : errno;
    }
#endif
}

int slevent_signal_pending(int signal_number) {
    if (signal_number <= 0 || signal_number >= (int)(sizeof(sl_signal_flags) / sizeof(sl_signal_flags[0]))) return 0;
    return sl_signal_flags[signal_number] != 0;
}

int slevent_clear_signal(int signal_number) {
    if (signal_number <= 0 || signal_number >= (int)(sizeof(sl_signal_flags) / sizeof(sl_signal_flags[0]))) return EINVAL;
    sl_signal_flags[signal_number] = 0;
    return 0;
}

#ifdef _WIN32
/* SL_EVENT_INVALID is (HANDLE)-1, which Windows treats as the current-process
 * pseudo-handle: waiting on it would block until the process exits. Reject it
 * (and 0) before any Win32 call, matching the POSIX branch's EINVAL. */
static HANDLE sl_event_handle(SLEventHandle event) {
    return (event == 0 || event == SL_EVENT_INVALID) ? NULL : (HANDLE)(intptr_t)event;
}
#else
/* A manual-reset event: a flag guarded by a mutex, with a condition variable so
 * that waiters block instead of polling and one set releases every waiter. */
typedef struct {
    pthread_mutex_t lock;
    pthread_cond_t cond;
    int state;
} SLEventObject;

#if defined(__APPLE__)
#define SL_EVENT_COND_CLOCK CLOCK_REALTIME   /* no pthread_condattr_setclock on macOS */
#else
#define SL_EVENT_COND_CLOCK CLOCK_MONOTONIC
#endif

static SLEventObject* sl_event_object(SLEventHandle event) {
    return (event == 0 || event == SL_EVENT_INVALID) ? NULL : (SLEventObject*)(intptr_t)event;
}
#endif

SLEventHandle slevent_create(int initial_state) {
#ifdef _WIN32
    HANDLE handle = CreateEventA(NULL, TRUE, initial_state ? TRUE : FALSE, NULL);
    return handle ? (SLEventHandle)(intptr_t)handle : SL_EVENT_INVALID;
#else
    SLEventObject* obj = (SLEventObject*)malloc(sizeof(*obj));
    pthread_condattr_t attr;
    if (!obj) return SL_EVENT_INVALID;
    if (pthread_mutex_init(&obj->lock, NULL) != 0) { free(obj); return SL_EVENT_INVALID; }
    if (pthread_condattr_init(&attr) != 0) { pthread_mutex_destroy(&obj->lock); free(obj); return SL_EVENT_INVALID; }
#if !defined(__APPLE__)
    pthread_condattr_setclock(&attr, SL_EVENT_COND_CLOCK);
#endif
    if (pthread_cond_init(&obj->cond, &attr) != 0) {
        pthread_condattr_destroy(&attr); pthread_mutex_destroy(&obj->lock); free(obj); return SL_EVENT_INVALID;
    }
    pthread_condattr_destroy(&attr);
    obj->state = initial_state ? 1 : 0;
    return (SLEventHandle)(intptr_t)obj;
#endif
}

int slevent_set(SLEventHandle event) {
#ifdef _WIN32
    HANDLE handle = sl_event_handle(event);
    if (!handle) return EINVAL;
    return SetEvent(handle) ? 0 : (int)GetLastError();
#else
    SLEventObject* obj = sl_event_object(event);
    if (!obj) return EINVAL;
    pthread_mutex_lock(&obj->lock);
    obj->state = 1;
    pthread_cond_broadcast(&obj->cond);
    pthread_mutex_unlock(&obj->lock);
    return 0;
#endif
}

int slevent_reset(SLEventHandle event) {
#ifdef _WIN32
    HANDLE handle = sl_event_handle(event);
    if (!handle) return EINVAL;
    return ResetEvent(handle) ? 0 : (int)GetLastError();
#else
    SLEventObject* obj = sl_event_object(event);
    if (!obj) return EINVAL;
    pthread_mutex_lock(&obj->lock);
    obj->state = 0;
    pthread_mutex_unlock(&obj->lock);
    return 0;
#endif
}

int slevent_wait(SLEventHandle event, uint32_t timeout_ms) {
#ifdef _WIN32
    HANDLE handle = sl_event_handle(event);
    DWORD result;
    if (!handle) return EINVAL;
    result = WaitForSingleObject(handle, timeout_ms == UINT32_MAX ? INFINITE : timeout_ms);
    return result == WAIT_OBJECT_0 ? 0 : (result == WAIT_TIMEOUT ? ETIMEDOUT : (int)GetLastError());
#else
    SLEventObject* obj = sl_event_object(event);
    int rc = 0;
    if (!obj) return EINVAL;
    pthread_mutex_lock(&obj->lock);
    if (!obj->state && timeout_ms == UINT32_MAX) {
        while (!obj->state) pthread_cond_wait(&obj->cond, &obj->lock);
    } else if (!obj->state && timeout_ms > 0) {
        struct timespec deadline;
        clock_gettime(SL_EVENT_COND_CLOCK, &deadline);
        deadline.tv_sec += (time_t)(timeout_ms / 1000u);
        deadline.tv_nsec += (long)(timeout_ms % 1000u) * 1000000L;
        if (deadline.tv_nsec >= 1000000000L) { deadline.tv_sec += 1; deadline.tv_nsec -= 1000000000L; }
        while (!obj->state && rc == 0) rc = pthread_cond_timedwait(&obj->cond, &obj->lock, &deadline);
    }
    rc = obj->state ? 0 : ETIMEDOUT;
    pthread_mutex_unlock(&obj->lock);
    return rc;
#endif
}

int slevent_close(SLEventHandle event) {
#ifdef _WIN32
    HANDLE handle = sl_event_handle(event);
    if (!handle) return EINVAL;
    return CloseHandle(handle) ? 0 : (int)GetLastError();
#else
    SLEventObject* obj = sl_event_object(event);
    if (!obj) return EINVAL;
    pthread_cond_destroy(&obj->cond);
    pthread_mutex_destroy(&obj->lock);
    free(obj);
    return 0;
#endif
}

int slevent_valid(SLEventHandle event) {
    return event != SL_EVENT_INVALID && event != 0;
}

int slevent_post(uint32_t type, uint32_t code, intptr_t value) {
    sl_lock();
    if (sl_queue_count == SL_EVENT_QUEUE_CAPACITY) {
        sl_unlock();
        return EAGAIN;
    }
    sl_queue[sl_queue_tail].type = type;
    sl_queue[sl_queue_tail].code = code;
    sl_queue[sl_queue_tail].value = value;
    sl_queue_tail = (sl_queue_tail + 1U) % SL_EVENT_QUEUE_CAPACITY;
    ++sl_queue_count;
    sl_unlock();
    return 0;
}

int slevent_poll(SLEvent* event) {
    if (!event) return EINVAL;
    sl_lock();
    if (sl_queue_count == 0) {
        sl_unlock();
        return 0;
    }
    *event = sl_queue[sl_queue_head];
    sl_queue_head = (sl_queue_head + 1U) % SL_EVENT_QUEUE_CAPACITY;
    --sl_queue_count;
    sl_unlock();
    return 1;
}