package core:c/libc

Source

FILE :: struct {}

Locale_Category :: enum i32 {
	ALL      = 0, 
	COLLATE  = 1, 
	CTYPE    = 2, 
	MESSAGES = 6, 
	MONETARY = 3, 
	NUMERIC  = 4, 
	TIME     = 5, 
}

Whence :: enum i32 {
	SET = 0, 
	CUR = 1, 
	END = 2, 
}

atomic_bool :: distinct bool

atomic_char :: distinct u8

atomic_char16_t :: distinct u16

atomic_char32_t :: distinct u32

atomic_flag :: distinct bool

atomic_int :: distinct i32

atomic_int_fast16_t :: distinct i32

atomic_int_fast32_t :: distinct i32

atomic_int_fast64_t :: distinct i64

atomic_int_fast8_t :: distinct i8

atomic_int_least16_t :: distinct i16

atomic_int_least32_t :: distinct i32

atomic_int_least64_t :: distinct i64

atomic_int_least8_t :: distinct i8

atomic_intmax_t :: distinct i64

atomic_intptr_t :: distinct int

atomic_llong :: distinct i64

atomic_long :: distinct i32

atomic_ptrdiff_t :: distinct int

atomic_schar :: distinct u8

atomic_short :: distinct i16

atomic_size_t :: distinct uint

atomic_uchar :: distinct u8

atomic_uint :: distinct u32

atomic_uint_fast16_t :: distinct u32

atomic_uint_fast32_t :: distinct u32

atomic_uint_fast64_t :: distinct u64

atomic_uint_fast8_t :: distinct u8

atomic_uint_least16_t :: distinct u16

atomic_uint_least32_t :: distinct u32

atomic_uint_least64_t :: distinct u64

atomic_uint_least8_t :: distinct u8

atomic_uintmax_t :: distinct u64

atomic_uintptr_t :: distinct uintptr

atomic_ullong :: distinct u64

atomic_ulong :: distinct u32

atomic_ushort :: distinct u16

atomic_wchar_t :: distinct u16

bool :: bool

char :: u8

char16_t :: u16

char32_t :: u32

clock_t :: distinct i32

cnd_t :: distinct rawptr

complex_double :: distinct complex128

complex_float :: distinct complex64

div_t :: struct {
	quot: i32,
	rem:  i32,
}

double :: f64

double_t :: f64

float :: f32

float_t :: f32

fpos_t :: distinct i64

int :: i32

int16_t :: i16

int32_t :: i32

int64_t :: i64

int8_t :: i8

int_fast16_t :: i32

int_fast32_t :: i32

int_fast64_t :: i64

int_fast8_t :: i8

int_least16_t :: i16

int_least32_t :: i32

int_least64_t :: i64

int_least8_t :: i8

intmax_t :: i64

intptr_t :: int

jmp_buf :: struct #align (16) {
	_: [4096]u8,
}

lconv :: struct {
	decimal_point:        cstring,
	thousand_sep:         cstring,
	grouping:             cstring,
	int_curr_symbol:      cstring,
	currency_symbol:      cstring,
	mon_decimal_points:   cstring,
	mon_thousands_sep:    cstring,
	mon_grouping:         cstring,
	positive_sign:        cstring,
	negative_sign:        cstring,
	int_frac_digits:      u8,
	frac_digits:          u8,
	p_cs_precedes:        u8,
	p_sep_by_space:       u8,
	n_cs_precedes:        u8,
	n_sep_by_space:       u8,
	p_sign_posn:          u8,
	n_sign_posn:          u8,
	_W_decimal_point:     [^]u16 `fmt:"s,0"`,
	_W_thousands_sep:     [^]u16 `fmt:"s,0"`,
	_W_int_curr_symbol:   [^]u16 `fmt:"s,0"`,
	_W_currency_symbol:   [^]u16 `fmt:"s,0"`,
	_W_mon_decimal_point: [^]u16 `fmt:"s,0"`,
	_W_mon_thousands_sep: [^]u16 `fmt:"s,0"`,
	_W_positive_sign:     [^]u16 `fmt:"s,0"`,
	_W_negative_sign:     [^]u16 `fmt:"s,0"`,
}

ldiv_t :: struct {
	quot: i32,
	rem:  i32,
}

lldiv_t :: struct {
	quot: i64,
	rem:  i64,
}

long :: i32

longlong :: i64

mbstate_t :: struct #align (16) {
	_: [32]u8,
}

