mirror of
https://github.com/odin-lang/Odin.git
synced 2026-02-13 06:43:35 +00:00
Add reflect.{to_int, to_uint, to_i64, to_u64, to_f64}
This commit is contained in:
gingerBill
@@ -515,21 +515,7 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
|
||||
new_arg_index := arg_index;
|
||||
ok := true;
|
||||
if arg_index < len(args) {
|
||||
arg := args[arg_index];
|
||||
arg.id = runtime.typeid_base(arg.id);
|
||||
switch i in arg {
|
||||
case int: num = i;
|
||||
case i8: num = int(i);
|
||||
case i16: num = int(i);
|
||||
case i32: num = int(i);
|
||||
case i64: num = int(i);
|
||||
case u8: num = int(i);
|
||||
case u16: num = int(i);
|
||||
case u32: num = int(i);
|
||||
case u64: num = int(i);
|
||||
case:
|
||||
ok = false;
|
||||
}
|
||||
num, ok = reflect.to_int(args[arg_index]);
|
||||
}
|
||||
|
||||
if ok {
|
||||
@@ -939,53 +925,8 @@ enum_value_to_string :: proc(val: any) -> (string, bool) {
|
||||
case runtime.Type_Info_Enum:
|
||||
Enum_Value :: runtime.Type_Info_Enum_Value;
|
||||
|
||||
ev: Enum_Value;
|
||||
ok := true;
|
||||
|
||||
bv := v;
|
||||
bv.id = runtime.typeid_core(e.base.id);
|
||||
|
||||
switch i in bv {
|
||||
case i8: ev = Enum_Value(i);
|
||||
case i16: ev = Enum_Value(i);
|
||||
case i32: ev = Enum_Value(i);
|
||||
case i64: ev = Enum_Value(i);
|
||||
case i128: ev = Enum_Value(i);
|
||||
|
||||
case int: ev = Enum_Value(i);
|
||||
|
||||
case u8: ev = Enum_Value(i);
|
||||
case u16: ev = Enum_Value(i);
|
||||
case u32: ev = Enum_Value(i);
|
||||
case u64: ev = Enum_Value(i);
|
||||
case u128: ev = Enum_Value(i);
|
||||
case uint: ev = Enum_Value(i);
|
||||
|
||||
case uintptr: ev = Enum_Value(i);
|
||||
|
||||
case i16le: ev = Enum_Value(i);
|
||||
case i32le: ev = Enum_Value(i);
|
||||
case i64le: ev = Enum_Value(i);
|
||||
case i128le: ev = Enum_Value(i);
|
||||
|
||||
case u16le: ev = Enum_Value(i);
|
||||
case u32le: ev = Enum_Value(i);
|
||||
case u64le: ev = Enum_Value(i);
|
||||
case u128le: ev = Enum_Value(i);
|
||||
|
||||
case i16be: ev = Enum_Value(i);
|
||||
case i32be: ev = Enum_Value(i);
|
||||
case i64be: ev = Enum_Value(i);
|
||||
case i128be: ev = Enum_Value(i);
|
||||
|
||||
case u16be: ev = Enum_Value(i);
|
||||
case u32be: ev = Enum_Value(i);
|
||||
case u64be: ev = Enum_Value(i);
|
||||
case u128be: ev = Enum_Value(i);
|
||||
|
||||
case:
|
||||
ok = false;
|
||||
}
|
||||
ev_, ok := reflect.to_i64(val);
|
||||
ev := Enum_Value(ev_);
|
||||
|
||||
if ok {
|
||||
if len(e.values) == 0 {
|
||||
@@ -1768,30 +1709,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
|
||||
} else {
|
||||
len_ptr := uintptr(v.data) + uintptr(info.base_integer.size);
|
||||
len_any := any{rawptr(len_ptr), info.base_integer.id};
|
||||
len: int = 0;
|
||||
switch i in len_any {
|
||||
case u8: len = int(i);
|
||||
case u16: len = int(i);
|
||||
case u32: len = int(i);
|
||||
case u64: len = int(i);
|
||||
case i8: len = int(i);
|
||||
case i16: len = int(i);
|
||||
case i32: len = int(i);
|
||||
case i64: len = int(i);
|
||||
case u16le: len = int(i);
|
||||
case u32le: len = int(i);
|
||||
case u64le: len = int(i);
|
||||
case i16le: len = int(i);
|
||||
case i32le: len = int(i);
|
||||
case i64le: len = int(i);
|
||||
case u16be: len = int(i);
|
||||
case u32be: len = int(i);
|
||||
case u64be: len = int(i);
|
||||
case i16be: len = int(i);
|
||||
case i32be: len = int(i);
|
||||
case i64be: len = int(i);
|
||||
}
|
||||
|
||||
len, _ := reflect.to_int(len_any);
|
||||
slice_type := reflect.type_info_base(info.slice).variant.(runtime.Type_Info_Slice);
|
||||
|
||||
strings.write_byte(fi.buf, '[');
|
||||
|
||||
@@ -502,10 +502,9 @@ enum_string :: proc(a: any) -> string {
|
||||
if a == nil do return "";
|
||||
ti := runtime.type_info_base(type_info_of(a.id));
|
||||
if e, ok := ti.variant.(runtime.Type_Info_Enum); ok {
|
||||
for _, i in e.values {
|
||||
value := &e.values[i];
|
||||
n := mem.compare_byte_ptrs((^byte)(a.data), (^byte)(value), ti.size);
|
||||
if n == 0 {
|
||||
v, _ := to_i64(a);
|
||||
for value, i in e.values {
|
||||
if value == runtime.Type_Info_Enum_Value(v) {
|
||||
return e.names[i];
|
||||
}
|
||||
}
|
||||
@@ -522,21 +521,10 @@ enum_from_name :: proc($EnumType: typeid, name: string) -> (value: EnumType, ok:
|
||||
if eti, eti_ok := ti.variant.(runtime.Type_Info_Enum); eti_ok {
|
||||
for value_name, i in eti.names {
|
||||
if value_name != name do continue;
|
||||
value_union := eti.values[i];
|
||||
switch v in value_union {
|
||||
case rune: value = EnumType(v); ok = true;
|
||||
case u8: value = EnumType(v); ok = true;
|
||||
case u16: value = EnumType(v); ok = true;
|
||||
case u32: value = EnumType(v); ok = true;
|
||||
case u64: value = EnumType(v); ok = true;
|
||||
case uint: value = EnumType(v); ok = true;
|
||||
case uintptr: value = EnumType(v); ok = true;
|
||||
case i8: value = EnumType(v); ok = true;
|
||||
case i16: value = EnumType(v); ok = true;
|
||||
case i32: value = EnumType(v); ok = true;
|
||||
case i64: value = EnumType(v); ok = true;
|
||||
case int: value = EnumType(v); ok = true;
|
||||
}
|
||||
v := eti.values[i];
|
||||
value = EnumType(v);
|
||||
ok = true;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
panic("expected enum type to reflect.enum_from_name");
|
||||
@@ -579,3 +567,331 @@ union_variant_typeid :: proc(a: any) -> typeid {
|
||||
|
||||
return nil;
|
||||
}
|
||||
|
||||
|
||||
to_int :: proc(a: any) -> (value: int, valid: bool) {
|
||||
v: i64;
|
||||
v, valid = to_i64(a);
|
||||
value = int(v);
|
||||
return;
|
||||
}
|
||||
|
||||
to_uint :: proc(a: any) -> (value: uint, valid: bool) {
|
||||
v: u64;
|
||||
v, valid = to_u64(a);
|
||||
value = uint(v);
|
||||
return;
|
||||
}
|
||||
|
||||
to_i64 :: proc(a: any) -> (value: i64, valid: bool) {
|
||||
if a == nil do 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_Integer:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case i8: value = i64(v);
|
||||
case i16: value = i64(v);
|
||||
case i32: value = i64(v);
|
||||
case i64: value = i64(v);
|
||||
case i128: value = i64(v);
|
||||
|
||||
case u8: value = i64(v);
|
||||
case u16: value = i64(v);
|
||||
case u32: value = i64(v);
|
||||
case u64: value = i64(v);
|
||||
case u128: value = i64(v);
|
||||
|
||||
case u16le: value = i64(v);
|
||||
case u32le: value = i64(v);
|
||||
case u64le: value = i64(v);
|
||||
case u128le:value = i64(v);
|
||||
|
||||
case i16le: value = i64(v);
|
||||
case i32le: value = i64(v);
|
||||
case i64le: value = i64(v);
|
||||
case i128le:value = i64(v);
|
||||
|
||||
case u16be: value = i64(v);
|
||||
case u32be: value = i64(v);
|
||||
case u64be: value = i64(v);
|
||||
case u128be:value = i64(v);
|
||||
|
||||
case i16be: value = i64(v);
|
||||
case i32be: value = i64(v);
|
||||
case i64be: value = i64(v);
|
||||
case i128be:value = i64(v);
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Rune:
|
||||
r := a.(rune);
|
||||
value = i64(r);
|
||||
valid = true;
|
||||
|
||||
case Type_Info_Float:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case f32: value = i64(f32(v));
|
||||
case f64: value = i64(f64(v));
|
||||
case f32le: value = i64(f32(v));
|
||||
case f64le: value = i64(f64(v));
|
||||
case f32be: value = i64(f32(v));
|
||||
case f64be: value = i64(f64(v));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Boolean:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case bool: value = i64(bool(v));
|
||||
case b8: value = i64(bool(v));
|
||||
case b16: value = i64(bool(v));
|
||||
case b32: value = i64(bool(v));
|
||||
case b64: value = i64(bool(v));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Complex:
|
||||
switch v in a {
|
||||
case complex64:
|
||||
if imag(v) == 0 {
|
||||
value = i64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case complex128:
|
||||
if imag(v) == 0 {
|
||||
value = i64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
case Type_Info_Quaternion:
|
||||
switch v in a {
|
||||
case quaternion128:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = i64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case quaternion256:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = i64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
to_u64 :: proc(a: any) -> (value: u64, valid: bool) {
|
||||
if a == nil do 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_Integer:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case i8: value = u64(v);
|
||||
case i16: value = u64(v);
|
||||
case i32: value = u64(v);
|
||||
case i64: value = u64(v);
|
||||
case i128: value = u64(v);
|
||||
|
||||
case u8: value = u64(v);
|
||||
case u16: value = u64(v);
|
||||
case u32: value = u64(v);
|
||||
case u64: value = u64(v);
|
||||
case u128: value = u64(v);
|
||||
|
||||
case u16le: value = u64(v);
|
||||
case u32le: value = u64(v);
|
||||
case u64le: value = u64(v);
|
||||
case u128le:value = u64(v);
|
||||
|
||||
case i16le: value = u64(v);
|
||||
case i32le: value = u64(v);
|
||||
case i64le: value = u64(v);
|
||||
case i128le:value = u64(v);
|
||||
|
||||
case u16be: value = u64(v);
|
||||
case u32be: value = u64(v);
|
||||
case u64be: value = u64(v);
|
||||
case u128be:value = u64(v);
|
||||
|
||||
case i16be: value = u64(v);
|
||||
case i32be: value = u64(v);
|
||||
case i64be: value = u64(v);
|
||||
case i128be:value = u64(v);
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Rune:
|
||||
r := a.(rune);
|
||||
value = u64(r);
|
||||
valid = true;
|
||||
|
||||
case Type_Info_Float:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case f32: value = u64(f32(v));
|
||||
case f64: value = u64(f64(v));
|
||||
case f32le: value = u64(f32(v));
|
||||
case f64le: value = u64(f64(v));
|
||||
case f32be: value = u64(f32(v));
|
||||
case f64be: value = u64(f64(v));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Boolean:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case bool: value = u64(bool(v));
|
||||
case b8: value = u64(bool(v));
|
||||
case b16: value = u64(bool(v));
|
||||
case b32: value = u64(bool(v));
|
||||
case b64: value = u64(bool(v));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Complex:
|
||||
switch v in a {
|
||||
case complex64:
|
||||
if imag(v) == 0 {
|
||||
value = u64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case complex128:
|
||||
if imag(v) == 0 {
|
||||
value = u64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
case Type_Info_Quaternion:
|
||||
switch v in a {
|
||||
case quaternion128:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = u64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case quaternion256:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = u64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
to_f64 :: proc(a: any) -> (value: f64, valid: bool) {
|
||||
if a == nil do 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_Integer:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case i8: value = f64(v);
|
||||
case i16: value = f64(v);
|
||||
case i32: value = f64(v);
|
||||
case i64: value = f64(v);
|
||||
case i128: value = f64(v);
|
||||
|
||||
case u8: value = f64(v);
|
||||
case u16: value = f64(v);
|
||||
case u32: value = f64(v);
|
||||
case u64: value = f64(v);
|
||||
case u128: value = f64(v);
|
||||
|
||||
case u16le: value = f64(v);
|
||||
case u32le: value = f64(v);
|
||||
case u64le: value = f64(v);
|
||||
case u128le:value = f64(v);
|
||||
|
||||
case i16le: value = f64(v);
|
||||
case i32le: value = f64(v);
|
||||
case i64le: value = f64(v);
|
||||
case i128le:value = f64(v);
|
||||
|
||||
case u16be: value = f64(v);
|
||||
case u32be: value = f64(v);
|
||||
case u64be: value = f64(v);
|
||||
case u128be:value = f64(v);
|
||||
|
||||
case i16be: value = f64(v);
|
||||
case i32be: value = f64(v);
|
||||
case i64be: value = f64(v);
|
||||
case i128be:value = f64(v);
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Rune:
|
||||
r := a.(rune);
|
||||
value = f64(i32(r));
|
||||
valid = true;
|
||||
|
||||
case Type_Info_Float:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case f32: value = f64(f32(v));
|
||||
case f64: value = f64(f64(v));
|
||||
case f32le: value = f64(f32(v));
|
||||
case f64le: value = f64(f64(v));
|
||||
case f32be: value = f64(f32(v));
|
||||
case f64be: value = f64(f64(v));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Boolean:
|
||||
valid = true;
|
||||
switch v in a {
|
||||
case bool: value = f64(i32(bool(v)));
|
||||
case b8: value = f64(i32(bool(v)));
|
||||
case b16: value = f64(i32(bool(v)));
|
||||
case b32: value = f64(i32(bool(v)));
|
||||
case b64: value = f64(i32(bool(v)));
|
||||
case: valid = false;
|
||||
}
|
||||
|
||||
case Type_Info_Complex:
|
||||
switch v in a {
|
||||
case complex64:
|
||||
if imag(v) == 0 {
|
||||
value = f64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case complex128:
|
||||
if imag(v) == 0 {
|
||||
value = f64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
case Type_Info_Quaternion:
|
||||
switch v in a {
|
||||
case quaternion128:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = f64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
case quaternion256:
|
||||
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
|
||||
value = f64(real(v));
|
||||
valid = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user