feat: implement loops

2026-10-22 18:24:28 +03:00
parent 0188991f4d
commit cc5bbd61f2
7 changed files with 396 additions and 4 deletions
@@ -159,6 +159,7 @@ fzl_node_t *parse_primary(fzl_parser_t *parser)
    {
      snprintf(plast_err, sizeof(plast_err), "'%s': expected ')' at %ld:%ld",
               peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
+      fzl_freeast(node);
      return NULL;
    }
    consume(parser);
@@ -256,6 +257,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
        if (!rparen || rparen->type != FZL_TOKTYPE_RPAREN)
        {
          free(args);
+          fzl_freeast(left);
          snprintf(plast_err, sizeof(plast_err),
                   "'%s': expected ')' after argument list at %ld:%ld",
                   peek(parser)->filename, peek(parser)->ln, peek(parser)->cn);
@@ -273,6 +275,7 @@ fzl_node_t *parse_postfix(fzl_parser_t *parser)
      {
        if (!is(parser, FZL_TOKTYPE_NAME))
        {
+          fzl_freeast(left);
          snprintf(plast_err, sizeof(plast_err),
                   "'%s': expected name after '.' at %ld:%ld",
                   last_known_tok->filename, last_known_tok->ln,
@@ -339,6 +342,7 @@ fzl_node_t *parse_power(fzl_parser_t *parser)
    right = parse_unary(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': failed to parse right side of power at %ld:%ld",
@@ -382,6 +386,7 @@ fzl_node_t *parse_factor(fzl_parser_t *parser)
    right = parse_factor(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': unfinished factor (mul/div) expression at %ld:%ld",
@@ -423,6 +428,7 @@ fzl_node_t *parse_term(fzl_parser_t *parser)
    right = parse_factor(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': unfinished term (add/sub) expression at %ld:%ld",
@@ -459,6 +465,7 @@ fzl_node_t *parse_cond(fzl_parser_t *parser)
    right           = parse_term(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': unfinished expression at %ld:%ld", op->filename, op->ln,
@@ -517,6 +524,7 @@ fzl_node_t *parse_and(fzl_parser_t *parser)
    right            = parse_cond(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': unfinished expression at %ld:%ld", or->filename, or->ln,
@@ -551,6 +559,7 @@ fzl_node_t *parse_or(fzl_parser_t *parser)
    right            = parse_and(parser);
    if (!right)
    {
+      fzl_freeast(left);
      if (!plast_err[0])
        snprintf(plast_err, sizeof(plast_err),
                 "'%s': unfinished expression at %ld:%ld", or->filename, or->ln,
@@ -578,6 +587,7 @@ fzl_node_t *parse_new(fzl_parser_t *parser)
  if (objname->type != FZL_NODETYPE_IDENTIFIER &&
      objname->type != FZL_NODETYPE_FIELD)
  {
+    fzl_freeast(objname);
    snprintf(plast_err, sizeof(plast_err),
             "'%s': expect class name after 'new' keyword at %ld:%ld",
             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
@@ -604,6 +614,7 @@ fzl_node_t *parse_assignment(fzl_parser_t *parser)
        left->type != FZL_NODETYPE_DECLARATION &&
        left->type != FZL_NODETYPE_FIELD)
    {
+      fzl_freeast(left);
      snprintf(plast_err, sizeof(plast_err),
               "'%s': cannot assign to '%s' at %ld:%ld", left->token->filename,
               (char *)left->token->value, asn->ln, asn->cn);
@@ -612,7 +623,10 @@ fzl_node_t *parse_assignment(fzl_parser_t *parser)

    fzl_node_t *right = parse_assignment(parser);
    if (!right)
+    {
+      fzl_freeast(left);
      return NULL;
+    }

    fzl_node_t *node      = fzl_mknode(FZL_NODETYPE_ASSIGN, asn);
    node->binary_op.left  = left;
@@ -692,6 +706,7 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
        fields = realloc(fields, fremainder * sizeof(fzl_node_t *));
        if (!fields)
        {
+          fzl_freeast(node);
          snprintf(plast_err, sizeof(plast_err),
                   "failed to resize fields array");
          free(methods);
@@ -709,6 +724,7 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
        methods = realloc(methods, mremainder * sizeof(fzl_node_t *));
        if (!methods)
        {
+          fzl_freeast(node);
          snprintf(plast_err, sizeof(plast_err),
                   "failed to resize methods array");
          free(fields);
@@ -723,6 +739,7 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
        snprintf(plast_err, sizeof(plast_err),
                 "failed to reallocate method args list");
        free(fields);
+        fzl_freeast(node);
        return NULL;
      }

@@ -741,6 +758,7 @@ fzl_node_t *parse_class(fzl_parser_t *parser)
    }
    else
    {
+      fzl_freeast(node);
      snprintf(plast_err, sizeof(plast_err),
               "'%s': unknown type of class member at %ld:%ld",
               node->token->filename, node->token->ln, node->token->cn);
@@ -827,6 +845,7 @@ fzl_node_t *parse_function(fzl_parser_t *parser)
  fzl_token_t *rpar = consume(parser);
  if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
  {
+    free(args);
    snprintf(plast_err, sizeof(plast_err),
             "'%s': expected ')' after argument list at %ld:%ld",
             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
@@ -842,6 +861,7 @@ fzl_node_t *parse_function(fzl_parser_t *parser)

  if (!is(parser, FZL_TOKTYPE_LBRACE))
  {
+    free(args);
    snprintf(plast_err, sizeof(plast_err),
             "'%s': expected '{' after function declaration at %ld:%ld",
             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
@@ -850,7 +870,10 @@ fzl_node_t *parse_function(fzl_parser_t *parser)

  fzl_node_t *body = parse_statement(parser);
  if (!body)
+  {
+    free(args);
    return NULL;
+  }

  fzl_node_t *node    = fzl_mknode(FZL_NODETYPE_FUNCTION, name);
  node->fn.args       = args;
@@ -875,7 +898,10 @@ fzl_node_t *parse_return(fzl_parser_t *parser)
  {
    fzl_node_t *retval = parse_expression(parser);
    if (!retval)
+    {
+      fzl_freeast(node);
      return NULL;
+    }

    node->ret.value = retval;
  }
@@ -905,6 +931,7 @@ fzl_node_t *parse_if(fzl_parser_t *parser)
  fzl_token_t *rparen = consume(parser);
  if (rparen->type != FZL_TOKTYPE_RPAREN)
  {
+    fzl_freeast(condition);
    snprintf(plast_err, sizeof(plast_err),
             "'%s': expected ')' after condition at %ld:%ld", rparen->filename,
             rparen->ln, rparen->cn);
@@ -914,14 +941,21 @@ fzl_node_t *parse_if(fzl_parser_t *parser)
  fzl_node_t *else_block = NULL;
  fzl_node_t *true_block = parse_statement(parser);
  if (!true_block)
+  {
+    fzl_freeast(condition);
    return NULL;
+  }

  if (is(parser, FZL_TOKTYPE_ELSE))
  {
    consume(parser); // else
    else_block = parse_statement(parser);
    if (!else_block)
+    {
+      fzl_freeast(condition);
+      fzl_freeast(true_block);
      return NULL;
+    }
  }

  fzl_node_t *stmt_node      = fzl_mknode(FZL_NODETYPE_CONDITIONAL, if_tok);
@@ -948,7 +982,10 @@ fzl_node_t *parse_block(fzl_parser_t *parser)
  {
    fzl_node_t *node = parse_statement(parser);
    if (!node)
+    {
+      free(stmts);
      return NULL;
+    }

    if (remainder <= count)
    {
@@ -961,6 +998,10 @@ fzl_node_t *parse_block(fzl_parser_t *parser)
  fzl_token_t *rbrace = consume(parser);
  if (!rbrace || rbrace->type != FZL_TOKTYPE_RBRACE)
  {
+    for (size_t i = 0; i < count; i++)
+      fzl_freeast(stmts[i]);
+    free(stmts);
+
    snprintf(plast_err, sizeof(plast_err),
             "'%s': missing '}' after block at %ld:%ld", rbrace->filename,
             rbrace->ln, rbrace->cn);
@@ -973,6 +1014,190 @@ fzl_node_t *parse_block(fzl_parser_t *parser)
  return node;
 }

+// For-loop parsing
+fzl_node_t *parse_for(fzl_parser_t *parser)
+{
+  fzl_token_t *tok  = consume(parser);
+  fzl_token_t *lpar = consume(parser);
+  if (lpar->type != FZL_TOKTYPE_LPAREN)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': expected '(' after for keyword at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *start = NULL;
+  if (!is(parser, FZL_TOKTYPE_SEMICOLON))
+  {
+    start = parse_expression(parser);
+    if (!start)
+    {
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': expected loop init or ';' at %ld:%ld",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+
+    fzl_token_t *sc = consume(parser);
+    if (!sc || sc->type != FZL_TOKTYPE_SEMICOLON)
+    {
+      fzl_freeast(start);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': missing ';' after init section at %ld:%ld",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+  }
+  else
+    consume(parser);
+
+  fzl_node_t *condition = NULL;
+  if (!is(parser, FZL_TOKTYPE_SEMICOLON))
+  {
+    condition = parse_expression(parser);
+    if (!condition)
+    {
+      fzl_freeast(start);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': expected loop condition or ';' at %ld:%ld",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+
+    fzl_token_t *sc = consume(parser);
+    if (!sc || sc->type != FZL_TOKTYPE_SEMICOLON)
+    {
+      fzl_freeast(start);
+      fzl_freeast(condition);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': missing ';' after condition at %ld:%ld",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+  }
+  else
+    consume(parser);
+
+  fzl_node_t *step = NULL;
+  if (!is(parser, FZL_TOKTYPE_RPAREN))
+  {
+    step = parse_expression(parser);
+    if (!step)
+    {
+      fzl_freeast(start);
+      fzl_freeast(condition);
+      snprintf(plast_err, sizeof(plast_err),
+               "'%s': expected loop step end or ')' at %ld:%ld",
+               last_known_tok->filename, last_known_tok->ln,
+               last_known_tok->cn);
+      return NULL;
+    }
+  }
+
+  fzl_token_t *rpar = consume(parser);
+  if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
+  {
+    fzl_freeast(start);
+    fzl_freeast(condition);
+    fzl_freeast(step);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing ')' after loop setup at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *body = parse_statement(parser);
+  if (!body)
+  {
+    fzl_freeast(start);
+    fzl_freeast(condition);
+    fzl_freeast(step);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing body of for loop at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_LOOP, tok);
+  node->loop.init  = start;
+  node->loop.cond  = condition;
+  node->loop.step  = step;
+  node->loop.body  = body;
+
+  return node;
+}
+
+// While-loop parsing
+fzl_node_t *parse_while(fzl_parser_t *parser)
+{
+  fzl_token_t *tok  = consume(parser);
+  fzl_token_t *lpar = consume(parser);
+  if (!lpar || lpar->type != FZL_TOKTYPE_LPAREN)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing '(' after while keyword at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *condition = parse_expression(parser);
+  if (!condition)
+  {
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing condition for 'while' at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_token_t *rpar = consume(parser);
+  if (!rpar || rpar->type != FZL_TOKTYPE_RPAREN)
+  {
+    fzl_freeast(condition);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing ')' after while loop condition at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *body = parse_statement(parser);
+  if (!body)
+  {
+    fzl_freeast(condition);
+    snprintf(plast_err, sizeof(plast_err),
+             "'%s': missing while loop body at %ld:%ld",
+             last_known_tok->filename, last_known_tok->ln, last_known_tok->cn);
+    return NULL;
+  }
+
+  fzl_node_t *node = fzl_mknode(FZL_NODETYPE_LOOP, tok);
+  node->loop.cond  = condition;
+  node->loop.body  = body;
+
+  return node;
+}
+
+// `while` and `for` loops
+fzl_node_t *parse_loop(fzl_parser_t *parser)
+{
+  if (!peek(parser))
+    return NULL;
+
+  if (is(parser, FZL_TOKTYPE_FOR))
+    return parse_for(parser);
+  else if (is(parser, FZL_TOKTYPE_WHILE))
+    return parse_while(parser);
+
+  snprintf(plast_err, sizeof(plast_err),
+           "'%s': unknown type of loop at %ld:%ld", last_known_tok->filename,
+           last_known_tok->ln, last_known_tok->cn);
+  return NULL;
+}
+
 // Statement parsing
 fzl_node_t *parse_statement(fzl_parser_t *parser)
 {
@@ -991,6 +1216,8 @@ fzl_node_t *parse_statement(fzl_parser_t *parser)
    return parse_if(parser);
  else if (is(parser, FZL_TOKTYPE_LBRACE))
    return parse_block(parser);
+  else if (is(parser, FZL_TOKTYPE_FOR) || is(parser, FZL_TOKTYPE_WHILE))
+    return parse_loop(parser);

  if (!res)
    res = parse_expression(parser);
@@ -1116,6 +1343,20 @@ void fzl_freeast(fzl_node_t *root)
          fzl_freeast(root->cond.else_block);
        break;

+      case FZL_NODETYPE_LOOP:
+        if (root->loop.init)
+          fzl_freeast(root->loop.init);
+
+        if (root->loop.cond)
+          fzl_freeast(root->loop.cond);
+
+        if (root->loop.step)
+          fzl_freeast(root->loop.step);
+
+        if (root->loop.body)
+          fzl_freeast(root->loop.body);
+        break;
+
      case FZL_NODETYPE_ADD:
      case FZL_NODETYPE_SUB:
      case FZL_NODETYPE_MUL: