package core:os

Source

Errno :: Error

Error :: union {
	General_Error, 
	io.Error, 
	runtime.Allocator_Error, 
	sys_windows.System_Error, 
}

File_Info :: struct {
	fullpath:          string,
	// allocated
	name:              string,
	// uses `fullpath` as underlying data
	size:              i64,
	mode:              File_Mode,
	is_dir:            bool,
	creation_time:     time.Time,
	modification_time: time.Time,
	access_time:       time.Time,
}

File_Mode :: distinct u32

File_Time :: distinct u64

General_Error :: enum u32 {
	None, 
	Permission_Denied, 
	Exist, 
	Not_Exist, 
	Closed, 
	Timeout, 
	Broken_Pipe, 
	// Indicates that an attempt to retrieve a file's size was made, but the
	// file doesn't have a size.
	No_Size, 
	Invalid_File, 
	Invalid_Dir, 
	Invalid_Path, 
	Invalid_Callback, 
	Pattern_Has_Separator, 
	Unsupported, 
	File_Is_Pipe, 
	Not_Dir, 
}

Handle :: distinct uintptr

Platform_Error :: sys_windows.System_Error

ARCH: .Odin_Arch_Type : ODIN_ARCH

ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

ERROR_ACCESS_DENIED: sys_windows.System_Error : _Platform_Error(5)

ERROR_ALREADY_EXISTS: sys_windows.System_Error : _Platform_Error(183)

ERROR_BROKEN_PIPE: sys_windows.System_Error : _Platform_Error(109)

ERROR_BUFFER_OVERFLOW: sys_windows.System_Error : _Platform_Error(111)

ERROR_DIR_NOT_EMPTY: sys_windows.System_Error : _Platform_Error(145)

ERROR_ENVVAR_NOT_FOUND: sys_windows.System_Error : _Platform_Error(203)

ERROR_EOF: io.Error : io.Error.EOF

ERROR_FILE_EXISTS: sys_windows.System_Error : _Platform_Error(80)

ERROR_FILE_IS_NOT_DIR :: General_Error.Not_Dir

ERROR_FILE_IS_PIPE :: General_Error.File_Is_Pipe

ERROR_FILE_NOT_FOUND: sys_windows.System_Error : _Platform_Error(2)

ERROR_HANDLE_EOF: sys_windows.System_Error : _Platform_Error(38)

ERROR_INSUFFICIENT_BUFFER: sys_windows.System_Error : _Platform_Error(122)

ERROR_INVALID_HANDLE: sys_windows.System_Error : _Platform_Error(6)

ERROR_INVALID_PARAMETER: sys_windows.System_Error : _Platform_Error(87)

ERROR_IO_PENDING: sys_windows.System_Error : _Platform_Error(997)

ERROR_MOD_NOT_FOUND: sys_windows.System_Error : _Platform_Error(126)

ERROR_MORE_DATA: sys_windows.System_Error : _Platform_Error(234)

ERROR_NEGATIVE_SEEK: sys_windows.System_Error : _Platform_Error(131)

ERROR_NETNAME_DELETED: sys_windows.System_Error : _Platform_Error(64)

ERROR_NONE :: Error{}

ERROR_NOT_ENOUGH_MEMORY: sys_windows.System_Error : _Platform_Error(8)

ERROR_NOT_FOUND: sys_windows.System_Error : _Platform_Error(1168)

ERROR_NO_MORE_FILES: sys_windows.System_Error : _Platform_Error(18)

ERROR_OPERATION_ABORTED: sys_windows.System_Error : _Platform_Error(995)

ERROR_PATH_NOT_FOUND: sys_windows.System_Error : _Platform_Error(3)

ERROR_PRIVILEGE_NOT_HELD: sys_windows.System_Error : _Platform_Error(1314)

ERROR_PROC_NOT_FOUND: sys_windows.System_Error : _Platform_Error(127)

File_Mode_Char_Device :: File_Mode(1 << 19)

File_Mode_Device :: File_Mode(1 << 18)

File_Mode_Dir :: File_Mode(1 << 16)

File_Mode_Named_Pipe :: File_Mode(1 << 17)

File_Mode_Sym_Link :: File_Mode(1 << 20)

INVALID_HANDLE: Handle : ~Handle(0)

OS: .Odin_OS_Type : ODIN_OS

O_APPEND: int : 0x00400

O_ASYNC: int : 0x02000

O_CLOEXEC: int : 0x80000

O_CREATE: int : 0x00040

O_EXCL: int : 0x00080

O_NOCTTY: int : 0x00100

O_NONBLOCK: int : 0x00800

O_RDONLY: int : 0x00000

O_RDWR: int : 0x00002

O_SYNC: int : 0x01000

O_TRUNC: int : 0x00200

O_WRONLY: int : 0x00001

SEEK_CUR: int : 1

SEEK_END: int : 2

SEEK_SET: int : 0

WINDOWS_11_BUILD_CUTOFF: int : 22_000

WSAEACCES: sys_windows.System_Error : _Platform_Error(10013)

WSAECONNRESET: sys_windows.System_Error : _Platform_Error(10054)

args: []string = …

stderr: Handle = …

stdin: Handle = …

stdout: Handle = …

change_directory :: set_current_directory

clear_env :: proc() {…}

close :: proc(fd: Handle) -> Error {…}

