mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-01-04 12:07:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add @(require_results) everywhere in os2

Browse Source
This commit is contained in:
gingerBill
2024-05-14 18:25:15 +01:00
parent 48c1822709
commit 450b9ceaec
13 changed files with 85 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/os/os2/allocators.odin
View File

@@ -3,6 +3,7 @@ package os2
import "base:runtime"
@(require_results)
file_allocator :: proc() -> runtime.Allocator {
return heap_allocator()
}
@@ -12,6 +13,7 @@ temp_allocator_proc :: runtime.arena_allocator_proc
@(private="file", thread_local)
global_default_temp_allocator_arena: runtime.Arena
@(require_results)
temp_allocator :: proc() -> runtime.Allocator {
return runtime.Allocator{
procedure = temp_allocator_proc,

3
core/os/os2/env.odin
View File

@@ -6,6 +6,7 @@ import "base:runtime"
// 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
@(require_results)
get_env :: proc(key: string, allocator: runtime.Allocator) -> string {
value, _ := lookup_env(key, allocator)
return value
@@ -15,6 +16,7 @@ get_env :: proc(key: string, allocator: runtime.Allocator) -> string {
// 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
@(require_results)
lookup_env :: proc(key: string, allocator: runtime.Allocator) -> (value: string, found: bool) {
return _lookup_env(key, allocator)
}
@@ -38,6 +40,7 @@ clear_env :: proc() {
// 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
@(require_results)
environ :: proc(allocator: runtime.Allocator) -> []string {
return _environ(allocator)
}

8
core/os/os2/file.odin
View File

@@ -51,22 +51,27 @@ stdout: ^File = nil // OS-Specific
stderr: ^File = nil // OS-Specific
@(require_results)
create :: proc(name: string) -> (^File, Error) {
return open(name, {.Read, .Write, .Create}, File_Mode(0o777))
}
@(require_results)
open :: proc(name: string, flags := File_Flags{.Read}, perm := File_Mode(0o777)) -> (^File, Error) {
return _open(name, flags, perm)
}
@(require_results)
new_file :: proc(handle: uintptr, name: string) -> ^File {
return _new_file(handle, name)
}
@(require_results)
fd :: proc(f: ^File) -> uintptr {
return _fd(f)
}
@(require_results)
name :: proc(f: ^File) -> string {
return _name(f)
}
@@ -200,15 +205,18 @@ fchange_times :: proc(f: ^File, atime, mtime: time.Time) -> Error {
return _fchtimes(f, atime, mtime)
}
@(require_results)
exists :: proc(path: string) -> bool {
return _exists(path)
}
@(require_results)
is_file :: proc(path: string) -> bool {
return _is_file(path)
}
is_dir :: is_directory
@(require_results)
is_directory :: proc(path: string) -> bool {
return _is_dir(path)
}

60
core/os/os2/file_linux.odin
View File

@@ -1,10 +1,9 @@
//+private
package os2
import "base:runtime"
import "core:io"
import "core:time"
import "core:strings"
import "base:runtime"
import "core:sys/unix"
INVALID_HANDLE :: -1
@@ -35,9 +34,9 @@ _File :: struct {
allocator: runtime.Allocator,
}
_open :: proc(name: string, flags: File_Flags, perm: File_Mode) -> (^File, Error) {
_open :: proc(name: string, flags: File_Flags, perm: File_Mode) -> (f: ^File, err: Error) {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
// Just default to using O_NOCTTY because needing to open a controlling
// terminal would be incredibly rare. This has no effect on files while
@@ -195,7 +194,7 @@ _truncate :: proc(f: ^File, size: i64) -> Error {
_remove :: proc(name: string) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
fd := unix.sys_open(name_cstr, int(File_Flags.Read))
if fd < 0 {
@@ -210,22 +209,25 @@ _remove :: proc(name: string) -> Error {
}
_rename :: proc(old_name, new_name: string) -> Error {
old_name_cstr := strings.clone_to_cstring(old_name, context.temp_allocator)
new_name_cstr := strings.clone_to_cstring(new_name, context.temp_allocator)
TEMP_ALLOCATOR_GUARD()
old_name_cstr := temp_cstring(old_name) or_return
new_name_cstr := temp_cstring(new_name) or_return
return _ok_or_error(unix.sys_rename(old_name_cstr, new_name_cstr))
}
_link :: proc(old_name, new_name: string) -> Error {
old_name_cstr := strings.clone_to_cstring(old_name, context.temp_allocator)
new_name_cstr := strings.clone_to_cstring(new_name, context.temp_allocator)
TEMP_ALLOCATOR_GUARD()
old_name_cstr := temp_cstring(old_name) or_return
new_name_cstr := temp_cstring(new_name) or_return
return _ok_or_error(unix.sys_link(old_name_cstr, new_name_cstr))
}
_symlink :: proc(old_name, new_name: string) -> Error {
old_name_cstr := strings.clone_to_cstring(old_name, context.temp_allocator)
new_name_cstr := strings.clone_to_cstring(new_name, context.temp_allocator)
TEMP_ALLOCATOR_GUARD()
old_name_cstr := temp_cstring(old_name) or_return
new_name_cstr := temp_cstring(new_name) or_return
return _ok_or_error(unix.sys_symlink(old_name_cstr, new_name_cstr))
}
@@ -234,7 +236,7 @@ _read_link_cstr :: proc(name_cstr: cstring, allocator: runtime.Allocator) -> (st
bufsz : uint = 256
buf := make([]byte, bufsz, allocator)
for {
rc := unix.sys_readlink(name_cstr, &(buf[0]), bufsz)
rc := unix.sys_readlink(name_cstr, &buf[0], bufsz)
if rc < 0 {
delete(buf)
return "", _get_platform_error(rc)
@@ -243,26 +245,26 @@ _read_link_cstr :: proc(name_cstr: cstring, allocator: runtime.Allocator) -> (st
delete(buf)
buf = make([]byte, bufsz, allocator)
} else {
return strings.string_from_ptr(&buf[0], rc), nil
return string(buf[:rc]), nil
}
}
}
_read_link :: proc(name: string, allocator: runtime.Allocator) -> (string, Error) {
_read_link :: proc(name: string, allocator: runtime.Allocator) -> (path: string, err: Error) {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _read_link_cstr(name_cstr, allocator)
}
_unlink :: proc(name: string) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _ok_or_error(unix.sys_unlink(name_cstr))
}
_chdir :: proc(name: string) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _ok_or_error(unix.sys_chdir(name_cstr))
}
@@ -272,7 +274,7 @@ _fchdir :: proc(f: ^File) -> Error {
_chmod :: proc(name: string, mode: File_Mode) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _ok_or_error(unix.sys_chmod(name_cstr, uint(mode)))
}
@@ -283,14 +285,14 @@ _fchmod :: proc(f: ^File, mode: File_Mode) -> Error {
// NOTE: will throw error without super user priviledges
_chown :: proc(name: string, uid, gid: int) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _ok_or_error(unix.sys_chown(name_cstr, uid, gid))
}
// NOTE: will throw error without super user priviledges
_lchown :: proc(name: string, uid, gid: int) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
return _ok_or_error(unix.sys_lchown(name_cstr, uid, gid))
}
@@ -301,7 +303,7 @@ _fchown :: proc(f: ^File, uid, gid: int) -> Error {
_chtimes :: proc(name: string, atime, mtime: time.Time) -> Error {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr := temp_cstring(name) or_return
times := [2]Unix_File_Time {
{ atime._nsec, 0 },
{ mtime._nsec, 0 },
@@ -319,13 +321,13 @@ _fchtimes :: proc(f: ^File, atime, mtime: time.Time) -> Error {
_exists :: proc(name: string) -> bool {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr, _ := temp_cstring(name)
return unix.sys_access(name_cstr, F_OK) == 0
}
_is_file :: proc(name: string) -> bool {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr, _ := temp_cstring(name)
s: _Stat
res := unix.sys_stat(name_cstr, &s)
if res < 0 {
@@ -345,7 +347,7 @@ _is_file_fd :: proc(fd: int) -> bool {
_is_dir :: proc(name: string) -> bool {
TEMP_ALLOCATOR_GUARD()
name_cstr := _temp_name_to_cstring(name)
name_cstr, _ := temp_cstring(name)
s: _Stat
res := unix.sys_stat(name_cstr, &s)
if res < 0 {
@@ -363,16 +365,6 @@ _is_dir_fd :: proc(fd: int) -> bool {
return S_ISDIR(s.mode)
}
// Ideally we want to use the temp_allocator. PATH_MAX on Linux is commonly
// defined as 512, however, it is well known that paths can exceed that limit.
// So, in theory you could have a path larger than the entire temp_allocator's
// buffer. Therefor, any large paths will use context.allocator.
@(private="file")
_temp_name_to_cstring :: proc(name: string) -> (cname: cstring) {
return strings.clone_to_cstring(name, temp_allocator())
}
@(private="package")
_file_stream_proc :: proc(stream_data: rawptr, mode: io.Stream_Mode, p: []byte, offset: i64, whence: io.Seek_From) -> (n: i64, err: io.Error) {
f := (^File)(stream_data)

3
core/os/os2/file_util.odin
View File

@@ -76,6 +76,7 @@ read_entire_file :: proc{
read_entire_file_from_file,
}
@(require_results)
read_entire_file_from_path :: proc(name: string, allocator: runtime.Allocator) -> (data: []byte, err: Error) {
f, ferr := open(name)
if ferr != nil {
@@ -85,6 +86,7 @@ read_entire_file_from_path :: proc(name: string, allocator: runtime.Allocator) -
return read_entire_file_from_file(f, allocator)
}
@(require_results)
read_entire_file_from_file :: proc(f: ^File, allocator: runtime.Allocator) -> (data: []byte, err: Error) {
size: int
has_size := true
@@ -135,6 +137,7 @@ read_entire_file_from_file :: proc(f: ^File, allocator: runtime.Allocator) -> (d
}
}
@(require_results)
write_entire_file :: proc(name: string, data: []byte, perm: File_Mode, truncate := true) -> Error {
flags := O_WRONLY|O_CREATE
if truncate {

2
core/os/os2/heap.odin
View File

@@ -2,6 +2,7 @@ package os2
import "base:runtime"
@(require_results)
heap_allocator :: proc() -> runtime.Allocator {
return runtime.Allocator{
procedure = heap_allocator_proc,
@@ -10,6 +11,7 @@ heap_allocator :: proc() -> runtime.Allocator {
}
@(require_results)
heap_allocator_proc :: proc(allocator_data: rawptr, mode: runtime.Allocator_Mode,
size, alignment: int,
old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, runtime.Allocator_Error) {

28
core/os/os2/internal_util.odin
View File

@@ -7,6 +7,7 @@ import "base:runtime"
// Splits pattern by the last wildcard "*", if it exists, and returns the prefix and suffix
// parts which are split by the last "*"
@(require_results)
_prefix_and_suffix :: proc(pattern: string) -> (prefix, suffix: string, err: Error) {
for i in 0..<len(pattern) {
if is_path_separator(pattern[i]) {
@@ -24,13 +25,32 @@ _prefix_and_suffix :: proc(pattern: string) -> (prefix, suffix: string, err: Err
return
}
clone_string :: proc(s: string, allocator: runtime.Allocator) -> string {
buf := make([]byte, len(s), allocator)
@(require_results)
clone_string :: proc(s: string, allocator: runtime.Allocator) -> (res: string, err: runtime.Allocator_Error) {
buf := make([]byte, len(s), allocator) or_return
copy(buf, s)
return string(buf)
return string(buf), nil
}
@(require_results)
clone_to_cstring :: proc(s: string, allocator: runtime.Allocator) -> (res: cstring, err: runtime.Allocator_Error) {
res = "" // do not use a `nil` cstring
buf := make([]byte, len(s)+1, allocator) or_return
copy(buf, s)
buf[len(s)] = 0
return cstring(&buf[0]), nil
}
@(require_results)
temp_cstring :: proc(s: string) -> (cstring, runtime.Allocator_Error) {
return clone_to_cstring(s, temp_allocator())
}
@(require_results)
concatenate_strings_from_buffer :: proc(buf: []byte, strings: ..string) -> string {
n := 0
for s in strings {
@@ -57,6 +77,7 @@ init_random_string_seed :: proc() {
_ = next_random(s)
}
@(require_results)
next_random :: proc(r: ^[2]u64) -> u64 {
old_state := r[0]
r[0] = old_state * 6364136223846793005 + (r[1]|1)
@@ -65,6 +86,7 @@ next_random :: proc(r: ^[2]u64) -> u64 {
return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 63))
}
@(require_results)
random_string :: proc(buf: []byte) -> string {
@static digits := "0123456789"

2
core/os/os2/path.odin
View File

@@ -6,6 +6,7 @@ Path_Separator :: _Path_Separator // OS-Specific
Path_Separator_String :: _Path_Separator_String // OS-Specific
Path_List_Separator :: _Path_List_Separator // OS-Specific
@(require_results)
is_path_separator :: proc(c: byte) -> bool {
return _is_path_separator(c)
}
@@ -26,6 +27,7 @@ remove_all :: proc(path: string) -> Error {
getwd :: get_working_directory
@(require_results)
get_working_directory :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
return _getwd(allocator)
}

3
core/os/os2/path_linux.odin
View File

@@ -32,7 +32,8 @@ _mkdir :: proc(path: string, perm: File_Mode) -> Error {
return .Invalid_Argument
}
path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
TEMP_ALLOCATOR_GUARD()
path_cstr := strings.clone_to_cstring(path, temp_allocator())
return _ok_or_error(unix.sys_mkdir(path_cstr, uint(perm & 0o777)))
}

1
core/os/os2/pipe.odin
View File

@@ -1,5 +1,6 @@
package os2
@(require_results)
pipe :: proc() -> (r, w: ^File, err: Error) {
return _pipe()
}

4
core/os/os2/stat.odin
View File

@@ -25,20 +25,24 @@ file_info_delete :: proc(fi: File_Info, allocator: runtime.Allocator) {
delete(fi.fullpath, allocator)
}
@(require_results)
fstat :: proc(f: ^File, allocator: runtime.Allocator) -> (File_Info, Error) {
return _fstat(f, allocator)
}
@(require_results)
stat :: proc(name: string, allocator: runtime.Allocator) -> (File_Info, Error) {
return _stat(name, allocator)
}
lstat :: stat_do_not_follow_links
@(require_results)
stat_do_not_follow_links :: proc(name: string, allocator: runtime.Allocator) -> (File_Info, Error) {
return _lstat(name, allocator)
}
@(require_results)
same_file :: proc(fi1, fi2: File_Info) -> bool {
return _same_file(fi1, fi2)
}

5
core/os/os2/temp_file.odin
View File

@@ -13,6 +13,7 @@ MAX_ATTEMPTS :: 1<<13 // Should be enough for everyone, right?
// If `dir` is an empty tring, `temp_directory()` will be used.
//
// The caller must `close` the file once finished with.
@(require_results)
create_temp_file :: proc(dir, pattern: string) -> (f: ^File, err: Error) {
TEMP_ALLOCATOR_GUARD()
dir := dir if dir != "" else temp_directory(temp_allocator()) or_return
@@ -44,6 +45,7 @@ mkdir_temp :: make_directory_temp
// The directory name is generated by taking a pattern, and adding a randomized string to the end.
// If the pattern includes an "*", the randm string replaces the last "*".
// If `dir` is an empty tring, `temp_directory()` will be used.
@(require_results)
make_directory_temp :: proc(dir, pattern: string, allocator: runtime.Allocator) -> (temp_path: string, err: Error) {
TEMP_ALLOCATOR_GUARD()
dir := dir if dir != "" else temp_directory(temp_allocator()) or_return
@@ -58,7 +60,7 @@ make_directory_temp :: proc(dir, pattern: string, allocator: runtime.Allocator)
name := concatenate_strings_from_buffer(name_buf[:], prefix, random_string(rand_buf[:]), suffix)
err = make_directory(name, 0o700)
if err == nil {
return clone_string(name, allocator), nil
return clone_string(name, allocator)
}
if err == .Exist {
attempts += 1
@@ -78,6 +80,7 @@ make_directory_temp :: proc(dir, pattern: string, allocator: runtime.Allocator)
}
temp_dir :: temp_directory
@(require_results)
temp_directory :: proc(allocator: runtime.Allocator) -> (string, Error) {
return _temp_dir(allocator)
}

3
core/os/os2/user.odin
View File

@@ -3,6 +3,7 @@ package os2
import "core:strings"
import "base:runtime"
@(require_results)
user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
#partial switch ODIN_OS {
case .Windows:
@@ -31,6 +32,7 @@ user_cache_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error
return
}
@(require_results)
user_config_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
#partial switch ODIN_OS {
case .Windows:
@@ -59,6 +61,7 @@ user_config_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Erro
return
}
@(require_results)
user_home_dir :: proc(allocator: runtime.Allocator) -> (dir: string, err: Error) {
env := "HOME"
#partial switch ODIN_OS {