package core:os/old

Source

ERROR_ACCESS_DENIED :: Handle

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, 
	Exist, 
	Not_Exist, 
	Timeout, 
	Broken_Pipe, 
	Invalid_File, 
	Invalid_Dir, 
	Invalid_Path, 
	Invalid_Callback, 
	Pattern_Has_Separator, 
	File_Is_Pipe, 
	Not_Dir, 
	// Environment variable not found.
	Env_Var_Not_Found, 
}

Platform_Error :: sys_windows.System_Error

ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

ERROR_ACCESS_DENIED :: ERROR_PROC_NOT_FOUND

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_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_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_NOT_ENOUGH_MEMORY: sys_windows.System_Error : _Platform_Error(8)

ERROR_NOT_ENOUGH_MEMORY :: SEEK_SET

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)

File_Mode :: OS

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 :: WINDOWS_11_BUILD_CUTOFF

File_Mode_Named_Pipe :: File_Mode(1 << 17)

File_Mode_Sym_Link :: File_Mode(1 << 20)

INVALID_HANDLE: Handle : ~Handle(0)

O_APPEND :: 0x00400

O_APPEND :: ERROR_ENVVAR_NOT_FOUND

O_ASYNC :: 0x02000

O_CLOEXEC :: 0x80000

O_CREATE :: ERROR_INVALID_HANDLE

O_EXCL :: 0x00080

O_NOCTTY :: 0x00100

O_RDONLY :: O_NONBLOCK

O_RDONLY :: 0x00000

O_RDWR :: 0x00002

O_SYNC :: 0x01000

O_TRUNC :: 0x00200

O_WRONLY :: 0x00001

SEEK_CUR :: 1

SEEK_END :: 2

WSAEACCES: sys_windows.System_Error : _Platform_Error(10013)

WSAECONNRESET: sys_windows.System_Error : _Platform_Error(10054)

cleanpath_from_buf :: ERROR_EOF

cleanpath_from_buf :: ERROR_NONE

clear_env :: ERROR_PRIVILEGE_NOT_HELD

get_last_error :: ERROR_ACCESS_DENIED

open :: ARCH

unset_env :: O_CREATE

Handle :: stderr

args: []string = …

flush :: stdin

stdout: Handle = …

ERROR_FILE_EXISTS :: get_last_error

ERROR_FILE_NOT_FOUND :: last_write_time_by_name

ERROR_HANDLE_EOF :: is_windows_10

ERROR_INVALID_HANDLE :: read_dir

ERROR_MOD_NOT_FOUND :: write_entire_file

File_Mode_Named_Pipe :: unlink

O_EXCL :: print_error

WSAECONNRESET :: write_encoded_rune

change_directory :: set_current_directory

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

close :: write_byte

current_thread_id :: get_current_directory

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

environ :: clear_env

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_from_win32_file_attribute_data :: write_at

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_env_buf :: proc(buf: []u8, key: string) -> (value: string) {…}

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

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

heap_allocator_proc :: unset_env

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_11 :: proc "contextless" () -> bool {…}

is_windows_7 :: pipe

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

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

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

is_windows_xp :: get_env_alloc

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

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

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

lookup_env_buffer :: proc(buf: []u8, key: string) -> (value: string, err: Error) {…}

lstat :: is_windows_vista

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) {…}

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_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_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Error) {…}

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

remove :: read_at_least

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

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

replace_environment_placeholders :: proc(path: string, allocator := context.allocator) -> (res: string) {…}

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) {…}

stdin :: read_entire_file_from_handle_or_err

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

windows_set_file_info_times :: is_windows_xp

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

write_byte :: get_std_handle

write_encoded_rune :: truncate

write_encoded_rune :: read_full

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: rune) -> (int, Error) {…}

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

get_current_directory :: read_entire_file_or_err

get_env :: proc{
	get_env_alloc,
	get_env_buf,
}

lookup_env :: proc{
	lookup_env_alloc,
	lookup_env_buffer,
}

read_entire_file :: proc{
	read_entire_file_from_filename,
	read_entire_file_from_handle,
}