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
492 lines
15 KiB
Plaintext
492 lines
15 KiB
Plaintext
fn __zero_std_url_is_unreserved(byte: u8) -> Bool {
|
|
return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8) || (byte >= 48_u8 && byte <= 57_u8) || byte == 45_u8 || byte == 46_u8 || byte == 95_u8 || byte == 126_u8
|
|
}
|
|
|
|
fn __zero_std_url_hex_char(value: u8) -> u8 {
|
|
if value < 10_u8 {
|
|
return 48_u8 + value
|
|
}
|
|
return 65_u8 + value - 10_u8
|
|
}
|
|
|
|
fn __zero_std_url_percent_encode(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
|
|
var input: usize = 0
|
|
var output: usize = 0
|
|
while input < std.mem.len(text) {
|
|
let byte: u8 = text[input]
|
|
if __zero_std_url_is_unreserved(byte) {
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = byte
|
|
output = output + 1
|
|
} else {
|
|
if output + 3 > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = 37_u8
|
|
buffer[output + 1] = __zero_std_url_hex_char(byte / 16_u8)
|
|
buffer[output + 2] = __zero_std_url_hex_char(byte % 16_u8)
|
|
output = output + 3
|
|
}
|
|
input = input + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_percent_decode(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
|
|
var input: usize = 0
|
|
var output: usize = 0
|
|
while input < std.mem.len(text) {
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
let byte: u8 = text[input]
|
|
if byte == 37_u8 {
|
|
if input + 2 >= std.mem.len(text) {
|
|
return null
|
|
}
|
|
let high: Maybe<u8> = std.ascii.hexValue(text[input + 1])
|
|
let low: Maybe<u8> = std.ascii.hexValue(text[input + 2])
|
|
if !high.has || !low.has {
|
|
return null
|
|
}
|
|
buffer[output] = high.value * 16_u8 + low.value
|
|
input = input + 3
|
|
} else {
|
|
buffer[output] = byte
|
|
input = input + 1
|
|
}
|
|
output = output + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_query_escape(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
|
|
var input: usize = 0
|
|
var output: usize = 0
|
|
while input < std.mem.len(text) {
|
|
let byte: u8 = text[input]
|
|
if byte == 32_u8 {
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = 43_u8
|
|
output = output + 1
|
|
} else if __zero_std_url_is_unreserved(byte) {
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = byte
|
|
output = output + 1
|
|
} else {
|
|
if output + 3 > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = 37_u8
|
|
buffer[output + 1] = __zero_std_url_hex_char(byte / 16_u8)
|
|
buffer[output + 2] = __zero_std_url_hex_char(byte % 16_u8)
|
|
output = output + 3
|
|
}
|
|
input = input + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_query_unescape(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
|
|
var input: usize = 0
|
|
var output: usize = 0
|
|
while input < std.mem.len(text) {
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
let byte: u8 = text[input]
|
|
if byte == 43_u8 {
|
|
buffer[output] = 32_u8
|
|
input = input + 1
|
|
} else if byte == 37_u8 {
|
|
if input + 2 >= std.mem.len(text) {
|
|
return null
|
|
}
|
|
let high: Maybe<u8> = std.ascii.hexValue(text[input + 1])
|
|
let low: Maybe<u8> = std.ascii.hexValue(text[input + 2])
|
|
if !high.has || !low.has {
|
|
return null
|
|
}
|
|
buffer[output] = high.value * 16_u8 + low.value
|
|
input = input + 3
|
|
} else {
|
|
buffer[output] = byte
|
|
input = input + 1
|
|
}
|
|
output = output + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_scheme(url: Span<u8>) -> Maybe<Span<u8>> {
|
|
var index: usize = 0
|
|
while index < std.mem.len(url) {
|
|
let byte: u8 = url[index]
|
|
if byte == 58_u8 {
|
|
if index == 0 {
|
|
return null
|
|
}
|
|
return url[..index]
|
|
}
|
|
if byte == 47_u8 || byte == 63_u8 || byte == 35_u8 {
|
|
return null
|
|
}
|
|
index = index + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_url_authority_start(url: Span<u8>) -> Maybe<usize> {
|
|
let scheme: Maybe<Span<u8>> = __zero_std_url_scheme(url)
|
|
if !scheme.has {
|
|
return null
|
|
}
|
|
let start: usize = std.mem.len(scheme.value) + 1
|
|
if start + 1 >= std.mem.len(url) || url[start] != 47_u8 || url[start + 1] != 47_u8 {
|
|
return null
|
|
}
|
|
return start + 2
|
|
}
|
|
|
|
fn __zero_std_url_authority(url: Span<u8>) -> Maybe<Span<u8>> {
|
|
let start: Maybe<usize> = __zero_std_url_authority_start(url)
|
|
if !start.has {
|
|
return null
|
|
}
|
|
var end: usize = start.value
|
|
while end < std.mem.len(url) && url[end] != 47_u8 && url[end] != 63_u8 && url[end] != 35_u8 {
|
|
end = end + 1
|
|
}
|
|
if end == start.value {
|
|
return null
|
|
}
|
|
return url[start.value..end]
|
|
}
|
|
|
|
fn __zero_std_url_host(url: Span<u8>) -> Maybe<Span<u8>> {
|
|
let authority: Maybe<Span<u8>> = __zero_std_url_authority(url)
|
|
if !authority.has {
|
|
return null
|
|
}
|
|
var start: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(authority.value) {
|
|
if authority.value[index] == 64_u8 {
|
|
start = index + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
if start < std.mem.len(authority.value) && authority.value[start] == 91_u8 {
|
|
var close: usize = start + 1
|
|
while close < std.mem.len(authority.value) && authority.value[close] != 93_u8 {
|
|
close = close + 1
|
|
}
|
|
if close >= std.mem.len(authority.value) || close == start + 1 {
|
|
return null
|
|
}
|
|
if close + 1 < std.mem.len(authority.value) && authority.value[close + 1] != 58_u8 {
|
|
return null
|
|
}
|
|
return authority.value[start..close + 1]
|
|
}
|
|
var end: usize = start
|
|
while end < std.mem.len(authority.value) && authority.value[end] != 58_u8 {
|
|
end = end + 1
|
|
}
|
|
if end == start {
|
|
return null
|
|
}
|
|
return authority.value[start..end]
|
|
}
|
|
|
|
fn __zero_std_url_path(url: Span<u8>) -> Span<u8> {
|
|
var start: usize = 0
|
|
let scheme: Maybe<Span<u8>> = __zero_std_url_scheme(url)
|
|
let authority_start: Maybe<usize> = __zero_std_url_authority_start(url)
|
|
if authority_start.has {
|
|
start = authority_start.value
|
|
while start < std.mem.len(url) && url[start] != 47_u8 && url[start] != 63_u8 && url[start] != 35_u8 {
|
|
start = start + 1
|
|
}
|
|
} else if scheme.has {
|
|
start = std.mem.len(scheme.value) + 1
|
|
}
|
|
if start >= std.mem.len(url) {
|
|
return url[std.mem.len(url)..]
|
|
}
|
|
var end: usize = start
|
|
while end < std.mem.len(url) && url[end] != 63_u8 && url[end] != 35_u8 {
|
|
end = end + 1
|
|
}
|
|
return url[start..end]
|
|
}
|
|
|
|
fn __zero_std_url_query(url: Span<u8>) -> Maybe<Span<u8>> {
|
|
var start: usize = 0
|
|
while start < std.mem.len(url) && url[start] != 63_u8 {
|
|
if url[start] == 35_u8 {
|
|
return null
|
|
}
|
|
start = start + 1
|
|
}
|
|
if start >= std.mem.len(url) {
|
|
return null
|
|
}
|
|
start = start + 1
|
|
var end: usize = start
|
|
while end < std.mem.len(url) && url[end] != 35_u8 {
|
|
end = end + 1
|
|
}
|
|
return url[start..end]
|
|
}
|
|
|
|
fn __zero_std_url_fragment(url: Span<u8>) -> Maybe<Span<u8>> {
|
|
var start: usize = 0
|
|
while start < std.mem.len(url) && url[start] != 35_u8 {
|
|
start = start + 1
|
|
}
|
|
if start >= std.mem.len(url) {
|
|
return null
|
|
}
|
|
return url[start + 1..]
|
|
}
|
|
|
|
fn __zero_std_url_query_value(query: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
|
|
var start: usize = 0
|
|
while start <= std.mem.len(query) {
|
|
var end: usize = start
|
|
while end < std.mem.len(query) && query[end] != 38_u8 {
|
|
end = end + 1
|
|
}
|
|
var eq: usize = start
|
|
while eq < end && query[eq] != 61_u8 {
|
|
eq = eq + 1
|
|
}
|
|
let name: Span<u8> = query[start..eq]
|
|
if std.mem.eql(name, key) {
|
|
if eq < end {
|
|
return query[eq + 1..end]
|
|
}
|
|
return query[end..end]
|
|
}
|
|
if end == std.mem.len(query) {
|
|
return null
|
|
}
|
|
start = end + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_url_query_value_decoded(buffer: MutSpan<u8>, query: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
|
|
var start: usize = 0
|
|
while start <= std.mem.len(query) {
|
|
var end: usize = start
|
|
while end < std.mem.len(query) && query[end] != 38_u8 {
|
|
end = end + 1
|
|
}
|
|
var eq: usize = start
|
|
while eq < end && query[eq] != 61_u8 {
|
|
eq = eq + 1
|
|
}
|
|
let name: Span<u8> = query[start..eq]
|
|
var matched: Bool = std.mem.eql(name, key)
|
|
if !matched {
|
|
let decoded_name: Maybe<Span<u8>> = __zero_std_url_query_unescape(buffer, name)
|
|
if decoded_name.has {
|
|
matched = std.mem.eql(decoded_name.value, key)
|
|
}
|
|
}
|
|
if matched {
|
|
if eq < end {
|
|
return __zero_std_url_query_unescape(buffer, query[eq + 1..end])
|
|
}
|
|
return buffer[..0]
|
|
}
|
|
if end == std.mem.len(query) {
|
|
return null
|
|
}
|
|
start = end + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_url_write_query_param(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
|
|
var output: usize = 0
|
|
let encoded_key: Maybe<Span<u8>> = __zero_std_url_query_escape(buffer, key)
|
|
if !encoded_key.has {
|
|
return null
|
|
}
|
|
output = output + std.mem.len(encoded_key.value)
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = 61_u8
|
|
output = output + 1
|
|
let encoded_value: Maybe<Span<u8>> = __zero_std_url_query_escape(buffer[output..], value)
|
|
if !encoded_value.has {
|
|
return null
|
|
}
|
|
output = output + std.mem.len(encoded_value.value)
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_write_form_field(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
|
|
return __zero_std_url_write_query_param(buffer, key, value)
|
|
}
|
|
|
|
fn __zero_std_url_append_form_field(buffer: MutSpan<u8>, form: Span<u8>, field: Span<u8>) -> Maybe<Span<u8>> {
|
|
let form_len: usize = std.mem.len(form)
|
|
let field_len: usize = std.mem.len(field)
|
|
if form_len == 0_usize {
|
|
if field_len > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var field_index: usize = 0
|
|
while field_index < field_len {
|
|
buffer[field_index] = field[field_index]
|
|
field_index = field_index + 1
|
|
}
|
|
return buffer[..field_len]
|
|
}
|
|
if form_len >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
if field_len > std.mem.len(buffer) - form_len - 1_usize {
|
|
return null
|
|
}
|
|
var output: usize = 0
|
|
while output < form_len {
|
|
buffer[output] = form[output]
|
|
output = output + 1
|
|
}
|
|
buffer[output] = 38_u8
|
|
output = output + 1
|
|
var field_index: usize = 0
|
|
while field_index < field_len {
|
|
buffer[output] = field[field_index]
|
|
output = output + 1
|
|
field_index = field_index + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_form_value(buffer: MutSpan<u8>, form: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
|
|
return __zero_std_url_query_value_decoded(buffer, form, key)
|
|
}
|
|
|
|
fn __zero_std_url_append_query(buffer: MutSpan<u8>, base: Span<u8>, query: Span<u8>) -> Maybe<Span<u8>> {
|
|
let base_len: usize = std.mem.len(base)
|
|
if base_len >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
if std.mem.len(query) > std.mem.len(buffer) - base_len - 1 {
|
|
return null
|
|
}
|
|
var fragment: usize = 0
|
|
while fragment < base_len && base[fragment] != 35_u8 {
|
|
fragment = fragment + 1
|
|
}
|
|
var output: usize = 0
|
|
while output < fragment {
|
|
buffer[output] = base[output]
|
|
output = output + 1
|
|
}
|
|
var separator: u8 = 63_u8
|
|
var index: usize = 0
|
|
while index < fragment {
|
|
if base[index] == 63_u8 {
|
|
separator = 38_u8
|
|
}
|
|
index = index + 1
|
|
}
|
|
buffer[output] = separator
|
|
output = output + 1
|
|
var query_index: usize = 0
|
|
while query_index < std.mem.len(query) {
|
|
buffer[output] = query[query_index]
|
|
output = output + 1
|
|
query_index = query_index + 1
|
|
}
|
|
var fragment_index: usize = fragment
|
|
while fragment_index < base_len {
|
|
buffer[output] = base[fragment_index]
|
|
output = output + 1
|
|
fragment_index = fragment_index + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_write_url(buffer: MutSpan<u8>, scheme: Span<u8>, host: Span<u8>, path: Span<u8>) -> Maybe<Span<u8>> {
|
|
if std.mem.len(scheme) == 0 || std.mem.len(host) == 0 {
|
|
return null
|
|
}
|
|
var output: usize = 0
|
|
let scheme_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, scheme)
|
|
if !scheme_end.has {
|
|
return null
|
|
}
|
|
output = scheme_end.value
|
|
let sep_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "://")
|
|
if !sep_end.has {
|
|
return null
|
|
}
|
|
output = sep_end.value
|
|
let host_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, host)
|
|
if !host_end.has {
|
|
return null
|
|
}
|
|
output = host_end.value
|
|
if std.mem.len(path) > 0 {
|
|
if path[0] != 47_u8 {
|
|
let slash_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "/")
|
|
if !slash_end.has {
|
|
return null
|
|
}
|
|
output = slash_end.value
|
|
}
|
|
let path_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, path)
|
|
if !path_end.has {
|
|
return null
|
|
}
|
|
output = path_end.value
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_url_append_fragment(buffer: MutSpan<u8>, base: Span<u8>, fragment: Span<u8>) -> Maybe<Span<u8>> {
|
|
var output: usize = 0
|
|
let base_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, base)
|
|
if !base_end.has {
|
|
return null
|
|
}
|
|
output = base_end.value
|
|
let marker_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "#")
|
|
if !marker_end.has {
|
|
return null
|
|
}
|
|
output = marker_end.value
|
|
let fragment_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, fragment)
|
|
if !fragment_end.has {
|
|
return null
|
|
}
|
|
return buffer[..fragment_end.value]
|
|
}
|
|
|
|
fn __zero_std_url_write_span(buffer: MutSpan<u8>, cursor: usize, bytes: Span<u8>) -> Maybe<usize> {
|
|
if cursor + std.mem.len(bytes) > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var index: usize = 0
|
|
while index < std.mem.len(bytes) {
|
|
buffer[cursor + index] = bytes[index]
|
|
index = index + 1
|
|
}
|
|
return cursor + std.mem.len(bytes)
|
|
}
|