more general way of setting create_thunk functions in Code struct

interpreter/code.c

@@ -102,25 +102,32 @@ struct Thunk* create_thunk_thunk(Code* expr, int frame_ptr)
     return &((ThunkEntry*) expr)->thunk;
 }
 
-Thunk* (*create_thunk_funs[10]) (Code* expr, int frame_ptr);
-
-void init_code()
-{
-    create_thunk_funs[CT_VAR] = create_thunk_var;
-    create_thunk_funs[CT_VAR_STRICT] = create_thunk_var_strict;
-    create_thunk_funs[CT_APP_THUNK] = create_thunk_app_static;
-    create_thunk_funs[CT_APP_PRIM1] = create_thunk_app_static;
-    create_thunk_funs[CT_APP_PRIM2] = create_thunk_app_static;
-    create_thunk_funs[CT_APP_FUN] = create_thunk_app_static;
-    create_thunk_funs[CT_APP_DYN] = create_thunk_app_dyn;
-    create_thunk_funs[CT_SELECT] = NULL;
-    create_thunk_funs[CT_IF] = NULL;
-    create_thunk_funs[CT_THUNK] = create_thunk_thunk;
-}
-
-create_thunk_fun get_create_thunk_fun(CodeType type)
+void set_create_thunk_fun(Code* code)
 {
-    return  create_thunk_funs[type];
+    switch(code->type)
+    {
+        case CT_APP_PRIM1:
+        case CT_APP_PRIM2:
+        case CT_APP_FUN:
+        case CT_APP_THUNK:
+            code->create_thunk = create_thunk_app_static;
+            break;
+        case CT_APP_DYN:
+            code->create_thunk = create_thunk_app_dyn;
+            break;
+        case CT_VAR:
+            code->create_thunk = create_thunk_var;
+            break;
+        case CT_VAR_STRICT:
+            code->create_thunk = create_thunk_var_strict;
+            break;
+        case CT_THUNK:
+            code->create_thunk = create_thunk_thunk;
+            break;
+        default:
+            code->create_thunk = NULL;
+            break;            
+    }
 }
 
 void exec(Code* expr, int frame_ptr, int root_frame_ptr)

interpreter/code.h

@@ -67,8 +67,7 @@ struct IfEntry {
 
 typedef Thunk* (*create_thunk_fun)(Code*, int);
 
-void init_code();
-create_thunk_fun get_create_thunk_fun(CodeType type);
+void set_create_thunk_fun(Code* code);
 
 void exec(Code* expr, int frame_ptr, int root_frame_ptr);
 struct Thunk* eval(Thunk* thunk);

interpreter/main.c

@@ -28,7 +28,6 @@ int main ( int argc, char *argv[] )
     init_mem();
     init_desc();
     init_prim();
-    init_code();
 
     char* input = "..\\tests\\Braun.bsapl";
     

interpreter/parse.c

@@ -236,7 +236,6 @@ ThunkEntry* parseLit(char **ptr) {
 
     struct ThunkEntry* entry = (ThunkEntry*) alloc_code(sizeof (ThunkEntry) + strlen);
     entry->base.type = CT_THUNK;
-    entry->base.create_thunk = get_create_thunk_fun(CT_THUNK);
     
     switch (type) {
         case 'I': // Int
@@ -275,6 +274,7 @@ ThunkEntry* parseLit(char **ptr) {
         }
     }
 
+    set_create_thunk_fun((Code*) entry);
     return entry;
 }
 
@@ -287,12 +287,10 @@ VarEntry* parseVar(char **ptr, VarEntry* target) {
     switch (type) {
         case 'L': // Local var
             entry->base.type = CT_VAR;
-            entry->base.create_thunk = get_create_thunk_fun(CT_VAR);
             entry->base.strict = false;
             break;
         case 'S': // Strict local var    
             entry->base.type = CT_VAR_STRICT;
-            entry->base.create_thunk = get_create_thunk_fun(CT_VAR_STRICT);
             entry->base.strict = true;
             break;
         default:
@@ -300,6 +298,7 @@ VarEntry* parseVar(char **ptr, VarEntry* target) {
     }
     
     if (!parseInt(ptr, &entry->index)) return 0;
+    set_create_thunk_fun((Code*) entry);
     return entry;    
 }
 
@@ -328,8 +327,9 @@ Code* parseApp(char **ptr, bool dynamic) {
         {
             struct ThunkEntry* entry = (ThunkEntry*) alloc_code(sizeof (ThunkEntry));
             entry->base.type = CT_THUNK;
-            entry->base.create_thunk = get_create_thunk_fun(CT_THUNK);
             entry->thunk.desc = desc;
+
+            set_create_thunk_fun((Code*) entry);
             return (Code*) entry;
         }
         
@@ -338,7 +338,6 @@ Code* parseApp(char **ptr, bool dynamic) {
 
         // TODO: CAS
         entry->base.type = CT_APP_FUN;
-        entry->base.create_thunk = get_create_thunk_fun(CT_APP_FUN);
     }
     else
     {
@@ -353,7 +352,6 @@ Code* parseApp(char **ptr, bool dynamic) {
         {
             parseVar(ptr, &entry->var);        
             entry->base.type = CT_APP_DYN;
-            entry->base.create_thunk = get_create_thunk_fun(CT_APP_DYN);
         }
         else
         {
@@ -366,27 +364,24 @@ Code* parseApp(char **ptr, bool dynamic) {
             if(desc->type == FT_PRIM1)
             {
                 entry->base.type = CT_APP_PRIM1;
-                entry->base.create_thunk = get_create_thunk_fun(CT_APP_PRIM1);
             }
             else if(desc->type == FT_PRIM2)
             {
                 entry->base.type = CT_APP_PRIM2;
-                entry->base.create_thunk = get_create_thunk_fun(CT_APP_PRIM2);
             }            
             else if(desc->type == FT_FUN)
             {
                 entry->base.type = CT_APP_FUN;
-                entry->base.create_thunk = get_create_thunk_fun(CT_APP_FUN);
             }
             else
             {
                 entry->base.type = CT_APP_THUNK;
-                entry->base.create_thunk = get_create_thunk_fun(CT_APP_THUNK);
             }
         }
     }
     
     entry->base.nr_args = nrArgs;        
+    set_create_thunk_fun((Code*) entry);
     return (Code*) entry;
 }
 
@@ -398,7 +393,6 @@ SelectEntry* parseSelect(char **ptr) {
 
     struct SelectEntry* entry = (SelectEntry*) alloc_code(sizeof (SelectEntry) + sizeof (SelectCaseEntry) * nrCases);
     entry->base.type = CT_SELECT;
-    entry->base.create_thunk = get_create_thunk_fun(CT_SELECT);
     entry->base.nr_cases = nrCases;
     entry->expr = expr;
 
@@ -424,17 +418,18 @@ SelectEntry* parseSelect(char **ptr) {
         entry->cases[i].body = (Code*) parseTerm(ptr);
     }
 
+    set_create_thunk_fun((Code*) entry);
     return entry;
 }
 
 IfEntry* parseIf(char **ptr) {
     struct IfEntry* entry = (IfEntry*) alloc_code(sizeof (IfEntry));
     entry->base.type = CT_IF;
-    entry->base.create_thunk = get_create_thunk_fun(CT_IF);
     entry->cond = parseTerm(ptr);
     entry->texpr = parseTerm(ptr);
     entry->fexpr = parseTerm(ptr);
 
+    set_create_thunk_fun((Code*) entry);    
     return entry;
 }