code cleanup and bugfixes

diff --git a/bin/onyx b/bin/onyx
index 28ba7ff10dee859e629db557fbefe9c81b26b5b7..9835d92eb38569282f50fbb7051b19daa8af0476 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/core/io/writer.onyx b/core/io/writer.onyx
index 27023c79ca4e2fdfd93fd89ba742693173248c29..0bb40c2b9742bbb56f6c010cb2d08eaae6223705 100644 (file)
--- a/core/io/writer.onyx
+++ b/core/io/writer.onyx
@@ -12,6 +12,10 @@ writer_make :: (s: ^Stream) -> Writer {
     return Writer.{ s };
 }
 
+write_byte :: (use writer: ^Writer, byte: u8) {
+    stream_write_byte(stream, byte);
+}
+
 write_str :: (use writer: ^Writer, s: str) {
     stream_write(stream, s);
 }
@@ -27,7 +31,7 @@ write_i32 :: (use writer: ^Writer, n: i32, base: u32 = 10) {
     use package core
 
     buf : [256] u8;
-    s := conv.i64_to_str(cast(i64) n, cast(u64) base, buf[0 .. 256]);
+    s := conv.i64_to_str(cast(i64) n, cast(u64) base, ~~buf);
     write_str(writer, s);
 }
 
@@ -35,7 +39,7 @@ write_i64 :: (use writer: ^Writer, n: i64, base: u64 = 10) {
     use package core
 
     buf : [256] u8;
-    s := conv.i64_to_str(n, base, buf[0 .. 256]);
+    s := conv.i64_to_str(n, base, ~~buf);
     write_str(writer, s);
 }
 
@@ -43,7 +47,7 @@ write_f32 :: (use writer: ^Writer, f: f32) {
     use package core
 
     buf : [256] u8;
-    s := conv.f64_to_str(cast(f64) f, buf[0 .. 256]);
+    s := conv.f64_to_str(cast(f64) f, ~~buf);
     write_str(writer, s);
 }
 
@@ -51,7 +55,7 @@ write_f64 :: (use writer: ^Writer, f: f64) {
     use package core
 
     buf : [256] u8;
-    s := conv.f64_to_str(f, buf[0 .. 256]);
+    s := conv.f64_to_str(f, ~~buf);
     write_str(writer, s);
 }
 