current_thread_id :: proc "contextless" () -> int {…}

environ :: proc(allocator := context.allocator) -> []string {…}

error_string :: proc "contextless" (ferr: Error) -> string {…}

exists :: proc(path: string) -> bool {…}

exit :: proc "contextless" (code: int) -> ! {…}

file_info_delete :: proc(fi: File_Info, allocator := context.allocator) {…}

file_info_slice_delete :: proc(infos: []File_Info, allocator := context.allocator) {…}

file_size :: proc(fd: Handle) -> (i64, Error) {…}

file_size_from_path :: proc(path: string) -> i64 {…}

flush :: proc(fd: Handle) -> (err: Error) {…}

fstat :: proc(fd: Handle, allocator := context.allocator) -> (fi: File_Info, err: Error) {…}

ftruncate :: proc(fd: Handle, length: i64) -> (err: Error) {…}

get_current_directory :: proc(allocator := context.allocator) -> string {…}

get_env :: proc(key: string, allocator := context.allocator) -> (value: string) {…}

get_last_error :: proc "contextless" () -> Error {…}

get_page_size :: proc() -> int {…}

get_std_handle :: proc "contextless" (h: uint) -> Handle {…}

get_windows_version_w :: proc "contextless" () -> sys_windows.OSVERSIONINFOEXW {…}

is_dir :: proc(path: string) -> bool {…}

is_file :: proc(path: string) -> bool {…}

is_path_separator :: proc(c: u8) -> bool {…}

is_platform_error :: proc "contextless" (ferr: Error) -> (err: i32, ok: bool) {…}

is_windows_10 :: proc "contextless" () -> bool {…}

is_windows_11 :: proc "contextless" () -> bool {…}

is_windows_7 :: proc "contextless" () -> bool {…}

is_windows_8 :: proc "contextless" () -> bool {…}

is_windows_8_1 :: proc "contextless" () -> bool {…}

is_windows_vista :: proc "contextless" () -> bool {…}

is_windows_xp :: proc "contextless" () -> bool {…}

last_write_time :: proc(fd: Handle) -> (File_Time, Error) {…}

last_write_time_by_name :: proc(name: string) -> (File_Time, Error) {…}

link :: proc(old_name, new_name: string) -> (err: Error) {…}

lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {…}

lstat :: proc(name: string, allocator := context.allocator) -> (File_Info, Error) {…}

make_directory :: proc(path: string, mode: u32 = 0) -> (err: Error) {…}

open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Error) {…}

pipe :: proc() -> (r, w: Handle, err: Error) {…}

print_error :: proc(f: Handle, ferr: Error, msg: string) -> (n: int, err: Error) {…}

processor_core_count :: proc() -> int {…}

read :: proc(fd: Handle, data: []u8) -> (total_read: int, err: Error) {…}

read_at :: proc(fd: Handle, data: []u8, offset: i64) -> (n: int, err: Error) {…}

read_at_least :: proc(fd: Handle, buf: []u8, min: int) -> (n: int, err: Error) {…}

read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Error) {…}

read_entire_file_from_filename :: proc(name: string, allocator := context.allocator, loc := #caller_location) -> (data: []u8, success: bool) {…}

read_entire_file_from_filename_or_err :: proc(name: string, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: Error) {…}

read_entire_file_from_handle :: proc(fd: Handle, allocator := context.allocator, loc := #caller_location) -> (data: []u8, success: bool) {…}

read_entire_file_from_handle_or_err :: proc(fd: Handle, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: Error) {…}

read_full :: proc(fd: Handle, buf: []u8) -> (n: int, err: Error) {…}

read_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Error) {…}

remove :: proc(name: string) -> Error {…}

remove_directory :: proc(path: string) -> (err: Error) {…}

rename :: proc(old_path, new_path: string) -> (err: Error) {…}

seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Error) {…}

set_current_directory :: proc(path: string) -> (err: Error) {…}

set_env :: proc(key, value: string) -> Error {…}

stat :: proc(name: string, allocator := context.allocator) -> (File_Info, Error) {…}

stream_from_handle :: proc(fd: Handle) -> io.Stream {…}

truncate :: proc(path: string, length: i64) -> (err: Error) {…}

unlink :: proc(path: string) -> (err: Error) {…}

unset_env :: proc(key: string) -> Error {…}

write :: proc(fd: Handle, data: []u8) -> (int, Error) {…}

write_at :: proc(fd: Handle, data: []u8, offset: i64) -> (n: int, err: Error) {…}

write_byte :: proc(fd: Handle, b: u8) -> (int, Error) {…}

write_encoded_rune :: proc(f: Handle, r: untyped rune) -> (n: int, err: Error) {…}

write_entire_file :: proc(name: string, data: []u8, truncate: bool = true) -> (success: bool) {…}

write_entire_file_or_err :: proc(name: string, data: []u8, truncate: bool = true) -> Error {…}

write_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Error) {…}

write_rune :: proc(fd: Handle, r: untyped rune) -> (int, Error) {…}

write_string :: proc(fd: Handle, str: string) -> (int, Error) {…}

read_entire_file :: proc{
	read_entire_file_from_filename,
	read_entire_file_from_handle,
}

read_entire_file_or_err :: proc{
	read_entire_file_from_filename_or_err,
	read_entire_file_from_handle_or_err,
}