zern/std/std.zr

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