package vendor:libc-shim

Source

Clock :: enum i32 {
	Monotonic = 1, 
}

FILE :: rawptr

Time_Spec :: struct {
	tv_sec:  i64,
	tv_nsec: i64,
}

clock_t :: i64

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

ATEXIT_MAX :: 32

EOF :: -1

abort :: proc "c" () -> ! {…}

abs :: proc "c" (x: i32) -> i32 {…}

acos :: proc "c" (x: f64) -> f64 {…}

acosf :: proc "c" (x: f32) -> f32 {…}

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

asin :: proc "c" (x: f64) -> f64 {…}

atan :: proc "c" (x: f64) -> f64 {…}

atan2 :: proc "c" (y, x: f64) -> f64 {…}

atan2f :: proc "c" (v: f32, v2: f32) -> f32 {…}

atexit :: proc "c" (function: proc "c" () -> !) -> i32 {…}

atof :: proc "c" (str: cstring) -> f64 {…}

atoi :: proc "c" (str: cstring) -> i32 {…}

atol :: proc "c" (str: cstring) -> i32 {…}

atoll :: proc "c" (str: cstring) -> i64 {…}

ceil :: proc "c" (x: f64) -> f64 {…}

ceilf :: proc "c" (x: f32) -> f32 {…}

clock :: proc "c" () -> i64 {…}

clock_gettine :: proc "c" (clockid: Clock, tp: ^Time_Spec) -> i32 {…}

cos :: proc "c" (x: f64) -> f64 {…}

cosf :: proc "c" (v: f32) -> f32 {…}

exit :: proc "c" (exit_code: i32) -> ! {…}

exp :: proc "c" (x: f64) -> f64 {…}

fabs :: proc "c" (x: f64) -> f64 {…}

fabsf :: proc "c" (x: f32) -> f32 {…}

fclose :: proc "c" (file: rawptr) -> i32 {…}

floor :: proc "c" (x: f64) -> f64 {…}

floorf :: proc "c" (x: f32) -> f32 {…}

fmod :: proc "c" (x, y: f64) -> f64 {…}

fmodf :: proc "c" (x, y: f32) -> f32 {…}

fopen :: proc "c" (path: cstring, mode: cstring) -> rawptr {…}

fread :: proc "c" (buffer: [^]u8, size: uint, count: uint, file: rawptr) -> uint {…}

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

fseek :: proc "c" (file: rawptr, offset: i32, whence: i32) -> i32 {…}

ftell :: proc "c" (file: rawptr) -> i32 {…}

fwrite :: proc "c" (buffer: [^]u8, size: uint, count: uint, file: rawptr) -> uint {…}

getchar :: proc "c" () -> i32 {…}

init_context :: proc "contextless" () {…}

isblank :: proc "c" (c: i32) -> b32 {…}

isdigit :: proc "c" (c: i32) -> b32 {…}

isfinited :: proc "c" (x: f64) -> bool {…}

isfinitef :: proc "c" (x: f32) -> bool {…}

isinfd :: proc "c" (v: f64) -> bool {…}

isinff :: proc "c" (v: f32) -> bool {…}

isnand :: proc "c" (v: f64) -> bool {…}

isnanf :: proc "c" (v: f32) -> bool {…}

isspace :: proc "c" (c: i32) -> b32 {…}

ldexp :: proc "c" (x: f64, y: i32) -> f64 {…}

ldiv :: proc "c" (number: i32, denom: i32) -> ldiv_t {…}

log :: proc "c" (x: f64) -> f64 {…}

log10 :: proc "c" (x: f64) -> f64 {…}

log2 :: proc "c" (x: f64) -> f64 {…}

logf :: proc "c" (x: f32) -> f32 {…}

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

memchr :: proc "c" (str: [^]u8, c: i32, n: uint) -> [^]u8 {…}

memcmp :: proc "c" (lhs: [^]u8, rhs: [^]u8, count: uint) -> i32 {…}

modf :: proc "c" (num: f64, iptr: ^f64) -> f64 {…}

pow :: proc "c" (x, y: f64) -> f64 {…}

powf :: proc "c" (x, y: f32) -> f32 {…}

putchar :: proc "c" (char: i32) -> i32 {…}

qsort :: proc "c" (base: rawptr, num: uint, size: uint, cmp: proc "c" (a, b: rawptr) -> i32) {…}

realloc :: proc "c" (ptr: rawptr, new_size: uint) -> rawptr {…}

remainderf :: proc "c" (x, y: f32) -> f32 {…}

sched_yield :: proc "c" () -> i32 {…}

set_context :: proc(ctx: runtime.Context = context) {…}

sin :: proc "c" (x: f64) -> f64 {…}

sinf :: proc "c" (v: f32) -> f32 {…}

sqrt :: proc "c" (x: f64) -> f64 {…}

sqrtf :: proc "c" (v: f32) -> f32 {…}

strchr :: proc "c" (str: cstring, ch: i32) -> cstring {…}

strcmp :: proc "c" (lhs: cstring, rhs: cstring) -> i32 {…}

strcpy :: proc "c" (dst: [^]u8, src: cstring) -> cstring {…}

strcspn :: proc "c" (dst: cstring, src: cstring) -> uint {…}

strlen :: proc "c" (str: cstring) -> u32 {…}

strncmp :: proc "c" (lhs: cstring, rhs: cstring, count: uint) -> i32 {…}

strncpy :: proc "c" (dst: [^]u8, src: cstring, count: uint) -> cstring {…}

strrchr :: proc "c" (str: cstring, ch: i32) -> cstring {…}

strstr :: proc "c" (str: cstring, substr: cstring) -> cstring {…}

strtod :: proc "c" (str: cstring, str_end: ^cstring) -> f64 {…}

strtol :: proc "c" (str: cstring, str_end: ^cstring, base: i32) -> i32 {…}

tan :: proc "c" (x: f64) -> f64 {…}

toupper :: proc "c" (c: i32) -> i32 {…}

trunc :: proc "c" (x: f64) -> f64 {…}

vfprintf :: proc "c" (file: rawptr, fmt: cstring, args: ^c.va_list) -> i32 {…}

vsnprintf :: proc "c" (buf: [^]u8, count: uint, fmt: cstring, args: ^c.va_list) -> i32 {…}

vsprintf :: proc "c" (buf: [^]u8, fmt: cstring, args: ^c.va_list) -> i32 {…}