mirror of
https://github.com/Ed94/Odin.git
synced 2026-06-14 18:02:22 -07:00
gingerBill
131 lines
2.8 KiB
Odin
131 lines
2.8 KiB
Odin
//+private
|
|
package os2
|
|
|
|
import "base:intrinsics"
|
|
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]) {
|
|
err = .Pattern_Has_Separator
|
|
return
|
|
}
|
|
}
|
|
prefix = pattern
|
|
for i := len(pattern)-1; i >= 0; i -= 1 {
|
|
if pattern[i] == '*' {
|
|
prefix, suffix = pattern[:i], pattern[i+1:]
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
@(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), 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)
|
|
string_from_null_terminated_bytes :: proc(b: []byte) -> (res: string) {
|
|
s := string(b)
|
|
i := 0
|
|
for ; i < len(s); i += 1 {
|
|
if s[i] == 0 {
|
|
break
|
|
}
|
|
}
|
|
return s[:i]
|
|
}
|
|
|
|
@(require_results)
|
|
concatenate_strings_from_buffer :: proc(buf: []byte, strings: ..string) -> string {
|
|
n := 0
|
|
for s in strings {
|
|
(n < len(buf)) or_break
|
|
n += copy(buf[n:], s)
|
|
}
|
|
n = min(len(buf), n)
|
|
return string(buf[:n])
|
|
}
|
|
|
|
@(require_results)
|
|
concatenate :: proc(strings: []string, allocator: runtime.Allocator) -> (res: string, err: runtime.Allocator_Error) {
|
|
n := 0
|
|
for s in strings {
|
|
n += len(s)
|
|
}
|
|
buf := make([]byte, n) or_return
|
|
n = 0
|
|
for s in strings {
|
|
n += copy(buf[n:], s)
|
|
}
|
|
return string(buf), nil
|
|
}
|
|
|
|
|
|
|
|
@(private="file")
|
|
random_string_seed: [2]u64
|
|
|
|
@(init, private="file")
|
|
init_random_string_seed :: proc() {
|
|
seed := u64(intrinsics.read_cycle_counter())
|
|
s := &random_string_seed
|
|
s[0] = 0
|
|
s[1] = (seed << 1) | 1
|
|
_ = next_random(s)
|
|
s[1] += seed
|
|
_ = next_random(s)
|
|
}
|
|
|
|
@(require_results)
|
|
next_random :: proc(r: ^[2]u64) -> u64 {
|
|
old_state := r[0]
|
|
r[0] = old_state * 6364136223846793005 + (r[1]|1)
|
|
xor_shifted := (((old_state >> 59) + 5) ~ old_state) * 12605985483714917081
|
|
rot := (old_state >> 59)
|
|
return (xor_shifted >> rot) | (xor_shifted << ((-rot) & 63))
|
|
}
|
|
|
|
@(require_results)
|
|
random_string :: proc(buf: []byte) -> string {
|
|
@(static, rodata) digits := "0123456789"
|
|
|
|
u := next_random(&random_string_seed)
|
|
|
|
b :: 10
|
|
i := len(buf)
|
|
for u >= b {
|
|
i -= 1
|
|
buf[i] = digits[u % b]
|
|
u /= b
|
|
}
|
|
i -= 1
|
|
buf[i] = digits[u % b]
|
|
return string(buf[i:])
|
|
}
|
|
|
|
|