include "std/linux_constants.zr" func panic[msg: str] : void io.print("PANIC: ") io.println(msg) // for gdb backtrace _builtin_syscall(SYS_kill, os.getpid(), SIGABRT) os.exit(1) const MEM_BLOCK_SIZE = 32 struct mem.Block size: i64 free: bool next: mem.Block prev: mem.Block func mem.align[x: i64] : i64 return (x + 7) & -8 func mem.Block._split[blk: mem.Block, needed: i64] : void if blk->size >= needed + MEM_BLOCK_SIZE + 8 new_blk := (blk as ptr + MEM_BLOCK_SIZE + needed) as mem.Block new_blk->size = blk->size - needed - MEM_BLOCK_SIZE new_blk->free = true new_blk->next = blk->next new_blk->prev = blk if blk->next as ptr blk->next->prev = new_blk else mem.write64(_builtin_heap_tail(), new_blk) blk->size = needed blk->next = new_blk func mem._request_space[size: i64] : mem.Block needed := size + MEM_BLOCK_SIZE alloc_size := (needed + 4095) & -4096 blk := _builtin_syscall(SYS_mmap, 0, alloc_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) as mem.Block if (blk as ptr as i64) == -1 panic("mem._request_space: failed to mmap") blk->size = alloc_size - MEM_BLOCK_SIZE blk->free = false blk->next = 0 as mem.Block blk->prev = 0 as mem.Block tail := mem.read64(_builtin_heap_tail()) as mem.Block if tail as ptr tail->next = blk blk->prev = tail mem.write64(_builtin_heap_tail(), blk) return blk func mem.alloc[size: i64] : ptr if size <= 0 panic("mem.alloc: called with nonpositive size") size = mem.align(size) cur := mem.read64(_builtin_heap_head()) as mem.Block while cur as ptr if cur->free && cur->size >= size cur->_split(size) cur->free = false return cur as ptr + MEM_BLOCK_SIZE cur = cur->next blk := mem._request_space(size) if !mem.read64(_builtin_heap_head()) mem.write64(_builtin_heap_head(), blk) blk->_split(size) return blk as ptr + MEM_BLOCK_SIZE func mem.free[x: any] : void ptr.free(x as ptr) func ptr.free[x: ptr] : void if x == 0 return blk := (x - MEM_BLOCK_SIZE) as mem.Block if blk->free return blk->free = true next := blk->next if next as ptr && next->free expected_next := (blk as ptr + MEM_BLOCK_SIZE + blk->size) as mem.Block if expected_next as ptr == next as ptr blk->size += MEM_BLOCK_SIZE + next->size blk->next = next->next if next->next as ptr next->next->prev = blk if mem.read64(_builtin_heap_tail()) == next as ptr mem.write64(_builtin_heap_tail(), blk) prev := blk->prev if prev as ptr && prev->free expected_blk := (prev as ptr + MEM_BLOCK_SIZE + prev->size) as mem.Block if expected_blk as ptr == blk as ptr prev->size += MEM_BLOCK_SIZE + blk->size prev->next = blk->next if blk->next as ptr blk->next->prev = prev if mem.read64(_builtin_heap_tail()) == blk as ptr mem.write64(_builtin_heap_tail(), prev) blk = prev block_total := blk->size + MEM_BLOCK_SIZE if (blk as i64 & 4095) == 0 && (block_total & 4095) == 0 if blk->prev as ptr blk->prev->next = blk->next else mem.write64(_builtin_heap_head(), blk->next) if blk->next as ptr blk->next->prev = blk->prev else mem.write64(_builtin_heap_tail(), blk->prev) _builtin_syscall(SYS_munmap, blk, block_total) func ptr.realloc[x: ptr, new_size: i64] : ptr if !x return mem.alloc(new_size) if new_size < 0 panic("mem.realloc: called with negative new_size") if new_size == 0 x->free() return 0 as ptr new_size = mem.align(new_size) blk := (x - MEM_BLOCK_SIZE) as mem.Block if blk->size >= new_size blk->_split(new_size) return x next := blk->next expected_next := (blk as ptr + MEM_BLOCK_SIZE + blk->size) as mem.Block if next as ptr && next->free && expected_next as ptr == next as ptr combined := blk->size + MEM_BLOCK_SIZE + next->size if combined >= new_size blk->size = combined blk->next = next->next if next->next as ptr next->next->prev = blk if mem.read64(_builtin_heap_tail()) == next as ptr mem.write64(_builtin_heap_tail(), blk) blk->_split(new_size) return x new_ptr := mem.alloc(new_size) mem.copy(x, new_ptr, math.min(blk->size, new_size)) x->free() return new_ptr func ptr.zero_and_free[x: ptr, size: i64] : void mem.zero(x, size) x->free() func mem.zero[x: ptr, size: i64] : void i := 0 while i + 8 <= size mem.write64(x + i, 0) i += 8 while i < size x[i] = 0 as u8 i += 1 func mem.copy[src: ptr, dst: ptr, n: i64] : void if dst > src && dst < src + n i := n while i - 8 >= 0 i -= 8 mem.write64(dst + i, mem.read64(src + i)) while i > 0 i -= 1 dst[i] = src[i] else i := 0 while i + 8 <= n mem.write64(dst + i, mem.read64(src + i)) i += 8 while i < n dst[i] = src[i] i += 1 func mem.read8[x: ptr] : u8 return x[0] func mem.read16[x: ptr] : i64 return x[0] as i64 | (x[1] << 8) func mem.read16be[x: ptr] : i64 return (x[0] << 8) as i64 | x[1] func mem.read32[x: ptr] : i64 return x[0] as i64 | (x[1] << 8) | (x[2] << 16) | (x[3] << 24) func mem.read32be[x: ptr] : i64 return (x[0] as i64 << 24) | (x[1] << 16) | (x[2] << 8) | x[3] func mem.read64[x: ptr] : i64 return _builtin_read64(x) func mem.write32[x: ptr, d: i64] : void x[0] = d & 0xff x[1] = (d >> 8) & 0xff x[2] = (d >> 16) & 0xff x[3] = (d >> 24) & 0xff func mem.write16[x: ptr, d: i64] : void x[0] = d & 0xff x[1] = (d >> 8) & 0xff func mem.write16be[x: ptr, d: i64] : void x[0] = (d >> 8) & 0xff x[1] = d & 0xff func mem.write64[x: ptr, d: any] : void _builtin_set64(x, d) func io.printf[..] : void s := _var_arg(0) as ptr i := 1 while s[0] if s[0] == '%' s += 1 if s[0] == 'd' io.print_i64(_var_arg(i) as i64) i += 1 else if s[0] == 'x' io.print_i64_hex(_var_arg(i) as i64) i += 1 else if s[0] == 's' io.print(_var_arg(i) as str) i += 1 else if s[0] == 'c' io.print_char(_var_arg(i) as u8) i += 1 else if s[0] == 'f' io.print_f64(_var_arg(i) as i64) i += 1 else if s[0] == '%' io.print_char('%') else if s[0] == 0 break else panic("io.printf: unrecognized format") else io.print_char(s[0]) s += 1 func io.print_sized[x: ptr, size: i64] : void _builtin_syscall(SYS_write, STDOUT, x, size) func io.print[x: str] : void io.print_sized(x as ptr, x->len()) func io.println[x: str] : void io.print(x) io.print("\n") func io.print_char[x: u8] : void io.print_sized(^x, 1) func io.print_bool[x: bool] : void if x io.print("true") else io.print("false") func io.print_i64[x: i64] : void s := _stackalloc(21) x->to_str_buf(s) io.print(s as str) func io.print_i64_hex[x: i64] : void s := _stackalloc(17) x->to_hex_str_buf(s) io.print(s as str) func io.println_i64[x: i64] : void s := _stackalloc(21) x->to_str_buf(s) io.println(s as str) // TODO: fix when we implement f64 params func io.print_f64[x: i64] : void s := _stackalloc(64) f64.to_str_buf(x, s) io.print(s as str) func f64.to_str_buf[x: i64, buf: ptr] : void bits := x sign := (bits >> 63) & 1 exp := (bits >> 52) & 0x7ff mant := bits & 0x000fffffffffffff if exp == 0x7ff if mant == 0 if sign mem.copy("-inf" as ptr, buf, 5) else mem.copy("inf" as ptr, buf, 4) else mem.copy("nan" as ptr, buf, 4) return p := 0 if sign buf[p] = '-' p += 1 bits = bits & 0x7fffffffffffffff if exp == 0 && mant == 0 buf[p] = '0' buf[p+1] = '.' buf[p+2] = '0' buf[p+3] = 0 return sig := mant if exp != 0 sig = sig | 0x0010000000000000 shift := exp - 1075 if shift >= 0 (sig << shift)->to_str_buf(buf + p) while buf[p] p += 1 buf[p] = '.' buf[p+1] = '0' buf[p+2] = 0 return ns := -shift if ns <= 52 int_part := sig >> ns int_part->to_str_buf(buf + p) while buf[p] p += 1 else buf[p] = '0' p += 1 buf[p] = '.' p += 1 mask := (1 << ns) - 1 frac := sig & mask for i in 0..6 if frac == 0 if i > 0 break buf[p] = '0' p += 1 break frac = frac * 10 digit := frac >> ns buf[p] = '0' + digit as u8 p += 1 frac = frac & mask buf[p] = 0 func io.read_char[] : u8 c := 0 as u8 _builtin_syscall(SYS_read, STDIN, ^c, 1) return c func io.read_line[] : str b := new str.Builder while true c := io.read_char() if c == '\n' break b->append_char(c) s := b->build() b->destroy() return s func io.read_text_file[path: str] : str, bool fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_RDONLY, 0) if fd < 0 return 0 as str, false size := _builtin_syscall(SYS_lseek, fd, 0, SEEK_END) _builtin_syscall(SYS_lseek, fd, 0, SEEK_SET) buffer := mem.alloc(size + 1) n := _builtin_syscall(SYS_read, fd, buffer, size) _builtin_syscall(SYS_close, fd) if n != size buffer->free() return 0 as str, false buffer[n] = 0 return buffer as str, true func io.read_binary_file[path: str] : Blob, bool fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_RDONLY, 0) if fd < 0 return 0 as Blob, false buf := new* Blob buf->size = _builtin_syscall(SYS_lseek, fd, 0, SEEK_END) _builtin_syscall(SYS_lseek, fd, 0, SEEK_SET) buf->data = mem.alloc(buf->size) n := _builtin_syscall(SYS_read, fd, buf->data, buf->size) _builtin_syscall(SYS_close, fd) if n != buf->size buf->free() return 0 as Blob, false return buf, true func io.write_file[path: str, content: str] : bool return io.write_binary_file(path, content as ptr, content->len()) func io.write_binary_file[path: str, content: ptr, size: i64] : bool fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_WRONLY|O_CREAT|O_TRUNC, math.octal_to_decimal(644)) if fd < 0 return false n := _builtin_syscall(SYS_write, fd, content, size) _builtin_syscall(SYS_close, fd) if n != size return false return true func str.free[s: str] : void mem.free(s) func str.len[s: str] : i64 i := 0 while s[i] i += 1 return i func str.make_copy[s: str] : str size := s->len() + 1 dup := mem.alloc(size) as str mem.copy(s as ptr, dup as ptr, size) return dup func str.equal[a: str, b: str] : bool i := 0 while a[i] != 0 && b[i] != 0 if a[i] != b[i] return false i += 1 return a[i] == b[i] func str.format_into[..] : i64 buf := _var_arg(0) as ptr size := _var_arg(1) as i64 if size <= 0 return 0 s := _var_arg(2) as ptr i := 3 n := 0 tmp := _stackalloc(64) as str while s[0] if s[0] == '%' s += 1 if s[0] == 'd' (_var_arg(i) as i64)->to_str_buf(tmp as ptr) tmp_len := tmp->len() remaining := size - n - 1 mem.copy(tmp as ptr, buf + n, math.min(tmp_len, remaining)) n += tmp_len i += 1 else if s[0] == 'x' (_var_arg(i) as i64)->to_hex_str_buf(tmp as ptr) tmp_len := tmp->len() remaining := size - n - 1 mem.copy(tmp as ptr, buf + n, math.min(tmp_len, remaining)) n += tmp_len i += 1 else if s[0] == 's' tmp_str := _var_arg(i) as str tmp_len := tmp_str->len() remaining := size - n - 1 mem.copy(tmp_str as ptr, buf + n, math.min(tmp_len, remaining)) n += tmp_len i += 1 else if s[0] == 'c' if n < size - 1 buf[n] = _var_arg(i) as u8 n += 1 i += 1 else if s[0] == 'f' // TODO: fix when we implement f64 params f64.to_str_buf(_var_arg(i), tmp as ptr) tmp_len := tmp->len() remaining := size - n - 1 mem.copy(tmp as ptr, buf + n, math.min(tmp_len, remaining)) n += tmp_len i += 1 else if s[0] == '%' if n < size - 1 buf[n] = '%' n += 1 else if s[0] == 0 break else panic("str.format_into: unrecognized format") else if n < size - 1 buf[n] = s[0] n += 1 s += 1 if n < size buf[n] = 0 else if size > 0 buf[size - 1] = 0 return n func str.concat[a: str, b: str] : str a_len := a->len() b_len := b->len() out := mem.alloc(a_len + b_len + 1) as str mem.copy(a as ptr, out as ptr, a_len) mem.copy(b as ptr, out as ptr + a_len, b_len) out[a_len + b_len] = 0 return out func str.contains[haystack: str, needle: str] : bool return haystack->find(needle) != -1 func str.find[haystack: str, needle: str] : i64 haystack_len := haystack->len() needle_len := needle->len() if needle_len == 0 return 0 if needle_len > haystack_len return -1 for i in 0..(haystack_len - needle_len + 1) if haystack[i] != needle[0] continue if needle_len == 1 return i match := true for j in 1..needle_len if haystack[i + j] != needle[j] match = false break if match return i return -1 func str.substr[s: str, start: i64, length: i64] : str out := mem.alloc(length + 1) as str mem.copy(s as ptr + start, out as ptr, length) out[length] = 0 return out func str.trim[s: str] : str len := s->len() if len == 0 out := mem.alloc(1) as str out[0] = 0 return out start := 0 end := len - 1 while start <= end && s[start]->is_whitespace() start += 1 while end >= start && s[end]->is_whitespace() end -= 1 return s->substr(start, end - start + 1) func str.split[haystack: str, needle: str]: Array haystack_len := haystack->len() needle_len := needle->len() result := [] if !needle_len if !haystack_len return result else for i in 0..haystack_len result->push(haystack->substr(i, 1)) return result start := 0 i := 0 while i < haystack_len if i <= haystack_len - needle_len match := true for j in 0..needle_len if haystack[i + j] != needle[j] match = false break if match result->push(haystack->substr(start, i - start)) start = i + needle_len i += needle_len continue i += 1 result->push(haystack->substr(start, haystack_len - start)) return result func str.reverse[s: str] : str len := s->len() out := mem.alloc(len + 1) as str for i in 0..len out[i] = s[len - i - 1] out[len] = 0 return out func str.parse_i64[s: str] : i64 len := s->len() i := 0 sign := 1 if i < len && s[i] == '-' sign = -1 i += 1 num := 0 while i < len d := s[i] if !d->is_digit() break num = num * 10 + (d - '0') i += 1 return num * sign func str.hex_encode[s: str, s_len: i64] : str hex_chars := "0123456789abcdef" out := mem.alloc(s_len * 2 + 1) as str for i in 0..s_len b := s[i] out[i * 2] = hex_chars[(b >> 4) & 15] out[i * 2 + 1] = hex_chars[b & 15] out[s_len * 2] = 0 return out func str._hex_digit_to_int[d: u8] : u8 if d->is_digit() return d - '0' lower : u8 = d | 32 if lower >= 'a' && lower <= 'f' return lower - 'a' + 10 panic("invalid hex digit passed to str._hex_digit_to_int") func str.hex_decode[s: str] : str s_len := s->len() if s_len % 2 != 0 panic("invalid hex string passed to str.hex_decode") out_len := s_len / 2 out := mem.alloc(out_len + 1) as str for i in 0..out_len high := str._hex_digit_to_int(s[i * 2]) low := str._hex_digit_to_int(s[i * 2 + 1]) out[i] = (high << 4) | low out[out_len] = 0 return out struct str.Builder data: ptr size: i64 capacity: i64 func str.Builder._grow[b: str.Builder, needed: i64] : void if b->size + needed > b->capacity new_capacity := 64 if b->capacity != 0 new_capacity = b->capacity * 2 while new_capacity < b->size + needed new_capacity = new_capacity * 2 b->data = b->data->realloc(new_capacity) b->capacity = new_capacity func str.Builder.append_char[b: str.Builder, c: u8] : void b->_grow(1) b->data[b->size] = c b->size += 1 func str.Builder.append[b: str.Builder, s: str] : void len := s->len() b->_grow(len) mem.copy(s as ptr, b->data + b->size, len) b->size += len func str.Builder.build[b: str.Builder] : str s := mem.alloc(b->size + 1) as str mem.copy(b->data, s as ptr, b->size) s[b->size] = 0 return s func str.Builder.destroy[b: str.Builder] : void if b->data != 0 b->data->free() b->size = 0 b->capacity = 0 func u8.is_whitespace[x: u8] : bool return x == ' ' || x == '\n' || x == '\t' || x == '\r' func u8.is_digit[x: u8] : bool return x >= '0' && x <= '9' func u8.is_hex_digit[x: u8] : bool return (x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F') func u8.is_lowercase[x: u8] : bool return x >= 'a' && x <= 'z' func u8.is_uppercase[x: u8] : bool return x >= 'A' && x <= 'Z' func u8.is_letter[x: u8] : bool return x->is_uppercase() || x->is_lowercase() func u8.is_alphanumeric[x: u8] : bool return x->is_letter() || x->is_digit() func u8.to_str[c: u8] : str s := mem.alloc(2) as str s[0] = c s[1] = 0 return s func i64.abs[n: i64] : i64 if n == -9223372036854775808 panic("MIN_I64 passed to math.abs") if n < 0 return -n return n func i64.sign[n: i64] : i64 if n < 0 return -1 else if n > 0 return 1 else return 0 func i64.isqrt[n: i64] : i64 if n < 0 panic("negative number passed to math.isqrt") if n == 0 || n == 1 return n guess := n next_guess := (guess + n / guess) / 2 while next_guess < guess guess = next_guess next_guess = (guess + n / guess) / 2 return guess func i64.is_prime[n: i64]: bool if n <= 1 return false if n == 2 || n == 3 return true if n % 2 == 0 || n % 3 == 0 return false i := 5 while i * i <= n if n % i == 0 || n % (i + 2) == 0 return false i += 6 return true func i64.to_str[n: i64] : str out := mem.alloc(21) n->to_str_buf(out) return out as str func i64.to_str_buf[n: i64, buf: ptr] : void if n == 0 buf[0] = '0' buf[1] = 0 return neg : bool = n < 0 if neg // MIN_I64 will fail but i so dont care n = -n tmp := _stackalloc(21) end := 20 tmp[end] = 0 end -= 1 for i in 0..19 if n == 0 break tmp[end] = '0' + (n % 10) n = n / 10 end -= 1 if neg tmp[end] = '-' end -= 1 len := 19 - end for i in 0..len buf[i] = tmp[end + 1 + i] buf[len] = 0 func i64.to_hex_str[n: i64] : str out := mem.alloc(17) n->to_hex_str_buf(out) return out as str func i64.to_hex_str_buf[n: i64, buf: ptr] : void hex_chars := "0123456789abcdef" if n == 0 buf[0] = '0' buf[1] = 0 return mask := (1 << 60) - 1 tmp := _stackalloc(17) len := 0 for i in 0..16 if n == 0 break tmp[len] = hex_chars[n & 15] n = (n >> 4) & mask len += 1 for j in 0..len buf[j] = tmp[len - 1 - j] buf[len] = 0 func math.gcd[a: i64, b: i64] : i64 a = a->abs() b = b->abs() while b != 0 tmp := b b = a % b a = tmp return a func math.min[a: i64, b: i64] : i64 if a < b return a return b func math.max[a: i64, b: i64] : i64 if a > b return a return b func math.pow[b: i64, e: i64] : i64 if e < 0 panic("negative exponent passed to math.pow") out := 1 while e > 0 if e & 1 out = out * b b = b * b e = e >> 1 return out func math.lcm[a: i64, b: i64] : i64 return (a / math.gcd(a, b)) * b func math.octal_to_decimal[octal: i64] : i64 decimal := 0 base := 1 while octal > 0 digit := octal % 10 decimal += digit * base base = base * 8 octal = octal / 10 return decimal struct Blob data: ptr size: i64 func Blob.alloc[size: i64] : Blob buffer := new* Blob buffer->size = size buffer->data = mem.alloc(size) return buffer func Blob.free[buf: Blob] : void buf->data->free() mem.free(buf) struct Array data: ptr size: i64 capacity: i64 func Array.new_preallocated_and_zeroed[size: i64] : Array xs := new* Array if size > 0 xs->data = mem.alloc(size * 8) mem.zero(xs->data, size * 8) xs->size = size xs->capacity = size return xs func Array.nth[xs: Array, n: i64] : any if n < 0 || n >= xs->size panic("Array.nth out of bounds") return mem.read64(xs->data + n * 8) func Array.set[xs: Array, n: i64, x: any] : void if n < 0 || n >= xs->size panic("array.set out of bounds") mem.write64(xs->data + n * 8, x) func Array.push[xs: Array, x: any] : void if xs->size == xs->capacity new_capacity := 4 if xs->capacity != 0 new_capacity = xs->capacity * 2 xs->data = xs->data->realloc(new_capacity * 8) xs->capacity = new_capacity mem.write64(xs->data + xs->size * 8, x) xs->size += 1 func Array.free[xs: Array] : void if xs->data != 0 xs->data->free() mem.free(xs) func Array.free_with_items[xs: Array] : void if xs->data != 0 for i in 0..xs->size mem.free(xs->nth(i)) xs->data->free() mem.free(xs) func Array.pop[xs: Array] : any if xs->size == 0 panic("Array.pop on empty array") x : any = Array.last(xs) xs->size = xs->size - 1 return x func Array.last[xs: Array] : any if xs->size == 0 panic("Array.last on empty array") return xs->nth(xs->size - 1) func Array.slice[xs: Array, start: i64, length: i64] : Array if start < 0 || length < 0 || start + length > xs->size panic("Array.slice out of bounds") new_array := Array.new_preallocated_and_zeroed(length) mem.copy(xs->data + start * 8, new_array->data, length * 8) return new_array func Array.concat[a: Array, b: Array] : Array new_array := Array.new_preallocated_and_zeroed(a->size + b->size) mem.copy(a->data, new_array->data, a->size * 8) mem.copy(b->data, new_array->data + a->size * 8, b->size * 8) return new_array func Array.quicksort[arr: Array] : void arr->_do_quicksort(0, arr->size - 1) func Array._do_quicksort[arr: Array, low: i64, high: i64] : void if low < high i := arr->_partition(low, high) arr->_do_quicksort(low, i - 1) arr->_do_quicksort(i + 1, high) func Array._partition[arr: Array, low: i64, high: i64] : i64 pivot : i64 = arr->nth(high) i := low - 1 for j in (low)..high if arr->nth(j) as i64 <= pivot i += 1 temp : i64 = arr->nth(i) arr->set(i, arr->nth(j)) arr->set(j, temp) temp : i64 = arr->nth(i + 1) arr->set(i + 1, arr->nth(high)) arr->set(high, temp) return i + 1 func Array.contains_str[arr: Array, s: str] : bool for i in 0..arr->size if (arr->nth(i) as str)->equal(s) return true return false func Array.count[arr: Array, item: any] : i64 count := 0 for i in 0..arr->size if arr->nth(i) == item count += 1 return count func Array.map[arr: Array, fn: ptr] : Array out := Array.new_preallocated_and_zeroed(arr->size) for i in 0..arr->size out->set(i, fn(arr->nth(i))) return out func Array.filter[arr: Array, fn: ptr] : Array out := [] for i in 0..arr->size if fn(arr->nth(i)) out->push(arr->nth(i)) return out func Array.reduce[arr: Array, fn: ptr, acc: any] : any for i in 0..arr->size acc = fn(acc, arr->nth(i)) return acc const HashMap._TABLE_SIZE = 100 struct HashMap table: Array struct HashMap._Node key: str value: any next: HashMap._Node func HashMap.new[] : HashMap map := new* HashMap map->table = Array.new_preallocated_and_zeroed(HashMap._TABLE_SIZE) return map func HashMap.insert[map: HashMap, key: str, value: any] : void index := HashMap._djb2(key) current : HashMap._Node = map->table->nth(index) while current as ptr if current->key->equal(key) current->value = value return current = current->next new_node := new* HashMap._Node new_node->key = key->make_copy() new_node->value = value new_node->next = map->table->nth(index) map->table->set(index, new_node) func HashMap.get[map: HashMap, key: str] : any, bool index := HashMap._djb2(key) current : HashMap._Node = map->table->nth(index) while current as ptr if current->key->equal(key) return current->value, true current = current->next return 0 as any, false func HashMap.delete[map: HashMap, key: str] : void index := HashMap._djb2(key) current : HashMap._Node = map->table->nth(index) prev := 0 as HashMap._Node while current as ptr if current->key->equal(key) if prev as ptr prev->next = current->next else map->table->set(index, current->next) current->key->free() mem.free(current) return prev = current current = current->next func HashMap._djb2[key: str] : i64 hash := 5381 for i in 0..key->len() hash = ((hash << 5) + hash) + key[i] hash = (hash & 0x7fffffffffffffff) // prevent negative return hash % HashMap._TABLE_SIZE func HashMap.free[map: HashMap] : void for i in 0..HashMap._TABLE_SIZE current : HashMap._Node = map->table->nth(i) while current as ptr tmp := current current = current->next tmp->key->free() mem.free(tmp) map->table->free() mem.free(map) func os.exit[code: i64] : void _builtin_syscall(SYS_exit, code) func os.getpid[] : i64 return _builtin_syscall(SYS_getpid) func os.basename[path: str] : str i := path->len() - 1 while i >= 0 && path[i] != '/' i -= 1 return path->substr(i + 1, path->len() - i - 1) struct os.Timespec tv_sec: i64 tv_nsec: i64 func os.sleep[ms: i64] : void if ms < 0 panic("negative time passed to os.sleep") req := new os.Timespec req->tv_sec = ms / 1000 req->tv_nsec = (ms % 1000) * 1000000 _builtin_syscall(SYS_nanosleep, req, 0) func os.urandom_buf[buf: ptr, n: i64] : void pos := 0 while pos < n ret := _builtin_syscall(SYS_getrandom, buf + pos, n - pos, 0) if ret <= 0 panic("os.urandom_buf: syscall failed") pos += ret func os.urandom[n: i64]: ptr buf := mem.alloc(n) os.urandom_buf(buf, n) return buf func os.urandom_i64[] : i64 n := 0 os.urandom_buf(^n, 8) return n struct os.Timeval tv_sec: i64 tv_usec: i64 func os.time[] : i64 tv := new os.Timeval _builtin_syscall(SYS_gettimeofday, tv, 0) out := tv->tv_sec * 1000 + tv->tv_usec / 1000 return out func os.run_shell_command[command: str] : i64, bool pid := _builtin_syscall(SYS_fork) if pid < 0 return -1, false if pid == 0 argv := ["sh", "-c", command, 0] // gets freed after child process exits _builtin_syscall(SYS_execve, "/bin/sh", argv->data, _builtin_environ()) os.exit(1) else status := 0 wp := _builtin_syscall(SYS_wait4, pid, ^status, 0, 0) if wp < 0 return -1, false st := status & 0xffffffff if (st & 0x7f) == 0 return (st >> 8) & 0xff, true else return -(st & 0x7f), true func os.file_exists[path: str] : bool return _builtin_syscall(SYS_faccessat, AT_FDCWD, path, F_OK, 0) == 0 func os.is_a_directory[path: str] : bool st := _stackalloc(256) // it has 21 mixed-size fields so ptr for now rc := _builtin_syscall(SYS_newfstatat, AT_FDCWD, path, st, 0) if rc != 0 return false return (mem.read32(st + 24) & S_IFMT) == S_IFDIR func os.list_directory[path: str] : Array, bool fd := _builtin_syscall(SYS_openat, AT_FDCWD, path, O_RDONLY, 0) if fd < 0 return 0 as Array, false files := [] buf := _stackalloc(1024) while true n := _builtin_syscall(SYS_getdents64, fd, buf, 1024) if n < 0 files->free_with_items() _builtin_syscall(SYS_close, fd) return 0 as Array, false else if n == 0 break pos := 0 while pos < n len := mem.read16(buf + pos + 16) name : ptr = buf + pos + 19 if name[0] skip := false // skip if name is exactly '.' or '..' if name[0] == '.' if name[1] == 0 skip = true else if name[1] == '.' if name[2] == 0 skip = true if !skip files->push((name as str)->make_copy()) pos += len _builtin_syscall(SYS_close, fd) return files, true