agila_open_tool/tools/v/vlib/builtin/builtin_windows.c.v

// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
@[has_globals]
module builtin

#include <io.h>
#include <fcntl.h>

// Cast the V callback to the Windows SDK callback type. Clang 20 treats the
// otherwise-compatible struct pointer mismatch as a hard error for v_win.c.
#define v_set_unhandled_exception_filter(handler) SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)(handler))

// See https://learn.microsoft.com/en-us/windows/win32/winprog/windows-data-types
// See https://www.codeproject.com/KB/string/cppstringguide1.aspx
pub type C.BOOL = int
pub type C.LONG = int

pub type C.HINSTANCE = voidptr

pub type C.HICON = voidptr

pub type C.HCURSOR = voidptr

pub type C.HBRUSH = voidptr

pub type C.HWND = voidptr

pub type C.HGLOBAL = voidptr

pub type C.HANDLE = voidptr

pub type C.LRESULT = voidptr

pub type C.CHAR = char

pub type C.TCHAR = u16 // It is u8 if UNICODE is not defined, but for V programs it always is

pub type C.WCHAR = u16

pub type C.LPSTR = &char

pub type C.LPWSTR = &C.WCHAR

pub type C.LPTSTR = &C.TCHAR

pub type C.LPCTSTR = &C.TCHAR

fn C.WriteConsoleW(voidptr, &u16, u32, &u32, voidptr) bool
fn C.WriteFile(voidptr, &u8, u32, &u32, voidptr) bool
fn C.ExitProcess(u32)
fn C.GetProcessHeap() voidptr
fn C.HeapAlloc(voidptr, u32, usize) voidptr
fn C.HeapFree(voidptr, u32, voidptr) bool

fn C._setmode(int, int) int

// set_stream_binary_mode disables CRT newline translation for redirected stdio streams.
fn set_stream_binary_mode(stream &C.FILE) {
	fd := C._fileno(stream)
	if fd >= 0 {
		C._setmode(fd, C._O_BINARY)
	}
}

fn is_terminal(fd int) int {
	mut mode := u32(0)
	$if v2_native_windows_pe_minimal ? {
		if fd != 0 && fd != 1 && fd != 2 {
			return 0
		}
		handle_id := if fd == 0 {
			std_input_handle
		} else if fd == 2 {
			std_error_handle
		} else {
			std_output_handle
		}
		handle := C.GetStdHandle(handle_id)
		if isnil(handle) || handle == voidptr(-1) {
			return 0
		}
		if !C.GetConsoleMode(handle, &mode) {
			return 0
		}
		return int(mode)
	} $else {
		osfh := voidptr(C._get_osfhandle(fd))
		C.GetConsoleMode(osfh, voidptr(&mode))
		return int(mode)
	}
}

// GetStdHandle takes DWORD values. Microsoft defines these as ((DWORD)-N),
// so spell the rollover values explicitly for native backends.
const std_input_handle = u32(0xfffffff6)
const std_output_handle = u32(0xfffffff5)
const std_error_handle = u32(0xfffffff4)
const enable_processed_output = 1
const enable_wrap_at_eol_output = 2
const evable_virtual_terminal_processing = 4

// Write UTF-8 directly as UTF-16 for console hosts instead of changing the console code page.
@[manualfree]
fn write_buf_to_console(fd int, buf &u8, buf_len int) bool {
	if buf_len <= 0 || is_terminal(fd) <= 0 {
		return false
	}
	mut console_handle := C.GetStdHandle(std_output_handle)
	if fd == 2 {
		console_handle = C.GetStdHandle(std_error_handle)
	}
	if isnil(console_handle) || console_handle == voidptr(-1) {
		return false
	}
	unsafe {
		wide_len := C.MultiByteToWideChar(cp_utf8, 0, &char(buf), buf_len, 0, 0)
		if wide_len <= 0 {
			return false
		}
		mut wide_buf := &u16(malloc_noscan((wide_len + 1) * int(sizeof(u16))))
		if isnil(wide_buf) {
			return false
		}
		defer {
			free(wide_buf)
		}
		converted := C.MultiByteToWideChar(cp_utf8, 0, &char(buf), buf_len, wide_buf, wide_len)
		if converted <= 0 {
			return false
		}
		wide_buf[converted] = 0
		mut remaining_chars := converted
		mut wide_ptr := wide_buf
		for remaining_chars > 0 {
			mut chars_written := u32(0)
			if !C.WriteConsoleW(console_handle, wide_ptr, u32(remaining_chars), &chars_written, nil)
				|| chars_written == 0 {
				return false
			}
			wide_ptr += int(chars_written)
			remaining_chars -= int(chars_written)
		}
		return true
	}
}

