mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-04 14:48:47 +00:00
Strip even more semicolons if followed by a } or ) on the same line
This commit is contained in:
gingerBill
+22
-22
@@ -117,7 +117,7 @@ backing_type_kind :: proc(T: typeid) -> Type_Kind {
|
||||
|
||||
|
||||
type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
|
||||
if info == nil { return nil; }
|
||||
if info == nil { return nil }
|
||||
|
||||
base := info
|
||||
loop: for {
|
||||
@@ -131,7 +131,7 @@ type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
|
||||
|
||||
|
||||
type_info_core :: proc(info: ^Type_Info) -> ^Type_Info {
|
||||
if info == nil { 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 { return nil; }
|
||||
if ti == nil { return nil }
|
||||
|
||||
bits := 8*ti.size
|
||||
|
||||
@@ -228,7 +228,7 @@ is_nil :: proc(v: any) -> bool {
|
||||
}
|
||||
|
||||
length :: proc(val: any) -> int {
|
||||
if val == nil { return 0; }
|
||||
if val == nil { return 0 }
|
||||
|
||||
#partial switch a in type_info_of(val.id).variant {
|
||||
case Type_Info_Named:
|
||||
@@ -263,7 +263,7 @@ length :: proc(val: any) -> int {
|
||||
}
|
||||
|
||||
capacity :: proc(val: any) -> int {
|
||||
if val == nil { return 0; }
|
||||
if val == nil { return 0 }
|
||||
|
||||
#partial switch a in type_info_of(val.id).variant {
|
||||
case Type_Info_Named:
|
||||
@@ -289,7 +289,7 @@ capacity :: proc(val: any) -> int {
|
||||
|
||||
|
||||
index :: proc(val: any, i: int, loc := #caller_location) -> any {
|
||||
if val == nil { return nil; }
|
||||
if val == nil { return nil }
|
||||
|
||||
#partial switch a in type_info_of(val.id).variant {
|
||||
case Type_Info_Named:
|
||||
@@ -336,7 +336,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 { return nil; }
|
||||
if a.is_cstring { return nil }
|
||||
|
||||
raw := (^mem.Raw_String)(val.data)
|
||||
runtime.bounds_check_error_loc(loc, i, raw.len)
|
||||
@@ -395,7 +395,7 @@ struct_field_by_name :: proc(T: typeid, name: string) -> (field: Struct_Field) {
|
||||
}
|
||||
|
||||
struct_field_value_by_name :: proc(a: any, field: string, allow_using := false) -> any {
|
||||
if a == nil { return nil; }
|
||||
if a == nil { return nil }
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(a.id))
|
||||
|
||||
@@ -538,7 +538,7 @@ struct_tag_lookup :: proc(tag: Struct_Tag, key: string) -> (value: Struct_Tag, o
|
||||
|
||||
|
||||
enum_string :: proc(a: any) -> string {
|
||||
if a == nil { 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)
|
||||
@@ -627,7 +627,7 @@ type_info_union_is_pure_maybe :: proc(info: runtime.Type_Info_Union) -> bool {
|
||||
}
|
||||
|
||||
union_variant_typeid :: proc(a: any) -> typeid {
|
||||
if a == nil { 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 {
|
||||
@@ -666,7 +666,7 @@ union_variant_typeid :: proc(a: any) -> typeid {
|
||||
}
|
||||
|
||||
get_union_variant_raw_tag :: proc(a: any) -> i64 {
|
||||
if a == nil { return -1; }
|
||||
if a == nil { return -1 }
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(a.id))
|
||||
if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
|
||||
@@ -697,7 +697,7 @@ get_union_variant_raw_tag :: proc(a: any) -> i64 {
|
||||
|
||||
|
||||
set_union_variant_raw_tag :: proc(a: any, tag: i64) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(a.id))
|
||||
if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
|
||||
@@ -727,7 +727,7 @@ set_union_variant_raw_tag :: proc(a: any, tag: i64) {
|
||||
}
|
||||
|
||||
set_union_variant_typeid :: proc(a: any, id: typeid) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(a.id))
|
||||
if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
|
||||
@@ -757,7 +757,7 @@ set_union_variant_typeid :: proc(a: any, id: typeid) {
|
||||
}
|
||||
|
||||
set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
|
||||
ti := runtime.type_info_base(type_info_of(a.id))
|
||||
if info, ok := ti.variant.(runtime.Type_Info_Union); ok {
|
||||
@@ -788,7 +788,7 @@ set_union_variant_type_info :: proc(a: any, tag_ti: ^Type_Info) {
|
||||
|
||||
|
||||
as_bool :: proc(a: any) -> (value: bool, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -824,7 +824,7 @@ as_uint :: proc(a: any) -> (value: uint, valid: bool) {
|
||||
}
|
||||
|
||||
as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -931,7 +931,7 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
|
||||
}
|
||||
|
||||
as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -1039,7 +1039,7 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
|
||||
|
||||
|
||||
as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -1144,7 +1144,7 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
|
||||
|
||||
|
||||
as_string :: proc(a: any) -> (value: string, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -1163,7 +1163,7 @@ as_string :: proc(a: any) -> (value: string, valid: bool) {
|
||||
}
|
||||
|
||||
relative_pointer_to_absolute :: proc(a: any) -> rawptr {
|
||||
if a == nil { return nil; }
|
||||
if a == nil { return nil }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -1219,7 +1219,7 @@ relative_pointer_to_absolute_raw :: proc(data: rawptr, base_integer_id: typeid)
|
||||
|
||||
|
||||
as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
@@ -1246,7 +1246,7 @@ as_pointer :: proc(a: any) -> (value: rawptr, valid: bool) {
|
||||
|
||||
|
||||
as_raw_data :: proc(a: any) -> (value: rawptr, valid: bool) {
|
||||
if a == nil { return; }
|
||||
if a == nil { return }
|
||||
a := a
|
||||
ti := runtime.type_info_core(type_info_of(a.id))
|
||||
a.id = ti.id
|
||||
|
||||
+46
-46
@@ -80,12 +80,12 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
|
||||
|
||||
case Type_Info_Array:
|
||||
y := b.variant.(Type_Info_Array) or_return
|
||||
if x.count != y.count { return false; }
|
||||
if x.count != y.count { return false }
|
||||
return are_types_identical(x.elem, y.elem)
|
||||
|
||||
case Type_Info_Enumerated_Array:
|
||||
y := b.variant.(Type_Info_Enumerated_Array) or_return
|
||||
if x.count != y.count { return false; }
|
||||
if x.count != y.count { return false }
|
||||
return are_types_identical(x.index, y.index) &&
|
||||
are_types_identical(x.elem, y.elem)
|
||||
|
||||
@@ -99,7 +99,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
|
||||
|
||||
case Type_Info_Tuple:
|
||||
y := b.variant.(Type_Info_Tuple) or_return
|
||||
if len(x.types) != len(y.types) { 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) {
|
||||
@@ -125,19 +125,19 @@ 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 { return false; }
|
||||
if !are_types_identical(xt, yt) { return false; }
|
||||
if xl != yl { 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 := b.variant.(Type_Info_Union) or_return
|
||||
if len(x.variants) != len(y.variants) { 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) { return false; }
|
||||
if !are_types_identical(xv, yv) { return false }
|
||||
}
|
||||
return true
|
||||
|
||||
@@ -170,7 +170,7 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
|
||||
}
|
||||
|
||||
is_signed :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { 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
|
||||
@@ -178,7 +178,7 @@ is_signed :: proc(info: ^Type_Info) -> bool {
|
||||
return false
|
||||
}
|
||||
is_unsigned :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { 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
|
||||
@@ -187,7 +187,7 @@ is_unsigned :: proc(info: ^Type_Info) -> bool {
|
||||
}
|
||||
|
||||
is_byte :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { return false; }
|
||||
if info == nil { return false }
|
||||
#partial switch i in type_info_base(info).variant {
|
||||
case Type_Info_Integer: return info.size == 1
|
||||
}
|
||||
@@ -196,127 +196,127 @@ is_byte :: proc(info: ^Type_Info) -> bool {
|
||||
|
||||
|
||||
is_integer :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { return false; }
|
||||
if info == nil { return false }
|
||||
_, ok := type_info_base(info).variant.(Type_Info_Pointer)
|
||||
return ok
|
||||
}
|
||||
is_multi_pointer :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { return false; }
|
||||
if info == nil { return false }
|
||||
_, ok := type_info_base(info).variant.(Type_Info_Multi_Pointer)
|
||||
return ok
|
||||
}
|
||||
is_procedure :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { return false; }
|
||||
if info == nil { return false }
|
||||
_, ok := type_info_base(info).variant.(Type_Info_Enum)
|
||||
return ok
|
||||
}
|
||||
is_simd_vector :: proc(info: ^Type_Info) -> bool {
|
||||
if info == nil { 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 { 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 { return false; }
|
||||
if info == nil { return false }
|
||||
_, ok := type_info_base(info).variant.(Type_Info_Relative_Slice)
|
||||
return ok
|
||||
}
|
||||
@@ -354,8 +354,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
return write_string(w, "nil")
|
||||
}
|
||||
|
||||
_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0; }
|
||||
_n2 :: proc(n: int, _: io.Error) -> int { return n; }
|
||||
_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0 }
|
||||
_n2 :: proc(n: int, _: io.Error) -> int { return n }
|
||||
_n :: proc{_n1, _n2}
|
||||
|
||||
switch info in ti.variant {
|
||||
@@ -441,9 +441,9 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
}
|
||||
case Type_Info_Tuple:
|
||||
count := len(info.names)
|
||||
if count != 1 { n += write_string(w, "("); }
|
||||
if count != 1 { n += write_string(w, "(") }
|
||||
for name, i in info.names {
|
||||
if i > 0 { n += write_string(w, ", "); }
|
||||
if i > 0 { n += write_string(w, ", ") }
|
||||
|
||||
t := info.types[i]
|
||||
|
||||
@@ -453,7 +453,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
}
|
||||
n += write_type(w, t)
|
||||
}
|
||||
if count != 1 { n += write_string(w, ")"); }
|
||||
if count != 1 { n += write_string(w, ")") }
|
||||
|
||||
case Type_Info_Array:
|
||||
n += _n(io.write_string(w, "["))
|
||||
@@ -500,8 +500,8 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
}
|
||||
|
||||
n += write_string(w, "struct ")
|
||||
if info.is_packed { n += write_string(w, "#packed "); }
|
||||
if info.is_raw_union { n += write_string(w, "#raw_union "); }
|
||||
if info.is_packed { n += write_string(w, "#packed ") }
|
||||
if info.is_raw_union { n += write_string(w, "#raw_union ") }
|
||||
if info.custom_align {
|
||||
n += _n(io.write_string(w, "#align "))
|
||||
n += _n(io.write_i64(w, i64(ti.align), 10))
|
||||
@@ -509,7 +509,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
}
|
||||
n += _n(io.write_byte(w, '{'))
|
||||
for name, i in info.names {
|
||||
if i > 0 { n += write_string(w, ", "); }
|
||||
if i > 0 { n += write_string(w, ", ") }
|
||||
n += _n(io.write_string(w, name))
|
||||
n += _n(io.write_string(w, ": "))
|
||||
n += write_type(w, info.types[i])
|
||||
@@ -525,7 +525,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
}
|
||||
n += _n(io.write_byte(w, '{'))
|
||||
for variant, i in info.variants {
|
||||
if i > 0 { n += write_string(w, ", "); }
|
||||
if i > 0 { n += write_string(w, ", ") }
|
||||
n += write_type(w, variant)
|
||||
}
|
||||
n += _n(io.write_byte(w, '}'))
|
||||
@@ -535,7 +535,7 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
|
||||
n += write_type(w, info.base)
|
||||
n += write_string(w, " {")
|
||||
for name, i in info.names {
|
||||
if i > 0 { n += write_string(w, ", "); }
|
||||
if i > 0 { n += write_string(w, ", ") }
|
||||
n += write_string(w, name)
|
||||
}
|
||||
n += _n(io.write_byte(w, '}'))
|
||||
|
||||
Reference in New Issue
Block a user