mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-19 21:10:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename try_copy_* to write_*

Browse Source
This commit is contained in:
gingerBill
2026-01-28 11:54:17 +00:00
parent 0d8b1481ea
commit 7135bbdd67
2 changed files with 185 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
base/runtime/error_checks.odin
View File

@@ -204,10 +204,10 @@ when ODIN_NO_RTTI {
@(cold, no_instrumentation)
handle_error :: proc "odin" (file: string, line, column: i32, from, to: typeid) -> ! {
do_msg :: proc "contextless" (i: ^int, buf: []byte, file: string, line, column: i32, from, to: typeid) -> bool {
try_copy_string(i, buf, "Invalid type assertion from ") or_return
try_copy_typeid(i, buf, from) or_return
try_copy_string(i, buf, " to ") or_return
try_copy_typeid(i, buf, to) or_return
write_string(i, buf, "Invalid type assertion from ") or_return
write_typeid(i, buf, from) or_return
write_string(i, buf, " to ") or_return
write_typeid(i, buf, to) or_return
return true
}
@@ -285,13 +285,13 @@ when ODIN_NO_RTTI {
@(cold, no_instrumentation)
handle_error :: proc "odin" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) -> ! {
do_msg :: proc "contextless" (i: ^int, buf: []byte, file: string, line, column: i32, from, to, actual: typeid) -> bool {
try_copy_string(i, buf, "Invalid type assertion from ") or_return
try_copy_typeid(i, buf, from) or_return
try_copy_string(i, buf, " to ") or_return
try_copy_typeid(i, buf, to) or_return
write_string(i, buf, "Invalid type assertion from ") or_return
write_typeid(i, buf, from) or_return
write_string(i, buf, " to ") or_return
write_typeid(i, buf, to) or_return
if actual != from {
try_copy_string(i, buf, ", actual type: ") or_return
try_copy_typeid(i, buf, actual) or_return
write_string(i, buf, ", actual type: ") or_return
write_typeid(i, buf, actual) or_return
}
return true
}

350
base/runtime/print.odin
View File

@@ -519,7 +519,7 @@ print_type :: #force_no_inline proc "contextless" (ti: ^Type_Info) {
@(require_results)
try_copy_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> bool {
write_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> bool {
if i^ < len(dst) {
i^ += copy(dst[i^:], src)
return true
@@ -529,7 +529,7 @@ try_copy_string :: proc "contextless" (i: ^int, dst: []byte, src: string) -> boo
@(require_results)
try_copy_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
write_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
if i^ < len(dst) {
dst[i^] = src
i^ += 1
@@ -540,7 +540,7 @@ try_copy_byte :: proc "contextless" (i: ^int, dst: []byte, src: byte) -> bool {
@(require_results)
try_copy_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
write_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
if j^ < len(dst) {
b :: u64(10)
u := x
@@ -553,13 +553,13 @@ try_copy_u64 :: proc "contextless" (j: ^int, dst: []byte, x: u64) -> bool {
}
i -= 1; a[i] = _INTEGER_DIGITS_VAR[u % b]
return try_copy_string(j, dst, string(a[i:]))
return write_string(j, dst, string(a[i:]))
}
return false
}
@(require_results)
try_copy_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
write_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
if j^ < len(dst) {
b :: u64(10)
u := u64(abs(x))
@@ -576,33 +576,33 @@ try_copy_i64 :: proc "contextless" (j: ^int, dst: []byte, x: i64) -> bool {
i -= 1; a[i] = '-'
}
return try_copy_string(j, dst, string(a[i:]))
return write_string(j, dst, string(a[i:]))
}
return false
}
@(require_results)
try_copy_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, loc: Source_Code_Location) -> bool {
try_copy_string(i, buf, loc.file_path) or_return
write_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, loc: Source_Code_Location) -> bool {
write_string(i, buf, loc.file_path) or_return
when ODIN_ERROR_POS_STYLE == .Default {
try_copy_byte(i, buf, '(') or_return
try_copy_u64 (i, buf, u64(loc.line)) or_return
write_byte(i, buf, '(') or_return
write_u64 (i, buf, u64(loc.line)) or_return
if loc.column != 0 {
try_copy_byte(i, buf, ':') or_return
try_copy_u64 (i, buf, u64(loc.column)) or_return
write_byte(i, buf, ':') or_return
write_u64 (i, buf, u64(loc.column)) or_return
}
try_copy_byte(i, buf, ')') or_return
write_byte(i, buf, ')') or_return
return true
} else when ODIN_ERROR_POS_STYLE == .Unix {
try_copy_byte(i, buf, ':') or_return
try_copy_u64 (i, buf, u64(loc.line)) or_return
write_byte(i, buf, ':') or_return
write_u64 (i, buf, u64(loc.line)) or_return
if loc.column != 0 {
try_copy_byte(i, buf, ':') or_return
try_copy_u64 (i, buf, u64(loc.column)) or_return
write_byte(i, buf, ':') or_return
write_u64 (i, buf, u64(loc.column)) or_return
}
try_copy_byte(i, buf, ':') or_return
write_byte(i, buf, ':') or_return
return true
} else {
#panic("unhandled ODIN_ERROR_POS_STYLE")
@@ -610,19 +610,19 @@ try_copy_caller_location :: #force_no_inline proc "contextless" (i: ^int, buf: [
}
@(require_results)
try_copy_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id: typeid) -> bool {
write_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id: typeid) -> bool {
when ODIN_NO_RTTI {
if id == nil {
try_copy_string(i, buf, "nil") or_return
write_string(i, buf, "nil") or_return
} else {
try_copy_string(i, buf, "<unknown type>") or_return
write_string(i, buf, "<unknown type>") or_return
}
} else {
if id == nil {
try_copy_string(i, buf, "nil") or_return
write_string(i, buf, "nil") or_return
} else {
ti := type_info_of(id)
try_copy_write_type(i, buf, ti) or_return
write_write_type(i, buf, ti) or_return
}
}
return true
@@ -630,304 +630,304 @@ try_copy_typeid :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, id
@(require_results)
try_copy_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> (written: int, ok: bool) #no_bounds_check {
write_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> (written: int, ok: bool) #no_bounds_check {
RUNE_SELF :: 0x80
if r < RUNE_SELF {
try_copy_byte(i, buf,byte(r)) or_return
write_byte(i, buf,byte(r)) or_return
return 1, true
}
b, n := encode_rune(r)
prev := i^
try_copy_string(i, buf, string(b[:n])) or_return
write_string(i, buf, string(b[:n])) or_return
return i^ - prev, true
}
@(require_results)
try_copy_encoded_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> bool {
try_copy_byte(i, buf, '\'') or_return
write_encoded_rune :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, r: rune) -> bool {
write_byte(i, buf, '\'') or_return
switch r {
case '\a': try_copy_string(i, buf, "\\a") or_return
case '\b': try_copy_string(i, buf, "\\b") or_return
case '\e': try_copy_string(i, buf, "\\e") or_return
case '\f': try_copy_string(i, buf, "\\f") or_return
case '\n': try_copy_string(i, buf, "\\n") or_return
case '\r': try_copy_string(i, buf, "\\r") or_return
case '\t': try_copy_string(i, buf, "\\t") or_return
case '\v': try_copy_string(i, buf, "\\v") or_return
case '\a': write_string(i, buf, "\\a") or_return
case '\b': write_string(i, buf, "\\b") or_return
case '\e': write_string(i, buf, "\\e") or_return
case '\f': write_string(i, buf, "\\f") or_return
case '\n': write_string(i, buf, "\\n") or_return
case '\r': write_string(i, buf, "\\r") or_return
case '\t': write_string(i, buf, "\\t") or_return
case '\v': write_string(i, buf, "\\v") or_return
case:
if r <= 0 {
try_copy_string(i, buf, "\\x00") or_return
write_string(i, buf, "\\x00") or_return
} else if r < 32 {
n0, n1 := u8(r) >> 4, u8(r) & 0xf
try_copy_string(i, buf, "\\x") or_return
try_copy_byte (i, buf, _INTEGER_DIGITS_VAR[n0]) or_return
try_copy_byte (i, buf, _INTEGER_DIGITS_VAR[n1]) or_return
write_string(i, buf, "\\x") or_return
write_byte (i, buf, _INTEGER_DIGITS_VAR[n0]) or_return
write_byte (i, buf, _INTEGER_DIGITS_VAR[n1]) or_return
} else {
_ = try_copy_rune(i, buf, r) or_return
_ = write_rune(i, buf, r) or_return
}
}
try_copy_byte(i, buf, '\'') or_return
write_byte(i, buf, '\'') or_return
return true
}
@(optimization_mode="favor_size")
try_copy_write_type :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, ti: ^Type_Info) -> bool {
write_write_type :: #force_no_inline proc "contextless" (i: ^int, buf: []byte, ti: ^Type_Info) -> bool {
if ti == nil {
try_copy_string(i, buf, "nil") or_return
write_string(i, buf, "nil") or_return
return true
}
switch info in ti.variant {
case Type_Info_Named:
try_copy_string(i, buf, info.name) or_return
write_string(i, buf, info.name) or_return
case Type_Info_Integer:
switch ti.id {
case int: try_copy_string(i, buf, "int") or_return
case uint: try_copy_string(i, buf, "uint") or_return
case uintptr: try_copy_string(i, buf, "uintptr") or_return
case int: write_string(i, buf, "int") or_return
case uint: write_string(i, buf, "uint") or_return
case uintptr: write_string(i, buf, "uintptr") or_return
case:
try_copy_byte(i, buf, 'i' if info.signed else 'u') or_return
try_copy_u64 (i, buf, u64(8*ti.size)) or_return
write_byte(i, buf, 'i' if info.signed else 'u') or_return
write_u64 (i, buf, u64(8*ti.size)) or_return
}
switch info.endianness {
case .Platform: // nothing
case .Little: try_copy_string(i, buf, "le") or_return
case .Big: try_copy_string(i, buf, "be") or_return
case .Little: write_string(i, buf, "le") or_return
case .Big: write_string(i, buf, "be") or_return
}
case Type_Info_Rune:
try_copy_string(i, buf, "rune") or_return
write_string(i, buf, "rune") or_return
case Type_Info_Float:
try_copy_byte(i, buf, 'f') or_return
try_copy_u64(i, buf, u64(8*ti.size)) or_return
write_byte(i, buf, 'f') or_return
write_u64(i, buf, u64(8*ti.size)) or_return
switch info.endianness {
case .Platform: // nothing
case .Little: try_copy_string(i, buf, "le") or_return
case .Big: try_copy_string(i, buf, "be") or_return
case .Little: write_string(i, buf, "le") or_return
case .Big: write_string(i, buf, "be") or_return
}
case Type_Info_Complex:
try_copy_string(i, buf, "complex") or_return
try_copy_u64 (i, buf, u64(8*ti.size)) or_return
write_string(i, buf, "complex") or_return
write_u64 (i, buf, u64(8*ti.size)) or_return
case Type_Info_Quaternion:
try_copy_string(i, buf, "quaternion") or_return
try_copy_u64 (i, buf, u64(8*ti.size)) or_return
write_string(i, buf, "quaternion") or_return
write_u64 (i, buf, u64(8*ti.size)) or_return
case Type_Info_String:
if info.is_cstring {
try_copy_byte(i, buf, 'c') or_return
write_byte(i, buf, 'c') or_return
}
try_copy_string(i, buf, "string") or_return
write_string(i, buf, "string") or_return
switch info.encoding {
case .UTF_8: /**/
case .UTF_16: try_copy_string(i, buf, "16") or_return
case .UTF_16: write_string(i, buf, "16") or_return
}
case Type_Info_Boolean:
switch ti.id {
case bool: try_copy_string(i, buf, "bool") or_return
case bool: write_string(i, buf, "bool") or_return
case:
try_copy_byte(i, buf, 'b') or_return
try_copy_u64 (i, buf, u64(8*ti.size)) or_return
write_byte(i, buf, 'b') or_return
write_u64 (i, buf, u64(8*ti.size)) or_return
}
case Type_Info_Any:
try_copy_string(i, buf, "any") or_return
write_string(i, buf, "any") or_return
case Type_Info_Type_Id:
try_copy_string(i, buf, "typeid") or_return
write_string(i, buf, "typeid") or_return
case Type_Info_Pointer:
if info.elem == nil {
try_copy_string(i, buf, "rawptr") or_return
write_string(i, buf, "rawptr") or_return
} else {
try_copy_string (i, buf, "^") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "^") or_return
write_write_type(i, buf, info.elem) or_return
}
case Type_Info_Multi_Pointer:
try_copy_string (i, buf, "[^]") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "[^]") or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Soa_Pointer:
try_copy_string (i, buf, "#soa ^") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "#soa ^") or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Procedure:
try_copy_string(i, buf, "proc") or_return
write_string(i, buf, "proc") or_return
if info.params == nil {
try_copy_string(i, buf, "()") or_return
write_string(i, buf, "()") or_return
} else {
t := info.params.variant.(Type_Info_Parameters)
try_copy_byte(i, buf, '(') or_return
write_byte(i, buf, '(') or_return
for t, j in t.types {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
try_copy_write_type(i, buf, t) or_return
if j > 0 { write_string(i, buf, ", ") or_return }
write_write_type(i, buf, t) or_return
}
try_copy_string(i, buf, ")") or_return
write_string(i, buf, ")") or_return
}
if info.results != nil {
try_copy_string (i, buf, " -> ") or_return
try_copy_write_type(i, buf, info.results) or_return
write_string (i, buf, " -> ") or_return
write_write_type(i, buf, info.results) or_return
}
case Type_Info_Parameters:
count := len(info.names)
if count != 1 { try_copy_byte(i, buf, '(') or_return }
if count != 1 { write_byte(i, buf, '(') or_return }
for name, j in info.names {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
if j > 0 { write_string(i, buf, ", ") or_return }
t := info.types[j]
if len(name) > 0 {
try_copy_string(i, buf, name) or_return
try_copy_string(i, buf, ": ") or_return
write_string(i, buf, name) or_return
write_string(i, buf, ": ") or_return
}
try_copy_write_type(i, buf, t) or_return
write_write_type(i, buf, t) or_return
}
if count != 1 { try_copy_string(i, buf, ")") or_return }
if count != 1 { write_string(i, buf, ")") or_return }
case Type_Info_Array:
try_copy_byte (i, buf, '[') or_return
try_copy_u64 (i, buf, u64(info.count)) or_return
try_copy_byte (i, buf, ']') or_return
try_copy_write_type(i, buf, info.elem) or_return
write_byte (i, buf, '[') or_return
write_u64 (i, buf, u64(info.count)) or_return
write_byte (i, buf, ']') or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Enumerated_Array:
if info.is_sparse {
try_copy_string(i, buf, "#sparse") or_return
write_string(i, buf, "#sparse") or_return
}
try_copy_byte (i, buf, '[') or_return
try_copy_write_type(i, buf, info.index) or_return
try_copy_byte (i, buf, ']') or_return
try_copy_write_type(i, buf, info.elem) or_return
write_byte (i, buf, '[') or_return
write_write_type(i, buf, info.index) or_return
write_byte (i, buf, ']') or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Dynamic_Array:
try_copy_string (i, buf, "[dynamic]") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "[dynamic]") or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Slice:
try_copy_string (i, buf, "[]") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "[]") or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Map:
try_copy_string (i, buf, "map[") or_return
try_copy_write_type(i, buf, info.key) or_return
try_copy_byte (i, buf, ']') or_return
try_copy_write_type(i, buf, info.value) or_return
write_string (i, buf, "map[") or_return
write_write_type(i, buf, info.key) or_return
write_byte (i, buf, ']') or_return
write_write_type(i, buf, info.value) or_return
case Type_Info_Struct:
switch info.soa_kind {
case .None: // Ignore
case .Fixed:
try_copy_string (i, buf, "#soa[") or_return
try_copy_u64 (i, buf, u64(info.soa_len)) or_return
try_copy_byte (i, buf, ']') or_return
try_copy_write_type(i, buf, info.soa_base_type) or_return
write_string (i, buf, "#soa[") or_return
write_u64 (i, buf, u64(info.soa_len)) or_return
write_byte (i, buf, ']') or_return
write_write_type(i, buf, info.soa_base_type) or_return
return true
case .Slice:
try_copy_string (i, buf, "#soa[]") or_return
try_copy_write_type(i, buf, info.soa_base_type) or_return
write_string (i, buf, "#soa[]") or_return
write_write_type(i, buf, info.soa_base_type) or_return
return true
case .Dynamic:
try_copy_string (i, buf, "#soa[dynamic]") or_return
try_copy_write_type(i, buf, info.soa_base_type) or_return
write_string (i, buf, "#soa[dynamic]") or_return
write_write_type(i, buf, info.soa_base_type) or_return
return true
}
try_copy_string(i, buf, "struct ") or_return
if .packed in info.flags { try_copy_string(i, buf, "#packed ") or_return }
if .raw_union in info.flags { try_copy_string(i, buf, "#raw_union ") or_return }
if .all_or_none in info.flags { try_copy_string(i, buf, "#all_or_none ") or_return }
write_string(i, buf, "struct ") or_return
if .packed in info.flags { write_string(i, buf, "#packed ") or_return }
if .raw_union in info.flags { write_string(i, buf, "#raw_union ") or_return }
if .all_or_none in info.flags { write_string(i, buf, "#all_or_none ") or_return }
if .align in info.flags {
try_copy_string(i, buf, "#align(") or_return
try_copy_u64(i, buf, u64(ti.align)) or_return
try_copy_string(i, buf, ") ") or_return
write_string(i, buf, "#align(") or_return
write_u64(i, buf, u64(ti.align)) or_return
write_string(i, buf, ") ") or_return
}
try_copy_byte(i, buf, '{') or_return
write_byte(i, buf, '{') or_return
for name, j in info.names[:info.field_count] {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
try_copy_string (i, buf, name) or_return
try_copy_string (i, buf, ": ") or_return
try_copy_write_type(i, buf, info.types[j]) or_return
if j > 0 { write_string(i, buf, ", ") or_return }
write_string (i, buf, name) or_return
write_string (i, buf, ": ") or_return
write_write_type(i, buf, info.types[j]) or_return
}
try_copy_byte(i, buf, '}') or_return
write_byte(i, buf, '}') or_return
case Type_Info_Union:
try_copy_string(i, buf, "union ") or_return
write_string(i, buf, "union ") or_return
if info.custom_align {
try_copy_string(i, buf, "#align(") or_return
try_copy_u64 (i, buf, u64(ti.align)) or_return
try_copy_string(i, buf, ") ") or_return
write_string(i, buf, "#align(") or_return
write_u64 (i, buf, u64(ti.align)) or_return
write_string(i, buf, ") ") or_return
}
if info.no_nil {
try_copy_string(i, buf, "#no_nil ") or_return
write_string(i, buf, "#no_nil ") or_return
}
try_copy_byte(i, buf, '{') or_return
write_byte(i, buf, '{') or_return
for variant, j in info.variants {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
try_copy_write_type(i, buf, variant) or_return
if j > 0 { write_string(i, buf, ", ") or_return }
write_write_type(i, buf, variant) or_return
}
try_copy_string(i, buf, "}") or_return
write_string(i, buf, "}") or_return
case Type_Info_Enum:
try_copy_string (i, buf, "enum ") or_return
try_copy_write_type(i, buf, info.base) or_return
try_copy_string (i, buf, " {") or_return
write_string (i, buf, "enum ") or_return
write_write_type(i, buf, info.base) or_return
write_string (i, buf, " {") or_return
for name, j in info.names {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
try_copy_string(i, buf, name) or_return
if j > 0 { write_string(i, buf, ", ") or_return }
write_string(i, buf, name) or_return
}
try_copy_string(i, buf, "}") or_return
write_string(i, buf, "}") or_return
case Type_Info_Bit_Set:
try_copy_string(i, buf, "bit_set[") or_return
write_string(i, buf, "bit_set[") or_return
#partial switch elem in type_info_base(info.elem).variant {
case Type_Info_Enum:
try_copy_write_type(i, buf, info.elem) or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Rune:
try_copy_encoded_rune(i, buf, rune(info.lower)) or_return
try_copy_string (i, buf, "..") or_return
try_copy_encoded_rune(i, buf, rune(info.upper)) or_return
write_encoded_rune(i, buf, rune(info.lower)) or_return
write_string (i, buf, "..") or_return
write_encoded_rune(i, buf, rune(info.upper)) or_return
case:
try_copy_i64 (i, buf, info.lower) or_return
try_copy_string(i, buf, "..") or_return
try_copy_i64 (i, buf, info.upper) or_return
write_i64 (i, buf, info.lower) or_return
write_string(i, buf, "..") or_return
write_i64 (i, buf, info.upper) or_return
}
if info.underlying != nil {
try_copy_string (i, buf, "; ") or_return
try_copy_write_type(i, buf, info.underlying) or_return
write_string (i, buf, "; ") or_return
write_write_type(i, buf, info.underlying) or_return
}
try_copy_byte(i, buf, ']') or_return
write_byte(i, buf, ']') or_return
case Type_Info_Bit_Field:
try_copy_string (i, buf, "bit_field ") or_return
try_copy_write_type(i, buf, info.backing_type) or_return
try_copy_string (i, buf, " {") or_return
write_string (i, buf, "bit_field ") or_return
write_write_type(i, buf, info.backing_type) or_return
write_string (i, buf, " {") or_return
for name, j in info.names[:info.field_count] {
if j > 0 { try_copy_string(i, buf, ", ") or_return }
try_copy_string (i, buf, name) or_return
try_copy_string (i, buf, ": ") or_return
try_copy_write_type(i, buf, info.types[j]) or_return
try_copy_string (i, buf, " | ") or_return
try_copy_u64 (i, buf, u64(info.bit_sizes[j])) or_return
if j > 0 { write_string(i, buf, ", ") or_return }
write_string (i, buf, name) or_return
write_string (i, buf, ": ") or_return
write_write_type(i, buf, info.types[j]) or_return
write_string (i, buf, " | ") or_return
write_u64 (i, buf, u64(info.bit_sizes[j])) or_return
}
try_copy_byte(i, buf, '}') or_return
write_byte(i, buf, '}') or_return
case Type_Info_Simd_Vector:
try_copy_string (i, buf, "#simd[") or_return
try_copy_u64 (i, buf, u64(info.count)) or_return
try_copy_byte (i, buf, ']') or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "#simd[") or_return
write_u64 (i, buf, u64(info.count)) or_return
write_byte (i, buf, ']') or_return
write_write_type(i, buf, info.elem) or_return
case Type_Info_Matrix:
if info.layout == .Row_Major {
try_copy_string(i, buf, "#row_major ") or_return
write_string(i, buf, "#row_major ") or_return
}
try_copy_string (i, buf, "matrix[") or_return
try_copy_u64 (i, buf, u64(info.row_count)) or_return
try_copy_string (i, buf, ", ") or_return
try_copy_u64 (i, buf, u64(info.column_count)) or_return
try_copy_string (i, buf, "]") or_return
try_copy_write_type(i, buf, info.elem) or_return
write_string (i, buf, "matrix[") or_return
write_u64 (i, buf, u64(info.row_count)) or_return
write_string (i, buf, ", ") or_return
write_u64 (i, buf, u64(info.column_count)) or_return
write_string (i, buf, "]") or_return
write_write_type(i, buf, info.elem) or_return
}
return true
}