Fix new `package path`

3 files changed, 213 insertions, 292 deletions

diff --git a/core/path/path.odin b/core/path/path.odin
index fb26eb229..b2fe1c7df 100644
--- a/core/path/path.odin
+++ b/core/path/path.odin
@@ -6,75 +6,75 @@ import "core:unicode/utf8"
 

 // returns everything preceding the last path element

 dir :: proc(path: string, new := false, allocator := context.allocator) -> string {

-    if path == "" do return "";

-

-    for i := len(path) - 1; i >= 0; i -= 1 {

-        if path[i] == '/' || path[i] == '\\' {

-            if path[:i] == "" {

-                // path is root

-                return new ? strings.new_string(SEPARATOR_STRING, allocator) : SEPARATOR_STRING;

-            } else {

-                return new ? strings.new_string(path[:i], allocator) : path[:i];

-            }

-        }

-    }

-

-    // path doesn't contain any folder structure

-    return "";

+	if path == "" do return "";

+

+	for i := len(path) - 1; i >= 0; i -= 1 {

+		if path[i] == '/' || path[i] == '\\' {

+			if path[:i] == "" {

+				// path is root

+				return new ? strings.clone(SEPARATOR_STRING, allocator) : SEPARATOR_STRING;

+			} else {

+				return new ? strings.clone(path[:i], allocator) : path[:i];

+			}

+		}

+	}

+

+	// path doesn't contain any folder structure

+	return "";

 }

 

 // returns the final path element

 base :: proc(path: string, new := false, allocator := context.allocator) -> string {

-    if path == "" do return "";

-

-    end := len(path) - 1;

-

-    for i := end; i >= 0; i -= 1 {

-        switch path[i] {

-        case '/', '\\':

-            if i != end {

-                return new ? strings.new_string(path[i+1:], allocator) : path[i+1:];

-            } else {

-                end = i; // we don't want trailing slashes

-            }

-        }

-    }

-

-    // path doesn't contain any folder structure, return entire path

-    return new ? strings.new_string(path, allocator) : path;

+	if path == "" do return "";

+

+	end := len(path) - 1;

+

+	for i := end; i >= 0; i -= 1 {

+		switch path[i] {

+		case '/', '\\':

+			if i != end {

+				return new ? strings.clone(path[i+1:], allocator) : path[i+1:];

+			} else {

+				end = i; // we don't want trailing slashes

+			}

+		}

+	}

+

+	// path doesn't contain any folder structure, return entire path

+	return new ? strings.clone(path, allocator) : path;

 }

 

 // returns the final path element, excluding the file extension if there is one

 name :: proc(path: string, new := false, allocator := context.allocator) -> string {

-    if path == "" do return "";

+	if path == "" do return "";

 

-    dot := len(path);

-    end := dot - 1;

+	dot := len(path);

+	end := dot - 1;

 

-    for i := end; i >= 0; i -= 1 {

-        switch path[i] {

-        case '.':       dot = (dot == end ? i : dot);

-        case '/', '\\': return new ? strings.new_string(path[i+1:dot], allocator) : path[i+1:dot];

-        }

-    }

+	for i := end; i >= 0; i -= 1 {

+		switch path[i] {

+		case '.':       dot = (dot == end ? i : dot);

+		case '/', '\\': return new ? strings.clone(path[i+1:dot], allocator) : path[i+1:dot];

+		}

+	}

 

-    // path doesn't contain any folder structure or file extensions; assumed to be a valid file name

-    return new ? strings.new_string(path, allocator) : path;

+	// path doesn't contain any folder structure or file extensions; assumed to be a valid file name

+	return new ? strings.clone(path, allocator) : path;

 }

 

 // returns the file extension, if there is one

 ext :: proc(path: string, new := false, allocator := context.allocator) -> string {

-    if path == "" do return "";

+	if path == "" do return "";

 

-    for i := len(path)-1; i >= 0; i -= 1 {

-        switch path[i] {

-        case '/', '\\': return "";

-        case '.':       return new ? strings.new_string(path[i+1:], allocator) : path[i+1:];

-        }

-    }

+	for i := len(path)-1; i >= 0; i -= 1 {

+		switch path[i] {

+		case '/', '\\': return "";

+		case '.':       return new ? strings.clone(path[i+1:], allocator) : path[i+1:];

+		}

+	}

 

-    // path does not include a file extension

-    return "";

+	// path does not include a file extension

+	return "";

 }

 

 