memory_order :: enum i32 {
	relaxed, 
	consume, 
	acquire, 
	release, 
	acq_rel, 
	seq_cst, 
}

mtx_t :: distinct rawptr

once_flag :: distinct i8

ptrdiff_t :: c.ptrdiff_t

schar :: i8

short :: i16

sig_atomic_t :: distinct i32

size_t :: uint

ssize_t :: int

thrd_start_t :: proc "c" (rawptr) -> i32

thrd_t :: struct {
	_: rawptr,
	_: u32,
}

time_t :: distinct i64

timespec :: struct #align (8) {
	tv_sec:  time_t,
	tv_nsec: i32,
}

tm :: struct #align (8) {
	tm_sec:   i32,
	tm_min:   i32,
	tm_hour:  i32,
	tm_mday:  i32,
	tm_mon:   i32,
	tm_year:  i32,
	tm_wday:  i32,
	tm_yday:  i32,
	tm_isdst: i32,
}

tss_dtor_t :: proc "c" (rawptr)

tss_t :: distinct i32

uchar :: u8

uint :: u32

uint16_t :: u16

uint32_t :: u32

uint64_t :: u64

uint8_t :: u8

uint_fast16_t :: u32

uint_fast32_t :: u32

uint_fast64_t :: u64

uint_fast8_t :: u8

uint_least16_t :: u16

uint_least32_t :: u32

uint_least64_t :: u64

uint_least8_t :: u8

uintmax_t :: u64

uintptr_t :: uintptr

ulong :: u32

ulonglong :: u64

ushort :: u16

va_list :: c.va_list

wchar_t :: u16

wctrans_t :: distinct u16

wctype_t :: distinct u16

wint_t :: distinct u16

ATOMIC_BOOL_LOCK_FREE :: true

ATOMIC_CHAR16_T_LOCK_FREE :: true

ATOMIC_CHAR32_T_LOCK_FREE :: true

ATOMIC_CHAR_LOCK_FREE :: true

ATOMIC_INT_LOCK_FREE :: true

ATOMIC_LLONG_LOCK_FREE :: true

ATOMIC_LONG_LOCK_FREE :: true

ATOMIC_POINTER_LOCK_FREE :: true

ATOMIC_SHORT_LOCK_FREE :: true

ATOMIC_WCHAR_T_LOCK_FREE :: true

BUFSIZ :: 512

CHAR_BIT :: 8

CLOCKS_PER_SEC :: 1000

EDOM :: 33

EILSEQ :: 42

EOF: i32 : int(-1)

ERANGE :: 34

EXIT_FAILURE :: 1

EXIT_SUCCESS :: 0

FILENAME_MAX :: 260

FOPEN_MAX :: 20

FP_ILOGB0: i32 : FP_ILOGBNAN

FP_ILOGBNAN: i32 : -1 - int((~uint(0)) >> 1)

FP_INFINITE :: 1

FP_NAN :: 0

FP_NORMAL :: 3

FP_SUBNORMAL :: 4

FP_ZERO :: 2

HUGE_VAL: f64 : double(INFINITY)

HUGE_VALF :: INFINITY

INFINITY :: 1e5000

INT16_MAX: i32 : c.INT16_MAX

INT16_MIN: i32 : c.INT16_MIN

INT32_MAX: i32 : c.INT32_MAX

INT32_MIN: i32 : c.INT32_MIN

INT64_MAX: i64 : c.INT64_MAX

INT64_MIN: i64 : c.INT64_MIN

INT8_MAX: i32 : c.INT8_MAX

INT8_MIN: i32 : c.INT8_MIN

LC_ALL :: 0

LC_COLLATE :: 1

LC_CTYPE :: 2

LC_MESSAGES :: 6

LC_MONETARY :: 3

LC_NUMERIC :: 4

LC_TIME :: 5

L_tmpnam :: 15

MATH_ERREXCEPT :: 2

MATH_ERRNO :: 1

NDEBUG :: !ODIN_DEBUG

NULL :: rawptr(uintptr(0))

PTRDIFF_MAX: c.ptrdiff_t : c.PTRDIFF_MAX

PTRDIFF_MIN: c.ptrdiff_t : c.PTRDIFF_MIN

RAND_MAX :: 0x7fff

SEEK_CUR :: 1

SEEK_END :: 2

SEEK_SET :: 0

SIGABRT :: 22

SIGFPE :: 8

