File_Info :: struct {
	fullpath:          string,
	name:              string,
	size:              i64,
	mode:              File_Mode,
	is_dir:            bool,
	creation_time:     time.Time,
	modification_time: time.Time,
	access_time:       time.Time,
}

File_Mode ¶
Source

File_Mode :: distinct u32

File_Time ¶
Source

File_Time :: distinct u64

Handle ¶
Source

Handle :: distinct uintptr

Constants

ARCH ¶
Source

ARCH: .Odin_Arch_Type : ODIN_ARCH

ENDIAN ¶
Source

ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

ERROR_ACCESS_DENIED ¶
Source

ERROR_ACCESS_DENIED: Errno : 5

ERROR_ALREADY_EXISTS ¶
Source

ERROR_ALREADY_EXISTS: Errno : 183

ERROR_BROKEN_PIPE ¶
Source

ERROR_BROKEN_PIPE: Errno : 109

ERROR_BUFFER_OVERFLOW ¶
Source

ERROR_BUFFER_OVERFLOW: Errno : 111

ERROR_DIR_NOT_EMPTY ¶
Source

ERROR_DIR_NOT_EMPTY: Errno : 145

ERROR_ENVVAR_NOT_FOUND ¶
Source

ERROR_ENVVAR_NOT_FOUND: Errno : 203

ERROR_EOF ¶
Source

ERROR_EOF :: 38

ERROR_FILE_EXISTS ¶
Source

ERROR_FILE_EXISTS: Errno : 80

ERROR_FILE_IS_NOT_DIR ¶
Source

ERROR_FILE_IS_NOT_DIR: Errno : 1 << 29 + 1

ERROR_FILE_IS_PIPE ¶
Source

ERROR_FILE_IS_PIPE: Errno : 1 << 29 + 0

Windows reserves errors >= 1<<29 for application use

ERROR_FILE_NOT_FOUND ¶
Source

ERROR_FILE_NOT_FOUND: Errno : 2

ERROR_HANDLE_EOF ¶
Source

ERROR_HANDLE_EOF: Errno : 38

ERROR_INSUFFICIENT_BUFFER ¶
Source

ERROR_INSUFFICIENT_BUFFER: Errno : 122

ERROR_INVALID_HANDLE ¶
Source

ERROR_INVALID_HANDLE: Errno : 6

ERROR_INVALID_PARAMETER ¶
Source

ERROR_INVALID_PARAMETER: Errno : 87

ERROR_IO_PENDING ¶
Source

ERROR_IO_PENDING: Errno : 997

ERROR_MOD_NOT_FOUND ¶
Source

ERROR_MOD_NOT_FOUND: Errno : 126

ERROR_MORE_DATA ¶
Source

ERROR_MORE_DATA: Errno : 234

ERROR_NEGATIVE_OFFSET ¶
Source

ERROR_NEGATIVE_OFFSET: Errno : 1 << 29 + 2

ERROR_NETNAME_DELETED ¶
Source

ERROR_NETNAME_DELETED: Errno : 64

ERROR_NONE ¶
Source

ERROR_NONE: Errno : 0

ERROR_NOT_ENOUGH_MEMORY ¶
Source

ERROR_NOT_ENOUGH_MEMORY: Errno : 8

ERROR_NOT_FOUND ¶
Source

ERROR_NOT_FOUND: Errno : 1168

ERROR_NO_MORE_FILES ¶
Source

ERROR_NO_MORE_FILES: Errno : 18

ERROR_OPERATION_ABORTED ¶
Source

ERROR_OPERATION_ABORTED: Errno : 995

ERROR_PATH_NOT_FOUND ¶
Source

ERROR_PATH_NOT_FOUND: Errno : 3

ERROR_PRIVILEGE_NOT_HELD ¶
Source

ERROR_PRIVILEGE_NOT_HELD: Errno : 1314

ERROR_PROC_NOT_FOUND ¶
Source

ERROR_PROC_NOT_FOUND: Errno : 127

File_Mode_Char_Device ¶
Source

File_Mode_Char_Device :: File_Mode(1 << 19)

File_Mode_Device ¶
Source

File_Mode_Device :: File_Mode(1 << 18)

File_Mode_Dir ¶
Source

File_Mode_Dir :: File_Mode(1 << 16)

File_Mode_Named_Pipe ¶
Source

File_Mode_Named_Pipe :: File_Mode(1 << 17)

File_Mode_Sym_Link ¶
Source

File_Mode_Sym_Link :: File_Mode(1 << 20)

INVALID_HANDLE ¶
Source

INVALID_HANDLE: Handle : ~Handle(0)

OS ¶
Source

OS: .Odin_OS_Type : ODIN_OS

O_APPEND ¶
Source

O_APPEND :: 0x00400

O_ASYNC ¶
Source

O_ASYNC :: 0x02000

O_CLOEXEC ¶
Source

O_CLOEXEC :: 0x80000

O_CREATE ¶
Source

O_CREATE :: 0x00040

O_EXCL ¶
Source

O_EXCL :: 0x00080

O_NOCTTY ¶
Source

O_NOCTTY :: 0x00100

O_NONBLOCK ¶
Source

O_NONBLOCK :: 0x00800

O_RDONLY ¶
Source

O_RDONLY :: 0x00000

O_RDWR ¶
Source

O_RDWR :: 0x00002

O_SYNC ¶
Source

O_SYNC :: 0x01000

O_TRUNC ¶
Source

O_TRUNC :: 0x00200

O_WRONLY ¶
Source

O_WRONLY :: 0x00001

SEEK_CUR ¶
Source

SEEK_CUR :: 1

SEEK_END ¶
Source

SEEK_END :: 2

SEEK_SET ¶
Source

SEEK_SET :: 0

WINDOWS_11_BUILD_CUTOFF ¶
Source

WINDOWS_11_BUILD_CUTOFF :: 22_000

Windows 11 (preview) has the same major and minor version numbers

as Windows 10: 10 and 0 respectively.

To determine if you're on Windows 10 or 11, we need to look at
the build number. As far as we can tell right now, the cutoff is build 22_000.

TODO: Narrow down this range once Win 11 is published and the last Win 10 builds

become available.

WSAEACCES ¶
Source

WSAEACCES: Errno : 10013

WSAECONNRESET ¶
Source

WSAECONNRESET: Errno : 10054

Variables

args ¶
Source

args: []string = …

"Argv" arguments converted to Odin strings

stderr ¶
Source

stderr: Handle = …

stdin ¶
Source

stdin: Handle = …

NOTE(bill): Uses startup to initialize it

stdout ¶
Source

stdout: Handle = …

Procedures

change_directory ¶
Source

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

clear_env ¶
Source

clear_env :: proc() {…}

clear_env deletes all environment variables

close ¶
Source

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

current_thread_id ¶
Source

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

environ ¶
Source

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

environ returns a copy of strings representing the environment, in the form "key=value" NOTE: the slice of strings and the strings with be allocated using the supplied allocator

exists ¶
Source

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

exit ¶
Source

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

file_info_delete ¶
Source

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

file_info_slice_delete ¶
Source

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

file_size ¶
Source

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

file_size_from_path ¶
Source

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

flush ¶
Source

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

fstat ¶
Source

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

ftruncate ¶
Source

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

get_current_directory ¶
Source

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

get_env ¶
Source

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

get_env retrieves the value of the environment variable named by the key It returns the value, which will be empty if the variable is not present To distinguish between an empty value and an unset value, use lookup_env NOTE: the value will be allocated with the supplied allocator

get_page_size ¶
Source

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

get_std_handle ¶
Source

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

get_windows_version_w ¶
Source

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

heap_alloc ¶
Source

heap_alloc :: proc(size: int, zero_memory: bool = true) -> rawptr {…}

heap_allocator ¶
Source

heap_allocator :: proc() -> runtime.Allocator {…}

heap_allocator_proc ¶
Source

heap_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            runtime.Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> ([]u8, runtime.Allocator_Error) {…}

heap_free ¶
Source

heap_free :: proc(ptr: rawptr) {…}

heap_resize ¶
Source

heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {…}

is_dir ¶
Source

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

is_file ¶
Source

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

is_path_separator ¶
Source

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

is_windows_10 ¶
Source

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

is_windows_11 ¶
Source

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

is_windows_7 ¶
Source

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

is_windows_8 ¶
Source

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

is_windows_8_1 ¶
Source

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

is_windows_vista ¶
Source

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

is_windows_xp ¶
Source

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

last_write_time ¶
Source

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

last_write_time_by_name ¶
Source

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

link ¶
Source

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

lookup_env ¶
Source

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

lookup_env gets the value of the environment variable named by the key If the variable is found in the environment the value (which can be empty) is returned and the boolean is true Otherwise the returned value will be empty and the boolean will be false NOTE: the value will be allocated with the supplied allocator

lstat ¶
Source

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

make_directory ¶
Source

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

open ¶
Source

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

pipe ¶
Source

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

processor_core_count ¶
Source

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

read ¶
Source

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

read_at ¶
Source

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

read_at returns n: 0, err: 0 on EOF on Windows, read_at changes the position of the file cursor, on *nix, it does not.

bytes: [8]u8{}
read_at(fd, bytes, 0)
read(fd, bytes)

will read from the location twice on *nix, and from two different locations on Windows

read_at_least ¶
Source

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

read_dir ¶
Source

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

read_entire_file_from_filename ¶
Source

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

read_entire_file_from_handle ¶
Source

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

read_full ¶
Source

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

read_ptr ¶
Source

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

remove ¶
Source

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

remove_directory ¶
Source

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

rename ¶
Source

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

seek ¶
Source

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

set_current_directory ¶
Source

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

set_env ¶
Source

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

set_env sets the value of the environment variable named by the key

stat ¶
Source

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

stream_from_handle ¶
Source

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

truncate ¶
Source

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

unlink ¶
Source

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

unset_env ¶
Source

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

unset_env unsets a single environment variable

write ¶
Source

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

write_at ¶
Source

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

on Windows, write_at changes the position of the file cursor, on *nix, it does not.

bytes: [8]u8{}
write_at(fd, bytes, 0)
write(fd, bytes)

will write to the location twice on *nix, and to two different locations on Windows

write_byte ¶
Source

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

write_encoded_rune ¶
Source

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

write_entire_file ¶
Source

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

write_ptr ¶
Source

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

write_rune ¶
Source

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

write_string ¶
Source

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

Procedure Groups

read_entire_file ¶
Source

read_entire_file :: proc{
	read_entire_file_from_filename,
	read_entire_file_from_handle,
}

Source Files

os.odin
stat.odin
stream.odin
(hidden platform specific files)

Generation Information

Generated with odin version dev-2023-06 (vendor "odin") Windows_amd64 @ 2023-06-02 21:08:32.586151300 +0000 UTC

package core:osSource

Index

Types