package core:c/libc

Source

FILE :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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,
	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,
}

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

lldiv_t :: struct {
	quot,
	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 "cdecl" (_: 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,
	tm_min,
	tm_hour,
	tm_mday,
	tm_mon,
	tm_year,
	tm_wday,
	tm_yday,
	tm_isdst: i32,
}

tss_dtor_t :: proc "cdecl" (_: 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 :: struct #align 16 {
	_: [4096]u8,
}

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

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 "odin" (value: $T) -> $T {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cabs :: proc "cdecl" (z: complex_double) -> complex_double ---

cabsf :: proc "cdecl" (z: complex_float) -> complex_float ---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

getenv :: proc "cdecl" (name: cstring) -> [^]u8 ---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

putwchar :: proc "cdecl" (c: u16) -> wint_t ---

qsort :: proc "cdecl" (base: rawptr, nmemb, size: uint, compar: proc "cdecl" (lhs, rhs: rawptr) -> i32) ---

quick_exit :: proc "cdecl" (status: i32) -> ! ---

raise :: proc "cdecl" (sig: i32) -> i32 ---

rand :: proc "cdecl" () -> i32 ---

realloc :: proc "cdecl" (ptr: rawptr, size: uint) -> rawptr ---

remove :: proc "cdecl" (filename: cstring) -> i32 ---

rename :: proc "cdecl" (old, new: cstring) -> i32 ---

rewind :: proc "cdecl" (stream: ^FILE) ---

scanf :: proc "cdecl" (format: cstring, args: ..any) -> i32 ---

setbuf :: proc "cdecl" (stream: ^FILE, buf: [^]u8) ---

setjmp :: proc "cdecl" (env: ^jmp_buf, hack: rawptr = nil) -> i32 ---

setvbuf :: proc "cdecl" (stream: ^FILE, buf: [^]u8, mode: i32, size: uint) -> i32 ---

signal :: proc "cdecl" (sig: i32, func: proc "cdecl" (_: i32)) -> proc "cdecl" (_: i32) ---

snprintf :: proc "cdecl" (s: [^]u8, format: cstring, args: ..any) -> i32 ---

srand :: proc "cdecl" (seed: u32) ---

sscanf :: proc "cdecl" (s, format: cstring, args: ..any) -> i32 ---

strcat :: proc "cdecl" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strchr :: proc "cdecl" (s: cstring, c: i32) -> [^]u8 ---

strcmp :: proc "cdecl" (s1, s2: cstring) -> i32 ---

strcoll :: proc "cdecl" (s1, s2: cstring) -> i32 ---

strcpn :: proc "cdecl" (s1, s2: cstring) -> [^]u8 ---

strcpy :: proc "cdecl" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strcspn :: proc "cdecl" (s1, s2: cstring) -> uint ---

strerror :: proc "cdecl" (errnum: i32) -> [^]u8 ---

strftime :: proc "cdecl" (s: [^]u8, maxsize: uint, format: cstring, timeptr: ^tm) -> uint ---

strlen :: proc "cdecl" (s: cstring) -> uint ---

strncat :: proc "cdecl" (s1: [^]u8, s2: cstring, n: uint) -> [^]u8 ---

strncmp :: proc "cdecl" (s1, s2: cstring, n: uint) -> i32 ---

strncpy :: proc "cdecl" (s1: [^]u8, s2: cstring, n: uint) -> [^]u8 ---

strpbrk :: proc "cdecl" (s1, s2: cstring) -> [^]u8 ---

strrchr :: proc "cdecl" (s: [^]u8, c: i32) -> [^]u8 ---

strtod :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8) -> f64 ---

strtof :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8) -> f32 ---

strtok :: proc "cdecl" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strtol :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8, base: i32) -> i32 ---

strtoll :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8, base: i32) -> i64 ---

strtoul :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8, base: i32) -> u32 ---

strtoull :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8, base: i32) -> u64 ---

strxfrm :: proc "cdecl" (s1: [^]u8, s2: cstring, n: uint) -> uint ---

swprintf :: proc "cdecl" (stream: ^FILE, n: uint, format: [^]u16, arg: ..any) -> i32 ---

swscanf :: proc "cdecl" (s, format: [^]u16, arg: ..any) -> i32 ---

system :: proc "cdecl" (cmd: cstring) -> i32 ---

thrd_create :: proc "cdecl" (thr: ^thrd_t, func: thrd_start_t, arg: rawptr) -> i32 ---

thrd_current :: proc "cdecl" () -> thrd_t ---

thrd_detach :: proc "cdecl" (thr: thrd_t) -> i32 ---