SIGILL :: 4

SIGINT :: 2

SIGSEGV :: 11

SIGTERM :: 15

SIG_ATOMIC_MAX: sig_atomic_t : max(sig_atomic_t)

SIG_ATOMIC_MIN: sig_atomic_t : min(sig_atomic_t)

SIG_DFL :: rawptr(uintptr(0))

SIG_ERR :: rawptr(~uintptr(0))

SIG_IGN :: rawptr(uintptr(1))

SIZE_MAX: uint : c.SIZE_MAX

TIME_UTC :: 1

TMP_MAX :: 32767

TSS_DTOR_ITERATIONS :: 4

UINT16_MAX: i32 : c.UINT16_MAX

UINT32_MAX: u32 : c.UINT32_MAX

UINT64_MAX: u64 : c.UINT64_MAX

UINT8_MAX: i32 : c.UINT8_MAX

WCHAR_MAX: u16 : c.WCHAR_MAX

WCHAR_MIN: u16 : c.WCHAR_MIN

WEOF: wint_t : ~wint_t(0)

WINT_MAX :: 1 << (size_of(wint_t) * 8)

WINT_MIN :: 0

math_errhandling :: 2

memory_order_acq_rel :: memory_order.acq_rel

memory_order_acquire :: memory_order.acquire

memory_order_consume :: memory_order.consume

memory_order_relaxed :: memory_order.relaxed

memory_order_release :: memory_order.release

memory_order_seq_cst :: memory_order.seq_cst

mtx_plain :: 1

mtx_recursive :: 0x100

mtx_timed :: 4

thrd_busy :: 3

thrd_error :: 4

thrd_nomem :: 1

thrd_success :: 0

thrd_timedout :: 2

NAN: f64 = …

stderr: ^FILE = …

stdin: ^FILE = …

stdout: ^FILE = …

ATOMIC_VAR_INIT :: proc(value: $T) -> $T {…}

CMPLX :: proc(x, y: f64) -> complex_double {…}

CMPLXF :: proc(x, y: f32) -> complex_float {…}

MB_CUR_MAX :: proc() -> uint {…}

abort :: proc "c" () -> ! ---

abs :: proc "c" (j: i32) -> i32 ---

aligned_alloc :: proc "c" (alignment, size: uint) -> rawptr {…}

aligned_free :: proc "c" (ptr: rawptr) {…}

asctime :: proc "c" (timeptr: ^tm) -> [^]u8 ---

at_quick_exit :: proc "c" (func: proc "c" ()) -> i32 ---

atexit :: proc "c" (func: proc "c" ()) -> i32 ---

atof :: proc "c" (nptr: cstring) -> f64 ---

atoi :: proc "c" (nptr: cstring) -> i32 ---

atol :: proc "c" (nptr: cstring) -> i32 ---

atoll :: proc "c" (nptr: cstring) -> i64 ---

atomic_compare_exchange_strong :: proc(object, expected: ^$T, desired: $T) -> bool {…}

atomic_compare_exchange_strong_explicit :: proc(object, expected: ^$T, desired: $T, success, failure: memory_order) -> bool {…}

atomic_compare_exchange_weak :: proc(object, expected: ^$T, desired: $T) -> bool {…}

atomic_compare_exchange_weak_explicit :: proc(object, expected: ^$T, desired: $T, success, failure: memory_order) -> bool {…}

atomic_exchange :: proc(object: ^$T, desired: $T) -> $T {…}

atomic_exchange_explicit :: proc(object: ^$T, desired: $T, order: memory_order) -> $T {…}

atomic_fetch_add :: proc(object: ^$T, operand: $T) -> $T {…}

atomic_fetch_add_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $T {…}

atomic_fetch_and :: proc(object: ^$T, operand: $T) -> $T {…}

atomic_fetch_and_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $T {…}

atomic_fetch_or :: proc(object: ^$T, operand: $T) -> $T {…}

atomic_fetch_or_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $T {…}

atomic_fetch_sub :: proc(object: ^$T, operand: $T) -> $T {…}

atomic_fetch_sub_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $T {…}

atomic_fetch_xor :: proc(object: ^$T, operand: $T) -> $T {…}

atomic_fetch_xor_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $T {…}

atomic_flag_clear :: proc(flag: ^atomic_flag) {…}

atomic_flag_clear_explicit :: proc(flag: ^atomic_flag, order: memory_order) {…}

