procedures are compile time known

diff --git a/bin/onyx b/bin/onyx
index e220a548606f6e3314dcdef4f0f708e305ec3591..9117f73bf5b83c3ee10bc304e1952eae8e6ff18b 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/examples/04_fixed_arrays.onyx b/examples/04_fixed_arrays.onyx
index bb0d73a98cdf4cf36edbcdc59ee5a04a853f51c6..63b0b62f277cfd4014d0640ca63c047be0696c7b 100644 (file)
--- a/examples/04_fixed_arrays.onyx
+++ b/examples/04_fixed_arrays.onyx
@@ -46,7 +46,7 @@ main :: proc (args: [] cstr) {
         for i: 0 .. 10 {
             array_param[i] = 1000 + i;
         }
-    };
+    }
 
     array_proc(arr);
     for element: arr {

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index ea239113367c164099463c06f65bc9dda7b8ceeb..578518d93af033b18100ef9aabdbd50866f7bcd4 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -797,13 +797,14 @@ typedef enum EntityType {
     Entity_Type_File_Contents,
     Entity_Type_Enum,
     Entity_Type_Type_Alias,
-    Entity_Type_Memory_Reservation,
+    Entity_Type_Memory_Reservation_Type,
     Entity_Type_Use,
     Entity_Type_Polymorphic_Proc,
     Entity_Type_Foreign_Function_Header,
     Entity_Type_Foreign_Global_Header,
     Entity_Type_Function_Header,
     Entity_Type_Global_Header,
+    Entity_Type_Memory_Reservation,
     Entity_Type_Expression,
     Entity_Type_Global,
     Entity_Type_Overloaded_Function,

diff --git a/src/onyx.c b/src/onyx.c
index 4df26fb82bc562da7241221c836ffcf6db96e26f..b1e6c3627cd4c1711e0bb5df1cd7b90554a56b4a 100644 (file)
--- a/src/onyx.c
+++ b/src/onyx.c
@@ -359,6 +359,10 @@ static void merge_parse_results(CompilerState* compiler_state, ParseResults* res
             }
 
             case Ast_Kind_Memres: {
+                ent.type = Entity_Type_Memory_Reservation_Type;
+                ent.mem_res = (AstMemRes *) node;
+                entity_heap_insert(&compiler_state->prog_info.entities, ent);
+
                 ent.type = Entity_Type_Memory_Reservation;
                 ent.mem_res = (AstMemRes *) node;
                 entity_heap_insert(&compiler_state->prog_info.entities, ent);

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 6ceda8e1c231652089241dbd326c5708d27359db..4a1af12a665c423035db9bea5979e498468d4c47 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -31,6 +31,7 @@ CHECK(function, AstFunction* func);
 CHECK(overloaded_function, AstOverloadedFunction* func);
 CHECK(struct, AstStructType* s_node);
 CHECK(function_header, AstFunction* func);
+CHECK(memres_type, AstMemRes* memres);
 CHECK(memres, AstMemRes* memres);
 
 static inline void fill_in_array_count(AstType* type_node) {
@@ -1474,9 +1475,12 @@ b32 check_function_header(AstFunction* func) {
     return 0;
 }
 
-b32 check_memres(AstMemRes* memres) {
+b32 check_memres_type(AstMemRes* memres) {
     fill_in_type((AstTyped *) memres);
+    return 0;
+}
 
+b32 check_memres(AstMemRes* memres) {
     if (memres->initial_value != NULL) {
         fill_in_type(memres->initial_value);
         check_expression(&memres->initial_value);
@@ -1552,6 +1556,10 @@ void check_entity(Entity* ent) {
                 if (check_struct((AstStructType *) ent->type_alias)) return;
             break;
 
+        case Entity_Type_Memory_Reservation_Type:
+            if (check_memres_type(ent->mem_res)) return;
+            break;
+
         case Entity_Type_Memory_Reservation:
             if (check_memres(ent->mem_res)) return;
             break;

diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index 8e15a731c01fed73248c2d3aadc864524f99488c..97749ccff4a92f9ff5355d7154643d111604ac21 100644 (file)
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -31,6 +31,7 @@ static void symres_global(AstGlobal* global);
 static void symres_overloaded_function(AstOverloadedFunction* ofunc);
 static void symres_use_package(AstUsePackage* package);
 static void symres_enum(AstEnumType* enum_node);
+static void symres_memres_type(AstMemRes** memres);
 static void symres_memres(AstMemRes** memres);
 
 static AstFieldAccess* make_field_access(AstTyped* node, char* field) {
@@ -679,6 +680,8 @@ void symres_function_header(AstFunction* func) {
     if (func->scope == NULL)
         func->scope = scope_create(semstate.node_allocator, semstate.curr_scope, func->token->pos);
 
+    func->flags |= Ast_Flag_Comptime;
+
     bh_arr_each(AstParam, param, func->params) {
         if (param->default_value != NULL) {
             symres_expression(&param->default_value);
@@ -884,14 +887,13 @@ static void symres_enum(AstEnumType* enum_node) {
     }
 }
 
-static void symres_memres(AstMemRes** memres) {
+static void symres_memres_type(AstMemRes** memres) {
     (*memres)->type_node = symres_type((*memres)->type_node);
+}
 
+static void symres_memres(AstMemRes** memres) {
     if ((*memres)->initial_value != NULL) {
         symres_expression(&(*memres)->initial_value);
-
-        // if ((*memres)->type_node == NULL)
-        //     (*memres)->type_node = (*memres)->initial_value->type_node;
     }
 }
 
@@ -923,13 +925,14 @@ void symres_entity(Entity* ent) {
                                               next_state = Entity_State_Finalized;
                                               break;
 
-        case Entity_Type_Overloaded_Function: symres_overloaded_function(ent->overloaded_function); break;
-        case Entity_Type_Expression:          symres_expression(&ent->expr); break;
-        case Entity_Type_Type_Alias:          ent->type_alias = symres_type(ent->type_alias); break;
-        case Entity_Type_Enum:                symres_enum(ent->enum_type); break;
-        case Entity_Type_Memory_Reservation:  symres_memres(&ent->mem_res); break;
-        case Entity_Type_Polymorphic_Proc:    symres_polyproc(ent->poly_proc); break;
-        case Entity_Type_String_Literal:      symres_expression(&ent->expr); break;
+        case Entity_Type_Overloaded_Function:     symres_overloaded_function(ent->overloaded_function); break;
+        case Entity_Type_Expression:              symres_expression(&ent->expr); break;
+        case Entity_Type_Type_Alias:              ent->type_alias = symres_type(ent->type_alias); break;
+        case Entity_Type_Enum:                    symres_enum(ent->enum_type); break;
+        case Entity_Type_Memory_Reservation_Type: symres_memres_type(&ent->mem_res); break;
+        case Entity_Type_Memory_Reservation:      symres_memres(&ent->mem_res); break;
+        case Entity_Type_Polymorphic_Proc:        symres_polyproc(ent->poly_proc); break;
+        case Entity_Type_String_Literal:          symres_expression(&ent->expr); break;
 
         default: break;
     }

diff --git a/src/onyxutils.c b/src/onyxutils.c
index c88e6378b7ee5eb4d60a50b931439330f5a1419a..2042a8b1728148b661cf050a6776cb9181a53602 100644 (file)
--- a/src/onyxutils.c
+++ b/src/onyxutils.c
@@ -115,13 +115,14 @@ const char* entity_type_strings[Entity_Type_Count] = {
     "File Contents",
     "Enum",
     "Type Alias",
-    "Memory Reservation",
+    "Memory Reservation Type",
     "Use",
     "Polymorphic Proc",
     "Foreign_Function Header",
     "Foreign_Global Header",
     "Function Header",
     "Global Header",
+    "Memory Reservation",
     "Expression",
     "Global",
     "Overloaded_Function",

diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index 9374d37289adaa1293e0c44fa6cb245e540c2aac..99d8dac926711906982ca7ca51e55f1153b10ebb 100644 (file)
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -3041,6 +3041,12 @@ static void emit_raw_data(OnyxWasmModule* mod, ptr data, AstTyped* node) {
         break;
     }
 
+    case Ast_Kind_Function: {
+        AstFunction* func = (AstFunction *) node;
+        *((u32 *) data) = get_element_idx(mod, func);
+        break;
+    }
+
     case Ast_Kind_NumLit: {
         // NOTE: This makes a big assumption that we are running on a
         // little endian machine, since WebAssembly is little endian