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
661 lines
20 KiB
Plaintext
661 lines
20 KiB
Plaintext
fn __zero_std_toml_validate(bytes: Span<u8>) -> Bool {
|
|
var index: usize = 0
|
|
while index < std.mem.len(bytes) {
|
|
let line_end: usize = __zero_std_toml_line_end(bytes, index)
|
|
let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
|
|
let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
|
|
if start < content_end {
|
|
if bytes[start] == 91_u8 {
|
|
let table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
|
|
if !table_end.has {
|
|
return false
|
|
}
|
|
} else {
|
|
let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
|
|
if !equals.has {
|
|
return false
|
|
}
|
|
let key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
|
|
let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
|
|
let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
|
|
if key_end == start || value_start == value_end || !__zero_std_toml_value_valid(bytes[value_start..value_end]) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
index = line_end
|
|
if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
|
|
index = index + 1
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_toml_validate_bytes(bytes: Span<u8>) -> Bool {
|
|
return __zero_std_toml_validate(bytes)
|
|
}
|
|
|
|
fn __zero_std_toml_field(bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
|
|
var table_start: usize = 0
|
|
var table_end: usize = 0
|
|
var has_table: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(bytes) {
|
|
let line_end: usize = __zero_std_toml_line_end(bytes, index)
|
|
let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
|
|
let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
|
|
if start < content_end {
|
|
if bytes[start] == 91_u8 {
|
|
let next_table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
|
|
if !next_table_end.has {
|
|
return null
|
|
}
|
|
table_start = start + 1
|
|
table_end = next_table_end.value
|
|
has_table = true
|
|
} else {
|
|
let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
|
|
if !equals.has {
|
|
return null
|
|
}
|
|
let field_key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
|
|
let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
|
|
let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
|
|
var table: Span<u8> = bytes[0..0]
|
|
if has_table {
|
|
table = bytes[table_start..table_end]
|
|
}
|
|
if __zero_std_toml_key_matches(table, bytes[start..field_key_end], key) {
|
|
return bytes[value_start..value_end]
|
|
}
|
|
}
|
|
}
|
|
index = line_end
|
|
if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
|
|
index = index + 1
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_string_decode(buffer: MutSpan<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
|
|
if std.mem.len(value) < 2 || value[0] != 34_u8 || value[std.mem.len(value) - 1] != 34_u8 {
|
|
return null
|
|
}
|
|
var input: usize = 1
|
|
var output: usize = 0
|
|
while input + 1 < std.mem.len(value) {
|
|
var byte: u8 = value[input]
|
|
if byte == 92_u8 {
|
|
input = input + 1
|
|
if input + 1 >= std.mem.len(value) {
|
|
return null
|
|
}
|
|
let escaped: u8 = value[input]
|
|
if escaped == 34_u8 {
|
|
byte = 34_u8
|
|
} else if escaped == 92_u8 {
|
|
byte = 92_u8
|
|
} else if escaped == 110_u8 {
|
|
byte = 10_u8
|
|
} else if escaped == 114_u8 {
|
|
byte = 13_u8
|
|
} else if escaped == 116_u8 {
|
|
byte = 9_u8
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
if output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = byte
|
|
output = output + 1
|
|
input = input + 1
|
|
}
|
|
return buffer[..output]
|
|
}
|
|
|
|
fn __zero_std_toml_string(buffer: MutSpan<u8>, bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return __zero_std_toml_string_decode(buffer, raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_u32(bytes: Span<u8>, key: Span<u8>) -> Maybe<u32> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseU32(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_i32(bytes: Span<u8>, key: Span<u8>) -> Maybe<i32> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseI32(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_bool(bytes: Span<u8>, key: Span<u8>) -> Maybe<Bool> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseBool(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_array_count(value: Span<u8>) -> Maybe<usize> {
|
|
if !__zero_std_toml_array_valid(value) {
|
|
return null
|
|
}
|
|
var count: usize = 0
|
|
var index: usize = 1
|
|
let end: usize = std.mem.len(value) - 1
|
|
while index < end {
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index == end {
|
|
return count
|
|
}
|
|
let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
|
|
if !item_end.has {
|
|
return null
|
|
}
|
|
count = count + 1
|
|
index = item_end.value
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index < end {
|
|
index = index + 1
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
fn __zero_std_toml_array_value(value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
|
|
if !__zero_std_toml_array_valid(value) {
|
|
return null
|
|
}
|
|
var count: usize = 0
|
|
var index: usize = 1
|
|
let end: usize = std.mem.len(value) - 1
|
|
while index < end {
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index == end {
|
|
return null
|
|
}
|
|
let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
|
|
if !item_end.has {
|
|
return null
|
|
}
|
|
if count == ordinal {
|
|
return value[index..item_end.value]
|
|
}
|
|
count = count + 1
|
|
index = item_end.value
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index < end {
|
|
index = index + 1
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_array_string(buffer: MutSpan<u8>, value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return __zero_std_toml_string_decode(buffer, raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_array_u32(value: Span<u8>, ordinal: usize) -> Maybe<u32> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseU32(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_array_i32(value: Span<u8>, ordinal: usize) -> Maybe<i32> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseI32(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_array_bool(value: Span<u8>, ordinal: usize) -> Maybe<Bool> {
|
|
let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
|
|
if !raw.has {
|
|
return null
|
|
}
|
|
return std.parse.parseBool(raw.value)
|
|
}
|
|
|
|
fn __zero_std_toml_key_byte_valid(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 == 95_u8
|
|
}
|
|
|
|
fn __zero_std_toml_dotted_key_valid(key: Span<u8>) -> Bool {
|
|
if std.mem.len(key) == 0 {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
var segment_has_byte: Bool = false
|
|
while index < std.mem.len(key) {
|
|
let byte: u8 = key[index]
|
|
if byte == 46_u8 {
|
|
if !segment_has_byte {
|
|
return false
|
|
}
|
|
segment_has_byte = false
|
|
} else if __zero_std_toml_key_byte_valid(byte) {
|
|
segment_has_byte = true
|
|
} else {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return segment_has_byte
|
|
}
|
|
|
|
fn __zero_std_toml_write_key_value_string(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
|
|
if !__zero_std_toml_dotted_key_valid(key) {
|
|
return null
|
|
}
|
|
var cursor: usize = 0
|
|
let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
|
|
if !key_end.has {
|
|
return null
|
|
}
|
|
cursor = key_end.value
|
|
let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
|
|
if !sep_end.has {
|
|
return null
|
|
}
|
|
cursor = sep_end.value
|
|
let value_end: Maybe<usize> = __zero_std_toml_write_escaped_string(buffer, cursor, value)
|
|
if !value_end.has {
|
|
return null
|
|
}
|
|
cursor = value_end.value
|
|
let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
|
|
if !line_end.has {
|
|
return null
|
|
}
|
|
return buffer[..line_end.value]
|
|
}
|
|
|
|
fn __zero_std_toml_write_key_value_u32(buffer: MutSpan<u8>, key: Span<u8>, value: u32) -> Maybe<Span<u8>> {
|
|
if !__zero_std_toml_dotted_key_valid(key) {
|
|
return null
|
|
}
|
|
var cursor: usize = 0
|
|
let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
|
|
if !key_end.has {
|
|
return null
|
|
}
|
|
cursor = key_end.value
|
|
let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
|
|
if !sep_end.has {
|
|
return null
|
|
}
|
|
cursor = sep_end.value
|
|
let digits: Maybe<Span<u8>> = std.fmt.u32(buffer[cursor..], value)
|
|
if !digits.has {
|
|
return null
|
|
}
|
|
cursor = cursor + std.mem.len(digits.value)
|
|
let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
|
|
if !line_end.has {
|
|
return null
|
|
}
|
|
return buffer[..line_end.value]
|
|
}
|
|
|
|
fn __zero_std_toml_write_key_value_bool(buffer: MutSpan<u8>, key: Span<u8>, value: Bool) -> Maybe<Span<u8>> {
|
|
if !__zero_std_toml_dotted_key_valid(key) {
|
|
return null
|
|
}
|
|
var cursor: usize = 0
|
|
let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
|
|
if !key_end.has {
|
|
return null
|
|
}
|
|
cursor = key_end.value
|
|
let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
|
|
if !sep_end.has {
|
|
return null
|
|
}
|
|
cursor = sep_end.value
|
|
var value_end: Maybe<usize> = null
|
|
if value {
|
|
value_end = __zero_std_toml_write_span(buffer, cursor, "true")
|
|
} else {
|
|
value_end = __zero_std_toml_write_span(buffer, cursor, "false")
|
|
}
|
|
if !value_end.has {
|
|
return null
|
|
}
|
|
cursor = value_end.value
|
|
let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
|
|
if !line_end.has {
|
|
return null
|
|
}
|
|
return buffer[..line_end.value]
|
|
}
|
|
|
|
fn __zero_std_toml_write_table_header(buffer: MutSpan<u8>, table: Span<u8>) -> Maybe<Span<u8>> {
|
|
if !__zero_std_toml_dotted_key_valid(table) {
|
|
return null
|
|
}
|
|
var cursor: usize = 0
|
|
let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "[")
|
|
if !open_end.has {
|
|
return null
|
|
}
|
|
cursor = open_end.value
|
|
let table_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, table)
|
|
if !table_end.has {
|
|
return null
|
|
}
|
|
cursor = table_end.value
|
|
let close_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "]\n")
|
|
if !close_end.has {
|
|
return null
|
|
}
|
|
return buffer[..close_end.value]
|
|
}
|
|
|
|
fn __zero_std_toml_line_end(bytes: Span<u8>, start: usize) -> usize {
|
|
var index: usize = start
|
|
while index < std.mem.len(bytes) && bytes[index] != 10_u8 {
|
|
index = index + 1
|
|
}
|
|
return index
|
|
}
|
|
|
|
fn __zero_std_toml_skip_ws(bytes: Span<u8>, start: usize, end: usize) -> usize {
|
|
var index: usize = start
|
|
while index < end && (bytes[index] == 32_u8 || bytes[index] == 9_u8 || bytes[index] == 13_u8) {
|
|
index = index + 1
|
|
}
|
|
return index
|
|
}
|
|
|
|
fn __zero_std_toml_trim_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
|
|
var index: usize = end
|
|
while index > start && (bytes[index - 1] == 32_u8 || bytes[index - 1] == 9_u8 || bytes[index - 1] == 13_u8) {
|
|
index = index - 1
|
|
}
|
|
return index
|
|
}
|
|
|
|
fn __zero_std_toml_comment_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
|
|
var index: usize = start
|
|
var in_string: Bool = false
|
|
var escaped: Bool = false
|
|
while index < end {
|
|
let byte: u8 = bytes[index]
|
|
if escaped {
|
|
escaped = false
|
|
} else if in_string && byte == 92_u8 {
|
|
escaped = true
|
|
} else if byte == 34_u8 {
|
|
in_string = !in_string
|
|
} else if !in_string && byte == 35_u8 {
|
|
return __zero_std_toml_trim_end(bytes, start, index)
|
|
}
|
|
index = index + 1
|
|
}
|
|
return end
|
|
}
|
|
|
|
fn __zero_std_toml_find_equals(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
|
|
var index: usize = start
|
|
var in_string: Bool = false
|
|
var escaped: Bool = false
|
|
while index < end {
|
|
let byte: u8 = bytes[index]
|
|
if escaped {
|
|
escaped = false
|
|
} else if in_string && byte == 92_u8 {
|
|
escaped = true
|
|
} else if byte == 34_u8 {
|
|
in_string = !in_string
|
|
} else if !in_string && byte == 61_u8 {
|
|
return index
|
|
}
|
|
index = index + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_table_end(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
|
|
if start >= end || bytes[start] != 91_u8 {
|
|
return null
|
|
}
|
|
var index: usize = start + 1
|
|
while index < end {
|
|
if bytes[index] == 93_u8 {
|
|
let trailing: usize = __zero_std_toml_skip_ws(bytes, index + 1, end)
|
|
if trailing == end && index > start + 1 {
|
|
return index
|
|
}
|
|
return null
|
|
}
|
|
index = index + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_string_value_end(value: Span<u8>) -> Maybe<usize> {
|
|
if std.mem.len(value) == 0 || value[0] != 34_u8 {
|
|
return null
|
|
}
|
|
var index: usize = 1
|
|
var escaped: Bool = false
|
|
while index < std.mem.len(value) {
|
|
let byte: u8 = value[index]
|
|
if escaped {
|
|
if !(byte == 34_u8 || byte == 92_u8 || byte == 110_u8 || byte == 114_u8 || byte == 116_u8) {
|
|
return null
|
|
}
|
|
escaped = false
|
|
} else if byte == 92_u8 {
|
|
escaped = true
|
|
} else if byte == 34_u8 {
|
|
return index + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_array_valid(value: Span<u8>) -> Bool {
|
|
if std.mem.len(value) < 2 || value[0] != 91_u8 || value[std.mem.len(value) - 1] != 93_u8 {
|
|
return false
|
|
}
|
|
var index: usize = 1
|
|
let end: usize = std.mem.len(value) - 1
|
|
while index < end {
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index == end {
|
|
return true
|
|
}
|
|
let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
|
|
if !item_end.has {
|
|
return false
|
|
}
|
|
index = item_end.value
|
|
index = __zero_std_toml_skip_ws(value, index, end)
|
|
if index < end {
|
|
if value[index] != 44_u8 {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_toml_array_item_end(value: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
|
|
if start >= end {
|
|
return null
|
|
}
|
|
if value[start] == 34_u8 {
|
|
let item_end: Maybe<usize> = __zero_std_toml_string_value_end(value[start..end])
|
|
if !item_end.has {
|
|
return null
|
|
}
|
|
return start + item_end.value
|
|
}
|
|
var index: usize = start
|
|
while index < end && value[index] != 44_u8 {
|
|
index = index + 1
|
|
}
|
|
let trimmed: usize = __zero_std_toml_trim_end(value, start, index)
|
|
if trimmed == start {
|
|
return null
|
|
}
|
|
if __zero_std_toml_value_valid(value[start..trimmed]) {
|
|
return trimmed
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_toml_value_valid(value: Span<u8>) -> Bool {
|
|
if std.mem.len(value) == 0 {
|
|
return false
|
|
}
|
|
if value[0] == 34_u8 {
|
|
let end: Maybe<usize> = __zero_std_toml_string_value_end(value)
|
|
return end.has && end.value == std.mem.len(value)
|
|
}
|
|
if value[0] == 91_u8 {
|
|
return __zero_std_toml_array_valid(value)
|
|
}
|
|
if std.mem.eql(value, "true") || std.mem.eql(value, "false") {
|
|
return true
|
|
}
|
|
let signed: Maybe<i32> = std.parse.parseI32(value)
|
|
if signed.has {
|
|
return true
|
|
}
|
|
let unsigned: Maybe<u32> = std.parse.parseU32(value)
|
|
return unsigned.has
|
|
}
|
|
|
|
fn __zero_std_toml_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)
|
|
}
|
|
|
|
fn __zero_std_toml_write_escaped_string(buffer: MutSpan<u8>, cursor: usize, value: Span<u8>) -> Maybe<usize> {
|
|
var output: usize = cursor
|
|
let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\"")
|
|
if !open_end.has {
|
|
return null
|
|
}
|
|
output = open_end.value
|
|
var index: usize = 0
|
|
while index < std.mem.len(value) {
|
|
let byte: u8 = value[index]
|
|
if byte == 34_u8 {
|
|
let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\"")
|
|
if !next.has {
|
|
return null
|
|
}
|
|
output = next.value
|
|
} else if byte == 92_u8 {
|
|
let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\\")
|
|
if !next.has {
|
|
return null
|
|
}
|
|
output = next.value
|
|
} else if byte == 10_u8 {
|
|
let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\n")
|
|
if !next.has {
|
|
return null
|
|
}
|
|
output = next.value
|
|
} else if byte == 13_u8 {
|
|
let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\r")
|
|
if !next.has {
|
|
return null
|
|
}
|
|
output = next.value
|
|
} else if byte == 9_u8 {
|
|
let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\t")
|
|
if !next.has {
|
|
return null
|
|
}
|
|
output = next.value
|
|
} else {
|
|
if byte < 32_u8 || output >= std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
buffer[output] = byte
|
|
output = output + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return __zero_std_toml_write_span(buffer, output, "\"")
|
|
}
|
|
|
|
fn __zero_std_toml_span_eq(left: Span<u8>, right: Span<u8>) -> Bool {
|
|
if std.mem.len(left) != std.mem.len(right) {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index < std.mem.len(right) {
|
|
if left[index] != right[index] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_toml_key_matches(table: Span<u8>, field: Span<u8>, query: Span<u8>) -> Bool {
|
|
if __zero_std_toml_span_eq(field, query) {
|
|
return true
|
|
}
|
|
if std.mem.len(table) == 0 {
|
|
return false
|
|
}
|
|
let table_len: usize = std.mem.len(table)
|
|
let field_len: usize = std.mem.len(field)
|
|
if std.mem.len(query) != table_len + 1 + field_len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index < table_len {
|
|
if query[index] != table[index] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
if query[table_len] != 46_u8 {
|
|
return false
|
|
}
|
|
var field_index: usize = 0
|
|
while field_index < field_len {
|
|
if query[table_len + 1 + field_index] != field[field_index] {
|
|
return false
|
|
}
|
|
field_index = field_index + 1
|
|
}
|
|
return true
|
|
}
|