@@ -82,119 +82,120 @@ rel :: proc{rel_between, rel_current};
 

 // returns the relative path from one path to another

 rel_between :: proc(from, to: string, allocator := context.allocator) -> string {

-    if from == "" || to == "" do return "";

-

-    from = full(from, context.temp_allocator);

-    to   = full(to,   context.temp_allocator);

-

-    from_is_dir := is_dir(from);

-    to_is_dir   := is_dir(to);

-

-    index, slash := 0, 0;

-

-    for {

-        if index >= len(from) {

-            if index >= len(to) || (from_is_dir && index < len(to) && (to[index] == '/' || to[index] == '\\')) {

-                slash = index;

-            }

-

-            break;

-        }

-        else if index >= len(to) {

-            if index >= len(from) || (to_is_dir && index < len(from) && (from[index] == '/' || from[index] == '\\')) {

-                slash = index;

-            }

-

-            break;

-        }

-

-        lchar, skip := utf8.decode_rune_in_string(from[index:]);

-        rchar, _    := utf8.decode_rune_in_string(to[index:]);

-

-        if (lchar == '/' || lchar == '\\') && (rchar == '/' || lchar == '\\') {

-            slash = index;

-        }

-        else if lchar != rchar {

-            break;

-        }

-

-        index += skip;

-    }

-

-    if slash < 1 {

-        // there is no common path, use the absolute `to` path

-        return strings.new_string(to, allocator);

-    }

-

-    from_slashes, to_slashes := 0, 0;

-

-    if slash < len(from) {

-        from = from[slash+1:];

-        

-        if from_is_dir {

-            from_slashes += 1;

-        }

-    }

-    else {

-        from = "";

-    }

-

-    if slash < len(to) {

-        to = to[slash+1:];

-

-        if to_is_dir {

-            to_slashes += 1;

-        }

-    }

-    else {

-        to = "";

-    }

-

-    for char in from {

-        if char == '/' || char == '\\' {

-            from_slashes += 1;

-        }

-    }

-

-    for char in to {

-        if char == '/' || char == '\\' {

-            to_slashes += 1;

-        }

-    }

-

-    if from_slashes == 0 {

-        buffer := make([]byte, 2 + len(to), allocator);

-

-        buffer[0] = '.';

-        buffer[1] = SEPARATOR;

-        copy(buffer[2:], ([]byte)(to));

-

-        return string(buffer);

-    }

-    else {

-        buffer := make([]byte, from_slashes*3 + len(to), allocator);

-

-        for i in 0..from_slashes-1 {

-            buffer[i*3+0] = '.';

-            buffer[i*3+1] = '.';

-            buffer[i*3+2] = SEPARATOR;

-        }

-

-        copy(buffer[from_slashes*3:], ([]byte)(to));

-

-        return string(buffer);

-    }

-

-    return "";

+	if from == "" || to == "" do return "";

+

+	from, to := from, to;

+	from = full(from, context.temp_allocator);

+	to   = full(to,   context.temp_allocator);

+

+	from_is_dir := is_dir(from);

+	to_is_dir   := is_dir(to);

+

+	index, slash := 0, 0;

+

+	for {

+		if index >= len(from) {

+			if index >= len(to) || (from_is_dir && index < len(to) && (to[index] == '/' || to[index] == '\\')) {

+				slash = index;

+			}

+

+			break;

+		}

+		else if index >= len(to) {

+			if index >= len(from) || (to_is_dir && index < len(from) && (from[index] == '/' || from[index] == '\\')) {

+				slash = index;

+			}

+

+			break;

+		}

+

+		lchar, skip := utf8.decode_rune_in_string(from[index:]);

+		rchar, _    := utf8.decode_rune_in_string(to[index:]);

+

+		if (lchar == '/' || lchar == '\\') && (rchar == '/' || lchar == '\\') {

+			slash = index;

+		}

+		else if lchar != rchar {

+			break;

+		}

+

+		index += skip;

+	}

+

+	if slash < 1 {

+		// there is no common path, use the absolute `to` path

+		return strings.clone(to, allocator);

+	}

+

+	from_slashes, to_slashes := 0, 0;

+

+	if slash < len(from) {

+		from = from[slash+1:];

+

+		if from_is_dir {

+			from_slashes += 1;

+		}

+	}

+	else {

+		from = "";

+	}

+

+	if slash < len(to) {

+		to = to[slash+1:];

+

+		if to_is_dir {

+			to_slashes += 1;

+		}

+	}

+	else {

+		to = "";

+	}

+

+	for char in from {

+		if char == '/' || char == '\\' {

+			from_slashes += 1;

+		}

+	}

+

+	for char in to {

+		if char == '/' || char == '\\' {

+			to_slashes += 1;

+		}

+	}

+

+	if from_slashes == 0 {

+		buffer := make([]byte, 2 + len(to), allocator);

+

+		buffer[0] = '.';

+		buffer[1] = SEPARATOR;

+		copy(buffer[2:], to);

+

+		return string(buffer);

+	}

+	else {

+		buffer := make([]byte, from_slashes*3 + len(to), allocator);

+

+		for i in 0..<from_slashes {

+			buffer[i*3+0] = '.';

+			buffer[i*3+1] = '.';

+			buffer[i*3+2] = SEPARATOR;

+		}

+

+		copy(buffer[from_slashes*3:], to);

+

+		return string(buffer);

+	}

+

+	return "";

 }

 

 // returns the relative path from the current directory to another path

