@shd101wyy/yo 0.0.2

package/std/libc/signal.yo

@@ -0,0 +1,101 @@
+// C11 signal.h - Signal handling functions and constants
+// Provides signal handling capabilities for process control
+
+c_include "<signal.h>",
+  // Signal handler type
+  // Note: In C this is: void (*signal(int sig, void (*func)(int)))(int)
+  // We simplify this for Yo
+  signal :
+    fn(sig : int, func : (fn(signal_num : int) -> unit)) -> (fn(signal_num : int) -> unit),
+  
+  // Raise a signal
+  raise :
+    fn(sig : int) -> int,
+
+  // Standard signal numbers (POSIX.1)
+  SIGHUP : int,      // Hangup
+  SIGINT : int,      // Interrupt (Ctrl+C)
+  SIGQUIT : int,     // Quit (Ctrl+\)
+  SIGILL : int,      // Illegal instruction
+  SIGTRAP : int,     // Trace/breakpoint trap
+  SIGABRT : int,     // Abort signal
+  SIGBUS : int,      // Bus error
+  SIGFPE : int,      // Floating point exception
+  SIGKILL : int,     // Kill signal (cannot be caught)
+  SIGUSR1 : int,     // User-defined signal 1
+  SIGSEGV : int,     // Segmentation fault
+  SIGUSR2 : int,     // User-defined signal 2
+  SIGPIPE : int,     // Broken pipe
+  SIGALRM : int,     // Alarm clock
+  SIGTERM : int,     // Termination signal
+  SIGCHLD : int,     // Child status changed
+  SIGCONT : int,     // Continue if stopped
+  SIGSTOP : int,     // Stop executing (cannot be caught)
+  SIGTSTP : int,     // Terminal stop signal (Ctrl+Z)
+  SIGTTIN : int,     // Background process attempting read
+  SIGTTOU : int,     // Background process attempting write
+  SIGURG : int,      // Urgent condition on socket
+  SIGXCPU : int,     // CPU limit exceeded
+  SIGXFSZ : int,     // File size limit exceeded
+  SIGVTALRM : int,   // Virtual alarm clock
+  SIGPROF : int,     // Profiling alarm clock
+  SIGWINCH : int,    // Window resize signal
+  SIGIO : int,       // I/O now possible
+  SIGPWR : int,      // Power failure restart
+  SIGSYS : int,      // Bad system call
+
+  // Signal handling constants
+  SIG_DFL : (fn(signal_num : int) -> unit),  // Default signal handling
+  SIG_IGN : (fn(signal_num : int) -> unit),  // Ignore signal
+  SIG_ERR : (fn(signal_num : int) -> unit),  // Signal error return
+
+  // C11 - Additional signal handling (optional)
+  sig_atomic_t : Type         // Type for atomic signal variables
+;
+
+// Export all signal functionality
+export 
+  // Signal functions
+  signal,
+  raise,
+
+  // Standard signals
+  SIGHUP,
+  SIGINT,
+  SIGQUIT,
+  SIGILL,
+  SIGTRAP,
+  SIGABRT,
+  SIGBUS,
+  SIGFPE,
+  SIGKILL,
+  SIGUSR1,
+  SIGSEGV,
+  SIGUSR2,
+  SIGPIPE,
+  SIGALRM,
+  SIGTERM,
+  SIGCHLD,
+  SIGCONT,
+  SIGSTOP,
+  SIGTSTP,
+  SIGTTIN,
+  SIGTTOU,
+  SIGURG,
+  SIGXCPU,
+  SIGXFSZ,
+  SIGVTALRM,
+  SIGPROF,
+  SIGWINCH,
+  SIGIO,
+  SIGPWR,
+  SIGSYS,
+
+  // Signal handling constants
+  SIG_DFL,
+  SIG_IGN,
+  SIG_ERR,
+
+  // Types
+  sig_atomic_t
+;

package/std/libc/stdatomic.yo

