package core:os

Source

Errno :: distinct int

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

Handle :: distinct uintptr

ARCH: .Odin_Arch_Type : ODIN_ARCH

ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

ERROR_ACCESS_DENIED: Errno : 5

ERROR_ALREADY_EXISTS: Errno : 183

ERROR_BROKEN_PIPE: Errno : 109

ERROR_BUFFER_OVERFLOW: Errno : 111

ERROR_DIR_NOT_EMPTY: Errno : 145

ERROR_ENVVAR_NOT_FOUND: Errno : 203

ERROR_EOF :: 38

ERROR_FILE_EXISTS: Errno : 80

ERROR_FILE_IS_NOT_DIR: Errno : 1 << 29 + 1

ERROR_FILE_IS_PIPE: Errno : 1 << 29 + 0

ERROR_FILE_NOT_FOUND: Errno : 2

ERROR_HANDLE_EOF: Errno : 38

ERROR_INSUFFICIENT_BUFFER: Errno : 122

ERROR_INVALID_HANDLE: Errno : 6

ERROR_INVALID_PARAMETER: Errno : 87

ERROR_IO_PENDING: Errno : 997

ERROR_MOD_NOT_FOUND: Errno : 126

ERROR_MORE_DATA: Errno : 234

ERROR_NEGATIVE_OFFSET: Errno : 1 << 29 + 2

ERROR_NETNAME_DELETED: Errno : 64

ERROR_NONE: Errno : 0

ERROR_NOT_ENOUGH_MEMORY: Errno : 8

ERROR_NOT_FOUND: Errno : 1168

ERROR_NO_MORE_FILES: Errno : 18

ERROR_OPERATION_ABORTED: Errno : 995

ERROR_PATH_NOT_FOUND: Errno : 3

ERROR_PRIVILEGE_NOT_HELD: Errno : 1314

ERROR_PROC_NOT_FOUND: Errno : 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 :: 0x00400

O_ASYNC :: 0x02000

O_CLOEXEC :: 0x80000

O_CREATE :: 0x00040

O_EXCL :: 0x00080

O_NOCTTY :: 0x00100

O_NONBLOCK :: 0x00800

O_RDONLY :: 0x00000

O_RDWR :: 0x00002

O_SYNC :: 0x01000

O_TRUNC :: 0x00200

O_WRONLY :: 0x00001

SEEK_CUR :: 1

SEEK_END :: 2

SEEK_SET :: 0

WINDOWS_11_BUILD_CUTOFF :: 22_000

WSAEACCES: Errno : 10013

WSAECONNRESET: Errno : 10054

args: []string = …

stderr: Handle = …

stdin: Handle = …

stdout: Handle = …

change_directory :: set_current_directory

clear_env :: proc() {…}

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

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

environ :: proc(allocator := context.allocator) -> []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, Errno) {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

write_encoded_rune :: proc(fd: Handle, r: rune) {…}

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

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

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

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

read_entire_file :: proc{
	read_entire_file_from_filename,
	read_entire_file_from_handle,
}