@[manualfree]
fn write_buf_to_console_kernel32(fd int, buf &u8, buf_len int) bool {
	if buf_len <= 0 || (fd != 1 && fd != 2) {
		return false
	}
	console_handle := C.GetStdHandle(if fd == 2 { std_error_handle } else { std_output_handle })
	if isnil(console_handle) || console_handle == voidptr(-1) {
		return false
	}
	mut mode := u32(0)
	if !C.GetConsoleMode(console_handle, &mode) {
		return false
	}
	unsafe {
		wide_len := C.MultiByteToWideChar(cp_utf8, 0, &char(buf), buf_len, 0, 0)
		if wide_len <= 0 {
			return false
		}
		heap := C.GetProcessHeap()
		if isnil(heap) {
			return false
		}
		wide_size := usize((wide_len + 1) * int(sizeof(u16)))
		mut wide_buf := &u16(C.HeapAlloc(heap, 0, wide_size))
		if isnil(wide_buf) {
			return false
		}
		defer {
			C.HeapFree(heap, 0, wide_buf)
		}
		converted := C.MultiByteToWideChar(cp_utf8, 0, &char(buf), buf_len, wide_buf, wide_len)
		if converted <= 0 {
			return false
		}
		wide_buf[converted] = 0
		mut remaining_chars := converted
		mut wide_ptr := wide_buf
		for remaining_chars > 0 {
			mut chars_written := u32(0)
			if !C.WriteConsoleW(console_handle, wide_ptr, u32(remaining_chars), &chars_written, nil)
				|| chars_written == 0 {
				return false
			}
			wide_ptr += int(chars_written)
			remaining_chars -= int(chars_written)
		}
		return true
	}
}

fn write_buf_to_fd_kernel32(fd int, buf &u8, buf_len int) bool {
	return write_buf_to_fd_kernel32_status(fd, buf, buf_len) == 0
}

fn write_buf_to_fd_kernel32_status(fd int, buf &u8, buf_len int) int {
	if buf_len <= 0 {
		return 0
	}
	if fd != 1 && fd != 2 {
		return 1
	}
	if write_buf_to_console_kernel32(fd, buf, buf_len) {
		return 0
	}
	handle_id := if fd == 2 { std_error_handle } else { std_output_handle }
	handle := C.GetStdHandle(handle_id)
	if isnil(handle) || handle == voidptr(-1) {
		return 2
	}
	mut ptr := unsafe { buf }
	mut remaining_bytes := buf_len
	unsafe {
		for remaining_bytes > 0 {
			chunk := if remaining_bytes > int(0x7fffffff) {
				int(0x7fffffff)
			} else {
				remaining_bytes
			}
			mut written := u32(0)
			if !C.WriteFile(handle, ptr, u32(chunk), &written, nil) {
				return 3
			}
			if written == 0 {
				return 4
			}
			ptr += int(written)
			remaining_bytes -= int(written)
		}
	}
	return 0
}

@[manualfree]
fn write_buf_to_fd_windows_non_minimal(fd int, buf &u8, buf_len int) {
	if buf_len <= 0 {
		return
	}
	mut ptr := unsafe { buf }
	mut remaining_bytes := isize(buf_len)
	if write_buf_to_console(fd, ptr, int(remaining_bytes)) {
		return
	}
	mut stream := voidptr(C.stdout)
	if fd == 2 {
		stream = voidptr(C.stderr)
	}
	mut x := isize(0)
	unsafe {
		for remaining_bytes > 0 {
			x = isize(C.fwrite(ptr, 1, remaining_bytes, stream))
			if x <= 0 {
				// GUI programs on Windows may not have a writable stdout/stderr stream.
				break
			}
			ptr += x
			remaining_bytes -= x
		}
	}
}

fn write_buf_to_fd_kernel32_or_exit(fd int, buf &u8, buf_len int) {
	write_status := write_buf_to_fd_kernel32_status(fd, buf, buf_len)
	if write_status != 0 {
		C.ExitProcess(u32(220 + write_status))
	}
}