@@ -0,0 +1,213 @@
+// C11 Atomic Operations and Types
+// Corresponds to C's <stdatomic.h>
+
+c_include "<stdatomic.h>",  
+  // Atomic types
+  atomic_bool: Type,
+  atomic_char: Type,
+  atomic_schar: Type,
+  atomic_uchar: Type,
+  atomic_short: Type,
+  atomic_ushort: Type,
+  atomic_int: Type,
+  atomic_uint: Type,
+  atomic_long: Type,
+  atomic_ulong: Type,
+  atomic_llong: Type,
+  atomic_ullong: Type,
+  atomic_char16_t: Type,
+  atomic_char32_t: Type,
+  atomic_wchar_t: Type,
+  atomic_int_least8_t: Type,
+  atomic_uint_least8_t: Type,
+  atomic_int_least16_t: Type,
+  atomic_uint_least16_t: Type,
+  atomic_int_least32_t: Type,
+  atomic_uint_least32_t: Type,
+  atomic_int_least64_t: Type,
+  atomic_uint_least64_t: Type,
+  atomic_int_fast8_t: Type,
+  atomic_uint_fast8_t: Type,
+  atomic_int_fast16_t: Type,
+  atomic_uint_fast16_t: Type,
+  atomic_int_fast32_t: Type,
+  atomic_uint_fast32_t: Type,
+  atomic_int_fast64_t: Type,
+  atomic_uint_fast64_t: Type,
+  atomic_intptr_t: Type,
+  atomic_uintptr_t: Type,
+  atomic_size_t: Type,
+  atomic_ptrdiff_t: Type,
+  atomic_intmax_t: Type,
+  atomic_uintmax_t: Type,
+
+  // Memory order enumeration
+  memory_order: Type,
+  memory_order_relaxed: memory_order,
+  memory_order_consume: memory_order,
+  memory_order_acquire: memory_order,
+  memory_order_release: memory_order,
+  memory_order_acq_rel: memory_order,
+  memory_order_seq_cst: memory_order,
+
+  // Atomic flag type
+  atomic_flag: Type,
+  ATOMIC_FLAG_INIT: atomic_flag,
+
+  // Generic atomic operations
+  atomic_init: 
+    fn(obj: *(atomic_bool), value: bool) -> unit,
+  atomic_load: 
+    fn(obj: *(atomic_bool)) -> bool,
+  atomic_load_explicit: 
+    fn(obj: *(atomic_bool), order: memory_order) -> bool,
+  atomic_store: 
+    fn(obj: *(atomic_bool), desired: bool) -> unit,
+  atomic_store_explicit: 
+    fn(obj: *(atomic_bool), desired: bool, order: memory_order) -> unit,
+  atomic_exchange: 
+    fn(obj: *(atomic_bool), desired: bool) -> bool,
+  atomic_exchange_explicit: 
+    fn(obj: *(atomic_bool), desired: bool, order: memory_order) -> bool,
+  atomic_compare_exchange_strong: 
+    fn(obj: *(atomic_bool), expected: *(bool), desired: bool) -> bool,
+  atomic_compare_exchange_strong_explicit: 
+    fn(obj: *(atomic_bool), expected: *(bool), desired: bool, success: memory_order, failure: memory_order) -> bool,
+  atomic_compare_exchange_weak: 
+    fn(obj: *(atomic_bool), expected: *(bool), desired: bool) -> bool,
+  atomic_compare_exchange_weak_explicit: 
+    fn(obj: *(atomic_bool), expected: *(bool), desired: bool, success: memory_order, failure: memory_order) -> bool,
+
+  // Integer atomic operations
+  atomic_fetch_add: 
+    fn(obj: *(atomic_int), arg: int) -> int,
+  atomic_fetch_add_explicit: 
+    fn(obj: *(atomic_int), arg: int, order: memory_order) -> int,
+  atomic_fetch_sub: 
+    fn(obj: *(atomic_int), arg: int) -> int,
+  atomic_fetch_sub_explicit: 
+    fn(obj: *(atomic_int), arg: int, order: memory_order) -> int,
+  atomic_fetch_or: 
+    fn(obj: *(atomic_int), arg: int) -> int,
+  atomic_fetch_or_explicit: 
+    fn(obj: *(atomic_int), arg: int, order: memory_order) -> int,
+  atomic_fetch_xor: 
+    fn(obj: *(atomic_int), arg: int) -> int,
+  atomic_fetch_xor_explicit: 
+    fn(obj: *(atomic_int), arg: int, order: memory_order) -> int,
+  atomic_fetch_and: 
+    fn(obj: *(atomic_int), arg: int) -> int,
+  atomic_fetch_and_explicit: 
+    fn(obj: *(atomic_int), arg: int, order: memory_order) -> int,
+
+  // Pointer atomic operations
+  atomic_load_ptr: 
+    fn(obj: *(*(void))) -> *(void),
+  atomic_store_ptr: 
+    fn(obj: *(*(void)), desired: *(void)) -> unit,
+  atomic_exchange_ptr: 
+    fn(obj: *(*(void)), desired: *(void)) -> *(void),
+  atomic_compare_exchange_strong_ptr: 
+    fn(obj: *(*(void)), expected: *(*(void)), desired: *(void)) -> bool,
+  atomic_compare_exchange_weak_ptr: 
+    fn(obj: *(*(void)), expected: *(*(void)), desired: *(void)) -> bool,
+
+  // Atomic flag operations
+  atomic_flag_test_and_set: 
+    fn(obj: *(atomic_flag)) -> bool,
+  atomic_flag_test_and_set_explicit: 
+    fn(obj: *(atomic_flag), order: memory_order) -> bool,
+  atomic_flag_clear: 
+    fn(obj: *(atomic_flag)) -> unit,
+  atomic_flag_clear_explicit: 
+    fn(obj: *(atomic_flag), order: memory_order) -> unit,
+
+  // Memory fences
+  atomic_thread_fence: 
+    fn(order: memory_order) -> unit,
+  atomic_signal_fence: 
+    fn(order: memory_order) -> unit,
+
+  // Lock-free property query
+  atomic_is_lock_free: 
+    fn(obj: *(atomic_bool)) -> bool,
+
+  // Kill dependency
+  kill_dependency: 
+    fn(y: i32) -> i32,
+
+  // Lock-free constants
+  ATOMIC_BOOL_LOCK_FREE: i32,
+  ATOMIC_CHAR_LOCK_FREE: i32,
+  ATOMIC_CHAR16_T_LOCK_FREE: i32,
+  ATOMIC_CHAR32_T_LOCK_FREE: i32,
+  ATOMIC_WCHAR_T_LOCK_FREE: i32,
+  ATOMIC_SHORT_LOCK_FREE: i32,
+  ATOMIC_INT_LOCK_FREE: i32,
+  ATOMIC_LONG_LOCK_FREE: i32,
+  ATOMIC_LLONG_LOCK_FREE: i32,
+  ATOMIC_POINTER_LOCK_FREE: i32;
+
+export
+  // Atomic types
+  atomic_bool, atomic_char, atomic_schar, atomic_uchar,
+  atomic_short, atomic_ushort, atomic_int, atomic_uint,
+  atomic_long, atomic_ulong, atomic_llong, atomic_ullong,
+  atomic_char16_t, atomic_char32_t, atomic_wchar_t,
+  atomic_int_least8_t, atomic_uint_least8_t,
+  atomic_int_least16_t, atomic_uint_least16_t,
+  atomic_int_least32_t, atomic_uint_least32_t,
+  atomic_int_least64_t, atomic_uint_least64_t,
+  atomic_int_fast8_t, atomic_uint_fast8_t,
+  atomic_int_fast16_t, atomic_uint_fast16_t,
+  atomic_int_fast32_t, atomic_uint_fast32_t,
+  atomic_int_fast64_t, atomic_uint_fast64_t,
+  atomic_intptr_t, atomic_uintptr_t,
+  atomic_size_t, atomic_ptrdiff_t,
+  atomic_intmax_t, atomic_uintmax_t,
+  
+  // Memory order and flag types
+  memory_order, atomic_flag,
+  
+  // Memory order constants
+  memory_order_relaxed, memory_order_consume,
+  memory_order_acquire, memory_order_release,
+  memory_order_acq_rel, memory_order_seq_cst,
+  
+  // Generic atomic operations
+  atomic_init, atomic_load, atomic_load_explicit,
+  atomic_store, atomic_store_explicit,
+  atomic_exchange, atomic_exchange_explicit,
+  atomic_compare_exchange_strong, atomic_compare_exchange_strong_explicit,
+  atomic_compare_exchange_weak, atomic_compare_exchange_weak_explicit,
+  
+  // Integer atomic operations
+  atomic_fetch_add, atomic_fetch_add_explicit,
+  atomic_fetch_sub, atomic_fetch_sub_explicit,
+  atomic_fetch_or, atomic_fetch_or_explicit,
+  atomic_fetch_xor, atomic_fetch_xor_explicit,
+  atomic_fetch_and, atomic_fetch_and_explicit,
+  
+  // Pointer atomic operations
+  atomic_load_ptr, atomic_store_ptr, atomic_exchange_ptr,
+  atomic_compare_exchange_strong_ptr, atomic_compare_exchange_weak_ptr,
+  
+  // Atomic flag operations
+  atomic_flag_test_and_set, atomic_flag_test_and_set_explicit,
+  atomic_flag_clear, atomic_flag_clear_explicit,
+  
+  // Memory fences
+  atomic_thread_fence, atomic_signal_fence,
+  
+  // Lock-free property
+  atomic_is_lock_free,
+  
+  // Lock-free constants
+  ATOMIC_BOOL_LOCK_FREE, ATOMIC_CHAR_LOCK_FREE,
+  ATOMIC_CHAR16_T_LOCK_FREE, ATOMIC_CHAR32_T_LOCK_FREE,
+  ATOMIC_WCHAR_T_LOCK_FREE, ATOMIC_SHORT_LOCK_FREE,
+  ATOMIC_INT_LOCK_FREE, ATOMIC_LONG_LOCK_FREE,
+  ATOMIC_LLONG_LOCK_FREE, ATOMIC_POINTER_LOCK_FREE,
+  
+  // Kill dependency
+  kill_dependency;