atomic_flag_test_and_set :: proc(flag: ^atomic_flag) -> bool {…}

atomic_flag_test_and_set_explicit :: proc(flag: ^atomic_flag, order: memory_order) -> bool {…}

atomic_init :: proc(obj: ^$T, value: $T) {…}

atomic_is_lock_free :: proc(obj: ^$T) -> bool {…}

atomic_load :: proc(object: ^$T) -> $T {…}

atomic_load_explicit :: proc(object: ^$T, order: memory_order) {…}

atomic_signal_fence :: proc(order: memory_order) {…}

atomic_store :: proc(object: ^$T, desired: $T) {…}

atomic_store_explicit :: proc(object: ^$T, desired: $T, order: memory_order) {…}

atomic_thread_fence :: proc(order: memory_order) {…}

bsearch :: proc "c" (key, base: rawptr, nmemb, size: uint, compar: proc "c" (lhs, rhs: rawptr) -> i32) -> rawptr ---

btowc :: proc "c" (c: i32) -> wint_t ---

c16rtomb :: proc "c" (s: ^u8, c16: u16, ps: ^mbstate_t) -> uint ---

c32rtomb :: proc "c" (s: ^u8, c32: u32, ps: ^mbstate_t) -> uint ---

cabs :: proc "c" (z: complex_double) -> f64 ---

cabsf :: proc "c" (z: complex_float) -> f32 ---

cacos :: proc "c" (z: complex_double) -> complex_double ---

cacosf :: proc "c" (z: complex_float) -> complex_float ---

cacosh :: proc "c" (z: complex_double) -> complex_double ---

cacoshf :: proc "c" (z: complex_float) -> complex_float ---

call_once :: proc "c" (flag: ^once_flag, func: proc "c" ()) ---

calloc :: proc "c" (nmemb, size: uint) -> rawptr ---

carg :: proc "c" (z: complex_double) -> f64 ---

cargf :: proc "c" (z: complex_float) -> f32 ---

casin :: proc "c" (z: complex_double) -> complex_double ---

casinf :: proc "c" (z: complex_float) -> complex_float ---

casinh :: proc "c" (z: complex_double) -> complex_double ---

casinhf :: proc "c" (z: complex_float) -> complex_float ---

catan :: proc "c" (z: complex_double) -> complex_double ---

catanf :: proc "c" (z: complex_float) -> complex_float ---

catanh :: proc "c" (z: complex_double) -> complex_double ---

catanhf :: proc "c" (z: complex_float) -> complex_float ---

ccos :: proc "c" (z: complex_double) -> complex_double ---

ccosf :: proc "c" (z: complex_float) -> complex_float ---

ccosh :: proc "c" (z: complex_double) -> complex_double ---

ccoshf :: proc "c" (z: complex_float) -> complex_float ---

cexp :: proc "c" (z: complex_double) -> complex_double ---

cexpf :: proc "c" (z: complex_float) -> complex_float ---

cimag :: proc "c" (z: complex_double) -> f64 ---

cimagf :: proc "c" (z: complex_float) -> f32 ---

clearerr :: proc "c" (stream: ^FILE) ---

clock :: proc "c" () -> clock_t ---

clog :: proc "c" (z: complex_double) -> complex_double ---

clogf :: proc "c" (z: complex_float) -> complex_float ---

cnd_broadcast :: proc "c" (cond: ^cnd_t) -> i32 ---

cnd_destroy :: proc "c" (cond: ^cnd_t) ---

cnd_init :: proc "c" (cond: ^cnd_t) -> i32 ---

cnd_signal :: proc "c" (cond: ^cnd_t) -> i32 ---

cnd_timedwait :: proc "c" (cond: ^cnd_t, mtx: ^mtx_t, ts: ^timespec) -> i32 ---

cnd_wait :: proc "c" (cond: ^cnd_t, mtx: ^mtx_t) -> i32 ---

conj :: proc "c" (z: complex_double) -> complex_double ---

conjf :: proc "c" (z: complex_float) -> complex_float ---

cpow :: proc "c" (x, y: complex_double) -> complex_double ---

cpowf :: proc "c" (x, y: complex_float) -> complex_float ---

cproj :: proc "c" (z: complex_double) -> complex_double ---

cprojf :: proc "c" (z: complex_float) -> complex_float ---

creal :: proc "c" (z: complex_double) -> f64 ---

crealf :: proc "c" (z: complex_float) -> f32 ---

