diff --git a/core/builtin/builtin.odin b/base/builtin/builtin.odin similarity index 100% rename from core/builtin/builtin.odin rename to base/builtin/builtin.odin diff --git a/core/intrinsics/intrinsics.odin b/base/intrinsics/intrinsics.odin similarity index 97% rename from core/intrinsics/intrinsics.odin rename to base/intrinsics/intrinsics.odin index c23cbd473..170a01a2b 100644 --- a/core/intrinsics/intrinsics.odin +++ b/base/intrinsics/intrinsics.odin @@ -5,6 +5,12 @@ package intrinsics // Package-Related is_package_imported :: proc(package_name: string) -> bool --- +// Matrix Related Procedures +transpose :: proc(m: $T/matrix[$R, $C]$E) -> matrix[C, R]E --- +outer_product :: proc(a: $A/[$X]$E, b: $B/[$Y]E) -> matrix[A, B]E --- +hadamard_product :: proc(a, b: $T/matrix[$R, $C]$E) -> T --- +matrix_flatten :: proc(m: $T/matrix[$R, $C]$E) -> [R*E]E --- + // Types soa_struct :: proc($N: int, $T: typeid) -> type/#soa[N]T diff --git a/core/runtime/core.odin b/base/runtime/core.odin similarity index 99% rename from core/runtime/core.odin rename to base/runtime/core.odin index 740482493..fbdf33085 100644 --- a/core/runtime/core.odin +++ b/base/runtime/core.odin @@ -21,7 +21,7 @@ //+no-instrumentation package runtime -import "core:intrinsics" +import "base:intrinsics" // NOTE(bill): This must match the compiler's Calling_Convention :: enum u8 { diff --git a/core/runtime/core_builtin.odin b/base/runtime/core_builtin.odin similarity index 97% rename from core/runtime/core_builtin.odin rename to base/runtime/core_builtin.odin index 3f4ebbc74..3692751bb 100644 --- a/core/runtime/core_builtin.odin +++ b/base/runtime/core_builtin.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" @builtin Maybe :: union($T: typeid) {T} @@ -824,39 +824,6 @@ map_insert :: proc(m: ^$T/map[$K]$V, key: K, value: V, loc := #caller_location) } -@builtin -incl_elem :: proc(s: ^$S/bit_set[$E; $U], elem: E) { - s^ |= {elem} -} -@builtin -incl_elems :: proc(s: ^$S/bit_set[$E; $U], elems: ..E) { - for elem in elems { - s^ |= {elem} - } -} -@builtin -incl_bit_set :: proc(s: ^$S/bit_set[$E; $U], other: S) { - s^ |= other -} -@builtin -excl_elem :: proc(s: ^$S/bit_set[$E; $U], elem: E) { - s^ &~= {elem} -} -@builtin -excl_elems :: proc(s: ^$S/bit_set[$E; $U], elems: ..E) { - for elem in elems { - s^ &~= {elem} - } -} -@builtin -excl_bit_set :: proc(s: ^$S/bit_set[$E; $U], other: S) { - s^ &~= other -} - -@builtin incl :: proc{incl_elem, incl_elems, incl_bit_set} -@builtin excl :: proc{excl_elem, excl_elems, excl_bit_set} - - @builtin card :: proc(s: $S/bit_set[$E; $U]) -> int { when size_of(S) == 1 { diff --git a/core/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin similarity index 99% rename from core/runtime/core_builtin_soa.odin rename to base/runtime/core_builtin_soa.odin index 6313a28f5..94f5be1d4 100644 --- a/core/runtime/core_builtin_soa.odin +++ b/base/runtime/core_builtin_soa.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" _ :: intrinsics /* diff --git a/core/runtime/default_allocators_arena.odin b/base/runtime/default_allocators_arena.odin similarity index 99% rename from core/runtime/default_allocators_arena.odin rename to base/runtime/default_allocators_arena.odin index 1fe3c6cfc..fcc98abfa 100644 --- a/core/runtime/default_allocators_arena.odin +++ b/base/runtime/default_allocators_arena.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: uint(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE) diff --git a/base/runtime/default_allocators_general.odin b/base/runtime/default_allocators_general.odin new file mode 100644 index 000000000..cbaf4d22a --- /dev/null +++ b/base/runtime/default_allocators_general.odin @@ -0,0 +1,12 @@ +package runtime + +when ODIN_DEFAULT_TO_NIL_ALLOCATOR { + default_allocator_proc :: nil_allocator_proc + default_allocator :: nil_allocator +} else when ODIN_DEFAULT_TO_PANIC_ALLOCATOR { + default_allocator_proc :: panic_allocator_proc + default_allocator :: panic_allocator +} else { + default_allocator :: heap_allocator + default_allocator_proc :: heap_allocator_proc +} diff --git a/core/runtime/default_allocators_nil.odin b/base/runtime/default_allocators_nil.odin similarity index 94% rename from core/runtime/default_allocators_nil.odin rename to base/runtime/default_allocators_nil.odin index c882f5196..ce8519c10 100644 --- a/core/runtime/default_allocators_nil.odin +++ b/base/runtime/default_allocators_nil.odin @@ -31,14 +31,6 @@ nil_allocator :: proc() -> Allocator { } - -when ODIN_OS == .Freestanding { - default_allocator_proc :: nil_allocator_proc - default_allocator :: nil_allocator -} - - - panic_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { diff --git a/core/runtime/default_temporary_allocator.odin b/base/runtime/default_temporary_allocator.odin similarity index 100% rename from core/runtime/default_temporary_allocator.odin rename to base/runtime/default_temporary_allocator.odin diff --git a/core/runtime/docs.odin b/base/runtime/docs.odin similarity index 100% rename from core/runtime/docs.odin rename to base/runtime/docs.odin diff --git a/core/runtime/dynamic_array_internal.odin b/base/runtime/dynamic_array_internal.odin similarity index 100% rename from core/runtime/dynamic_array_internal.odin rename to base/runtime/dynamic_array_internal.odin diff --git a/core/runtime/dynamic_map_internal.odin b/base/runtime/dynamic_map_internal.odin similarity index 99% rename from core/runtime/dynamic_map_internal.odin rename to base/runtime/dynamic_map_internal.odin index 491a7974d..64cb02586 100644 --- a/core/runtime/dynamic_map_internal.odin +++ b/base/runtime/dynamic_map_internal.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" _ :: intrinsics // High performance, cache-friendly, open-addressed Robin Hood hashing hash map diff --git a/core/runtime/entry_unix.odin b/base/runtime/entry_unix.odin similarity index 98% rename from core/runtime/entry_unix.odin rename to base/runtime/entry_unix.odin index f494a509e..233007936 100644 --- a/core/runtime/entry_unix.odin +++ b/base/runtime/entry_unix.odin @@ -3,7 +3,7 @@ //+no-instrumentation package runtime -import "core:intrinsics" +import "base:intrinsics" when ODIN_BUILD_MODE == .Dynamic { @(link_name="_odin_entry_point", linkage="strong", require/*, link_section=".init"*/) diff --git a/core/runtime/entry_unix_no_crt_amd64.asm b/base/runtime/entry_unix_no_crt_amd64.asm similarity index 100% rename from core/runtime/entry_unix_no_crt_amd64.asm rename to base/runtime/entry_unix_no_crt_amd64.asm diff --git a/core/runtime/entry_unix_no_crt_darwin_arm64.asm b/base/runtime/entry_unix_no_crt_darwin_arm64.asm similarity index 100% rename from core/runtime/entry_unix_no_crt_darwin_arm64.asm rename to base/runtime/entry_unix_no_crt_darwin_arm64.asm diff --git a/core/runtime/entry_unix_no_crt_i386.asm b/base/runtime/entry_unix_no_crt_i386.asm similarity index 100% rename from core/runtime/entry_unix_no_crt_i386.asm rename to base/runtime/entry_unix_no_crt_i386.asm diff --git a/core/runtime/entry_wasm.odin b/base/runtime/entry_wasm.odin similarity index 94% rename from core/runtime/entry_wasm.odin rename to base/runtime/entry_wasm.odin index e7f3f156f..c608942ba 100644 --- a/core/runtime/entry_wasm.odin +++ b/base/runtime/entry_wasm.odin @@ -3,7 +3,7 @@ //+no-instrumentation package runtime -import "core:intrinsics" +import "base:intrinsics" when !ODIN_TEST && !ODIN_NO_ENTRY_POINT { @(link_name="_start", linkage="strong", require, export) diff --git a/core/runtime/entry_windows.odin b/base/runtime/entry_windows.odin similarity index 98% rename from core/runtime/entry_windows.odin rename to base/runtime/entry_windows.odin index b6fbe1dcc..7020e9ea8 100644 --- a/core/runtime/entry_windows.odin +++ b/base/runtime/entry_windows.odin @@ -3,7 +3,7 @@ //+no-instrumentation package runtime -import "core:intrinsics" +import "base:intrinsics" when ODIN_BUILD_MODE == .Dynamic { @(link_name="DllMain", linkage="strong", require) diff --git a/core/runtime/error_checks.odin b/base/runtime/error_checks.odin similarity index 100% rename from core/runtime/error_checks.odin rename to base/runtime/error_checks.odin diff --git a/base/runtime/heap_allocator.odin b/base/runtime/heap_allocator.odin new file mode 100644 index 000000000..75f79ab77 --- /dev/null +++ b/base/runtime/heap_allocator.odin @@ -0,0 +1,110 @@ +package runtime + +import "base:intrinsics" + +heap_allocator :: proc() -> Allocator { + return Allocator{ + procedure = heap_allocator_proc, + data = nil, + } +} + +heap_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, + size, alignment: int, + old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + // + // NOTE(tetra, 2020-01-14): The heap doesn't respect alignment. + // Instead, we overallocate by `alignment + size_of(rawptr) - 1`, and insert + // padding. We also store the original pointer returned by heap_alloc right before + // the pointer we return to the user. + // + + aligned_alloc :: proc(size, alignment: int, old_ptr: rawptr = nil, zero_memory := true) -> ([]byte, Allocator_Error) { + a := max(alignment, align_of(rawptr)) + space := size + a - 1 + + allocated_mem: rawptr + if old_ptr != nil { + original_old_ptr := ([^]rawptr)(old_ptr)[-1] + allocated_mem = heap_resize(original_old_ptr, space+size_of(rawptr)) + } else { + allocated_mem = heap_alloc(space+size_of(rawptr), zero_memory) + } + aligned_mem := rawptr(([^]u8)(allocated_mem)[size_of(rawptr):]) + + ptr := uintptr(aligned_mem) + aligned_ptr := (ptr - 1 + uintptr(a)) & -uintptr(a) + diff := int(aligned_ptr - ptr) + if (size + diff) > space || allocated_mem == nil { + return nil, .Out_Of_Memory + } + + aligned_mem = rawptr(aligned_ptr) + ([^]rawptr)(aligned_mem)[-1] = allocated_mem + + return byte_slice(aligned_mem, size), nil + } + + aligned_free :: proc(p: rawptr) { + if p != nil { + heap_free(([^]rawptr)(p)[-1]) + } + } + + aligned_resize :: proc(p: rawptr, old_size: int, new_size: int, new_alignment: int, zero_memory := true) -> (new_memory: []byte, err: Allocator_Error) { + if p == nil { + return nil, nil + } + + new_memory = aligned_alloc(new_size, new_alignment, p, zero_memory) or_return + + // NOTE: heap_resize does not zero the new memory, so we do it + if zero_memory && new_size > old_size { + new_region := raw_data(new_memory[old_size:]) + intrinsics.mem_zero(new_region, new_size - old_size) + } + return + } + + switch mode { + case .Alloc, .Alloc_Non_Zeroed: + return aligned_alloc(size, alignment, nil, mode == .Alloc) + + case .Free: + aligned_free(old_memory) + + case .Free_All: + return nil, .Mode_Not_Implemented + + case .Resize, .Resize_Non_Zeroed: + if old_memory == nil { + return aligned_alloc(size, alignment, nil, mode == .Resize) + } + return aligned_resize(old_memory, old_size, size, alignment, mode == .Resize) + + case .Query_Features: + set := (^Allocator_Mode_Set)(old_memory) + if set != nil { + set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Resize_Non_Zeroed, .Query_Features} + } + return nil, nil + + case .Query_Info: + return nil, .Mode_Not_Implemented + } + + return nil, nil +} + + +heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { + return _heap_alloc(size, zero_memory) +} + +heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { + return _heap_resize(ptr, new_size) +} + +heap_free :: proc(ptr: rawptr) { + _heap_free(ptr) +} \ No newline at end of file diff --git a/base/runtime/heap_allocator_other.odin b/base/runtime/heap_allocator_other.odin new file mode 100644 index 000000000..45049c7e9 --- /dev/null +++ b/base/runtime/heap_allocator_other.odin @@ -0,0 +1,15 @@ +//+build js, wasi, freestanding, essence +//+private +package runtime + +_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { + unimplemented("base:runtime 'heap_alloc' procedure is not supported on this platform") +} + +_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { + unimplemented("base:runtime 'heap_resize' procedure is not supported on this platform") +} + +_heap_free :: proc(ptr: rawptr) { + unimplemented("base:runtime 'heap_free' procedure is not supported on this platform") +} \ No newline at end of file diff --git a/base/runtime/heap_allocator_unix.odin b/base/runtime/heap_allocator_unix.odin new file mode 100644 index 000000000..bfbbb5303 --- /dev/null +++ b/base/runtime/heap_allocator_unix.odin @@ -0,0 +1,38 @@ +//+build linux, darwin, freebsd, openbsd +//+private +package runtime + +when ODIN_OS == .Darwin { + foreign import libc "system:System.framework" +} else { + foreign import libc "system:c" +} + +@(default_calling_convention="c") +foreign libc { + @(link_name="malloc") _unix_malloc :: proc(size: int) -> rawptr --- + @(link_name="calloc") _unix_calloc :: proc(num, size: int) -> rawptr --- + @(link_name="free") _unix_free :: proc(ptr: rawptr) --- + @(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr --- +} + +_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { + if size <= 0 { + return nil + } + if zero_memory { + return _unix_calloc(1, size) + } else { + return _unix_malloc(size) + } +} + +_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { + // NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on + // POSIX platforms. Ensure your caller takes this into account. + return _unix_realloc(ptr, new_size) +} + +_heap_free :: proc(ptr: rawptr) { + _unix_free(ptr) +} \ No newline at end of file diff --git a/base/runtime/heap_allocator_windows.odin b/base/runtime/heap_allocator_windows.odin new file mode 100644 index 000000000..2097c3671 --- /dev/null +++ b/base/runtime/heap_allocator_windows.odin @@ -0,0 +1,39 @@ +package runtime + +foreign import kernel32 "system:Kernel32.lib" + +@(private="file") +@(default_calling_convention="system") +foreign kernel32 { + // NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency + + // default_allocator + GetProcessHeap :: proc() -> rawptr --- + HeapAlloc :: proc(hHeap: rawptr, dwFlags: u32, dwBytes: uint) -> rawptr --- + HeapReAlloc :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr, dwBytes: uint) -> rawptr --- + HeapFree :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr) -> b32 --- +} + +_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { + HEAP_ZERO_MEMORY :: 0x00000008 + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY if zero_memory else 0, uint(size)) +} +_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { + if new_size == 0 { + _heap_free(ptr) + return nil + } + if ptr == nil { + return _heap_alloc(new_size) + } + + HEAP_ZERO_MEMORY :: 0x00000008 + return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, uint(new_size)) +} +_heap_free :: proc(ptr: rawptr) { + if ptr == nil { + return + } + HeapFree(GetProcessHeap(), 0, ptr) +} + diff --git a/core/runtime/internal.odin b/base/runtime/internal.odin similarity index 99% rename from core/runtime/internal.odin rename to base/runtime/internal.odin index a03c2a701..21342ef17 100644 --- a/core/runtime/internal.odin +++ b/base/runtime/internal.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" @(private="file") IS_WASM :: ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 diff --git a/core/runtime/os_specific.odin b/base/runtime/os_specific.odin similarity index 100% rename from core/runtime/os_specific.odin rename to base/runtime/os_specific.odin diff --git a/base/runtime/os_specific_bsd.odin b/base/runtime/os_specific_bsd.odin new file mode 100644 index 000000000..7f23b625e --- /dev/null +++ b/base/runtime/os_specific_bsd.odin @@ -0,0 +1,22 @@ +//+build freebsd, openbsd +//+private +package runtime + +foreign import libc "system:c" + +@(default_calling_convention="c") +foreign libc { + @(link_name="write") + _unix_write :: proc(fd: i32, buf: rawptr, size: int) -> int --- + + __error :: proc() -> ^i32 --- +} + +_os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { + ret := _unix_write(2, raw_data(data), len(data)) + if ret < len(data) { + err := __error() + return int(ret), _OS_Errno(err^ if err != nil else 0) + } + return int(ret), 0 +} diff --git a/base/runtime/os_specific_darwin.odin b/base/runtime/os_specific_darwin.odin new file mode 100644 index 000000000..0cb46024c --- /dev/null +++ b/base/runtime/os_specific_darwin.odin @@ -0,0 +1,26 @@ +//+build darwin +//+private +package runtime + +foreign import libc "system:System.framework" + +@(default_calling_convention="c") +foreign libc { + @(link_name="__stderrp") + _stderr: rawptr + + @(link_name="fwrite") + _fwrite :: proc(ptr: rawptr, size: uint, nmemb: uint, stream: rawptr) -> uint --- + + @(link_name="__error") + _get_errno :: proc() -> ^i32 --- +} + +_os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { + ret := _fwrite(raw_data(data), 1, len(data), _stderr) + if ret < len(data) { + err := _get_errno() + return int(ret), _OS_Errno(err^ if err != nil else 0) + } + return int(ret), 0 +} diff --git a/core/runtime/os_specific_freestanding.odin b/base/runtime/os_specific_freestanding.odin similarity index 93% rename from core/runtime/os_specific_freestanding.odin rename to base/runtime/os_specific_freestanding.odin index a6d04cefb..817b22483 100644 --- a/core/runtime/os_specific_freestanding.odin +++ b/base/runtime/os_specific_freestanding.odin @@ -1,4 +1,5 @@ //+build freestanding +//+private package runtime // TODO(bill): reimplement `os.write` diff --git a/core/runtime/os_specific_js.odin b/base/runtime/os_specific_js.odin similarity index 95% rename from core/runtime/os_specific_js.odin rename to base/runtime/os_specific_js.odin index 246141d87..541c785ef 100644 --- a/core/runtime/os_specific_js.odin +++ b/base/runtime/os_specific_js.odin @@ -1,4 +1,5 @@ //+build js +//+private package runtime foreign import "odin_env" diff --git a/base/runtime/os_specific_linux.odin b/base/runtime/os_specific_linux.odin new file mode 100644 index 000000000..abcfc741b --- /dev/null +++ b/base/runtime/os_specific_linux.odin @@ -0,0 +1,24 @@ +//+private +package runtime + +import "base:intrinsics" + +_os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { + when ODIN_ARCH == .amd64 { + SYS_write :: uintptr(1) + } else when ODIN_ARCH == .arm64 { + SYS_write :: uintptr(64) + } else when ODIN_ARCH == .i386 { + SYS_write :: uintptr(4) + } else when ODIN_ARCH == .arm32 { + SYS_write :: uintptr(4) + } + + stderr :: 2 + + ret := int(intrinsics.syscall(SYS_write, uintptr(stderr), uintptr(raw_data(data)), uintptr(len(data)))) + if ret < 0 && ret > -4096 { + return 0, _OS_Errno(-ret) + } + return ret, 0 +} diff --git a/core/runtime/os_specific_wasi.odin b/base/runtime/os_specific_wasi.odin similarity index 95% rename from core/runtime/os_specific_wasi.odin rename to base/runtime/os_specific_wasi.odin index 3f69504ee..502f027f0 100644 --- a/core/runtime/os_specific_wasi.odin +++ b/base/runtime/os_specific_wasi.odin @@ -1,4 +1,5 @@ //+build wasi +//+private package runtime import "core:sys/wasm/wasi" diff --git a/base/runtime/os_specific_windows.odin b/base/runtime/os_specific_windows.odin new file mode 100644 index 000000000..74681a3ab --- /dev/null +++ b/base/runtime/os_specific_windows.odin @@ -0,0 +1,51 @@ +//+build windows +//+private +package runtime + +foreign import kernel32 "system:Kernel32.lib" + +@(private="file") +@(default_calling_convention="system") +foreign kernel32 { + // NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency + + // os_write + GetStdHandle :: proc(which: u32) -> rawptr --- + SetHandleInformation :: proc(hObject: rawptr, dwMask: u32, dwFlags: u32) -> b32 --- + WriteFile :: proc(hFile: rawptr, lpBuffer: rawptr, nNumberOfBytesToWrite: u32, lpNumberOfBytesWritten: ^u32, lpOverlapped: rawptr) -> b32 --- + GetLastError :: proc() -> u32 --- +} + +_os_write :: proc "contextless" (data: []byte) -> (n: int, err: _OS_Errno) #no_bounds_check { + if len(data) == 0 { + return 0, 0 + } + + STD_ERROR_HANDLE :: ~u32(0) -12 + 1 + HANDLE_FLAG_INHERIT :: 0x00000001 + MAX_RW :: 1<<30 + + h := GetStdHandle(STD_ERROR_HANDLE) + when size_of(uintptr) == 8 { + SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) + } + + single_write_length: u32 + total_write: i64 + length := i64(len(data)) + + for total_write < length { + remaining := length - total_write + to_write := u32(min(i32(remaining), MAX_RW)) + + e := WriteFile(h, &data[total_write], to_write, &single_write_length, nil) + if single_write_length <= 0 || !e { + err = _OS_Errno(GetLastError()) + n = int(total_write) + return + } + total_write += i64(single_write_length) + } + n = int(total_write) + return +} diff --git a/core/runtime/print.odin b/base/runtime/print.odin similarity index 100% rename from core/runtime/print.odin rename to base/runtime/print.odin diff --git a/core/runtime/procs.odin b/base/runtime/procs.odin similarity index 100% rename from core/runtime/procs.odin rename to base/runtime/procs.odin diff --git a/core/runtime/procs_darwin.odin b/base/runtime/procs_darwin.odin similarity index 97% rename from core/runtime/procs_darwin.odin rename to base/runtime/procs_darwin.odin index 9c53b5b16..497978a76 100644 --- a/core/runtime/procs_darwin.odin +++ b/base/runtime/procs_darwin.odin @@ -3,7 +3,7 @@ package runtime foreign import "system:Foundation.framework" -import "core:intrinsics" +import "base:intrinsics" objc_id :: ^intrinsics.objc_object objc_Class :: ^intrinsics.objc_class diff --git a/core/runtime/procs_js.odin b/base/runtime/procs_js.odin similarity index 100% rename from core/runtime/procs_js.odin rename to base/runtime/procs_js.odin diff --git a/core/runtime/procs_wasm.odin b/base/runtime/procs_wasm.odin similarity index 100% rename from core/runtime/procs_wasm.odin rename to base/runtime/procs_wasm.odin diff --git a/core/runtime/procs_windows_amd64.asm b/base/runtime/procs_windows_amd64.asm similarity index 100% rename from core/runtime/procs_windows_amd64.asm rename to base/runtime/procs_windows_amd64.asm diff --git a/core/runtime/procs_windows_amd64.odin b/base/runtime/procs_windows_amd64.odin similarity index 100% rename from core/runtime/procs_windows_amd64.odin rename to base/runtime/procs_windows_amd64.odin diff --git a/core/runtime/procs_windows_i386.odin b/base/runtime/procs_windows_i386.odin similarity index 100% rename from core/runtime/procs_windows_i386.odin rename to base/runtime/procs_windows_i386.odin diff --git a/core/runtime/udivmod128.odin b/base/runtime/udivmod128.odin similarity index 99% rename from core/runtime/udivmod128.odin rename to base/runtime/udivmod128.odin index 87ef73c2c..eceb815bf 100644 --- a/core/runtime/udivmod128.odin +++ b/base/runtime/udivmod128.odin @@ -1,6 +1,6 @@ package runtime -import "core:intrinsics" +import "base:intrinsics" udivmod128 :: proc "c" (a, b: u128, rem: ^u128) -> u128 { _ctz :: intrinsics.count_trailing_zeros diff --git a/core/bufio/scanner.odin b/core/bufio/scanner.odin index b9e620250..ee2d5d1f6 100644 --- a/core/bufio/scanner.odin +++ b/core/bufio/scanner.odin @@ -4,7 +4,7 @@ import "core:bytes" import "core:io" import "core:mem" import "core:unicode/utf8" -import "core:intrinsics" +import "base:intrinsics" // Extra errors returns by scanning procedures Scanner_Extra_Error :: enum i32 { diff --git a/core/c/c.odin b/core/c/c.odin index 05732476f..edd88d228 100644 --- a/core/c/c.odin +++ b/core/c/c.odin @@ -1,6 +1,6 @@ package c -import builtin "core:builtin" +import builtin "base:builtin" char :: builtin.u8 // assuming -funsigned-char diff --git a/core/c/libc/complex.odin b/core/c/libc/complex.odin index 7f2ca37ae..81d2b75be 100644 --- a/core/c/libc/complex.odin +++ b/core/c/libc/complex.odin @@ -67,7 +67,7 @@ foreign libc { crealf :: proc(z: complex_float) -> float --- } -import builtin "core:builtin" +import builtin "base:builtin" complex_float :: distinct builtin.complex64 complex_double :: distinct builtin.complex128 diff --git a/core/c/libc/math.odin b/core/c/libc/math.odin index 0a6ecc0c3..81d51728d 100644 --- a/core/c/libc/math.odin +++ b/core/c/libc/math.odin @@ -2,7 +2,7 @@ package libc // 7.12 Mathematics -import "core:intrinsics" +import "base:intrinsics" when ODIN_OS == .Windows { foreign import libc "system:libucrt.lib" diff --git a/core/c/libc/stdarg.odin b/core/c/libc/stdarg.odin index b79b22b5a..faae6a6c6 100644 --- a/core/c/libc/stdarg.odin +++ b/core/c/libc/stdarg.odin @@ -2,7 +2,7 @@ package libc // 7.16 Variable arguments -import "core:intrinsics" +import "base:intrinsics" @(private="file") @(default_calling_convention="none") diff --git a/core/c/libc/stdatomic.odin b/core/c/libc/stdatomic.odin index 6e1581c58..8dc243b78 100644 --- a/core/c/libc/stdatomic.odin +++ b/core/c/libc/stdatomic.odin @@ -2,7 +2,7 @@ package libc // 7.17 Atomics -import "core:intrinsics" +import "base:intrinsics" ATOMIC_BOOL_LOCK_FREE :: true ATOMIC_CHAR_LOCK_FREE :: true diff --git a/core/c/libc/string.odin b/core/c/libc/string.odin index 8f83ee1b9..e6a959f7b 100644 --- a/core/c/libc/string.odin +++ b/core/c/libc/string.odin @@ -1,6 +1,6 @@ package libc -import "core:runtime" +import "base:runtime" // 7.24 String handling diff --git a/core/compress/common.odin b/core/compress/common.odin index b343ce493..b22172e61 100644 --- a/core/compress/common.odin +++ b/core/compress/common.odin @@ -12,7 +12,7 @@ package compress import "core:io" import "core:bytes" -import "core:runtime" +import "base:runtime" /* These settings bound how much compression algorithms will allocate for their output buffer. diff --git a/core/compress/shoco/shoco.odin b/core/compress/shoco/shoco.odin index 04b0bfdc2..e65acb0bc 100644 --- a/core/compress/shoco/shoco.odin +++ b/core/compress/shoco/shoco.odin @@ -11,7 +11,7 @@ // package shoco is an implementation of the shoco short string compressor package shoco -import "core:intrinsics" +import "base:intrinsics" import "core:compress" Shoco_Pack :: struct { diff --git a/core/container/bit_array/bit_array.odin b/core/container/bit_array/bit_array.odin index d649d039f..dbd2e0d3a 100644 --- a/core/container/bit_array/bit_array.odin +++ b/core/container/bit_array/bit_array.odin @@ -1,6 +1,6 @@ package dynamic_bit_array -import "core:intrinsics" +import "base:intrinsics" import "core:mem" /* diff --git a/core/container/intrusive/list/intrusive_list.odin b/core/container/intrusive/list/intrusive_list.odin index 7302f24f5..1a3175002 100644 --- a/core/container/intrusive/list/intrusive_list.odin +++ b/core/container/intrusive/list/intrusive_list.odin @@ -1,6 +1,6 @@ package container_intrusive_list -import "core:intrinsics" +import "base:intrinsics" // An intrusive doubly-linked list // diff --git a/core/container/lru/lru_cache.odin b/core/container/lru/lru_cache.odin index b59f29f0c..23f01fac3 100644 --- a/core/container/lru/lru_cache.odin +++ b/core/container/lru/lru_cache.odin @@ -1,7 +1,7 @@ package container_lru -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" _ :: runtime _ :: intrinsics diff --git a/core/container/priority_queue/priority_queue.odin b/core/container/priority_queue/priority_queue.odin index 0c43816e1..8a6d77288 100644 --- a/core/container/priority_queue/priority_queue.odin +++ b/core/container/priority_queue/priority_queue.odin @@ -1,6 +1,6 @@ package container_priority_queue -import "core:builtin" +import "base:builtin" Priority_Queue :: struct($T: typeid) { queue: [dynamic]T, diff --git a/core/container/queue/queue.odin b/core/container/queue/queue.odin index bdc61c2a6..e46dccb33 100644 --- a/core/container/queue/queue.odin +++ b/core/container/queue/queue.odin @@ -1,7 +1,7 @@ package container_queue -import "core:builtin" -import "core:runtime" +import "base:builtin" +import "base:runtime" _ :: runtime // Dynamically resizable double-ended queue/ring-buffer diff --git a/core/container/small_array/small_array.odin b/core/container/small_array/small_array.odin index b471d1706..ecec7b80c 100644 --- a/core/container/small_array/small_array.odin +++ b/core/container/small_array/small_array.odin @@ -1,7 +1,7 @@ package container_small_array -import "core:builtin" -import "core:runtime" +import "base:builtin" +import "base:runtime" _ :: runtime Small_Array :: struct($N: int, $T: typeid) where N >= 0 { diff --git a/core/container/topological_sort/topological_sort.odin b/core/container/topological_sort/topological_sort.odin index f1e9bf57b..0d34e8d02 100644 --- a/core/container/topological_sort/topological_sort.odin +++ b/core/container/topological_sort/topological_sort.odin @@ -3,8 +3,8 @@ // map type is being used to accelerate lookups. package container_topological_sort -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" _ :: intrinsics _ :: runtime diff --git a/core/dynlib/lib.odin b/core/dynlib/lib.odin index e9ee77d2c..8d603f2e4 100644 --- a/core/dynlib/lib.odin +++ b/core/dynlib/lib.odin @@ -1,8 +1,8 @@ package dynlib -import "core:intrinsics" +import "base:intrinsics" import "core:reflect" -import "core:runtime" +import "base:runtime" _ :: intrinsics _ :: reflect _ :: runtime diff --git a/core/dynlib/lib_windows.odin b/core/dynlib/lib_windows.odin index 9a1b5f998..c7bfe1537 100644 --- a/core/dynlib/lib_windows.odin +++ b/core/dynlib/lib_windows.odin @@ -4,7 +4,7 @@ package dynlib import win32 "core:sys/windows" import "core:strings" -import "core:runtime" +import "base:runtime" import "core:reflect" _load_library :: proc(path: string, global_symbols := false) -> (Library, bool) { diff --git a/core/encoding/endian/endian.odin b/core/encoding/endian/endian.odin index d70d873be..708b919fb 100644 --- a/core/encoding/endian/endian.odin +++ b/core/encoding/endian/endian.odin @@ -1,6 +1,6 @@ package encoding_endian -import "core:intrinsics" +import "base:intrinsics" import "core:math/bits" Byte_Order :: enum u8 { diff --git a/core/encoding/json/marshal.odin b/core/encoding/json/marshal.odin index ab2af9561..e9285364b 100644 --- a/core/encoding/json/marshal.odin +++ b/core/encoding/json/marshal.odin @@ -2,7 +2,7 @@ package json import "core:mem" import "core:math/bits" -import "core:runtime" +import "base:runtime" import "core:strconv" import "core:strings" import "core:reflect" diff --git a/core/encoding/json/unmarshal.odin b/core/encoding/json/unmarshal.odin index c1905f6b0..0a55bb553 100644 --- a/core/encoding/json/unmarshal.odin +++ b/core/encoding/json/unmarshal.odin @@ -5,7 +5,7 @@ import "core:math" import "core:reflect" import "core:strconv" import "core:strings" -import "core:runtime" +import "base:runtime" Unmarshal_Data_Error :: enum { Invalid_Data, diff --git a/core/encoding/xml/xml_reader.odin b/core/encoding/xml/xml_reader.odin index 562d519d5..bf8646bc3 100644 --- a/core/encoding/xml/xml_reader.odin +++ b/core/encoding/xml/xml_reader.odin @@ -29,11 +29,11 @@ package xml import "core:bytes" import "core:encoding/entity" -import "core:intrinsics" +import "base:intrinsics" import "core:mem" import "core:os" import "core:strings" -import "core:runtime" +import "base:runtime" likely :: intrinsics.expect diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index 25012eb65..a3e5d943c 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -4,12 +4,12 @@ import "core:math/bits" import "core:mem" import "core:io" import "core:reflect" -import "core:runtime" +import "base:runtime" import "core:strconv" import "core:strings" import "core:time" import "core:unicode/utf8" -import "core:intrinsics" +import "base:intrinsics" // Internal data structure that stores the required information for formatted printing Info :: struct { diff --git a/core/fmt/fmt_os.odin b/core/fmt/fmt_os.odin index 3d1b0847b..afc28ffff 100644 --- a/core/fmt/fmt_os.odin +++ b/core/fmt/fmt_os.odin @@ -2,7 +2,7 @@ //+build !js package fmt -import "core:runtime" +import "base:runtime" import "core:os" import "core:io" import "core:bufio" diff --git a/core/hash/crc32.odin b/core/hash/crc32.odin index fead4d74f..761444676 100644 --- a/core/hash/crc32.odin +++ b/core/hash/crc32.odin @@ -1,6 +1,6 @@ package hash -import "core:intrinsics" +import "base:intrinsics" @(optimization_mode="speed") crc32 :: proc(data: []byte, seed := u32(0)) -> u32 #no_bounds_check { diff --git a/core/hash/hash.odin b/core/hash/hash.odin index 176d17141..ea99b630c 100644 --- a/core/hash/hash.odin +++ b/core/hash/hash.odin @@ -1,7 +1,7 @@ package hash import "core:mem" -import "core:intrinsics" +import "base:intrinsics" @(optimization_mode="speed") adler32 :: proc(data: []byte, seed := u32(1)) -> u32 #no_bounds_check { diff --git a/core/hash/xxhash/common.odin b/core/hash/xxhash/common.odin index 8b34c1e8f..faf88e0d4 100644 --- a/core/hash/xxhash/common.odin +++ b/core/hash/xxhash/common.odin @@ -9,8 +9,8 @@ */ package xxhash -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" mem_copy :: runtime.mem_copy byte_swap :: intrinsics.byte_swap diff --git a/core/hash/xxhash/streaming.odin b/core/hash/xxhash/streaming.odin index 6f630b042..07744a12b 100644 --- a/core/hash/xxhash/streaming.odin +++ b/core/hash/xxhash/streaming.odin @@ -10,7 +10,7 @@ package xxhash import "core:mem" -import "core:intrinsics" +import "base:intrinsics" /* === XXH3 128-bit streaming === diff --git a/core/hash/xxhash/xxhash_3.odin b/core/hash/xxhash/xxhash_3.odin index fa50075f9..611f4dc9f 100644 --- a/core/hash/xxhash/xxhash_3.odin +++ b/core/hash/xxhash/xxhash_3.odin @@ -9,7 +9,7 @@ */ package xxhash -import "core:intrinsics" +import "base:intrinsics" /* ************************************************************************* diff --git a/core/hash/xxhash/xxhash_32.odin b/core/hash/xxhash/xxhash_32.odin index 5bc87c2c0..2f27118f2 100644 --- a/core/hash/xxhash/xxhash_32.odin +++ b/core/hash/xxhash/xxhash_32.odin @@ -9,7 +9,7 @@ */ package xxhash -import "core:intrinsics" +import "base:intrinsics" /* 32-bit hash functions diff --git a/core/hash/xxhash/xxhash_64.odin b/core/hash/xxhash/xxhash_64.odin index 9280e9c59..b274da374 100644 --- a/core/hash/xxhash/xxhash_64.odin +++ b/core/hash/xxhash/xxhash_64.odin @@ -9,7 +9,7 @@ */ package xxhash -import "core:intrinsics" +import "base:intrinsics" /* 64-bit hash functions diff --git a/core/image/common.odin b/core/image/common.odin index ad01f7e6b..c7507a85f 100644 --- a/core/image/common.odin +++ b/core/image/common.odin @@ -13,7 +13,7 @@ package image import "core:bytes" import "core:mem" import "core:compress" -import "core:runtime" +import "base:runtime" /* 67_108_864 pixels max by default. diff --git a/core/image/netpbm/netpbm.odin b/core/image/netpbm/netpbm.odin index 24df76c8e..079c5b4be 100644 --- a/core/image/netpbm/netpbm.odin +++ b/core/image/netpbm/netpbm.odin @@ -8,7 +8,7 @@ import "core:mem" import "core:strconv" import "core:strings" import "core:unicode" -import "core:runtime" +import "base:runtime" Image :: image.Image Format :: image.Netpbm_Format diff --git a/core/image/png/helpers.odin b/core/image/png/helpers.odin index f0209d4d7..ac61378da 100644 --- a/core/image/png/helpers.odin +++ b/core/image/png/helpers.odin @@ -16,7 +16,7 @@ import coretime "core:time" import "core:strings" import "core:bytes" import "core:mem" -import "core:runtime" +import "base:runtime" /* Cleanup of image-specific data. diff --git a/core/image/png/png.odin b/core/image/png/png.odin index 1821e55cd..4bb070da8 100644 --- a/core/image/png/png.odin +++ b/core/image/png/png.odin @@ -22,8 +22,8 @@ import "core:hash" import "core:bytes" import "core:io" import "core:mem" -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" // Limit chunk sizes. // By default: IDAT = 8k x 8k x 16-bits + 8k filter bytes. diff --git a/core/io/io.odin b/core/io/io.odin index d3cae7bce..ea8e240b0 100644 --- a/core/io/io.odin +++ b/core/io/io.odin @@ -3,7 +3,7 @@ // operations into an abstracted stream interface. package io -import "core:intrinsics" +import "base:intrinsics" import "core:unicode/utf8" // Seek whence values diff --git a/core/log/log.odin b/core/log/log.odin index b4039caa0..0d89fdb74 100644 --- a/core/log/log.odin +++ b/core/log/log.odin @@ -1,6 +1,6 @@ package log -import "core:runtime" +import "base:runtime" import "core:fmt" diff --git a/core/log/log_allocator.odin b/core/log/log_allocator.odin index 322c2e717..16f1abe31 100644 --- a/core/log/log_allocator.odin +++ b/core/log/log_allocator.odin @@ -1,6 +1,6 @@ package log -import "core:runtime" +import "base:runtime" import "core:fmt" Log_Allocator_Format :: enum { diff --git a/core/math/big/common.odin b/core/math/big/common.odin index 74a641d83..fabf39520 100644 --- a/core/math/big/common.odin +++ b/core/math/big/common.odin @@ -6,7 +6,7 @@ package math_big -import "core:intrinsics" +import "base:intrinsics" /* TODO: Make the tunables runtime adjustable where practical. diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin index a4313a244..8ab19e3e7 100644 --- a/core/math/big/helpers.odin +++ b/core/math/big/helpers.odin @@ -6,7 +6,7 @@ package math_big -import "core:intrinsics" +import "base:intrinsics" import rnd "core:math/rand" /* diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin index ca8dbf4c5..829cbf0e2 100644 --- a/core/math/big/internal.odin +++ b/core/math/big/internal.odin @@ -28,9 +28,9 @@ package math_big import "core:mem" -import "core:intrinsics" +import "base:intrinsics" import rnd "core:math/rand" -import "core:builtin" +import "base:builtin" /* Low-level addition, unsigned. Handbook of Applied Cryptography, algorithm 14.7. diff --git a/core/math/big/private.odin b/core/math/big/private.odin index d41e66343..d045b4239 100644 --- a/core/math/big/private.odin +++ b/core/math/big/private.odin @@ -19,7 +19,7 @@ package math_big -import "core:intrinsics" +import "base:intrinsics" import "core:mem" /* diff --git a/core/math/big/public.odin b/core/math/big/public.odin index 3227d7bc4..070c45283 100644 --- a/core/math/big/public.odin +++ b/core/math/big/public.odin @@ -12,7 +12,7 @@ package math_big -import "core:intrinsics" +import "base:intrinsics" /* =========================== diff --git a/core/math/big/radix.odin b/core/math/big/radix.odin index d15ce0e98..8d8ea734e 100644 --- a/core/math/big/radix.odin +++ b/core/math/big/radix.odin @@ -16,7 +16,7 @@ package math_big -import "core:intrinsics" +import "base:intrinsics" import "core:mem" import "core:os" diff --git a/core/math/big/rat.odin b/core/math/big/rat.odin index 35618affb..e0e58b80f 100644 --- a/core/math/big/rat.odin +++ b/core/math/big/rat.odin @@ -1,7 +1,7 @@ package math_big -import "core:builtin" -import "core:intrinsics" +import "base:builtin" +import "base:intrinsics" import "core:math" Rat :: struct { diff --git a/core/math/big/tune.odin b/core/math/big/tune.odin index ec1ef9a5b..5938dafde 100644 --- a/core/math/big/tune.odin +++ b/core/math/big/tune.odin @@ -11,7 +11,7 @@ package math_big import "core:time" -import "core:runtime" +import "base:runtime" print_value :: proc(name: string, value: i64) { runtime.print_string("\t") diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin index 959b5536f..154b5a142 100644 --- a/core/math/bits/bits.odin +++ b/core/math/bits/bits.odin @@ -1,6 +1,6 @@ package math_bits -import "core:intrinsics" +import "base:intrinsics" U8_MIN :: 0 U16_MIN :: 0 diff --git a/core/math/cmplx/cmplx.odin b/core/math/cmplx/cmplx.odin index c029be30c..4625f83c6 100644 --- a/core/math/cmplx/cmplx.odin +++ b/core/math/cmplx/cmplx.odin @@ -1,6 +1,6 @@ package math_cmplx -import "core:builtin" +import "base:builtin" import "core:math" // The original C code, the long comment, and the constants diff --git a/core/math/cmplx/cmplx_invtrig.odin b/core/math/cmplx/cmplx_invtrig.odin index a746a370f..b84f0ac9c 100644 --- a/core/math/cmplx/cmplx_invtrig.odin +++ b/core/math/cmplx/cmplx_invtrig.odin @@ -1,6 +1,6 @@ package math_cmplx -import "core:builtin" +import "base:builtin" import "core:math" // The original C code, the long comment, and the constants diff --git a/core/math/ease/ease.odin b/core/math/ease/ease.odin index 0e6569bca..5ed0dd56a 100644 --- a/core/math/ease/ease.odin +++ b/core/math/ease/ease.odin @@ -2,7 +2,7 @@ package ease import "core:math" -import "core:intrinsics" +import "base:intrinsics" import "core:time" @(private) PI_2 :: math.PI / 2 diff --git a/core/math/fixed/fixed.odin b/core/math/fixed/fixed.odin index d347e9c11..b8000a5c6 100644 --- a/core/math/fixed/fixed.odin +++ b/core/math/fixed/fixed.odin @@ -2,7 +2,7 @@ package math_fixed import "core:math" import "core:strconv" -import "core:intrinsics" +import "base:intrinsics" _, _, _ :: intrinsics, strconv, math Fixed :: struct($Backing: typeid, $Fraction_Width: uint) diff --git a/core/math/linalg/extended.odin b/core/math/linalg/extended.odin index b6e05a2c2..eee339245 100644 --- a/core/math/linalg/extended.odin +++ b/core/math/linalg/extended.odin @@ -1,6 +1,6 @@ package linalg -import "core:builtin" +import "base:builtin" import "core:math" @(require_results) diff --git a/core/math/linalg/general.odin b/core/math/linalg/general.odin index 60185d64d..24bc4c7b3 100644 --- a/core/math/linalg/general.odin +++ b/core/math/linalg/general.odin @@ -1,8 +1,8 @@ package linalg import "core:math" -import "core:builtin" -import "core:intrinsics" +import "base:builtin" +import "base:intrinsics" // Generic @@ -66,7 +66,7 @@ quaternion256_dot :: proc "contextless" (a, b: $T/quaternion256) -> (c: f64) { dot :: proc{scalar_dot, vector_dot, quaternion64_dot, quaternion128_dot, quaternion256_dot} inner_product :: dot -outer_product :: builtin.outer_product +outer_product :: intrinsics.outer_product @(require_results) quaternion_inverse :: proc "contextless" (q: $Q) -> Q where IS_QUATERNION(Q) { @@ -179,8 +179,7 @@ identity :: proc "contextless" ($T: typeid/[$N][N]$E) -> (m: T) #no_bounds_check return m } -trace :: builtin.matrix_trace -transpose :: builtin.transpose +transpose :: intrinsics.transpose @(require_results) matrix_mul :: proc "contextless" (a, b: $M/matrix[$N, N]$E) -> (c: M) @@ -355,3 +354,273 @@ matrix_cast :: proc "contextless" (v: $A/matrix[$M, $N]$T, $Elem_Type: typeid) - @(require_results) to_quaternion64 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) } @(require_results) to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) } @(require_results) to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) } + + +hadamard_product :: intrinsics.hadamard_product +matrix_flatten :: intrinsics.matrix_flatten + + +determinant :: proc{ + matrix1x1_determinant, + matrix2x2_determinant, + matrix3x3_determinant, + matrix4x4_determinant, +} + +adjugate :: proc{ + matrix1x1_adjugate, + matrix2x2_adjugate, + matrix3x3_adjugate, + matrix4x4_adjugate, +} + +inverse_transpose :: proc{ + matrix1x1_inverse_transpose, + matrix2x2_inverse_transpose, + matrix3x3_inverse_transpose, + matrix4x4_inverse_transpose, +} + + +inverse :: proc{ + matrix1x1_inverse, + matrix2x2_inverse, + matrix3x3_inverse, + matrix4x4_inverse, +} + +@(require_results) +hermitian_adjoint :: proc "contextless" (m: $M/matrix[$N, N]$T) -> M where intrinsics.type_is_complex(T), N >= 1 { + return conj(transpose(m)) +} + +@(require_results) +trace :: proc "contextless" (m: $M/matrix[$N, N]$T) -> (trace: T) { + for i in 0.. (minor: T) where N > 1 { + K :: int(N-1) + cut_down: matrix[K, K]T + for col_idx in 0..= column) + for row_idx in 0..= row) + cut_down[row_idx, col_idx] = m[i, j] + } + } + return determinant(cut_down) +} + + + +@(require_results) +matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) { + return m[0, 0] +} + +@(require_results) +matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) { + return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] +} +@(require_results) +matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) { + a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) + b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) + c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) + return a + b + c +} +@(require_results) +matrix4x4_determinant :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { + a := adjugate(m) + #no_bounds_check for i in 0..<4 { + det += m[0, i] * a[0, i] + } + return +} + + + + +@(require_results) +matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y = x + return +} + +@(require_results) +matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + y[0, 0] = +x[1, 1] + y[0, 1] = -x[1, 0] + y[1, 0] = -x[0, 1] + y[1, 1] = +x[0, 0] + return +} + +@(require_results) +matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { + y[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) + y[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) + y[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) + y[1, 0] = -(m[0, 1] * m[2, 2] - m[2, 1] * m[0, 2]) + y[1, 1] = +(m[0, 0] * m[2, 2] - m[2, 0] * m[0, 2]) + y[1, 2] = -(m[0, 0] * m[2, 1] - m[2, 0] * m[0, 1]) + y[2, 0] = +(m[0, 1] * m[1, 2] - m[1, 1] * m[0, 2]) + y[2, 1] = -(m[0, 0] * m[1, 2] - m[1, 0] * m[0, 2]) + y[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) + return +} + + +@(require_results) +matrix4x4_adjugate :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { + for i in 0..<4 { + for j in 0..<4 { + sign: T = 1 if (i + j) % 2 == 0 else -1 + y[i, j] = sign * matrix_minor(x, i, j) + } + } + return +} + +@(require_results) +matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[1, 0] = -x[0, 1] / d + y[0, 1] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[1, 0] = -x[0, 1] * id + y[0, 1] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +matrix4x4_inverse_transpose :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[0, 1] = -x[0, 1] / d + y[1, 0] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[0, 1] = -x[0, 1] * id + y[1, 0] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] * id + } + } + } + return +} + +@(require_results) +matrix4x4_inverse :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] * id + } + } + } + return +} diff --git a/core/math/linalg/glsl/linalg_glsl.odin b/core/math/linalg/glsl/linalg_glsl.odin index 0d91ad4a3..bda1f1723 100644 --- a/core/math/linalg/glsl/linalg_glsl.odin +++ b/core/math/linalg/glsl/linalg_glsl.odin @@ -1,7 +1,8 @@ // core:math/linalg/glsl implements a GLSL-like mathematics library plus numerous other utility procedures package math_linalg_glsl -import "core:builtin" +import "base:builtin" +import "base:intrinsics" TAU :: 6.28318530717958647692528676655900576 PI :: 3.14159265358979323846264338327950288 @@ -1838,30 +1839,281 @@ dquatMulDvec3 :: proc "c" (q: dquat, v: dvec3) -> dvec3 { -@(require_results) inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return builtin.inverse(m) } -@(require_results) inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return builtin.inverse(m) } -@(require_results) inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return builtin.inverse(m) } -@(require_results) inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return builtin.inverse(m) } -@(require_results) inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return builtin.inverse(m) } -@(require_results) inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return builtin.inverse(m) } +@(require_results) inverse_mat2 :: proc "c" (m: mat2) -> mat2 { return inverse_matrix2x2(m) } +@(require_results) inverse_mat3 :: proc "c" (m: mat3) -> mat3 { return inverse_matrix3x3(m) } +@(require_results) inverse_mat4 :: proc "c" (m: mat4) -> mat4 { return inverse_matrix4x4(m) } +@(require_results) inverse_dmat2 :: proc "c" (m: dmat2) -> dmat2 { return inverse_matrix2x2(m) } +@(require_results) inverse_dmat3 :: proc "c" (m: dmat3) -> dmat3 { return inverse_matrix3x3(m) } +@(require_results) inverse_dmat4 :: proc "c" (m: dmat4) -> dmat4 { return inverse_matrix4x4(m) } @(require_results) inverse_quat :: proc "c" (q: quat) -> quat { return 1/q } @(require_results) inverse_dquat :: proc "c" (q: dquat) -> dquat { return 1/q } -inverse :: proc{ - inverse_mat2, - inverse_mat3, - inverse_mat4, - inverse_dmat2, - inverse_dmat3, - inverse_dmat4, - inverse_quat, - inverse_dquat, + +transpose :: intrinsics.transpose + + +determinant :: proc{ + determinant_matrix1x1, + determinant_matrix2x2, + determinant_matrix3x3, + determinant_matrix4x4, +} + +adjugate :: proc{ + adjugate_matrix1x1, + adjugate_matrix2x2, + adjugate_matrix3x3, + adjugate_matrix4x4, +} + +inverse_transpose :: proc{ + inverse_transpose_matrix1x1, + inverse_transpose_matrix2x2, + inverse_transpose_matrix3x3, + inverse_transpose_matrix4x4, +} + + +inverse :: proc{ + inverse_matrix1x1, + inverse_matrix2x2, + inverse_matrix3x3, + inverse_matrix4x4, +} + +@(require_results) +hermitian_adjoint :: proc "contextless" (m: $M/matrix[$N, N]$T) -> M where intrinsics.type_is_complex(T), N >= 1 { + return conj(transpose(m)) +} + +@(require_results) +trace :: proc "contextless" (m: $M/matrix[$N, N]$T) -> (trace: T) { + for i in 0.. (minor: T) where N > 1 { + K :: int(N-1) + cut_down: matrix[K, K]T + for col_idx in 0..= column) + for row_idx in 0..= row) + cut_down[row_idx, col_idx] = m[i, j] + } + } + return determinant(cut_down) +} + + + +@(require_results) +determinant_matrix1x1 :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) { + return m[0, 0] +} + +@(require_results) +determinant_matrix2x2 :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) { + return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] +} +@(require_results) +determinant_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) { + a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) + b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) + c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) + return a + b + c +} +@(require_results) +determinant_matrix4x4 :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { + a := adjugate(m) + #no_bounds_check for i in 0..<4 { + det += m[0, i] * a[0, i] + } + return +} + + + + +@(require_results) +adjugate_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y = x + return +} + +@(require_results) +adjugate_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + y[0, 0] = +x[1, 1] + y[0, 1] = -x[1, 0] + y[1, 0] = -x[0, 1] + y[1, 1] = +x[0, 0] + return +} + +@(require_results) +adjugate_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { + y[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) + y[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) + y[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) + y[1, 0] = -(m[0, 1] * m[2, 2] - m[2, 1] * m[0, 2]) + y[1, 1] = +(m[0, 0] * m[2, 2] - m[2, 0] * m[0, 2]) + y[1, 2] = -(m[0, 0] * m[2, 1] - m[2, 0] * m[0, 1]) + y[2, 0] = +(m[0, 1] * m[1, 2] - m[1, 1] * m[0, 2]) + y[2, 1] = -(m[0, 0] * m[1, 2] - m[1, 0] * m[0, 2]) + y[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) + return +} + + +@(require_results) +adjugate_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { + for i in 0..<4 { + for j in 0..<4 { + sign: T = 1 if (i + j) % 2 == 0 else -1 + y[i, j] = sign * matrix_minor(x, i, j) + } + } + return +} + +@(require_results) +inverse_transpose_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +inverse_transpose_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[1, 0] = -x[0, 1] / d + y[0, 1] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[1, 0] = -x[0, 1] * id + y[0, 1] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +inverse_transpose_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +inverse_transpose_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +inverse_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +inverse_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[0, 1] = -x[0, 1] / d + y[1, 0] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[0, 1] = -x[0, 1] * id + y[1, 0] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +inverse_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] * id + } + } + } + return +} + +@(require_results) +inverse_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] * id + } + } + } + return } -transpose :: builtin.transpose -inverse_transpose :: builtin.inverse_transpose -adjugate :: builtin.adjugate -hermitian_adjoint :: builtin.hermitian_adjoint -minor :: builtin.matrix_minor -determinant :: builtin.determinant -trace :: builtin.matrix_trace \ No newline at end of file diff --git a/core/math/linalg/hlsl/linalg_hlsl.odin b/core/math/linalg/hlsl/linalg_hlsl.odin index 351aa7ea3..f5e8bf147 100644 --- a/core/math/linalg/hlsl/linalg_hlsl.odin +++ b/core/math/linalg/hlsl/linalg_hlsl.odin @@ -1,7 +1,8 @@ // core:math/linalg/hlsl implements a HLSL-like mathematics library plus numerous other utility procedures package math_linalg_hlsl -import "core:builtin" +import "base:builtin" +import "base:intrinsics" TAU :: 6.28318530717958647692528676655900576 PI :: 3.14159265358979323846264338327950288 @@ -1471,14 +1472,14 @@ not :: proc{ -@(require_results) inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return builtin.inverse(m) } -@(require_results) inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return builtin.inverse(m) } -@(require_results) inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return builtin.inverse(m) } -@(require_results) inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return builtin.inverse(m) } -@(require_results) inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return builtin.inverse(m) } -@(require_results) inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return builtin.inverse(m) } -@(require_results) inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return builtin.inverse(m) } -@(require_results) inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return builtin.inverse(m) } +@(require_results) inverse_float1x1 :: proc "c" (m: float1x1) -> float1x1 { return inverse_matrix1x1(m) } +@(require_results) inverse_float2x2 :: proc "c" (m: float2x2) -> float2x2 { return inverse_matrix2x2(m) } +@(require_results) inverse_float3x3 :: proc "c" (m: float3x3) -> float3x3 { return inverse_matrix3x3(m) } +@(require_results) inverse_float4x4 :: proc "c" (m: float4x4) -> float4x4 { return inverse_matrix4x4(m) } +@(require_results) inverse_double1x1 :: proc "c" (m: double1x1) -> double1x1 { return inverse_matrix1x1(m) } +@(require_results) inverse_double2x2 :: proc "c" (m: double2x2) -> double2x2 { return inverse_matrix2x2(m) } +@(require_results) inverse_double3x3 :: proc "c" (m: double3x3) -> double3x3 { return inverse_matrix3x3(m) } +@(require_results) inverse_double4x4 :: proc "c" (m: double4x4) -> double4x4 { return inverse_matrix4x4(m) } inverse :: proc{ inverse_float1x1, @@ -1489,15 +1490,275 @@ inverse :: proc{ inverse_double2x2, inverse_double3x3, inverse_double4x4, + + inverse_matrix1x1, + inverse_matrix2x2, + inverse_matrix3x3, + inverse_matrix4x4, } -transpose :: builtin.transpose -inverse_transpose :: builtin.inverse_transpose -adjugate :: builtin.adjugate -hermitian_adjoint :: builtin.hermitian_adjoint -minor :: builtin.matrix_minor -determinant :: builtin.determinant -trace :: builtin.matrix_trace +transpose :: intrinsics.transpose + + +determinant :: proc{ + determinant_matrix1x1, + determinant_matrix2x2, + determinant_matrix3x3, + determinant_matrix4x4, +} + +adjugate :: proc{ + adjugate_matrix1x1, + adjugate_matrix2x2, + adjugate_matrix3x3, + adjugate_matrix4x4, +} + +inverse_transpose :: proc{ + inverse_transpose_matrix1x1, + inverse_transpose_matrix2x2, + inverse_transpose_matrix3x3, + inverse_transpose_matrix4x4, +} + +@(require_results) +hermitian_adjoint :: proc "contextless" (m: $M/matrix[$N, N]$T) -> M where intrinsics.type_is_complex(T), N >= 1 { + return conj(transpose(m)) +} + +@(require_results) +trace :: proc "contextless" (m: $M/matrix[$N, N]$T) -> (trace: T) { + for i in 0.. (minor: T) where N > 1 { + K :: int(N-1) + cut_down: matrix[K, K]T + for col_idx in 0..= column) + for row_idx in 0..= row) + cut_down[row_idx, col_idx] = m[i, j] + } + } + return determinant(cut_down) +} + + + +@(require_results) +determinant_matrix1x1 :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) { + return m[0, 0] +} + +@(require_results) +determinant_matrix2x2 :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) { + return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] +} +@(require_results) +determinant_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) { + a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) + b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) + c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) + return a + b + c +} +@(require_results) +determinant_matrix4x4 :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { + a := adjugate(m) + #no_bounds_check for i in 0..<4 { + det += m[0, i] * a[0, i] + } + return +} + + + + +@(require_results) +adjugate_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y = x + return +} + +@(require_results) +adjugate_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + y[0, 0] = +x[1, 1] + y[0, 1] = -x[1, 0] + y[1, 0] = -x[0, 1] + y[1, 1] = +x[0, 0] + return +} + +@(require_results) +adjugate_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { + y[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) + y[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) + y[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) + y[1, 0] = -(m[0, 1] * m[2, 2] - m[2, 1] * m[0, 2]) + y[1, 1] = +(m[0, 0] * m[2, 2] - m[2, 0] * m[0, 2]) + y[1, 2] = -(m[0, 0] * m[2, 1] - m[2, 0] * m[0, 1]) + y[2, 0] = +(m[0, 1] * m[1, 2] - m[1, 1] * m[0, 2]) + y[2, 1] = -(m[0, 0] * m[1, 2] - m[1, 0] * m[0, 2]) + y[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) + return +} + + +@(require_results) +adjugate_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { + for i in 0..<4 { + for j in 0..<4 { + sign: T = 1 if (i + j) % 2 == 0 else -1 + y[i, j] = sign * matrix_minor(x, i, j) + } + } + return +} + +@(require_results) +inverse_transpose_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +inverse_transpose_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[1, 0] = -x[0, 1] / d + y[0, 1] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[1, 0] = -x[0, 1] * id + y[0, 1] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +inverse_transpose_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +inverse_transpose_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[i, j] * id + } + } + } + return +} + +@(require_results) +inverse_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { + y[0, 0] = 1/x[0, 0] + return +} + +@(require_results) +inverse_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { + d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] + when intrinsics.type_is_integer(T) { + y[0, 0] = +x[1, 1] / d + y[0, 1] = -x[0, 1] / d + y[1, 0] = -x[1, 0] / d + y[1, 1] = +x[0, 0] / d + } else { + id := 1 / d + y[0, 0] = +x[1, 1] * id + y[0, 1] = -x[0, 1] * id + y[1, 0] = -x[1, 0] * id + y[1, 1] = +x[0, 0] * id + } + return +} + +@(require_results) +inverse_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d := determinant(x) + when intrinsics.type_is_integer(T) { + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<3 { + for j in 0..<3 { + y[i, j] = a[j, i] * id + } + } + } + return +} + +@(require_results) +inverse_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { + a := adjugate(x) + d: T + for i in 0..<4 { + d += x[0, i] * a[0, i] + } + when intrinsics.type_is_integer(T) { + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] / d + } + } + } else { + id := 1/d + for i in 0..<4 { + for j in 0..<4 { + y[i, j] = a[j, i] * id + } + } + } + return +} + + + asfloat :: proc{ asfloat_float, diff --git a/core/math/linalg/specific.odin b/core/math/linalg/specific.odin index 1f96eb178..36783e1e2 100644 --- a/core/math/linalg/specific.odin +++ b/core/math/linalg/specific.odin @@ -1,6 +1,6 @@ package linalg -import "core:builtin" +import "base:builtin" import "core:math" F16_EPSILON :: 1e-3 @@ -1447,16 +1447,16 @@ matrix3_adjoint :: proc{ @(require_results) -matrix3_inverse_transpose_f16 :: proc "contextless" (m: Matrix3f16) -> (inverse_transpose: Matrix3f16) { - return builtin.inverse_transpose(m) +matrix3_inverse_transpose_f16 :: proc "contextless" (m: Matrix3f16) -> (p: Matrix3f16) { + return inverse_transpose(m) } @(require_results) -matrix3_inverse_transpose_f32 :: proc "contextless" (m: Matrix3f32) -> (inverse_transpose: Matrix3f32) { - return builtin.inverse_transpose(m) +matrix3_inverse_transpose_f32 :: proc "contextless" (m: Matrix3f32) -> (p: Matrix3f32) { + return inverse_transpose(m) } @(require_results) -matrix3_inverse_transpose_f64 :: proc "contextless" (m: Matrix3f64) -> (inverse_transpose: Matrix3f64) { - return builtin.inverse_transpose(m) +matrix3_inverse_transpose_f64 :: proc "contextless" (m: Matrix3f64) -> (p: Matrix3f64) { + return inverse_transpose(m) } matrix3_inverse_transpose :: proc{ matrix3_inverse_transpose_f16, diff --git a/core/math/math.odin b/core/math/math.odin index 696293f70..7fdbcba04 100644 --- a/core/math/math.odin +++ b/core/math/math.odin @@ -1,7 +1,7 @@ package math -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" _ :: intrinsics Float_Class :: enum { diff --git a/core/math/math_basic.odin b/core/math/math_basic.odin index 95e0a93ec..041efd272 100644 --- a/core/math/math_basic.odin +++ b/core/math/math_basic.odin @@ -1,7 +1,7 @@ //+build !js package math -import "core:intrinsics" +import "base:intrinsics" @(default_calling_convention="none", private="file") foreign _ { diff --git a/core/math/math_basic_js.odin b/core/math/math_basic_js.odin index acd3c2b39..5b9adabcd 100644 --- a/core/math/math_basic_js.odin +++ b/core/math/math_basic_js.odin @@ -1,7 +1,7 @@ //+build js package math -import "core:intrinsics" +import "base:intrinsics" foreign import "odin_env" diff --git a/core/math/rand/rand.odin b/core/math/rand/rand.odin index 7e6d58ee2..14894e82c 100644 --- a/core/math/rand/rand.odin +++ b/core/math/rand/rand.odin @@ -4,7 +4,7 @@ Package core:math/rand implements various random number generators */ package rand -import "core:intrinsics" +import "base:intrinsics" import "core:math" import "core:mem" diff --git a/core/mem/alloc.odin b/core/mem/alloc.odin index 4cea20f30..e25fc2bc1 100644 --- a/core/mem/alloc.odin +++ b/core/mem/alloc.odin @@ -1,6 +1,6 @@ package mem -import "core:runtime" +import "base:runtime" // NOTE(bill, 2019-12-31): These are defined in `package runtime` as they are used in the `context`. This is to prevent an import definition cycle. Allocator_Mode :: runtime.Allocator_Mode diff --git a/core/mem/allocators.odin b/core/mem/allocators.odin index 76f87a450..13d5536b7 100644 --- a/core/mem/allocators.odin +++ b/core/mem/allocators.odin @@ -1,7 +1,7 @@ package mem -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" import "core:sync" nil_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, diff --git a/core/mem/mem.odin b/core/mem/mem.odin index dd985d5dd..0ea9d5b79 100644 --- a/core/mem/mem.odin +++ b/core/mem/mem.odin @@ -1,7 +1,7 @@ package mem -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" Byte :: runtime.Byte Kilobyte :: runtime.Kilobyte diff --git a/core/mem/raw.odin b/core/mem/raw.odin index 9a521598e..56790e959 100644 --- a/core/mem/raw.odin +++ b/core/mem/raw.odin @@ -1,7 +1,7 @@ package mem -import "core:builtin" -import "core:runtime" +import "base:builtin" +import "base:runtime" Raw_Any :: runtime.Raw_Any Raw_String :: runtime.Raw_String diff --git a/core/mem/virtual/virtual.odin b/core/mem/virtual/virtual.odin index 00a9e6a5d..efbdefcf6 100644 --- a/core/mem/virtual/virtual.odin +++ b/core/mem/virtual/virtual.odin @@ -1,8 +1,8 @@ package mem_virtual import "core:mem" -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" _ :: runtime DEFAULT_PAGE_SIZE := uint(4096) diff --git a/core/mem/virtual/virtual_darwin.odin b/core/mem/virtual/virtual_darwin.odin index 5be17c0f9..d2e3c8b51 100644 --- a/core/mem/virtual/virtual_darwin.odin +++ b/core/mem/virtual/virtual_darwin.odin @@ -2,7 +2,7 @@ //+private package mem_virtual -foreign import libc "System.framework" +foreign import libc "system:System.framework" import "core:c" PROT_NONE :: 0x0 /* [MC2] no permissions */ diff --git a/core/net/common.odin b/core/net/common.odin index 70a027138..2a6f44602 100644 --- a/core/net/common.odin +++ b/core/net/common.odin @@ -21,7 +21,7 @@ package net Jeroen van Rijn: Cross platform unification, code style, documentation */ -import "core:runtime" +import "base:runtime" /* TUNEABLES - See also top of `dns.odin` for DNS configuration. diff --git a/core/odin/ast/clone.odin b/core/odin/ast/clone.odin index 4e7f14580..d105f6035 100644 --- a/core/odin/ast/clone.odin +++ b/core/odin/ast/clone.odin @@ -1,6 +1,6 @@ package odin_ast -import "core:intrinsics" +import "base:intrinsics" import "core:mem" import "core:fmt" import "core:reflect" diff --git a/core/os/dir_linux.odin b/core/os/dir_linux.odin index 4971fa9d5..3a51d7c70 100644 --- a/core/os/dir_linux.odin +++ b/core/os/dir_linux.odin @@ -2,7 +2,7 @@ package os import "core:strings" import "core:mem" -import "core:runtime" +import "base:runtime" read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { dirp: Dir diff --git a/core/os/dir_windows.odin b/core/os/dir_windows.odin index 531a5cd82..491507313 100644 --- a/core/os/dir_windows.odin +++ b/core/os/dir_windows.odin @@ -2,7 +2,7 @@ package os import win32 "core:sys/windows" import "core:strings" -import "core:runtime" +import "base:runtime" read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { find_data_to_file_info :: proc(base_path: string, d: ^win32.WIN32_FIND_DATAW) -> (fi: File_Info) { diff --git a/core/os/env_windows.odin b/core/os/env_windows.odin index ff20f126a..0e3c7f04a 100644 --- a/core/os/env_windows.odin +++ b/core/os/env_windows.odin @@ -1,7 +1,7 @@ package os import win32 "core:sys/windows" -import "core:runtime" +import "base:runtime" // lookup_env gets the value of the environment variable named by the key // If the variable is found in the environment the value (which can be empty) is returned and the boolean is true diff --git a/core/os/file_windows.odin b/core/os/file_windows.odin index 96f6d8e8f..831e9c38c 100644 --- a/core/os/file_windows.odin +++ b/core/os/file_windows.odin @@ -1,8 +1,8 @@ package os import win32 "core:sys/windows" -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" import "core:unicode/utf16" is_path_separator :: proc(c: byte) -> bool { diff --git a/core/os/os.odin b/core/os/os.odin index 3210a39d0..c74712d4e 100644 --- a/core/os/os.odin +++ b/core/os/os.odin @@ -1,5 +1,6 @@ package os +import "base:runtime" import "core:mem" import "core:strconv" import "core:unicode/utf8" @@ -168,99 +169,12 @@ read_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) { return read(fd, s) } -heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, mem.Allocator_Error) { - // - // NOTE(tetra, 2020-01-14): The heap doesn't respect alignment. - // Instead, we overallocate by `alignment + size_of(rawptr) - 1`, and insert - // padding. We also store the original pointer returned by heap_alloc right before - // the pointer we return to the user. - // +heap_allocator_proc :: runtime.heap_allocator_proc +heap_allocator :: runtime.heap_allocator - aligned_alloc :: proc(size, alignment: int, old_ptr: rawptr = nil, zero_memory := true) -> ([]byte, mem.Allocator_Error) { - a := max(alignment, align_of(rawptr)) - space := size + a - 1 - - allocated_mem: rawptr - if old_ptr != nil { - original_old_ptr := mem.ptr_offset((^rawptr)(old_ptr), -1)^ - allocated_mem = heap_resize(original_old_ptr, space+size_of(rawptr)) - } else { - allocated_mem = heap_alloc(space+size_of(rawptr), zero_memory) - } - aligned_mem := rawptr(mem.ptr_offset((^u8)(allocated_mem), size_of(rawptr))) - - ptr := uintptr(aligned_mem) - aligned_ptr := (ptr - 1 + uintptr(a)) & -uintptr(a) - diff := int(aligned_ptr - ptr) - if (size + diff) > space || allocated_mem == nil { - return nil, .Out_Of_Memory - } - - aligned_mem = rawptr(aligned_ptr) - mem.ptr_offset((^rawptr)(aligned_mem), -1)^ = allocated_mem - - return mem.byte_slice(aligned_mem, size), nil - } - - aligned_free :: proc(p: rawptr) { - if p != nil { - heap_free(mem.ptr_offset((^rawptr)(p), -1)^) - } - } - - aligned_resize :: proc(p: rawptr, old_size: int, new_size: int, new_alignment: int, zero_memory := true) -> (new_memory: []byte, err: mem.Allocator_Error) { - if p == nil { - return nil, nil - } - - new_memory = aligned_alloc(new_size, new_alignment, p, zero_memory) or_return - - // NOTE: heap_resize does not zero the new memory, so we do it - if zero_memory && new_size > old_size { - new_region := mem.raw_data(new_memory[old_size:]) - mem.zero(new_region, new_size - old_size) - } - return - } - - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - return aligned_alloc(size, alignment, nil, mode == .Alloc) - - case .Free: - aligned_free(old_memory) - - case .Free_All: - return nil, .Mode_Not_Implemented - - case .Resize, .Resize_Non_Zeroed: - if old_memory == nil { - return aligned_alloc(size, alignment, nil, mode == .Resize) - } - return aligned_resize(old_memory, old_size, size, alignment, mode == .Resize) - - case .Query_Features: - set := (^mem.Allocator_Mode_Set)(old_memory) - if set != nil { - set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Resize_Non_Zeroed, .Query_Features} - } - return nil, nil - - case .Query_Info: - return nil, .Mode_Not_Implemented - } - - return nil, nil -} - -heap_allocator :: proc() -> mem.Allocator { - return mem.Allocator{ - procedure = heap_allocator_proc, - data = nil, - } -} +heap_alloc :: runtime.heap_alloc +heap_resize :: runtime.heap_resize +heap_free :: runtime.heap_free processor_core_count :: proc() -> int { return _processor_core_count() diff --git a/core/os/os2/env.odin b/core/os/os2/env.odin index 54c26981b..bed4bebd9 100644 --- a/core/os/os2/env.odin +++ b/core/os/os2/env.odin @@ -1,6 +1,6 @@ package os2 -import "core:runtime" +import "base:runtime" // get_env retrieves the value of the environment variable named by the key // It returns the value, which will be empty if the variable is not present diff --git a/core/os/os2/env_linux.odin b/core/os/os2/env_linux.odin index e7165b583..eb463f22c 100644 --- a/core/os/os2/env_linux.odin +++ b/core/os/os2/env_linux.odin @@ -1,7 +1,7 @@ //+private package os2 -import "core:runtime" +import "base:runtime" _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) { //TODO diff --git a/core/os/os2/env_windows.odin b/core/os/os2/env_windows.odin index 105063343..9829b7de1 100644 --- a/core/os/os2/env_windows.odin +++ b/core/os/os2/env_windows.odin @@ -2,7 +2,7 @@ package os2 import win32 "core:sys/windows" -import "core:runtime" +import "base:runtime" _lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) { if key == "" { diff --git a/core/os/os2/errors.odin b/core/os/os2/errors.odin index 2cff73ebd..426375a5a 100644 --- a/core/os/os2/errors.odin +++ b/core/os/os2/errors.odin @@ -1,7 +1,7 @@ package os2 import "core:io" -import "core:runtime" +import "base:runtime" General_Error :: enum u32 { None, diff --git a/core/os/os2/file.odin b/core/os/os2/file.odin index da822374a..1b98ae1dd 100644 --- a/core/os/os2/file.odin +++ b/core/os/os2/file.odin @@ -2,7 +2,7 @@ package os2 import "core:io" import "core:time" -import "core:runtime" +import "base:runtime" File :: struct { impl: _File, @@ -156,41 +156,46 @@ read_link :: proc(name: string, allocator: runtime.Allocator) -> (string, Error) } -chdir :: proc(name: string) -> Error { +chdir :: change_directory +change_directory :: proc(name: string) -> Error { return _chdir(name) } -chmod :: proc(name: string, mode: File_Mode) -> Error { +chmod :: change_mode +change_mode :: proc(name: string, mode: File_Mode) -> Error { return _chmod(name, mode) } - -chown :: proc(name: string, uid, gid: int) -> Error { +chown :: change_owner +change_owner :: proc(name: string, uid, gid: int) -> Error { return _chown(name, uid, gid) } -fchdir :: proc(f: ^File) -> Error { +fchdir :: fchange_directory +fchange_directory :: proc(f: ^File) -> Error { return _fchdir(f) } - -fchmod :: proc(f: ^File, mode: File_Mode) -> Error { +fchmod :: fchange_mode +fchange_mode :: proc(f: ^File, mode: File_Mode) -> Error { return _fchmod(f, mode) } -fchown :: proc(f: ^File, uid, gid: int) -> Error { +fchown :: fchange_owner +fchange_owner :: proc(f: ^File, uid, gid: int) -> Error { return _fchown(f, uid, gid) } - -lchown :: proc(name: string, uid, gid: int) -> Error { +lchown :: change_owner_do_not_follow_links +change_owner_do_not_follow_links :: proc(name: string, uid, gid: int) -> Error { return _lchown(name, uid, gid) } - -chtimes :: proc(name: string, atime, mtime: time.Time) -> Error { +chtimes :: change_times +change_times :: proc(name: string, atime, mtime: time.Time) -> Error { return _chtimes(name, atime, mtime) } -fchtimes :: proc(f: ^File, atime, mtime: time.Time) -> Error { +fchtimes :: fchange_times +fchange_times :: proc(f: ^File, atime, mtime: time.Time) -> Error { return _fchtimes(f, atime, mtime) } @@ -202,7 +207,8 @@ is_file :: proc(path: string) -> bool { return _is_file(path) } -is_dir :: proc(path: string) -> bool { +is_dir :: is_directory +is_directory :: proc(path: string) -> bool { return _is_dir(path) } @@ -213,7 +219,7 @@ copy_file :: proc(dst_path, src_path: string) -> Error { info := fstat(src, _file_allocator()) or_return defer file_info_delete(info, _file_allocator()) - if info.is_dir { + if info.is_directory { return .Invalid_File } diff --git a/core/os/os2/file_linux.odin b/core/os/os2/file_linux.odin index ddd827bce..d5626791f 100644 --- a/core/os/os2/file_linux.odin +++ b/core/os/os2/file_linux.odin @@ -4,7 +4,7 @@ package os2 import "core:io" import "core:time" import "core:strings" -import "core:runtime" +import "base:runtime" import "core:sys/unix" INVALID_HANDLE :: -1 diff --git a/core/os/os2/file_util.odin b/core/os/os2/file_util.odin index 60c3efe44..e52d53f08 100644 --- a/core/os/os2/file_util.odin +++ b/core/os/os2/file_util.odin @@ -1,7 +1,7 @@ package os2 import "core:mem" -import "core:runtime" +import "base:runtime" import "core:strconv" import "core:unicode/utf8" @@ -74,14 +74,21 @@ read_ptr :: proc(f: ^File, data: rawptr, len: int) -> (n: int, err: Error) { } +read_entire_file :: proc{ + read_entire_file_from_path, + read_entire_file_from_file, +} -read_entire_file :: proc(name: string, allocator: runtime.Allocator) -> (data: []byte, err: Error) { +read_entire_file_from_path :: proc(name: string, allocator: runtime.Allocator) -> (data: []byte, err: Error) { f, ferr := open(name) if ferr != nil { return nil, ferr } defer close(f) + return read_entire_file_from_file(f, allocator) +} +read_entire_file_from_file :: proc(f: ^File, allocator: runtime.Allocator) -> (data: []byte, err: Error) { size: int if size64, err := file_size(f); err == nil { if i64(int(size64)) != size64 { diff --git a/core/os/os2/file_windows.odin b/core/os/os2/file_windows.odin index 7c31defe9..ba8e8cdac 100644 --- a/core/os/os2/file_windows.odin +++ b/core/os/os2/file_windows.odin @@ -4,7 +4,7 @@ package os2 import "core:io" import "core:mem" import "core:sync" -import "core:runtime" +import "base:runtime" import "core:strings" import "core:time" import "core:unicode/utf16" diff --git a/core/os/os2/heap.odin b/core/os/os2/heap.odin index 92b5a9928..a07a0d618 100644 --- a/core/os/os2/heap.odin +++ b/core/os/os2/heap.odin @@ -1,6 +1,6 @@ package os2 -import "core:runtime" +import "base:runtime" heap_allocator :: proc() -> runtime.Allocator { return runtime.Allocator{ diff --git a/core/os/os2/heap_linux.odin b/core/os/os2/heap_linux.odin index 74528f242..bb4acba13 100644 --- a/core/os/os2/heap_linux.odin +++ b/core/os/os2/heap_linux.odin @@ -200,7 +200,7 @@ _heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode, case .Free_All: return nil, .Mode_Not_Implemented - case .Resize: + case .Resize, .Resize_Non_Zeroed: if old_memory == nil { return aligned_alloc(size, alignment) } diff --git a/core/os/os2/path.odin b/core/os/os2/path.odin index c27015862..a3e7a5a96 100644 --- a/core/os/os2/path.odin +++ b/core/os/os2/path.odin @@ -1,6 +1,6 @@ package os2 -import "core:runtime" +import "base:runtime" Path_Separator :: _Path_Separator // OS-Specific Path_List_Separator :: _Path_List_Separator // OS-Specific @@ -9,11 +9,13 @@ is_path_separator :: proc(c: byte) -> bool { return _is_path_separator(c) } -mkdir :: proc(name: string, perm: File_Mode) -> Error { +mkdir :: make_directory +make_directory :: proc(name: string, perm: File_Mode) -> Error { return _mkdir(name, perm) } -mkdir_all :: proc(path: string, perm: File_Mode) -> Error { +mkdir_all :: make_directory_all +make_directory_all :: proc(path: string, perm: File_Mode) -> Error { return _mkdir_all(path, perm) } @@ -22,10 +24,12 @@ remove_all :: proc(path: string) -> Error { } - -getwd :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) { +getwd :: get_working_directory +get_working_directory :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) { return _getwd(allocator) } -setwd :: proc(dir: string) -> (err: Error) { + +setwd :: set_working_directory +set_working_directory :: proc(dir: string) -> (err: Error) { return _setwd(dir) } diff --git a/core/os/os2/path_linux.odin b/core/os/os2/path_linux.odin index 2a0ef29d8..93de749b8 100644 --- a/core/os/os2/path_linux.odin +++ b/core/os/os2/path_linux.odin @@ -3,7 +3,7 @@ package os2 import "core:strings" import "core:strconv" -import "core:runtime" +import "base:runtime" import "core:sys/unix" _Path_Separator :: '/' diff --git a/core/os/os2/path_windows.odin b/core/os/os2/path_windows.odin index a2306784e..45c6bdc37 100644 --- a/core/os/os2/path_windows.odin +++ b/core/os/os2/path_windows.odin @@ -2,7 +2,7 @@ package os2 import win32 "core:sys/windows" -import "core:runtime" +import "base:runtime" import "core:strings" _Path_Separator :: '\\' @@ -33,7 +33,7 @@ _mkdir_all :: proc(path: string, perm: File_Mode) -> Error { dir, err := stat(path, _temp_allocator()) if err == nil { - if dir.is_dir { + if dir.is_directory { return nil } return .Exist @@ -60,7 +60,7 @@ _mkdir_all :: proc(path: string, perm: File_Mode) -> Error { err = mkdir(path, perm) if err != nil { dir1, err1 := lstat(path, _temp_allocator()) - if err1 == nil && dir1.is_dir { + if err1 == nil && dir1.is_directory { return nil } return err diff --git a/core/os/os2/process.odin b/core/os/os2/process.odin index db47e2f5b..862434b7b 100644 --- a/core/os/os2/process.odin +++ b/core/os/os2/process.odin @@ -2,7 +2,7 @@ package os2 import "core:sync" import "core:time" -import "core:runtime" +import "base:runtime" args: []string diff --git a/core/os/os2/stat.odin b/core/os/os2/stat.odin index 24a01fb0a..a64522ac1 100644 --- a/core/os/os2/stat.odin +++ b/core/os/os2/stat.odin @@ -1,14 +1,14 @@ package os2 import "core:time" -import "core:runtime" +import "base:runtime" File_Info :: struct { - fullpath: string, - name: string, - size: i64, - mode: File_Mode, - is_dir: bool, + fullpath: string, + name: string, + size: i64, + mode: File_Mode, + is_directory: bool, creation_time: time.Time, modification_time: time.Time, access_time: time.Time, @@ -33,7 +33,8 @@ stat :: proc(name: string, allocator: runtime.Allocator) -> (File_Info, Error) { return _stat(name, allocator) } -lstat :: proc(name: string, allocator: runtime.Allocator) -> (File_Info, Error) { +lstat :: stat_do_not_follow_links +stat_do_not_follow_links :: proc(name: string, allocator: runtime.Allocator) -> (File_Info, Error) { return _lstat(name, allocator) } diff --git a/core/os/os2/stat_linux.odin b/core/os/os2/stat_linux.odin index 530e0e7d0..db929a719 100644 --- a/core/os/os2/stat_linux.odin +++ b/core/os/os2/stat_linux.odin @@ -2,7 +2,7 @@ package os2 import "core:time" -import "core:runtime" +import "base:runtime" import "core:strings" import "core:sys/unix" import "core:path/filepath" @@ -101,7 +101,7 @@ _fstat_internal :: proc(fd: int, allocator: runtime.Allocator) -> (File_Info, Er name = "", size = s.size, mode = 0, - is_dir = S_ISDIR(s.mode), + is_directory = S_ISDIR(s.mode), modification_time = time.Time {s.modified.seconds}, access_time = time.Time {s.last_access.seconds}, creation_time = time.Time{0}, // regular stat does not provide this diff --git a/core/os/os2/stat_windows.odin b/core/os/os2/stat_windows.odin index 5de5269d7..8d8e17fcf 100644 --- a/core/os/os2/stat_windows.odin +++ b/core/os/os2/stat_windows.odin @@ -1,7 +1,7 @@ //+private package os2 -import "core:runtime" +import "base:runtime" import "core:time" import "core:strings" import win32 "core:sys/windows" @@ -228,7 +228,7 @@ _file_info_from_win32_file_attribute_data :: proc(d: ^win32.WIN32_FILE_ATTRIBUTE fi.size = i64(d.nFileSizeHigh)<<32 + i64(d.nFileSizeLow) fi.mode |= _file_mode_from_file_attributes(d.dwFileAttributes, nil, 0) - fi.is_dir = fi.mode & File_Mode_Dir != 0 + fi.is_directory = fi.mode & File_Mode_Dir != 0 fi.creation_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftCreationTime)) fi.modification_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftLastWriteTime)) @@ -245,7 +245,7 @@ _file_info_from_win32_find_data :: proc(d: ^win32.WIN32_FIND_DATAW, name: string fi.size = i64(d.nFileSizeHigh)<<32 + i64(d.nFileSizeLow) fi.mode |= _file_mode_from_file_attributes(d.dwFileAttributes, nil, 0) - fi.is_dir = fi.mode & File_Mode_Dir != 0 + fi.is_directory = fi.mode & File_Mode_Dir != 0 fi.creation_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftCreationTime)) fi.modification_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftLastWriteTime)) @@ -282,7 +282,7 @@ _file_info_from_get_file_information_by_handle :: proc(path: string, h: win32.HA fi.size = i64(d.nFileSizeHigh)<<32 + i64(d.nFileSizeLow) fi.mode |= _file_mode_from_file_attributes(ti.FileAttributes, h, ti.ReparseTag) - fi.is_dir = fi.mode & File_Mode_Dir != 0 + fi.is_directory = fi.mode & File_Mode_Dir != 0 fi.creation_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftCreationTime)) fi.modification_time = time.unix(0, win32.FILETIME_as_unix_nanoseconds(d.ftLastWriteTime)) diff --git a/core/os/os2/temp_file.odin b/core/os/os2/temp_file.odin index b05c186a0..f12c2800e 100644 --- a/core/os/os2/temp_file.odin +++ b/core/os/os2/temp_file.odin @@ -1,15 +1,17 @@ package os2 -import "core:runtime" +import "base:runtime" -create_temp :: proc(dir, pattern: string) -> (^File, Error) { +create_temp_file :: proc(dir, pattern: string) -> (^File, Error) { return _create_temp(dir, pattern) } -mkdir_temp :: proc(dir, pattern: string, allocator: runtime.Allocator) -> (string, Error) { +mkdir_temp :: make_directory_temp +make_directory_temp :: proc(dir, pattern: string, allocator: runtime.Allocator) -> (string, Error) { return _mkdir_temp(dir, pattern, allocator) } -temp_dir :: proc(allocator: runtime.Allocator) -> (string, Error) { +temp_dir :: temp_directory +temp_directory :: proc(allocator: runtime.Allocator) -> (string, Error) { return _temp_dir(allocator) } diff --git a/core/os/os2/temp_file_linux.odin b/core/os/os2/temp_file_linux.odin index 201fb0e93..dd7ac5c97 100644 --- a/core/os/os2/temp_file_linux.odin +++ b/core/os/os2/temp_file_linux.odin @@ -1,7 +1,7 @@ //+private package os2 -import "core:runtime" +import "base:runtime" _create_temp :: proc(dir, pattern: string) -> (^File, Error) { diff --git a/core/os/os2/temp_file_windows.odin b/core/os/os2/temp_file_windows.odin index 08837f7f0..27d6a3d77 100644 --- a/core/os/os2/temp_file_windows.odin +++ b/core/os/os2/temp_file_windows.odin @@ -1,7 +1,7 @@ //+private package os2 -import "core:runtime" +import "base:runtime" import win32 "core:sys/windows" _create_temp :: proc(dir, pattern: string) -> (^File, Error) { diff --git a/core/os/os2/user.odin b/core/os/os2/user.odin index 0e9f126aa..0af461bf5 100644 --- a/core/os/os2/user.odin +++ b/core/os/os2/user.odin @@ -1,7 +1,7 @@ package os2 import "core:strings" -import "core:runtime" +import "base:runtime" user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) { #partial switch ODIN_OS { diff --git a/core/os/os_darwin.odin b/core/os/os_darwin.odin index 82cf5e1f3..5a093b421 100644 --- a/core/os/os_darwin.odin +++ b/core/os/os_darwin.odin @@ -1,10 +1,10 @@ package os foreign import dl "system:dl" -foreign import libc "System.framework" -foreign import pthread "System.framework" +foreign import libc "system:System.framework" +foreign import pthread "system:System.framework" -import "core:runtime" +import "base:runtime" import "core:strings" import "core:c" @@ -859,25 +859,6 @@ access :: proc(path: string, mask: int) -> bool { return _unix_access(cstr, mask) == 0 } -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - if size <= 0 { - return nil - } - if zero_memory { - return _unix_calloc(1, size) - } else { - return _unix_malloc(size) - } -} -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - // NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on - // POSIX platforms. Ensure your caller takes this into account. - return _unix_realloc(ptr, new_size) -} -heap_free :: proc(ptr: rawptr) { - _unix_free(ptr) -} - lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) { runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator) path_str := strings.clone_to_cstring(key, context.temp_allocator) diff --git a/core/os/os_freebsd.odin b/core/os/os_freebsd.odin index c2ea82bf5..2fccac87d 100644 --- a/core/os/os_freebsd.odin +++ b/core/os/os_freebsd.odin @@ -3,7 +3,7 @@ package os foreign import dl "system:dl" foreign import libc "system:c" -import "core:runtime" +import "base:runtime" import "core:strings" import "core:c" @@ -255,7 +255,7 @@ W_OK :: 2 // Test for write permission R_OK :: 4 // Test for read permission foreign libc { - @(link_name="__error") __errno_location :: proc() -> ^int --- + @(link_name="__error") __errno_location :: proc() -> ^c.int --- @(link_name="open") _unix_open :: proc(path: cstring, flags: c.int, mode: c.int) -> Handle --- @(link_name="close") _unix_close :: proc(fd: Handle) -> c.int --- @@ -305,7 +305,7 @@ is_path_separator :: proc(r: rune) -> bool { } get_last_error :: proc "contextless" () -> int { - return __errno_location()^ + return int(__errno_location()^) } open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) { @@ -617,27 +617,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) { return true, ERROR_NONE } -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - if size <= 0 { - return nil - } - if zero_memory { - return _unix_calloc(1, c.size_t(size)) - } else { - return _unix_malloc(c.size_t(size)) - } -} - -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - // NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on - // POSIX platforms. Ensure your caller takes this into account. - return _unix_realloc(ptr, c.size_t(new_size)) -} - -heap_free :: proc(ptr: rawptr) { - _unix_free(ptr) -} - lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) { runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator) diff --git a/core/os/os_js.odin b/core/os/os_js.odin index 5d7eb784e..910cb8155 100644 --- a/core/os/os_js.odin +++ b/core/os/os_js.odin @@ -1,8 +1,8 @@ //+build js package os -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" import "core:unicode/utf16" is_path_separator :: proc(c: byte) -> bool { @@ -237,17 +237,6 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) { } - -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - unimplemented("core:os procedure not supported on JS target") -} -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - unimplemented("core:os procedure not supported on JS target") -} -heap_free :: proc(ptr: rawptr) { - unimplemented("core:os procedure not supported on JS target") -} - get_page_size :: proc() -> int { unimplemented("core:os procedure not supported on JS target") } diff --git a/core/os/os_linux.odin b/core/os/os_linux.odin index 298335ac9..713019951 100644 --- a/core/os/os_linux.odin +++ b/core/os/os_linux.odin @@ -3,11 +3,11 @@ package os foreign import dl "system:dl" foreign import libc "system:c" -import "core:runtime" +import "base:runtime" import "core:strings" import "core:c" import "core:strconv" -import "core:intrinsics" +import "base:intrinsics" // NOTE(flysand): For compatibility we'll make core:os package // depend on the old (scheduled for removal) linux package. @@ -888,27 +888,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) { return true, ERROR_NONE } -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - if size <= 0 { - return nil - } - if zero_memory { - return _unix_calloc(1, c.size_t(size)) - } else { - return _unix_malloc(c.size_t(size)) - } -} - -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - // NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on - // POSIX platforms. Ensure your caller takes this into account. - return _unix_realloc(ptr, c.size_t(new_size)) -} - -heap_free :: proc(ptr: rawptr) { - _unix_free(ptr) -} - lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) { runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator) path_str := strings.clone_to_cstring(key, context.temp_allocator) diff --git a/core/os/os_openbsd.odin b/core/os/os_openbsd.odin index 957873a0b..1a9b88c02 100644 --- a/core/os/os_openbsd.odin +++ b/core/os/os_openbsd.odin @@ -4,7 +4,7 @@ foreign import libc "system:c" import "core:strings" import "core:c" -import "core:runtime" +import "base:runtime" Handle :: distinct i32 Pid :: distinct i32 @@ -246,7 +246,7 @@ AT_REMOVEDIR :: 0x08 @(default_calling_convention="c") foreign libc { - @(link_name="__errno") __errno :: proc() -> ^int --- + @(link_name="__error") __error :: proc() -> ^c.int --- @(link_name="fork") _unix_fork :: proc() -> pid_t --- @(link_name="getthrid") _unix_getthrid :: proc() -> int --- @@ -296,7 +296,7 @@ is_path_separator :: proc(r: rune) -> bool { } get_last_error :: proc "contextless" () -> int { - return __errno()^ + return int(__error()^) } fork :: proc() -> (Pid, Errno) { @@ -615,27 +615,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) { return true, ERROR_NONE } -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - if size <= 0 { - return nil - } - if zero_memory { - return _unix_calloc(1, c.size_t(size)) - } else { - return _unix_malloc(c.size_t(size)) - } -} - -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - // NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on - // POSIX platforms. Ensure your caller takes this into account. - return _unix_realloc(ptr, c.size_t(new_size)) -} - -heap_free :: proc(ptr: rawptr) { - _unix_free(ptr) -} - lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) { runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator) path_str := strings.clone_to_cstring(key, context.temp_allocator) diff --git a/core/os/os_wasi.odin b/core/os/os_wasi.odin index c407acdb4..9bfd87322 100644 --- a/core/os/os_wasi.odin +++ b/core/os/os_wasi.odin @@ -1,7 +1,7 @@ package os import "core:sys/wasm/wasi" -import "core:runtime" +import "base:runtime" Handle :: distinct i32 Errno :: distinct i32 @@ -103,28 +103,6 @@ file_size :: proc(fd: Handle) -> (i64, Errno) { } - -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - return nil -} -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - if new_size == 0 { - heap_free(ptr) - return nil - } - if ptr == nil { - return heap_alloc(new_size) - } - - return nil -} -heap_free :: proc(ptr: rawptr) { - if ptr == nil { - return - } -} - - exit :: proc "contextless" (code: int) -> ! { runtime._cleanup_runtime_contextless() wasi.proc_exit(wasi.exitcode_t(code)) diff --git a/core/os/os_windows.odin b/core/os/os_windows.odin index 7b4c2f6c2..b375e7c66 100644 --- a/core/os/os_windows.odin +++ b/core/os/os_windows.odin @@ -2,8 +2,8 @@ package os import win32 "core:sys/windows" -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" Handle :: distinct uintptr File_Time :: distinct u64 @@ -91,28 +91,6 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) { } - -heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY if zero_memory else 0, uint(size)) -} -heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - if new_size == 0 { - heap_free(ptr) - return nil - } - if ptr == nil { - return heap_alloc(new_size) - } - - return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, uint(new_size)) -} -heap_free :: proc(ptr: rawptr) { - if ptr == nil { - return - } - win32.HeapFree(win32.GetProcessHeap(), 0, ptr) -} - get_page_size :: proc() -> int { // NOTE(tetra): The page size never changes, so why do anything complicated // if we don't have to. diff --git a/core/os/stat_windows.odin b/core/os/stat_windows.odin index efea329ce..4bb3bd4c4 100644 --- a/core/os/stat_windows.odin +++ b/core/os/stat_windows.odin @@ -1,7 +1,7 @@ package os import "core:time" -import "core:runtime" +import "base:runtime" import win32 "core:sys/windows" @(private) diff --git a/core/path/filepath/path_unix.odin b/core/path/filepath/path_unix.odin index 898f34b6a..9beda5557 100644 --- a/core/path/filepath/path_unix.odin +++ b/core/path/filepath/path_unix.odin @@ -2,12 +2,12 @@ package filepath when ODIN_OS == .Darwin { - foreign import libc "System.framework" + foreign import libc "system:System.framework" } else { foreign import libc "system:c" } -import "core:runtime" +import "base:runtime" import "core:strings" SEPARATOR :: '/' diff --git a/core/path/filepath/path_windows.odin b/core/path/filepath/path_windows.odin index e7dd4ab3e..5ebd2cdc2 100644 --- a/core/path/filepath/path_windows.odin +++ b/core/path/filepath/path_windows.odin @@ -1,7 +1,7 @@ package filepath import "core:strings" -import "core:runtime" +import "base:runtime" import "core:os" import win32 "core:sys/windows" diff --git a/core/path/slashpath/path.odin b/core/path/slashpath/path.odin index ada473c34..52b4878bc 100644 --- a/core/path/slashpath/path.odin +++ b/core/path/slashpath/path.odin @@ -5,7 +5,7 @@ // To manipulate operating system specific paths, use the path/filepath package package slashpath -import "core:runtime" +import "base:runtime" import "core:strings" // is_separator checks whether the byte is a valid separator character diff --git a/core/prof/spall/spall.odin b/core/prof/spall/spall.odin index 19a05d70a..7e4334c2c 100644 --- a/core/prof/spall/spall.odin +++ b/core/prof/spall/spall.odin @@ -2,7 +2,7 @@ package spall import "core:os" import "core:time" -import "core:intrinsics" +import "base:intrinsics" import "core:mem" // File Format diff --git a/core/reflect/iterator.odin b/core/reflect/iterator.odin index 2e143284a..5b84f0133 100644 --- a/core/reflect/iterator.odin +++ b/core/reflect/iterator.odin @@ -1,6 +1,6 @@ package reflect -import "core:runtime" +import "base:runtime" @(require_results) iterate_array :: proc(val: any, it: ^int) -> (elem: any, index: int, ok: bool) { diff --git a/core/reflect/reflect.odin b/core/reflect/reflect.odin index 5b57a5ee8..1ff7df229 100644 --- a/core/reflect/reflect.odin +++ b/core/reflect/reflect.odin @@ -1,7 +1,7 @@ package reflect -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" _ :: intrinsics Type_Info :: runtime.Type_Info diff --git a/core/runtime/core_builtin_matrix.odin b/core/runtime/core_builtin_matrix.odin deleted file mode 100644 index 7d60d625c..000000000 --- a/core/runtime/core_builtin_matrix.odin +++ /dev/null @@ -1,274 +0,0 @@ -package runtime - -import "core:intrinsics" -_ :: intrinsics - - -@(builtin) -determinant :: proc{ - matrix1x1_determinant, - matrix2x2_determinant, - matrix3x3_determinant, - matrix4x4_determinant, -} - -@(builtin) -adjugate :: proc{ - matrix1x1_adjugate, - matrix2x2_adjugate, - matrix3x3_adjugate, - matrix4x4_adjugate, -} - -@(builtin) -inverse_transpose :: proc{ - matrix1x1_inverse_transpose, - matrix2x2_inverse_transpose, - matrix3x3_inverse_transpose, - matrix4x4_inverse_transpose, -} - - -@(builtin) -inverse :: proc{ - matrix1x1_inverse, - matrix2x2_inverse, - matrix3x3_inverse, - matrix4x4_inverse, -} - -@(builtin, require_results) -hermitian_adjoint :: proc "contextless" (m: $M/matrix[$N, N]$T) -> M where intrinsics.type_is_complex(T), N >= 1 { - return conj(transpose(m)) -} - -@(builtin, require_results) -matrix_trace :: proc "contextless" (m: $M/matrix[$N, N]$T) -> (trace: T) { - for i in 0.. (minor: T) where N > 1 { - K :: N-1 - cut_down: matrix[K, K]T - for col_idx in 0..= column) - for row_idx in 0..= row) - cut_down[row_idx, col_idx] = m[i, j] - } - } - return determinant(cut_down) -} - - - -@(builtin, require_results) -matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) { - return m[0, 0] -} - -@(builtin, require_results) -matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) { - return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] -} -@(builtin, require_results) -matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) { - a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) - b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) - c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) - return a + b + c -} -@(builtin, require_results) -matrix4x4_determinant :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) { - a := adjugate(m) - #no_bounds_check for i in 0..<4 { - det += m[0, i] * a[0, i] - } - return -} - - - - -@(builtin, require_results) -matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { - y = x - return -} - -@(builtin, require_results) -matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { - y[0, 0] = +x[1, 1] - y[0, 1] = -x[1, 0] - y[1, 0] = -x[0, 1] - y[1, 1] = +x[0, 0] - return -} - -@(builtin, require_results) -matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) { - y[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) - y[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) - y[0, 2] = +(m[1, 0] * m[2, 1] - m[2, 0] * m[1, 1]) - y[1, 0] = -(m[0, 1] * m[2, 2] - m[2, 1] * m[0, 2]) - y[1, 1] = +(m[0, 0] * m[2, 2] - m[2, 0] * m[0, 2]) - y[1, 2] = -(m[0, 0] * m[2, 1] - m[2, 0] * m[0, 1]) - y[2, 0] = +(m[0, 1] * m[1, 2] - m[1, 1] * m[0, 2]) - y[2, 1] = -(m[0, 0] * m[1, 2] - m[1, 0] * m[0, 2]) - y[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) - return -} - - -@(builtin, require_results) -matrix4x4_adjugate :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) { - for i in 0..<4 { - for j in 0..<4 { - sign: T = 1 if (i + j) % 2 == 0 else -1 - y[i, j] = sign * matrix_minor(x, i, j) - } - } - return -} - -@(builtin, require_results) -matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { - y[0, 0] = 1/x[0, 0] - return -} - -@(builtin, require_results) -matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { - d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] - when intrinsics.type_is_integer(T) { - y[0, 0] = +x[1, 1] / d - y[1, 0] = -x[0, 1] / d - y[0, 1] = -x[1, 0] / d - y[1, 1] = +x[0, 0] / d - } else { - id := 1 / d - y[0, 0] = +x[1, 1] * id - y[1, 0] = -x[0, 1] * id - y[0, 1] = -x[1, 0] * id - y[1, 1] = +x[0, 0] * id - } - return -} - -@(builtin, require_results) -matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { - a := adjugate(x) - d := determinant(x) - when intrinsics.type_is_integer(T) { - for i in 0..<3 { - for j in 0..<3 { - y[i, j] = a[i, j] / d - } - } - } else { - id := 1/d - for i in 0..<3 { - for j in 0..<3 { - y[i, j] = a[i, j] * id - } - } - } - return -} - -@(builtin, require_results) -matrix4x4_inverse_transpose :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { - a := adjugate(x) - d: T - for i in 0..<4 { - d += x[0, i] * a[0, i] - } - when intrinsics.type_is_integer(T) { - for i in 0..<4 { - for j in 0..<4 { - y[i, j] = a[i, j] / d - } - } - } else { - id := 1/d - for i in 0..<4 { - for j in 0..<4 { - y[i, j] = a[i, j] * id - } - } - } - return -} - -@(builtin, require_results) -matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) { - y[0, 0] = 1/x[0, 0] - return -} - -@(builtin, require_results) -matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) { - d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0] - when intrinsics.type_is_integer(T) { - y[0, 0] = +x[1, 1] / d - y[0, 1] = -x[0, 1] / d - y[1, 0] = -x[1, 0] / d - y[1, 1] = +x[0, 0] / d - } else { - id := 1 / d - y[0, 0] = +x[1, 1] * id - y[0, 1] = -x[0, 1] * id - y[1, 0] = -x[1, 0] * id - y[1, 1] = +x[0, 0] * id - } - return -} - -@(builtin, require_results) -matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) #no_bounds_check { - a := adjugate(x) - d := determinant(x) - when intrinsics.type_is_integer(T) { - for i in 0..<3 { - for j in 0..<3 { - y[i, j] = a[j, i] / d - } - } - } else { - id := 1/d - for i in 0..<3 { - for j in 0..<3 { - y[i, j] = a[j, i] * id - } - } - } - return -} - -@(builtin, require_results) -matrix4x4_inverse :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) #no_bounds_check { - a := adjugate(x) - d: T - for i in 0..<4 { - d += x[0, i] * a[0, i] - } - when intrinsics.type_is_integer(T) { - for i in 0..<4 { - for j in 0..<4 { - y[i, j] = a[j, i] / d - } - } - } else { - id := 1/d - for i in 0..<4 { - for j in 0..<4 { - y[i, j] = a[j, i] * id - } - } - } - return -} diff --git a/core/runtime/default_allocators_general.odin b/core/runtime/default_allocators_general.odin deleted file mode 100644 index 994a672b0..000000000 --- a/core/runtime/default_allocators_general.odin +++ /dev/null @@ -1,23 +0,0 @@ -//+build !windows -//+build !freestanding -//+build !wasi -//+build !js -package runtime - -// TODO(bill): reimplement these procedures in the os_specific stuff -import "core:os" - -when ODIN_DEFAULT_TO_NIL_ALLOCATOR { - _ :: os - - // mem.nil_allocator reimplementation - default_allocator_proc :: nil_allocator_proc - default_allocator :: nil_allocator -} else { - - default_allocator_proc :: os.heap_allocator_proc - - default_allocator :: proc() -> Allocator { - return os.heap_allocator() - } -} diff --git a/core/runtime/default_allocators_js.odin b/core/runtime/default_allocators_js.odin deleted file mode 100644 index 715073f08..000000000 --- a/core/runtime/default_allocators_js.odin +++ /dev/null @@ -1,5 +0,0 @@ -//+build js -package runtime - -default_allocator_proc :: panic_allocator_proc -default_allocator :: panic_allocator diff --git a/core/runtime/default_allocators_wasi.odin b/core/runtime/default_allocators_wasi.odin deleted file mode 100644 index a7e6842a6..000000000 --- a/core/runtime/default_allocators_wasi.odin +++ /dev/null @@ -1,5 +0,0 @@ -//+build wasi -package runtime - -default_allocator_proc :: panic_allocator_proc -default_allocator :: panic_allocator diff --git a/core/runtime/default_allocators_windows.odin b/core/runtime/default_allocators_windows.odin deleted file mode 100644 index 1b0f78428..000000000 --- a/core/runtime/default_allocators_windows.odin +++ /dev/null @@ -1,44 +0,0 @@ -//+build windows -package runtime - -when ODIN_DEFAULT_TO_NIL_ALLOCATOR { - // mem.nil_allocator reimplementation - default_allocator_proc :: nil_allocator_proc - default_allocator :: nil_allocator -} else { - default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, - size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> (data: []byte, err: Allocator_Error) { - switch mode { - case .Alloc, .Alloc_Non_Zeroed: - data, err = _windows_default_alloc(size, alignment, mode == .Alloc) - - case .Free: - _windows_default_free(old_memory) - - case .Free_All: - return nil, .Mode_Not_Implemented - - case .Resize, .Resize_Non_Zeroed: - data, err = _windows_default_resize(old_memory, old_size, size, alignment) - - case .Query_Features: - set := (^Allocator_Mode_Set)(old_memory) - if set != nil { - set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Query_Features} - } - - case .Query_Info: - return nil, .Mode_Not_Implemented - } - - return - } - - default_allocator :: proc() -> Allocator { - return Allocator{ - procedure = default_allocator_proc, - data = nil, - } - } -} diff --git a/core/runtime/os_specific_any.odin b/core/runtime/os_specific_any.odin deleted file mode 100644 index 6a96655c4..000000000 --- a/core/runtime/os_specific_any.odin +++ /dev/null @@ -1,16 +0,0 @@ -//+build !darwin -//+build !freestanding -//+build !js -//+build !wasi -//+build !windows -package runtime - -import "core:os" - -// TODO(bill): reimplement `os.write` so that it does not rely on package os -// NOTE: Use os_specific_linux.odin, os_specific_darwin.odin, etc -_os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { - context = default_context() - n, err := os.write(os.stderr, data) - return int(n), _OS_Errno(err) -} diff --git a/core/runtime/os_specific_darwin.odin b/core/runtime/os_specific_darwin.odin deleted file mode 100644 index 5de9a7d57..000000000 --- a/core/runtime/os_specific_darwin.odin +++ /dev/null @@ -1,12 +0,0 @@ -//+build darwin -package runtime - -import "core:intrinsics" - -_os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) { - ret := intrinsics.syscall(0x2000004, 1, uintptr(raw_data(data)), uintptr(len(data))) - if ret < 0 { - return 0, _OS_Errno(-ret) - } - return int(ret), 0 -} diff --git a/core/runtime/os_specific_windows.odin b/core/runtime/os_specific_windows.odin deleted file mode 100644 index 4a5907466..000000000 --- a/core/runtime/os_specific_windows.odin +++ /dev/null @@ -1,135 +0,0 @@ -//+build windows -package runtime - -foreign import kernel32 "system:Kernel32.lib" - -@(private="file") -@(default_calling_convention="system") -foreign kernel32 { - // NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency - - // os_write - GetStdHandle :: proc(which: u32) -> rawptr --- - SetHandleInformation :: proc(hObject: rawptr, dwMask: u32, dwFlags: u32) -> b32 --- - WriteFile :: proc(hFile: rawptr, lpBuffer: rawptr, nNumberOfBytesToWrite: u32, lpNumberOfBytesWritten: ^u32, lpOverlapped: rawptr) -> b32 --- - GetLastError :: proc() -> u32 --- - - // default_allocator - GetProcessHeap :: proc() -> rawptr --- - HeapAlloc :: proc(hHeap: rawptr, dwFlags: u32, dwBytes: uint) -> rawptr --- - HeapReAlloc :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr, dwBytes: uint) -> rawptr --- - HeapFree :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr) -> b32 --- -} - -_os_write :: proc "contextless" (data: []byte) -> (n: int, err: _OS_Errno) #no_bounds_check { - if len(data) == 0 { - return 0, 0 - } - - STD_ERROR_HANDLE :: ~u32(0) -12 + 1 - HANDLE_FLAG_INHERIT :: 0x00000001 - MAX_RW :: 1<<30 - - h := GetStdHandle(STD_ERROR_HANDLE) - when size_of(uintptr) == 8 { - SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) - } - - single_write_length: u32 - total_write: i64 - length := i64(len(data)) - - for total_write < length { - remaining := length - total_write - to_write := u32(min(i32(remaining), MAX_RW)) - - e := WriteFile(h, &data[total_write], to_write, &single_write_length, nil) - if single_write_length <= 0 || !e { - err = _OS_Errno(GetLastError()) - n = int(total_write) - return - } - total_write += i64(single_write_length) - } - n = int(total_write) - return -} - -heap_alloc :: proc "contextless" (size: int, zero_memory := true) -> rawptr { - HEAP_ZERO_MEMORY :: 0x00000008 - return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY if zero_memory else 0, uint(size)) -} -heap_resize :: proc "contextless" (ptr: rawptr, new_size: int) -> rawptr { - if new_size == 0 { - heap_free(ptr) - return nil - } - if ptr == nil { - return heap_alloc(new_size) - } - - HEAP_ZERO_MEMORY :: 0x00000008 - return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, uint(new_size)) -} -heap_free :: proc "contextless" (ptr: rawptr) { - if ptr == nil { - return - } - HeapFree(GetProcessHeap(), 0, ptr) -} - - -// -// NOTE(tetra, 2020-01-14): The heap doesn't respect alignment. -// Instead, we overallocate by `alignment + size_of(rawptr) - 1`, and insert -// padding. We also store the original pointer returned by heap_alloc right before -// the pointer we return to the user. -// - - - -_windows_default_alloc_or_resize :: proc "contextless" (size, alignment: int, old_ptr: rawptr = nil, zero_memory := true) -> ([]byte, Allocator_Error) { - if size == 0 { - _windows_default_free(old_ptr) - return nil, nil - } - - a := max(alignment, align_of(rawptr)) - space := size + a - 1 - - allocated_mem: rawptr - if old_ptr != nil { - original_old_ptr := ([^]rawptr)(old_ptr)[-1] - allocated_mem = heap_resize(original_old_ptr, space+size_of(rawptr)) - } else { - allocated_mem = heap_alloc(space+size_of(rawptr), zero_memory) - } - aligned_mem := ([^]u8)(allocated_mem)[size_of(rawptr):] - - ptr := uintptr(aligned_mem) - aligned_ptr := (ptr - 1 + uintptr(a)) & -uintptr(a) - diff := int(aligned_ptr - ptr) - if (size + diff) > space || allocated_mem == nil { - return nil, .Out_Of_Memory - } - - aligned_mem = ([^]byte)(aligned_ptr) - ([^]rawptr)(aligned_mem)[-1] = allocated_mem - - return aligned_mem[:size], nil -} - -_windows_default_alloc :: proc "contextless" (size, alignment: int, zero_memory := true) -> ([]byte, Allocator_Error) { - return _windows_default_alloc_or_resize(size, alignment, nil, zero_memory) -} - - -_windows_default_free :: proc "contextless" (ptr: rawptr) { - if ptr != nil { - heap_free(([^]rawptr)(ptr)[-1]) - } -} - -_windows_default_resize :: proc "contextless" (p: rawptr, old_size: int, new_size: int, new_alignment: int) -> ([]byte, Allocator_Error) { - return _windows_default_alloc_or_resize(new_size, new_alignment, p) -} diff --git a/core/simd/simd.odin b/core/simd/simd.odin index 9d530ec31..c5a594df6 100644 --- a/core/simd/simd.odin +++ b/core/simd/simd.odin @@ -1,7 +1,7 @@ package simd -import "core:builtin" -import "core:intrinsics" +import "base:builtin" +import "base:intrinsics" // 128-bit vector aliases u8x16 :: #simd[16]u8 diff --git a/core/slice/map.odin b/core/slice/map.odin index 50d6dbd37..545ba8305 100644 --- a/core/slice/map.odin +++ b/core/slice/map.odin @@ -1,7 +1,7 @@ package slice -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" _ :: intrinsics _ :: runtime diff --git a/core/slice/ptr.odin b/core/slice/ptr.odin index b17a27dc8..99d4157c3 100644 --- a/core/slice/ptr.odin +++ b/core/slice/ptr.odin @@ -1,7 +1,7 @@ package slice -import "core:builtin" -import "core:runtime" +import "base:builtin" +import "base:runtime" ptr_add :: proc(p: $P/^$T, x: int) -> ^T { return ([^]T)(p)[x:] diff --git a/core/slice/slice.odin b/core/slice/slice.odin index 2a9e29d01..88f8cb799 100644 --- a/core/slice/slice.odin +++ b/core/slice/slice.odin @@ -1,9 +1,9 @@ package slice -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import "core:math/bits" -import "core:runtime" +import "base:runtime" _ :: intrinsics _ :: builtin diff --git a/core/slice/sort_private.odin b/core/slice/sort_private.odin index 32eb7d417..487b51907 100644 --- a/core/slice/sort_private.odin +++ b/core/slice/sort_private.odin @@ -1,7 +1,7 @@ //+private package slice -import "core:intrinsics" +import "base:intrinsics" _ :: intrinsics ORD :: intrinsics.type_is_ordered diff --git a/core/sort/sort.odin b/core/sort/sort.odin index ad972ef8e..322613cc4 100644 --- a/core/sort/sort.odin +++ b/core/sort/sort.odin @@ -2,7 +2,7 @@ package sort import "core:mem" import _slice "core:slice" -import "core:intrinsics" +import "base:intrinsics" _ :: intrinsics _ :: _slice diff --git a/core/strconv/decimal/decimal.odin b/core/strconv/decimal/decimal.odin index 4130da306..06503d01a 100644 --- a/core/strconv/decimal/decimal.odin +++ b/core/strconv/decimal/decimal.odin @@ -249,7 +249,7 @@ shift_right :: proc(a: ^Decimal, k: uint) { trim(a) } -import "core:runtime" +import "base:runtime" println :: proc(args: ..any) { for arg, i in args { if i != 0 { diff --git a/core/strings/builder.odin b/core/strings/builder.odin index d87626d07..72eb815f9 100644 --- a/core/strings/builder.odin +++ b/core/strings/builder.odin @@ -1,6 +1,6 @@ package strings -import "core:runtime" +import "base:runtime" import "core:unicode/utf8" import "core:strconv" import "core:mem" diff --git a/core/strings/intern.odin b/core/strings/intern.odin index 812307b2e..88eea3c50 100644 --- a/core/strings/intern.odin +++ b/core/strings/intern.odin @@ -1,6 +1,6 @@ package strings -import "core:runtime" +import "base:runtime" import "core:mem" // Custom string entry struct diff --git a/core/sync/atomic.odin b/core/sync/atomic.odin index 0900a6544..65d063f15 100644 --- a/core/sync/atomic.odin +++ b/core/sync/atomic.odin @@ -1,6 +1,6 @@ package sync -import "core:intrinsics" +import "base:intrinsics" cpu_relax :: intrinsics.cpu_relax diff --git a/core/sync/futex_darwin.odin b/core/sync/futex_darwin.odin index b85b15782..44746e57b 100644 --- a/core/sync/futex_darwin.odin +++ b/core/sync/futex_darwin.odin @@ -5,7 +5,7 @@ package sync import "core:c" import "core:time" -foreign import System "System.framework" +foreign import System "system:System.framework" foreign System { // __ulock_wait is not available on 10.15 diff --git a/core/sync/futex_wasm.odin b/core/sync/futex_wasm.odin index 248542836..de1013364 100644 --- a/core/sync/futex_wasm.odin +++ b/core/sync/futex_wasm.odin @@ -2,7 +2,7 @@ //+build wasm32, wasm64p32 package sync -import "core:intrinsics" +import "base:intrinsics" import "core:time" _futex_wait :: proc "contextless" (f: ^Futex, expected: u32) -> bool { diff --git a/core/sync/primitives.odin b/core/sync/primitives.odin index 5e71f6336..8fa3dd232 100644 --- a/core/sync/primitives.odin +++ b/core/sync/primitives.odin @@ -1,6 +1,6 @@ package sync -import "core:runtime" +import "base:runtime" import "core:time" current_thread_id :: proc "contextless" () -> int { diff --git a/core/sync/primitives_darwin.odin b/core/sync/primitives_darwin.odin index 726113ae7..146f69e86 100644 --- a/core/sync/primitives_darwin.odin +++ b/core/sync/primitives_darwin.odin @@ -3,9 +3,9 @@ package sync import "core:c" -import "core:intrinsics" +import "base:intrinsics" -foreign import pthread "System.framework" +foreign import pthread "system:System.framework" _current_thread_id :: proc "contextless" () -> int { tid: u64 diff --git a/core/sys/darwin/mach_darwin.odin b/core/sys/darwin/mach_darwin.odin index e6272b9aa..ac33ebb62 100644 --- a/core/sys/darwin/mach_darwin.odin +++ b/core/sys/darwin/mach_darwin.odin @@ -1,6 +1,6 @@ package darwin -foreign import pthread "System.framework" +foreign import pthread "system:System.framework" import "core:c" diff --git a/core/sys/darwin/xnu_system_call_helpers.odin b/core/sys/darwin/xnu_system_call_helpers.odin index c225c77fb..753f7f058 100644 --- a/core/sys/darwin/xnu_system_call_helpers.odin +++ b/core/sys/darwin/xnu_system_call_helpers.odin @@ -1,7 +1,7 @@ package darwin import "core:c" -import "core:runtime" +import "base:runtime" // this package uses the sys prefix for the proc names to indicate that these aren't native syscalls but directly call such sys_write_string :: proc (fd: c.int, message: string) -> bool { diff --git a/core/sys/darwin/xnu_system_call_wrappers.odin b/core/sys/darwin/xnu_system_call_wrappers.odin index c7a6d6bc4..3b051ac19 100644 --- a/core/sys/darwin/xnu_system_call_wrappers.odin +++ b/core/sys/darwin/xnu_system_call_wrappers.odin @@ -1,7 +1,7 @@ package darwin import "core:c" -import "core:intrinsics" +import "base:intrinsics" /* flock */ LOCK_SH :: 1 /* shared lock */ diff --git a/core/sys/info/cpu_intel.odin b/core/sys/info/cpu_intel.odin index 1344c3d2a..2b8f9852f 100644 --- a/core/sys/info/cpu_intel.odin +++ b/core/sys/info/cpu_intel.odin @@ -1,7 +1,7 @@ //+build i386, amd64 package sysinfo -import "core:intrinsics" +import "base:intrinsics" // cpuid :: proc(ax, cx: u32) -> (eax, ebc, ecx, edx: u32) --- cpuid :: intrinsics.x86_cpuid diff --git a/core/sys/info/platform_darwin.odin b/core/sys/info/platform_darwin.odin index 4ca542b7a..4316b2ade 100644 --- a/core/sys/info/platform_darwin.odin +++ b/core/sys/info/platform_darwin.odin @@ -4,7 +4,7 @@ package sysinfo import sys "core:sys/unix" import "core:strconv" import "core:strings" -import "core:runtime" +import "base:runtime" @(private) version_string_buf: [1024]u8 diff --git a/core/sys/info/platform_freebsd.odin b/core/sys/info/platform_freebsd.odin index 1d53da998..26b4be7e9 100644 --- a/core/sys/info/platform_freebsd.odin +++ b/core/sys/info/platform_freebsd.odin @@ -4,7 +4,7 @@ package sysinfo import sys "core:sys/unix" import "core:strings" import "core:strconv" -import "core:runtime" +import "base:runtime" @(private) version_string_buf: [1024]u8 diff --git a/core/sys/info/platform_linux.odin b/core/sys/info/platform_linux.odin index 14961c2a8..93770a460 100644 --- a/core/sys/info/platform_linux.odin +++ b/core/sys/info/platform_linux.odin @@ -1,8 +1,8 @@ // +build linux package sysinfo -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" import "core:strings" import "core:strconv" diff --git a/core/sys/info/platform_openbsd.odin b/core/sys/info/platform_openbsd.odin index dbca6eaf3..772531ceb 100644 --- a/core/sys/info/platform_openbsd.odin +++ b/core/sys/info/platform_openbsd.odin @@ -4,7 +4,7 @@ package sysinfo import sys "core:sys/unix" import "core:strings" import "core:strconv" -import "core:runtime" +import "base:runtime" @(private) version_string_buf: [1024]u8 diff --git a/core/sys/info/platform_windows.odin b/core/sys/info/platform_windows.odin index 9c1c7b04c..250f938b1 100644 --- a/core/sys/info/platform_windows.odin +++ b/core/sys/info/platform_windows.odin @@ -2,12 +2,12 @@ package sysinfo import sys "core:sys/windows" -import "core:intrinsics" +import "base:intrinsics" import "core:strings" import "core:unicode/utf16" import "core:fmt" -import "core:runtime" +import "base:runtime" @(private) version_string_buf: [1024]u8 diff --git a/core/sys/linux/helpers.odin b/core/sys/linux/helpers.odin index cf4143924..9bee57c11 100644 --- a/core/sys/linux/helpers.odin +++ b/core/sys/linux/helpers.odin @@ -1,7 +1,7 @@ //+build linux package linux -import "core:intrinsics" +import "base:intrinsics" // Note(flysand): In the case of syscall let's get rid of extra // casting. First of all, let these syscalls return int, because diff --git a/core/sys/linux/sys.odin b/core/sys/linux/sys.odin index 9a0f18e9f..8a93f0a47 100644 --- a/core/sys/linux/sys.odin +++ b/core/sys/linux/sys.odin @@ -1,6 +1,6 @@ package linux -import "core:intrinsics" +import "base:intrinsics" /* diff --git a/core/sys/unix/pthread_darwin.odin b/core/sys/unix/pthread_darwin.odin index a28de4ad0..358b5d2fd 100644 --- a/core/sys/unix/pthread_darwin.odin +++ b/core/sys/unix/pthread_darwin.odin @@ -86,7 +86,7 @@ PTHREAD_CANCEL_DISABLE :: 1 PTHREAD_CANCEL_DEFERRED :: 0 PTHREAD_CANCEL_ASYNCHRONOUS :: 1 -foreign import pthread "System.framework" +foreign import pthread "system:System.framework" @(default_calling_convention="c") foreign pthread { diff --git a/core/sys/unix/syscalls_linux.odin b/core/sys/unix/syscalls_linux.odin index 3083c084b..038c16276 100644 --- a/core/sys/unix/syscalls_linux.odin +++ b/core/sys/unix/syscalls_linux.odin @@ -1,6 +1,6 @@ package unix -import "core:intrinsics" +import "base:intrinsics" // Linux has inconsistent system call numbering across architectures, // for largely historical reasons. This attempts to provide a unified diff --git a/core/sys/unix/sysctl_darwin.odin b/core/sys/unix/sysctl_darwin.odin index f9530b86f..76c72f478 100644 --- a/core/sys/unix/sysctl_darwin.odin +++ b/core/sys/unix/sysctl_darwin.odin @@ -2,7 +2,7 @@ package unix import "core:sys/darwin" -import "core:intrinsics" +import "base:intrinsics" _ :: darwin diff --git a/core/sys/unix/sysctl_freebsd.odin b/core/sys/unix/sysctl_freebsd.odin index 5b0bcb88d..d1acbc2a1 100644 --- a/core/sys/unix/sysctl_freebsd.odin +++ b/core/sys/unix/sysctl_freebsd.odin @@ -1,7 +1,7 @@ //+build freebsd package unix -import "core:intrinsics" +import "base:intrinsics" sysctl :: proc(mib: []i32, val: ^$T) -> (ok: bool) { mib := mib diff --git a/core/sys/unix/time_unix.odin b/core/sys/unix/time_unix.odin index fa3a7a29d..108067dd4 100644 --- a/core/sys/unix/time_unix.odin +++ b/core/sys/unix/time_unix.odin @@ -2,7 +2,7 @@ package unix when ODIN_OS == .Darwin { - foreign import libc "System.framework" + foreign import libc "system:System.framework" } else { foreign import libc "system:c" } diff --git a/core/sys/valgrind/callgrind.odin b/core/sys/valgrind/callgrind.odin index cf377e353..b1ba8c6e9 100644 --- a/core/sys/valgrind/callgrind.odin +++ b/core/sys/valgrind/callgrind.odin @@ -1,7 +1,7 @@ //+build amd64 package sys_valgrind -import "core:intrinsics" +import "base:intrinsics" Callgrind_Client_Request :: enum uintptr { Dump_Stats = 'C'<<24 | 'T'<<16, diff --git a/core/sys/valgrind/helgrind.odin b/core/sys/valgrind/helgrind.odin index 41c047d05..2f0114522 100644 --- a/core/sys/valgrind/helgrind.odin +++ b/core/sys/valgrind/helgrind.odin @@ -1,7 +1,7 @@ //+build amd64 package sys_valgrind -import "core:intrinsics" +import "base:intrinsics" Helgrind_Client_Request :: enum uintptr { Clean_Memory = 'H'<<24 | 'G'<<16, diff --git a/core/sys/valgrind/memcheck.odin b/core/sys/valgrind/memcheck.odin index 6a9fab854..dfbe4c3be 100644 --- a/core/sys/valgrind/memcheck.odin +++ b/core/sys/valgrind/memcheck.odin @@ -1,7 +1,7 @@ //+build amd64 package sys_valgrind -import "core:intrinsics" +import "base:intrinsics" Mem_Check_Client_Request :: enum uintptr { Make_Mem_No_Access = 'M'<<24 | 'C'<<16, diff --git a/core/sys/valgrind/valgrind.odin b/core/sys/valgrind/valgrind.odin index b587ea3bf..d0c46af53 100644 --- a/core/sys/valgrind/valgrind.odin +++ b/core/sys/valgrind/valgrind.odin @@ -1,7 +1,7 @@ //+build amd64 package sys_valgrind -import "core:intrinsics" +import "base:intrinsics" Client_Request :: enum uintptr { Running_On_Valgrind = 4097, diff --git a/core/sys/windows/util.odin b/core/sys/windows/util.odin index 9c9d8f7b4..c68d58de0 100644 --- a/core/sys/windows/util.odin +++ b/core/sys/windows/util.odin @@ -1,8 +1,8 @@ // +build windows package sys_windows -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" L :: intrinsics.constant_utf16_cstring diff --git a/core/testing/runner_windows.odin b/core/testing/runner_windows.odin index dbb9ed1c0..15264355b 100644 --- a/core/testing/runner_windows.odin +++ b/core/testing/runner_windows.odin @@ -3,8 +3,8 @@ package testing import win32 "core:sys/windows" -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" import "core:time" Sema :: struct { diff --git a/core/testing/testing.odin b/core/testing/testing.odin index 1ba05315c..fa12c62b4 100644 --- a/core/testing/testing.odin +++ b/core/testing/testing.odin @@ -3,7 +3,7 @@ package testing import "core:fmt" import "core:io" import "core:time" -import "core:intrinsics" +import "base:intrinsics" import "core:reflect" _ :: reflect // alias reflect to nothing to force visibility for -vet diff --git a/core/text/edit/text_edit.odin b/core/text/edit/text_edit.odin index 3f6565557..caccb6be8 100644 --- a/core/text/edit/text_edit.odin +++ b/core/text/edit/text_edit.odin @@ -6,7 +6,7 @@ package text_edit * https://rxi.github.io/a_simple_undo_system.html */ -import "core:runtime" +import "base:runtime" import "core:time" import "core:mem" import "core:strings" diff --git a/core/text/match/strlib.odin b/core/text/match/strlib.odin index 189ed7ec0..bfa696dcd 100644 --- a/core/text/match/strlib.odin +++ b/core/text/match/strlib.odin @@ -1,6 +1,6 @@ package text_match -import "core:runtime" +import "base:runtime" import "core:unicode" import "core:unicode/utf8" import "core:strings" diff --git a/core/text/table/table.odin b/core/text/table/table.odin index 8d96cb26f..5423519d3 100644 --- a/core/text/table/table.odin +++ b/core/text/table/table.odin @@ -12,7 +12,7 @@ import "core:io" import "core:fmt" import "core:mem" import "core:mem/virtual" -import "core:runtime" +import "base:runtime" Cell :: struct { text: string, diff --git a/core/thread/thread.odin b/core/thread/thread.odin index 9fcc5b84f..1c473bd1d 100644 --- a/core/thread/thread.odin +++ b/core/thread/thread.odin @@ -1,8 +1,8 @@ package thread -import "core:runtime" +import "base:runtime" import "core:mem" -import "core:intrinsics" +import "base:intrinsics" _ :: intrinsics diff --git a/core/thread/thread_js.odin b/core/thread/thread_js.odin index 3c4935495..4f5b5b086 100644 --- a/core/thread/thread_js.odin +++ b/core/thread/thread_js.odin @@ -1,7 +1,7 @@ //+build js package thread -import "core:intrinsics" +import "base:intrinsics" import "core:sync" import "core:mem" diff --git a/core/thread/thread_pool.odin b/core/thread/thread_pool.odin index 1a4119e5f..fddcac89e 100644 --- a/core/thread/thread_pool.odin +++ b/core/thread/thread_pool.odin @@ -6,7 +6,7 @@ package thread Made available under Odin's BSD-3 license. */ -import "core:intrinsics" +import "base:intrinsics" import "core:sync" import "core:mem" diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin index c73085ef6..19e421646 100644 --- a/core/thread/thread_unix.odin +++ b/core/thread/thread_unix.odin @@ -2,7 +2,7 @@ // +private package thread -import "core:intrinsics" +import "base:intrinsics" import "core:sync" import "core:sys/unix" diff --git a/core/thread/thread_windows.odin b/core/thread/thread_windows.odin index 28b2294d1..e85b2b62a 100644 --- a/core/thread/thread_windows.odin +++ b/core/thread/thread_windows.odin @@ -2,7 +2,7 @@ //+private package thread -import "core:intrinsics" +import "base:intrinsics" import "core:sync" import win32 "core:sys/windows" diff --git a/core/time/perf.odin b/core/time/perf.odin index 87192093a..123d67eca 100644 --- a/core/time/perf.odin +++ b/core/time/perf.odin @@ -1,7 +1,7 @@ package time -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" Tick :: struct { _nsec: i64, // relative amount diff --git a/core/time/time.odin b/core/time/time.odin index 90d051a31..7911457de 100644 --- a/core/time/time.odin +++ b/core/time/time.odin @@ -1,6 +1,6 @@ package time -import "core:intrinsics" +import "base:intrinsics" Duration :: distinct i64 diff --git a/core/time/tsc_darwin.odin b/core/time/tsc_darwin.odin index 9e54ee8f7..6688ae7d8 100644 --- a/core/time/tsc_darwin.odin +++ b/core/time/tsc_darwin.odin @@ -4,7 +4,7 @@ package time import "core:c" -foreign import libc "System.framework" +foreign import libc "system:System.framework" foreign libc { @(link_name="sysctlbyname") _sysctlbyname :: proc(path: cstring, oldp: rawptr, oldlenp: rawptr, newp: rawptr, newlen: int) -> c.int --- } diff --git a/core/unicode/utf8/utf8string/string.odin b/core/unicode/utf8/utf8string/string.odin index 86267defb..431939efe 100644 --- a/core/unicode/utf8/utf8string/string.odin +++ b/core/unicode/utf8/utf8string/string.odin @@ -1,8 +1,8 @@ package utf8string import "core:unicode/utf8" -import "core:runtime" -import "core:builtin" +import "base:runtime" +import "base:builtin" String :: struct { contents: string, diff --git a/examples/all/all_main.odin b/examples/all/all_main.odin index 0872e0550..5f03508df 100644 --- a/examples/all/all_main.odin +++ b/examples/all/all_main.odin @@ -94,7 +94,7 @@ import slashpath "core:path/slashpath" import filepath "core:path/filepath" import reflect "core:reflect" -import runtime "core:runtime" +import runtime "base:runtime" import simd "core:simd" import slice "core:slice" import slice_heap "core:slice/heap" diff --git a/examples/demo/demo.odin b/examples/demo/demo.odin index bc6a4d9ea..b2736ffcd 100644 --- a/examples/demo/demo.odin +++ b/examples/demo/demo.odin @@ -2438,7 +2438,7 @@ matrix_type :: proc() { // component-wise multiplication // since a * b would be a standard matrix multiplication - c6 := hadamard_product(a, b) + c6 := intrinsics.hadamard_product(a, b) fmt.println("a + b", c0) @@ -2480,7 +2480,7 @@ matrix_type :: proc() { 5, 0, 6, 0, 0, 7, 0, 8, } - fmt.println("b4", matrix_flatten(b4)) + fmt.println("b4", intrinsics.matrix_flatten(b4)) } { // Casting non-square matrices @@ -2519,7 +2519,7 @@ matrix_type :: proc() { // This is because matrices are stored as values (not a reference type), and thus operations on them will // be stored on the stack. Restricting the maximum element count minimizing the possibility of stack overflows. - // Built-in Procedures (Compiler Level) + // 'intrinsics' Procedures (Compiler Level) // transpose(m) // transposes a matrix // outer_product(a, b) @@ -2540,13 +2540,13 @@ matrix_type :: proc() { // conj(x) // conjugates the elements of a matrix for complex element types only - // Built-in Procedures (Runtime Level) (all square matrix procedures) + // Procedures in "core:math/linalg" and related (Runtime Level) (all square matrix procedures) // determinant(m) // adjugate(m) // inverse(m) // inverse_transpose(m) // hermitian_adjoint(m) - // matrix_trace(m) + // trace(m) // matrix_minor(m) } diff --git a/src/build_settings.cpp b/src/build_settings.cpp index af518bcb4..c29a012ec 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -323,6 +323,7 @@ struct BuildContext { bool ODIN_DEBUG; // Odin in debug mode bool ODIN_DISABLE_ASSERT; // Whether the default 'assert' et al is disabled in code or not bool ODIN_DEFAULT_TO_NIL_ALLOCATOR; // Whether the default allocator is a "nil" allocator or not (i.e. it does nothing) + bool ODIN_DEFAULT_TO_PANIC_ALLOCATOR; // Whether the default allocator is a "panic" allocator or not (i.e. panics on any call to it) bool ODIN_FOREIGN_ERROR_PROCEDURES; bool ODIN_VALGRIND_SUPPORT; @@ -1161,7 +1162,27 @@ gb_internal String get_fullpath_relative(gbAllocator a, String base_dir, String } -gb_internal String get_fullpath_core(gbAllocator a, String path) { +gb_internal String get_fullpath_base_collection(gbAllocator a, String path) { + String module_dir = odin_root_dir(); + + String base = str_lit("base/"); + + isize str_len = module_dir.len + base.len + path.len; + u8 *str = gb_alloc_array(heap_allocator(), u8, str_len+1); + defer (gb_free(heap_allocator(), str)); + + isize i = 0; + gb_memmove(str+i, module_dir.text, module_dir.len); i += module_dir.len; + gb_memmove(str+i, base.text, base.len); i += base.len; + gb_memmove(str+i, path.text, path.len); i += path.len; + str[i] = 0; + + String res = make_string(str, i); + res = string_trim_whitespace(res); + return path_to_fullpath(a, res); +} + +gb_internal String get_fullpath_core_collection(gbAllocator a, String path) { String module_dir = odin_root_dir(); String core = str_lit("core/"); @@ -1454,6 +1475,16 @@ gb_internal void init_build_context(TargetMetrics *cross_target, Subtarget subta break; } } + + if (bc->metrics.os == TargetOs_freestanding) { + bc->ODIN_DEFAULT_TO_NIL_ALLOCATOR = !bc->ODIN_DEFAULT_TO_PANIC_ALLOCATOR; + } else if (is_arch_wasm()) { + if (bc->metrics.os == TargetOs_js || bc->metrics.os == TargetOs_wasi) { + // TODO(bill): Should these even have a default "heap-like" allocator? + } + bc->ODIN_DEFAULT_TO_PANIC_ALLOCATOR = true; + bc->ODIN_DEFAULT_TO_NIL_ALLOCATOR = !bc->ODIN_DEFAULT_TO_PANIC_ALLOCATOR; + } } #if defined(GB_SYSTEM_WINDOWS) @@ -1588,8 +1619,8 @@ gb_internal bool init_build_paths(String init_filename) { produces_output_file = true; } - - if (build_context.ODIN_DEFAULT_TO_NIL_ALLOCATOR) { + if (build_context.ODIN_DEFAULT_TO_NIL_ALLOCATOR || + build_context.ODIN_DEFAULT_TO_PANIC_ALLOCATOR) { bc->no_dynamic_literals = true; } diff --git a/src/check_decl.cpp b/src/check_decl.cpp index ed3a109c2..3ccf1b97a 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -1143,7 +1143,7 @@ gb_internal void check_proc_decl(CheckerContext *ctx, Entity *e, DeclInfo *d) { "\tat %s", LIT(name), token_pos_to_string(pos)); } - } else if (!are_types_identical(this_type, other_type)) { + } else if (!signature_parameter_similar_enough(this_type, other_type)) { error(d->proc_lit, "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %s", @@ -1284,7 +1284,7 @@ gb_internal void check_global_variable_decl(CheckerContext *ctx, Entity *&e, Ast TokenPos pos = f->token.pos; Type *this_type = base_type(e->type); Type *other_type = base_type(f->type); - if (!are_types_identical(this_type, other_type)) { + if (!signature_parameter_similar_enough(this_type, other_type)) { error(e->token, "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %s", diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 4f47ba523..041bf1703 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -4581,7 +4581,8 @@ gb_internal bool is_entity_declared_for_selector(Entity *entity, Scope *import_s if (entity->kind == Entity_Builtin) { // NOTE(bill): Builtin's are in the universal scope which is part of every scopes hierarchy // This means that we should just ignore the found result through it - *allow_builtin = entity->scope == import_scope || entity->scope != builtin_pkg->scope; + *allow_builtin = entity->scope == import_scope || + (entity->scope != builtin_pkg->scope && entity->scope != intrinsics_pkg->scope); } else if ((entity->scope->flags&ScopeFlag_Global) == ScopeFlag_Global && (import_scope->flags&ScopeFlag_Global) == 0) { is_declared = false; } diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index d56e5e212..6897701d6 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1934,7 +1934,7 @@ gb_internal void check_value_decl_stmt(CheckerContext *ctx, Ast *node, u32 mod_f TokenPos pos = f->token.pos; Type *this_type = base_type(e->type); Type *other_type = base_type(f->type); - if (!are_types_identical(this_type, other_type)) { + if (!signature_parameter_similar_enough(this_type, other_type)) { error(e->token, "Foreign entity '%.*s' previously declared elsewhere with a different type\n" "\tat %s", diff --git a/src/checker.cpp b/src/checker.cpp index 498fce7d2..03ff5aec3 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -770,15 +770,17 @@ gb_internal void add_type_info_dependency(CheckerInfo *info, DeclInfo *d, Type * rw_mutex_unlock(&d->type_info_deps_mutex); } -gb_internal AstPackage *get_core_package(CheckerInfo *info, String name) { + +gb_internal AstPackage *get_runtime_package(CheckerInfo *info) { + String name = str_lit("runtime"); gbAllocator a = heap_allocator(); - String path = get_fullpath_core(a, name); + String path = get_fullpath_base_collection(a, name); defer (gb_free(a, path.text)); auto found = string_map_get(&info->packages, path); if (found == nullptr) { gb_printf_err("Name: %.*s\n", LIT(name)); gb_printf_err("Fullpath: %.*s\n", LIT(path)); - + for (auto const &entry : info->packages) { gb_printf_err("%.*s\n", LIT(entry.key)); } @@ -787,6 +789,26 @@ gb_internal AstPackage *get_core_package(CheckerInfo *info, String name) { return *found; } +gb_internal AstPackage *get_core_package(CheckerInfo *info, String name) { + if (name == "runtime") { + return get_runtime_package(info); + } + + gbAllocator a = heap_allocator(); + String path = get_fullpath_core_collection(a, name); + defer (gb_free(a, path.text)); + auto found = string_map_get(&info->packages, path); + if (found == nullptr) { + gb_printf_err("Name: %.*s\n", LIT(name)); + gb_printf_err("Fullpath: %.*s\n", LIT(path)); + + for (auto const &entry : info->packages) { + gb_printf_err("%.*s\n", LIT(entry.key)); + } + GB_ASSERT_MSG(found != nullptr, "Missing core package %.*s", LIT(name)); + } + return *found; +} gb_internal void add_package_dependency(CheckerContext *c, char const *package_name, char const *name) { String n = make_string_c(name); @@ -1069,19 +1091,20 @@ gb_internal void init_universal(void) { } - add_global_bool_constant("ODIN_DEBUG", bc->ODIN_DEBUG); - add_global_bool_constant("ODIN_DISABLE_ASSERT", bc->ODIN_DISABLE_ASSERT); - add_global_bool_constant("ODIN_DEFAULT_TO_NIL_ALLOCATOR", bc->ODIN_DEFAULT_TO_NIL_ALLOCATOR); - add_global_bool_constant("ODIN_NO_DYNAMIC_LITERALS", bc->no_dynamic_literals); - add_global_bool_constant("ODIN_NO_CRT", bc->no_crt); - add_global_bool_constant("ODIN_USE_SEPARATE_MODULES", bc->use_separate_modules); - add_global_bool_constant("ODIN_TEST", bc->command_kind == Command_test); - add_global_bool_constant("ODIN_NO_ENTRY_POINT", bc->no_entry_point); - add_global_bool_constant("ODIN_FOREIGN_ERROR_PROCEDURES", bc->ODIN_FOREIGN_ERROR_PROCEDURES); - add_global_bool_constant("ODIN_NO_RTTI", bc->no_rtti); + add_global_bool_constant("ODIN_DEBUG", bc->ODIN_DEBUG); + add_global_bool_constant("ODIN_DISABLE_ASSERT", bc->ODIN_DISABLE_ASSERT); + add_global_bool_constant("ODIN_DEFAULT_TO_NIL_ALLOCATOR", bc->ODIN_DEFAULT_TO_NIL_ALLOCATOR); + add_global_bool_constant("ODIN_DEFAULT_TO_PANIC_ALLOCATOR", bc->ODIN_DEFAULT_TO_PANIC_ALLOCATOR); + add_global_bool_constant("ODIN_NO_DYNAMIC_LITERALS", bc->no_dynamic_literals); + add_global_bool_constant("ODIN_NO_CRT", bc->no_crt); + add_global_bool_constant("ODIN_USE_SEPARATE_MODULES", bc->use_separate_modules); + add_global_bool_constant("ODIN_TEST", bc->command_kind == Command_test); + add_global_bool_constant("ODIN_NO_ENTRY_POINT", bc->no_entry_point); + add_global_bool_constant("ODIN_FOREIGN_ERROR_PROCEDURES", bc->ODIN_FOREIGN_ERROR_PROCEDURES); + add_global_bool_constant("ODIN_NO_RTTI", bc->no_rtti); - add_global_bool_constant("ODIN_VALGRIND_SUPPORT", bc->ODIN_VALGRIND_SUPPORT); - add_global_bool_constant("ODIN_TILDE", bc->tilde_backend); + add_global_bool_constant("ODIN_VALGRIND_SUPPORT", bc->ODIN_VALGRIND_SUPPORT); + add_global_bool_constant("ODIN_TILDE", bc->tilde_backend); add_global_constant("ODIN_COMPILE_TIMESTAMP", t_untyped_integer, exact_value_i64(odin_compile_timestamp())); @@ -3813,6 +3836,7 @@ gb_internal void check_builtin_attributes(CheckerContext *ctx, Entity *e, Array< case Entity_ProcGroup: case Entity_Procedure: case Entity_TypeName: + case Entity_Constant: // Okay break; default: @@ -4555,10 +4579,10 @@ gb_internal Array find_import_path(Checker *c, AstPackage *start continue; } - if (pkg->kind == Package_Runtime) { - // NOTE(bill): Allow cyclic imports within the runtime package for the time being - continue; - } + // if (pkg->kind == Package_Runtime) { + // // NOTE(bill): Allow cyclic imports within the runtime package for the time being + // continue; + // } ImportPathItem item = {pkg, decl}; if (pkg == end) { diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp index 3bab16293..42ffa6938 100644 --- a/src/checker_builtin_procs.hpp +++ b/src/checker_builtin_procs.hpp @@ -34,11 +34,6 @@ enum BuiltinProcId { BuiltinProc_soa_zip, BuiltinProc_soa_unzip, - - BuiltinProc_transpose, - BuiltinProc_outer_product, - BuiltinProc_hadamard_product, - BuiltinProc_matrix_flatten, BuiltinProc_unreachable, @@ -48,6 +43,11 @@ enum BuiltinProcId { // "Intrinsics" BuiltinProc_is_package_imported, + + BuiltinProc_transpose, + BuiltinProc_outer_product, + BuiltinProc_hadamard_product, + BuiltinProc_matrix_flatten, BuiltinProc_soa_struct, @@ -341,11 +341,6 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { {STR_LIT("soa_zip"), 1, true, Expr_Expr, BuiltinProcPkg_builtin}, {STR_LIT("soa_unzip"), 1, false, Expr_Expr, BuiltinProcPkg_builtin}, - - {STR_LIT("transpose"), 1, false, Expr_Expr, BuiltinProcPkg_builtin}, - {STR_LIT("outer_product"), 2, false, Expr_Expr, BuiltinProcPkg_builtin}, - {STR_LIT("hadamard_product"), 2, false, Expr_Expr, BuiltinProcPkg_builtin}, - {STR_LIT("matrix_flatten"), 1, false, Expr_Expr, BuiltinProcPkg_builtin}, {STR_LIT("unreachable"), 0, false, Expr_Expr, BuiltinProcPkg_builtin, /*diverging*/true}, @@ -356,6 +351,11 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = { // "Intrinsics" {STR_LIT("is_package_imported"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + + {STR_LIT("transpose"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("outer_product"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("hadamard_product"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, + {STR_LIT("matrix_flatten"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics}, {STR_LIT("soa_struct"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, // Type diff --git a/src/main.cpp b/src/main.cpp index 19271d667..d77f135a1 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -273,6 +273,7 @@ enum BuildFlagKind { BuildFlag_DisallowDo, BuildFlag_DefaultToNilAllocator, + BuildFlag_DefaultToPanicAllocator, BuildFlag_StrictStyle, BuildFlag_ForeignErrorProcedures, BuildFlag_NoRTTI, @@ -460,6 +461,7 @@ gb_internal bool parse_build_flags(Array args) { add_flag(&build_flags, BuildFlag_DisallowDo, str_lit("disallow-do"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_DefaultToNilAllocator, str_lit("default-to-nil-allocator"), BuildFlagParam_None, Command__does_check); + add_flag(&build_flags, BuildFlag_DefaultToPanicAllocator, str_lit("default-to-panic-allocator"),BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_StrictStyle, str_lit("strict-style"), BuildFlagParam_None, Command__does_check); add_flag(&build_flags, BuildFlag_ForeignErrorProcedures, str_lit("foreign-error-procedures"), BuildFlagParam_None, Command__does_check); @@ -1122,8 +1124,20 @@ gb_internal bool parse_build_flags(Array args) { break; case BuildFlag_DefaultToNilAllocator: + if (build_context.ODIN_DEFAULT_TO_PANIC_ALLOCATOR) { + gb_printf_err("'-default-to-panic-allocator' cannot be used with '-default-to-nil-allocator'\n"); + bad_flags = true; + } build_context.ODIN_DEFAULT_TO_NIL_ALLOCATOR = true; break; + case BuildFlag_DefaultToPanicAllocator: + if (build_context.ODIN_DEFAULT_TO_NIL_ALLOCATOR) { + gb_printf_err("'-default-to-nil-allocator' cannot be used with '-default-to-panic-allocator'\n"); + bad_flags = true; + } + build_context.ODIN_DEFAULT_TO_PANIC_ALLOCATOR = true; + break; + case BuildFlag_ForeignErrorProcedures: build_context.ODIN_FOREIGN_ERROR_PROCEDURES = true; break; @@ -2376,6 +2390,7 @@ int main(int arg_count, char const **arg_ptr) { TIME_SECTION("init default library collections"); array_init(&library_collections, heap_allocator()); // NOTE(bill): 'core' cannot be (re)defined by the user + add_library_collection(str_lit("base"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("base"))); add_library_collection(str_lit("core"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("core"))); add_library_collection(str_lit("vendor"), get_fullpath_relative(heap_allocator(), odin_root_dir(), str_lit("vendor"))); diff --git a/src/parser.cpp b/src/parser.cpp index b16a88de5..489d6b5d5 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -5460,6 +5460,11 @@ gb_internal bool determine_path_from_string(BlockingMutex *file_mutex, Ast *node if (collection_name.len > 0) { + // NOTE(bill): `base:runtime` == `core:runtime` + if (collection_name == "core" && string_starts_with(file_str, str_lit("runtime"))) { + collection_name = str_lit("base"); + } + if (collection_name == "system") { if (node->kind != Ast_ForeignImportDecl) { syntax_error(node, "The library collection 'system' is restrict for 'foreign_library'"); @@ -5489,13 +5494,12 @@ gb_internal bool determine_path_from_string(BlockingMutex *file_mutex, Ast *node #endif } - if (is_package_name_reserved(file_str)) { *path = file_str; - if (collection_name == "core") { + if (collection_name == "core" || collection_name == "base") { return true; } else { - syntax_error(node, "The package '%.*s' must be imported with the core library collection: 'core:%.*s'", LIT(file_str), LIT(file_str)); + syntax_error(node, "The package '%.*s' must be imported with the 'base' library collection: 'base:%.*s'", LIT(file_str), LIT(file_str)); return false; } } @@ -6133,7 +6137,7 @@ gb_internal ParseFileError parse_packages(Parser *p, String init_filename) { { // Add these packages serially and then process them parallel TokenPos init_pos = {}; { - String s = get_fullpath_core(permanent_allocator(), str_lit("runtime")); + String s = get_fullpath_base_collection(permanent_allocator(), str_lit("runtime")); try_add_import_path(p, s, s, init_pos, Package_Runtime); } @@ -6141,7 +6145,7 @@ gb_internal ParseFileError parse_packages(Parser *p, String init_filename) { p->init_fullpath = init_fullpath; if (build_context.command_kind == Command_test) { - String s = get_fullpath_core(permanent_allocator(), str_lit("testing")); + String s = get_fullpath_core_collection(permanent_allocator(), str_lit("testing")); try_add_import_path(p, s, s, init_pos, Package_Normal); } diff --git a/tests/core/hash/test_core_hash.odin b/tests/core/hash/test_core_hash.odin index e69490143..932d2f34c 100644 --- a/tests/core/hash/test_core_hash.odin +++ b/tests/core/hash/test_core_hash.odin @@ -7,7 +7,7 @@ import "core:testing" import "core:fmt" import "core:os" import "core:math/rand" -import "core:intrinsics" +import "base:intrinsics" TEST_count := 0 TEST_fail := 0 diff --git a/tests/core/image/test_core_image.odin b/tests/core/image/test_core_image.odin index bce5c910b..54b3608b7 100644 --- a/tests/core/image/test_core_image.odin +++ b/tests/core/image/test_core_image.odin @@ -27,7 +27,7 @@ import "core:mem" import "core:os" import "core:time" -import "core:runtime" +import "base:runtime" TEST_SUITE_PATH :: "assets/PNG" diff --git a/tests/core/math/big/test.odin b/tests/core/math/big/test.odin index 8a44ec087..e0762a66d 100644 --- a/tests/core/math/big/test.odin +++ b/tests/core/math/big/test.odin @@ -14,7 +14,7 @@ package math_big_tests TODO: Write tests for `internal_*` and test reusing parameters with the public implementations. */ -import "core:runtime" +import "base:runtime" import "core:strings" import "core:math/big" diff --git a/tests/core/runtime/test_core_runtime.odin b/tests/core/runtime/test_core_runtime.odin index 5ae07ffe2..786cf003a 100644 --- a/tests/core/runtime/test_core_runtime.odin +++ b/tests/core/runtime/test_core_runtime.odin @@ -1,11 +1,11 @@ package test_core_runtime import "core:fmt" -import "core:intrinsics" +import "base:intrinsics" import "core:mem" import "core:os" import "core:reflect" -import "core:runtime" +import "base:runtime" import "core:testing" TEST_count := 0 diff --git a/tests/core/strings/test_core_strings.odin b/tests/core/strings/test_core_strings.odin index 3424675b3..f49476765 100644 --- a/tests/core/strings/test_core_strings.odin +++ b/tests/core/strings/test_core_strings.odin @@ -4,7 +4,7 @@ import "core:strings" import "core:testing" import "core:fmt" import "core:os" -import "core:runtime" +import "base:runtime" import "core:mem" TEST_count := 0 diff --git a/tests/documentation/documentation_tester.odin b/tests/documentation/documentation_tester.odin index 1f0f8ca97..8a798d6c5 100644 --- a/tests/documentation/documentation_tester.odin +++ b/tests/documentation/documentation_tester.odin @@ -273,7 +273,7 @@ import "core:io" import "core:fmt" import "core:thread" import "core:sync" -import "core:intrinsics" +import "base:intrinsics" @(private="file") _read_pipe: os.Handle diff --git a/tests/internal/test_map.odin b/tests/internal/test_map.odin index 781fbad74..2c808d85e 100644 --- a/tests/internal/test_map.odin +++ b/tests/internal/test_map.odin @@ -1,7 +1,7 @@ package test_internal_map import "core:fmt" -import "core:intrinsics" +import "base:intrinsics" import "core:math/rand" import "core:mem" import "core:os" diff --git a/vendor/OpenGL/helpers.odin b/vendor/OpenGL/helpers.odin index 82b69b9ae..a7432db95 100644 --- a/vendor/OpenGL/helpers.odin +++ b/vendor/OpenGL/helpers.odin @@ -5,7 +5,7 @@ package vendor_gl import "core:os" import "core:fmt" import "core:strings" -import "core:runtime" +import "base:runtime" _ :: fmt _ :: runtime diff --git a/vendor/OpenGL/wrappers.odin b/vendor/OpenGL/wrappers.odin index e17b0eb3c..550ba3cfa 100644 --- a/vendor/OpenGL/wrappers.odin +++ b/vendor/OpenGL/wrappers.odin @@ -2,7 +2,7 @@ package vendor_gl #assert(size_of(bool) == size_of(u8)) -import "core:runtime" +import "base:runtime" import "core:fmt" _ :: runtime _ :: fmt diff --git a/vendor/commonmark/cmark.odin b/vendor/commonmark/cmark.odin index 4331e3116..3563dff16 100644 --- a/vendor/commonmark/cmark.odin +++ b/vendor/commonmark/cmark.odin @@ -8,7 +8,7 @@ package vendor_commonmark import "core:c" import "core:c/libc" -import "core:runtime" +import "base:runtime" COMMONMARK_SHARED :: #config(COMMONMARK_SHARED, false) BINDING_VERSION :: Version_Info{major = 0, minor = 30, patch = 2} diff --git a/vendor/darwin/Foundation/NSApplication.odin b/vendor/darwin/Foundation/NSApplication.odin index 3fa0d28b6..c87a3d44c 100644 --- a/vendor/darwin/Foundation/NSApplication.odin +++ b/vendor/darwin/Foundation/NSApplication.odin @@ -2,8 +2,8 @@ package objc_Foundation foreign import "system:Foundation.framework" -import "core:intrinsics" -import "core:runtime" +import "base:intrinsics" +import "base:runtime" import "core:strings" RunLoopMode :: ^String diff --git a/vendor/darwin/Foundation/NSArray.odin b/vendor/darwin/Foundation/NSArray.odin index 3e6520c0d..b238f63f8 100644 --- a/vendor/darwin/Foundation/NSArray.odin +++ b/vendor/darwin/Foundation/NSArray.odin @@ -1,6 +1,6 @@ package objc_Foundation -import "core:intrinsics" +import "base:intrinsics" @(objc_class="NSArray") Array :: struct { diff --git a/vendor/darwin/Foundation/NSBlock.odin b/vendor/darwin/Foundation/NSBlock.odin index ecb31bcfb..b9d94bfee 100644 --- a/vendor/darwin/Foundation/NSBlock.odin +++ b/vendor/darwin/Foundation/NSBlock.odin @@ -1,7 +1,7 @@ package objc_Foundation -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import "core:mem" @(objc_class="NSBlock") diff --git a/vendor/darwin/Foundation/NSEnumerator.odin b/vendor/darwin/Foundation/NSEnumerator.odin index 555e58141..52f3f49d7 100644 --- a/vendor/darwin/Foundation/NSEnumerator.odin +++ b/vendor/darwin/Foundation/NSEnumerator.odin @@ -1,7 +1,7 @@ package objc_Foundation import "core:c" -import "core:intrinsics" +import "base:intrinsics" FastEnumerationState :: struct #packed { state: c.ulong, diff --git a/vendor/darwin/Foundation/NSMenu.odin b/vendor/darwin/Foundation/NSMenu.odin index 6ed9b9918..79da36601 100644 --- a/vendor/darwin/Foundation/NSMenu.odin +++ b/vendor/darwin/Foundation/NSMenu.odin @@ -1,7 +1,7 @@ package objc_Foundation -import "core:builtin" -import "core:intrinsics" +import "base:builtin" +import "base:intrinsics" KeyEquivalentModifierFlag :: enum UInteger { CapsLock = 16, // Set if Caps Lock key is pressed. diff --git a/vendor/darwin/Foundation/NSObject.odin b/vendor/darwin/Foundation/NSObject.odin index fdcf05880..31ece47a1 100644 --- a/vendor/darwin/Foundation/NSObject.odin +++ b/vendor/darwin/Foundation/NSObject.odin @@ -1,6 +1,6 @@ package objc_Foundation -import "core:intrinsics" +import "base:intrinsics" methodSignatureForSelector :: proc "c" (obj: ^Object, selector: SEL) -> rawptr { return msgSend(rawptr, obj, "methodSignatureForSelector:", selector) diff --git a/vendor/darwin/Foundation/NSTypes.odin b/vendor/darwin/Foundation/NSTypes.odin index 671832a2d..fbd883a8f 100644 --- a/vendor/darwin/Foundation/NSTypes.odin +++ b/vendor/darwin/Foundation/NSTypes.odin @@ -1,6 +1,6 @@ package objc_Foundation -import "core:intrinsics" +import "base:intrinsics" @(private) msgSend :: intrinsics.objc_send diff --git a/vendor/darwin/Foundation/NSWindow.odin b/vendor/darwin/Foundation/NSWindow.odin index 16dd5afc3..7159a7c3a 100644 --- a/vendor/darwin/Foundation/NSWindow.odin +++ b/vendor/darwin/Foundation/NSWindow.odin @@ -1,8 +1,8 @@ package objc_Foundation import "core:strings" -import "core:runtime" -import "core:intrinsics" +import "base:runtime" +import "base:intrinsics" Rect :: struct { using origin: Point, diff --git a/vendor/darwin/Foundation/objc.odin b/vendor/darwin/Foundation/objc.odin index 6469b1d1d..673996cbe 100644 --- a/vendor/darwin/Foundation/objc.odin +++ b/vendor/darwin/Foundation/objc.odin @@ -4,7 +4,7 @@ foreign import "system:Foundation.framework" // NOTE: Most of our bindings are reliant on Cocoa (everything under appkit) so just unconditionally import it @(require) foreign import "system:Cocoa.framework" -import "core:intrinsics" +import "base:intrinsics" import "core:c" IMP :: proc "c" (object: id, sel: SEL, #c_vararg args: ..any) -> id diff --git a/vendor/darwin/Metal/MetalTypes.odin b/vendor/darwin/Metal/MetalTypes.odin index b14fe2886..6d372b925 100644 --- a/vendor/darwin/Metal/MetalTypes.odin +++ b/vendor/darwin/Metal/MetalTypes.odin @@ -1,7 +1,7 @@ package objc_Metal import NS "vendor:darwin/Foundation" -import "core:intrinsics" +import "base:intrinsics" BOOL :: NS.BOOL id :: ^NS.Object diff --git a/vendor/darwin/MetalKit/MetalKit.odin b/vendor/darwin/MetalKit/MetalKit.odin index eb09410d1..060824923 100644 --- a/vendor/darwin/MetalKit/MetalKit.odin +++ b/vendor/darwin/MetalKit/MetalKit.odin @@ -3,7 +3,7 @@ package objc_MetalKit import NS "vendor:darwin/Foundation" import MTL "vendor:darwin/Metal" import CA "vendor:darwin/QuartzCore" -import "core:intrinsics" +import "base:intrinsics" @(require) foreign import "system:MetalKit.framework" diff --git a/vendor/darwin/QuartzCore/QuartzCore.odin b/vendor/darwin/QuartzCore/QuartzCore.odin index 93998d95d..8b118ba04 100644 --- a/vendor/darwin/QuartzCore/QuartzCore.odin +++ b/vendor/darwin/QuartzCore/QuartzCore.odin @@ -2,7 +2,7 @@ package objc_QuartzCore import NS "vendor:darwin/Foundation" import MTL "vendor:darwin/Metal" -import "core:intrinsics" +import "base:intrinsics" @(private) msgSend :: intrinsics.objc_send diff --git a/vendor/fontstash/fontstash.odin b/vendor/fontstash/fontstash.odin index 1516e34cf..70edcd109 100644 --- a/vendor/fontstash/fontstash.odin +++ b/vendor/fontstash/fontstash.odin @@ -2,7 +2,7 @@ //+vet !using-param package fontstash -import "core:runtime" +import "base:runtime" import "core:log" import "core:os" import "core:mem" diff --git a/vendor/lua/5.1/lua.odin b/vendor/lua/5.1/lua.odin index a49fa4505..b53c61bb3 100644 --- a/vendor/lua/5.1/lua.odin +++ b/vendor/lua/5.1/lua.odin @@ -1,7 +1,7 @@ package lua_5_1 -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import c "core:c/libc" diff --git a/vendor/lua/5.2/lua.odin b/vendor/lua/5.2/lua.odin index c03fdb6a5..5474da95d 100644 --- a/vendor/lua/5.2/lua.odin +++ b/vendor/lua/5.2/lua.odin @@ -1,7 +1,7 @@ package lua_5_2 -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import c "core:c/libc" diff --git a/vendor/lua/5.3/lua.odin b/vendor/lua/5.3/lua.odin index c32801bb2..e0975e5f8 100644 --- a/vendor/lua/5.3/lua.odin +++ b/vendor/lua/5.3/lua.odin @@ -1,7 +1,7 @@ package lua_5_3 -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import c "core:c/libc" diff --git a/vendor/lua/5.4/lua.odin b/vendor/lua/5.4/lua.odin index dd870d7fa..80f7ead3a 100644 --- a/vendor/lua/5.4/lua.odin +++ b/vendor/lua/5.4/lua.odin @@ -1,7 +1,7 @@ package lua_5_4 -import "core:intrinsics" -import "core:builtin" +import "base:intrinsics" +import "base:builtin" import c "core:c/libc" diff --git a/vendor/nanovg/gl/gl.odin b/vendor/nanovg/gl/gl.odin index 50df6e1b5..48998bda5 100644 --- a/vendor/nanovg/gl/gl.odin +++ b/vendor/nanovg/gl/gl.odin @@ -1390,7 +1390,7 @@ CreateFramebuffer :: proc(ctx: ^nvg.Context, w, h: int, imageFlags: ImageFlags) gl.GetIntegerv(gl.RENDERBUFFER_BINDING, &tempRBO) imageFlags := imageFlags - incl(&imageFlags, ImageFlags { .FLIP_Y, .PREMULTIPLIED }) + imageFlags += {.FLIP_Y, .PREMULTIPLIED} fb.image = nvg.CreateImageRGBA(ctx, w, h, imageFlags, nil) fb.texture = ImageHandle(ctx, fb.image) fb.ctx = ctx diff --git a/vendor/sdl2/sdl2.odin b/vendor/sdl2/sdl2.odin index adf6dbd49..719390adc 100644 --- a/vendor/sdl2/sdl2.odin +++ b/vendor/sdl2/sdl2.odin @@ -23,7 +23,7 @@ package sdl2 import "core:c" -import "core:intrinsics" +import "base:intrinsics" when ODIN_OS == .Windows { foreign import lib "SDL2.lib" diff --git a/vendor/sdl2/sdl_stdinc.odin b/vendor/sdl2/sdl_stdinc.odin index 97722f4fe..9136ae026 100644 --- a/vendor/sdl2/sdl_stdinc.odin +++ b/vendor/sdl2/sdl_stdinc.odin @@ -1,9 +1,6 @@ package sdl2 import "core:c" -import "core:intrinsics" -import "core:runtime" -_, _ :: intrinsics, runtime when ODIN_OS == .Windows { foreign import lib "SDL2.lib" @@ -19,16 +16,6 @@ FOURCC :: #force_inline proc "c" (A, B, C, D: u8) -> u32 { } -stack_alloc :: proc "c" ($T: typeid, #any_int count: int) -> ^T { - return (^T)(intrinsics.alloca(size_of(T)*count)) -} -stack_make :: proc "c" ($T: typeid/[]$E, #any_int count: int) -> T { - ptr := (^T)(intrinsics.alloca(size_of(T)*count)) - return transmute(T)runtime.Raw_Slice{ptr, count} -} -stack_free :: proc "c" (ptr: rawptr) {} - - malloc_func :: proc "c" (size: c.size_t) -> rawptr calloc_func :: proc "c" (nmemb, size: c.size_t) -> rawptr realloc_func :: proc "c" (mem: rawptr, size: c.size_t) -> rawptr diff --git a/vendor/wasm/js/dom_all_targets.odin b/vendor/wasm/js/dom_all_targets.odin index 7b3ad1a64..ef629b347 100644 --- a/vendor/wasm/js/dom_all_targets.odin +++ b/vendor/wasm/js/dom_all_targets.odin @@ -1,7 +1,7 @@ //+build !js package wasm_js_interface -import "core:runtime" +import "base:runtime" get_element_value_string :: proc "contextless" (id: string, buf: []byte) -> string { diff --git a/vendor/wasm/js/memory_js.odin b/vendor/wasm/js/memory_js.odin index cdeb58128..1a8690325 100644 --- a/vendor/wasm/js/memory_js.odin +++ b/vendor/wasm/js/memory_js.odin @@ -2,7 +2,7 @@ package wasm_js_interface import "core:mem" -import "core:intrinsics" +import "base:intrinsics" PAGE_SIZE :: 64 * 1024 page_alloc :: proc(page_count: int) -> (data: []byte, err: mem.Allocator_Error) {