From 31472908ecda1d32260e01ca04c39fcd3a490b42 Mon Sep 17 00:00:00 2001
From: Brendan Hansen <brendan.f.hansen@gmail.com>
Date: Fri, 28 Aug 2020 23:53:38 -0500
Subject: [PATCH] weird bugfix with operator precedence

---
 core/builtin.onyx    |  15 +++++++++++++++
 core/string.onyx     |   4 ++--
 onyx                 | Bin 582568 -> 582568 bytes
 progs/poly_test.onyx |  45 ++++++++++++++++++++++++++++++++++++++++---
 src/onyxparser.c     |   4 +++-
 5 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/core/builtin.onyx b/core/builtin.onyx
index 3224e303..022be1df 100644
--- 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 0cd56794..c56d6f6e 100644
--- 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
GIT binary patch
delta 2234
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

delta 2234
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

diff --git a/progs/poly_test.onyx b/progs/poly_test.onyx
index 050a3cde..430f4636 100644
--- 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 85d51b0d..8db27f25 100644
--- 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;
 }
-- 
2.25.1