csin :: proc "c" (z: complex_double) -> complex_double ---

csinf :: proc "c" (z: complex_float) -> complex_float ---

csinh :: proc "c" (z: complex_double) -> complex_double ---

csinhf :: proc "c" (z: complex_float) -> complex_float ---

csqrt :: proc "c" (z: complex_double) -> complex_double ---

csqrtf :: proc "c" (z: complex_float) -> complex_float ---

ctan :: proc "c" (z: complex_double) -> complex_double ---

ctanf :: proc "c" (z: complex_float) -> complex_float ---

ctanh :: proc "c" (z: complex_double) -> complex_double ---

ctanhf :: proc "c" (z: complex_float) -> complex_float ---

ctime :: proc "c" (timer: ^time_t) -> [^]u8 ---

difftime :: proc "c" (time1, time2: time_t) -> f64 ---

div :: proc "c" (numer, denom: i32) -> div_t ---

errno :: proc "contextless" () -> ^i32 {…}

exit :: proc "c" (status: i32) -> ! ---

fclose :: proc "c" (stream: ^FILE) -> i32 ---

feof :: proc "c" (stream: ^FILE) -> i32 ---

ferror :: proc "c" (stream: ^FILE) -> i32 ---

fflush :: proc "c" (stream: ^FILE) -> i32 ---

fgetc :: proc "c" (stream: ^FILE) -> i32 ---

fgetpos :: proc "c" (stream: ^FILE, pos: ^fpos_t) -> i32 ---

fgets :: proc "c" (s: [^]u8, n: i32, stream: ^FILE) -> [^]u8 ---

fgetws :: proc "c" (s: [^]u16, n: i32, stream: ^FILE) -> u16 ---

fopen :: proc "c" (filename, mode: cstring) -> ^FILE ---

fprintf :: proc "c" (stream: ^FILE, format: cstring, .. args: ..any) -> i32 ---

fputc :: proc "c" (s: cstring, stream: ^FILE) -> i32 ---

fputwc :: proc "c" (c: u16, stream: ^FILE) -> wint_t ---

fputws :: proc "c" (s: [^]u16, stream: ^FILE) -> i32 ---

fread :: proc "c" (ptr: rawptr, size: uint, nmemb: uint, stream: ^FILE) -> uint ---

free :: proc "c" (ptr: rawptr) ---

freopen :: proc "c" (filename, mode: cstring, stream: ^FILE) -> ^FILE ---

fscanf :: proc "c" (stream: ^FILE, format: cstring, .. args: ..any) -> i32 ---

fseek :: proc "c" (stream: ^FILE, offset: i32, whence: Whence) -> i32 ---

fsetpos :: proc "c" (stream: ^FILE, pos: ^fpos_t) -> i32 ---

ftell :: proc "c" (stream: ^FILE) -> i32 ---

fwgetc :: proc "c" (stream: ^FILE) -> wint_t ---

fwide :: proc "c" (stream: ^FILE, mode: i32) -> i32 ---

fwprintf :: proc "c" (stream: ^FILE, format: [^]u16, .. arg: ..any) -> i32 ---

fwrite :: proc "c" (ptr: rawptr, size: uint, nmemb: uint, stream: ^FILE) -> uint ---

fwscanf :: proc "c" (stream: ^FILE, format: [^]u16, .. arg: ..any) -> i32 ---

getc :: proc "c" (stream: ^FILE) -> i32 ---

getchar :: proc "c" () -> i32 ---

getenv :: proc "c" (name: cstring) -> cstring ---

getwc :: proc "c" (stream: ^FILE) -> wint_t ---

getwchar :: proc "c" () -> wint_t ---

gmtime :: proc "c" (timer: ^time_t) -> ^tm ---

isalnum :: proc "c" (c: i32) -> i32 ---

isalpha :: proc "c" (c: i32) -> i32 ---

isblank :: proc "c" (c: i32) -> i32 ---

iscntrl :: proc "c" (c: i32) -> i32 ---

isdigit :: proc "c" (c: i32) -> i32 ---

isfinite :: proc(x: $T) -> bool {…}

isgraph :: proc "c" (c: i32) -> i32 ---

isgreater :: proc(x, y: $T) -> bool {…}

isgreaterequal :: proc(x, y: $T) -> bool {…}

isinf :: proc(x: $T) -> bool {…}

isless :: proc(x, y: $T) -> bool {…}

islessequal :: proc(x, y: $T) -> bool {…}