@[markused]
fn builtin_init() {
	$if v2_native_windows_pe_minimal ? {
		return
	} $else {
		$if gcboehm ? {
			$if !gc_warn_on_stderr ? {
				gc_set_warn_proc(internal_gc_warn_proc_none)
			}
		}
		set_stream_binary_mode(C.stdout)
		set_stream_binary_mode(C.stderr)
		if is_terminal(1) > 0 {
			C.SetConsoleMode(C.GetStdHandle(std_output_handle),
				enable_processed_output | enable_wrap_at_eol_output | evable_virtual_terminal_processing)
			C.SetConsoleMode(C.GetStdHandle(std_error_handle),
				enable_processed_output | enable_wrap_at_eol_output | evable_virtual_terminal_processing)
			unsafe {
				set_stream_unbuffered(C.stdout)
				set_stream_unbuffered(C.stderr)
			}
		}
		$if !no_backtrace ? {
			add_unhandled_exception_handler()
		}
		// On windows, the default buffering is block based (~4096bytes), which interferes badly with non cmd shells
		// It is much better to have it off by default instead.
		unbuffer_stdout()
	}
}

// TODO: copypaste from os
// we want to be able to use this here without having to `import os`
struct ExceptionRecord {
pub:
	// status_ constants
	code        u32
	flags       u32
	record      &ExceptionRecord = unsafe { nil }
	address     voidptr
	param_count u32
	// params []voidptr
}

struct ContextRecord {
	// TODO
}

struct ExceptionPointers {
pub:
	exception_record &ExceptionRecord = unsafe { nil }
	context_record   &ContextRecord   = unsafe { nil }
}

@[callconv: stdcall]
type TopLevelExceptionFilter = fn (&ExceptionPointers) C.LONG

fn C.SetUnhandledExceptionFilter(TopLevelExceptionFilter) voidptr
fn C.v_set_unhandled_exception_filter(TopLevelExceptionFilter) voidptr

@[callconv: stdcall]
fn unhandled_exception_handler(e &ExceptionPointers) C.LONG {
	match e.exception_record.code {
		// These are 'used' by the backtrace printer
		// so we dont want to catch them...
		0x4001000A, 0x40010006, 0x406D1388, 0xE06D7363 {
			return 0
		}
		else {
			eprintln('Unhandled Exception 0x' + ptr_str(e.exception_record.code) + ' at ' +
				ptr_str(e.exception_record.address))
			flush_stdout()
			flush_stderr()
			print_backtrace_skipping_top_frames(5)
			flush_stdout()
			flush_stderr()
		}
	}

	return 0
}

fn add_unhandled_exception_handler() {
	// A vectored handler also sees first-chance exceptions that Windows APIs may
	// handle internally, which can lead to false-positive "Unhandled Exception"
	// reports. Register a top-level filter instead.
	C.v_set_unhandled_exception_filter(unhandled_exception_handler)
}

fn C.IsDebuggerPresent() bool

fn C.__debugbreak()

fn break_if_debugger_attached() {
	$if tinyc {
		unsafe {
			mut ptr := &voidptr(0)
			*ptr = nil
			_ = ptr
		}
	} $else {
		if C.IsDebuggerPresent() {
			C.__debugbreak()
		}
	}
}

const format_message_allocate_buffer = 0x00000100
const format_message_argument_array = 0x00002000
const format_message_from_hmodule = 0x00000800
const format_message_from_string = 0x00000400
const format_message_from_system = 0x00001000
const format_message_ignore_inserts = 0x00000200

// return an error message generated from WinAPI's `LastError`
pub fn winapi_lasterr_str() string {
	err_msg_id := C.GetLastError()
	if err_msg_id == 8 {
		// handle this case special since `FormatMessageW()` might not work anymore
		return 'insufficient memory'
	}
	mut msgbuf := &u16(unsafe { nil })
	res := C.FormatMessageW(format_message_allocate_buffer | format_message_from_system | format_message_ignore_inserts,
		0, err_msg_id, 0, voidptr(&msgbuf), 0, 0)
	err_msg := if res == 0 {
		'Win-API error ${err_msg_id}'
	} else {
		unsafe { string_from_wide(msgbuf) }
	}
	return err_msg
}

// panic with an error message generated from WinAPI's `LastError`
@[noreturn]
pub fn panic_lasterr(base string) {
	panic(base + winapi_lasterr_str())
}