feat: implement conditions

src/compiler/fzl_walker.c

@@ -13,6 +13,9 @@
 #include <stdlib.h>
 #include <string.h>
 
+// TODO: implement backpatching struct for jumping on if/else blocks
+// TODO: implement conditional binops; conditions
+
 char wlast_err[256];
 
 fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
@@ -52,6 +55,9 @@ fzl_walker_t *fzl_mkwalker(fzl_node_t *root)
     return NULL;
   }
 
+  memset(walker->bp_table, 0, sizeof(walker->bp_table));
+  walker->bp_top = 0;
+
   return walker;
 }
 
@@ -152,8 +158,139 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
   {
     switch (node->type)
     {
-      case FZL_NODETYPE_UNARY_PLUS:
+      case FZL_NODETYPE_NOT:
+      {
+        fzl_walk_res_t res = walk(walker, node->unary_op.operand);
+        if (res.error)
+          return res;
+
+        push_op(walker, FZL_OPCODE_NOT);
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
         break;
+      }
+
+      case FZL_NODETYPE_EQUAL:
+      case FZL_NODETYPE_NEQUAL:
+      case FZL_NODETYPE_LESS:
+      case FZL_NODETYPE_LESS_EQUAL:
+      case FZL_NODETYPE_GREATER:
+      case FZL_NODETYPE_GREATER_EQUAL:
+      {
+        fzl_walk_res_t left = walk(walker, node->binary_op.left);
+        if (left.error)
+          return left;
+
+        fzl_walk_res_t right = walk(walker, node->binary_op.right);
+        if (right.error)
+          return right;
+
+        if (!is_compatible(left.type, right.type))
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "incompatible types at %ld:%ld", node->token->ln,
+                   node->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        switch (node->type)
+        {
+          case FZL_NODETYPE_EQUAL:
+            push_op(walker, FZL_OPCODE_CMP_EQ);
+            break;
+          case FZL_NODETYPE_NEQUAL:
+            push_op(walker, FZL_OPCODE_CMP_NEQ);
+            break;
+          case FZL_NODETYPE_LESS:
+            push_op(walker, FZL_OPCODE_CMP_LT);
+            break;
+          case FZL_NODETYPE_LESS_EQUAL:
+            push_op(walker, FZL_OPCODE_CMP_LTEQ);
+            break;
+          case FZL_NODETYPE_GREATER:
+            push_op(walker, FZL_OPCODE_CMP_GT);
+            break;
+          case FZL_NODETYPE_GREATER_EQUAL:
+            push_op(walker, FZL_OPCODE_CMP_GTEQ);
+            break;
+          default:
+            break;
+        }
+
+        current_res = (fzl_walk_res_t){.type = left.type, .error = false};
+        break;
+      }
+
+      case FZL_NODETYPE_OR:
+      case FZL_NODETYPE_AND:
+      {
+        fzl_walk_res_t left = walk(walker, node->binary_op.left);
+        if (left.error)
+          return left;
+
+        fzl_walk_res_t right = walk(walker, node->binary_op.right);
+        if (right.error)
+          return right;
+
+        if (!is_compatible(left.type, right.type))
+        {
+          snprintf(wlast_err, sizeof(wlast_err),
+                   "incompatible types at %ld:%ld", node->token->ln,
+                   node->token->cn);
+          return (fzl_walk_res_t){.error = true, .error_msg = wlast_err};
+        }
+
+        if (node->type == FZL_NODETYPE_AND)
+          push_op(walker, FZL_OPCODE_AND);
+        else
+          push_op(walker, FZL_OPCODE_OR);
+
+        current_res = (fzl_walk_res_t){.type = left.type, .error = false};
+        break;
+      }
+
+      case FZL_NODETYPE_CONDITIONAL:
+      {
+        fzl_walk_res_t cres = walk(walker, node->cond.condition);
+        if (cres.error)
+          return cres;
+
+        push_op(walker, FZL_OPCODE_JZ);
+
+        size_t jz_if = walker->op_count;
+        push_word(walker, (uint64_t)0);
+
+        fzl_walk_res_t tblock_res = walk(walker, node->cond.true_block);
+        if (tblock_res.error)
+          return tblock_res;
+
+        push_op(walker, FZL_OPCODE_JMP);
+        size_t jmp_else = walker->op_count;
+        push_word(walker, (uint64_t)0);
+
+        walker->ops[jz_if] = walker->op_count;
+
+        if (node->cond.else_block)
+        {
+          fzl_walk_res_t fblock_res = walk(walker, node->cond.else_block);
+          if (fblock_res.error)
+            return fblock_res;
+        }
+
+        walker->ops[jmp_else] = walker->op_count;
+
+        current_res = (fzl_walk_res_t){.type = FZL_TYPE_NULL, .error = false};
+        break;
+      }
+
+      case FZL_NODETYPE_UNARY_PLUS:
+      {
+        fzl_walk_res_t res = walk(walker, node->unary_op.operand);
+        if (res.error)
+          return res;
+
+        current_res = res;
+        break;
+      }
 
       case FZL_NODETYPE_IDENTIFIER:
       {
@@ -248,6 +385,15 @@ fzl_walk_res_t walk(fzl_walker_t *walker, fzl_node_t *node)
           push_word(walker, num);
           current_res = (fzl_walk_res_t){.type = FZL_TYPE_INT, .error = false};
         }
+        else if (node->token->type == FZL_TOKTYPE_BOOL_LITERAL)
+        {
+          fzl_token_t *tok = node->token;
+          uint64_t val     = strcmp(tok->value, "true") == 0 ? 1 : 0;
+
+          push_op(walker, FZL_OPCODE_PUSHBOOL);
+          push_word(walker, val);
+          current_res = (fzl_walk_res_t){.type = FZL_TYPE_BOOL, .error = false};
+        }
         break;
 
       case FZL_NODETYPE_ADD:
@@ -423,6 +569,12 @@ int fzl_walk(fzl_walker_t *walker)
   fzl_walk_res_t result = walk(walker, walker->root);
   push_op(walker, FZL_OPCODE_RM_ENVTABLE);
 
+  if (walker->bp_top > 0)
+  {
+    snprintf(wlast_err, sizeof(wlast_err), "unfinished conditional block");
+    return -1;
+  }
+
   if (result.error && !wlast_err[0])
     snprintf(wlast_err, sizeof(wlast_err), "%s", result.error_msg);
 
@@ -443,5 +595,8 @@ void fzl_freewalker(fzl_walker_t *walker)
   if (walker->ops)
     free(walker->ops);
 
+  while (walker->sym_top > 0)
+    fzl_freesymt(walker->syms[--walker->sym_top]);
+
   free(walker);
 }