mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-03 14:18:47 +00:00
Remove unneeded semicolons from the core library
This commit is contained in:
gingerBill
+145
-145
@@ -7,40 +7,40 @@ import "core:strings"
|
||||
// is_separator checks whether the byte is a valid separator character
|
||||
is_separator :: proc(c: byte) -> bool {
|
||||
switch c {
|
||||
case '/': return true;
|
||||
case '\\': return ODIN_OS == "windows";
|
||||
case '/': return true
|
||||
case '\\': return ODIN_OS == "windows"
|
||||
}
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
@(private)
|
||||
is_slash :: proc(c: byte) -> bool {
|
||||
return c == '\\' || c == '/';
|
||||
return c == '\\' || c == '/'
|
||||
}
|
||||
|
||||
split :: proc(path: string) -> (dir, file: string) {
|
||||
vol := volume_name(path);
|
||||
i := len(path) - 1;
|
||||
vol := volume_name(path)
|
||||
i := len(path) - 1
|
||||
for i >= len(vol) && !is_separator(path[i]) {
|
||||
i -= 1;
|
||||
i -= 1
|
||||
}
|
||||
return path[:i+1], path[i+1:];
|
||||
return path[:i+1], path[i+1:]
|
||||
}
|
||||
|
||||
volume_name :: proc(path: string) -> string {
|
||||
return path[:volume_name_len(path)];
|
||||
return path[:volume_name_len(path)]
|
||||
}
|
||||
|
||||
volume_name_len :: proc(path: string) -> int {
|
||||
if ODIN_OS == "windows" {
|
||||
if len(path) < 2 {
|
||||
return 0;
|
||||
return 0
|
||||
}
|
||||
c := path[0];
|
||||
c := path[0]
|
||||
if path[1] == ':' {
|
||||
switch c {
|
||||
case 'a'..='z', 'A'..='Z':
|
||||
return 2;
|
||||
return 2
|
||||
}
|
||||
}
|
||||
|
||||
@@ -49,153 +49,153 @@ volume_name_len :: proc(path: string) -> int {
|
||||
!is_slash(path[2]) && path[2] != '.' {
|
||||
for n := 3; n < l-1; n += 1 {
|
||||
if is_slash(path[n]) {
|
||||
n += 1;
|
||||
n += 1
|
||||
if !is_slash(path[n]) {
|
||||
if path[n] == '.' {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
for ; n < l; n += 1 {
|
||||
if is_slash(path[n]) {
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
return n;
|
||||
return n
|
||||
}
|
||||
break;
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return 0
|
||||
}
|
||||
|
||||
base :: proc(path: string) -> string {
|
||||
if path == "" {
|
||||
return ".";
|
||||
return "."
|
||||
}
|
||||
|
||||
path := path;
|
||||
path := path
|
||||
for len(path) > 0 && is_separator(path[len(path)-1]) {
|
||||
path = path[:len(path)-1];
|
||||
path = path[:len(path)-1]
|
||||
}
|
||||
|
||||
path = path[volume_name_len(path):];
|
||||
path = path[volume_name_len(path):]
|
||||
|
||||
i := len(path)-1;
|
||||
i := len(path)-1
|
||||
for i >= 0 && !is_separator(path[i]) {
|
||||
i -= 1;
|
||||
i -= 1
|
||||
}
|
||||
if i >= 0 {
|
||||
path = path[i+1:];
|
||||
path = path[i+1:]
|
||||
}
|
||||
if path == "" {
|
||||
return SEPARATOR_STRING;
|
||||
return SEPARATOR_STRING
|
||||
}
|
||||
return path;
|
||||
return path
|
||||
}
|
||||
|
||||
|
||||
clean :: proc(path: string, allocator := context.allocator) -> string {
|
||||
context.allocator = allocator;
|
||||
context.allocator = allocator
|
||||
|
||||
path := path;
|
||||
original_path := path;
|
||||
vol_len := volume_name_len(path);
|
||||
path = path[vol_len:];
|
||||
path := path
|
||||
original_path := path
|
||||
vol_len := volume_name_len(path)
|
||||
path = path[vol_len:]
|
||||
|
||||
if path == "" {
|
||||
if vol_len > 1 && original_path[1] != ':' {
|
||||
s, ok := from_slash(original_path);
|
||||
s, ok := from_slash(original_path)
|
||||
if !ok {
|
||||
s = strings.clone(s);
|
||||
s = strings.clone(s)
|
||||
}
|
||||
return s;
|
||||
return s
|
||||
}
|
||||
return strings.concatenate({original_path, "."});
|
||||
return strings.concatenate({original_path, "."})
|
||||
}
|
||||
|
||||
rooted := is_separator(path[0]);
|
||||
rooted := is_separator(path[0])
|
||||
|
||||
n := len(path);
|
||||
n := len(path)
|
||||
out := &Lazy_Buffer{
|
||||
s = path,
|
||||
vol_and_path = original_path,
|
||||
vol_len = vol_len,
|
||||
};
|
||||
}
|
||||
|
||||
r, dot_dot := 0, 0;
|
||||
r, dot_dot := 0, 0
|
||||
if rooted {
|
||||
lazy_buffer_append(out, SEPARATOR);
|
||||
r, dot_dot = 1, 1;
|
||||
lazy_buffer_append(out, SEPARATOR)
|
||||
r, dot_dot = 1, 1
|
||||
}
|
||||
|
||||
for r < n {
|
||||
switch {
|
||||
case is_separator(path[r]):
|
||||
r += 1;
|
||||
r += 1
|
||||
case path[r] == '.' && (r+1 == n || is_separator(path[r+1])):
|
||||
r += 1;
|
||||
r += 1
|
||||
case path[r] == '.' && path[r+1] == '.' && (r+2 == n || is_separator(path[r+2])):
|
||||
r += 2;
|
||||
r += 2
|
||||
switch {
|
||||
case out.w > dot_dot:
|
||||
out.w -= 1;
|
||||
out.w -= 1
|
||||
for out.w > dot_dot && !is_separator(lazy_buffer_index(out, out.w)) {
|
||||
out.w -= 1;
|
||||
out.w -= 1
|
||||
}
|
||||
case !rooted:
|
||||
if out.w > 0 {
|
||||
lazy_buffer_append(out, SEPARATOR);
|
||||
lazy_buffer_append(out, SEPARATOR)
|
||||
}
|
||||
lazy_buffer_append(out, '.');
|
||||
lazy_buffer_append(out, '.');
|
||||
dot_dot = out.w;
|
||||
lazy_buffer_append(out, '.')
|
||||
lazy_buffer_append(out, '.')
|
||||
dot_dot = out.w
|
||||
}
|
||||
case:
|
||||
if rooted && out.w != 1 || !rooted && out.w != 0 {
|
||||
lazy_buffer_append(out, SEPARATOR);
|
||||
lazy_buffer_append(out, SEPARATOR)
|
||||
}
|
||||
for ; r < n && !is_separator(path[r]); r += 1 {
|
||||
lazy_buffer_append(out, path[r]);
|
||||
lazy_buffer_append(out, path[r])
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if out.w == 0 {
|
||||
lazy_buffer_append(out, '.');
|
||||
lazy_buffer_append(out, '.')
|
||||
}
|
||||
|
||||
s := lazy_buffer_string(out);
|
||||
cleaned, new_allocation := from_slash(s);
|
||||
s := lazy_buffer_string(out)
|
||||
cleaned, new_allocation := from_slash(s)
|
||||
if new_allocation {
|
||||
delete(s);
|
||||
lazy_buffer_destroy(out);
|
||||
delete(s)
|
||||
lazy_buffer_destroy(out)
|
||||
}
|
||||
return cleaned;
|
||||
return cleaned
|
||||
}
|
||||
|
||||
from_slash :: proc(path: string, allocator := context.allocator) -> (new_path: string, new_allocation: bool) {
|
||||
if SEPARATOR == '/' {
|
||||
return path, false;
|
||||
return path, false
|
||||
}
|
||||
return strings.replace_all(path, "/", SEPARATOR_STRING, allocator);
|
||||
return strings.replace_all(path, "/", SEPARATOR_STRING, allocator)
|
||||
}
|
||||
|
||||
to_slash :: proc(path: string, allocator := context.allocator) -> (new_path: string, new_allocation: bool) {
|
||||
if SEPARATOR == '/' {
|
||||
return path, false;
|
||||
return path, false
|
||||
}
|
||||
return strings.replace_all(path, SEPARATOR_STRING, "/", allocator);
|
||||
return strings.replace_all(path, SEPARATOR_STRING, "/", allocator)
|
||||
}
|
||||
|
||||
ext :: proc(path: string) -> string {
|
||||
for i := len(path)-1; i >= 0 && !is_separator(path[i]); i -= 1 {
|
||||
if path[i] == '.' {
|
||||
return path[i:];
|
||||
return path[i:]
|
||||
}
|
||||
}
|
||||
return "";
|
||||
return ""
|
||||
}
|
||||
|
||||
|
||||
@@ -206,145 +206,145 @@ Relative_Error :: enum {
|
||||
}
|
||||
|
||||
rel :: proc(base_path, target_path: string, allocator := context.allocator) -> (string, Relative_Error) {
|
||||
context.allocator = allocator;
|
||||
base_clean, target_clean := clean(base_path), clean(target_path);
|
||||
context.allocator = allocator
|
||||
base_clean, target_clean := clean(base_path), clean(target_path)
|
||||
|
||||
delete_target := true;
|
||||
delete_target := true
|
||||
defer {
|
||||
if delete_target {
|
||||
delete(target_clean);
|
||||
delete(target_clean)
|
||||
}
|
||||
delete(base_clean);
|
||||
delete(base_clean)
|
||||
}
|
||||
|
||||
if strings.equal_fold(target_clean, base_clean) {
|
||||
return strings.clone("."), .None;
|
||||
return strings.clone("."), .None
|
||||
}
|
||||
|
||||
base_vol, target_vol := volume_name(base_path), volume_name(target_path);
|
||||
base := base_clean[len(base_vol):];
|
||||
target := target_clean[len(target_vol):];
|
||||
base_vol, target_vol := volume_name(base_path), volume_name(target_path)
|
||||
base := base_clean[len(base_vol):]
|
||||
target := target_clean[len(target_vol):]
|
||||
if base == "." {
|
||||
base = "";
|
||||
base = ""
|
||||
}
|
||||
|
||||
base_slashed := len(base) > 0 && base[0] == SEPARATOR;
|
||||
target_slashed := len(target) > 0 && target[0] == SEPARATOR;
|
||||
base_slashed := len(base) > 0 && base[0] == SEPARATOR
|
||||
target_slashed := len(target) > 0 && target[0] == SEPARATOR
|
||||
if base_slashed != target_slashed || !strings.equal_fold(base_vol, target_vol) {
|
||||
return "", .Cannot_Relate;
|
||||
return "", .Cannot_Relate
|
||||
}
|
||||
|
||||
bl, tl := len(base), len(target);
|
||||
b0, bi, t0, ti: int;
|
||||
bl, tl := len(base), len(target)
|
||||
b0, bi, t0, ti: int
|
||||
for {
|
||||
for bi < bl && base[bi] != SEPARATOR {
|
||||
bi += 1;
|
||||
bi += 1
|
||||
}
|
||||
for ti < tl && target[ti] != SEPARATOR {
|
||||
ti += 1;
|
||||
ti += 1
|
||||
}
|
||||
if !strings.equal_fold(target[t0:ti], base[b0:bi]) {
|
||||
break;
|
||||
break
|
||||
}
|
||||
if bi < bl {
|
||||
bi += 1;
|
||||
bi += 1
|
||||
}
|
||||
if ti < tl {
|
||||
ti += 1;
|
||||
ti += 1
|
||||
}
|
||||
b0, t0 = bi, ti;
|
||||
b0, t0 = bi, ti
|
||||
}
|
||||
|
||||
if base[b0:bi] == ".." {
|
||||
return "", .Cannot_Relate;
|
||||
return "", .Cannot_Relate
|
||||
}
|
||||
|
||||
if b0 != bl {
|
||||
seps := strings.count(base[b0:bl], SEPARATOR_STRING);
|
||||
size := 2 + seps*3;
|
||||
seps := strings.count(base[b0:bl], SEPARATOR_STRING)
|
||||
size := 2 + seps*3
|
||||
if tl != t0 {
|
||||
size += 1 + tl - t0;
|
||||
size += 1 + tl - t0
|
||||
}
|
||||
buf := make([]byte, size);
|
||||
n := copy(buf, "..");
|
||||
buf := make([]byte, size)
|
||||
n := copy(buf, "..")
|
||||
for in 0..<seps {
|
||||
buf[n] = SEPARATOR;
|
||||
copy(buf[n+1:], "..");
|
||||
n += 3;
|
||||
buf[n] = SEPARATOR
|
||||
copy(buf[n+1:], "..")
|
||||
n += 3
|
||||
}
|
||||
if t0 != tl {
|
||||
buf[n] = SEPARATOR;
|
||||
copy(buf[n+1:], target[t0:]);
|
||||
buf[n] = SEPARATOR
|
||||
copy(buf[n+1:], target[t0:])
|
||||
}
|
||||
return string(buf), .None;
|
||||
return string(buf), .None
|
||||
}
|
||||
|
||||
delete_target = false;
|
||||
return target[t0:], .None;
|
||||
delete_target = false
|
||||
return target[t0:], .None
|
||||
}
|
||||
|
||||
dir :: proc(path: string, allocator := context.allocator) -> string {
|
||||
vol := volume_name(path);
|
||||
i := len(path) - 1;
|
||||
vol := volume_name(path)
|
||||
i := len(path) - 1
|
||||
for i >= len(vol) && !is_separator(path[i]) {
|
||||
i -= 1;
|
||||
i -= 1
|
||||
}
|
||||
dir := clean(path[len(vol) : i+1], allocator);
|
||||
defer delete(dir, allocator);
|
||||
dir := clean(path[len(vol) : i+1], allocator)
|
||||
defer delete(dir, allocator)
|
||||
if dir == "." && len(vol) > 2 {
|
||||
return strings.clone(vol);
|
||||
return strings.clone(vol)
|
||||
}
|
||||
return strings.concatenate({vol, dir});
|
||||
return strings.concatenate({vol, dir})
|
||||
}
|
||||
|
||||
|
||||
|
||||
split_list :: proc(path: string, allocator := context.allocator) -> []string {
|
||||
if path == "" {
|
||||
return nil;
|
||||
return nil
|
||||
}
|
||||
|
||||
start: int;
|
||||
quote: bool;
|
||||
start: int
|
||||
quote: bool
|
||||
|
||||
start, quote = 0, false;
|
||||
count := 0;
|
||||
start, quote = 0, false
|
||||
count := 0
|
||||
|
||||
for i := 0; i < len(path); i += 1 {
|
||||
c := path[i];
|
||||
c := path[i]
|
||||
switch {
|
||||
case c == '"':
|
||||
quote = !quote;
|
||||
quote = !quote
|
||||
case c == LIST_SEPARATOR && !quote:
|
||||
count += 1;
|
||||
count += 1
|
||||
}
|
||||
}
|
||||
|
||||
start, quote = 0, false;
|
||||
list := make([]string, count, allocator);
|
||||
index := 0;
|
||||
start, quote = 0, false
|
||||
list := make([]string, count, allocator)
|
||||
index := 0
|
||||
for i := 0; i < len(path); i += 1 {
|
||||
c := path[i];
|
||||
c := path[i]
|
||||
switch {
|
||||
case c == '"':
|
||||
quote = !quote;
|
||||
quote = !quote
|
||||
case c == LIST_SEPARATOR && !quote:
|
||||
list[index] = path[start:i];
|
||||
index += 1;
|
||||
start = i + 1;
|
||||
list[index] = path[start:i]
|
||||
index += 1
|
||||
start = i + 1
|
||||
}
|
||||
}
|
||||
assert(index == count);
|
||||
assert(index == count)
|
||||
|
||||
for s0, i in list {
|
||||
s, new := strings.replace_all(s0, `"`, ``, allocator);
|
||||
s, new := strings.replace_all(s0, `"`, ``, allocator)
|
||||
if !new {
|
||||
s = strings.clone(s, allocator);
|
||||
s = strings.clone(s, allocator)
|
||||
}
|
||||
list[i] = s;
|
||||
list[i] = s
|
||||
}
|
||||
|
||||
return list;
|
||||
return list
|
||||
}
|
||||
|
||||
|
||||
@@ -366,38 +366,38 @@ Lazy_Buffer :: struct {
|
||||
@(private)
|
||||
lazy_buffer_index :: proc(lb: ^Lazy_Buffer, i: int) -> byte {
|
||||
if lb.b != nil {
|
||||
return lb.b[i];
|
||||
return lb.b[i]
|
||||
}
|
||||
return lb.s[i];
|
||||
return lb.s[i]
|
||||
}
|
||||
@(private)
|
||||
lazy_buffer_append :: proc(lb: ^Lazy_Buffer, c: byte) {
|
||||
if lb.b == nil {
|
||||
if lb.w < len(lb.s) && lb.s[lb.w] == c {
|
||||
lb.w += 1;
|
||||
return;
|
||||
lb.w += 1
|
||||
return
|
||||
}
|
||||
lb.b = make([]byte, len(lb.s));
|
||||
copy(lb.b, lb.s[:lb.w]);
|
||||
lb.b = make([]byte, len(lb.s))
|
||||
copy(lb.b, lb.s[:lb.w])
|
||||
}
|
||||
lb.b[lb.w] = c;
|
||||
lb.w += 1;
|
||||
lb.b[lb.w] = c
|
||||
lb.w += 1
|
||||
}
|
||||
@(private)
|
||||
lazy_buffer_string :: proc(lb: ^Lazy_Buffer) -> string {
|
||||
if lb.b == nil {
|
||||
return strings.clone(lb.vol_and_path[:lb.vol_len+lb.w]);
|
||||
return strings.clone(lb.vol_and_path[:lb.vol_len+lb.w])
|
||||
}
|
||||
|
||||
x := lb.vol_and_path[:lb.vol_len];
|
||||
y := string(lb.b[:lb.w]);
|
||||
z := make([]byte, len(x)+len(y));
|
||||
copy(z, x);
|
||||
copy(z[len(x):], y);
|
||||
return string(z);
|
||||
x := lb.vol_and_path[:lb.vol_len]
|
||||
y := string(lb.b[:lb.w])
|
||||
z := make([]byte, len(x)+len(y))
|
||||
copy(z, x)
|
||||
copy(z[len(x):], y)
|
||||
return string(z)
|
||||
}
|
||||
@(private)
|
||||
lazy_buffer_destroy :: proc(lb: ^Lazy_Buffer) {
|
||||
delete(lb.b);
|
||||
lb^ = {};
|
||||
delete(lb.b)
|
||||
lb^ = {}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user