#ifndef _WIN32 #ifndef _POSIX_C_SOURCE #define _POSIX_C_SOURCE 200809L #endif #endif #include "sleela_events.h" #include #include #include #include #ifdef _WIN32 #include #else #include #include #include #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; }