|
|
@@ -1,2014 +1,14 @@
|
|
|
package main
|
|
|
|
|
|
import "core:fmt"
|
|
|
-import "core:mem"
|
|
|
-import "core:os"
|
|
|
-import "core:thread"
|
|
|
-import "core:time"
|
|
|
-import "core:reflect"
|
|
|
-import "core:runtime"
|
|
|
-import "intrinsics"
|
|
|
+import "core:encoding/json"
|
|
|
|
|
|
-
|
|
|
-/*
|
|
|
- The Odin programming language is fast, concise, readable, pragmatic and open sourced.
|
|
|
- It is designed with the intent of replacing C with the following goals:
|
|
|
- * simplicity
|
|
|
- * high performance
|
|
|
- * built for modern systems
|
|
|
- * joy of programming
|
|
|
-
|
|
|
- # Installing Odin
|
|
|
- Getting Started - https://odin-lang.org/docs/install/
|
|
|
- Instructions for downloading and install the Odin compiler and libraries.
|
|
|
-
|
|
|
- # Learning Odin
|
|
|
- Overview of Odin - https://odin-lang.org/docs/overview/
|
|
|
- An overview of the Odin programming language.
|
|
|
- Frequently Asked Questions (FAQ) - https://odin-lang.org/docs/faq/
|
|
|
- Answers to common questions about Odin.
|
|
|
-*/
|
|
|
-
|
|
|
-the_basics :: proc() {
|
|
|
- fmt.println("\n# the basics");
|
|
|
-
|
|
|
- { // The Basics
|
|
|
- fmt.println("Hellope");
|
|
|
-
|
|
|
- // Lexical elements and literals
|
|
|
- // A comment
|
|
|
-
|
|
|
- my_integer_variable: int; // A comment for documentaton
|
|
|
-
|
|
|
- // Multi-line comments begin with /* and end with */. Multi-line comments can
|
|
|
- // also be nested (unlike in C):
|
|
|
- /*
|
|
|
- You can have any text or code here and
|
|
|
- have it be commented.
|
|
|
- /*
|
|
|
- NOTE: comments can be nested!
|
|
|
- */
|
|
|
- */
|
|
|
-
|
|
|
- // String literals are enclosed in double quotes and character literals in single quotes.
|
|
|
- // Special characters are escaped with a backslash \
|
|
|
-
|
|
|
- some_string := "This is a string";
|
|
|
- _ = 'A'; // unicode codepoint literal
|
|
|
- _ = '\n';
|
|
|
- _ = "C:\\Windows\\notepad.exe";
|
|
|
- // Raw string literals are enclosed with single back ticks
|
|
|
- _ = `C:\Windows\notepad.exe`;
|
|
|
-
|
|
|
- // The length of a string in bytes can be found using the built-in `len` procedure:
|
|
|
- _ = len("Foo");
|
|
|
- _ = len(some_string);
|
|
|
-
|
|
|
-
|
|
|
- // Numbers
|
|
|
-
|
|
|
- // Numerical literals are written similar to most other programming languages.
|
|
|
- // A useful feature in Odin is that underscores are allowed for better
|
|
|
- // readability: 1_000_000_000 (one billion). A number that contains a dot is a
|
|
|
- // floating point literal: 1.0e9 (one billion). If a number literal is suffixed
|
|
|
- // with i, is an imaginary number literal: 2i (2 multiply the square root of -1).
|
|
|
-
|
|
|
- // Binary literals are prefixed with 0b, octal literals with 0o, and hexadecimal
|
|
|
- // literals 0x. A leading zero does not produce an octal constant (unlike C).
|
|
|
-
|
|
|
- // In Odin, if a number constant is possible to be represented by a type without
|
|
|
- // precision loss, it will automatically convert to that type.
|
|
|
-
|
|
|
- x: int = 1.0; // A float literal but it can be represented by an integer without precision loss
|
|
|
- // Constant literals are “untyped” which means that they can implicitly convert to a type.
|
|
|
-
|
|
|
- y: int; // `y` is typed of type `int`
|
|
|
- y = 1; // `1` is an untyped integer literal which can implicitly convert to `int`
|
|
|
-
|
|
|
- z: f64; // `z` is typed of type `f64` (64-bit floating point number)
|
|
|
- z = 1; // `1` is an untyped integer literals which can be implicity conver to `f64`
|
|
|
- // No need for any suffixes or decimal places like in other languages
|
|
|
- // CONSTANTS JUST WORK!!!
|
|
|
-
|
|
|
-
|
|
|
- // Assignment statements
|
|
|
- h: int = 123; // declares a new variable `h` with type `int` and assigns a value to it
|
|
|
- h = 637; // assigns a new value to `h`
|
|
|
-
|
|
|
- // `=` is the assignment operator
|
|
|
-
|
|
|
- // You can assign multiple variables with it:
|
|
|
- a, b := 1, "hello"; // declares `a` and `b` and infers the types from the assignments
|
|
|
- b, a = "byte", 0;
|
|
|
-
|
|
|
- // Note: `:=` is two tokens, `:` and `=`. The following are equivalent,
|
|
|
- /*
|
|
|
- i: int = 123;
|
|
|
- i: = 123;
|
|
|
- i := 123;
|
|
|
- */
|
|
|
-
|
|
|
- // Constant declarations
|
|
|
- // Constants are entities (symbols) which have an assigned value.
|
|
|
- // The constant’s value cannot be changed.
|
|
|
- // The constant’s value must be able to be evaluated at compile time:
|
|
|
- X :: "what"; // constant `X` has the untyped string value "what"
|
|
|
-
|
|
|
- // Constants can be explicitly typed like a variable declaration:
|
|
|
- Y : int : 123;
|
|
|
- Z :: Y + 7; // constant computations are possible
|
|
|
-
|
|
|
- _ = my_integer_variable;
|
|
|
- _ = x;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-control_flow :: proc() {
|
|
|
- fmt.println("\n# control flow");
|
|
|
- { // Control flow
|
|
|
- // For loop
|
|
|
- // Odin has only one loop statement, the `for` loop
|
|
|
-
|
|
|
- // Basic for loop
|
|
|
- for i := 0; i < 10; i += 1 {
|
|
|
- fmt.println(i);
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE: Unlike other languages like C, there are no parentheses `( )` surrounding the three components.
|
|
|
- // Braces `{ }` or a `do` are always required>
|
|
|
- for i := 0; i < 10; i += 1 { }
|
|
|
- for i := 0; i < 10; i += 1 do fmt.print();
|
|
|
-
|
|
|
- // The initial and post statements are optional
|
|
|
- i := 0;
|
|
|
- for ; i < 10; {
|
|
|
- i += 1;
|
|
|
- }
|
|
|
-
|
|
|
- // These semicolons can be dropped. This `for` loop is equivalent to C's `while` loop
|
|
|
- i = 0;
|
|
|
- for i < 10 {
|
|
|
- i += 1;
|
|
|
- }
|
|
|
-
|
|
|
- // If the condition is omitted, this produces an infinite loop:
|
|
|
- for {
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- // Range-based for loop
|
|
|
- // The basic for loop
|
|
|
- for j := 0; j < 10; j += 1 {
|
|
|
- fmt.println(j);
|
|
|
- }
|
|
|
- // can also be written
|
|
|
- for j in 0..<10 {
|
|
|
- fmt.println(j);
|
|
|
- }
|
|
|
- for j in 0..9 {
|
|
|
- fmt.println(j);
|
|
|
- }
|
|
|
-
|
|
|
- // Certain built-in types can be iterated over
|
|
|
- some_string := "Hello, 世界";
|
|
|
- for character in some_string { // Strings are assumed to be UTF-8
|
|
|
- fmt.println(character);
|
|
|
- }
|
|
|
-
|
|
|
- some_array := [3]int{1, 4, 9};
|
|
|
- for value in some_array {
|
|
|
- fmt.println(value);
|
|
|
- }
|
|
|
-
|
|
|
- some_slice := []int{1, 4, 9};
|
|
|
- for value in some_slice {
|
|
|
- fmt.println(value);
|
|
|
- }
|
|
|
-
|
|
|
- some_dynamic_array := [dynamic]int{1, 4, 9};
|
|
|
- defer delete(some_dynamic_array);
|
|
|
- for value in some_dynamic_array {
|
|
|
- fmt.println(value);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4};
|
|
|
- defer delete(some_map);
|
|
|
- for key in some_map {
|
|
|
- fmt.println(key);
|
|
|
- }
|
|
|
-
|
|
|
- // Alternatively a second index value can be added
|
|
|
- for character, index in some_string {
|
|
|
- fmt.println(index, character);
|
|
|
- }
|
|
|
- for value, index in some_array {
|
|
|
- fmt.println(index, value);
|
|
|
- }
|
|
|
- for value, index in some_slice {
|
|
|
- fmt.println(index, value);
|
|
|
- }
|
|
|
- for value, index in some_dynamic_array {
|
|
|
- fmt.println(index, value);
|
|
|
- }
|
|
|
- for key, value in some_map {
|
|
|
- fmt.println(key, value);
|
|
|
- }
|
|
|
-
|
|
|
- // The iterated values are copies and cannot be written to.
|
|
|
- // The following idiom is useful for iterating over a container in a by-reference manner:
|
|
|
- for _, idx in some_slice {
|
|
|
- some_slice[idx] = (idx+1)*(idx+1);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // If statements
|
|
|
- x := 123;
|
|
|
- if x >= 0 {
|
|
|
- fmt.println("x is positive");
|
|
|
- }
|
|
|
-
|
|
|
- if y := -34; y < 0 {
|
|
|
- fmt.println("y is negative");
|
|
|
- }
|
|
|
-
|
|
|
- if y := 123; y < 0 {
|
|
|
- fmt.println("y is negative");
|
|
|
- } else if y == 0 {
|
|
|
- fmt.println("y is zero");
|
|
|
- } else {
|
|
|
- fmt.println("y is positive");
|
|
|
- }
|
|
|
-
|
|
|
- // Switch statement
|
|
|
- // A switch statement is another way to write a sequence of if-else statements.
|
|
|
- // In Odin, the default case is denoted as a case without any expression.
|
|
|
-
|
|
|
- switch arch := ODIN_ARCH; arch {
|
|
|
- case "386":
|
|
|
- fmt.println("32-bit");
|
|
|
- case "amd64":
|
|
|
- fmt.println("64-bit");
|
|
|
- case: // default
|
|
|
- fmt.println("Unsupported architecture");
|
|
|
- }
|
|
|
-
|
|
|
- // Odin’s `switch` is like one in C or C++, except that Odin only runs the selected case.
|
|
|
- // This means that a `break` statement is not needed at the end of each case.
|
|
|
- // Another important difference is that the case values need not be integers nor constants.
|
|
|
-
|
|
|
- // To achieve a C-like fall through into the next case block, the keyword `fallthrough` can be used.
|
|
|
- one_angry_dwarf :: proc() -> int {
|
|
|
- fmt.println("one_angry_dwarf was called");
|
|
|
- return 1;
|
|
|
- }
|
|
|
-
|
|
|
- switch j := 0; j {
|
|
|
- case 0:
|
|
|
- case one_angry_dwarf():
|
|
|
- }
|
|
|
-
|
|
|
- // A switch statement without a condition is the same as `switch true`.
|
|
|
- // This can be used to write a clean and long if-else chain and have the
|
|
|
- // ability to break if needed
|
|
|
-
|
|
|
- switch {
|
|
|
- case x < 0:
|
|
|
- fmt.println("x is negative");
|
|
|
- case x == 0:
|
|
|
- fmt.println("x is zero");
|
|
|
- case:
|
|
|
- fmt.println("x is positive");
|
|
|
- }
|
|
|
-
|
|
|
- // A `switch` statement can also use ranges like a range-based loop:
|
|
|
- switch c := 'j'; c {
|
|
|
- case 'A'..'Z', 'a'..'z', '0'..'9':
|
|
|
- fmt.println("c is alphanumeric");
|
|
|
- }
|
|
|
-
|
|
|
- switch x {
|
|
|
- case 0..<10:
|
|
|
- fmt.println("units");
|
|
|
- case 10..<13:
|
|
|
- fmt.println("pre-teens");
|
|
|
- case 13..<20:
|
|
|
- fmt.println("teens");
|
|
|
- case 20..<30:
|
|
|
- fmt.println("twenties");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- { // Defer statement
|
|
|
- // A defer statement defers the execution of a statement until the end of
|
|
|
- // the scope it is in.
|
|
|
-
|
|
|
- // The following will print 4 then 234:
|
|
|
- {
|
|
|
- x := 123;
|
|
|
- defer fmt.println(x);
|
|
|
- {
|
|
|
- defer x = 4;
|
|
|
- x = 2;
|
|
|
- }
|
|
|
- fmt.println(x);
|
|
|
-
|
|
|
- x = 234;
|
|
|
- }
|
|
|
-
|
|
|
- // You can defer an entire block too:
|
|
|
- {
|
|
|
- bar :: proc() {}
|
|
|
-
|
|
|
- defer {
|
|
|
- fmt.println("1");
|
|
|
- fmt.println("2");
|
|
|
- }
|
|
|
-
|
|
|
- cond := false;
|
|
|
- defer if cond {
|
|
|
- bar();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Defer statements are executed in the reverse order that they were declared:
|
|
|
- {
|
|
|
- defer fmt.println("1");
|
|
|
- defer fmt.println("2");
|
|
|
- defer fmt.println("3");
|
|
|
- }
|
|
|
- // Will print 3, 2, and then 1.
|
|
|
-
|
|
|
- if false {
|
|
|
- f, err := os.open("my_file.txt");
|
|
|
- if err != 0 {
|
|
|
- // handle error
|
|
|
- }
|
|
|
- defer os.close(f);
|
|
|
- // rest of code
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- { // When statement
|
|
|
- /*
|
|
|
- The when statement is almost identical to the if statement but with some differences:
|
|
|
-
|
|
|
- * Each condition must be a constant expression as a when
|
|
|
- statement is evaluated at compile time.
|
|
|
- * The statements within a branch do not create a new scope
|
|
|
- * The compiler checks the semantics and code only for statements
|
|
|
- that belong to the first condition that is true
|
|
|
- * An initial statement is not allowed in a when statement
|
|
|
- * when statements are allowed at file scope
|
|
|
- */
|
|
|
-
|
|
|
- // Example
|
|
|
- when ODIN_ARCH == "386" {
|
|
|
- fmt.println("32 bit");
|
|
|
- } else when ODIN_ARCH == "amd64" {
|
|
|
- fmt.println("64 bit");
|
|
|
- } else {
|
|
|
- fmt.println("Unsupported architecture");
|
|
|
- }
|
|
|
- // The when statement is very useful for writing platform specific code.
|
|
|
- // This is akin to the #if construct in C’s preprocessor however, in Odin,
|
|
|
- // it is type checked.
|
|
|
- }
|
|
|
-
|
|
|
- { // Branch statements
|
|
|
- cond, cond1, cond2 := false, false, false;
|
|
|
- one_step :: proc() { fmt.println("one_step"); }
|
|
|
- beyond :: proc() { fmt.println("beyond"); }
|
|
|
-
|
|
|
- // Break statement
|
|
|
- for cond {
|
|
|
- switch {
|
|
|
- case:
|
|
|
- if cond {
|
|
|
- break; // break out of the `switch` statement
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- break; // break out of the `for` statement
|
|
|
- }
|
|
|
-
|
|
|
- loop: for cond1 {
|
|
|
- for cond2 {
|
|
|
- break loop; // leaves both loops
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Continue statement
|
|
|
- for cond {
|
|
|
- if cond2 {
|
|
|
- continue;
|
|
|
- }
|
|
|
- fmt.println("Hellope");
|
|
|
- }
|
|
|
-
|
|
|
- // Fallthrough statement
|
|
|
-
|
|
|
- // Odin’s switch is like one in C or C++, except that Odin only runs the selected
|
|
|
- // case. This means that a break statement is not needed at the end of each case.
|
|
|
- // Another important difference is that the case values need not be integers nor
|
|
|
- // constants.
|
|
|
-
|
|
|
- // fallthrough can be used to explicitly fall through into the next case block:
|
|
|
-
|
|
|
- switch i := 0; i {
|
|
|
- case 0:
|
|
|
- one_step();
|
|
|
- fallthrough;
|
|
|
- case 1:
|
|
|
- beyond();
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-named_proc_return_parameters :: proc() {
|
|
|
- fmt.println("\n# named proc return parameters");
|
|
|
-
|
|
|
- foo0 :: proc() -> int {
|
|
|
- return 123;
|
|
|
- }
|
|
|
- foo1 :: proc() -> (a: int) {
|
|
|
- a = 123;
|
|
|
- return;
|
|
|
- }
|
|
|
- foo2 :: proc() -> (a, b: int) {
|
|
|
- // Named return values act like variables within the scope
|
|
|
- a = 321;
|
|
|
- b = 567;
|
|
|
- return b, a;
|
|
|
- }
|
|
|
- fmt.println("foo0 =", foo0()); // 123
|
|
|
- fmt.println("foo1 =", foo1()); // 123
|
|
|
- fmt.println("foo2 =", foo2()); // 567 321
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-explicit_procedure_overloading :: proc() {
|
|
|
- fmt.println("\n# explicit procedure overloading");
|
|
|
-
|
|
|
- add_ints :: proc(a, b: int) -> int {
|
|
|
- x := a + b;
|
|
|
- fmt.println("add_ints", x);
|
|
|
- return x;
|
|
|
- }
|
|
|
- add_floats :: proc(a, b: f32) -> f32 {
|
|
|
- x := a + b;
|
|
|
- fmt.println("add_floats", x);
|
|
|
- return x;
|
|
|
- }
|
|
|
- add_numbers :: proc(a: int, b: f32, c: u8) -> int {
|
|
|
- x := int(a) + int(b) + int(c);
|
|
|
- fmt.println("add_numbers", x);
|
|
|
- return x;
|
|
|
- }
|
|
|
-
|
|
|
- add :: proc{add_ints, add_floats, add_numbers};
|
|
|
-
|
|
|
- add(int(1), int(2));
|
|
|
- add(f32(1), f32(2));
|
|
|
- add(int(1), f32(2), u8(3));
|
|
|
-
|
|
|
- add(1, 2); // untyped ints coerce to int tighter than f32
|
|
|
- add(1.0, 2.0); // untyped floats coerce to f32 tighter than int
|
|
|
- add(1, 2, 3); // three parameters
|
|
|
-
|
|
|
- // Ambiguous answers
|
|
|
- // add(1.0, 2);
|
|
|
- // add(1, 2.0);
|
|
|
-}
|
|
|
-
|
|
|
-struct_type :: proc() {
|
|
|
- fmt.println("\n# struct type");
|
|
|
- // A struct is a record type in Odin. It is a collection of fields.
|
|
|
- // Struct fields are accessed by using a dot:
|
|
|
- {
|
|
|
- Vector2 :: struct {
|
|
|
- x: f32,
|
|
|
- y: f32,
|
|
|
- };
|
|
|
- v := Vector2{1, 2};
|
|
|
- v.x = 4;
|
|
|
- fmt.println(v.x);
|
|
|
-
|
|
|
- // Struct fields can be accessed through a struct pointer:
|
|
|
-
|
|
|
- v = Vector2{1, 2};
|
|
|
- p := &v;
|
|
|
- p.x = 1335;
|
|
|
- fmt.println(v);
|
|
|
-
|
|
|
- // We could write p^.x, however, it is to nice abstract the ability
|
|
|
- // to not explicitly dereference the pointer. This is very useful when
|
|
|
- // refactoring code to use a pointer rather than a value, and vice versa.
|
|
|
- }
|
|
|
- {
|
|
|
- // A struct literal can be denoted by providing the struct’s type
|
|
|
- // followed by {}. A struct literal must either provide all the
|
|
|
- // arguments or none:
|
|
|
- Vector3 :: struct {
|
|
|
- x, y, z: f32,
|
|
|
- };
|
|
|
- v: Vector3;
|
|
|
- v = Vector3{}; // Zero value
|
|
|
- v = Vector3{1, 4, 9};
|
|
|
-
|
|
|
- // You can list just a subset of the fields if you specify the
|
|
|
- // field by name (the order of the named fields does not matter):
|
|
|
- v = Vector3{z=1, y=2};
|
|
|
- assert(v.x == 0);
|
|
|
- assert(v.y == 2);
|
|
|
- assert(v.z == 1);
|
|
|
- }
|
|
|
- {
|
|
|
- // Structs can tagged with different memory layout and alignment requirements:
|
|
|
-
|
|
|
- a :: struct #align 4 {}; // align to 4 bytes
|
|
|
- b :: struct #packed {}; // remove padding between fields
|
|
|
- c :: struct #raw_union {}; // all fields share the same offset (0). This is the same as C's union
|
|
|
- }
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-union_type :: proc() {
|
|
|
- fmt.println("\n# union type");
|
|
|
- {
|
|
|
- val: union{int, bool};
|
|
|
- val = 137;
|
|
|
- if i, ok := val.(int); ok {
|
|
|
- fmt.println(i);
|
|
|
- }
|
|
|
- val = true;
|
|
|
- fmt.println(val);
|
|
|
-
|
|
|
- val = nil;
|
|
|
-
|
|
|
- switch v in val {
|
|
|
- case int: fmt.println("int", v);
|
|
|
- case bool: fmt.println("bool", v);
|
|
|
- case: fmt.println("nil");
|
|
|
- }
|
|
|
- }
|
|
|
- {
|
|
|
- // There is a duality between `any` and `union`
|
|
|
- // An `any` has a pointer to the data and allows for any type (open)
|
|
|
- // A `union` has as binary blob to store the data and allows only certain types (closed)
|
|
|
- // The following code is with `any` but has the same syntax
|
|
|
- val: any;
|
|
|
- val = 137;
|
|
|
- if i, ok := val.(int); ok {
|
|
|
- fmt.println(i);
|
|
|
- }
|
|
|
- val = true;
|
|
|
- fmt.println(val);
|
|
|
-
|
|
|
- val = nil;
|
|
|
-
|
|
|
- switch v in val {
|
|
|
- case int: fmt.println("int", v);
|
|
|
- case bool: fmt.println("bool", v);
|
|
|
- case: fmt.println("nil");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- Vector3 :: distinct [3]f32;
|
|
|
- Quaternion :: distinct quaternion128;
|
|
|
-
|
|
|
- // More realistic examples
|
|
|
- {
|
|
|
- // NOTE(bill): For the above basic examples, you may not have any
|
|
|
- // particular use for it. However, my main use for them is not for these
|
|
|
- // simple cases. My main use is for hierarchical types. Many prefer
|
|
|
- // subtyping, embedding the base data into the derived types. Below is
|
|
|
- // an example of this for a basic game Entity.
|
|
|
-
|
|
|
- Entity :: struct {
|
|
|
- id: u64,
|
|
|
- name: string,
|
|
|
- position: Vector3,
|
|
|
- orientation: Quaternion,
|
|
|
-
|
|
|
- derived: any,
|
|
|
- };
|
|
|
-
|
|
|
- Frog :: struct {
|
|
|
- using entity: Entity,
|
|
|
- jump_height: f32,
|
|
|
- };
|
|
|
-
|
|
|
- Monster :: struct {
|
|
|
- using entity: Entity,
|
|
|
- is_robot: bool,
|
|
|
- is_zombie: bool,
|
|
|
- };
|
|
|
-
|
|
|
- // See `parametric_polymorphism` procedure for details
|
|
|
- new_entity :: proc($T: typeid) -> ^Entity {
|
|
|
- t := new(T);
|
|
|
- t.derived = t^;
|
|
|
- return t;
|
|
|
- }
|
|
|
-
|
|
|
- entity := new_entity(Monster);
|
|
|
-
|
|
|
- switch e in entity.derived {
|
|
|
- case Frog:
|
|
|
- fmt.println("Ribbit");
|
|
|
- case Monster:
|
|
|
- if e.is_robot do fmt.println("Robotic");
|
|
|
- if e.is_zombie do fmt.println("Grrrr!");
|
|
|
- fmt.println("I'm a monster");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- // NOTE(bill): A union can be used to achieve something similar. Instead
|
|
|
- // of embedding the base data into the derived types, the derived data
|
|
|
- // in embedded into the base type. Below is the same example of the
|
|
|
- // basic game Entity but using an union.
|
|
|
-
|
|
|
- Entity :: struct {
|
|
|
- id: u64,
|
|
|
- name: string,
|
|
|
- position: Vector3,
|
|
|
- orientation: Quaternion,
|
|
|
-
|
|
|
- derived: union {Frog, Monster},
|
|
|
- };
|
|
|
-
|
|
|
- Frog :: struct {
|
|
|
- using entity: ^Entity,
|
|
|
- jump_height: f32,
|
|
|
- };
|
|
|
-
|
|
|
- Monster :: struct {
|
|
|
- using entity: ^Entity,
|
|
|
- is_robot: bool,
|
|
|
- is_zombie: bool,
|
|
|
- };
|
|
|
-
|
|
|
- // See `parametric_polymorphism` procedure for details
|
|
|
- new_entity :: proc($T: typeid) -> ^Entity {
|
|
|
- t := new(Entity);
|
|
|
- t.derived = T{entity = t};
|
|
|
- return t;
|
|
|
- }
|
|
|
-
|
|
|
- entity := new_entity(Monster);
|
|
|
-
|
|
|
- switch e in entity.derived {
|
|
|
- case Frog:
|
|
|
- fmt.println("Ribbit");
|
|
|
- case Monster:
|
|
|
- if e.is_robot do fmt.println("Robotic");
|
|
|
- if e.is_zombie do fmt.println("Grrrr!");
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE(bill): As you can see, the usage code has not changed, only its
|
|
|
- // memory layout. Both approaches have their own advantages but they can
|
|
|
- // be used together to achieve different results. The subtyping approach
|
|
|
- // can allow for a greater control of the memory layout and memory
|
|
|
- // allocation, e.g. storing the derivatives together. However, this is
|
|
|
- // also its disadvantage. You must either preallocate arrays for each
|
|
|
- // derivative separation (which can be easily missed) or preallocate a
|
|
|
- // bunch of "raw" memory; determining the maximum size of the derived
|
|
|
- // types would require the aid of metaprogramming. Unions solve this
|
|
|
- // particular problem as the data is stored with the base data.
|
|
|
- // Therefore, it is possible to preallocate, e.g. [100]Entity.
|
|
|
-
|
|
|
- // It should be noted that the union approach can have the same memory
|
|
|
- // layout as the any and with the same type restrictions by using a
|
|
|
- // pointer type for the derivatives.
|
|
|
-
|
|
|
- /*
|
|
|
- Entity :: struct {
|
|
|
- ...
|
|
|
- derived: union{^Frog, ^Monster},
|
|
|
- }
|
|
|
-
|
|
|
- Frog :: struct {
|
|
|
- using entity: Entity,
|
|
|
- ...
|
|
|
- }
|
|
|
- Monster :: struct {
|
|
|
- using entity: Entity,
|
|
|
- ...
|
|
|
-
|
|
|
- }
|
|
|
- new_entity :: proc(T: type) -> ^Entity {
|
|
|
- t := new(T);
|
|
|
- t.derived = t;
|
|
|
- return t;
|
|
|
- }
|
|
|
- */
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-using_statement :: proc() {
|
|
|
- fmt.println("\n# using statement");
|
|
|
- // using can used to bring entities declared in a scope/namespace
|
|
|
- // into the current scope. This can be applied to import declarations,
|
|
|
- // import names, struct fields, procedure fields, and struct values.
|
|
|
-
|
|
|
- Vector3 :: struct{x, y, z: f32};
|
|
|
- {
|
|
|
- Entity :: struct {
|
|
|
- position: Vector3,
|
|
|
- orientation: quaternion128,
|
|
|
- };
|
|
|
-
|
|
|
- // It can used like this:
|
|
|
- foo0 :: proc(entity: ^Entity) {
|
|
|
- fmt.println(entity.position.x, entity.position.y, entity.position.z);
|
|
|
- }
|
|
|
-
|
|
|
- // The entity members can be brought into the procedure scope by using it:
|
|
|
- foo1 :: proc(entity: ^Entity) {
|
|
|
- using entity;
|
|
|
- fmt.println(position.x, position.y, position.z);
|
|
|
- }
|
|
|
-
|
|
|
- // The using can be applied to the parameter directly:
|
|
|
- foo2 :: proc(using entity: ^Entity) {
|
|
|
- fmt.println(position.x, position.y, position.z);
|
|
|
- }
|
|
|
-
|
|
|
- // It can also be applied to sub-fields:
|
|
|
- foo3 :: proc(entity: ^Entity) {
|
|
|
- using entity.position;
|
|
|
- fmt.println(x, y, z);
|
|
|
- }
|
|
|
- }
|
|
|
- {
|
|
|
- // We can also apply the using statement to the struct fields directly,
|
|
|
- // making all the fields of position appear as if they on Entity itself:
|
|
|
- Entity :: struct {
|
|
|
- using position: Vector3,
|
|
|
- orientation: quaternion128,
|
|
|
- };
|
|
|
- foo :: proc(entity: ^Entity) {
|
|
|
- fmt.println(entity.x, entity.y, entity.z);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Subtype polymorphism
|
|
|
- // It is possible to get subtype polymorphism, similar to inheritance-like
|
|
|
- // functionality in C++, but without the requirement of vtables or unknown
|
|
|
- // struct layout:
|
|
|
-
|
|
|
- Colour :: struct {r, g, b, a: u8};
|
|
|
- Frog :: struct {
|
|
|
- ribbit_volume: f32,
|
|
|
- using entity: Entity,
|
|
|
- colour: Colour,
|
|
|
- };
|
|
|
-
|
|
|
- frog: Frog;
|
|
|
- // Both work
|
|
|
- foo(&frog.entity);
|
|
|
- foo(&frog);
|
|
|
- frog.x = 123;
|
|
|
-
|
|
|
- // Note: using can be applied to arbitrarily many things, which allows
|
|
|
- // the ability to have multiple subtype polymorphism (but also its issues).
|
|
|
-
|
|
|
- // Note: using’d fields can still be referred by name.
|
|
|
- }
|
|
|
- { // using on an enum declaration
|
|
|
-
|
|
|
- using Foo :: enum {A, B, C};
|
|
|
-
|
|
|
- f0 := A;
|
|
|
- f1 := B;
|
|
|
- f2 := C;
|
|
|
- fmt.println(f0, f1, f2);
|
|
|
- fmt.println(len(Foo));
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-implicit_context_system :: proc() {
|
|
|
- fmt.println("\n# implicit context system");
|
|
|
- // In each scope, there is an implicit value named context. This
|
|
|
- // context variable is local to each scope and is implicitly passed
|
|
|
- // by pointer to any procedure call in that scope (if the procedure
|
|
|
- // has the Odin calling convention).
|
|
|
-
|
|
|
- // The main purpose of the implicit context system is for the ability
|
|
|
- // to intercept third-party code and libraries and modify their
|
|
|
- // functionality. One such case is modifying how a library allocates
|
|
|
- // something or logs something. In C, this was usually achieved with
|
|
|
- // the library defining macros which could be overridden so that the
|
|
|
- // user could define what he wanted. However, not many libraries
|
|
|
- // supported this in many languages by default which meant intercepting
|
|
|
- // third-party code to see what it does and to change how it does it is
|
|
|
- // not possible.
|
|
|
-
|
|
|
- c := context; // copy the current scope's context
|
|
|
-
|
|
|
- context.user_index = 456;
|
|
|
- {
|
|
|
- context.allocator = my_custom_allocator();
|
|
|
- context.user_index = 123;
|
|
|
- what_a_fool_believes(); // the `context` for this scope is implicitly passed to `what_a_fool_believes`
|
|
|
- }
|
|
|
-
|
|
|
- // `context` value is local to the scope it is in
|
|
|
- assert(context.user_index == 456);
|
|
|
-
|
|
|
- what_a_fool_believes :: proc() {
|
|
|
- c := context; // this `context` is the same as the parent procedure that it was called from
|
|
|
- // From this example, context.user_index == 123
|
|
|
- // An context.allocator is assigned to the return value of `my_custom_allocator()`
|
|
|
- assert(context.user_index == 123);
|
|
|
-
|
|
|
- // The memory management procedure use the `context.allocator` by
|
|
|
- // default unless explicitly specified otherwise
|
|
|
- china_grove := new(int);
|
|
|
- free(china_grove);
|
|
|
-
|
|
|
- _ = c;
|
|
|
- }
|
|
|
-
|
|
|
- my_custom_allocator :: mem.nil_allocator;
|
|
|
- _ = c;
|
|
|
-
|
|
|
- // By default, the context value has default values for its parameters which is
|
|
|
- // decided in the package runtime. What the defaults are are compiler specific.
|
|
|
-
|
|
|
- // To see what the implicit context value contains, please see the following
|
|
|
- // definition in package runtime.
|
|
|
-}
|
|
|
-
|
|
|
-parametric_polymorphism :: proc() {
|
|
|
- fmt.println("\n# parametric polymorphism");
|
|
|
-
|
|
|
- print_value :: proc(value: $T) {
|
|
|
- fmt.printf("print_value: %T %v\n", value, value);
|
|
|
- }
|
|
|
-
|
|
|
- v1: int = 1;
|
|
|
- v2: f32 = 2.1;
|
|
|
- v3: f64 = 3.14;
|
|
|
- v4: string = "message";
|
|
|
-
|
|
|
- print_value(v1);
|
|
|
- print_value(v2);
|
|
|
- print_value(v3);
|
|
|
- print_value(v4);
|
|
|
-
|
|
|
- fmt.println();
|
|
|
-
|
|
|
- add :: proc(p, q: $T) -> T {
|
|
|
- x: T = p + q;
|
|
|
- return x;
|
|
|
- }
|
|
|
-
|
|
|
- a := add(3, 4);
|
|
|
- fmt.printf("a: %T = %v\n", a, a);
|
|
|
-
|
|
|
- b := add(3.2, 4.3);
|
|
|
- fmt.printf("b: %T = %v\n", b, b);
|
|
|
-
|
|
|
- // This is how `new` is implemented
|
|
|
- alloc_type :: proc($T: typeid) -> ^T {
|
|
|
- t := cast(^T)alloc(size_of(T), align_of(T));
|
|
|
- t^ = T{}; // Use default initialization value
|
|
|
- return t;
|
|
|
- }
|
|
|
-
|
|
|
- copy_slice :: proc(dst, src: []$T) -> int {
|
|
|
- n := min(len(dst), len(src));
|
|
|
- if n > 0 {
|
|
|
- mem.copy(&dst[0], &src[0], n*size_of(T));
|
|
|
- }
|
|
|
- return n;
|
|
|
- }
|
|
|
-
|
|
|
- double_params :: proc(a: $A, b: $B) -> A {
|
|
|
- return a + A(b);
|
|
|
- }
|
|
|
-
|
|
|
- fmt.println(double_params(12, 1.345));
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- { // Polymorphic Types and Type Specialization
|
|
|
- Table_Slot :: struct(Key, Value: typeid) {
|
|
|
- occupied: bool,
|
|
|
- hash: u32,
|
|
|
- key: Key,
|
|
|
- value: Value,
|
|
|
- };
|
|
|
- TABLE_SIZE_MIN :: 32;
|
|
|
- Table :: struct(Key, Value: typeid) {
|
|
|
- count: int,
|
|
|
- allocator: mem.Allocator,
|
|
|
- slots: []Table_Slot(Key, Value),
|
|
|
- };
|
|
|
-
|
|
|
- // Only allow types that are specializations of a (polymorphic) slice
|
|
|
- make_slice :: proc($T: typeid/[]$E, len: int) -> T {
|
|
|
- return make(T, len);
|
|
|
- }
|
|
|
-
|
|
|
- // Only allow types that are specializations of `Table`
|
|
|
- allocate :: proc(table: ^$T/Table, capacity: int) {
|
|
|
- c := context;
|
|
|
- if table.allocator.procedure != nil do c.allocator = table.allocator;
|
|
|
- context = c;
|
|
|
-
|
|
|
- table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN));
|
|
|
- }
|
|
|
-
|
|
|
- expand :: proc(table: ^$T/Table) {
|
|
|
- c := context;
|
|
|
- if table.allocator.procedure != nil do c.allocator = table.allocator;
|
|
|
- context = c;
|
|
|
-
|
|
|
- old_slots := table.slots;
|
|
|
- defer delete(old_slots);
|
|
|
-
|
|
|
- cap := max(2*len(table.slots), TABLE_SIZE_MIN);
|
|
|
- allocate(table, cap);
|
|
|
-
|
|
|
- for s in old_slots do if s.occupied {
|
|
|
- put(table, s.key, s.value);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Polymorphic determination of a polymorphic struct
|
|
|
- // put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
|
|
|
- put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
|
|
|
- hash := get_hash(key); // Ad-hoc method which would fail in a different scope
|
|
|
- index := find_index(table, key, hash);
|
|
|
- if index < 0 {
|
|
|
- if f64(table.count) >= 0.75*f64(len(table.slots)) {
|
|
|
- expand(table);
|
|
|
- }
|
|
|
- assert(table.count <= len(table.slots));
|
|
|
-
|
|
|
- index = int(hash % u32(len(table.slots)));
|
|
|
-
|
|
|
- for table.slots[index].occupied {
|
|
|
- if index += 1; index >= len(table.slots) {
|
|
|
- index = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- table.count += 1;
|
|
|
- }
|
|
|
-
|
|
|
- slot := &table.slots[index];
|
|
|
- slot.occupied = true;
|
|
|
- slot.hash = hash;
|
|
|
- slot.key = key;
|
|
|
- slot.value = value;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
|
|
|
- find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
|
|
|
- hash := get_hash(key);
|
|
|
- index := find_index(table, key, hash);
|
|
|
- if index < 0 {
|
|
|
- return Value{}, false;
|
|
|
- }
|
|
|
- return table.slots[index].value, true;
|
|
|
- }
|
|
|
-
|
|
|
- find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
|
|
|
- if len(table.slots) <= 0 do return -1;
|
|
|
-
|
|
|
- index := int(hash % u32(len(table.slots)));
|
|
|
- for table.slots[index].occupied {
|
|
|
- if table.slots[index].hash == hash {
|
|
|
- if table.slots[index].key == key {
|
|
|
- return index;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if index += 1; index >= len(table.slots) {
|
|
|
- index = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- get_hash :: proc(s: string) -> u32 { // fnv32a
|
|
|
- h: u32 = 0x811c9dc5;
|
|
|
- for i in 0..<len(s) {
|
|
|
- h = (h ~ u32(s[i])) * 0x01000193;
|
|
|
- }
|
|
|
- return h;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- table: Table(string, int);
|
|
|
-
|
|
|
- for i in 0..36 do put(&table, "Hellope", i);
|
|
|
- for i in 0..42 do put(&table, "World!", i);
|
|
|
-
|
|
|
- found, _ := find(&table, "Hellope");
|
|
|
- fmt.printf("`found` is %v\n", found);
|
|
|
-
|
|
|
- found, _ = find(&table, "World!");
|
|
|
- fmt.printf("`found` is %v\n", found);
|
|
|
-
|
|
|
- // I would not personally design a hash table like this in production
|
|
|
- // but this is a nice basic example
|
|
|
- // A better approach would either use a `u64` or equivalent for the key
|
|
|
- // and let the user specify the hashing function or make the user store
|
|
|
- // the hashing procedure with the table
|
|
|
- }
|
|
|
-
|
|
|
- { // Parametric polymorphic union
|
|
|
- Error :: enum {
|
|
|
- Foo0,
|
|
|
- Foo1,
|
|
|
- Foo2,
|
|
|
- Foo3,
|
|
|
- };
|
|
|
- Para_Union :: union(T: typeid) {T, Error};
|
|
|
- r: Para_Union(int);
|
|
|
- fmt.println(typeid_of(type_of(r)));
|
|
|
-
|
|
|
- fmt.println(r);
|
|
|
- r = 123;
|
|
|
- fmt.println(r);
|
|
|
- r = Error.Foo0; // r = .Foo0; is allow too, see implicit selector expressions below
|
|
|
- fmt.println(r);
|
|
|
- }
|
|
|
-
|
|
|
- { // Polymorphic names
|
|
|
- foo :: proc($N: $I, $T: typeid) -> (res: [N]T) {
|
|
|
- // `N` is the constant value passed
|
|
|
- // `I` is the type of N
|
|
|
- // `T` is the type passed
|
|
|
- fmt.printf("Generating an array of type %v from the value %v of type %v\n",
|
|
|
- typeid_of(type_of(res)), N, typeid_of(I));
|
|
|
- for i in 0..<N {
|
|
|
- res[i] = T(i*i);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- T :: int;
|
|
|
- array := foo(4, T);
|
|
|
- for v, i in array {
|
|
|
- assert(v == T(i*i));
|
|
|
- }
|
|
|
-
|
|
|
- // Matrix multiplication
|
|
|
- mul :: proc(a: [$M][$N]$T, b: [N][$P]T) -> (c: [M][P]T) {
|
|
|
- for i in 0..<M {
|
|
|
- for j in 0..<P {
|
|
|
- for k in 0..<N {
|
|
|
- c[i][j] += a[i][k] * b[k][j];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- x := [2][3]f32{
|
|
|
- {1, 2, 3},
|
|
|
- {3, 2, 1},
|
|
|
- };
|
|
|
- y := [3][2]f32{
|
|
|
- {0, 8},
|
|
|
- {6, 2},
|
|
|
- {8, 4},
|
|
|
- };
|
|
|
- z := mul(x, y);
|
|
|
- assert(z == {{36, 24}, {20, 32}});
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-prefix_table := [?]string{
|
|
|
- "White",
|
|
|
- "Red",
|
|
|
- "Green",
|
|
|
- "Blue",
|
|
|
- "Octarine",
|
|
|
- "Black",
|
|
|
-};
|
|
|
-
|
|
|
-threading_example :: proc() {
|
|
|
- fmt.println("\n# threading_example");
|
|
|
-
|
|
|
- { // Basic Threads
|
|
|
- fmt.println("\n## Basic Threads");
|
|
|
- worker_proc :: proc(t: ^thread.Thread) {
|
|
|
- for iteration in 1..5 {
|
|
|
- fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration);
|
|
|
- fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration);
|
|
|
- time.sleep(1 * time.Millisecond);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- threads := make([dynamic]^thread.Thread, 0, len(prefix_table));
|
|
|
- defer delete(threads);
|
|
|
-
|
|
|
- for in prefix_table {
|
|
|
- if t := thread.create(worker_proc); t != nil {
|
|
|
- t.init_context = context;
|
|
|
- t.use_init_context = true;
|
|
|
- t.user_index = len(threads);
|
|
|
- append(&threads, t);
|
|
|
- thread.start(t);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for len(threads) > 0 {
|
|
|
- for i := 0; i < len(threads); /**/ {
|
|
|
- if t := threads[i]; thread.is_done(t) {
|
|
|
- fmt.printf("Thread %d is done\n", t.user_index);
|
|
|
- thread.destroy(t);
|
|
|
-
|
|
|
- ordered_remove(&threads, i);
|
|
|
- } else {
|
|
|
- i += 1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- { // Thread Pool
|
|
|
- fmt.println("\n## Thread Pool");
|
|
|
- task_proc :: proc(t: ^thread.Task) {
|
|
|
- index := t.user_index % len(prefix_table);
|
|
|
- for iteration in 1..5 {
|
|
|
- fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration);
|
|
|
- fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration);
|
|
|
- time.sleep(1 * time.Millisecond);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- pool: thread.Pool;
|
|
|
- thread.pool_init(pool=&pool, thread_count=3);
|
|
|
- defer thread.pool_destroy(&pool);
|
|
|
-
|
|
|
-
|
|
|
- for i in 0..<30 {
|
|
|
- thread.pool_add_task(pool=&pool, procedure=task_proc, data=nil, user_index=i);
|
|
|
- }
|
|
|
-
|
|
|
- thread.pool_start(&pool);
|
|
|
- thread.pool_wait_and_process(&pool);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-array_programming :: proc() {
|
|
|
- fmt.println("\n# array programming");
|
|
|
- {
|
|
|
- a := [3]f32{1, 2, 3};
|
|
|
- b := [3]f32{5, 6, 7};
|
|
|
- c := a * b;
|
|
|
- d := a + b;
|
|
|
- e := 1 + (c - d) / 2;
|
|
|
- fmt.printf("%.1f\n", e); // [0.5, 3.0, 6.5]
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- a := [3]f32{1, 2, 3};
|
|
|
- b := swizzle(a, 2, 1, 0);
|
|
|
- assert(b == [3]f32{3, 2, 1});
|
|
|
-
|
|
|
- c := swizzle(a, 0, 0);
|
|
|
- assert(c == [2]f32{1, 1});
|
|
|
- assert(c == 1);
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- Vector3 :: distinct [3]f32;
|
|
|
- a := Vector3{1, 2, 3};
|
|
|
- b := Vector3{5, 6, 7};
|
|
|
- c := (a * b)/2 + 1;
|
|
|
- d := c.x + c.y + c.z;
|
|
|
- fmt.printf("%.1f\n", d); // 22.0
|
|
|
-
|
|
|
- cross :: proc(a, b: Vector3) -> Vector3 {
|
|
|
- i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1);
|
|
|
- j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0);
|
|
|
- return i - j;
|
|
|
- }
|
|
|
-
|
|
|
- blah :: proc(a: Vector3) -> f32 {
|
|
|
- return a.x + a.y + a.z;
|
|
|
- }
|
|
|
-
|
|
|
- x := cross(a, b);
|
|
|
- fmt.println(x);
|
|
|
- fmt.println(blah(x));
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-map_type :: proc() {
|
|
|
- fmt.println("\n# map type");
|
|
|
-
|
|
|
- m := make(map[string]int);
|
|
|
- defer delete(m);
|
|
|
-
|
|
|
- m["Bob"] = 2;
|
|
|
- m["Ted"] = 5;
|
|
|
- fmt.println(m["Bob"]);
|
|
|
-
|
|
|
- delete_key(&m, "Ted");
|
|
|
-
|
|
|
- // If an element of a key does not exist, the zero value of the
|
|
|
- // element will be returned. To check to see if an element exists
|
|
|
- // can be done in two ways:
|
|
|
- elem, ok := m["Bob"];
|
|
|
- exists := "Bob" in m;
|
|
|
- _, _ = elem, ok;
|
|
|
- _ = exists;
|
|
|
-}
|
|
|
-
|
|
|
-implicit_selector_expression :: proc() {
|
|
|
- fmt.println("\n# implicit selector expression");
|
|
|
-
|
|
|
- Foo :: enum {A, B, C};
|
|
|
-
|
|
|
- f: Foo;
|
|
|
- f = Foo.A;
|
|
|
- f = .A;
|
|
|
-
|
|
|
- BAR :: bit_set[Foo]{.B, .C};
|
|
|
-
|
|
|
- switch f {
|
|
|
- case .A:
|
|
|
- fmt.println("HITHER");
|
|
|
- case .B:
|
|
|
- fmt.println("NEVER");
|
|
|
- case .C:
|
|
|
- fmt.println("FOREVER");
|
|
|
- }
|
|
|
-
|
|
|
- my_map := make(map[Foo]int);
|
|
|
- defer delete(my_map);
|
|
|
-
|
|
|
- my_map[.A] = 123;
|
|
|
- my_map[Foo.B] = 345;
|
|
|
-
|
|
|
- fmt.println(my_map[.A] + my_map[Foo.B] + my_map[.C]);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-partial_switch :: proc() {
|
|
|
- fmt.println("\n# partial_switch");
|
|
|
- { // enum
|
|
|
- Foo :: enum {
|
|
|
- A,
|
|
|
- B,
|
|
|
- C,
|
|
|
- D,
|
|
|
- };
|
|
|
-
|
|
|
- f := Foo.A;
|
|
|
- switch f {
|
|
|
- case .A: fmt.println("A");
|
|
|
- case .B: fmt.println("B");
|
|
|
- case .C: fmt.println("C");
|
|
|
- case .D: fmt.println("D");
|
|
|
- case: fmt.println("?");
|
|
|
- }
|
|
|
-
|
|
|
- #partial switch f {
|
|
|
- case .A: fmt.println("A");
|
|
|
- case .D: fmt.println("D");
|
|
|
- }
|
|
|
- }
|
|
|
- { // union
|
|
|
- Foo :: union {int, bool};
|
|
|
- f: Foo = 123;
|
|
|
- switch in f {
|
|
|
- case int: fmt.println("int");
|
|
|
- case bool: fmt.println("bool");
|
|
|
- case:
|
|
|
- }
|
|
|
-
|
|
|
- #partial switch in f {
|
|
|
- case bool: fmt.println("bool");
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-cstring_example :: proc() {
|
|
|
- fmt.println("\n# cstring_example");
|
|
|
-
|
|
|
- W :: "Hellope";
|
|
|
- X :: cstring(W);
|
|
|
- Y :: string(X);
|
|
|
-
|
|
|
- w := W;
|
|
|
- _ = w;
|
|
|
- x: cstring = X;
|
|
|
- y: string = Y;
|
|
|
- z := string(x);
|
|
|
- fmt.println(x, y, z);
|
|
|
- fmt.println(len(x), len(y), len(z));
|
|
|
- fmt.println(len(W), len(X), len(Y));
|
|
|
- // IMPORTANT NOTE for cstring variables
|
|
|
- // len(cstring) is O(N)
|
|
|
- // cast(string)cstring is O(N)
|
|
|
-}
|
|
|
-
|
|
|
-bit_set_type :: proc() {
|
|
|
- fmt.println("\n# bit_set type");
|
|
|
-
|
|
|
- {
|
|
|
- using Day :: enum {
|
|
|
- Sunday,
|
|
|
- Monday,
|
|
|
- Tuesday,
|
|
|
- Wednesday,
|
|
|
- Thursday,
|
|
|
- Friday,
|
|
|
- Saturday,
|
|
|
- };
|
|
|
-
|
|
|
- Days :: distinct bit_set[Day];
|
|
|
- WEEKEND :: Days{Sunday, Saturday};
|
|
|
-
|
|
|
- d: Days;
|
|
|
- d = {Sunday, Monday};
|
|
|
- e := d | WEEKEND;
|
|
|
- e |= {Monday};
|
|
|
- fmt.println(d, e);
|
|
|
-
|
|
|
- ok := Saturday in e; // `in` is only allowed for `map` and `bit_set` types
|
|
|
- fmt.println(ok);
|
|
|
- if Saturday in e {
|
|
|
- fmt.println("Saturday in", e);
|
|
|
- }
|
|
|
- X :: Saturday in WEEKEND; // Constant evaluation
|
|
|
- fmt.println(X);
|
|
|
- fmt.println("Cardinality:", card(e));
|
|
|
- }
|
|
|
- {
|
|
|
- x: bit_set['A'..'Z'];
|
|
|
- #assert(size_of(x) == size_of(u32));
|
|
|
- y: bit_set[0..8; u16];
|
|
|
- fmt.println(typeid_of(type_of(x))); // bit_set[A..Z]
|
|
|
- fmt.println(typeid_of(type_of(y))); // bit_set[0..8; u16]
|
|
|
-
|
|
|
- incl(&x, 'F');
|
|
|
- assert('F' in x);
|
|
|
- excl(&x, 'F');
|
|
|
- assert('F' not_in x);
|
|
|
-
|
|
|
- y |= {1, 4, 2};
|
|
|
- assert(2 in y);
|
|
|
- }
|
|
|
- {
|
|
|
- Letters :: bit_set['A'..'Z'];
|
|
|
- a := Letters{'A', 'B'};
|
|
|
- b := Letters{'A', 'B', 'C', 'D', 'F'};
|
|
|
- c := Letters{'A', 'B'};
|
|
|
-
|
|
|
- assert(a <= b); // 'a' is a subset of 'b'
|
|
|
- assert(b >= a); // 'b' is a superset of 'a'
|
|
|
- assert(a < b); // 'a' is a strict subset of 'b'
|
|
|
- assert(b > a); // 'b' is a strict superset of 'a'
|
|
|
-
|
|
|
- assert(!(a < c)); // 'a' is a not strict subset of 'c'
|
|
|
- assert(!(c > a)); // 'c' is a not strict superset of 'a'
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-deferred_procedure_associations :: proc() {
|
|
|
- fmt.println("\n# deferred procedure associations");
|
|
|
-
|
|
|
- @(deferred_out=closure)
|
|
|
- open :: proc(s: string) -> bool {
|
|
|
- fmt.println(s);
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- closure :: proc(ok: bool) {
|
|
|
- fmt.println("Goodbye?", ok);
|
|
|
- }
|
|
|
-
|
|
|
- if open("Welcome") {
|
|
|
- fmt.println("Something in the middle, mate.");
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-reflection :: proc() {
|
|
|
- fmt.println("\n# reflection");
|
|
|
-
|
|
|
- Foo :: struct {
|
|
|
- x: int `tag1`,
|
|
|
- y: string `json:"y_field"`,
|
|
|
- z: bool, // no tag
|
|
|
- };
|
|
|
-
|
|
|
- id := typeid_of(Foo);
|
|
|
- names := reflect.struct_field_names(id);
|
|
|
- types := reflect.struct_field_types(id);
|
|
|
- tags := reflect.struct_field_tags(id);
|
|
|
-
|
|
|
- assert(len(names) == len(types) && len(names) == len(tags));
|
|
|
-
|
|
|
- fmt.println("Foo :: struct {");
|
|
|
- for tag, i in tags {
|
|
|
- name, type := names[i], types[i];
|
|
|
- if tag != "" {
|
|
|
- fmt.printf("\t%s: %T `%s`,\n", name, type, tag);
|
|
|
- } else {
|
|
|
- fmt.printf("\t%s: %T,\n", name, type);
|
|
|
- }
|
|
|
- }
|
|
|
- fmt.println("}");
|
|
|
-
|
|
|
-
|
|
|
- for tag, i in tags {
|
|
|
- if val, ok := reflect.struct_tag_lookup(tag, "json"); ok {
|
|
|
- fmt.printf("json: %s -> %s\n", names[i], val);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-quaternions :: proc() {
|
|
|
- // Not just an April Fool's Joke any more, but a fully working thing!
|
|
|
- fmt.println("\n# quaternions");
|
|
|
-
|
|
|
- { // Quaternion operations
|
|
|
- q := 1 + 2i + 3j + 4k;
|
|
|
- r := quaternion(5, 6, 7, 8);
|
|
|
- t := q * r;
|
|
|
- fmt.printf("(%v) * (%v) = %v\n", q, r, t);
|
|
|
- v := q / r;
|
|
|
- fmt.printf("(%v) / (%v) = %v\n", q, r, v);
|
|
|
- u := q + r;
|
|
|
- fmt.printf("(%v) + (%v) = %v\n", q, r, u);
|
|
|
- s := q - r;
|
|
|
- fmt.printf("(%v) - (%v) = %v\n", q, r, s);
|
|
|
- }
|
|
|
- { // The quaternion types
|
|
|
- q128: quaternion128; // 4xf32
|
|
|
- q256: quaternion256; // 4xf64
|
|
|
- q128 = quaternion(1, 0, 0, 0);
|
|
|
- q256 = 1; // quaternion(1, 0, 0, 0);
|
|
|
- }
|
|
|
- { // Built-in procedures
|
|
|
- q := 1 + 2i + 3j + 4k;
|
|
|
- fmt.println("q =", q);
|
|
|
- fmt.println("real(q) =", real(q));
|
|
|
- fmt.println("imag(q) =", imag(q));
|
|
|
- fmt.println("jmag(q) =", jmag(q));
|
|
|
- fmt.println("kmag(q) =", kmag(q));
|
|
|
- fmt.println("conj(q) =", conj(q));
|
|
|
- fmt.println("abs(q) =", abs(q));
|
|
|
- }
|
|
|
- { // Conversion of a complex type to a quaternion type
|
|
|
- c := 1 + 2i;
|
|
|
- q := quaternion256(c);
|
|
|
- fmt.println(c);
|
|
|
- fmt.println(q);
|
|
|
- }
|
|
|
- { // Memory layout of Quaternions
|
|
|
- q := 1 + 2i + 3j + 4k;
|
|
|
- a := transmute([4]f64)q;
|
|
|
- fmt.println("Quaternion memory layout: xyzw/(ijkr)");
|
|
|
- fmt.println(q); // 1.000+2.000i+3.000j+4.000k
|
|
|
- fmt.println(a); // [2.000, 3.000, 4.000, 1.000]
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-inline_for_statement :: proc() {
|
|
|
- fmt.println("\n#inline for statements");
|
|
|
-
|
|
|
- // 'inline for' works the same as if the 'inline' prefix did not
|
|
|
- // exist but these ranged loops are explicitly unrolled which can
|
|
|
- // be very very useful for certain optimizations
|
|
|
-
|
|
|
- fmt.println("Ranges");
|
|
|
- inline for x, i in 1..<4 {
|
|
|
- fmt.println(x, i);
|
|
|
- }
|
|
|
-
|
|
|
- fmt.println("Strings");
|
|
|
- inline for r, i in "Hello, 世界" {
|
|
|
- fmt.println(r, i);
|
|
|
- }
|
|
|
-
|
|
|
- fmt.println("Arrays");
|
|
|
- inline for elem, idx in ([4]int{1, 4, 9, 16}) {
|
|
|
- fmt.println(elem, idx);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- Foo_Enum :: enum {
|
|
|
- A = 1,
|
|
|
- B,
|
|
|
- C = 6,
|
|
|
- D,
|
|
|
- };
|
|
|
- fmt.println("Enum types");
|
|
|
- inline for elem, idx in Foo_Enum {
|
|
|
- fmt.println(elem, idx);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-where_clauses :: proc() {
|
|
|
- fmt.println("\n#procedure 'where' clauses");
|
|
|
-
|
|
|
- { // Sanity checks
|
|
|
- simple_sanity_check :: proc(x: [2]int)
|
|
|
- where len(x) > 1,
|
|
|
- type_of(x) == [2]int {
|
|
|
- fmt.println(x);
|
|
|
- }
|
|
|
- }
|
|
|
- { // Parametric polymorphism checks
|
|
|
- cross_2d :: proc(a, b: $T/[2]$E) -> E
|
|
|
- where intrinsics.type_is_numeric(E) {
|
|
|
- return a.x*b.y - a.y*b.x;
|
|
|
- }
|
|
|
- cross_3d :: proc(a, b: $T/[3]$E) -> T
|
|
|
- where intrinsics.type_is_numeric(E) {
|
|
|
- x := a.y*b.z - a.z*b.y;
|
|
|
- y := a.z*b.x - a.x*b.z;
|
|
|
- z := a.x*b.y - a.y*b.z;
|
|
|
- return T{x, y, z};
|
|
|
- }
|
|
|
-
|
|
|
- a := [2]int{1, 2};
|
|
|
- b := [2]int{5, -3};
|
|
|
- fmt.println(cross_2d(a, b));
|
|
|
-
|
|
|
- x := [3]f32{1, 4, 9};
|
|
|
- y := [3]f32{-5, 0, 3};
|
|
|
- fmt.println(cross_3d(x, y));
|
|
|
-
|
|
|
- // Failure case
|
|
|
- // i := [2]bool{true, false};
|
|
|
- // j := [2]bool{false, true};
|
|
|
- // fmt.println(cross_2d(i, j));
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- { // Procedure groups usage
|
|
|
- foo :: proc(x: [$N]int) -> bool
|
|
|
- where N > 2 {
|
|
|
- fmt.println(#procedure, "was called with the parameter", x);
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- bar :: proc(x: [$N]int) -> bool
|
|
|
- where 0 < N,
|
|
|
- N <= 2 {
|
|
|
- fmt.println(#procedure, "was called with the parameter", x);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- baz :: proc{foo, bar};
|
|
|
-
|
|
|
- x := [3]int{1, 2, 3};
|
|
|
- y := [2]int{4, 9};
|
|
|
- ok_x := baz(x);
|
|
|
- ok_y := baz(y);
|
|
|
- assert(ok_x == true);
|
|
|
- assert(ok_y == false);
|
|
|
- }
|
|
|
-
|
|
|
- { // Record types
|
|
|
- Foo :: struct(T: typeid, N: int)
|
|
|
- where intrinsics.type_is_integer(T),
|
|
|
- N > 2 {
|
|
|
- x: [N]T,
|
|
|
- y: [N-2]T,
|
|
|
- };
|
|
|
-
|
|
|
- T :: i32;
|
|
|
- N :: 5;
|
|
|
- f: Foo(T, N);
|
|
|
- #assert(size_of(f) == (N+N-2)*size_of(T));
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-when ODIN_OS == "windows" do foreign import kernel32 "system:kernel32.lib"
|
|
|
-
|
|
|
-foreign_system :: proc() {
|
|
|
- fmt.println("\n#foreign system");
|
|
|
- when ODIN_OS == "windows" {
|
|
|
- // It is sometimes necessarily to interface with foreign code,
|
|
|
- // such as a C library. In Odin, this is achieved through the
|
|
|
- // foreign system. You can “import” a library into the code
|
|
|
- // using the same semantics as a normal import declaration.
|
|
|
-
|
|
|
- // This foreign import declaration will create a
|
|
|
- // “foreign import name” which can then be used to associate
|
|
|
- // entities within a foreign block.
|
|
|
-
|
|
|
- foreign kernel32 {
|
|
|
- ExitProcess :: proc "stdcall" (exit_code: u32) ---
|
|
|
- }
|
|
|
-
|
|
|
- // Foreign procedure declarations have the cdecl/c calling
|
|
|
- // convention by default unless specified otherwise. Due to
|
|
|
- // foreign procedures do not have a body declared within this
|
|
|
- // code, you need append the --- symbol to the end to distinguish
|
|
|
- // it as a procedure literal without a body and not a procedure type.
|
|
|
-
|
|
|
- // The attributes system can be used to change specific properties
|
|
|
- // of entities declared within a block:
|
|
|
-
|
|
|
- @(default_calling_convention = "std")
|
|
|
- foreign kernel32 {
|
|
|
- @(link_name="GetLastError") get_last_error :: proc() -> i32 ---
|
|
|
- }
|
|
|
-
|
|
|
- // Example using the link_prefix attribute
|
|
|
- @(default_calling_convention = "std")
|
|
|
- @(link_prefix = "Get")
|
|
|
- foreign kernel32 {
|
|
|
- LastError :: proc() -> i32 ---
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-ranged_fields_for_array_compound_literals :: proc() {
|
|
|
- fmt.println("\n#ranged fields for array compound literals");
|
|
|
- { // Normal Array Literal
|
|
|
- foo := [?]int{1, 4, 9, 16};
|
|
|
- fmt.println(foo);
|
|
|
- }
|
|
|
- { // Indexed
|
|
|
- foo := [?]int{
|
|
|
- 3 = 16,
|
|
|
- 1 = 4,
|
|
|
- 2 = 9,
|
|
|
- 0 = 1,
|
|
|
- };
|
|
|
- fmt.println(foo);
|
|
|
- }
|
|
|
- { // Ranges
|
|
|
- i := 2;
|
|
|
- foo := [?]int {
|
|
|
- 0 = 123,
|
|
|
- 5..9 = 54,
|
|
|
- 10..<16 = i*3 + (i-1)*2,
|
|
|
- };
|
|
|
- #assert(len(foo) == 16);
|
|
|
- fmt.println(foo); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
|
|
|
- }
|
|
|
- { // Slice and Dynamic Array support
|
|
|
- i := 2;
|
|
|
- foo_slice := []int {
|
|
|
- 0 = 123,
|
|
|
- 5..9 = 54,
|
|
|
- 10..<16 = i*3 + (i-1)*2,
|
|
|
- };
|
|
|
- assert(len(foo_slice) == 16);
|
|
|
- fmt.println(foo_slice); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
|
|
|
-
|
|
|
- foo_dynamic_array := [dynamic]int {
|
|
|
- 0 = 123,
|
|
|
- 5..9 = 54,
|
|
|
- 10..<16 = i*3 + (i-1)*2,
|
|
|
- };
|
|
|
- assert(len(foo_dynamic_array) == 16);
|
|
|
- fmt.println(foo_dynamic_array); // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-deprecated_attribute :: proc() {
|
|
|
- @(deprecated="Use foo_v2 instead")
|
|
|
- foo_v1 :: proc(x: int) {
|
|
|
- fmt.println("foo_v1");
|
|
|
- }
|
|
|
- foo_v2 :: proc(x: int) {
|
|
|
- fmt.println("foo_v2");
|
|
|
- }
|
|
|
-
|
|
|
- // NOTE: Uncomment to see the warning messages
|
|
|
- // foo_v1(1);
|
|
|
-}
|
|
|
-
|
|
|
-range_statements_with_multiple_return_values :: proc() {
|
|
|
- // IMPORTANT NOTE(bill, 2019-11-02): This feature is subject to be changed/removed
|
|
|
- fmt.println("\n#range statements with multiple return values");
|
|
|
- My_Iterator :: struct {
|
|
|
- index: int,
|
|
|
- data: []i32,
|
|
|
- };
|
|
|
- make_my_iterator :: proc(data: []i32) -> My_Iterator {
|
|
|
- return My_Iterator{data = data};
|
|
|
- }
|
|
|
- my_iterator :: proc(it: ^My_Iterator) -> (val: i32, idx: int, cond: bool) {
|
|
|
- if cond = it.index < len(it.data); cond {
|
|
|
- val = it.data[it.index];
|
|
|
- idx = it.index;
|
|
|
- it.index += 1;
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- data := make([]i32, 6);
|
|
|
- for _, i in data {
|
|
|
- data[i] = i32(i*i);
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- it := make_my_iterator(data);
|
|
|
- for val in my_iterator(&it) {
|
|
|
- fmt.println(val);
|
|
|
- }
|
|
|
- }
|
|
|
- {
|
|
|
- it := make_my_iterator(data);
|
|
|
- for val, idx in my_iterator(&it) {
|
|
|
- fmt.println(val, idx);
|
|
|
- }
|
|
|
- }
|
|
|
- {
|
|
|
- it := make_my_iterator(data);
|
|
|
- for {
|
|
|
- val, _, cond := my_iterator(&it);
|
|
|
- if !cond do break;
|
|
|
- fmt.println(val);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-soa_struct_layout :: proc() {
|
|
|
- // IMPORTANT NOTE(bill, 2019-11-03): This feature is subject to be changed/removed
|
|
|
- // NOTE(bill): Most likely #soa [N]T
|
|
|
- fmt.println("\n#SOA Struct Layout");
|
|
|
-
|
|
|
- {
|
|
|
- Vector3 :: struct {x, y, z: f32};
|
|
|
-
|
|
|
- N :: 2;
|
|
|
- v_aos: [N]Vector3;
|
|
|
- v_aos[0].x = 1;
|
|
|
- v_aos[0].y = 4;
|
|
|
- v_aos[0].z = 9;
|
|
|
-
|
|
|
- fmt.println(len(v_aos));
|
|
|
- fmt.println(v_aos[0]);
|
|
|
- fmt.println(v_aos[0].x);
|
|
|
- fmt.println(&v_aos[0].x);
|
|
|
-
|
|
|
- v_aos[1] = {0, 3, 4};
|
|
|
- v_aos[1].x = 2;
|
|
|
- fmt.println(v_aos[1]);
|
|
|
- fmt.println(v_aos);
|
|
|
-
|
|
|
- v_soa: #soa[N]Vector3;
|
|
|
-
|
|
|
- v_soa[0].x = 1;
|
|
|
- v_soa[0].y = 4;
|
|
|
- v_soa[0].z = 9;
|
|
|
-
|
|
|
-
|
|
|
- // Same syntax as AOS and treat as if it was an array
|
|
|
- fmt.println(len(v_soa));
|
|
|
- fmt.println(v_soa[0]);
|
|
|
- fmt.println(v_soa[0].x);
|
|
|
- fmt.println(&v_soa[0].x);
|
|
|
- v_soa[1] = {0, 3, 4};
|
|
|
- v_soa[1].x = 2;
|
|
|
- fmt.println(v_soa[1]);
|
|
|
-
|
|
|
- // Can use SOA syntax if necessary
|
|
|
- v_soa.x[0] = 1;
|
|
|
- v_soa.y[0] = 4;
|
|
|
- v_soa.z[0] = 9;
|
|
|
- fmt.println(v_soa.x[0]);
|
|
|
-
|
|
|
- // Same pointer addresses with both syntaxes
|
|
|
- assert(&v_soa[0].x == &v_soa.x[0]);
|
|
|
-
|
|
|
-
|
|
|
- // Same fmt printing
|
|
|
- fmt.println(v_aos);
|
|
|
- fmt.println(v_soa);
|
|
|
- }
|
|
|
- {
|
|
|
- // Works with arrays of length <= 4 which have the implicit fields xyzw/rgba
|
|
|
- Vector3 :: distinct [3]f32;
|
|
|
-
|
|
|
- N :: 2;
|
|
|
- v_aos: [N]Vector3;
|
|
|
- v_aos[0].x = 1;
|
|
|
- v_aos[0].y = 4;
|
|
|
- v_aos[0].z = 9;
|
|
|
-
|
|
|
- v_soa: #soa[N]Vector3;
|
|
|
-
|
|
|
- v_soa[0].x = 1;
|
|
|
- v_soa[0].y = 4;
|
|
|
- v_soa[0].z = 9;
|
|
|
- }
|
|
|
- {
|
|
|
- // SOA Slices
|
|
|
- // Vector3 :: struct {x, y, z: f32};
|
|
|
- Vector3 :: struct {x: i8, y: i16, z: f32};
|
|
|
-
|
|
|
- N :: 3;
|
|
|
- v: #soa[N]Vector3;
|
|
|
- v[0].x = 1;
|
|
|
- v[0].y = 4;
|
|
|
- v[0].z = 9;
|
|
|
-
|
|
|
- s: #soa[]Vector3;
|
|
|
- s = v[:];
|
|
|
- assert(len(s) == N);
|
|
|
- fmt.println(s);
|
|
|
- fmt.println(s[0].x);
|
|
|
-
|
|
|
- a := s[1:2];
|
|
|
- assert(len(a) == 1);
|
|
|
- fmt.println(a);
|
|
|
-
|
|
|
- d: #soa[dynamic]Vector3;
|
|
|
-
|
|
|
- append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3});
|
|
|
- fmt.println(d);
|
|
|
- fmt.println(len(d));
|
|
|
- fmt.println(cap(d));
|
|
|
- fmt.println(d[:]);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-constant_literal_expressions :: proc() {
|
|
|
- fmt.println("\n#constant literal expressions");
|
|
|
-
|
|
|
- Bar :: struct {x, y: f32};
|
|
|
- Foo :: struct {a, b: int, using c: Bar};
|
|
|
-
|
|
|
- FOO_CONST :: Foo{b = 2, a = 1, c = {3, 4}};
|
|
|
-
|
|
|
-
|
|
|
- fmt.println(FOO_CONST.a);
|
|
|
- fmt.println(FOO_CONST.b);
|
|
|
- fmt.println(FOO_CONST.c);
|
|
|
- fmt.println(FOO_CONST.c.x);
|
|
|
- fmt.println(FOO_CONST.c.y);
|
|
|
- fmt.println(FOO_CONST.x); // using works as expected
|
|
|
- fmt.println(FOO_CONST.y);
|
|
|
-
|
|
|
- fmt.println("-------");
|
|
|
-
|
|
|
- ARRAY_CONST :: [3]int{1 = 4, 2 = 9, 0 = 1};
|
|
|
-
|
|
|
- fmt.println(ARRAY_CONST[0]);
|
|
|
- fmt.println(ARRAY_CONST[1]);
|
|
|
- fmt.println(ARRAY_CONST[2]);
|
|
|
-
|
|
|
- fmt.println("-------");
|
|
|
-
|
|
|
- FOO_ARRAY_DEFAULTS :: [3]Foo{{}, {}, {}};
|
|
|
- fmt.println(FOO_ARRAY_DEFAULTS[2].x);
|
|
|
-
|
|
|
- fmt.println("-------");
|
|
|
-
|
|
|
- Baz :: enum{A=5, B, C, D};
|
|
|
- ENUM_ARRAY_CONST :: [Baz]int{.A .. .C = 1, .D = 16};
|
|
|
-
|
|
|
- fmt.println(ENUM_ARRAY_CONST[.A]);
|
|
|
- fmt.println(ENUM_ARRAY_CONST[.B]);
|
|
|
- fmt.println(ENUM_ARRAY_CONST[.C]);
|
|
|
- fmt.println(ENUM_ARRAY_CONST[.D]);
|
|
|
-
|
|
|
- fmt.println("-------");
|
|
|
-
|
|
|
- Partial_Baz :: enum{A=5, B, C, D=16};
|
|
|
- #assert(len(Partial_Baz) < len(#partial [Partial_Baz]int));
|
|
|
- PARTIAL_ENUM_ARRAY_CONST :: #partial [Partial_Baz]int{.A .. .C = 1, .D = 16};
|
|
|
-
|
|
|
- fmt.println(PARTIAL_ENUM_ARRAY_CONST[.A]);
|
|
|
- fmt.println(PARTIAL_ENUM_ARRAY_CONST[.B]);
|
|
|
- fmt.println(PARTIAL_ENUM_ARRAY_CONST[.C]);
|
|
|
- fmt.println(PARTIAL_ENUM_ARRAY_CONST[.D]);
|
|
|
-
|
|
|
- fmt.println("-------");
|
|
|
-
|
|
|
-
|
|
|
- STRING_CONST :: "Hellope!";
|
|
|
-
|
|
|
- fmt.println(STRING_CONST[0]);
|
|
|
- fmt.println(STRING_CONST[2]);
|
|
|
- fmt.println(STRING_CONST[3]);
|
|
|
-
|
|
|
- fmt.println(STRING_CONST[0:5]);
|
|
|
- fmt.println(STRING_CONST[3:][:4]);
|
|
|
-}
|
|
|
-
|
|
|
-union_maybe :: proc() {
|
|
|
- fmt.println("\n#union #maybe");
|
|
|
-
|
|
|
- Maybe :: union(T: typeid) #maybe {T};
|
|
|
-
|
|
|
- i: Maybe(u8);
|
|
|
- p: Maybe(^u8); // No tag is stored for pointers, nil is the sentinel value
|
|
|
-
|
|
|
- #assert(size_of(i) == size_of(u8) + size_of(u8));
|
|
|
- #assert(size_of(p) == size_of(^u8));
|
|
|
-
|
|
|
- i = 123;
|
|
|
- x := i.?;
|
|
|
- y, y_ok := p.?;
|
|
|
- p = &x;
|
|
|
- z, z_ok := p.?;
|
|
|
-
|
|
|
- fmt.println(i, p);
|
|
|
- fmt.println(x, &x);
|
|
|
- fmt.println(y, y_ok);
|
|
|
- fmt.println(z, z_ok);
|
|
|
-}
|
|
|
-
|
|
|
-dummy_procedure :: proc() {
|
|
|
- fmt.println("dummy_procedure");
|
|
|
-}
|
|
|
-
|
|
|
-explicit_context_definition :: proc "c" () {
|
|
|
- // Try commenting the following statement out below
|
|
|
- context = runtime.default_context();
|
|
|
-
|
|
|
- fmt.println("\n#explicit context definition");
|
|
|
- dummy_procedure();
|
|
|
-}
|
|
|
-
|
|
|
-relative_data_types :: proc() {
|
|
|
- fmt.println("\n#relative data types");
|
|
|
-
|
|
|
- x: int = 123;
|
|
|
- ptr: #relative(i16) ^int;
|
|
|
- ptr = &x;
|
|
|
- fmt.println(ptr^);
|
|
|
-
|
|
|
- arr := [3]int{1, 2, 3};
|
|
|
- s := arr[:];
|
|
|
- rel_slice: #relative(i16) []int;
|
|
|
- rel_slice = s;
|
|
|
- fmt.println(rel_slice);
|
|
|
- fmt.println(rel_slice[:]);
|
|
|
- fmt.println(rel_slice[1]);
|
|
|
-}
|
|
|
-
|
|
|
-pure_procedures :: proc() {
|
|
|
- fmt.println("\n#pure procedures");
|
|
|
-
|
|
|
- square :: proc "pure" (x: int) -> int {
|
|
|
- return x*x + 1;
|
|
|
- }
|
|
|
-
|
|
|
- do_math :: proc "pure" (x: int) -> int {
|
|
|
- // Only "pure" procedure calls are allowed within a "pure" procedure
|
|
|
- return square(x) + 1;
|
|
|
- }
|
|
|
-
|
|
|
- x := do_math(5);
|
|
|
- fmt.println(x);
|
|
|
+Employee :: struct {
|
|
|
+ name: string `json:"name"`,
|
|
|
+ age: int `json:"age"`,
|
|
|
+ salary: int `json:"salary"`,
|
|
|
}
|
|
|
|
|
|
main :: proc() {
|
|
|
- when true {
|
|
|
- the_basics();
|
|
|
- control_flow();
|
|
|
- named_proc_return_parameters();
|
|
|
- explicit_procedure_overloading();
|
|
|
- struct_type();
|
|
|
- union_type();
|
|
|
- using_statement();
|
|
|
- implicit_context_system();
|
|
|
- parametric_polymorphism();
|
|
|
- array_programming();
|
|
|
- map_type();
|
|
|
- implicit_selector_expression();
|
|
|
- partial_switch();
|
|
|
- cstring_example();
|
|
|
- bit_set_type();
|
|
|
- deferred_procedure_associations();
|
|
|
- reflection();
|
|
|
- quaternions();
|
|
|
- inline_for_statement();
|
|
|
- where_clauses();
|
|
|
- foreign_system();
|
|
|
- ranged_fields_for_array_compound_literals();
|
|
|
- deprecated_attribute();
|
|
|
- range_statements_with_multiple_return_values();
|
|
|
- threading_example();
|
|
|
- soa_struct_layout();
|
|
|
- constant_literal_expressions();
|
|
|
- union_maybe();
|
|
|
- explicit_context_definition();
|
|
|
- relative_data_types();
|
|
|
- pure_procedures();
|
|
|
- }
|
|
|
+
|
|
|
}
|
gingerBill