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

Remove usage of do in core library

Browse Source
This commit is contained in:
gingerBill
2020-09-23 17:17:14 +01:00
parent 4844dd4d96
commit fc4fdd588e
45 changed files with 960 additions and 520 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/reflect/reflect.odin
+35 -21
View File
@@ -116,7 +116,7 @@ backing_type_kind :: proc(T: typeid) -> Type_Kind {
type_info_base :: proc(info: ^runtime.Type_Info) -> ^runtime.Type_Info {
if info == nil do return nil;
if info == nil { return nil; }
base := info;
loop: for {
@@ -130,7 +130,7 @@ type_info_base :: proc(info: ^runtime.Type_Info) -> ^runtime.Type_Info {
type_info_core :: proc(info: ^runtime.Type_Info) -> ^runtime.Type_Info {
if info == nil do return nil;
if info == nil { return nil; }
base := info;
loop: for {
@@ -159,7 +159,7 @@ typeid_base_without_enum :: typeid_core;
typeid_elem :: proc(id: typeid) -> typeid {
ti := type_info_of(id);
if ti == nil do return nil;
if ti == nil { return nil; }
bits := 8*ti.size;
@@ -219,14 +219,16 @@ is_nil :: proc(v: any) -> bool {
if data != nil {
return true;
}
for v in data do if v != 0 {
return false;
for v in data {
if v != 0 {
return false;
}
}
return true;
}
length :: proc(val: any) -> int {
if val == nil do return 0;
if val == nil { return 0; }
#partial switch a in type_info_of(val.id).variant {
case Type_Info_Named:
@@ -261,7 +263,7 @@ length :: proc(val: any) -> int {
}
capacity :: proc(val: any) -> int {
if val == nil do return 0;
if val == nil { return 0; }
#partial switch a in type_info_of(val.id).variant {
case Type_Info_Named:
@@ -287,7 +289,7 @@ capacity :: proc(val: any) -> int {
index :: proc(val: any, i: int, loc := #caller_location) -> any {
if val == nil do return nil;
if val == nil { return nil; }
#partial switch a in type_info_of(val.id).variant {
case Type_Info_Named:
@@ -327,7 +329,7 @@ index :: proc(val: any, i: int, loc := #caller_location) -> any {
return any{data, a.elem.id};
case Type_Info_String:
if a.is_cstring do return nil;
if a.is_cstring { return nil; }
raw := (^mem.Raw_String)(val.data);
runtime.bounds_check_error_loc(loc, i, raw.len);
@@ -380,7 +382,7 @@ struct_field_by_name :: proc(T: typeid, name: string) -> (field: Struct_Field) {
}
struct_field_value_by_name :: proc(a: any, field: string, recurse := false) -> any {
if a == nil do return nil;
if a == nil { return nil; }
ti := runtime.type_info_base(type_info_of(a.id));
@@ -457,7 +459,9 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
i += 1;
}
t = t[i:];
if len(t) == 0 do break;
if len(t) == 0 {
break;
}
i = 0;
loop: for i < len(t) {
@@ -470,8 +474,12 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
i += 1;
}
if i == 0 do break;
if i+1 >= len(t) do break;
if i == 0 {
break;
}
if i+1 >= len(t) {
break;
}
if t[i] != ':' || t[i+1] != '"' {
break;
@@ -481,11 +489,15 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
i = 1;
for i < len(t) && t[i] != '"' { // find closing quote
if t[i] == '\\' do i += 1; // Skip escaped characters
if t[i] == '\\' {
i += 1; // Skip escaped characters
}
i += 1;
}
if i >= len(t) do break;
if i >= len(t) {
break;
}
val := string(t[:i+1]);
t = t[i+1:];
@@ -499,7 +511,7 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
enum_string :: proc(a: any) -> string {
if a == nil do return "";
if a == nil { return ""; }
ti := runtime.type_info_base(type_info_of(a.id));
if e, ok := ti.variant.(runtime.Type_Info_Enum); ok {
v, _ := as_i64(a);
@@ -520,7 +532,9 @@ enum_from_name :: proc($EnumType: typeid, name: string) -> (value: EnumType, ok:
ti := type_info_base(type_info_of(EnumType));
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;
if value_name != name {
continue;
}
v := eti.values[i];
value = EnumType(v);
ok = true;
@@ -538,7 +552,7 @@ union_variant_type_info :: proc(a: any) -> ^runtime.Type_Info {
}
union_variant_typeid :: proc(a: any) -> typeid {
if a == nil do return nil;
if a == nil { return nil; }
ti := runtime.type_info_base(type_info_of(a.id));
if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
@@ -584,7 +598,7 @@ as_uint :: proc(a: any) -> (value: uint, valid: bool) {
}
as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
if a == nil do return;
if a == nil { return; }
a := a;
ti := runtime.type_info_core(type_info_of(a.id));
a.id = ti.id;
@@ -691,7 +705,7 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
}
as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
if a == nil do return;
if a == nil { return; }
a := a;
ti := runtime.type_info_core(type_info_of(a.id));
a.id = ti.id;
@@ -799,7 +813,7 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
if a == nil do return;
if a == nil { return; }
a := a;
ti := runtime.type_info_core(type_info_of(a.id));
a.id = ti.id;
core/reflect/types.odin
+72 -68
View File
@@ -3,7 +3,9 @@ package reflect
import "core:strings"
are_types_identical :: proc(a, b: ^Type_Info) -> bool {
if a == b do return true;
if a == b {
return true;
}
if (a == nil && b != nil) ||
(a != nil && b == nil) {
@@ -19,12 +21,12 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
switch x in a.variant {
case Type_Info_Named:
y, ok := b.variant.(Type_Info_Named);
if !ok do return false;
if !ok { return false; }
return x.base == y.base;
case Type_Info_Integer:
y, ok := b.variant.(Type_Info_Integer);
if !ok do return false;
if !ok { return false; }
return x.signed == y.signed && x.endianness == y.endianness;
case Type_Info_Rune:
@@ -61,12 +63,12 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
case Type_Info_Pointer:
y, ok := b.variant.(Type_Info_Pointer);
if !ok do return false;
if !ok { return false; }
return are_types_identical(x.elem, y.elem);
case Type_Info_Procedure:
y, ok := b.variant.(Type_Info_Procedure);
if !ok do return false;
if !ok { return false; }
switch {
case x.variadic != y.variadic,
x.convention != y.convention:
@@ -77,31 +79,31 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
case Type_Info_Array:
y, ok := b.variant.(Type_Info_Array);
if !ok do return false;
if x.count != y.count do return false;
if !ok { return false; }
if x.count != y.count { return false; }
return are_types_identical(x.elem, y.elem);
case Type_Info_Enumerated_Array:
y, ok := b.variant.(Type_Info_Enumerated_Array);
if !ok do return false;
if x.count != y.count do return false;
if !ok { return false; }
if x.count != y.count { return false; }
return are_types_identical(x.index, y.index) &&
are_types_identical(x.elem, y.elem);
case Type_Info_Dynamic_Array:
y, ok := b.variant.(Type_Info_Dynamic_Array);
if !ok do return false;
if !ok { return false; }
return are_types_identical(x.elem, y.elem);
case Type_Info_Slice:
y, ok := b.variant.(Type_Info_Slice);
if !ok do return false;
if !ok { return false; }
return are_types_identical(x.elem, y.elem);
case Type_Info_Tuple:
y, ok := b.variant.(Type_Info_Tuple);
if !ok do return false;
if len(x.types) != len(y.types) do return false;
if !ok { return false; }
if len(x.types) != len(y.types) { return false; }
for _, i in x.types {
xt, yt := x.types[i], y.types[i];
if !are_types_identical(xt, yt) {
@@ -112,7 +114,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
case Type_Info_Struct:
y, ok := b.variant.(Type_Info_Struct);
if !ok do return false;
if !ok { return false; }
switch {
case len(x.types) != len(y.types),
x.is_packed != y.is_packed,
@@ -128,20 +130,20 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
xt, yt := x.types[i], y.types[i];
xl, yl := x.tags[i], y.tags[i];
if xn != yn do return false;
if !are_types_identical(xt, yt) do return false;
if xl != yl do return false;
if xn != yn { return false; }
if !are_types_identical(xt, yt) { return false; }
if xl != yl { return false; }
}
return true;
case Type_Info_Union:
y, ok := b.variant.(Type_Info_Union);
if !ok do return false;
if len(x.variants) != len(y.variants) do return false;
if !ok { return false; }
if len(x.variants) != len(y.variants) { return false; }
for _, i in x.variants {
xv, yv := x.variants[i], y.variants[i];
if !are_types_identical(xv, yv) do return false;
if !are_types_identical(xv, yv) { return false; }
}
return true;
@@ -151,48 +153,48 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
case Type_Info_Map:
y, ok := b.variant.(Type_Info_Map);
if !ok do return false;
if !ok { return false; }
return are_types_identical(x.key, y.key) && are_types_identical(x.value, y.value);
case Type_Info_Bit_Field:
y, ok := b.variant.(Type_Info_Bit_Field);
if !ok do return false;
if len(x.names) != len(y.names) do return false;
if !ok { return false; }
if len(x.names) != len(y.names) { return false; }
for _, i in x.names {
xb, yb := x.bits[i], y.bits[i];
xo, yo := x.offsets[i], y.offsets[i];
xn, yn := x.names[i], y.names[i];
if xb != yb do return false;
if xo != yo do return false;
if xn != yn do return false;
if xb != yb { return false; }
if xo != yo { return false; }
if xn != yn { return false; }
}
return true;
case Type_Info_Bit_Set:
y, ok := b.variant.(Type_Info_Bit_Set);
if !ok do return false;
if !ok { return false; }
return x.elem == y.elem && x.lower == y.lower && x.upper == y.upper;
case Type_Info_Opaque:
y, ok := b.variant.(Type_Info_Opaque);
if !ok do return false;
if !ok { return false; }
return x.elem == y.elem;
case Type_Info_Simd_Vector:
y, ok := b.variant.(Type_Info_Simd_Vector);
if !ok do return false;
if !ok { return false; }
return x.count == y.count && x.elem == y.elem;
case Type_Info_Relative_Pointer:
y, ok := b.variant.(Type_Info_Relative_Pointer);
if !ok do return false;
if !ok { return false; }
return x.base_integer == y.base_integer && x.pointer == y.pointer;
case Type_Info_Relative_Slice:
y, ok := b.variant.(Type_Info_Relative_Slice);
if !ok do return false;
if !ok { return false; }
return x.base_integer == y.base_integer && x.slice == y.slice;
}
@@ -200,7 +202,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
}
is_signed :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
#partial switch i in type_info_base(info).variant {
case Type_Info_Integer: return i.signed;
case Type_Info_Float: return true;
@@ -208,7 +210,7 @@ is_signed :: proc(info: ^Type_Info) -> bool {
return false;
}
is_unsigned :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
#partial switch i in type_info_base(info).variant {
case Type_Info_Integer: return !i.signed;
case Type_Info_Float: return false;
@@ -218,127 +220,127 @@ is_unsigned :: proc(info: ^Type_Info) -> bool {
is_integer :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Integer);
return ok;
}
is_rune :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Rune);
return ok;
}
is_float :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Float);
return ok;
}
is_complex :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Complex);
return ok;
}
is_quaternion :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Quaternion);
return ok;
}
is_any :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Any);
return ok;
}
is_string :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_String);
return ok;
}
is_cstring :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
v, ok := type_info_base(info).variant.(Type_Info_String);
return ok && v.is_cstring;
}
is_boolean :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Boolean);
return ok;
}
is_pointer :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Pointer);
return ok;
}
is_procedure :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Procedure);
return ok;
}
is_array :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Array);
return ok;
}
is_enumerated_array :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Enumerated_Array);
return ok;
}
is_dynamic_array :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Dynamic_Array);
return ok;
}
is_dynamic_map :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Map);
return ok;
}
is_slice :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Slice);
return ok;
}
is_tuple :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Tuple);
return ok;
}
is_struct :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
s, ok := type_info_base(info).variant.(Type_Info_Struct);
return ok && !s.is_raw_union;
}
is_raw_union :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
s, ok := type_info_base(info).variant.(Type_Info_Struct);
return ok && s.is_raw_union;
}
is_union :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Union);
return ok;
}
is_enum :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Enum);
return ok;
}
is_opaque :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Opaque);
return ok;
}
is_simd_vector :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector);
return ok;
}
is_relative_pointer :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Relative_Pointer);
return ok;
}
is_relative_slice :: proc(info: ^Type_Info) -> bool {
if info == nil do return false;
if info == nil { return false; }
_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice);
return ok;
}
@@ -428,7 +430,9 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
t := info.params.variant.(Type_Info_Tuple);
write_string(buf, "(");
for t, i in t.types {
if i > 0 do write_string(buf, ", ");
if i > 0 {
write_string(buf, ", ");
}
write_type(buf, t);
}
write_string(buf, ")");
@@ -439,9 +443,9 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
case Type_Info_Tuple:
count := len(info.names);
if count != 1 do write_string(buf, "(");
if count != 1 { write_string(buf, "("); }
for name, i in info.names {
if i > 0 do write_string(buf, ", ");
if i > 0 { write_string(buf, ", "); }
t := info.types[i];
@@ -451,7 +455,7 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
write_type(buf, t);
}
if count != 1 do write_string(buf, ")");
if count != 1 { write_string(buf, ")"); }
case Type_Info_Array:
write_string(buf, "[");
@@ -498,8 +502,8 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
write_string(buf, "struct ");
if info.is_packed do write_string(buf, "#packed ");
if info.is_raw_union do write_string(buf, "#raw_union ");
if info.is_packed { write_string(buf, "#packed "); }
if info.is_raw_union { write_string(buf, "#raw_union "); }
if info.custom_align {
write_string(buf, "#align ");
write_i64(buf, i64(ti.align), 10);
@@ -507,7 +511,7 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
write_byte(buf, '{');
for name, i in info.names {
if i > 0 do write_string(buf, ", ");
if i > 0 { write_string(buf, ", "); }
write_string(buf, name);
write_string(buf, ": ");
write_type(buf, info.types[i]);
@@ -523,7 +527,7 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
write_byte(buf, '{');
for variant, i in info.variants {
if i > 0 do write_string(buf, ", ");
if i > 0 { write_string(buf, ", "); }
write_type(buf, variant);
}
write_byte(buf, '}');
@@ -533,7 +537,7 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
write_type(buf, info.base);
write_string(buf, " {");
for name, i in info.names {
if i > 0 do write_string(buf, ", ");
if i > 0 { write_string(buf, ", "); }
write_string(buf, name);
}
write_byte(buf, '}');
@@ -547,7 +551,7 @@ write_type :: proc(buf: ^strings.Builder, ti: ^Type_Info) {
}
write_string(buf, " {");
for name, i in info.names {
if i > 0 do write_string(buf, ", ");
if i > 0 { write_string(buf, ", "); }
write_string(buf, name);
write_string(buf, ": ");
write_i64(buf, i64(info.bits[i]), 10);