-rel_current :: proc(to: string, allocator := context.temp_allocator) -> string {

-    return inline rel_between(current(context.temp_allocator), to, allocator);

+rel_current :: proc(to: string, allocator := context.allocator) -> string {

+	return rel_between(current(context.allocator), to, allocator);

 }

 

 

 // splits the path elements into slices of the original path string

-split :: proc(s: string, allocator := context.temp_allocator) -> []string #no_bounds_check {

-    return inline strings.split(s, []string{"\\", "/"}, true, allocator);

+split :: proc(s: string, allocator := context.allocator) -> []string {

+	return strings.split_multi(s, []string{"\\", "/"}, true, allocator);

 }

diff --git a/core/path/path_linux.odin b/core/path/path_linux.odin
deleted file mode 100644
index 83783f857..000000000
--- a/core/path/path_linux.odin
+++ /dev/null
@@ -1,80 +0,0 @@
-package path
-
-foreign import libc "system:c"
-
-import "core:os"
-import "core:strings"
-
-
-MAX :: 4096; // @note(bp): apparently PATH_MAX is bullshit
-
-SEPARATOR        :: '/';
-SEPARATOR_STRING :: "/";
-
-
-@(private)
-null_term :: proc(str: string) -> string {
-    for c, i in str {
-        if c == '\x00' {
-            return str[:i];
-        }
-    }
-    return str;
-}
-
-
-full :: proc(path: string, allocator := context.temp_allocator) -> string {
-    cpath := strings.clone_to_cstring(path, context.temp_allocator);
-    
-    foreign libc {
-        realpath :: proc(path: cstring, resolved_path: ^u8) -> cstring ---;
-    }
-
-    buf := make([dynamic]u8, MAX, MAX, allocator);
-
-    cstr := realpath(cpath, &buf[0]);
-    for cstr == nil && os.get_last_error() == int(os.ENAMETOOLONG) {
-        resize(&buf, len(buf) + MAX);
-        cstr = realpath(cpath, &buf[0]);
-    }
-
-    return null_term(string(buf[:]));
-}
-
-current :: proc(allocator := context.temp_allocator) -> string {
-    foreign libc{
-        getcwd :: proc(buf: ^u8, size: int) -> cstring ---;
-    }
-
-    buf := make([dynamic]u8, MAX, MAX, allocator);
-
-    cstr := getcwd(&buf[0], len(buf));
-    for cstr == nil && os.get_last_error() == int(os.ENAMETOOLONG) {
-        resize(&buf, len(buf) + MAX);
-        cstr = getcwd(&buf[0], len(buf));
-    }
-
-    return null_term(string(buf[:]));
-}
-
-
-exists :: proc(path: string) -> bool {
-    if _, err := os.stat(path); err != os.ERROR_NONE {
-        return true;
-    }
-    return false;
-}
-
-is_dir :: proc(path: string) -> bool {
-    if stat, err := os.stat(path); err == os.ERROR_NONE {
-        return os.S_ISDIR(stat.mode);
-    }
-    return false;
-}
-
-is_file :: proc(path: string) -> bool {
-    if stat, err := os.stat(path); err == os.ERROR_NONE {
-        return os.S_ISREG(stat.mode);
-    }
-    return false;
-}
diff --git a/core/path/path_windows.odin b/core/path/path_windows.odin
index 460e0bf27..d73681187 100644
--- a/core/path/path_windows.odin
+++ b/core/path/path_windows.odin
@@ -1,7 +1,7 @@
 package path

 

 import "core:strings"

-import "core:sys/win32"

+import win32 "core:sys/windows"

 

 

 SEPARATOR        :: '\\';

@@ -9,106 +9,106 @@ SEPARATOR_STRING :: "\\";
 

 

 @(private)

-null_term :: proc"contextless"(str: string) -> string {

-    for c, i in str {

-        if c == '\x00' {

-            return str[:i];

-        }

-    }

-    return str;

+null_term :: proc "contextless" (str: string) -> string {

+	for c, i in str {

+		if c == '\x00' {

+			return str[:i];

+		}

+	}

+	return str;

 }

 

 

 long :: proc(path: string, allocator := context.temp_allocator) -> string {

-    c_path := win32.utf8_to_wstring(path, context.temp_allocator);

-    length := win32.get_long_path_name_w(c_path, nil, 0);

+	c_path := win32.utf8_to_wstring(path, context.temp_allocator);

+	length := win32.GetLongPathNameW(c_path, nil, 0);

 

-    if length == 0 do return "";

+	if length == 0 do return "";

 

-    buf := make([]u16, length, context.temp_allocator);

+	buf := make([]u16, length, context.temp_allocator);

 

-    win32.get_long_path_name_w(c_path, win32.Wstring(&buf[0]), length);

+	win32.GetLongPathNameW(c_path, win32.LPCWSTR(&buf[0]), length);

 

-    res := win32.ucs2_to_utf8(buf[:length], allocator);

+	res := win32.utf16_to_utf8(buf[:length], allocator);

 

-    return null_term(res);

+	return null_term(res);

 }

 

 short :: proc(path: string, allocator := context.temp_allocator) -> string {

-    c_path := win32.utf8_to_wstring(path, context.temp_allocator);

-    length := win32.get_short_path_name_w(c_path, nil, 0);

+	c_path := win32.utf8_to_wstring(path, context.temp_allocator);

+	length := win32.GetShortPathNameW(c_path, nil, 0);

 

-    if length == 0 do return "";

-    

-    buf := make([]u16, length, context.temp_allocator);

+	if length == 0 do return "";

 

-    win32.get_short_path_name_w(c_path, win32.Wstring(&buf[0]), length);

+	buf := make([]u16, length, context.temp_allocator);

 

-    res := win32.ucs2_to_utf8(buf[:length], allocator);

+	win32.GetShortPathNameW(c_path, win32.LPCWSTR(&buf[0]), length);

 

-    return null_term(res);

+	res := win32.utf16_to_utf8(buf[:length], allocator);

+

+	return null_term(res);

 }

 

 full :: proc(path: string, allocator := context.temp_allocator) -> string {

-    c_path := win32.utf8_to_wstring(path, context.temp_allocator);

-    length := win32.get_full_path_name_w(c_path, 0, nil, nil);

+	c_path := win32.utf8_to_wstring(path, context.temp_allocator);

+	length := win32.GetFullPathNameW(c_path, 0, nil, nil);

 

-    if length == 0 do return "";

+	if length == 0 do return "";

 

-    buf := make([]u16, length, context.temp_allocator);

+	buf := make([]u16, length, context.temp_allocator);

 

-    win32.get_full_path_name_w(c_path, length, win32.Wstring(&buf[0]), nil);

+	win32.GetFullPathNameW(c_path, length, win32.LPCWSTR(&buf[0]), nil);

 

-    res := win32.ucs2_to_utf8(buf[:length], allocator);

+	res := win32.utf16_to_utf8(buf[:length], allocator);

 

-    return null_term(res);

+	return null_term(res);

 }

 

 current :: proc(allocator := context.temp_allocator) -> string {

-    length := win32.get_current_directory_w(0, nil);

+	length := win32.GetCurrentDirectoryW(0, nil);

 

-    if length == 0 do return "";

+	if length == 0 do return "";

 

-    buf := make([]u16, length, context.temp_allocator);

+	buf := make([]u16, length, context.temp_allocator);

 

-    win32.get_current_directory_w(length, win32.Wstring(&buf[0]));

+	win32.GetCurrentDirectoryW(length, win32.LPCWSTR(&buf[0]));

 

-    res := win32.ucs2_to_utf8(buf[:length], allocator);

+	res := win32.utf16_to_utf8(buf[:length], allocator);

 

-    return strings.trim_null(res);

+	return strings.trim_null(res);

 }

 

 

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

-    c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

-    attribs := win32.get_file_attributes_w(c_path);

+	c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

+	attribs := win32.GetFileAttributesW(c_path);

 

-    return i32(attribs) != win32.INVALID_FILE_ATTRIBUTES;

+	return i32(attribs) != win32.INVALID_FILE_ATTRIBUTES;

 }

 

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

-    c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

-    attribs := win32.get_file_attributes_w(c_path);

+	c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

+	attribs := win32.GetFileAttributesW(c_path);

 

-    return (i32(attribs) != win32.INVALID_FILE_ATTRIBUTES) && (attribs & win32.FILE_ATTRIBUTE_DIRECTORY == win32.FILE_ATTRIBUTE_DIRECTORY);

+	return (i32(attribs) != win32.INVALID_FILE_ATTRIBUTES) && (attribs & win32.FILE_ATTRIBUTE_DIRECTORY == win32.FILE_ATTRIBUTE_DIRECTORY);

 }

 

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