package/std/libc/stdint.yo

@@ -0,0 +1,214 @@
+// C11 stdint.h - Fixed-width integer types and limits
+// Note: Yo already has i8, i16, i32, i64, u8, u16, u32, u64
+// This file provides C-compatible aliases and additional types/constants
+
+// Type aliases for C compatibility (mapping Yo types to C stdint names)
+int8_t :: i8;
+int16_t :: i16;
+int32_t :: i32;
+int64_t :: i64;
+uint8_t :: u8;
+uint16_t :: u16;
+uint32_t :: u32;
+uint64_t :: u64;
+
+c_include "<stdint.h>",
+  // Additional types needed for some limits
+  wint_t : Type,
+
+  // Least-width integer types (at least N bits)
+  int_least8_t : Type,
+  int_least16_t : Type,
+  int_least32_t : Type,
+  int_least64_t : Type,
+  uint_least8_t : Type,
+  uint_least16_t : Type,
+  uint_least32_t : Type,
+  uint_least64_t : Type,
+
+  // Fastest minimum-width integer types (fastest with at least N bits)
+  int_fast8_t : Type,
+  int_fast16_t : Type,
+  int_fast32_t : Type,
+  int_fast64_t : Type,
+  uint_fast8_t : Type,
+  uint_fast16_t : Type,
+  uint_fast32_t : Type,
+  uint_fast64_t : Type,
+
+  // Pointer-sized integers
+  intptr_t : Type,
+  uintptr_t : Type,
+
+  // Maximum-width integer types
+  intmax_t : Type,
+  uintmax_t : Type,
+
+  // Limits for exact-width integer types
+  INT8_MIN : i8,
+  INT8_MAX : i8,
+  INT16_MIN : i16,
+  INT16_MAX : i16,
+  INT32_MIN : i32,
+  INT32_MAX : i32,
+  INT64_MIN : i64,
+  INT64_MAX : i64,
+  UINT8_MAX : u8,
+  UINT16_MAX : u16,
+  UINT32_MAX : u32,
+  UINT64_MAX : u64,
+
+  // Limits for least-width integer types
+  INT_LEAST8_MIN : int_least8_t,
+  INT_LEAST8_MAX : int_least8_t,
+  INT_LEAST16_MIN : int_least16_t,
+  INT_LEAST16_MAX : int_least16_t,
+  INT_LEAST32_MIN : int_least32_t,
+  INT_LEAST32_MAX : int_least32_t,
+  INT_LEAST64_MIN : int_least64_t,
+  INT_LEAST64_MAX : int_least64_t,
+  UINT_LEAST8_MAX : uint_least8_t,
+  UINT_LEAST16_MAX : uint_least16_t,
+  UINT_LEAST32_MAX : uint_least32_t,
+  UINT_LEAST64_MAX : uint_least64_t,
+
+  // Limits for fastest minimum-width integer types
+  INT_FAST8_MIN : int_fast8_t,
+  INT_FAST8_MAX : int_fast8_t,
+  INT_FAST16_MIN : int_fast16_t,
+  INT_FAST16_MAX : int_fast16_t,
+  INT_FAST32_MIN : int_fast32_t,
+  INT_FAST32_MAX : int_fast32_t,
+  INT_FAST64_MIN : int_fast64_t,
+  INT_FAST64_MAX : int_fast64_t,
+  UINT_FAST8_MAX : uint_fast8_t,
+  UINT_FAST16_MAX : uint_fast16_t,
+  UINT_FAST32_MAX : uint_fast32_t,
+  UINT_FAST64_MAX : uint_fast64_t,
+
+  // Limits for pointer-sized integer types
+  INTPTR_MIN : intptr_t,
+  INTPTR_MAX : intptr_t,
+  UINTPTR_MAX : uintptr_t,
+
+  // Limits for maximum-width integer types
+  INTMAX_MIN : intmax_t,
+  INTMAX_MAX : intmax_t,
+  UINTMAX_MAX : uintmax_t,
+
+  // Limits for ptrdiff_t, size_t, and sig_atomic_t
+  PTRDIFF_MIN : isize,
+  PTRDIFF_MAX : isize,
+  SIZE_MAX : usize,
+  SIG_ATOMIC_MIN : int,
+  SIG_ATOMIC_MAX : int,
+
+  // Limits for wint_t (wide character input type)
+  WINT_MIN : wint_t,
+  WINT_MAX : wint_t
+;
+
+// Export all stdint functionality
+export 
+  // C-compatible type aliases
+  int8_t,
+  int16_t,
+  int32_t,
+  int64_t,
+  uint8_t,
+  uint16_t,
+  uint32_t,
+  uint64_t,
+
+  // Least-width types
+  int_least8_t,
+  int_least16_t,
+  int_least32_t,
+  int_least64_t,
+  uint_least8_t,
+  uint_least16_t,
+  uint_least32_t,
+  uint_least64_t,
+
+  // Fastest minimum-width types
+  int_fast8_t,
+  int_fast16_t,
+  int_fast32_t,
+  int_fast64_t,
+  uint_fast8_t,
+  uint_fast16_t,
+  uint_fast32_t,
+  uint_fast64_t,
+
+  // Pointer-sized types
+  intptr_t,
+  uintptr_t,
+
+  // Maximum-width types
+  intmax_t,
+  uintmax_t,
+
+  // Exact-width limits
+  INT8_MIN,
+  INT8_MAX,
+  INT16_MIN,
+  INT16_MAX,
+  INT32_MIN,
+  INT32_MAX,
+  INT64_MIN,
+  INT64_MAX,
+  UINT8_MAX,
+  UINT16_MAX,
+  UINT32_MAX,
+  UINT64_MAX,
+
+  // Least-width limits
+  INT_LEAST8_MIN,
+  INT_LEAST8_MAX,
+  INT_LEAST16_MIN,
+  INT_LEAST16_MAX,
+  INT_LEAST32_MIN,
+  INT_LEAST32_MAX,
+  INT_LEAST64_MIN,
+  INT_LEAST64_MAX,
+  UINT_LEAST8_MAX,
+  UINT_LEAST16_MAX,
+  UINT_LEAST32_MAX,
+  UINT_LEAST64_MAX,
+
+  // Fastest minimum-width limits
+  INT_FAST8_MIN,
+  INT_FAST8_MAX,
+  INT_FAST16_MIN,
+  INT_FAST16_MAX,
+  INT_FAST32_MIN,
+  INT_FAST32_MAX,
+  INT_FAST64_MIN,
+  INT_FAST64_MAX,
+  UINT_FAST8_MAX,
+  UINT_FAST16_MAX,
+  UINT_FAST32_MAX,
+  UINT_FAST64_MAX,
+
+  // Pointer-sized limits
+  INTPTR_MIN,
+  INTPTR_MAX,
+  UINTPTR_MAX,
+
+  // Maximum-width limits
+  INTMAX_MIN,
+  INTMAX_MAX,
+  UINTMAX_MAX,
+
+  // Other limits
+  PTRDIFF_MIN,
+  PTRDIFF_MAX,
+  SIZE_MAX,
+  SIG_ATOMIC_MIN,
+  SIG_ATOMIC_MAX,
+  WINT_MIN,
+  WINT_MAX,
+
+  // Additional types
+  wint_t
+;