ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-31 03:40:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into bill/new-slice-sort

Browse Source
This commit is contained in:
gingerBill
2025-10-08 11:34:53 +01:00
parent 13b8607cc3 c1054d4d8e
commit 7815d78f88
12 changed files with 1305 additions and 1124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/bytes/bytes.odin
+7 -2
View File
@@ -134,8 +134,13 @@ equal_fold :: proc(u, v: []byte) -> bool {
return false
}
// TODO(bill): Unicode folding
r := unicode.simple_fold(sr)
for r != sr && r < tr {
r = unicode.simple_fold(sr)
}
if r == tr {
continue loop
}
return false
}
core/container/rbtree/rbtree.odin
+4 -3
View File
@@ -128,9 +128,9 @@ find_value :: proc(t: ^$T/Tree($Key, $Value), key: Key) -> (value: Value, ok: bo
return
}
// find_or_insert attempts to insert the value into the tree, and returns
// the node, a boolean indicating if the value was inserted, and the
// node allocator error if relevant. If the value is already present, the existing node is updated.
// find_or_insert attempts to insert the key-value pair into the tree, and returns
// the node, a boolean indicating if a new node was inserted, and the
// node allocator error if relevant. If the key is already present, the existing node is updated and returned.
find_or_insert :: proc(t: ^$T/Tree($Key, $Value), key: Key, value: Value) -> (n: ^Node(Key, Value), inserted: bool, err: runtime.Allocator_Error) {
n_ptr := &t._root
for n_ptr^ != nil {
@@ -141,6 +141,7 @@ find_or_insert :: proc(t: ^$T/Tree($Key, $Value), key: Key, value: Value) -> (n:
case .Greater:
n_ptr = &n._right
case .Equal:
n.value = value
return
}
}
core/math/math.odin
+6 -1
View File
@@ -402,7 +402,12 @@ remap :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T)
if old_range == 0 {
return new_range / 2
}
return ((old_value - old_min) / old_range) * new_range + new_min
when intrinsics.type_is_integer(T) {
return (((old_value - old_min)) * new_range) / old_range + new_min
} else {
return ((old_value - old_min) / old_range) * new_range + new_min
}
}
@(require_results)
core/reflect/reflect.odin
+46 -24
View File
@@ -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 {
core/strings/strings.odin
+7 -2
View File
@@ -436,8 +436,13 @@ equal_fold :: proc(u, v: string) -> (res: bool) {
return false
}
// TODO(bill): Unicode folding
r := unicode.simple_fold(sr)
for r != sr && r < tr {
r = unicode.simple_fold(sr)
}
if r == tr {
continue loop
}
return false
}