refactored entities to be allocated to an arena

diff --git a/bin/onyx b/bin/onyx
index 41524eaf3be39766b3a2c5fa7fd9cea1469e5cc1..103abee57dbd8dbaa2ab45f7c90670a8b7537426 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index bda0f218a1bd10c902e6b1db1dbdaed90e2ea7ca..f8217c5b1b7d0edaaac582964d00325118256c27 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -28,6 +28,7 @@ typedef struct AstRangeLiteral AstRangeLiteral;
 typedef struct AstCompound AstCompound;
 
 typedef struct AstDirectiveSolidify AstDirectiveSolidify;
+typedef struct AstStaticIf AstStaticIf;
 
 typedef struct AstReturn AstReturn;
 typedef struct AstJump AstJump;
@@ -165,6 +166,7 @@ typedef enum AstKind {
     Ast_Kind_Switch_Case,
 
     Ast_Kind_Directive_Solidify,
+    Ast_Kind_Static_If,
 
     Ast_Kind_Count
 } AstKind;
@@ -853,6 +855,19 @@ struct AstPolyProc {
     bh_table(AstSolidifiedFunction) concrete_funcs;
 };
 
+
+struct AstStaticIf {
+    AstNode_base;
+
+    AstTyped* cond;
+
+    bh_arr(struct Entity *) true_entities;
+    bh_arr(struct Entity *) false_entities;
+};
+
+
+
+
 extern AstNode empty_node;
 
 typedef enum EntityState {
@@ -861,6 +876,8 @@ typedef enum EntityState {
     Entity_State_Parse_Builtin,
     Entity_State_Introduce_Symbols,
     Entity_State_Parse,
+    Entity_State_Comptime_Resolve_Symbols,
+    Entity_State_Comptime_Check_Types,
     Entity_State_Resolve_Symbols,
     Entity_State_Check_Types,
     Entity_State_Code_Gen,
@@ -928,14 +945,17 @@ typedef struct Entity {
 } Entity;
 
 typedef struct EntityHeap {
-    bh_arr(Entity) entities;
+    bh_arena entity_arena;
+    bh_arr(Entity *) entities;
 
     i32 state_count[Entity_State_Count];
 } EntityHeap;
 
+void entity_heap_init(EntityHeap* entities);
+void entity_heap_insert_existing(EntityHeap* entities, Entity* e);
 void entity_heap_insert(EntityHeap* entities, Entity e);
-Entity entity_heap_top(EntityHeap* entities);
-void entity_heap_change_top(EntityHeap* entities, Entity new_top);
+Entity* entity_heap_top(EntityHeap* entities);
+void entity_heap_change_top(EntityHeap* entities, Entity* new_top);
 void entity_heap_remove_top(EntityHeap* entities);
 void add_entities_for_node(AstNode* node, Scope* scope, Package* package);
 

diff --git a/onyx.exe b/onyx.exe
index f11e97262c190e805f492c4f6f7457634903ba72..acff63a61a6562e68cafef39c7799378f72172ef 100644 (file)
Binary files a/onyx.exe and b/onyx.exe differ

diff --git a/src/onyx.c b/src/onyx.c
index f3f4f0e9ea5f2894b7959c4a2d5103b1843d9b2b..55bbecabf61c13d05dc3148989e8f1c242055faa 100644 (file)
--- a/src/onyx.c
+++ b/src/onyx.c
@@ -152,6 +152,8 @@ static void context_init(CompileOptions* opts) {
     context.wasm_module = bh_alloc_item(global_heap_allocator, OnyxWasmModule);
     *context.wasm_module = onyx_wasm_module_create(global_heap_allocator);
 
+    entity_heap_init(&context.entities);
+
     // NOTE: Add builtin entities to pipeline.
     entity_heap_insert(&context.entities, ((Entity) {
         .state = Entity_State_Parse_Builtin,
@@ -327,7 +329,7 @@ static void output_dummy_progress_bar() {
 
     printf("\e[2;1H");
     for (i32 i = 0; i < Entity_State_Count - 1; i++) {
-        printf("%20s (%4d) | ", entity_state_strings[i], eh->state_count[i]);
+        printf("%25s (%4d) | ", entity_state_strings[i], eh->state_count[i]);
         
         printf("\e[0K");
         for (i32 c = 0; c < eh->state_count[i] * 50 / bh_arr_length(eh->entities); c++) printf("\xe2\x96\x88");
@@ -343,16 +345,16 @@ static i32 onyx_compile() {
         printf("\e[2J");
 
     while (!bh_arr_is_empty(context.entities.entities)) {
-        Entity ent = entity_heap_top(&context.entities);
+        Entity* ent = entity_heap_top(&context.entities);
         entity_heap_remove_top(&context.entities);
 
 #if defined(_BH_LINUX)
         if (context.options->fun_output) {
             output_dummy_progress_bar();
             
-            if (ent.expr->token) {
-                OnyxFilePos pos = ent.expr->token->pos;
-                printf("\e[0K%s on %s in %s:%d:%d\n", entity_state_strings[ent.state], entity_type_strings[ent.type], pos.filename, pos.line, pos.column);
+            if (ent->expr->token) {
+                OnyxFilePos pos = ent->expr->token->pos;
+                printf("\e[0K%s on %s in %s:%d:%d\n", entity_state_strings[ent->state], entity_type_strings[ent->type], pos.filename, pos.line, pos.column);
             }
             
             // Slowing things down for the effect
@@ -360,12 +362,12 @@ static i32 onyx_compile() {
         }
 #endif
         
-        b32 changed = process_entity(&ent);
+        b32 changed = process_entity(ent);
 
         if (onyx_has_errors()) return ONYX_COMPILER_PROGRESS_ERROR;
 
-        if (changed && ent.state != Entity_State_Finalized)
-            entity_heap_insert(&context.entities, ent);
+        if (changed && ent->state != Entity_State_Finalized)
+            entity_heap_insert_existing(&context.entities, ent);
     }
 
     // NOTE: Output to file

diff --git a/src/onyxastnodes.c b/src/onyxastnodes.c
index 5969e12dc9e3586e6ce1e7b53018593b8709528d..89f7cba4a6790f14bf8da16cd3f6c2b50c5ce40e 100644 (file)
--- a/src/onyxastnodes.c
+++ b/src/onyxastnodes.c
@@ -81,6 +81,9 @@ static const char* ast_node_names[] = {
     "SWITCH",
     "SWITCH CASE",
 
+    "SOLIDIFY",
+    "STATIC IF",
+
     "AST_NODE_KIND_COUNT",
 };
 
@@ -107,6 +110,8 @@ const char* entity_state_strings[Entity_State_Count] = {
     "Parse Builtin",
     "Introduce Symbols",
     "Parse",
+    "Resolve Static Symbols",
+    "Check Static Types",
     "Resolve Symbols",
     "Check Types",
     "Code Gen",

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 25bd07cf4a131f1776f88026245dc3bbc7c4c8ca..51de8a54f8b82d90d5e5ece4bdbc813d23b47f41 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -1281,7 +1281,7 @@ CheckStatus check_field_access(AstFieldAccess** pfield) {
     AstFieldAccess* field = *pfield;
     CHECK(expression, &field->expr);
     if (field->expr->type == NULL) {
-        onyx_report_error(field->token->pos, "Unable able to deduce type of expression for accessing field.");
+        onyx_report_error(field->token->pos, "Unable to deduce type of expression for accessing field.");
         return Check_Error;
     }
 

diff --git a/src/onyxentities.c b/src/onyxentities.c
index ceb2b6cf334f5b15bf32c27a64a0cfdf753e0fc4..2164fbfdb4e45aa459baf21a6b4d05e29f816e6a 100644 (file)
--- a/src/onyxentities.c
+++ b/src/onyxentities.c
@@ -15,8 +15,8 @@ static i32 entity_compare(Entity* e1, Entity* e2) {
 #define eh_rchild(index) (((index) * 2) + 2)
 
 static void eh_shift_up(EntityHeap* entities, i32 index) {
-       while (index > 0 && entity_compare(&entities->entities[eh_parent(index)], &entities->entities[index]) > 0) {
-               Entity tmp = entities->entities[eh_parent(index)];
+       while (index > 0 && entity_compare(entities->entities[eh_parent(index)], entities->entities[index]) > 0) {
+               Entity* tmp = entities->entities[eh_parent(index)];
                entities->entities[eh_parent(index)] = entities->entities[index];                       
                entities->entities[index] = tmp;
 
@@ -29,18 +29,18 @@ static void eh_shift_down(EntityHeap* entities, i32 index) {
 
        i32 l = eh_lchild(index);       
        if (l < bh_arr_length(entities->entities)
-               && entity_compare(&entities->entities[l], &entities->entities[min_index]) < 0) {
+               && entity_compare(entities->entities[l], entities->entities[min_index]) < 0) {
                min_index = l;
        }
 
        i32 r = eh_rchild(index);       
        if (r < bh_arr_length(entities->entities)
-               && entity_compare(&entities->entities[r], &entities->entities[min_index]) < 0) {
+               && entity_compare(entities->entities[r], entities->entities[min_index]) < 0) {
                min_index = r;
        }
 
        if (index != min_index) {
-               Entity tmp = entities->entities[min_index];
+               Entity* tmp = entities->entities[min_index];
                entities->entities[min_index] = entities->entities[index];
                entities->entities[index] = tmp;
 
@@ -48,7 +48,21 @@ static void eh_shift_down(EntityHeap* entities, i32 index) {
        }
 }
 
-void entity_heap_insert(EntityHeap* entities, Entity e) {
+void entity_heap_init(EntityHeap* entities) {
+    bh_arena_init(&entities->entity_arena, global_heap_allocator, 32 * 1024);
+}
+
+// nocheckin
+// Allocates the entity in the entity heap. Don't quite feel this is necessary...
+Entity* entity_heap_register(EntityHeap* entities, Entity e) {
+    bh_allocator alloc = bh_arena_allocator(&entities->entity_arena);
+    Entity* entity = bh_alloc_item(alloc, Entity);
+    *entity = e;
+
+    return entity;
+}
+
+void entity_heap_insert_existing(EntityHeap* entities, Entity* e) {
        if (entities->entities == NULL) {
                bh_arr_new(global_heap_allocator, entities->entities, 128);
        }       
@@ -56,23 +70,30 @@ void entity_heap_insert(EntityHeap* entities, Entity e) {
        bh_arr_push(entities->entities, e);
        eh_shift_up(entities, bh_arr_length(entities->entities) - 1);
 
-       entities->state_count[e.state]++;
+       entities->state_count[e->state]++;
+}
+
+// nocheckin
+// Temporary wrapper
+void entity_heap_insert(EntityHeap* entities, Entity e) {
+    Entity* entity = entity_heap_register(entities, e);
+    entity_heap_insert_existing(entities, entity);
 }
 
-Entity entity_heap_top(EntityHeap* entities) {
+Entity* entity_heap_top(EntityHeap* entities) {
        return entities->entities[0];
 }
 
-void entity_heap_change_top(EntityHeap* entities, Entity new_top) {
-       entities->state_count[entities->entities[0].state]--;
-       entities->state_count[new_top.state]--;
+void entity_heap_change_top(EntityHeap* entities, Entity* new_top) {
+       entities->state_count[entities->entities[0]->state]--;
+       entities->state_count[new_top->state]--;
        
        entities->entities[0] = new_top;
        eh_shift_down(entities, 0);
 }
 
 void entity_heap_remove_top(EntityHeap* entities) {
-    entities->state_count[entities->entities[0].state]--;
+    entities->state_count[entities->entities[0]->state]--;
 
        entities->entities[0] = entities->entities[bh_arr_length(entities->entities) - 1];
        bh_arr_pop(entities->entities);