@@ -74,7 +78,35 @@ write_range :: (use writer: ^Writer, r: range, sep := " ") {
 write_format :: (use writer: ^Writer, format: str, va: ...) {
     // POTENTIAL BUG: this buffer will need to be bigger (or dynamic).
     buffer: [2048] u8;
-    write_str(writer, conv.str_format_va(format, buffer[0 .. 2048], va));
+    write_str(writer, conv.str_format_va(format, ~~buffer, va));
+}
+
+write_escaped_str :: (use writer: ^Writer, s: str) {
+    write_byte(writer, #char "\"");
+
+    while i := 0; i < s.count {
+        defer i += 1;
+        ch := s[i];
+
+        @Incomplete
+        switch ch {
+            case #char "\n" { write_byte(writer, #char "\\"); write_byte(writer, #char "n");  }
+            case #char "\r" { write_byte(writer, #char "\\"); write_byte(writer, #char "r");  }
+            case #char "\t" { write_byte(writer, #char "\\"); write_byte(writer, #char "t");  }
+            case #char "\v" { write_byte(writer, #char "\\"); write_byte(writer, #char "v");  }
+            case #char "\b" { write_byte(writer, #char "\\"); write_byte(writer, #char "b");  }
+            case #char "\f" { write_byte(writer, #char "\\"); write_byte(writer, #char "f");  }
+            case #char "\0" { write_byte(writer, #char "\\"); write_byte(writer, #char "0");  }
+            case #char "\"" { write_byte(writer, #char "\\"); write_byte(writer, #char "\""); }
+
+            case #default {
+                @Speed
+                write_byte(writer, ch);
+            }
+        } 
+    }
+
+    write_byte(writer, #char "\"");
 }
 
 write :: #match {

diff --git a/core/stdio.onyx b/core/stdio.onyx
index 1724fef705c6387d4fb1dff266e43dc591743b4b..90d4680e78a87c31b0b60183992bbe62d8a076da 100644 (file)
--- a/core/stdio.onyx
+++ b/core/stdio.onyx
@@ -16,12 +16,12 @@ auto_flush_stdio := true
 
 print :: #match {
     (x: str) {
-        io.write(^print_writer, x);
+        io.write(^stdio.print_writer, x);
         if x[x.count - 1] == #char "\n" && auto_flush_stdio do __flush_stdio();
     },
 
-    (x: $T)        { io.write(^print_writer, x); },
-    (x: $T, y: $R) { io.write(^print_writer, x, y); },
+    (x: $T)        { io.write(^stdio.print_writer, x); },
+    (x: $T, y: $R) { io.write(^stdio.print_writer, x, y); },
 }
 
 println :: (x: $T) {
@@ -100,22 +100,24 @@ byte_dump :: (ptr: rawptr, byte_count: u32, bytes_per_line := 8) {
 // Private and internal things
 //
 
-#private_file print_stream : io.DynamicStringStream;
-#private_file print_writer : io.Writer;
+stdio : struct {
+    print_stream : io.DynamicStringStream;
+    print_writer : io.Writer;
+}
 
 __stdio_init :: () {
-    print_stream = io.dynamic_string_stream_make(2048, context.allocator);
-    print_writer = io.writer_make(^print_stream);
+    stdio.print_stream = io.dynamic_string_stream_make(2048, context.allocator);
+    stdio.print_writer = io.writer_make(^stdio.print_stream);
 }
 
 
 __flush_stdio :: () {
-    if print_stream.data.count == 0 do return;
+    if stdio.print_stream.data.count == 0 do return;
 
-    ^print_stream
+    ^stdio.print_stream
         |> io.dynamic_string_stream_to_str()
         |> runtime.__output_string();
 
-    ^print_stream |> io.stream_flush();
+    ^stdio.print_stream |> io.stream_flush();
 }
 

diff --git a/include/bh.h b/include/bh.h
index c82ef733eb3f57658fedb15bc06397b5f0af1f60..068f8e0a355382b536a8f5d90afe20ea9eec90bb 100644 (file)
--- a/include/bh.h
+++ b/include/bh.h
@@ -1018,7 +1018,6 @@ BH_ALLOCATOR_PROC(bh_arena_allocator_proc) {
         }
 
         if (alloc_arena->size + size >= alloc_arena->arena_size) {
-            alloc_arena->size = sizeof(ptr);
             bh__arena_internal* new_arena = (bh__arena_internal *) bh_alloc(alloc_arena->backing, alloc_arena->arena_size);
 
             if (new_arena == NULL) {
@@ -1029,6 +1028,7 @@ BH_ALLOCATOR_PROC(bh_arena_allocator_proc) {
             new_arena->next_arena = NULL;
             ((bh__arena_internal *)(alloc_arena->current_arena))->next_arena = new_arena;
             alloc_arena->current_arena = new_arena;
+            alloc_arena->size = sizeof(ptr);
         }
 
         retval = bh_pointer_add(alloc_arena->current_arena, alloc_arena->size);

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index 490976c92561931bff336035f1849ac9d4f574c3..3cf22675c532f510583adb2a41d42e748527e4a0 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -112,7 +112,6 @@ typedef enum AstKind {
     Ast_Kind_Overloaded_Function,
     Ast_Kind_Polymorphic_Proc,
     Ast_Kind_Block,
-    Ast_Kind_Local_Group,
     Ast_Kind_Local,
     Ast_Kind_Global,
     Ast_Kind_Symbol,

diff --git a/src/onyxastnodes.c b/src/onyxastnodes.c
index 09ed6cc24b33a6cdf32c43153c148176d8a2acce..abb5752a17028e49a0adc2666371112c7c266005 100644 (file)
--- a/src/onyxastnodes.c
+++ b/src/onyxastnodes.c
@@ -15,7 +15,6 @@ static const char* ast_node_names[] = {
     "OVERLOADED_FUNCTION",
     "POLYMORPHIC PROC",
     "BLOCK",
-    "LOCAL GROUP",
     "LOCAL",
     "GLOBAL",
     "SYMBOL",

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 59b43914072d1e91723fdaeee62b9782bc273b57..ee2c539582f29f6c5622ce31876eff06f5de0195 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -637,7 +637,7 @@ static void report_bad_binaryop(AstBinaryOp* binop) {
             node_get_type_name(binop->right));
 }
 
-CheckStatus check_binop_assignment(AstBinaryOp* binop, b32 assignment_is_ok) {
+CheckStatus check_binaryop_assignment(AstBinaryOp* binop, b32 assignment_is_ok) {
     if (!assignment_is_ok) {
         onyx_report_error(binop->token->pos, "Assignment not valid in expression.");
         return Check_Error;
@@ -744,19 +744,6 @@ CheckStatus check_binop_assignment(AstBinaryOp* binop, b32 assignment_is_ok) {
 CheckStatus check_binaryop_compare(AstBinaryOp** pbinop) {
     AstBinaryOp* binop = *pbinop;
 
-    // :UnaryFieldAccessIsGross
-    if (binop->left->kind == Ast_Kind_Unary_Field_Access || binop->right->kind == Ast_Kind_Unary_Field_Access) {
-        if      (type_check_or_auto_cast(&binop->left, binop->right->type));
-        else if (type_check_or_auto_cast(&binop->right, binop->left->type));
-        else {
-            report_bad_binaryop(binop);
-            return Check_Error;
-        }
-
-        binop->type = &basic_types[Basic_Kind_Bool];
-        return Check_Success;
-    }
-
     if (   type_is_structlike_strict(binop->left->type)
         || type_is_structlike_strict(binop->right->type)) {
         report_bad_binaryop(binop);
@@ -852,7 +839,7 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop, b32 assignment_is_ok) {
         binop->flags |= Ast_Flag_Comptime;
     }
 
-    if (binop_is_assignment(binop->operation)) return check_binop_assignment(binop, assignment_is_ok);
+    if (binop_is_assignment(binop->operation)) return check_binaryop_assignment(binop, assignment_is_ok);
 
     if (expression_types_must_be_known) {
         if (binop->left->type == NULL || binop->right->type == NULL) {
@@ -861,6 +848,16 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop, b32 assignment_is_ok) {
         }
     }
 
+    // :UnaryFieldAccessIsGross
+    if (binop->left->kind == Ast_Kind_Unary_Field_Access || binop->right->kind == Ast_Kind_Unary_Field_Access) {
+        if      (type_check_or_auto_cast(&binop->left, binop->right->type));
+        else if (type_check_or_auto_cast(&binop->right, binop->left->type));
+        else {
+            report_bad_binaryop(binop);
+            return Check_Error;
+        }
+    }
+
     // NOTE: Try operator overloading before checking everything else.
     if ((binop->left->type != NULL && binop->right->type != NULL) &&
         (binop->left->type->kind != Type_Kind_Basic || binop->right->type->kind != Type_Kind_Basic)) {
@@ -881,16 +878,6 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop, b32 assignment_is_ok) {
     if (binop->operation == Binary_Op_Bool_And || binop->operation == Binary_Op_Bool_Or)
         return check_binaryop_bool(pbinop);
 
-    // :UnaryFieldAccessIsGross
-    if (binop->left->kind == Ast_Kind_Unary_Field_Access || binop->right->kind == Ast_Kind_Unary_Field_Access) {
-        if      (type_check_or_auto_cast(&binop->left, binop->right->type));
-        else if (type_check_or_auto_cast(&binop->right, binop->left->type));
-        else {
-            report_bad_binaryop(binop);
-            return Check_Error;
-        }
-    }
-
     // NOTE: The left side cannot be compound.
     //       The right side always is numeric.
     //       The left side cannot be rawptr.

diff --git a/src/onyxclone.c b/src/onyxclone.c
index ca0e813396e1b0f6446ec3e3b03fb78ba7afa00e..7a6f810aae8ef5fc17885bc886cf4e09e12397a3 100644 (file)
--- a/src/onyxclone.c
+++ b/src/onyxclone.c
@@ -34,7 +34,6 @@ static inline i32 ast_kind_to_size(AstNode* node) {
         case Ast_Kind_Overloaded_Function: return sizeof(AstOverloadedFunction);
         case Ast_Kind_Polymorphic_Proc: return sizeof(AstPolyProc);
         case Ast_Kind_Block: return sizeof(AstBlock);
-        case Ast_Kind_Local_Group: return sizeof(AstNode);
         case Ast_Kind_Local: return sizeof(AstLocal);
         case Ast_Kind_Global: return sizeof(AstGlobal);
         case Ast_Kind_Symbol: return sizeof(AstNode);
@@ -71,6 +70,7 @@ static inline i32 ast_kind_to_size(AstNode* node) {
         case Ast_Kind_Subscript: return sizeof(AstSubscript);
         case Ast_Kind_Slice: return sizeof(AstSubscript);
         case Ast_Kind_Field_Access: return sizeof(AstFieldAccess);
+        case Ast_Kind_Unary_Field_Access: return sizeof(AstUnaryFieldAccess);
         case Ast_Kind_Pipe: return sizeof(AstBinaryOp);
         case Ast_Kind_Range_Literal: return sizeof(AstRangeLiteral);
         case Ast_Kind_Method_Call: return sizeof(AstBinaryOp);
@@ -91,6 +91,7 @@ static inline i32 ast_kind_to_size(AstNode* node) {
         case Ast_Kind_Compound: return sizeof(AstCompound);
         case Ast_Kind_Named_Value: return sizeof(AstNamedValue);
         case Ast_Kind_Call_Site: return sizeof(AstCallSite);
+        case Ast_Kind_Static_If: return sizeof(AstIfWhile);
         case Ast_Kind_Count: return 0;
        }