mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-06-06 18:54:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix old_demos; Fix when bug; Fix enum .names

Browse Source
This commit is contained in:
Ginger Bill
2017-09-29 21:11:16 +01:00
parent 793bc8c585
commit 11614c2649
13 changed files with 285 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.bat
View File

@@ -43,7 +43,7 @@ del *.ilk > NUL 2> NUL
cl %compiler_settings% "src\main.cpp" ^
/link %linker_settings% -OUT:%exe_name% ^
&& odin run examples/demo.odin -opt=0
&& odin run examples/old_demos/demo006.odin -opt=0
rem && odin docs core/fmt.odin
del *.obj > NUL 2> NUL

2
examples/factorial.odin
View File

@@ -1,4 +1,4 @@
import "fmt.odin";
import "core:fmt.odin";
main :: proc() {
recursive_factorial :: proc(i: u64) -> u64 {

24
examples/game.odin
View File

@@ -1,9 +1,9 @@
import win32 "sys/windows.odin" when ODIN_OS == "windows";
import wgl "sys/wgl.odin" when ODIN_OS == "windows";
import "fmt.odin";
import "math.odin";
import "os.odin";
import gl "opengl.odin";
import win32 "core:sys/windows.odin" when ODIN_OS == "windows";
import wgl "core:sys/wgl.odin" when ODIN_OS == "windows";
import "core:fmt.odin";
import "core:math.odin";
import "core:os.odin";
import gl "core:opengl.odin";
TWO_HEARTS :: '💕';
@@ -32,12 +32,12 @@ to_c_string :: proc(s: string) -> []u8 {
Window :: struct {
width, height: int;
wc: win32.Wnd_Class_Ex_A;
dc: win32.Hdc;
hwnd: win32.Hwnd;
opengl_context, rc: wgl.Hglrc;
c_title: []u8;
width, height: int,
wc: win32.Wnd_Class_Ex_A,
dc: win32.Hdc,
hwnd: win32.Hwnd,
opengl_context, rc: wgl.Hglrc,
c_title: []u8,
}
make_window :: proc(title: string, msg, height: int, window_proc: win32.Wnd_Proc) -> (Window, bool) {

2
examples/hello.odin
View File

@@ -1,4 +1,4 @@
import "fmt.odin";
import "core:fmt.odin";
main :: proc() {
fmt.println("Hellope, world!");

40
examples/old_demos/demo001.odin
View File

@@ -1,9 +1,9 @@
#import "fmt.odin";
#import "os.odin";
#import "mem.odin";
// #import "http_test.odin" as ht;
// #import "game.odin" as game;
// #import "punity.odin" as pn;
import "core:fmt.odin";
import "core:os.odin";
import "core:mem.odin";
// import "http_test.odin" as ht;
// import "game.odin" as game;
// import "punity.odin" as pn;
main :: proc() {
struct_padding();
@@ -160,21 +160,21 @@ type_introspection :: proc() {
info: ^Type_Info;
x: int;
info = type_info(int); // by type
info = type_info_of_val(x); // by value
info = type_info_of(int); // by type
info = type_info_of(x); // by value
// See: runtime.odin
match i in info {
case Type_Info.Integer:
match i in info.variant {
case Type_Info_Integer:
fmt.println("integer!");
case Type_Info.Float:
case Type_Info_Float:
fmt.println("float!");
default:
case:
fmt.println("potato!");
}
// Unsafe cast
integer_info := cast(^Type_Info.Integer)cast(rawptr)info;
integer_info := cast(^Type_Info_Integer)cast(rawptr)info;
}
{
@@ -185,9 +185,9 @@ type_introspection :: proc() {
v2: Vector3;
v3: Vector3;
t1 := type_info_of_val(v1);
t2 := type_info_of_val(v2);
t3 := type_info_of_val(v3);
t1 := type_info_of(v1);
t2 := type_info_of(v2);
t3 := type_info_of(v3);
fmt.println();
fmt.print("Type of v1 is:\n\t", t1);
@@ -262,12 +262,12 @@ crazy_introspection :: proc() {
TOMATO,
}
fruit_ti := type_info(Fruit);
name := (union_cast(^Type_Info.Named)fruit_ti).name; // Unsafe casts
info, _ := union_cast(^Type_Info.Enum)type_info_base(fruit_ti); // Unsafe casts
fruit_ti := type_info_of(Fruit);
name := fruit_ti.variant.(Type_Info_Named).name;
info, _ := type_info_base(fruit_ti).variant.(Type_Info_Enum);
fmt.printf("%s :: enum %T {\n", name, info.base);
for i := 0; i < len(info.values); i++ {
for _, i in info.values {
fmt.printf("\t%s\t= %v,\n", info.names[i], info.values[i]);
}
fmt.printf("}\n");

177
examples/old_demos/demo002.odin
View File

@@ -1,7 +1,8 @@
// Demo 002
#load "fmt.odin";
#load "math.odin";
// #load "game.odin"
export "core:fmt.odin";
export "core:math.odin";
export "core:mem.odin";
// export "game.odin"
#thread_local tls_int: int;
@@ -94,11 +95,9 @@ enumerations :: proc() {
}
variadic_procedures :: proc() {
print_ints :: proc(args: ..int) {
print_ints :: proc(args: ...int) {
for arg, i in args {
if i > 0 {
print(", ");
}
if i > 0 do print(", ");
print(arg);
}
}
@@ -107,13 +106,11 @@ variadic_procedures :: proc() {
print_ints(1); nl();
print_ints(1, 2, 3); nl();
print_prefix_f32s :: proc(prefix: string, args: ..f32) {
print_prefix_f32s :: proc(prefix: string, args: ...f32) {
print(prefix);
print(": ");
for arg, i in args {
if i > 0 {
print(", ");
}
if i > 0 do print(", ");
print(arg);
}
}
@@ -147,13 +144,7 @@ new_builtins :: proc() {
// Q: Should this be `free` rather than `free` and should I overload it for slices too?
{
prev_context := context;
defer __context = prev_context;
// Q: Should I add a `push_context` feature to the language?
__context.allocator = default_allocator();
push_allocator default_allocator() {
a := new(int);
defer free(a);
@@ -164,7 +155,7 @@ new_builtins :: proc() {
{
a: int = 123;
b: type_of_val(a) = 321;
b: type_of(a) = 321;
// NOTE(bill): This matches the current naming scheme
// size_of
@@ -205,7 +196,7 @@ new_builtins :: proc() {
a: [16]int;
a[1] = 1;
b := ^a;
b := &a;
// Auto pointer deref
// consistent with record members
assert(b[1] == 1);
@@ -255,7 +246,7 @@ match_statement :: proc() {
print("5!\n");
fallthrough; // explicit fallthrough
default:
case:
print("default!\n");
}
@@ -267,7 +258,7 @@ match_statement :: proc() {
// break by default
case TAU:
print("τ!\n");
default:
case:
print("default!\n");
}
@@ -279,7 +270,7 @@ match_statement :: proc() {
// break by default
case "Goodbye":
print("farewell\n");
default:
case:
print("???\n");
}
@@ -302,7 +293,7 @@ match_statement :: proc() {
print("dozens\n");
case a >= 100 && a < 1000:
print("hundreds\n");
default:
case:
print("a fuck ton\n");
}
@@ -332,11 +323,9 @@ match_statement :: proc() {
Vector3 :: struct {x, y, z: f32}
print_floats :: proc(args: ..f32) {
print_floats :: proc(args: ...f32) {
for arg, i in args {
if i > 0 {
print(", ");
}
if i > 0 do print(", ");
print(arg);
}
println();
@@ -355,7 +344,7 @@ namespacing :: proc() {
Thing :: #type struct {
y: int,
test: bool,
}
};
b: Thing; // Uses this scope's Thing
b.test = true;
@@ -473,10 +462,10 @@ namespacing :: proc() {
}
e := Entity{position = Vector3{1, 2, 3}};
print_pos_1(^e);
print_pos_2(^e);
print_pos_3(^e);
print_pos_4(^e);
print_pos_1(&e);
print_pos_2(&e);
print_pos_3(&e);
print_pos_4(&e);
// This is similar to C++'s `this` pointer that is implicit and only available in methods
}
@@ -574,20 +563,20 @@ subtyping :: proc() {
entity_count := 0;
next_entity :: proc(entities: []Entity, entity_count: ^int) -> ^Entity {
e := ^entities[entity_count^];
entity_count^++;
e := &entities[entity_count^];
entity_count^ += 1;
return e;
}
f: Frog;
f.entity = next_entity(entities[..], ^entity_count);
f.entity = next_entity(entities[..], &entity_count);
f.position = Vector3{3, 4, 6};
using f.position;
print_floats(x, y, z);
}
{
/*{
// Down casting
Entity :: struct {
@@ -609,7 +598,7 @@ subtyping :: proc() {
// NOTE(bill): `down_cast` is unsafe and there are not check are compile time or run time
// Q: Should I completely remove `down_cast` as I added it in about 30 minutes
}
}*/
{
// Multiple "inheritance"/subclassing
@@ -630,7 +619,7 @@ subtyping :: proc() {
tagged_unions :: proc() {
{
EntityKind :: enum {
Entity_Kind :: enum {
INVALID,
FROG,
GIRAFFE,
@@ -638,8 +627,8 @@ tagged_unions :: proc() {
}
Entity :: struct {
kind: EntityKind
using data: raw_union {
kind: Entity_Kind
using data: struct #raw_union {
frog: struct {
jump_height: f32,
colour: u32,
@@ -657,33 +646,31 @@ tagged_unions :: proc() {
}
e: Entity;
e.kind = EntityKind.FROG;
e.kind = Entity_Kind.FROG;
e.frog.jump_height = 12;
f: type_of_val(e.frog);
f: type_of(e.frog);
// But this is very unsafe and extremely cumbersome to write
// In C++, I use macros to alleviate this but it's not a solution
}
{
Entity :: union {
Frog{
jump_height: f32,
colour: u32,
},
Giraffe{
neck_length: f32,
spot_count: int,
},
Helicopter{
blade_count: int,
weight: f32,
pilot_name: string,
},
Frog :: struct {
jump_height: f32,
colour: u32,
}
Giraffe :: struct {
neck_length: f32,
spot_count: int,
}
Helicopter :: struct {
blade_count: int,
weight: f32,
pilot_name: string,
}
Entity :: union {Frog, Giraffe, Helicopter};
using Entity;
f1: Frog = Frog{12, 0xff9900};
f2: Entity = Frog{12, 0xff9900}; // Implicit cast
f3 := cast(Entity)Frog{12, 0xff9900}; // Explicit cast
@@ -703,7 +690,7 @@ tagged_unions :: proc() {
// Requires a pointer to the union
// `x` will be a pointer to type of the case
match x in ^f {
match x in &f {
case Frog:
print("Frog!\n");
print(x.jump_height); nl();
@@ -713,7 +700,7 @@ tagged_unions :: proc() {
print("Giraffe!\n");
case Helicopter:
print("ROFLCOPTER!\n");
default:
case:
print("invalid entity\n");
}
@@ -755,11 +742,11 @@ tagged_unions :: proc() {
AstNode :: struct {};
ExactValue :: struct {};
EntityKind :: enum {
Entity_Kind :: enum {
Invalid,
Constant,
Variable,
UsingVariable,
Using_Variable,
TypeName,
Procedure,
Builtin,
@@ -769,14 +756,14 @@ tagged_unions :: proc() {
Guid :: i64;
Entity :: struct {
kind: EntityKind,
kind: Entity_Kind,
guid: Guid,
scope: ^Scope,
token: Token,
type_: ^Type,
using data: raw_union {
using data: struct #raw_union {
Constant: struct {
value: ExactValue,
},
@@ -786,7 +773,7 @@ tagged_unions :: proc() {
is_field: bool, // Is struct field
anonymous: bool, // Variable is an anonymous
},
UsingVariable: struct {
Using_Variable: struct {
},
TypeName: struct {
},
@@ -813,44 +800,44 @@ tagged_unions :: proc() {
Guid :: i64;
Entity_Base :: struct {
}
Entity :: union {
Constant :: struct {
value: ExactValue,
}
Variable :: struct {
visited: bool, // Cycle detection
used: bool, // Variable is used
is_field: bool, // Is struct field
anonymous: bool, // Variable is an anonymous
}
Using_Variable :: struct {
}
TypeName :: struct {
}
Procedure :: struct {
used: bool,
}
Builtin :: struct {
id: int,
}
Entity :: struct {
guid: Guid,
scope: ^Scope,
token: Token,
type_: ^Type,
Constant{
value: ExactValue,
},
Variable{
visited: bool, // Cycle detection
used: bool, // Variable is used
is_field: bool, // Is struct field
anonymous: bool, // Variable is an anonymous
},
UsingVariable{
},
TypeName{
},
Procedure{
used: bool,
},
Builtin{
id: int,
},
variant: union {Constant, Variable, Using_Variable, TypeName, Procedure, Builtin},
}
using Entity;
e: Entity;
e = Variable{
used = true,
anonymous = false,
e := Entity{
variant = Variable{
used = true,
anonymous = false,
},
};
@@ -863,13 +850,13 @@ tagged_unions :: proc() {
{
// `Raw` unions still have uses, especially for mathematic types
Vector2 :: raw_union {
Vector2 :: struct #raw_union {
using xy_: struct { x, y: f32 },
e: [2]f32,
v: [vector 2]f32,
}
Vector3 :: raw_union {
Vector3 :: struct #raw_union {
using xyz_: struct { x, y, z: f32 },
xy: Vector2,
e: [3]f32,

18
examples/old_demos/demo004.odin
View File

@@ -1,14 +1,14 @@
#import "fmt.odin";
#import "utf8.odin";
#import "hash.odin";
#import "mem.odin";
import "core:fmt.odin";
import "core:utf8.odin";
import "core:hash.odin";
import "core:mem.odin";
main :: proc() {
{ // New Standard Library stuff
s := "Hello";
fmt.println(s,
utf8.valid_string(s),
hash.murmur64(cast([]byte)s));
hash.murmur64(cast([]u8)s));
// utf8.odin
// hash.odin
@@ -20,10 +20,10 @@ main :: proc() {
{
arena: mem.Arena;
mem.init_arena_from_context(^arena, mem.megabytes(16)); // Uses default allocator
defer mem.free_arena(^arena);
mem.init_arena_from_context(&arena, mem.megabytes(16)); // Uses default allocator
defer mem.destroy_arena(&arena);
push_allocator mem.arena_allocator(^arena) {
push_allocator mem.arena_allocator(&arena) {
x := new(int);
x^ = 1337;
@@ -49,7 +49,7 @@ main :: proc() {
// You can also "push" a context
c := context; // Create copy of the allocator
c.allocator = mem.arena_allocator(^arena);
c.allocator = mem.arena_allocator(&arena);
push_context c {
x := new(int);

51
examples/old_demos/demo005.odin
View File

@@ -1,13 +1,13 @@
#import "fmt.odin";
#import "utf8.odin";
// #import "atomic.odin";
// #import "hash.odin";
// #import "math.odin";
// #import "mem.odin";
// #import "opengl.odin";
// #import "os.odin";
// #import "sync.odin";
// #import win32 "sys/windows.odin";
import "core:fmt.odin";
import "core:utf8.odin";
// import "core:atomic.odin";
// import "core:hash.odin";
// import "core:math.odin";
// import "core:mem.odin";
// import "core:opengl.odin";
// import "core:os.odin";
// import "core:sync.odin";
// import win32 "core:sys/windows.odin";
main :: proc() {
// syntax();
@@ -43,7 +43,7 @@ syntax :: proc() {
Thing2 :: struct {x: f32, y: int, z: ^[]int};
// Slice interals are now just a `ptr+len+cap`
slice: []int; compile_assert(size_of_val(slice) == 3*size_of(int));
slice: []int; compile_assert(size_of(slice) == 3*size_of(int));
// Helper type - Help the reader understand what it is quicker
My_Int :: #type int;
@@ -90,22 +90,17 @@ Prefix_Type :: struct {x: int, y: f32, z: rawptr};
prefixes :: proc() {
using var: Prefix_Type;
immutable const := Prefix_Type{1, 2, nil};
var.x = 123;
x = 123;
// const.x = 123; // const is immutable
foo :: proc(using immutable pt: Prefix_Type, immutable int_ptr: ^int) {
// int_ptr = nil; // Not valid
// int_ptr^ = 123; // Not valid
foo :: proc(using pt: Prefix_Type) {
}
// Same as C99's `restrict`
bar :: proc(no_alias a, b: ^int) {
bar :: proc(#no_alias a, b: ^int) {
// Assumes a never equals b so it can perform optimizations with that fact
}
@@ -138,14 +133,18 @@ when_statements :: proc() {
foreign_procedures();
}
#foreign_system_library win32_user "user32.lib" when ODIN_OS == "windows";
when ODIN_OS == "windows" {
foreign_system_library win32_user "user32.lib";
}
// NOTE: This is done on purpose for two reasons:
// * Makes it clear where the platform specific stuff is
// * Removes the need to solve the travelling salesman problem when importing files :P
foreign_procedures :: proc() {
ShowWindow :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #foreign win32_user;
show_window :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #foreign win32_user "ShowWindow";
foreign win32_user {
ShowWindow :: proc(hwnd: rawptr, cmd_show: i32) -> i32 ---;
show_window :: proc(hwnd: rawptr, cmd_show: i32) -> i32 #link_name "ShowWindow" ---;
}
// NOTE: If that library doesn't get used, it doesn't get linked with
// NOTE: There is not link checking yet to see if that procedure does come from that library
@@ -203,14 +202,14 @@ loops :: proc() {
fmt.println(val, idx);
}
primes := [..]int{2, 3, 5, 7, 11, 13, 17, 19};
primes := [...]int{2, 3, 5, 7, 11, 13, 17, 19};
for p in primes {
fmt.println(p);
}
// Pointers to arrays, slices, or strings are allowed
for _ in ^primes {
for _ in &primes {
// ignore the value and just iterate across it
}
@@ -219,7 +218,7 @@ loops :: proc() {
name := "你好，世界";
fmt.println(name);
for r in name {
compile_assert(type_of_val(r) == rune);
compile_assert(type_of(r) == rune);
fmt.printf("%r\n", r);
}
@@ -270,8 +269,8 @@ procedure_overloading :: proc() {
a: i32 = 123;
b: f32;
c: rawptr;
fmt.println(foo(^a));
foo(^b);
fmt.println(foo(&a));
foo(&b);
foo(c);
// foo(nil); // nil could go to numerous types thus the ambiguity

128
examples/old_demos/demo006.odin
View File

@@ -1,14 +1,14 @@
#import "atomic.odin";
#import "hash.odin";
#import "mem.odin";
#import "opengl.odin";
#import "strconv.odin";
#import "sync.odin";
#import win32 "sys/windows.odin";
// import "core:atomic.odin";
import "core:hash.odin";
import "core:mem.odin";
import "core:opengl.odin";
import "core:strconv.odin";
import "core:sync.odin";
import win32 "core:sys/windows.odin";
#import "fmt.odin";
#import "os.odin";
#import "math.odin";
import "core:fmt.odin";
import "core:os.odin";
import "core:math.odin";
main :: proc() {
@@ -55,7 +55,7 @@ when true {
for i in 0..16 {
}
// Is similar to
for _i := 0; _i < 16; _i++ { immutable i := _i;
for i := 0; i < 16; i += 1 {
}
}
@@ -77,16 +77,15 @@ when true {
}
{
t := type_info(int);
using Type_Info;
match i in t {
case Integer, Float:
t := type_info_of(int);
match i in t.variant {
case Type_Info_Integer, Type_Info_Float:
fmt.println("It's a number");
}
x: any = 123;
foo match i in x {
foo: match i in x {
case int, f32:
fmt.println("It's an int or f32");
break foo;
@@ -112,21 +111,20 @@ when true {
{
// Slices now store a capacity
buf: [256]byte;
s: []byte;
buf: [256]u8;
s: []u8;
s = buf[..0]; // == buf[0..0];
fmt.println("count =", s.count);
fmt.println("capacity =", s.capacity);
append(s, 1, 2, 3);
fmt.println("count =", len(s));
fmt.println("capacity =", cap(s));
append(&s, 1, 2, 3);
fmt.println(s);
s = buf[1..2..3];
fmt.println("count =", s.count);
fmt.println("capacity =", s.capacity);
fmt.println("count =", len(s));
fmt.println("capacity =", cap(s));
fmt.println(s);
clear(s); // Sets count to zero
s.count = 0; // Equivalent
clear(&s); // Sets count to zero
}
{
@@ -136,11 +134,11 @@ when true {
flags: u32,
}
foo_array: [256]Foo;
foo_as_bytes: []byte = slice_to_bytes(foo_array[..]);
foo_as_bytes: []u8 = mem.slice_to_bytes(foo_array[..]);
// Useful for things like
// os.write(handle, foo_as_bytes);
foo_slice := slice_ptr(cast(^Foo)foo_as_bytes.data, foo_as_bytes.count/size_of(Foo), foo_as_bytes.capacity/size_of(Foo));
foo_slice := mem.slice_ptr(cast(^Foo)&foo_as_bytes[0], len(foo_as_bytes)/size_of(Foo), cap(foo_as_bytes)/size_of(Foo));
// Question: Should there be a bytes_to_slice procedure or is it clearer to do this even if it is error prone?
// And if so what would the syntax be?
// slice_transmute([]Foo, foo_as_bytes);
@@ -161,33 +159,26 @@ when true {
fmt.println(i);
}
compile_assert(size_of([vector 7]bool) == size_of([7]bool));
compile_assert(size_of([vector 7]i32) == size_of([7]i32));
compile_assert(size_of([vector 7]bool) >= size_of([7]bool));
compile_assert(size_of([vector 7]i32) >= size_of([7]i32));
// align_of([vector 7]i32) != align_of([7]i32) // this may be the case
}
{
// fmt.* changes
// bprint* returns `int` (bytes written)
// sprint* returns `string` (bytes written as a string)
// bprint* returns `string`
data: [256]byte;
str := fmt.sprintf(data[..0], "Hellope %d %s %c", 123, "others", '!');
data: [256]u8;
str := fmt.bprintf(data[..], "Hellope %d %s %c", 123, "others", '!');
fmt.println(str);
buf := data[..0];
count := fmt.bprintf(^buf, "Hellope %d %s %c", 321, "y'all", '!');
fmt.println(cast(string)buf[..count]);
// NOTE(bill): We may change this but because this is a library feature, I am not that bothered yet
}
{
x: [dynamic]f64;
reserve(x, 16);
reserve(&x, 16);
defer free(x); // `free` is overloaded for numerous types
// Number literals can have underscores in them for readability
append(x, 2_000_000.500_000, 123, 5, 7); // variadic append
append(&x, 2_000_000.500_000, 123, 5, 7); // variadic append
for p, i in x {
if i > 0 { fmt.print(", "); }
@@ -201,13 +192,13 @@ when true {
x := [dynamic]f64{2_000_000.500_000, 3, 5, 7};
defer free(x);
fmt.println(x); // fmt.print* supports printing of dynamic types
clear(x);
clear(&x);
fmt.println(x);
}
{
m: map[f32]int;
reserve(m, 16);
reserve(&m, 16);
defer free(m);
m[1.0] = 1278;
@@ -241,12 +232,12 @@ when true {
assert(ok && c == 7654);
fmt.println(m);
delete(m, "c"); // deletes entry with key "c"
delete(&m, "c"); // deletes entry with key "c"
_, found := m["c"];
assert(!found);
fmt.println(m);
clear(m);
clear(&m);
fmt.println(m);
// NOTE: Fixed size maps are planned but we have not yet implemented
@@ -257,7 +248,21 @@ when true {
Vector3 :: struct{x, y, z: f32};
Quaternion :: struct{x, y, z, w: f32};
Entity :: union {
// Variants
Frog :: struct {
ribbit_volume: f32,
jump_height: f32,
}
Door :: struct {
openness: f32,
}
Map :: struct {
width, height: f32,
place_positions: []Vector3,
place_names: []string,
}
Entity :: struct {
// Common Fields
id: u64,
name: string,
@@ -265,25 +270,13 @@ when true {
orientation: Quaternion,
flags: u32,
// Variants
Frog{
ribbit_volume: f32,
jump_height: f32,
},
Door{
openness: f32,
},
Map{
width, height: f32,
place_positions: []Vector3,
place_names: []string,
},
variant: union { Frog, Door, Map },
}
entity: Entity;
entity.id = 1337;
// implicit conversion from variant to base type
entity = Entity.Frog{
id = 1337,
entity.variant = Frog{
ribbit_volume = 0.5,
jump_height = 2.1,
/*other data */
@@ -292,26 +285,25 @@ when true {
entity.name = "Frank";
entity.position = Vector3{1, 4, 9};
using Entity;
match e in entity {
match e in entity.variant {
case Frog:
fmt.println("Ribbit");
case Door:
fmt.println("Creak");
case Map:
fmt.println("Rustle");
default:
case:
fmt.println("Just a normal entity");
}
if frog, ok := union_cast(Frog)entity; ok {
fmt.printf("The frog jumps %f feet high at %v\n", frog.jump_height, frog.position);
if frog, ok := entity.variant.(Frog); ok {
fmt.printf("The frog jumps %f feet high at %v\n", frog.jump_height, entity.position);
}
// Panics if not the correct type
frog: Frog;
frog = union_cast(Frog)entity;
frog, _ = union_cast(Frog)entity; // ignore error and force cast
frog = entity.variant.(Frog);
frog, _ = entity.variant.(Frog); // ignore error and force cast
}
}
}

80
examples/punity.odin
View File

@@ -1,7 +1,7 @@
import win32 "sys/windows.odin";
import "fmt.odin";
import "os.odin";
import "mem.odin";
import win32 "core:sys/windows.odin";
import "core:fmt.odin";
import "core:os.odin";
import "core:mem.odin";
CANVAS_WIDTH :: 128;
@@ -25,13 +25,13 @@ DRAW_LIST_RESERVE :: 128;
MAX_KEYS :: 256;
Core :: struct {
stack: ^Bank;
storage: ^Bank;
stack: ^Bank,
storage: ^Bank,
running: bool;
key_modifiers: u32;
key_states: [MAX_KEYS]u8;
key_deltas: [MAX_KEYS]u8;
running: bool,
key_modifiers: u32,
key_states: [MAX_KEYS]u8,
key_deltas: [MAX_KEYS]u8,
perf_frame,
perf_frame_inner,
@@ -39,66 +39,66 @@ Core :: struct {
perf_audio,
perf_blit,
perf_blit_cvt,
perf_blit_gdi: Perf_Span;
perf_blit_gdi: Perf_Span,
frame: i64;
frame: i64,
canvas: Canvas;
draw_list: ^Draw_List;
canvas: Canvas,
draw_list: ^Draw_List,
}
Perf_Span :: struct {
stamp: f64;
delta: f32;
stamp: f64,
delta: f32,
}
Bank :: struct {
memory: []u8;
cursor: int;
memory: []u8,
cursor: int,
}
Bank_State :: struct {
state: Bank;
bank: ^Bank;
state: Bank,
bank: ^Bank,
}
Color :: struct #raw_union {
using channels: struct{a, b, g, r: u8};
rgba: u32;
using channels: struct{a, b, g, r: u8},
rgba: u32,
}
Palette :: struct {
colors: [256]Color;
colors_count: u8;
colors: [256]Color,
colors_count: u8,
}
Rect :: struct #raw_union {
using minmax: struct {min_x, min_y, max_x, max_y: int};
using pos: struct {left, top, right, bottom: int};
e: [4]int;
using minmax: struct {min_x, min_y, max_x, max_y: int},
using pos: struct {left, top, right, bottom: int},
e: [4]int,
}
Bitmap :: struct {
pixels: []u8;
width: int;
height: int;
pixels: []u8,
width: int,
height: int,
}
Font :: struct {
using bitmap: Bitmap;
char_width: int;
char_height: int;
using bitmap: Bitmap,
char_width: int,
char_height: int,
}
Canvas :: struct {
using bitmap: ^Bitmap;
palette: Palette;
translate_x: int;
translate_y: int;
clip: Rect;
font: ^Font;
using bitmap: ^Bitmap,
palette: Palette,
translate_x: int,
translate_y: int,
clip: Rect,
font: ^Font,
}
DrawFlag :: enum {
@@ -110,7 +110,7 @@ DrawFlag :: enum {
Draw_Item :: struct {}
Draw_List :: struct {
items: []Draw_Item;
items: []Draw_Item,
}
Key :: enum {

3
src/check_expr.cpp
View File

@@ -4823,6 +4823,9 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h
if (entity != nullptr && (entity->flags&EntityFlag_TypeField)) {
add_type_info_type(c, operand->type);
}
if (is_type_enum(operand->type)) {
add_type_info_type(c, operand->type);
}
}
if (entity == nullptr && selector->kind == AstNode_BasicLit) {
if (is_type_struct(operand->type) || is_type_tuple(operand->type)) {

1
src/check_stmt.cpp
View File

@@ -393,7 +393,6 @@ struct TypeAndToken {
};
void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) {
flags &= ~Stmt_CheckScopeDecls;
Operand operand = {Addressing_Invalid};
check_expr(c, &operand, ws->cond);
if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) {

43
src/ir.cpp
View File

@@ -853,10 +853,19 @@ String ir_get_global_name(irModule *m, irValue *v) {
String *found = map_get(&m->entity_names, hash_entity(e));
if (found != nullptr) {
name = *found;
} else {
GB_ASSERT(name.len > 0);
}
return name;
}
void ir_add_entity_name(irModule *m, Entity *e, String name) {
GB_ASSERT(name.len > 0);
map_set(&m->entity_names, hash_entity(e), name);
}
irValue *ir_instr_local(irProcedure *p, Entity *e, bool zero_initialized) {
@@ -1153,14 +1162,21 @@ irValue *ir_generate_array(irModule *m, Type *elem_type, i64 count, String prefi
gbAllocator a = m->allocator;
Token token = {Token_Ident};
isize name_len = prefix.len + 10;
token.string.text = gb_alloc_array(a, u8, name_len);
token.string.len = gb_snprintf(cast(char *)token.string.text, name_len,
"%.*s-%llx", LIT(prefix), cast(unsigned long long)id)-1;
Entity *e = make_entity_variable(a, nullptr, token, make_type_array(a, elem_type, count), false);
char *text = gb_alloc_array(a, char, name_len);
gb_snprintf(text, name_len,
"%.*s-%llx", LIT(prefix), cast(unsigned long long)id);
String s = make_string_c(text);
Entity *e = make_entity_variable(a, nullptr,
make_token_ident(s),
make_type_array(a, elem_type, count),
false);
irValue *value = ir_value_global(a, e, nullptr);
value->Global.is_private = true;
ir_module_add_value(m, e, value);
map_set(&m->members, hash_string(token.string), value);
map_set(&m->members, hash_string(s), value);
return value;
}
@@ -3436,6 +3452,7 @@ irValue *ir_type_info(irProcedure *proc, Type *type) {
type = default_type(type);
i32 entry_index = cast(i32)type_info_index(info, type);
GB_ASSERT(entry_index >= 0);
// gb_printf_err("%d %s\n", entry_index, type_to_string(type));
@@ -3639,7 +3656,8 @@ void ir_mangle_add_sub_type_name(irModule *m, Entity *field, String parent) {
"%.*s.%.*s", LIT(parent), LIT(cn));
String child = {text, new_name_len-1};
map_set(&m->entity_names, hash_entity(field), child);
GB_ASSERT(child.len > 0);
ir_add_entity_name(m, field, child);
ir_gen_global_type_name(m, field, child);
}
@@ -5148,15 +5166,16 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
String name = e->token.string;
if (name == "names") {
irValue *ti_ptr = ir_type_info(proc, type);
irValue *variant = ir_emit_struct_ep(proc, ti_ptr, 2);
irValue *names_ptr = nullptr;
if (is_type_enum(type)) {
irValue *enum_info = ir_emit_conv(proc, ti_ptr, t_type_info_enum_ptr);
names_ptr = ir_emit_struct_ep(proc, enum_info, 3);
irValue *enum_info = ir_emit_conv(proc, variant, t_type_info_enum_ptr);
names_ptr = ir_emit_struct_ep(proc, enum_info, 1);
} else if (type->kind == Type_Struct) {
irValue *struct_info = ir_emit_conv(proc, ti_ptr, t_type_info_struct_ptr);
names_ptr = ir_emit_struct_ep(proc, struct_info, 3);
irValue *struct_info = ir_emit_conv(proc, variant, t_type_info_struct_ptr);
names_ptr = ir_emit_struct_ep(proc, struct_info, 1);
}
return ir_addr(names_ptr);
} else {
@@ -7641,7 +7660,7 @@ void ir_gen_tree(irGen *s) {
if (!e->scope->is_global) {
name = ir_mangle_name(s, e->token.pos.file, e);
}
map_set(&m->entity_names, hash_entity(e), name);
ir_add_entity_name(m, e, name);
irValue *g = ir_value_global(a, e, nullptr);
g->Global.name = name;
@@ -7716,7 +7735,7 @@ void ir_gen_tree(irGen *s) {
} else if (check_is_entity_overloaded(e)) {
name = ir_mangle_name(s, e->token.pos.file, e);
}
map_set(&m->entity_names, hash_entity(e), name);
ir_add_entity_name(m, e, name);
switch (e->kind) {
case Entity_TypeName: