package core:os

⌘K
Ctrl+K
or
/

    Index

    Constants (55)
    Variables (4)
    Procedures (65)
    Procedure Groups (1)

    Types

    File_Info ¶

    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,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    File_Time ¶

    File_Time :: distinct u64
    Related Procedures With Returns

    Constants

    ARCH ¶

    ARCH: .Odin_Arch_Type : ODIN_ARCH

    ENDIAN ¶

    ENDIAN: .Odin_Endian_Type : ODIN_ENDIAN

    ERROR_ACCESS_DENIED ¶

    ERROR_ACCESS_DENIED: Errno : 5

    ERROR_ALREADY_EXISTS ¶

    ERROR_ALREADY_EXISTS: Errno : 183

    ERROR_BROKEN_PIPE ¶

    ERROR_BROKEN_PIPE: Errno : 109

    ERROR_BUFFER_OVERFLOW ¶

    ERROR_BUFFER_OVERFLOW: Errno : 111

    ERROR_DIR_NOT_EMPTY ¶

    ERROR_DIR_NOT_EMPTY: Errno : 145

    ERROR_ENVVAR_NOT_FOUND ¶

    ERROR_ENVVAR_NOT_FOUND: Errno : 203

    ERROR_EOF ¶

    ERROR_EOF :: 38

    ERROR_FILE_EXISTS ¶

    ERROR_FILE_EXISTS: Errno : 80

    ERROR_FILE_IS_NOT_DIR ¶

    ERROR_FILE_IS_NOT_DIR: Errno : 1 << 29 + 1

    ERROR_FILE_IS_PIPE ¶

    ERROR_FILE_IS_PIPE: Errno : 1 << 29 + 0
     

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

    ERROR_FILE_NOT_FOUND ¶

    ERROR_FILE_NOT_FOUND: Errno : 2

    ERROR_HANDLE_EOF ¶

    ERROR_HANDLE_EOF: Errno : 38

    ERROR_INSUFFICIENT_BUFFER ¶

    ERROR_INSUFFICIENT_BUFFER: Errno : 122

    ERROR_INVALID_HANDLE ¶

    ERROR_INVALID_HANDLE: Errno : 6

    ERROR_INVALID_PARAMETER ¶

    ERROR_INVALID_PARAMETER: Errno : 87

    ERROR_IO_PENDING ¶

    ERROR_IO_PENDING: Errno : 997

    ERROR_MOD_NOT_FOUND ¶

    ERROR_MOD_NOT_FOUND: Errno : 126

    ERROR_MORE_DATA ¶

    ERROR_MORE_DATA: Errno : 234

    ERROR_NEGATIVE_OFFSET ¶

    ERROR_NEGATIVE_OFFSET: Errno : 1 << 29 + 2

    ERROR_NETNAME_DELETED ¶

    ERROR_NETNAME_DELETED: Errno : 64

    ERROR_NONE ¶

    ERROR_NONE: Errno : 0

    ERROR_NOT_ENOUGH_MEMORY ¶

    ERROR_NOT_ENOUGH_MEMORY: Errno : 8

    ERROR_NOT_FOUND ¶

    ERROR_NOT_FOUND: Errno : 1168

    ERROR_NO_MORE_FILES ¶

    ERROR_NO_MORE_FILES: Errno : 18

    ERROR_OPERATION_ABORTED ¶

    ERROR_OPERATION_ABORTED: Errno : 995

    ERROR_PATH_NOT_FOUND ¶

    ERROR_PATH_NOT_FOUND: Errno : 3

    ERROR_PRIVILEGE_NOT_HELD ¶

    ERROR_PRIVILEGE_NOT_HELD: Errno : 1314

    ERROR_PROC_NOT_FOUND ¶

    ERROR_PROC_NOT_FOUND: Errno : 127

    File_Mode_Char_Device ¶

    File_Mode_Char_Device :: File_Mode(1 << 19)

    File_Mode_Device ¶

    File_Mode_Device :: File_Mode(1 << 18)

    File_Mode_Dir ¶

    File_Mode_Dir :: File_Mode(1 << 16)

    File_Mode_Named_Pipe ¶

    File_Mode_Named_Pipe :: File_Mode(1 << 17)
    File_Mode_Sym_Link :: File_Mode(1 << 20)

    INVALID_HANDLE ¶

    INVALID_HANDLE: Handle : ~Handle(0)

    OS ¶

    OS: .Odin_OS_Type : ODIN_OS

    O_APPEND ¶

    O_APPEND :: 0x00400

    O_ASYNC ¶

    O_ASYNC :: 0x02000

    O_CLOEXEC ¶

    O_CLOEXEC :: 0x80000

    O_CREATE ¶

    O_CREATE :: 0x00040

    O_EXCL ¶

    O_EXCL :: 0x00080

    O_NOCTTY ¶

    O_NOCTTY :: 0x00100

    O_NONBLOCK ¶

    O_NONBLOCK :: 0x00800

    O_RDONLY ¶

    O_RDONLY :: 0x00000

    O_RDWR ¶

    O_RDWR :: 0x00002

    O_SYNC ¶

    O_SYNC :: 0x01000

    O_TRUNC ¶

    O_TRUNC :: 0x00200

    O_WRONLY ¶

    O_WRONLY :: 0x00001

    SEEK_CUR ¶

    SEEK_CUR :: 1

    SEEK_END ¶

    SEEK_END :: 2

    SEEK_SET ¶

    SEEK_SET :: 0

    WINDOWS_11_BUILD_CUTOFF ¶

    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 ¶

    WSAEACCES: Errno : 10013

    WSAECONNRESET ¶

    WSAECONNRESET: Errno : 10054

    Variables

    args ¶

    args: []string = …
     

    "Argv" arguments converted to Odin strings

    stderr ¶

    stderr: Handle = …

    stdin ¶

    stdin: Handle = …
     

    NOTE(bill): Uses startup to initialize it

    stdout ¶

    stdout: Handle = …

    Procedures

    clear_env ¶

    clear_env :: proc() {…}
     

    clear_env deletes all environment variables

    close ¶

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

    current_thread_id ¶

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

    environ ¶

    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 ¶

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

    exit ¶

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

    file_info_delete ¶

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

    file_info_slice_delete ¶

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

    file_size ¶

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

    file_size_from_path ¶

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

    flush ¶

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

    fstat ¶

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

    ftruncate ¶

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

    get_current_directory ¶

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

    get_env ¶

    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 ¶

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

    get_std_handle ¶

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

    get_windows_version_w ¶

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

    is_dir ¶

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

    is_file ¶

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

    is_path_separator ¶

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

    is_windows_10 ¶

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

    is_windows_11 ¶

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

    is_windows_7 ¶

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

    is_windows_8 ¶

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

    is_windows_8_1 ¶

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

    is_windows_vista ¶

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

    is_windows_xp ¶

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

    last_write_time ¶

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

    last_write_time_by_name ¶

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

    lookup_env ¶

    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 ¶

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

    make_directory ¶

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

    open ¶

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

    pipe ¶

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

    processor_core_count ¶

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

    read ¶

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

    read_at ¶

    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 ¶

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

    read_dir ¶

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

    read_entire_file_from_filename ¶

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

    read_entire_file_from_handle ¶

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

    read_full ¶

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

    read_ptr ¶

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

    remove ¶

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

    remove_directory ¶

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

    rename ¶

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

    seek ¶

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

    set_current_directory ¶

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

    set_env ¶

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

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

    stat ¶

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

    stream_from_handle ¶

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

    truncate ¶

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

    unset_env ¶

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

    unset_env unsets a single environment variable

    write ¶

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

    write_at ¶

    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 ¶

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

    write_encoded_rune ¶

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

    write_entire_file ¶

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

    write_ptr ¶

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

    write_rune ¶

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

    write_string ¶

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

    Procedure Groups

    Source Files

    Generation Information

    Generated with odin version dev-2024-07 (vendor "odin") Windows_amd64 @ 2024-07-18 21:09:42.389992100 +0000 UTC