// 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 "core:fmt.odin"; import "core:os.odin"; import "core:math.odin"; main :: proc() { when true { /* Added: * Unexported entities and fields using an underscore prefix - See `sync.odin` and explain Removed: * Maybe/option types * Remove `type` keyword and other "reserved" keywords * ..< and .. removed and replace with .. (half-closed range) Changed: * `#assert` and `assert` return the value of the condition for semantic reasons * thread_local -> #thread_local * #include -> #load * Files only get checked if they are actually used * match x in y {} // For type match statements * Version numbering now starts from 0.1.0 and uses the convention: - major.minor.patch * Core library additions to Windows specific stuff */ { Fruit :: enum { APPLE, BANANA, COCONUT, } fmt.println(Fruit.names); } { A :: struct {x, y: f32}; B :: struct #align 16 {x, y: f32}; fmt.println("align_of(A) =", align_of(A)); fmt.println("align_of(B) =", align_of(B)); } { // Removal of ..< and .. for i in 0..16 { } // Is similar to for i := 0; i < 16; i += 1 { } } { thing: for i in 0..10 { for j in i+1..10 { if j == 2 { fmt.println(i, j); continue thing; } if j == 3 { break thing; } } } // Works with, `for`, `for in`, `match`, `match in` // NOTE(bill): This solves most of the problems I need `goto` for } { 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 { case int, f32: fmt.println("It's an int or f32"); break foo; } } { cond := true; x: int; if cond { x = 3; } else { x = 4; } // Ternary operator y := cond ? 3 : 4; FOO :: true ? 123 : 432; // Constant ternary expression fmt.println("Ternary values:", y, FOO); } { // Slices now store a capacity buf: [256]u8; s: []u8; s = buf[..0]; // == buf[0..0]; 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 =", len(s)); fmt.println("capacity =", cap(s)); fmt.println(s); clear(&s); // Sets count to zero } { Foo :: struct { x, y, z: f32, ok: bool, flags: u32, } foo_array: [256]Foo; foo_as_bytes: []u8 = mem.slice_to_bytes(foo_array[..]); // Useful for things like // os.write(handle, foo_as_bytes); 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); } { Vec3 :: [vector 3]f32; x := Vec3{1, 2, 3}; y := Vec3{4, 5, 6}; fmt.println(x < y); fmt.println(x + y); fmt.println(x - y); fmt.println(x * y); fmt.println(x / y); for i in x { fmt.println(i); } #assert(size_of([vector 7]bool) >= size_of([7]bool)); #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 `string` data: [256]u8; str := fmt.bprintf(data[..], "Hellope %d %s %c", 123, "others", '!'); fmt.println(str); } { x: [dynamic]f64; 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 for p, i in x { if i > 0 { fmt.print(", "); } fmt.print(p); } fmt.println(); } { // Dynamic array "literals" 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); fmt.println(x); } { m: map[f32]int; reserve(&m, 16); defer free(m); m[1.0] = 1278; m[2.0] = 7643; m[3.0] = 564; _, ok := m[3.0]; c := m[3.0]; assert(ok && c == 564); fmt.print("map["); i := 0; for val, key in m { if i > 0 { fmt.print(", "); } fmt.printf("%v=%v", key, val); i += 1; } fmt.println("]"); } { m := map[string]u32{ "a" = 56, "b" = 13453, "c" = 7654, }; defer free(m); c := m["c"]; _, ok := m["c"]; assert(ok && c == 7654); fmt.println(m); delete(&m, "c"); // deletes entry with key "c" _, found := m["c"]; assert(!found); fmt.println(m); clear(&m); fmt.println(m); // NOTE: Fixed size maps are planned but we have not yet implemented // them as we have had no need for them as of yet } { Vector3 :: struct{x, y, z: f32}; Quaternion :: struct{x, y, z, w: f32}; // 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, using position: Vector3, orientation: Quaternion, flags: u32, variant: union { Frog, Door, Map }, } entity: Entity; entity.id = 1337; // implicit conversion from variant to base type entity.variant = Frog{ ribbit_volume = 0.5, jump_height = 2.1, /*other data */ }; entity.name = "Frank"; entity.position = Vector3{1, 4, 9}; match e in entity.variant { case Frog: fmt.println("Ribbit"); case Door: fmt.println("Creak"); case Map: fmt.println("Rustle"); case: fmt.println("Just a normal entity"); } 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 = entity.variant.(Frog); frog, _ = entity.variant.(Frog); // ignore error and force cast } } }