weird bugfix with operator precedence

diff --git a/core/builtin.onyx b/core/builtin.onyx
index 3224e3036695a70a962c76912bcab4fb8b2bc308..022be1df5948818a89ccba895633bbe8b23f8d46 100644 (file)
--- a/core/builtin.onyx
+++ b/core/builtin.onyx
@@ -103,6 +103,21 @@ array_contains :: proc (arr: ^[..] $T, x: T) -> bool {
     return false;
 }
 
+array_pop :: proc (arr: ^[..] $T) -> T {
+    arr.count -= 1;
+    return arr.data[arr.count];
+}
+
+array_average :: proc (arr: ^[..] $T) -> T {
+    sum := cast(T) 0;
+    for i: 0, arr.count {
+        sum += arr.data[i];
+    }
+
+    return sum / cast(T) arr.count;
+}
+
+
 context : struct {
        allocator      : Allocator;
        temp_allocator : Allocator;

diff --git a/core/string.onyx b/core/string.onyx
index 0cd56794215b101963f7d4a7a38a3a73ecc62e5f..c56d6f6e3d4e4b033739a2d20a37bb9d75676abf 100644 (file)
--- a/core/string.onyx
+++ b/core/string.onyx
@@ -197,7 +197,7 @@ i64_to_string :: proc (n_: i64, base: u64, buf: Buffer) -> string {
     return string.{ data = c + 1, count = len };
 }
 
-string_builder_add_u64 :: proc (use sb: ^StringBuilder, n: u64, base := 10l) -> ^StringBuilder {
+string_builder_add_i64 :: proc (use sb: ^StringBuilder, n: i64, base := 10l) -> ^StringBuilder {
     buf : [256] u8;
     s := i64_to_string(n, base, Buffer.{ cast(rawptr) buf, 256 });
     return string_builder_add_string(sb, s);
@@ -216,7 +216,7 @@ string_builder_add_bool :: proc (use sb: ^StringBuilder, b: bool) -> ^StringBuil
 string_builder_append :: proc #overloaded {
     string_builder_add_string,
     string_builder_add_cstring,
-    string_builder_add_u64,
+    string_builder_add_i64,
     string_builder_add_bool,
 }
 

diff --git a/onyx b/onyx
index 40d74102c540f67517a5b4d90784215375394f1d..c9f25d80b16920f3d678788c514c1988f927cad7 100755 (executable)
Binary files a/onyx and b/onyx differ

diff --git a/progs/poly_test.onyx b/progs/poly_test.onyx
index 050a3cde7ea55a9102fbcb33895d5e71e492696d..430f4636ee824587d444bed8e8652f54f2b99494 100644 (file)
--- a/progs/poly_test.onyx
+++ b/progs/poly_test.onyx
@@ -42,7 +42,23 @@ print_arr :: proc (arr: ^[..] $T) {
     print("\n");
 }
 
+print_vec_arr :: proc (arr: ^[..] Vec3) {
+    for i: 0, arr.count {
+        print("Vec3(");
+        print(arr.data[i].x);
+        print(", ");
+        print(arr.data[i].y);
+        print(", ");
+        print(arr.data[i].z);
+        print(")\n");
+    }
+
+    print("\n");
+}
+
 main :: proc (args: [] cstring) {
+    print(cast(u32) __heap_start, 16);
+
     iarr : [..] i32;
     array_init(^iarr, 24);
     defer array_free(^iarr);
@@ -71,6 +87,8 @@ main :: proc (args: [] cstring) {
 
     print_arr_details(^iarr);
     print_arr(^iarr);
+    print(array_average(^iarr));
+    print("\n");
 
 
 
@@ -78,14 +96,35 @@ main :: proc (args: [] cstring) {
     array_init(^barr, 10);
     defer array_free(^barr);
 
-    for i: 0, 1000 {
+    for i: 0, 500 {
         array_add(^barr, cast(u64) (3 * i * i + 4 * i - 2));
     }
 
     print_arr_details(^barr);
     print_arr(^barr);
+    print(array_average(^barr));
+    print("\n");
 
-    print("Does the array contain 2638? ");
-    print(array_contains(^barr, 2638l));
+    print("Does the array contain 2637? ");
+    print(array_contains(^barr, 2637l));
     print("\n");
+
+
+
+    varr : [..] Vec3;
+    array_init(^varr);
+    defer array_free(^varr);
+
+    for i: 0, 20 {
+        array_add(^varr, Vec3.{ i, i * i, i * i * i });
+    }
+
+    print_arr_details(^varr);
+    print_vec_arr(^varr);
+}
+
+Vec3 :: struct {
+    x: i32;
+    y: i32;
+    z: i32;
 }
\ No newline at end of file

diff --git a/src/onyxparser.c b/src/onyxparser.c
index 85d51b0dec50e296495c7d7faf84b901804c7411..8db27f256f890b99cd67c7dbb5940f6fe18dc072 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -630,7 +630,7 @@ static inline i32 get_precedence(BinaryOp kind) {
 // With expected precedence rules
 static AstTyped* parse_expression(OnyxParser* parser) {
     bh_arr(AstBinaryOp*) tree_stack = NULL;
-    bh_arr_new(global_scratch_allocator, tree_stack, 4);
+    bh_arr_new(global_heap_allocator, tree_stack, 4);
     bh_arr_set_length(tree_stack, 0);
 
     AstTyped* left = parse_factor(parser);
@@ -720,6 +720,8 @@ static AstTyped* parse_expression(OnyxParser* parser) {
         }
     }
 
+    bh_arr_free(tree_stack);
+
 expression_done:
     return root;
 }