memory.occ

import syscall_x86_64 from sys;
import win_syscall_x86_64 from sys;

module std {
    generic<T>
    struct mem_heap {
        u64 len;
        T* user_p;
    }

    generic<T>
    fn __malloc_generic(u64 len) T* {
        mem_heap<T>* heap;

        len  = 16 + len;
        len  = (len + 4095) & -4096;
    
				if is_linux64 == true {
						heap = syscall_x86_64::mmap(0, len, 0x1 | 0x2, 0x20 | 0x02, -1, 0);

						if (heap == -1) {
								syscall_x86_64::write(1, "mmap failed\n", 12);
								return 0;
						}
				}
				else if is_win64 == true {
						heap = win_syscall_x86_64::VirtualAllocEx(
                -1,
                0,
                len,
                0x3000,    
                0x04);      

            if (heap == 0) {
                return 0;
            }
				}

        heap.len = len;
        heap.user_p = heap + 16;
        
        return heap.user_p;
    }

    generic<T>
    fn __free_generic(T* ptr) {
        mem_heap<T>* heap;

        if ptr == 0 {
            syscall_x86_64::write(1, "nullptr in free\n", 16);

            return 0;
        }

        heap = ptr - 16;
				
				if is_linux64 == true {
						syscall_x86_64::munmap(heap, heap.len);
				}
				else if is_win64 == true {
						win_syscall_x86_64::VirtualFreeEx(-1, heap, 0);
				}
    }

    generic<T>
    fn __realloc_generic(T* ptr, u64 new_size) T* {
        if ptr == 0 {
            return __malloc_generic<T>(new_size);
        }

        mem_heap<T>* old_heap = ptr - 16;
        u64 old_len = old_heap.len;
        u64 old_user_size = old_len - 16;

        T* new_ptr = __malloc_generic<T>(new_size);
        if new_ptr == 0 {
            return 0;
        }

        u64 copy_size = old_user_size;
        if new_size < old_user_size {
            copy_size = new_size;
        }

        i64 i = 0;
        while i < copy_size {
            i8* src = ptr + i;
            i8* dst = new_ptr + i;
            $dst = $src;
            i += 1;
        }

        __free_generic<T>(ptr);
        return new_ptr;
    }

    fn realloc(i64 ptr, u64 new_size) i64 {
        return __realloc_generic<i64>(ptr, new_size);
    }

    fn malloc(u64 len) i64 {
        return __malloc_generic<i64>(len);
    }

    fn free(i64 ptr) {
        __free_generic<i64>(ptr);
    }
}

/*fn main() {
  i64 addr = 0;
  i64 x = win_syscall_x86_64::VirtualAllocEx(-1, addr, 4096, 0x1000 | 0x2000, 4);
  return x;
}

fn main() {
    u64* p = memory::malloc<u64>(8);
        
    i64 v = 0;
    $p = 10; 
    v = $p;

    memory::free<u64>(p);

    return v;
}*/