400 lines
14 KiB
Plaintext
400 lines
14 KiB
Plaintext
// Expect retcode = 0
|
|
|
|
// 纯词法路径工具，不访问文件系统。调用方必须显式选择 POSIX 或 Windows 规则；
|
|
// 输入视图均为借用，拥有型结果写入 ByteBuffer，失败保持原输出不变。
|
|
type .{ .Status, .make } = @import("error.spl");
|
|
type .{ .ByteView } = @import("byte_view.spl");
|
|
type .{ .ByteBuffer } = @import("byte_buffer.spl");
|
|
type .{ .Vec } = @import("vec.spl");
|
|
type .{ .is_alpha } = @import("ascii.spl");
|
|
|
|
type PathStyle = enum { Posix, Windows }
|
|
|
|
fn is_windows(style: PathStyle): bool {
|
|
match style { .Posix => { ret false; }, .Windows => { ret true; }, }
|
|
ret false;
|
|
}
|
|
|
|
fn separator(style: PathStyle): u8 {
|
|
if is_windows(style) { ret '\\'; }
|
|
ret '/';
|
|
}
|
|
|
|
fn is_sep(style: PathStyle, byte: u8): bool {
|
|
if is_windows(style) { ret byte == '/' || byte == '\\'; }
|
|
ret byte == '/';
|
|
}
|
|
|
|
fn is_drive_prefix(path: ByteView): bool {
|
|
ret path.len >= 2 && is_alpha(path.ptr[0]) && path.ptr[1] == ':';
|
|
}
|
|
|
|
fn is_unc(path: ByteView, style: PathStyle): bool {
|
|
ret is_windows(style) && path.len >= 2 &&
|
|
is_sep(style, path.ptr[0]) && is_sep(style, path.ptr[1]);
|
|
}
|
|
|
|
fn is_absolute(path: ByteView, style: PathStyle): bool {
|
|
if path.len == 0 { ret false; }
|
|
if !is_windows(style) { ret path.ptr[0] == '/'; }
|
|
if is_unc(path, style) { ret true; }
|
|
if is_drive_prefix(path) {
|
|
ret path.len >= 3 && is_sep(style, path.ptr[2]);
|
|
}
|
|
// 根相对路径以当前盘符为根，本模块将其视为绝对。
|
|
ret is_sep(style, path.ptr[0]);
|
|
}
|
|
|
|
// UNC 根长度不含共享名后的分隔符；不完整时返回 0。
|
|
fn unc_root_len(path: ByteView, style: PathStyle): usize {
|
|
if !is_unc(path, style) { ret 0; }
|
|
var i: usize = 2;
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
var server = i;
|
|
while i < path.len && !is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
if i == server { ret 0; }
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
var share = i;
|
|
while i < path.len && !is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
if i == share { ret 0; }
|
|
ret i;
|
|
}
|
|
|
|
fn root_len(path: ByteView, style: PathStyle): usize {
|
|
if path.len == 0 { ret 0; }
|
|
if !is_windows(style) {
|
|
if path.ptr[0] == '/' { ret 1; }
|
|
ret 0;
|
|
}
|
|
var unc = unc_root_len(path, style);
|
|
if unc != 0 { ret unc; }
|
|
if is_drive_prefix(path) {
|
|
if path.len >= 3 && is_sep(style, path.ptr[2]) { ret 3; }
|
|
ret 2;
|
|
}
|
|
if is_sep(style, path.ptr[0]) { ret 1; }
|
|
ret 0;
|
|
}
|
|
|
|
fn last_sep(path: ByteView, style: PathStyle): usize {
|
|
var i = path.len;
|
|
while i > 0 {
|
|
i = i - 1;
|
|
if is_sep(style, path.ptr[i]) { ret i; }
|
|
}
|
|
ret ~(0 as usize);
|
|
}
|
|
|
|
fn slice_or_empty(path: ByteView, start: usize, end: usize): ByteView {
|
|
match ByteView.slice(path, start, end) {
|
|
.Ok(value) => { ret value; },
|
|
.Err(error) => { ret ByteView.empty(); },
|
|
}
|
|
ret ByteView.empty();
|
|
}
|
|
|
|
fn dirname(path: ByteView, style: PathStyle): ByteView {
|
|
var root = root_len(path, style);
|
|
if root != 0 && path.len == root { ret path; }
|
|
var index = last_sep(path, style);
|
|
if index == ~(0 as usize) {
|
|
if is_windows(style) && is_drive_prefix(path) {
|
|
ret slice_or_empty(path, 0, 2);
|
|
}
|
|
ret ByteView.empty();
|
|
}
|
|
if root != 0 && index <= root { ret slice_or_empty(path, 0, root); }
|
|
if index == 0 { ret slice_or_empty(path, 0, 1); }
|
|
ret slice_or_empty(path, 0, index);
|
|
}
|
|
|
|
fn basename(path: ByteView, style: PathStyle): ByteView {
|
|
var root = root_len(path, style);
|
|
if root != 0 && path.len == root { ret ByteView.empty(); }
|
|
var index = last_sep(path, style);
|
|
if index == ~(0 as usize) {
|
|
if is_windows(style) && is_drive_prefix(path) {
|
|
ret slice_or_empty(path, 2, path.len);
|
|
}
|
|
ret path;
|
|
}
|
|
ret slice_or_empty(path, index + 1, path.len);
|
|
}
|
|
|
|
fn extension(path: ByteView, style: PathStyle): ByteView {
|
|
var base = basename(path, style);
|
|
var i = base.len;
|
|
while i > 0 {
|
|
i = i - 1;
|
|
if base.ptr[i] == '.' {
|
|
if i == 0 { ret ByteView.empty(); }
|
|
ret slice_or_empty(base, i + 1, base.len);
|
|
}
|
|
}
|
|
ret ByteView.empty();
|
|
}
|
|
|
|
// Windows 盘符相对路径依赖进程的盘符工作目录，join 明确拒绝该歧义。
|
|
fn join_into(out: *ByteBuffer, dir: ByteView,
|
|
rel: ByteView, style: PathStyle): Status {
|
|
if out == null { ret .Err(make(.InvalidArgument)); }
|
|
var fresh = ByteBuffer.new();
|
|
if is_absolute(rel, style) {
|
|
match ByteBuffer.append(&fresh, ByteView.as_slice(rel)) {
|
|
.Ok => {}, .Err(error) => { ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
ByteBuffer.drop(out);
|
|
out.* = ByteBuffer.take(&fresh);
|
|
ret .Ok;
|
|
}
|
|
if is_windows(style) && is_drive_prefix(rel) {
|
|
ByteBuffer.drop(&fresh);
|
|
ret .Err(make(.InvalidArgument));
|
|
}
|
|
match ByteBuffer.append(&fresh, ByteView.as_slice(dir)) {
|
|
.Ok => {}, .Err(error) => { ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
var drive_relative_base = is_windows(style) && dir.len == 2 && is_drive_prefix(dir);
|
|
if dir.len != 0 && !is_sep(style, dir.ptr[dir.len - 1]) && rel.len != 0 &&
|
|
!drive_relative_base {
|
|
match ByteBuffer.append_byte(&fresh, separator(style)) {
|
|
.Ok => {}, .Err(error) => { ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
}
|
|
match ByteBuffer.append(&fresh, ByteView.as_slice(rel)) {
|
|
.Ok => {}, .Err(error) => { ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
ByteBuffer.drop(out);
|
|
out.* = ByteBuffer.take(&fresh);
|
|
ret .Ok;
|
|
}
|
|
|
|
fn segment_is_parent(buffer: ByteBuffer, rollback: usize, style: PathStyle): bool {
|
|
var start = rollback;
|
|
if start < buffer.storage.len && is_sep(style, buffer.storage.data[start]) {
|
|
start = start + 1;
|
|
}
|
|
ret buffer.storage.len - start == 2 &&
|
|
buffer.storage.data[start] == '.' && buffer.storage.data[start + 1] == '.';
|
|
}
|
|
|
|
fn append_segment(out: *ByteBuffer, starts: *Vec,
|
|
segment: ByteView, style: PathStyle): Status {
|
|
var rollback = out.storage.len;
|
|
if rollback != 0 && !is_sep(style, out.storage.data[rollback - 1]) &&
|
|
!(is_windows(style) && out.storage.data[rollback - 1] == ':') {
|
|
match ByteBuffer.append_byte(out, separator(style)) {
|
|
.Ok => {}, .Err(error) => { ret .Err(error); },
|
|
}
|
|
}
|
|
match Vec.push(starts, &rollback as *u8) {
|
|
.Ok => {},
|
|
.Err(error) => { out.storage.len = rollback; ret .Err(error); },
|
|
}
|
|
match ByteBuffer.append(out, ByteView.as_slice(segment)) {
|
|
.Ok => {},
|
|
.Err(error) => {
|
|
starts.len = starts.len - 1;
|
|
out.storage.len = rollback;
|
|
ret .Err(error);
|
|
},
|
|
}
|
|
ret .Ok;
|
|
}
|
|
|
|
// 规范化分隔符并折叠 '.'/'..'。相对路径无法消去的前导 '..' 会被保留；
|
|
// 绝对路径的 '..' 不会越过根，UNC 的 server/share 也不可被消去。
|
|
fn normalize_into(out: *ByteBuffer, path: ByteView, style: PathStyle): Status {
|
|
if out == null { ret .Err(make(.InvalidArgument)); }
|
|
var fresh = ByteBuffer.new();
|
|
var starts = Vec.blank(@sizeof(usize), @alignof(usize));
|
|
var i: usize = 0;
|
|
var absolute = false;
|
|
var protected: usize = 0;
|
|
|
|
if path.len != 0 {
|
|
if !is_windows(style) && path.ptr[0] == '/' {
|
|
absolute = true;
|
|
match ByteBuffer.append_byte(&fresh, '/') {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
} else if is_unc(path, style) {
|
|
absolute = true;
|
|
protected = 2;
|
|
match ByteBuffer.append(&fresh, "\\\\") {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
i = 2;
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
} else if is_windows(style) && is_drive_prefix(path) {
|
|
match ByteBuffer.append(&fresh, path.ptr[0..2]) {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
i = 2;
|
|
if i < path.len && is_sep(style, path.ptr[i]) {
|
|
absolute = true;
|
|
match ByteBuffer.append_byte(&fresh, '\\') {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
}
|
|
} else if is_windows(style) && is_sep(style, path.ptr[0]) {
|
|
absolute = true;
|
|
match ByteBuffer.append_byte(&fresh, '\\') {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
}
|
|
}
|
|
|
|
while i < path.len {
|
|
while i < path.len && is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
if i >= path.len { break; }
|
|
var begin = i;
|
|
while i < path.len && !is_sep(style, path.ptr[i]) { i = i + 1; }
|
|
var segment = slice_or_empty(path, begin, i);
|
|
|
|
if ByteView.eq(segment, ByteView.from_slice(".")) {
|
|
if protected != 0 && starts.len < protected {
|
|
Vec.drop(&starts); ByteBuffer.drop(&fresh);
|
|
ret .Err(make(.InvalidArgument));
|
|
}
|
|
continue;
|
|
}
|
|
if ByteView.eq(segment, ByteView.from_slice("..")) {
|
|
if protected != 0 && starts.len < protected {
|
|
Vec.drop(&starts); ByteBuffer.drop(&fresh);
|
|
ret .Err(make(.InvalidArgument));
|
|
}
|
|
if starts.len > protected {
|
|
var last: usize = 0;
|
|
match Vec.get(&starts, starts.len - 1) {
|
|
.Ok(ptr) => { last = (ptr as *usize).*; },
|
|
.Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
if !segment_is_parent(fresh, last, style) {
|
|
fresh.storage.len = last;
|
|
starts.len = starts.len - 1;
|
|
continue;
|
|
}
|
|
}
|
|
if absolute { continue; }
|
|
}
|
|
|
|
match append_segment(&fresh, &starts, segment, style) {
|
|
.Ok => {}, .Err(error) => { Vec.drop(&starts); ByteBuffer.drop(&fresh); ret .Err(error); },
|
|
}
|
|
}
|
|
|
|
if protected != 0 && starts.len < protected {
|
|
Vec.drop(&starts); ByteBuffer.drop(&fresh);
|
|
ret .Err(make(.InvalidArgument));
|
|
}
|
|
Vec.drop(&starts);
|
|
ByteBuffer.drop(out);
|
|
out.* = ByteBuffer.take(&fresh);
|
|
ret .Ok;
|
|
}
|
|
|
|
fn expect_ok(result: Status) {
|
|
match result { .Ok => {}, .Err(error) => { @assert(false, "unexpected path error"); }, }
|
|
}
|
|
|
|
fn expect_invalid(result: Status) {
|
|
match result {
|
|
.Ok => { @assert(false, "expected invalid path"); },
|
|
.Err(error) => {
|
|
match error.kind { .InvalidArgument => {}, _ => { @assert(false); }, }
|
|
},
|
|
}
|
|
}
|
|
|
|
fn view(text: []u8): ByteView { ret ByteView.from_slice(text); }
|
|
|
|
fn expect_view(got: ByteView, expected: []u8) {
|
|
@assert(ByteView.eq(got, view(expected)), "path view");
|
|
}
|
|
|
|
fn expect_out(out: *ByteBuffer, expected: []u8) {
|
|
var actual = ByteBuffer.as_slice(out.*);
|
|
@assert(actual.len == expected.len, "path output length");
|
|
var i: usize = 0;
|
|
while i < expected.len {
|
|
@assert(actual.ptr[i] == expected.ptr[i], "path output byte");
|
|
i = i + 1;
|
|
}
|
|
}
|
|
|
|
fn test_style_and_parts() {
|
|
@assert(is_absolute(view("/a"), .Posix));
|
|
@assert(!is_absolute(view("\\a"), .Posix));
|
|
@assert(is_absolute(view("C:\\a"), .Windows));
|
|
@assert(!is_absolute(view("C:a"), .Windows));
|
|
@assert(is_absolute(view("\\\\server\\share\\a"), .Windows));
|
|
@assert(!is_absolute(view("C:/a"), .Posix));
|
|
expect_view(dirname(view("/a/b"), .Posix), "/a");
|
|
expect_view(dirname(view("/a"), .Posix), "/");
|
|
expect_view(basename(view("/a/b"), .Posix), "b");
|
|
expect_view(extension(view("a/b.spl"), .Posix), "spl");
|
|
expect_view(extension(view("a/.hidden"), .Posix), "");
|
|
expect_view(dirname(view("C:\\a"), .Windows), "C:\\");
|
|
expect_view(basename(view("C:\\a"), .Windows), "a");
|
|
expect_view(dirname(view("C:relative"), .Windows), "C:");
|
|
expect_view(basename(view("C:relative"), .Windows), "relative");
|
|
expect_view(dirname(view("\\\\server\\share\\file"), .Windows),
|
|
"\\\\server\\share");
|
|
}
|
|
|
|
fn test_join() {
|
|
var out = ByteBuffer.new();
|
|
defer { ByteBuffer.drop(&out); }
|
|
expect_ok(join_into(&out, view("stage2/utils"), view("vec.spl"), .Posix));
|
|
expect_out(&out, "stage2/utils/vec.spl");
|
|
expect_ok(join_into(&out, view("C:\\base"), view("child\\x"), .Windows));
|
|
expect_out(&out, "C:\\base\\child\\x");
|
|
expect_ok(join_into(&out, view("C:"), view("child"), .Windows));
|
|
expect_out(&out, "C:child");
|
|
expect_ok(join_into(&out, view("ignored"), view("D:/abs"), .Windows));
|
|
expect_out(&out, "D:/abs");
|
|
expect_invalid(join_into(&out, view("C:\\base"), view("D:relative"), .Windows));
|
|
expect_out(&out, "D:/abs");
|
|
}
|
|
|
|
fn test_normalize_posix() {
|
|
var out = ByteBuffer.new();
|
|
defer { ByteBuffer.drop(&out); }
|
|
expect_ok(normalize_into(&out, view("a/b/../c"), .Posix));
|
|
expect_out(&out, "a/c");
|
|
expect_ok(normalize_into(&out, view("../../a/./b"), .Posix));
|
|
expect_out(&out, "../../a/b");
|
|
expect_ok(normalize_into(&out, view("/../../a//b"), .Posix));
|
|
expect_out(&out, "/a/b");
|
|
expect_ok(normalize_into(&out, view("a\\b/../c"), .Posix));
|
|
expect_out(&out, "c");
|
|
}
|
|
|
|
fn test_normalize_windows() {
|
|
var out = ByteBuffer.new();
|
|
defer { ByteBuffer.drop(&out); }
|
|
expect_ok(normalize_into(&out, view("C:/a\\b/../c"), .Windows));
|
|
expect_out(&out, "C:\\a\\c");
|
|
expect_ok(normalize_into(&out, view("C:foo\\..\\bar"), .Windows));
|
|
expect_out(&out, "C:bar");
|
|
expect_ok(normalize_into(&out, view("\\root\\..\\file"), .Windows));
|
|
expect_out(&out, "\\file");
|
|
expect_ok(normalize_into(&out,
|
|
view("\\\\server\\share\\a\\..\\file"), .Windows));
|
|
expect_out(&out, "\\\\server\\share\\file");
|
|
expect_ok(ByteBuffer.assign(&out, "preserved"));
|
|
expect_invalid(normalize_into(&out, view("\\\\server\\..\\file"), .Windows));
|
|
expect_out(&out, "preserved");
|
|
}
|
|
|
|
fn main() {
|
|
test_style_and_parts();
|
|
test_join();
|
|
test_normalize_posix();
|
|
test_normalize_windows();
|
|
}
|