feat: implement objects and classes

src/compiler/fzl_walker.c

@@ -5,6 +5,7 @@
 #include <compiler/fzl_token.h>
 #include <compiler/fzl_walker.h>
 #include <compiler/utils/fzl_const_pool.h>
+#include <compiler/utils/fzl_ctable.h>
 #include <compiler/utils/fzl_symtable.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -52,7 +53,9 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
     return NULL;
   }
 
-  walker->ctx = NULL;
+  walker->ctx           = NULL;
+  walker->classes_count = 0;
+  memset(walker->classes, 0, sizeof(walker->classes));
 
   return walker;
 }
@@ -103,6 +106,36 @@ static bool is_compatible(fzl_type_t t1, fzl_type_t t2)
   return t1 >= FZL_TYPE_INT8 && t2 >= FZL_TYPE_INT8;
 }
 
+// Add one layer of ctx
+fzl_walk_ctx_t *nest_ctx(fzl_walker_t *walker, fzl_walk_ctx_type_t type)
+{
+  if (!walker)
+    return NULL;
+
+  fzl_walk_ctx_t *newctx = malloc(sizeof(fzl_walk_ctx_t));
+  if (!newctx)
+    return NULL;
+
+  newctx->type   = type;
+  newctx->parent = walker->ctx;
+  walker->ctx    = newctx;
+
+  return walker->ctx;
+}
+
+// Go outside current ctx and then clean it
+fzl_walk_ctx_t *fin_ctx(fzl_walker_t *walker)
+{
+  if (!walker)
+    return NULL;
+
+  fzl_walk_ctx_t *curr = walker->ctx;
+  walker->ctx          = walker->ctx->parent;
+
+  free(curr);
+  return walker->ctx;
+}
+
 // Add const to consts table
 size_t add_const(fzl_walker_t *walker, fzl_const_t c)
 {
@@ -154,6 +187,178 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
   {
     switch (node->type)
     {
+      case FZL_NODETYPE_CLASS:
+      {
+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_CLASS);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        newctx->fn              = node;
+        newctx->initial_env_lvl = walker->sym_top;
+
+        walker->classes[walker->classes_count] =
+            fzl_mkctable(node->class.name->value);
+        fzl_ctable_t *class = walker->classes[walker->classes_count++];
+        class->name         = node->class.name->value;
+
+        for (size_t i = 0; i < node->class.fields_count; i++)
+        {
+          if (class->fields_remainder <= class->fields_count)
+          {
+            class->fields_remainder *= 2;
+            class->fields =
+                realloc(class->fields,
+                        class->fields_remainder * sizeof(fzl_ctable_field_t));
+          }
+
+          class->fields[class->fields_count] = (fzl_ctable_field_t){
+              .name       = node->class.fields[i]->var.identifier->token->value,
+              .type       = tok_to_type(node->class.fields[i]->var.type),
+              .slot_index = class->fields_count++};
+        }
+
+        for (size_t i = 0; i < node->class.methods_count; i++)
+        {
+          fzl_node_t *fn = node->class.methods[i];
+
+          size_t classname_len = strlen(class->name);
+          size_t fnname_len    = strlen(fn->fn.name->value);
+          char *method_name    = malloc(classname_len + fnname_len + 2);
+
+          strcpy(method_name, class->name);
+          method_name[classname_len] = '_';
+          strcpy((method_name + classname_len + 1), fn->fn.name->value);
+          method_name[classname_len + fnname_len + 1] = 0;
+
+          fn->fn.name->value   = method_name;
+          fzl_walk_res_t fnres = walk(walker, fn);
+          if (fnres.error)
+            return fnres;
+        }
+
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
+        break;
+      }
+
+      case FZL_NODETYPE_CONSTRUCT:
+      {
+        fzl_node_t *classname = node->construct.name;
+        fzl_ctable_t *ct      = NULL;
+        for (size_t i = 0; i < walker->classes_count; i++)
+        {
+          if (strcmp((char *)classname->token->value,
+                     walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+        if (!ct)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': class '%s' not found (at %ld:%ld)",
+                   classname->token->filename, (char *)classname->token->value,
+                   classname->token->ln, classname->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        push_op(walker, FZL_OPCODE_ALLOC_OBJECT);
+        push_word(walker, ct->fields_count);
+
+        current_res = (fzl_walk_res_t){
+            .type = FZL_TYPE_OBJECT, .error = false, .classname = ct->name};
+        break;
+      }
+
+      case FZL_NODETYPE_FIELD:
+      {
+        fzl_sym_t sym;
+        bool exists = false;
+        for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+          if ((exists = fzl_symt_get(walker->syms[i],
+                                     node->memb.parent->token->value, &sym)))
+            break;
+
+        if (!exists)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': cannot find symbol '%s' at %ld:%ld",
+                   node->token->filename, (char *)node->token->value,
+                   node->token->ln, node->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        if (!sym.classname)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': '%s' is not an object (at %ld:%ld)",
+                   node->token->filename, sym.name, node->token->ln,
+                   node->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        fzl_ctable_t *ct = NULL;
+        for (size_t i = 0; i < walker->classes_count; i++)
+        {
+          if (strcmp(sym.classname, walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+
+        fzl_token_t *tok = node->memb.parent->token;
+        if (!ct)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': access to unknown class '%s' at %ld:%ld",
+                   tok->filename, (char *)tok->value, tok->ln, tok->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        fzl_token_t *ftok = node->memb.field->token;
+        fzl_ctable_field_t ctf;
+        bool field_exists = false;
+        for (size_t i = 0; i < ct->fields_count; i++)
+        {
+          if (strcmp(ftok->value, ct->fields[i].name) == 0)
+          {
+            field_exists = true;
+            ctf          = ct->fields[i];
+            break;
+          }
+        }
+
+        if (!field_exists)
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': cannot find field '%s' in class '%s' at %ld:%ld",
+                   ftok->filename, (char *)ftok->value, (char *)tok->value,
+                   ftok->ln, ftok->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        fzl_walk_res_t parent_res = walk(walker, node->memb.parent);
+        if (parent_res.error)
+          return parent_res;
+
+        push_op(walker, FZL_OPCODE_GET_FIELD);
+        push_word(walker, ctf.slot_index);
+
+        current_res = (fzl_walk_res_t){
+            .type = ctf.type, .error = false, .classname = sym.classname};
+        break;
+      }
+
       case FZL_NODETYPE_FUNCTION:
       {
         push_op(walker, FZL_OPCODE_JMP);
@@ -183,9 +388,17 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         // NOTE: add sym_top limit check
         size_t lvl                      = walker->sym_top;
         walker->syms[walker->sym_top++] = fzl_mksymt();
-        walker->ctx                     = malloc(sizeof(fzl_walk_ctx_t));
-        walker->ctx->fn                 = node;
-        walker->ctx->initial_env_lvl    = lvl;
+
+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_FN);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        newctx->type            = FZL_WALK_CTX_TYPE_FN;
+        newctx->fn              = node;
+        newctx->initial_env_lvl = lvl;
 
         push_op(walker, FZL_OPCODE_MK_ENVTABLE);
 
@@ -205,18 +418,25 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         // near future
 
         push_op(walker, FZL_OPCODE_RM_ENVTABLE);
+        push_op(walker, FZL_OPCODE_RET);
         walker->ops[skip_ip] = walker->op_count;
 
-        walker->ctx = NULL; // NOTE: think about nested function defs (not now)
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
         for (ssize_t i = walker->sym_top - 1; i >= lvl; i--)
           fzl_freesymt(walker->syms[--walker->sym_top]);
 
+        current_res = (fzl_walk_res_t){.type = fntype, .error = false};
         break;
       }
 
       case FZL_NODETYPE_RETURN:
       {
-        if (!walker->ctx)
+        if (!walker->ctx || walker->ctx->type != FZL_WALK_CTX_TYPE_FN)
         {
           snprintf(
               wlast_err, sizeof(wlast_err),
@@ -415,7 +635,8 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         push_word(walker, n);
         push_op(walker, FZL_OPCODE_LOOKUP_ENV);
 
-        current_res = (fzl_walk_res_t){.type = sym.type, .error = false};
+        current_res = (fzl_walk_res_t){
+            .type = sym.type, .error = false, .classname = sym.classname};
         break;
       }
 
@@ -434,18 +655,18 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         break;
 
       case FZL_NODETYPE_CALL:
-        if (node->call.args_count > 0)
-        {
-          for (size_t i = 0; i < node->call.args_count; i++)
-          {
-            fzl_walk_res_t res = walk(walker, node->call.args[i]);
-            if (res.error)
-              return res;
-          }
-        }
-
         if (strcmp(node->token->value, "printline") == 0)
         {
+          if (node->call.args_count > 0)
+          {
+            for (size_t i = 0; i < node->call.args_count; i++)
+            {
+              fzl_walk_res_t res = walk(walker, node->call.args[i]);
+              if (res.error)
+                return res;
+            }
+          }
+
           push_op(walker, FZL_OPCODE_CALL_BUILTIN);
           push_word(walker, FZL_BUILTIN_PRINTLINE);
           if (node->call.args_count < 1)
@@ -459,32 +680,138 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         }
         else
         {
-          fzl_sym_t res;
-          bool found = false;
-          for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
-            if ((found =
-                     fzl_symt_get(walker->syms[i], node->token->value, &res)))
-              break;
-
-          if (!found)
+          if (node->call.callee->type == FZL_NODETYPE_IDENTIFIER)
           {
-            snprintf(wlast_err, sizeof(wlast_err),
-                     "call to unknown function '%s'",
-                     (char *)node->token->value);
-            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
-          }
+            if (node->call.args_count > 0)
+            {
+              for (size_t i = 0; i < node->call.args_count; i++)
+              {
+                fzl_walk_res_t res = walk(walker, node->call.args[i]);
+                if (res.error)
+                  return res;
+              }
+            }
 
-          if (!res.ip)
+            fzl_sym_t res;
+            bool found = false;
+            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+              if ((found =
+                       fzl_symt_get(walker->syms[i], node->token->value, &res)))
+                break;
+
+            if (!found)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "call to unknown function '%s'",
+                       (char *)node->token->value);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            if (!res.ip)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "cannot jump to address 0x0");
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            push_op(walker, FZL_OPCODE_CALL);
+            push_word(walker, res.ip);
+
+            current_res = (fzl_walk_res_t){.type = res.type, .error = false};
+          }
+          else if (node->call.callee->type == FZL_NODETYPE_FIELD)
           {
-            snprintf(wlast_err, sizeof(wlast_err),
-                     "cannot jump to address 0x0");
-            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            fzl_node_t *parent_node = node->call.callee->memb.parent;
+
+            fzl_sym_t res;
+            bool found = false;
+            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+              if ((found = fzl_symt_get(walker->syms[i],
+                                        parent_node->token->value, &res)))
+                break;
+
+            if (!found)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': access to unknown object '%s' at %ld:%ld",
+                       node->token->filename, (char *)parent_node->token->value,
+                       node->token->ln, node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            if (res.type != FZL_TYPE_OBJECT || !res.classname)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': name '%s' is not an object (at %ld:%ld)",
+                       parent_node->token->filename,
+                       (char *)parent_node->token->value,
+                       parent_node->token->ln, parent_node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            found = false;
+            for (size_t i = 0; i < walker->classes_count; i++)
+            {
+              if (strcmp(walker->classes[i]->name, res.classname) == 0)
+              {
+                found = true;
+                break;
+              }
+            }
+
+            if (!found)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': class '%s' not found at %ld:%ld",
+                       node->token->filename, res.classname, node->token->ln,
+                       node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            char *classname  = res.classname;
+            size_t classlen  = strlen(res.classname);
+            size_t fnlen     = strlen(node->call.callee->token->value);
+            char *methodname = malloc(classlen + fnlen + 2);
+            strcpy(methodname, res.classname);
+            strcpy((methodname + classlen + 1),
+                   node->call.callee->token->value);
+            methodname[classlen]             = '_';
+            methodname[classlen + fnlen + 1] = 0;
+
+            found = false;
+            for (ssize_t i = walker->sym_top - 1; i >= 0; i--)
+              if ((found = fzl_symt_get(walker->syms[i], methodname, &res)))
+                break;
+
+            if (!found)
+            {
+              snprintf(wlast_err, sizeof(wlast_err),
+                       "'%s': class '%s' has no method '%s' at %ld:%ld",
+                       node->token->filename, classname,
+                       (char *)node->call.callee->token->value, node->token->ln,
+                       node->token->cn);
+              return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+            }
+
+            fzl_walk_res_t parent = walk(walker, parent_node);
+            if (parent.error)
+              return parent;
+
+            if (node->call.args_count > 0)
+            {
+              for (size_t i = 0; i < node->call.args_count; i++)
+              {
+                fzl_walk_res_t res = walk(walker, node->call.args[i]);
+                if (res.error)
+                  return res;
+              }
+            }
+
+            push_op(walker, FZL_OPCODE_CALL);
+            push_word(walker, res.ip);
+
+            current_res = (fzl_walk_res_t){.type = res.type, .error = false};
           }
-
-          push_op(walker, FZL_OPCODE_CALL);
-          push_word(walker, res.ip);
-
-          current_res = (fzl_walk_res_t){.type = res.type, .error = false};
         }
         break;
 
@@ -604,9 +931,33 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
 
       case FZL_NODETYPE_DECLARATION:
       {
+        fzl_ctable_t *ct = NULL;
+        for (size_t i = 0; i < walker->classes_count; i++)
+        {
+          if (strcmp(node->var.type->value, walker->classes[i]->name) == 0)
+          {
+            ct = walker->classes[i];
+            break;
+          }
+        }
+
         fzl_symtable_res_t res = fzl_symt_put(
             walker->syms[walker->sym_top - 1],
-            node->var.identifier->token->value, tok_to_type(node->var.type), 0);
+            node->var.identifier->token->value,
+            ct != NULL ? FZL_TYPE_OBJECT : tok_to_type(node->var.type), 0);
+
+        if (ct)
+          fzl_symt_setobjclass(walker->syms[walker->sym_top - 1],
+                               node->var.identifier->token->value, ct->name);
+
+        if (res != FZL_SYMTABLE_RESULT_OK)
+        {
+          fzl_token_t *tok = node->var.identifier->token;
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "'%s': cannot store '%s' at %ld:%ld", tok->filename,
+                   (char *)tok->value, tok->ln, tok->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
 
         fzl_token_t *id_tok = node->var.identifier->token;
         size_t const_n      = add_const(
@@ -631,11 +982,20 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
         if (rres.error)
           return rres;
 
+        fzl_walk_ctx_t *newctx = nest_ctx(walker, FZL_WALK_CTX_TYPE_ASSIGN);
+        if (!newctx)
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to nest context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
         if (node->binary_op.left->type == FZL_NODETYPE_DECLARATION)
         {
           fzl_walk_res_t lres = walk(walker, node->binary_op.left);
           if (lres.error)
             return lres;
+
+          push_op(walker, FZL_OPCODE_WRITE);
         }
         else if (node->binary_op.left->type == FZL_NODETYPE_IDENTIFIER)
         {
@@ -672,9 +1032,65 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
                                         node->binary_op.left->token->value_sz});
           push_op(walker, FZL_OPCODE_LOADCONST);
           push_word(walker, const_n);
+          push_op(walker, FZL_OPCODE_WRITE);
+        }
+        else if (node->binary_op.left->type == FZL_NODETYPE_FIELD)
+        {
+          fzl_node_t *field_node = node->binary_op.left;
+          fzl_walk_res_t obj_res = walk(walker, field_node->memb.parent);
+          if (obj_res.error)
+            return obj_res;
+
+          fzl_ctable_t *ct;
+          for (size_t i = 0; i < walker->classes_count; i++)
+          {
+            if (strcmp(obj_res.classname, walker->classes[i]->name) == 0)
+            {
+              ct = walker->classes[i];
+              break;
+            }
+          }
+
+          if (!ct)
+          {
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%s': cannot find class '%s' at %ld:%ld",
+                     field_node->token->filename, obj_res.classname,
+                     field_node->token->ln, field_node->token->cn);
+            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+
+          fzl_ctable_field_t *ctf;
+          for (size_t i = 0; i < ct->fields_count; i++)
+          {
+            if (strcmp(field_node->memb.field->token->value,
+                       ct->fields[i].name) == 0)
+            {
+              ctf = &ct->fields[i];
+              break;
+            }
+          }
+
+          if (!ctf)
+          {
+            fzl_node_t *fn = field_node->memb.field;
+            snprintf(wlast_err, sizeof(wlast_err),
+                     "'%s': class '%s' has no field '%s' at %ld:%ld",
+                     fn->token->filename, obj_res.classname,
+                     (char *)fn->token->value, fn->token->ln, fn->token->cn);
+            return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+          }
+
+          push_op(walker, FZL_OPCODE_SET_FIELD);
+          push_word(walker, ctf->slot_index);
+        }
+
+        if (!fin_ctx(walker))
+        {
+          snprintf(wlast_err, sizeof(wlast_err), "failed to clean context");
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
         }
 
-        push_op(walker, FZL_OPCODE_WRITE);
         current_res = (fzl_walk_res_t){.type = rres.type, .error = false};
         break;
       }
@@ -695,10 +1111,14 @@ int fzl_walk(fzl_walker_t *walker)
     return -1;
   }
 
+  nest_ctx(walker, FZL_WALK_CTX_TYPE_GLOBAL);
+
   push_op(walker, FZL_OPCODE_MK_ENVTABLE);
   fzl_walk_res_t result = walk(walker, walker->root);
   push_op(walker, FZL_OPCODE_RM_ENVTABLE);
 
+  fin_ctx(walker);
+
   if (result.error && !wlast_err[0])
     snprintf(wlast_err, sizeof(wlast_err), "%s", result.error_msg);
 
@@ -722,5 +1142,8 @@ void fzl_freewalker(fzl_walker_t *walker)
   while (walker->sym_top > 0)
     fzl_freesymt(walker->syms[--walker->sym_top]);
 
+  for (size_t i = 0; i < walker->classes_count; i++)
+    fzl_freectable(walker->classes[i]);
+
   free(walker);
 }