-    c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

-    attribs := win32.get_file_attributes_w(c_path);

+	c_path  := win32.utf8_to_wstring(path, context.temp_allocator);

+	attribs := win32.GetFileAttributesW(c_path);

 

-    return (i32(attribs) != win32.INVALID_FILE_ATTRIBUTES) && (attribs & win32.FILE_ATTRIBUTE_DIRECTORY != win32.FILE_ATTRIBUTE_DIRECTORY);

+	return (i32(attribs) != win32.INVALID_FILE_ATTRIBUTES) && (attribs & win32.FILE_ATTRIBUTE_DIRECTORY != win32.FILE_ATTRIBUTE_DIRECTORY);

 }

 

 

 drive :: proc(path: string, new := false, allocator := context.allocator) -> string {

-    if len(path) >= 3 {

-        letter := path[:2];

+	if len(path) >= 3 {

+		letter := path[:2];

 

-        if path[1] == ':' && (path[2] == '\\' || path[2] == '/') {

-            return new ? strings.new_string(path[:2], allocator) : path[:2];

-        }

-    }

+		if path[1] == ':' && (path[2] == '\\' || path[2] == '/') {

+			return new ? strings.clone(path[:2], allocator) : path[:2];

+		}

+	}

 

-    return "";

+	return "";

 }