wehub-resource-sync
e7738de6d2
CI / Deep Native Runtime Cases (1/6) (push) Has been skipped
CI / Native Preflight (push) Failing after 1s
CI / Native Runtime Cases (1/2) (push) Failing after 0s
CI / Native Runtime Cases (2/2) (push) Failing after 1s
CI / Native Metadata Reports (push) Failing after 0s
CI / Native Direct Backend Artifacts (push) Failing after 0s
CI / Native Sanitizer Smoke (push) Failing after 1s
CI / Command Contract Snapshots (push) Failing after 1s
CI / Deep Conformance Suite (push) Has been skipped
CI / Graph Build Perf (push) Failing after 1s
CI / Deep Native Preflight (push) Has been skipped
CI / Deep Native Runtime Cases (2/6) (push) Has been skipped
CI / Deep Native Runtime Cases (3/6) (push) Has been skipped
CI / Conformance Suite (push) Failing after 1s
CI / Workspace Checks (push) Failing after 0s
CI / Deep Native Runtime Cases (5/6) (push) Has been skipped
CI / Deep Native Runtime Cases (6/6) (push) Has been skipped
CI / Deep Native Runtime Cases (4/6) (push) Has been skipped
CI / Deep Graph Build Perf (push) Has been skipped
366 lines
11 KiB
Plaintext
366 lines
11 KiB
Plaintext
fn __zero_std_path_is_sep(byte: u8) -> Bool {
|
|
return byte == 47_u8 || byte == 92_u8
|
|
}
|
|
|
|
fn __zero_std_path_is_abs(path: String) -> Bool {
|
|
return std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0])
|
|
}
|
|
|
|
fn __zero_std_path_segment_end(path: String, index: usize) -> Bool {
|
|
return index >= std.mem.len(path) || __zero_std_path_is_sep(path[index])
|
|
}
|
|
|
|
fn __zero_std_path_trim_end(path: String) -> usize {
|
|
var end: usize = std.mem.len(path)
|
|
while end > 0 && __zero_std_path_is_sep(path[end - 1]) {
|
|
end = end - 1
|
|
}
|
|
return end
|
|
}
|
|
|
|
fn __zero_std_path_basename(path: String) -> String {
|
|
let end: usize = __zero_std_path_trim_end(path)
|
|
var start: usize = end
|
|
while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
|
|
start = start - 1
|
|
}
|
|
return path[start..end]
|
|
}
|
|
|
|
fn __zero_std_path_dirname(path: String) -> String {
|
|
let end: usize = __zero_std_path_trim_end(path)
|
|
var root_len: usize = 0
|
|
if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {
|
|
root_len = 1
|
|
}
|
|
if root_len > 0 && end == 0 {
|
|
return path[..root_len]
|
|
}
|
|
var split: usize = end
|
|
while split > 0 && !__zero_std_path_is_sep(path[split - 1]) {
|
|
split = split - 1
|
|
}
|
|
while split > root_len && __zero_std_path_is_sep(path[split - 1]) {
|
|
split = split - 1
|
|
}
|
|
return path[..split]
|
|
}
|
|
|
|
fn __zero_std_path_extension(path: String) -> String {
|
|
let end: usize = __zero_std_path_trim_end(path)
|
|
var start: usize = end
|
|
while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
|
|
start = start - 1
|
|
}
|
|
var dot: usize = end
|
|
var scan: usize = end
|
|
while scan > start {
|
|
scan = scan - 1
|
|
if path[scan] == 46_u8 {
|
|
dot = scan
|
|
scan = start
|
|
}
|
|
}
|
|
if dot == end {
|
|
return path[end..end]
|
|
}
|
|
if dot == start {
|
|
return path[end..end]
|
|
}
|
|
return path[dot + 1..end]
|
|
}
|
|
|
|
fn __zero_std_path_stem(path: String) -> String {
|
|
let end: usize = __zero_std_path_trim_end(path)
|
|
var start: usize = end
|
|
while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
|
|
start = start - 1
|
|
}
|
|
var dot: usize = end
|
|
var scan: usize = end
|
|
while scan > start {
|
|
scan = scan - 1
|
|
if path[scan] == 46_u8 {
|
|
dot = scan
|
|
scan = start
|
|
}
|
|
}
|
|
if dot == end {
|
|
return path[start..end]
|
|
}
|
|
if dot == start {
|
|
return path[start..end]
|
|
}
|
|
if end - start == 2 && path[start] == 46_u8 && path[start + 1] == 46_u8 {
|
|
return path[start..end]
|
|
}
|
|
return path[start..dot]
|
|
}
|
|
|
|
fn __zero_std_path_split_dir(path: String) -> String {
|
|
return __zero_std_path_dirname(path)
|
|
}
|
|
|
|
fn __zero_std_path_split_base(path: String) -> String {
|
|
return __zero_std_path_basename(path)
|
|
}
|
|
|
|
fn __zero_std_path_component_count(path: String) -> usize {
|
|
var count: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(path) {
|
|
while index < std.mem.len(path) && __zero_std_path_is_sep(path[index]) {
|
|
index = index + 1
|
|
}
|
|
if index < std.mem.len(path) {
|
|
count = count + 1
|
|
while index < std.mem.len(path) && !__zero_std_path_is_sep(path[index]) {
|
|
index = index + 1
|
|
}
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
fn __zero_std_path_component(path: String, component_index: usize) -> Maybe<String> {
|
|
var count: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(path) {
|
|
while index < std.mem.len(path) && __zero_std_path_is_sep(path[index]) {
|
|
index = index + 1
|
|
}
|
|
if index < std.mem.len(path) {
|
|
let start: usize = index
|
|
while index < std.mem.len(path) && !__zero_std_path_is_sep(path[index]) {
|
|
index = index + 1
|
|
}
|
|
if count == component_index {
|
|
return path[start..index]
|
|
}
|
|
count = count + 1
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_path_abs(buffer: MutSpan<u8>, base: String, target: String) -> Maybe<String> {
|
|
if __zero_std_path_is_abs(target) {
|
|
return __zero_std_path_copy(buffer, target)
|
|
}
|
|
var base_end: usize = __zero_std_path_trim_end(base)
|
|
if base_end == 0 && (std.mem.len(base) > 0 && __zero_std_path_is_sep(base[0])) {
|
|
base_end = 1
|
|
}
|
|
let base_is_root: Bool = base_end == 1 && __zero_std_path_is_sep(base[0])
|
|
let target_len: usize = std.mem.len(target)
|
|
var total: usize = base_end + target_len
|
|
if base_end > 0 && target_len > 0 && !base_is_root {
|
|
total = total + 1
|
|
}
|
|
if total > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var out: usize = 0
|
|
while out < base_end {
|
|
if base_is_root && out == 0 {
|
|
buffer[out] = 47_u8
|
|
} else {
|
|
buffer[out] = base[out]
|
|
}
|
|
out = out + 1
|
|
}
|
|
if base_end > 0 && target_len > 0 && !base_is_root {
|
|
buffer[out] = 47_u8
|
|
out = out + 1
|
|
}
|
|
var read: usize = 0
|
|
while read < target_len {
|
|
buffer[out] = target[read]
|
|
out = out + 1
|
|
read = read + 1
|
|
}
|
|
return buffer[..out]
|
|
}
|
|
|
|
fn __zero_std_path_copy(buffer: MutSpan<u8>, source: String) -> Maybe<String> {
|
|
let len: usize = std.mem.len(source)
|
|
if len > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var index: usize = 0
|
|
while index < len {
|
|
buffer[index] = source[index]
|
|
index = index + 1
|
|
}
|
|
return buffer[..len]
|
|
}
|
|
|
|
fn __zero_std_path_join(buffer: MutSpan<u8>, left: String, right: String) -> Maybe<String> {
|
|
var left_end: usize = __zero_std_path_trim_end(left)
|
|
if left_end == 0 && (std.mem.len(left) > 0 && __zero_std_path_is_sep(left[0])) {
|
|
left_end = 1
|
|
}
|
|
let left_is_root: Bool = left_end == 1 && __zero_std_path_is_sep(left[0])
|
|
let right_is_root: Bool = std.mem.len(right) > 0 && __zero_std_path_is_sep(right[0])
|
|
var right_start: usize = 0
|
|
while right_start < std.mem.len(right) && __zero_std_path_is_sep(right[right_start]) {
|
|
right_start = right_start + 1
|
|
}
|
|
let right_len: usize = std.mem.len(right) - right_start
|
|
var total: usize = left_end + right_len
|
|
if left_end == 0 && right_is_root {
|
|
total = total + 1
|
|
}
|
|
if left_end > 0 && right_len > 0 && !left_is_root {
|
|
total = total + 1
|
|
}
|
|
if total > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var out: usize = 0
|
|
while out < left_end {
|
|
if left_is_root && out == 0 {
|
|
buffer[out] = 47_u8
|
|
} else {
|
|
buffer[out] = left[out]
|
|
}
|
|
out = out + 1
|
|
}
|
|
if left_end == 0 && right_is_root {
|
|
buffer[out] = 47_u8
|
|
out = out + 1
|
|
}
|
|
if left_end > 0 && right_len > 0 && !left_is_root {
|
|
buffer[out] = 47_u8
|
|
out = out + 1
|
|
}
|
|
var read: usize = right_start
|
|
while read < std.mem.len(right) {
|
|
buffer[out] = right[read]
|
|
out = out + 1
|
|
read = read + 1
|
|
}
|
|
return buffer[..out]
|
|
}
|
|
|
|
fn __zero_std_path_output_ends_parent(buffer: MutSpan<u8>, out: usize, root_len: usize) -> Bool {
|
|
if out <= root_len {
|
|
return false
|
|
}
|
|
var segment_start: usize = out
|
|
while segment_start > root_len && !__zero_std_path_is_sep(buffer[segment_start - 1]) {
|
|
segment_start = segment_start - 1
|
|
}
|
|
let segment_len: usize = out - segment_start
|
|
if segment_len != 2 {
|
|
return false
|
|
}
|
|
return buffer[segment_start] == 46_u8 && buffer[segment_start + 1] == 46_u8
|
|
}
|
|
|
|
fn __zero_std_path_normalize(buffer: MutSpan<u8>, path: String) -> Maybe<String> {
|
|
var read: usize = 0
|
|
var out: usize = 0
|
|
var root_len: usize = 0
|
|
if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 47_u8
|
|
out = 1
|
|
root_len = 1
|
|
read = 1
|
|
}
|
|
while read < std.mem.len(path) {
|
|
while read < std.mem.len(path) && __zero_std_path_is_sep(path[read]) {
|
|
read = read + 1
|
|
}
|
|
if read < std.mem.len(path) {
|
|
let segment_start: usize = read
|
|
while read < std.mem.len(path) && !__zero_std_path_is_sep(path[read]) {
|
|
read = read + 1
|
|
}
|
|
let segment_end: usize = read
|
|
let segment_len: usize = segment_end - segment_start
|
|
if segment_len == 1 && path[segment_start] == 46_u8 {
|
|
read = segment_end
|
|
} else if segment_len == 2 && path[segment_start] == 46_u8 && path[segment_start + 1] == 46_u8 {
|
|
if root_len == 1 && out == root_len {
|
|
read = segment_end
|
|
} else if out > root_len && !__zero_std_path_output_ends_parent(buffer, out, root_len) {
|
|
while out > root_len && !__zero_std_path_is_sep(buffer[out - 1]) {
|
|
out = out - 1
|
|
}
|
|
if out > root_len && __zero_std_path_is_sep(buffer[out - 1]) {
|
|
out = out - 1
|
|
}
|
|
} else {
|
|
var needed: usize = segment_len
|
|
if out > root_len {
|
|
needed = needed + 1
|
|
}
|
|
if out + needed > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
if out > root_len {
|
|
buffer[out] = 47_u8
|
|
out = out + 1
|
|
}
|
|
var copy: usize = segment_start
|
|
while copy < segment_end {
|
|
buffer[out] = path[copy]
|
|
out = out + 1
|
|
copy = copy + 1
|
|
}
|
|
}
|
|
} else {
|
|
var needed: usize = segment_len
|
|
if out > root_len {
|
|
needed = needed + 1
|
|
}
|
|
if out + needed > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
if out > root_len {
|
|
buffer[out] = 47_u8
|
|
out = out + 1
|
|
}
|
|
var copy: usize = segment_start
|
|
while copy < segment_end {
|
|
buffer[out] = path[copy]
|
|
out = out + 1
|
|
copy = copy + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return buffer[..out]
|
|
}
|
|
|
|
fn __zero_std_path_relative(buffer: MutSpan<u8>, base: String, target: String) -> Maybe<String> {
|
|
let base_end: usize = __zero_std_path_trim_end(base)
|
|
let target_len: usize = std.mem.len(target)
|
|
let base_prefix: String = base[..base_end]
|
|
let base_matches: Bool = std.str.startsWith(target, base_prefix)
|
|
if base_matches && base_end == target_len {
|
|
return buffer[..0]
|
|
}
|
|
if base_matches && base_end < target_len {
|
|
if __zero_std_path_is_sep(target[base_end]) {
|
|
var out: usize = 0
|
|
var read: usize = base_end + 1
|
|
let rel_len: usize = target_len - read
|
|
if rel_len > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
while read < target_len {
|
|
buffer[out] = target[read]
|
|
out = out + 1
|
|
read = read + 1
|
|
}
|
|
return buffer[..out]
|
|
}
|
|
}
|
|
return __zero_std_path_copy(buffer, target)
|
|
}
|