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
496 lines
14 KiB
Plaintext
496 lines
14 KiB
Plaintext
fn __zero_std_fmt_write_u32_at(buffer: MutSpan<u8>, offset: usize, value: u32) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var digits: usize = 1
|
|
var scan: u32 = value
|
|
while scan >= 10_u32 {
|
|
digits = digits + 1
|
|
scan = scan / 10_u32
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: u32 = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u8 = (current % 10_u32) as u8
|
|
buffer[cursor] = 48_u8 + digit
|
|
current = current / 10_u32
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_write_usize_at(buffer: MutSpan<u8>, offset: usize, value: usize) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var digits: usize = 1
|
|
var scan: usize = value
|
|
while scan >= 10 {
|
|
digits = digits + 1
|
|
scan = scan / 10
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: usize = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u8 = (current % 10) as u8
|
|
buffer[cursor] = 48_u8 + digit
|
|
current = current / 10
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_write_u64_at(buffer: MutSpan<u8>, offset: usize, value: u64) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var digits: usize = 1
|
|
var scan: u64 = value
|
|
while scan >= 10_u64 {
|
|
digits = digits + 1
|
|
scan = scan / 10_u64
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: u64 = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u8 = (current % 10_u64) as u8
|
|
buffer[cursor] = 48_u8 + digit
|
|
current = current / 10_u64
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_digit_lower(value: u32) -> u8 {
|
|
if value < 10_u32 {
|
|
return 48_u8 + (value as u8)
|
|
}
|
|
return 87_u8 + (value as u8)
|
|
}
|
|
|
|
fn __zero_std_fmt_write_u32_base_at(buffer: MutSpan<u8>, offset: usize, value: u32, base: u32) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
|
|
return null
|
|
}
|
|
var digits: usize = 1
|
|
var scan: u32 = value
|
|
while scan >= base {
|
|
digits = digits + 1
|
|
scan = scan / base
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: u32 = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u32 = current % base
|
|
buffer[cursor] = __zero_std_fmt_digit_lower(digit)
|
|
current = current / base
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_write_usize_base_at(buffer: MutSpan<u8>, offset: usize, value: usize, base: u32) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
|
|
return null
|
|
}
|
|
let usize_base: usize = base as usize
|
|
var digits: usize = 1
|
|
var scan: usize = value
|
|
while scan >= usize_base {
|
|
digits = digits + 1
|
|
scan = scan / usize_base
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: usize = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u32 = (current % usize_base) as u32
|
|
buffer[cursor] = __zero_std_fmt_digit_lower(digit)
|
|
current = current / usize_base
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_write_u64_base_at(buffer: MutSpan<u8>, offset: usize, value: u64, base: u32) -> Maybe<usize> {
|
|
if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
|
|
return null
|
|
}
|
|
let u64_base: u64 = base as u64
|
|
var digits: usize = 1
|
|
var scan: u64 = value
|
|
while scan >= u64_base {
|
|
digits = digits + 1
|
|
scan = scan / u64_base
|
|
}
|
|
if offset + digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = offset + digits
|
|
var current: u64 = value
|
|
while cursor > offset {
|
|
cursor = cursor - 1
|
|
let digit: u32 = (current % u64_base) as u32
|
|
buffer[cursor] = __zero_std_fmt_digit_lower(digit)
|
|
current = current / u64_base
|
|
}
|
|
return offset + digits
|
|
}
|
|
|
|
fn __zero_std_fmt_write_bytes(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
|
|
if std.mem.len(text) > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var index: usize = 0
|
|
while index < std.mem.len(text) {
|
|
buffer[index] = text[index]
|
|
index = index + 1
|
|
}
|
|
return buffer[..std.mem.len(text)]
|
|
}
|
|
|
|
fn __zero_std_fmt_bool(buffer: MutSpan<u8>, value: Bool) -> Maybe<Span<u8>> {
|
|
if value {
|
|
return __zero_std_fmt_write_bytes(buffer, "true")
|
|
}
|
|
return __zero_std_fmt_write_bytes(buffer, "false")
|
|
}
|
|
|
|
fn __zero_std_fmt_u32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 0, value)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_usize(buffer: MutSpan<u8>, value: usize) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_usize_at(buffer, 0, value)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_u64(buffer: MutSpan<u8>, value: u64) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 0, value)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i32(buffer: MutSpan<u8>, value: i32) -> Maybe<Span<u8>> {
|
|
if value >= 0 {
|
|
return __zero_std_fmt_u32(buffer, value as u32)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 45_u8
|
|
let min_i32: i32 = 0 - 2147483647 - 1
|
|
if value == min_i32 {
|
|
let written_min: Maybe<Span<u8>> = __zero_std_fmt_write_bytes(buffer[1..], "2147483648")
|
|
if written_min.has {
|
|
return buffer[..11]
|
|
}
|
|
return null
|
|
}
|
|
let magnitude: u32 = (0 - value) as u32
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 1, magnitude)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i64(buffer: MutSpan<u8>, value: i64) -> Maybe<Span<u8>> {
|
|
if value >= 0 {
|
|
return __zero_std_fmt_u64(buffer, value as u64)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 45_u8
|
|
let min_i64: i64 = 0 - 9223372036854775807 - 1
|
|
if value == min_i64 {
|
|
let written_min: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, 9223372036854775808_u64)
|
|
if written_min.has {
|
|
return buffer[..written_min.value]
|
|
}
|
|
return null
|
|
}
|
|
let magnitude: u64 = (0_i64 - value) as u64
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, magnitude)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_u32_base(buffer: MutSpan<u8>, value: u32, base: u32) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 0, value, base)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_usize_base(buffer: MutSpan<u8>, value: usize, base: u32) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_usize_base_at(buffer, 0, value, base)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_u64_base(buffer: MutSpan<u8>, value: u64, base: u32) -> Maybe<Span<u8>> {
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 0, value, base)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i32_base(buffer: MutSpan<u8>, value: i32, base: u32) -> Maybe<Span<u8>> {
|
|
if base < 2_u32 || base > 36_u32 {
|
|
return null
|
|
}
|
|
if value >= 0 {
|
|
return __zero_std_fmt_u32_base(buffer, value as u32, base)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 45_u8
|
|
let min_i32: i32 = 0 - 2147483647 - 1
|
|
if value == min_i32 {
|
|
let written_min: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 1, 2147483648_u32, base)
|
|
if written_min.has {
|
|
return buffer[..written_min.value]
|
|
}
|
|
return null
|
|
}
|
|
let magnitude: u32 = (0 - value) as u32
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 1, magnitude, base)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i64_base(buffer: MutSpan<u8>, value: i64, base: u32) -> Maybe<Span<u8>> {
|
|
if base < 2_u32 || base > 36_u32 {
|
|
return null
|
|
}
|
|
if value >= 0 {
|
|
return __zero_std_fmt_u64_base(buffer, value as u64, base)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 45_u8
|
|
let min_i64: i64 = 0 - 9223372036854775807 - 1
|
|
if value == min_i64 {
|
|
let written_min: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 1, 9223372036854775808_u64, base)
|
|
if written_min.has {
|
|
return buffer[..written_min.value]
|
|
}
|
|
return null
|
|
}
|
|
let magnitude: u64 = (0_i64 - value) as u64
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 1, magnitude, base)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i32_sign(buffer: MutSpan<u8>, value: i32) -> Maybe<Span<u8>> {
|
|
if value < 0 {
|
|
return __zero_std_fmt_i32(buffer, value)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 43_u8
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 1, value as u32)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_i64_sign(buffer: MutSpan<u8>, value: i64) -> Maybe<Span<u8>> {
|
|
if value < 0 {
|
|
return __zero_std_fmt_i64(buffer, value)
|
|
}
|
|
if std.mem.len(buffer) == 0 {
|
|
return null
|
|
}
|
|
buffer[0] = 43_u8
|
|
let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, value as u64)
|
|
if written.has {
|
|
return buffer[..written.value]
|
|
}
|
|
return null
|
|
}
|
|
|
|
fn __zero_std_fmt_pad_left(buffer: MutSpan<u8>, text: Span<u8>, width: usize, pad: u8) -> Maybe<Span<u8>> {
|
|
let len: usize = std.mem.len(text)
|
|
if len >= width {
|
|
return __zero_std_fmt_write_bytes(buffer, text)
|
|
}
|
|
if width > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
let fill: usize = width - len
|
|
var index: usize = 0
|
|
while index < fill {
|
|
buffer[index] = pad
|
|
index = index + 1
|
|
}
|
|
var text_index: usize = 0
|
|
while text_index < len {
|
|
buffer[fill + text_index] = text[text_index]
|
|
text_index = text_index + 1
|
|
}
|
|
return buffer[..width]
|
|
}
|
|
|
|
fn __zero_std_fmt_pad_right(buffer: MutSpan<u8>, text: Span<u8>, width: usize, pad: u8) -> Maybe<Span<u8>> {
|
|
let len: usize = std.mem.len(text)
|
|
if len >= width {
|
|
return __zero_std_fmt_write_bytes(buffer, text)
|
|
}
|
|
if width > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var text_index: usize = 0
|
|
while text_index < len {
|
|
buffer[text_index] = text[text_index]
|
|
text_index = text_index + 1
|
|
}
|
|
var index: usize = len
|
|
while index < width {
|
|
buffer[index] = pad
|
|
index = index + 1
|
|
}
|
|
return buffer[..width]
|
|
}
|
|
|
|
fn __zero_std_fmt_write_span(writer: mutref<FixedWriter>, text: Span<u8>) -> Bool {
|
|
return std.io.fixedWriterWrite(writer, text)
|
|
}
|
|
|
|
fn __zero_std_fmt_write_bool(writer: mutref<FixedWriter>, value: Bool) -> Bool {
|
|
var storage: [5]u8 = [0_u8; 5]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_bool(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_u32(writer: mutref<FixedWriter>, value: u32) -> Bool {
|
|
var storage: [10]u8 = [0_u8; 10]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_u32(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_usize(writer: mutref<FixedWriter>, value: usize) -> Bool {
|
|
var storage: [20]u8 = [0_u8; 20]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_usize(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_u64(writer: mutref<FixedWriter>, value: u64) -> Bool {
|
|
var storage: [20]u8 = [0_u8; 20]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_u64(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_i32(writer: mutref<FixedWriter>, value: i32) -> Bool {
|
|
var storage: [12]u8 = [0_u8; 12]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_i32(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_i64(writer: mutref<FixedWriter>, value: i64) -> Bool {
|
|
var storage: [20]u8 = [0_u8; 20]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_i64(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_i32_sign(writer: mutref<FixedWriter>, value: i32) -> Bool {
|
|
var storage: [12]u8 = [0_u8; 12]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_i32_sign(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_write_i64_sign(writer: mutref<FixedWriter>, value: i64) -> Bool {
|
|
var storage: [20]u8 = [0_u8; 20]
|
|
let text: Maybe<Span<u8>> = __zero_std_fmt_i64_sign(storage, value)
|
|
if text.has {
|
|
return __zero_std_fmt_write_span(writer, text.value)
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn __zero_std_fmt_hex_lower_u32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
|
|
var digits: usize = 1
|
|
var scan: u32 = value
|
|
while scan >= 16_u32 {
|
|
digits = digits + 1
|
|
scan = scan / 16_u32
|
|
}
|
|
if digits > std.mem.len(buffer) {
|
|
return null
|
|
}
|
|
var cursor: usize = digits
|
|
var current: u32 = value
|
|
while cursor > 0 {
|
|
cursor = cursor - 1
|
|
let digit: u8 = (current % 16_u32) as u8
|
|
if digit < 10_u8 {
|
|
buffer[cursor] = 48_u8 + digit
|
|
} else {
|
|
buffer[cursor] = 87_u8 + digit
|
|
}
|
|
current = current / 16_u32
|
|
}
|
|
return buffer[..digits]
|
|
}
|