From 5320feb6737c4d89ce54fda463ea8ff8b8200dba Mon Sep 17 00:00:00 2001 From: Jeroen van Rijn Date: Tue, 7 Oct 2025 22:54:35 +0200 Subject: [PATCH] Add reflect.as_string16 and fix typos --- core/reflect/reflect.odin | 70 +++++++++++++++++++++++++-------------- 1 file changed, 46 insertions(+), 24 deletions(-) diff --git a/core/reflect/reflect.odin b/core/reflect/reflect.odin index 86fa9d4b5..5fbff08c2 100644 --- a/core/reflect/reflect.odin +++ b/core/reflect/reflect.odin @@ -153,7 +153,7 @@ when !ODIN_NO_RTTI { } -// any_base returns an `any` whether the `typeid` has been replaced with the `base-type` equivalent +// any_base returns an `any` where the `typeid` has been replaced with the `base-type` equivalent @(require_results) any_base :: proc(v: any) -> any { v := v @@ -163,7 +163,7 @@ any_base :: proc(v: any) -> any { return v } -// any_core returns an `any` whether the `typeid` has been replaced with the `core-type` equivalent +// any_core returns an `any` where the `typeid` has been replaced with the `core-type` equivalent @(require_results) any_core :: proc(v: any) -> any { v := v @@ -368,7 +368,7 @@ capacity :: proc(val: any) -> int { } -// Dynamically indexes `any` as an indexable-type if possbiel. Returns `nil` if not possible +// Dynamically indexes `any` as an indexable-type if possible. Returns `nil` if not possible @(require_results) index :: proc(val: any, i: int, loc := #caller_location) -> any { if val == nil { return nil } @@ -455,13 +455,13 @@ deref :: proc(val: any) -> any { -// Struct_Tag represents the type of the string of a struct field +// `Struct_Tag` represents the type of the `string` of a struct field // -// Through convention, tags are the concatenation of optionally space separationed key:"value" pairs. +// Through convention, tags are the concatenation of optionally space-separated key:"value" pairs. // Each key is a non-empty string which contains no control characters other than space, quotes, and colon. Struct_Tag :: distinct string -// Struct_Field represents a information of a field of a struct +// `Struct_Field` represents a information of a field of a struct Struct_Field :: struct { name: string, type: ^Type_Info, @@ -541,8 +541,8 @@ struct_field_value_by_name :: proc(a: any, field: string, allow_using := false) // Returns an `any` of a struct field specified by a `Struct_Field` // Example: -// v := struct_field_value_by_name(the_struct, field) -// nested_value_through_using := struct_field_value_by_name(the_struct, field, allow_using=true) +// field := struct_field_value_by_name(the_struct, "field_name") +// value_by_field := struct_field_value(the_struct, field) @(require_results) struct_field_value :: proc(a: any, field: Struct_Field) -> any { if a == nil { return nil } @@ -573,7 +573,7 @@ struct_field_types :: proc(T: typeid) -> []^Type_Info { } -// Returns a `[]Struct_Type` of the tags of the struct fields of type `T` +// Returns a `[]Struct_Tag` of the tags of the struct fields of type `T` @(require_results) struct_field_tags :: proc(T: typeid) -> []Struct_Tag { ti := runtime.type_info_base(type_info_of(T)) @@ -673,23 +673,23 @@ struct_fields_zipped :: proc(T: typeid) -> (fields: #soa[]Struct_Field) { // struct_tag_get returns the value associated with a key in the tag string. -// If the key is present in the tag, the value (which might be empty) is return. Otherwise an empty string is returned. +// If the key is present in the tag, the value (which might be empty) is returned. Otherwise an empty string is returned. // This is just a wrapper around `struct_tag_lookup` with the `ok` value being ignored. // -// The convention for is usually of the form: +// The convention for struct tags is usually of the form: // // `key:"value" another:"set" and:"whatever"` @(require_results) struct_tag_get :: proc(tag: Struct_Tag, key: string) -> (value: string) { v, _ := struct_tag_lookup(tag, key) - return string(v) + return v } // struct_tag_lookup returns the value associated with a key in the tag string. // If the key is present in the tag, the value (which might be empty) is return. Otherwise an empty string is returned. // The `ok` value returns whether the value was explicit set in the tag string. // -// The convention for is usually of the form: +// The convention for struct tags is usually of the form: // // `key:"value" another:"set" and:"whatever"` @(require_results) @@ -770,7 +770,7 @@ enum_string :: proc(a: any) -> string { return "" } -// Given a enum type and a value name, get the enum value. +// Given an enum type and a value name, get the enum value. @(require_results) enum_from_name :: proc($Enum_Type: typeid, name: string) -> (value: Enum_Type, ok: bool) { ti := type_info_base(type_info_of(Enum_Type)) @@ -917,7 +917,7 @@ type_info_union_is_pure_maybe :: proc(info: runtime.Type_Info_Union) -> bool { return len(info.variants) == 1 && is_pointer_internally(info.variants[0]) } -// Returns `typeid` of a any-encoded union type. Panics if a union was not passed. +// UNSAFE: Returns `typeid` of a any-encoded union type. Panics if a union was not passed. @(require_results) union_variant_typeid :: proc(a: any) -> typeid { if a == nil { return nil } @@ -1003,7 +1003,7 @@ get_union_variant :: proc(a: any) -> any { return any{a.data, id} } -// Converts a pointer to a union to a union containing the pointers to the variant types, and stores a pointer of the variant value in the new union +// Converts a pointer to a union, to a union containing the pointers to the variant types, and stores a pointer of the variant value in the new union // // Example: // val: union{i32, f32, string} @@ -1114,7 +1114,7 @@ set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) { panic("expected a union to reflect.set_union_variant_type_info") } -// UNSAFE: Manually set the variant value of a union using an any. Panics if a union was not passed. +// UNSAFE: Manually set the variant value of a union using an `any`. Panics if a union was not passed. set_union_value :: proc(dst: any, value: any) -> bool { if dst == nil { return false } @@ -1153,7 +1153,7 @@ set_union_value :: proc(dst: any, value: any) -> bool { panic("expected a union to reflect.set_union_variant_typeid") } -// Checks to see if the data stored is a bit_set and is big_ending. Panics if a bit_set was not passed. +// UNSAFE: Checks to see if the data stored is a `bit_set` and is big endian. Panics if a `bit_set` was not passed. @(require_results) bit_set_is_big_endian :: proc(value: any, loc := #caller_location) -> bool { if value == nil { return ODIN_ENDIAN == .Big } @@ -1185,7 +1185,7 @@ Bit_Field :: struct { tag: Struct_Tag, } -// Returns the fields of a bit_field type `T` as an `#soa` slice. +// Returns the fields of a `bit_field` type `T` as an `#soa` slice. // This is useful to iterate over. // Example: // for field, i in reflect.bit_fields_zipped(Foo_Bit_Field) { ... } @@ -1204,7 +1204,7 @@ bit_fields_zipped :: proc(T: typeid) -> (fields: #soa[]Bit_Field) { return nil } -// bit_field_names returns a `[]string` of the field names of a bit_field type `T` +// bit_field_names returns a `[]string` of the field names of a `bit_field` type `T` @(require_results) bit_field_names :: proc(T: typeid) -> []string { ti := runtime.type_info_base(type_info_of(T)) @@ -1214,7 +1214,7 @@ bit_field_names :: proc(T: typeid) -> []string { return nil } -// bit_field_types returns a `[]^Type_Info` of the field representation types of a bit_field type `T`, not the backing integer-bit-width types +// bit_field_types returns a `[]^Type_Info` of the field representation types of a `bit_field` type `T`, not the backing integer-bit-width types @(require_results) bit_field_types :: proc(T: typeid) -> []^Type_Info { ti := runtime.type_info_base(type_info_of(T)) @@ -1224,7 +1224,7 @@ bit_field_types :: proc(T: typeid) -> []^Type_Info { return nil } -// bit_field_types returns a `[]uintptr` of the field bit-width-sizes of a bit_field type `T` +// bit_field_types returns a `[]uintptr` of the field bit-width-sizes of a `bit_field` type `T` @(require_results) bit_field_sizes :: proc(T: typeid) -> []uintptr { ti := runtime.type_info_base(type_info_of(T)) @@ -1234,7 +1234,7 @@ bit_field_sizes :: proc(T: typeid) -> []uintptr { return nil } -// bit_field_types returns a `[]uintptr` of the field offsets in bits of a bit_field type `T` +// bit_field_types returns a `[]uintptr` of the field offsets in bits of a `bit_field` type `T` @(require_results) bit_field_offsets :: proc(T: typeid) -> []uintptr { ti := runtime.type_info_base(type_info_of(T)) @@ -1244,7 +1244,7 @@ bit_field_offsets :: proc(T: typeid) -> []uintptr { return nil } -// bit_field_types returns a `[]Struct_Tag` of the field tags of a bit_field type `T` +// bit_field_types returns a `[]Struct_Tag` of the field tags of a `bit_field` type `T` @(require_results) bit_field_tags :: proc(T: typeid) -> []Struct_Tag { ti := runtime.type_info_base(type_info_of(T)) @@ -1655,6 +1655,27 @@ as_string :: proc(a: any) -> (value: string, valid: bool) { return } +// as_string16 attempts to convert an `any` to a `string16`. +@(require_results) +as_string16 :: proc(a: any) -> (value: string16, valid: bool) { + if a == nil { return } + a := a + ti := runtime.type_info_core(type_info_of(a.id)) + a.id = ti.id + + #partial switch info in ti.variant { + case Type_Info_String: + valid = true + switch v in a { + case string16: value = v + case cstring16: value = string16(v) + case: valid = false + } + } + + return +} + @(require_results) relative_pointer_to_absolute_raw :: proc(data: rawptr, base_integer_id: typeid) -> rawptr { _handle :: proc(ptr: ^$T) -> rawptr where intrinsics.type_is_integer(T) { @@ -1770,6 +1791,7 @@ DEFAULT_EQUAL_MAX_RECURSION_LEVEL :: 32 not_equal :: proc(a, b: any, including_indirect_array_recursion := false, recursion_level := 0) -> bool { return !equal(a, b, including_indirect_array_recursion, recursion_level) } + // Checks to see if two `any` values are semantically equivalent @(require_results) equal :: proc(a, b: any, including_indirect_array_recursion := false, recursion_level := 0) -> bool {