thrd_equal :: proc "cdecl" (lhs, rhs: thrd_t) -> i32 ---

thrd_exit :: proc "cdecl" (res: i32) -> ! ---

thrd_join :: proc "cdecl" (thr: thrd_t, res: ^i32) -> i32 ---

thrd_sleep :: proc "cdecl" (duration, remaining: ^timespec) -> i32 ---

thrd_yield :: proc "cdecl" () ---

time :: proc "cdecl" (timer: ^time_t) -> time_t ---

timespec_get :: proc "cdecl" (ts: ^timespec, base: i32) -> i32 ---

tmpfile :: proc "cdecl" () -> ^FILE ---

tmpnam :: proc "cdecl" (s: [^]u8) -> [^]u8 ---

tolower :: proc "cdecl" (c: i32) -> i32 ---

toupper :: proc "cdecl" (c: i32) -> i32 ---

towctrans :: proc "cdecl" (wc: wint_t, desc: wctrans_t) -> wint_t ---

towlower :: proc "cdecl" (wc: wint_t) -> wint_t ---

towupper :: proc "cdecl" (wc: wint_t) -> wint_t ---

tss_create :: proc "cdecl" (key: ^tss_t, dtor: tss_dtor_t) -> i32 ---

tss_delete :: proc "cdecl" (key: tss_t) ---

tss_get :: proc "cdecl" (key: tss_t) -> rawptr ---

tss_set :: proc "cdecl" (key: tss_t, val: rawptr) -> i32 ---

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

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

va_copy :: proc "odin" (dst, src: ^va_list) {…}

va_end :: proc "odin" (ap: ^va_list) {…}

va_start :: proc "odin" (ap: ^va_list, _: any) {…}

vfprintf :: proc "cdecl" (stream: ^FILE, format: cstring, arg: ^va_list) -> i32 ---

vfscanf :: proc "cdecl" (stream: ^FILE, format: cstring, arg: ^va_list) -> i32 ---

vfwprintf :: proc "cdecl" (stream: ^FILE, format: [^]u16, arg: va_list) -> i32 ---

vfwscanf :: proc "cdecl" (stream: ^FILE, format: [^]u16, arg: va_list) -> i32 ---

vprintf :: proc "cdecl" (format: cstring, arg: ^va_list) -> i32 ---

vscanf :: proc "cdecl" (format: cstring, arg: ^va_list) -> i32 ---

vsnprintf :: proc "cdecl" (s: [^]u8, n: uint, format: cstring, arg: ^va_list) -> i32 ---

vsprintf :: proc "cdecl" (s: [^]u8, format: cstring, arg: ^va_list) -> i32 ---

vsscanf :: proc "cdecl" (s, format: cstring, arg: ^va_list) -> i32 ---

vswprintf :: proc "cdecl" (s: [^]u16, n: uint, format: [^]u16, arg: va_list) -> i32 ---

vswscanf :: proc "cdecl" (s, format: [^]u16, arg: va_list) -> i32 ---

vwprintf :: proc "cdecl" (format: [^]u16, arg: va_list) -> i32 ---

vwscanf :: proc "cdecl" (format: [^]u16, arg: va_list) -> i32 ---

wcrtomb :: proc "cdecl" (s: ^u8, wc: u16, ps: ^mbstate_t) -> uint ---

wcscat :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---

wcschr :: proc "cdecl" (s: [^]u16, c: u16) -> [^]u16 ---

wcscmp :: proc "cdecl" (s1, s2: [^]u16) -> i32 ---

wcscoll :: proc "cdecl" (s1, s2: [^]u16) -> i32 ---

wcscpy :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---

wcscspn :: proc "cdecl" (s1, s2: [^]u16) -> uint ---

wcsftime :: proc "cdecl" (s: [^]u16, maxsize: uint, format: [^]u16, timeptr: ^tm) -> uint ---

wcslen :: proc "cdecl" (s: [^]u16) -> uint ---

wcsncat :: proc "cdecl" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wcsncmp :: proc "cdecl" (s1, s2: [^]u16, n: uint) -> i32 ---

wcsncpy :: proc "cdecl" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wcspbrk :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---

wcsrchr :: proc "cdecl" (s: [^]u16, c: u16) -> [^]u16 ---

wcsrtombs :: proc "cdecl" (dst: ^u8, src: ^[^]u16, len: uint, ps: ^mbstate_t) -> uint ---

wcsspn :: proc "cdecl" (s1, s2: [^]u16) -> uint ---

wcsstr :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---

wcstod :: proc "cdecl" (nptr: [^]u16, endptr: ^[^]u16) -> f64 ---