clean up and standardize types across the codebase, unify atomic operations, improve UTF-8 handling throughout the system, remove obsolete input and named queue interfaces, redesign process preparation and creation, tighten IPC and service boundaries, improve error handling and reliability, minor documentation cleanup, fix doom surfaces, fix panic in ini parsing.

code/public/ntlite/atomic.h

@@ -0,0 +1,98 @@
+// Fixed-width atomic operations for nt-lite-owned storage.
+
+#pragma once
+
+#include <stdint.h>
+#include <intrin.h>
+
+_Static_assert(sizeof(long) == sizeof(int32_t), "MSVC long must be 32-bit");
+_Static_assert(sizeof(__int64) == sizeof(int64_t), "MSVC __int64 must be 64-bit");
+
+// Atomically compares and exchanges a signed 32-bit value.
+static __forceinline int32_t NtlAtomicCompareExchange32(volatile int32_t* destination,
+                                                       int32_t exchange,
+                                                       int32_t comparand) {
+    return (int32_t)_InterlockedCompareExchange((volatile long*)destination,
+                                                (long)exchange,
+                                                (long)comparand);
+}
+
+// Atomically loads a signed 32-bit value.
+static __forceinline int32_t NtlAtomicLoad32(const volatile int32_t* source) {
+    return (int32_t)_InterlockedCompareExchange((volatile long*)source, 0, 0);
+}
+
+// Atomically compares and exchanges an unsigned 32-bit value.
+static __forceinline uint32_t NtlAtomicCompareExchangeU32(volatile uint32_t* destination,
+                                                         uint32_t exchange,
+                                                         uint32_t comparand) {
+    return (uint32_t)_InterlockedCompareExchange((volatile long*)destination,
+                                                 (long)exchange,
+                                                 (long)comparand);
+}
+
+// Atomically loads an unsigned 32-bit value.
+static __forceinline uint32_t NtlAtomicLoadU32(const volatile uint32_t* source) {
+    return (uint32_t)_InterlockedCompareExchange((volatile long*)source, 0, 0);
+}
+
+// Atomically exchanges an unsigned 32-bit value.
+static __forceinline uint32_t NtlAtomicExchangeU32(volatile uint32_t* destination, uint32_t value) {
+    return (uint32_t)_InterlockedExchange((volatile long*)destination, (long)value);
+}
+
+// Atomically exchanges a signed 32-bit value.
+static __forceinline int32_t NtlAtomicExchange32(volatile int32_t* destination, int32_t value) {
+    return (int32_t)_InterlockedExchange((volatile long*)destination, (long)value);
+}
+
+// Atomically increments a signed 32-bit value.
+static __forceinline int32_t NtlAtomicIncrement32(volatile int32_t* destination) {
+    return (int32_t)_InterlockedIncrement((volatile long*)destination);
+}
+
+// Atomically decrements a signed 32-bit value.
+static __forceinline int32_t NtlAtomicDecrement32(volatile int32_t* destination) {
+    return (int32_t)_InterlockedDecrement((volatile long*)destination);
+}
+
+// Atomically compares and exchanges a signed 64-bit value.
+static __forceinline int64_t NtlAtomicCompareExchange64(volatile int64_t* destination,
+                                                       int64_t exchange,
+                                                       int64_t comparand) {
+    return (int64_t)_InterlockedCompareExchange64((volatile __int64*)destination,
+                                                  (__int64)exchange,
+                                                  (__int64)comparand);
+}
+
+// Atomically loads a signed 64-bit value.
+static __forceinline int64_t NtlAtomicLoad64(const volatile int64_t* source) {
+    return (int64_t)_InterlockedCompareExchange64((volatile __int64*)source, 0, 0);
+}
+
+// Atomically increments a signed 64-bit value.
+static __forceinline int64_t NtlAtomicIncrement64(volatile int64_t* destination) {
+    return (int64_t)_InterlockedIncrement64((volatile __int64*)destination);
+}
+
+// Atomically decrements a signed 64-bit value.
+static __forceinline int64_t NtlAtomicDecrement64(volatile int64_t* destination) {
+    return (int64_t)_InterlockedDecrement64((volatile __int64*)destination);
+}
+
+// Atomically adds to a signed 64-bit value and returns the previous value.
+static __forceinline int64_t NtlAtomicExchangeAdd64(volatile int64_t* destination, int64_t value) {
+    return (int64_t)_InterlockedExchangeAdd64((volatile __int64*)destination, (__int64)value);
+}
+
+// Atomically compares and exchanges a pointer value.
+static __forceinline void* NtlAtomicCompareExchangePointer(void* volatile* destination,
+                                                           void* exchange,
+                                                           void* comparand) {
+    return _InterlockedCompareExchangePointer((void* volatile*)destination, exchange, comparand);
+}
+
+// Atomically exchanges a pointer value.
+static __forceinline void* NtlAtomicExchangePointer(void* volatile* destination, void* value) {
+    return _InterlockedExchangePointer((void* volatile*)destination, value);
+}