stdio.occ

include "memory.occ"
import win_syscall_x86_64 from std/sys;

// will make this file use raw syscalls later on + inline assembly

module std {
    fn __strlen_fast(string str) {
        i64 len = $(str - 8);
        return len;
    }

    fn __syscall_write(i64, string, i64) shellcode i64 {
        0x55 0x48 0x89 0xE5
        0xB8 0x01 0x00 0x00 0x00
        0x0F 0x05
        0x48 0x89 0xEC 0x5D 0xC3
    }

    fn __syscall_print_char(i64) shellcode i64 {
        0x55 0x48 0x89 0xE5
        0x57
        0x48 0x89 0xE6
        0xBF 0x01 0x00 0x00 0x00
        0xBA 0x01 0x00 0x00 0x00
        0xB8 0x01 0x00 0x00 0x00
        0x0F 0x05
        0x48 0x89 0xEC 0x5D 0xC3
    }

    fn GetWindowsBuildNumber() u32 {
        return $(0x7FFE0000 + 0x260) & 0x0000FFFF;
    }

    fn GetStdOutFromPEB() shellcode i64 {
        0x55 0x48 0x89 0xE5 0x48 0x83 0xEC 0x20 0x65 0x48 0x8B 0x04 0x25 0x60 0x00 0x00 0x00 0x48 0x8B 0x40 0x20 0x48 0x8B 0x40 0x28 0x48 0x89 0xEC 0x5D 0xC3
    }

    fn print_string_windows(string s) {
        win_syscall_x86_64::WriteFile(GetStdOutFromPEB(), s, $(s - 8));
    }

    fn print_char_windows(i64 c) {
        u64* buf = __malloc_generic<u64>(9);
        $(buf + 8) = c;
        win_syscall_x86_64::WriteFile(GetStdOutFromPEB(), buf + 8, 1);
        __free_generic<u64>(buf);
    }

    fn print_char(i64 c) {
        if is_linux64 == true {
            __syscall_print_char(c);
        }
        else if is_win64 == true {
            print_char_windows(c);
        }
    }

    fn print_string(string s) {
        if is_linux64 == true {
            __syscall_write(1, s, __strlen_fast(s));
        }
        else if is_win64 == true {
            print_string_windows(s);
        }
    }

    fn print_newline() {
        print_char(10);
    }

    fn __write_digits(i64 n, i64 buf, i64 pos) i64 {
        if n >= 10 {
            pos = __write_digits(n / 10, buf, pos);
        }
        $(buf + pos) = (n % 10) + 48;
        return pos + 1;
    }

    fn i64_to_string(i64 n) string {
        i64* buf = __malloc_generic<i64>(40);
        i64 data = buf + 8;
        i64 pos = 0;

        if n < 0 {
            $(data) = 45;
            pos = 1;
            n = -n;
            if n < 0 {
                $(data + 1) = 57;  $(data + 2) = 50;  $(data + 3) = 50;
                $(data + 4) = 51;  $(data + 5) = 51;  $(data + 6) = 55;
                $(data + 7) = 50;  $(data + 8) = 48;  $(data + 9) = 51;
                $(data + 10) = 54; $(data + 11) = 56; $(data + 12) = 53;
                $(data + 13) = 52; $(data + 14) = 55; $(data + 15) = 55;
                $(data + 16) = 53; $(data + 17) = 56; $(data + 18) = 48;
                $(data + 19) = 56; $(data + 20) = 0;
                $(buf) = 20;
                return data;
            }
        }

        if n == 0 {
            $(data + pos) = 48;
            pos = pos + 1;
        }
        else {
            pos = __write_digits(n, data, pos);
        }

        $(data + pos) = 0;
        $(buf) = pos;

        return data;
    }

    fn print_integer(i64 n) {
        print_string(i64_to_string(n));
    }

    fn __print_hex(i64 n) {
        i64 upper = (n >> 4) & 0x0FFFFFFFFFFFFFFF;
        if upper != 0 {
            __print_hex(upper);
        }

        i64 digit = n & 15;

        if digit < 10 {
            print_char(digit + 48);
        }
        else {
            print_char(digit - 10 + 97);
        }
    }

    fn __printf_float(i64 val, i64 precision) {
        f64 dval = __bitcast_f64(val);
        f32 value = f32(dval);

        i64 is_neg = 0;
        if value < 0 {
            is_neg = 1;
            value = -value;
        }

        if value > 9000000000000000000.0 {
            if is_neg == 1 { print_string("-"); }
            print_string("inf");
            return;
        }

        i64 int_part = i64(value);
        f32 frac = value - f32(int_part);

        i64 frac_int = 0;
        if precision == 1 { frac_int = i64(frac * 1e1); }
        else if precision == 2 { frac_int = i64(frac * 1e2); }
        else if precision == 3 { frac_int = i64(frac * 1e3); }
        else if precision == 4 { frac_int = i64(frac * 1e4); }
        else if precision == 5 { frac_int = i64(frac * 1e5); }
        else { frac_int = i64(frac * 1e6); }

        if frac_int < 0 { frac_int = -frac_int; }

        if is_neg == 1 {
            print_string("-");
        }
        print_integer(int_part);

        if precision > 0 {
            print_string(".");

            i64 digits = 0;
            i64 temp = frac_int;
            if temp == 0 { digits = 1; }
            while temp > 0 {
                digits = digits + 1;
                temp = temp / 10;
            }

            i64 pad = precision - digits;
            while pad > 0 {
                print_string("0");
                pad = pad - 1;
            }
            print_integer(frac_int);
        }
    }

    fn printf(string fmt, ...) {
        string p = fmt;
        i64 arg_idx = 0;
        i64 c = $p & 255;

        while c != 0 {
            if c == 37 {
                p = p + 1;
                c = $p & 255;

                if c == 100 || c == 105 {
                    print_integer(__varargs[arg_idx]);
                    arg_idx = arg_idx + 1;
                }
                else if c == 115 {
                    print_string(__varargs[arg_idx]);
                    arg_idx = arg_idx + 1;
                }
                else if c == 99 {
                    print_char(__varargs[arg_idx]);
                    arg_idx = arg_idx + 1;
                }
                else if c == 120 {
                    __print_hex(__varargs[arg_idx]);
                    arg_idx = arg_idx + 1;
                }
                else if c == 102 {
                    __printf_float(__varargs[arg_idx], 6);
                    arg_idx = arg_idx + 1;
                }
                else if c == 46 {
                    p = p + 1;
                    c = $p & 255;
                    i64 prec = 0;
                    while c >= 48 && c <= 57 {
                        prec = prec * 10 + (c - 48);
                        p = p + 1;
                        c = $p & 255;
                    }
                    if c == 102 {
                        __printf_float(__varargs[arg_idx], prec);
                        arg_idx = arg_idx + 1;
                    }
                }
                else if c == 37 {
                    print_char(37);
                }
                else {
                    print_char(37);
                    print_char(c);
                }
            }
            else {
                print_char(c);
            }

            p = p + 1;
            c = $p & 255;
        }
    }
}

/*
fn main() {
    i64 x = memory::malloc<i64>(8);	
    $x = 10;
    i64 y = $x;
    memory::free<i64>(x);

    stdio::printf("%i\n", y);
}
*/