islessgreater :: proc(x, y: $T) -> bool {…}

islower :: proc "c" (c: i32) -> i32 ---

isnan :: proc(x: $T) -> bool {…}

isnormal :: proc(x: $T) -> bool {…}

isprint :: proc "c" (c: i32) -> i32 ---

ispunct :: proc "c" (c: i32) -> i32 ---

isspace :: proc "c" (c: i32) -> i32 ---

isunordered :: proc(x, y: $T) -> bool {…}

isupper :: proc "c" (c: i32) -> i32 ---

iswalnum :: proc "c" (wc: wint_t) -> i32 ---

iswalpha :: proc "c" (wc: wint_t) -> i32 ---

iswblank :: proc "c" (wc: wint_t) -> i32 ---

iswcntrl :: proc "c" (wc: wint_t) -> i32 ---

iswctype :: proc "c" (wc: wint_t, desc: wctype_t) -> i32 ---

iswdigit :: proc "c" (wc: wint_t) -> i32 ---

iswgraph :: proc "c" (wc: wint_t) -> i32 ---

iswlower :: proc "c" (wc: wint_t) -> i32 ---

iswprint :: proc "c" (wc: wint_t) -> i32 ---

iswpunct :: proc "c" (wc: wint_t) -> i32 ---

iswspace :: proc "c" (wc: wint_t) -> i32 ---

iswupper :: proc "c" (wc: wint_t) -> i32 ---

iswxdigit :: proc "c" (wc: wint_t) -> i32 ---

isxdigit :: proc "c" (c: i32) -> i32 ---

kill_dependency :: proc(value: $T) -> $T {…}

labs :: proc "c" (j: i32) -> i32 ---

ldiv :: proc "c" (numer, denom: i32) -> ldiv_t ---

llabs :: proc "c" (j: i64) -> i64 ---

lldiv :: proc "c" (numer, denom: i64) -> lldiv_t ---

localeconv :: proc "c" () -> ^lconv ---

localtime :: proc "c" (timer: ^time_t) -> ^tm ---

longjmp :: proc "c" (env: ^jmp_buf, val: i32) -> ! ---

malloc :: proc "c" (size: uint) -> rawptr ---

mblen :: proc "c" (s: cstring, n: uint) -> i32 ---

mbrlen :: proc "c" (s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtoc16 :: proc "c" (pc16: [^]u16, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtoc32 :: proc "c" (pc32: [^]u32, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtowc :: proc "c" (pwc: [^]u16, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbsinit :: proc "c" (ps: ^mbstate_t) -> i32 ---

mbsrtowcs :: proc "c" (dst: [^]u16, src: ^cstring, len: uint, ps: ^mbstate_t) -> uint ---

mbstowcs :: proc "c" (pwcs: ^u16, s: cstring, n: uint) -> uint ---

mbtowc :: proc "c" (pwc: ^u16, s: cstring, n: uint) -> i32 ---

memchr :: proc "c" (s: rawptr, c: i32, n: uint) -> rawptr ---

memcmp :: proc "c" (s1, s2: rawptr, n: uint) -> i32 ---

memcpy :: proc "c" (s1, s2: rawptr, n: uint) -> rawptr ---

memmove :: proc "c" (s1, s2: rawptr, n: uint) -> rawptr ---

memset :: proc "c" (s: rawptr, c: i32, n: uint) -> rawptr {…}

mktime :: proc "c" (timeptr: ^tm) -> time_t ---

mtx_destroy :: proc "c" (mtx: ^mtx_t) ---

mtx_init :: proc "c" (mtx: ^mtx_t, type: i32) -> i32 ---

mtx_lock :: proc "c" (mtx: ^mtx_t) -> i32 ---

mtx_timedlock :: proc "c" (mtx: ^mtx_t, ts: ^timespec) -> i32 ---

mtx_trylock :: proc "c" (mtx: ^mtx_t) -> i32 ---

mtx_unlock :: proc "c" (mtx: ^mtx_t) -> i32 ---

perror :: proc "c" (s: cstring) ---

printf :: proc "c" (format: cstring, .. args: ..any) -> i32 ---

putc :: proc "c" (c: i32, stream: ^FILE) -> i32 ---

putchar :: proc "c" (c: i32) -> i32 ---

puts :: proc "c" (s: cstring) -> i32 ---

putwc :: proc "c" (c: u16, stream: ^FILE) -> wint_t ---