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

Merge pull request #238 from odin-lang/big-int

Browse Source 
Big int
This commit is contained in:
gingerBill
2018-07-28 18:39:15 +01:00
committed by GitHub
parent 1ab40d8600 8504ff920b
commit 8d2c4a78a1
13 changed files with 1801 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/types/types.odin
+79 -79
View File
@@ -1,8 +1,8 @@
package types
import "core:runtime"
import rt "core:runtime"
are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
are_types_identical :: proc(a, b: ^rt.Type_Info) -> bool {
if a == b do return true;
if (a == nil && b != nil) ||
@@ -17,47 +17,47 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
}
switch x in a.variant {
case runtime.Type_Info_Named:
y, ok := b.variant.(runtime.Type_Info_Named);
case rt.Type_Info_Named:
y, ok := b.variant.(rt.Type_Info_Named);
if !ok do return false;
return x.base == y.base;
case runtime.Type_Info_Integer:
y, ok := b.variant.(runtime.Type_Info_Integer);
case rt.Type_Info_Integer:
y, ok := b.variant.(rt.Type_Info_Integer);
if !ok do return false;
return x.signed == y.signed;
case runtime.Type_Info_Rune:
_, ok := b.variant.(runtime.Type_Info_Rune);
case rt.Type_Info_Rune:
_, ok := b.variant.(rt.Type_Info_Rune);
return ok;
case runtime.Type_Info_Float:
_, ok := b.variant.(runtime.Type_Info_Float);
case rt.Type_Info_Float:
_, ok := b.variant.(rt.Type_Info_Float);
return ok;
case runtime.Type_Info_Complex:
_, ok := b.variant.(runtime.Type_Info_Complex);
case rt.Type_Info_Complex:
_, ok := b.variant.(rt.Type_Info_Complex);
return ok;
case runtime.Type_Info_String:
_, ok := b.variant.(runtime.Type_Info_String);
case rt.Type_Info_String:
_, ok := b.variant.(rt.Type_Info_String);
return ok;
case runtime.Type_Info_Boolean:
_, ok := b.variant.(runtime.Type_Info_Boolean);
case rt.Type_Info_Boolean:
_, ok := b.variant.(rt.Type_Info_Boolean);
return ok;
case runtime.Type_Info_Any:
_, ok := b.variant.(runtime.Type_Info_Any);
case rt.Type_Info_Any:
_, ok := b.variant.(rt.Type_Info_Any);
return ok;
case runtime.Type_Info_Pointer:
y, ok := b.variant.(runtime.Type_Info_Pointer);
case rt.Type_Info_Pointer:
y, ok := b.variant.(rt.Type_Info_Pointer);
if !ok do return false;
return are_types_identical(x.elem, y.elem);
case runtime.Type_Info_Procedure:
y, ok := b.variant.(runtime.Type_Info_Procedure);
case rt.Type_Info_Procedure:
y, ok := b.variant.(rt.Type_Info_Procedure);
if !ok do return false;
switch {
case x.variadic != y.variadic,
@@ -67,24 +67,24 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
return are_types_identical(x.params, y.params) && are_types_identical(x.results, y.results);
case runtime.Type_Info_Array:
y, ok := b.variant.(runtime.Type_Info_Array);
case rt.Type_Info_Array:
y, ok := b.variant.(rt.Type_Info_Array);
if !ok do return false;
if x.count != y.count do return false;
return are_types_identical(x.elem, y.elem);
case runtime.Type_Info_Dynamic_Array:
y, ok := b.variant.(runtime.Type_Info_Dynamic_Array);
case rt.Type_Info_Dynamic_Array:
y, ok := b.variant.(rt.Type_Info_Dynamic_Array);
if !ok do return false;
return are_types_identical(x.elem, y.elem);
case runtime.Type_Info_Slice:
y, ok := b.variant.(runtime.Type_Info_Slice);
case rt.Type_Info_Slice:
y, ok := b.variant.(rt.Type_Info_Slice);
if !ok do return false;
return are_types_identical(x.elem, y.elem);
case runtime.Type_Info_Tuple:
y, ok := b.variant.(runtime.Type_Info_Tuple);
case rt.Type_Info_Tuple:
y, ok := b.variant.(rt.Type_Info_Tuple);
if !ok do return false;
if len(x.types) != len(y.types) do return false;
for _, i in x.types {
@@ -95,8 +95,8 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
}
return true;
case runtime.Type_Info_Struct:
y, ok := b.variant.(runtime.Type_Info_Struct);
case rt.Type_Info_Struct:
y, ok := b.variant.(rt.Type_Info_Struct);
if !ok do return false;
switch {
case len(x.types) != len(y.types),
@@ -114,8 +114,8 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
}
return true;
case runtime.Type_Info_Union:
y, ok := b.variant.(runtime.Type_Info_Union);
case rt.Type_Info_Union:
y, ok := b.variant.(rt.Type_Info_Union);
if !ok do return false;
if len(x.variants) != len(y.variants) do return false;
@@ -125,17 +125,17 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
}
return true;
case runtime.Type_Info_Enum:
case rt.Type_Info_Enum:
// NOTE(bill): Should be handled above
return false;
case runtime.Type_Info_Map:
y, ok := b.variant.(runtime.Type_Info_Map);
case rt.Type_Info_Map:
y, ok := b.variant.(rt.Type_Info_Map);
if !ok do return false;
return are_types_identical(x.key, y.key) && are_types_identical(x.value, y.value);
case runtime.Type_Info_Bit_Field:
y, ok := b.variant.(runtime.Type_Info_Bit_Field);
case rt.Type_Info_Bit_Field:
y, ok := b.variant.(rt.Type_Info_Bit_Field);
if !ok do return false;
if len(x.names) != len(y.names) do return false;
@@ -156,101 +156,101 @@ are_types_identical :: proc(a, b: ^runtime.Type_Info) -> bool {
}
is_signed :: proc(info: ^runtime.Type_Info) -> bool {
is_signed :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
switch i in runtime.type_info_base(info).variant {
case runtime.Type_Info_Integer: return i.signed;
case runtime.Type_Info_Float: return true;
switch i in rt.type_info_base(info).variant {
case rt.Type_Info_Integer: return i.signed;
case rt.Type_Info_Float: return true;
}
return false;
}
is_integer :: proc(info: ^runtime.Type_Info) -> bool {
is_integer :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Integer);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Integer);
return ok;
}
is_rune :: proc(info: ^runtime.Type_Info) -> bool {
is_rune :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Rune);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Rune);
return ok;
}
is_float :: proc(info: ^runtime.Type_Info) -> bool {
is_float :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Float);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Float);
return ok;
}
is_complex :: proc(info: ^runtime.Type_Info) -> bool {
is_complex :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Complex);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Complex);
return ok;
}
is_any :: proc(info: ^runtime.Type_Info) -> bool {
is_any :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Any);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Any);
return ok;
}
is_string :: proc(info: ^runtime.Type_Info) -> bool {
is_string :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_String);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_String);
return ok;
}
is_boolean :: proc(info: ^runtime.Type_Info) -> bool {
is_boolean :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Boolean);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Boolean);
return ok;
}
is_pointer :: proc(info: ^runtime.Type_Info) -> bool {
is_pointer :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Pointer);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Pointer);
return ok;
}
is_procedure :: proc(info: ^runtime.Type_Info) -> bool {
is_procedure :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Procedure);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Procedure);
return ok;
}
is_array :: proc(info: ^runtime.Type_Info) -> bool {
is_array :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Array);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Array);
return ok;
}
is_dynamic_array :: proc(info: ^runtime.Type_Info) -> bool {
is_dynamic_array :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Dynamic_Array);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Dynamic_Array);
return ok;
}
is_dynamic_map :: proc(info: ^runtime.Type_Info) -> bool {
is_dynamic_map :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Map);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Map);
return ok;
}
is_slice :: proc(info: ^runtime.Type_Info) -> bool {
is_slice :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Slice);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Slice);
return ok;
}
is_tuple :: proc(info: ^runtime.Type_Info) -> bool {
is_tuple :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Tuple);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Tuple);
return ok;
}
is_struct :: proc(info: ^runtime.Type_Info) -> bool {
is_struct :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
s, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Struct);
s, ok := rt.type_info_base(info).variant.(rt.Type_Info_Struct);
return ok && !s.is_raw_union;
}
is_raw_union :: proc(info: ^runtime.Type_Info) -> bool {
is_raw_union :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
s, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Struct);
s, ok := rt.type_info_base(info).variant.(rt.Type_Info_Struct);
return ok && s.is_raw_union;
}
is_union :: proc(info: ^runtime.Type_Info) -> bool {
is_union :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Union);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Union);
return ok;
}
is_enum :: proc(info: ^runtime.Type_Info) -> bool {
is_enum :: proc(info: ^rt.Type_Info) -> bool {
if info == nil do return false;
_, ok := runtime.type_info_base(info).variant.(runtime.Type_Info_Enum);
_, ok := rt.type_info_base(info).variant.(rt.Type_Info_Enum);
return ok;
}
core/unicode/utf16/utf16.odin
+2 -2
View File
@@ -1,7 +1,7 @@
package utf16
REPLACEMENT_CHAR :: '\uFFFD';
MAX_RUNE :: '\U0010FFFF';
REPLACEMENT_CHAR :: '\ufffd';
MAX_RUNE :: '\U0010ffff';
_surr1 :: 0xd800;
_surr2 :: 0xdc00;