From adac039a2b612a811d02a47480becc23d02599e1 Mon Sep 17 00:00:00 2001 From: Dragos Popescu Date: Mon, 20 Mar 2023 04:08:48 +0100 Subject: [PATCH 1/4] Made most libraries panic on js targets instead of not compiling --- core/dynlib/lib_js.odin | 15 + core/os/os_js.odin | 163 +++++++++- core/thread/thread_js.odin | 55 ++++ vendor/wasm/js/dom_all_targets.odin | 36 +++ vendor/wasm/js/events_all_targets.odin | 288 ++++++++++++++++++ vendor/wasm/js/memory_all_targets.odin | 14 + .../wasm/js/{memory.odin => memory_js.odin} | 0 7 files changed, 569 insertions(+), 2 deletions(-) create mode 100644 core/dynlib/lib_js.odin create mode 100644 core/thread/thread_js.odin create mode 100644 vendor/wasm/js/dom_all_targets.odin create mode 100644 vendor/wasm/js/events_all_targets.odin create mode 100644 vendor/wasm/js/memory_all_targets.odin rename vendor/wasm/js/{memory.odin => memory_js.odin} (100%) diff --git a/core/dynlib/lib_js.odin b/core/dynlib/lib_js.odin new file mode 100644 index 000000000..1250833ec --- /dev/null +++ b/core/dynlib/lib_js.odin @@ -0,0 +1,15 @@ +//+build js +//+private +package dynlib + +_load_library :: proc(path: string, global_symbols := false) -> (Library, bool) { + panic("core:dynlib not supported by JS target") +} + +_unload_library :: proc(library: Library) -> bool { + panic("core:dynlib not supported by JS target") +} + +_symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) { + panic("core:dynlib not supported by JS target") +} diff --git a/core/os/os_js.odin b/core/os/os_js.odin index f2563f217..718fb65c7 100644 --- a/core/os/os_js.odin +++ b/core/os/os_js.odin @@ -1,4 +1,163 @@ +//+build js package os -// +build js -#panic("package os does not support a js target") \ No newline at end of file +import "core:intrinsics" +import "core:runtime" +import "core:unicode/utf16" + +is_path_separator :: proc(c: byte) -> bool { + return c == '/' || c == '\\' +} + +open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Errno) { + panic("core:os procedure not supported on JS target") +} + +close :: proc(fd: Handle) -> Errno { + panic("core:os procedure not supported on JS target") +} + +flush :: proc(fd: Handle) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + + +write :: proc(fd: Handle, data: []byte) -> (int, Errno) { + panic("core:os procedure not supported on JS target") +} + +@(private="file") +read_console :: proc(handle: win32.HANDLE, b: []byte) -> (n: int, err: Errno) { + panic("core:os procedure not supported on JS target") +} + +read :: proc(fd: Handle, data: []byte) -> (int, Errno) { + panic("core:os procedure not supported on JS target") +} + +seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { + panic("core:os procedure not supported on JS target") +} + +file_size :: proc(fd: Handle) -> (i64, Errno) { + panic("core:os procedure not supported on JS target") +} + + +@(private) +MAX_RW :: 1<<30 + +@(private) +pread :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Errno) { + panic("core:os procedure not supported on JS target") +} +@(private) +pwrite :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Errno) { + panic("core:os procedure not supported on JS target") +} + +read_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) { + panic("core:os procedure not supported on JS target") +} +write_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) { + panic("core:os procedure not supported on JS target") +} + + + +// NOTE(bill): Uses startup to initialize it +//stdin := get_std_handle(uint(win32.STD_INPUT_HANDLE)) +//stdout := get_std_handle(uint(win32.STD_OUTPUT_HANDLE)) +//stderr := get_std_handle(uint(win32.STD_ERROR_HANDLE)) + + +get_std_handle :: proc "contextless" (h: uint) -> Handle { + panic("core:os procedure not supported on JS target") +} + + +exists :: proc(path: string) -> bool { + panic("core:os procedure not supported on JS target") +} + +is_file :: proc(path: string) -> bool { + panic("core:os procedure not supported on JS target") +} + +is_dir :: proc(path: string) -> bool { + panic("core:os procedure not supported on JS target") +} + +// NOTE(tetra): GetCurrentDirectory is not thread safe with SetCurrentDirectory and GetFullPathName +//@private cwd_lock := win32.SRWLOCK{} // zero is initialized + +get_current_directory :: proc(allocator := context.allocator) -> string { + panic("core:os procedure not supported on JS target") +} + +set_current_directory :: proc(path: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + + +change_directory :: proc(path: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + +make_directory :: proc(path: string, mode: u32 = 0) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + +remove_directory :: proc(path: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + + +@(private) +is_abs :: proc(path: string) -> bool { + panic("core:os procedure not supported on JS target") +} + +@(private) +fix_long_path :: proc(path: string) -> string { + panic("core:os procedure not supported on JS target") +} + + +link :: proc(old_name, new_name: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + +unlink :: proc(path: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + + +rename :: proc(old_path, new_path: string) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + +ftruncate :: proc(fd: Handle, length: i64) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + +truncate :: proc(path: string, length: i64) -> (err: Errno) { + panic("core:os procedure not supported on JS target") +} + + +remove :: proc(name: string) -> Errno { + panic("core:os procedure not supported on JS target") +} + + +pipe :: proc() -> (r, w: Handle, err: Errno) { + panic("core:os procedure not supported on JS target") +} + diff --git a/core/thread/thread_js.odin b/core/thread/thread_js.odin new file mode 100644 index 000000000..909c07447 --- /dev/null +++ b/core/thread/thread_js.odin @@ -0,0 +1,55 @@ +//+build js +package thread + +import "core:intrinsics" +import "core:sync" +import "core:mem" + +Thread_State :: enum u8 { + Started, + Joined, + Done, +} + +Thread_Os_Specific :: struct { + +} + +_thread_priority_map := [Thread_Priority]i32{ + .Normal = 0, + .Low = -2, + .High = +2, +} + +_create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread { + panic("core:thread procedure not supported on js target") +} + +_start :: proc(t: ^Thread) { + panic("core:thread procedure not supported on js target") +} + +_is_done :: proc(t: ^Thread) -> bool { + panic("core:thread procedure not supported on js target") +} + +_join :: proc(t: ^Thread) { + panic("core:thread procedure not supported on js target") +} + +_join_multiple :: proc(threads: ..^Thread) { + panic("core:thread procedure not supported on js target") +} + +_destroy :: proc(thread: ^Thread) { + panic("core:thread procedure not supported on js target") +} + +_terminate :: proc(using thread : ^Thread, exit_code: int) { + panic("core:thread procedure not supported on js target") +} + +_yield :: proc() { + panic("core:thread procedure not supported on js target") +} + diff --git a/vendor/wasm/js/dom_all_targets.odin b/vendor/wasm/js/dom_all_targets.odin new file mode 100644 index 000000000..7b3ad1a64 --- /dev/null +++ b/vendor/wasm/js/dom_all_targets.odin @@ -0,0 +1,36 @@ +//+build !js +package wasm_js_interface + +import "core:runtime" + + +get_element_value_string :: proc "contextless" (id: string, buf: []byte) -> string { + context = runtime.default_context() + panic("vendor:wasm/js not supported on non JS targets") +} + + +get_element_min_max :: proc "contextless" (id: string) -> (min, max: f64) { + context = runtime.default_context() + panic("vendor:wasm/js not supported on non JS targets") +} + + +Rect :: struct { + x, y, width, height: f64, +} + +get_bounding_client_rect :: proc "contextless" (id: string) -> (rect: Rect) { + context = runtime.default_context() + panic("vendor:wasm/js not supported on non JS targets") +} + +window_get_rect :: proc "contextless" () -> (rect: Rect) { + context = runtime.default_context() + panic("vendor:wasm/js not supported on non JS targets") +} + +window_get_scroll :: proc "contextless" () -> (x, y: f64) { + context = runtime.default_context() + panic("vendor:wasm/js not supported on non JS targets") +} diff --git a/vendor/wasm/js/events_all_targets.odin b/vendor/wasm/js/events_all_targets.odin new file mode 100644 index 000000000..2bc7e8ceb --- /dev/null +++ b/vendor/wasm/js/events_all_targets.odin @@ -0,0 +1,288 @@ +//+build !js +package wasm_js_interface + + +Event_Kind :: enum u32 { + Invalid, + + Load, + Unload, + Error, + Resize, + Visibility_Change, + Fullscreen_Change, + Fullscreen_Error, + + Click, + Double_Click, + Mouse_Move, + Mouse_Over, + Mouse_Out, + Mouse_Up, + Mouse_Down, + + Key_Up, + Key_Down, + Key_Press, + + Scroll, + Wheel, + + Focus, + Submit, + Blur, + Change, + Select, + + Animation_Start, + Animation_End, + Animation_Iteration, + Animation_Cancel, + + Copy, + Cut, + Paste, + + // Drag, + // Drag_Start, + // Drag_End, + // Drag_Enter, + // Drag_Leave, + // Drag_Over, + // Drop, + + Pointer_Cancel, + Pointer_Down, + Pointer_Enter, + Pointer_Leave, + Pointer_Move, + Pointer_Over, + Pointer_Up, + Got_Pointer_Capture, + Lost_Pointer_Capture, + Pointer_Lock_Change, + Pointer_Lock_Error, + + Selection_Change, + Selection_Start, + + Touch_Cancel, + Touch_End, + Touch_Move, + Touch_Start, + + Transition_Start, + Transition_End, + Transition_Run, + Transition_Cancel, + + Context_Menu, + + Custom, + +} +event_kind_string := [Event_Kind]string{ + .Invalid = "", + + .Load = "load", + .Unload = "unload", + .Error = "error", + .Resize = "resize", + .Visibility_Change = "visibilitychange", + .Fullscreen_Change = "fullscreenchange", + .Fullscreen_Error = "fullscreenerror", + + .Click = "click", + .Double_Click = "dblclick", + .Mouse_Move = "mousemove", + .Mouse_Over = "mouseover", + .Mouse_Out = "mouseout", + .Mouse_Up = "mouseup", + .Mouse_Down = "mousedown", + + .Key_Up = "keyup", + .Key_Down = "keydown", + .Key_Press = "keypress", + + .Scroll = "scroll", + .Wheel = "wheel", + + .Focus = "focus", + .Submit = "submit", + .Blur = "blur", + .Change = "change", + .Select = "select", + + .Animation_Start = "animationstart", + .Animation_End = "animationend", + .Animation_Iteration = "animationiteration", + .Animation_Cancel = "animationcancel", + + .Copy = "copy", + .Cut = "cut", + .Paste = "paste", + + // .Drag, = "drag", + // .Drag_Start, = "dragstart", + // .Drag_End, = "dragend", + // .Drag_Enter, = "dragenter", + // .Drag_Leave, = "dragleave", + // .Drag_Over, = "dragover", + // .Drop, = "drop", + + .Pointer_Cancel = "pointercancel", + .Pointer_Down = "pointerdown", + .Pointer_Enter = "pointerenter", + .Pointer_Leave = "pointerleave", + .Pointer_Move = "pointermove", + .Pointer_Over = "pointerover", + .Pointer_Up = "pointerup", + .Got_Pointer_Capture = "gotpointercapture", + .Lost_Pointer_Capture = "lostpointercapture", + .Pointer_Lock_Change = "pointerlockchange", + .Pointer_Lock_Error = "pointerlockerror", + + .Selection_Change = "selectionchange", + .Selection_Start = "selectionstart", + + .Transition_Start = "transitionstart", + .Transition_End = "transitionend", + .Transition_Run = "transitionrun", + .Transition_Cancel = "transitioncancel", + + .Touch_Cancel = "touchcancel", + .Touch_End = "touchend", + .Touch_Move = "touchmove", + .Touch_Start = "touchstart", + + .Context_Menu = "contextmenu", + + .Custom = "?custom?", +} + +Delta_Mode :: enum u32 { + Pixel = 0, + Line = 1, + Page = 2, +} + +Key_Location :: enum u8 { + Standard = 0, + Left = 1, + Right = 2, + Numpad = 3, +} + +KEYBOARD_MAX_KEY_SIZE :: 16 +KEYBOARD_MAX_CODE_SIZE :: 16 + +Event_Target_Kind :: enum u32 { + Element = 0, + Document = 1, + Window = 2, +} + +Event_Phase :: enum u8 { + None = 0, + Capturing_Phase = 1, + At_Target = 2, + Bubbling_Phase = 3, +} + +Event_Option :: enum u8 { + Bubbles = 0, + Cancelable = 1, + Composed = 2, +} +Event_Options :: distinct bit_set[Event_Option; u8] + +Event :: struct { + kind: Event_Kind, + target_kind: Event_Target_Kind, + current_target_kind: Event_Target_Kind, + id: string, + timestamp: f64, + + phase: Event_Phase, + options: Event_Options, + is_composing: bool, + is_trusted: bool, + + using data: struct #raw_union #align 8 { + scroll: struct { + delta: [2]f64, + }, + visibility_change: struct { + is_visible: bool, + }, + wheel: struct { + delta: [3]f64, + delta_mode: Delta_Mode, + }, + + key: struct { + key: string, + code: string, + location: Key_Location, + + ctrl: bool, + shift: bool, + alt: bool, + meta: bool, + + repeat: bool, + + _key_buf: [KEYBOARD_MAX_KEY_SIZE]byte, + _code_buf: [KEYBOARD_MAX_KEY_SIZE]byte, + }, + + mouse: struct { + screen: [2]i64, + client: [2]i64, + offset: [2]i64, + page: [2]i64, + movement: [2]i64, + + ctrl: bool, + shift: bool, + alt: bool, + meta: bool, + + button: i16, + buttons: bit_set[0..<16; u16], + }, + }, + + + user_data: rawptr, + callback: proc(e: Event), +} + + +add_event_listener :: proc(id: string, kind: Event_Kind, user_data: rawptr, callback: proc(e: Event), use_capture := false) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + +remove_event_listener :: proc(id: string, kind: Event_Kind, user_data: rawptr, callback: proc(e: Event)) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + +add_window_event_listener :: proc(kind: Event_Kind, user_data: rawptr, callback: proc(e: Event), use_capture := false) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + +remove_window_event_listener :: proc(kind: Event_Kind, user_data: rawptr, callback: proc(e: Event)) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + +remove_event_listener_from_event :: proc(e: Event) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + +add_custom_event_listener :: proc(id: string, name: string, user_data: rawptr, callback: proc(e: Event), use_capture := false) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} +remove_custom_event_listener :: proc(id: string, name: string, user_data: rawptr, callback: proc(e: Event)) -> bool { + panic("vendor:wasm/js not supported on non JS targets") +} + diff --git a/vendor/wasm/js/memory_all_targets.odin b/vendor/wasm/js/memory_all_targets.odin new file mode 100644 index 000000000..e1de6a696 --- /dev/null +++ b/vendor/wasm/js/memory_all_targets.odin @@ -0,0 +1,14 @@ +//+build !js +package wasm_js_interface + +import "core:mem" + +PAGE_SIZE :: 64 * 1024 +page_alloc :: proc(page_count: int) -> (data: []byte, err: mem.Allocator_Error) { + panic("vendor:wasm/js not supported on non-js targets") +} + +page_allocator :: proc() -> mem.Allocator { + panic("vendor:wasm/js not supported on non-js targets") +} + diff --git a/vendor/wasm/js/memory.odin b/vendor/wasm/js/memory_js.odin similarity index 100% rename from vendor/wasm/js/memory.odin rename to vendor/wasm/js/memory_js.odin From 951511704dda5532ceaac228ca44eeffe6016a3f Mon Sep 17 00:00:00 2001 From: Dragos Popescu Date: Mon, 20 Mar 2023 21:57:51 +0100 Subject: [PATCH 2/4] Responded to PR review. Made dynlib return false on js instead of panic --- core/dynlib/lib_js.odin | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/dynlib/lib_js.odin b/core/dynlib/lib_js.odin index 1250833ec..37dab8758 100644 --- a/core/dynlib/lib_js.odin +++ b/core/dynlib/lib_js.odin @@ -3,13 +3,13 @@ package dynlib _load_library :: proc(path: string, global_symbols := false) -> (Library, bool) { - panic("core:dynlib not supported by JS target") + return } _unload_library :: proc(library: Library) -> bool { - panic("core:dynlib not supported by JS target") + return } _symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) { - panic("core:dynlib not supported by JS target") + return } From ef3d8bdc428a8248ff108f3a4d5ba0fc866ca9e3 Mon Sep 17 00:00:00 2001 From: Dragos Popescu Date: Tue, 21 Mar 2023 04:17:31 +0100 Subject: [PATCH 3/4] Fixed more compile time errors when including os and thread to js targets --- core/os/os_js.odin | 116 ++++++++++++++++++++++++++++++++++++- core/thread/thread_js.odin | 2 +- 2 files changed, 116 insertions(+), 2 deletions(-) diff --git a/core/os/os_js.odin b/core/os/os_js.odin index 718fb65c7..dee487088 100644 --- a/core/os/os_js.odin +++ b/core/os/os_js.odin @@ -28,7 +28,7 @@ write :: proc(fd: Handle, data: []byte) -> (int, Errno) { } @(private="file") -read_console :: proc(handle: win32.HANDLE, b: []byte) -> (n: int, err: Errno) { +read_console :: proc(handle: Handle, b: []byte) -> (n: int, err: Errno) { panic("core:os procedure not supported on JS target") } @@ -73,6 +73,7 @@ write_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) get_std_handle :: proc "contextless" (h: uint) -> Handle { + context = runtime.default_context() panic("core:os procedure not supported on JS target") } @@ -161,3 +162,116 @@ pipe :: proc() -> (r, w: Handle, err: Errno) { panic("core:os procedure not supported on JS target") } +read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { + panic("core:os procedure not supported on JS target") +} + +Handle :: distinct uintptr +File_Time :: distinct u64 +Errno :: distinct int + + +INVALID_HANDLE :: ~Handle(0) + + + +O_RDONLY :: 0x00000 +O_WRONLY :: 0x00001 +O_RDWR :: 0x00002 +O_CREATE :: 0x00040 +O_EXCL :: 0x00080 +O_NOCTTY :: 0x00100 +O_TRUNC :: 0x00200 +O_NONBLOCK :: 0x00800 +O_APPEND :: 0x00400 +O_SYNC :: 0x01000 +O_ASYNC :: 0x02000 +O_CLOEXEC :: 0x80000 + + +ERROR_NONE: Errno : 0 +ERROR_FILE_NOT_FOUND: Errno : 2 +ERROR_PATH_NOT_FOUND: Errno : 3 +ERROR_ACCESS_DENIED: Errno : 5 +ERROR_INVALID_HANDLE: Errno : 6 +ERROR_NOT_ENOUGH_MEMORY: Errno : 8 +ERROR_NO_MORE_FILES: Errno : 18 +ERROR_HANDLE_EOF: Errno : 38 +ERROR_NETNAME_DELETED: Errno : 64 +ERROR_FILE_EXISTS: Errno : 80 +ERROR_INVALID_PARAMETER: Errno : 87 +ERROR_BROKEN_PIPE: Errno : 109 +ERROR_BUFFER_OVERFLOW: Errno : 111 +ERROR_INSUFFICIENT_BUFFER: Errno : 122 +ERROR_MOD_NOT_FOUND: Errno : 126 +ERROR_PROC_NOT_FOUND: Errno : 127 +ERROR_DIR_NOT_EMPTY: Errno : 145 +ERROR_ALREADY_EXISTS: Errno : 183 +ERROR_ENVVAR_NOT_FOUND: Errno : 203 +ERROR_MORE_DATA: Errno : 234 +ERROR_OPERATION_ABORTED: Errno : 995 +ERROR_IO_PENDING: Errno : 997 +ERROR_NOT_FOUND: Errno : 1168 +ERROR_PRIVILEGE_NOT_HELD: Errno : 1314 +WSAEACCES: Errno : 10013 +WSAECONNRESET: Errno : 10054 + +// Windows reserves errors >= 1<<29 for application use +ERROR_FILE_IS_PIPE: Errno : 1<<29 + 0 +ERROR_FILE_IS_NOT_DIR: Errno : 1<<29 + 1 +ERROR_NEGATIVE_OFFSET: Errno : 1<<29 + 2 + +// "Argv" arguments converted to Odin strings +args := _alloc_command_line_arguments() + + + + + +last_write_time :: proc(fd: Handle) -> (File_Time, Errno) { + panic("core:os procedure not supported on JS target") +} + +last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) { + panic("core:os procedure not supported on JS target") +} + + + +heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { + panic("core:os procedure not supported on JS target") +} +heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { + panic("core:os procedure not supported on JS target") +} +heap_free :: proc(ptr: rawptr) { + panic("core:os procedure not supported on JS target") +} + +get_page_size :: proc() -> int { + panic("core:os procedure not supported on JS target") +} + +@(private) +_processor_core_count :: proc() -> int { + panic("core:os procedure not supported on JS target") +} + +exit :: proc "contextless" (code: int) -> ! { + context = runtime.default_context() + panic("core:os procedure not supported on JS target") +} + + + +current_thread_id :: proc "contextless" () -> int { + context = runtime.default_context() + panic("core:os procedure not supported on JS target") +} + + + +_alloc_command_line_arguments :: proc() -> []string { + return nil +} + diff --git a/core/thread/thread_js.odin b/core/thread/thread_js.odin index 909c07447..10da79848 100644 --- a/core/thread/thread_js.odin +++ b/core/thread/thread_js.odin @@ -12,7 +12,7 @@ Thread_State :: enum u8 { } Thread_Os_Specific :: struct { - + flags: bit_set[Thread_State; u8], } _thread_priority_map := [Thread_Priority]i32{ From b2ecb37b358446a2be5e644961e9e7f8552f88d5 Mon Sep 17 00:00:00 2001 From: Dragos Popescu Date: Wed, 22 Mar 2023 12:10:27 +0100 Subject: [PATCH 4/4] Changed js panics to unimplemented where sensible --- core/os/os_js.odin | 80 +++++++++++++++++++------------------- core/thread/thread_js.odin | 16 ++++---- 2 files changed, 48 insertions(+), 48 deletions(-) diff --git a/core/os/os_js.odin b/core/os/os_js.odin index dee487088..5d7eb784e 100644 --- a/core/os/os_js.odin +++ b/core/os/os_js.odin @@ -10,38 +10,38 @@ is_path_separator :: proc(c: byte) -> bool { } open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } close :: proc(fd: Handle) -> Errno { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } flush :: proc(fd: Handle) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } write :: proc(fd: Handle, data: []byte) -> (int, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @(private="file") read_console :: proc(handle: Handle, b: []byte) -> (n: int, err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } read :: proc(fd: Handle, data: []byte) -> (int, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } file_size :: proc(fd: Handle) -> (i64, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @@ -50,18 +50,18 @@ MAX_RW :: 1<<30 @(private) pread :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @(private) pwrite :: proc(fd: Handle, data: []byte, offset: i64) -> (int, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } read_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } write_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @@ -74,96 +74,96 @@ write_at :: proc(fd: Handle, data: []byte, offset: i64) -> (n: int, err: Errno) get_std_handle :: proc "contextless" (h: uint) -> Handle { context = runtime.default_context() - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } exists :: proc(path: string) -> bool { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } is_file :: proc(path: string) -> bool { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } is_dir :: proc(path: string) -> bool { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } // NOTE(tetra): GetCurrentDirectory is not thread safe with SetCurrentDirectory and GetFullPathName //@private cwd_lock := win32.SRWLOCK{} // zero is initialized get_current_directory :: proc(allocator := context.allocator) -> string { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } set_current_directory :: proc(path: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } change_directory :: proc(path: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } make_directory :: proc(path: string, mode: u32 = 0) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } remove_directory :: proc(path: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @(private) is_abs :: proc(path: string) -> bool { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @(private) fix_long_path :: proc(path: string) -> string { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } link :: proc(old_name, new_name: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } unlink :: proc(path: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } rename :: proc(old_path, new_path: string) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } ftruncate :: proc(fd: Handle, length: i64) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } truncate :: proc(path: string, length: i64) -> (err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } remove :: proc(name: string) -> Errno { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } pipe :: proc() -> (r, w: Handle, err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } Handle :: distinct uintptr @@ -229,44 +229,44 @@ args := _alloc_command_line_arguments() last_write_time :: proc(fd: Handle) -> (File_Time, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } heap_alloc :: proc(size: int, zero_memory := true) -> rawptr { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } heap_free :: proc(ptr: rawptr) { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } get_page_size :: proc() -> int { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } @(private) _processor_core_count :: proc() -> int { - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } exit :: proc "contextless" (code: int) -> ! { context = runtime.default_context() - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } current_thread_id :: proc "contextless" () -> int { context = runtime.default_context() - panic("core:os procedure not supported on JS target") + unimplemented("core:os procedure not supported on JS target") } diff --git a/core/thread/thread_js.odin b/core/thread/thread_js.odin index 10da79848..5821ab238 100644 --- a/core/thread/thread_js.odin +++ b/core/thread/thread_js.odin @@ -22,34 +22,34 @@ _thread_priority_map := [Thread_Priority]i32{ } _create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _start :: proc(t: ^Thread) { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _is_done :: proc(t: ^Thread) -> bool { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _join :: proc(t: ^Thread) { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _join_multiple :: proc(threads: ..^Thread) { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _destroy :: proc(thread: ^Thread) { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _terminate :: proc(using thread : ^Thread, exit_code: int) { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") } _yield :: proc() { - panic("core:thread procedure not supported on js target") + unimplemented("core:thread procedure not supported on js target") }